Samsara\Fermat\Values\ImmutableDecimal

Complexity

Total Complexity

12

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Test Coverage

Coverage

91.18%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	continuousModulo()	0	24	4
B	setValue()	0	41	8

<?php


namespace Samsara\Fermat\Values;


use Samsara\Exceptions\SystemError\PlatformError\MissingPackage;

use Samsara\Exceptions\UsageError\IntegrityConstraint;

use Samsara\Fermat\Enums\NumberBase;

use Samsara\Fermat\Numbers;

use Samsara\Fermat\Provider\ArithmeticProvider;

use Samsara\Fermat\Provider\BaseConversionProvider;

use Samsara\Fermat\Types\Base\Interfaces\Numbers\NumberInterface;

use Samsara\Fermat\Types\Decimal;

use Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface;


/**

 *

 */

class ImmutableDecimal extends Decimal

{


    /**

     * @param NumberInterface|string|int|float $mod

     * @return DecimalInterface

     * @throws IntegrityConstraint

     * @throws MissingPackage

     */

    public function continuousModulo(NumberInterface|string|int|float $mod): DecimalInterface

    {


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


        $scale = ($this->getScale() < $mod->getScale()) ? $mod->getScale() : $this->getScale();


        $newScale = $scale+2;

        $thisNum = Numbers::make(Numbers::IMMUTABLE, $this->getValue(NumberBase::Ten), $newScale);


        if (is_object($mod) && method_exists($mod, 'truncateToScale')) {

            $mod = $mod->truncateToScale($newScale);

        } else {

            $mod = Numbers::make(Numbers::IMMUTABLE, $mod, $newScale);

        }



        $multiple = $thisNum->divide($mod, $newScale)->floor();


        $subtract = $mod->multiply($multiple);


        $remainder = $thisNum->subtract($subtract);


        return $remainder->truncateToScale($this->getScale()-1);


    }


    /**

     * @param string $value

     * @param int|null $scale

     * @param NumberBase|null $base

     * @param bool $setToNewBase

     * @return ImmutableDecimal

     * @throws IntegrityConstraint

     */

    protected function setValue(string $value, ?int $scale = null, ?NumberBase $base = null, bool $setToNewBase = false): ImmutableDecimal

    {

        $imaginary = false;


        if (str_contains($value, 'i')) {

            $value = str_replace('i', '', $value);

            $imaginary = true;

        }


        if ((!is_null($base) && $base != NumberBase::Ten)) {

            $value = BaseConversionProvider::convertStringToBaseTen($value, $base);

        }


        if ($setToNewBase) {

            $base = $base ?? NumberBase::Ten;

        } else {

            $base = $this->getBase();

        }


        $sign = $this->sign;


        $translated = $this->translateValue($value);

        $determinedScale = $this->determineScale($translated[1]);


        $this->sign = $sign;


        $determinedScale = $this->getScale() > $determinedScale ? $this->getScale() : $determinedScale;


        $scale = $scale ?? $determinedScale;


        if ($imaginary) {

            $value .= 'i';

        }


        $return = new ImmutableDecimal($value, $scale, $base, true);


        if (isset($this->calcMode)) {

            $return->setMode($this->calcMode);

It seems like $this->calcMode can also be of type null; however, parameter $mode of Samsara\Fermat\Types\Base\Number::setMode() does only seem to accept Samsara\Fermat\Enums\CalcMode, maybe add an additional type check?

        }


        return $return;

    }


}