Release/3.3.0 (#23)

Author: gustavofreze

README.md

@@ -163,18 +163,6 @@ rounding occurs:
     $result->toString(); # 0.99
     ```
 
-#### Negate
-
-Sometimes it is necessary to convert a value to negative, in these cases you can use the `negate` method.
-
-```php
-$value = BigDecimal::fromFloat(value: 1);
-
-$result = $value->negate();
-
-$result->toString(); # -1
-```
-
 #### Others
 
 Check out other available resources by looking at the [BigNumber](src/BigNumber.php) interface.

src/BigNumber.php

@@ -113,13 +113,6 @@ public function isZero(): bool;
      */
     public function multiply(BigNumber $multiplier): BigNumber;
 
-    /**
-     * Returns a new BigNumber with the negated value of the current BigNumber.
-     *
-     * @return BigNumber A new BigNumber representing the negated value of the current number.
-     */
-    public function negate(): BigNumber;
-
     /**
      * Subtracts another BigNumber (subtrahend) from the current BigNumber (minuend).
      *

src/Internal/BigNumberBehavior.php

@@ -74,13 +74,6 @@ public function withScale(int $scale): BigNumber
         return static::fromString(value: $number->value, scale: $scale);
     }
 
-    public function negate(): BigNumber
-    {
-        $multiplicand = static::fromFloat(value: -1);
-
-        return $this->multiply(multiplier: $multiplicand);
-    }
-
     public function getScale(): ?int
     {
         return $this->scale->value;

tests/BigNumberTest.php

@@ -75,31 +75,6 @@ public function testDivide(int $scale, mixed $value, mixed $other, array $expect
         self::assertSame(floatval($expected['float']), $actual->toFloat());
     }
 
-    public function testNegate(): void
-    {
-        /** @Given a BigNumber instance */
-        $value = LargeNumber::fromFloat(value: 123.45);
-
-        /** @When calling the negate method */
-        $actual = $value->negate();
-
-        /** @Then the result should be the negative of the original value */
-        self::assertInstanceOf(LargeNumber::class, $actual);
-        self::assertSame('-123.45', $actual->toString());
-        self::assertSame(-123.45, $actual->toFloat());
-
-        /** @Given a BigNumber instance with a negative value */
-        $negativeValue = LargeNumber::fromFloat(value: -543.21);
-
-        /** @When calling the negate method */
-        $actualNegative = $negativeValue->negate();
-
-        /** @Then the result should be the positive of the original negative value */
-        self::assertInstanceOf(LargeNumber::class, $actualNegative);
-        self::assertSame('543.21', $actualNegative->toString());
-        self::assertSame(543.21, $actualNegative->toFloat());
-    }
-
     #[DataProvider('providerForTestDivisionByZero')]
     public function testDivisionByZero(mixed $value, mixed $other): void
     {

tests/Models/LargeNumber.php

@@ -11,15 +11,15 @@
 
 final class LargeNumber extends BigNumberBehavior implements BigNumber
 {
-    public static function fromFloat(float $value, ?int $scale = BigNumber::AUTOMATIC_SCALE): BigNumber
+    public static function fromFloat(float $value, ?int $scale = BigNumber::AUTOMATIC_SCALE): LargeNumber
     {
         $scale = Scale::from(value: $scale);
         $number = Number::from(value: $value);
 
         return new LargeNumber(number: $number, scale: $scale);
     }
 
-    public static function fromString(string $value, ?int $scale = BigNumber::AUTOMATIC_SCALE): BigNumber
+    public static function fromString(string $value, ?int $scale = BigNumber::AUTOMATIC_SCALE): LargeNumber
     {
         $scale = Scale::from(value: $scale);
         $number = Number::from(value: $value);

tests/NegativeBigDecimalTest.php

@@ -36,6 +36,21 @@ public function testFromString(): void
         self::assertInstanceOf(NegativeBigDecimal::class, $actual);
     }
 
+    public function testNegativeValueReturnsNegativeFloat(): void
+    {
+        /** @Given a negative float value */
+        $value = -10.155;
+
+        /** @When creating a NegativeBigDecimal from the float */
+        $negativeBigDecimal = NegativeBigDecimal::fromFloat(value: $value);
+
+        /** @Then the toFloat method should return the correct negative value */
+        self::assertSame($value, $negativeBigDecimal->toFloat());
+
+        /** @Then the toString method should return the correct string representation */
+        self::assertSame(sprintf('-%s', abs($value)), $negativeBigDecimal->toString());
+    }
+
     #[DataProvider('dataProviderForTestNonNegativeValue')]
     public function testNonNegativeValue(mixed $value): void
     {
@@ -50,20 +65,6 @@ public function testNonNegativeValue(mixed $value): void
         NegativeBigDecimal::fromFloat(value: $value);
     }
 
-    public function testNonNegativeValueWithNegate(): void
-    {
-        /** @Given a NegativeBigDecimal value */
-        $template = 'Value <%s> is not valid. Must be a negative number less than zero.';
-
-        /** @Then a NonNegativeValue exception should be thrown when the value is negated */
-        $this->expectException(NonNegativeValue::class);
-        $this->expectExceptionMessage(sprintf($template, 10.155));
-
-        /** @When negating a negative number, it should trigger an exception */
-        $negative = NegativeBigDecimal::fromFloat(value: -10.155);
-        $negative->negate();
-    }
-
     public static function dataProviderForTestNonNegativeValue(): array
     {
         return [

tests/PositiveBigDecimalTest.php

@@ -51,20 +51,6 @@ public function testNonPositiveValue(mixed $value): void
         PositiveBigDecimal::fromFloat(value: $value);
     }
 
-    public function testNonPositiveValueWithNegate(): void
-    {
-        /** @Given a PositiveBigDecimal value */
-        $template = 'Value <%s> is not valid. Must be a positive number greater than zero.';
-
-        /** @Then a NonPositiveValue exception should be thrown when the value is negated */
-        $this->expectException(NonPositiveValue::class);
-        $this->expectExceptionMessage(sprintf($template, -1.00));
-
-        /** @When negating a positive number, it should trigger an exception */
-        $positive = PositiveBigDecimal::fromFloat(value: 10.155);
-        $positive->negate();
-    }
-
     public function testNonPositiveValueWithCustomClass(): void
     {
         /** @Given a non-positive value */