create-prisma-php-app 1.0.0

package/vendor/brick/math/README.md

@@ -0,0 +1,247 @@
+## Brick\Math
+
+<img src="https://raw.githubusercontent.com/brick/brick/master/logo.png" alt="" align="left" height="64">
+
+A PHP library to work with arbitrary precision numbers.
+
+[![Build Status](https://github.com/brick/math/workflows/CI/badge.svg)](https://github.com/brick/math/actions)
+[![Coverage Status](https://coveralls.io/repos/github/brick/math/badge.svg?branch=master)](https://coveralls.io/github/brick/math?branch=master)
+[![Latest Stable Version](https://poser.pugx.org/brick/math/v/stable)](https://packagist.org/packages/brick/math)
+[![Total Downloads](https://poser.pugx.org/brick/math/downloads)](https://packagist.org/packages/brick/math)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
+
+### Installation
+
+This library is installable via [Composer](https://getcomposer.org/):
+
+```bash
+composer require brick/math
+```
+
+### Requirements
+
+This library requires PHP 8.0 or later.
+
+For PHP 7.4 compatibility, you can use version `0.10`. For PHP 7.1, 7.2 & 7.3, you can use version `0.9`. Note that [these PHP versions are EOL](http://php.net/supported-versions.php) and not supported anymore. If you're still using one of these PHP versions, you should consider upgrading as soon as possible.
+
+Although the library can work seamlessly on any PHP installation, it is highly recommended that you install the
+[GMP](http://php.net/manual/en/book.gmp.php) or [BCMath](http://php.net/manual/en/book.bc.php) extension
+to speed up calculations. The fastest available calculator implementation will be automatically selected at runtime.
+
+### Project status & release process
+
+While this library is still under development, it is well tested and considered stable enough to use in production
+environments.
+
+The current releases are numbered `0.x.y`. When a non-breaking change is introduced (adding new methods, optimizing
+existing code, etc.), `y` is incremented.
+
+**When a breaking change is introduced, a new `0.x` version cycle is always started.**
+
+It is therefore safe to lock your project to a given release cycle, such as `^0.11`.
+
+If you need to upgrade to a newer release cycle, check the [release history](https://github.com/brick/math/releases)
+for a list of changes introduced by each further `0.x.0` version.
+
+### Package contents
+
+This library provides the following public classes in the `Brick\Math` namespace:
+
+- [BigNumber](https://github.com/brick/math/blob/0.11.0/src/BigNumber.php): base class for `BigInteger`, `BigDecimal` and `BigRational`
+- [BigInteger](https://github.com/brick/math/blob/0.11.0/src/BigInteger.php): represents an arbitrary-precision integer number.
+- [BigDecimal](https://github.com/brick/math/blob/0.11.0/src/BigDecimal.php): represents an arbitrary-precision decimal number.
+- [BigRational](https://github.com/brick/math/blob/0.11.0/src/BigRational.php): represents an arbitrary-precision rational number (fraction).
+- [RoundingMode](https://github.com/brick/math/blob/0.11.0/src/RoundingMode.php): holds constants for the rounding modes.
+
+And the following exceptions in the `Brick\Math\Exception` namespace:
+
+- [MathException](https://github.com/brick/math/blob/0.11.0/src/Exception/MathException.php): base class for all exceptions
+- [DivisionByZeroException](https://github.com/brick/math/blob/0.11.0/src/Exception/DivisionByZeroException.php): thrown when a division by zero occurs
+- [IntegerOverflowException](https://github.com/brick/math/blob/0.11.0/src/Exception/IntegerOverflowException.php): thrown when attempting to convert a too large `BigInteger` to `int`
+- [NumberFormatException](https://github.com/brick/math/blob/0.11.0/src/Exception/NumberFormatException.php): thrown when parsing a number string in an invalid format
+- [RoundingNecessaryException](https://github.com/brick/math/blob/0.11.0/src/Exception/RoundingNecessaryException.php): thrown when the result of the operation cannot be represented without explicit rounding
+- [NegativeNumberException](https://github.com/brick/math/blob/0.11.0/src/Exception/NegativeNumberException.php): thrown when attempting to calculate the square root of a negative number
+
+### Overview
+
+#### Instantiation
+
+The constructors of the classes are not public, you must use a factory method to obtain an instance.
+
+All classes provide an `of()` factory method that accepts any of the following types:
+
+- `BigNumber` instances
+- `int` numbers
+- `float` numbers
+- `string` representations of integer, decimal and rational numbers
+
+Example:
+
+```php
+BigInteger::of(123546);
+BigInteger::of('9999999999999999999999999999999999999999999');
+
+BigDecimal::of(1.2);
+BigDecimal::of('9.99999999999999999999999999999999999999999999');
+
+BigRational::of('2/3');
+BigRational::of('1.1'); // 11/10
+```
+
+Note that all `of()` methods accept all of the representations above, *as long as it can be safely converted to
+the current type*:
+
+```php
+BigInteger::of('1.00'); // 1
+BigInteger::of('1.01'); // RoundingNecessaryException
+
+BigDecimal::of('1/8'); // 0.125
+BigDecimal::of('1/3'); // RoundingNecessaryException
+```
+
+Note about native integers: instantiating from an `int` is safe *as long as you don't exceed the maximum
+value for your platform* (`PHP_INT_MAX`), in which case it would be transparently converted to `float` by PHP without
+notice, and could result in a loss of information. In doubt, prefer instantiating from a `string`, which supports
+an unlimited numbers of digits:
+
+```php
+echo BigInteger::of(999999999999999999999); // 1000000000000000000000
+echo BigInteger::of('999999999999999999999'); // 999999999999999999999
+```
+
+Note about floating-point values: instantiating from a `float` might be unsafe, as floating-point values are
+imprecise by design, and could result in a loss of information. Always prefer instantiating from a `string`, which
+supports an unlimited number of digits:
+
+```php
+echo BigDecimal::of(1.99999999999999999999); // 2
+echo BigDecimal::of('1.99999999999999999999'); // 1.99999999999999999999
+```
+
+#### Immutability & chaining
+
+The `BigInteger`, `BigDecimal` and `BigRational` classes are immutable: their value never changes,
+so that they can be safely passed around. All methods that return a `BigInteger`, `BigDecimal` or `BigRational`
+return a new object, leaving the original object unaffected:
+
+```php
+$ten = BigInteger::of(10);
+
+echo $ten->plus(5); // 15
+echo $ten->multipliedBy(3); // 30
+```
+
+The methods can be chained for better readability:
+
+```php
+echo BigInteger::of(10)->plus(5)->multipliedBy(3); // 45
+```
+
+#### Parameter types
+
+All methods that accept a number: `plus()`, `minus()`, `multipliedBy()`, etc. accept the same types as `of()`.
+For example, given the following number:
+
+```php
+$integer = BigInteger::of(123);
+```
+
+The following lines are equivalent:
+
+```php
+$integer->multipliedBy(123);
+$integer->multipliedBy('123');
+$integer->multipliedBy($integer);
+```
+
+Just like `of()`, other types of `BigNumber` are acceptable, as long as they can be safely converted to the current type:
+
+```php
+echo BigInteger::of(2)->multipliedBy(BigDecimal::of('2.0')); // 4
+echo BigInteger::of(2)->multipliedBy(BigDecimal::of('2.5')); // RoundingNecessaryException
+echo BigDecimal::of(2.5)->multipliedBy(BigInteger::of(2)); // 5.0
+```
+
+#### Division & rounding
+
+##### BigInteger
+
+By default, dividing a `BigInteger` returns the exact result of the division, or throws an exception if the remainder
+of the division is not zero:
+
+```php
+echo BigInteger::of(999)->dividedBy(3); // 333
+echo BigInteger::of(1000)->dividedBy(3); // RoundingNecessaryException
+```
+
+You can pass an optional [rounding mode](https://github.com/brick/math/blob/0.11.0/src/RoundingMode.php) to round the result, if necessary:
+
+```php
+echo BigInteger::of(1000)->dividedBy(3, RoundingMode::DOWN); // 333
+echo BigInteger::of(1000)->dividedBy(3, RoundingMode::UP); // 334
+```
+
+If you're into quotients and remainders, there are methods for this, too:
+
+```php
+echo BigInteger::of(1000)->quotient(3); // 333
+echo BigInteger::of(1000)->remainder(3); // 1
+```
+
+You can even get both at the same time:
+
+```php
+[$quotient, $remainder] = BigInteger::of(1000)->quotientAndRemainder(3);
+```
+
+##### BigDecimal
+
+Dividing a `BigDecimal` always requires a scale to be specified. If the exact result of the division does not fit in
+the given scale, a [rounding mode](https://github.com/brick/math/blob/0.11.0/src/RoundingMode.php) must be provided.
+
+```php
+echo BigDecimal::of(1)->dividedBy('8', 3); // 0.125
+echo BigDecimal::of(1)->dividedBy('8', 2); // RoundingNecessaryException
+echo BigDecimal::of(1)->dividedBy('8', 2, RoundingMode::HALF_DOWN); // 0.12
+echo BigDecimal::of(1)->dividedBy('8', 2, RoundingMode::HALF_UP); // 0.13
+```
+
+If you know that the division yields a finite number of decimals places, you can use `exactlyDividedBy()`, which will
+automatically compute the required scale to fit the result, or throw an exception if the division yields an infinite
+repeating decimal:
+
+```php
+echo BigDecimal::of(1)->exactlyDividedBy(256); // 0.00390625
+echo BigDecimal::of(1)->exactlyDividedBy(11); // RoundingNecessaryException
+```
+
+##### BigRational
+
+The result of the division of a `BigRational` can always be represented exactly:
+
+```php
+echo BigRational::of('123/456')->dividedBy('7'); // 123/3192
+echo BigRational::of('123/456')->dividedBy('9/8'); // 984/4104
+```
+
+#### Bitwise operations
+
+`BigInteger` supports bitwise operations:
+
+- `and()`
+- `or()`
+- `xor()`
+- `not()`
+
+and bit shifting:
+
+- `shiftedLeft()`
+- `shiftedRight()`
+
+#### Serialization
+
+`BigInteger`, `BigDecimal` and `BigRational` can be safely serialized on a machine and unserialized on another,
+even if these machines do not share the same set of PHP extensions.
+
+For example, serializing on a machine with GMP support and unserializing on a machine that does not have this extension
+installed will still work as expected.

package/vendor/brick/math/composer.json

@@ -0,0 +1,34 @@
+{
+    "name": "brick/math",
+    "description": "Arbitrary-precision arithmetic library",
+    "type": "library",
+    "keywords": [
+        "Brick",
+        "Math",
+        "Arbitrary-precision",
+        "Arithmetic",
+        "BigInteger",
+        "BigDecimal",
+        "BigRational",
+        "Bignum"
+    ],
+    "license": "MIT",
+    "require": {
+        "php": "^8.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^9.0",
+        "php-coveralls/php-coveralls": "^2.2",
+        "vimeo/psalm": "5.0.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Brick\\Math\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Brick\\Math\\Tests\\": "tests/"
+        }
+    }
+}

package/vendor/brick/math/phpunit.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+use Brick\Math\Internal\Calculator;
+
+require __DIR__ . '/vendor/autoload.php';
+
+/**
+ * @return Calculator
+ */
+function getCalculatorImplementation()
+{
+    switch ($calculator = \getenv('CALCULATOR')) {
+        case 'GMP':
+            $calculator = new Calculator\GmpCalculator();
+            break;
+
+        case 'BCMath':
+            $calculator = new Calculator\BcMathCalculator();
+            break;
+
+        case 'Native':
+            $calculator = new Calculator\NativeCalculator();
+            break;
+
+        default:
+            if ($calculator === false) {
+                echo 'CALCULATOR environment variable not set!' . PHP_EOL;
+            } else {
+                echo 'Unknown calculator: ' . $calculator . PHP_EOL;
+            }
+
+            echo 'Example usage: CALCULATOR={calculator} vendor/bin/phpunit' . PHP_EOL;
+            echo 'Available calculators: GMP, BCMath, Native' . PHP_EOL;
+            exit(1);
+    }
+
+    echo 'Using ', \get_class($calculator), PHP_EOL;
+
+    return $calculator;
+}
+
+Calculator::set(getCalculatorImplementation());
+
+$scale = \getenv('BCMATH_DEFAULT_SCALE');
+
+if ($scale !== false) {
+    echo "Using bcscale($scale)", PHP_EOL;
+    \bcscale((int) $scale);
+}

package/vendor/brick/math/phpunit.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" colors="true" bootstrap="phpunit.php" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
+    <testsuites>
+        <testsuite name="Math tests">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <coverage processUncoveredFiles="true">
+        <include>
+            <directory suffix=".php">src</directory>
+        </include>
+    </coverage>
+</phpunit>

package/vendor/brick/math/psalm.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<psalm
+    errorLevel="1"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="vendor" />
+        </ignoreFiles>
+    </projectFiles>
+
+    <issueHandlers>
+        <ArgumentTypeCoercion>
+            <errorLevel type="suppress">
+                <file name="src/Internal/Calculator/BcMathCalculator.php" />
+            </errorLevel>
+        </ArgumentTypeCoercion>
+
+        <ImpureByReferenceAssignment>
+            <errorLevel type="suppress">
+                <file name="src/Internal/Calculator.php" />
+            </errorLevel>
+        </ImpureByReferenceAssignment>
+    </issueHandlers>
+</psalm>

package/vendor/brick/math/random-tests.php

@@ -0,0 +1,162 @@
+<?php
+
+/**
+ * This script stress tests calculators with random large numbers and ensures that all implementations return the same
+ * results. It is designed to run in an infinite loop unless a bug is found.
+ */
+
+declare(strict_types=1);
+
+require __DIR__ . '/vendor/autoload.php';
+
+use Brick\Math\Internal\Calculator;
+
+(new class(30) { // max digits
+    private Calculator\GmpCalculator $gmp;
+    private Calculator\BcMathCalculator $bcmath;
+    private Calculator\NativeCalculator $native;
+
+    private int $testCounter = 0;
+    private float $lastOutputTime = 0.0;
+    private int $currentSecond = 0;
+    private int $currentSecondTestCounter = 0;
+    private int $testsPerSecond = 0;
+
+    public function __construct(
+        private int $maxDigits,
+    ) {
+        $this->gmp    = new Calculator\GmpCalculator();
+        $this->bcmath = new Calculator\BcMathCalculator();
+        $this->native = new Calculator\NativeCalculator();
+    }
+
+    public function __invoke() : void
+    {
+        for (;;) {
+            $a = $this->generateRandomNumber();
+            $b = $this->generateRandomNumber();
+            $c = $this->generateRandomNumber();
+
+            $this->runTests($a, $b);
+            $this->runTests($b, $a);
+
+            if ($a !== '0') {
+                $this->runTests("-$a", $b);
+                $this->runTests($b, "-$a");
+            }
+
+            if ($b !== '0') {
+                $this->runTests($a, "-$b");
+                $this->runTests("-$b", $a);
+            }
+
+            if ($a !== '0' && $b !== '0') {
+                $this->runTests("-$a", "-$b");
+                $this->runTests("-$b", "-$a");
+            }
+
+            if ($c !== '0') {
+                $this->test("$a POW $b MOD $c", fn (Calculator $calc) => $calc->modPow($a, $b, $c));
+            }
+        }
+    }
+
+    /**
+     * @param string $a The left operand.
+     * @param string $b The right operand.
+     */
+    private function runTests(string $a, string $b) : void
+    {
+        $this->test("$a + $b", fn (Calculator $c) => $c->add($a, $b));
+        $this->test("$a - $b", fn (Calculator $c) => $c->sub($a, $b));
+        $this->test("$a * $b", fn (Calculator $c) => $c->mul($a, $b));
+
+        if ($b !== '0') {
+            $this->test("$a / $b", fn (Calculator $c) => $c->divQR($a, $b));
+            $this->test("$a MOD $b", fn (Calculator $c) => $c->mod($a, $b));
+        }
+
+        if ($b !== '0' && $b[0] !== '-') {
+            $this->test("INV $a MOD $b", fn (Calculator $c) => $c->modInverse($a, $b));
+        }
+
+        $this->test("GCD $a, $b", fn (Calculator $c) => $c->gcd($a, $b));
+
+        if ($a[0] !== '-') {
+            $this->test("SQRT $a", fn (Calculator $c) => $c->sqrt($a));
+        }
+
+        $this->test("$a AND $b", fn (Calculator $c) => $c->and($a, $b));
+        $this->test("$a OR $b", fn (Calculator $c) => $c->or($a, $b));
+        $this->test("$a XOR $b", fn (Calculator $c) => $c->xor($a, $b));
+    }
+
+    /**
+     * @param string $test A string representing the test being executed.
+     * @param Closure(Calculator): mixed $callback A callback function accepting a Calculator instance and returning a calculation result.
+     */
+    private function test(string $test, Closure $callback) : void
+    {
+        $gmpResult    = $callback($this->gmp);
+        $bcmathResult = $callback($this->bcmath);
+        $nativeResult = $callback($this->native);
+
+        if ($gmpResult !== $bcmathResult) {
+            $this->failure('GMP', 'BCMath', $test);
+        }
+
+        if ($gmpResult !== $nativeResult) {
+            $this->failure('GMP', 'Native', $test);
+        }
+
+        $this->testCounter++;
+        $this->currentSecondTestCounter++;
+
+        $time = microtime(true);
+        $second = (int) $time;
+
+        if ($second !== $this->currentSecond) {
+            $this->currentSecond = $second;
+            $this->testsPerSecond = $this->currentSecondTestCounter;
+            $this->currentSecondTestCounter = 0;
+        }
+
+        if ($time - $this->lastOutputTime >= 0.1) {
+            echo "\r", number_format($this->testCounter), ' (', number_format($this->testsPerSecond) . ' / s)';
+            $this->lastOutputTime = $time;
+        }
+    }
+
+    /**
+     * @param string $c1   The name of the first calculator.
+     * @param string $c2   The name of the second calculator.
+     * @param string $test A string representing the test being executed.
+     */
+    private function failure(string $c1, string $c2, string $test) : void
+    {
+        echo PHP_EOL;
+        echo 'FAILURE!', PHP_EOL;
+        echo $c1, ' vs ', $c2, PHP_EOL;
+        echo $test, PHP_EOL;
+        die;
+    }
+
+    private function generateRandomNumber() : string
+    {
+        $length = random_int(1, $this->maxDigits);
+
+        $number = '';
+
+        for ($i = 0; $i < $length; $i++) {
+            $number .= random_int(0, 9);
+        }
+
+        $number = ltrim($number, '0');
+
+        if ($number === '') {
+            return '0';
+        }
+
+        return $number;
+    }
+})();