RoundingProvider::roundHalfUp() - Code Metrics - Inspection of "Merge pull request #135 from JordanRL/f-refactorin..." - JordanRL/Fermat - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 2683bd...cf87f7 )

by Jordan
created 2022-10-12 17:31 UTC
RoundingProvider::roundHalfUp() A

↳ Parent: RoundingProvider
Complexity

Conditions	6
Paths	8
Size

Total Lines	9
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	6
Importance

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

namespace Samsara\Fermat\Provider;

use JetBrains\PhpStorm\ExpectedValues;
use JetBrains\PhpStorm\Pure;
use Samsara\Fermat\Enums\RandomMode;
use Samsara\Fermat\Enums\RoundingMode;
use Samsara\Fermat\Provider\RoundingModeAdapters\ModeAdapterFactory;
use Samsara\Fermat\Types\Base\Interfaces\Numbers\DecimalInterface;

/**
 *
 */
class RoundingProvider
{

    private static RoundingMode $mode = RoundingMode::HalfEven;

    /**
     * @param RoundingMode $mode
     * @return void
     */
    public static function setRoundingMode(
        RoundingMode $mode
    ): void
    {
        static::$mode = $mode;

    }

    /**
     * @return RoundingMode
     */
    public static function getRoundingMode(): RoundingMode
    {
        return self::$mode;
    }

    /**
     * @param string $decimal
     * @param int $places
     * @return string
     */
    public static function round(string $decimal, int $places = 0): string
    {
        $carry = 0;

        [
            $rawString,
            $roundedPart,
            $roundedPartString,
            $otherPart,
            $pos,
            $wholePart,
            $decimalPart,
            $currentPart,
            $isNegative
        ] = self::roundPreFormat($decimal, $places);

        $sign = $isNegative ? '-' : '';
        $imaginary = str_ends_with($decimal, 'i') ? 'i' : '';

        if (empty($decimalPart) && $places >= 0) {
            return $sign.$rawString.$imaginary;
        }

        do {
            if (!array_key_exists($pos, $roundedPart)) {
            if (!array_key_exists($pos, /** @scrutinizer ignore-type */ $roundedPart)) {
                break;
            }

            [$digit, $nextDigit, $remainder] = self::roundLoopStart(
                $roundedPart,
                /** @scrutinizer ignore-type */ $roundedPart,
                $otherPart,
                /** @scrutinizer ignore-type */ $otherPart,
                $roundedPartString,
                $pos,
                $carry,
                $currentPart
            );

            if ($carry == 0) {
                $roundingMode = ModeAdapterFactory::getAdapter(self::getRoundingMode(), $isNegative, $remainder);
                $carry = $roundingMode->determineCarry($digit, $nextDigit);
            } else {
                if ($digit > 9) {
                    $carry = 1;
                    $roundedPart[$pos] = '0';
                } else {
                    $carry = 0;
                    $roundedPart[$pos] = $digit;
                }
            }

            [$roundedPart, $otherPart, $pos, $carry, $currentPart] = self::roundLoopEnd(
                $roundedPart,
                /** @scrutinizer ignore-type */ $roundedPart,
                $otherPart,
                /** @scrutinizer ignore-type */ $otherPart,
                $pos,
                $carry,
                $currentPart
            );
        } while ($carry == 1);

        [$newWholePart, $newDecimalPart] = self::roundPostFormat($currentPart, $wholePart, $roundedPart, $otherPart, $places);
        [$newWholePart, $newDecimalPart] = self::roundPostFormat($currentPart, $wholePart, $roundedPart, /** @scrutinizer ignore-type */ $otherPart, $places);

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

    /**
     * @param string $decimal
     * @param int $places
     * @return array
     */
    private static function roundPreFormat(string $decimal, int $places): array
    {
        $decimal = trim(rtrim($decimal));

        $isNegative = str_starts_with($decimal, '-');

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

        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;

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

        return [
            $rawString,
            $roundedPart,
            $roundedPartString,
            $otherPart,
            $pos,
            $wholePart,
            $decimalPart,
            $currentPart,
            $isNegative
        ];
    }

    /**
     * @param string $currentPart
     * @param string $wholePart
     * @param array $roundedPart
     * @param array $otherPart
     * @param int $places
     * @return array
     */
    private static function roundPostFormat(
        string $currentPart,
        string $wholePart,
        array $roundedPart,
        array $otherPart,
        int $places
    ): array
    {
        if ($currentPart) {
            $newDecimalPart = implode('', $roundedPart);
            $newWholePart = implode('', $otherPart);
        } 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';
        }

        return [$newWholePart, $newDecimalPart];
    }

    /**
     * @param array $roundedPart
     * @param array $otherPart
     * @param string $roundedPartString
     * @param int $pos
     * @param int $carry
     * @param bool $currentPart
     * @return array
     */
    private static function roundLoopStart(
        array $roundedPart,
        array $otherPart,
        string $roundedPartString,
        int $pos,
        int $carry,
        bool $currentPart
    ): array
    {
        $digit = (int)$roundedPart[$pos] + $carry;

        if ($carry == 0 && $digit == 5 && strlen($roundedPartString) > $pos+1) {
            $remainder = substr($roundedPartString, $pos+1);
        } else {
            $remainder = null;
        }

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

        return [$digit, $nextDigit, $remainder];
    }

    /**
     * @param array $roundedPart
     * @param array $otherPart
     * @param int $pos
     * @param int $carry
     * @param bool $currentPart
     * @return array
     */
    private static function roundLoopEnd(
        array $roundedPart,
        array $otherPart,
        int $pos,
        int $carry,
        bool $currentPart
    ): array
    {
        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);
                $carry = 0;
            }
        } else {
            $pos -= 1;
        }

        return [$roundedPart, $otherPart, $pos, $carry, $currentPart];
    }

}
JordanRL / Fermat

Push — master ( 2683bd...cf87f7 )

RoundingProvider::roundHalfUp() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
