Samsara\Fermat\Provider\StatsProvider

Complexity

Total Complexity

17

Size/Duplication

Total Lines	252
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	gaussErrorFunction()	0	35	1
A	complementNormalCDF()	0	6	1
A	inverseGaussErrorFunction()	0	38	3
A	binomialCoefficient()	0	23	5
A	inverseErrorCoefficients()	0	34	5
A	normalCDF()	0	35	1
A	inverseNormalCDF()	0	11	1

<?php

namespace Samsara\Fermat\Provider;

use Ds\Vector;
use Samsara\Exceptions\UsageError\IntegrityConstraint;
use Samsara\Exceptions\SystemError\LogicalError\IncompatibleObjectState;
use Samsara\Exceptions\UsageError\OptionalExit;
use Samsara\Fermat\Numbers;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\FractionInterface;
use Samsara\Fermat\Values\ImmutableDecimal;
use Samsara\Fermat\Values\ImmutableFraction;

class StatsProvider
{

    /**
     * @var Vector
     */
    protected static $inverseErrorCoefs;

    /**
     * @param $x
     *
     * @return NumberInterface
     * @throws IntegrityConstraint
     * @throws OptionalExit|\ReflectionException
     */
    public static function normalCDF($x): ImmutableDecimal
    {
        $x = Numbers::makeOrDont(Numbers::IMMUTABLE, $x);

        $precision = $x->getPrecision();
        $internalPrecision = $precision+2;

        $pi = Numbers::makePi($internalPrecision);
        $e = Numbers::makeE($internalPrecision);
        $one = Numbers::makeOne($internalPrecision);

        $eExponent = Numbers::make(Numbers::IMMUTABLE, $x->getValue());

The method getValue() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface.

        $eExponent = $eExponent->pow(2)->divide(2)->multiply(-1);

        $answer = Numbers::make(Numbers::IMMUTABLE, 0.5);
        $answer = $answer->add(
            $one->divide($pi->multiply(2)->sqrt())
                ->multiply($e->pow($eExponent))
                ->multiply(SeriesProvider::maclaurinSeries(
                    $x,

It seems like $x can also be of type Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface[] and Samsara\Fermat\Values\ImmutableDecimal[] and Samsara\Fermat\Values\MutableDecimal[]; however, parameter $input of Samsara\Fermat\Provider\SeriesProvider::maclaurinSeries() does only seem to accept Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface, maybe add an additional type check?

                    function ($n) {

The parameter $n is not used and could be removed.

                        return Numbers::makeOne();
                    },
                    function ($n) {
                        return SequenceProvider::nthOddNumber($n);
                    },
                    function ($n) {
                        return SequenceProvider::nthOddNumber($n)->doubleFactorial();

The method doubleFactorial() does not exist on Samsara\Fermat\Types\NumberCollection.

The method doubleFactorial() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. It seems like you code against a sub-type of Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface such as Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface or Samsara\Fermat\Types\Decimal.

                    },
                    0,
                    $internalPrecision
                ))
        );

        return $answer->truncateToPrecision($precision);

The method truncateToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\FractionInterface.

The method truncateToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. It seems like you code against a sub-type of Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface such as Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface or Samsara\Fermat\Types\Decimal.

The method truncateToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\ComplexNumberInterface.

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

The method truncateToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Coordinates\CoordinateInterface.

The method truncateToPrecision() does not exist on Samsara\Fermat\Values\Geometry\CoordinateSystems\CartesianCoordinate.

The expression return $answer->truncateToPrecision($precision) could return the type Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface which includes types incompatible with the type-hinted return Samsara\Fermat\Values\ImmutableDecimal. Consider adding an additional type-check to rule them out.

The method truncateToPrecision() does not exist on Samsara\Fermat\Values\ImmutableComplexNumber.

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

The method truncateToPrecision() does not exist on Samsara\Fermat\Values\MutableComplexNumber.

    }

    /**
     * @param $x
     *
     * @return DecimalInterface|NumberInterface
     * @throws IntegrityConstraint
     * @throws OptionalExit
     */
    public static function complementNormalCDF($x): ImmutableDecimal
    {
        $p = self::normalCDF($x);
        $one = Numbers::makeOne();

        return $one->subtract($p);

The expression return $one->subtract($p) could return the type Samsara\Fermat\Values\ImmutableComplexNumber which is incompatible with the type-hinted return Samsara\Fermat\Values\ImmutableDecimal. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param $x
     *
     * @return DecimalInterface|FractionInterface|NumberInterface|ImmutableDecimal
     * @throws IntegrityConstraint
     * @throws OptionalExit
     */
    public static function gaussErrorFunction($x): ImmutableDecimal
    {

        $x = Numbers::makeOrDont(Numbers::IMMUTABLE, $x);

        $precision = $x->getPrecision();
        $internalPrecision = $precision + 2;

        $answer = Numbers::makeOne($internalPrecision);
        $pi = Numbers::makePi($internalPrecision);

        $answer = $answer->multiply(2)->divide($pi->sqrt());

        $answer = $answer->multiply(
            SeriesProvider::maclaurinSeries(
                $x,

It seems like $x can also be of type Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface[] and Samsara\Fermat\Values\ImmutableDecimal[] and Samsara\Fermat\Values\MutableDecimal[]; however, parameter $input of Samsara\Fermat\Provider\SeriesProvider::maclaurinSeries() does only seem to accept Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface, maybe add an additional type check?

                function ($n) {
                    $negOne = Numbers::make(Numbers::IMMUTABLE, -1);

                    return $negOne->pow($n);
                },
                function ($n) {
                    return SequenceProvider::nthOddNumber($n);
                },
                function ($n) {
                    $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);

                    return $n->factorial()->multiply(SequenceProvider::nthOddNumber($n->asInt()));

The method asInt() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. It seems like you code against a sub-type of Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface such as Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface or Samsara\Fermat\Types\Decimal.

The method factorial() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. It seems like you code against a sub-type of Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface such as Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface or Samsara\Fermat\Types\Decimal.

                },
                0,
                $internalPrecision
            )
        );

        return $answer->truncateToPrecision($precision);

    }

    /**
     * @param     $p
     * @param int $precision
     *
     * @return DecimalInterface|NumberInterface|ImmutableDecimal
     * @throws IntegrityConstraint
     * @throws OptionalExit
     */
    public static function inverseNormalCDF($p, int $precision = 10): ImmutableDecimal
    {
        $p = Numbers::makeOrDont(Numbers::IMMUTABLE, $p);

        $precision = $precision ?? $p->getPrecision();
        $internalPrecision = $precision + 2;

        $two = Numbers::make(Numbers::IMMUTABLE, 2, $internalPrecision);
        $invErfArg = $two->multiply($p)->subtract(1);

        return StatsProvider::inverseGaussErrorFunction($invErfArg, $internalPrecision)->multiply($two->sqrt($internalPrecision))->roundToPrecision($precision);

The method roundToPrecision() does not exist on Samsara\Fermat\Values\ImmutableComplexNumber.

The method roundToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Coordinates\CoordinateInterface.

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

The method roundToPrecision() does not exist on Samsara\Fermat\Values\Geometry\CoordinateSystems\CartesianCoordinate.

The method roundToPrecision() does not exist on Samsara\Fermat\Values\MutableComplexNumber.

The method roundToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\FractionInterface.

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

The method roundToPrecision() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\ComplexNumberInterface.

    }

    /**
     * @param $n
     * @param $k
     *
     * @return DecimalInterface|NumberInterface|ImmutableDecimal
     * @throws IntegrityConstraint
     * @throws IncompatibleObjectState
     */
    public static function binomialCoefficient($n, $k): ImmutableDecimal
    {

        $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);
        $k = Numbers::makeOrDont(Numbers::IMMUTABLE, $k);

        if ($k->isLessThan(0) || $n->isLessThan($k)) {

The method isLessThan() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. It seems like you code against a sub-type of Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface such as Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface or Samsara\Fermat\Types\Fraction or Samsara\Fermat\Types\Decimal.

            throw new IntegrityConstraint(
                '$k must be larger or equal to 0 and less than or equal to $n',
                'Provide valid $n and $k values such that 0 <= $k <= $n',
                'For $n choose $k, the values of $n and $k must satisfy the inequality 0 <= $k <= $n'
            );
        }

        if (!$n->isInt() || !$k->isInt()) {

The method isInt() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface. It seems like you code against a sub-type of Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface such as Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface or Samsara\Fermat\Types\Fraction or Samsara\Fermat\Types\Fraction or Samsara\Fermat\Types\Decimal.

            throw new IntegrityConstraint(
                '$k and $n must be whole numbers',
                'Provide whole numbers for $n and $k',
                'For $n choose $k, the values $n and $k must be whole numbers'
            );
        }

        return $n->factorial()->divide($k->factorial()->multiply($n->subtract($k)->factorial()));

The method factorial() does not exist on Samsara\Fermat\Values\ImmutableComplexNumber.

The method factorial() does not exist on Samsara\Fermat\Types\Base\Interfaces\Numbers\FractionInterface.

    }

    public static function inverseErrorCoefficients(int $termIndex): ImmutableFraction
    {

        $terms =& static::$inverseErrorCoefs;

        if (is_null(static::$inverseErrorCoefs)) {
            $terms = new Vector();
            $terms->push(new ImmutableFraction(Numbers::makeOne(), Numbers::makeOne()));
            $terms->push(new ImmutableFraction(Numbers::makeOne(), Numbers::makeOne()));
        }

        if ($terms->offsetExists($termIndex)) {
            return $terms->get($termIndex);
        }

        $nextTerm = $terms->count();

        for ($k = $nextTerm;$k <= $termIndex;$k++) {
            $termValue = new ImmutableFraction(new ImmutableDecimal('0'), new ImmutableDecimal('1'));
            for ($m = 0;$m <= ($k - 1);$m++) {
                $part1 = $terms->get($m);
                $part2 = $terms->get($k - 1 - $m);
                $part3 = $part1->multiply($part2);
                $part4 = ($m + 1)*($m*2 + 1);
                $part5 = $part3->divide($part4);
                $termValue = $termValue->add($part5);
            }

            $termValue = $termValue->simplify();

            $terms->push($termValue);
        }

        return $terms->get($termIndex);

    }

    /**
     * @param $z
     * @param int $precision
     *
     * @return ImmutableDecimal
     * @throws IntegrityConstraint
     * @throws OptionalExit
     * @throws \ReflectionException
     */
    public static function inverseGaussErrorFunction($z, int $precision = 10): ImmutableDecimal
    {

        $z = Numbers::makeOrDont(Numbers::IMMUTABLE, $z);

        $precision = $precision ?? $z->getPrecision();
        $internalPrecision = $precision + 1;

        $pi = Numbers::makePi($internalPrecision);

        $answer = SeriesProvider::maclaurinSeries(
            $z,

It seems like $z can also be of type Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface[] and Samsara\Fermat\Values\ImmutableDecimal[] and Samsara\Fermat\Values\MutableDecimal[]; however, parameter $input of Samsara\Fermat\Provider\SeriesProvider::maclaurinSeries() does only seem to accept Samsara\Fermat\Types\Base\Interfaces\Numbers\SimpleNumberInterface, maybe add an additional type check?

            function ($n) use ($pi) {
                if ($n > 0) {
                    return $pi->pow($n)->multiply(StatsProvider::inverseErrorCoefficients($n));
                }

                return Numbers::makeOne();
            },
            function ($n) {
                return SequenceProvider::nthOddNumber($n);
            },
            function ($n) {
                if ($n > 0) {
                    $extra = Numbers::make(Numbers::IMMUTABLE, 2)->pow(SequenceProvider::nthEvenNumber($n));
                } else {
                    $extra = Numbers::makeOne();
                }

                return SequenceProvider::nthOddNumber($n)->multiply($extra);
            },
            0,
            $internalPrecision
        );

        $answer = $answer->multiply($pi->sqrt($internalPrecision)->divide(2, $internalPrecision));

        return $answer->roundToPrecision($precision);

    }

}