Samsara\Fermat\Core\Provider\SeriesProvider::maclaurinSeries()

Complexity

Conditions	10
Paths	37

Size

Total Lines	81
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	36
CRAP Score	10.1815

Importance

Changes

0

<?php
    public static function maclaurinSeries(
        SimpleNumberInterface $input, // x value in series
        callable $numerator, // a function determining what the sign (+/-) is at the nth term
        callable $exponent, // a function determining the exponent of x at the nth term
        callable $denominator, // a function determining the denominator at the nth term
        int $startTermAt = 0,
        int $scale = 10,
        int $consecutiveDivergeLimit = 5,
        int $totalDivergeLimit = 10): ImmutableDecimal
    {

        ++$scale;

        $sum = Numbers::makeZero($scale);
        $value = Numbers::make(Numbers::IMMUTABLE, $input->getValue(NumberBase::Ten), $scale);

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

        $continue = true;
        $termNumber = $startTermAt;

        $adjustmentOfZero = 0;
        $prevDiff = Numbers::makeZero($scale);
        $prevSum = $sum;
        $divergeCount = -1;
        $persistentDivergeCount = -1;
        $currentScale = 0;

        while ($continue) {
            $term = Numbers::makeOne($scale);

            try {
                $exTerm = $value->pow($exponent($termNumber));
                $term = $term->multiply($exTerm);
                $term = $term->divide($denominator($termNumber), $scale);
                $term = $term->multiply($numerator($termNumber));
            } catch (IntegrityConstraint $constraint) {
                return $sum->truncateToScale($currentScale+1);
            }

            /** @var ImmutableDecimal $term */
            if ($term->numberOfLeadingZeros() >= $scale && !$term->isWhole()) {
                $continue = false;
            }

            $currentScale = $term->numberOfLeadingZeros();

            if ($term->isEqual(0)) {
                $adjustmentOfZero++;
            } else {
                $adjustmentOfZero = 0;
            }

            if ($adjustmentOfZero > 15) {
                $continue = false;
            }

            /** @var ImmutableDecimal $sum */
            $sum = $sum->add($term);
            $currDiff = $sum->subtract($prevSum)->abs();

            if ($prevDiff->isLessThan($currDiff)) {
                $divergeCount++;
                $persistentDivergeCount++;
            } else {
                $divergeCount = 0;
            }

            if ($divergeCount === $consecutiveDivergeLimit || $persistentDivergeCount === $totalDivergeLimit) {
                throw new OptionalExit(
                    'Series appear to be diverging. Current diverge count: '.$divergeCount.' | Persistent diverge count: '.$persistentDivergeCount,
                    'A call was made to SeriesProvider::maclaurinSeries() that seems to be diverging. Exiting the loop.',
                    'The series being calculated appears to be diverging, and the process has been stopped in an attempt to avoid an infinite loop.'
                );
            }

            $prevDiff = $currDiff;
            $prevSum = $sum;

            $termNumber++;
        }

        return $sum->roundToScale($scale);

}