Samsara\Fermat\Stats\Values\Distribution\Exponential

Complexity

Total Complexity

16

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Test Coverage

Coverage

8.51%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	cdf()	0	30	2
A	rangePdf()	0	28	3
A	random()	0	16	1
A	rangeRandom()	0	18	6
A	__construct()	0	13	2
A	pdf()	0	30	2

<?php

namespace Samsara\Fermat\Stats\Values\Distribution;

use Samsara\Exceptions\UsageError\IntegrityConstraint;
use Samsara\Exceptions\UsageError\OptionalExit;
use Samsara\Fermat\Core\Numbers;
use Samsara\Fermat\Stats\Types\Distribution;
use Samsara\Fermat\Core\Provider\RandomProvider;
use Samsara\Fermat\Core\Types\Base\Interfaces\Numbers\DecimalInterface;
use Samsara\Fermat\Core\Values\ImmutableDecimal;

class Exponential extends Distribution
{

    /**
     * @var ImmutableDecimal
     */
    private $lambda;

    /**
     * Exponential constructor.
     *
     * @param int|float|DecimalInterface $lambda This is the *rate parameter* not the *scale parameter*
     *
     * @throws IntegrityConstraint
     */
    public function __construct($lambda)
    {
        $lambda = Numbers::makeOrDont(Numbers::IMMUTABLE, $lambda);

        if (!$lambda->isPositive()) {

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

            throw new IntegrityConstraint(
                'Lambda must be positive',
                'Provide a positive lambda',
                'Exponential distributions work on time to occurrence; the mean time to occurrence (lambda) must be positive'
            );
        }

        $this->lambda = $lambda;

It seems like $lambda can also be of type Samsara\Fermat\Core\Types\Base\Interfaces\Numbers\NumberInterface. However, the property $lambda is declared as type Samsara\Fermat\Core\Values\ImmutableDecimal. Maybe add an additional type check?

    }

    /**
     * @param int|float|DecimalInterface $x
     *
     * @return ImmutableDecimal
     * @throws IntegrityConstraint
     */
    public function cdf($x, int $scale = 10): ImmutableDecimal
    {

        $x = Numbers::makeOrDont(Numbers::IMMUTABLE, $x);
        /** @var ImmutableDecimal $one */
        $one = Numbers::makeOne();

        if (!$x->isPositive()) {
            throw new IntegrityConstraint(
                'X must be positive',
                'Provide a positive x',
                'Exponential distributions work on time to occurrence; the time to occurrence (x) must be positive'
            );
        }

        $internalScale = $scale + 2;

        /** @var ImmutableDecimal $e */
        $e = Numbers::makeE($internalScale);

        /** @var ImmutableDecimal $cdf */
        $cdf =
            $one->subtract(
                $e->pow(
                    $x->multiply($this->lambda)
                        ->multiply(-1)
                )
            )->truncateToScale($scale);

        return $cdf;

    }

    /**
     * @param $x
     *
     * @return ImmutableDecimal
     * @throws IntegrityConstraint
     */
    public function pdf($x, int $scale = 10): ImmutableDecimal
    {

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

        if (!$x->isPositive()) {
            throw new IntegrityConstraint(
                'X must be positive',
                'Provide a positive x',
                'Exponential distributions work on time to occurrence; the time to occurrence (x) must be positive'
            );
        }

        $internalScale = $scale + 2;

        /** @var ImmutableDecimal $e */
        $e = Numbers::makeE($internalScale);

        /** @var ImmutableDecimal $pdf */
        $pdf =
            $this->lambda
                ->multiply(
                    $e->pow(
                        $this->lambda
                            ->multiply(-1)
                            ->multiply($x)
                    )
                )->truncateToScale($scale);

        return $pdf;

    }

    /**
     * @param $x1
     * @param $x2
     *
     * @return ImmutableDecimal
     * @throws IntegrityConstraint
     */
    public function rangePdf($x1, $x2, int $scale = 10): ImmutableDecimal
    {
        $x1 = Numbers::makeOrDont(Numbers::IMMUTABLE, $x1);
        $x2 = Numbers::makeOrDont(Numbers::IMMUTABLE, $x2);

        if (!$x1->isPositive() || !$x2->isPositive()) {
            throw new IntegrityConstraint(
                'X must be positive',
                'Provide a positive x',
                'Exponential distributions work on time to occurrence; the time to occurrence (x) must be positive'
            );
        }

        $internalScale = $scale + 2;

        /** @var ImmutableDecimal $rangePdf */
        $rangePdf =
            $this->pdf(
                $x2,
                $internalScale
            )->subtract(
                $this->pdf(
                    $x1,
                    $internalScale)
            )->abs()
            ->truncateToScale($scale);

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

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

        return $rangePdf;
    }

    /**
     * @return ImmutableDecimal
     *
     * @codeCoverageIgnore
     */
    public function random(): ImmutableDecimal
    {

        $u = RandomProvider::randomDecimal(10);
        $one = Numbers::makeOne();

        /** @var ImmutableDecimal $random */
        $random =
            $one->subtract($u)
                ->ln()
                ->divide(
                    $this->lambda
                        ->multiply(-1)
                );

        return $random;

    }

    /**
     * @param int|float|DecimalInterface $min
     * @param int|float|DecimalInterface $max
     * @param int $maxIterations
     *
     * @return ImmutableDecimal
     * @throws OptionalExit
     *
     * @codeCoverageIgnore
     */
    public function rangeRandom($min = 0, $max = PHP_INT_MAX, int $maxIterations = 20): ImmutableDecimal
    {

        $i = 0;

        do {
            $randomNumber = $this->random();
            $i++;
        } while (($randomNumber->isGreaterThan($max) || $randomNumber->isLessThan($min)) && $i < $maxIterations);

        if ($randomNumber->isGreaterThan($max) || $randomNumber->isLessThan($min)) {
            throw new OptionalExit(
                'All random numbers generated were outside of the requested range',
                'A suitable random number, restricted by the $max ('.$max.') and $min ('.$min.'), could not be found within '.$maxIterations.' iterations'

Are you sure $min of type Samsara\Fermat\Core\Types\Base\Interfaces\Numbers\DecimalInterface|double|integer can be used in concatenation?

Are you sure $max of type Samsara\Fermat\Core\Types\Base\Interfaces\Numbers\DecimalInterface|double|integer can be used in concatenation?

            );
        }

        return $randomNumber;
    }

}