commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chtom...@apache.org
Subject [54/57] [abbrv] [math] Add missing '@Override' annotations.
Date Tue, 20 Sep 2016 18:20:39 GMT
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;
         }


Mime
View raw message