diff --git a/.github/workflows/ci-management.yml b/.github/workflows/ci-management.yml
index 7c54813a..309338f1 100644
--- a/.github/workflows/ci-management.yml
+++ b/.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
diff --git a/src/Samsara/Fermat/Complex/Types/ComplexNumber.php b/src/Samsara/Fermat/Complex/Types/ComplexNumber.php
index 6a283f7c..12524489 100644
--- a/src/Samsara/Fermat/Complex/Types/ComplexNumber.php
+++ b/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);
diff --git a/src/Samsara/Fermat/Complex/Types/Traits/ArithmeticComplexHelperTrait.php b/src/Samsara/Fermat/Complex/Types/Traits/ArithmeticComplexHelperTrait.php
index 851b7213..b5d7096b 100644
--- a/src/Samsara/Fermat/Complex/Types/Traits/ArithmeticComplexHelperTrait.php
+++ b/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];
diff --git a/src/Samsara/Fermat/Core/Numbers.php b/src/Samsara/Fermat/Core/Numbers.php
index 532fc368..732fd5d2 100644
--- a/src/Samsara/Fermat/Core/Numbers.php
+++ b/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
         );
diff --git a/src/Samsara/Fermat/Core/Provider/RandomProvider.php b/src/Samsara/Fermat/Core/Provider/RandomProvider.php
index 8810a9eb..c87b18de 100644
--- a/src/Samsara/Fermat/Core/Provider/RandomProvider.php
+++ b/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);
 
         /**
diff --git a/src/Samsara/Fermat/Core/Provider/RoundingProvider.php b/src/Samsara/Fermat/Core/Provider/RoundingProvider.php
index 555a874a..b6c91871 100644
--- a/src/Samsara/Fermat/Core/Provider/RoundingProvider.php
+++ b/src/Samsara/Fermat/Core/Provider/RoundingProvider.php
@@ -21,7 +21,7 @@ public static function setRoundingMode(
         RoundingMode $mode
     ): void
     {
-        static::$mode = $mode;
+        self::$mode = $mode;
     }
 
     /**
diff --git a/src/Samsara/Fermat/Core/Provider/SequenceProvider.php b/src/Samsara/Fermat/Core/Provider/SequenceProvider.php
index 4acecfa5..09de45a5 100644
--- a/src/Samsara/Fermat/Core/Provider/SequenceProvider.php
+++ b/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))));
     }
 
 }
\ No newline at end of file
diff --git a/src/Samsara/Fermat/Core/Types/Decimal.php b/src/Samsara/Fermat/Core/Types/Decimal.php
index 1d40ed88..ac815bf5 100644
--- a/src/Samsara/Fermat/Core/Types/Decimal.php
+++ b/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;
diff --git a/src/Samsara/Fermat/Core/Types/Fraction.php b/src/Samsara/Fermat/Core/Types/Fraction.php
index af3321a1..c385a175 100644
--- a/src/Samsara/Fermat/Core/Types/Fraction.php
+++ b/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();
diff --git a/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticHelperSimpleTrait.php b/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticHelperSimpleTrait.php
index fc804523..25ce44a7 100644
--- a/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticHelperSimpleTrait.php
+++ b/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticHelperSimpleTrait.php
@@ -52,8 +52,8 @@ protected function helperAddSub(
             return $this->helperAddSubFraction($thisNum, $thatNum, $operation);
         } else {
             $value = match ($operation) {
-                CalcOperation::Addition => $thisNum->addSelector($thatNum),
-                CalcOperation::Subtraction => $thisNum->subtractSelector($thatNum),
+                CalcOperation::Addition => $this->addSelector($thatNum),
+                CalcOperation::Subtraction => $this->subtractSelector($thatNum),
                 /** @codeCoverageIgnore  */
                 default => throw new IncompatibleObjectState(
                     'Cannot use the AddSub helper with other operations',
@@ -135,6 +135,13 @@ protected function helperAddSubFraction(
         CalcOperation                      $operation
     ): ImmutableFraction|MutableFraction
     {
+        if ($this instanceof Decimal) {
+            throw new IncompatibleObjectState(
+                'Cannot call protected method helperAddSubFraction() from descendent of Decimal',
+                'Use a descendent of Fraction instead'
+            );
+        }
+
         if ($thatNum instanceof Fraction && $thisNum->getDenominator()->isEqual($thatNum->getDenominator())) {
             $finalDenominator = $thisNum->getDenominator();
             $finalNumerator = match ($operation) {
@@ -147,9 +154,9 @@ protected function helperAddSubFraction(
                 )
             };
         } elseif ($thatNum instanceof Fraction) {
-            $finalDenominator = $thisNum->getSmallestCommonDenominator($thatNum);
+            $finalDenominator = $this->getSmallestCommonDenominator($thatNum);
 
-            [$thisNumerator, $thatNumerator] = $thisNum->getNumeratorsWithSameDenominator($thatNum, $finalDenominator);
+            [$thisNumerator, $thatNumerator] = $this->getNumeratorsWithSameDenominator($thatNum, $finalDenominator);
 
             $finalNumerator = match ($operation) {
                 CalcOperation::Addition => $thisNumerator->add($thatNumerator),
@@ -227,7 +234,7 @@ protected function helperMulDiv(
     }
 
     /**
-     * @param ImmutableDecimal|ImmutableFraction|ImmutableComplexNumber $thisNum
+     * @param ImmutableFraction $thisNum
      * @param ImmutableDecimal|ImmutableFraction|ImmutableComplexNumber $thatNum
      * @param CalcOperation $operation
      * @param int $scale
@@ -236,12 +243,19 @@ protected function helperMulDiv(
      * @throws IntegrityConstraint
      */
     public function helperMulDivFraction(
-        ImmutableDecimal|ImmutableFraction|ImmutableComplexNumber $thisNum,
+        ImmutableFraction $thisNum,
         ImmutableDecimal|ImmutableFraction|ImmutableComplexNumber $thatNum,
         CalcOperation $operation,
         int $scale
     ): static|ImmutableComplexNumber
     {
+        if ($this instanceof Decimal) {
+            throw new IncompatibleObjectState(
+                'Cannot call protected method helperMulDivFraction() from descendent of Decimal',
+                'Use a descendent of Fraction instead'
+            );
+        }
+
         if ($thatNum instanceof ImmutableFraction) {
             $mulNumerator = match ($operation) {
                 CalcOperation::Multiplication => $thatNum->getNumerator(),
diff --git a/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticNativeTrait.php b/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticNativeTrait.php
index b7e46994..95beec94 100644
--- a/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticNativeTrait.php
+++ b/src/Samsara/Fermat/Core/Types/Traits/Arithmetic/ArithmeticNativeTrait.php
@@ -22,9 +22,9 @@ protected static function translateToNative(Decimal $num): int|float
 
     /**
      * @param Decimal $num
-     * @return int|float
+     * @return string
      */
-    protected function addNative(Decimal $num): int|float
+    protected function addNative(Decimal $num): string
     {
         $left = self::translateToNative($this);
         $right = self::translateToNative($num);
@@ -35,9 +35,9 @@ protected function addNative(Decimal $num): int|float
 
     /**
      * @param Decimal $num
-     * @return int|float
+     * @return string
      */
-    protected function subtractNative(Decimal $num): int|float
+    protected function subtractNative(Decimal $num): string
     {
         $left = self::translateToNative($this);
         $right = self::translateToNative($num);
@@ -48,9 +48,9 @@ protected function subtractNative(Decimal $num): int|float
 
     /**
      * @param Decimal $num
-     * @return int|float
+     * @return string
      */
-    protected function multiplyNative(Decimal $num): int|float
+    protected function multiplyNative(Decimal $num): string
     {
         $left = self::translateToNative($this);
         $right = self::translateToNative($num);
@@ -61,9 +61,9 @@ protected function multiplyNative(Decimal $num): int|float
 
     /**
      * @param Decimal $num
-     * @return int|float
+     * @return string
      */
-    protected function divideNative(Decimal $num): int|float
+    protected function divideNative(Decimal $num): string
     {
         $left = self::translateToNative($this);
         $right = self::translateToNative($num);
@@ -74,9 +74,9 @@ protected function divideNative(Decimal $num): int|float
 
     /**
      * @param Decimal $num
-     * @return int|float
+     * @return string
      */
-    protected function powNative(Decimal $num): int|float
+    protected function powNative(Decimal $num): string
     {
         $left = self::translateToNative($this);
         $right = self::translateToNative($num);
@@ -86,11 +86,13 @@ protected function powNative(Decimal $num): int|float
     }
 
     /**
-     * @return int|float
+     * @return string
      */
-    protected function sqrtNative(): int|float
+    protected function sqrtNative(): string
     {
-        $value = sqrt($this->abs()->asFloat());
+        $left = self::translateToNative($this);
+
+        $value = sqrt(abs($left));
         return (string)$value;
     }
 
diff --git a/src/Samsara/Fermat/Core/Types/Traits/ArithmeticSimpleTrait.php b/src/Samsara/Fermat/Core/Types/Traits/ArithmeticSimpleTrait.php
index a2227b73..c024612b 100644
--- a/src/Samsara/Fermat/Core/Types/Traits/ArithmeticSimpleTrait.php
+++ b/src/Samsara/Fermat/Core/Types/Traits/ArithmeticSimpleTrait.php
@@ -93,14 +93,14 @@ public function multiply(
     /**
      * @param string|int|float|Decimal|Fraction|ComplexNumber $num
      * @param int|null $scale
-     * @return static|ImmutableFraction|MutableFraction|ImmutableComplexNumber|MutableComplexNumber|ImmutableDecimal|MutableDecimal
+     * @return static|ImmutableFraction|ImmutableComplexNumber|ImmutableDecimal
      * @throws IntegrityConstraint
      * @throws IncompatibleObjectState
      */
     public function divide(
         string|int|float|Decimal|Fraction|ComplexNumber $num,
         ?int $scale = null
-    ): MutableDecimal|ImmutableDecimal|MutableComplexNumber|ImmutableComplexNumber|MutableFraction|ImmutableFraction|static
+    ): ImmutableDecimal|ImmutableComplexNumber|ImmutableFraction|static
     {
 
         $scale = $scale ?? $this->getScale();
@@ -172,7 +172,7 @@ public function pow(
 
             $originalScale = $this->getScale();
 
-            $value = $thisNum->powSelector($thatNum);
+            $value = $this->powSelector($thatNum);
 
             if ($this->isImaginary()) {
                 $value .= 'i';
diff --git a/src/Samsara/Fermat/Core/Types/Traits/Decimal/FormatterTrait.php b/src/Samsara/Fermat/Core/Types/Traits/Decimal/FormatterTrait.php
index a862261d..83a38b14 100644
--- a/src/Samsara/Fermat/Core/Types/Traits/Decimal/FormatterTrait.php
+++ b/src/Samsara/Fermat/Core/Types/Traits/Decimal/FormatterTrait.php
@@ -45,9 +45,9 @@ public static function createFromFormat(
 
     /**
      * @param NumberFormat $format
-     * @return Decimal
+     * @return static
      */
-    public function setFormat(NumberFormat $format): Decimal
+    public function setFormat(NumberFormat $format): static
     {
         $this->format = $format;
 
@@ -64,9 +64,9 @@ public function getGrouping(): NumberGrouping
 
     /**
      * @param NumberGrouping $grouping
-     * @return Decimal
+     * @return static
      */
-    public function setGrouping(NumberGrouping $grouping): Decimal
+    public function setGrouping(NumberGrouping $grouping): static
     {
         $this->grouping = $grouping;
 
diff --git a/src/Samsara/Fermat/Core/Types/Traits/Decimal/ScaleTrait.php b/src/Samsara/Fermat/Core/Types/Traits/Decimal/ScaleTrait.php
index 33a98e1b..69f6d08e 100644
--- a/src/Samsara/Fermat/Core/Types/Traits/Decimal/ScaleTrait.php
+++ b/src/Samsara/Fermat/Core/Types/Traits/Decimal/ScaleTrait.php
@@ -42,13 +42,13 @@ protected function setScale(int $scale): static
     /**
      * @param int $decimals
      * @param RoundingMode|null $mode
-     * @return ImmutableDecimal|MutableDecimal|static
+     * @return static
      * @throws IntegrityConstraint
      */
     public function round(
         int $decimals = 0,
         ?RoundingMode $mode = null
-    ): ImmutableDecimal|MutableDecimal|static
+    ): static
     {
         if ($this->getValue(NumberBase::Ten) == Number::INFINITY || $this->getValue(NumberBase::Ten) == Number::NEG_INFINITY) {
             return $this;
@@ -68,12 +68,12 @@ public function round(
 
     /**
      * @param int $decimals
-     * @return ImmutableDecimal|MutableDecimal|static
+     * @return static
      * @throws IntegrityConstraint
      */
     public function truncate(
         int $decimals = 0
-    ): ImmutableDecimal|MutableDecimal|static
+    ): static
     {
         if ($this->getValue(NumberBase::Ten) == Number::INFINITY || $this->getValue(NumberBase::Ten) == Number::NEG_INFINITY) {
             return $this;
@@ -112,42 +112,42 @@ public function truncate(
     /**
      * @param int $scale
      * @param RoundingMode|null $mode
-     * @return ImmutableDecimal|MutableDecimal|static
+     * @return static
      */
     public function roundToScale(
         int $scale,
         ?RoundingMode $mode = null
-    ): ImmutableDecimal|MutableDecimal|static
+    ): static
     {
         return $this->round($scale, $mode)->setScale($scale);
     }
 
     /**
      * @param int $scale
-     * @return ImmutableDecimal|MutableDecimal|static
+     * @return static
      * @throws IntegrityConstraint
      */
     public function truncateToScale(
         int $scale
-    ): ImmutableDecimal|MutableDecimal|static
+    ): static
     {
         return $this->truncate($scale)->setScale($scale);
     }
 
     /**
-     * @return ImmutableDecimal|MutableDecimal|static
+     * @return static
      * @throws IntegrityConstraint
      */
-    public function ceil(): ImmutableDecimal|MutableDecimal|static
+    public function ceil(): static
     {
         return $this->round(0, RoundingMode::Ceil);
     }
 
     /**
-     * @return ImmutableDecimal|MutableDecimal|static
+     * @return static
      * @throws IntegrityConstraint
      */
-    public function floor(): ImmutableDecimal|MutableDecimal|static
+    public function floor(): static
     {
         return $this->round(0, RoundingMode::Floor);
     }
diff --git a/src/Samsara/Fermat/Core/Types/Traits/InputNormalizationTrait.php b/src/Samsara/Fermat/Core/Types/Traits/InputNormalizationTrait.php
index 7e7e390a..75ff1f14 100644
--- a/src/Samsara/Fermat/Core/Types/Traits/InputNormalizationTrait.php
+++ b/src/Samsara/Fermat/Core/Types/Traits/InputNormalizationTrait.php
@@ -111,9 +111,9 @@ protected static function stringSelector(string $input, ?CalcMode $mode): Immuta
         if (str_contains($input, '/')) {
             $input = Numbers::makeFractionFromString(Numbers::IMMUTABLE_FRACTION, $input)->setMode($mode);
         } elseif (strrpos($input, '+') || strrpos($input, '-')) {
-            $input = ComplexNumbers::make(ComplexNumbers::IMMUTABLE_COMPLEX, $input)->setMode($mode);
+            $input = ImmutableComplexNumber::makeFromString(ComplexNumbers::IMMUTABLE_COMPLEX, $input)->setMode($mode);
         } else {
-            $input = Numbers::make(Numbers::IMMUTABLE, $input)->setMode($mode);
+            $input = (new ImmutableDecimal($input))->setMode($mode);
         }
 
         return $input;
diff --git a/src/Samsara/Fermat/Core/Types/Tuple.php b/src/Samsara/Fermat/Core/Types/Tuple.php
index c77760da..55bdf39b 100644
--- a/src/Samsara/Fermat/Core/Types/Tuple.php
+++ b/src/Samsara/Fermat/Core/Types/Tuple.php
@@ -33,7 +33,9 @@ public function __construct(...$data)
         if (is_array($data[0])) {
             $data = $data[0];
         }
-        $this->data = Numbers::makeOrDont(Numbers::IMMUTABLE, $data);
+        /** @var ImmutableDecimal[] $data */
+        $data = Numbers::makeOrDont(Numbers::IMMUTABLE, $data);
+        $this->data = $data;
         $this->size = count($this->data);
     }
 
@@ -79,7 +81,7 @@ public function set(int $index, ImmutableDecimal $value): self
     }
 
     /**
-     * @return array|ImmutableDecimal
+     * @return ImmutableDecimal[]
      */
     public function all(): array
     {
diff --git a/src/Samsara/Fermat/Core/Values/ImmutableDecimal.php b/src/Samsara/Fermat/Core/Values/ImmutableDecimal.php
index 828dbfdd..cce9fc9e 100644
--- a/src/Samsara/Fermat/Core/Values/ImmutableDecimal.php
+++ b/src/Samsara/Fermat/Core/Values/ImmutableDecimal.php
@@ -24,12 +24,13 @@ class ImmutableDecimal extends Decimal
     public function continuousModulo(Decimal|string|int|float $mod): static
     {
 
+        /** @var ImmutableDecimal $mod */
         $mod = Numbers::makeOrDont(Numbers::IMMUTABLE, $mod);
 
         $scale = ($this->getScale() < $mod->getScale()) ? $mod->getScale() : $this->getScale();
 
         $newScale = $scale+2;
-        $thisNum = Numbers::make(Numbers::IMMUTABLE, $this->getValue(NumberBase::Ten), $newScale);
+        $thisNum = new ImmutableDecimal($this->getValue(NumberBase::Ten), $newScale);
 
         $mod = $mod->truncateToScale($newScale);
 
@@ -45,6 +46,7 @@ public function continuousModulo(Decimal|string|int|float $mod): static
 
         $subtract = $mod->multiply($multiple);
 
+        /** @var static $remainder */
         $remainder = $thisNum->subtract($subtract);
 
         return $remainder->truncateToScale($this->getScale()-1);
diff --git a/src/Samsara/Fermat/Core/Values/ImmutableFraction.php b/src/Samsara/Fermat/Core/Values/ImmutableFraction.php
index d3d13940..8a318fdc 100644
--- a/src/Samsara/Fermat/Core/Values/ImmutableFraction.php
+++ b/src/Samsara/Fermat/Core/Values/ImmutableFraction.php
@@ -20,7 +20,7 @@ class ImmutableFraction extends Fraction
     protected function setValue(ImmutableDecimal $numerator, ImmutableDecimal $denominator): static
     {
 
-        return new ImmutableFraction($numerator, $denominator, $this->base);
+        return new static($numerator, $denominator, $this->base);
 
     }
 
diff --git a/src/Samsara/Fermat/Core/Values/MutableDecimal.php b/src/Samsara/Fermat/Core/Values/MutableDecimal.php
index 6a007d0e..0a24a86f 100644
--- a/src/Samsara/Fermat/Core/Values/MutableDecimal.php
+++ b/src/Samsara/Fermat/Core/Values/MutableDecimal.php
@@ -2,6 +2,7 @@
 
 namespace Samsara\Fermat\Core\Values;
 
+use Samsara\Exceptions\SystemError\LogicalError\IncompatibleObjectState;
 use Samsara\Exceptions\SystemError\PlatformError\MissingPackage;
 use Samsara\Exceptions\UsageError\IntegrityConstraint;
 use Samsara\Fermat\Core\Enums\NumberBase;
@@ -16,8 +17,11 @@ class MutableDecimal extends Decimal
 {
 
     /**
+     * @param Decimal|string|int|float $mod
+     * @return static
      * @throws IntegrityConstraint
      * @throws MissingPackage
+     * @throws IncompatibleObjectState
      */
     public function continuousModulo(Decimal|string|int|float $mod): static
     {
@@ -37,7 +41,7 @@ public function continuousModulo(Decimal|string|int|float $mod): static
 
         $remainder = $oldNum->subtract($mod->multiply($multiple));
 
-        return Numbers::make(Numbers::MUTABLE, $remainder->truncate($this->scale-1)->getValue(NumberBase::Ten), $this->scale-1, $this->getBase());
+        return new static($remainder->truncate($this->scale-1)->getValue(NumberBase::Ten), $this->scale-1, $this->getBase());
 
     }
 
diff --git a/src/Samsara/Fermat/LinearAlgebra/Types/Matrix.php b/src/Samsara/Fermat/LinearAlgebra/Types/Matrix.php
index 27b46382..8cb43cdc 100644
--- a/src/Samsara/Fermat/LinearAlgebra/Types/Matrix.php
+++ b/src/Samsara/Fermat/LinearAlgebra/Types/Matrix.php
@@ -84,7 +84,6 @@ public function getDeterminant(): ImmutableDecimal
                 $determinant = $determinant->add($value->multiply($childMatrix->getDeterminant())->multiply(SequenceProvider::nthPowerNegativeOne($key)));
             }
         } else {
-            /** @var ImmutableDecimal $value */
             $determinant = $this->rows[0]->get(0)->multiply($this->rows[1]->get(1))->subtract($this->rows[1]->get(0)->multiply($this->rows[0]->get(1)));
         }
 
diff --git a/src/Samsara/Fermat/Stats/Provider/StatsProvider.php b/src/Samsara/Fermat/Stats/Provider/StatsProvider.php
index be4ca057..0f100fde 100644
--- a/src/Samsara/Fermat/Stats/Provider/StatsProvider.php
+++ b/src/Samsara/Fermat/Stats/Provider/StatsProvider.php
@@ -48,7 +48,7 @@ public static function normalCDF($x): ImmutableDecimal
         $eExponent = Numbers::make(Numbers::IMMUTABLE, $x->getValue());
         $eExponent = $eExponent->pow(2)->divide(2)->multiply(-1);
 
-        $answer = Numbers::make(Numbers::IMMUTABLE, 0.5);
+        $answer = new ImmutableDecimal(0.5);
         $answer = $answer->add(
             $one->divide($pi->multiply(2)->sqrt())
                 ->multiply($e->pow($eExponent))
@@ -169,7 +169,9 @@ public static function inverseNormalCDF($p, ?int $scale = null): ImmutableDecima
     public static function binomialCoefficient($n, $k): ImmutableDecimal
     {
 
+        /** @var ImmutableDecimal $n */
         $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);
+        /** @var ImmutableDecimal $k */
         $k = Numbers::makeOrDont(Numbers::IMMUTABLE, $k);
 
         if ($k->isLessThan(0) || $n->isLessThan($k)) {
@@ -188,7 +190,10 @@ public static function binomialCoefficient($n, $k): ImmutableDecimal
             );
         }
 
-        return $n->factorial()->divide($k->factorial()->multiply($n->subtract($k)->factorial()));
+        /** @var ImmutableDecimal $return */
+        $return = $n->factorial()->divide($k->factorial()->multiply($n->subtract($k)->factorial()));
+
+        return $return;
 
     }
 
diff --git a/src/Samsara/Fermat/Stats/Values/Distribution/Exponential.php b/src/Samsara/Fermat/Stats/Values/Distribution/Exponential.php
index 66f820f7..4a2867b2 100644
--- a/src/Samsara/Fermat/Stats/Values/Distribution/Exponential.php
+++ b/src/Samsara/Fermat/Stats/Values/Distribution/Exponential.php
@@ -2,6 +2,8 @@
 
 namespace Samsara\Fermat\Stats\Values\Distribution;
 
+use Samsara\Exceptions\SystemError\LogicalError\IncompatibleObjectState;
+use Samsara\Exceptions\SystemError\PlatformError\MissingPackage;
 use Samsara\Exceptions\UsageError\IntegrityConstraint;
 use Samsara\Exceptions\UsageError\OptionalExit;
 use Samsara\Fermat\Core\Numbers;
@@ -16,20 +18,18 @@
 class Exponential extends Distribution
 {
 
-    /**
-     * @var ImmutableDecimal
-     */
-    private $lambda;
+    private ImmutableDecimal $lambda;
 
     /**
      * Exponential constructor.
      *
-     * @param int|float|Decimal $lambda This is the *rate parameter* not the *scale parameter*
+     * @param int|float|string|Decimal $lambda This is the *rate parameter* not the *scale parameter*
      *
      * @throws IntegrityConstraint
      */
-    public function __construct($lambda)
+    public function __construct(int|float|string|Decimal $lambda)
     {
+        /** @var ImmutableDecimal $lambda */
         $lambda = Numbers::makeOrDont(Numbers::IMMUTABLE, $lambda);
 
         if (!$lambda->isPositive()) {
@@ -45,9 +45,11 @@ public function __construct($lambda)
 
     /**
      * @param float|int|Decimal $x
-     *
+     * @param int $scale
      * @return ImmutableDecimal
+     * @throws IncompatibleObjectState
      * @throws IntegrityConstraint
+     * @throws MissingPackage
      */
     public function cdf(float|int|Decimal $x, int $scale = 10): ImmutableDecimal
     {
@@ -82,9 +84,10 @@ public function cdf(float|int|Decimal $x, int $scale = 10): ImmutableDecimal
 
     /**
      * @param $x
-     *
+     * @param int $scale
      * @return ImmutableDecimal
      * @throws IntegrityConstraint
+     * @throws IncompatibleObjectState
      */
     public function pdf($x, int $scale = 10): ImmutableDecimal
     {
@@ -121,9 +124,10 @@ public function pdf($x, int $scale = 10): ImmutableDecimal
     /**
      * @param $x1
      * @param $x2
-     *
+     * @param int $scale
      * @return ImmutableDecimal
      * @throws IntegrityConstraint
+     * @throws MissingPackage
      */
     public function rangePdf($x1, $x2, int $scale = 10): ImmutableDecimal
     {
diff --git a/src/Samsara/Fermat/Stats/Values/Distribution/Poisson.php b/src/Samsara/Fermat/Stats/Values/Distribution/Poisson.php
index 109aa5fa..eb74075a 100644
--- a/src/Samsara/Fermat/Stats/Values/Distribution/Poisson.php
+++ b/src/Samsara/Fermat/Stats/Values/Distribution/Poisson.php
@@ -3,6 +3,7 @@
 namespace Samsara\Fermat\Stats\Values\Distribution;
 
 use Samsara\Exceptions\SystemError\LogicalError\IncompatibleObjectState;
+use Samsara\Exceptions\SystemError\PlatformError\MissingPackage;
 use Samsara\Exceptions\UsageError\IntegrityConstraint;
 use Samsara\Exceptions\UsageError\OptionalExit;
 use Samsara\Fermat\Core\Enums\RandomMode;
@@ -18,20 +19,18 @@
 class Poisson extends Distribution
 {
 
-    /**
-     * @var ImmutableDecimal
-     */
-    private $lambda;
+    private ImmutableDecimal $lambda;
 
     /**
      * Poisson constructor.
      *
-     * @param int|float|Decimal $lambda
+     * @param int|float|string|Decimal $lambda
      *
      * @throws IntegrityConstraint
      */
-    public function __construct($lambda)
+    public function __construct(int|float|string|Decimal $lambda)
     {
+        /** @var ImmutableDecimal $lambda */
         $lambda = Numbers::makeOrDont(Numbers::IMMUTABLE, $lambda);
 
         if (!$lambda->isPositive()) {
@@ -47,10 +46,10 @@ public function __construct($lambda)
 
     /**
      * @param int|float|Decimal $k
-     *
+     * @param int $scale
      * @return ImmutableDecimal
-     * @throws IntegrityConstraint
      * @throws IncompatibleObjectState
+     * @throws IntegrityConstraint
      */
     public function probabilityOfKEvents($k, int $scale = 10): ImmutableDecimal
     {
@@ -61,10 +60,11 @@ public function probabilityOfKEvents($k, int $scale = 10): ImmutableDecimal
 
     /**
      * @param int|float|Decimal $x
-     *
+     * @param int $scale
      * @return ImmutableDecimal
-     * @throws IntegrityConstraint
      * @throws IncompatibleObjectState
+     * @throws IntegrityConstraint
+     * @throws MissingPackage
      */
     public function cdf(int|float|Decimal $x, int $scale = 10): ImmutableDecimal
     {
@@ -99,10 +99,10 @@ public function cdf(int|float|Decimal $x, int $scale = 10): ImmutableDecimal
 
     /**
      * @param float|int|Decimal $x
-     *
+     * @param int $scale
      * @return ImmutableDecimal
-     * @throws IntegrityConstraint
      * @throws IncompatibleObjectState
+     * @throws IntegrityConstraint
      */
     public function pmf(float|int|Decimal $x, int $scale = 10): ImmutableDecimal
     {