commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ggreg...@apache.org
Subject [03/10] [math] Revert "Remove redundant type arguments."
Date Tue, 20 Sep 2016 17:31:53 GMT
http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/linear/MatrixUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/linear/MatrixUtilsTest.java b/src/test/java/org/apache/commons/math4/linear/MatrixUtilsTest.java
index c8bd3f9..b547cdc 100644
--- a/src/test/java/org/apache/commons/math4/linear/MatrixUtilsTest.java
+++ b/src/test/java/org/apache/commons/math4/linear/MatrixUtilsTest.java
@@ -104,9 +104,9 @@ public final class MatrixUtilsTest {
 
     @Test
     public void testcreateFieldMatrix() {
-        Assert.assertEquals(new Array2DRowFieldMatrix<>(asFraction(testData)),
+        Assert.assertEquals(new Array2DRowFieldMatrix<Fraction>(asFraction(testData)),
                      MatrixUtils.createFieldMatrix(asFraction(testData)));
-        Assert.assertEquals(new Array2DRowFieldMatrix<>(FractionField.getInstance(), fractionColMatrix),
+        Assert.assertEquals(new Array2DRowFieldMatrix<Fraction>(FractionField.getInstance(), fractionColMatrix),
                      MatrixUtils.createFieldMatrix(fractionColMatrix));
         try {
             MatrixUtils.createFieldMatrix(asFraction(new double[][] {{1}, {1,2}}));  // ragged
@@ -149,9 +149,9 @@ public final class MatrixUtilsTest {
     @Test
     public void testCreateRowFieldMatrix() {
         Assert.assertEquals(MatrixUtils.createRowFieldMatrix(asFraction(row)),
-                     new Array2DRowFieldMatrix<>(asFraction(rowMatrix)));
+                     new Array2DRowFieldMatrix<Fraction>(asFraction(rowMatrix)));
         Assert.assertEquals(MatrixUtils.createRowFieldMatrix(fractionRow),
-                     new Array2DRowFieldMatrix<>(fractionRowMatrix));
+                     new Array2DRowFieldMatrix<Fraction>(fractionRowMatrix));
         try {
             MatrixUtils.createRowFieldMatrix(new Fraction[] {});  // empty
             Assert.fail("Expecting MathIllegalArgumentException");
@@ -187,9 +187,9 @@ public final class MatrixUtilsTest {
     @Test
     public void testCreateColumnFieldMatrix() {
         Assert.assertEquals(MatrixUtils.createColumnFieldMatrix(asFraction(col)),
-                     new Array2DRowFieldMatrix<>(asFraction(colMatrix)));
+                     new Array2DRowFieldMatrix<Fraction>(asFraction(colMatrix)));
         Assert.assertEquals(MatrixUtils.createColumnFieldMatrix(fractionCol),
-                     new Array2DRowFieldMatrix<>(fractionColMatrix));
+                     new Array2DRowFieldMatrix<Fraction>(fractionColMatrix));
 
         try {
             MatrixUtils.createColumnFieldMatrix(new Fraction[] {});  // empty
@@ -268,7 +268,7 @@ public final class MatrixUtilsTest {
                 { new BigFraction(2), new BigFraction(5), new BigFraction(3) },
                 { new BigFraction(1), new BigFraction(0), new BigFraction(8) }
         };
-        FieldMatrix<BigFraction> m = new Array2DRowFieldMatrix<>(bfData, false);
+        FieldMatrix<BigFraction> m = new Array2DRowFieldMatrix<BigFraction>(bfData, false);
         RealMatrix converted = MatrixUtils.bigFractionMatrixToRealMatrix(m);
         RealMatrix reference = new Array2DRowRealMatrix(testData, false);
         Assert.assertEquals(0.0, converted.subtract(reference).getNorm(), 0.0);
@@ -281,7 +281,7 @@ public final class MatrixUtilsTest {
                 { new Fraction(2), new Fraction(5), new Fraction(3) },
                 { new Fraction(1), new Fraction(0), new Fraction(8) }
         };
-        FieldMatrix<Fraction> m = new Array2DRowFieldMatrix<>(fData, false);
+        FieldMatrix<Fraction> m = new Array2DRowFieldMatrix<Fraction>(fData, false);
         RealMatrix converted = MatrixUtils.fractionMatrixToRealMatrix(m);
         RealMatrix reference = new Array2DRowRealMatrix(testData, false);
         Assert.assertEquals(0.0, converted.subtract(reference).getNorm(), 0.0);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/linear/SparseFieldMatrixTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/linear/SparseFieldMatrixTest.java b/src/test/java/org/apache/commons/math4/linear/SparseFieldMatrixTest.java
index 0266b30..176b227 100644
--- a/src/test/java/org/apache/commons/math4/linear/SparseFieldMatrixTest.java
+++ b/src/test/java/org/apache/commons/math4/linear/SparseFieldMatrixTest.java
@@ -209,7 +209,7 @@ public class SparseFieldMatrixTest {
         SparseFieldMatrix<Fraction> m2 = createSparseMatrix(testData2);
         assertClose("inverse multiply", m.multiply(mInv), identity,
                 entryTolerance);
-        assertClose("inverse multiply", m.multiply(new Array2DRowFieldMatrix<>(FractionField.getInstance(), testDataInv)), identity,
+        assertClose("inverse multiply", m.multiply(new Array2DRowFieldMatrix<Fraction>(FractionField.getInstance(), testDataInv)), identity,
                     entryTolerance);
         assertClose("inverse multiply", mInv.multiply(m), identity,
                 entryTolerance);
@@ -270,7 +270,7 @@ public class SparseFieldMatrixTest {
         assertClose("identity operate", testVector, m.operate(testVector),
                 entryTolerance);
         assertClose("identity operate", testVector, m.operate(
-                new ArrayFieldVector<>(testVector)).toArray(), entryTolerance);
+                new ArrayFieldVector<Fraction>(testVector)).toArray(), entryTolerance);
         m = createSparseMatrix(bigSingular);
         try {
             m.operate(testVector);
@@ -296,8 +296,8 @@ public class SparseFieldMatrixTest {
     @Test
     public void testTranspose() {
         FieldMatrix<Fraction> m = createSparseMatrix(testData);
-        FieldMatrix<Fraction> mIT = new FieldLUDecomposition<>(m).getSolver().getInverse().transpose();
-        FieldMatrix<Fraction> mTI = new FieldLUDecomposition<>(m.transpose()).getSolver().getInverse();
+        FieldMatrix<Fraction> mIT = new FieldLUDecomposition<Fraction>(m).getSolver().getInverse().transpose();
+        FieldMatrix<Fraction> mTI = new FieldLUDecomposition<Fraction>(m.transpose()).getSolver().getInverse();
         assertClose("inverse-transpose", mIT, mTI, normTolerance);
         m = createSparseMatrix(testData2);
         FieldMatrix<Fraction> mt = createSparseMatrix(testData2T);
@@ -311,7 +311,7 @@ public class SparseFieldMatrixTest {
         assertClose("premultiply", m.preMultiply(testVector), preMultTest,
             normTolerance);
         assertClose("premultiply", m.preMultiply(
-            new ArrayFieldVector<>(testVector).toArray()), preMultTest, normTolerance);
+            new ArrayFieldVector<Fraction>(testVector).toArray()), preMultTest, normTolerance);
         m = createSparseMatrix(bigSingular);
         try {
             m.preMultiply(testVector);
@@ -392,7 +392,7 @@ public class SparseFieldMatrixTest {
         Assert.assertEquals(2, p.getRowDimension());
         Assert.assertEquals(2, p.getColumnDimension());
         // Invert p
-        FieldMatrix<Fraction> pInverse = new FieldLUDecomposition<>(p).getSolver().getInverse();
+        FieldMatrix<Fraction> pInverse = new FieldLUDecomposition<Fraction>(p).getSolver().getInverse();
         Assert.assertEquals(2, pInverse.getRowDimension());
         Assert.assertEquals(2, pInverse.getColumnDimension());
 
@@ -402,9 +402,9 @@ public class SparseFieldMatrixTest {
         FieldMatrix<Fraction> coefficients = createSparseMatrix(coefficientsData);
         Fraction[] constants = { new Fraction(1), new Fraction(-2), new Fraction(1) };
         Fraction[] solution;
-        solution = new FieldLUDecomposition<>(coefficients)
+        solution = new FieldLUDecomposition<Fraction>(coefficients)
             .getSolver()
-            .solve(new ArrayFieldVector<>(constants, false)).toArray();
+            .solve(new ArrayFieldVector<Fraction>(constants, false)).toArray();
         Assert.assertEquals((new Fraction(2).multiply((solution[0])).add(new Fraction(3).multiply(solution[1])).subtract(new Fraction(2).multiply(solution[2]))).doubleValue(),
                 constants[0].doubleValue(), 1E-12);
         Assert.assertEquals(((new Fraction(-1).multiply(solution[0])).add(new Fraction(7).multiply(solution[1])).add(new Fraction(6).multiply(solution[2]))).doubleValue(),
@@ -525,8 +525,8 @@ public class SparseFieldMatrixTest {
     @Test
     public void testGetRowVector() {
         FieldMatrix<Fraction> m = createSparseMatrix(subTestData);
-        FieldVector<Fraction> mRow0 = new ArrayFieldVector<>(subRow0[0]);
-        FieldVector<Fraction> mRow3 = new ArrayFieldVector<>(subRow3[0]);
+        FieldVector<Fraction> mRow0 = new ArrayFieldVector<Fraction>(subRow0[0]);
+        FieldVector<Fraction> mRow3 = new ArrayFieldVector<Fraction>(subRow3[0]);
         Assert.assertEquals("Row0", mRow0, m.getRowVector(0));
         Assert.assertEquals("Row3", mRow3, m.getRowVector(3));
         try {
@@ -569,7 +569,7 @@ public class SparseFieldMatrixTest {
         for (int i = 0; i < data.length; ++i) {
             data[i] = column[i][0];
         }
-        return new ArrayFieldVector<>(data, false);
+        return new ArrayFieldVector<Fraction>(data, false);
     }
 
     @Test
@@ -653,7 +653,7 @@ public class SparseFieldMatrixTest {
             // expected
         }
         try {
-            new SparseFieldMatrix<>(field, 0, 0);
+            new SparseFieldMatrix<Fraction>(field, 0, 0);
             Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException e) {
             // expected
@@ -702,7 +702,7 @@ public class SparseFieldMatrixTest {
     }
 
     private SparseFieldMatrix<Fraction> createSparseMatrix(Fraction[][] data) {
-        SparseFieldMatrix<Fraction> matrix = new SparseFieldMatrix<>(field, data.length, data[0].length);
+        SparseFieldMatrix<Fraction> matrix = new SparseFieldMatrix<Fraction>(field, data.length, data[0].length);
         for (int row = 0; row < data.length; row++) {
             for (int col = 0; col < data[row].length; col++) {
                 matrix.setEntry(row, col, data[row][col]);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..3a607f4 100644
--- a/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java
+++ b/src/test/java/org/apache/commons/math4/linear/SparseFieldVectorTest.java
@@ -58,7 +58,7 @@ public class SparseFieldVectorTest {
 
     @Test
     public void testMapFunctions() throws FractionConversionException {
-        SparseFieldVector<Fraction> v1 = new SparseFieldVector<>(field,vec1);
+        SparseFieldVector<Fraction> v1 = new SparseFieldVector<Fraction>(field,vec1);
 
         //octave =  v1 .+ 2.0
         FieldVector<Fraction> v_mapAdd = v1.mapAdd(new Fraction(2));
@@ -120,17 +120,17 @@ public class SparseFieldVectorTest {
 
     @Test
     public void testBasicFunctions() throws FractionConversionException {
-        SparseFieldVector<Fraction> v1 = new SparseFieldVector<>(field,vec1);
-        SparseFieldVector<Fraction> v2 = new SparseFieldVector<>(field,vec2);
+        SparseFieldVector<Fraction> v1 = new SparseFieldVector<Fraction>(field,vec1);
+        SparseFieldVector<Fraction> v2 = new SparseFieldVector<Fraction>(field,vec2);
 
-        FieldVector<Fraction> v2_t = new ArrayFieldVectorTest.FieldVectorTestImpl<>(vec2);
+        FieldVector<Fraction> v2_t = new ArrayFieldVectorTest.FieldVectorTestImpl<Fraction>(vec2);
 
         //octave =  v1 + v2
         FieldVector<Fraction> v_add = v1.add(v2);
         Fraction[] result_add = {new Fraction(5), new Fraction(7), new Fraction(9)};
         Assert.assertArrayEquals("compare vect" ,v_add.toArray(),result_add);
 
-        FieldVector<Fraction> vt2 = new ArrayFieldVectorTest.FieldVectorTestImpl<>(vec2);
+        FieldVector<Fraction> vt2 = new ArrayFieldVectorTest.FieldVectorTestImpl<Fraction>(vec2);
         FieldVector<Fraction> v_add_i = v1.add(vt2);
         Fraction[] result_add_i = {new Fraction(5), new Fraction(7), new Fraction(9)};
         Assert.assertArrayEquals("compare vect" ,v_add_i.toArray(),result_add_i);
@@ -181,12 +181,12 @@ public class SparseFieldVectorTest {
     @Test
     public void testOuterProduct() {
         final SparseFieldVector<Fraction> u
-            = new SparseFieldVector<>(FractionField.getInstance(),
+            = new SparseFieldVector<Fraction>(FractionField.getInstance(),
                                               new Fraction[] {new Fraction(1),
                                                               new Fraction(2),
                                                               new Fraction(-3)});
         final SparseFieldVector<Fraction> v
-            = new SparseFieldVector<>(FractionField.getInstance(),
+            = new SparseFieldVector<Fraction>(FractionField.getInstance(),
                                               new Fraction[] {new Fraction(4),
                                                               new Fraction(-2)});
 
@@ -203,7 +203,7 @@ public class SparseFieldVectorTest {
 
     @Test
     public void testMisc() {
-        SparseFieldVector<Fraction> v1 = new SparseFieldVector<>(field,vec1);
+        SparseFieldVector<Fraction> v1 = new SparseFieldVector<Fraction>(field,vec1);
 
         String out1 = v1.toString();
         Assert.assertTrue("some output ",  out1.length()!=0);
@@ -220,11 +220,11 @@ public class SparseFieldVectorTest {
     @Test
     public void testPredicates() {
 
-        SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2) });
+        SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2) });
 
         v.setEntry(0, field.getZero());
-        Assert.assertEquals(v, new SparseFieldVector<>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2) }));
-        Assert.assertNotSame(v, new SparseFieldVector<>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2), new Fraction(3) }));
+        Assert.assertEquals(v, new SparseFieldVector<Fraction>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2) }));
+        Assert.assertNotSame(v, new SparseFieldVector<Fraction>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2), new Fraction(3) }));
 
     }
 
@@ -260,7 +260,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final FieldVectorPreservingVisitor<Fraction> visitor;
         visitor = new FieldVectorPreservingVisitor<Fraction>() {
 
@@ -347,7 +347,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final int expectedStart = 2;
         final int expectedEnd = 7;
         final FieldVectorPreservingVisitor<Fraction> visitor;
@@ -385,7 +385,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final FieldVectorPreservingVisitor<Fraction> visitor;
         visitor = new FieldVectorPreservingVisitor<Fraction>() {
             private final boolean[] visited = new boolean[data.length];
@@ -474,7 +474,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final int expectedStart = 2;
         final int expectedEnd = 7;
         final FieldVectorPreservingVisitor<Fraction> visitor;
@@ -514,7 +514,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final FieldVectorChangingVisitor<Fraction> visitor;
         visitor = new FieldVectorChangingVisitor<Fraction>() {
 
@@ -605,7 +605,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final int expectedStart = 2;
         final int expectedEnd = 7;
         final FieldVectorChangingVisitor<Fraction> visitor;
@@ -647,7 +647,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final FieldVectorChangingVisitor<Fraction> visitor;
         visitor = new FieldVectorChangingVisitor<Fraction>() {
             private final boolean[] visited = new boolean[data.length];
@@ -740,7 +740,7 @@ public class SparseFieldVectorTest {
             Fraction.ZERO, Fraction.TWO, Fraction.ZERO,
             Fraction.ZERO, Fraction.ZERO, new Fraction(3)
         };
-        final SparseFieldVector<Fraction> v = new SparseFieldVector<>(field, data);
+        final SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, data);
         final int expectedStart = 2;
         final int expectedEnd = 7;
         final FieldVectorChangingVisitor<Fraction> visitor;
@@ -781,6 +781,6 @@ public class SparseFieldVectorTest {
         for (int i = 0; i < n; ++i) {
             t[i] = Fraction.ZERO;
         }
-        return new SparseFieldVector<>(field, t);
+        return new SparseFieldVector<Fraction>(field, t);
     }
 }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/linear/UnmodifiableRealVectorAbstractTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/linear/UnmodifiableRealVectorAbstractTest.java b/src/test/java/org/apache/commons/math4/linear/UnmodifiableRealVectorAbstractTest.java
index 121789e..9930801 100644
--- a/src/test/java/org/apache/commons/math4/linear/UnmodifiableRealVectorAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/linear/UnmodifiableRealVectorAbstractTest.java
@@ -53,7 +53,7 @@ public abstract class UnmodifiableRealVectorAbstractTest {
      * The list of methods which are excluded from the general test
      * {@link #testAllButExcluded()}.
      */
-    protected static final Set<String> EXCLUDE = new HashSet<>();
+    protected static final Set<String> EXCLUDE = new HashSet<String>();
     /** The random number generator (always initialized with the same seed. */
     protected static final Random RANDOM;
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/clustering/DBSCANClustererTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/clustering/DBSCANClustererTest.java b/src/test/java/org/apache/commons/math4/ml/clustering/DBSCANClustererTest.java
index e3413a7..0820fbc 100644
--- a/src/test/java/org/apache/commons/math4/ml/clustering/DBSCANClustererTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/clustering/DBSCANClustererTest.java
@@ -99,7 +99,7 @@ public class DBSCANClustererTest {
         };
 
         final DBSCANClusterer<DoublePoint> transformer =
-                new DBSCANClusterer<>(2.0, 5);
+                new DBSCANClusterer<DoublePoint>(2.0, 5);
         final List<Cluster<DoublePoint>> clusters = transformer.cluster(Arrays.asList(points));
 
         final List<DoublePoint> clusterOne =
@@ -152,7 +152,7 @@ public class DBSCANClustererTest {
 
         };
 
-        final DBSCANClusterer<DoublePoint> clusterer = new DBSCANClusterer<>(3, 3);
+        final DBSCANClusterer<DoublePoint> clusterer = new DBSCANClusterer<DoublePoint>(3, 3);
         List<Cluster<DoublePoint>> clusters = clusterer.cluster(Arrays.asList(points));
 
         Assert.assertEquals(1, clusters.size());
@@ -164,13 +164,13 @@ public class DBSCANClustererTest {
 
     @Test
     public void testGetEps() {
-        final DBSCANClusterer<DoublePoint> transformer = new DBSCANClusterer<>(2.0, 5);
+        final DBSCANClusterer<DoublePoint> transformer = new DBSCANClusterer<DoublePoint>(2.0, 5);
         Assert.assertEquals(2.0, transformer.getEps(), 0.0);
     }
 
     @Test
     public void testGetMinPts() {
-        final DBSCANClusterer<DoublePoint> transformer = new DBSCANClusterer<>(2.0, 5);
+        final DBSCANClusterer<DoublePoint> transformer = new DBSCANClusterer<DoublePoint>(2.0, 5);
         Assert.assertEquals(5, transformer.getMinPts());
     }
 
@@ -186,7 +186,7 @@ public class DBSCANClustererTest {
 
     @Test(expected = NullArgumentException.class)
     public void testNullDataset() {
-        DBSCANClusterer<DoublePoint> clusterer = new DBSCANClusterer<>(2.0, 5);
+        DBSCANClusterer<DoublePoint> clusterer = new DBSCANClusterer<DoublePoint>(2.0, 5);
         clusterer.cluster(null);
     }
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/clustering/FuzzyKMeansClustererTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/clustering/FuzzyKMeansClustererTest.java b/src/test/java/org/apache/commons/math4/ml/clustering/FuzzyKMeansClustererTest.java
index dd5ca36..a46c01e 100644
--- a/src/test/java/org/apache/commons/math4/ml/clustering/FuzzyKMeansClustererTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/clustering/FuzzyKMeansClustererTest.java
@@ -43,7 +43,7 @@ public class FuzzyKMeansClustererTest {
 
     @Test
     public void testCluster() {
-        final List<DoublePoint> points = new ArrayList<>();
+        final List<DoublePoint> points = new ArrayList<DoublePoint>();
 
         // create 10 data points: [1], ... [10]
         for (int i = 1; i <= 10; i++) {
@@ -52,7 +52,7 @@ public class FuzzyKMeansClustererTest {
         }
 
         final FuzzyKMeansClusterer<DoublePoint> transformer =
-                new FuzzyKMeansClusterer<>(3, 2.0);
+                new FuzzyKMeansClusterer<DoublePoint>(3, 2.0);
         final List<CentroidCluster<DoublePoint>> clusters = transformer.cluster(points);
 
         // we expect 3 clusters:
@@ -90,7 +90,7 @@ public class FuzzyKMeansClustererTest {
 
     @Test(expected = NullArgumentException.class)
     public void testNullDataset() {
-        final FuzzyKMeansClusterer<DoublePoint> clusterer = new FuzzyKMeansClusterer<>(3, 2.0);
+        final FuzzyKMeansClusterer<DoublePoint> clusterer = new FuzzyKMeansClusterer<DoublePoint>(3, 2.0);
         clusterer.cluster(null);
     }
 
@@ -99,7 +99,7 @@ public class FuzzyKMeansClustererTest {
         final DistanceMeasure measure = new CanberraDistance();
         final RandomGenerator random = new JDKRandomGenerator();
         final FuzzyKMeansClusterer<DoublePoint> clusterer =
-                new FuzzyKMeansClusterer<>(3, 2.0, 100, measure, 1e-6, random);
+                new FuzzyKMeansClusterer<DoublePoint>(3, 2.0, 100, measure, 1e-6, random);
 
         Assert.assertEquals(3, clusterer.getK());
         Assert.assertEquals(2.0, clusterer.getFuzziness(), 1e-6);
@@ -111,11 +111,11 @@ public class FuzzyKMeansClustererTest {
 
     @Test
     public void testSingleCluster() {
-        final List<DoublePoint> points = new ArrayList<>();
+        final List<DoublePoint> points = new ArrayList<DoublePoint>();
         points.add(new DoublePoint(new double[] { 1, 1 }));
 
         final FuzzyKMeansClusterer<DoublePoint> transformer =
-                new FuzzyKMeansClusterer<>(1, 2.0);
+                new FuzzyKMeansClusterer<DoublePoint>(1, 2.0);
         final List<CentroidCluster<DoublePoint>> clusters = transformer.cluster(points);
 
         Assert.assertEquals(1, clusters.size());
@@ -123,14 +123,14 @@ public class FuzzyKMeansClustererTest {
 
     @Test
     public void testClusterCenterEqualsPoints() {
-        final List<DoublePoint> points = new ArrayList<>();
+        final List<DoublePoint> points = new ArrayList<DoublePoint>();
         points.add(new DoublePoint(new double[] { 1, 1 }));
         points.add(new DoublePoint(new double[] { 1.00001, 1.00001 }));
         points.add(new DoublePoint(new double[] { 2, 2 }));
         points.add(new DoublePoint(new double[] { 3, 3 }));
 
         final FuzzyKMeansClusterer<DoublePoint> transformer =
-                new FuzzyKMeansClusterer<>(3, 2.0);
+                new FuzzyKMeansClusterer<DoublePoint>(3, 2.0);
         final List<CentroidCluster<DoublePoint>> clusters = transformer.cluster(points);
 
         Assert.assertEquals(3, clusters.size());

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/clustering/KMeansPlusPlusClustererTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/clustering/KMeansPlusPlusClustererTest.java b/src/test/java/org/apache/commons/math4/ml/clustering/KMeansPlusPlusClustererTest.java
index 56f262d..39ef2c5 100644
--- a/src/test/java/org/apache/commons/math4/ml/clustering/KMeansPlusPlusClustererTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/clustering/KMeansPlusPlusClustererTest.java
@@ -52,7 +52,7 @@ public class KMeansPlusPlusClustererTest {
     @Test
     public void testPerformClusterAnalysisDegenerate() {
         KMeansPlusPlusClusterer<DoublePoint> transformer =
-                new KMeansPlusPlusClusterer<>(1, 1);
+                new KMeansPlusPlusClusterer<DoublePoint>(1, 1);
 
         DoublePoint[] points = new DoublePoint[] {
                 new DoublePoint(new int[] { 1959, 325100 }),
@@ -102,7 +102,7 @@ public class KMeansPlusPlusClustererTest {
 
             for (int n = 2; n < 27; ++n) {
                 KMeansPlusPlusClusterer<DoublePoint> transformer =
-                    new KMeansPlusPlusClusterer<>(n, 100, new EuclideanDistance(), random, strategy);
+                    new KMeansPlusPlusClusterer<DoublePoint>(n, 100, new EuclideanDistance(), random, strategy);
 
                 List<? extends Cluster<DoublePoint>> clusters =
                         transformer.cluster(Arrays.asList(breakingPoints));
@@ -143,7 +143,7 @@ public class KMeansPlusPlusClustererTest {
         DoublePoint repeatedPoint = new DoublePoint(repeatedArray);
         DoublePoint uniquePoint = new DoublePoint(uniqueArray);
 
-        Collection<DoublePoint> points = new ArrayList<>();
+        Collection<DoublePoint> points = new ArrayList<DoublePoint>();
         final int NUM_REPEATED_POINTS = 10 * 1000;
         for (int i = 0; i < NUM_REPEATED_POINTS; ++i) {
             points.add(repeatedPoint);
@@ -158,7 +158,7 @@ public class KMeansPlusPlusClustererTest {
         random.setSeed(RANDOM_SEED);
 
         KMeansPlusPlusClusterer<DoublePoint> clusterer =
-            new KMeansPlusPlusClusterer<>(NUM_CLUSTERS, NUM_ITERATIONS,
+            new KMeansPlusPlusClusterer<DoublePoint>(NUM_CLUSTERS, NUM_ITERATIONS,
                     new CloseDistance(), random);
         List<CentroidCluster<DoublePoint>> clusters = clusterer.cluster(points);
 
@@ -178,7 +178,7 @@ public class KMeansPlusPlusClustererTest {
     @Test(expected=NumberIsTooSmallException.class)
     public void testPerformClusterAnalysisToManyClusters() {
         KMeansPlusPlusClusterer<DoublePoint> transformer =
-            new KMeansPlusPlusClusterer<>(3, 1, new EuclideanDistance(), random);
+            new KMeansPlusPlusClusterer<DoublePoint>(3, 1, new EuclideanDistance(), random);
 
         DoublePoint[] points = new DoublePoint[] {
             new DoublePoint(new int[] {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/clustering/MultiKMeansPlusPlusClustererTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/clustering/MultiKMeansPlusPlusClustererTest.java b/src/test/java/org/apache/commons/math4/ml/clustering/MultiKMeansPlusPlusClustererTest.java
index 12816d7..d707112 100644
--- a/src/test/java/org/apache/commons/math4/ml/clustering/MultiKMeansPlusPlusClustererTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/clustering/MultiKMeansPlusPlusClustererTest.java
@@ -34,7 +34,7 @@ public class MultiKMeansPlusPlusClustererTest {
     @Test
     public void dimension2() {
         MultiKMeansPlusPlusClusterer<DoublePoint> transformer =
-            new MultiKMeansPlusPlusClusterer<>(
+            new MultiKMeansPlusPlusClusterer<DoublePoint>(
                     new KMeansPlusPlusClusterer<DoublePoint>(3, 10), 5);
 
         DoublePoint[] points = new DoublePoint[] {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/clustering/evaluation/SumOfClusterVariancesTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/clustering/evaluation/SumOfClusterVariancesTest.java b/src/test/java/org/apache/commons/math4/ml/clustering/evaluation/SumOfClusterVariancesTest.java
index 37c59a6..0b20f8b 100644
--- a/src/test/java/org/apache/commons/math4/ml/clustering/evaluation/SumOfClusterVariancesTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/clustering/evaluation/SumOfClusterVariancesTest.java
@@ -38,7 +38,7 @@ public class SumOfClusterVariancesTest {
 
     @Before
     public void setUp() {
-        evaluator = new SumOfClusterVariances<>(new EuclideanDistance());
+        evaluator = new SumOfClusterVariances<DoublePoint>(new EuclideanDistance());
     }
 
     @Test
@@ -55,9 +55,9 @@ public class SumOfClusterVariancesTest {
                 new DoublePoint(new double[] { 10 })
         };
 
-        final List<Cluster<DoublePoint>> clusters = new ArrayList<>();
+        final List<Cluster<DoublePoint>> clusters = new ArrayList<Cluster<DoublePoint>>();
 
-        final Cluster<DoublePoint> cluster1 = new Cluster<>();
+        final Cluster<DoublePoint> cluster1 = new Cluster<DoublePoint>();
         for (DoublePoint p : points1) {
             cluster1.addPoint(p);
         }
@@ -65,7 +65,7 @@ public class SumOfClusterVariancesTest {
 
         assertEquals(1.0/3.0, evaluator.score(clusters), 1e-6);
 
-        final Cluster<DoublePoint> cluster2 = new Cluster<>();
+        final Cluster<DoublePoint> cluster2 = new Cluster<DoublePoint>();
         for (DoublePoint p : points2) {
             cluster2.addPoint(p);
         }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/neuralnet/MapUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/neuralnet/MapUtilsTest.java b/src/test/java/org/apache/commons/math4/ml/neuralnet/MapUtilsTest.java
index 4404aac..f716fc8 100644
--- a/src/test/java/org/apache/commons/math4/ml/neuralnet/MapUtilsTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/neuralnet/MapUtilsTest.java
@@ -49,8 +49,8 @@ public class MapUtilsTest {
         final Network net = new NeuronString(3, false, initArray).getNetwork();
         final DistanceMeasure dist = new EuclideanDistance();
 
-        final Set<Neuron> allBest = new HashSet<>();
-        final Set<Neuron> best = new HashSet<>();
+        final Set<Neuron> allBest = new HashSet<Neuron>();
+        final Set<Neuron> best = new HashSet<Neuron>();
         double[][] features;
 
         // The following tests ensures that
@@ -97,7 +97,7 @@ public class MapUtilsTest {
 
     @Test
     public void testSort() {
-        final Set<Neuron> list = new HashSet<>();
+        final Set<Neuron> list = new HashSet<Neuron>();
 
         for (int i = 0; i < 4; i++) {
             list.add(new Neuron(i, new double[] { i - 0.5 }));

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/neuralnet/oned/NeuronStringTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/neuralnet/oned/NeuronStringTest.java b/src/test/java/org/apache/commons/math4/ml/neuralnet/oned/NeuronStringTest.java
index 5871956..e7654fd 100644
--- a/src/test/java/org/apache/commons/math4/ml/neuralnet/oned/NeuronStringTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/neuralnet/oned/NeuronStringTest.java
@@ -139,7 +139,7 @@ public class NeuronStringTest {
     public void testGetNeighboursWithExclude() {
         final FeatureInitializer[] initArray = { init };
         final Network net = new NeuronString(5, true, initArray).getNetwork();
-        final Collection<Neuron> exclude = new ArrayList<>();
+        final Collection<Neuron> exclude = new ArrayList<Neuron>();
         exclude.add(net.getNeuron(1));
         final Collection<Neuron> neighbours = net.getNeighbours(net.getNeuron(0),
                                                                 exclude);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/KohonenTrainingTaskTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/KohonenTrainingTaskTest.java b/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/KohonenTrainingTaskTest.java
index 373a5bd..dd669d5 100644
--- a/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/KohonenTrainingTaskTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/neuralnet/sofm/KohonenTrainingTaskTest.java
@@ -112,7 +112,7 @@ public class KohonenTrainingTaskTest {
         final ExecutorService service = Executors.newCachedThreadPool();
         final int numProcs = Runtime.getRuntime().availableProcessors();
         final Runnable[] tasks = solver.createParallelTasks(numProcs, 5000);
-        final List<Future<?>> execOutput = new ArrayList<>();
+        final List<Future<?>> execOutput = new ArrayList<Future<?>>();
         // Run tasks.
         for (Runnable r : tasks) {
             execOutput.add(service.submit(r));
@@ -165,7 +165,7 @@ public class KohonenTrainingTaskTest {
      * @return the total distance.
      */
     private Collection<City> uniqueCities(City[] cityList) {
-        final Set<City> unique = new HashSet<>();
+        final Set<City> unique = new HashSet<City>();
         for (City c : cityList) {
             unique.add(c);
         }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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 37a9b2d..fea0f16 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
@@ -58,7 +58,7 @@ public class TravellingSalesmanSolver {
     /** RNG. */
     private final RandomGenerator random;
     /** Set of cities. */
-    private final Set<City> cities = new HashSet<>();
+    private final Set<City> cities = new HashSet<City>();
     /** SOFM. */
     private final Network net;
     /** Distance function. */
@@ -176,7 +176,7 @@ public class TravellingSalesmanSolver {
      * @return the iterator.
      */
     private Iterator<double[]> createRandomIterator(final long numSamples) {
-        final List<City> cityList = new ArrayList<>();
+        final List<City> cityList = new ArrayList<City>();
         cityList.addAll(cities);
 
         return new Iterator<double[]>() {
@@ -204,7 +204,7 @@ public class TravellingSalesmanSolver {
      */
     private List<Neuron> getNeuronList() {
         // Sequence of coordinates.
-        final List<Neuron> list = new ArrayList<>();
+        final List<Neuron> list = new ArrayList<Neuron>();
 
         // First neuron.
         Neuron current = net.getNeuron(FIRST_NEURON_ID);
@@ -230,7 +230,7 @@ public class TravellingSalesmanSolver {
      */
     public List<double[]> getCoordinatesList() {
         // Sequence of coordinates.
-        final List<double[]> coordinatesList = new ArrayList<>();
+        final List<double[]> coordinatesList = new ArrayList<double[]>();
 
         for (Neuron n : getNeuronList()) {
             coordinatesList.add(n.getFeatures());

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/src/test/java/org/apache/commons/math4/ml/neuralnet/twod/NeuronSquareMesh2DTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/ml/neuralnet/twod/NeuronSquareMesh2DTest.java b/src/test/java/org/apache/commons/math4/ml/neuralnet/twod/NeuronSquareMesh2DTest.java
index 8337175..d233b24 100644
--- a/src/test/java/org/apache/commons/math4/ml/neuralnet/twod/NeuronSquareMesh2DTest.java
+++ b/src/test/java/org/apache/commons/math4/ml/neuralnet/twod/NeuronSquareMesh2DTest.java
@@ -574,7 +574,7 @@ public class NeuronSquareMesh2DTest {
                                              initArray).getNetwork();
 
         Collection<Neuron> neighbours;
-        Collection<Neuron> exclude = new HashSet<>();
+        Collection<Neuron> exclude = new HashSet<Neuron>();
 
         // Level-1 neighbourhood.
         neighbours = net.getNeighbours(net.getNeuron(12));
@@ -623,7 +623,7 @@ public class NeuronSquareMesh2DTest {
                                                    initArray).getNetwork();
 
         Collection<Neuron> neighbours;
-        Collection<Neuron> exclude = new HashSet<>();
+        Collection<Neuron> exclude = new HashSet<Neuron>();
 
         // Level-1 neighbourhood.
         neighbours = net.getNeighbours(net.getNeuron(8));
@@ -854,13 +854,13 @@ public class NeuronSquareMesh2DTest {
                                                               3, true,
                                                               SquareNeighbourhood.VON_NEUMANN,
                                                               initArray);
-        final Set<Neuron> fromMap = new HashSet<>();
+        final Set<Neuron> fromMap = new HashSet<Neuron>();
         for (Neuron n : map) {
             fromMap.add(n);
         }
 
         final Network net = map.getNetwork();
-        final Set<Neuron> fromNet = new HashSet<>();
+        final Set<Neuron> fromNet = new HashSet<Neuron>();
         for (Neuron n : net) {
             fromNet.add(n);
         }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..870ee1e 100644
--- a/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java
+++ b/src/test/java/org/apache/commons/math4/ode/ContinuousOutputFieldModelTest.java
@@ -42,12 +42,12 @@ public class ContinuousOutputFieldModelTest {
     }
 
     private <T extends RealFieldElement<T>> void doTestBoundaries(final Field<T> field) {
-        TestFieldProblem3<T> pb = new TestFieldProblem3<>(field, field.getZero().add(0.9));
+        TestFieldProblem3<T> pb = new TestFieldProblem3<T>(field, field.getZero().add(0.9));
         double minStep = 0;
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
-        FirstOrderFieldIntegrator<T> integ = new DormandPrince54FieldIntegrator<>(field, minStep, maxStep, 1.0e-8, 1.0e-8);
+        FirstOrderFieldIntegrator<T> integ = new DormandPrince54FieldIntegrator<T>(field, minStep, maxStep, 1.0e-8, 1.0e-8);
         integ.addStepHandler(new ContinuousOutputFieldModel<T>());
-        integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+        integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
         ContinuousOutputFieldModel<T> cm = (ContinuousOutputFieldModel<T>) integ.getStepHandlers().iterator().next();
         cm.getInterpolatedState(pb.getInitialState().getTime().multiply(2).subtract(pb.getFinalTime()));
         cm.getInterpolatedState(pb.getFinalTime().multiply(2).subtract(pb.getInitialState().getTime()));
@@ -61,13 +61,13 @@ public class ContinuousOutputFieldModelTest {
 
     private <T extends RealFieldElement<T>> void doTestRandomAccess(final Field<T> field)  {
 
-        TestFieldProblem3<T> pb = new TestFieldProblem3<>(field, field.getZero().add(0.9));
+        TestFieldProblem3<T> pb = new TestFieldProblem3<T>(field, field.getZero().add(0.9));
         double minStep = 0;
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
-        FirstOrderFieldIntegrator<T> integ = new DormandPrince54FieldIntegrator<>(field, minStep, maxStep, 1.0e-8, 1.0e-8);
-        ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<>();
+        FirstOrderFieldIntegrator<T> integ = new DormandPrince54FieldIntegrator<T>(field, minStep, maxStep, 1.0e-8, 1.0e-8);
+        ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<T>();
         integ.addStepHandler(cm);
-        integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+        integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
 
         Random random = new Random(347588535632l);
         T maxError    = field.getZero();
@@ -117,32 +117,32 @@ public class ContinuousOutputFieldModelTest {
         };
 
         // integrate backward from &pi; to 0;
-        ContinuousOutputFieldModel<T> cm1 = new ContinuousOutputFieldModel<>();
+        ContinuousOutputFieldModel<T> cm1 = new ContinuousOutputFieldModel<T>();
         FirstOrderFieldIntegrator<T> integ1 =
-                        new DormandPrince853FieldIntegrator<>(field, 0, 1.0, 1.0e-8, 1.0e-8);
+                        new DormandPrince853FieldIntegrator<T>(field, 0, 1.0, 1.0e-8, 1.0e-8);
         integ1.addStepHandler(cm1);
         T t0 = field.getZero().add(FastMath.PI);
         T[] y0 = MathArrays.buildArray(field, 2);
         y0[0] = field.getOne().negate();
         y0[1] = field.getZero();
-        integ1.integrate(new FieldExpandableODE<>(problem),
-                         new FieldODEState<>(t0, y0),
+        integ1.integrate(new FieldExpandableODE<T>(problem),
+                         new FieldODEState<T>(t0, y0),
                          field.getZero());
 
         // integrate backward from 2&pi; to &pi;
-        ContinuousOutputFieldModel<T> cm2 = new ContinuousOutputFieldModel<>();
+        ContinuousOutputFieldModel<T> cm2 = new ContinuousOutputFieldModel<T>();
         FirstOrderFieldIntegrator<T> integ2 =
-                        new DormandPrince853FieldIntegrator<>(field, 0, 0.1, 1.0e-12, 1.0e-12);
+                        new DormandPrince853FieldIntegrator<T>(field, 0, 0.1, 1.0e-12, 1.0e-12);
         integ2.addStepHandler(cm2);
         t0 = field.getZero().add(2.0 * FastMath.PI);
         y0[0] = field.getOne();
         y0[1] = field.getZero();
-        integ2.integrate(new FieldExpandableODE<>(problem),
-                         new FieldODEState<>(t0, y0),
+        integ2.integrate(new FieldExpandableODE<T>(problem),
+                         new FieldODEState<T>(t0, y0),
                          field.getZero().add(FastMath.PI));
 
         // merge the two half circles
-        ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<>();
+        ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<T>();
         cm.append(cm2);
         cm.append(new ContinuousOutputFieldModel<T>());
         cm.append(cm1);
@@ -164,7 +164,7 @@ public class ContinuousOutputFieldModelTest {
     }
 
     private <T extends RealFieldElement<T>> void doTestErrorConditions(final Field<T> field) {
-        ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<>();
+        ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<T>();
         cm.handleStep(buildInterpolator(field, 0, 1, new double[] { 0.0, 1.0, -2.0 }), true);
 
         // dimension mismatch
@@ -184,7 +184,7 @@ public class ContinuousOutputFieldModelTest {
     private <T extends RealFieldElement<T>> boolean checkAppendError(Field<T> field, ContinuousOutputFieldModel<T> cm,
                                                                      double t0, double t1, double[] y) {
         try {
-            ContinuousOutputFieldModel<T> otherCm = new ContinuousOutputFieldModel<>();
+            ContinuousOutputFieldModel<T> otherCm = new ContinuousOutputFieldModel<T>();
             otherCm.handleStep(buildInterpolator(field, t0, t1, y), true);
             cm.append(otherCm);
         } catch(DimensionMismatchException dme) {
@@ -201,9 +201,9 @@ public class ContinuousOutputFieldModelTest {
         for (int i = 0; i < y.length; ++i) {
             fieldY[i] = field.getZero().add(y[i]);
         }
-        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>() {
+        final FieldODEStateAndDerivative<T> s0 = new FieldODEStateAndDerivative<T>(field.getZero().add(t0), fieldY, fieldY);
+        final FieldODEStateAndDerivative<T> s1 = new FieldODEStateAndDerivative<T>(field.getZero().add(t1), fieldY, fieldY);
+        final FieldEquationsMapper<T> mapper   = new FieldExpandableODE<T>(new FirstOrderFieldDifferentialEquations<T>() {
             public int getDimension() {
                 return s0.getStateDimension();
             }
@@ -213,7 +213,7 @@ public class ContinuousOutputFieldModelTest {
                 return y;
             }
         }).getMapper();
-        return new DummyFieldStepInterpolator<>(t1 >= t0, s0, s1, s0, s1, mapper);
+        return new DummyFieldStepInterpolator<T>(t1 >= t0, s0, s1, s0, s1, mapper);
     }
 
     public void checkValue(double value, double reference) {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..79070d0 100644
--- a/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java
+++ b/src/test/java/org/apache/commons/math4/ode/FieldExpandableODETest.java
@@ -39,8 +39,8 @@ public class FieldExpandableODETest {
     }
 
     private <T extends RealFieldElement<T>> void doTestOnlyMainEquation(final Field<T> field) {
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
         Assert.assertEquals(main.getDimension(), equation.getMapper().getTotalDimension());
         Assert.assertEquals(1, equation.getMapper().getNumberOfEquations());
         T t0 = field.getZero().add(10);
@@ -70,11 +70,11 @@ public class FieldExpandableODETest {
 
     private <T extends RealFieldElement<T>> void doTestMainAndSecondary(final Field<T> field) {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
-        FieldSecondaryEquations<T> secondary1 = new Linear<>(field, 3, main.getDimension());
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
+        FieldSecondaryEquations<T> secondary1 = new Linear<T>(field, 3, main.getDimension());
         int i1 = equation.addSecondaryEquations(secondary1);
-        FieldSecondaryEquations<T> secondary2 = new Linear<>(field, 5, main.getDimension() + secondary1.getDimension());
+        FieldSecondaryEquations<T> secondary2 = new Linear<T>(field, 5, main.getDimension() + secondary1.getDimension());
         int i2 = equation.addSecondaryEquations(secondary2);
         Assert.assertEquals(main.getDimension() + secondary1.getDimension() + secondary2.getDimension(),
                             equation.getMapper().getTotalDimension());
@@ -127,11 +127,11 @@ public class FieldExpandableODETest {
 
     private <T extends RealFieldElement<T>> void doTestMap(final Field<T> field) {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
-        FieldSecondaryEquations<T> secondary1 = new Linear<>(field, 3, main.getDimension());
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
+        FieldSecondaryEquations<T> secondary1 = new Linear<T>(field, 3, main.getDimension());
         int i1 = equation.addSecondaryEquations(secondary1);
-        FieldSecondaryEquations<T> secondary2 = new Linear<>(field, 5, main.getDimension() + secondary1.getDimension());
+        FieldSecondaryEquations<T> secondary2 = new Linear<T>(field, 5, main.getDimension() + secondary1.getDimension());
         int i2 = equation.addSecondaryEquations(secondary2);
         Assert.assertEquals(main.getDimension() + secondary1.getDimension() + secondary2.getDimension(),
                             equation.getMapper().getTotalDimension());
@@ -215,9 +215,9 @@ public class FieldExpandableODETest {
     private <T extends RealFieldElement<T>> void doTestExtractDimensionMismatch(final Field<T> field)
         throws DimensionMismatchException {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
-        FieldSecondaryEquations<T> secondary1 = new Linear<>(field, 3, main.getDimension());
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
+        FieldSecondaryEquations<T> secondary1 = new Linear<T>(field, 3, main.getDimension());
         int i1 = equation.addSecondaryEquations(secondary1);
         T[] tooShort    = MathArrays.buildArray(field, main.getDimension());
         equation.getMapper().extractEquationData(i1, tooShort);
@@ -231,9 +231,9 @@ public class FieldExpandableODETest {
     private <T extends RealFieldElement<T>> void doTestInsertTooShortComplete(final Field<T> field)
         throws DimensionMismatchException {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
-        FieldSecondaryEquations<T> secondary1 = new Linear<>(field, 3, main.getDimension());
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
+        FieldSecondaryEquations<T> secondary1 = new Linear<T>(field, 3, main.getDimension());
         int i1 = equation.addSecondaryEquations(secondary1);
         T[] equationData = MathArrays.buildArray(field, secondary1.getDimension());
         T[] tooShort     = MathArrays.buildArray(field, main.getDimension());
@@ -248,9 +248,9 @@ public class FieldExpandableODETest {
     private <T extends RealFieldElement<T>> void doTestInsertWrongEquationData(final Field<T> field)
         throws DimensionMismatchException {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
-        FieldSecondaryEquations<T> secondary1 = new Linear<>(field, 3, main.getDimension());
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
+        FieldSecondaryEquations<T> secondary1 = new Linear<T>(field, 3, main.getDimension());
         int i1 = equation.addSecondaryEquations(secondary1);
         T[] wrongEquationData = MathArrays.buildArray(field, secondary1.getDimension() + 1);
         T[] complete          = MathArrays.buildArray(field, equation.getMapper().getTotalDimension());
@@ -265,8 +265,8 @@ public class FieldExpandableODETest {
     private <T extends RealFieldElement<T>> void doTestNegativeIndex(final Field<T> field)
         throws MathIllegalArgumentException {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
         T[] complete = MathArrays.buildArray(field, equation.getMapper().getTotalDimension());
         equation.getMapper().extractEquationData(-1, complete);
     }
@@ -279,8 +279,8 @@ public class FieldExpandableODETest {
     private <T extends RealFieldElement<T>> void doTestTooLargeIndex(final Field<T> field)
         throws MathIllegalArgumentException {
 
-        FirstOrderFieldDifferentialEquations<T> main = new Linear<>(field, 3, 0);
-        FieldExpandableODE<T> equation = new FieldExpandableODE<>(main);
+        FirstOrderFieldDifferentialEquations<T> main = new Linear<T>(field, 3, 0);
+        FieldExpandableODE<T> equation = new FieldExpandableODE<T>(main);
         T[] complete = MathArrays.buildArray(field, equation.getMapper().getTotalDimension());
         equation.getMapper().extractEquationData(+1, complete);
     }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..cc79777 100644
--- a/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java
+++ b/src/test/java/org/apache/commons/math4/ode/TestFieldProblem4.java
@@ -67,8 +67,8 @@ public class TestFieldProblem4<T extends RealFieldElement<T>>
         @SuppressWarnings("unchecked")
         FieldEventHandler<T>[] handlers =
                         (FieldEventHandler<T>[]) Array.newInstance(FieldEventHandler.class, 2);
-        handlers[0] = new Bounce<>();
-        handlers[1] = new Stop<>();
+        handlers[0] = new Bounce<T>();
+        handlers[1] = new Stop<T>();
         return handlers;
     }
 
@@ -130,7 +130,7 @@ public class TestFieldProblem4<T extends RealFieldElement<T>>
             T[] y = state.getState();
             y[0] = y[0].negate();
             y[1] = y[1].negate();
-            return new FieldODEState<>(state.getTime(), y);
+            return new FieldODEState<T>(state.getTime(), y);
         }
 
     }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..9d1b78b 100644
--- a/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java
+++ b/src/test/java/org/apache/commons/math4/ode/TestFieldProblemAbstract.java
@@ -114,7 +114,7 @@ public abstract class TestFieldProblemAbstract<T extends RealFieldElement<T>>
      * @return initial state
      */
     public FieldODEState<T> getInitialState() {
-        return new FieldODEState<>(t0, y0);
+        return new FieldODEState<T>(t0, y0);
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..e489e4e 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
@@ -90,8 +90,8 @@ public class OverlappingEventsTest implements FirstOrderDifferentialEquations {
         double t = 0.0;
         double tEnd = 10.0;
         double[] y = {0.0, 0.0};
-        List<Double> events1 = new ArrayList<>();
-        List<Double> events2 = new ArrayList<>();
+        List<Double> events1 = new ArrayList<Double>();
+        List<Double> events2 = new ArrayList<Double>();
         while (t < tEnd) {
             t = integrator.integrate(this, t, y, tEnd, y);
             //System.out.println("t=" + t + ",\t\ty=[" + y[0] + "," + y[1] + "]");

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6df150da/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..61372f5 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
@@ -152,8 +152,8 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
         EmbeddedRungeKuttaFieldIntegrator<T> integrator = createIntegrator(field, 0.0, 1.0, 1.0e-10, 1.0e-10);
 
         try  {
-            integrator.integrate(new FieldExpandableODE<>(equations),
-                                 new FieldODEState<>(field.getOne().negate(),
+            integrator.integrate(new FieldExpandableODE<T>(equations),
+                                 new FieldODEState<T>(field.getOne().negate(),
                                                       MathArrays.buildArray(field, 1)),
                                  field.getZero());
             Assert.fail("an exception should have been thrown");
@@ -162,8 +162,8 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
           }
 
           try  {
-              integrator.integrate(new FieldExpandableODE<>(equations),
-                                   new FieldODEState<>(field.getZero(),
+              integrator.integrate(new FieldExpandableODE<T>(equations),
+                                   new FieldODEState<T>(field.getZero(),
                                                         MathArrays.buildArray(field, 1)),
                                    field.getOne());
                Assert.fail("an exception should have been thrown");
@@ -182,7 +182,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
     protected <T extends RealFieldElement<T>> void doTestMinStep(final Field<T> field)
         throws NumberIsTooSmallException {
 
-        TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
+        TestFieldProblem1<T> pb = new TestFieldProblem1<T>(field);
         double minStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).multiply(0.1).getReal();
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
         double[] vecAbsoluteTolerance = { 1.0e-15, 1.0e-16 };
@@ -190,9 +190,9 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
         FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                               vecAbsoluteTolerance, vecRelativeTolerance);
-        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
+        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<T>(pb, integ);
         integ.addStepHandler(handler);
-        integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+        integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
         Assert.fail("an exception should have been thrown");
 
     }
@@ -206,7 +206,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
         int previousCalls = Integer.MAX_VALUE;
         for (int i = -12; i < -2; ++i) {
-            TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
+            TestFieldProblem1<T> pb = new TestFieldProblem1<T>(field);
             double minStep = 0;
             double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
             double scalAbsoluteTolerance = FastMath.pow(10.0, i);
@@ -214,9 +214,9 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
             FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                                   scalAbsoluteTolerance, scalRelativeTolerance);
-            TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
+            TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<T>(pb, integ);
             integ.addStepHandler(handler);
-            integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+            integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
 
             Assert.assertTrue(handler.getMaximalValueError().getReal() < (factor * scalAbsoluteTolerance));
             Assert.assertEquals(0, handler.getMaximalTimeError().getReal(), epsilon);
@@ -237,7 +237,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
                                                                 final double epsilonMaxValue,
                                                                 final String name) {
 
-      TestFieldProblem4<T> pb = new TestFieldProblem4<>(field);
+      TestFieldProblem4<T> pb = new TestFieldProblem4<T>(field);
       double minStep = 0;
       double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
       double scalAbsoluteTolerance = 1.0e-8;
@@ -245,7 +245,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
       FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                             scalAbsoluteTolerance, scalRelativeTolerance);
-      TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
+      TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<T>(pb, integ);
       integ.addStepHandler(handler);
       FieldEventHandler<T>[] functions = pb.getEventsHandlers();
       double convergence = 1.0e-8 * maxStep;
@@ -253,7 +253,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
           integ.addEventHandler(functions[l], Double.POSITIVE_INFINITY, convergence, 1000);
       }
       Assert.assertEquals(functions.length, integ.getEventHandlers().size());
-      integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+      integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
 
       Assert.assertEquals(0, handler.getMaximalValueError().getReal(), epsilonMaxValue);
       Assert.assertEquals(0, handler.getMaximalTimeError().getReal(), convergence);
@@ -269,7 +269,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
     protected <T extends RealFieldElement<T>> void doTestEventsErrors(final Field<T> field)
         throws LocalException {
-        final TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
+        final TestFieldProblem1<T> pb = new TestFieldProblem1<T>(field);
         double minStep = 0;
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
         double scalAbsoluteTolerance = 1.0e-8;
@@ -277,7 +277,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
         FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                               scalAbsoluteTolerance, scalRelativeTolerance);
-        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
+        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<T>(pb, integ);
         integ.addStepHandler(handler);
 
         integ.addEventHandler(new FieldEventHandler<T>() {
@@ -299,7 +299,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
           }
         }, Double.POSITIVE_INFINITY, 1.0e-8 * maxStep, 1000);
 
-        integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+        integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
 
     }
 
@@ -308,7 +308,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
     protected <T extends RealFieldElement<T>> void doTestEventsNoConvergence(final Field<T> field){
 
-        final TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
+        final TestFieldProblem1<T> pb = new TestFieldProblem1<T>(field);
         double minStep = 0;
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
         double scalAbsoluteTolerance = 1.0e-8;
@@ -316,7 +316,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
         FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                               scalAbsoluteTolerance, scalRelativeTolerance);
-        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
+        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<T>(pb, integ);
         integ.addStepHandler(handler);
 
         integ.addEventHandler(new FieldEventHandler<T>() {
@@ -336,7 +336,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
         }, Double.POSITIVE_INFINITY, 1.0e-8 * maxStep, 3);
 
         try {
-            integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+            integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
             Assert.fail("an exception should have been thrown");
         } catch (MaxCountExceededException mcee) {
             // Expected.
@@ -348,13 +348,13 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
     public abstract void testSanityChecks();
 
     protected <T extends RealFieldElement<T>> void doTestSanityChecks(Field<T> field) {
-        TestFieldProblem3<T> pb = new TestFieldProblem3<>(field);
+        TestFieldProblem3<T> pb = new TestFieldProblem3<T>(field);
         try  {
             EmbeddedRungeKuttaFieldIntegrator<T> integrator = createIntegrator(field, 0,
                                                                                pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal(),
                                                                                new double[4], new double[4]);
-            integrator.integrate(new FieldExpandableODE<>(pb),
-                                 new FieldODEState<>(pb.getInitialState().getTime(),
+            integrator.integrate(new FieldExpandableODE<T>(pb),
+                                 new FieldODEState<T>(pb.getInitialState().getTime(),
                                                       MathArrays.buildArray(field, 6)),
                                  pb.getFinalTime());
             Assert.fail("an exception should have been thrown");
@@ -365,7 +365,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
                             createIntegrator(field, 0,
                                              pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal(),
                                              new double[2], new double[4]);
-            integrator.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+            integrator.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
             Assert.fail("an exception should have been thrown");
         } catch(DimensionMismatchException ie) {
         }
@@ -374,7 +374,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
                             createIntegrator(field, 0,
                                              pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal(),
                                              new double[4], new double[4]);
-            integrator.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getInitialState().getTime());
+            integrator.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getInitialState().getTime());
             Assert.fail("an exception should have been thrown");
         } catch(NumberIsTooSmallException ie) {
         }
@@ -391,7 +391,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
         throws DimensionMismatchException, NumberIsTooSmallException,
                MaxCountExceededException, NoBracketingException {
 
-        TestFieldProblem5<T> pb = new TestFieldProblem5<>(field);
+        TestFieldProblem5<T> pb = new TestFieldProblem5<T>(field);
         double minStep = 0;
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).abs().getReal();
         double scalAbsoluteTolerance = 1.0e-8;
@@ -400,9 +400,9 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
         EmbeddedRungeKuttaFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                                       scalAbsoluteTolerance,
                                                                       scalRelativeTolerance);
-        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
+        TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<T>(pb, integ);
         integ.addStepHandler(handler);
-        integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+        integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
 
         Assert.assertEquals(0, handler.getLastError().getReal(),         epsilonLast);
         Assert.assertEquals(0, handler.getMaximalValueError().getReal(), epsilonMaxValue);
@@ -416,7 +416,7 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
     protected <T extends RealFieldElement<T>> void doTestKepler(Field<T> field, double epsilon) {
 
-        final TestFieldProblem3<T> pb  = new TestFieldProblem3<>(field, field.getZero().add(0.9));
+        final TestFieldProblem3<T> pb  = new TestFieldProblem3<T>(field, field.getZero().add(0.9));
         double minStep = 0;
         double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
         double[] vecAbsoluteTolerance = { 1.0e-8, 1.0e-8, 1.0e-10, 1.0e-10 };
@@ -424,8 +424,8 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
 
         FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
                                                               vecAbsoluteTolerance, vecRelativeTolerance);
-        integ.addStepHandler(new KeplerHandler<>(pb, epsilon));
-        integ.integrate(new FieldExpandableODE<>(pb), pb.getInitialState(), pb.getFinalTime());
+        integ.addStepHandler(new KeplerHandler<T>(pb, epsilon));
+        integ.integrate(new FieldExpandableODE<T>(pb), pb.getInitialState(), pb.getFinalTime());
     }
 
     private static class KeplerHandler<T extends RealFieldElement<T>> implements FieldStepHandler<T> {
@@ -486,8 +486,8 @@ public abstract class AbstractEmbeddedRungeKuttaFieldIntegratorTest {
                                          t.subtract(t0).multiply(0.001).getReal(), t.subtract(t0).getReal(),
                                          1.0e-12, 1.0e-12);
         FieldODEStateAndDerivative<DerivativeStructure> result =
-                        integrator.integrate(new FieldExpandableODE<>(sinCos),
-                                             new FieldODEState<>(t0, y0),
+                        integrator.integrate(new FieldExpandableODE<DerivativeStructure>(sinCos),
+                                             new FieldODEState<DerivativeStructure>(t0, y0),
                                              t);
 
         // check values


Mime
View raw message