Samsara\Fermat\Provider\ConstantProvider

Complexity

Total Complexity

22

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Test Coverage

Coverage

95.06%

Importance

Changes	1
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	makeE()	0	31	6
A	makeLn10()	0	13	3
A	_makeLnSpecial()	0	19	2
A	makeLn1p1()	0	16	3
A	makeLn2()	0	14	3
A	makePi()	0	41	5

<?php


namespace Samsara\Fermat\Provider;


use Samsara\Exceptions\SystemError\PlatformError\MissingPackage;
use Samsara\Exceptions\UsageError\IntegrityConstraint;
use Samsara\Fermat\Enums\CalcMode;
use Samsara\Fermat\Enums\NumberBase;
use Samsara\Fermat\Numbers;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface;
use Samsara\Fermat\Values\ImmutableDecimal;

/**
 *
 */
class ConstantProvider
{

    private static DecimalInterface $pi;
    private static DecimalInterface $e;
    private static DecimalInterface $ln10;
    private static DecimalInterface $ln2;
    private static DecimalInterface $ln1p1;

    /**
     * @param int $digits
     * @return string
     * @throws IntegrityConstraint
     * @throws MissingPackage
     */
    public static function makePi(int $digits): string
    {

        if (isset(self::$pi) && self::$pi->numberOfDecimalDigits() >= $digits) {
            return self::$pi->truncateToScale($digits)->getValue(NumberBase::Ten);

The call to Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface::getValue() has too many arguments starting with Samsara\Fermat\Enums\NumberBase::Ten.

        }

        $internalScale = ($digits*2) + 10;

        $C = Numbers::make(Numbers::IMMUTABLE, '10005', $internalScale)->setMode(CalcMode::Precision)->sqrt($internalScale)->multiply(426880);
        $M = Numbers::make(Numbers::IMMUTABLE, '1', $internalScale)->setMode(CalcMode::Precision);
        $L = Numbers::make(Numbers::IMMUTABLE, '13591409', $internalScale)->setMode(CalcMode::Precision);
        $K = Numbers::make(Numbers::IMMUTABLE, '6', $internalScale)->setMode(CalcMode::Precision);
        $X = Numbers::make(Numbers::IMMUTABLE, '1')->setMode(CalcMode::Precision);
        $sum = Numbers::make(Numbers::MUTABLE,'0', $internalScale + 2)->setMode(CalcMode::Precision);
        $termNum = 0;
        $one = Numbers::makeOne($internalScale)->setMode(CalcMode::Precision);

        $continue = true;

        while ($continue) {
            $term = $M->multiply($L)->divide($X, $internalScale);

            if ($termNum > $internalScale) {
                $continue = false;
            }

            $sum->add($term);

            $M = $M->multiply($K->pow(3)->subtract($K->multiply(16))->divide($one->add($termNum)->pow(3), $internalScale));
            $L = $L->add(545140134);
            $X = $X->multiply('-262537412640768000');
            $K = $K->add(12);
            $termNum++;
        }

        $pi = $C->divide($sum, $internalScale);

        self::$pi = $pi->truncateToScale($digits);

        return $pi->truncateToScale($digits)->getValue(NumberBase::Ten);

    }

    /**
     * Consider also: sum [0 -> INF] { (2n + 2) / (2n + 1)! }
     *
     * This converges faster (though it's unclear if the calculation is actually faster), and can be represented by this
     * set of Fermat calls:
     *
     * SequenceProvider::nthEvenNumber($n + 1)->divide(SequenceProvider::nthOddNumber($n)->factorial());
     *
     * Perhaps by substituting the nthOddNumber()->factorial() call with something tracked locally, the performance can
     * be improved. Current performance is acceptable even out past 200 digits.
     *
     * @param int $digits
     * @return string
     * @throws IntegrityConstraint
     */
    public static function makeE(int $digits): string
    {

        if (isset(self::$e) && self::$e->numberOfDecimalDigits() >= $digits) {
            return self::$e->truncateToScale($digits)->getValue(NumberBase::Ten);

The call to Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface::getValue() has too many arguments starting with Samsara\Fermat\Enums\NumberBase::Ten.

        }

        $internalScale = $digits + 3;

        $one = Numbers::makeOne($internalScale+5)->setMode(CalcMode::Precision);
        $denominator = Numbers::make(Numbers::MUTABLE, '1', $internalScale)->setMode(CalcMode::Precision);
        $e = Numbers::make(NUmbers::MUTABLE, '2', $internalScale)->setMode(CalcMode::Precision);
        $n = Numbers::make(Numbers::MUTABLE, '2', $internalScale)->setMode(CalcMode::Precision);

        $continue = true;

        while ($continue) {
            $denominator->multiply($n);
            $n->add($one);
            $term = $one->divide($denominator);

            if ($term->numberOfLeadingZeros() > $internalScale || $term->isEqual(0)) {

The method numberOfLeadingZeros() does not exist on Samsara\Fermat\Types\Fraction.

                $continue = false;
            }

            $e->add($term);
        }

        self::$e = $e->truncateToScale($digits);

The method truncateToScale() does not exist on Samsara\Fermat\Values\MutableFraction.

The method truncateToScale() does not exist on Samsara\Fermat\Values\ImmutableFraction.

        return $e->truncateToScale($digits)->getValue(NumberBase::Ten);

    }

    /**
     * The lnScale() implementation is very efficient, so this is probably our best bet for computing more digits of
     * ln(10) to provide.
     *
     * @param int $digits
     * @return string
     * @throws IntegrityConstraint
     */
    public static function makeLn10(int $digits): string
    {

        if (isset(self::$ln10) && self::$ln10->numberOfDecimalDigits() >= $digits) {
            return self::$ln10->truncateToScale($digits)->getValue(NumberBase::Ten);

The call to Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface::getValue() has too many arguments starting with Samsara\Fermat\Enums\NumberBase::Ten.

        }

        $ln10 = Numbers::make(Numbers::IMMUTABLE, 10, $digits+2)->setMode(CalcMode::Precision);
        $ln10 = $ln10->ln();

The method ln() does not exist on Samsara\Fermat\Values\ImmutableFraction.

The method ln() does not exist on Samsara\Fermat\Values\MutableFraction.

        self::$ln10 = $ln10;

        return $ln10->truncateToScale($digits)->getValue(NumberBase::Ten);

    }

    /**
     * This function is a special case of the ln() function where x can be represented by (n + 1)/n, where n is an
     * integer. This particular special case converges extremely rapidly. For ln(2), n = 1.
     *
     * @param int $digits
     * @return string
     */
    public static function makeLn2(int $digits): string
    {

        if (isset(self::$ln2) && self::$ln2->numberOfDecimalDigits() >= $digits) {
            return self::$ln2->truncateToScale($digits)->getValue(NumberBase::Ten);

The call to Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface::getValue() has too many arguments starting with Samsara\Fermat\Enums\NumberBase::Ten.

        }

        $twoThirds = Numbers::make(Numbers::IMMUTABLE, str_pad('0.', $digits+3, '6'));
        $nine = Numbers::make(Numbers::IMMUTABLE, 9, $digits+3);
        $ln2 = self::_makeLnSpecial($digits, $nine, $twoThirds);

It seems like $twoThirds can also be of type Samsara\Fermat\Values\ImmutableFraction and Samsara\Fermat\Values\MutableDecimal and Samsara\Fermat\Values\MutableFraction; however, parameter $outerNum of Samsara\Fermat\Provider\ConstantProvider::_makeLnSpecial() does only seem to accept Samsara\Fermat\Values\ImmutableDecimal, maybe add an additional type check?

It seems like $nine can also be of type Samsara\Fermat\Values\ImmutableFraction and Samsara\Fermat\Values\MutableDecimal and Samsara\Fermat\Values\MutableFraction; however, parameter $innerNum of Samsara\Fermat\Provider\ConstantProvider::_makeLnSpecial() does only seem to accept Samsara\Fermat\Values\ImmutableDecimal, maybe add an additional type check?

        self::$ln2 = $ln2;

        return $ln2->getValue(NumberBase::Ten);

    }

    /**
     * This function is a special case of the ln() function where x can be represented by (n + 1)/n, where n is an
     * integer. This particular special case converges extremely rapidly. For ln(1.1), n = 10.
     *
     * @param int $digits
     * @return string
     */
    public static function makeLn1p1(int $digits): string
    {

        if (isset(self::$ln1p1) && self::$ln1p1->numberOfDecimalDigits() >= $digits) {
            return self::$ln1p1->truncateToScale($digits)->getValue(NumberBase::Ten);

The call to Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface::getValue() has too many arguments starting with Samsara\Fermat\Enums\NumberBase::Ten.

        }

        $two = Numbers::make(Numbers::IMMUTABLE, 2, $digits+3);
        $twentyOne = Numbers::make(Numbers::IMMUTABLE, 21, $digits+3);
        $fourFortyOne = Numbers::make(Numbers::IMMUTABLE, 441, $digits+3);
        $twoDivTwentyOne = $two->divide($twentyOne);
        $ln1p1 = self::_makeLnSpecial($digits, $fourFortyOne, $twoDivTwentyOne);

It seems like $fourFortyOne can also be of type Samsara\Fermat\Values\ImmutableFraction and Samsara\Fermat\Values\MutableDecimal and Samsara\Fermat\Values\MutableFraction; however, parameter $innerNum of Samsara\Fermat\Provider\ConstantProvider::_makeLnSpecial() does only seem to accept Samsara\Fermat\Values\ImmutableDecimal, maybe add an additional type check?

It seems like $twoDivTwentyOne can also be of type Samsara\Fermat\Types\Fraction and Samsara\Fermat\Values\ImmutableFraction and Samsara\Fermat\Values\MutableDecimal and Samsara\Fermat\Values\MutableFraction; however, parameter $outerNum of Samsara\Fermat\Provider\ConstantProvider::_makeLnSpecial() does only seem to accept Samsara\Fermat\Values\ImmutableDecimal, maybe add an additional type check?

        self::$ln1p1 = $ln1p1;

        return $ln1p1->getValue(NumberBase::Ten);

    }

    /**
     * @param int $digits
     * @param ImmutableDecimal $innerNum
     * @param ImmutableDecimal $outerNum
     * @return ImmutableDecimal
     */
    private static function _makeLnSpecial(int $digits, ImmutableDecimal $innerNum, ImmutableDecimal $outerNum): ImmutableDecimal
    {
        $one = Numbers::makeOne($digits+3);
        $two = Numbers::make(Numbers::IMMUTABLE, 2, $digits+3);
        $sum = Numbers::makeZero($digits+3);
        $k = 0;

        do {

            $diff = $one->divide($one->add($two->multiply($k))->multiply($innerNum->pow($k)), $digits+3)->truncate($digits+2);

The method truncate() does not exist on Samsara\Fermat\Types\Fraction.

            $sum = $sum->add($diff);

            $k++;

        } while (!$diff->isEqual(0));

        $lnSpecial = $outerNum->multiply($sum);
        return $lnSpecial->truncateToScale($digits);
    }

}