SequenceProvider::nthEvenNumber() - Code Metrics - Inspection of "Merging dev into master to include complex numbers..." - JordanRL/Fermat - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Pull Request — master (#47)

by Jordan
created 2020-05-05 07:30 UTC
SequenceProvider::nthEvenNumber() A

↳ Parent: SequenceProvider
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
cc	1
eloc	2
c	1
b	0
f	1
nc	1
nop	1
dl	0
loc	6
ccs	3
cts	3
cp	1
crap	1
rs	10
<?php

namespace Samsara\Fermat\Provider;

use Samsara\Exceptions\SystemError\LogicalError\IncompatibleObjectState;
use Samsara\Exceptions\UsageError\IntegrityConstraint;
use Samsara\Fermat\Numbers;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface;
use Samsara\Fermat\Values\ImmutableDecimal;

class SequenceProvider
{

    const EULER_ZIGZAG = [
        '1',                                                        // 0
        '1',                                                        // 1
        '1',                                                        // 2
        '2',                                                        // 3
        '5',                                                        // 4
        '16',                                                       // 5
        '61',                                                       // 6
        '272',                                                      // 7
        '1385',                                                     // 8
        '7936',                                                     // 9
        '50521',                                                    // 10
        '353792',                                                   // 11
        '2702765',                                                  // 12
        '22368256',                                                 // 13
        '199360981',                                                // 14
        '1903757312',                                               // 15
        '19391512145',                                              // 16
        '209865342976',                                             // 17
        '2404879675441',                                            // 18
        '29088885112832',                                           // 19
        '370371188237525',                                          // 20
        '4951498053124096',                                         // 21
        '69348874393137901',                                        // 22
        '1015423886506852352',                                      // 23
        '15514534163557086905',                                     // 24
        '246921480190207983616',                                    // 25
        '4087072509293123892361',                                   // 26
        '70251601603943959887872',                                  // 27
        '1252259641403629865468285',                                // 28
        '23119184187809597841473536',                               // 29
        '441543893249023104553682821',                              // 30
        '8713962757125169296170811392',                             // 31
        '177519391579539289436664789665',                           // 32
        '3729407703720529571097509625856',                          // 33
        '80723299235887898062168247453281',                         // 34
        '1798651693450888780071750349094912',                       // 35
        '41222060339517702122347079671259045',                      // 36
        '970982810785059112379399707952152576',                     // 37
        '23489580527043108252017828576198947741',                   // 38
        '583203324917310043943191641625494290432',                  // 39
        '14851150718114980017877156781405826684425',                // 40
        '387635983772083031828014624002175135645696',               // 41
        '10364622733519612119397957304745185976310201',             // 42
        '283727921907431909304183316295787837183229952',            // 43
        '7947579422597592703608040510088070619519273805',           // 44
        '227681379129930886488600284336316164603920777216',         // 45
        '6667537516685544977435028474773748197524107684661',        // 46
        '199500252157859031027160499643195658166340757225472',      // 47
        '6096278645568542158691685742876843153976539044435185',     // 48
        '190169564657928428175235445073924928592047775873499136',   // 49
        '6053285248188621896314383785111649088103498225146815121',  // 50
    ];

    /**
     * OEIS: A005408
     *
     * @param $n
     *
     * @return DecimalInterface|NumberInterface
     * @throws IntegrityConstraint
     */
    public static function nthOddNumber($n)
    {

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

        return $n->multiply(2)->add(1);

    }

    /**
     * OEIS: A005843
     *
     * @param $n
     *
     * @return DecimalInterface|NumberInterface
     * @throws IntegrityConstraint
     */
    public static function nthEvenNumber($n)
    {

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

        return $n->multiply(2);

    }

    /**
     * OEIS: A033999
     *
     * @param $n
     *
     * @return DecimalInterface|NumberInterface
     * @throws IntegrityConstraint
     */
    public static function nthPowerNegativeOne($n)
    {

        $negOne = Numbers::makeOrDont(Numbers::IMMUTABLE, -1, 100);
        $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);

        if ($n->modulo(2)->isEqual(0)) {
        if ($n->/** @scrutinizer ignore-call */ modulo(2)->isEqual(0)) {
            return Numbers::makeOne();
        } else {
            return $negOne;
        }

    }

    /**
     * OEIS: A000111
     *
     * @param $n
     *
     * @return DecimalInterface|NumberInterface
     * @throws IntegrityConstraint
     * @throws IncompatibleObjectState
     */
    public static function nthEulerZigzag($n)
    {

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

        if ($n->isGreaterThan(50)) {
        if ($n->/** @scrutinizer ignore-call */ isGreaterThan(50)) {
            throw new IntegrityConstraint(
                '$n cannot be larger than 50',
                'Limit your use of the Euler Zigzag Sequence to the 50th index',
                'This library does not support the Euler Zigzag Sequence (OEIS: A000111) beyond E(50)'
            );
        }

        return Numbers::make(Numbers::IMMUTABLE, static::EULER_ZIGZAG[$n->asInt()], 100);
        return Numbers::make(Numbers::IMMUTABLE, static::EULER_ZIGZAG[$n->/** @scrutinizer ignore-call */ asInt()], 100);

    }

    /**
     * WARNING: This function is VERY unoptimized. Be careful of large m values.
     *
     * @param $n
     *
     * @return DecimalInterface|NumberInterface
     * @throws IntegrityConstraint
     */
    public static function nthBernoulliNumber($n)
    {

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

        if ($n->isEqual(0)) {
            return Numbers::makeOne();
        } elseif ($n->isEqual(1)) {
            return Numbers::make(Numbers::IMMUTABLE, '0.5', 100);
        }

        if ($n->isGreaterThan(1) && $n->modulo(2)->isEqual(1)) {
            return Numbers::makeZero();
        }

        $b = Numbers::make(Numbers::IMMUTABLE, -1, 100);
        $two = Numbers::make(Numbers::IMMUTABLE, 2, 100);
        $four = Numbers::make(Numbers::IMMUTABLE, 4, 100);

        $b = $b->pow($n->divide(2)->floor())
        $b = $b->pow($n->divide(2)->/** @scrutinizer ignore-call */ floor())
            ->multiply($n->divide($two->pow($n)->subtract($four->pow($n))))
            ->multiply(static::nthEulerZigzag($n));

        return $b;

    }

    /**
     * OEIS: A000045
     *
     * This uses an implementation of the fast-doubling Karatsuba multiplication algorithm as described by 'Nayuki':
     *
     * https://www.nayuki.io/page/fast-fibonacci-algorithms
     *
     * @param $n
     * @return ImmutableDecimal
     * @throws IntegrityConstraint
     */
    public static function nthFibonacciNumber($n): ImmutableDecimal
    {
        $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);
        if (!$n->isInt()) {
        if (!$n->/** @scrutinizer ignore-call */ isInt()) {
            throw new IntegrityConstraint(
                'Sequences can only have integer term numbers',
                'Provide a valid term number',
                'The nthFibonacciNumber function takes the term number as its argument; provide an integer term number'
            );
        }

        if ($n->isLessThan(0)) {
        if ($n->/** @scrutinizer ignore-call */ isLessThan(0)) {
            throw new IntegrityConstraint(
                'Negative term numbers not valid for Fibonacci Sequence',
                'Provide a positive term number',
                'A negative term number for the Fibonacci sequence was requested; provide a positive term number'
            );
        }

        $fastFib = static::_fib($n);
        $fastFib = static::_fib(/** @scrutinizer ignore-type */ $n);

        return $fastFib[0];
    }

    private static function _fib(ImmutableDecimal $number): array
    {
        if ($number->isEqual(0)) {
            return [Numbers::makeZero(), Numbers::makeOne()];
        }

        /**
         * @var ImmutableDecimal $a
         * @var ImmutableDecimal $b
         * @var ImmutableDecimal $prevCall
         */
        $prevCall = $number->divide(2)->floor();
        list($a, $b) = static::_fib($prevCall);
        $c = $a->multiply($b->multiply(2)->subtract($a));
        $d = $a->multiply($a)->add($b->multiply($b));
        if ($number->modulo(2)->isEqual(0)) {
            return [$c, $d];
        } else {
            return [$d, $c->add($d)];
        }
    }

}
JordanRL / Fermat

Pull Request — master (#47)

SequenceProvider::nthEvenNumber() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
