22119510950

Committed 17 Feb 2026 11:13PM UTC coverage: 98.99%. Remained the same

Build # 22119510950

Build Type

push

github

Committed by

BenMorel

Commit Message

Update README

[skip CI]

Run Details

1372 of 1386 relevant lines covered (98.99%)

2345.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.92

/src/Internal/DecimalHelper.php

<?php

declare(strict_types=1);

namespace Brick\Math\Internal;

use Brick\Math\RoundingMode;

use function ltrim;
use function rtrim;
use function str_pad;
use function str_repeat;
use function strlen;
use function substr;

use const STR_PAD_LEFT;

/**
 * Shared helper for decimal operations.
 *
 * @internal
 */
final class DecimalHelper
{
    private function __construct()
    {
    }

    /**
     * Computes the scale needed to represent the exact decimal result of a reduced fraction.
     *
     * Returns null if the denominator has prime factors other than 2 or 5.
     *
     * @param string $denominator The denominator of the reduced fraction. Must be strictly positive.
     *
     * @return non-negative-int|null
     *
     * @pure
     */
    public static function computeScaleFromReducedFractionDenominator(string $denominator): ?int
    {
        $calculator = CalculatorRegistry::get();

        $d = rtrim($denominator, '0');

        /** @var non-negative-int $scale rtrim can only shorten a string */
        $scale = strlen($denominator) - strlen($d);

        foreach ([5, 2] as $prime) {
            for (; ;) {
                $lastDigit = (int) $d[-1];

                if ($lastDigit % $prime !== 0) {
                    break;
                }

                $d = $calculator->divQ($d, (string) $prime);
                $scale++;
            }
        }

        return $d === '1' ? $scale : null;
    }

    /**
     * Scales an unscaled decimal value to the requested scale.
     *
     * Returns null when rounding is necessary and the rounding mode is Unnecessary.
     *
     * @param string       $value        The unscaled value.
     * @param int          $currentScale The current scale.
     * @param int          $targetScale  The target scale.
     * @param RoundingMode $roundingMode The rounding mode.
     *
     * @return string|null The unscaled value at the target scale, or null if RoundingMode::Unnecessary is used and rounding is necessary.
     *
     * @pure
     */
    public static function scale(string $value, int $currentScale, int $targetScale, RoundingMode $roundingMode): ?string
    {
        $scaled = self::tryScaleExactly($value, $currentScale, $targetScale);

        if ($scaled !== null) {
            return $scaled;
        }

        if ($roundingMode === RoundingMode::Unnecessary) {
            return null;
        }

        $divisor = '1' . str_repeat('0', $currentScale - $targetScale);

        return CalculatorRegistry::get()->divRound($value, $divisor, $roundingMode);
    }

    /**
     * Adds leading zeros if necessary to represent the full decimal number.
     *
     * @param string $value The unscaled value.
     * @param int    $scale The current scale.
     *
     * @pure
     */
    public static function padUnscaledValue(string $value, int $scale): string
    {
        $targetLength = $scale + 1;
        $negative = ($value[0] === '-');
        $length = strlen($value);

        if ($negative) {
            $length--;
        }

        if ($length >= $targetLength) {
            return $value;
        }

        if ($negative) {
            $value = substr($value, 1);
        }

        $value = str_pad($value, $targetLength, '0', STR_PAD_LEFT);

        if ($negative) {
            $value = '-' . $value;
        }

        return $value;
    }

    /**
     * Tries to scale exactly without rounding, returning null when rounding would be required.
     *
     * @param string $value        The unscaled value.
     * @param int    $currentScale The current scale.
     * @param int    $targetScale  The target scale.
     *
     * @return string|null The unscaled value at the target scale, or null if rounding would be required.
     *
     * @pure
     */
    public static function tryScaleExactly(string $value, int $currentScale, int $targetScale): ?string
    {
        if ($value === '0' || $targetScale === $currentScale) {
            return $value;
        }

        if ($targetScale > $currentScale) {
            return $value . str_repeat('0', $targetScale - $currentScale);
        }

        $negative = ($value[0] === '-');
        if ($negative) {
            $value = substr($value, 1);
        }

        $value = self::padUnscaledValue($value, $currentScale);
        $discardedDigits = $currentScale - $targetScale;

        if (substr($value, -$discardedDigits) !== str_repeat('0', $discardedDigits)) {
            return null;
        }

        $value = substr($value, 0, -$discardedDigits);
        $value = ltrim($value, '0');

        if ($value === '') {
            return '0';
        }

        if ($negative) {
            $value = '-' . $value;
        }

        return $value;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Brick\Math\Internal;
6
7	use Brick\Math\RoundingMode;
8
9	use function ltrim;
10	use function rtrim;
11	use function str_pad;
12	use function str_repeat;
13	use function strlen;
14	use function substr;
15
16	use const STR_PAD_LEFT;
17
18	/**
19	* Shared helper for decimal operations.
20	*
21	* @internal
22	*/
23	final class DecimalHelper
24	{
25	private function __construct()
26	{
27	}	×
28
29	/**
30	* Computes the scale needed to represent the exact decimal result of a reduced fraction.
31	*
32	* Returns null if the denominator has prime factors other than 2 or 5.
33	*
34	* @param string $denominator The denominator of the reduced fraction. Must be strictly positive.
35	*
36	* @return non-negative-int\|null
37	*
38	* @pure
39	*/
40	public static function computeScaleFromReducedFractionDenominator(string $denominator): ?int
41	{
42	$calculator = CalculatorRegistry::get();	705✔
43
44	$d = rtrim($denominator, '0');	705✔
45
46	/** @var non-negative-int $scale rtrim can only shorten a string */
47	$scale = strlen($denominator) - strlen($d);	705✔
48
49	foreach ([5, 2] as $prime) {	705✔
50	for (; ;) {
51	$lastDigit = (int) $d[-1];	705✔
52
53	if ($lastDigit % $prime !== 0) {	705✔
54	break;	705✔
55	}
56
57	$d = $calculator->divQ($d, (string) $prime);	360✔
58	$scale++;	705✔
59	}
60	}
61
62	return $d === '1' ? $scale : null;	705✔
63	}
64
65	/**
66	* Scales an unscaled decimal value to the requested scale.
67	*
68	* Returns null when rounding is necessary and the rounding mode is Unnecessary.
69	*
70	* @param string $value The unscaled value.
71	* @param int $currentScale The current scale.
72	* @param int $targetScale The target scale.
73	* @param RoundingMode $roundingMode The rounding mode.
74	*
75	* @return string\|null The unscaled value at the target scale, or null if RoundingMode::Unnecessary is used and rounding is necessary.
76	*
77	* @pure
78	*/
79	public static function scale(string $value, int $currentScale, int $targetScale, RoundingMode $roundingMode): ?string
80	{
81	$scaled = self::tryScaleExactly($value, $currentScale, $targetScale);	5,709✔
82
83	if ($scaled !== null) {	5,709✔
84	return $scaled;	2,229✔
85	}
86
87	if ($roundingMode === RoundingMode::Unnecessary) {	3,480✔
88	return null;	51✔
89	}
90
91	$divisor = '1' . str_repeat('0', $currentScale - $targetScale);	3,429✔
92
93	return CalculatorRegistry::get()->divRound($value, $divisor, $roundingMode);	3,429✔
94	}
95
96	/**
97	* Adds leading zeros if necessary to represent the full decimal number.
98	*
99	* @param string $value The unscaled value.
100	* @param int $scale The current scale.
101	*
102	* @pure
103	*/
104	public static function padUnscaledValue(string $value, int $scale): string
105	{
106	$targetLength = $scale + 1;	9,114✔
107	$negative = ($value[0] === '-');	9,114✔
108	$length = strlen($value);	9,114✔
109
110	if ($negative) {	9,114✔
111	$length--;	1,185✔
112	}
113
114	if ($length >= $targetLength) {	9,114✔
115	return $value;	6,492✔
116	}
117
118	if ($negative) {	2,658✔
119	$value = substr($value, 1);	372✔
120	}
121
122	$value = str_pad($value, $targetLength, '0', STR_PAD_LEFT);	2,658✔
123
124	if ($negative) {	2,658✔
125	$value = '-' . $value;	372✔
126	}
127
128	return $value;	2,658✔
129	}
130
131	/**
132	* Tries to scale exactly without rounding, returning null when rounding would be required.
133	*
134	* @param string $value The unscaled value.
135	* @param int $currentScale The current scale.
136	* @param int $targetScale The target scale.
137	*
138	* @return string\|null The unscaled value at the target scale, or null if rounding would be required.
139	*
140	* @pure
141	*/
142	public static function tryScaleExactly(string $value, int $currentScale, int $targetScale): ?string
143	{
144	if ($value === '0' \|\| $targetScale === $currentScale) {	5,967✔
145	return $value;	168✔
146	}
147
148	if ($targetScale > $currentScale) {	5,817✔
149	return $value . str_repeat('0', $targetScale - $currentScale);	12✔
150	}
151
152	$negative = ($value[0] === '-');	5,805✔
153	if ($negative) {	5,805✔
154	$value = substr($value, 1);	51✔
155	}
156
157	$value = self::padUnscaledValue($value, $currentScale);	5,805✔
158	$discardedDigits = $currentScale - $targetScale;	5,805✔
159
160	if (substr($value, -$discardedDigits) !== str_repeat('0', $discardedDigits)) {	5,805✔
161	return null;	3,537✔
162	}
163
164	$value = substr($value, 0, -$discardedDigits);	2,268✔
165	$value = ltrim($value, '0');	2,268✔
166
167	if ($value === '') {	2,268✔
168	return '0';	×
169	}
170
171	if ($negative) {	2,268✔
172	$value = '-' . $value;	33✔
173	}
174
175	return $value;	2,268✔
176	}
177	}

brick / math / 22119510950

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous