Bringing the codebase up the PHPStan level 3

Signed-off-by: Jordan LeDoux <jordan.ledoux@gmail.com>

.github/workflows/ci-management.yml

@@ -29,7 +29,7 @@ jobs:
       - uses: php-actions/phpstan@v3
         with:
           path: src/
-          level: 1
+          level: 3
           memory_limit: 512M
   phpmetrics:
     runs-on: ubuntu-latest

src/Samsara/Fermat/Complex/Types/ComplexNumber.php

@@ -255,12 +255,12 @@ public function isLessThanOrEqualTo($value): bool|null
      * @param array $number
      * @param $scale
      * @param NumberBase $base
-     * @return ComplexNumber
+     * @return static
      * @throws IncompatibleObjectState
      * @throws IntegrityConstraint
      * @throws OptionalExit
      */
-    public static function makeFromArray(array $number, $scale = null, NumberBase $base = NumberBase::Ten): ComplexNumber
+    public static function makeFromArray(array $number, $scale = null, NumberBase $base = NumberBase::Ten): static
     {
 
         if (count($number) != 2) {
@@ -273,8 +273,8 @@ public static function makeFromArray(array $number, $scale = null, NumberBase $b
 
         [$part1, $part2] = $number;
 
-        $part1 = Numbers::make(Numbers::IMMUTABLE, $part1);
-        $part2 = Numbers::make(Numbers::IMMUTABLE, $part2);
+        $part1 = new ImmutableDecimal($part1);
+        $part2 = new ImmutableDecimal($part2);
 
         if (($part1->isReal() && $part2->isReal()) || ($part1->isImaginary() && $part2->isImaginary())) {
             throw new IntegrityConstraint(
@@ -295,12 +295,12 @@ public static function makeFromArray(array $number, $scale = null, NumberBase $b
      * @param string $expression
      * @param $scale
      * @param NumberBase $base
-     * @return ComplexNumber
+     * @return static
      * @throws IncompatibleObjectState
      * @throws IntegrityConstraint
      * @throws OptionalExit
      */
-    public static function makeFromString(string $expression, $scale = null, NumberBase $base = NumberBase::Ten): ComplexNumber
+    public static function makeFromString(string $expression, $scale = null, NumberBase $base = NumberBase::Ten): static
     {
         if (str_contains($expression, '+')) {
             [$part1, $part2] = explode('+', $expression);

src/Samsara/Fermat/Complex/Types/Traits/ArithmeticComplexHelperTrait.php

@@ -160,7 +160,9 @@ protected function helperPowPolar(
 
         $trigArg = $trigArgLnPart->add($trigArgThetaPart);
 
+        /** @var ImmutableDecimal $newRealPart */
         $newRealPart = $trigArg->cos($internalScale)->multiply($coef);
+        /** @var ImmutableDecimal $newImaginaryPart */
         $newImaginaryPart = $trigArg->sin($internalScale)->multiply($coef)->multiply('1i');
 
         return [$newRealPart, $newImaginaryPart];

src/Samsara/Fermat/Core/Numbers.php

@@ -154,10 +154,10 @@ public static function makeOrDont(string|object $type, mixed $value, ?int $scale
      * @param string $value
      * @param NumberBase $base
      *
-     * @return Fraction
+     * @return ImmutableFraction|MutableFraction|Fraction
      * @throws IntegrityConstraint
      */
-    public static function makeFractionFromString(string $type, string $value, NumberBase $base = NumberBase::Ten): Fraction
+    public static function makeFractionFromString(string $type, string $value, NumberBase $base = NumberBase::Ten): ImmutableFraction|MutableFraction|Fraction
     {
         $parts = explode('/', $value);
 
@@ -218,15 +218,15 @@ public static function makeTau($scale = null): ImmutableDecimal
             }
 
             if ($scale > 100) {
-                $pi = self::make(self::IMMUTABLE, ConstantProvider::makePi($scale+2), $scale + 2);
+                $pi = new ImmutableDecimal(ConstantProvider::makePi($scale+2), $scale + 2);
                 /** @var ImmutableDecimal */
                 return $pi->multiply(2)->truncateToScale($scale);
             }
 
-            return self::make(self::IMMUTABLE, self::TAU, $scale+1)->truncateToScale($scale);
+            return (new ImmutableDecimal(self::TAU, $scale+1))->truncateToScale($scale);
         }
 
-        return self::make(self::IMMUTABLE, self::TAU, 100);
+        return new ImmutableDecimal(self::TAU, 100);
     }
 
     /**
@@ -294,7 +294,7 @@ public static function makeNaturalLog2(?int $scale = null): ImmutableDecimal
      */
     public static function makeOne(?int $scale = null): ImmutableDecimal
     {
-        return self::make(self::IMMUTABLE, 1, $scale);
+        return new ImmutableDecimal(1, $scale);
     }
 
     /**
@@ -305,7 +305,7 @@ public static function makeOne(?int $scale = null): ImmutableDecimal
      */
     public static function makeZero(?int $scale = null): ImmutableDecimal
     {
-        return self::make(self::IMMUTABLE, 0, $scale);
+        return new ImmutableDecimal(0, $scale);
     }
 
     private static function makeConstant(string $constant, ?int $scale): ImmutableDecimal
@@ -321,8 +321,7 @@ private static function makeConstant(string $constant, ?int $scale): ImmutableDe
             }
 
             if ($scale > 100) {
-                return self::make(
-                    self::IMMUTABLE,
+                return new ImmutableDecimal(
                     match ($constant) {
                         self::LN_2 => ConstantProvider::makeLn2($scale),
                         self::LN_10 => ConstantProvider::makeLn10($scale),
@@ -334,15 +333,13 @@ private static function makeConstant(string $constant, ?int $scale): ImmutableDe
                 );
             }
 
-            return self::make(
-                self::IMMUTABLE,
+            return (new ImmutableDecimal(
                 $constant,
                 $scale+1
-            )->truncateToScale($scale);
+            ))->truncateToScale($scale);
         }
 
-        return self::make(
-            self::IMMUTABLE,
+        return new ImmutableDecimal(
             $constant,
             100
         );

src/Samsara/Fermat/Core/Provider/RandomProvider.php

@@ -41,7 +41,9 @@ public static function randomInt(
         ?int $seed = null
     ): ImmutableDecimal
     {
+        /** @var ImmutableDecimal $minDecimal */
         $minDecimal = Numbers::makeOrDont(Numbers::IMMUTABLE, $min);
+        /** @var ImmutableDecimal $maxDecimal */
         $maxDecimal = Numbers::makeOrDont(Numbers::IMMUTABLE, $max);
 
         /**

src/Samsara/Fermat/Core/Provider/RoundingProvider.php

@@ -21,7 +21,7 @@ public static function setRoundingMode(
         RoundingMode $mode
     ): void
     {
-        static::$mode = $mode;
+        self::$mode = $mode;
     }
 
     /**

src/Samsara/Fermat/Core/Provider/SequenceProvider.php

@@ -75,6 +75,7 @@ class SequenceProvider
      * OEIS: A005408
      *
      * @param int $n
+     * @param int|null $scale
      * @param bool $asCollection
      * @param int $collectionSize
      *
@@ -128,7 +129,7 @@ public static function nthEvenNumber(int $n, int $scale = null, bool $asCollecti
             return $sequence;
         }
         if ($n > (PHP_INT_MAX/2)) {
-            $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n, $scale);
+            $n = new ImmutableDecimal($n, $scale);
 
             return $n->multiply(2);
         } else {
@@ -195,7 +196,7 @@ public static function nthEulerZigzag(int $n, bool $asCollection = false, int $c
             );
         }
 
-        return Numbers::make(Numbers::IMMUTABLE, static::EULER_ZIGZAG[$n], 100);
+        return new ImmutableDecimal(static::EULER_ZIGZAG[$n], 100);
 
     }
 
@@ -218,7 +219,7 @@ public static function nthBernoulliNumber($n, ?int $scale = null): ImmutableDeci
 
         $internalScale = (int)ceil($scale*(log10($scale)+1));
 
-        $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n, $internalScale)->setMode(CalcMode::Precision);
+        $n = (new ImmutableDecimal($n, $internalScale))->setMode(CalcMode::Precision);
 
         if (!$n->isWhole()) {
             throw new IntegrityConstraint(
@@ -241,7 +242,7 @@ public static function nthBernoulliNumber($n, ?int $scale = null): ImmutableDeci
         }
 
         if ($n->isEqual(1)) {
-            return Numbers::make(Numbers::IMMUTABLE, '-0.5', $scale);
+            return new ImmutableDecimal('-0.5', $scale);
         }
 
         if ($n->modulo(2)->isEqual(1)) {
@@ -250,7 +251,7 @@ public static function nthBernoulliNumber($n, ?int $scale = null): ImmutableDeci
 
         $tau = Numbers::makeTau($internalScale)->setMode(CalcMode::Precision);
 
-        $d = Numbers::make(Numbers::IMMUTABLE, 4, $internalScale)->setMode(CalcMode::Precision)->add(
+        $d = (new ImmutableDecimal(4, $internalScale))->setMode(CalcMode::Precision)->add(
             $n->factorial()->ln($internalScale)->subtract(
                 $n->multiply($tau->log10($internalScale))
             )->truncate()
@@ -313,9 +314,9 @@ public static function nthPrimeNumbers(int $n): NumberCollection
     {
         $collection = new NumberCollection();
 
-        $collection->push(Numbers::make(Numbers::IMMUTABLE, 2));
+        $collection->push(new ImmutableDecimal(2));
 
-        $currentPrime = Numbers::make(Numbers::IMMUTABLE, 3);
+        $currentPrime = new ImmutableDecimal(3);
 
         for ($i = 1;$i < $n;$i++) {
             while (!$currentPrime->isPrime()) {
@@ -345,7 +346,7 @@ public static function nthPrimeNumbers(int $n): NumberCollection
      */
     public static function nthFibonacciNumber(int $n, bool $asCollection = false, int $collectionSize = 10): ImmutableDecimal|NumberCollection
     {
-        $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);
+        $n = new ImmutableDecimal($n);
 
         if ($n->isLessThan(0)) {
             throw new IntegrityConstraint(
@@ -355,7 +356,7 @@ public static function nthFibonacciNumber(int $n, bool $asCollection = false, in
             );
         }
 
-        $fastFib = static::_fib($n);
+        $fastFib = self::_fib($n);
 
         if ($asCollection) {
             $sequence = new NumberCollection();
@@ -394,7 +395,7 @@ public static function nthFibonacciPair(int $n): array
             );
         }
 
-        return static::_fib($n);
+        return self::_fib($n);
     }
 
     /**
@@ -407,9 +408,9 @@ public static function nthLucasNumber(int $n): ImmutableDecimal
     {
 
         if ($n == 0) {
-            return Numbers::make(Numbers::IMMUTABLE, 2);
+            return new ImmutableDecimal(2);
         } elseif ($n == 1) {
-            return Numbers::make(Numbers::IMMUTABLE, 1);
+            return new ImmutableDecimal(1);
         } elseif ($n < 0) {
             throw new IntegrityConstraint(
                 'Negative term numbers not valid for Lucas Numbers',
@@ -418,8 +419,8 @@ public static function nthLucasNumber(int $n): ImmutableDecimal
             );
         }
 
-        [$F1, $fib] = static::_fib(Numbers::make(Numbers::IMMUTABLE, $n-1));
-        [$fib, $F2] = static::_fib($fib);
+        [$F1, $fib] = self::_fib(new ImmutableDecimal($n-1));
+        [, $F2] = self::_fib($fib);
 
         return $F1->add($F2);
 
@@ -460,13 +461,8 @@ private static function _fib(ImmutableDecimal $number): array
             return [Numbers::makeZero(), Numbers::makeOne()];
         }
 
-        /**
-         * @var ImmutableDecimal $a
-         * @var ImmutableDecimal $b
-         * @var ImmutableDecimal $prevCall
-         */
         $prevCall = $number->divide(2)->floor();
-        [$a, $b] = static::_fib($prevCall);
+        [$a, $b] = self::_fib($prevCall);
         $c = $a->multiply($b->multiply(2)->subtract($a));
         $d = $a->multiply($a)->add($b->multiply($b));
 
@@ -479,7 +475,7 @@ private static function _fib(ImmutableDecimal $number): array
 
     private static function _nextprime(ImmutableDecimal $number): ImmutableDecimal
     {
-        return Numbers::make(Numbers::IMMUTABLE, gmp_strval(gmp_nextprime($number->getValue(NumberBase::Ten))));
+        return new ImmutableDecimal(gmp_strval(gmp_nextprime($number->getValue(NumberBase::Ten))));
     }
 
 }

src/Samsara/Fermat/Core/Types/Decimal.php

@@ -50,7 +50,7 @@ final public function __construct($value, int $scale = null, NumberBase $base =
 
         $this->base = $base;
 
-        $value = $value instanceof Number ? $value->getValue(NumberBase::Ten) : (string)$value;
+        $value = $value instanceof Decimal ? $value->getValue(NumberBase::Ten) : (string)$value;
 
         if (str_contains($value, 'i')) {
             $this->imaginary = true;

src/Samsara/Fermat/Core/Types/Fraction.php

@@ -37,7 +37,9 @@ abstract class Fraction extends Number
     final public function __construct($numerator, $denominator, NumberBase $base = NumberBase::Ten)
     {
 
+        /** @var ImmutableDecimal $numerator */
         $numerator = Numbers::makeOrDont(Numbers::IMMUTABLE, $numerator, null, $base);
+        /** @var ImmutableDecimal $denominator */
         $denominator = Numbers::makeOrDont(Numbers::IMMUTABLE, $denominator, null, $base);
 
         if ($denominator->isEqual(0)) {
@@ -149,7 +151,7 @@ public function isComplex(): bool
     }
 
     /**
-     * @return Fraction|ImmutableFraction|MutableFraction
+     * @return static|ImmutableFraction|MutableFraction
      * @throws IntegrityConstraint
      * @throws IncompatibleObjectState
      */
@@ -262,7 +264,7 @@ public function asReal(): ImmutableDecimal|ImmutableFraction
      * @param Decimal|null $lcm
      * @return ImmutableDecimal[]
      */
-    protected function getNumeratorsWithSameDenominator(Fraction $fraction, Decimal $lcm = null): array
+    public function getNumeratorsWithSameDenominator(Fraction $fraction, Decimal $lcm = null): array
     {
 
         $thisNumerator = $this->getNumerator();