'删除非必要文件'

-APP_NAME=Laravel
-APP_ENV=local
-APP_KEY=base64:/auyqKGh43iaRgeb1sFk3QO/3Ay43fEB3mxEh7XmmlQ=
-APP_DEBUG=true
-APP_URL=http://localhost
-
-LOG_CHANNEL=daily
-LOG_DEPRECATIONS_CHANNEL=null
-LOG_LEVEL=debug
-
-DB_CONNECTION=mysql
-DB_HOST=127.0.0.1
-DB_PORT=3306
-DB_DATABASE=forget
-DB_USERNAME=forget
-DB_PASSWORD=forget
-
-BROADCAST_DRIVER=log
-CACHE_DRIVER=file
-FILESYSTEM_DRIVER=local
-QUEUE_CONNECTION=redis
-SESSION_DRIVER=file
-SESSION_LIFETIME=120
-
-MEMCACHED_HOST=127.0.0.1
-REDIS_HOST=127.0.0.1
-REDIS_PASSWORD=null
-REDIS_PORT=6379
-
-MAIL_MAILER=smtp
-MAIL_HOST=mailhog
-MAIL_PORT=1025
-MAIL_USERNAME=null
-MAIL_PASSWORD=null
-MAIL_ENCRYPTION=null
-MAIL_FROM_ADDRESS=null
-MAIL_FROM_NAME="${APP_NAME}"
-
-AWS_ACCESS_KEY_ID=
-AWS_SECRET_ACCESS_KEY=
-AWS_DEFAULT_REGION=us-east-1
-AWS_BUCKET=
-AWS_USE_PATH_STYLE_ENDPOINT=false
-
-PUSHER_APP_ID=
-PUSHER_APP_KEY=
-PUSHER_APP_SECRET=
-PUSHER_APP_CLUSTER=mt1
-
-MIX_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
-MIX_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"
-
-API_URL=https://sitefile.globalso.com/
-TRANSMIT_URL=https://hub.globalso.com/
-MERCHANT_NUMBER=1288
-SECRET_TOKEN=ni4w5ba983c5a805fd54655d015354e6c3bc

-Copyright (c) 2013-2017 Alexander <iam.asm89@gmail.com>
-
-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.

-# Stack/Cors
-
-Library and middleware enabling cross-origin resource sharing for your
-http-{foundation,kernel} using application. It attempts to implement the
-[W3C Recommendation] for cross-origin resource sharing.
-
-[W3C Recommendation]: http://www.w3.org/TR/cors/
-
-Build status: ![.github/workflows/run-tests.yml](https://github.com/asm89/stack-cors/workflows/.github/workflows/run-tests.yml/badge.svg)
-
-## Installation
-
-Require `asm89/stack-cors` using composer.
-
-## Usage
-
-This package can be used as a library or as [stack middleware].
-
-[stack middleware]: http://stackphp.com/
-
-### Options
-
-| Option                 | Description                                                | Default value |
-|------------------------|------------------------------------------------------------|---------------|
-| `allowedMethods`         | Matches the request method.                                | `[]`          |
-| `allowedOrigins`         | Matches the request origin.                                | `[]`          |
-| `allowedOriginsPatterns` | Matches the request origin with `preg_match`.              | `[]`          |
-| `allowedHeaders`         | Sets the Access-Control-Allow-Headers response header.     | `[]`          |
-| `exposedHeaders`         | Sets the Access-Control-Expose-Headers response header.    | `false`       |
-| `maxAge`                 | Sets the Access-Control-Max-Age response header.<br/>Set to `null` to omit the header/use browser default.           | `0`       |
-| `supportsCredentials`    | Sets the Access-Control-Allow-Credentials header.          | `false`       |
-
-The _allowedMethods_ and _allowedHeaders_ options are case-insensitive.
-
-You don't need to provide both _allowedOrigins_ and _allowedOriginsPatterns_. If one of the strings passed matches, it is considered a valid origin.
-
-If `['*']` is provided to _allowedMethods_, _allowedOrigins_ or _allowedHeaders_ all methods / origins / headers are allowed.
-
-If _supportsCredentials_ is `true`, you must [explicitly set](https://fetch.spec.whatwg.org/#cors-protocol-and-credentials) `allowedHeaders` for any headers which are not CORS safelisted.
-
-### Example: using the library
-
-```php
-<?php
-
-use Asm89\Stack\CorsService;
-
-$cors = new CorsService([
-    'allowedHeaders'         => ['x-allowed-header', 'x-other-allowed-header'],
-    'allowedMethods'         => ['DELETE', 'GET', 'POST', 'PUT'],
-    'allowedOrigins'         => ['http://localhost'],
-    'allowedOriginsPatterns' => ['/localhost:\d/'],
-    'exposedHeaders'         => false,
-    'maxAge'                 => 600,
-    'supportsCredentials'    => true,
-]);
-
-$cors->addActualRequestHeaders(Response $response, $origin);
-$cors->handlePreflightRequest(Request $request);
-$cors->isActualRequestAllowed(Request $request);
-$cors->isCorsRequest(Request $request);
-$cors->isPreflightRequest(Request $request);
-```
-
-## Example: using the stack middleware
-
-```php
-<?php
-
-use Asm89\Stack\Cors;
-
-$app = new Cors($app, [
-    // you can use ['*'] to allow any headers
-    'allowedHeaders'      => ['x-allowed-header', 'x-other-allowed-header'],
-    // you can use ['*'] to allow any methods
-    'allowedMethods'      => ['DELETE', 'GET', 'POST', 'PUT'],
-    // you can use ['*'] to allow requests from any origin
-    'allowedOrigins'      => ['localhost'],
-    // you can enter regexes that are matched to the origin request header
-    'allowedOriginsPatterns' => ['/localhost:\d/'],
-    'exposedHeaders'      => false,
-    'maxAge'              => 600,
-    'supportsCredentials' => false,
-]);
-```

-{
-    "name": "asm89/stack-cors",
-    "description": "Cross-origin resource sharing library and stack middleware",
-    "keywords": ["stack", "cors"],
-    "homepage": "https://github.com/asm89/stack-cors",
-    "type": "library",
-    "license": "MIT",
-    "authors": [
-        {
-            "name": "Alexander",
-            "email": "iam.asm89@gmail.com"
-        }
-    ],
-    "require": {
-        "php": "^7.3|^8.0",
-        "symfony/http-foundation": "^5.3|^6|^7",
-        "symfony/http-kernel": "^5.3|^6|^7"
-    },
-    "require-dev": {
-        "phpunit/phpunit": "^9",
-        "squizlabs/php_codesniffer": "^3.5"
-    },
-    "autoload": {
-        "psr-4": {
-            "Asm89\\Stack\\": "src/"
-        }
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "Asm89\\Stack\\Tests\\": "tests/"
-        }
-    },
-    "scripts": {
-        "test": "phpunit",
-        "check-style": "phpcs -p --standard=PSR12 --exclude=Generic.Files.LineLength --runtime-set ignore_errors_on_exit 1 --runtime-set ignore_warnings_on_exit 1 src",
-        "fix-style": "phpcbf -p --standard=PSR12 --exclude=Generic.Files.LineLength --runtime-set ignore_errors_on_exit 1 --runtime-set ignore_warnings_on_exit 1 src"
-    },
-    "extra": {
-        "branch-alias": {
-            "dev-master": "2.2-dev"
-        }
-    },
-    "minimum-stability": "beta",
-    "prefer-stable": true
-}

-<?php
-
-/*
- * This file is part of asm89/stack-cors.
- *
- * (c) Alexander <iam.asm89@gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Asm89\Stack;
-
-use Symfony\Component\HttpFoundation\Response;
-use Symfony\Component\HttpKernel\HttpKernelInterface;
-use Symfony\Component\HttpFoundation\Request;
-
-class Cors implements HttpKernelInterface
-{
-    /**
-     * @var \Symfony\Component\HttpKernel\HttpKernelInterface
-     */
-    private $app;
-
-    /**
-     * @var \Asm89\Stack\CorsService
-     */
-    private $cors;
-
-    private $defaultOptions = [
-        'allowedHeaders'         => [],
-        'allowedMethods'         => [],
-        'allowedOrigins'         => [],
-        'allowedOriginsPatterns' => [],
-        'exposedHeaders'         => [],
-        'maxAge'                 => 0,
-        'supportsCredentials'    => false,
-    ];
-
-    public function __construct(HttpKernelInterface $app, array $options = [])
-    {
-        $this->app  = $app;
-        $this->cors = new CorsService(array_merge($this->defaultOptions, $options));
-    }
-
-    public function handle(Request $request, int $type = HttpKernelInterface::MAIN_REQUEST, bool $catch = true): Response
-    {
-        if ($this->cors->isPreflightRequest($request)) {
-            $response = $this->cors->handlePreflightRequest($request);
-            return $this->cors->varyHeader($response, 'Access-Control-Request-Method');
-        }
-
-        $response = $this->app->handle($request, $type, $catch);
-
-        if ($request->getMethod() === 'OPTIONS') {
-            $this->cors->varyHeader($response, 'Access-Control-Request-Method');
-        }
-
-        return $this->cors->addActualRequestHeaders($response, $request);
-    }
-}

-<?php
-
-/*
- * This file is part of asm89/stack-cors.
- *
- * (c) Alexander <iam.asm89@gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Asm89\Stack;
-
-use Symfony\Component\HttpFoundation\Request;
-use Symfony\Component\HttpFoundation\Response;
-
-class CorsService
-{
-    private $options;
-
-    public function __construct(array $options = [])
-    {
-        $this->options = $this->normalizeOptions($options);
-    }
-
-    private function normalizeOptions(array $options = []): array
-    {
-        $options += [
-            'allowedOrigins' => [],
-            'allowedOriginsPatterns' => [],
-            'supportsCredentials' => false,
-            'allowedHeaders' => [],
-            'exposedHeaders' => [],
-            'allowedMethods' => [],
-            'maxAge' => 0,
-        ];
-
-        // normalize array('*') to true
-        if (in_array('*', $options['allowedOrigins'])) {
-            $options['allowedOrigins'] = true;
-        }
-        if (in_array('*', $options['allowedHeaders'])) {
-            $options['allowedHeaders'] = true;
-        } else {
-            $options['allowedHeaders'] = array_map('strtolower', $options['allowedHeaders']);
-        }
-
-        if (in_array('*', $options['allowedMethods'])) {
-            $options['allowedMethods'] = true;
-        } else {
-            $options['allowedMethods'] = array_map('strtoupper', $options['allowedMethods']);
-        }
-
-        return $options;
-    }
-
-    /**
-     * @deprecated use isOriginAllowed
-     */
-    public function isActualRequestAllowed(Request $request): bool
-    {
-        return $this->isOriginAllowed($request);
-    }
-
-    public function isCorsRequest(Request $request): bool
-    {
-        return $request->headers->has('Origin');
-    }
-
-    public function isPreflightRequest(Request $request): bool
-    {
-        return $request->getMethod() === 'OPTIONS' && $request->headers->has('Access-Control-Request-Method');
-    }
-
-    public function handlePreflightRequest(Request $request): Response
-    {
-        $response = new Response();
-
-        $response->setStatusCode(204);
-
-        return $this->addPreflightRequestHeaders($response, $request);
-    }
-
-    public function addPreflightRequestHeaders(Response $response, Request $request): Response
-    {
-        $this->configureAllowedOrigin($response, $request);
-
-        if ($response->headers->has('Access-Control-Allow-Origin')) {
-            $this->configureAllowCredentials($response, $request);
-
-            $this->configureAllowedMethods($response, $request);
-
-            $this->configureAllowedHeaders($response, $request);
-
-            $this->configureMaxAge($response, $request);
-        }
-
-        return $response;
-    }
-
-    public function isOriginAllowed(Request $request): bool
-    {
-        if ($this->options['allowedOrigins'] === true) {
-            return true;
-        }
-
-        if (!$request->headers->has('Origin')) {
-            return false;
-        }
-
-        $origin = $request->headers->get('Origin');
-
-        if (in_array($origin, $this->options['allowedOrigins'])) {
-            return true;
-        }
-
-        foreach ($this->options['allowedOriginsPatterns'] as $pattern) {
-            if (preg_match($pattern, $origin)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public function addActualRequestHeaders(Response $response, Request $request): Response
-    {
-        $this->configureAllowedOrigin($response, $request);
-
-        if ($response->headers->has('Access-Control-Allow-Origin')) {
-            $this->configureAllowCredentials($response, $request);
-
-            $this->configureExposedHeaders($response, $request);
-        }
-
-        return $response;
-    }
-
-    private function configureAllowedOrigin(Response $response, Request $request)
-    {
-        if ($this->options['allowedOrigins'] === true && !$this->options['supportsCredentials']) {
-            // Safe+cacheable, allow everything
-            $response->headers->set('Access-Control-Allow-Origin', '*');
-        } elseif ($this->isSingleOriginAllowed()) {
-            // Single origins can be safely set
-            $response->headers->set('Access-Control-Allow-Origin', array_values($this->options['allowedOrigins'])[0]);
-        } else {
-            // For dynamic headers, set the requested Origin header when set and allowed
-            if ($this->isCorsRequest($request) && $this->isOriginAllowed($request)) {
-                $response->headers->set('Access-Control-Allow-Origin', $request->headers->get('Origin'));
-            }
-
-            $this->varyHeader($response, 'Origin');
-        }
-    }
-
-    private function isSingleOriginAllowed(): bool
-    {
-        if ($this->options['allowedOrigins'] === true || !empty($this->options['allowedOriginsPatterns'])) {
-            return false;
-        }
-
-        return count($this->options['allowedOrigins']) === 1;
-    }
-
-    private function configureAllowedMethods(Response $response, Request $request)
-    {
-        if ($this->options['allowedMethods'] === true) {
-            $allowMethods = strtoupper($request->headers->get('Access-Control-Request-Method'));
-            $this->varyHeader($response, 'Access-Control-Request-Method');
-        } else {
-            $allowMethods = implode(', ', $this->options['allowedMethods']);
-        }
-
-        $response->headers->set('Access-Control-Allow-Methods', $allowMethods);
-    }
-
-    private function configureAllowedHeaders(Response $response, Request $request)
-    {
-        if ($this->options['allowedHeaders'] === true) {
-            $allowHeaders = $request->headers->get('Access-Control-Request-Headers');
-            $this->varyHeader($response, 'Access-Control-Request-Headers');
-        } else {
-            $allowHeaders = implode(', ', $this->options['allowedHeaders']);
-        }
-        $response->headers->set('Access-Control-Allow-Headers', $allowHeaders);
-    }
-
-    private function configureAllowCredentials(Response $response, Request $request)
-    {
-        if ($this->options['supportsCredentials']) {
-            $response->headers->set('Access-Control-Allow-Credentials', 'true');
-        }
-    }
-
-    private function configureExposedHeaders(Response $response, Request $request)
-    {
-        if ($this->options['exposedHeaders']) {
-            $response->headers->set('Access-Control-Expose-Headers', implode(', ', $this->options['exposedHeaders']));
-        }
-    }
-
-    private function configureMaxAge(Response $response, Request $request)
-    {
-        if ($this->options['maxAge'] !== null) {
-            $response->headers->set('Access-Control-Max-Age', (int) $this->options['maxAge']);
-        }
-    }
-
-    public function varyHeader(Response $response, $header): Response
-    {
-        if (!$response->headers->has('Vary')) {
-            $response->headers->set('Vary', $header);
-        } elseif (!in_array($header, explode(', ', $response->headers->get('Vary')))) {
-            $response->headers->set('Vary', $response->headers->get('Vary') . ', ' . $header);
-        }
-
-        return $response;
-    }
-
-    private function isSameHost(Request $request): bool
-    {
-        return $request->headers->get('Origin') === $request->getSchemeAndHttpHost();
-    }
-}

-<?php
-
-// autoload.php @generated by Composer
-
-require_once __DIR__ . '/composer/autoload_real.php';
-
-return ComposerAutoloaderInitf0f55c3019081348437d7ad8517c7f84::getLoader();

-../nesbot/carbon/bin/carbon

-../symfony/error-handler/Resources/bin/patch-type-declarations

-../nikic/php-parser/bin/php-parse

-../phpunit/phpunit/phpunit

-../psy/psysh/bin/psysh

-../laravel/sail/bin/sail

-../symfony/var-dumper/Resources/bin/var-dump-server

-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-## [0.9.3](https://github.com/brick/math/releases/tag/0.9.3) - 2021-08-15
-
-🚀 **Compatibility with PHP 8.1**
-
-- Support for custom object serialization; this removes a warning on PHP 8.1 due to the `Serializable` interface being deprecated (thanks @TRowbotham)
-
-## [0.9.2](https://github.com/brick/math/releases/tag/0.9.2) - 2021-01-20
-
-🐛 **Bug fix**
-
-- Incorrect results could be returned when using the BCMath calculator, with a default scale set with `bcscale()`, on PHP >= 7.2 (#55).
-
-## [0.9.1](https://github.com/brick/math/releases/tag/0.9.1) - 2020-08-19
-
-✨ New features
-
-- `BigInteger::not()` returns the bitwise `NOT` value
-
-🐛 **Bug fixes**
-
-- `BigInteger::toBytes()` could return an incorrect binary representation for some numbers
-- The bitwise operations `and()`, `or()`, `xor()` on `BigInteger` could return an incorrect result when the GMP extension is not available
-
-## [0.9.0](https://github.com/brick/math/releases/tag/0.9.0) - 2020-08-18
-
-👌 **Improvements**
-
-- `BigNumber::of()` now accepts `.123` and `123.` formats, both of which return a `BigDecimal`
-
-💥 **Breaking changes**
-
-- Deprecated method `BigInteger::powerMod()` has been removed - use `modPow()` instead
-- Deprecated method `BigInteger::parse()` has been removed - use `fromBase()` instead
-
-## [0.8.17](https://github.com/brick/math/releases/tag/0.8.17) - 2020-08-19
-
-🐛 **Bug fix**
-
-- `BigInteger::toBytes()` could return an incorrect binary representation for some numbers
-- The bitwise operations `and()`, `or()`, `xor()` on `BigInteger` could return an incorrect result when the GMP extension is not available
-
-## [0.8.16](https://github.com/brick/math/releases/tag/0.8.16) - 2020-08-18
-
-🚑 **Critical fix**
-
-- This version reintroduces the deprecated `BigInteger::parse()` method, that has been removed by mistake in version `0.8.9` and should have lasted for the whole `0.8` release cycle.
-
-✨ **New features**
-
-- `BigInteger::modInverse()` calculates a modular multiplicative inverse
-- `BigInteger::fromBytes()` creates a `BigInteger` from a byte string
-- `BigInteger::toBytes()` converts a `BigInteger` to a byte string
-- `BigInteger::randomBits()` creates a pseudo-random `BigInteger` of a given bit length
-- `BigInteger::randomRange()` creates a pseudo-random `BigInteger` between two bounds
-
-💩 **Deprecations**
-
-- `BigInteger::powerMod()` is now deprecated in favour of `modPow()`
-
-## [0.8.15](https://github.com/brick/math/releases/tag/0.8.15) - 2020-04-15
-
-🐛 **Fixes**
-
-- added missing `ext-json` requirement, due to `BigNumber` implementing `JsonSerializable`
-
-⚡️ **Optimizations**
-
-- additional optimization in `BigInteger::remainder()`
-
-## [0.8.14](https://github.com/brick/math/releases/tag/0.8.14) - 2020-02-18
-
-✨ **New features**
-
-- `BigInteger::getLowestSetBit()` returns the index of the rightmost one bit
-
-## [0.8.13](https://github.com/brick/math/releases/tag/0.8.13) - 2020-02-16
-
-✨ **New features**
-
-- `BigInteger::isEven()` tests whether the number is even
-- `BigInteger::isOdd()` tests whether the number is odd
-- `BigInteger::testBit()` tests if a bit is set
-- `BigInteger::getBitLength()` returns the number of bits in the minimal representation of the number
-
-## [0.8.12](https://github.com/brick/math/releases/tag/0.8.12) - 2020-02-03
-
-🛠️ **Maintenance release**
-
-Classes are now annotated for better static analysis with [psalm](https://psalm.dev/).
-
-This is a maintenance release: no bug fixes, no new features, no breaking changes.
-
-## [0.8.11](https://github.com/brick/math/releases/tag/0.8.11) - 2020-01-23
-
-✨ **New feature**
-
-`BigInteger::powerMod()` performs a power-with-modulo operation. Useful for crypto.
-
-## [0.8.10](https://github.com/brick/math/releases/tag/0.8.10) - 2020-01-21
-
-✨ **New feature**
-
-`BigInteger::mod()` returns the **modulo** of two numbers. The *modulo* differs from the *remainder* when the signs of the operands are different.
-
-## [0.8.9](https://github.com/brick/math/releases/tag/0.8.9) - 2020-01-08
-
-⚡️ **Performance improvements**
-
-A few additional optimizations in `BigInteger` and `BigDecimal` when one of the operands can be returned as is. Thanks to @tomtomsen in #24.
-
-## [0.8.8](https://github.com/brick/math/releases/tag/0.8.8) - 2019-04-25
-
-🐛 **Bug fixes**
-
-- `BigInteger::toBase()` could return an empty string for zero values (BCMath & Native calculators only, GMP calculator unaffected)
-
-✨ **New features**
-
-- `BigInteger::toArbitraryBase()` converts a number to an arbitrary base, using a custom alphabet
-- `BigInteger::fromArbitraryBase()` converts a string in an arbitrary base, using a custom alphabet, back to a number
-
-These methods can be used as the foundation to convert strings between different bases/alphabets, using BigInteger as an intermediate representation.
-
-💩 **Deprecations**
-
-- `BigInteger::parse()` is now deprecated in favour of `fromBase()`
-
-`BigInteger::fromBase()` works the same way as `parse()`, with 2 minor differences:
-
-- the `$base` parameter is required, it does not default to `10`
-- it throws a `NumberFormatException` instead of an `InvalidArgumentException` when the number is malformed
-
-## [0.8.7](https://github.com/brick/math/releases/tag/0.8.7) - 2019-04-20
-
-**Improvements**
-
-- Safer conversion from `float` when using custom locales
-- **Much faster** `NativeCalculator` implementation 🚀
-
-You can expect **at least a 3x performance improvement** for common arithmetic operations when using the library on systems without GMP or BCMath; it gets exponentially faster on multiplications with a high number of digits. This is due to calculations now being performed on whole blocks of digits (the block size depending on the platform, 32-bit or 64-bit) instead of digit-by-digit as before.
-
-## [0.8.6](https://github.com/brick/math/releases/tag/0.8.6) - 2019-04-11
-
-**New method**
-
-`BigNumber::sum()` returns the sum of one or more numbers.
-
-## [0.8.5](https://github.com/brick/math/releases/tag/0.8.5) - 2019-02-12
-
-**Bug fix**: `of()` factory methods could fail when passing a `float` in environments using a `LC_NUMERIC` locale with a decimal separator other than `'.'` (#20).
-
-Thanks @manowark 👍
-
-## [0.8.4](https://github.com/brick/math/releases/tag/0.8.4) - 2018-12-07
-
-**New method**
-
-`BigDecimal::sqrt()` calculates the square root of a decimal number, to a given scale.
-
-## [0.8.3](https://github.com/brick/math/releases/tag/0.8.3) - 2018-12-06
-
-**New method**
-
-`BigInteger::sqrt()` calculates the square root of a number (thanks @peter279k).
-
-**New exception**
-
-`NegativeNumberException` is thrown when calling `sqrt()` on a negative number.
-
-## [0.8.2](https://github.com/brick/math/releases/tag/0.8.2) - 2018-11-08
-
-**Performance update**
-
-- Further improvement of `toInt()` performance
-- `NativeCalculator` can now perform some multiplications more efficiently
-
-## [0.8.1](https://github.com/brick/math/releases/tag/0.8.1) - 2018-11-07
-
-Performance optimization of `toInt()` methods.
-
-## [0.8.0](https://github.com/brick/math/releases/tag/0.8.0) - 2018-10-13
-
-**Breaking changes**
-
-The following deprecated methods have been removed. Use the new method name instead:
-
-| Method removed | Replacement method |
-| --- | --- |
-| `BigDecimal::getIntegral()` | `BigDecimal::getIntegralPart()` |
-| `BigDecimal::getFraction()` | `BigDecimal::getFractionalPart()` |
-
----
-
-**New features**
-
-`BigInteger` has been augmented with 5 new methods for bitwise operations:
-
-| New method | Description |
-| --- | --- |
-| `and()` | performs a bitwise `AND` operation on two numbers |
-| `or()` | performs a bitwise `OR` operation on two numbers |
-| `xor()` | performs a bitwise `XOR` operation on two numbers |
-| `shiftedLeft()` | returns the number shifted left by a number of bits |
-| `shiftedRight()` | returns the number shifted right by a number of bits |
-
-Thanks to @DASPRiD 👍
-
-## [0.7.3](https://github.com/brick/math/releases/tag/0.7.3) - 2018-08-20
-
-**New method:** `BigDecimal::hasNonZeroFractionalPart()`
-
-**Renamed/deprecated methods:**
-
-- `BigDecimal::getIntegral()` has been renamed to `getIntegralPart()` and is now deprecated
-- `BigDecimal::getFraction()` has been renamed to `getFractionalPart()` and is now deprecated
-
-## [0.7.2](https://github.com/brick/math/releases/tag/0.7.2) - 2018-07-21
-
-**Performance update**
-
-`BigInteger::parse()` and `toBase()` now use GMP's built-in base conversion features when available.
-
-## [0.7.1](https://github.com/brick/math/releases/tag/0.7.1) - 2018-03-01
-
-This is a maintenance release, no code has been changed.
-
-- When installed with `--no-dev`, the autoloader does not autoload tests anymore
-- Tests and other files unnecessary for production are excluded from the dist package
-
-This will help make installations more compact.
-
-## [0.7.0](https://github.com/brick/math/releases/tag/0.7.0) - 2017-10-02
-
-Methods renamed:
-
-- `BigNumber:sign()` has been renamed to `getSign()`
-- `BigDecimal::unscaledValue()` has been renamed to `getUnscaledValue()`
-- `BigDecimal::scale()` has been renamed to `getScale()`
-- `BigDecimal::integral()` has been renamed to `getIntegral()`
-- `BigDecimal::fraction()` has been renamed to `getFraction()`
-- `BigRational::numerator()` has been renamed to `getNumerator()`
-- `BigRational::denominator()` has been renamed to `getDenominator()`
-
-Classes renamed:
-
-- `ArithmeticException` has been renamed to `MathException`
-
-## [0.6.2](https://github.com/brick/math/releases/tag/0.6.2) - 2017-10-02
-
-The base class for all exceptions is now `MathException`.
-`ArithmeticException` has been deprecated, and will be removed in 0.7.0.
-
-## [0.6.1](https://github.com/brick/math/releases/tag/0.6.1) - 2017-10-02
-
-A number of methods have been renamed:
-
-- `BigNumber:sign()` is deprecated; use `getSign()` instead
-- `BigDecimal::unscaledValue()` is deprecated; use `getUnscaledValue()` instead
-- `BigDecimal::scale()` is deprecated; use `getScale()` instead
-- `BigDecimal::integral()` is deprecated; use `getIntegral()` instead
-- `BigDecimal::fraction()` is deprecated; use `getFraction()` instead
-- `BigRational::numerator()` is deprecated; use `getNumerator()` instead
-- `BigRational::denominator()` is deprecated; use `getDenominator()` instead
-
-The old methods will be removed in version 0.7.0.
-
-## [0.6.0](https://github.com/brick/math/releases/tag/0.6.0) - 2017-08-25
-
-- Minimum PHP version is now [7.1](https://gophp71.org/); for PHP 5.6 and PHP 7.0 support, use version `0.5`
-- Deprecated method `BigDecimal::withScale()` has been removed; use `toScale()` instead
-- Method `BigNumber::toInteger()` has been renamed to `toInt()`
-
-## [0.5.4](https://github.com/brick/math/releases/tag/0.5.4) - 2016-10-17
-
-`BigNumber` classes now implement [JsonSerializable](http://php.net/manual/en/class.jsonserializable.php).
-The JSON output is always a string.
-
-## [0.5.3](https://github.com/brick/math/releases/tag/0.5.3) - 2016-03-31
-
-This is a bugfix release. Dividing by a negative power of 1 with the same scale as the dividend could trigger an incorrect optimization which resulted in a wrong result. See #6.
-
-## [0.5.2](https://github.com/brick/math/releases/tag/0.5.2) - 2015-08-06
-
-The `$scale` parameter of `BigDecimal::dividedBy()` is now optional again.
-
-## [0.5.1](https://github.com/brick/math/releases/tag/0.5.1) - 2015-07-05
-
-**New method: `BigNumber::toScale()`**
-
-This allows to convert any `BigNumber` to a `BigDecimal` with a given scale, using rounding if necessary.
-
-## [0.5.0](https://github.com/brick/math/releases/tag/0.5.0) - 2015-07-04
-
-**New features**
-- Common `BigNumber` interface for all classes, with the following methods:
-  - `sign()` and derived methods (`isZero()`, `isPositive()`, ...)
-  - `compareTo()` and derived methods (`isEqualTo()`, `isGreaterThan()`, ...) that work across different `BigNumber` types
-  - `toBigInteger()`, `toBigDecimal()`, `toBigRational`() conversion methods
-  - `toInteger()` and `toFloat()` conversion methods to native types
-- Unified `of()` behaviour: every class now accepts any type of number, provided that it can be safely converted to the current type
-- New method: `BigDecimal::exactlyDividedBy()`; this method automatically computes the scale of the result, provided that the division yields a finite number of digits
-- New methods: `BigRational::quotient()` and `remainder()`
-- Fine-grained exceptions: `DivisionByZeroException`, `RoundingNecessaryException`, `NumberFormatException`
-- Factory methods `zero()`, `one()` and `ten()` available in all classes
-- Rounding mode reintroduced in `BigInteger::dividedBy()`
-
-This release also comes with many performance improvements.
-
----
-
-**Breaking changes**
-- `BigInteger`:
-  - `getSign()` is renamed to `sign()`
-  - `toString()` is renamed to `toBase()`
-  - `BigInteger::dividedBy()` now throws an exception by default if the remainder is not zero; use `quotient()` to get the previous behaviour
-- `BigDecimal`:
-  - `getSign()` is renamed to `sign()`
-  - `getUnscaledValue()` is renamed to `unscaledValue()`
-  - `getScale()` is renamed to `scale()`
-  - `getIntegral()` is renamed to `integral()`
-  - `getFraction()` is renamed to `fraction()`
-  - `divideAndRemainder()` is renamed to `quotientAndRemainder()`
-  - `dividedBy()` now takes a **mandatory** `$scale` parameter **before** the rounding mode
-  - `toBigInteger()` does not accept a `$roundingMode` parameter any more
-  - `toBigRational()` does not simplify the fraction any more; explicitly add `->simplified()` to get the previous behaviour
-- `BigRational`:
-  - `getSign()` is renamed to `sign()`
-  - `getNumerator()` is renamed to  `numerator()`
-  - `getDenominator()` is renamed to  `denominator()`
-  - `of()` is renamed to `nd()`, while `parse()` is renamed to `of()`
-- Miscellaneous:
-  - `ArithmeticException` is moved to an `Exception\` sub-namespace
-  - `of()` factory methods now throw `NumberFormatException` instead of `InvalidArgumentException`
-
-## [0.4.3](https://github.com/brick/math/releases/tag/0.4.3) - 2016-03-31
-
-Backport of two bug fixes from the 0.5 branch:
-- `BigInteger::parse()` did not always throw `InvalidArgumentException` as expected
-- Dividing by a negative power of 1 with the same scale as the dividend could trigger an incorrect optimization which resulted in a wrong result. See #6.
-
-## [0.4.2](https://github.com/brick/math/releases/tag/0.4.2) - 2015-06-16
-
-New method: `BigDecimal::stripTrailingZeros()`
-
-## [0.4.1](https://github.com/brick/math/releases/tag/0.4.1) - 2015-06-12
-
-Introducing a `BigRational` class, to perform calculations on fractions of any size.
-
-## [0.4.0](https://github.com/brick/math/releases/tag/0.4.0) - 2015-06-12
-
-Rounding modes have been removed from `BigInteger`, and are now a concept specific to `BigDecimal`.
-
-`BigInteger::dividedBy()` now always returns the quotient of the division.
-
-## [0.3.5](https://github.com/brick/math/releases/tag/0.3.5) - 2016-03-31
-
-Backport of two bug fixes from the 0.5 branch:
-
-- `BigInteger::parse()` did not always throw `InvalidArgumentException` as expected
-- Dividing by a negative power of 1 with the same scale as the dividend could trigger an incorrect optimization which resulted in a wrong result. See #6.
-
-## [0.3.4](https://github.com/brick/math/releases/tag/0.3.4) - 2015-06-11
-
-New methods:
-- `BigInteger::remainder()` returns the remainder of a division only
-- `BigInteger::gcd()` returns the greatest common divisor of two numbers
-
-## [0.3.3](https://github.com/brick/math/releases/tag/0.3.3) - 2015-06-07
-
-Fix `toString()` not handling negative numbers.
-
-## [0.3.2](https://github.com/brick/math/releases/tag/0.3.2) - 2015-06-07
-
-`BigInteger` and `BigDecimal` now have a `getSign()` method that returns:
-- `-1` if the number is negative
-- `0` if the number is zero
-- `1` if the number is positive
-
-## [0.3.1](https://github.com/brick/math/releases/tag/0.3.1) - 2015-06-05
-
-Minor performance improvements
-
-## [0.3.0](https://github.com/brick/math/releases/tag/0.3.0) - 2015-06-04
-
-The `$roundingMode` and `$scale` parameters have been swapped in `BigDecimal::dividedBy()`.
-
-## [0.2.2](https://github.com/brick/math/releases/tag/0.2.2) - 2015-06-04
-
-Stronger immutability guarantee for `BigInteger` and `BigDecimal`.
-
-So far, it would have been possible to break immutability of these classes by calling the `unserialize()` internal function. This release fixes that.
-
-## [0.2.1](https://github.com/brick/math/releases/tag/0.2.1) - 2015-06-02
-
-Added `BigDecimal::divideAndRemainder()`
-
-## [0.2.0](https://github.com/brick/math/releases/tag/0.2.0) - 2015-05-22
-
-- `min()` and `max()` do not accept an `array` any more, but a variable number of parameters
-- **minimum PHP version is now 5.6**
-- continuous integration with PHP 7
-
-## [0.1.1](https://github.com/brick/math/releases/tag/0.1.1) - 2014-09-01
-
-- Added `BigInteger::power()`
-- Added HHVM support
-
-## [0.1.0](https://github.com/brick/math/releases/tag/0.1.0) - 2014-08-31
-
-First beta release.
-

-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.

-# Security Policy
-
-## Supported Versions
-
-Only the last two release streams are supported.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 0.9.x   | :white_check_mark: |
-| 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.

-{
-    "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 || ^9.0",
-        "php-coveralls/php-coveralls": "^2.2",
-        "vimeo/psalm": "4.9.2"
-    },
-    "autoload": {
-        "psr-4": {
-            "Brick\\Math\\": "src/"
-        }
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "Brick\\Math\\Tests\\": "tests/"
-        }
-    }
-}

-<?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
-         * @var BigDecimal|null $zero
-         */
-        static $zero;
-
-        if ($zero === null) {
-            $zero = new BigDecimal('0');
-        }
-
-        return $zero;
-    }
-
-    /**
-     * Returns a BigDecimal representing one, with a scale of zero.
-     *
-     * @return BigDecimal
-     *
-     * @psalm-pure
-     */
-    public static function one() : BigDecimal
-    {
-        /**
-         * @psalm-suppress ImpureStaticVariable
-         * @var BigDecimal|null $one
-         */
-        static $one;
-
-        if ($one === null) {
-            $one = new BigDecimal('1');
-        }
-
-        return $one;
-    }
-
-    /**
-     * Returns a BigDecimal representing ten, with a scale of zero.
-     *
-     * @return BigDecimal
-     *
-     * @psalm-pure
-     */
-    public static function ten() : BigDecimal
-    {
-        /**
-         * @psalm-suppress ImpureStaticVariable
-         * @var BigDecimal|null $ten
-         */
-        static $ten;
-
-        if ($ten === null) {
-            $ten = new BigDecimal('10');
-        }
-
-        return $ten;
-    }
-
-    /**
-     * Returns the sum of this number and the given one.
-     *
-     * The result has a scale of `max($this->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
-    {
-        $zeroScaleDecimal = $this->scale === 0 ? $this : $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 for serializing the object and SHOULD NOT be accessed directly.
-     *
-     * @internal
-     *
-     * @return array{value: string, scale: int}
-     */
-    public function __serialize(): array
-    {
-        return ['value' => $this->value, 'scale' => $this->scale];
-    }
-
-    /**
-     * This method is only here to allow unserializing the object and cannot be accessed directly.
-     *
-     * @internal
-     * @psalm-suppress RedundantPropertyInitializationCheck
-     *
-     * @param array{value: string, scale: int} $data
-     *
-     * @return void
-     *
-     * @throws \LogicException
-     */
-    public function __unserialize(array $data): void
-    {
-        if (isset($this->value)) {
-            throw new \LogicException('__unserialize() is an internal function, it must not be called directly.');
-        }
-
-        $this->value = $data['value'];
-        $this->scale = $data['scale'];
-    }
-
-    /**
-     * This method is required by interface Serializable and SHOULD NOT be accessed directly.
-     *
-     * @internal
-     *
-     * @return string
-     */
-    public function serialize() : string
-    {
-        return $this->value . ':' . $this->scale;
-    }
-
-    /**
-     * This method is only here to implement interface Serializable and cannot be accessed directly.
-     *
-     * @internal
-     * @psalm-suppress RedundantPropertyInitializationCheck
-     *
-     * @param string $value
-     *
-     * @return void
-     *
-     * @throws \LogicException
-     */
-    public function unserialize($value) : void
-    {
-        if (isset($this->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{string, 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;
-    }
-}

-<?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.
-     *
-     * @psalm-param callable(int): string $randomBytesGenerator
-     *
-     * @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.
-     *
-     * @psalm-param (callable(int): string)|null $randomBytesGenerator
-     *
-     * @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
-         * @var BigInteger|null $zero
-         */
-        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
-         * @var BigInteger|null $one
-         */
-        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
-         * @var BigInteger|null $ten
-         */
-        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()) {
-                $bin = \hex2bin($hex);
-                assert($bin !== false);
-
-                $hex = \bin2hex(~$bin);
-                $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 for serializing the object and SHOULD NOT be accessed directly.
-     *
-     * @internal
-     *
-     * @return array{value: string}
-     */
-    public function __serialize(): array
-    {
-        return ['value' => $this->value];
-    }
-
-    /**
-     * This method is only here to allow unserializing the object and cannot be accessed directly.
-     *
-     * @internal
-     * @psalm-suppress RedundantPropertyInitializationCheck
-     *
-     * @param array{value: string} $data
-     *
-     * @return void
-     *
-     * @throws \LogicException
-     */
-    public function __unserialize(array $data): void
-    {
-        if (isset($this->value)) {
-            throw new \LogicException('__unserialize() is an internal function, it must not be called directly.');
-        }
-
-        $this->value = $data['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
-     * @psalm-suppress RedundantPropertyInitializationCheck
-     *
-     * @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;
-    }
-}

-<?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);
-        }
-
-        /** @psalm-suppress RedundantCastGivenDocblockType We cannot trust the untyped $value here! */
-        $value = \is_float($value) ? self::floatToString($value) : (string) $value;
-
-        $throw = static 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 = static 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) {
-            assert($denominator !== null);
-
-            if ($sign !== null) {
-                $numerator = $sign . $numerator;
-            }
-
-            $numerator   = self::cleanUp($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
-     * @psalm-suppress TooManyArguments
-     * @psalm-suppress UnsafeInstantiation
-     */
-    protected static function create(... $args) : BigNumber
-    {
-        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-suppress LessSpecificReturnStatement
-     * @psalm-suppress MoreSpecificReturnType
-     * @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-suppress LessSpecificReturnStatement
-     * @psalm-suppress MoreSpecificReturnType
-     * @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-suppress LessSpecificReturnStatement
-     * @psalm-suppress MoreSpecificReturnType
-     * @psalm-pure
-     */
-    public static function sum(...$values) : BigNumber
-    {
-        /** @var BigNumber|null $sum */
-        $sum = null;
-
-        foreach ($values as $value) {
-            $value = static::of($value);
-
-            $sum = $sum === null ? $value : 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();
-    }
-}

-<?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
-         * @var BigRational|null $zero
-         */
-        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
-         * @var BigRational|null $one
-         */
-        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
-         * @var BigRational|null $ten
-         */
-        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 for serializing the object and SHOULD NOT be accessed directly.
-     *
-     * @internal
-     *
-     * @return array{numerator: BigInteger, denominator: BigInteger}
-     */
-    public function __serialize(): array
-    {
-        return ['numerator' => $this->numerator, 'denominator' => $this->denominator];
-    }
-
-    /**
-     * This method is only here to allow unserializing the object and cannot be accessed directly.
-     *
-     * @internal
-     * @psalm-suppress RedundantPropertyInitializationCheck
-     *
-     * @param array{numerator: BigInteger, denominator: BigInteger} $data
-     *
-     * @return void
-     *
-     * @throws \LogicException
-     */
-    public function __unserialize(array $data): void
-    {
-        if (isset($this->numerator)) {
-            throw new \LogicException('__unserialize() is an internal function, it must not be called directly.');
-        }
-
-        $this->numerator = $data['numerator'];
-        $this->denominator = $data['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
-     * @psalm-suppress RedundantPropertyInitializationCheck
-     *
-     * @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);
-    }
-}

-<?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.');
-    }
-}

-<?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));
-    }
-}

-<?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
-{
-}

-<?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
-{
-}

-<?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));
-    }
-}

-<?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.');
-    }
-}