<form method="POST">
    <h3>Editing: BigDecimal.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

declare(strict_types=1);

namespace Brick\Math;

use Brick\Math\Exception\DivisionByZeroException;
use Brick\Math\Exception\MathException;
use Brick\Math\Exception\NegativeNumberException;
use Brick\Math\Internal\Calculator;

/**
 * Immutable, arbitrary-precision signed decimal numbers.
 *
 * @psalm-immutable
 */
final class BigDecimal extends BigNumber
{
    /**
     * The unscaled value of this decimal number.
     *
     * This is a string of digits with an optional leading minus sign.
     * No leading zero must be present.
     * No leading minus sign must be present if the value is 0.
     *
     * @var string
     */
    private $value;

    /**
     * The scale (number of digits after the decimal point) of this decimal number.
     *
     * This must be zero or more.
     *
     * @var int
     */
    private $scale;

    /**
     * Protected constructor. Use a factory method to obtain an instance.
     *
     * @param string $value The unscaled value, validated.
     * @param int    $scale The scale, validated.
     */
    protected function __construct(string $value, int $scale = 0)
    {
        $this-&gt;value = $value;
        $this-&gt;scale = $scale;
    }

    /**
     * Creates a BigDecimal of the given value.
     *
     * @param BigNumber|int|float|string $value
     *
     * @return BigDecimal
     *
     * @throws MathException If the value cannot be converted to a BigDecimal.
     *
     * @psalm-pure
     */
    public static function of($value) : BigNumber
    {
        return parent::of($value)-&gt;toBigDecimal();
    }

    /**
     * Creates a BigDecimal from an unscaled value and a scale.
     *
     * 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.
     *
     * @return BigDecimal
     *
     * @throws \InvalidArgumentException If the scale is negative.
     *
     * @psalm-pure
     */
    public static function ofUnscaledValue($value, int $scale = 0) : BigDecimal
    {
        if ($scale &lt; 0) {
            throw new \InvalidArgumentException('The scale cannot be negative.');
        }

        return new BigDecimal((string) BigInteger::of($value), $scale);
    }

    /**
     * Returns a BigDecimal representing zero, with a scale of zero.
     *
     * @return BigDecimal
     *
     * @psalm-pure
     */
    public static function zero() : BigDecimal
    {
        /**
         * @psalm-suppress ImpureStaticVariable
         * @var BigDecimal|null $zero
         */
        static $zero;

        if ($zero === null) {
            $zero = new BigDecimal('0');
        }

        return $zero;
    }

    /**
     * Returns a BigDecimal representing one, with a scale of zero.
     *
     * @return BigDecimal
     *
     * @psalm-pure
     */
    public static function one() : BigDecimal
    {
        /**
         * @psalm-suppress ImpureStaticVariable
         * @var BigDecimal|null $one
         */
        static $one;

        if ($one === null) {
            $one = new BigDecimal('1');
        }

        return $one;
    }

    /**
     * Returns a BigDecimal representing ten, with a scale of zero.
     *
     * @return BigDecimal
     *
     * @psalm-pure
     */
    public static function ten() : BigDecimal
    {
        /**
         * @psalm-suppress ImpureStaticVariable
         * @var BigDecimal|null $ten
         */
        static $ten;

        if ($ten === null) {
            $ten = new BigDecimal('10');
        }

        return $ten;
    }

    /**
     * Returns the sum of this number and the given one.
     *
     * The result has a scale of `max($this-&gt;scale, $that-&gt;scale)`.
     *
     * @param BigNumber|int|float|string $that The number to add. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal The result.
     *
     * @throws MathException If the number is not valid, or is not convertible to a BigDecimal.
     */
    public function plus($that) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;value === '0' &amp;&amp; $that-&gt;scale &lt;= $this-&gt;scale) {
            return $this;
        }

        if ($this-&gt;value === '0' &amp;&amp; $this-&gt;scale &lt;= $that-&gt;scale) {
            return $that;
        }

        [$a, $b] = $this-&gt;scaleValues($this, $that);

        $value = Calculator::get()-&gt;add($a, $b);
        $scale = $this-&gt;scale &gt; $that-&gt;scale ? $this-&gt;scale : $that-&gt;scale;

        return new BigDecimal($value, $scale);
    }

    /**
     * Returns the difference of this number and the given one.
     *
     * The result has a scale of `max($this-&gt;scale, $that-&gt;scale)`.
     *
     * @param BigNumber|int|float|string $that The number to subtract. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal The result.
     *
     * @throws MathException If the number is not valid, or is not convertible to a BigDecimal.
     */
    public function minus($that) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;value === '0' &amp;&amp; $that-&gt;scale &lt;= $this-&gt;scale) {
            return $this;
        }

        [$a, $b] = $this-&gt;scaleValues($this, $that);

        $value = Calculator::get()-&gt;sub($a, $b);
        $scale = $this-&gt;scale &gt; $that-&gt;scale ? $this-&gt;scale : $that-&gt;scale;

        return new BigDecimal($value, $scale);
    }

    /**
     * Returns the product of this number and the given one.
     *
     * The result has a scale of `$this-&gt;scale + $that-&gt;scale`.
     *
     * @param BigNumber|int|float|string $that The multiplier. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal The result.
     *
     * @throws MathException If the multiplier is not a valid number, or is not convertible to a BigDecimal.
     */
    public function multipliedBy($that) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;value === '1' &amp;&amp; $that-&gt;scale === 0) {
            return $this;
        }

        if ($this-&gt;value === '1' &amp;&amp; $this-&gt;scale === 0) {
            return $that;
        }

        $value = Calculator::get()-&gt;mul($this-&gt;value, $that-&gt;value);
        $scale = $this-&gt;scale + $that-&gt;scale;

        return new BigDecimal($value, $scale);
    }

    /**
     * Returns the result of the division of this number by the given one, at the given scale.
     *
     * @param BigNumber|int|float|string $that         The divisor.
     * @param int|null                   $scale        The desired scale, or null to use the scale of this number.
     * @param int                        $roundingMode An optional rounding mode.
     *
     * @return BigDecimal
     *
     * @throws \InvalidArgumentException If the scale or rounding mode is invalid.
     * @throws MathException             If the number is invalid, is zero, or rounding was necessary.
     */
    public function dividedBy($that, ?int $scale = null, int $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;isZero()) {
            throw DivisionByZeroException::divisionByZero();
        }

        if ($scale === null) {
            $scale = $this-&gt;scale;
        } elseif ($scale &lt; 0) {
            throw new \InvalidArgumentException('Scale cannot be negative.');
        }

        if ($that-&gt;value === '1' &amp;&amp; $that-&gt;scale === 0 &amp;&amp; $scale === $this-&gt;scale) {
            return $this;
        }

        $p = $this-&gt;valueWithMinScale($that-&gt;scale + $scale);
        $q = $that-&gt;valueWithMinScale($this-&gt;scale - $scale);

        $result = Calculator::get()-&gt;divRound($p, $q, $roundingMode);

        return new BigDecimal($result, $scale);
    }

    /**
     * Returns the exact result of the division of this number by the given one.
     *
     * The scale of the result is automatically calculated to fit all the fraction digits.
     *
     * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal The result.
     *
     * @throws MathException If the divisor is not a valid number, is not convertible to a BigDecimal, is zero,
     *                       or the result yields an infinite number of digits.
     */
    public function exactlyDividedBy($that) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;value === '0') {
            throw DivisionByZeroException::divisionByZero();
        }

        [, $b] = $this-&gt;scaleValues($this, $that);

        $d = \rtrim($b, '0');
        $scale = \strlen($b) - \strlen($d);

        $calculator = Calculator::get();

        foreach ([5, 2] as $prime) {
            for (;;) {
                $lastDigit = (int) $d[-1];

                if ($lastDigit % $prime !== 0) {
                    break;
                }

                $d = $calculator-&gt;divQ($d, (string) $prime);
                $scale++;
            }
        }

        return $this-&gt;dividedBy($that, $scale)-&gt;stripTrailingZeros();
    }

    /**
     * Returns this number exponentiated to the given value.
     *
     * The result has a scale of `$this-&gt;scale * $exponent`.
     *
     * @param int $exponent The exponent.
     *
     * @return BigDecimal The result.
     *
     * @throws \InvalidArgumentException If the exponent is not in the range 0 to 1,000,000.
     */
    public function power(int $exponent) : BigDecimal
    {
        if ($exponent === 0) {
            return BigDecimal::one();
        }

        if ($exponent === 1) {
            return $this;
        }

        if ($exponent &lt; 0 || $exponent &gt; Calculator::MAX_POWER) {
            throw new \InvalidArgumentException(\sprintf(
                'The exponent %d is not in the range 0 to %d.',
                $exponent,
                Calculator::MAX_POWER
            ));
        }

        return new BigDecimal(Calculator::get()-&gt;pow($this-&gt;value, $exponent), $this-&gt;scale * $exponent);
    }

    /**
     * Returns the quotient of the division of this number by this given one.
     *
     * The quotient has a scale of `0`.
     *
     * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal The quotient.
     *
     * @throws MathException If the divisor is not a valid decimal number, or is zero.
     */
    public function quotient($that) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;isZero()) {
            throw DivisionByZeroException::divisionByZero();
        }

        $p = $this-&gt;valueWithMinScale($that-&gt;scale);
        $q = $that-&gt;valueWithMinScale($this-&gt;scale);

        $quotient = Calculator::get()-&gt;divQ($p, $q);

        return new BigDecimal($quotient, 0);
    }

    /**
     * Returns the remainder of the division of this number by this given one.
     *
     * The remainder has a scale of `max($this-&gt;scale, $that-&gt;scale)`.
     *
     * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal The remainder.
     *
     * @throws MathException If the divisor is not a valid decimal number, or is zero.
     */
    public function remainder($that) : BigDecimal
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;isZero()) {
            throw DivisionByZeroException::divisionByZero();
        }

        $p = $this-&gt;valueWithMinScale($that-&gt;scale);
        $q = $that-&gt;valueWithMinScale($this-&gt;scale);

        $remainder = Calculator::get()-&gt;divR($p, $q);

        $scale = $this-&gt;scale &gt; $that-&gt;scale ? $this-&gt;scale : $that-&gt;scale;

        return new BigDecimal($remainder, $scale);
    }

    /**
     * Returns the quotient and remainder of the division of this number by the given one.
     *
     * The quotient has a scale of `0`, and the remainder has a scale of `max($this-&gt;scale, $that-&gt;scale)`.
     *
     * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigDecimal.
     *
     * @return BigDecimal[] An array containing the quotient and the remainder.
     *
     * @throws MathException If the divisor is not a valid decimal number, or is zero.
     */
    public function quotientAndRemainder($that) : array
    {
        $that = BigDecimal::of($that);

        if ($that-&gt;isZero()) {
            throw DivisionByZeroException::divisionByZero();
        }

        $p = $this-&gt;valueWithMinScale($that-&gt;scale);
        $q = $that-&gt;valueWithMinScale($this-&gt;scale);

        [$quotient, $remainder] = Calculator::get()-&gt;divQR($p, $q);

        $scale = $this-&gt;scale &gt; $that-&gt;scale ? $this-&gt;scale : $that-&gt;scale;

        $quotient = new BigDecimal($quotient, 0);
        $remainder = new BigDecimal($remainder, $scale);

        return [$quotient, $remainder];
    }

    /**
     * Returns the square root of this number, rounded down to the given number of decimals.
     *
     * @param int $scale
     *
     * @return BigDecimal
     *
     * @throws \InvalidArgumentException If the scale is negative.
     * @throws NegativeNumberException If this number is negative.
     */
    public function sqrt(int $scale) : BigDecimal
    {
        if ($scale &lt; 0) {
            throw new \InvalidArgumentException('Scale cannot be negative.');
        }

        if ($this-&gt;value === '0') {
            return new BigDecimal('0', $scale);
        }

        if ($this-&gt;value[0] === '-') {
            throw new NegativeNumberException('Cannot calculate the square root of a negative number.');
        }

        $value = $this-&gt;value;
        $addDigits = 2 * $scale - $this-&gt;scale;

        if ($addDigits &gt; 0) {
            // add zeros
            $value .= \str_repeat('0', $addDigits);
        } elseif ($addDigits &lt; 0) {
            // trim digits
            if (-$addDigits &gt;= \strlen($this-&gt;value)) {
                // requesting a scale too low, will always yield a zero result
                return new BigDecimal('0', $scale);
            }

            $value = \substr($value, 0, $addDigits);
        }

        $value = Calculator::get()-&gt;sqrt($value);

        return new BigDecimal($value, $scale);
    }

    /**
     * Returns a copy of this BigDecimal with the decimal point moved $n places to the left.
     *
     * @param int $n
     *
     * @return BigDecimal
     */
    public function withPointMovedLeft(int $n) : BigDecimal
    {
        if ($n === 0) {
            return $this;
        }

        if ($n &lt; 0) {
            return $this-&gt;withPointMovedRight(-$n);
        }

        return new BigDecimal($this-&gt;value, $this-&gt;scale + $n);
    }

    /**
     * Returns a copy of this BigDecimal with the decimal point moved $n places to the right.
     *
     * @param int $n
     *
     * @return BigDecimal
     */
    public function withPointMovedRight(int $n) : BigDecimal
    {
        if ($n === 0) {
            return $this;
        }

        if ($n &lt; 0) {
            return $this-&gt;withPointMovedLeft(-$n);
        }

        $value = $this-&gt;value;
        $scale = $this-&gt;scale - $n;

        if ($scale &lt; 0) {
            if ($value !== '0') {
                $value .= \str_repeat('0', -$scale);
            }
            $scale = 0;
        }

        return new BigDecimal($value, $scale);
    }

    /**
     * Returns a copy of this BigDecimal with any trailing zeros removed from the fractional part.
     *
     * @return BigDecimal
     */
    public function stripTrailingZeros() : BigDecimal
    {
        if ($this-&gt;scale === 0) {
            return $this;
        }

        $trimmedValue = \rtrim($this-&gt;value, '0');

        if ($trimmedValue === '') {
            return BigDecimal::zero();
        }

        $trimmableZeros = \strlen($this-&gt;value) - \strlen($trimmedValue);

        if ($trimmableZeros === 0) {
            return $this;
        }

        if ($trimmableZeros &gt; $this-&gt;scale) {
            $trimmableZeros = $this-&gt;scale;
        }

        $value = \substr($this-&gt;value, 0, -$trimmableZeros);
        $scale = $this-&gt;scale - $trimmableZeros;

        return new BigDecimal($value, $scale);
    }

    /**
     * Returns the absolute value of this number.
     *
     * @return BigDecimal
     */
    public function abs() : BigDecimal
    {
        return $this-&gt;isNegative() ? $this-&gt;negated() : $this;
    }

    /**
     * Returns the negated value of this number.
     *
     * @return BigDecimal
     */
    public function negated() : BigDecimal
    {
        return new BigDecimal(Calculator::get()-&gt;neg($this-&gt;value), $this-&gt;scale);
    }

    /**
     * {@inheritdoc}
     */
    public function compareTo($that) : int
    {
        $that = BigNumber::of($that);

        if ($that instanceof BigInteger) {
            $that = $that-&gt;toBigDecimal();
        }

        if ($that instanceof BigDecimal) {
            [$a, $b] = $this-&gt;scaleValues($this, $that);

            return Calculator::get()-&gt;cmp($a, $b);
        }

        return - $that-&gt;compareTo($this);
    }

    /**
     * {@inheritdoc}
     */
    public function getSign() : int
    {
        return ($this-&gt;value === '0') ? 0 : (($this-&gt;value[0] === '-') ? -1 : 1);
    }

    /**
     * @return BigInteger
     */
    public function getUnscaledValue() : BigInteger
    {
        return BigInteger::create($this-&gt;value);
    }

    /**
     * @return int
     */
    public function getScale() : int
    {
        return $this-&gt;scale;
    }

    /**
     * Returns a string representing the integral part of this decimal number.
     *
     * Example: `-123.456` =&gt; `-123`.
     *
     * @return string
     */
    public function getIntegralPart() : string
    {
        if ($this-&gt;scale === 0) {
            return $this-&gt;value;
        }

        $value = $this-&gt;getUnscaledValueWithLeadingZeros();

        return \substr($value, 0, -$this-&gt;scale);
    }

    /**
     * Returns a string representing the fractional part of this decimal number.
     *
     * If the scale is zero, an empty string is returned.
     *
     * Examples: `-123.456` =&gt; '456', `123` =&gt; ''.
     *
     * @return string
     */
    public function getFractionalPart() : string
    {
        if ($this-&gt;scale === 0) {
            return '';
        }

        $value = $this-&gt;getUnscaledValueWithLeadingZeros();

        return \substr($value, -$this-&gt;scale);
    }

    /**
     * Returns whether this decimal number has a non-zero fractional part.
     *
     * @return bool
     */
    public function hasNonZeroFractionalPart() : bool
    {
        return $this-&gt;getFractionalPart() !== \str_repeat('0', $this-&gt;scale);
    }

    /**
     * {@inheritdoc}
     */
    public function toBigInteger() : BigInteger
    {
        $zeroScaleDecimal = $this-&gt;scale === 0 ? $this : $this-&gt;dividedBy(1, 0);

        return BigInteger::create($zeroScaleDecimal-&gt;value);
    }

    /**
     * {@inheritdoc}
     */
    public function toBigDecimal() : BigDecimal
    {
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function toBigRational() : BigRational
    {
        $numerator = BigInteger::create($this-&gt;value);
        $denominator = BigInteger::create('1' . \str_repeat('0', $this-&gt;scale));

        return BigRational::create($numerator, $denominator, false);
    }

    /**
     * {@inheritdoc}
     */
    public function toScale(int $scale, int $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
    {
        if ($scale === $this-&gt;scale) {
            return $this;
        }

        return $this-&gt;dividedBy(BigDecimal::one(), $scale, $roundingMode);
    }

    /**
     * {@inheritdoc}
     */
    public function toInt() : int
    {
        return $this-&gt;toBigInteger()-&gt;toInt();
    }

    /**
     * {@inheritdoc}
     */
    public function toFloat() : float
    {
        return (float) (string) $this;
    }

    /**
     * {@inheritdoc}
     */
    public function __toString() : string
    {
        if ($this-&gt;scale === 0) {
            return $this-&gt;value;
        }

        $value = $this-&gt;getUnscaledValueWithLeadingZeros();

        return \substr($value, 0, -$this-&gt;scale) . '.' . \substr($value, -$this-&gt;scale);
    }

    /**
     * This method is required for serializing the object and SHOULD NOT be accessed directly.
     *
     * @internal
     *
     * @return array{value: string, scale: int}
     */
    public function __serialize(): array
    {
        return ['value' =&gt; $this-&gt;value, 'scale' =&gt; $this-&gt;scale];
    }

    /**
     * This method is only here to allow unserializing the object and cannot be accessed directly.
     *
     * @internal
     * @psalm-suppress RedundantPropertyInitializationCheck
     *
     * @param array{value: string, scale: int} $data
     *
     * @return void
     *
     * @throws \LogicException
     */
    public function __unserialize(array $data): void
    {
        if (isset($this-&gt;value)) {
            throw new \LogicException('__unserialize() is an internal function, it must not be called directly.');
        }

        $this-&gt;value = $data['value'];
        $this-&gt;scale = $data['scale'];
    }

    /**
     * This method is required by interface Serializable and SHOULD NOT be accessed directly.
     *
     * @internal
     *
     * @return string
     */
    public function serialize() : string
    {
        return $this-&gt;value . ':' . $this-&gt;scale;
    }

    /**
     * This method is only here to implement interface Serializable and cannot be accessed directly.
     *
     * @internal
     * @psalm-suppress RedundantPropertyInitializationCheck
     *
     * @param string $value
     *
     * @return void
     *
     * @throws \LogicException
     */
    public function unserialize($value) : void
    {
        if (isset($this-&gt;value)) {
            throw new \LogicException('unserialize() is an internal function, it must not be called directly.');
        }

        [$value, $scale] = \explode(':', $value);

        $this-&gt;value = $value;
        $this-&gt;scale = (int) $scale;
    }

    /**
     * Puts the internal values of the given decimal numbers on the same scale.
     *
     * @param BigDecimal $x The first decimal number.
     * @param BigDecimal $y The second decimal number.
     *
     * @return array{string, string} The scaled integer values of $x and $y.
     */
    private function scaleValues(BigDecimal $x, BigDecimal $y) : array
    {
        $a = $x-&gt;value;
        $b = $y-&gt;value;

        if ($b !== '0' &amp;&amp; $x-&gt;scale &gt; $y-&gt;scale) {
            $b .= \str_repeat('0', $x-&gt;scale - $y-&gt;scale);
        } elseif ($a !== '0' &amp;&amp; $x-&gt;scale &lt; $y-&gt;scale) {
            $a .= \str_repeat('0', $y-&gt;scale - $x-&gt;scale);
        }

        return [$a, $b];
    }

    /**
     * @param int $scale
     *
     * @return string
     */
    private function valueWithMinScale(int $scale) : string
    {
        $value = $this-&gt;value;

        if ($this-&gt;value !== '0' &amp;&amp; $scale &gt; $this-&gt;scale) {
            $value .= \str_repeat('0', $scale - $this-&gt;scale);
        }

        return $value;
    }

    /**
     * Adds leading zeros if necessary to the unscaled value to represent the full decimal number.
     *
     * @return string
     */
    private function getUnscaledValueWithLeadingZeros() : string
    {
        $value = $this-&gt;value;
        $targetLength = $this-&gt;scale + 1;
        $negative = ($value[0] === '-');
        $length = \strlen($value);

        if ($negative) {
            $length--;
        }

        if ($length &gt;= $targetLength) {
            return $this-&gt;value;
        }

        if ($negative) {
            $value = \substr($value, 1);
        }

        $value = \str_pad($value, $targetLength, '0', STR_PAD_LEFT);

        if ($negative) {
            $value = '-' . $value;
        }

        return $value;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>