http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/linear/ArrayFieldVectorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/linear/ArrayFieldVectorTest.java b/src/test/java/org/apache/commons/math4/linear/ArrayFieldVectorTest.java index 1268b26..2369824 100644 --- a/src/test/java/org/apache/commons/math4/linear/ArrayFieldVectorTest.java +++ b/src/test/java/org/apache/commons/math4/linear/ArrayFieldVectorTest.java @@ -90,6 +90,7 @@ public class ArrayFieldVectorTest { data = d.clone(); } + @Override public Field<T> getField() { return field; } @@ -98,10 +99,12 @@ public class ArrayFieldVectorTest { return new UnsupportedOperationException("Not supported, unneeded for test purposes"); } + @Override public FieldVector<T> copy() { throw unsupported(); } + @Override public FieldVector<T> add(FieldVector<T> v) { throw unsupported(); } @@ -110,6 +113,7 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public FieldVector<T> subtract(FieldVector<T> v) { throw unsupported(); } @@ -118,22 +122,27 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public FieldVector<T> mapAdd(T d) { throw unsupported(); } + @Override public FieldVector<T> mapAddToSelf(T d) { throw unsupported(); } + @Override public FieldVector<T> mapSubtract(T d) { throw unsupported(); } + @Override public FieldVector<T> mapSubtractToSelf(T d) { throw unsupported(); } + @Override public FieldVector<T> mapMultiply(T d) { T[] out = buildArray(data.length); for (int i = 0; i < data.length; i++) { @@ -142,26 +151,32 @@ public class ArrayFieldVectorTest { return new FieldVectorTestImpl<>(out); } + @Override public FieldVector<T> mapMultiplyToSelf(T d) { throw unsupported(); } + @Override public FieldVector<T> mapDivide(T d) { throw unsupported(); } + @Override public FieldVector<T> mapDivideToSelf(T d) { throw unsupported(); } + @Override public FieldVector<T> mapInv() { throw unsupported(); } + @Override public FieldVector<T> mapInvToSelf() { throw unsupported(); } + @Override public FieldVector<T> ebeMultiply(FieldVector<T> v) { throw unsupported(); } @@ -170,6 +185,7 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public FieldVector<T> ebeDivide(FieldVector<T> v) { throw unsupported(); } @@ -182,6 +198,7 @@ public class ArrayFieldVectorTest { return data.clone(); } + @Override public T dotProduct(FieldVector<T> v) { T dot = field.getZero(); for (int i = 0; i < data.length; i++) { @@ -198,6 +215,7 @@ public class ArrayFieldVectorTest { return dot; } + @Override public FieldVector<T> projection(FieldVector<T> v) { throw unsupported(); } @@ -206,6 +224,7 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public FieldMatrix<T> outerProduct(FieldVector<T> v) { throw unsupported(); } @@ -214,18 +233,22 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public T getEntry(int index) { return data[index]; } + @Override public int getDimension() { return data.length; } + @Override public FieldVector<T> append(FieldVector<T> v) { throw unsupported(); } + @Override public FieldVector<T> append(T d) { throw unsupported(); } @@ -234,14 +257,17 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public FieldVector<T> getSubVector(int index, int n) { throw unsupported(); } + @Override public void setEntry(int index, T value) { throw unsupported(); } + @Override public void setSubVector(int index, FieldVector<T> v) { throw unsupported(); } @@ -250,10 +276,12 @@ public class ArrayFieldVectorTest { throw unsupported(); } + @Override public void set(T value) { throw unsupported(); } + @Override public T[] toArray() { return data.clone(); } @@ -681,6 +709,7 @@ public class ArrayFieldVectorTest { private int expectedIndex; + @Override public void visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -688,6 +717,7 @@ public class ArrayFieldVectorTest { ++expectedIndex; } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -696,6 +726,7 @@ public class ArrayFieldVectorTest { expectedIndex = 0; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -710,14 +741,17 @@ public class ArrayFieldVectorTest { final FieldVectorPreservingVisitor<Fraction> visitor; visitor = new FieldVectorPreservingVisitor<Fraction>() { + @Override public void visit(int index, Fraction value) { // Do nothing } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -770,6 +804,7 @@ public class ArrayFieldVectorTest { private int expectedIndex; + @Override public void visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -777,6 +812,7 @@ public class ArrayFieldVectorTest { ++expectedIndex; } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -785,6 +821,7 @@ public class ArrayFieldVectorTest { expectedIndex = expectedStart; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -805,12 +842,14 @@ public class ArrayFieldVectorTest { visitor = new FieldVectorPreservingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public void visit(final int actualIndex, final Fraction actualValue) { visited[actualIndex] = true; Assert.assertEquals(Integer.toString(actualIndex), data[actualIndex], actualValue); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -819,6 +858,7 @@ public class ArrayFieldVectorTest { Arrays.fill(visited, false); } + @Override public Fraction end() { for (int i = 0; i < data.length; i++) { Assert.assertTrue("entry " + i + "has not been visited", @@ -837,14 +877,17 @@ public class ArrayFieldVectorTest { final FieldVectorPreservingVisitor<Fraction> visitor; visitor = new FieldVectorPreservingVisitor<Fraction>() { + @Override public void visit(int index, Fraction value) { // Do nothing } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -896,12 +939,14 @@ public class ArrayFieldVectorTest { visitor = new FieldVectorPreservingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public void visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(Integer.toString(actualIndex), data[actualIndex], actualValue); visited[actualIndex] = true; } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -910,6 +955,7 @@ public class ArrayFieldVectorTest { Arrays.fill(visited, true); } + @Override public Fraction end() { for (int i = expectedStart; i <= expectedEnd; i++) { Assert.assertTrue("entry " + i + "has not been visited", @@ -935,6 +981,7 @@ public class ArrayFieldVectorTest { private int expectedIndex; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -943,6 +990,7 @@ public class ArrayFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -951,6 +999,7 @@ public class ArrayFieldVectorTest { expectedIndex = 0; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -968,14 +1017,17 @@ public class ArrayFieldVectorTest { final FieldVectorChangingVisitor<Fraction> visitor; visitor = new FieldVectorChangingVisitor<Fraction>() { + @Override public Fraction visit(int index, Fraction value) { return Fraction.ZERO; } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -1028,6 +1080,7 @@ public class ArrayFieldVectorTest { private int expectedIndex; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -1036,6 +1089,7 @@ public class ArrayFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -1044,6 +1098,7 @@ public class ArrayFieldVectorTest { expectedIndex = expectedStart; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -1067,6 +1122,7 @@ public class ArrayFieldVectorTest { visitor = new FieldVectorChangingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { visited[actualIndex] = true; Assert.assertEquals(Integer.toString(actualIndex), @@ -1074,6 +1130,7 @@ public class ArrayFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -1082,6 +1139,7 @@ public class ArrayFieldVectorTest { Arrays.fill(visited, false); } + @Override public Fraction end() { for (int i = 0; i < data.length; i++) { Assert.assertTrue("entry " + i + "has not been visited", @@ -1103,14 +1161,17 @@ public class ArrayFieldVectorTest { final FieldVectorChangingVisitor<Fraction> visitor; visitor = new FieldVectorChangingVisitor<Fraction>() { + @Override public Fraction visit(int index, Fraction value) { return Fraction.ZERO; } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -1162,6 +1223,7 @@ public class ArrayFieldVectorTest { visitor = new FieldVectorChangingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(Integer.toString(actualIndex), data[actualIndex], actualValue); @@ -1169,6 +1231,7 @@ public class ArrayFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -1177,6 +1240,7 @@ public class ArrayFieldVectorTest { Arrays.fill(visited, true); } + @Override public Fraction end() { for (int i = expectedStart; i <= expectedEnd; i++) { Assert.assertTrue("entry " + i + "has not been visited",
http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/linear/ConjugateGradientTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/linear/ConjugateGradientTest.java b/src/test/java/org/apache/commons/math4/linear/ConjugateGradientTest.java index 07c2ee0..9cbbc8f 100644 --- a/src/test/java/org/apache/commons/math4/linear/ConjugateGradientTest.java +++ b/src/test/java/org/apache/commons/math4/linear/ConjugateGradientTest.java @@ -179,14 +179,17 @@ public class ConjugateGradientTest { final RealVector x = new ArrayRealVector(n); final IterationListener listener = new IterationListener() { + @Override public void terminationPerformed(final IterationEvent e) { // Do nothing } + @Override public void iterationStarted(final IterationEvent e) { // Do nothing } + @Override public void iterationPerformed(final IterationEvent e) { final IterativeLinearSolverEvent evt; evt = (IterativeLinearSolverEvent) e; @@ -196,6 +199,7 @@ public class ConjugateGradientTest { x.setSubVector(0, v); } + @Override public void initializationPerformed(final IterationEvent e) { // Do nothing } @@ -350,14 +354,17 @@ public class ConjugateGradientTest { final RealVector x = new ArrayRealVector(n); final IterationListener listener = new IterationListener() { + @Override public void terminationPerformed(final IterationEvent e) { // Do nothing } + @Override public void iterationStarted(final IterationEvent e) { // Do nothing } + @Override public void iterationPerformed(final IterationEvent e) { final IterativeLinearSolverEvent evt; evt = (IterativeLinearSolverEvent) e; @@ -367,6 +374,7 @@ public class ConjugateGradientTest { x.setSubVector(0, v); } + @Override public void initializationPerformed(final IterationEvent e) { // Do nothing } @@ -479,11 +487,13 @@ public class ConjugateGradientTest { } } + @Override public void initializationPerformed(final IterationEvent e) { ++count[0]; doTestVectorsAreUnmodifiable(e); } + @Override public void iterationPerformed(final IterationEvent e) { ++count[2]; Assert.assertEquals("iteration performed", @@ -491,6 +501,7 @@ public class ConjugateGradientTest { doTestVectorsAreUnmodifiable(e); } + @Override public void iterationStarted(final IterationEvent e) { ++count[1]; Assert.assertEquals("iteration started", @@ -498,6 +509,7 @@ public class ConjugateGradientTest { doTestVectorsAreUnmodifiable(e); } + @Override public void terminationPerformed(final IterationEvent e) { ++count[3]; doTestVectorsAreUnmodifiable(e); @@ -538,18 +550,22 @@ public class ConjugateGradientTest { FastMath.max(1E-5 * rnorm, 1E-10)); } + @Override public void initializationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationStarted(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void terminationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } @@ -585,18 +601,22 @@ public class ConjugateGradientTest { FastMath.max(1E-5 * rnorm, 1E-10)); } + @Override public void initializationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationStarted(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void terminationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java b/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java index 5df1142..29efdd3 100644 --- a/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java +++ b/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java @@ -266,6 +266,7 @@ public class SparseFieldVectorTest { private int expectedIndex; + @Override public void visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -273,6 +274,7 @@ public class SparseFieldVectorTest { ++expectedIndex; } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -281,6 +283,7 @@ public class SparseFieldVectorTest { expectedIndex = 0; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -295,14 +298,17 @@ public class SparseFieldVectorTest { final FieldVectorPreservingVisitor<Fraction> visitor; visitor = new FieldVectorPreservingVisitor<Fraction>() { + @Override public void visit(int index, Fraction value) { // Do nothing } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -355,6 +361,7 @@ public class SparseFieldVectorTest { private int expectedIndex; + @Override public void visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -362,6 +369,7 @@ public class SparseFieldVectorTest { ++expectedIndex; } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -370,6 +378,7 @@ public class SparseFieldVectorTest { expectedIndex = expectedStart; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -390,12 +399,14 @@ public class SparseFieldVectorTest { visitor = new FieldVectorPreservingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public void visit(final int actualIndex, final Fraction actualValue) { visited[actualIndex] = true; Assert.assertEquals(Integer.toString(actualIndex), data[actualIndex], actualValue); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -404,6 +415,7 @@ public class SparseFieldVectorTest { Arrays.fill(visited, false); } + @Override public Fraction end() { for (int i = 0; i < data.length; i++) { Assert.assertTrue("entry " + i + "has not been visited", @@ -422,14 +434,17 @@ public class SparseFieldVectorTest { final FieldVectorPreservingVisitor<Fraction> visitor; visitor = new FieldVectorPreservingVisitor<Fraction>() { + @Override public void visit(int index, Fraction value) { // Do nothing } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -481,12 +496,14 @@ public class SparseFieldVectorTest { visitor = new FieldVectorPreservingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public void visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(Integer.toString(actualIndex), data[actualIndex], actualValue); visited[actualIndex] = true; } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -495,6 +512,7 @@ public class SparseFieldVectorTest { Arrays.fill(visited, true); } + @Override public Fraction end() { for (int i = expectedStart; i <= expectedEnd; i++) { Assert.assertTrue("entry " + i + "has not been visited", @@ -520,6 +538,7 @@ public class SparseFieldVectorTest { private int expectedIndex; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -528,6 +547,7 @@ public class SparseFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -536,6 +556,7 @@ public class SparseFieldVectorTest { expectedIndex = 0; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -553,14 +574,17 @@ public class SparseFieldVectorTest { final FieldVectorChangingVisitor<Fraction> visitor; visitor = new FieldVectorChangingVisitor<Fraction>() { + @Override public Fraction visit(int index, Fraction value) { return Fraction.ZERO; } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -613,6 +637,7 @@ public class SparseFieldVectorTest { private int expectedIndex; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(expectedIndex, actualIndex); Assert.assertEquals(Integer.toString(actualIndex), @@ -621,6 +646,7 @@ public class SparseFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -629,6 +655,7 @@ public class SparseFieldVectorTest { expectedIndex = expectedStart; } + @Override public Fraction end() { return Fraction.ZERO; } @@ -652,6 +679,7 @@ public class SparseFieldVectorTest { visitor = new FieldVectorChangingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { visited[actualIndex] = true; Assert.assertEquals(Integer.toString(actualIndex), @@ -659,6 +687,7 @@ public class SparseFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -667,6 +696,7 @@ public class SparseFieldVectorTest { Arrays.fill(visited, false); } + @Override public Fraction end() { for (int i = 0; i < data.length; i++) { Assert.assertTrue("entry " + i + "has not been visited", @@ -688,14 +718,17 @@ public class SparseFieldVectorTest { final FieldVectorChangingVisitor<Fraction> visitor; visitor = new FieldVectorChangingVisitor<Fraction>() { + @Override public Fraction visit(int index, Fraction value) { return Fraction.ZERO; } + @Override public void start(int dimension, int start, int end) { // Do nothing } + @Override public Fraction end() { return Fraction.ZERO; } @@ -747,6 +780,7 @@ public class SparseFieldVectorTest { visitor = new FieldVectorChangingVisitor<Fraction>() { private final boolean[] visited = new boolean[data.length]; + @Override public Fraction visit(final int actualIndex, final Fraction actualValue) { Assert.assertEquals(Integer.toString(actualIndex), data[actualIndex], actualValue); @@ -754,6 +788,7 @@ public class SparseFieldVectorTest { return actualValue.add(actualIndex); } + @Override public void start(final int actualSize, final int actualStart, final int actualEnd) { Assert.assertEquals(data.length, actualSize); @@ -762,6 +797,7 @@ public class SparseFieldVectorTest { Arrays.fill(visited, true); } + @Override public Fraction end() { for (int i = expectedStart; i <= expectedEnd; i++) { Assert.assertTrue("entry " + i + "has not been visited", http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/linear/SymmLQTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/linear/SymmLQTest.java b/src/test/java/org/apache/commons/math4/linear/SymmLQTest.java index 5934b58..75ae635 100644 --- a/src/test/java/org/apache/commons/math4/linear/SymmLQTest.java +++ b/src/test/java/org/apache/commons/math4/linear/SymmLQTest.java @@ -503,10 +503,12 @@ public class SymmLQTest { final RealVector xFromListener = new ArrayRealVector(n); final IterationListener listener = new IterationListener() { + @Override public void initializationPerformed(final IterationEvent e) { ++count[0]; } + @Override public void iterationPerformed(final IterationEvent e) { ++count[2]; Assert.assertEquals("iteration performed", @@ -514,6 +516,7 @@ public class SymmLQTest { e.getIterations() - 1); } + @Override public void iterationStarted(final IterationEvent e) { ++count[1]; Assert.assertEquals("iteration started", @@ -521,6 +524,7 @@ public class SymmLQTest { e.getIterations() - 1); } + @Override public void terminationPerformed(final IterationEvent e) { ++count[3]; final IterativeLinearSolverEvent ilse; @@ -625,18 +629,22 @@ public class SymmLQTest { FastMath.max(1E-5 * rnorm, 1E-10)); } + @Override public void initializationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationStarted(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void terminationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } @@ -673,18 +681,22 @@ public class SymmLQTest { FastMath.max(1E-5 * rnorm, 1E-10)); } + @Override public void initializationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void iterationStarted(final IterationEvent e) { doTestNormOfResidual(e); } + @Override public void terminationPerformed(final IterationEvent e) { doTestNormOfResidual(e); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ml/neuralnet/OffsetFeatureInitializer.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ml/neuralnet/OffsetFeatureInitializer.java b/src/test/java/org/apache/commons/math4/ml/neuralnet/OffsetFeatureInitializer.java index 9e13e35..fb91d80 100644 --- a/src/test/java/org/apache/commons/math4/ml/neuralnet/OffsetFeatureInitializer.java +++ b/src/test/java/org/apache/commons/math4/ml/neuralnet/OffsetFeatureInitializer.java @@ -43,6 +43,7 @@ public class OffsetFeatureInitializer } /** {@inheritDoc} */ + @Override public double value() { return orig.value() + inc++; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/TravellingSalesmanSolver.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/TravellingSalesmanSolver.java b/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/TravellingSalesmanSolver.java index aad20db..c15a869 100644 --- a/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/TravellingSalesmanSolver.java +++ b/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/TravellingSalesmanSolver.java @@ -183,15 +183,18 @@ public class TravellingSalesmanSolver { /** Number of samples. */ private long n = 0; /** {@inheritDoc} */ + @Override public boolean hasNext() { return n < numSamples; } /** {@inheritDoc} */ + @Override public double[] next() { ++n; return cityList.get(random.nextInt(cityList.size())).getCoordinates(); } /** {@inheritDoc} */ + @Override public void remove() { throw new MathUnsupportedOperationException(); } @@ -405,6 +408,7 @@ class City { } /** {@inheritDoc} */ + @Override public boolean equals(Object o) { if (o instanceof City) { final City other = (City) o; @@ -415,6 +419,7 @@ class City { } /** {@inheritDoc} */ + @Override public int hashCode() { int result = 17; http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java b/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java index b50d0b9..46a01d0 100644 --- a/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java +++ b/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java @@ -103,15 +103,18 @@ public class ContinuousOutputFieldModelTest { // theoretical solution: y[0] = cos(t), y[1] = sin(t) FirstOrderFieldDifferentialEquations<T> problem = new FirstOrderFieldDifferentialEquations<T>() { + @Override public T[] computeDerivatives(T t, T[] y) { T[] yDot = MathArrays.buildArray(field, 2); yDot[0] = y[1].negate(); yDot[1] = y[0]; return yDot; } + @Override public int getDimension() { return 2; } + @Override public void init(T t0, T[] y0, T finalTime) { } }; @@ -204,11 +207,14 @@ public class ContinuousOutputFieldModelTest { final FieldODEStateAndDerivative<T> s0 = new FieldODEStateAndDerivative<>(field.getZero().add(t0), fieldY, fieldY); final FieldODEStateAndDerivative<T> s1 = new FieldODEStateAndDerivative<>(field.getZero().add(t1), fieldY, fieldY); final FieldEquationsMapper<T> mapper = new FieldExpandableODE<>(new FirstOrderFieldDifferentialEquations<T>() { + @Override public int getDimension() { return s0.getStateDimension(); } + @Override public void init(T t0, T[] y0, T finalTime) { } + @Override public T[] computeDerivatives(T t, T[] y) { return y; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java b/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java index 20fc11f..6a4e399 100644 --- a/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java +++ b/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java @@ -298,10 +298,12 @@ public class FieldExpandableODETest { this.start = start; } + @Override public int getDimension() { return dimension; } + @Override public void init(final T t0, final T[] y0, final T finalTime) { Assert.assertEquals(dimension, y0.length); Assert.assertEquals(10.0, t0.getReal(), 1.0e-15); @@ -311,6 +313,7 @@ public class FieldExpandableODETest { } } + @Override public T[] computeDerivatives(final T t, final T[] y) { final T[] yDot = MathArrays.buildArray(field, dimension); for (int i = 0; i < dimension; ++i) { @@ -319,6 +322,7 @@ public class FieldExpandableODETest { return yDot; } + @Override public void init(final T t0, final T[] primary0, final T[] secondary0, final T finalTime) { Assert.assertEquals(dimension, secondary0.length); Assert.assertEquals(10.0, t0.getReal(), 1.0e-15); @@ -331,6 +335,7 @@ public class FieldExpandableODETest { } } + @Override public T[] computeDerivatives(final T t, final T[] primary, final T[] primaryDot, final T[] secondary) { final T[] secondaryDot = MathArrays.buildArray(field, dimension); for (int i = 0; i < dimension; ++i) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/FirstOrderConverterTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/FirstOrderConverterTest.java b/src/test/java/org/apache/commons/math4/ode/FirstOrderConverterTest.java index 0ea620e..a22f5c8 100644 --- a/src/test/java/org/apache/commons/math4/ode/FirstOrderConverterTest.java +++ b/src/test/java/org/apache/commons/math4/ode/FirstOrderConverterTest.java @@ -86,11 +86,13 @@ public class FirstOrderConverterTest { omega2 = omega * omega; } - public int getDimension() { + @Override + public int getDimension() { return n; } - public void computeSecondDerivatives(double t, double[] y, double[] yDot, + @Override + public void computeSecondDerivatives(double t, double[] y, double[] yDot, double[] yDDot) { for (int i = 0; i < n; ++i) { yDDot[i] = -omega2 * y[i]; http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/JacobianMatricesTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/JacobianMatricesTest.java b/src/test/java/org/apache/commons/math4/ode/JacobianMatricesTest.java index d843ccb..fab7f2a 100644 --- a/src/test/java/org/apache/commons/math4/ode/JacobianMatricesTest.java +++ b/src/test/java/org/apache/commons/math4/ode/JacobianMatricesTest.java @@ -329,16 +329,19 @@ public class JacobianMatricesTest { this.b = b; } + @Override public int getDimension() { return 2; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { double prod = y[0] * y[0] * y[1]; yDot[0] = 1 + prod - (b + 1) * y[0]; yDot[1] = b * y[0] - prod; } + @Override public void computeMainStateJacobian(double t, double[] y, double[] yDot, double[][] dFdY) { double p = 2 * y[0] * y[1]; @@ -349,6 +352,7 @@ public class JacobianMatricesTest { dFdY[1][1] = -y02; } + @Override public void computeParameterJacobian(double t, double[] y, double[] yDot, String paramName, double[] dFdP) { if (isSupported(paramName)) { @@ -382,11 +386,13 @@ public class JacobianMatricesTest { this.b = b; } + @Override public int getDimension() { return 2; } /** {@inheritDoc} */ + @Override public double getParameter(final String name) throws UnknownParameterException { complainIfNotSupported(name); @@ -394,12 +400,14 @@ public class JacobianMatricesTest { } /** {@inheritDoc} */ + @Override public void setParameter(final String name, final double value) throws UnknownParameterException { complainIfNotSupported(name); b = value; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { double prod = y[0] * y[0] * y[1]; yDot[0] = 1 + prod - (b + 1) * y[0]; @@ -437,15 +445,18 @@ public class JacobianMatricesTest { this.omega = omega; } + @Override public int getDimension() { return 2; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = omega * (cy - y[1]); yDot[1] = omega * (y[0] - cx); } + @Override public void computeMainStateJacobian(double t, double[] y, double[] yDot, double[][] dFdY) { dFdY[0][0] = 0; @@ -454,6 +465,7 @@ public class JacobianMatricesTest { dFdY[1][1] = 0; } + @Override public void computeParameterJacobian(double t, double[] y, double[] yDot, String paramName, double[] dFdP) throws UnknownParameterException { @@ -533,15 +545,18 @@ public class JacobianMatricesTest { this.omega = omega; } + @Override public int getDimension() { return 2; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = omega * (cy - y[1]); yDot[1] = omega * (y[0] - cx); } + @Override public double getParameter(final String name) throws UnknownParameterException { if (name.equals(CX)) { @@ -555,6 +570,7 @@ public class JacobianMatricesTest { } } + @Override public void setParameter(final String name, final double value) throws UnknownParameterException { if (name.equals(CX)) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java b/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java index 01db18f..a47afb6 100644 --- a/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java +++ b/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java @@ -113,19 +113,23 @@ public class TestFieldProblem4<T extends RealFieldElement<T>> sign = +1; } + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { } + @Override public T g(FieldODEStateAndDerivative<T> state) { return state.getState()[0].multiply(sign); } + @Override public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) { // this sign change is needed because the state will be reset soon sign = -sign; return Action.RESET_STATE; } + @Override public FieldODEState<T> resetState(FieldODEStateAndDerivative<T> state) { T[] y = state.getState(); y[0] = y[0].negate(); @@ -140,17 +144,21 @@ public class TestFieldProblem4<T extends RealFieldElement<T>> public Stop() { } + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { } + @Override public T g(FieldODEStateAndDerivative<T> state) { return state.getTime().subtract(12.0); } + @Override public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) { return Action.STOP; } + @Override public FieldODEState<T> resetState(FieldODEStateAndDerivative<T> state) { return state; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java index cf404d6..b8e5f08 100644 --- a/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java +++ b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java @@ -105,6 +105,7 @@ public abstract class TestFieldProblemAbstract<T extends RealFieldElement<T>> /** Get the problem dimension. * @return problem dimension */ + @Override public int getDimension() { return n; } @@ -160,10 +161,12 @@ public abstract class TestFieldProblemAbstract<T extends RealFieldElement<T>> } /** {@inheritDoc} */ + @Override public void init(T t0, T[] y0, T t) { } /** {@inheritDoc} */ + @Override public T[] computeDerivatives(T t, T[] y) { ++calls; return doComputeDerivatives(t, y); http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemHandler.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/TestFieldProblemHandler.java b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemHandler.java index c298bf3..14d9329 100644 --- a/src/test/java/org/apache/commons/math4/ode/TestFieldProblemHandler.java +++ b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemHandler.java @@ -64,6 +64,7 @@ public class TestFieldProblemHandler<T extends RealFieldElement<T>> expectedStepStart = null; } + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { maxValueError = problem.getField().getZero(); maxTimeError = problem.getField().getZero(); @@ -71,6 +72,7 @@ public class TestFieldProblemHandler<T extends RealFieldElement<T>> expectedStepStart = null; } + @Override public void handleStep(FieldStepInterpolator<T> interpolator, boolean isLast) throws MaxCountExceededException { T start = integrator.getCurrentStepStart().getTime(); http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/TestProblem4.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/TestProblem4.java b/src/test/java/org/apache/commons/math4/ode/TestProblem4.java index 29da0f5..accc5a7 100644 --- a/src/test/java/org/apache/commons/math4/ode/TestProblem4.java +++ b/src/test/java/org/apache/commons/math4/ode/TestProblem4.java @@ -99,19 +99,23 @@ public class TestProblem4 sign = +1; } + @Override public void init(double t0, double[] y0, double t) { } + @Override public double g(double t, double[] y) { return sign * y[0]; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { // this sign change is needed because the state will be reset soon sign = -sign; return Action.RESET_STATE; } + @Override public void resetState(double t, double[] y) { y[0] = -y[0]; y[1] = -y[1]; @@ -124,17 +128,21 @@ public class TestProblem4 public Stop() { } + @Override public void init(double t0, double[] y0, double t) { } + @Override public double g(double t, double[] y) { return t - 12.0; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { return Action.STOP; } + @Override public void resetState(double t, double[] y) { } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/TestProblemAbstract.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/TestProblemAbstract.java b/src/test/java/org/apache/commons/math4/ode/TestProblemAbstract.java index e59df45..baa1ba1 100644 --- a/src/test/java/org/apache/commons/math4/ode/TestProblemAbstract.java +++ b/src/test/java/org/apache/commons/math4/ode/TestProblemAbstract.java @@ -85,7 +85,8 @@ public abstract class TestProblemAbstract this.errorScale = errorScale.clone(); } - public int getDimension() { + @Override +public int getDimension() { return n; } @@ -144,7 +145,8 @@ public abstract class TestProblemAbstract return calls; } - public void computeDerivatives(double t, double[] y, double[] yDot) { + @Override +public void computeDerivatives(double t, double[] y, double[] yDot) { ++calls; doComputeDerivatives(t, y, yDot); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/TestProblemHandler.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/TestProblemHandler.java b/src/test/java/org/apache/commons/math4/ode/TestProblemHandler.java index 73402e5..00c40b3 100644 --- a/src/test/java/org/apache/commons/math4/ode/TestProblemHandler.java +++ b/src/test/java/org/apache/commons/math4/ode/TestProblemHandler.java @@ -63,14 +63,16 @@ public class TestProblemHandler expectedStepStart = Double.NaN; } - public void init(double t0, double[] y0, double t) { + @Override +public void init(double t0, double[] y0, double t) { maxValueError = 0; maxTimeError = 0; lastError = 0; expectedStepStart = Double.NaN; } - public void handleStep(StepInterpolator interpolator, boolean isLast) throws MaxCountExceededException { + @Override +public void handleStep(StepInterpolator interpolator, boolean isLast) throws MaxCountExceededException { double start = integrator.getCurrentStepStart(); if (FastMath.abs((start - problem.getInitialTime()) / integrator.getCurrentSignedStepsize()) > 0.001) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/events/CloseEventsTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/events/CloseEventsTest.java b/src/test/java/org/apache/commons/math4/ode/events/CloseEventsTest.java index 59366d1..ecd3b4c 100644 --- a/src/test/java/org/apache/commons/math4/ode/events/CloseEventsTest.java +++ b/src/test/java/org/apache/commons/math4/ode/events/CloseEventsTest.java @@ -93,18 +93,22 @@ public class CloseEventsTest { return actualT; } + @Override public void init(double t0, double[] y0, double t) { } + @Override public double g(double t, double[] y) { return t - eventT; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { this.actualT = t; return Action.CONTINUE; } + @Override public void resetState(double t, double[] y) { } @@ -113,10 +117,12 @@ public class CloseEventsTest { /** Some basic equations to integrate. */ public static class Equation implements FirstOrderDifferentialEquations { + @Override public int getDimension() { return 2; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = 1.0; yDot[1] = 2.0; http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/events/EventFilterTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/events/EventFilterTest.java b/src/test/java/org/apache/commons/math4/ode/events/EventFilterTest.java index 7fb853d..34085b0 100644 --- a/src/test/java/org/apache/commons/math4/ode/events/EventFilterTest.java +++ b/src/test/java/org/apache/commons/math4/ode/events/EventFilterTest.java @@ -220,10 +220,12 @@ public class EventFilterTest { } private static class SineCosine implements FirstOrderDifferentialEquations { + @Override public int getDimension() { return 2; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = y[1]; yDot[1] = -y[0]; @@ -246,14 +248,17 @@ public class EventFilterTest { return eventCount; } + @Override public void init(double t0, double[] y0, double t) { eventCount = 0; } + @Override public double g(double t, double[] y) { return y[0]; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { if (increasing) { Assert.assertTrue(expectIncreasing); @@ -264,6 +269,7 @@ public class EventFilterTest { return Action.RESET_STATE; } + @Override public void resetState(double t, double[] y) { // in fact, we don't really reset anything for this test } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/events/EventStateTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/events/EventStateTest.java b/src/test/java/org/apache/commons/math4/ode/events/EventStateTest.java index cb8f5a8..cd13861 100644 --- a/src/test/java/org/apache/commons/math4/ode/events/EventStateTest.java +++ b/src/test/java/org/apache/commons/math4/ode/events/EventStateTest.java @@ -50,9 +50,11 @@ public class EventStateTest { tolerance, 100, new BrentSolver(tolerance)); es.setExpandable(new ExpandableStatefulODE(new FirstOrderDifferentialEquations() { + @Override public int getDimension() { return 0; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { } })); @@ -89,10 +91,12 @@ public class EventStateTest { FirstOrderDifferentialEquations equation = new FirstOrderDifferentialEquations() { + @Override public int getDimension() { return 1; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = 1.0; } @@ -120,9 +124,11 @@ public class EventStateTest { this.tEvent = tEvent; } + @Override public void init(double t0, double[] y0, double t) { } + @Override public double g(double t, double[] y) { // the bug corresponding to issue 695 causes the g function // to be called at obsolete times t despite an event @@ -133,12 +139,14 @@ public class EventStateTest { return t - tEvent; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { // remember in a class variable when the event was triggered lastTriggerTime = t; return Action.RESET_STATE; } + @Override public void resetState(double t, double[] y) { y[0] += 1.0; } @@ -154,10 +162,12 @@ public class EventStateTest { ExpandableStatefulODE equation = new ExpandableStatefulODE(new FirstOrderDifferentialEquations() { + @Override public int getDimension() { return 1; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = 2.0; } @@ -166,10 +176,12 @@ public class EventStateTest { equation.setPrimaryState(new double[1]); equation.addSecondaryEquations(new SecondaryEquations() { + @Override public int getDimension() { return 1; } + @Override public void computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary, double[] secondaryDot) { @@ -199,17 +211,21 @@ public class EventStateTest { this.target = target; } + @Override public void init(double t0, double[] y0, double t) { } + @Override public double g(double t, double[] y) { return y[index] - target; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { return Action.STOP; } + @Override public void resetState(double t, double[] y) { } @@ -222,10 +238,12 @@ public class EventStateTest { FirstOrderDifferentialEquations equation = new FirstOrderDifferentialEquations() { + @Override public int getDimension() { return 1; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = 1.0; } @@ -254,16 +272,20 @@ public class EventStateTest { this.count = 0; } + @Override public void init(double t0, double[] y0, double t) { } + @Override public void resetState(double t, double[] y) { } + @Override public double g(double t, double[] y) { return (t - r1) * (r2 - t); } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { return ++count < 2 ? Action.CONTINUE : Action.STOP; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/events/OverlappingEventsTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/events/OverlappingEventsTest.java b/src/test/java/org/apache/commons/math4/ode/events/OverlappingEventsTest.java index 38f1cf3..7d24ad3 100644 --- a/src/test/java/org/apache/commons/math4/ode/events/OverlappingEventsTest.java +++ b/src/test/java/org/apache/commons/math4/ode/events/OverlappingEventsTest.java @@ -119,11 +119,13 @@ public class OverlappingEventsTest implements FirstOrderDifferentialEquations { } /** {@inheritDoc} */ + @Override public int getDimension() { return 2; } /** {@inheritDoc} */ + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { yDot[0] = 1.0; yDot[1] = 2.0; @@ -147,21 +149,25 @@ public class OverlappingEventsTest implements FirstOrderDifferentialEquations { } /** {@inheritDoc} */ + @Override public void init(double t0, double[] y0, double t) { } /** {@inheritDoc} */ + @Override public double g(double t, double[] y) { return (eventType == 0) ? y[idx] >= 1.0 ? 1.0 : -1.0 : y[idx] - 1.0; } /** {@inheritDoc} */ + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { return Action.STOP; } /** {@inheritDoc} */ + @Override public void resetState(double t, double[] y) { // Never called. } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/events/ReappearingEventTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/events/ReappearingEventTest.java b/src/test/java/org/apache/commons/math4/ode/events/ReappearingEventTest.java index b53e760..84e7b85 100644 --- a/src/test/java/org/apache/commons/math4/ode/events/ReappearingEventTest.java +++ b/src/test/java/org/apache/commons/math4/ode/events/ReappearingEventTest.java @@ -66,10 +66,12 @@ public class ReappearingEventTest { } private static class Ode implements FirstOrderDifferentialEquations { + @Override public int getDimension() { return 7; } + @Override public void computeDerivatives(double t, double[] y, double[] yDot) { Arrays.fill(yDot, 1.0); } @@ -78,17 +80,21 @@ public class ReappearingEventTest { /** State events for this unit test. */ protected static class Event implements EventHandler { + @Override public void init(double t0, double[] y0, double t) { } + @Override public double g(double t, double[] y) { return y[6] - 15.0; } + @Override public Action eventOccurred(double t, double[] y, boolean increasing) { return Action.STOP; } + @Override public void resetState(double t, double[] y) { // Never called. } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java index aceede0..01b6512 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java @@ -133,13 +133,16 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { protected <T extends RealFieldElement<T>> void doTestForwardBackwardExceptions(final Field<T> field) { FirstOrderFieldDifferentialEquations<T> equations = new FirstOrderFieldDifferentialEquations<T>() { + @Override public int getDimension() { return 1; } + @Override public void init(T t0, T[] y0, T t) { } + @Override public T[] computeDerivatives(T t, T[] y) { if (t.getReal() < -0.5) { throw new LocalException(); @@ -281,12 +284,15 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { integ.addStepHandler(handler); integ.addEventHandler(new FieldEventHandler<T>() { - public void init(FieldODEStateAndDerivative<T> state0, T t) { + @Override + public void init(FieldODEStateAndDerivative<T> state0, T t) { } - public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) { + @Override + public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) { return Action.CONTINUE; } - public T g(FieldODEStateAndDerivative<T> state) { + @Override + public T g(FieldODEStateAndDerivative<T> state) { T middle = pb.getInitialState().getTime().add(pb.getFinalTime()).multiply(0.5); T offset = state.getTime().subtract(middle); if (offset.getReal() > 0) { @@ -294,7 +300,8 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { } return offset; } - public FieldODEState<T> resetState(FieldODEStateAndDerivative<T> state) { + @Override + public FieldODEState<T> resetState(FieldODEStateAndDerivative<T> state) { return state; } }, Double.POSITIVE_INFINITY, 1.0e-8 * maxStep, 1000); @@ -320,16 +327,20 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { integ.addStepHandler(handler); integ.addEventHandler(new FieldEventHandler<T>() { + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { } + @Override public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) { return Action.CONTINUE; } + @Override public T g(FieldODEStateAndDerivative<T> state) { T middle = pb.getInitialState().getTime().add(pb.getFinalTime()).multiply(0.5); T offset = state.getTime().subtract(middle); return (offset.getReal() > 0) ? offset.add(0.5) : offset.subtract(0.5); } + @Override public FieldODEState<T> resetState(FieldODEStateAndDerivative<T> state) { return state; } @@ -437,9 +448,11 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { this.epsilon = epsilon; maxError = pb.getField().getZero(); } + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { maxError = pb.getField().getZero(); } + @Override public void handleStep(FieldStepInterpolator<T> interpolator, boolean isLast) throws MaxCountExceededException { @@ -528,10 +541,12 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { this.omega = omega; } + @Override public int getDimension() { return 2; } + @Override public void init(final DerivativeStructure t0, final DerivativeStructure[] y0, final DerivativeStructure finalTime) { @@ -551,6 +566,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest { } + @Override public DerivativeStructure[] computeDerivatives(final DerivativeStructure t, final DerivativeStructure[] y) { return new DerivativeStructure[] { omega.multiply(y[1]), http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java index 80b6828..3c96a74 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java @@ -128,13 +128,16 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { k[2] = field.getZero().add(1.0e-6); FirstOrderFieldDifferentialEquations<T> ode = new FirstOrderFieldDifferentialEquations<T>() { + @Override public int getDimension() { return k.length; } + @Override public void init(T t0, T[] y0, T t) { } + @Override public T[] computeDerivatives(T t, T[] y) { T[] yDot = MathArrays.buildArray(field, k.length); for (int i = 0; i < y.length; ++i) { @@ -164,17 +167,21 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { integrator.addEventHandler(new FieldEventHandler<T>() { + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { } + @Override public FieldODEState<T> resetState(FieldODEStateAndDerivative<T> state) { return state; } + @Override public T g(FieldODEStateAndDerivative<T> state) { return state.getTime().subtract(tEvent); } + @Override public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) { Assert.assertEquals(tEvent.getReal(), state.getTime().getReal(), epsilonT); return Action.CONTINUE; @@ -385,9 +392,11 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { this.epsilon = epsilon; maxError = pb.getField().getZero(); } + @Override public void init(FieldODEStateAndDerivative<T> state0, T t) { maxError = pb.getField().getZero(); } + @Override public void handleStep(FieldStepInterpolator<T> interpolator, boolean isLast) throws MaxCountExceededException { @@ -414,6 +423,7 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { final T step = field.getZero().add(1.23456); RungeKuttaFieldIntegrator<T> integ = createIntegrator(field, step); integ.addStepHandler(new FieldStepHandler<T>() { + @Override public void handleStep(FieldStepInterpolator<T> interpolator, boolean isLast) { if (! isLast) { Assert.assertEquals(step.getReal(), @@ -421,17 +431,21 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { epsilon); } } + @Override public void init(FieldODEStateAndDerivative<T> s0, T t) { } }); integ.integrate(new FieldExpandableODE<>(new FirstOrderFieldDifferentialEquations<T>() { + @Override public void init(T t0, T[] y0, T t) { } + @Override public T[] computeDerivatives(T t, T[] y) { T[] dot = MathArrays.buildArray(t.getField(), 1); dot[0] = t.getField().getOne(); return dot; } + @Override public int getDimension() { return 1; } @@ -472,13 +486,16 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { final T t = field.getZero().add(0.001); FirstOrderFieldDifferentialEquations<T> equations = new FirstOrderFieldDifferentialEquations<T>() { + @Override public int getDimension() { return 1; } + @Override public void init(T t0, T[] y0, T t) { } + @Override public T[] computeDerivatives(T t, T[] y) { Assert.assertTrue(t.getReal() >= FastMath.nextAfter(t0.getReal(), Double.NEGATIVE_INFINITY)); Assert.assertTrue(t.getReal() <= FastMath.nextAfter(t.getReal(), Double.POSITIVE_INFINITY)); @@ -590,10 +607,12 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { this.omega = omega; } + @Override public int getDimension() { return 2; } + @Override public void init(final DerivativeStructure t0, final DerivativeStructure[] y0, final DerivativeStructure finalTime) { @@ -613,6 +632,7 @@ public abstract class AbstractRungeKuttaFieldIntegratorTest { } + @Override public DerivativeStructure[] computeDerivatives(final DerivativeStructure t, final DerivativeStructure[] y) { return new DerivativeStructure[] { omega.multiply(y[1]), http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthFieldIntegratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthFieldIntegratorTest.java index 15d05a8..0918abd 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthFieldIntegratorTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthFieldIntegratorTest.java @@ -28,6 +28,7 @@ import org.junit.Test; public class AdamsBashforthFieldIntegratorTest extends AdamsFieldIntegratorAbstractTest { + @Override protected <T extends RealFieldElement<T>> AdamsFieldIntegrator<T> createIntegrator(Field<T> field, final int nSteps, final double minStep, final double maxStep, final double scalAbsoluteTolerance, final double scalRelativeTolerance) { @@ -35,6 +36,7 @@ public class AdamsBashforthFieldIntegratorTest extends AdamsFieldIntegratorAbstr scalAbsoluteTolerance, scalRelativeTolerance); } + @Override protected <T extends RealFieldElement<T>> AdamsFieldIntegrator<T> createIntegrator(Field<T> field, final int nSteps, final double minStep, final double maxStep, final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) { @@ -42,11 +44,13 @@ public class AdamsBashforthFieldIntegratorTest extends AdamsFieldIntegratorAbstr vecAbsoluteTolerance, vecRelativeTolerance); } + @Override @Test(expected=NumberIsTooSmallException.class) public void testMinStep() { doDimensionCheck(Decimal64Field.getInstance()); } + @Override @Test public void testIncreasingTolerance() { // the 2.6 and 122 factors are only valid for this test @@ -55,21 +59,25 @@ public class AdamsBashforthFieldIntegratorTest extends AdamsFieldIntegratorAbstr doTestIncreasingTolerance(Decimal64Field.getInstance(), 2.6, 122); } + @Override @Test(expected = MaxCountExceededException.class) public void exceedMaxEvaluations() { doExceedMaxEvaluations(Decimal64Field.getInstance(), 650); } + @Override @Test public void backward() { doBackward(Decimal64Field.getInstance(), 4.3e-8, 4.3e-8, 1.0e-16, "Adams-Bashforth"); } + @Override @Test public void polynomial() { doPolynomial(Decimal64Field.getInstance(), 5, 0.004, 6.0e-10); } + @Override @Test(expected=MathIllegalStateException.class) public void testStartFailure() { doTestStartFailure(Decimal64Field.getInstance()); http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegratorTest.java index f655238..70af74b 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegratorTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegratorTest.java @@ -198,6 +198,7 @@ public class AdamsBashforthIntegratorTest { this.nbSteps = nbSteps; } + @Override public void integrate(ExpandableStatefulODE equations, double t) { double tStart = equations.getTime() + 0.01 * (t - equations.getTime()); getCounter().increment(nbSteps); @@ -227,12 +228,15 @@ public class AdamsBashforthIntegratorTest { this.interpolatedTime = problem.getInitialTime(); } + @Override public void readExternal(ObjectInput arg0) { } + @Override public void writeExternal(ObjectOutput arg0) { } + @Override public double getPreviousTime() { return previousTime; } @@ -241,6 +245,7 @@ public class AdamsBashforthIntegratorTest { previousTime = time; } + @Override public double getCurrentTime() { return currentTime; } @@ -249,18 +254,22 @@ public class AdamsBashforthIntegratorTest { currentTime = time; } + @Override public double getInterpolatedTime() { return interpolatedTime; } + @Override public void setInterpolatedTime(double time) { interpolatedTime = time; } + @Override public double[] getInterpolatedState() { return problem.computeTheoreticalState(interpolatedTime); } + @Override public double[] getInterpolatedDerivatives() { double[] y = problem.computeTheoreticalState(interpolatedTime); double[] yDot = new double[y.length]; @@ -268,18 +277,22 @@ public class AdamsBashforthIntegratorTest { return yDot; } + @Override public double[] getInterpolatedSecondaryState(int index) { return null; } + @Override public double[] getInterpolatedSecondaryDerivatives(int index) { return null; } + @Override public boolean isForward() { return problem.getFinalTime() > problem.getInitialTime(); } + @Override public StepInterpolator copy() { return this; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java index 1f786bc..a767f35 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java @@ -198,6 +198,7 @@ public abstract class AdamsFieldIntegratorAbstractTest { this.nbSteps = nbSteps; } + @Override public FieldODEStateAndDerivative<T> integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime) { T tStart = initialState.getTime().add(finalTime.subtract(initialState.getTime()).multiply(0.01)); @@ -237,18 +238,22 @@ public abstract class AdamsFieldIntegratorAbstractTest { return currentTime; } + @Override public boolean isForward() { return problem.getFinalTime().subtract(problem.getInitialState().getTime()).getReal() >= 0; } + @Override public FieldODEStateAndDerivative<T> getPreviousState() { return getInterpolatedState(previousTime); } + @Override public FieldODEStateAndDerivative<T> getCurrentState() { return getInterpolatedState(currentTime); } + @Override public FieldODEStateAndDerivative<T> getInterpolatedState(T time) { T[] y = problem.computeTheoreticalState(time); T[] yDot = problem.computeDerivatives(time, y); http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegratorTest.java index 84a0f7d..b3a2063 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegratorTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegratorTest.java @@ -28,6 +28,7 @@ import org.junit.Test; public class AdamsMoultonFieldIntegratorTest extends AdamsFieldIntegratorAbstractTest { + @Override protected <T extends RealFieldElement<T>> AdamsFieldIntegrator<T> createIntegrator(Field<T> field, final int nSteps, final double minStep, final double maxStep, final double scalAbsoluteTolerance, final double scalRelativeTolerance) { @@ -35,6 +36,7 @@ public class AdamsMoultonFieldIntegratorTest extends AdamsFieldIntegratorAbstrac scalAbsoluteTolerance, scalRelativeTolerance); } + @Override protected <T extends RealFieldElement<T>> AdamsFieldIntegrator<T> createIntegrator(Field<T> field, final int nSteps, final double minStep, final double maxStep, final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) { @@ -42,11 +44,13 @@ public class AdamsMoultonFieldIntegratorTest extends AdamsFieldIntegratorAbstrac vecAbsoluteTolerance, vecRelativeTolerance); } + @Override @Test(expected=NumberIsTooSmallException.class) public void testMinStep() { doDimensionCheck(Decimal64Field.getInstance()); } + @Override @Test public void testIncreasingTolerance() { // the 0.45 and 8.69 factors are only valid for this test @@ -55,21 +59,25 @@ public class AdamsMoultonFieldIntegratorTest extends AdamsFieldIntegratorAbstrac doTestIncreasingTolerance(Decimal64Field.getInstance(), 0.45, 8.69); } + @Override @Test(expected = MaxCountExceededException.class) public void exceedMaxEvaluations() { doExceedMaxEvaluations(Decimal64Field.getInstance(), 650); } + @Override @Test public void backward() { doBackward(Decimal64Field.getInstance(), 3.0e-9, 3.0e-9, 1.0e-16, "Adams-Moulton"); } + @Override @Test public void polynomial() { doPolynomial(Decimal64Field.getInstance(), 5, 2.2e-05, 1.1e-11); } + @Override @Test(expected=MathIllegalStateException.class) public void testStartFailure() { doTestStartFailure(Decimal64Field.getInstance()); http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegratorTest.java index 3e03651..23063bf 100644 --- a/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegratorTest.java +++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegratorTest.java @@ -186,6 +186,7 @@ public class AdamsMoultonIntegratorTest { this.nbSteps = nbSteps; } + @Override public void integrate(ExpandableStatefulODE equations, double t) { double tStart = equations.getTime() + 0.01 * (t - equations.getTime()); getCounter().increment(nbSteps); @@ -215,12 +216,15 @@ public class AdamsMoultonIntegratorTest { this.interpolatedTime = problem.getInitialTime(); } + @Override public void readExternal(ObjectInput arg0) { } + @Override public void writeExternal(ObjectOutput arg0) { } + @Override public double getPreviousTime() { return previousTime; } @@ -229,6 +233,7 @@ public class AdamsMoultonIntegratorTest { previousTime = time; } + @Override public double getCurrentTime() { return currentTime; } @@ -237,18 +242,22 @@ public class AdamsMoultonIntegratorTest { currentTime = time; } + @Override public double getInterpolatedTime() { return interpolatedTime; } + @Override public void setInterpolatedTime(double time) { interpolatedTime = time; } + @Override public double[] getInterpolatedState() { return problem.computeTheoreticalState(interpolatedTime); } + @Override public double[] getInterpolatedDerivatives() { double[] y = problem.computeTheoreticalState(interpolatedTime); double[] yDot = new double[y.length]; @@ -256,18 +265,22 @@ public class AdamsMoultonIntegratorTest { return yDot; } + @Override public double[] getInterpolatedSecondaryState(int index) { return null; } + @Override public double[] getInterpolatedSecondaryDerivatives(int index) { return null; } + @Override public boolean isForward() { return problem.getFinalTime() > problem.getInitialTime(); } + @Override public StepInterpolator copy() { return this; }