Litipk /
php-bignumbers
Complex classes like Decimal often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Decimal, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 17 | class Decimal |
||
| 18 | { |
||
| 19 | const DEFAULT_SCALE = 16; |
||
| 20 | const CLASSIC_DECIMAL_NUMBER_REGEXP = '/^([+\-]?)0*(([1-9][0-9]*|[0-9])(\.[0-9]+)?)$/'; |
||
| 21 | const EXP_NOTATION_NUMBER_REGEXP = '/^ (?P<sign> [+\-]?) 0*(?P<mantissa> [0-9](?P<decimals> \.[0-9]+)?) [eE] (?P<expSign> [+\-]?)(?P<exp> \d+)$/x'; |
||
| 22 | const EXP_NUM_GROUPS_NUMBER_REGEXP = '/^ (?P<int> \d*) (?: \. (?P<dec> \d+) ) E (?P<sign>[\+\-]) (?P<exp>\d+) $/x'; |
||
| 23 | |||
| 24 | /** |
||
| 25 | * Internal numeric value |
||
| 26 | * @var string |
||
| 27 | */ |
||
| 28 | protected $value; |
||
| 29 | |||
| 30 | /** |
||
| 31 | * Number of digits behind the point |
||
| 32 | * @var integer |
||
| 33 | */ |
||
| 34 | private $scale; |
||
| 35 | |||
| 36 | 157 | private function __construct(string $value, int $scale) |
|
| 41 | |||
| 42 | private function __clone() |
||
| 45 | |||
| 46 | /** |
||
| 47 | * Decimal "constructor". |
||
| 48 | * |
||
| 49 | * @param mixed $value |
||
| 50 | * @param int $scale |
||
| 51 | * @return Decimal |
||
| 52 | */ |
||
| 53 | 9 | public static function create($value, int $scale = null): Decimal |
|
| 54 | { |
||
| 55 | 9 | if (\is_int($value)) { |
|
| 56 | 4 | return self::fromInteger($value); |
|
| 57 | 8 | } elseif (\is_float($value)) { |
|
| 58 | 4 | return self::fromFloat($value, $scale); |
|
| 59 | 4 | } elseif (\is_string($value)) { |
|
| 60 | 2 | return self::fromString($value, $scale); |
|
| 61 | 2 | } elseif ($value instanceof Decimal) { |
|
| 62 | 1 | return self::fromDecimal($value, $scale); |
|
| 63 | } else { |
||
| 64 | 1 | throw new \TypeError( |
|
| 65 | 'Expected (int, float, string, Decimal), but received ' . |
||
|
|
|||
| 66 | 1 | (\is_object($value) ? \get_class($value) : \gettype($value)) |
|
| 67 | ); |
||
| 68 | } |
||
| 69 | } |
||
| 70 | |||
| 71 | 98 | public static function fromInteger(int $intValue): Decimal |
|
| 77 | |||
| 78 | /** |
||
| 79 | * @param float $fltValue |
||
| 80 | * @param int $scale |
||
| 81 | * @return Decimal |
||
| 82 | */ |
||
| 83 | 35 | public static function fromFloat(float $fltValue, int $scale = null): Decimal |
|
| 84 | { |
||
| 85 | 35 | self::paramsValidation($fltValue, $scale); |
|
| 86 | |||
| 87 | 35 | if (\is_infinite($fltValue)) { |
|
| 88 | throw new InfiniteInputError('fltValue must be a finite number'); |
||
| 89 | 35 | } elseif (\is_nan($fltValue)) { |
|
| 90 | 1 | throw new NaNInputError("fltValue can't be NaN"); |
|
| 91 | } |
||
| 92 | |||
| 93 | 34 | $strValue = (string) $fltValue; |
|
| 94 | 34 | $hasPoint = (false !== \strpos($strValue, '.')); |
|
| 95 | |||
| 96 | 34 | if (\preg_match(self::EXP_NUM_GROUPS_NUMBER_REGEXP, $strValue, $capture)) { |
|
| 97 | 6 | if (null === $scale) { |
|
| 98 | 3 | $scale = ('-' === $capture['sign']) |
|
| 99 | 2 | ? $capture['exp'] + \strlen($capture['dec']) |
|
| 100 | 3 | : self::DEFAULT_SCALE; |
|
| 101 | } |
||
| 102 | 6 | $strValue = \number_format($fltValue, $scale, '.', ''); |
|
| 103 | } else { |
||
| 104 | $naturalScale = ( |
||
| 105 | 28 | \strlen((string)\fmod($fltValue, 1.0)) - 2 - (($fltValue < 0) ? 1 : 0) + (!$hasPoint ? 1 : 0) |
|
| 106 | ); |
||
| 107 | |||
| 108 | 28 | if (null === $scale) { |
|
| 109 | 26 | $scale = $naturalScale; |
|
| 110 | } else { |
||
| 111 | 2 | $strValue .= ($hasPoint ? '' : '.') . \str_pad('', $scale - $naturalScale, '0'); |
|
| 112 | } |
||
| 113 | } |
||
| 114 | |||
| 115 | 34 | return new static($strValue, $scale); |
|
| 116 | } |
||
| 117 | |||
| 118 | /** |
||
| 119 | * @param string $strValue |
||
| 120 | * @param integer $scale |
||
| 121 | * @return Decimal |
||
| 122 | */ |
||
| 123 | 131 | public static function fromString(string $strValue, int $scale = null): Decimal |
|
| 124 | { |
||
| 125 | 131 | self::paramsValidation($strValue, $scale); |
|
| 126 | |||
| 127 | 130 | if (\preg_match(self::CLASSIC_DECIMAL_NUMBER_REGEXP, $strValue, $captures) === 1) { |
|
| 128 | |||
| 129 | // Now it's time to strip leading zeros in order to normalize inner values |
||
| 130 | 125 | $value = self::normalizeSign($captures[1]) . $captures[2]; |
|
| 131 | 125 | $min_scale = isset($captures[4]) ? \max(0, \strlen($captures[4]) - 1) : 0; |
|
| 132 | |||
| 133 | 8 | } elseif (\preg_match(self::EXP_NOTATION_NUMBER_REGEXP, $strValue, $captures) === 1) { |
|
| 134 | 7 | list($min_scale, $value) = self::fromExpNotationString( |
|
| 135 | 7 | $scale, |
|
| 136 | 7 | $captures['sign'], |
|
| 137 | 7 | $captures['mantissa'], |
|
| 138 | 7 | \strlen($captures['mantissa']) - 1, |
|
| 139 | 7 | $captures['expSign'], |
|
| 140 | 7 | (int)$captures['exp'] |
|
| 141 | ); |
||
| 142 | } else { |
||
| 143 | 1 | throw new NaNInputError('strValue must be a number'); |
|
| 144 | } |
||
| 145 | |||
| 146 | 129 | $scale = $scale ?? $min_scale; |
|
| 147 | 129 | if ($scale < $min_scale) { |
|
| 148 | 68 | $value = self::innerRound($value, $scale); |
|
| 149 | 126 | } elseif ($min_scale < $scale) { |
|
| 150 | 17 | $hasPoint = (false !== \strpos($value, '.')); |
|
| 151 | 17 | $value .= ($hasPoint ? '' : '.') . \str_pad('', $scale - $min_scale, '0'); |
|
| 152 | } |
||
| 153 | |||
| 154 | 129 | return new static($value, $scale); |
|
| 155 | } |
||
| 156 | |||
| 157 | /** |
||
| 158 | * Constructs a new Decimal object based on a previous one, |
||
| 159 | * but changing it's $scale property. |
||
| 160 | * |
||
| 161 | * @param Decimal $decValue |
||
| 162 | * @param null|int $scale |
||
| 163 | * @return Decimal |
||
| 164 | */ |
||
| 165 | 3 | public static function fromDecimal(Decimal $decValue, int $scale = null): Decimal |
|
| 179 | |||
| 180 | /** |
||
| 181 | * Adds two Decimal objects |
||
| 182 | * @param Decimal $b |
||
| 183 | * @param null|int $scale |
||
| 184 | * @return Decimal |
||
| 185 | */ |
||
| 186 | 40 | public function add(Decimal $b, int $scale = null): Decimal |
|
| 195 | |||
| 196 | /** |
||
| 197 | * Subtracts two BigNumber objects |
||
| 198 | * @param Decimal $b |
||
| 199 | * @param integer $scale |
||
| 200 | * @return Decimal |
||
| 201 | */ |
||
| 202 | 33 | public function sub(Decimal $b, int $scale = null): Decimal |
|
| 211 | |||
| 212 | /** |
||
| 213 | * Multiplies two BigNumber objects |
||
| 214 | * @param Decimal $b |
||
| 215 | * @param integer $scale |
||
| 216 | * @return Decimal |
||
| 217 | */ |
||
| 218 | 48 | public function mul(Decimal $b, int $scale = null): Decimal |
|
| 231 | |||
| 232 | /** |
||
| 233 | * Divides the object by $b . |
||
| 234 | * Warning: div with $scale == 0 is not the same as |
||
| 235 | * integer division because it rounds the |
||
| 236 | * last digit in order to minimize the error. |
||
| 237 | * |
||
| 238 | * @param Decimal $b |
||
| 239 | * @param integer $scale |
||
| 240 | * @return Decimal |
||
| 241 | */ |
||
| 242 | 63 | public function div(Decimal $b, int $scale = null): Decimal |
|
| 277 | |||
| 278 | /** |
||
| 279 | * Returns the square root of this object |
||
| 280 | * @param integer $scale |
||
| 281 | * @return Decimal |
||
| 282 | */ |
||
| 283 | 4 | public function sqrt(int $scale = null): Decimal |
|
| 300 | |||
| 301 | /** |
||
| 302 | * Powers this value to $b |
||
| 303 | * |
||
| 304 | * @param Decimal $b exponent |
||
| 305 | * @param integer $scale |
||
| 306 | * @return Decimal |
||
| 307 | */ |
||
| 308 | 10 | public function pow(Decimal $b, int $scale = null): Decimal |
|
| 309 | { |
||
| 310 | 10 | if ($this->isZero()) { |
|
| 311 | 2 | if ($b->isPositive()) { |
|
| 312 | 1 | return Decimal::fromDecimal($this, $scale); |
|
| 313 | } else { |
||
| 314 | 1 | throw new \DomainException("zero can't be powered to zero or negative numbers."); |
|
| 315 | } |
||
| 316 | 8 | } elseif ($b->isZero()) { |
|
| 317 | 1 | return DecimalConstants::One(); |
|
| 318 | 7 | } else if ($b->isNegative()) { |
|
| 319 | 2 | return DecimalConstants::One()->div( |
|
| 320 | 2 | $this->pow($b->additiveInverse(), max($scale, self::DEFAULT_SCALE)), |
|
| 321 | 2 | max($scale, self::DEFAULT_SCALE) |
|
| 322 | ); |
||
| 323 | 7 | } elseif (0 === $b->scale) { |
|
| 324 | 4 | $pow_scale = \max($this->scale, $b->scale, $scale ?? 0); |
|
| 325 | |||
| 326 | 4 | return self::fromString( |
|
| 327 | 4 | \bcpow($this->value, $b->value, $pow_scale+1), |
|
| 328 | 4 | $pow_scale |
|
| 329 | ); |
||
| 330 | } else { |
||
| 331 | 4 | if ($this->isPositive()) { |
|
| 332 | 3 | $pow_scale = \max($this->scale, $b->scale, $scale ?? 0); |
|
| 333 | |||
| 334 | 3 | $truncated_b = \bcadd($b->value, '0', 0); |
|
| 335 | 3 | $remaining_b = \bcsub($b->value, $truncated_b, $b->scale); |
|
| 336 | |||
| 337 | 3 | $first_pow_approx = \bcpow($this->value, $truncated_b, $pow_scale+1); |
|
| 338 | 3 | $intermediate_root = self::innerPowWithLittleExponent( |
|
| 339 | 3 | $this->value, |
|
| 340 | 3 | $remaining_b, |
|
| 341 | 3 | $b->scale, |
|
| 342 | 3 | $pow_scale+1 |
|
| 343 | ); |
||
| 344 | |||
| 345 | 3 | return Decimal::fromString( |
|
| 346 | 3 | \bcmul($first_pow_approx, $intermediate_root, $pow_scale+1), |
|
| 347 | 3 | $pow_scale |
|
| 348 | ); |
||
| 349 | } else { // elseif ($this->isNegative()) |
||
| 350 | 1 | if (!$b->isInteger()) { |
|
| 351 | 1 | throw new NotImplementedError( |
|
| 352 | "Usually negative numbers can't be powered to non integer numbers. " . |
||
| 353 | 1 | "The cases where is possible are not implemented." |
|
| 354 | ); |
||
| 355 | } |
||
| 356 | |||
| 357 | return (\preg_match('/^[+\-]?[0-9]*[02468](\.0+)?$/', $b->value, $captures) === 1) |
||
| 358 | ? $this->additiveInverse()->pow($b, $scale) // $b is an even number |
||
| 359 | : $this->additiveInverse()->pow($b, $scale)->additiveInverse(); // $b is an odd number |
||
| 360 | } |
||
| 361 | } |
||
| 362 | } |
||
| 363 | |||
| 364 | /** |
||
| 365 | * Returns the object's logarithm in base 10 |
||
| 366 | * @param integer $scale |
||
| 367 | * @return Decimal |
||
| 368 | */ |
||
| 369 | 5 | public function log10(int $scale = null): Decimal |
|
| 386 | |||
| 387 | 94 | public function isZero(int $scale = null): bool |
|
| 393 | |||
| 394 | 29 | public function isPositive(): bool |
|
| 398 | |||
| 399 | 69 | public function isNegative(): bool |
|
| 403 | |||
| 404 | 3 | public function isInteger(): bool |
|
| 408 | |||
| 409 | /** |
||
| 410 | * Equality comparison between this object and $b |
||
| 411 | * @param Decimal $b |
||
| 412 | * @param integer $scale |
||
| 413 | * @return boolean |
||
| 414 | */ |
||
| 415 | 115 | public function equals(Decimal $b, int $scale = null): bool |
|
| 433 | |||
| 434 | /** |
||
| 435 | * $this > $b : returns 1 , $this < $b : returns -1 , $this == $b : returns 0 |
||
| 436 | * |
||
| 437 | * @param Decimal $b |
||
| 438 | * @param integer $scale |
||
| 439 | * @return integer |
||
| 440 | */ |
||
| 441 | 42 | public function comp(Decimal $b, int $scale = null): int |
|
| 457 | |||
| 458 | /** |
||
| 459 | * Returns the element's additive inverse. |
||
| 460 | * @return Decimal |
||
| 461 | */ |
||
| 462 | 15 | public function additiveInverse(): Decimal |
|
| 474 | |||
| 475 | |||
| 476 | /** |
||
| 477 | * "Rounds" the Decimal to have at most $scale digits after the point |
||
| 478 | * @param integer $scale |
||
| 479 | * @return Decimal |
||
| 480 | */ |
||
| 481 | 52 | public function round(int $scale = 0): Decimal |
|
| 489 | |||
| 490 | /** |
||
| 491 | * "Ceils" the Decimal to have at most $scale digits after the point |
||
| 492 | * @param integer $scale |
||
| 493 | * @return Decimal |
||
| 494 | */ |
||
| 495 | 4 | public function ceil($scale = 0): Decimal |
|
| 507 | |||
| 508 | 28 | private function innerTruncate(int $scale = 0, bool $ceil = true): Decimal |
|
| 531 | |||
| 532 | /** |
||
| 533 | * "Floors" the Decimal to have at most $scale digits after the point |
||
| 534 | * @param integer $scale |
||
| 535 | * @return Decimal |
||
| 536 | */ |
||
| 537 | 47 | public function floor(int $scale = 0): Decimal |
|
| 549 | |||
| 550 | /** |
||
| 551 | * Returns the absolute value (always a positive number) |
||
| 552 | * @return Decimal |
||
| 553 | */ |
||
| 554 | 21 | public function abs(): Decimal |
|
| 560 | |||
| 561 | /** |
||
| 562 | * Calculate modulo with a decimal |
||
| 563 | * @param Decimal $d |
||
| 564 | * @param integer $scale |
||
| 565 | * @return $this % $d |
||
| 566 | */ |
||
| 567 | 27 | public function mod(Decimal $d, int $scale = null): Decimal |
|
| 572 | |||
| 573 | /** |
||
| 574 | * Calculates the sine of this method with the highest possible accuracy |
||
| 575 | * Note that accuracy is limited by the accuracy of predefined PI; |
||
| 576 | * |
||
| 577 | * @param integer $scale |
||
| 578 | * @return Decimal sin($this) |
||
| 579 | */ |
||
| 580 | 13 | public function sin(int $scale = null): Decimal |
|
| 581 | { |
||
| 582 | // First normalise the number in the [0, 2PI] domain |
||
| 583 | 13 | $x = $this->mod(DecimalConstants::PI()->mul(Decimal::fromString("2"))); |
|
| 584 | |||
| 585 | // PI has only 32 significant numbers |
||
| 586 | 13 | $scale = (null === $scale) ? 32 : $scale; |
|
| 587 | |||
| 588 | 13 | return self::factorialSerie( |
|
| 589 | 13 | $x, |
|
| 590 | 13 | DecimalConstants::zero(), |
|
| 591 | function ($i) { |
||
| 592 | 13 | return ($i % 2 === 1) ? ( |
|
| 593 | 13 | ($i % 4 === 1) ? DecimalConstants::one() : DecimalConstants::negativeOne() |
|
| 594 | 13 | ) : DecimalConstants::zero(); |
|
| 595 | 13 | }, |
|
| 596 | 13 | $scale |
|
| 597 | ); |
||
| 598 | } |
||
| 599 | |||
| 600 | /** |
||
| 601 | * Calculates the cosecant of this with the highest possible accuracy |
||
| 602 | * Note that accuracy is limited by the accuracy of predefined PI; |
||
| 603 | * |
||
| 604 | * @param integer $scale |
||
| 605 | * @return Decimal |
||
| 606 | */ |
||
| 607 | 3 | public function cosec(int $scale = null): Decimal |
|
| 618 | |||
| 619 | /** |
||
| 620 | * Calculates the cosine of this method with the highest possible accuracy |
||
| 621 | * Note that accuracy is limited by the accuracy of predefined PI; |
||
| 622 | * |
||
| 623 | * @param integer $scale |
||
| 624 | * @return Decimal cos($this) |
||
| 625 | */ |
||
| 626 | 13 | public function cos(int $scale = null): Decimal |
|
| 627 | { |
||
| 628 | // First normalise the number in the [0, 2PI] domain |
||
| 629 | 13 | $x = $this->mod(DecimalConstants::PI()->mul(Decimal::fromString("2"))); |
|
| 630 | |||
| 631 | // PI has only 32 significant numbers |
||
| 632 | 13 | $scale = ($scale === null) ? 32 : $scale; |
|
| 633 | |||
| 634 | 13 | return self::factorialSerie( |
|
| 635 | 13 | $x, |
|
| 636 | 13 | DecimalConstants::one(), |
|
| 637 | function ($i) { |
||
| 638 | 13 | return ($i % 2 === 0) ? ( |
|
| 639 | 13 | ($i % 4 === 0) ? DecimalConstants::one() : DecimalConstants::negativeOne() |
|
| 640 | 13 | ) : DecimalConstants::zero(); |
|
| 641 | 13 | }, |
|
| 642 | 13 | $scale |
|
| 643 | ); |
||
| 644 | } |
||
| 645 | |||
| 646 | /** |
||
| 647 | * Calculates the secant of this with the highest possible accuracy |
||
| 648 | * Note that accuracy is limited by the accuracy of predefined PI; |
||
| 649 | * |
||
| 650 | * @param integer $scale |
||
| 651 | * @return Decimal |
||
| 652 | */ |
||
| 653 | 3 | public function sec(int $scale = null): Decimal |
|
| 664 | |||
| 665 | /** |
||
| 666 | * Calculates the arcsine of this with the highest possible accuracy |
||
| 667 | * |
||
| 668 | * @param integer $scale |
||
| 669 | * @return Decimal |
||
| 670 | */ |
||
| 671 | 5 | public function arcsin(int $scale = null): Decimal |
|
| 672 | { |
||
| 673 | 5 | if($this->comp(DecimalConstants::one(), $scale + 2) === 1 || $this->comp(DecimalConstants::negativeOne(), $scale + 2) === -1) { |
|
| 674 | 2 | throw new \DomainException( |
|
| 675 | 2 | "The arcsin of this number is undefined." |
|
| 676 | ); |
||
| 677 | } |
||
| 678 | |||
| 679 | 3 | if ($this->round($scale)->isZero()) { |
|
| 680 | return DecimalConstants::zero(); |
||
| 681 | } |
||
| 682 | 3 | if ($this->round($scale)->equals(DecimalConstants::one())) { |
|
| 683 | 1 | return DecimalConstants::pi()->div(Decimal::fromInteger(2))->round($scale); |
|
| 684 | } |
||
| 685 | 2 | if ($this->round($scale)->equals(DecimalConstants::negativeOne())) { |
|
| 686 | 1 | return DecimalConstants::pi()->div(Decimal::fromInteger(-2))->round($scale); |
|
| 687 | } |
||
| 688 | |||
| 689 | 1 | $scale = ($scale === null) ? 32 : $scale; |
|
| 690 | |||
| 691 | 1 | return self::powerSerie( |
|
| 692 | 1 | $this, |
|
| 693 | 1 | DecimalConstants::zero(), |
|
| 694 | 1 | $scale |
|
| 695 | ); |
||
| 696 | } |
||
| 697 | |||
| 698 | /** |
||
| 699 | * Calculates the arccosine of this with the highest possible accuracy |
||
| 700 | * |
||
| 701 | * @param integer $scale |
||
| 702 | * @return Decimal |
||
| 703 | */ |
||
| 704 | 5 | public function arccos(int $scale = null): Decimal |
|
| 705 | { |
||
| 706 | 5 | if($this->comp(DecimalConstants::one(), $scale + 2) === 1 || $this->comp(DecimalConstants::negativeOne(), $scale + 2) === -1) { |
|
| 707 | 2 | throw new \DomainException( |
|
| 708 | 2 | "The arccos of this number is undefined." |
|
| 709 | ); |
||
| 710 | } |
||
| 711 | |||
| 712 | 3 | $piOverTwo = DecimalConstants::pi()->div(Decimal::fromInteger(2), $scale + 2)->round($scale); |
|
| 713 | |||
| 714 | 3 | if ($this->round($scale)->isZero()) { |
|
| 715 | return $piOverTwo; |
||
| 716 | } |
||
| 717 | 3 | if ($this->round($scale)->equals(DecimalConstants::one())) { |
|
| 718 | 1 | return DecimalConstants::zero(); |
|
| 719 | } |
||
| 720 | 2 | if ($this->round($scale)->equals(DecimalConstants::negativeOne())) { |
|
| 721 | 1 | return DecimalConstants::pi()->round($scale); |
|
| 722 | } |
||
| 723 | |||
| 724 | 1 | $scale = ($scale === null) ? 32 : $scale; |
|
| 725 | |||
| 726 | 1 | return $piOverTwo->sub( |
|
| 727 | 1 | self::powerSerie( |
|
| 728 | 1 | $this, |
|
| 729 | 1 | DecimalConstants::zero(), |
|
| 730 | 1 | $scale |
|
| 731 | ) |
||
| 732 | 1 | )->round($scale); |
|
| 733 | } |
||
| 734 | |||
| 735 | /** |
||
| 736 | * Calculates the arctangente of this with the highest possible accuracy |
||
| 737 | * |
||
| 738 | * @param integer $scale |
||
| 739 | * @return Decimal |
||
| 740 | */ |
||
| 741 | 3 | public function arctan(int $scale = null): Decimal |
|
| 742 | { |
||
| 743 | 3 | $piOverFour = DecimalConstants::pi()->div(Decimal::fromInteger(4), $scale + 2)->round($scale); |
|
| 744 | |||
| 745 | 3 | if ($this->round($scale)->isZero()) { |
|
| 746 | 1 | return DecimalConstants::zero(); |
|
| 747 | } |
||
| 748 | 2 | if ($this->round($scale)->equals(DecimalConstants::one())) { |
|
| 749 | return $piOverFour; |
||
| 750 | } |
||
| 751 | 2 | if ($this->round($scale)->equals(DecimalConstants::negativeOne())) { |
|
| 752 | 1 | return DecimalConstants::negativeOne()->mul($piOverFour); |
|
| 753 | } |
||
| 754 | |||
| 755 | 1 | $scale = ($scale === null) ? 32 : $scale; |
|
| 756 | |||
| 757 | 1 | return self::simplePowerSerie( |
|
| 758 | 1 | $this, |
|
| 759 | 1 | DecimalConstants::zero(), |
|
| 760 | 1 | $scale + 2 |
|
| 761 | 1 | )->round($scale); |
|
| 762 | } |
||
| 763 | |||
| 764 | /** |
||
| 765 | * Calculates the arccotangente of this with the highest possible accuracy |
||
| 766 | * |
||
| 767 | * @param integer $scale |
||
| 768 | * @return Decimal |
||
| 769 | */ |
||
| 770 | 3 | public function arccot(int $scale = null): Decimal |
|
| 771 | { |
||
| 772 | 3 | $scale = ($scale === null) ? 32 : $scale; |
|
| 773 | |||
| 774 | 3 | $piOverTwo = DecimalConstants::pi()->div(Decimal::fromInteger(2), $scale + 2); |
|
| 775 | 3 | if ($this->round($scale)->isZero()) { |
|
| 776 | 1 | return $piOverTwo->round($scale); |
|
| 777 | } |
||
| 778 | |||
| 779 | 2 | $piOverFour = DecimalConstants::pi()->div(Decimal::fromInteger(4), $scale + 2); |
|
| 780 | 2 | if ($this->round($scale)->equals(DecimalConstants::one())) { |
|
| 781 | return $piOverFour->round($scale); |
||
| 782 | } |
||
| 783 | 2 | if ($this->round($scale)->equals(DecimalConstants::negativeOne())) { |
|
| 784 | 1 | return DecimalConstants::negativeOne()->mul($piOverFour, $scale + 2)->round($scale); |
|
| 785 | } |
||
| 786 | |||
| 787 | 1 | return $piOverTwo->sub( |
|
| 788 | 1 | self::simplePowerSerie( |
|
| 789 | 1 | $this, |
|
| 790 | 1 | DecimalConstants::zero(), |
|
| 791 | 1 | $scale + 2 |
|
| 792 | ) |
||
| 793 | 1 | )->round($scale); |
|
| 794 | } |
||
| 795 | |||
| 796 | /** |
||
| 797 | * Calculates the arcsecant of this with the highest possible accuracy |
||
| 798 | * |
||
| 799 | * @param integer $scale |
||
| 800 | * @return Decimal |
||
| 801 | */ |
||
| 802 | 5 | public function arcsec(int $scale = null): Decimal |
|
| 829 | |||
| 830 | /** |
||
| 831 | * Calculates the arccosecant of this with the highest possible accuracy |
||
| 832 | * |
||
| 833 | * @param integer $scale |
||
| 834 | * @return Decimal |
||
| 835 | */ |
||
| 836 | 5 | public function arccsc(int $scale = null): Decimal |
|
| 859 | |||
| 860 | /** |
||
| 861 | * Returns exp($this), said in other words: e^$this . |
||
| 862 | * |
||
| 863 | * @param integer $scale |
||
| 864 | * @return Decimal |
||
| 865 | */ |
||
| 866 | 11 | public function exp(int $scale = null): Decimal |
|
| 881 | |||
| 882 | /** |
||
| 883 | * Internal method used to compute sin, cos and exp |
||
| 884 | * |
||
| 885 | * @param Decimal $x |
||
| 886 | * @param Decimal $firstTerm |
||
| 887 | * @param callable $generalTerm |
||
| 888 | * @param $scale |
||
| 889 | * @return Decimal |
||
| 890 | */ |
||
| 891 | 28 | private static function factorialSerie (Decimal $x, Decimal $firstTerm, callable $generalTerm, int $scale): Decimal |
|
| 915 | |||
| 916 | |||
| 917 | /** |
||
| 918 | * Internal method used to compute arcsine and arcosine |
||
| 919 | * |
||
| 920 | * @param Decimal $x |
||
| 921 | * @param Decimal $firstTerm |
||
| 922 | * @param $scale |
||
| 923 | * @return Decimal |
||
| 924 | */ |
||
| 925 | 6 | private static function powerSerie (Decimal $x, Decimal $firstTerm, int $scale): Decimal |
|
| 965 | |||
| 966 | /** |
||
| 967 | * Internal method used to compute arctan and arccotan |
||
| 968 | * |
||
| 969 | * @param Decimal $x |
||
| 970 | * @param Decimal $firstTerm |
||
| 971 | * @param $scale |
||
| 972 | * @return Decimal |
||
| 973 | */ |
||
| 974 | 2 | private static function simplePowerSerie (Decimal $x, Decimal $firstTerm, int $scale): Decimal |
|
| 1003 | |||
| 1004 | /** |
||
| 1005 | * Calculates the tangent of this method with the highest possible accuracy |
||
| 1006 | * Note that accuracy is limited by the accuracy of predefined PI; |
||
| 1007 | * |
||
| 1008 | * @param integer $scale |
||
| 1009 | * @return Decimal tan($this) |
||
| 1010 | */ |
||
| 1011 | 4 | public function tan(int $scale = null): Decimal |
|
| 1022 | |||
| 1023 | /** |
||
| 1024 | * Calculates the cotangent of this method with the highest possible accuracy |
||
| 1025 | * Note that accuracy is limited by the accuracy of predefined PI; |
||
| 1026 | * |
||
| 1027 | * @param integer $scale |
||
| 1028 | * @return Decimal cotan($this) |
||
| 1029 | */ |
||
| 1030 | 4 | public function cotan(int $scale = null): Decimal |
|
| 1041 | |||
| 1042 | /** |
||
| 1043 | * Indicates if the passed parameter has the same sign as the method's bound object. |
||
| 1044 | * |
||
| 1045 | * @param Decimal $b |
||
| 1046 | * @return bool |
||
| 1047 | */ |
||
| 1048 | public function hasSameSign(Decimal $b): bool |
||
| 1052 | |||
| 1053 | 3 | public function asFloat(): float |
|
| 1057 | |||
| 1058 | 1 | public function asInteger(): int |
|
| 1062 | |||
| 1063 | /** |
||
| 1064 | * WARNING: use with caution! Return the inner representation of the class. |
||
| 1065 | */ |
||
| 1066 | 11 | public function innerValue(): string |
|
| 1070 | |||
| 1071 | /** |
||
| 1072 | * @return string |
||
| 1073 | */ |
||
| 1074 | 58 | public function __toString(): string |
|
| 1078 | |||
| 1079 | /* |
||
| 1080 | * |
||
| 1081 | */ |
||
| 1082 | 7 | private static function fromExpNotationString( |
|
| 1112 | |||
| 1113 | /** |
||
| 1114 | * "Rounds" the decimal string to have at most $scale digits after the point |
||
| 1115 | * |
||
| 1116 | * @param string $value |
||
| 1117 | * @param int $scale |
||
| 1118 | * @return string |
||
| 1119 | */ |
||
| 1120 | 136 | private static function innerRound(string $value, int $scale = 0): string |
|
| 1135 | |||
| 1136 | /** |
||
| 1137 | * Calculates the logarithm (in base 10) of $value |
||
| 1138 | * |
||
| 1139 | * @param string $value The number we want to calculate its logarithm (only positive numbers) |
||
| 1140 | * @param int $in_scale Expected scale used by $value (only positive numbers) |
||
| 1141 | * @param int $out_scale Scale used by the return value (only positive numbers) |
||
| 1142 | * @return string |
||
| 1143 | */ |
||
| 1144 | 23 | private static function innerLog10(string $value, int $in_scale, int $out_scale): string |
|
| 1180 | |||
| 1181 | /** |
||
| 1182 | * Returns $base^$exponent |
||
| 1183 | * |
||
| 1184 | * @param string $base |
||
| 1185 | * @param string $exponent 0 < $exponent < 1 |
||
| 1186 | * @param int $exp_scale Number of $exponent's significative digits |
||
| 1187 | * @param int $out_scale Number of significative digits that we want to compute |
||
| 1188 | * @return string |
||
| 1189 | */ |
||
| 1190 | 3 | private static function innerPowWithLittleExponent( |
|
| 1218 | |||
| 1219 | /** |
||
| 1220 | * Auxiliar method. It helps us to decompose the exponent into many summands. |
||
| 1221 | * |
||
| 1222 | * @param string $exponent_remaining |
||
| 1223 | * @param int $actual_index |
||
| 1224 | * @param int $exp_scale Number of $exponent's significative digits |
||
| 1225 | * @param int $inner_scale ceil($exp_scale*log(10)/log(2))+1; |
||
| 1226 | * @return array |
||
| 1227 | */ |
||
| 1228 | 3 | private static function computeSquareIndex( |
|
| 1246 | |||
| 1247 | /** |
||
| 1248 | * Auxiliar method. Computes $base^((1/2)^$index) |
||
| 1249 | * |
||
| 1250 | * @param string $base |
||
| 1251 | * @param integer $index |
||
| 1252 | * @param integer $out_scale |
||
| 1253 | * @return string |
||
| 1254 | */ |
||
| 1255 | 3 | private static function compute2NRoot(string $base, int $index, int $out_scale): string |
|
| 1265 | |||
| 1266 | /** |
||
| 1267 | * Validates basic constructor's arguments |
||
| 1268 | * @param mixed $value |
||
| 1269 | * @param null|int $scale |
||
| 1270 | */ |
||
| 1271 | 160 | protected static function paramsValidation($value, int $scale = null) |
|
| 1281 | |||
| 1282 | /** |
||
| 1283 | * @return string |
||
| 1284 | */ |
||
| 1285 | 129 | private static function normalizeSign(string $sign): string |
|
| 1293 | |||
| 1294 | /** |
||
| 1295 | * Counts the number of significant digits of $val. |
||
| 1296 | * Assumes a consistent internal state (without zeros at the end or the start). |
||
| 1297 | * |
||
| 1298 | * @param Decimal $val |
||
| 1299 | * @param Decimal $abs $val->abs() |
||
| 1300 | * @return int |
||
| 1301 | */ |
||
| 1302 | 20 | private static function countSignificativeDigits(Decimal $val, Decimal $abs): int |
|
| 1308 | } |
||
| 1309 |
Loading history...
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue.
If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress.
In this case you can add the
@ignorePhpDoc annotation to the duplicate definition and it will be ignored.