commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From s...@apache.org
Subject svn commit: r1197463 - in /commons/proper/math/trunk/src/test/java/org/apache/commons/math: ./ analysis/solvers/ linear/ random/ util/
Date Fri, 04 Nov 2011 09:48:28 GMT
Author: sebb
Date: Fri Nov  4 09:48:27 2011
New Revision: 1197463

URL: http://svn.apache.org/viewvc?rev=1197463&view=rev
Log:
Missing @Override

Modified:
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/RetryRunner.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BracketingNthOrderBrentSolverTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/IllinoisSolverTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/PegasusSolverTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolverTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/SecantSolverTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/RealVectorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealVectorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/AbstractRandomGeneratorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/BitsStreamGeneratorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/FastMathTestPerformance.java

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/RetryRunner.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/RetryRunner.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/RetryRunner.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/RetryRunner.java Fri Nov
 4 09:48:27 2011
@@ -50,6 +50,7 @@ public class RetryRunner extends BlockJU
              * if one attempt succeeds, we succeed, if all attempts fail, we
              * fail with the reason corresponding to the last attempt
              */
+            @Override
             public void evaluate() throws Throwable {
                 Throwable failureReason = null;
 

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BracketingNthOrderBrentSolverTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BracketingNthOrderBrentSolverTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BracketingNthOrderBrentSolverTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BracketingNthOrderBrentSolverTest.java
Fri Nov  4 09:48:27 2011
@@ -33,11 +33,13 @@ import org.junit.Test;
  */
 public final class BracketingNthOrderBrentSolverTest extends BaseSecantSolverAbstractTest
{
     /** {@inheritDoc} */
+    @Override
     protected UnivariateRealSolver getSolver() {
         return new BracketingNthOrderBrentSolver();
     }
 
     /** {@inheritDoc} */
+    @Override
     protected int[] getQuinticEvalCounts() {
         return new int[] {1, 3, 8, 1, 9, 4, 8, 1, 12, 1, 14};
     }
@@ -88,27 +90,39 @@ public final class BracketingNthOrderBre
         // the reference roots have been computed by the Dfp solver to more than
         // 80 digits and checked with emacs (only the first 20 digits are reproduced here)
         compare(new TestFunction(0.0, -2, 2) {
+            @Override
             public double value(double x)      { return FastMath.sin(x) - 0.5 * x; }
+            @Override
             public double derivative(double x) { return FastMath.cos(x) - 0.5; }
         });
         compare(new TestFunction(6.3087771299726890947, -5, 10) {
+            @Override
             public double value(double x)      { return FastMath.pow(x, 5) + x - 10000; }
+            @Override
             public double derivative(double x) { return 5 * FastMath.pow(x, 4) + 1; }
         });
         compare(new TestFunction(9.6335955628326951924, 0.001, 10) {
+            @Override
             public double value(double x)      { return FastMath.sqrt(x) - 1 / x - 3; }
+            @Override
             public double derivative(double x) { return 0.5 / FastMath.sqrt(x) + 1 / (x *
x); }
         });
         compare(new TestFunction(2.8424389537844470678, -5, 5) {
+            @Override
             public double value(double x)      { return FastMath.exp(x) + x - 20; }
+            @Override
             public double derivative(double x) { return FastMath.exp(x) + 1; }
         });
         compare(new TestFunction(8.3094326942315717953, 0.001, 10) {
+            @Override
             public double value(double x)      { return FastMath.log(x) + FastMath.sqrt(x)
- 5; }
+            @Override
             public double derivative(double x) { return 1 / x + 0.5 / FastMath.sqrt(x); }
         });
         compare(new TestFunction(1.4655712318767680266, -0.5, 1.5) {
+            @Override
             public double value(double x)      { return (x - 1) * x * x - 1; }
+            @Override
             public double derivative(double x) { return (3 * x - 2) * x; }
         });
 

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/IllinoisSolverTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/IllinoisSolverTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/IllinoisSolverTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/IllinoisSolverTest.java
Fri Nov  4 09:48:27 2011
@@ -24,11 +24,13 @@ package org.apache.commons.math.analysis
  */
 public final class IllinoisSolverTest extends BaseSecantSolverAbstractTest {
     /** {@inheritDoc} */
+    @Override
     protected UnivariateRealSolver getSolver() {
         return new IllinoisSolver();
     }
 
     /** {@inheritDoc} */
+    @Override
     protected int[] getQuinticEvalCounts() {
         return new int[] {3, 7, 9, 10, 10, 10, 12, 12, 14, 15, 20};
     }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/PegasusSolverTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/PegasusSolverTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/PegasusSolverTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/PegasusSolverTest.java
Fri Nov  4 09:48:27 2011
@@ -24,11 +24,13 @@ package org.apache.commons.math.analysis
  */
 public final class PegasusSolverTest extends BaseSecantSolverAbstractTest {
     /** {@inheritDoc} */
+    @Override
     protected UnivariateRealSolver getSolver() {
         return new PegasusSolver();
     }
 
     /** {@inheritDoc} */
+    @Override
     protected int[] getQuinticEvalCounts() {
         return new int[] {3, 7, 9, 8, 9, 8, 10, 10, 12, 16, 18};
     }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolverTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolverTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolverTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolverTest.java
Fri Nov  4 09:48:27 2011
@@ -29,11 +29,13 @@ import org.junit.Assert;
  */
 public final class RegulaFalsiSolverTest extends BaseSecantSolverAbstractTest {
     /** {@inheritDoc} */
+    @Override
     protected UnivariateRealSolver getSolver() {
         return new RegulaFalsiSolver();
     }
 
     /** {@inheritDoc} */
+    @Override
     protected int[] getQuinticEvalCounts() {
         // While the Regula Falsi method guarantees convergence, convergence
         // may be extremely slow. The last test case does not converge within

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/SecantSolverTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/SecantSolverTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/SecantSolverTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/SecantSolverTest.java
Fri Nov  4 09:48:27 2011
@@ -24,11 +24,13 @@ package org.apache.commons.math.analysis
  */
 public final class SecantSolverTest extends BaseSecantSolverAbstractTest {
     /** {@inheritDoc} */
+    @Override
     protected UnivariateRealSolver getSolver() {
         return new SecantSolver();
     }
 
     /** {@inheritDoc} */
+    @Override
     protected int[] getQuinticEvalCounts() {
         // As the Secant method does not maintain a bracketed solution,
         // convergence is not guaranteed. Two test cases are disabled (-1) due

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java
Fri Nov  4 09:48:27 2011
@@ -95,14 +95,17 @@ public class ArrayRealVectorTest {
             return new UnsupportedOperationException("Not supported, unneeded for test purposes");
         }
 
+        @Override
         public RealVector map(UnivariateRealFunction function) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapToSelf(UnivariateRealFunction function) {
             throw unsupported();
         }
 
+        @Override
         public Iterator<Entry> iterator() {
             return new Iterator<Entry>() {
                 int i = 0;
@@ -128,14 +131,17 @@ public class ArrayRealVectorTest {
             };
         }
 
+        @Override
         public Iterator<Entry> sparseIterator() {
             return iterator();
         }
 
+        @Override
         public RealVector copy() {
             throw unsupported();
         }
 
+        @Override
         public RealVector add(RealVector v) {
             throw unsupported();
         }
@@ -144,6 +150,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector subtract(RealVector v) {
             throw unsupported();
         }
@@ -152,22 +159,27 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapAdd(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapAddToSelf(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapSubtract(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapSubtractToSelf(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapMultiply(double d) {
             double[] out = new double[data.length];
             for (int i = 0; i < data.length; i++) {
@@ -176,18 +188,22 @@ public class ArrayRealVectorTest {
             return new ArrayRealVector(out);
         }
 
+        @Override
         public RealVector mapMultiplyToSelf(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapDivide(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector mapDivideToSelf(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector ebeMultiply(RealVector v) {
             throw unsupported();
         }
@@ -196,6 +212,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector ebeDivide(RealVector v) {
             throw unsupported();
         }
@@ -204,6 +221,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public double dotProduct(RealVector v) {
             double dot = 0;
             for (int i = 0; i < data.length; i++) {
@@ -220,6 +238,7 @@ public class ArrayRealVectorTest {
             return dot;
         }
 
+        @Override
         public double cosine(RealVector v) {
             throw unsupported();
         }
@@ -228,18 +247,22 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public double getNorm() {
             throw unsupported();
         }
 
+        @Override
         public double getL1Norm() {
             throw unsupported();
         }
 
+        @Override
         public double getLInfNorm() {
             throw unsupported();
         }
 
+        @Override
         public double getDistance(RealVector v) {
             throw unsupported();
         }
@@ -248,6 +271,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public double getL1Distance(RealVector v) {
             throw unsupported();
         }
@@ -256,6 +280,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public double getLInfDistance(RealVector v) {
             throw unsupported();
         }
@@ -264,14 +289,17 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector unitVector() {
             throw unsupported();
         }
 
+        @Override
         public void unitize() {
             throw unsupported();
         }
 
+        @Override
         public RealVector projection(RealVector v) {
             throw unsupported();
         }
@@ -280,6 +308,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealMatrix outerProduct(RealVector v) {
             throw unsupported();
         }
@@ -288,18 +317,22 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public double getEntry(int index) {
             return data[index];
         }
 
+        @Override
         public int getDimension() {
             return data.length;
         }
 
+        @Override
         public RealVector append(RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public RealVector append(double d) {
             throw unsupported();
         }
@@ -308,14 +341,17 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector getSubVector(int index, int n) {
             throw unsupported();
         }
 
+        @Override
         public void setEntry(int index, double value) {
             throw unsupported();
         }
 
+        @Override
         public void setSubVector(int index, RealVector v) {
             throw unsupported();
         }
@@ -324,18 +360,22 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public void set(double value) {
             throw unsupported();
         }
 
+        @Override
         public double[] toArray() {
             return data.clone();
         }
 
+        @Override
         public boolean isNaN() {
             throw unsupported();
         }
 
+        @Override
         public boolean isInfinite() {
             throw unsupported();
         }
@@ -344,6 +384,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector combine(double a, double b, RealVector y) {
             throw unsupported();
         }
@@ -352,6 +393,7 @@ public class ArrayRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector combineToSelf(double a, double b, RealVector y) {
             throw unsupported();
         }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/RealVectorTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/RealVectorTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/RealVectorTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/RealVectorTest.java
Fri Nov  4 09:48:27 2011
@@ -95,10 +95,12 @@ public class RealVectorTest {
             return this;
         }
 
+        @Override
         public RealVector ebeMultiply(RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public RealVector ebeDivide(RealVector v) {
             throw unsupported();
         }
@@ -123,26 +125,32 @@ public class RealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector projection(RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public double getEntry(int index) {
             return values[index];
         }
 
+        @Override
         public void setEntry(int index, double value) {
             values[index] = value;
         }
 
+        @Override
         public int getDimension() {
             return values.length;
         }
 
+        @Override
         public RealVector append(RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public RealVector append(double d) {
             throw unsupported();
         }
@@ -151,6 +159,7 @@ public class RealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector getSubVector(int index, int n) {
             throw unsupported();
         }
@@ -158,14 +167,17 @@ public class RealVectorTest {
         public void setSubVector(int index, double[] v) {
             throw unsupported();
         }
+        @Override
         public void setSubVector(int index, RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public boolean isNaN() {
             throw unsupported();
         }
 
+        @Override
         public boolean isInfinite() {
             throw unsupported();
         }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealVectorTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealVectorTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealVectorTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealVectorTest.java
Fri Nov  4 09:48:27 2011
@@ -165,10 +165,12 @@ public class SparseRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector ebeMultiply(RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public RealVector ebeDivide(RealVector v) {
             throw unsupported();
         }
@@ -222,6 +224,7 @@ public class SparseRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public RealVector projection(RealVector v) {
             throw unsupported();
         }
@@ -231,26 +234,32 @@ public class SparseRealVectorTest {
             throw unsupported();
         }
 
+        @Override
         public double getEntry(int index) {
             return data[index];
         }
 
+        @Override
         public int getDimension() {
             return data.length;
         }
 
+        @Override
         public RealVector append(RealVector v) {
             throw unsupported();
         }
 
+        @Override
         public RealVector append(double d) {
             throw unsupported();
         }
 
+        @Override
         public RealVector getSubVector(int index, int n) {
             throw unsupported();
         }
 
+        @Override
         public void setEntry(int index, double value) {
             data[index] = value;
         }
@@ -270,10 +279,12 @@ public class SparseRealVectorTest {
             return data.clone();
         }
 
+        @Override
         public boolean isNaN() {
             throw unsupported();
         }
 
+        @Override
         public boolean isInfinite() {
             throw unsupported();
         }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/AbstractRandomGeneratorTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/AbstractRandomGeneratorTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/AbstractRandomGeneratorTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/AbstractRandomGeneratorTest.java
Fri Nov  4 09:48:27 2011
@@ -28,6 +28,7 @@ public class AbstractRandomGeneratorTest
         super();
     }
     
+    @Override
     protected RandomGenerator makeGenerator() {
         RandomGenerator generator = new TestRandomGenerator();
         generator.setSeed(1001);

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/BitsStreamGeneratorTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/BitsStreamGeneratorTest.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/BitsStreamGeneratorTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/BitsStreamGeneratorTest.java
Fri Nov  4 09:48:27 2011
@@ -30,6 +30,7 @@ public class BitsStreamGeneratorTest ext
         super();
     }
     
+    @Override
     protected RandomGenerator makeGenerator() {
         RandomGenerator generator = new TestBitStreamGenerator();
         generator.setSeed(1000);

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/FastMathTestPerformance.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/FastMathTestPerformance.java?rev=1197463&r1=1197462&r2=1197463&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/FastMathTestPerformance.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/FastMathTestPerformance.java
Fri Nov  4 09:48:27 2011
@@ -555,16 +555,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.log(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.log(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.log(x);
                                         }
@@ -575,16 +578,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.log10(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.log10(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.log10(x);
                                         }
@@ -595,16 +601,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.log1p(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.log1p(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.log1p(x);
                                         }
@@ -615,16 +624,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.pow(x, y);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.pow(x, y);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.pow(x, y);
                                         }
@@ -635,16 +647,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.exp(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.exp(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.exp(x);
                                         }
@@ -655,16 +670,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.sin(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.sin(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.sin(x);
                                         }
@@ -675,16 +693,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.asin(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.asin(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.asin(x);
                                         }
@@ -695,16 +716,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.cos(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.cos(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.cos(x);
                                         }
@@ -715,16 +739,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.acos(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.acos(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.acos(x);
                                         }
@@ -735,16 +762,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.tan(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.tan(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.tan(x);
                                         }
@@ -755,16 +785,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.atan(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.atan(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.atan(x);
                                         }
@@ -775,16 +808,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.atan2(x, y);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.atan2(x, y);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.atan2(x, y);
                                         }
@@ -795,16 +831,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.hypot(x, y);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.hypot(x, y);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.hypot(x, y);
                                         }
@@ -816,16 +855,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.cbrt(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.cbrt(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.cbrt(x);
                                         }
@@ -836,16 +878,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.sqrt(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.sqrt(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.sqrt(x);
                                         }
@@ -856,16 +901,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.cosh(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.cosh(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.cosh(x);
                                         }
@@ -876,16 +924,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.sinh(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.sinh(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.sinh(x);
                                         }
@@ -896,16 +947,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.tanh(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.tanh(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.tanh(x);
                                         }
@@ -916,16 +970,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.expm1(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.expm1(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.expm1(x);
                                         }
@@ -936,16 +993,19 @@ public class FastMathTestPerformance {
                                     numStat,
                                     false,
                                     new PerfTestUtils.RunTest(SM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return StrictMath.abs(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(M) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return Math.abs(x);
                                         }
                                     },
                                     new PerfTestUtils.RunTest(FM) {
+                                        @Override
                                         public Double call() throws Exception {
                                             return FastMath.abs(x);
                                         }



Mime
View raw message