ArithmeticProvider - Code Metrics - Inspection of "Merge pull request #127 from JordanRL/f-base-conve..." - JordanRL/Fermat - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c50f33...e75397 )

by Jordan

created 2022-09-25 09:14 UTC

ArithmeticProvider A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	188
Duplicated Lines	0 %

Test Coverage

Coverage

38.89%

Importance

Changes

Metric	Value
eloc	73
c	0
b	0
f	0
dl	0
loc	188
ccs	28
cts	72
cp	0.3889
rs	10
wmc	18

9 Methods

Rating	Name	Size	Complexity
A	squareRoot()	12	2
A	powmod()	14	2
A	modulo()	14	2
A	pow()	13	2
A	divide()	13	2
A	subtract()	13	2
A	multiply()	13	2
A	compare()	11	2
A	add()	13	2

<?php

namespace Samsara\Fermat\Provider;

use Decimal\Decimal;
use Samsara\Exceptions\UsageError\IntegrityConstraint;

/**
 *
 */
class ArithmeticProvider
{

    /**
     * @param string $number1
     * @param string $number2
     * @param $scale
     * @return string
     */
    public static function add(string $number1, string $number2, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($number1, $scale+2);
            $number2 = new Decimal($number2, $scale+2);

            $result = $number1->add($number2);

            $result = $result->toFixed($scale+2);
        } else {
            $result = \bcadd($number1, $number2, $scale);
        }
        return $result;
    }

    /**
     * @param string $left
     * @param string $right
     * @param $scale
     * @return string
     */
    public static function subtract(string $left, string $right, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($left, $scale+2);
            $number2 = new Decimal($right, $scale+2);

            $result = $number1->sub($number2);

            $result = $result->toFixed($scale+2);
        } else {
            $result = \bcsub($left, $right, $scale);
        }
        return $result;
    }

    /**
     * @param string $number1
     * @param string $number2
     * @param $scale
     * @return string
     */
    public static function multiply(string $number1, string $number2, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($number1, $scale+2);
            $number2 = new Decimal($number2, $scale+2);

            $result = $number1->mul($number2);

            $result = $result->toFixed($scale+2);
        } else {
            $result = \bcmul($number1, $number2, $scale);
        }
        return $result;
    }

    /**
     * @param string $numerator
     * @param string $denominator
     * @param $scale
     * @return string
     */
    public static function divide(string $numerator, string $denominator, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($numerator, $scale);
            $number2 = new Decimal($denominator, $scale);

            $result = $number1->div($number2);

            $result = $result->toFixed($scale, false, Decimal::ROUND_TRUNCATE);
        } else {
            $result = \bcdiv($numerator, $denominator, $scale);
        }
        return $result;
    }

    /**
     * @param string $base
     * @param string $exponent
     * @param $scale
     * @return string
     */
    public static function pow(string $base, string $exponent, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($base, $scale+2);
            $number2 = new Decimal($exponent, $scale+2);

            $result = $number1->pow($number2);

            $result = $result->toFixed($scale+2);
        } else {
            $result = \bcpow($base, $exponent, $scale);
        }
        return $result;
    }

    /**
     * @param string $number
     * @param $scale
     * @return string
     */
    public static function squareRoot(string $number, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number = new Decimal($number, $scale+2);

            $result = $number->sqrt();

            $result = $result->toFixed($scale+2);
        } else {
            $result = \bcsqrt($number, $scale);
        }
        return $result;
    }

    /**
     * @param string $number
     * @param $modulo
     * @return string
     */
    public static function modulo(string $number, $modulo)
    {
        if (extension_loaded('decimal')) {
            $precision = (max(strlen($modulo), 12));
            $number1 = new Decimal($number, $precision);
            $number2 = new Decimal($modulo, $precision);

            $result = $number1->mod($number2);

            $result = $result->toString();
        } else {
            $result = \bcmod($number, $modulo);
        }
        return $result;
    }

    /**
     * @param string $left
     * @param string $right
     * @param $scale
     * @return int
     */
    public static function compare(string $left, string $right, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($left, $scale+2);
            $number2 = new Decimal($right, $scale+2);

            $result = $number1->compareTo($number2);
        } else {
            $result = \bccomp($left, $right, $scale);
        }
        return $result;
    }

    /**
     * @param string $left
     * @param string $right
     * @param string $modulus
     * @param $scale
     * @return string
     */
    public static function powmod(string $left, string $right, string $modulus, $scale = 100)
    {
        if (extension_loaded('decimal')) {
            $number1 = new Decimal($left, $scale+2);
            $number2 = new Decimal($right, $scale+2);
            $number3 = new Decimal($modulus, $scale+2);

            $result = $number1->pow($number2)->mod($number3);

            $result = $result->toFixed($scale+2);
        } else {
            $result = \bcpowmod($left, $right, $modulus, $scale);
        }
        return $result;
    }

}

1		<?php
2
3		namespace Samsara\Fermat\Provider;
4
5		use Decimal\Decimal;
6		use Samsara\Exceptions\UsageError\IntegrityConstraint;
7
8		/**
9		*
10		*/
11		class ArithmeticProvider
12		{
13
14		/**
15		* @param string $number1
16		* @param string $number2
17		* @param $scale
18		* @return string
19		*/
20	31	public static function add(string $number1, string $number2, $scale = 100)
21		{
22	31	if (extension_loaded('decimal')) {
23		$number1 = new Decimal($number1, $scale+2);
24		$number2 = new Decimal($number2, $scale+2);
25
26		$result = $number1->add($number2);
27
28		$result = $result->toFixed($scale+2);
29		} else {
30	31	$result = \bcadd($number1, $number2, $scale);
31		}
32	31	return $result;
33		}
34
35		/**
36		* @param string $left
37		* @param string $right
38		* @param $scale
39		* @return string
40		*/
41	30	public static function subtract(string $left, string $right, $scale = 100)
42		{
43	30	if (extension_loaded('decimal')) {
44		$number1 = new Decimal($left, $scale+2);
45		$number2 = new Decimal($right, $scale+2);
46
47		$result = $number1->sub($number2);
48
49		$result = $result->toFixed($scale+2);
50		} else {
51	30	$result = \bcsub($left, $right, $scale);
52		}
53	30	return $result;
54		}
55
56		/**
57		* @param string $number1
58		* @param string $number2
59		* @param $scale
60		* @return string
61		*/
62	33	public static function multiply(string $number1, string $number2, $scale = 100)
63		{
64	33	if (extension_loaded('decimal')) {
65		$number1 = new Decimal($number1, $scale+2);
66		$number2 = new Decimal($number2, $scale+2);
67
68		$result = $number1->mul($number2);
69
70		$result = $result->toFixed($scale+2);
71		} else {
72	33	$result = \bcmul($number1, $number2, $scale);
73		}
74	33	return $result;
75		}
76
77		/**
78		* @param string $numerator
79		* @param string $denominator
80		* @param $scale
81		* @return string
82		*/
83	41	public static function divide(string $numerator, string $denominator, $scale = 100)
84		{
85	41	if (extension_loaded('decimal')) {
86		$number1 = new Decimal($numerator, $scale);
87		$number2 = new Decimal($denominator, $scale);
88
89		$result = $number1->div($number2);
90
91		$result = $result->toFixed($scale, false, Decimal::ROUND_TRUNCATE);
92		} else {
93	41	$result = \bcdiv($numerator, $denominator, $scale);
94		}
95	41	return $result;
96		}
97
98		/**
99		* @param string $base
100		* @param string $exponent
101		* @param $scale
102		* @return string
103		*/
104	29	public static function pow(string $base, string $exponent, $scale = 100)
105		{
106	29	if (extension_loaded('decimal')) {
107		$number1 = new Decimal($base, $scale+2);
108		$number2 = new Decimal($exponent, $scale+2);
109
110		$result = $number1->pow($number2);
111
112		$result = $result->toFixed($scale+2);
113		} else {
114	29	$result = \bcpow($base, $exponent, $scale);
115		}
116	29	return $result;
117		}
118
119		/**
120		* @param string $number
121		* @param $scale
122		* @return string
123		*/
124	12	public static function squareRoot(string $number, $scale = 100)
125		{
126	12	if (extension_loaded('decimal')) {
127		$number = new Decimal($number, $scale+2);
128
129		$result = $number->sqrt();
130
131		$result = $result->toFixed($scale+2);
132		} else {
133	12	$result = \bcsqrt($number, $scale);
134		}
135	12	return $result;
136		}
137
138		/**
139		* @param string $number
140		* @param $modulo
141		* @return string
142		*/
143		public static function modulo(string $number, $modulo)
144		{
145		if (extension_loaded('decimal')) {
146		$precision = (max(strlen($modulo), 12));
147		$number1 = new Decimal($number, $precision);
148		$number2 = new Decimal($modulo, $precision);
149
150		$result = $number1->mod($number2);
151
152		$result = $result->toString();
153		} else {
154		$result = \bcmod($number, $modulo);
155		}
156		return $result;
157		}
158
159		/**
160		* @param string $left
161		* @param string $right
162		* @param $scale
163		* @return int
164		*/
165	106	public static function compare(string $left, string $right, $scale = 100)
166		{
167	106	if (extension_loaded('decimal')) {
168		$number1 = new Decimal($left, $scale+2);
169		$number2 = new Decimal($right, $scale+2);
170
171		$result = $number1->compareTo($number2);
172		} else {
173	106	$result = \bccomp($left, $right, $scale);
174		}
175	106	return $result;
176		}
177
178		/**
179		* @param string $left
180		* @param string $right
181		* @param string $modulus
182		* @param $scale
183		* @return string
184		*/
185		public static function powmod(string $left, string $right, string $modulus, $scale = 100)
186		{
187		if (extension_loaded('decimal')) {
188		$number1 = new Decimal($left, $scale+2);
189		$number2 = new Decimal($right, $scale+2);
190		$number3 = new Decimal($modulus, $scale+2);
191
192		$result = $number1->pow($number2)->mod($number3);
193
194		$result = $result->toFixed($scale+2);
195		} else {
196		$result = \bcpowmod($left, $right, $modulus, $scale);
197		}
198		return $result;
199		}
200
201		}

JordanRL / Fermat

Push — master ( c50f33...e75397 )

ArithmeticProvider A

Complexity

Size/Duplication

Test Coverage

Importance

9 Methods

Duplication Side-by-Side

Filter issues like