Cubiche\Domain\System\Integer

Complexity

Total Complexity

37

Size/Duplication

Total Lines	303
Duplicated Lines	2.97 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	fromNative()	0	4	1
A	__construct()	0	12	2
A	toInteger()	0	4	1
A	toReal()	0	4	1
A	toDecimal()	0	4	1
A	isInfinite()	0	4	1
A	isPositive()	0	4	1
A	isNegative()	0	4	1
A	isZero()	0	4	1
A	invertedAdd()	0	4	1
A	addInteger()	0	4	1
A	addReal()	0	4	1
A	addDecimal()	0	4	1
A	invertedSub()	0	4	1
A	subInteger()	0	4	1
A	subReal()	0	4	1
A	subDecimal()	0	4	1
A	invertedMult()	0	4	1
A	multInteger()	0	4	1
A	multReal()	0	4	1
A	multDecimal()	0	4	1
A	invertedDiv()	0	4	1
A	divInteger()	9	9	2
A	divReal()	0	4	1
A	divDecimal()	0	4	1
A	invertedPow()	0	4	1
A	powInteger()	0	4	1
A	powReal()	0	4	1
A	powDecimal()	0	4	1
A	sqrt()	0	4	1
A	inc()	0	4	1
A	dec()	0	4	1
A	mod()	0	4	1
A	isEven()	0	4	1
A	isOdd()	0	4	1

<?php

/*
 * This file is part of the Cubiche package.
 *
 * Copyright (c) Cubiche
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cubiche\Domain\System;

/**
 * Integer Class.
 *
 * @author Karel Osorio Ramírez <osorioramirez@gmail.com>
 */
class Integer extends Number
{
    /**
     * @param int $value
     *
     * @return \Cubiche\Domain\System\Integer
     */
    public static function fromNative($value)
    {
        return new static($value);
    }

    /**
     * @param int $value
     *
     * @throws \InvalidArgumentException
     */
    protected function __construct($value)
    {
        $filteredValue = \filter_var($value, FILTER_VALIDATE_INT);
        if ($filteredValue === false) {
            throw new \InvalidArgumentException(sprintf(
                'Argument "%s" is invalid. Allowed types for argument are "int".',
                $value
            ));
        }

        $this->value = $value;
    }

    /**
     * {@inheritdoc}
     */
    public function toInteger(RoundingMode $roundingMode = null)
    {
        return new self($this->value);
    }

    /**
     * {@inheritdoc}
     */
    public function toReal()
    {
        return Real::fromNative($this->value);
    }

    /**
     * {@inheritdoc}
     */
    public function toDecimal()
    {
        return Decimal::fromNative($this->value);
    }

    /**
     * {@inheritdoc}
     */
    public function isInfinite()
    {
        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function isPositive()
    {
        return $this->value > 0;
    }

    /**
     * {@inheritdoc}
     */
    public function isNegative()
    {
        return $this->value < 0;
    }

    /**
     * {@inheritdoc}
     */
    public function isZero()
    {
        return $this->value === 0;
    }

    /**
     * {@inheritdoc}
     */
    protected function invertedAdd(Number $x)
    {
        return $x->addInteger($this);
    }

    /**
     * {@inheritdoc}
     */
    public function addInteger(Integer $x)
    {
        return new static($this->toNative() + $x->toNative());
    }

    /**
     * {@inheritdoc}
     */
    public function addReal(Real $x)
    {
        return $this->toReal()->addReal($x);
    }

    /**
     * {@inheritdoc}
     */
    public function addDecimal(Decimal $x, $scale = null)
    {
        return $this->toDecimal()->addDecimal($x, $scale);
    }

    /**
     * {@inheritdoc}
     */
    protected function invertedSub(Number $x)
    {
        return $x->subInteger($this);
    }

    /**
     * {@inheritdoc}
     */
    public function subInteger(Integer $x)
    {
        return new static($this->toNative() - $x->toNative());
    }

    /**
     * {@inheritdoc}
     */
    public function subReal(Real $x)
    {
        return $this->toReal()->subReal($x);
    }

    /**
     * {@inheritdoc}
     */
    public function subDecimal(Decimal $x, $scale = null)
    {
        return $this->toDecimal()->subDecimal($x, $scale);
    }

    /**
     * {@inheritdoc}
     */
    protected function invertedMult(Number $x)
    {
        return $x->multInteger($this);
    }

    /**
     * {@inheritdoc}
     */
    public function multInteger(Integer $x)
    {
        return new static($this->toNative() * $x->toNative());
    }

    /**
     * {@inheritdoc}
     */
    public function multReal(Real $x)
    {
        return $this->toReal()->multReal($x);
    }

    /**
     * {@inheritdoc}
     */
    public function multDecimal(Decimal $x, $scale = null)
    {
        return $this->toDecimal()->multDecimal($x, $scale);
    }

    /**
     * {@inheritdoc}
     */
    protected function invertedDiv(Number $x)
    {
        return $x->divInteger($this);
    }

    /**
     * {@inheritdoc}
     */
    public function divInteger(Integer $x)

This method seems to be duplicated in your project.

    {
        $value = $this->divSpecialCases($x);
        if ($value !== null) {
            return $value;
        }

        return Real::fromNative($this->toNative() / $x->toNative());
    }

    /**
     * {@inheritdoc}
     */
    public function divReal(Real $x)
    {
        return $this->toReal()->divReal($x);
    }

    /**
     * {@inheritdoc}
     */
    public function divDecimal(Decimal $x, $scale = null)
    {
        return $this->toDecimal()->divDecimal($x, $scale);
    }

    /**
     * {@inheritdoc}
     */
    protected function invertedPow(Number $x)
    {
        return $x->powInteger($this);
    }

    /**
     * @param int $x
     *
     * @return Number
     */
    public function powInteger(Integer $x)
    {
        return new static(\pow($this->toNative(), $x->toNative()));
    }

    /**
     * {@inheritdoc}
     */
    public function powReal(Real $x)
    {
        return $this->toReal()->powReal($x);
    }

    /**
     * {@inheritdoc}
     */
    public function powDecimal(Decimal $x, $scale = null)
    {
        return $this->toDecimal()->powDecimal($x, $scale);
    }

    /**
     * {@inheritdoc}
     */
    public function sqrt($scale = null)
    {
        return $this->toReal()->sqrt($scale);
    }

    /**
     * @return \Cubiche\Domain\System\Integer
     */
    public function inc()
    {
        return new static($this->toNative() + 1);
    }

    /**
     * @return \Cubiche\Domain\System\Integer
     */
    public function dec()
    {
        return new static($this->toNative() - 1);
    }

    /**
     * @param int $x
     *
     * @return \Cubiche\Domain\System\Integer
     */
    public function mod(Integer $x)
    {
        return new static($this->toNative() % $x->toNative());
    }

    /**
     * @return bool
     */
    public function isEven()
    {
        return $this->mod(self::fromNative(2))->isZero();
    }

    /**
     * @return bool
     */
    public function isOdd()
    {
        return !$this->isEven();
    }
}