aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/brick/math
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/brick/math')
-rw-r--r--vendor/brick/math/LICENSE20
-rw-r--r--vendor/brick/math/SECURITY.md16
-rw-r--r--vendor/brick/math/composer.json35
-rw-r--r--vendor/brick/math/psalm-baseline.xml40
-rw-r--r--vendor/brick/math/psalm.xml56
-rw-r--r--vendor/brick/math/random-tests.php184
-rw-r--r--vendor/brick/math/src/BigDecimal.php855
-rw-r--r--vendor/brick/math/src/BigInteger.php1134
-rw-r--r--vendor/brick/math/src/BigNumber.php566
-rw-r--r--vendor/brick/math/src/BigRational.php479
-rw-r--r--vendor/brick/math/src/Exception/DivisionByZeroException.php41
-rw-r--r--vendor/brick/math/src/Exception/IntegerOverflowException.php27
-rw-r--r--vendor/brick/math/src/Exception/MathException.php14
-rw-r--r--vendor/brick/math/src/Exception/NegativeNumberException.php12
-rw-r--r--vendor/brick/math/src/Exception/NumberFormatException.php35
-rw-r--r--vendor/brick/math/src/Exception/RoundingNecessaryException.php21
-rw-r--r--vendor/brick/math/src/Internal/Calculator.php756
-rw-r--r--vendor/brick/math/src/Internal/Calculator/BcMathCalculator.php92
-rw-r--r--vendor/brick/math/src/Internal/Calculator/GmpCalculator.php156
-rw-r--r--vendor/brick/math/src/Internal/Calculator/NativeCalculator.php616
-rw-r--r--vendor/brick/math/src/RoundingMode.php107
21 files changed, 5262 insertions, 0 deletions
diff --git a/vendor/brick/math/LICENSE b/vendor/brick/math/LICENSE
new file mode 100644
index 000000000..f9b724f00
--- /dev/null
+++ b/vendor/brick/math/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-present Benjamin Morel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/brick/math/SECURITY.md b/vendor/brick/math/SECURITY.md
new file mode 100644
index 000000000..6bdc74f0d
--- /dev/null
+++ b/vendor/brick/math/SECURITY.md
@@ -0,0 +1,16 @@
+# Security Policy
+
+## Supported Versions
+
+Only the latest release stream is supported.
+
+| Version | Supported |
+| ------- | ------------------ |
+| 0.8.x | :white_check_mark: |
+| < 0.8 | :x: |
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
diff --git a/vendor/brick/math/composer.json b/vendor/brick/math/composer.json
new file mode 100644
index 000000000..d347b6bde
--- /dev/null
+++ b/vendor/brick/math/composer.json
@@ -0,0 +1,35 @@
+{
+ "name": "brick/math",
+ "description": "Arbitrary-precision arithmetic library",
+ "type": "library",
+ "keywords": [
+ "Brick",
+ "Math",
+ "Arbitrary-precision",
+ "Arithmetic",
+ "BigInteger",
+ "BigDecimal",
+ "BigRational",
+ "Bignum"
+ ],
+ "license": "MIT",
+ "require": {
+ "php": "^7.1|^8.0",
+ "ext-json": "*"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.5.15|^8.5",
+ "php-coveralls/php-coveralls": "^2.2",
+ "vimeo/psalm": "^3.5"
+ },
+ "autoload": {
+ "psr-4": {
+ "Brick\\Math\\": "src/"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "Brick\\Math\\Tests\\": "tests/"
+ }
+ }
+}
diff --git a/vendor/brick/math/psalm-baseline.xml b/vendor/brick/math/psalm-baseline.xml
new file mode 100644
index 000000000..fe05b998c
--- /dev/null
+++ b/vendor/brick/math/psalm-baseline.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<files psalm-version="3.8.5@e6ec5fa22a7b9e61670a24d07b3119aff80dcd89">
+ <file src="src/Internal/Calculator/BcMathCalculator.php">
+ <InvalidNullableReturnType occurrences="3">
+ <code>string</code>
+ <code>string</code>
+ <code>string</code>
+ </InvalidNullableReturnType>
+ <InvalidReturnStatement occurrences="1">
+ <code>[$q, $r]</code>
+ </InvalidReturnStatement>
+ <InvalidReturnType occurrences="1">
+ <code>array</code>
+ </InvalidReturnType>
+ <NullableReturnStatement occurrences="3">
+ <code>\bcdiv($a, $b, 0)</code>
+ <code>\bcmod($a, $b)</code>
+ <code>\bcpowmod($base, $exp, $mod, 0)</code>
+ </NullableReturnStatement>
+ </file>
+ <file src="src/Internal/Calculator/NativeCalculator.php">
+ <InvalidOperand occurrences="6">
+ <code>$a</code>
+ <code>$a</code>
+ <code>$a</code>
+ <code>$b</code>
+ <code>$blockA</code>
+ <code>$blockA</code>
+ </InvalidOperand>
+ <LoopInvalidation occurrences="4">
+ <code>$i</code>
+ <code>$i</code>
+ <code>$i</code>
+ <code>$j</code>
+ </LoopInvalidation>
+ <PossiblyInvalidArgument occurrences="1">
+ <code>$e / 2</code>
+ </PossiblyInvalidArgument>
+ </file>
+</files>
diff --git a/vendor/brick/math/psalm.xml b/vendor/brick/math/psalm.xml
new file mode 100644
index 000000000..123263ef4
--- /dev/null
+++ b/vendor/brick/math/psalm.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0"?>
+<psalm
+ totallyTyped="false"
+ resolveFromConfigFile="true"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns="https://getpsalm.org/schema/config"
+ xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+ errorBaseline="psalm-baseline.xml"
+>
+ <projectFiles>
+ <directory name="src" />
+ <ignoreFiles>
+ <directory name="vendor" />
+ </ignoreFiles>
+ </projectFiles>
+
+ <issueHandlers>
+ <LessSpecificReturnType errorLevel="info" />
+
+ <!-- level 3 issues - slightly lazy code writing, but provably low false-negatives -->
+
+ <DeprecatedMethod errorLevel="info" />
+ <DeprecatedProperty errorLevel="info" />
+ <DeprecatedClass errorLevel="info" />
+ <DeprecatedConstant errorLevel="info" />
+ <DeprecatedFunction errorLevel="info" />
+ <DeprecatedInterface errorLevel="info" />
+ <DeprecatedTrait errorLevel="info" />
+
+ <InternalMethod errorLevel="info" />
+ <InternalProperty errorLevel="info" />
+ <InternalClass errorLevel="info" />
+
+ <MissingClosureReturnType errorLevel="info" />
+ <MissingReturnType errorLevel="info" />
+ <MissingPropertyType errorLevel="info" />
+ <InvalidDocblock errorLevel="info" />
+ <MisplacedRequiredParam errorLevel="info" />
+
+ <PropertyNotSetInConstructor errorLevel="info" />
+ <MissingConstructor errorLevel="info" />
+ <MissingClosureParamType errorLevel="info" />
+ <MissingParamType errorLevel="info" />
+
+ <RedundantCondition errorLevel="info" />
+
+ <DocblockTypeContradiction errorLevel="info" />
+ <RedundantConditionGivenDocblockType errorLevel="info" />
+
+ <UnresolvableInclude errorLevel="info" />
+
+ <RawObjectIteration errorLevel="info" />
+
+ <InvalidStringClass errorLevel="info" />
+ </issueHandlers>
+</psalm>
diff --git a/vendor/brick/math/random-tests.php b/vendor/brick/math/random-tests.php
new file mode 100644
index 000000000..c59529f6f
--- /dev/null
+++ b/vendor/brick/math/random-tests.php
@@ -0,0 +1,184 @@
+<?php
+
+/**
+ * This script stress tests calculators with random large numbers and ensures that all implementations return the same
+ * results. It is designed to run in an infinite loop unless a bug is found.
+ */
+
+declare(strict_types=1);
+
+require __DIR__ . '/vendor/autoload.php';
+
+use Brick\Math\Internal\Calculator;
+
+(new class(30) { // max digits
+ private $gmp;
+ private $bcmath;
+ private $native;
+
+ private $maxDigits;
+
+ public function __construct(int $maxDigits)
+ {
+ $this->gmp = new Calculator\GmpCalculator();
+ $this->bcmath = new Calculator\BcMathCalculator();
+ $this->native = new Calculator\NativeCalculator();
+
+ $this->maxDigits = $maxDigits;
+ }
+
+ public function __invoke() : void
+ {
+ for (;;) {
+ $a = $this->generateRandomNumber();
+ $b = $this->generateRandomNumber();
+ $c = $this->generateRandomNumber();
+
+ $this->runTests($a, $b);
+ $this->runTests($b, $a);
+
+ if ($a !== '0') {
+ $this->runTests("-$a", $b);
+ $this->runTests($b, "-$a");
+ }
+
+ if ($b !== '0') {
+ $this->runTests($a, "-$b");
+ $this->runTests("-$b", $a);
+ }
+
+ if ($a !== '0' && $b !== '0') {
+ $this->runTests("-$a", "-$b");
+ $this->runTests("-$b", "-$a");
+ }
+
+ if ($c !== '0') {
+ $this->test("$a POW $b MOD $c", function(Calculator $calc) use($a, $b, $c) {
+ return $calc->modPow($a, $b, $c);
+ });
+ }
+ }
+ }
+
+ /**
+ * @param string $a The left operand.
+ * @param string $b The right operand.
+ */
+ function runTests(string $a, string $b) : void
+ {
+ $this->test("$a + $b", function(Calculator $c) use($a, $b) {
+ return $c->add($a, $b);
+ });
+
+ $this->test("$a - $b", function(Calculator $c) use($a, $b) {
+ return $c->sub($a, $b);
+ });
+
+ $this->test("$a * $b", function(Calculator $c) use($a, $b) {
+ return $c->mul($a, $b);
+ });
+
+ if ($b !== '0') {
+ $this->test("$a / $b", function(Calculator $c) use($a, $b) {
+ return $c->divQR($a, $b);
+ });
+
+ $this->test("$a MOD $b", function(Calculator $c) use($a, $b) {
+ return $c->mod($a, $b);
+ });
+ }
+
+ if ($b !== '0' && $b[0] !== '-') {
+ $this->test("INV $a MOD $b", function(Calculator $c) use($a, $b) {
+ return $c->modInverse($a, $b);
+ });
+ }
+
+ $this->test("GCD $a, $b", function(Calculator $c) use($a, $b) {
+ return $c->gcd($a, $b);
+ });
+
+ if ($a[0] !== '-') {
+ $this->test("SQRT $a", function(Calculator $c) use($a, $b) {
+ return $c->sqrt($a);
+ });
+ }
+
+ $this->test("$a AND $b", function(Calculator $c) use($a, $b) {
+ return $c->and($a, $b);
+ });
+
+ $this->test("$a OR $b", function(Calculator $c) use($a, $b) {
+ return $c->or($a, $b);
+ });
+
+ $this->test("$a XOR $b", function(Calculator $c) use($a, $b) {
+ return $c->xor($a, $b);
+ });
+ }
+
+ /**
+ * @param string $test A string representing the test being executed.
+ * @param Closure $callback A callback function accepting a Calculator instance and returning a calculation result.
+ */
+ private function test(string $test, Closure $callback) : void
+ {
+ static $counter = 0;
+ static $lastOutputTime = null;
+
+ $gmpResult = $callback($this->gmp);
+ $bcmathResult = $callback($this->bcmath);
+ $nativeResult = $callback($this->native);
+
+ if ($gmpResult !== $bcmathResult) {
+ self::failure('GMP', 'BCMath', $test);
+ }
+
+ if ($gmpResult !== $nativeResult) {
+ self::failure('GMP', 'Native', $test);
+ }
+
+ $counter++;
+ $time = microtime(true);
+
+ if ($lastOutputTime === null) {
+ $lastOutputTime = $time;
+ } elseif ($time - $lastOutputTime >= 0.1) {
+ echo "\r", number_format($counter);
+ $lastOutputTime = $time;
+ }
+ }
+
+ /**
+ * @param string $c1 The name of the first calculator.
+ * @param string $c2 The name of the second calculator.
+ * @param string $test A string representing the test being executed.
+ */
+ private static function failure(string $c1, string $c2, string $test) : void
+ {
+ echo PHP_EOL;
+ echo 'FAILURE!', PHP_EOL;
+ echo $c1, ' vs ', $c2, PHP_EOL;
+ echo $test, PHP_EOL;
+ die;
+ }
+
+ private function generateRandomNumber() : string
+ {
+ $length = random_int(1, $this->maxDigits);
+
+ $number = '';
+
+ for ($i = 0; $i < $length; $i++) {
+ $number .= random_int(0, 9);
+ }
+
+ $number = ltrim($number, '0');
+
+ if ($number === '') {
+ return '0';
+ }
+
+ return $number;
+ }
+})();
diff --git a/vendor/brick/math/src/BigDecimal.php b/vendor/brick/math/src/BigDecimal.php
new file mode 100644
index 000000000..287177140
--- /dev/null
+++ b/vendor/brick/math/src/BigDecimal.php
@@ -0,0 +1,855 @@
+<?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->value = $value;
+ $this->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)->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 < 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 */
+ 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 */
+ 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 */
+ 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->scale, $that->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->value === '0' && $that->scale <= $this->scale) {
+ return $this;
+ }
+
+ if ($this->value === '0' && $this->scale <= $that->scale) {
+ return $that;
+ }
+
+ [$a, $b] = $this->scaleValues($this, $that);
+
+ $value = Calculator::get()->add($a, $b);
+ $scale = $this->scale > $that->scale ? $this->scale : $that->scale;
+
+ return new BigDecimal($value, $scale);
+ }
+
+ /**
+ * Returns the difference of this number and the given one.
+ *
+ * The result has a scale of `max($this->scale, $that->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->value === '0' && $that->scale <= $this->scale) {
+ return $this;
+ }
+
+ [$a, $b] = $this->scaleValues($this, $that);
+
+ $value = Calculator::get()->sub($a, $b);
+ $scale = $this->scale > $that->scale ? $this->scale : $that->scale;
+
+ return new BigDecimal($value, $scale);
+ }
+
+ /**
+ * Returns the product of this number and the given one.
+ *
+ * The result has a scale of `$this->scale + $that->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->value === '1' && $that->scale === 0) {
+ return $this;
+ }
+
+ if ($this->value === '1' && $this->scale === 0) {
+ return $that;
+ }
+
+ $value = Calculator::get()->mul($this->value, $that->value);
+ $scale = $this->scale + $that->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->isZero()) {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ if ($scale === null) {
+ $scale = $this->scale;
+ } elseif ($scale < 0) {
+ throw new \InvalidArgumentException('Scale cannot be negative.');
+ }
+
+ if ($that->value === '1' && $that->scale === 0 && $scale === $this->scale) {
+ return $this;
+ }
+
+ $p = $this->valueWithMinScale($that->scale + $scale);
+ $q = $that->valueWithMinScale($this->scale - $scale);
+
+ $result = Calculator::get()->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->value === '0') {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ [, $b] = $this->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->divQ($d, (string) $prime);
+ $scale++;
+ }
+ }
+
+ return $this->dividedBy($that, $scale)->stripTrailingZeros();
+ }
+
+ /**
+ * Returns this number exponentiated to the given value.
+ *
+ * The result has a scale of `$this->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 < 0 || $exponent > 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()->pow($this->value, $exponent), $this->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->isZero()) {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ $p = $this->valueWithMinScale($that->scale);
+ $q = $that->valueWithMinScale($this->scale);
+
+ $quotient = Calculator::get()->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->scale, $that->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->isZero()) {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ $p = $this->valueWithMinScale($that->scale);
+ $q = $that->valueWithMinScale($this->scale);
+
+ $remainder = Calculator::get()->divR($p, $q);
+
+ $scale = $this->scale > $that->scale ? $this->scale : $that->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->scale, $that->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->isZero()) {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ $p = $this->valueWithMinScale($that->scale);
+ $q = $that->valueWithMinScale($this->scale);
+
+ [$quotient, $remainder] = Calculator::get()->divQR($p, $q);
+
+ $scale = $this->scale > $that->scale ? $this->scale : $that->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 < 0) {
+ throw new \InvalidArgumentException('Scale cannot be negative.');
+ }
+
+ if ($this->value === '0') {
+ return new BigDecimal('0', $scale);
+ }
+
+ if ($this->value[0] === '-') {
+ throw new NegativeNumberException('Cannot calculate the square root of a negative number.');
+ }
+
+ $value = $this->value;
+ $addDigits = 2 * $scale - $this->scale;
+
+ if ($addDigits > 0) {
+ // add zeros
+ $value .= \str_repeat('0', $addDigits);
+ } elseif ($addDigits < 0) {
+ // trim digits
+ if (-$addDigits >= \strlen($this->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()->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 < 0) {
+ return $this->withPointMovedRight(-$n);
+ }
+
+ return new BigDecimal($this->value, $this->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 < 0) {
+ return $this->withPointMovedLeft(-$n);
+ }
+
+ $value = $this->value;
+ $scale = $this->scale - $n;
+
+ if ($scale < 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->scale === 0) {
+ return $this;
+ }
+
+ $trimmedValue = \rtrim($this->value, '0');
+
+ if ($trimmedValue === '') {
+ return BigDecimal::zero();
+ }
+
+ $trimmableZeros = \strlen($this->value) - \strlen($trimmedValue);
+
+ if ($trimmableZeros === 0) {
+ return $this;
+ }
+
+ if ($trimmableZeros > $this->scale) {
+ $trimmableZeros = $this->scale;
+ }
+
+ $value = \substr($this->value, 0, -$trimmableZeros);
+ $scale = $this->scale - $trimmableZeros;
+
+ return new BigDecimal($value, $scale);
+ }
+
+ /**
+ * Returns the absolute value of this number.
+ *
+ * @return BigDecimal
+ */
+ public function abs() : BigDecimal
+ {
+ return $this->isNegative() ? $this->negated() : $this;
+ }
+
+ /**
+ * Returns the negated value of this number.
+ *
+ * @return BigDecimal
+ */
+ public function negated() : BigDecimal
+ {
+ return new BigDecimal(Calculator::get()->neg($this->value), $this->scale);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compareTo($that) : int
+ {
+ $that = BigNumber::of($that);
+
+ if ($that instanceof BigInteger) {
+ $that = $that->toBigDecimal();
+ }
+
+ if ($that instanceof BigDecimal) {
+ [$a, $b] = $this->scaleValues($this, $that);
+
+ return Calculator::get()->cmp($a, $b);
+ }
+
+ return - $that->compareTo($this);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSign() : int
+ {
+ return ($this->value === '0') ? 0 : (($this->value[0] === '-') ? -1 : 1);
+ }
+
+ /**
+ * @return BigInteger
+ */
+ public function getUnscaledValue() : BigInteger
+ {
+ return BigInteger::create($this->value);
+ }
+
+ /**
+ * @return int
+ */
+ public function getScale() : int
+ {
+ return $this->scale;
+ }
+
+ /**
+ * Returns a string representing the integral part of this decimal number.
+ *
+ * Example: `-123.456` => `-123`.
+ *
+ * @return string
+ */
+ public function getIntegralPart() : string
+ {
+ if ($this->scale === 0) {
+ return $this->value;
+ }
+
+ $value = $this->getUnscaledValueWithLeadingZeros();
+
+ return \substr($value, 0, -$this->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` => '456', `123` => ''.
+ *
+ * @return string
+ */
+ public function getFractionalPart() : string
+ {
+ if ($this->scale === 0) {
+ return '';
+ }
+
+ $value = $this->getUnscaledValueWithLeadingZeros();
+
+ return \substr($value, -$this->scale);
+ }
+
+ /**
+ * Returns whether this decimal number has a non-zero fractional part.
+ *
+ * @return bool
+ */
+ public function hasNonZeroFractionalPart() : bool
+ {
+ return $this->getFractionalPart() !== \str_repeat('0', $this->scale);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigInteger() : BigInteger
+ {
+ if ($this->scale === 0) {
+ $zeroScaleDecimal = $this;
+ } else {
+ $zeroScaleDecimal = $this->dividedBy(1, 0);
+ }
+
+ return BigInteger::create($zeroScaleDecimal->value);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigDecimal() : BigDecimal
+ {
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigRational() : BigRational
+ {
+ $numerator = BigInteger::create($this->value);
+ $denominator = BigInteger::create('1' . \str_repeat('0', $this->scale));
+
+ return BigRational::create($numerator, $denominator, false);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toScale(int $scale, int $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
+ {
+ if ($scale === $this->scale) {
+ return $this;
+ }
+
+ return $this->dividedBy(BigDecimal::one(), $scale, $roundingMode);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toInt() : int
+ {
+ return $this->toBigInteger()->toInt();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toFloat() : float
+ {
+ return (float) (string) $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function __toString() : string
+ {
+ if ($this->scale === 0) {
+ return $this->value;
+ }
+
+ $value = $this->getUnscaledValueWithLeadingZeros();
+
+ return \substr($value, 0, -$this->scale) . '.' . \substr($value, -$this->scale);
+ }
+
+ /**
+ * This method is required by interface Serializable and SHOULD NOT be accessed directly.
+ *
+ * @internal
+ *
+ * @return string
+ */
+ public function serialize() : string
+ {
+ return $this->value . ':' . $this->scale;
+ }
+
+ /**
+ * This method is only here to implement interface Serializable and cannot be accessed directly.
+ *
+ * @internal
+ *
+ * @param string $value
+ *
+ * @return void
+ *
+ * @throws \LogicException
+ */
+ public function unserialize($value) : void
+ {
+ if (isset($this->value)) {
+ throw new \LogicException('unserialize() is an internal function, it must not be called directly.');
+ }
+
+ [$value, $scale] = \explode(':', $value);
+
+ $this->value = $value;
+ $this->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{0: string, 1: string} The scaled integer values of $x and $y.
+ */
+ private function scaleValues(BigDecimal $x, BigDecimal $y) : array
+ {
+ $a = $x->value;
+ $b = $y->value;
+
+ if ($b !== '0' && $x->scale > $y->scale) {
+ $b .= \str_repeat('0', $x->scale - $y->scale);
+ } elseif ($a !== '0' && $x->scale < $y->scale) {
+ $a .= \str_repeat('0', $y->scale - $x->scale);
+ }
+
+ return [$a, $b];
+ }
+
+ /**
+ * @param int $scale
+ *
+ * @return string
+ */
+ private function valueWithMinScale(int $scale) : string
+ {
+ $value = $this->value;
+
+ if ($this->value !== '0' && $scale > $this->scale) {
+ $value .= \str_repeat('0', $scale - $this->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->value;
+ $targetLength = $this->scale + 1;
+ $negative = ($value[0] === '-');
+ $length = \strlen($value);
+
+ if ($negative) {
+ $length--;
+ }
+
+ if ($length >= $targetLength) {
+ return $this->value;
+ }
+
+ if ($negative) {
+ $value = \substr($value, 1);
+ }
+
+ $value = \str_pad($value, $targetLength, '0', STR_PAD_LEFT);
+
+ if ($negative) {
+ $value = '-' . $value;
+ }
+
+ return $value;
+ }
+}
diff --git a/vendor/brick/math/src/BigInteger.php b/vendor/brick/math/src/BigInteger.php
new file mode 100644
index 000000000..cee3ce82b
--- /dev/null
+++ b/vendor/brick/math/src/BigInteger.php
@@ -0,0 +1,1134 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math;
+
+use Brick\Math\Exception\DivisionByZeroException;
+use Brick\Math\Exception\IntegerOverflowException;
+use Brick\Math\Exception\MathException;
+use Brick\Math\Exception\NegativeNumberException;
+use Brick\Math\Exception\NumberFormatException;
+use Brick\Math\Internal\Calculator;
+
+/**
+ * An arbitrary-size integer.
+ *
+ * All methods accepting a number as a parameter accept either a BigInteger instance,
+ * an integer, or a string representing an arbitrary size integer.
+ *
+ * @psalm-immutable
+ */
+final class BigInteger extends BigNumber
+{
+ /**
+ * The value, as a string of digits with optional leading minus sign.
+ *
+ * No leading zeros must be present.
+ * No leading minus sign must be present if the number is zero.
+ *
+ * @var string
+ */
+ private $value;
+
+ /**
+ * Protected constructor. Use a factory method to obtain an instance.
+ *
+ * @param string $value A string of digits, with optional leading minus sign.
+ */
+ protected function __construct(string $value)
+ {
+ $this->value = $value;
+ }
+
+ /**
+ * Creates a BigInteger of the given value.
+ *
+ * @param BigNumber|int|float|string $value
+ *
+ * @return BigInteger
+ *
+ * @throws MathException If the value cannot be converted to a BigInteger.
+ *
+ * @psalm-pure
+ */
+ public static function of($value) : BigNumber
+ {
+ return parent::of($value)->toBigInteger();
+ }
+
+ /**
+ * Creates a number from a string in a given base.
+ *
+ * The string can optionally be prefixed with the `+` or `-` sign.
+ *
+ * Bases greater than 36 are not supported by this method, as there is no clear consensus on which of the lowercase
+ * or uppercase characters should come first. Instead, this method accepts any base up to 36, and does not
+ * differentiate lowercase and uppercase characters, which are considered equal.
+ *
+ * For bases greater than 36, and/or custom alphabets, use the fromArbitraryBase() method.
+ *
+ * @param string $number The number to convert, in the given base.
+ * @param int $base The base of the number, between 2 and 36.
+ *
+ * @return BigInteger
+ *
+ * @throws NumberFormatException If the number is empty, or contains invalid chars for the given base.
+ * @throws \InvalidArgumentException If the base is out of range.
+ *
+ * @psalm-pure
+ */
+ public static function fromBase(string $number, int $base) : BigInteger
+ {
+ if ($number === '') {
+ throw new NumberFormatException('The number cannot be empty.');
+ }
+
+ if ($base < 2 || $base > 36) {
+ throw new \InvalidArgumentException(\sprintf('Base %d is not in range 2 to 36.', $base));
+ }
+
+ if ($number[0] === '-') {
+ $sign = '-';
+ $number = \substr($number, 1);
+ } elseif ($number[0] === '+') {
+ $sign = '';
+ $number = \substr($number, 1);
+ } else {
+ $sign = '';
+ }
+
+ if ($number === '') {
+ throw new NumberFormatException('The number cannot be empty.');
+ }
+
+ $number = \ltrim($number, '0');
+
+ if ($number === '') {
+ // The result will be the same in any base, avoid further calculation.
+ return BigInteger::zero();
+ }
+
+ if ($number === '1') {
+ // The result will be the same in any base, avoid further calculation.
+ return new BigInteger($sign . '1');
+ }
+
+ $pattern = '/[^' . \substr(Calculator::ALPHABET, 0, $base) . ']/';
+
+ if (\preg_match($pattern, \strtolower($number), $matches) === 1) {
+ throw new NumberFormatException(\sprintf('"%s" is not a valid character in base %d.', $matches[0], $base));
+ }
+
+ if ($base === 10) {
+ // The number is usable as is, avoid further calculation.
+ return new BigInteger($sign . $number);
+ }
+
+ $result = Calculator::get()->fromBase($number, $base);
+
+ return new BigInteger($sign . $result);
+ }
+
+ /**
+ * Parses a string containing an integer in an arbitrary base, using a custom alphabet.
+ *
+ * Because this method accepts an alphabet with any character, including dash, it does not handle negative numbers.
+ *
+ * @param string $number The number to parse.
+ * @param string $alphabet The alphabet, for example '01' for base 2, or '01234567' for base 8.
+ *
+ * @return BigInteger
+ *
+ * @throws NumberFormatException If the given number is empty or contains invalid chars for the given alphabet.
+ * @throws \InvalidArgumentException If the alphabet does not contain at least 2 chars.
+ *
+ * @psalm-pure
+ */
+ public static function fromArbitraryBase(string $number, string $alphabet) : BigInteger
+ {
+ if ($number === '') {
+ throw new NumberFormatException('The number cannot be empty.');
+ }
+
+ $base = \strlen($alphabet);
+
+ if ($base < 2) {
+ throw new \InvalidArgumentException('The alphabet must contain at least 2 chars.');
+ }
+
+ $pattern = '/[^' . \preg_quote($alphabet, '/') . ']/';
+
+ if (\preg_match($pattern, $number, $matches) === 1) {
+ throw NumberFormatException::charNotInAlphabet($matches[0]);
+ }
+
+ $number = Calculator::get()->fromArbitraryBase($number, $alphabet, $base);
+
+ return new BigInteger($number);
+ }
+
+ /**
+ * Translates a string of bytes containing the binary representation of a BigInteger into a BigInteger.
+ *
+ * The input string is assumed to be in big-endian byte-order: the most significant byte is in the zeroth element.
+ *
+ * If `$signed` is true, the input is assumed to be in two's-complement representation, and the leading bit is
+ * interpreted as a sign bit. If `$signed` is false, the input is interpreted as an unsigned number, and the
+ * resulting BigInteger will always be positive or zero.
+ *
+ * This method can be used to retrieve a number exported by `toBytes()`, as long as the `$signed` flags match.
+ *
+ * @param string $value The byte string.
+ * @param bool $signed Whether to interpret as a signed number in two's-complement representation with a leading
+ * sign bit.
+ *
+ * @return BigInteger
+ *
+ * @throws NumberFormatException If the string is empty.
+ */
+ public static function fromBytes(string $value, bool $signed = true) : BigInteger
+ {
+ if ($value === '') {
+ throw new NumberFormatException('The byte string must not be empty.');
+ }
+
+ $twosComplement = false;
+
+ if ($signed) {
+ $x = \ord($value[0]);
+
+ if (($twosComplement = ($x >= 0x80))) {
+ $value = ~$value;
+ }
+ }
+
+ $number = self::fromBase(\bin2hex($value), 16);
+
+ if ($twosComplement) {
+ return $number->plus(1)->negated();
+ }
+
+ return $number;
+ }
+
+ /**
+ * Generates a pseudo-random number in the range 0 to 2^numBits - 1.
+ *
+ * Using the default random bytes generator, this method is suitable for cryptographic use.
+ *
+ * @param int $numBits The number of bits.
+ * @param callable|null $randomBytesGenerator A function that accepts a number of bytes as an integer, and returns a
+ * string of random bytes of the given length. Defaults to the
+ * `random_bytes()` function.
+ *
+ * @return BigInteger
+ *
+ * @throws \InvalidArgumentException If $numBits is negative.
+ */
+ public static function randomBits(int $numBits, ?callable $randomBytesGenerator = null) : BigInteger
+ {
+ if ($numBits < 0) {
+ throw new \InvalidArgumentException('The number of bits cannot be negative.');
+ }
+
+ if ($numBits === 0) {
+ return BigInteger::zero();
+ }
+
+ if ($randomBytesGenerator === null) {
+ $randomBytesGenerator = 'random_bytes';
+ }
+
+ $byteLength = \intdiv($numBits - 1, 8) + 1;
+
+ $extraBits = ($byteLength * 8 - $numBits);
+ $bitmask = \chr(0xFF >> $extraBits);
+
+ $randomBytes = $randomBytesGenerator($byteLength);
+ $randomBytes[0] = $randomBytes[0] & $bitmask;
+
+ return self::fromBytes($randomBytes, false);
+ }
+
+ /**
+ * Generates a pseudo-random number between `$min` and `$max`.
+ *
+ * Using the default random bytes generator, this method is suitable for cryptographic use.
+ *
+ * @param BigNumber|int|float|string $min The lower bound. Must be convertible to a BigInteger.
+ * @param BigNumber|int|float|string $max The upper bound. Must be convertible to a BigInteger.
+ * @param callable|null $randomBytesGenerator A function that accepts a number of bytes as an integer,
+ * and returns a string of random bytes of the given length.
+ * Defaults to the `random_bytes()` function.
+ *
+ * @return BigInteger
+ *
+ * @throws MathException If one of the parameters cannot be converted to a BigInteger,
+ * or `$min` is greater than `$max`.
+ */
+ public static function randomRange($min, $max, ?callable $randomBytesGenerator = null) : BigInteger
+ {
+ $min = BigInteger::of($min);
+ $max = BigInteger::of($max);
+
+ if ($min->isGreaterThan($max)) {
+ throw new MathException('$min cannot be greater than $max.');
+ }
+
+ if ($min->isEqualTo($max)) {
+ return $min;
+ }
+
+ $diff = $max->minus($min);
+ $bitLength = $diff->getBitLength();
+
+ // try until the number is in range (50% to 100% chance of success)
+ do {
+ $randomNumber = self::randomBits($bitLength, $randomBytesGenerator);
+ } while ($randomNumber->isGreaterThan($diff));
+
+ return $randomNumber->plus($min);
+ }
+
+ /**
+ * Returns a BigInteger representing zero.
+ *
+ * @return BigInteger
+ *
+ * @psalm-pure
+ */
+ public static function zero() : BigInteger
+ {
+ /** @psalm-suppress ImpureStaticVariable */
+ static $zero;
+
+ if ($zero === null) {
+ $zero = new BigInteger('0');
+ }
+
+ return $zero;
+ }
+
+ /**
+ * Returns a BigInteger representing one.
+ *
+ * @return BigInteger
+ *
+ * @psalm-pure
+ */
+ public static function one() : BigInteger
+ {
+ /** @psalm-suppress ImpureStaticVariable */
+ static $one;
+
+ if ($one === null) {
+ $one = new BigInteger('1');
+ }
+
+ return $one;
+ }
+
+ /**
+ * Returns a BigInteger representing ten.
+ *
+ * @return BigInteger
+ *
+ * @psalm-pure
+ */
+ public static function ten() : BigInteger
+ {
+ /** @psalm-suppress ImpureStaticVariable */
+ static $ten;
+
+ if ($ten === null) {
+ $ten = new BigInteger('10');
+ }
+
+ return $ten;
+ }
+
+ /**
+ * Returns the sum of this number and the given one.
+ *
+ * @param BigNumber|int|float|string $that The number to add. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger The result.
+ *
+ * @throws MathException If the number is not valid, or is not convertible to a BigInteger.
+ */
+ public function plus($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '0') {
+ return $this;
+ }
+
+ if ($this->value === '0') {
+ return $that;
+ }
+
+ $value = Calculator::get()->add($this->value, $that->value);
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns the difference of this number and the given one.
+ *
+ * @param BigNumber|int|float|string $that The number to subtract. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger The result.
+ *
+ * @throws MathException If the number is not valid, or is not convertible to a BigInteger.
+ */
+ public function minus($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '0') {
+ return $this;
+ }
+
+ $value = Calculator::get()->sub($this->value, $that->value);
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns the product of this number and the given one.
+ *
+ * @param BigNumber|int|float|string $that The multiplier. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger The result.
+ *
+ * @throws MathException If the multiplier is not a valid number, or is not convertible to a BigInteger.
+ */
+ public function multipliedBy($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '1') {
+ return $this;
+ }
+
+ if ($this->value === '1') {
+ return $that;
+ }
+
+ $value = Calculator::get()->mul($this->value, $that->value);
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns the result of the division of this number by the given one.
+ *
+ * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigInteger.
+ * @param int $roundingMode An optional rounding mode.
+ *
+ * @return BigInteger The result.
+ *
+ * @throws MathException If the divisor is not a valid number, is not convertible to a BigInteger, is zero,
+ * or RoundingMode::UNNECESSARY is used and the remainder is not zero.
+ */
+ public function dividedBy($that, int $roundingMode = RoundingMode::UNNECESSARY) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '1') {
+ return $this;
+ }
+
+ if ($that->value === '0') {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ $result = Calculator::get()->divRound($this->value, $that->value, $roundingMode);
+
+ return new BigInteger($result);
+ }
+
+ /**
+ * Returns this number exponentiated to the given value.
+ *
+ * @param int $exponent The exponent.
+ *
+ * @return BigInteger The result.
+ *
+ * @throws \InvalidArgumentException If the exponent is not in the range 0 to 1,000,000.
+ */
+ public function power(int $exponent) : BigInteger
+ {
+ if ($exponent === 0) {
+ return BigInteger::one();
+ }
+
+ if ($exponent === 1) {
+ return $this;
+ }
+
+ if ($exponent < 0 || $exponent > Calculator::MAX_POWER) {
+ throw new \InvalidArgumentException(\sprintf(
+ 'The exponent %d is not in the range 0 to %d.',
+ $exponent,
+ Calculator::MAX_POWER
+ ));
+ }
+
+ return new BigInteger(Calculator::get()->pow($this->value, $exponent));
+ }
+
+ /**
+ * Returns the quotient of the division of this number by the given one.
+ *
+ * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger
+ *
+ * @throws DivisionByZeroException If the divisor is zero.
+ */
+ public function quotient($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '1') {
+ return $this;
+ }
+
+ if ($that->value === '0') {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ $quotient = Calculator::get()->divQ($this->value, $that->value);
+
+ return new BigInteger($quotient);
+ }
+
+ /**
+ * Returns the remainder of the division of this number by the given one.
+ *
+ * The remainder, when non-zero, has the same sign as the dividend.
+ *
+ * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger
+ *
+ * @throws DivisionByZeroException If the divisor is zero.
+ */
+ public function remainder($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '1') {
+ return BigInteger::zero();
+ }
+
+ if ($that->value === '0') {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ $remainder = Calculator::get()->divR($this->value, $that->value);
+
+ return new BigInteger($remainder);
+ }
+
+ /**
+ * Returns the quotient and remainder of the division of this number by the given one.
+ *
+ * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger[] An array containing the quotient and the remainder.
+ *
+ * @throws DivisionByZeroException If the divisor is zero.
+ */
+ public function quotientAndRemainder($that) : array
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '0') {
+ throw DivisionByZeroException::divisionByZero();
+ }
+
+ [$quotient, $remainder] = Calculator::get()->divQR($this->value, $that->value);
+
+ return [
+ new BigInteger($quotient),
+ new BigInteger($remainder)
+ ];
+ }
+
+ /**
+ * Returns the modulo of this number and the given one.
+ *
+ * The modulo operation yields the same result as the remainder operation when both operands are of the same sign,
+ * and may differ when signs are different.
+ *
+ * The result of the modulo operation, when non-zero, has the same sign as the divisor.
+ *
+ * @param BigNumber|int|float|string $that The divisor. Must be convertible to a BigInteger.
+ *
+ * @return BigInteger
+ *
+ * @throws DivisionByZeroException If the divisor is zero.
+ */
+ public function mod($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '0') {
+ throw DivisionByZeroException::modulusMustNotBeZero();
+ }
+
+ $value = Calculator::get()->mod($this->value, $that->value);
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns the modular multiplicative inverse of this BigInteger modulo $m.
+ *
+ * @param BigInteger $m
+ *
+ * @return BigInteger
+ *
+ * @throws DivisionByZeroException If $m is zero.
+ * @throws NegativeNumberException If $m is negative.
+ * @throws MathException If this BigInteger has no multiplicative inverse mod m (that is, this BigInteger
+ * is not relatively prime to m).
+ */
+ public function modInverse(BigInteger $m) : BigInteger
+ {
+ if ($m->value === '0') {
+ throw DivisionByZeroException::modulusMustNotBeZero();
+ }
+
+ if ($m->isNegative()) {
+ throw new NegativeNumberException('Modulus must not be negative.');
+ }
+
+ if ($m->value === '1') {
+ return BigInteger::zero();
+ }
+
+ $value = Calculator::get()->modInverse($this->value, $m->value);
+
+ if ($value === null) {
+ throw new MathException('Unable to compute the modInverse for the given modulus.');
+ }
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns this number raised into power with modulo.
+ *
+ * This operation only works on positive numbers.
+ *
+ * @param BigNumber|int|float|string $exp The exponent. Must be positive or zero.
+ * @param BigNumber|int|float|string $mod The modulus. Must be strictly positive.
+ *
+ * @return BigInteger
+ *
+ * @throws NegativeNumberException If any of the operands is negative.
+ * @throws DivisionByZeroException If the modulus is zero.
+ */
+ public function modPow($exp, $mod) : BigInteger
+ {
+ $exp = BigInteger::of($exp);
+ $mod = BigInteger::of($mod);
+
+ if ($this->isNegative() || $exp->isNegative() || $mod->isNegative()) {
+ throw new NegativeNumberException('The operands cannot be negative.');
+ }
+
+ if ($mod->isZero()) {
+ throw DivisionByZeroException::modulusMustNotBeZero();
+ }
+
+ $result = Calculator::get()->modPow($this->value, $exp->value, $mod->value);
+
+ return new BigInteger($result);
+ }
+
+ /**
+ * Returns the greatest common divisor of this number and the given one.
+ *
+ * The GCD is always positive, unless both operands are zero, in which case it is zero.
+ *
+ * @param BigNumber|int|float|string $that The operand. Must be convertible to an integer number.
+ *
+ * @return BigInteger
+ */
+ public function gcd($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ if ($that->value === '0' && $this->value[0] !== '-') {
+ return $this;
+ }
+
+ if ($this->value === '0' && $that->value[0] !== '-') {
+ return $that;
+ }
+
+ $value = Calculator::get()->gcd($this->value, $that->value);
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns the integer square root number of this number, rounded down.
+ *
+ * The result is the largest x such that x² ≤ n.
+ *
+ * @return BigInteger
+ *
+ * @throws NegativeNumberException If this number is negative.
+ */
+ public function sqrt() : BigInteger
+ {
+ if ($this->value[0] === '-') {
+ throw new NegativeNumberException('Cannot calculate the square root of a negative number.');
+ }
+
+ $value = Calculator::get()->sqrt($this->value);
+
+ return new BigInteger($value);
+ }
+
+ /**
+ * Returns the absolute value of this number.
+ *
+ * @return BigInteger
+ */
+ public function abs() : BigInteger
+ {
+ return $this->isNegative() ? $this->negated() : $this;
+ }
+
+ /**
+ * Returns the inverse of this number.
+ *
+ * @return BigInteger
+ */
+ public function negated() : BigInteger
+ {
+ return new BigInteger(Calculator::get()->neg($this->value));
+ }
+
+ /**
+ * Returns the integer bitwise-and combined with another integer.
+ *
+ * This method returns a negative BigInteger if and only if both operands are negative.
+ *
+ * @param BigNumber|int|float|string $that The operand. Must be convertible to an integer number.
+ *
+ * @return BigInteger
+ */
+ public function and($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ return new BigInteger(Calculator::get()->and($this->value, $that->value));
+ }
+
+ /**
+ * Returns the integer bitwise-or combined with another integer.
+ *
+ * This method returns a negative BigInteger if and only if either of the operands is negative.
+ *
+ * @param BigNumber|int|float|string $that The operand. Must be convertible to an integer number.
+ *
+ * @return BigInteger
+ */
+ public function or($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ return new BigInteger(Calculator::get()->or($this->value, $that->value));
+ }
+
+ /**
+ * Returns the integer bitwise-xor combined with another integer.
+ *
+ * This method returns a negative BigInteger if and only if exactly one of the operands is negative.
+ *
+ * @param BigNumber|int|float|string $that The operand. Must be convertible to an integer number.
+ *
+ * @return BigInteger
+ */
+ public function xor($that) : BigInteger
+ {
+ $that = BigInteger::of($that);
+
+ return new BigInteger(Calculator::get()->xor($this->value, $that->value));
+ }
+
+ /**
+ * Returns the bitwise-not of this BigInteger.
+ *
+ * @return BigInteger
+ */
+ public function not() : BigInteger
+ {
+ return $this->negated()->minus(1);
+ }
+
+ /**
+ * Returns the integer left shifted by a given number of bits.
+ *
+ * @param int $distance The distance to shift.
+ *
+ * @return BigInteger
+ */
+ public function shiftedLeft(int $distance) : BigInteger
+ {
+ if ($distance === 0) {
+ return $this;
+ }
+
+ if ($distance < 0) {
+ return $this->shiftedRight(- $distance);
+ }
+
+ return $this->multipliedBy(BigInteger::of(2)->power($distance));
+ }
+
+ /**
+ * Returns the integer right shifted by a given number of bits.
+ *
+ * @param int $distance The distance to shift.
+ *
+ * @return BigInteger
+ */
+ public function shiftedRight(int $distance) : BigInteger
+ {
+ if ($distance === 0) {
+ return $this;
+ }
+
+ if ($distance < 0) {
+ return $this->shiftedLeft(- $distance);
+ }
+
+ $operand = BigInteger::of(2)->power($distance);
+
+ if ($this->isPositiveOrZero()) {
+ return $this->quotient($operand);
+ }
+
+ return $this->dividedBy($operand, RoundingMode::UP);
+ }
+
+ /**
+ * Returns the number of bits in the minimal two's-complement representation of this BigInteger, excluding a sign bit.
+ *
+ * For positive BigIntegers, this is equivalent to the number of bits in the ordinary binary representation.
+ * Computes (ceil(log2(this < 0 ? -this : this+1))).
+ *
+ * @return int
+ */
+ public function getBitLength() : int
+ {
+ if ($this->value === '0') {
+ return 0;
+ }
+
+ if ($this->isNegative()) {
+ return $this->abs()->minus(1)->getBitLength();
+ }
+
+ return \strlen($this->toBase(2));
+ }
+
+ /**
+ * Returns the index of the rightmost (lowest-order) one bit in this BigInteger.
+ *
+ * Returns -1 if this BigInteger contains no one bits.
+ *
+ * @return int
+ */
+ public function getLowestSetBit() : int
+ {
+ $n = $this;
+ $bitLength = $this->getBitLength();
+
+ for ($i = 0; $i <= $bitLength; $i++) {
+ if ($n->isOdd()) {
+ return $i;
+ }
+
+ $n = $n->shiftedRight(1);
+ }
+
+ return -1;
+ }
+
+ /**
+ * Returns whether this number is even.
+ *
+ * @return bool
+ */
+ public function isEven() : bool
+ {
+ return \in_array($this->value[-1], ['0', '2', '4', '6', '8'], true);
+ }
+
+ /**
+ * Returns whether this number is odd.
+ *
+ * @return bool
+ */
+ public function isOdd() : bool
+ {
+ return \in_array($this->value[-1], ['1', '3', '5', '7', '9'], true);
+ }
+
+ /**
+ * Returns true if and only if the designated bit is set.
+ *
+ * Computes ((this & (1<<n)) != 0).
+ *
+ * @param int $n The bit to test, 0-based.
+ *
+ * @return bool
+ *
+ * @throws \InvalidArgumentException If the bit to test is negative.
+ */
+ public function testBit(int $n) : bool
+ {
+ if ($n < 0) {
+ throw new \InvalidArgumentException('The bit to test cannot be negative.');
+ }
+
+ return $this->shiftedRight($n)->isOdd();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compareTo($that) : int
+ {
+ $that = BigNumber::of($that);
+
+ if ($that instanceof BigInteger) {
+ return Calculator::get()->cmp($this->value, $that->value);
+ }
+
+ return - $that->compareTo($this);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSign() : int
+ {
+ return ($this->value === '0') ? 0 : (($this->value[0] === '-') ? -1 : 1);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigInteger() : BigInteger
+ {
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigDecimal() : BigDecimal
+ {
+ return BigDecimal::create($this->value);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigRational() : BigRational
+ {
+ return BigRational::create($this, BigInteger::one(), false);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toScale(int $scale, int $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
+ {
+ return $this->toBigDecimal()->toScale($scale, $roundingMode);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toInt() : int
+ {
+ $intValue = (int) $this->value;
+
+ if ($this->value !== (string) $intValue) {
+ throw IntegerOverflowException::toIntOverflow($this);
+ }
+
+ return $intValue;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toFloat() : float
+ {
+ return (float) $this->value;
+ }
+
+ /**
+ * Returns a string representation of this number in the given base.
+ *
+ * The output will always be lowercase for bases greater than 10.
+ *
+ * @param int $base
+ *
+ * @return string
+ *
+ * @throws \InvalidArgumentException If the base is out of range.
+ */
+ public function toBase(int $base) : string
+ {
+ if ($base === 10) {
+ return $this->value;
+ }
+
+ if ($base < 2 || $base > 36) {
+ throw new \InvalidArgumentException(\sprintf('Base %d is out of range [2, 36]', $base));
+ }
+
+ return Calculator::get()->toBase($this->value, $base);
+ }
+
+ /**
+ * Returns a string representation of this number in an arbitrary base with a custom alphabet.
+ *
+ * Because this method accepts an alphabet with any character, including dash, it does not handle negative numbers;
+ * a NegativeNumberException will be thrown when attempting to call this method on a negative number.
+ *
+ * @param string $alphabet The alphabet, for example '01' for base 2, or '01234567' for base 8.
+ *
+ * @return string
+ *
+ * @throws NegativeNumberException If this number is negative.
+ * @throws \InvalidArgumentException If the given alphabet does not contain at least 2 chars.
+ */
+ public function toArbitraryBase(string $alphabet) : string
+ {
+ $base = \strlen($alphabet);
+
+ if ($base < 2) {
+ throw new \InvalidArgumentException('The alphabet must contain at least 2 chars.');
+ }
+
+ if ($this->value[0] === '-') {
+ throw new NegativeNumberException(__FUNCTION__ . '() does not support negative numbers.');
+ }
+
+ return Calculator::get()->toArbitraryBase($this->value, $alphabet, $base);
+ }
+
+ /**
+ * Returns a string of bytes containing the binary representation of this BigInteger.
+ *
+ * The string is in big-endian byte-order: the most significant byte is in the zeroth element.
+ *
+ * If `$signed` is true, the output will be in two's-complement representation, and a sign bit will be prepended to
+ * the output. If `$signed` is false, no sign bit will be prepended, and this method will throw an exception if the
+ * number is negative.
+ *
+ * The string will contain the minimum number of bytes required to represent this BigInteger, including a sign bit
+ * if `$signed` is true.
+ *
+ * This representation is compatible with the `fromBytes()` factory method, as long as the `$signed` flags match.
+ *
+ * @param bool $signed Whether to output a signed number in two's-complement representation with a leading sign bit.
+ *
+ * @return string
+ *
+ * @throws NegativeNumberException If $signed is false, and the number is negative.
+ */
+ public function toBytes(bool $signed = true) : string
+ {
+ if (! $signed && $this->isNegative()) {
+ throw new NegativeNumberException('Cannot convert a negative number to a byte string when $signed is false.');
+ }
+
+ $hex = $this->abs()->toBase(16);
+
+ if (\strlen($hex) % 2 !== 0) {
+ $hex = '0' . $hex;
+ }
+
+ $baseHexLength = \strlen($hex);
+
+ if ($signed) {
+ if ($this->isNegative()) {
+ $hex = \bin2hex(~\hex2bin($hex));
+ $hex = self::fromBase($hex, 16)->plus(1)->toBase(16);
+
+ $hexLength = \strlen($hex);
+
+ if ($hexLength < $baseHexLength) {
+ $hex = \str_repeat('0', $baseHexLength - $hexLength) . $hex;
+ }
+
+ if ($hex[0] < '8') {
+ $hex = 'FF' . $hex;
+ }
+ } else {
+ if ($hex[0] >= '8') {
+ $hex = '00' . $hex;
+ }
+ }
+ }
+
+ return \hex2bin($hex);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function __toString() : string
+ {
+ return $this->value;
+ }
+
+ /**
+ * This method is required by interface Serializable and SHOULD NOT be accessed directly.
+ *
+ * @internal
+ *
+ * @return string
+ */
+ public function serialize() : string
+ {
+ return $this->value;
+ }
+
+ /**
+ * This method is only here to implement interface Serializable and cannot be accessed directly.
+ *
+ * @internal
+ *
+ * @param string $value
+ *
+ * @return void
+ *
+ * @throws \LogicException
+ */
+ public function unserialize($value) : void
+ {
+ if (isset($this->value)) {
+ throw new \LogicException('unserialize() is an internal function, it must not be called directly.');
+ }
+
+ $this->value = $value;
+ }
+}
diff --git a/vendor/brick/math/src/BigNumber.php b/vendor/brick/math/src/BigNumber.php
new file mode 100644
index 000000000..59fcc7ce5
--- /dev/null
+++ b/vendor/brick/math/src/BigNumber.php
@@ -0,0 +1,566 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math;
+
+use Brick\Math\Exception\DivisionByZeroException;
+use Brick\Math\Exception\MathException;
+use Brick\Math\Exception\NumberFormatException;
+use Brick\Math\Exception\RoundingNecessaryException;
+
+/**
+ * Common interface for arbitrary-precision rational numbers.
+ *
+ * @psalm-immutable
+ */
+abstract class BigNumber implements \Serializable, \JsonSerializable
+{
+ /**
+ * The regular expression used to parse integer, decimal and rational numbers.
+ */
+ private const PARSE_REGEXP =
+ '/^' .
+ '(?<sign>[\-\+])?' .
+ '(?:' .
+ '(?:' .
+ '(?<integral>[0-9]+)?' .
+ '(?<point>\.)?' .
+ '(?<fractional>[0-9]+)?' .
+ '(?:[eE](?<exponent>[\-\+]?[0-9]+))?' .
+ ')|(?:' .
+ '(?<numerator>[0-9]+)' .
+ '\/?' .
+ '(?<denominator>[0-9]+)' .
+ ')' .
+ ')' .
+ '$/';
+
+ /**
+ * Creates a BigNumber of the given value.
+ *
+ * The concrete return type is dependent on the given value, with the following rules:
+ *
+ * - BigNumber instances are returned as is
+ * - integer numbers are returned as BigInteger
+ * - floating point numbers are converted to a string then parsed as such
+ * - strings containing a `/` character are returned as BigRational
+ * - 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
+ *
+ * @param BigNumber|int|float|string $value
+ *
+ * @return BigNumber
+ *
+ * @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
+ */
+ public static function of($value) : BigNumber
+ {
+ if ($value instanceof BigNumber) {
+ return $value;
+ }
+
+ if (\is_int($value)) {
+ return new BigInteger((string) $value);
+ }
+
+ if (\is_float($value)) {
+ $value = self::floatToString($value);
+ } else {
+ $value = (string) $value;
+ }
+
+ $throw = function() use ($value) : void {
+ throw new NumberFormatException(\sprintf(
+ 'The given value "%s" does not represent a valid number.',
+ $value
+ ));
+ };
+
+ if (\preg_match(self::PARSE_REGEXP, $value, $matches) !== 1) {
+ $throw();
+ }
+
+ $getMatch = function(string $value) use ($matches) : ?string {
+ return isset($matches[$value]) && $matches[$value] !== '' ? $matches[$value] : null;
+ };
+
+ $sign = $getMatch('sign');
+ $numerator = $getMatch('numerator');
+ $denominator = $getMatch('denominator');
+
+ if ($numerator !== null) {
+ $numerator = self::cleanUp($sign . $numerator);
+ $denominator = self::cleanUp($denominator);
+
+ if ($denominator === '0') {
+ throw DivisionByZeroException::denominatorMustNotBeZero();
+ }
+
+ return new BigRational(
+ new BigInteger($numerator),
+ new BigInteger($denominator),
+ false
+ );
+ }
+
+ $point = $getMatch('point');
+ $integral = $getMatch('integral');
+ $fractional = $getMatch('fractional');
+ $exponent = $getMatch('exponent');
+
+ if ($integral === null && $fractional === null) {
+ $throw();
+ }
+
+ if ($integral === null) {
+ $integral = '0';
+ }
+
+ if ($point !== null || $exponent !== null) {
+ $fractional = $fractional ?? '';
+ $exponent = $exponent !== null ? (int) $exponent : 0;
+
+ if ($exponent === PHP_INT_MIN || $exponent === PHP_INT_MAX) {
+ throw new NumberFormatException('Exponent too large.');
+ }
+
+ $unscaledValue = self::cleanUp($sign . $integral . $fractional);
+
+ $scale = \strlen($fractional) - $exponent;
+
+ if ($scale < 0) {
+ if ($unscaledValue !== '0') {
+ $unscaledValue .= \str_repeat('0', - $scale);
+ }
+ $scale = 0;
+ }
+
+ return new BigDecimal($unscaledValue, $scale);
+ }
+
+ $integral = self::cleanUp($sign . $integral);
+
+ return new BigInteger($integral);
+ }
+
+ /**
+ * Safely converts float to string, avoiding locale-dependent issues.
+ *
+ * @see https://github.com/brick/math/pull/20
+ *
+ * @param float $float
+ *
+ * @return string
+ *
+ * @psalm-pure
+ * @psalm-suppress ImpureFunctionCall
+ */
+ private static function floatToString(float $float) : string
+ {
+ $currentLocale = \setlocale(LC_NUMERIC, '0');
+ \setlocale(LC_NUMERIC, 'C');
+
+ $result = (string) $float;
+
+ \setlocale(LC_NUMERIC, $currentLocale);
+
+ return $result;
+ }
+
+ /**
+ * Proxy method to access protected constructors from sibling classes.
+ *
+ * @internal
+ *
+ * @param mixed ...$args The arguments to the constructor.
+ *
+ * @return static
+ *
+ * @psalm-pure
+ */
+ protected static function create(... $args) : BigNumber
+ {
+ /** @psalm-suppress TooManyArguments */
+ return new static(... $args);
+ }
+
+ /**
+ * Returns the minimum of the given values.
+ *
+ * @param BigNumber|int|float|string ...$values The numbers to compare. All the numbers need to be convertible
+ * to an instance of the class this method is called on.
+ *
+ * @return static The minimum value.
+ *
+ * @throws \InvalidArgumentException If no values are given.
+ * @throws MathException If an argument is not valid.
+ *
+ * @psalm-pure
+ */
+ public static function min(...$values) : BigNumber
+ {
+ $min = null;
+
+ foreach ($values as $value) {
+ $value = static::of($value);
+
+ if ($min === null || $value->isLessThan($min)) {
+ $min = $value;
+ }
+ }
+
+ if ($min === null) {
+ throw new \InvalidArgumentException(__METHOD__ . '() expects at least one value.');
+ }
+
+ return $min;
+ }
+
+ /**
+ * Returns the maximum of the given values.
+ *
+ * @param BigNumber|int|float|string ...$values The numbers to compare. All the numbers need to be convertible
+ * to an instance of the class this method is called on.
+ *
+ * @return static The maximum value.
+ *
+ * @throws \InvalidArgumentException If no values are given.
+ * @throws MathException If an argument is not valid.
+ *
+ * @psalm-pure
+ */
+ public static function max(...$values) : BigNumber
+ {
+ $max = null;
+
+ foreach ($values as $value) {
+ $value = static::of($value);
+
+ if ($max === null || $value->isGreaterThan($max)) {
+ $max = $value;
+ }
+ }
+
+ if ($max === null) {
+ throw new \InvalidArgumentException(__METHOD__ . '() expects at least one value.');
+ }
+
+ return $max;
+ }
+
+ /**
+ * Returns the sum of the given values.
+ *
+ * @param BigNumber|int|float|string ...$values The numbers to add. All the numbers need to be convertible
+ * to an instance of the class this method is called on.
+ *
+ * @return static The sum.
+ *
+ * @throws \InvalidArgumentException If no values are given.
+ * @throws MathException If an argument is not valid.
+ *
+ * @psalm-pure
+ */
+ public static function sum(...$values) : BigNumber
+ {
+ /** @var BigNumber|null $sum */
+ $sum = null;
+
+ foreach ($values as $value) {
+ $value = static::of($value);
+
+ if ($sum === null) {
+ $sum = $value;
+ } else {
+ $sum = self::add($sum, $value);
+ }
+ }
+
+ if ($sum === null) {
+ throw new \InvalidArgumentException(__METHOD__ . '() expects at least one value.');
+ }
+
+ return $sum;
+ }
+
+ /**
+ * Adds two BigNumber instances in the correct order to avoid a RoundingNecessaryException.
+ *
+ * @todo This could be better resolved by creating an abstract protected method in BigNumber, and leaving to
+ * concrete classes the responsibility to perform the addition themselves or delegate it to the given number,
+ * depending on their ability to perform the operation. This will also require a version bump because we're
+ * potentially breaking custom BigNumber implementations (if any...)
+ *
+ * @param BigNumber $a
+ * @param BigNumber $b
+ *
+ * @return BigNumber
+ *
+ * @psalm-pure
+ */
+ private static function add(BigNumber $a, BigNumber $b) : BigNumber
+ {
+ if ($a instanceof BigRational) {
+ return $a->plus($b);
+ }
+
+ if ($b instanceof BigRational) {
+ return $b->plus($a);
+ }
+
+ if ($a instanceof BigDecimal) {
+ return $a->plus($b);
+ }
+
+ if ($b instanceof BigDecimal) {
+ return $b->plus($a);
+ }
+
+ /** @var BigInteger $a */
+
+ return $a->plus($b);
+ }
+
+ /**
+ * Removes optional leading zeros and + sign from the given number.
+ *
+ * @param string $number The number, validated as a non-empty string of digits with optional leading sign.
+ *
+ * @return string
+ *
+ * @psalm-pure
+ */
+ private static function cleanUp(string $number) : string
+ {
+ $firstChar = $number[0];
+
+ if ($firstChar === '+' || $firstChar === '-') {
+ $number = \substr($number, 1);
+ }
+
+ $number = \ltrim($number, '0');
+
+ if ($number === '') {
+ return '0';
+ }
+
+ if ($firstChar === '-') {
+ return '-' . $number;
+ }
+
+ return $number;
+ }
+
+ /**
+ * Checks if this number is equal to the given one.
+ *
+ * @param BigNumber|int|float|string $that
+ *
+ * @return bool
+ */
+ public function isEqualTo($that) : bool
+ {
+ return $this->compareTo($that) === 0;
+ }
+
+ /**
+ * Checks if this number is strictly lower than the given one.
+ *
+ * @param BigNumber|int|float|string $that
+ *
+ * @return bool
+ */
+ public function isLessThan($that) : bool
+ {
+ return $this->compareTo($that) < 0;
+ }
+
+ /**
+ * Checks if this number is lower than or equal to the given one.
+ *
+ * @param BigNumber|int|float|string $that
+ *
+ * @return bool
+ */
+ public function isLessThanOrEqualTo($that) : bool
+ {
+ return $this->compareTo($that) <= 0;
+ }
+
+ /**
+ * Checks if this number is strictly greater than the given one.
+ *
+ * @param BigNumber|int|float|string $that
+ *
+ * @return bool
+ */
+ public function isGreaterThan($that) : bool
+ {
+ return $this->compareTo($that) > 0;
+ }
+
+ /**
+ * Checks if this number is greater than or equal to the given one.
+ *
+ * @param BigNumber|int|float|string $that
+ *
+ * @return bool
+ */
+ public function isGreaterThanOrEqualTo($that) : bool
+ {
+ return $this->compareTo($that) >= 0;
+ }
+
+ /**
+ * Checks if this number equals zero.
+ *
+ * @return bool
+ */
+ public function isZero() : bool
+ {
+ return $this->getSign() === 0;
+ }
+
+ /**
+ * Checks if this number is strictly negative.
+ *
+ * @return bool
+ */
+ public function isNegative() : bool
+ {
+ return $this->getSign() < 0;
+ }
+
+ /**
+ * Checks if this number is negative or zero.
+ *
+ * @return bool
+ */
+ public function isNegativeOrZero() : bool
+ {
+ return $this->getSign() <= 0;
+ }
+
+ /**
+ * Checks if this number is strictly positive.
+ *
+ * @return bool
+ */
+ public function isPositive() : bool
+ {
+ return $this->getSign() > 0;
+ }
+
+ /**
+ * Checks if this number is positive or zero.
+ *
+ * @return bool
+ */
+ public function isPositiveOrZero() : bool
+ {
+ return $this->getSign() >= 0;
+ }
+
+ /**
+ * Returns the sign of this number.
+ *
+ * @return int -1 if the number is negative, 0 if zero, 1 if positive.
+ */
+ abstract public function getSign() : int;
+
+ /**
+ * Compares this number to the given one.
+ *
+ * @param BigNumber|int|float|string $that
+ *
+ * @return int [-1,0,1] If `$this` is lower than, equal to, or greater than `$that`.
+ *
+ * @throws MathException If the number is not valid.
+ */
+ abstract public function compareTo($that) : int;
+
+ /**
+ * Converts this number to a BigInteger.
+ *
+ * @return BigInteger The converted number.
+ *
+ * @throws RoundingNecessaryException If this number cannot be converted to a BigInteger without rounding.
+ */
+ abstract public function toBigInteger() : BigInteger;
+
+ /**
+ * Converts this number to a BigDecimal.
+ *
+ * @return BigDecimal The converted number.
+ *
+ * @throws RoundingNecessaryException If this number cannot be converted to a BigDecimal without rounding.
+ */
+ abstract public function toBigDecimal() : BigDecimal;
+
+ /**
+ * Converts this number to a BigRational.
+ *
+ * @return BigRational The converted number.
+ */
+ abstract public function toBigRational() : BigRational;
+
+ /**
+ * Converts this number to a BigDecimal with the given scale, using rounding if necessary.
+ *
+ * @param int $scale The scale of the resulting `BigDecimal`.
+ * @param int $roundingMode A `RoundingMode` constant.
+ *
+ * @return BigDecimal
+ *
+ * @throws RoundingNecessaryException If this number cannot be converted to the given scale without rounding.
+ * This only applies when RoundingMode::UNNECESSARY is used.
+ */
+ abstract public function toScale(int $scale, int $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal;
+
+ /**
+ * Returns the exact value of this number as a native integer.
+ *
+ * If this number cannot be converted to a native integer without losing precision, an exception is thrown.
+ * Note that the acceptable range for an integer depends on the platform and differs for 32-bit and 64-bit.
+ *
+ * @return int The converted value.
+ *
+ * @throws MathException If this number cannot be exactly converted to a native integer.
+ */
+ abstract public function toInt() : int;
+
+ /**
+ * Returns an approximation of this number as a floating-point value.
+ *
+ * Note that this method can discard information as the precision of a floating-point value
+ * is inherently limited.
+ *
+ * If the number is greater than the largest representable floating point number, positive infinity is returned.
+ * If the number is less than the smallest representable floating point number, negative infinity is returned.
+ *
+ * @return float The converted value.
+ */
+ abstract public function toFloat() : float;
+
+ /**
+ * Returns a string representation of this number.
+ *
+ * The output of this method can be parsed by the `of()` factory method;
+ * this will yield an object equal to this one, without any information loss.
+ *
+ * @return string
+ */
+ abstract public function __toString() : string;
+
+ /**
+ * {@inheritdoc}
+ */
+ public function jsonSerialize() : string
+ {
+ return $this->__toString();
+ }
+}
diff --git a/vendor/brick/math/src/BigRational.php b/vendor/brick/math/src/BigRational.php
new file mode 100644
index 000000000..ff035c5c0
--- /dev/null
+++ b/vendor/brick/math/src/BigRational.php
@@ -0,0 +1,479 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math;
+
+use Brick\Math\Exception\DivisionByZeroException;
+use Brick\Math\Exception\MathException;
+use Brick\Math\Exception\NumberFormatException;
+use Brick\Math\Exception\RoundingNecessaryException;
+
+/**
+ * An arbitrarily large rational number.
+ *
+ * This class is immutable.
+ *
+ * @psalm-immutable
+ */
+final class BigRational extends BigNumber
+{
+ /**
+ * The numerator.
+ *
+ * @var BigInteger
+ */
+ private $numerator;
+
+ /**
+ * The denominator. Always strictly positive.
+ *
+ * @var BigInteger
+ */
+ private $denominator;
+
+ /**
+ * Protected constructor. Use a factory method to obtain an instance.
+ *
+ * @param BigInteger $numerator The numerator.
+ * @param BigInteger $denominator The denominator.
+ * @param bool $checkDenominator Whether to check the denominator for negative and zero.
+ *
+ * @throws DivisionByZeroException If the denominator is zero.
+ */
+ protected function __construct(BigInteger $numerator, BigInteger $denominator, bool $checkDenominator)
+ {
+ if ($checkDenominator) {
+ if ($denominator->isZero()) {
+ throw DivisionByZeroException::denominatorMustNotBeZero();
+ }
+
+ if ($denominator->isNegative()) {
+ $numerator = $numerator->negated();
+ $denominator = $denominator->negated();
+ }
+ }
+
+ $this->numerator = $numerator;
+ $this->denominator = $denominator;
+ }
+
+ /**
+ * Creates a BigRational of the given value.
+ *
+ * @param BigNumber|int|float|string $value
+ *
+ * @return BigRational
+ *
+ * @throws MathException If the value cannot be converted to a BigRational.
+ *
+ * @psalm-pure
+ */
+ public static function of($value) : BigNumber
+ {
+ return parent::of($value)->toBigRational();
+ }
+
+ /**
+ * Creates a BigRational out of a numerator and a denominator.
+ *
+ * If the denominator is negative, the signs of both the numerator and the denominator
+ * will be inverted to ensure that the denominator is always positive.
+ *
+ * @param BigNumber|int|float|string $numerator The numerator. Must be convertible to a BigInteger.
+ * @param BigNumber|int|float|string $denominator The denominator. Must be convertible to a BigInteger.
+ *
+ * @return BigRational
+ *
+ * @throws NumberFormatException If an argument does not represent a valid number.
+ * @throws RoundingNecessaryException If an argument represents a non-integer number.
+ * @throws DivisionByZeroException If the denominator is zero.
+ *
+ * @psalm-pure
+ */
+ public static function nd($numerator, $denominator) : BigRational
+ {
+ $numerator = BigInteger::of($numerator);
+ $denominator = BigInteger::of($denominator);
+
+ return new BigRational($numerator, $denominator, true);
+ }
+
+ /**
+ * Returns a BigRational representing zero.
+ *
+ * @return BigRational
+ *
+ * @psalm-pure
+ */
+ public static function zero() : BigRational
+ {
+ /** @psalm-suppress ImpureStaticVariable */
+ static $zero;
+
+ if ($zero === null) {
+ $zero = new BigRational(BigInteger::zero(), BigInteger::one(), false);
+ }
+
+ return $zero;
+ }
+
+ /**
+ * Returns a BigRational representing one.
+ *
+ * @return BigRational
+ *
+ * @psalm-pure
+ */
+ public static function one() : BigRational
+ {
+ /** @psalm-suppress ImpureStaticVariable */
+ static $one;
+
+ if ($one === null) {
+ $one = new BigRational(BigInteger::one(), BigInteger::one(), false);
+ }
+
+ return $one;
+ }
+
+ /**
+ * Returns a BigRational representing ten.
+ *
+ * @return BigRational
+ *
+ * @psalm-pure
+ */
+ public static function ten() : BigRational
+ {
+ /** @psalm-suppress ImpureStaticVariable */
+ static $ten;
+
+ if ($ten === null) {
+ $ten = new BigRational(BigInteger::ten(), BigInteger::one(), false);
+ }
+
+ return $ten;
+ }
+
+ /**
+ * @return BigInteger
+ */
+ public function getNumerator() : BigInteger
+ {
+ return $this->numerator;
+ }
+
+ /**
+ * @return BigInteger
+ */
+ public function getDenominator() : BigInteger
+ {
+ return $this->denominator;
+ }
+
+ /**
+ * Returns the quotient of the division of the numerator by the denominator.
+ *
+ * @return BigInteger
+ */
+ public function quotient() : BigInteger
+ {
+ return $this->numerator->quotient($this->denominator);
+ }
+
+ /**
+ * Returns the remainder of the division of the numerator by the denominator.
+ *
+ * @return BigInteger
+ */
+ public function remainder() : BigInteger
+ {
+ return $this->numerator->remainder($this->denominator);
+ }
+
+ /**
+ * Returns the quotient and remainder of the division of the numerator by the denominator.
+ *
+ * @return BigInteger[]
+ */
+ public function quotientAndRemainder() : array
+ {
+ return $this->numerator->quotientAndRemainder($this->denominator);
+ }
+
+ /**
+ * Returns the sum of this number and the given one.
+ *
+ * @param BigNumber|int|float|string $that The number to add.
+ *
+ * @return BigRational The result.
+ *
+ * @throws MathException If the number is not valid.
+ */
+ public function plus($that) : BigRational
+ {
+ $that = BigRational::of($that);
+
+ $numerator = $this->numerator->multipliedBy($that->denominator);
+ $numerator = $numerator->plus($that->numerator->multipliedBy($this->denominator));
+ $denominator = $this->denominator->multipliedBy($that->denominator);
+
+ return new BigRational($numerator, $denominator, false);
+ }
+
+ /**
+ * Returns the difference of this number and the given one.
+ *
+ * @param BigNumber|int|float|string $that The number to subtract.
+ *
+ * @return BigRational The result.
+ *
+ * @throws MathException If the number is not valid.
+ */
+ public function minus($that) : BigRational
+ {
+ $that = BigRational::of($that);
+
+ $numerator = $this->numerator->multipliedBy($that->denominator);
+ $numerator = $numerator->minus($that->numerator->multipliedBy($this->denominator));
+ $denominator = $this->denominator->multipliedBy($that->denominator);
+
+ return new BigRational($numerator, $denominator, false);
+ }
+
+ /**
+ * Returns the product of this number and the given one.
+ *
+ * @param BigNumber|int|float|string $that The multiplier.
+ *
+ * @return BigRational The result.
+ *
+ * @throws MathException If the multiplier is not a valid number.
+ */
+ public function multipliedBy($that) : BigRational
+ {
+ $that = BigRational::of($that);
+
+ $numerator = $this->numerator->multipliedBy($that->numerator);
+ $denominator = $this->denominator->multipliedBy($that->denominator);
+
+ return new BigRational($numerator, $denominator, false);
+ }
+
+ /**
+ * Returns the result of the division of this number by the given one.
+ *
+ * @param BigNumber|int|float|string $that The divisor.
+ *
+ * @return BigRational The result.
+ *
+ * @throws MathException If the divisor is not a valid number, or is zero.
+ */
+ public function dividedBy($that) : BigRational
+ {
+ $that = BigRational::of($that);
+
+ $numerator = $this->numerator->multipliedBy($that->denominator);
+ $denominator = $this->denominator->multipliedBy($that->numerator);
+
+ return new BigRational($numerator, $denominator, true);
+ }
+
+ /**
+ * Returns this number exponentiated to the given value.
+ *
+ * @param int $exponent The exponent.
+ *
+ * @return BigRational The result.
+ *
+ * @throws \InvalidArgumentException If the exponent is not in the range 0 to 1,000,000.
+ */
+ public function power(int $exponent) : BigRational
+ {
+ if ($exponent === 0) {
+ $one = BigInteger::one();
+
+ return new BigRational($one, $one, false);
+ }
+
+ if ($exponent === 1) {
+ return $this;
+ }
+
+ return new BigRational(
+ $this->numerator->power($exponent),
+ $this->denominator->power($exponent),
+ false
+ );
+ }
+
+ /**
+ * Returns the reciprocal of this BigRational.
+ *
+ * The reciprocal has the numerator and denominator swapped.
+ *
+ * @return BigRational
+ *
+ * @throws DivisionByZeroException If the numerator is zero.
+ */
+ public function reciprocal() : BigRational
+ {
+ return new BigRational($this->denominator, $this->numerator, true);
+ }
+
+ /**
+ * Returns the absolute value of this BigRational.
+ *
+ * @return BigRational
+ */
+ public function abs() : BigRational
+ {
+ return new BigRational($this->numerator->abs(), $this->denominator, false);
+ }
+
+ /**
+ * Returns the negated value of this BigRational.
+ *
+ * @return BigRational
+ */
+ public function negated() : BigRational
+ {
+ return new BigRational($this->numerator->negated(), $this->denominator, false);
+ }
+
+ /**
+ * Returns the simplified value of this BigRational.
+ *
+ * @return BigRational
+ */
+ public function simplified() : BigRational
+ {
+ $gcd = $this->numerator->gcd($this->denominator);
+
+ $numerator = $this->numerator->quotient($gcd);
+ $denominator = $this->denominator->quotient($gcd);
+
+ return new BigRational($numerator, $denominator, false);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compareTo($that) : int
+ {
+ return $this->minus($that)->getSign();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSign() : int
+ {
+ return $this->numerator->getSign();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigInteger() : BigInteger
+ {
+ $simplified = $this->simplified();
+
+ if (! $simplified->denominator->isEqualTo(1)) {
+ throw new RoundingNecessaryException('This rational number cannot be represented as an integer value without rounding.');
+ }
+
+ return $simplified->numerator;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigDecimal() : BigDecimal
+ {
+ return $this->numerator->toBigDecimal()->exactlyDividedBy($this->denominator);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBigRational() : BigRational
+ {
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toScale(int $scale, int $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal
+ {
+ return $this->numerator->toBigDecimal()->dividedBy($this->denominator, $scale, $roundingMode);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toInt() : int
+ {
+ return $this->toBigInteger()->toInt();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toFloat() : float
+ {
+ return $this->numerator->toFloat() / $this->denominator->toFloat();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function __toString() : string
+ {
+ $numerator = (string) $this->numerator;
+ $denominator = (string) $this->denominator;
+
+ if ($denominator === '1') {
+ return $numerator;
+ }
+
+ return $this->numerator . '/' . $this->denominator;
+ }
+
+ /**
+ * This method is required by interface Serializable and SHOULD NOT be accessed directly.
+ *
+ * @internal
+ *
+ * @return string
+ */
+ public function serialize() : string
+ {
+ return $this->numerator . '/' . $this->denominator;
+ }
+
+ /**
+ * This method is only here to implement interface Serializable and cannot be accessed directly.
+ *
+ * @internal
+ *
+ * @param string $value
+ *
+ * @return void
+ *
+ * @throws \LogicException
+ */
+ public function unserialize($value) : void
+ {
+ if (isset($this->numerator)) {
+ throw new \LogicException('unserialize() is an internal function, it must not be called directly.');
+ }
+
+ [$numerator, $denominator] = \explode('/', $value);
+
+ $this->numerator = BigInteger::of($numerator);
+ $this->denominator = BigInteger::of($denominator);
+ }
+}
diff --git a/vendor/brick/math/src/Exception/DivisionByZeroException.php b/vendor/brick/math/src/Exception/DivisionByZeroException.php
new file mode 100644
index 000000000..a4e443176
--- /dev/null
+++ b/vendor/brick/math/src/Exception/DivisionByZeroException.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when a division by zero occurs.
+ */
+class DivisionByZeroException extends MathException
+{
+ /**
+ * @return DivisionByZeroException
+ *
+ * @psalm-pure
+ */
+ public static function divisionByZero() : DivisionByZeroException
+ {
+ return new self('Division by zero.');
+ }
+
+ /**
+ * @return DivisionByZeroException
+ *
+ * @psalm-pure
+ */
+ public static function modulusMustNotBeZero() : DivisionByZeroException
+ {
+ return new self('The modulus must not be zero.');
+ }
+
+ /**
+ * @return DivisionByZeroException
+ *
+ * @psalm-pure
+ */
+ public static function denominatorMustNotBeZero() : DivisionByZeroException
+ {
+ return new self('The denominator of a rational number cannot be zero.');
+ }
+}
diff --git a/vendor/brick/math/src/Exception/IntegerOverflowException.php b/vendor/brick/math/src/Exception/IntegerOverflowException.php
new file mode 100644
index 000000000..e0b07d3c7
--- /dev/null
+++ b/vendor/brick/math/src/Exception/IntegerOverflowException.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+use Brick\Math\BigInteger;
+
+/**
+ * Exception thrown when an integer overflow occurs.
+ */
+class IntegerOverflowException extends MathException
+{
+ /**
+ * @param BigInteger $value
+ *
+ * @return IntegerOverflowException
+ *
+ * @psalm-pure
+ */
+ public static function toIntOverflow(BigInteger $value) : IntegerOverflowException
+ {
+ $message = '%s is out of range %d to %d and cannot be represented as an integer.';
+
+ return new self(\sprintf($message, (string) $value, PHP_INT_MIN, PHP_INT_MAX));
+ }
+}
diff --git a/vendor/brick/math/src/Exception/MathException.php b/vendor/brick/math/src/Exception/MathException.php
new file mode 100644
index 000000000..21fda90e1
--- /dev/null
+++ b/vendor/brick/math/src/Exception/MathException.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Base class for all math exceptions.
+ *
+ * This class is abstract to ensure that only fine-grained exceptions are thrown throughout the code.
+ */
+class MathException extends \RuntimeException
+{
+}
diff --git a/vendor/brick/math/src/Exception/NegativeNumberException.php b/vendor/brick/math/src/Exception/NegativeNumberException.php
new file mode 100644
index 000000000..473911341
--- /dev/null
+++ b/vendor/brick/math/src/Exception/NegativeNumberException.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when attempting to perform an unsupported operation, such as a square root, on a negative number.
+ */
+class NegativeNumberException extends MathException
+{
+}
diff --git a/vendor/brick/math/src/Exception/NumberFormatException.php b/vendor/brick/math/src/Exception/NumberFormatException.php
new file mode 100644
index 000000000..2fd0be73a
--- /dev/null
+++ b/vendor/brick/math/src/Exception/NumberFormatException.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when attempting to create a number from a string with an invalid format.
+ */
+class NumberFormatException extends MathException
+{
+ /**
+ * @param string $char The failing character.
+ *
+ * @return NumberFormatException
+ *
+ * @psalm-pure
+ */
+ public static function charNotInAlphabet(string $char) : self
+ {
+ $ord = \ord($char);
+
+ if ($ord < 32 || $ord > 126) {
+ $char = \strtoupper(\dechex($ord));
+
+ if ($ord < 10) {
+ $char = '0' . $char;
+ }
+ } else {
+ $char = '"' . $char . '"';
+ }
+
+ return new self(sprintf('Char %s is not a valid character in the given alphabet.', $char));
+ }
+}
diff --git a/vendor/brick/math/src/Exception/RoundingNecessaryException.php b/vendor/brick/math/src/Exception/RoundingNecessaryException.php
new file mode 100644
index 000000000..1c6100563
--- /dev/null
+++ b/vendor/brick/math/src/Exception/RoundingNecessaryException.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when a number cannot be represented at the requested scale without rounding.
+ */
+class RoundingNecessaryException extends MathException
+{
+ /**
+ * @return RoundingNecessaryException
+ *
+ * @psalm-pure
+ */
+ public static function roundingNecessary() : RoundingNecessaryException
+ {
+ return new self('Rounding is necessary to represent the result of the operation at this scale.');
+ }
+}
diff --git a/vendor/brick/math/src/Internal/Calculator.php b/vendor/brick/math/src/Internal/Calculator.php
new file mode 100644
index 000000000..44795acbb
--- /dev/null
+++ b/vendor/brick/math/src/Internal/Calculator.php
@@ -0,0 +1,756 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Internal;
+
+use Brick\Math\Exception\RoundingNecessaryException;
+use Brick\Math\RoundingMode;
+
+/**
+ * Performs basic operations on arbitrary size integers.
+ *
+ * Unless otherwise specified, all parameters must be validated as non-empty strings of digits,
+ * without leading zero, and with an optional leading minus sign if the number is not zero.
+ *
+ * Any other parameter format will lead to undefined behaviour.
+ * All methods must return strings respecting this format, unless specified otherwise.
+ *
+ * @internal
+ *
+ * @psalm-immutable
+ */
+abstract class Calculator
+{
+ /**
+ * The maximum exponent value allowed for the pow() method.
+ */
+ public const MAX_POWER = 1000000;
+
+ /**
+ * The alphabet for converting from and to base 2 to 36, lowercase.
+ */
+ public const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+
+ /**
+ * The Calculator instance in use.
+ *
+ * @var Calculator|null
+ */
+ private static $instance;
+
+ /**
+ * Sets the Calculator instance to use.
+ *
+ * An instance is typically set only in unit tests: the autodetect is usually the best option.
+ *
+ * @param Calculator|null $calculator The calculator instance, or NULL to revert to autodetect.
+ *
+ * @return void
+ */
+ final public static function set(?Calculator $calculator) : void
+ {
+ self::$instance = $calculator;
+ }
+
+ /**
+ * Returns the Calculator instance to use.
+ *
+ * If none has been explicitly set, the fastest available implementation will be returned.
+ *
+ * @return Calculator
+ *
+ * @psalm-pure
+ * @psalm-suppress ImpureStaticProperty
+ */
+ final public static function get() : Calculator
+ {
+ if (self::$instance === null) {
+ /** @psalm-suppress ImpureMethodCall */
+ self::$instance = self::detect();
+ }
+
+ return self::$instance;
+ }
+
+ /**
+ * Returns the fastest available Calculator implementation.
+ *
+ * @codeCoverageIgnore
+ *
+ * @return Calculator
+ */
+ private static function detect() : Calculator
+ {
+ if (\extension_loaded('gmp')) {
+ return new Calculator\GmpCalculator();
+ }
+
+ if (\extension_loaded('bcmath')) {
+ return new Calculator\BcMathCalculator();
+ }
+
+ return new Calculator\NativeCalculator();
+ }
+
+ /**
+ * Extracts the sign & digits of the operands.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return array{0: bool, 1: bool, 2: string, 3: string} Whether $a and $b are negative, followed by their digits.
+ */
+ final protected function init(string $a, string $b) : array
+ {
+ return [
+ $aNeg = ($a[0] === '-'),
+ $bNeg = ($b[0] === '-'),
+
+ $aNeg ? \substr($a, 1) : $a,
+ $bNeg ? \substr($b, 1) : $b,
+ ];
+ }
+
+ /**
+ * Returns the absolute value of a number.
+ *
+ * @param string $n The number.
+ *
+ * @return string The absolute value.
+ */
+ final public function abs(string $n) : string
+ {
+ return ($n[0] === '-') ? \substr($n, 1) : $n;
+ }
+
+ /**
+ * Negates a number.
+ *
+ * @param string $n The number.
+ *
+ * @return string The negated value.
+ */
+ final public function neg(string $n) : string
+ {
+ if ($n === '0') {
+ return '0';
+ }
+
+ if ($n[0] === '-') {
+ return \substr($n, 1);
+ }
+
+ return '-' . $n;
+ }
+
+ /**
+ * Compares two numbers.
+ *
+ * @param string $a The first number.
+ * @param string $b The second number.
+ *
+ * @return int [-1, 0, 1] If the first number is less than, equal to, or greater than the second number.
+ */
+ final public function cmp(string $a, string $b) : int
+ {
+ [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);
+
+ if ($aNeg && ! $bNeg) {
+ return -1;
+ }
+
+ if ($bNeg && ! $aNeg) {
+ return 1;
+ }
+
+ $aLen = \strlen($aDig);
+ $bLen = \strlen($bDig);
+
+ if ($aLen < $bLen) {
+ $result = -1;
+ } elseif ($aLen > $bLen) {
+ $result = 1;
+ } else {
+ $result = $aDig <=> $bDig;
+ }
+
+ return $aNeg ? -$result : $result;
+ }
+
+ /**
+ * Adds two numbers.
+ *
+ * @param string $a The augend.
+ * @param string $b The addend.
+ *
+ * @return string The sum.
+ */
+ abstract public function add(string $a, string $b) : string;
+
+ /**
+ * Subtracts two numbers.
+ *
+ * @param string $a The minuend.
+ * @param string $b The subtrahend.
+ *
+ * @return string The difference.
+ */
+ abstract public function sub(string $a, string $b) : string;
+
+ /**
+ * Multiplies two numbers.
+ *
+ * @param string $a The multiplicand.
+ * @param string $b The multiplier.
+ *
+ * @return string The product.
+ */
+ abstract public function mul(string $a, string $b) : string;
+
+ /**
+ * Returns the quotient of the division of two numbers.
+ *
+ * @param string $a The dividend.
+ * @param string $b The divisor, must not be zero.
+ *
+ * @return string The quotient.
+ */
+ abstract public function divQ(string $a, string $b) : string;
+
+ /**
+ * Returns the remainder of the division of two numbers.
+ *
+ * @param string $a The dividend.
+ * @param string $b The divisor, must not be zero.
+ *
+ * @return string The remainder.
+ */
+ abstract public function divR(string $a, string $b) : string;
+
+ /**
+ * Returns the quotient and remainder of the division of two numbers.
+ *
+ * @param string $a The dividend.
+ * @param string $b The divisor, must not be zero.
+ *
+ * @return string[] An array containing the quotient and remainder.
+ */
+ abstract public function divQR(string $a, string $b) : array;
+
+ /**
+ * Exponentiates a number.
+ *
+ * @param string $a The base number.
+ * @param int $e The exponent, validated as an integer between 0 and MAX_POWER.
+ *
+ * @return string The power.
+ */
+ abstract public function pow(string $a, int $e) : string;
+
+ /**
+ * @param string $a
+ * @param string $b The modulus; must not be zero.
+ *
+ * @return string
+ */
+ public function mod(string $a, string $b) : string
+ {
+ return $this->divR($this->add($this->divR($a, $b), $b), $b);
+ }
+
+ /**
+ * Returns the modular multiplicative inverse of $x modulo $m.
+ *
+ * If $x has no multiplicative inverse mod m, this method must return null.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library has built-in support.
+ *
+ * @param string $x
+ * @param string $m The modulus; must not be negative or zero.
+ *
+ * @return string|null
+ */
+ public function modInverse(string $x, string $m) : ?string
+ {
+ if ($m === '1') {
+ return '0';
+ }
+
+ $modVal = $x;
+
+ if ($x[0] === '-' || ($this->cmp($this->abs($x), $m) >= 0)) {
+ $modVal = $this->mod($x, $m);
+ }
+
+ $x = '0';
+ $y = '0';
+ $g = $this->gcdExtended($modVal, $m, $x, $y);
+
+ if ($g !== '1') {
+ return null;
+ }
+
+ return $this->mod($this->add($this->mod($x, $m), $m), $m);
+ }
+
+ /**
+ * Raises a number into power with modulo.
+ *
+ * @param string $base The base number; must be positive or zero.
+ * @param string $exp The exponent; must be positive or zero.
+ * @param string $mod The modulus; must be strictly positive.
+ *
+ * @return string The power.
+ */
+ abstract public function modPow(string $base, string $exp, string $mod) : string;
+
+ /**
+ * Returns the greatest common divisor of the two numbers.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library
+ * has built-in support for GCD calculations.
+ *
+ * @param string $a The first number.
+ * @param string $b The second number.
+ *
+ * @return string The GCD, always positive, or zero if both arguments are zero.
+ */
+ public function gcd(string $a, string $b) : string
+ {
+ if ($a === '0') {
+ return $this->abs($b);
+ }
+
+ if ($b === '0') {
+ return $this->abs($a);
+ }
+
+ return $this->gcd($b, $this->divR($a, $b));
+ }
+
+ private function gcdExtended(string $a, string $b, string &$x, string &$y) : string
+ {
+ if ($a === '0') {
+ $x = '0';
+ $y = '1';
+
+ return $b;
+ }
+
+ $x1 = '0';
+ $y1 = '0';
+
+ $gcd = $this->gcdExtended($this->mod($b, $a), $a, $x1, $y1);
+
+ $x = $this->sub($y1, $this->mul($this->divQ($b, $a), $x1));
+ $y = $x1;
+
+ return $gcd;
+ }
+
+ /**
+ * Returns the square root of the given number, rounded down.
+ *
+ * The result is the largest x such that x² ≤ n.
+ * The input MUST NOT be negative.
+ *
+ * @param string $n The number.
+ *
+ * @return string The square root.
+ */
+ abstract public function sqrt(string $n) : string;
+
+ /**
+ * Converts a number from an arbitrary base.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library
+ * has built-in support for base conversion.
+ *
+ * @param string $number The number, positive or zero, non-empty, case-insensitively validated for the given base.
+ * @param int $base The base of the number, validated from 2 to 36.
+ *
+ * @return string The converted number, following the Calculator conventions.
+ */
+ public function fromBase(string $number, int $base) : string
+ {
+ return $this->fromArbitraryBase(\strtolower($number), self::ALPHABET, $base);
+ }
+
+ /**
+ * Converts a number to an arbitrary base.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library
+ * has built-in support for base conversion.
+ *
+ * @param string $number The number to convert, following the Calculator conventions.
+ * @param int $base The base to convert to, validated from 2 to 36.
+ *
+ * @return string The converted number, lowercase.
+ */
+ public function toBase(string $number, int $base) : string
+ {
+ $negative = ($number[0] === '-');
+
+ if ($negative) {
+ $number = \substr($number, 1);
+ }
+
+ $number = $this->toArbitraryBase($number, self::ALPHABET, $base);
+
+ if ($negative) {
+ return '-' . $number;
+ }
+
+ return $number;
+ }
+
+ /**
+ * Converts a non-negative number in an arbitrary base using a custom alphabet, to base 10.
+ *
+ * @param string $number The number to convert, validated as a non-empty string,
+ * containing only chars in the given alphabet/base.
+ * @param string $alphabet The alphabet that contains every digit, validated as 2 chars minimum.
+ * @param int $base The base of the number, validated from 2 to alphabet length.
+ *
+ * @return string The number in base 10, following the Calculator conventions.
+ */
+ final public function fromArbitraryBase(string $number, string $alphabet, int $base) : string
+ {
+ // remove leading "zeros"
+ $number = \ltrim($number, $alphabet[0]);
+
+ if ($number === '') {
+ return '0';
+ }
+
+ // optimize for "one"
+ if ($number === $alphabet[1]) {
+ return '1';
+ }
+
+ $result = '0';
+ $power = '1';
+
+ $base = (string) $base;
+
+ for ($i = \strlen($number) - 1; $i >= 0; $i--) {
+ $index = \strpos($alphabet, $number[$i]);
+
+ if ($index !== 0) {
+ $result = $this->add($result, ($index === 1)
+ ? $power
+ : $this->mul($power, (string) $index)
+ );
+ }
+
+ if ($i !== 0) {
+ $power = $this->mul($power, $base);
+ }
+ }
+
+ return $result;
+ }
+
+ /**
+ * Converts a non-negative number to an arbitrary base using a custom alphabet.
+ *
+ * @param string $number The number to convert, positive or zero, following the Calculator conventions.
+ * @param string $alphabet The alphabet that contains every digit, validated as 2 chars minimum.
+ * @param int $base The base to convert to, validated from 2 to alphabet length.
+ *
+ * @return string The converted number in the given alphabet.
+ */
+ final public function toArbitraryBase(string $number, string $alphabet, int $base) : string
+ {
+ if ($number === '0') {
+ return $alphabet[0];
+ }
+
+ $base = (string) $base;
+ $result = '';
+
+ while ($number !== '0') {
+ [$number, $remainder] = $this->divQR($number, $base);
+ $remainder = (int) $remainder;
+
+ $result .= $alphabet[$remainder];
+ }
+
+ return \strrev($result);
+ }
+
+ /**
+ * Performs a rounded division.
+ *
+ * Rounding is performed when the remainder of the division is not zero.
+ *
+ * @param string $a The dividend.
+ * @param string $b The divisor, must not be zero.
+ * @param int $roundingMode The rounding mode.
+ *
+ * @return string
+ *
+ * @throws \InvalidArgumentException If the rounding mode is invalid.
+ * @throws RoundingNecessaryException If RoundingMode::UNNECESSARY is provided but rounding is necessary.
+ */
+ final public function divRound(string $a, string $b, int $roundingMode) : string
+ {
+ [$quotient, $remainder] = $this->divQR($a, $b);
+
+ $hasDiscardedFraction = ($remainder !== '0');
+ $isPositiveOrZero = ($a[0] === '-') === ($b[0] === '-');
+
+ $discardedFractionSign = function() use ($remainder, $b) : int {
+ $r = $this->abs($this->mul($remainder, '2'));
+ $b = $this->abs($b);
+
+ return $this->cmp($r, $b);
+ };
+
+ $increment = false;
+
+ switch ($roundingMode) {
+ case RoundingMode::UNNECESSARY:
+ if ($hasDiscardedFraction) {
+ throw RoundingNecessaryException::roundingNecessary();
+ }
+ break;
+
+ case RoundingMode::UP:
+ $increment = $hasDiscardedFraction;
+ break;
+
+ case RoundingMode::DOWN:
+ break;
+
+ case RoundingMode::CEILING:
+ $increment = $hasDiscardedFraction && $isPositiveOrZero;
+ break;
+
+ case RoundingMode::FLOOR:
+ $increment = $hasDiscardedFraction && ! $isPositiveOrZero;
+ break;
+
+ case RoundingMode::HALF_UP:
+ $increment = $discardedFractionSign() >= 0;
+ break;
+
+ case RoundingMode::HALF_DOWN:
+ $increment = $discardedFractionSign() > 0;
+ break;
+
+ case RoundingMode::HALF_CEILING:
+ $increment = $isPositiveOrZero ? $discardedFractionSign() >= 0 : $discardedFractionSign() > 0;
+ break;
+
+ case RoundingMode::HALF_FLOOR:
+ $increment = $isPositiveOrZero ? $discardedFractionSign() > 0 : $discardedFractionSign() >= 0;
+ break;
+
+ case RoundingMode::HALF_EVEN:
+ $lastDigit = (int) $quotient[-1];
+ $lastDigitIsEven = ($lastDigit % 2 === 0);
+ $increment = $lastDigitIsEven ? $discardedFractionSign() > 0 : $discardedFractionSign() >= 0;
+ break;
+
+ default:
+ throw new \InvalidArgumentException('Invalid rounding mode.');
+ }
+
+ if ($increment) {
+ return $this->add($quotient, $isPositiveOrZero ? '1' : '-1');
+ }
+
+ return $quotient;
+ }
+
+ /**
+ * Calculates bitwise AND of two numbers.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library
+ * has built-in support for bitwise operations.
+ *
+ * @param string $a
+ * @param string $b
+ *
+ * @return string
+ */
+ public function and(string $a, string $b) : string
+ {
+ return $this->bitwise('and', $a, $b);
+ }
+
+ /**
+ * Calculates bitwise OR of two numbers.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library
+ * has built-in support for bitwise operations.
+ *
+ * @param string $a
+ * @param string $b
+ *
+ * @return string
+ */
+ public function or(string $a, string $b) : string
+ {
+ return $this->bitwise('or', $a, $b);
+ }
+
+ /**
+ * Calculates bitwise XOR of two numbers.
+ *
+ * This method can be overridden by the concrete implementation if the underlying library
+ * has built-in support for bitwise operations.
+ *
+ * @param string $a
+ * @param string $b
+ *
+ * @return string
+ */
+ public function xor(string $a, string $b) : string
+ {
+ return $this->bitwise('xor', $a, $b);
+ }
+
+ /**
+ * Performs a bitwise operation on a decimal number.
+ *
+ * @param string $operator The operator to use, must be "and", "or" or "xor".
+ * @param string $a The left operand.
+ * @param string $b The right operand.
+ *
+ * @return string
+ */
+ private function bitwise(string $operator, string $a, string $b) : string
+ {
+ [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);
+
+ $aBin = $this->toBinary($aDig);
+ $bBin = $this->toBinary($bDig);
+
+ $aLen = \strlen($aBin);
+ $bLen = \strlen($bBin);
+
+ if ($aLen > $bLen) {
+ $bBin = \str_repeat("\x00", $aLen - $bLen) . $bBin;
+ } elseif ($bLen > $aLen) {
+ $aBin = \str_repeat("\x00", $bLen - $aLen) . $aBin;
+ }
+
+ if ($aNeg) {
+ $aBin = $this->twosComplement($aBin);
+ }
+ if ($bNeg) {
+ $bBin = $this->twosComplement($bBin);
+ }
+
+ switch ($operator) {
+ case 'and':
+ $value = $aBin & $bBin;
+ $negative = ($aNeg and $bNeg);
+ break;
+
+ case 'or':
+ $value = $aBin | $bBin;
+ $negative = ($aNeg or $bNeg);
+ break;
+
+ case 'xor':
+ $value = $aBin ^ $bBin;
+ $negative = ($aNeg xor $bNeg);
+ break;
+
+ // @codeCoverageIgnoreStart
+ default:
+ throw new \InvalidArgumentException('Invalid bitwise operator.');
+ // @codeCoverageIgnoreEnd
+ }
+
+ if ($negative) {
+ $value = $this->twosComplement($value);
+ }
+
+ $result = $this->toDecimal($value);
+
+ return $negative ? $this->neg($result) : $result;
+ }
+
+ /**
+ * @param string $number A positive, binary number.
+ *
+ * @return string
+ */
+ private function twosComplement(string $number) : string
+ {
+ $xor = \str_repeat("\xff", \strlen($number));
+
+ $number = $number ^ $xor;
+
+ for ($i = \strlen($number) - 1; $i >= 0; $i--) {
+ $byte = \ord($number[$i]);
+
+ if (++$byte !== 256) {
+ $number[$i] = \chr($byte);
+ break;
+ }
+
+ $number[$i] = "\x00";
+
+ if ($i === 0) {
+ $number = "\x01" . $number;
+ }
+ }
+
+ return $number;
+ }
+
+ /**
+ * Converts a decimal number to a binary string.
+ *
+ * @param string $number The number to convert, positive or zero, only digits.
+ *
+ * @return string
+ */
+ private function toBinary(string $number) : string
+ {
+ $result = '';
+
+ while ($number !== '0') {
+ [$number, $remainder] = $this->divQR($number, '256');
+ $result .= \chr((int) $remainder);
+ }
+
+ return \strrev($result);
+ }
+
+ /**
+ * Returns the positive decimal representation of a binary number.
+ *
+ * @param string $bytes The bytes representing the number.
+ *
+ * @return string
+ */
+ private function toDecimal(string $bytes) : string
+ {
+ $result = '0';
+ $power = '1';
+
+ for ($i = \strlen($bytes) - 1; $i >= 0; $i--) {
+ $index = \ord($bytes[$i]);
+
+ if ($index !== 0) {
+ $result = $this->add($result, ($index === 1)
+ ? $power
+ : $this->mul($power, (string) $index)
+ );
+ }
+
+ if ($i !== 0) {
+ $power = $this->mul($power, '256');
+ }
+ }
+
+ return $result;
+ }
+}
diff --git a/vendor/brick/math/src/Internal/Calculator/BcMathCalculator.php b/vendor/brick/math/src/Internal/Calculator/BcMathCalculator.php
new file mode 100644
index 000000000..c087245bd
--- /dev/null
+++ b/vendor/brick/math/src/Internal/Calculator/BcMathCalculator.php
@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Internal\Calculator;
+
+use Brick\Math\Internal\Calculator;
+
+/**
+ * Calculator implementation built around the bcmath library.
+ *
+ * @internal
+ *
+ * @psalm-immutable
+ */
+class BcMathCalculator extends Calculator
+{
+ /**
+ * {@inheritdoc}
+ */
+ public function add(string $a, string $b) : string
+ {
+ return \bcadd($a, $b, 0);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function sub(string $a, string $b) : string
+ {
+ return \bcsub($a, $b, 0);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function mul(string $a, string $b) : string
+ {
+ return \bcmul($a, $b, 0);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divQ(string $a, string $b) : string
+ {
+ return \bcdiv($a, $b, 0);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divR(string $a, string $b) : string
+ {
+ return \bcmod($a, $b);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divQR(string $a, string $b) : array
+ {
+ $q = \bcdiv($a, $b, 0);
+ $r = \bcmod($a, $b);
+
+ return [$q, $r];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function pow(string $a, int $e) : string
+ {
+ return \bcpow($a, (string) $e, 0);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function modPow(string $base, string $exp, string $mod) : string
+ {
+ return \bcpowmod($base, $exp, $mod, 0);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function sqrt(string $n) : string
+ {
+ return \bcsqrt($n, 0);
+ }
+}
diff --git a/vendor/brick/math/src/Internal/Calculator/GmpCalculator.php b/vendor/brick/math/src/Internal/Calculator/GmpCalculator.php
new file mode 100644
index 000000000..52d18800a
--- /dev/null
+++ b/vendor/brick/math/src/Internal/Calculator/GmpCalculator.php
@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Internal\Calculator;
+
+use Brick\Math\Internal\Calculator;
+
+/**
+ * Calculator implementation built around the GMP library.
+ *
+ * @internal
+ *
+ * @psalm-immutable
+ */
+class GmpCalculator extends Calculator
+{
+ /**
+ * {@inheritdoc}
+ */
+ public function add(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_add($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function sub(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_sub($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function mul(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_mul($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divQ(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_div_q($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divR(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_div_r($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divQR(string $a, string $b) : array
+ {
+ [$q, $r] = \gmp_div_qr($a, $b);
+
+ return [
+ \gmp_strval($q),
+ \gmp_strval($r)
+ ];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function pow(string $a, int $e) : string
+ {
+ return \gmp_strval(\gmp_pow($a, $e));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function modInverse(string $x, string $m) : ?string
+ {
+ $result = \gmp_invert($x, $m);
+
+ if ($result === false) {
+ return null;
+ }
+
+ return \gmp_strval($result);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function modPow(string $base, string $exp, string $mod) : string
+ {
+ return \gmp_strval(\gmp_powm($base, $exp, $mod));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gcd(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_gcd($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fromBase(string $number, int $base) : string
+ {
+ return \gmp_strval(\gmp_init($number, $base));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function toBase(string $number, int $base) : string
+ {
+ return \gmp_strval($number, $base);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function and(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_and($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function or(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_or($a, $b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function xor(string $a, string $b) : string
+ {
+ return \gmp_strval(\gmp_xor($a, $b));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function sqrt(string $n) : string
+ {
+ return \gmp_strval(\gmp_sqrt($n));
+ }
+}
diff --git a/vendor/brick/math/src/Internal/Calculator/NativeCalculator.php b/vendor/brick/math/src/Internal/Calculator/NativeCalculator.php
new file mode 100644
index 000000000..d248e6849
--- /dev/null
+++ b/vendor/brick/math/src/Internal/Calculator/NativeCalculator.php
@@ -0,0 +1,616 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Internal\Calculator;
+
+use Brick\Math\Internal\Calculator;
+
+/**
+ * Calculator implementation using only native PHP code.
+ *
+ * @internal
+ *
+ * @psalm-immutable
+ */
+class NativeCalculator extends Calculator
+{
+ /**
+ * The max number of digits the platform can natively add, subtract, multiply or divide without overflow.
+ * For multiplication, this represents the max sum of the lengths of both operands.
+ *
+ * For addition, it is assumed that an extra digit can hold a carry (1) without overflowing.
+ * Example: 32-bit: max number 1,999,999,999 (9 digits + carry)
+ * 64-bit: max number 1,999,999,999,999,999,999 (18 digits + carry)
+ *
+ * @var int
+ */
+ private $maxDigits;
+
+ /**
+ * Class constructor.
+ *
+ * @codeCoverageIgnore
+ */
+ public function __construct()
+ {
+ switch (PHP_INT_SIZE) {
+ case 4:
+ $this->maxDigits = 9;
+ break;
+
+ case 8:
+ $this->maxDigits = 18;
+ break;
+
+ default:
+ throw new \RuntimeException('The platform is not 32-bit or 64-bit as expected.');
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function add(string $a, string $b) : string
+ {
+ $result = $a + $b;
+
+ if (is_int($result)) {
+ return (string) $result;
+ }
+
+ if ($a === '0') {
+ return $b;
+ }
+
+ if ($b === '0') {
+ return $a;
+ }
+
+ [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);
+
+ if ($aNeg === $bNeg) {
+ $result = $this->doAdd($aDig, $bDig);
+ } else {
+ $result = $this->doSub($aDig, $bDig);
+ }
+
+ if ($aNeg) {
+ $result = $this->neg($result);
+ }
+
+ return $result;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function sub(string $a, string $b) : string
+ {
+ return $this->add($a, $this->neg($b));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function mul(string $a, string $b) : string
+ {
+ $result = $a * $b;
+
+ if (is_int($result)) {
+ return (string) $result;
+ }
+
+ if ($a === '0' || $b === '0') {
+ return '0';
+ }
+
+ if ($a === '1') {
+ return $b;
+ }
+
+ if ($b === '1') {
+ return $a;
+ }
+
+ if ($a === '-1') {
+ return $this->neg($b);
+ }
+
+ if ($b === '-1') {
+ return $this->neg($a);
+ }
+
+ [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);
+
+ $result = $this->doMul($aDig, $bDig);
+
+ if ($aNeg !== $bNeg) {
+ $result = $this->neg($result);
+ }
+
+ return $result;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divQ(string $a, string $b) : string
+ {
+ return $this->divQR($a, $b)[0];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divR(string $a, string $b): string
+ {
+ return $this->divQR($a, $b)[1];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function divQR(string $a, string $b) : array
+ {
+ if ($a === '0') {
+ return ['0', '0'];
+ }
+
+ if ($a === $b) {
+ return ['1', '0'];
+ }
+
+ if ($b === '1') {
+ return [$a, '0'];
+ }
+
+ if ($b === '-1') {
+ return [$this->neg($a), '0'];
+ }
+
+ $na = $a * 1; // cast to number
+
+ if (is_int($na)) {
+ $nb = $b * 1;
+
+ if (is_int($nb)) {
+ // the only division that may overflow is PHP_INT_MIN / -1,
+ // which cannot happen here as we've already handled a divisor of -1 above.
+ $r = $na % $nb;
+ $q = ($na - $r) / $nb;
+
+ assert(is_int($q));
+
+ return [
+ (string) $q,
+ (string) $r
+ ];
+ }
+ }
+
+ [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);
+
+ [$q, $r] = $this->doDiv($aDig, $bDig);
+
+ if ($aNeg !== $bNeg) {
+ $q = $this->neg($q);
+ }
+
+ if ($aNeg) {
+ $r = $this->neg($r);
+ }
+
+ return [$q, $r];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function pow(string $a, int $e) : string
+ {
+ if ($e === 0) {
+ return '1';
+ }
+
+ if ($e === 1) {
+ return $a;
+ }
+
+ $odd = $e % 2;
+ $e -= $odd;
+
+ $aa = $this->mul($a, $a);
+ $result = $this->pow($aa, $e / 2);
+
+ if ($odd === 1) {
+ $result = $this->mul($result, $a);
+ }
+
+ return $result;
+ }
+
+ /**
+ * Algorithm from: https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/
+ *
+ * {@inheritdoc}
+ */
+ public function modPow(string $base, string $exp, string $mod) : string
+ {
+ // special case: the algorithm below fails with 0 power 0 mod 1 (returns 1 instead of 0)
+ if ($base === '0' && $exp === '0' && $mod === '1') {
+ return '0';
+ }
+
+ // special case: the algorithm below fails with power 0 mod 1 (returns 1 instead of 0)
+ if ($exp === '0' && $mod === '1') {
+ return '0';
+ }
+
+ $x = $base;
+
+ $res = '1';
+
+ // numbers are positive, so we can use remainder instead of modulo
+ $x = $this->divR($x, $mod);
+
+ while ($exp !== '0') {
+ if (in_array($exp[-1], ['1', '3', '5', '7', '9'])) { // odd
+ $res = $this->divR($this->mul($res, $x), $mod);
+ }
+
+ $exp = $this->divQ($exp, '2');
+ $x = $this->divR($this->mul($x, $x), $mod);
+ }
+
+ return $res;
+ }
+
+ /**
+ * Adapted from https://cp-algorithms.com/num_methods/roots_newton.html
+ *
+ * {@inheritDoc}
+ */
+ public function sqrt(string $n) : string
+ {
+ if ($n === '0') {
+ return '0';
+ }
+
+ // initial approximation
+ $x = \str_repeat('9', \intdiv(\strlen($n), 2) ?: 1);
+
+ $decreased = false;
+
+ for (;;) {
+ $nx = $this->divQ($this->add($x, $this->divQ($n, $x)), '2');
+
+ if ($x === $nx || $this->cmp($nx, $x) > 0 && $decreased) {
+ break;
+ }
+
+ $decreased = $this->cmp($nx, $x) < 0;
+ $x = $nx;
+ }
+
+ return $x;
+ }
+
+ /**
+ * Performs the addition of two non-signed large integers.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return string
+ */
+ private function doAdd(string $a, string $b) : string
+ {
+ [$a, $b, $length] = $this->pad($a, $b);
+
+ $carry = 0;
+ $result = '';
+
+ for ($i = $length - $this->maxDigits;; $i -= $this->maxDigits) {
+ $blockLength = $this->maxDigits;
+
+ if ($i < 0) {
+ $blockLength += $i;
+ $i = 0;
+ }
+
+ $blockA = \substr($a, $i, $blockLength);
+ $blockB = \substr($b, $i, $blockLength);
+
+ $sum = (string) ($blockA + $blockB + $carry);
+ $sumLength = \strlen($sum);
+
+ if ($sumLength > $blockLength) {
+ $sum = \substr($sum, 1);
+ $carry = 1;
+ } else {
+ if ($sumLength < $blockLength) {
+ $sum = \str_repeat('0', $blockLength - $sumLength) . $sum;
+ }
+ $carry = 0;
+ }
+
+ $result = $sum . $result;
+
+ if ($i === 0) {
+ break;
+ }
+ }
+
+ if ($carry === 1) {
+ $result = '1' . $result;
+ }
+
+ return $result;
+ }
+
+ /**
+ * Performs the subtraction of two non-signed large integers.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return string
+ */
+ private function doSub(string $a, string $b) : string
+ {
+ if ($a === $b) {
+ return '0';
+ }
+
+ // Ensure that we always subtract to a positive result: biggest minus smallest.
+ $cmp = $this->doCmp($a, $b);
+
+ $invert = ($cmp === -1);
+
+ if ($invert) {
+ $c = $a;
+ $a = $b;
+ $b = $c;
+ }
+
+ [$a, $b, $length] = $this->pad($a, $b);
+
+ $carry = 0;
+ $result = '';
+
+ $complement = 10 ** $this->maxDigits;
+
+ for ($i = $length - $this->maxDigits;; $i -= $this->maxDigits) {
+ $blockLength = $this->maxDigits;
+
+ if ($i < 0) {
+ $blockLength += $i;
+ $i = 0;
+ }
+
+ $blockA = \substr($a, $i, $blockLength);
+ $blockB = \substr($b, $i, $blockLength);
+
+ $sum = $blockA - $blockB - $carry;
+
+ if ($sum < 0) {
+ $sum += $complement;
+ $carry = 1;
+ } else {
+ $carry = 0;
+ }
+
+ $sum = (string) $sum;
+ $sumLength = \strlen($sum);
+
+ if ($sumLength < $blockLength) {
+ $sum = \str_repeat('0', $blockLength - $sumLength) . $sum;
+ }
+
+ $result = $sum . $result;
+
+ if ($i === 0) {
+ break;
+ }
+ }
+
+ // Carry cannot be 1 when the loop ends, as a > b
+ assert($carry === 0);
+
+ $result = \ltrim($result, '0');
+
+ if ($invert) {
+ $result = $this->neg($result);
+ }
+
+ return $result;
+ }
+
+ /**
+ * Performs the multiplication of two non-signed large integers.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return string
+ */
+ private function doMul(string $a, string $b) : string
+ {
+ $x = \strlen($a);
+ $y = \strlen($b);
+
+ $maxDigits = \intdiv($this->maxDigits, 2);
+ $complement = 10 ** $maxDigits;
+
+ $result = '0';
+
+ for ($i = $x - $maxDigits;; $i -= $maxDigits) {
+ $blockALength = $maxDigits;
+
+ if ($i < 0) {
+ $blockALength += $i;
+ $i = 0;
+ }
+
+ $blockA = (int) \substr($a, $i, $blockALength);
+
+ $line = '';
+ $carry = 0;
+
+ for ($j = $y - $maxDigits;; $j -= $maxDigits) {
+ $blockBLength = $maxDigits;
+
+ if ($j < 0) {
+ $blockBLength += $j;
+ $j = 0;
+ }
+
+ $blockB = (int) \substr($b, $j, $blockBLength);
+
+ $mul = $blockA * $blockB + $carry;
+ $value = $mul % $complement;
+ $carry = ($mul - $value) / $complement;
+
+ $value = (string) $value;
+ $value = \str_pad($value, $maxDigits, '0', STR_PAD_LEFT);
+
+ $line = $value . $line;
+
+ if ($j === 0) {
+ break;
+ }
+ }
+
+ if ($carry !== 0) {
+ $line = $carry . $line;
+ }
+
+ $line = \ltrim($line, '0');
+
+ if ($line !== '') {
+ $line .= \str_repeat('0', $x - $blockALength - $i);
+ $result = $this->add($result, $line);
+ }
+
+ if ($i === 0) {
+ break;
+ }
+ }
+
+ return $result;
+ }
+
+ /**
+ * Performs the division of two non-signed large integers.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return string[] The quotient and remainder.
+ */
+ private function doDiv(string $a, string $b) : array
+ {
+ $cmp = $this->doCmp($a, $b);
+
+ if ($cmp === -1) {
+ return ['0', $a];
+ }
+
+ $x = \strlen($a);
+ $y = \strlen($b);
+
+ // we now know that a >= b && x >= y
+
+ $q = '0'; // quotient
+ $r = $a; // remainder
+ $z = $y; // focus length, always $y or $y+1
+
+ for (;;) {
+ $focus = \substr($a, 0, $z);
+
+ $cmp = $this->doCmp($focus, $b);
+
+ if ($cmp === -1) {
+ if ($z === $x) { // remainder < dividend
+ break;
+ }
+
+ $z++;
+ }
+
+ $zeros = \str_repeat('0', $x - $z);
+
+ $q = $this->add($q, '1' . $zeros);
+ $a = $this->sub($a, $b . $zeros);
+
+ $r = $a;
+
+ if ($r === '0') { // remainder == 0
+ break;
+ }
+
+ $x = \strlen($a);
+
+ if ($x < $y) { // remainder < dividend
+ break;
+ }
+
+ $z = $y;
+ }
+
+ return [$q, $r];
+ }
+
+ /**
+ * Compares two non-signed large numbers.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return int [-1, 0, 1]
+ */
+ private function doCmp(string $a, string $b) : int
+ {
+ $x = \strlen($a);
+ $y = \strlen($b);
+
+ $cmp = $x <=> $y;
+
+ if ($cmp !== 0) {
+ return $cmp;
+ }
+
+ return \strcmp($a, $b) <=> 0; // enforce [-1, 0, 1]
+ }
+
+ /**
+ * Pads the left of one of the given numbers with zeros if necessary to make both numbers the same length.
+ *
+ * The numbers must only consist of digits, without leading minus sign.
+ *
+ * @param string $a The first operand.
+ * @param string $b The second operand.
+ *
+ * @return array{0: string, 1: string, 2: int}
+ */
+ private function pad(string $a, string $b) : array
+ {
+ $x = \strlen($a);
+ $y = \strlen($b);
+
+ if ($x > $y) {
+ $b = \str_repeat('0', $x - $y) . $b;
+
+ return [$a, $b, $x];
+ }
+
+ if ($x < $y) {
+ $a = \str_repeat('0', $y - $x) . $a;
+
+ return [$a, $b, $y];
+ }
+
+ return [$a, $b, $x];
+ }
+}
diff --git a/vendor/brick/math/src/RoundingMode.php b/vendor/brick/math/src/RoundingMode.php
new file mode 100644
index 000000000..06936d8db
--- /dev/null
+++ b/vendor/brick/math/src/RoundingMode.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math;
+
+/**
+ * Specifies a rounding behavior for numerical operations capable of discarding precision.
+ *
+ * Each rounding mode indicates how the least significant returned digit of a rounded result
+ * is to be calculated. If fewer digits are returned than the digits needed to represent the
+ * exact numerical result, the discarded digits will be referred to as the discarded fraction
+ * regardless the digits' contribution to the value of the number. In other words, considered
+ * as a numerical value, the discarded fraction could have an absolute value greater than one.
+ */
+final class RoundingMode
+{
+ /**
+ * Private constructor. This class is not instantiable.
+ *
+ * @codeCoverageIgnore
+ */
+ private function __construct()
+ {
+ }
+
+ /**
+ * Asserts that the requested operation has an exact result, hence no rounding is necessary.
+ *
+ * If this rounding mode is specified on an operation that yields a result that
+ * cannot be represented at the requested scale, a RoundingNecessaryException is thrown.
+ */
+ public const UNNECESSARY = 0;
+
+ /**
+ * Rounds away from zero.
+ *
+ * Always increments the digit prior to a nonzero discarded fraction.
+ * Note that this rounding mode never decreases the magnitude of the calculated value.
+ */
+ public const UP = 1;
+
+ /**
+ * Rounds towards zero.
+ *
+ * Never increments the digit prior to a discarded fraction (i.e., truncates).
+ * Note that this rounding mode never increases the magnitude of the calculated value.
+ */
+ public const DOWN = 2;
+
+ /**
+ * Rounds towards positive infinity.
+ *
+ * If the result is positive, behaves as for UP; if negative, behaves as for DOWN.
+ * Note that this rounding mode never decreases the calculated value.
+ */
+ public const CEILING = 3;
+
+ /**
+ * Rounds towards negative infinity.
+ *
+ * If the result is positive, behave as for DOWN; if negative, behave as for UP.
+ * Note that this rounding mode never increases the calculated value.
+ */
+ public const FLOOR = 4;
+
+ /**
+ * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.
+ *
+ * Behaves as for UP if the discarded fraction is >= 0.5; otherwise, behaves as for DOWN.
+ * Note that this is the rounding mode commonly taught at school.
+ */
+ public const HALF_UP = 5;
+
+ /**
+ * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round down.
+ *
+ * Behaves as for UP if the discarded fraction is > 0.5; otherwise, behaves as for DOWN.
+ */
+ public const HALF_DOWN = 6;
+
+ /**
+ * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round towards positive infinity.
+ *
+ * If the result is positive, behaves as for HALF_UP; if negative, behaves as for HALF_DOWN.
+ */
+ public const HALF_CEILING = 7;
+
+ /**
+ * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round towards negative infinity.
+ *
+ * If the result is positive, behaves as for HALF_DOWN; if negative, behaves as for HALF_UP.
+ */
+ public const HALF_FLOOR = 8;
+
+ /**
+ * Rounds towards the "nearest neighbor" unless both neighbors are equidistant, in which case rounds towards the even neighbor.
+ *
+ * Behaves as for HALF_UP if the digit to the left of the discarded fraction is odd;
+ * behaves as for HALF_DOWN if it's even.
+ *
+ * Note that this is the rounding mode that statistically minimizes
+ * cumulative error when applied repeatedly over a sequence of calculations.
+ * It is sometimes known as "Banker's rounding", and is chiefly used in the USA.
+ */
+ public const HALF_EVEN = 9;
+}