Samsara\Fermat\Provider\RoundingProvider::round()

Complexity

Conditions	29
Paths	> 20000

Size

Total Lines	127
Code Lines	89

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	77
CRAP Score	29.0017

Importance

Changes	1
Bugs	0	Features	0

<?php
    public static function round(DecimalInterface $decimal, int $places = 0): string
    {
        static::$decimal = $decimal;

Since $decimal is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $decimal to at least protected.

        $rawString = str_replace('-', '', $decimal->getAsBaseTenRealNumber());

        $sign = $decimal->isNegative() ? '-' : '';
        $imaginary = $decimal->isImaginary() ? 'i' : '';

        if ($decimal->isInt() && $places >= 0) {
            return $sign.$rawString.$imaginary;
        }

        if (str_contains($rawString, '.')) {
            [$wholePart, $decimalPart] = explode('.', $rawString);
        } else {
            $wholePart = $rawString;
            $decimalPart = '';
        }

        $absPlaces = abs($places);

        $currentPart = $places >= 0;
        $roundedPart = $currentPart ? str_split($decimalPart) : str_split($wholePart);
        $roundedPartString = $currentPart ? $decimalPart : $wholePart;
        $otherPart = $currentPart ? str_split($wholePart) : str_split($decimalPart);
        $baseLength = $currentPart ? strlen($decimalPart)-1 : strlen($wholePart);
        $pos = $currentPart ? $places : $baseLength + $places;
        $carry = 0;

        if ($currentPart) {
            $pos = ($absPlaces > $baseLength) ? $baseLength : $pos;
        } else {
            $pos = ($absPlaces >= $baseLength) ? 0 : $pos;
        }

        do {
            if (!array_key_exists($pos, $roundedPart)) {

It seems like $roundedPart can also be of type true; however, parameter $array of array_key_exists() does only seem to accept ArrayObject|array, maybe add an additional type check?

                break;
            }

            $digit = (int)$roundedPart[$pos] + $carry;

            if ($carry == 0 && $digit == 5) {
                static::$remainder = substr($roundedPartString, $pos+1);

Since $remainder is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $remainder to at least protected.

            } else {
                static::$remainder = null;
            }

            if ($pos == 0) {
                if ($currentPart) {
                    $nextDigit = (int)$otherPart[count($otherPart)-1];

It seems like $otherPart can also be of type true; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

                } else {
                    $nextDigit = 0;
                }
            } else {
                $nextDigit = (int)$roundedPart[$pos-1];
            }

            if ($carry == 0) {
                $carry = match (self::getRoundingMode()) {
                    RoundingMode::HalfUp => self::roundHalfUp($digit),
                    RoundingMode::HalfDown => self::roundHalfDown($digit),
                    RoundingMode::HalfOdd => self::roundHalfOdd($digit, $nextDigit),
                    RoundingMode::HalfZero => self::roundHalfZero($digit),
                    RoundingMode::HalfInf => self::roundHalfInf($digit),
                    RoundingMode::Ceil => self::roundCeil($digit),
                    RoundingMode::Floor => self::roundFloor(),
                    RoundingMode::HalfRandom => self::roundRandom($digit),
                    RoundingMode::HalfAlternating => self::roundAlternating($digit),
                    RoundingMode::Stochastic => self::roundStochastic($digit),
                    default => self::roundHalfEven($digit, $nextDigit)
                };
            } else {
                if ($digit > 9) {
                    $carry = 1;
                    $roundedPart[$pos] = '0';
                } else {
                    $carry = 0;
                    $roundedPart[$pos] = $digit;
                }
            }

            if ($pos == 0 && $carry == 1) {
                if ($currentPart) {
                    $currentPart = false;

                    // Do the variable swap dance
                    $temp = $otherPart;
                    $otherPart = $roundedPart;
                    $roundedPart = $temp;

                    $pos = count($roundedPart)-1;
                } else {
                    array_unshift($roundedPart, $carry);

It seems like $roundedPart can also be of type true; however, parameter $array of array_unshift() does only seem to accept array, maybe add an additional type check?

                    $carry = 0;
                }
            } else {
                $pos -= 1;
            }
        } while ($carry == 1);

        if ($currentPart) {
            $newDecimalPart = implode('', $roundedPart);
            $newWholePart = implode('', $otherPart);

It seems like $otherPart can also be of type true; however, parameter $pieces of implode() does only seem to accept array, maybe add an additional type check?

        } else {
            $newDecimalPart = implode('', $otherPart);
            $newWholePart = implode('', $roundedPart);
        }

        if ($places > 0) {
            $newDecimalPart = substr($newDecimalPart, 0, $places);
        } elseif ($places == 0) {
            $newDecimalPart = '0';
        } else {
            $newWholePart = substr($newWholePart, 0, strlen($wholePart)+$places).str_repeat('0', $places*-1);
            $newDecimalPart = '0';
        }

        if (!strlen(str_replace('0', '', $newDecimalPart))) {
            $newDecimalPart = '0';
        }

        static::$remainder = null;
        static::$decimal = null;

        return $sign.$newWholePart.'.'.$newDecimalPart.$imaginary;
    }
}