SequenceProvider - Code Metrics - Inspection of "Merge Number Collection Code Into dev" - JordanRL/Fermat - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — dev (#23)

by Jordan
created 2018-01-30 20:11 UTC
SequenceProvider A

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	222
Duplicated Lines	0 %
Coupling/Cohesion

Components	0
Dependencies	3
Test Coverage

Coverage
23.21%
Importance

Changes
Metric	Value
wmc	16
lcom	0
cbo	3
dl	0
loc	222
ccs	13
cts	56
cp	0.2321
rs	10
c	0
b	0
f	0
7 Methods

Rating	Name	Size	Complexity
A	nthOddNumber()	8	1
A	nthEvenNumber()	8	1
A	nthPowerNegativeOne()	8	1
A	nthEulerZigzag()	16	2
B	nthBernoulliNumber()	26	5
A	nthFibonacciNumber()	23	3
A	_fib()	21	3
<?php

namespace Samsara\Fermat\Provider;

use Samsara\Exceptions\UsageError\IntegrityConstraint;
use Samsara\Fermat\Numbers;
use Samsara\Fermat\Types\Base\DecimalInterface;
use Samsara\Fermat\Types\Base\NumberInterface;
use Samsara\Fermat\Values\ImmutableNumber;

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
     */
    public static function nthOddNumber($n)
    {

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

        return $n->multiply(2)->add(1);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

    }

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

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

        return $n->multiply(2);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

    }

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

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

        return $negOne->pow($n);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

    }

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

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

        if ($n->isGreaterThan(50)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            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);

    }

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

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

        if ($n->isEqual(0)) {
            return Numbers::makeOne();
        } elseif ($n->isEqual(1)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            return Numbers::make(Numbers::IMMUTABLE, '0.5', 100);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        if ($n->isGreaterThan(1) && $n->modulo(2)->isEqual(1)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            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())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->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 ImmutableNumber
     * @throws IntegrityConstraint
     */
    public static function nthFibonacciNumber($n): ImmutableNumber
    {
        $n = Numbers::makeOrDont(Numbers::IMMUTABLE, $n);
        if (!$n->isInt()) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            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)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            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);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        return $fastFib[0];
    }

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

        /**
         * @var ImmutableNumber $a
         * @var ImmutableNumber $b
         * @var ImmutableNumber $prevCall
         */
        $prevCall = $number->divide(2)->floor();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        list($a, $b) = static::_fib($prevCall);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        $c = $a->multiply($b->multiply(2)->subtract($a));
        $d = $a->multiply($a)->add($b->multiply($b));
        if ($number->modulo(2)->isEqual(0)) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            return [$c, $d];
        } else {
            return [$d, $c->add($d)];
        }
    }

}
Pull Request — dev (#23)

SequenceProvider A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

7 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

JordanRL / Fermat

Pull Request — dev (#23)

SequenceProvider A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

7 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
