commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ggreg...@apache.org
Subject [2/4] [math] Add missing '@Override' annotations.
Date Tue, 20 Sep 2016 17:38:18 GMT
http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungKuttaFieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungKuttaFieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungKuttaFieldStepInterpolatorTest.java
index f484baa..2292028 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungKuttaFieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungKuttaFieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class ClassicalRungKuttaFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class ClassicalRungKuttaFieldStepInterpolatorTest extends RungeKuttaField
                                                                mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new ClassicalRungeKuttaFieldIntegrator<>(field, field.getOne());
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-15);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 2.6e-7, 3.6e-6);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 2.8e-17, 1.2e-16, 3.4e-16, 2.1e-17);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegratorTest.java
index ebc9962..45e4e4e 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegratorTest.java
@@ -24,6 +24,7 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class ClassicalRungeKuttaFieldIntegratorTest extends RungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, T step) {
         return new ClassicalRungeKuttaFieldIntegrator<>(field, step);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
index 016576b..8fc5df3 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
@@ -52,11 +52,13 @@ public class ClassicalRungeKuttaIntegratorTest {
       final double[] k      = { 1.0e-4, 1.0e-5, 1.0e-6 };
       FirstOrderDifferentialEquations ode = new FirstOrderDifferentialEquations() {
 
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return k.length;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               for (int i = 0; i < y.length; ++i) {
                   yDot[i] = k[i] * y[i];
               }
@@ -79,17 +81,21 @@ public class ClassicalRungeKuttaIntegratorTest {
 
       integrator.addEventHandler(new EventHandler() {
 
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
 
-          public void resetState(double t, double[] y) {
+          @Override
+        public void resetState(double t, double[] y) {
           }
 
-          public double g(double t, double[] y) {
+          @Override
+        public double g(double t, double[] y) {
               return t - tEvent;
           }
 
-          public Action eventOccurred(double t, double[] y, boolean increasing) {
+          @Override
+        public Action eventOccurred(double t, double[] y, boolean increasing) {
               Assert.assertEquals(tEvent, t, 5.0e-6);
               return Action.CONTINUE;
           }
@@ -263,9 +269,11 @@ public class ClassicalRungeKuttaIntegratorTest {
       this.pb = pb;
       maxError = 0;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       maxError = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast)
         throws MaxCountExceededException {
 
@@ -295,21 +303,25 @@ public class ClassicalRungeKuttaIntegratorTest {
       final double step = 1.23456;
       FirstOrderIntegrator integ = new ClassicalRungeKuttaIntegrator(step);
       integ.addStepHandler(new StepHandler() {
-          public void handleStep(StepInterpolator interpolator, boolean isLast) {
+          @Override
+        public void handleStep(StepInterpolator interpolator, boolean isLast) {
               if (! isLast) {
                   Assert.assertEquals(step,
                                interpolator.getCurrentTime() - interpolator.getPreviousTime(),
                                1.0e-12);
               }
           }
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
       });
       integ.integrate(new FirstOrderDifferentialEquations() {
-          public void computeDerivatives(double t, double[] y, double[] dot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] dot) {
               dot[0] = 1.0;
           }
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
       }, 0.0, new double[] { 0.0 }, 5.0, new double[1]);
@@ -323,11 +335,13 @@ public class ClassicalRungeKuttaIntegratorTest {
       final double end   = 0.001;
       FirstOrderDifferentialEquations equations = new FirstOrderDifferentialEquations() {
 
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               Assert.assertTrue(t >= FastMath.nextAfter(start, Double.NEGATIVE_INFINITY));
               Assert.assertTrue(t <= FastMath.nextAfter(end,   Double.POSITIVE_INFINITY));
               yDot[0] = -100.0 * y[0];

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegratorTest.java
index 28267e0..c3e24b1 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegratorTest.java
@@ -24,12 +24,14 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class DormandPrince54FieldIntegratorTest extends EmbeddedRungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> EmbeddedRungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, final double minStep, final double maxStep,
                      final double scalAbsoluteTolerance, final double scalRelativeTolerance) {
         return new DormandPrince54FieldIntegrator<>(field, minStep, maxStep, scalAbsoluteTolerance, scalRelativeTolerance);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> EmbeddedRungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, final double minStep, final double maxStep,
                      final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldStepInterpolatorTest.java
index b10501f..4bda2df 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class DormandPrince54FieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class DormandPrince54FieldStepInterpolatorTest extends RungeKuttaFieldSte
                                                            mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new DormandPrince54FieldIntegrator<>(field, 0, 1, 1, 1);
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-50);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 9.5e-14, 1.8e-15);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 2.8e-17, 2.3e-16, 5.6e-16, 5.6e-17);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54IntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54IntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54IntegratorTest.java
index b4909c9..870d5e9 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54IntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54IntegratorTest.java
@@ -135,9 +135,11 @@ public class DormandPrince54IntegratorTest {
       this.minStep = minStep;
     }
 
+    @Override
     public void init(double t0, double[] y0, double t) {
     }
 
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast) {
       if (isLast) {
         lastSeen = true;
@@ -281,10 +283,12 @@ public class DormandPrince54IntegratorTest {
     public KeplerHandler(TestProblem3 pb) {
       this.pb = pb;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       nbSteps = 0;
       maxError = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast)
         throws MaxCountExceededException {
 
@@ -321,11 +325,13 @@ public class DormandPrince54IntegratorTest {
       minStep = 0;
       maxStep = 0;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       firstTime = true;
       minStep = 0;
       maxStep = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator,
                            boolean isLast) {
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54StepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
index 06949e3..8fa30ff 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
@@ -121,7 +121,8 @@ public class DormandPrince54StepInterpolatorTest {
                                                                       scalAbsoluteTolerance,
                                                                       scalRelativeTolerance);
       integ.addStepHandler(new StepHandler() {
-          public void handleStep(StepInterpolator interpolator, boolean isLast)
+          @Override
+        public void handleStep(StepInterpolator interpolator, boolean isLast)
               throws MaxCountExceededException {
               StepInterpolator cloned = interpolator.copy();
               double tA = cloned.getPreviousTime();
@@ -142,7 +143,8 @@ public class DormandPrince54StepInterpolatorTest {
                   }
               }
           }
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
       });
       integ.integrate(pb,

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldIntegratorTest.java
index 258ccc7..839c6e1 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldIntegratorTest.java
@@ -24,12 +24,14 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class DormandPrince853FieldIntegratorTest extends EmbeddedRungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> EmbeddedRungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, final double minStep, final double maxStep,
                      final double scalAbsoluteTolerance, final double scalRelativeTolerance) {
         return new DormandPrince853FieldIntegrator<>(field, minStep, maxStep, scalAbsoluteTolerance, scalRelativeTolerance);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> EmbeddedRungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, final double minStep, final double maxStep,
                      final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldStepInterpolatorTest.java
index 69dbec4..541dbe0 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853FieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class DormandPrince853FieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class DormandPrince853FieldStepInterpolatorTest extends RungeKuttaFieldSt
                                                             mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new DormandPrince853FieldIntegrator<>(field, 0, 1, 1, 1);
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-50);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 3.1e-17, 3.4e-16);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 3.4e-12, 5.7e-11, 1.9e-10, 3.1e-9);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853IntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853IntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853IntegratorTest.java
index 33c721c..21bd0c2 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853IntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853IntegratorTest.java
@@ -49,11 +49,13 @@ public class DormandPrince853IntegratorTest {
       final double[] k  = { 1.0e-4, 1.0e-5, 1.0e-6 };
       FirstOrderDifferentialEquations ode = new FirstOrderDifferentialEquations() {
 
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return k.length;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               for (int i = 0; i < y.length; ++i) {
                   yDot[i] = k[i] * y[i];
               }
@@ -79,17 +81,21 @@ public class DormandPrince853IntegratorTest {
       integrator.setInitialStepSize(60.0);
       integrator.addEventHandler(new EventHandler() {
 
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
 
-          public void resetState(double t, double[] y) {
+          @Override
+        public void resetState(double t, double[] y) {
           }
 
-          public double g(double t, double[] y) {
+          @Override
+        public double g(double t, double[] y) {
               return t - tEvent;
           }
 
-          public Action eventOccurred(double t, double[] y, boolean increasing) {
+          @Override
+        public Action eventOccurred(double t, double[] y, boolean increasing) {
               Assert.assertEquals(tEvent, t, 5.0e-6);
               return Action.CONTINUE;
           }
@@ -200,11 +206,13 @@ public class DormandPrince853IntegratorTest {
       final double end   = 0.001;
       FirstOrderDifferentialEquations equations = new FirstOrderDifferentialEquations() {
 
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               Assert.assertTrue(t >= FastMath.nextAfter(start, Double.NEGATIVE_INFINITY));
               Assert.assertTrue(t <= FastMath.nextAfter(end,   Double.POSITIVE_INFINITY));
               yDot[0] = -100.0 * y[0];
@@ -340,11 +348,13 @@ public class DormandPrince853IntegratorTest {
 
       FirstOrderDifferentialEquations sincos = new FirstOrderDifferentialEquations() {
 
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 2;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               yDot[0] =  y[1];
               yDot[1] = -y[0];
           }
@@ -377,26 +387,31 @@ public class DormandPrince853IntegratorTest {
           this.index = index;
       }
 
-      public void init(double t0, double[] y0, double t) {
+      @Override
+    public void init(double t0, double[] y0, double t) {
           tMin = t0;
       }
 
-      public void handleStep(StepInterpolator interpolator, boolean isLast) {
+      @Override
+    public void handleStep(StepInterpolator interpolator, boolean isLast) {
           tMin = interpolator.getCurrentTime();
       }
 
-      public double g(double t, double[]  y) {
+      @Override
+    public double g(double t, double[]  y) {
           // once a step has been handled by handleStep,
           // events checking should only refer to dates after the step
           Assert.assertTrue(t >= tMin);
           return y[index];
       }
 
-      public Action eventOccurred(double t, double[] y, boolean increasing) {
+      @Override
+    public Action eventOccurred(double t, double[] y, boolean increasing) {
           return Action.RESET_STATE;
       }
 
-      public void resetState(double t, double[] y) {
+      @Override
+    public void resetState(double t, double[] y) {
           // in fact, we don't need to reset anything for the test
       }
 
@@ -406,10 +421,12 @@ public class DormandPrince853IntegratorTest {
     public KeplerHandler(TestProblem3 pb) {
       this.pb = pb;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       nbSteps = 0;
       maxError = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast)
         throws MaxCountExceededException {
 
@@ -446,11 +463,13 @@ public class DormandPrince853IntegratorTest {
         minStep = 0;
         maxStep = 0;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       firstTime = true;
       minStep = 0;
       maxStep = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator,
                            boolean isLast) {
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853StepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
index 512c5b7..3a739ac 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
@@ -121,6 +121,7 @@ public class DormandPrince853StepInterpolatorTest {
                                                                       scalAbsoluteTolerance,
                                                                       scalRelativeTolerance);
     integ.addStepHandler(new StepHandler() {
+        @Override
         public void handleStep(StepInterpolator interpolator, boolean isLast)
             throws MaxCountExceededException {
             StepInterpolator cloned = interpolator.copy();
@@ -142,6 +143,7 @@ public class DormandPrince853StepInterpolatorTest {
                 }
             }
         }
+        @Override
         public void init(double t0, double[] y0, double t) {
         }
     });

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
index edb9501..74cf664 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
@@ -133,13 +133,16 @@ public abstract class EmbeddedRungeKuttaFieldIntegratorAbstractTest {
     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 EmbeddedRungeKuttaFieldIntegratorAbstractTest {
         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 EmbeddedRungeKuttaFieldIntegratorAbstractTest {
             }
             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 EmbeddedRungeKuttaFieldIntegratorAbstractTest {
         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 EmbeddedRungeKuttaFieldIntegratorAbstractTest {
             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 EmbeddedRungeKuttaFieldIntegratorAbstractTest {
             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 EmbeddedRungeKuttaFieldIntegratorAbstractTest {
 
         }
 
+        @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/EulerFieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldIntegratorTest.java
index d492cab..25ca071 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldIntegratorTest.java
@@ -24,6 +24,7 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class EulerFieldIntegratorTest extends RungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, T step) {
         return new EulerFieldIntegrator<>(field, step);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolatorTest.java
index 9f7f1ff..99bc9a5 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class EulerFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -39,21 +40,25 @@ public class EulerFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpola
                                                  mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new EulerFieldIntegrator<>(field, field.getOne());
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-15);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 3.3e-4, 7.9e-3);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 7.0e-18, 1.0e-50, 1.0e-50, 1.0e-50);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerIntegratorTest.java
index e132190..1d63340 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/EulerIntegratorTest.java
@@ -171,6 +171,7 @@ public class EulerIntegratorTest {
       final double step = 1.23456;
       FirstOrderIntegrator integ = new EulerIntegrator(step);
       integ.addStepHandler(new StepHandler() {
+        @Override
         public void handleStep(StepInterpolator interpolator, boolean isLast) {
             if (! isLast) {
                 Assert.assertEquals(step,
@@ -178,14 +179,17 @@ public class EulerIntegratorTest {
                              1.0e-12);
             }
         }
+        @Override
         public void init(double t0, double[] y0, double t) {
         }
       });
       integ.integrate(new FirstOrderDifferentialEquations() {
-                          public void computeDerivatives(double t, double[] y, double[] dot) {
+                          @Override
+                        public void computeDerivatives(double t, double[] y, double[] dot) {
                               dot[0] = 1.0;
                           }
-                          public int getDimension() {
+                          @Override
+                        public int getDimension() {
                               return 1;
                           }
                       }, 0.0, new double[] { 0.0 }, 5.0, new double[1]);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegratorTest.java
index 7100cbf..9255a72 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegratorTest.java
@@ -24,6 +24,7 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class GillFieldIntegratorTest extends RungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, T step) {
         return new GillFieldIntegrator<>(field, step);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolatorTest.java
index 3c7d21c..4b4ea9c 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class GillFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class GillFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolat
                                                 mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new GillFieldIntegrator<>(field, field.getOne());
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-15);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 2.6e-7, 3.6e-6);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 1.4e-17, 1.0e-50, 3.4e-16, 2.1e-17);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/GillIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillIntegratorTest.java
index 790c877..138fdc4 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/GillIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/GillIntegratorTest.java
@@ -193,9 +193,11 @@ public class GillIntegratorTest {
     public KeplerStepHandler(TestProblem3 pb) {
       this.pb = pb;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       maxError = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast)
         throws MaxCountExceededException {
 
@@ -225,21 +227,25 @@ public class GillIntegratorTest {
       final double step = 1.23456;
       FirstOrderIntegrator integ = new GillIntegrator(step);
       integ.addStepHandler(new StepHandler() {
-          public void handleStep(StepInterpolator interpolator, boolean isLast) {
+          @Override
+        public void handleStep(StepInterpolator interpolator, boolean isLast) {
               if (! isLast) {
                   Assert.assertEquals(step,
                                interpolator.getCurrentTime() - interpolator.getPreviousTime(),
                                1.0e-12);
               }
           }
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
       });
       integ.integrate(new FirstOrderDifferentialEquations() {
-          public void computeDerivatives(double t, double[] y, double[] dot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] dot) {
               dot[0] = 1.0;
           }
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
       }, 0.0, new double[] { 0.0 }, 5.0, new double[1]);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
index ad39b78..ae8a8e5 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
@@ -283,11 +283,13 @@ public class GraggBulirschStoerIntegratorTest {
       final double end   = 0.001;
       FirstOrderDifferentialEquations equations = new FirstOrderDifferentialEquations() {
 
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               Assert.assertTrue(t >= FastMath.nextAfter(start, Double.NEGATIVE_INFINITY));
               Assert.assertTrue(t <= FastMath.nextAfter(end,   Double.POSITIVE_INFINITY));
               yDot[0] = -100.0 * y[0];
@@ -320,10 +322,12 @@ public class GraggBulirschStoerIntegratorTest {
     FirstOrderIntegrator integ = new GraggBulirschStoerIntegrator(1e-10, 100.0, 1e-7, 1e-7);
       integ.addStepHandler(new StepHandler() {
 
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
 
-          public void handleStep(StepInterpolator interpolator, boolean isLast)
+          @Override
+        public void handleStep(StepInterpolator interpolator, boolean isLast)
               throws MaxCountExceededException {
               double t = interpolator.getCurrentTime();
               interpolator.setInterpolatedTime(t);
@@ -337,11 +341,13 @@ public class GraggBulirschStoerIntegratorTest {
       double t0 = 3.0;
       double tend = 10.0;
       integ.integrate(new FirstOrderDifferentialEquations() {
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
 
-          public void computeDerivatives(double t, double[] y, double[] yDot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] yDot) {
               yDot[0] = 3.0;
           }
       }, t0, y, tend, y);
@@ -352,10 +358,12 @@ public class GraggBulirschStoerIntegratorTest {
     public KeplerStepHandler(TestProblem3 pb) {
       this.pb = pb;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       nbSteps = 0;
       maxError = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast)
         throws MaxCountExceededException {
 
@@ -392,11 +400,13 @@ public class GraggBulirschStoerIntegratorTest {
         minStep = 0;
         maxStep = 0;
     }
+    @Override
     public void init(double t0, double[] y0, double t) {
       firstTime = true;
       minStep = 0;
       maxStep = 0;
     }
+    @Override
     public void handleStep(StepInterpolator interpolator,
                            boolean isLast) {
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
index a3a211d..fa637d2 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
@@ -123,6 +123,7 @@ public class GraggBulirschStoerStepInterpolatorTest {
                                                                           scalAbsoluteTolerance,
                                                                           scalRelativeTolerance);
     integ.addStepHandler(new StepHandler() {
+        @Override
         public void handleStep(StepInterpolator interpolator, boolean isLast)
             throws MaxCountExceededException {
             StepInterpolator cloned = interpolator.copy();
@@ -144,6 +145,7 @@ public class GraggBulirschStoerStepInterpolatorTest {
                 }
             }
         }
+        @Override
         public void init(double t0, double[] y0, double t) {
         }
     });

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldIntegratorTest.java
index 6263e7c..b0110ae 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldIntegratorTest.java
@@ -24,12 +24,14 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class HighamHall54FieldIntegratorTest extends EmbeddedRungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> EmbeddedRungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, final double minStep, final double maxStep,
                      final double scalAbsoluteTolerance, final double scalRelativeTolerance) {
         return new HighamHall54FieldIntegrator<>(field, minStep, maxStep, scalAbsoluteTolerance, scalRelativeTolerance);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> EmbeddedRungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, final double minStep, final double maxStep,
                      final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldStepInterpolatorTest.java
index 7559e98..b32929c 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54FieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class HighamHall54FieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class HighamHall54FieldStepInterpolatorTest extends RungeKuttaFieldStepIn
                                                         mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new HighamHall54FieldIntegrator<>(field, 0, 1, 1, 1);
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 4.9e-16);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 4.0e-13, 2.7e-15);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 1.3e-16, 1.0e-50, 3.6e-15, 2.1e-16);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54IntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54IntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54IntegratorTest.java
index d34de40..1f57bc1 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54IntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54IntegratorTest.java
@@ -46,6 +46,7 @@ public class HighamHall54IntegratorTest {
           new HighamHall54Integrator(0.0, 1.0, 1.0e-10, 1.0e-10);
       FirstOrderDifferentialEquations equations =
           new FirstOrderDifferentialEquations() {
+            @Override
             public void computeDerivatives(double t, double[] y, double[] dot) {
             if (t < -0.5) {
                 throw new LocalException();
@@ -53,7 +54,8 @@ public class HighamHall54IntegratorTest {
                 throw new RuntimeException("oops");
            }
           }
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
       };
@@ -212,11 +214,14 @@ public class HighamHall54IntegratorTest {
       integ.addStepHandler(handler);
 
       integ.addEventHandler(new EventHandler() {
+        @Override
         public void init(double t0, double[] y0, double t) {
         }
+        @Override
         public Action eventOccurred(double t, double[] y, boolean increasing) {
           return Action.CONTINUE;
         }
+        @Override
         public double g(double t, double[] y) {
           double middle = (pb.getInitialTime() + pb.getFinalTime()) / 2;
           double offset = t - middle;
@@ -225,6 +230,7 @@ public class HighamHall54IntegratorTest {
           }
           return offset;
         }
+        @Override
         public void resetState(double t, double[] y) {
         }
       }, Double.POSITIVE_INFINITY, 1.0e-8 * maxStep, 1000);
@@ -257,17 +263,21 @@ public class HighamHall54IntegratorTest {
     integ.addStepHandler(handler);
 
     integ.addEventHandler(new EventHandler() {
-      public void init(double t0, double[] y0, double t) {
+      @Override
+    public void init(double t0, double[] y0, double t) {
       }
-      public Action eventOccurred(double t, double[] y, boolean increasing) {
+      @Override
+    public Action eventOccurred(double t, double[] y, boolean increasing) {
         return Action.CONTINUE;
       }
-      public double g(double t, double[] y) {
+      @Override
+    public double g(double t, double[] y) {
         double middle = (pb.getInitialTime() + pb.getFinalTime()) / 2;
         double offset = t - middle;
         return (offset > 0) ? (offset + 0.5) : (offset - 0.5);
       }
-      public void resetState(double t, double[] y) {
+      @Override
+    public void resetState(double t, double[] y) {
       }
     }, Double.POSITIVE_INFINITY, 1.0e-8 * maxStep, 3);
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54StepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54StepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54StepInterpolatorTest.java
index 47f653f..d4d23b4 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54StepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/HighamHall54StepInterpolatorTest.java
@@ -121,6 +121,7 @@ public class HighamHall54StepInterpolatorTest {
                                                               scalAbsoluteTolerance,
                                                               scalRelativeTolerance);
     integ.addStepHandler(new StepHandler() {
+        @Override
         public void handleStep(StepInterpolator interpolator, boolean isLast)
             throws MaxCountExceededException {
             StepInterpolator cloned = interpolator.copy();
@@ -142,6 +143,7 @@ public class HighamHall54StepInterpolatorTest {
                 }
             }
         }
+        @Override
         public void init(double t0, double[] y0, double t) {
         }
     });

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegratorTest.java
index 31db176..3074d61 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegratorTest.java
@@ -28,6 +28,7 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class LutherFieldIntegratorTest extends RungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, T step) {
         return new LutherFieldIntegrator<>(field, step);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldStepInterpolatorTest.java
index 1a0d5e2..b83cbf5 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherFieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class LutherFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class LutherFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpol
                                                   mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new LutherFieldIntegrator<>(field, field.getOne());
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-15);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 1.1e-7, 9.6e-9);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 8.4e-17, 2.3e-16, 2.1e-14, 1.3e-15);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherIntegratorTest.java
index 018232e..cccbe1a 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/LutherIntegratorTest.java
@@ -52,10 +52,12 @@ public class LutherIntegratorTest {
         final double[] k      = { 1.0e-4, 1.0e-5, 1.0e-6 };
         FirstOrderDifferentialEquations ode = new FirstOrderDifferentialEquations() {
 
+            @Override
             public int getDimension() {
                 return k.length;
             }
 
+            @Override
             public void computeDerivatives(double t, double[] y, double[] yDot) {
                 for (int i = 0; i < y.length; ++i) {
                     yDot[i] = k[i] * y[i];
@@ -79,16 +81,20 @@ public class LutherIntegratorTest {
 
         integrator.addEventHandler(new EventHandler() {
 
+            @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 - tEvent;
             }
 
+            @Override
             public Action eventOccurred(double t, double[] y, boolean increasing) {
                 Assert.assertEquals(tEvent, t, 1.0e-15);
                 return Action.CONTINUE;
@@ -263,9 +269,11 @@ public class LutherIntegratorTest {
             this.pb = pb;
             maxError = 0;
         }
+        @Override
         public void init(double t0, double[] y0, double t) {
             maxError = 0;
         }
+        @Override
         public void handleStep(StepInterpolator interpolator, boolean isLast) {
 
             double[] interpolatedY = interpolator.getInterpolatedState ();
@@ -291,6 +299,7 @@ public class LutherIntegratorTest {
         final double step = 1.23456;
         FirstOrderIntegrator integ = new LutherIntegrator(step);
         integ.addStepHandler(new StepHandler() {
+            @Override
             public void handleStep(StepInterpolator interpolator, boolean isLast) {
                 if (! isLast) {
                     Assert.assertEquals(step,
@@ -298,13 +307,16 @@ public class LutherIntegratorTest {
                                         1.0e-12);
                 }
             }
+            @Override
             public void init(double t0, double[] y0, double t) {
             }
         });
         integ.integrate(new FirstOrderDifferentialEquations() {
+            @Override
             public void computeDerivatives(double t, double[] y, double[] dot) {
                 dot[0] = 1.0;
             }
+            @Override
             public int getDimension() {
                 return 1;
             }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegratorTest.java
index 0f64075..fe31cf9 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegratorTest.java
@@ -24,6 +24,7 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class MidpointFieldIntegratorTest extends RungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, T step) {
         return new MidpointFieldIntegrator<>(field, step);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolatorTest.java
index ef0aa9c..4794bb0 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class MidpointFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class MidpointFieldStepInterpolatorTest extends RungeKuttaFieldStepInterp
                                                     mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new MidpointFieldIntegrator<>(field, field.getOne());
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-15);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 3.3e-4, 1.1e-5);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 1.4e-17, 1.0e-50, 1.0e-50, 7.0e-18);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegratorTest.java
index 1a1139d..eb87c03 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegratorTest.java
@@ -171,21 +171,25 @@ public class MidpointIntegratorTest {
       final double step = 1.23456;
       FirstOrderIntegrator integ = new MidpointIntegrator(step);
       integ.addStepHandler(new StepHandler() {
-          public void handleStep(StepInterpolator interpolator, boolean isLast) {
+          @Override
+        public void handleStep(StepInterpolator interpolator, boolean isLast) {
               if (! isLast) {
                   Assert.assertEquals(step,
                                interpolator.getCurrentTime() - interpolator.getPreviousTime(),
                                1.0e-12);
               }
           }
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
       });
       integ.integrate(new FirstOrderDifferentialEquations() {
-          public void computeDerivatives(double t, double[] y, double[] dot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] dot) {
               dot[0] = 1.0;
           }
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
       }, 0.0, new double[] { 0.0 }, 5.0, new double[1]);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
index a6d480c..36b1dec 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
@@ -128,13 +128,16 @@ public abstract class RungeKuttaFieldIntegratorAbstractTest {
         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 RungeKuttaFieldIntegratorAbstractTest {
 
         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 RungeKuttaFieldIntegratorAbstractTest {
             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 RungeKuttaFieldIntegratorAbstractTest {
         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 RungeKuttaFieldIntegratorAbstractTest {
                                         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 RungeKuttaFieldIntegratorAbstractTest {
         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 RungeKuttaFieldIntegratorAbstractTest {
             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 RungeKuttaFieldIntegratorAbstractTest {
 
         }
 
+        @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/RungeKuttaFieldStepInterpolatorAbstractTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java
index ca77ac3..9bde16a 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java
@@ -289,11 +289,14 @@ public abstract class RungeKuttaFieldStepInterpolatorAbstractTest {
         protected SinCos(final Field<T> field) {
             this.field = field;
         }
+        @Override
         public int getDimension() {
             return 2;
         }
+        @Override
         public void init(final T t0, final T[] y0, final T finalTime) {
         }
+        @Override
         public T[] computeDerivatives(final T t, final T[] y) {
             T[] yDot = MathArrays.buildArray(field, 2);
             yDot[0] = y[1];

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/StepFieldProblem.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/StepFieldProblem.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/StepFieldProblem.java
index 0368c85..1fc3b62 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/StepFieldProblem.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/StepFieldProblem.java
@@ -37,12 +37,14 @@ public class StepFieldProblem<T extends RealFieldElement<T>>
         setRate(rateBefore);
     }
 
+    @Override
     public T[] computeDerivatives(T t, T[] y) {
         T[] yDot = MathArrays.buildArray(field, 1);
         yDot[0] = rate;
         return yDot;
     }
 
+    @Override
     public int getDimension() {
         return 1;
     }
@@ -51,21 +53,26 @@ public class StepFieldProblem<T extends RealFieldElement<T>>
         this.rate = rate;
     }
 
+    @Override
     public void init(T t0, T[] y0, T t) {
     }
 
+    @Override
     public void init(FieldODEStateAndDerivative<T> state0, T t) {
     }
 
+    @Override
     public Action eventOccurred(FieldODEStateAndDerivative<T> state, boolean increasing) {
         setRate(rateAfter);
         return Action.RESET_DERIVATIVES;
     }
 
+    @Override
     public T g(FieldODEStateAndDerivative<T> state) {
         return state.getTime().subtract(switchTime);
     }
 
+    @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/nonstiff/StepProblem.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/StepProblem.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/StepProblem.java
index 5a52597..4f3ab5e 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/StepProblem.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/StepProblem.java
@@ -31,11 +31,13 @@ public class StepProblem
     setRate(rateBefore);
   }
 
-  public void computeDerivatives(double t, double[] y, double[] yDot) {
+  @Override
+public void computeDerivatives(double t, double[] y, double[] yDot) {
     yDot[0] = rate;
   }
 
-  public int getDimension() {
+  @Override
+public int getDimension() {
     return 1;
   }
 
@@ -43,19 +45,23 @@ public class StepProblem
     this.rate = rate;
   }
 
-  public void init(double t0, double[] y0, double t) {
+  @Override
+public void init(double t0, double[] y0, double t) {
   }
 
-  public Action eventOccurred(double t, double[] y, boolean increasing) {
+  @Override
+public Action eventOccurred(double t, double[] y, boolean increasing) {
     setRate(rateAfter);
     return Action.RESET_DERIVATIVES;
   }
 
-  public double g(double t, double[] y) {
+  @Override
+public double g(double t, double[] y) {
     return t - switchTime;
   }
 
-  public void resetState(double t, double[] y) {
+  @Override
+public void resetState(double t, double[] y) {
   }
 
   private double rate;

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegratorTest.java
index 1739a28..62eae5d 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegratorTest.java
@@ -24,6 +24,7 @@ import org.apache.commons.math4.util.Decimal64Field;
 
 public class ThreeEighthesFieldIntegratorTest extends RungeKuttaFieldIntegratorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldIntegrator<T>
     createIntegrator(Field<T> field, T step) {
         return new ThreeEighthesFieldIntegrator<>(field, step);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolatorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolatorTest.java
index 601a32f..f125a2d 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolatorTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
 
 public class ThreeEighthesFieldStepInterpolatorTest extends RungeKuttaFieldStepInterpolatorAbstractTest {
 
+    @Override
     protected <T extends RealFieldElement<T>> RungeKuttaFieldStepInterpolator<T>
     createInterpolator(Field<T> field, boolean forward, T[][] yDotK,
                        FieldODEStateAndDerivative<T> globalPreviousState,
@@ -40,21 +41,25 @@ public class ThreeEighthesFieldStepInterpolatorTest extends RungeKuttaFieldStepI
                                                          mapper);
     }
 
+    @Override
     protected <T extends RealFieldElement<T>> FieldButcherArrayProvider<T>
     createButcherArrayProvider(final Field<T> field) {
         return new ThreeEighthesFieldIntegrator<>(field, field.getOne());
     }
 
+    @Override
     @Test
     public void interpolationAtBounds() {
         doInterpolationAtBounds(Decimal64Field.getInstance(), 1.0e-15);
     }
 
+    @Override
     @Test
     public void interpolationInside() {
         doInterpolationInside(Decimal64Field.getInstance(), 2.6e-7, 3.6e-6);
     }
 
+    @Override
     @Test
     public void nonFieldInterpolatorConsistency() {
         doNonFieldInterpolatorConsistency(Decimal64Field.getInstance(), 1.4e-17, 1.2e-16, 3.4e-16, 1.4e-17);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegratorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegratorTest.java b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegratorTest.java
index 6d95401..c81de9a 100644
--- a/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegratorTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegratorTest.java
@@ -184,10 +184,12 @@ public class ThreeEighthesIntegratorTest {
       maxError = 0;
     }
 
+    @Override
     public void init(double t0, double[] y0, double t) {
       maxError = 0;
     }
 
+    @Override
     public void handleStep(StepInterpolator interpolator, boolean isLast)
         throws MaxCountExceededException {
 
@@ -219,21 +221,25 @@ public class ThreeEighthesIntegratorTest {
       final double step = 1.23456;
       FirstOrderIntegrator integ = new ThreeEighthesIntegrator(step);
       integ.addStepHandler(new StepHandler() {
-          public void handleStep(StepInterpolator interpolator, boolean isLast) {
+          @Override
+        public void handleStep(StepInterpolator interpolator, boolean isLast) {
               if (! isLast) {
                   Assert.assertEquals(step,
                                interpolator.getCurrentTime() - interpolator.getPreviousTime(),
                                1.0e-12);
               }
           }
-          public void init(double t0, double[] y0, double t) {
+          @Override
+        public void init(double t0, double[] y0, double t) {
           }
       });
       integ.integrate(new FirstOrderDifferentialEquations() {
-          public void computeDerivatives(double t, double[] y, double[] dot) {
+          @Override
+        public void computeDerivatives(double t, double[] y, double[] dot) {
               dot[0] = 1.0;
           }
-          public int getDimension() {
+          @Override
+        public int getDimension() {
               return 1;
           }
       }, 0.0, new double[] { 0.0 }, 5.0, new double[1]);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/sampling/StepInterpolatorTestUtils.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/sampling/StepInterpolatorTestUtils.java b/src/test/java/org/apache/commons/math4/ode/sampling/StepInterpolatorTestUtils.java
index d3d5fca..7a8834d 100644
--- a/src/test/java/org/apache/commons/math4/ode/sampling/StepInterpolatorTestUtils.java
+++ b/src/test/java/org/apache/commons/math4/ode/sampling/StepInterpolatorTestUtils.java
@@ -43,6 +43,7 @@ public class StepInterpolatorTestUtils {
                MaxCountExceededException, NoBracketingException {
         integrator.addStepHandler(new StepHandler() {
 
+            @Override
             public void handleStep(StepInterpolator interpolator, boolean isLast)
                 throws MaxCountExceededException {
 
@@ -84,6 +85,7 @@ public class StepInterpolatorTestUtils {
 
             }
 
+            @Override
             public void init(double t0, double[] y0, double t) {
             }
 
@@ -100,6 +102,7 @@ public class StepInterpolatorTestUtils {
                                                                                    final double threshold) {
         integrator.addStepHandler(new FieldStepHandler<T>() {
 
+            @Override
             public void handleStep(FieldStepInterpolator<T> interpolator, boolean isLast)
                 throws MaxCountExceededException {
 
@@ -132,6 +135,7 @@ public class StepInterpolatorTestUtils {
 
             }
 
+            @Override
             public void init(FieldODEStateAndDerivative<T> state0, T t) {
             }
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerOutputTestBase.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerOutputTestBase.java b/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerOutputTestBase.java
index 6f6bfbe..682e16c 100644
--- a/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerOutputTestBase.java
+++ b/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerOutputTestBase.java
@@ -265,20 +265,24 @@ public abstract class StepNormalizerOutputTestBase
     }
 
     /** {@inheritDoc} */
+    @Override
     public int getDimension() {
         return 1;
     }
 
     /** {@inheritDoc} */
+    @Override
     public void computeDerivatives(double t, double[] y, double[] yDot) {
         yDot[0] = y[0];
     }
 
     /** {@inheritDoc} */
+    @Override
     public void init(double t0, double[] y0, double t) {
     }
 
     /** {@inheritDoc} */
+    @Override
     public void handleStep(double t, double[] y, double[] yDot, boolean isLast) {
         output.add(t);
     }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerTest.java b/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerTest.java
index 3a8ba4b..488ff94 100644
--- a/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/sampling/StepNormalizerTest.java
@@ -49,9 +49,11 @@ public class StepNormalizerTest {
     integ.addStepHandler(new StepNormalizer(range / 10.0,
                                        new FixedStepHandler() {
                                          private boolean firstCall = true;
-                                         public void init(double t0, double[] y0, double t) {
+                                         @Override
+                                        public void init(double t0, double[] y0, double t) {
                                          }
-                                         public void handleStep(double t,
+                                         @Override
+                                        public void handleStep(double t,
                                                                 double[] y,
                                                                 double[] yDot,
                                                                 boolean isLast) {
@@ -79,9 +81,11 @@ public class StepNormalizerTest {
     setLastSeen(false);
     integ.addStepHandler(new StepNormalizer(range / 10.5,
                                        new FixedStepHandler() {
-                                         public void init(double t0, double[] y0, double t) {
+                                         @Override
+                                        public void init(double t0, double[] y0, double t) {
                                          }
-                                         public void handleStep(double t,
+                                         @Override
+                                        public void handleStep(double t,
                                                                 double[] y,
                                                                 double[] yDot,
                                                                 boolean isLast) {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
index 1d6ea55..4db0f2b 100644
--- a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
+++ b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
@@ -121,6 +121,7 @@ public class MultiStartMultivariateOptimizerTest {
             count = 0;
         }
 
+        @Override
         public double value(double[] x) {
             ++count;
             double a = x[1] - x[0] * x[0];

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
index ed67a63..3335ec5 100644
--- a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
+++ b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
@@ -163,6 +163,7 @@ public class MultivariateFunctionMappingAdapterTest {
             this.yMax     = yMax;
         }
 
+        @Override
         public double value(double[] point) {
             // the function should never be called with out of range points
             Assert.assertTrue(point[0] >= xMin);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
index 0c02844..79d1ece 100644
--- a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
+++ b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
@@ -171,6 +171,7 @@ public class MultivariateFunctionPenaltyAdapterTest {
             this.yMax     = yMax;
         }
 
+        @Override
         public double value(double[] point) {
             // the function should never be called with out of range points
             Assert.assertTrue(point[0] >= xMin);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/221c843b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/gradient/CircleScalar.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/gradient/CircleScalar.java b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/gradient/CircleScalar.java
index 0c80254..5e5e90a 100644
--- a/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/gradient/CircleScalar.java
+++ b/src/test/java/org/apache/commons/math4/optim/nonlinear/scalar/gradient/CircleScalar.java
@@ -49,6 +49,7 @@ public class CircleScalar {
 
     public ObjectiveFunction getObjectiveFunction() {
         return new ObjectiveFunction(new MultivariateFunction() {
+                @Override
                 public double value(double[] params)  {
                     Vector2D center = new Vector2D(params[0], params[1]);
                     double radius = getRadius(center);
@@ -64,6 +65,7 @@ public class CircleScalar {
 
     public ObjectiveFunctionGradient getObjectiveFunctionGradient() {
         return new ObjectiveFunctionGradient(new MultivariateVectorFunction() {
+                @Override
                 public double[] value(double[] params) {
                     Vector2D center = new Vector2D(params[0], params[1]);
                     double radius = getRadius(center);


Mime
View raw message