Expose all coefficients in equation

Author: R. Kaleta

src/main/java/algolib/maths/Equation.java

@@ -4,7 +4,6 @@
 import java.text.DecimalFormatSymbols;
 import java.util.Arrays;
 import java.util.Locale;
-import java.util.Objects;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -20,6 +19,11 @@ private Equation(double[] coefficients, double freeTerm)
         this.freeTerm = freeTerm;
     }
 
+    public double[] getCoefficients()
+    {
+        return coefficients;
+    }
+
     public double getFreeTerm()
     {
         return freeTerm;
@@ -30,25 +34,6 @@ public static Equation of(double[] coefficients, double free)
         return new Equation(coefficients, free);
     }
 
-    @Override
-    public boolean equals(Object obj)
-    {
-        if(this == obj)
-            return true;
-
-        if(!(obj instanceof Equation other))
-            return false;
-
-        return Double.compare(other.freeTerm, freeTerm) == 0 && Arrays.equals(coefficients,
-                                                                              other.coefficients);
-    }
-
-    @Override
-    public int hashCode()
-    {
-        return Objects.hash(freeTerm, Arrays.hashCode(coefficients));
-    }
-
     @Override
     public String toString()
     {
@@ -69,16 +54,6 @@ public int size()
         return coefficients.length;
     }
 
-    /**
-     * Gets the coefficient by the variable at given index.
-     * @param i the index of variable
-     * @return the coefficient specified by the index
-     */
-    public double getCoefficient(int i)
-    {
-        return coefficients[i];
-    }
-
     /**
      * Negates this equation.
      * @return the equation with all coefficients negated

src/main/java/algolib/maths/EquationSystem.java

@@ -1,6 +1,7 @@
 package algolib.maths;
 
 import java.util.Arrays;
+import java.util.stream.Collectors;
 
 /** Structure of system of linear equations. */
 public final class EquationSystem
@@ -38,6 +39,14 @@ public int hashCode()
         return Arrays.hashCode(equations);
     }
 
+    @Override
+    public String toString()
+    {
+        return "{ %s }".formatted(Arrays.stream(equations)
+                                        .map(Equation::toString)
+                                        .collect(Collectors.joining(" ; ")));
+    }
+
     /**
      * Gets the number of equations in this system.
      * @return the number of equations
@@ -68,29 +77,29 @@ public double[] solve()
     {
         gaussianReduce();
 
-        if(equations[equations.length - 1].getCoefficient(equations.length - 1) == 0
-                   && equations[equations.length - 1].getFreeTerm() == 0)
+        int lastIndex = equations.length - 1;
+
+        if(equations[lastIndex].getCoefficients()[lastIndex] == 0
+                   && equations[lastIndex].getFreeTerm() == 0)
             throw new InfiniteSolutionsException();
 
-        if(equations[equations.length - 1].getCoefficient(equations.length - 1) == 0
-                   && equations[equations.length - 1].getFreeTerm() != 0)
+        if(equations[lastIndex].getCoefficients()[lastIndex] == 0
+                   && equations[lastIndex].getFreeTerm() != 0)
             throw new NoSolutionException();
 
         double[] solution = new double[equations.length];
 
-        solution[equations.length - 1] =
-                equations[equations.length - 1].getFreeTerm() / equations[equations.length
-                                                                                  - 1].getCoefficient(
-                        equations.length - 1);
+        solution[lastIndex] = equations[lastIndex].getFreeTerm()
+                                      / equations[lastIndex].getCoefficients()[lastIndex];
 
         for(int i = equations.length - 2; i >= 0; --i)
         {
             double value = equations[i].getFreeTerm();
 
-            for(int j = equations.length - 1; j > i; --j)
-                value -= equations[i].getCoefficient(j) * solution[j];
+            for(int j = lastIndex; j > i; --j)
+                value -= equations[i].getCoefficients()[j] * solution[j];
 
-            solution[i] = value / equations[i].getCoefficient(i);
+            solution[i] = value / equations[i].getCoefficients()[i];
         }
 
         return solution;
@@ -101,24 +110,16 @@ public void gaussianReduce()
     {
         for(int i = 0; i < equations.length - 1; ++i)
         {
-            int indexMin = i;
-
-            for(int j = i + 1; j < equations.length; ++j)
-            {
-                double minCoef = equations[indexMin].getCoefficient(i);
-                double actCoef = equations[j].getCoefficient(i);
-
-                if(actCoef != 0 && (minCoef == 0 || Math.abs(actCoef) < Math.abs(minCoef)))
-                    indexMin = j;
-            }
+            int indexMin = getMinimalCoefficientIndex(i);
 
-            if(equations[indexMin].getCoefficient(i) != 0)
+            if(equations[indexMin].getCoefficients()[i] != 0)
             {
                 swap(indexMin, i);
 
                 for(int j = i + 1; j < equations.length; ++j)
                 {
-                    double param = equations[j].getCoefficient(i) / equations[i].getCoefficient(i);
+                    double param =
+                            equations[j].getCoefficients()[i] / equations[i].getCoefficients()[i];
 
                     if(param != 0)
                         equations[j] = equations[j].add(equations[i].multiply(-param));
@@ -149,4 +150,22 @@ public boolean hasSolution(double[] solution)
     {
         return Arrays.stream(equations).allMatch(eq -> eq.hasSolution(solution));
     }
+
+    private int getMinimalCoefficientIndex(int startingIndex)
+    {
+        int indexMin = startingIndex;
+
+        for(int i = startingIndex + 1; i < equations.length; ++i)
+        {
+            double minCoefficient = equations[indexMin].getCoefficients()[startingIndex];
+            double currentCoefficient = equations[i].getCoefficients()[startingIndex];
+
+            if(currentCoefficient != 0 && (minCoefficient == 0
+                                                   || Math.abs(currentCoefficient) < Math.abs(
+                    minCoefficient)))
+                indexMin = i;
+        }
+
+        return indexMin;
+    }
 }

src/test/java/algolib/maths/EquationSystemTest.java

@@ -6,6 +6,21 @@
 // Tests: Structure of linear equations system.
 public class EquationSystemTest
 {
+    @Test
+    public void toString_ThenStringRepresentation()
+    {
+        // given
+        var testObject = EquationSystem.of(Equation.of(new double[]{2.0, 3.0, -2.0}, 15),
+                                           Equation.of(new double[]{7.0, -1.0, 0.0}, 4),
+                                           Equation.of(new double[]{-1.0, 6.0, 4.0}, 9));
+        // when
+        String result = testObject.toString();
+        // then
+        Assertions.assertThat(result)
+                  .isEqualTo("{ 2 x_0 + 3 x_1 + -2 x_2 = 15 ; 7 x_0 + -1 x_1 = 4 ; "
+                                     + "-1 x_0 + 6 x_1 + 4 x_2 = 9 }");
+    }
+
     @Test
     public void solve_WhenSingleSolution_ThenSolution()
     {

src/test/java/algolib/maths/EquationTest.java

@@ -1,6 +1,5 @@
 package algolib.maths;
 
-import java.util.stream.IntStream;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -29,7 +28,7 @@ public void negate_ThenNegated()
         // when
         Equation result = testObject.negate();
         // then
-        Assertions.assertThat(coefficients(result))
+        Assertions.assertThat(result.getCoefficients())
                   .usingComparatorWithPrecision(0.0)
                   .containsExactly(-2, -3, 0, 2.5);
         Assertions.assertThat(result.getFreeTerm()).isEqualTo(-15);
@@ -41,7 +40,7 @@ public void add_ThenAddingEquations()
         // when
         Equation result = testObject.add(Equation.of(new double[]{1, -1, 4, 10}, 5));
         // then
-        Assertions.assertThat(coefficients(result))
+        Assertions.assertThat(result.getCoefficients())
                   .usingComparatorWithPrecision(0.0)
                   .containsExactly(3, 2, 4, 7.5);
         Assertions.assertThat(result.getFreeTerm()).isEqualTo(20);
@@ -53,7 +52,7 @@ public void subtract_ThenSubtractingEquations()
         // when
         Equation result = testObject.subtract(Equation.of(new double[]{1, -1, 4, 10}, 5));
         // then
-        Assertions.assertThat(coefficients(result))
+        Assertions.assertThat(result.getCoefficients())
                   .usingComparatorWithPrecision(0.0)
                   .containsExactly(1, 4, -4, -12.5);
         Assertions.assertThat(result.getFreeTerm()).isEqualTo(10);
@@ -65,7 +64,7 @@ public void multiply_WhenConstantIsNonZero_ThenMultiplyingEachCoefficient()
         // when
         Equation result = testObject.multiply(2);
         // then
-        Assertions.assertThat(coefficients(result))
+        Assertions.assertThat(result.getCoefficients())
                   .usingComparatorWithPrecision(0.0)
                   .containsExactly(4, 6, 0, -5);
         Assertions.assertThat(result.getFreeTerm()).isEqualTo(30);
@@ -86,7 +85,7 @@ public void divide_WhenConstantIsNonZero_ThenDividingEachCoefficient()
         // when
         Equation result = testObject.divide(-2);
         // then
-        Assertions.assertThat(coefficients(result))
+        Assertions.assertThat(result.getCoefficients())
                   .usingComparatorWithPrecision(0.0)
                   .containsExactly(-1, -1.5, 0, 1.25);
         Assertions.assertThat(result.getFreeTerm()).isEqualTo(-7.5);
@@ -127,9 +126,4 @@ public void hasSolution_WhenNotSolution_ThenFalse()
         // then
         Assertions.assertThat(result).isFalse();
     }
-
-    private double[] coefficients(Equation equation)
-    {
-        return IntStream.range(0, equation.size()).mapToDouble(equation::getCoefficient).toArray();
-    }
 }