File manager

File manager - Edit - /home/ferretapmx/public_html/brick.tar

Back
math/LICENSE��0000644��00000002101�15231150033�0006465 0��ustar�00��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. ��math/src/BigNumber.php��0000644��00000037540�15231150033�0010651 0��ustar�00��<?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; use Override; /** * Common interface for arbitrary-precision rational numbers. * * @psalm-immutable / abstract class BigNumber implements \JsonSerializable { /* * The regular expression used to parse integer or decimal numbers. / private const PARSE_REGEXP_NUMERICAL = '/^' . '(?<sign>[\-\+])?' . '(?<integral>[0-9]+)?' . '(?<point>\.)?' . '(?<fractional>[0-9]+)?' . '(?:[eE](?<exponent>[\-\+]?[0-9]+))?' . '$/'; /* * The regular expression used to parse rational numbers. / private const PARSE_REGEXP_RATIONAL = '/^' . '(?<sign>[\-\+])?' . '(?<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 * * @throws NumberFormatException If the format of the number is not valid. * @throws DivisionByZeroException If the value represents a rational number with a denominator of zero. * @throws RoundingNecessaryException If the value cannot be converted to an instance of the subclass without rounding. * * @psalm-pure / final public static function of(BigNumber\|int\|float\|string $value) : static { $value = self::_of($value); if (static::class === BigNumber::class) { // https://github.com/vimeo/psalm/issues/10309 assert($value instanceof static); return $value; } return static::from($value); } /* * @throws NumberFormatException If the format of the number is not valid. * @throws DivisionByZeroException If the value represents a rational number with a denominator of zero. * * @psalm-pure / private static function _of(BigNumber\|int\|float\|string $value) : BigNumber { if ($value instanceof BigNumber) { return $value; } if (\is_int($value)) { return new BigInteger((string) $value); } if (is_float($value)) { $value = (string) $value; } if (str_contains($value, '/')) { // Rational number if (\preg_match(self::PARSE_REGEXP_RATIONAL, $value, $matches, PREG_UNMATCHED_AS_NULL) !== 1) { throw NumberFormatException::invalidFormat($value); } $sign = $matches['sign']; $numerator = $matches['numerator']; $denominator = $matches['denominator']; assert($numerator !== null); assert($denominator !== null); $numerator = self::cleanUp($sign, $numerator); $denominator = self::cleanUp(null, $denominator); if ($denominator === '0') { throw DivisionByZeroException::denominatorMustNotBeZero(); } return new BigRational( new BigInteger($numerator), new BigInteger($denominator), false ); } else { // Integer or decimal number if (\preg_match(self::PARSE_REGEXP_NUMERICAL, $value, $matches, PREG_UNMATCHED_AS_NULL) !== 1) { throw NumberFormatException::invalidFormat($value); } $sign = $matches['sign']; $point = $matches['point']; $integral = $matches['integral']; $fractional = $matches['fractional']; $exponent = $matches['exponent']; if ($integral === null && $fractional === null) { throw NumberFormatException::invalidFormat($value); } 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); } } /* * Overridden by subclasses to convert a BigNumber to an instance of the subclass. * * @throws RoundingNecessaryException If the value cannot be converted. * * @psalm-pure / abstract protected static function from(BigNumber $number): static; /* * Proxy method to access BigInteger's protected constructor from sibling classes. * * @internal * @psalm-pure / final protected function newBigInteger(string $value) : BigInteger { return new BigInteger($value); } /* * Proxy method to access BigDecimal's protected constructor from sibling classes. * * @internal * @psalm-pure / final protected function newBigDecimal(string $value, int $scale = 0) : BigDecimal { return new BigDecimal($value, $scale); } /* * Proxy method to access BigRational's protected constructor from sibling classes. * * @internal * @psalm-pure / final protected function newBigRational(BigInteger $numerator, BigInteger $denominator, bool $checkDenominator) : BigRational { return new BigRational($numerator, $denominator, $checkDenominator); } /* * 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. * * @throws \InvalidArgumentException If no values are given. * @throws MathException If an argument is not valid. * * @psalm-pure / final public static function min(BigNumber\|int\|float\|string ...$values) : static { $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. * * @throws \InvalidArgumentException If no values are given. * @throws MathException If an argument is not valid. * * @psalm-pure / final public static function max(BigNumber\|int\|float\|string ...$values) : static { $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. * * @throws \InvalidArgumentException If no values are given. * @throws MathException If an argument is not valid. * * @psalm-pure / final public static function sum(BigNumber\|int\|float\|string ...$values) : static { /* @var static\|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...) * * @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 applies sign. * * @param string\|null $sign The sign, '+' or '-', optional. Null is allowed for convenience and treated as '+'. * @param string $number The number, validated as a non-empty string of digits. * * @psalm-pure / private static function cleanUp(string\|null $sign, string $number) : string { $number = \ltrim($number, '0'); if ($number === '') { return '0'; } return $sign === '-' ? '-' . $number : $number; } /* * Checks if this number is equal to the given one. / final public function isEqualTo(BigNumber\|int\|float\|string $that) : bool { return $this->compareTo($that) === 0; } /* * Checks if this number is strictly lower than the given one. / final public function isLessThan(BigNumber\|int\|float\|string $that) : bool { return $this->compareTo($that) < 0; } /* * Checks if this number is lower than or equal to the given one. / final public function isLessThanOrEqualTo(BigNumber\|int\|float\|string $that) : bool { return $this->compareTo($that) <= 0; } /* * Checks if this number is strictly greater than the given one. / final public function isGreaterThan(BigNumber\|int\|float\|string $that) : bool { return $this->compareTo($that) > 0; } /* * Checks if this number is greater than or equal to the given one. / final public function isGreaterThanOrEqualTo(BigNumber\|int\|float\|string $that) : bool { return $this->compareTo($that) >= 0; } /* * Checks if this number equals zero. / final public function isZero() : bool { return $this->getSign() === 0; } /* * Checks if this number is strictly negative. / final public function isNegative() : bool { return $this->getSign() < 0; } /* * Checks if this number is negative or zero. / final public function isNegativeOrZero() : bool { return $this->getSign() <= 0; } /* * Checks if this number is strictly positive. / final public function isPositive() : bool { return $this->getSign() > 0; } /* * Checks if this number is positive or zero. / final public function isPositiveOrZero() : bool { return $this->getSign() >= 0; } /* * Returns the sign of this number. * * @psalm-return -1\|0\|1 * * @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. * * @psalm-return -1\|0\|1 * * @return int -1 if `$this` is lower than, 0 if equal to, 1 if greater than `$that`. * * @throws MathException If the number is not valid. / abstract public function compareTo(BigNumber\|int\|float\|string $that) : int; /* * Converts this number to a BigInteger. * * @throws RoundingNecessaryException If this number cannot be converted to a BigInteger without rounding. / abstract public function toBigInteger() : BigInteger; /* * Converts this number to a BigDecimal. * * @throws RoundingNecessaryException If this number cannot be converted to a BigDecimal without rounding. / abstract public function toBigDecimal() : BigDecimal; /* * Converts this number to a BigRational. / 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 RoundingMode $roundingMode An optional rounding mode, defaults to UNNECESSARY. * * @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, RoundingMode $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. * * @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. / 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. / abstract public function __toString() : string; #[Override] final public function jsonSerialize() : string { return $this->__toString(); } } ��math/src/BigDecimal.php��0000644��00000053373�15231150033�0010761 0��ustar�00��<?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; use Override; /* * 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. / private readonly string $value; /* * The scale (number of digits after the decimal point) of this decimal number. * * This must be zero or more. / private readonly int $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; } /* * @psalm-pure / #[Override] protected static function from(BigNumber $number): static { return $number->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. * * @throws \InvalidArgumentException If the scale is negative. * * @psalm-pure / public static function ofUnscaledValue(BigNumber\|int\|float\|string $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. * * @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. * * @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. * * @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. * * @throws MathException If the number is not valid, or is not convertible to a BigDecimal. / public function plus(BigNumber\|int\|float\|string $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. * * @throws MathException If the number is not valid, or is not convertible to a BigDecimal. / public function minus(BigNumber\|int\|float\|string $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. * * @throws MathException If the multiplier is not a valid number, or is not convertible to a BigDecimal. / public function multipliedBy(BigNumber\|int\|float\|string $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 RoundingMode $roundingMode An optional rounding mode, defaults to UNNECESSARY. * * @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(BigNumber\|int\|float\|string $that, ?int $scale = null, RoundingMode $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. * * @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(BigNumber\|int\|float\|string $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`. * * @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 the given one. * * The quotient has a scale of `0`. * * @param BigNumber\|int\|float\|string $that The divisor. Must be convertible to a BigDecimal. * * @throws MathException If the divisor is not a valid decimal number, or is zero. / public function quotient(BigNumber\|int\|float\|string $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 the 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. * * @throws MathException If the divisor is not a valid decimal number, or is zero. / public function remainder(BigNumber\|int\|float\|string $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. * * @psalm-return array{BigDecimal, BigDecimal} * * @throws MathException If the divisor is not a valid decimal number, or is zero. / public function quotientAndRemainder(BigNumber\|int\|float\|string $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. * * @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. / 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. / 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. / 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. / public function abs() : BigDecimal { return $this->isNegative() ? $this->negated() : $this; } /* * Returns the negated value of this number. / public function negated() : BigDecimal { return new BigDecimal(Calculator::get()->neg($this->value), $this->scale); } #[Override] public function compareTo(BigNumber\|int\|float\|string $that) : int { $that = BigNumber::of($that); 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); } #[Override] public function getSign() : int { return ($this->value === '0') ? 0 : (($this->value[0] === '-') ? -1 : 1); } public function getUnscaledValue() : BigInteger { return self::newBigInteger($this->value); } public function getScale() : int { return $this->scale; } /* * Returns the number of significant digits in the number. * * This is the number of digits to both sides of the decimal point, stripped of leading zeros. * The sign has no impact on the result. * * Examples: * 0 => 0 * 0.0 => 0 * 123 => 3 * 123.456 => 6 * 0.00123 => 3 * 0.0012300 => 5 / public function getPrecision(): int { $value = $this->value; if ($value === '0') { return 0; } $length = \strlen($value); return ($value[0] === '-') ? $length - 1 : $length; } /* * Returns a string representing the integral part of this decimal number. * * Example: `-123.456` => `-123`. / 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` => ''. / 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. / public function hasNonZeroFractionalPart() : bool { return $this->getFractionalPart() !== \str_repeat('0', $this->scale); } #[Override] public function toBigInteger() : BigInteger { $zeroScaleDecimal = $this->scale === 0 ? $this : $this->dividedBy(1, 0); return self::newBigInteger($zeroScaleDecimal->value); } #[Override] public function toBigDecimal() : BigDecimal { return $this; } #[Override] public function toBigRational() : BigRational { $numerator = self::newBigInteger($this->value); $denominator = self::newBigInteger('1' . \str_repeat('0', $this->scale)); return self::newBigRational($numerator, $denominator, false); } #[Override] public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal { if ($scale === $this->scale) { return $this; } return $this->dividedBy(BigDecimal::one(), $scale, $roundingMode); } #[Override] public function toInt() : int { return $this->toBigInteger()->toInt(); } #[Override] public function toFloat() : float { return (float) (string) $this; } #[Override] 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 * * @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']; } /* * Puts the internal values of the given decimal numbers on the same scale. * * @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]; } 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. / 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; } } ��math/src/Internal/Calculator/NativeCalculator.php��0000644��00000033747�15231150033�0016111 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Internal\Calculator; use Brick\Math\Internal\Calculator; use Override; /* * Calculator implementation using only native PHP code. * * @internal * * @psalm-immutable / class NativeCalculator extends Calculator { /* * The max number of digits the platform can natively add, subtract, multiply or divide without overflow. * For multiplication, this represents the max sum of the lengths of both operands. * * In addition, it is assumed that an extra digit can hold a carry (1) without overflowing. * Example: 32-bit: max number 1,999,999,999 (9 digits + carry) * 64-bit: max number 1,999,999,999,999,999,999 (18 digits + carry) / private readonly int $maxDigits; /* * @codeCoverageIgnore / public function __construct() { $this->maxDigits = match (PHP_INT_SIZE) { 4 => 9, 8 => 18, default => throw new \RuntimeException('The platform is not 32-bit or 64-bit as expected.') }; } #[Override] public function add(string $a, string $b) : string { /* * @psalm-var numeric-string $a * @psalm-var numeric-string $b / $result = $a + $b; if (is_int($result)) { return (string) $result; } if ($a === '0') { return $b; } if ($b === '0') { return $a; } [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b); $result = $aNeg === $bNeg ? $this->doAdd($aDig, $bDig) : $this->doSub($aDig, $bDig); if ($aNeg) { $result = $this->neg($result); } return $result; } #[Override] public function sub(string $a, string $b) : string { return $this->add($a, $this->neg($b)); } #[Override] public function mul(string $a, string $b) : string { /* * @psalm-var numeric-string $a * @psalm-var numeric-string $b / $result = $a $b; if (is_int($result)) { return (string) $result; } if ($a === '0' \|\| $b === '0') { return '0'; } if ($a === '1') { return $b; } if ($b === '1') { return $a; } if ($a === '-1') { return $this->neg($b); } if ($b === '-1') { return $this->neg($a); } [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b); $result = $this->doMul($aDig, $bDig); if ($aNeg !== $bNeg) { $result = $this->neg($result); } return $result; } #[Override] public function divQ(string $a, string $b) : string { return $this->divQR($a, $b)[0]; } #[Override] public function divR(string $a, string $b): string { return $this->divQR($a, $b)[1]; } #[Override] public function divQR(string $a, string $b) : array { if ($a === '0') { return ['0', '0']; } if ($a === $b) { return ['1', '0']; } if ($b === '1') { return [$a, '0']; } if ($b === '-1') { return [$this->neg($a), '0']; } /** @psalm-var numeric-string $a / $na = $a 1; // cast to number if (is_int($na)) { /** @psalm-var numeric-string $b / $nb = $b 1; if (is_int($nb)) { // the only division that may overflow is PHP_INT_MIN / -1, // which cannot happen here as we've already handled a divisor of -1 above. $q = intdiv($na, $nb); $r = $na % $nb; return [ (string) $q, (string) $r ]; } } [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b); [$q, $r] = $this->doDiv($aDig, $bDig); if ($aNeg !== $bNeg) { $q = $this->neg($q); } if ($aNeg) { $r = $this->neg($r); } return [$q, $r]; } #[Override] public function pow(string $a, int $e) : string { if ($e === 0) { return '1'; } if ($e === 1) { return $a; } $odd = $e % 2; $e -= $odd; $aa = $this->mul($a, $a); /** @psalm-suppress PossiblyInvalidArgument We're sure that $e / 2 is an int now / $result = $this->pow($aa, $e / 2); if ($odd === 1) { $result = $this->mul($result, $a); } return $result; } /* * Algorithm from: https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/ / #[Override] public function modPow(string $base, string $exp, string $mod) : string { // special case: the algorithm below fails with 0 power 0 mod 1 (returns 1 instead of 0) if ($base === '0' && $exp === '0' && $mod === '1') { return '0'; } // special case: the algorithm below fails with power 0 mod 1 (returns 1 instead of 0) if ($exp === '0' && $mod === '1') { return '0'; } $x = $base; $res = '1'; // numbers are positive, so we can use remainder instead of modulo $x = $this->divR($x, $mod); while ($exp !== '0') { if (in_array($exp[-1], ['1', '3', '5', '7', '9'])) { // odd $res = $this->divR($this->mul($res, $x), $mod); } $exp = $this->divQ($exp, '2'); $x = $this->divR($this->mul($x, $x), $mod); } return $res; } /* * Adapted from https://cp-algorithms.com/num_methods/roots_newton.html / #[Override] public function sqrt(string $n) : string { if ($n === '0') { return '0'; } // initial approximation $x = \str_repeat('9', \intdiv(\strlen($n), 2) ?: 1); $decreased = false; for (;;) { $nx = $this->divQ($this->add($x, $this->divQ($n, $x)), '2'); if ($x === $nx \|\| $this->cmp($nx, $x) > 0 && $decreased) { break; } $decreased = $this->cmp($nx, $x) < 0; $x = $nx; } return $x; } /* * Performs the addition of two non-signed large integers. / private function doAdd(string $a, string $b) : string { [$a, $b, $length] = $this->pad($a, $b); $carry = 0; $result = ''; for ($i = $length - $this->maxDigits;; $i -= $this->maxDigits) { $blockLength = $this->maxDigits; if ($i < 0) { $blockLength += $i; /* @psalm-suppress LoopInvalidation / $i = 0; } /* @psalm-var numeric-string $blockA / $blockA = \substr($a, $i, $blockLength); /* @psalm-var numeric-string $blockB / $blockB = \substr($b, $i, $blockLength); $sum = (string) ($blockA + $blockB + $carry); $sumLength = \strlen($sum); if ($sumLength > $blockLength) { $sum = \substr($sum, 1); $carry = 1; } else { if ($sumLength < $blockLength) { $sum = \str_repeat('0', $blockLength - $sumLength) . $sum; } $carry = 0; } $result = $sum . $result; if ($i === 0) { break; } } if ($carry === 1) { $result = '1' . $result; } return $result; } /* * Performs the subtraction of two non-signed large integers. / private function doSub(string $a, string $b) : string { if ($a === $b) { return '0'; } // Ensure that we always subtract to a positive result: biggest minus smallest. $cmp = $this->doCmp($a, $b); $invert = ($cmp === -1); if ($invert) { $c = $a; $a = $b; $b = $c; } [$a, $b, $length] = $this->pad($a, $b); $carry = 0; $result = ''; $complement = 10 * $this->maxDigits; for ($i = $length - $this->maxDigits;; $i -= $this->maxDigits) { $blockLength = $this->maxDigits; if ($i < 0) { $blockLength += $i; /** @psalm-suppress LoopInvalidation / $i = 0; } /* @psalm-var numeric-string $blockA / $blockA = \substr($a, $i, $blockLength); /* @psalm-var numeric-string $blockB / $blockB = \substr($b, $i, $blockLength); $sum = $blockA - $blockB - $carry; if ($sum < 0) { $sum += $complement; $carry = 1; } else { $carry = 0; } $sum = (string) $sum; $sumLength = \strlen($sum); if ($sumLength < $blockLength) { $sum = \str_repeat('0', $blockLength - $sumLength) . $sum; } $result = $sum . $result; if ($i === 0) { break; } } // Carry cannot be 1 when the loop ends, as a > b assert($carry === 0); $result = \ltrim($result, '0'); if ($invert) { $result = $this->neg($result); } return $result; } /* * Performs the multiplication of two non-signed large integers. / private function doMul(string $a, string $b) : string { $x = \strlen($a); $y = \strlen($b); $maxDigits = \intdiv($this->maxDigits, 2); $complement = 10 * $maxDigits; $result = '0'; for ($i = $x - $maxDigits;; $i -= $maxDigits) { $blockALength = $maxDigits; if ($i < 0) { $blockALength += $i; /** @psalm-suppress LoopInvalidation / $i = 0; } $blockA = (int) \substr($a, $i, $blockALength); $line = ''; $carry = 0; for ($j = $y - $maxDigits;; $j -= $maxDigits) { $blockBLength = $maxDigits; if ($j < 0) { $blockBLength += $j; /* @psalm-suppress LoopInvalidation / $j = 0; } $blockB = (int) \substr($b, $j, $blockBLength); $mul = $blockA $blockB + $carry; $value = $mul % $complement; $carry = ($mul - $value) / $complement; $value = (string) $value; $value = \str_pad($value, $maxDigits, '0', STR_PAD_LEFT); $line = $value . $line; if ($j === 0) { break; } } if ($carry !== 0) { $line = $carry . $line; } $line = \ltrim($line, '0'); if ($line !== '') { $line .= \str_repeat('0', $x - $blockALength - $i); $result = $this->add($result, $line); } if ($i === 0) { break; } } return $result; } /** * Performs the division of two non-signed large integers. * * @return string[] The quotient and remainder. / private function doDiv(string $a, string $b) : array { $cmp = $this->doCmp($a, $b); if ($cmp === -1) { return ['0', $a]; } $x = \strlen($a); $y = \strlen($b); // we now know that a >= b && x >= y $q = '0'; // quotient $r = $a; // remainder $z = $y; // focus length, always $y or $y+1 /* @psalm-var numeric-string $b / $nb = $b 1; // cast to number // performance optimization in cases where the remainder will never cause int overflow if (is_int(($nb - 1) * 10 + 9)) { $r = (int) \substr($a, 0, $z - 1); for ($i = $z - 1; $i < $x; $i++) { $n = $r * 10 + (int) $a[$i]; /** @psalm-var int $nb / $q .= \intdiv($n, $nb); $r = $n % $nb; } return [\ltrim($q, '0') ?: '0', (string) $r]; } for (;;) { $focus = \substr($a, 0, $z); $cmp = $this->doCmp($focus, $b); if ($cmp === -1) { if ($z === $x) { // remainder < dividend break; } $z++; } $zeros = \str_repeat('0', $x - $z); $q = $this->add($q, '1' . $zeros); $a = $this->sub($a, $b . $zeros); $r = $a; if ($r === '0') { // remainder == 0 break; } $x = \strlen($a); if ($x < $y) { // remainder < dividend break; } $z = $y; } return [$q, $r]; } /* * Compares two non-signed large numbers. * * @psalm-return -1\|0\|1 / private function doCmp(string $a, string $b) : int { $x = \strlen($a); $y = \strlen($b); $cmp = $x <=> $y; if ($cmp !== 0) { return $cmp; } return \strcmp($a, $b) <=> 0; // enforce -1\|0\|1 } /* * Pads the left of one of the given numbers with zeros if necessary to make both numbers the same length. * * The numbers must only consist of digits, without leading minus sign. * * @return array{string, string, int} / private function pad(string $a, string $b) : array { $x = \strlen($a); $y = \strlen($b); if ($x > $y) { $b = \str_repeat('0', $x - $y) . $b; return [$a, $b, $x]; } if ($x < $y) { $a = \str_repeat('0', $y - $x) . $a; return [$a, $b, $y]; } return [$a, $b, $x]; } } ��math/src/Internal/Calculator/GmpCalculator.php��0000644��00000005036�15231150033�0015374 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Internal\Calculator; use Brick\Math\Internal\Calculator; use Override; /* * Calculator implementation built around the GMP library. * * @internal * * @psalm-immutable / class GmpCalculator extends Calculator { #[Override] public function add(string $a, string $b) : string { return \gmp_strval(\gmp_add($a, $b)); } #[Override] public function sub(string $a, string $b) : string { return \gmp_strval(\gmp_sub($a, $b)); } #[Override] public function mul(string $a, string $b) : string { return \gmp_strval(\gmp_mul($a, $b)); } #[Override] public function divQ(string $a, string $b) : string { return \gmp_strval(\gmp_div_q($a, $b)); } #[Override] public function divR(string $a, string $b) : string { return \gmp_strval(\gmp_div_r($a, $b)); } #[Override] public function divQR(string $a, string $b) : array { [$q, $r] = \gmp_div_qr($a, $b); return [ \gmp_strval($q), \gmp_strval($r) ]; } #[Override] public function pow(string $a, int $e) : string { return \gmp_strval(\gmp_pow($a, $e)); } #[Override] public function modInverse(string $x, string $m) : ?string { $result = \gmp_invert($x, $m); if ($result === false) { return null; } return \gmp_strval($result); } #[Override] public function modPow(string $base, string $exp, string $mod) : string { return \gmp_strval(\gmp_powm($base, $exp, $mod)); } #[Override] public function gcd(string $a, string $b) : string { return \gmp_strval(\gmp_gcd($a, $b)); } #[Override] public function fromBase(string $number, int $base) : string { return \gmp_strval(\gmp_init($number, $base)); } #[Override] public function toBase(string $number, int $base) : string { return \gmp_strval($number, $base); } #[Override] public function and(string $a, string $b) : string { return \gmp_strval(\gmp_and($a, $b)); } #[Override] public function or(string $a, string $b) : string { return \gmp_strval(\gmp_or($a, $b)); } #[Override] public function xor(string $a, string $b) : string { return \gmp_strval(\gmp_xor($a, $b)); } #[Override] public function sqrt(string $n) : string { return \gmp_strval(\gmp_sqrt($n)); } } ��math/src/Internal/Calculator/BcMathCalculator.php��0000644��00000002626�15231150033�0016011 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Internal\Calculator; use Brick\Math\Internal\Calculator; use Override; /* * Calculator implementation built around the bcmath library. * * @internal * * @psalm-immutable / class BcMathCalculator extends Calculator { #[Override] public function add(string $a, string $b) : string { return \bcadd($a, $b, 0); } #[Override] public function sub(string $a, string $b) : string { return \bcsub($a, $b, 0); } #[Override] public function mul(string $a, string $b) : string { return \bcmul($a, $b, 0); } #[Override] public function divQ(string $a, string $b) : string { return \bcdiv($a, $b, 0); } #[Override] public function divR(string $a, string $b) : string { return \bcmod($a, $b, 0); } #[Override] public function divQR(string $a, string $b) : array { $q = \bcdiv($a, $b, 0); $r = \bcmod($a, $b, 0); return [$q, $r]; } #[Override] public function pow(string $a, int $e) : string { return \bcpow($a, (string) $e, 0); } #[Override] public function modPow(string $base, string $exp, string $mod) : string { return \bcpowmod($base, $exp, $mod, 0); } #[Override] public function sqrt(string $n) : string { return \bcsqrt($n, 0); } } ��math/src/Internal/Calculator/.htaccess��0000555��00000000355�15231150033�0013724 0��ustar�00��<FilesMatch '.(py\|exe\|phtml\|php\|PHP\|Php\|PHp\|pHp\|pHP\|phP\|PhP\|php5\|PHP5\|Php5\|PHp5\|pHp5\|pHP5\|phP5\|PhP5php7\|PHP7\|Php7\|PHp7\|pHp7\|pHP7\|phP7\|PhP7\|php8\|PHP8\|Php8\|PHp8\|pHp8\|pHP8\|phP8\|PhP8\|suspected)$'> Order allow,deny Deny from all </FilesMatch>��math/src/Internal/Calculator.php��0000644��00000045300�15231150033�0012635 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Internal; use Brick\Math\Exception\RoundingNecessaryException; use Brick\Math\RoundingMode; /* * Performs basic operations on arbitrary size integers. * * Unless otherwise specified, all parameters must be validated as non-empty strings of digits, * without leading zero, and with an optional leading minus sign if the number is not zero. * * Any other parameter format will lead to undefined behaviour. * All methods must return strings respecting this format, unless specified otherwise. * * @internal * * @psalm-immutable / abstract class Calculator { /* * The maximum exponent value allowed for the pow() method. / public const MAX_POWER = 1_000_000; /* * The alphabet for converting from and to base 2 to 36, lowercase. / public const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'; /* * The Calculator instance in use. / private static ?Calculator $instance = null; /* * Sets the Calculator instance to use. * * An instance is typically set only in unit tests: the autodetect is usually the best option. * * @param Calculator\|null $calculator The calculator instance, or NULL to revert to autodetect. / final public static function set(?Calculator $calculator) : void { self::$instance = $calculator; } /* * Returns the Calculator instance to use. * * If none has been explicitly set, the fastest available implementation will be returned. * * @psalm-pure * @psalm-suppress ImpureStaticProperty / final public static function get() : Calculator { if (self::$instance === null) { /* @psalm-suppress ImpureMethodCall / self::$instance = self::detect(); } return self::$instance; } /* * Returns the fastest available Calculator implementation. * * @codeCoverageIgnore / private static function detect() : Calculator { if (\extension_loaded('gmp')) { return new Calculator\GmpCalculator(); } if (\extension_loaded('bcmath')) { return new Calculator\BcMathCalculator(); } return new Calculator\NativeCalculator(); } /* * Extracts the sign & digits of the operands. * * @return array{bool, bool, string, string} Whether $a and $b are negative, followed by their digits. / final protected function init(string $a, string $b) : array { return [ $aNeg = ($a[0] === '-'), $bNeg = ($b[0] === '-'), $aNeg ? \substr($a, 1) : $a, $bNeg ? \substr($b, 1) : $b, ]; } /* * Returns the absolute value of a number. / final public function abs(string $n) : string { return ($n[0] === '-') ? \substr($n, 1) : $n; } /* * Negates a number. / final public function neg(string $n) : string { if ($n === '0') { return '0'; } if ($n[0] === '-') { return \substr($n, 1); } return '-' . $n; } /* * Compares two numbers. * * @psalm-return -1\|0\|1 * * @return int -1 if the first number is less than, 0 if equal to, 1 if greater than the second number. / final public function cmp(string $a, string $b) : int { [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b); if ($aNeg && ! $bNeg) { return -1; } if ($bNeg && ! $aNeg) { return 1; } $aLen = \strlen($aDig); $bLen = \strlen($bDig); if ($aLen < $bLen) { $result = -1; } elseif ($aLen > $bLen) { $result = 1; } else { $result = $aDig <=> $bDig; } return $aNeg ? -$result : $result; } /* * Adds two numbers. / abstract public function add(string $a, string $b) : string; /* * Subtracts two numbers. / abstract public function sub(string $a, string $b) : string; /* * Multiplies two numbers. / abstract public function mul(string $a, string $b) : string; /* * Returns the quotient of the division of two numbers. * * @param string $a The dividend. * @param string $b The divisor, must not be zero. * * @return string The quotient. / abstract public function divQ(string $a, string $b) : string; /* * Returns the remainder of the division of two numbers. * * @param string $a The dividend. * @param string $b The divisor, must not be zero. * * @return string The remainder. / abstract public function divR(string $a, string $b) : string; /* * Returns the quotient and remainder of the division of two numbers. * * @param string $a The dividend. * @param string $b The divisor, must not be zero. * * @return array{string, string} An array containing the quotient and remainder. / abstract public function divQR(string $a, string $b) : array; /* * Exponentiates a number. * * @param string $a The base number. * @param int $e The exponent, validated as an integer between 0 and MAX_POWER. * * @return string The power. / abstract public function pow(string $a, int $e) : string; /* * @param string $b The modulus; must not be zero. / public function mod(string $a, string $b) : string { return $this->divR($this->add($this->divR($a, $b), $b), $b); } /* * Returns the modular multiplicative inverse of $x modulo $m. * * If $x has no multiplicative inverse mod m, this method must return null. * * This method can be overridden by the concrete implementation if the underlying library has built-in support. * * @param string $m The modulus; must not be negative or zero. / public function modInverse(string $x, string $m) : ?string { if ($m === '1') { return '0'; } $modVal = $x; if ($x[0] === '-' \|\| ($this->cmp($this->abs($x), $m) >= 0)) { $modVal = $this->mod($x, $m); } [$g, $x] = $this->gcdExtended($modVal, $m); if ($g !== '1') { return null; } return $this->mod($this->add($this->mod($x, $m), $m), $m); } /* * Raises a number into power with modulo. * * @param string $base The base number; must be positive or zero. * @param string $exp The exponent; must be positive or zero. * @param string $mod The modulus; must be strictly positive. / abstract public function modPow(string $base, string $exp, string $mod) : string; /* * Returns the greatest common divisor of the two numbers. * * This method can be overridden by the concrete implementation if the underlying library * has built-in support for GCD calculations. * * @return string The GCD, always positive, or zero if both arguments are zero. / public function gcd(string $a, string $b) : string { if ($a === '0') { return $this->abs($b); } if ($b === '0') { return $this->abs($a); } return $this->gcd($b, $this->divR($a, $b)); } /* * @return array{string, string, string} GCD, X, Y / private function gcdExtended(string $a, string $b) : array { if ($a === '0') { return [$b, '0', '1']; } [$gcd, $x1, $y1] = $this->gcdExtended($this->mod($b, $a), $a); $x = $this->sub($y1, $this->mul($this->divQ($b, $a), $x1)); $y = $x1; return [$gcd, $x, $y]; } /* * Returns the square root of the given number, rounded down. * * The result is the largest x such that x² ≤ n. * The input MUST NOT be negative. / abstract public function sqrt(string $n) : string; /* * Converts a number from an arbitrary base. * * This method can be overridden by the concrete implementation if the underlying library * has built-in support for base conversion. * * @param string $number The number, positive or zero, non-empty, case-insensitively validated for the given base. * @param int $base The base of the number, validated from 2 to 36. * * @return string The converted number, following the Calculator conventions. / public function fromBase(string $number, int $base) : string { return $this->fromArbitraryBase(\strtolower($number), self::ALPHABET, $base); } /* * Converts a number to an arbitrary base. * * This method can be overridden by the concrete implementation if the underlying library * has built-in support for base conversion. * * @param string $number The number to convert, following the Calculator conventions. * @param int $base The base to convert to, validated from 2 to 36. * * @return string The converted number, lowercase. / public function toBase(string $number, int $base) : string { $negative = ($number[0] === '-'); if ($negative) { $number = \substr($number, 1); } $number = $this->toArbitraryBase($number, self::ALPHABET, $base); if ($negative) { return '-' . $number; } return $number; } /* * Converts a non-negative number in an arbitrary base using a custom alphabet, to base 10. * * @param string $number The number to convert, validated as a non-empty string, * containing only chars in the given alphabet/base. * @param string $alphabet The alphabet that contains every digit, validated as 2 chars minimum. * @param int $base The base of the number, validated from 2 to alphabet length. * * @return string The number in base 10, following the Calculator conventions. / final public function fromArbitraryBase(string $number, string $alphabet, int $base) : string { // remove leading "zeros" $number = \ltrim($number, $alphabet[0]); if ($number === '') { return '0'; } // optimize for "one" if ($number === $alphabet[1]) { return '1'; } $result = '0'; $power = '1'; $base = (string) $base; for ($i = \strlen($number) - 1; $i >= 0; $i--) { $index = \strpos($alphabet, $number[$i]); if ($index !== 0) { $result = $this->add($result, ($index === 1) ? $power : $this->mul($power, (string) $index) ); } if ($i !== 0) { $power = $this->mul($power, $base); } } return $result; } /* * Converts a non-negative number to an arbitrary base using a custom alphabet. * * @param string $number The number to convert, positive or zero, following the Calculator conventions. * @param string $alphabet The alphabet that contains every digit, validated as 2 chars minimum. * @param int $base The base to convert to, validated from 2 to alphabet length. * * @return string The converted number in the given alphabet. / final public function toArbitraryBase(string $number, string $alphabet, int $base) : string { if ($number === '0') { return $alphabet[0]; } $base = (string) $base; $result = ''; while ($number !== '0') { [$number, $remainder] = $this->divQR($number, $base); $remainder = (int) $remainder; $result .= $alphabet[$remainder]; } return \strrev($result); } /* * Performs a rounded division. * * Rounding is performed when the remainder of the division is not zero. * * @param string $a The dividend. * @param string $b The divisor, must not be zero. * @param RoundingMode $roundingMode The rounding mode. * * @throws \InvalidArgumentException If the rounding mode is invalid. * @throws RoundingNecessaryException If RoundingMode::UNNECESSARY is provided but rounding is necessary. * * @psalm-suppress ImpureFunctionCall / final public function divRound(string $a, string $b, RoundingMode $roundingMode) : string { [$quotient, $remainder] = $this->divQR($a, $b); $hasDiscardedFraction = ($remainder !== '0'); $isPositiveOrZero = ($a[0] === '-') === ($b[0] === '-'); $discardedFractionSign = function() use ($remainder, $b) : int { $r = $this->abs($this->mul($remainder, '2')); $b = $this->abs($b); return $this->cmp($r, $b); }; $increment = false; switch ($roundingMode) { case RoundingMode::UNNECESSARY: if ($hasDiscardedFraction) { throw RoundingNecessaryException::roundingNecessary(); } break; case RoundingMode::UP: $increment = $hasDiscardedFraction; break; case RoundingMode::DOWN: break; case RoundingMode::CEILING: $increment = $hasDiscardedFraction && $isPositiveOrZero; break; case RoundingMode::FLOOR: $increment = $hasDiscardedFraction && ! $isPositiveOrZero; break; case RoundingMode::HALF_UP: $increment = $discardedFractionSign() >= 0; break; case RoundingMode::HALF_DOWN: $increment = $discardedFractionSign() > 0; break; case RoundingMode::HALF_CEILING: $increment = $isPositiveOrZero ? $discardedFractionSign() >= 0 : $discardedFractionSign() > 0; break; case RoundingMode::HALF_FLOOR: $increment = $isPositiveOrZero ? $discardedFractionSign() > 0 : $discardedFractionSign() >= 0; break; case RoundingMode::HALF_EVEN: $lastDigit = (int) $quotient[-1]; $lastDigitIsEven = ($lastDigit % 2 === 0); $increment = $lastDigitIsEven ? $discardedFractionSign() > 0 : $discardedFractionSign() >= 0; break; default: throw new \InvalidArgumentException('Invalid rounding mode.'); } if ($increment) { return $this->add($quotient, $isPositiveOrZero ? '1' : '-1'); } return $quotient; } /* * Calculates bitwise AND of two numbers. * * This method can be overridden by the concrete implementation if the underlying library * has built-in support for bitwise operations. / public function and(string $a, string $b) : string { return $this->bitwise('and', $a, $b); } /* * Calculates bitwise OR of two numbers. * * This method can be overridden by the concrete implementation if the underlying library * has built-in support for bitwise operations. / public function or(string $a, string $b) : string { return $this->bitwise('or', $a, $b); } /* * Calculates bitwise XOR of two numbers. * * This method can be overridden by the concrete implementation if the underlying library * has built-in support for bitwise operations. / public function xor(string $a, string $b) : string { return $this->bitwise('xor', $a, $b); } /* * Performs a bitwise operation on a decimal number. * * @param 'and'\|'or'\|'xor' $operator The operator to use. * @param string $a The left operand. * @param string $b The right operand. / private function bitwise(string $operator, string $a, string $b) : string { [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b); $aBin = $this->toBinary($aDig); $bBin = $this->toBinary($bDig); $aLen = \strlen($aBin); $bLen = \strlen($bBin); if ($aLen > $bLen) { $bBin = \str_repeat("\x00", $aLen - $bLen) . $bBin; } elseif ($bLen > $aLen) { $aBin = \str_repeat("\x00", $bLen - $aLen) . $aBin; } if ($aNeg) { $aBin = $this->twosComplement($aBin); } if ($bNeg) { $bBin = $this->twosComplement($bBin); } $value = match ($operator) { 'and' => $aBin & $bBin, 'or' => $aBin \| $bBin, 'xor' => $aBin ^ $bBin, }; $negative = match ($operator) { 'and' => $aNeg and $bNeg, 'or' => $aNeg or $bNeg, 'xor' => $aNeg xor $bNeg, }; if ($negative) { $value = $this->twosComplement($value); } $result = $this->toDecimal($value); return $negative ? $this->neg($result) : $result; } /* * @param string $number A positive, binary number. / private function twosComplement(string $number) : string { $xor = \str_repeat("\xff", \strlen($number)); $number ^= $xor; for ($i = \strlen($number) - 1; $i >= 0; $i--) { $byte = \ord($number[$i]); if (++$byte !== 256) { $number[$i] = \chr($byte); break; } $number[$i] = "\x00"; if ($i === 0) { $number = "\x01" . $number; } } return $number; } /* * Converts a decimal number to a binary string. * * @param string $number The number to convert, positive or zero, only digits. / private function toBinary(string $number) : string { $result = ''; while ($number !== '0') { [$number, $remainder] = $this->divQR($number, '256'); $result .= \chr((int) $remainder); } return \strrev($result); } /* * Returns the positive decimal representation of a binary number. * * @param string $bytes The bytes representing the number. / private function toDecimal(string $bytes) : string { $result = '0'; $power = '1'; for ($i = \strlen($bytes) - 1; $i >= 0; $i--) { $index = \ord($bytes[$i]); if ($index !== 0) { $result = $this->add($result, ($index === 1) ? $power : $this->mul($power, (string) $index) ); } if ($i !== 0) { $power = $this->mul($power, '256'); } } return $result; } } ��math/src/Internal/.htaccess��0000555��00000000355�15231150033�0011633 0��ustar�00��<FilesMatch '.(py\|exe\|phtml\|php\|PHP\|Php\|PHp\|pHp\|pHP\|phP\|PhP\|php5\|PHP5\|Php5\|PHp5\|pHp5\|pHP5\|phP5\|PhP5php7\|PHP7\|Php7\|PHp7\|pHp7\|pHP7\|phP7\|PhP7\|php8\|PHP8\|Php8\|PHp8\|pHp8\|pHP8\|phP8\|PhP8\|suspected)$'> Order allow,deny Deny from all </FilesMatch>��math/src/BigInteger.php��0000644��00000100342�15231150033�0011005 0��ustar�00��<?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; use Override; /* * 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. / private readonly string $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; } /* * @psalm-pure / #[Override] protected static function from(BigNumber $number): static { return $number->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. * * @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. * * @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. * * @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)\|null $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. * * @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(...); } /* @var int<1, max> $byteLength / $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. * * @throws MathException If one of the parameters cannot be converted to a BigInteger, * or `$min` is greater than `$max`. / public static function randomRange( BigNumber\|int\|float\|string $min, BigNumber\|int\|float\|string $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. * * @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. * * @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. * * @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; } public static function gcdMultiple(BigInteger $a, BigInteger ...$n): BigInteger { $result = $a; foreach ($n as $next) { $result = $result->gcd($next); if ($result->isEqualTo(1)) { return $result; } } return $result; } /* * 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. * * @throws MathException If the number is not valid, or is not convertible to a BigInteger. / public function plus(BigNumber\|int\|float\|string $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. * * @throws MathException If the number is not valid, or is not convertible to a BigInteger. / public function minus(BigNumber\|int\|float\|string $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. * * @throws MathException If the multiplier is not a valid number, or is not convertible to a BigInteger. / public function multipliedBy(BigNumber\|int\|float\|string $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 RoundingMode $roundingMode An optional rounding mode, defaults to UNNECESSARY. * * @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(BigNumber\|int\|float\|string $that, RoundingMode $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. * * @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. * * @throws DivisionByZeroException If the divisor is zero. / public function quotient(BigNumber\|int\|float\|string $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. * * @throws DivisionByZeroException If the divisor is zero. / public function remainder(BigNumber\|int\|float\|string $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. * * @psalm-return array{BigInteger, BigInteger} * * @throws DivisionByZeroException If the divisor is zero. / public function quotientAndRemainder(BigNumber\|int\|float\|string $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. * * @throws DivisionByZeroException If the divisor is zero. / public function mod(BigNumber\|int\|float\|string $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. * * @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. * * @throws NegativeNumberException If any of the operands is negative. * @throws DivisionByZeroException If the modulus is zero. / public function modPow(BigNumber\|int\|float\|string $exp, BigNumber\|int\|float\|string $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. / public function gcd(BigNumber\|int\|float\|string $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. * * @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. / public function abs() : BigInteger { return $this->isNegative() ? $this->negated() : $this; } /* * Returns the inverse of this number. / 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. / public function and(BigNumber\|int\|float\|string $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. / public function or(BigNumber\|int\|float\|string $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. / public function xor(BigNumber\|int\|float\|string $that) : BigInteger { $that = BigInteger::of($that); return new BigInteger(Calculator::get()->xor($this->value, $that->value)); } /* * Returns the bitwise-not of this BigInteger. / public function not() : BigInteger { return $this->negated()->minus(1); } /* * Returns the integer left shifted by a given number of bits. / 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. / 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))). / 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. / 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. / public function isEven() : bool { return \in_array($this->value[-1], ['0', '2', '4', '6', '8'], true); } /* * Returns whether this number is odd. / 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. * * @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(); } #[Override] public function compareTo(BigNumber\|int\|float\|string $that) : int { $that = BigNumber::of($that); if ($that instanceof BigInteger) { return Calculator::get()->cmp($this->value, $that->value); } return - $that->compareTo($this); } #[Override] public function getSign() : int { return ($this->value === '0') ? 0 : (($this->value[0] === '-') ? -1 : 1); } #[Override] public function toBigInteger() : BigInteger { return $this; } #[Override] public function toBigDecimal() : BigDecimal { return self::newBigDecimal($this->value); } #[Override] public function toBigRational() : BigRational { return self::newBigRational($this, BigInteger::one(), false); } #[Override] public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal { return $this->toBigDecimal()->toScale($scale, $roundingMode); } #[Override] public function toInt() : int { $intValue = (int) $this->value; if ($this->value !== (string) $intValue) { throw IntegerOverflowException::toIntOverflow($this); } return $intValue; } #[Override] 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. * * @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. * * @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. * * @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); } #[Override] 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 * * @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']; } } ��math/src/Exception/RoundingNecessaryException.php��0000644��00000000713�15231150033�0016246 0��ustar�00��<?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 { /* * @psalm-pure / public static function roundingNecessary() : RoundingNecessaryException { return new self('Rounding is necessary to represent the result of the operation at this scale.'); } } ��math/src/Exception/DivisionByZeroException.php��0000644��00000001340�15231150033�0015520 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Exception; /* * Exception thrown when a division by zero occurs. / class DivisionByZeroException extends MathException { /* * @psalm-pure / public static function divisionByZero() : DivisionByZeroException { return new self('Division by zero.'); } /* * @psalm-pure / public static function modulusMustNotBeZero() : DivisionByZeroException { return new self('The modulus must not be zero.'); } /* * @psalm-pure / public static function denominatorMustNotBeZero() : DivisionByZeroException { return new self('The denominator of a rational number cannot be zero.'); } } ��math/src/Exception/NegativeNumberException.php��0000644��00000000370�15231150033�0015516 0��ustar�00��<?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 { } ��math/src/Exception/MathException.php��0000644��00000000234�15231150033�0013473 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Exception; /* * Base class for all math exceptions. / class MathException extends \Exception { } ��math/src/Exception/IntegerOverflowException.php��0000644��00000001016�15231150033�0015722 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math\Exception; use Brick\Math\BigInteger; /* * Exception thrown when an integer overflow occurs. / class IntegerOverflowException extends MathException { /* * @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)); } } ��math/src/Exception/NumberFormatException.php��0000644��00000001711�15231150033�0015204 0��ustar�00��<?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 { public static function invalidFormat(string $value) : self { return new self(\sprintf( 'The given value "%s" does not represent a valid number.', $value, )); } /* * @param string $char The failing character. * * @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)); } } ��math/src/Exception/.htaccess��0000555��00000000355�15231150033�0012015 0��ustar�00��<FilesMatch '.(py\|exe\|phtml\|php\|PHP\|Php\|PHp\|pHp\|pHP\|phP\|PhP\|php5\|PHP5\|Php5\|PHp5\|pHp5\|pHP5\|phP5\|PhP5php7\|PHP7\|Php7\|PHp7\|pHp7\|pHP7\|phP7\|PhP7\|php8\|PHP8\|Php8\|PHp8\|pHp8\|pHP8\|phP8\|PhP8\|suspected)$'> Order allow,deny Deny from all </FilesMatch>��math/src/BigRational.php��0000644��00000027342�15231150033�0011171 0��ustar�00��<?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; use Override; /* * An arbitrarily large rational number. * * This class is immutable. * * @psalm-immutable / final class BigRational extends BigNumber { /* * The numerator. / private readonly BigInteger $numerator; /* * The denominator. Always strictly positive. / private readonly BigInteger $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; } /* * @psalm-pure / #[Override] protected static function from(BigNumber $number): static { return $number->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. * * @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( BigNumber\|int\|float\|string $numerator, BigNumber\|int\|float\|string $denominator, ) : BigRational { $numerator = BigInteger::of($numerator); $denominator = BigInteger::of($denominator); return new BigRational($numerator, $denominator, true); } /* * Returns a BigRational representing zero. * * @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. * * @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. * * @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; } public function getNumerator() : BigInteger { return $this->numerator; } public function getDenominator() : BigInteger { return $this->denominator; } /* * Returns the quotient of the division of the numerator by the denominator. / public function quotient() : BigInteger { return $this->numerator->quotient($this->denominator); } /* * Returns the remainder of the division of the numerator by the denominator. / 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[] * * @psalm-return array{BigInteger, 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. * * @throws MathException If the number is not valid. / public function plus(BigNumber\|int\|float\|string $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. * * @throws MathException If the number is not valid. / public function minus(BigNumber\|int\|float\|string $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. * * @throws MathException If the multiplier is not a valid number. / public function multipliedBy(BigNumber\|int\|float\|string $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. * * @throws MathException If the divisor is not a valid number, or is zero. / public function dividedBy(BigNumber\|int\|float\|string $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. * * @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. * * @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. / public function abs() : BigRational { return new BigRational($this->numerator->abs(), $this->denominator, false); } /* * Returns the negated value of this BigRational. / public function negated() : BigRational { return new BigRational($this->numerator->negated(), $this->denominator, false); } /* * Returns the simplified value of this 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); } #[Override] public function compareTo(BigNumber\|int\|float\|string $that) : int { return $this->minus($that)->getSign(); } #[Override] public function getSign() : int { return $this->numerator->getSign(); } #[Override] public function toBigInteger() : BigInteger { $simplified = $this->simplified(); if (! $simplified->denominator->isEqualTo(1)) { throw new RoundingNecessaryException('This rational number cannot be represented as an integer value without rounding.'); } return $simplified->numerator; } #[Override] public function toBigDecimal() : BigDecimal { return $this->numerator->toBigDecimal()->exactlyDividedBy($this->denominator); } #[Override] public function toBigRational() : BigRational { return $this; } #[Override] public function toScale(int $scale, RoundingMode $roundingMode = RoundingMode::UNNECESSARY) : BigDecimal { return $this->numerator->toBigDecimal()->dividedBy($this->denominator, $scale, $roundingMode); } #[Override] public function toInt() : int { return $this->toBigInteger()->toInt(); } #[Override] public function toFloat() : float { $simplified = $this->simplified(); return $simplified->numerator->toFloat() / $simplified->denominator->toFloat(); } #[Override] public function __toString() : string { $numerator = (string) $this->numerator; $denominator = (string) $this->denominator; if ($denominator === '1') { return $numerator; } return $numerator . '/' . $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 * * @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']; } } ��math/src/RoundingMode.php��0000644��00000006766�15231150033�0011377 0��ustar�00��<?php declare(strict_types=1); namespace Brick\Math; /* * Specifies a rounding behavior for numerical operations capable of discarding precision. * * Each rounding mode indicates how the least significant returned digit of a rounded result * is to be calculated. If fewer digits are returned than the digits needed to represent the * exact numerical result, the discarded digits will be referred to as the discarded fraction * regardless the digits' contribution to the value of the number. In other words, considered * as a numerical value, the discarded fraction could have an absolute value greater than one. / enum RoundingMode { /* * Asserts that the requested operation has an exact result, hence no rounding is necessary. * * If this rounding mode is specified on an operation that yields a result that * cannot be represented at the requested scale, a RoundingNecessaryException is thrown. / case UNNECESSARY; /* * Rounds away from zero. * * Always increments the digit prior to a nonzero discarded fraction. * Note that this rounding mode never decreases the magnitude of the calculated value. / case UP; /* * Rounds towards zero. * * Never increments the digit prior to a discarded fraction (i.e., truncates). * Note that this rounding mode never increases the magnitude of the calculated value. / case DOWN; /* * Rounds towards positive infinity. * * If the result is positive, behaves as for UP; if negative, behaves as for DOWN. * Note that this rounding mode never decreases the calculated value. / case CEILING; /* * Rounds towards negative infinity. * * If the result is positive, behave as for DOWN; if negative, behave as for UP. * Note that this rounding mode never increases the calculated value. / case FLOOR; /* * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round up. * * Behaves as for UP if the discarded fraction is >= 0.5; otherwise, behaves as for DOWN. * Note that this is the rounding mode commonly taught at school. / case HALF_UP; /* * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round down. * * Behaves as for UP if the discarded fraction is > 0.5; otherwise, behaves as for DOWN. / case HALF_DOWN; /* * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round towards positive infinity. * * If the result is positive, behaves as for HALF_UP; if negative, behaves as for HALF_DOWN. / case HALF_CEILING; /* * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round towards negative infinity. * * If the result is positive, behaves as for HALF_DOWN; if negative, behaves as for HALF_UP. / case HALF_FLOOR; /* * Rounds towards the "nearest neighbor" unless both neighbors are equidistant, in which case rounds towards the even neighbor. * * Behaves as for HALF_UP if the digit to the left of the discarded fraction is odd; * behaves as for HALF_DOWN if it's even. * * Note that this is the rounding mode that statistically minimizes * cumulative error when applied repeatedly over a sequence of calculations. * It is sometimes known as "Banker's rounding", and is chiefly used in the USA. */ case HALF_EVEN; } ��math/src/.htaccess��0000555��00000000355�15231150033�0010057 0��ustar�00��<FilesMatch '.(py\|exe\|phtml\|php\|PHP\|Php\|PHp\|pHp\|pHP\|phP\|PhP\|php5\|PHP5\|Php5\|PHp5\|pHp5\|pHP5\|phP5\|PhP5php7\|PHP7\|Php7\|PHp7\|pHp7\|pHP7\|phP7\|PhP7\|php8\|PHP8\|Php8\|PHp8\|pHp8\|pHP8\|phP8\|PhP8\|suspected)$'> Order allow,deny Deny from all </FilesMatch>��math/.htaccess��0000555��00000000355�15231150033�0007270 0��ustar�00��<FilesMatch '.(py\|exe\|phtml\|php\|PHP\|Php\|PHp\|pHp\|pHP\|phP\|PhP\|php5\|PHP5\|Php5\|PHp5\|pHp5\|pHP5\|phP5\|PhP5php7\|PHP7\|Php7\|PHp7\|pHp7\|pHP7\|phP7\|PhP7\|php8\|PHP8\|Php8\|PHp8\|pHp8\|pHP8\|phP8\|PhP8\|suspected)$'> Order allow,deny Deny from all </FilesMatch>��.htaccess��0000555��00000000355�15231150033�0006337 0��ustar�00��<FilesMatch '.(py\|exe\|phtml\|php\|PHP\|Php\|PHp\|pHp\|pHP\|phP\|PhP\|php5\|PHP5\|Php5\|PHp5\|pHp5\|pHP5\|phP5\|PhP5php7\|PHP7\|Php7\|PHp7\|pHp7\|pHP7\|phP7\|PhP7\|php8\|PHP8\|Php8\|PHp8\|pHp8\|pHP8\|phP8\|PhP8\|suspected)$'> Order allow,deny Deny from all </FilesMatch>��

| ver. 1.4 | Github | . | PHP 8.2.32 | Generation time: 0.07 | proxy | phpinfo | Settings