You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2019/10/28 01:46:07 UTC
[commons-math] 08/08: MATH-1500 (unit tests).
This is an automated email from the ASF dual-hosted git repository.
erans pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-math.git
commit 471d4d60dc21fbccb8c6b4616a00238c245f78f6
Author: Gilles Sadowski <gi...@harfang.homelinux.org>
AuthorDate: Mon Oct 28 01:51:42 2019 +0100
MATH-1500 (unit tests).
---
.../field/linalg/FieldLUDecompositionTest.java | 195 +++++++++++++--------
1 file changed, 121 insertions(+), 74 deletions(-)
diff --git a/src/test/java/org/apache/commons/math4/field/linalg/FieldLUDecompositionTest.java b/src/test/java/org/apache/commons/math4/field/linalg/FieldLUDecompositionTest.java
index b756643..8f08580 100644
--- a/src/test/java/org/apache/commons/math4/field/linalg/FieldLUDecompositionTest.java
+++ b/src/test/java/org/apache/commons/math4/field/linalg/FieldLUDecompositionTest.java
@@ -17,60 +17,47 @@
package org.apache.commons.math4.field.linalg;
-import org.apache.commons.numbers.fraction.Fraction;
-import org.apache.commons.numbers.field.FractionField;
import org.junit.Test;
import org.junit.Assert;
-import org.apache.commons.math4.linear.NonSquareMatrixException;
+import org.apache.commons.numbers.fraction.Fraction;
+import org.apache.commons.numbers.field.FractionField;
import org.apache.commons.math4.linear.SingularMatrixException;
+import org.apache.commons.math4.exception.DimensionMismatchException;
public class FieldLUDecompositionTest {
- private final Fraction[][] testData = {
- { Fraction.of(1), Fraction.of(2), Fraction.of(3)},
- { Fraction.of(2), Fraction.of(5), Fraction.of(3)},
- { Fraction.of(1), Fraction.of(0), Fraction.of(8)}
+ private final int[][] testData = {
+ { 1, 2, 3 },
+ { 2, 5, 3 },
+ { 1, 0, 8 }
+ };
+ private final int[][] testDataMinus = {
+ { -1, -2, -3 },
+ { -2, -5, -3 },
+ { -1, 0, -8 }
};
- private final Fraction[][] testDataMinus = {
- { Fraction.of(-1), Fraction.of(-2), Fraction.of(-3)},
- { Fraction.of(-2), Fraction.of(-5), Fraction.of(-3)},
- { Fraction.of(-1), Fraction.of(0), Fraction.of(-8)}
+ private final int[][] luData = {
+ { 2, 3, 3 },
+ { 2, 3, 7 },
+ { 6, 6, 8 }
};
- private final Fraction[][] luData = {
- { Fraction.of(2), Fraction.of(3), Fraction.of(3) },
- { Fraction.of(2), Fraction.of(3), Fraction.of(7) },
- { Fraction.of(6), Fraction.of(6), Fraction.of(8) }
+ private final int[][] luData2 = {
+ { 2, 3, 3 },
+ { 0, 5, 7 },
+ { 6, 9, 8 }
};
// singular matrices
- private final Fraction[][] singular = {
- { Fraction.of(2), Fraction.of(3) },
- { Fraction.of(2), Fraction.of(3) }
+ private int[][] singular = {
+ { 2, 3 },
+ { 2, 3 }
};
- private final Fraction[][] bigSingular = {
- { Fraction.of(1), Fraction.of(2), Fraction.of(3), Fraction.of(4) },
- { Fraction.of(2), Fraction.of(5), Fraction.of(3), Fraction.of(4) },
- { Fraction.of(7), Fraction.of(3), Fraction.of(256), Fraction.of(1930) },
- { Fraction.of(3), Fraction.of(7), Fraction.of(6), Fraction.of(8) }
+ private final int[][] bigSingular = {
+ { 1, 2, 3, 4 },
+ { 2, 5, 3, 4 },
+ { 7, 3, 256, 1930 },
+ { 3, 7, 6, 8 }
}; // 4th row = 1st + 2nd
- /**
- * @param data Matrix.
- * @return a {@link FieldDenseMatrix} instance.
- */
- private FieldDenseMatrix<Fraction> create(Fraction[][] data) {
- final FieldDenseMatrix<Fraction> m = FieldDenseMatrix.create(FractionField.get(),
- data.length,
- data[0].length);
- for (int i = 0; i < data.length; i++) {
- for (int j = 0; j < data.length; j++) {
- m.set(i, j, data[i][j]);
- }
- }
-
- return m;
- }
-
- /** test dimensions */
@Test
public void testDimensions() {
FieldDenseMatrix<Fraction> matrix = create(testData);
@@ -80,7 +67,6 @@ public class FieldLUDecompositionTest {
Assert.assertEquals(testData.length, LU.getP().getRowDimension());
}
- /** test PA = LU */
@Test
public void testPAEqualLU() {
FieldDenseMatrix<Fraction> matrix = create(testData);
@@ -105,7 +91,7 @@ public class FieldLUDecompositionTest {
Assert.assertEquals(p.multiply(matrix), l.multiply(u));
}
- /** test that L is lower triangular with unit diagonal */
+ /* L is lower triangular with unit diagonal */
@Test
public void testLLowerTriangular() {
FieldDenseMatrix<Fraction> matrix = create(testData);
@@ -118,7 +104,7 @@ public class FieldLUDecompositionTest {
}
}
- /** test that U is upper triangular */
+ /* U is upper triangular */
@Test
public void testUUpperTriangular() {
FieldDenseMatrix<Fraction> matrix = create(testData);
@@ -130,7 +116,7 @@ public class FieldLUDecompositionTest {
}
}
- /** test that P is a permutation matrix */
+ /* P is a permutation matrix */
@Test
public void testPPermutation() {
FieldDenseMatrix<Fraction> matrix = create(testData);
@@ -202,20 +188,20 @@ public class FieldLUDecompositionTest {
@Test
public void testMatricesValues1() {
FieldLUDecomposition<Fraction> lu = FieldLUDecomposition.of(create(testData));
- FieldDenseMatrix<Fraction> lRef = create(new Fraction[][] {
- { Fraction.of(1), Fraction.of(0), Fraction.of(0) },
- { Fraction.of(2), Fraction.of(1), Fraction.of(0) },
- { Fraction.of(1), Fraction.of(-2), Fraction.of(1) }
+ FieldDenseMatrix<Fraction> lRef = create(new int[][] {
+ { 1, 0, 0 },
+ { 2, 1, 0 },
+ { 1, -2, 1 }
});
- FieldDenseMatrix<Fraction> uRef = create(new Fraction[][] {
- { Fraction.of(1), Fraction.of(2), Fraction.of(3) },
- { Fraction.of(0), Fraction.of(1), Fraction.of(-3) },
- { Fraction.of(0), Fraction.of(0), Fraction.of(-1) }
+ FieldDenseMatrix<Fraction> uRef = create(new int[][] {
+ { 1, 2, 3 },
+ { 0, 1, -3 },
+ { 0, 0, -1 }
});
- FieldDenseMatrix<Fraction> pRef = create(new Fraction[][] {
- { Fraction.of(1), Fraction.of(0), Fraction.of(0) },
- { Fraction.of(0), Fraction.of(1), Fraction.of(0) },
- { Fraction.of(0), Fraction.of(0), Fraction.of(1) }
+ FieldDenseMatrix<Fraction> pRef = create(new int[][] {
+ { 1, 0, 0 },
+ { 0, 1, 0 },
+ { 0, 0, 1 }
});
int[] pivotRef = { 0, 1, 2 };
@@ -234,34 +220,95 @@ public class FieldLUDecompositionTest {
@Test
public void testMatricesValues2() {
- FieldLUDecomposition<Fraction> lu = FieldLUDecomposition.of(create(luData));
- FieldDenseMatrix<Fraction> lRef = create(new Fraction[][] {
- { Fraction.of(1), Fraction.of(0), Fraction.of(0) },
- { Fraction.of(3), Fraction.of(1), Fraction.of(0) },
- { Fraction.of(1), Fraction.of(0), Fraction.of(1) }
+ final FieldLUDecomposition<Fraction> lu = FieldLUDecomposition.of(create(luData));
+ final FieldDenseMatrix<Fraction> lRef = create(new int[][] {
+ { 1, 0, 0 },
+ { 3, 1, 0 },
+ { 1, 0, 1 }
});
- FieldDenseMatrix<Fraction> uRef = create(new Fraction[][] {
- { Fraction.of(2), Fraction.of(3), Fraction.of(3) },
- { Fraction.of(0), Fraction.of(-3), Fraction.of(-1) },
- { Fraction.of(0), Fraction.of(0), Fraction.of(4) }
+ final FieldDenseMatrix<Fraction> uRef = create(new int[][] {
+ { 2, 3, 3 },
+ { 0, -3, -1 },
+ { 0, 0, 4 }
});
- FieldDenseMatrix<Fraction> pRef = create(new Fraction[][] {
- { Fraction.of(1), Fraction.of(0), Fraction.of(0) },
- { Fraction.of(0), Fraction.of(0), Fraction.of(1) },
- { Fraction.of(0), Fraction.of(1), Fraction.of(0) }
+ final FieldDenseMatrix<Fraction> pRef = create(new int[][] {
+ { 1, 0, 0 },
+ { 0, 0, 1 },
+ { 0, 1, 0 }
});
int[] pivotRef = { 0, 2, 1 };
// check values against known references
- FieldDenseMatrix<Fraction> l = lu.getL();
+ final FieldDenseMatrix<Fraction> l = lu.getL();
Assert.assertEquals(lRef, l);
- FieldDenseMatrix<Fraction> u = lu.getU();
+ final FieldDenseMatrix<Fraction> u = lu.getU();
Assert.assertEquals(uRef, u);
- FieldDenseMatrix<Fraction> p = lu.getP();
+ final FieldDenseMatrix<Fraction> p = lu.getP();
Assert.assertEquals(pRef, p);
int[] pivot = lu.getPivot();
- for (int i = 0; i < pivotRef.length; ++i) {
+ for (int i = 0; i < pivotRef.length; i++) {
Assert.assertEquals(pivotRef[i], pivot[i]);
}
}
+
+ @Test(expected=DimensionMismatchException.class)
+ public void testSolveDimensionErrors() {
+ FieldLUDecomposition
+ .of(create(testData))
+ .getSolver()
+ .solve(create(new int[2][2]));
+ }
+
+ @Test
+ public void testSolve() {
+ final FieldDecompositionSolver<Fraction> solver = FieldLUDecomposition
+ .of(create(testData))
+ .getSolver();
+ final FieldDenseMatrix<Fraction> b = create(new int[][] {
+ { 1, 0 },
+ { 2, -5 },
+ { 3, 1 }
+ });
+ final FieldDenseMatrix<Fraction> xRef = create(new int[][] {
+ { 19, -71 },
+ { -6, 22 },
+ { -2, 9 }
+ });
+
+ final FieldDenseMatrix<Fraction> x = solver.solve(b);
+ for (int i = 0; i < x.getRowDimension(); i++){
+ for (int j = 0; j < x.getColumnDimension(); j++){
+ Assert.assertEquals("(" + i + ", " + j + ")",
+ xRef.get(i, j), x.get(i, j));
+ }
+ }
+ }
+
+ @Test
+ public void testDeterminant() {
+ Assert.assertEquals(-1, determinant(testData), 1e-15);
+ Assert.assertEquals(24, determinant(luData), 1e-14);
+ Assert.assertEquals(-10, determinant(luData2), 1e-14);
+ Assert.assertEquals(0, determinant(singular), 1e-15);
+ Assert.assertEquals(0, determinant(bigSingular), 1e-15);
+ }
+
+ private static double determinant(int[][] data) {
+ return FieldLUDecomposition.of(create(data)).getDeterminant().doubleValue();
+ }
+
+ private static FieldDenseMatrix<Fraction> create(final int[][] data) {
+ final int numRows = data.length;
+ final int numCols = data[0].length;
+ final FieldDenseMatrix<Fraction> m = FieldDenseMatrix
+ .create(FractionField.get(), numRows, numCols);
+
+ for (int i = 0; i < numRows; i++) {
+ for (int j = 0; j < numCols; j++) {
+ m.set(i, j, Fraction.of(data[i][j], 1));
+ }
+ }
+
+ return m;
+ }
}