(commons-lang) branch master updated: Fraction.add and subtract return the reduced form when an operand is zero (#1787)

[ggregory]

This is an automated email from the ASF dual-hosted git repository.

garydgregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git


The following commit(s) were added to refs/heads/master by this push:
     new 284be5d6a Fraction.add and subtract return the reduced form when an 
operand is zero (#1787)
284be5d6a is described below

commit 284be5d6a5bc8d903297e2a6f86ecf3494e44d1d
Author: Jeff Lenamon <85593689+lenam...@users.noreply.github.com>
AuthorDate: Wed Sep 9 02:39:17 2026 -0400

    Fraction.add and subtract return the reduced form when an operand is zero 
(#1787)
---
 .../org/apache/commons/lang3/math/Fraction.java    |  4 ++--
 .../apache/commons/lang3/math/FractionTest.java    | 28 ++++++++++++++++++++++
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/apache/commons/lang3/math/Fraction.java 
b/src/main/java/org/apache/commons/lang3/math/Fraction.java
index cb18b130d..95f40dc34 100644
--- a/src/main/java/org/apache/commons/lang3/math/Fraction.java
+++ b/src/main/java/org/apache/commons/lang3/math/Fraction.java
@@ -551,10 +551,10 @@ private Fraction addSub(final Fraction fraction, final 
boolean isAdd) {
         Objects.requireNonNull(fraction, "fraction");
         // zero is identity for addition.
         if (numerator == 0) {
-            return isAdd ? fraction : fraction.negate();
+            return isAdd ? fraction.reduce() : fraction.reduce().negate();
         }
         if (fraction.numerator == 0) {
-            return this;
+            return reduce();
         }
         // Knuth 4.5.1 assumes operands in lowest terms and this class does 
not reduce on
         // construction, so reduce both first, as multiplyBy does.
diff --git a/src/test/java/org/apache/commons/lang3/math/FractionTest.java 
b/src/test/java/org/apache/commons/lang3/math/FractionTest.java
index 57ec9d3a4..a3d4c9ed2 100644
--- a/src/test/java/org/apache/commons/lang3/math/FractionTest.java
+++ b/src/test/java/org/apache/commons/lang3/math/FractionTest.java
@@ -118,6 +118,34 @@ void testAddSubtractUnreducedOperands() {
         assertThrows(ArithmeticException.class, () -> maxValue.add(maxValue));
     }
 
+    @Test
+    void testAddSubtractZeroOperand() {
+        // A zero operand returns the other operand in reduced form.
+        Fraction f = Fraction.ZERO.add(Fraction.getFraction(2, 4));
+        assertEquals(1, f.getNumerator());
+        assertEquals(2, f.getDenominator());
+
+        f = Fraction.getFraction(2, 4).add(Fraction.ZERO);
+        assertEquals(1, f.getNumerator());
+        assertEquals(2, f.getDenominator());
+
+        f = Fraction.ZERO.subtract(Fraction.getFraction(2, 4));
+        assertEquals(-1, f.getNumerator());
+        assertEquals(2, f.getDenominator());
+
+        f = Fraction.getFraction(2, 4).subtract(Fraction.ZERO);
+        assertEquals(1, f.getNumerator());
+        assertEquals(2, f.getDenominator());
+
+        // Integer.MIN_VALUE/2 reduces to -1073741824/1, whose negation fits 
an int.
+        f = Fraction.ZERO.subtract(Fraction.getFraction(Integer.MIN_VALUE, 2));
+        assertEquals(1073741824, f.getNumerator());
+        assertEquals(1, f.getDenominator());
+
+        // Integer.MIN_VALUE/1 is in lowest terms and still cannot be negated.
+        assertThrows(ArithmeticException.class, () -> 
Fraction.ZERO.subtract(Fraction.getFraction(Integer.MIN_VALUE, 1)));
+    }
+
     @Test
     void testAdd() {
         Fraction f;