commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r754727 [3/3] - in /commons/proper/math/trunk/src: java/org/apache/commons/math/optimization/ java/org/apache/commons/math/optimization/general/ test/org/apache/commons/math/optimization/general/
Date Sun, 15 Mar 2009 19:11:06 GMT
Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/MinpackTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/MinpackTest.java?rev=754727&r1=754726&r2=754727&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/MinpackTest.java
(original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/MinpackTest.java
Sun Mar 15 19:11:02 2009
@@ -19,7 +19,10 @@
 
 import java.util.Arrays;
 
+import org.apache.commons.math.optimization.ObjectiveException;
 import org.apache.commons.math.optimization.OptimizationException;
+import org.apache.commons.math.optimization.VectorialDifferentiableObjectiveFunction;
+import org.apache.commons.math.optimization.VectorialPointValuePair;
 
 
 import junit.framework.*;
@@ -86,8 +89,7 @@
  * @author Jorge J. More (original fortran minpack tests)
  * @author Luc Maisonobe (non-minpack tests and minpack tests Java translation)
  */
-public class MinpackTest
-  extends TestCase {
+public class MinpackTest extends TestCase {
 
   public MinpackTest(String name) {
     super(name);
@@ -502,157 +504,117 @@
   }
 
   private void minpackTest(MinpackFunction function, boolean exceptionExpected) {
-    LevenbergMarquardtEstimator estimator = new LevenbergMarquardtEstimator();
-    estimator.setMaxCostEval(100 * (function.getN() + 1));
-    estimator.setCostRelativeTolerance(Math.sqrt(2.22044604926e-16));
-    estimator.setParRelativeTolerance(Math.sqrt(2.22044604926e-16));
-    estimator.setOrthoTolerance(2.22044604926e-16);
-    assertTrue(function.checkTheoreticalStartCost(estimator.getRMS(function)));
-    try {
-      estimator.estimate(function);
-      assertFalse(exceptionExpected);
-    } catch (OptimizationException lsse) {
-      assertTrue(exceptionExpected);
-    }
-    assertTrue(function.checkTheoreticalMinCost(estimator.getRMS(function)));
-    assertTrue(function.checkTheoreticalMinParams());
+      LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();
+      optimizer.setMaxEvaluations(100 * (function.getN() + 1));
+      optimizer.setCostRelativeTolerance(Math.sqrt(2.22044604926e-16));
+      optimizer.setParRelativeTolerance(Math.sqrt(2.22044604926e-16));
+      optimizer.setOrthoTolerance(2.22044604926e-16);
+//      assertTrue(function.checkTheoreticalStartCost(optimizer.getRMS()));
+      try {
+          VectorialPointValuePair optimum =
+              optimizer.optimize(function,
+                                 function.getTarget(), function.getWeight(),
+                                 function.getStartPoint());
+          assertFalse(exceptionExpected);
+          assertTrue(function.checkTheoreticalMinCost(optimizer.getRMS()));
+          assertTrue(function.checkTheoreticalMinParams(optimum));
+      } catch (OptimizationException lsse) {
+          assertTrue(exceptionExpected);
+      } catch (ObjectiveException oe) {
+          assertTrue(exceptionExpected);
+      }
   }
 
-  private static abstract class MinpackFunction implements EstimationProblem {
+  private static abstract class MinpackFunction
+      implements VectorialDifferentiableObjectiveFunction {
  
-    protected MinpackFunction(int m,
-                              double[] startParams,
-                              double   theoreticalStartCost,
-                              double   theoreticalMinCost,
-                              double[] theoreticalMinParams) {
-      this.m = m;
-      this.n = startParams.length;
-      parameters = new EstimatedParameter[n];
-      for (int i = 0; i < n; ++i) {
-        parameters[i] = new EstimatedParameter("p" + i, startParams[i]);
-      }
-      this.theoreticalStartCost = theoreticalStartCost;
-      this.theoreticalMinCost   = theoreticalMinCost;
-      this.theoreticalMinParams = theoreticalMinParams;
-      this.costAccuracy         = 1.0e-8;
-      this.paramsAccuracy       = 1.0e-5;
-    }
-
-    protected static double[] buildArray(int n, double x) {
-      double[] array = new double[n];
-      Arrays.fill(array, x);
-      return array;
-    }
-
-    protected void setCostAccuracy(double costAccuracy) {
-      this.costAccuracy = costAccuracy;
-    }
-
-    protected void setParamsAccuracy(double paramsAccuracy) {
-      this.paramsAccuracy = paramsAccuracy;
-    }
-
-    public int getN() {
-      return parameters.length;
-    }
-
-    public boolean checkTheoreticalStartCost(double rms) {
-      double threshold = costAccuracy * (1.0 + theoreticalStartCost);
-      return Math.abs(Math.sqrt(m) * rms - theoreticalStartCost) <= threshold;
-    }
+      private static final long serialVersionUID = -6209760235478794233L;
+      protected int      n;
+      protected int      m;
+      protected double[] startParams;
+      protected double   theoreticalMinCost;
+      protected double[] theoreticalMinParams;
+      protected double   costAccuracy;
+      protected double   paramsAccuracy;
 
-    public boolean checkTheoreticalMinCost(double rms) {
-      double threshold = costAccuracy * (1.0 + theoreticalMinCost);
-     return Math.abs(Math.sqrt(m) * rms - theoreticalMinCost) <= threshold;
-    }
-
-    public boolean checkTheoreticalMinParams() {
-      if (theoreticalMinParams != null) {
-        for (int i = 0; i < theoreticalMinParams.length; ++i) {
-          double mi = theoreticalMinParams[i];
-          double vi = parameters[i].getEstimate();
-          if (Math.abs(mi - vi) > (paramsAccuracy * (1.0 + Math.abs(mi)))) {
-            return false;
-          }
-        }
+      protected MinpackFunction(int m, double[] startParams,
+                                double theoreticalMinCost, double[] theoreticalMinParams)
{
+          this.m = m;
+          this.n = startParams.length;
+          this.startParams          = startParams.clone();
+          this.theoreticalMinCost   = theoreticalMinCost;
+          this.theoreticalMinParams = theoreticalMinParams;
+          this.costAccuracy         = 1.0e-8;
+          this.paramsAccuracy       = 1.0e-5;
       }
-      return true;
-    }
- 
-    public WeightedMeasurement[] getMeasurements() {
-      WeightedMeasurement[] measurements = new WeightedMeasurement[m];
-      for (int i = 0; i < m; ++i) {
-        measurements[i] = new MinpackMeasurement(i);
+
+      protected static double[] buildArray(int n, double x) {
+          double[] array = new double[n];
+          Arrays.fill(array, x);
+          return array;
       }
-      return measurements;
-    }
 
-    public EstimatedParameter[] getUnboundParameters() {
-      return parameters;
-    }
+      public double[] getTarget() {
+          return buildArray(m, 0.0);
+      }
 
-    public EstimatedParameter[] getAllParameters() {
-      return parameters;
-    }
+      public double[] getWeight() {
+          return buildArray(m, 1.0);
+      }
 
-    protected abstract double[][] getJacobian();
+      public double[] getStartPoint() {
+          return startParams.clone();
+      }
 
-    protected abstract double[] getResiduals();
+      protected void setCostAccuracy(double costAccuracy) {
+          this.costAccuracy = costAccuracy;
+      }
 
-    private class MinpackMeasurement extends WeightedMeasurement {
+      protected void setParamsAccuracy(double paramsAccuracy) {
+          this.paramsAccuracy = paramsAccuracy;
+      }
 
-      public MinpackMeasurement(int index) {
-        super(1.0, 0.0);
-        this.index = index;
+      public int getN() {
+          return startParams.length;
       }
 
-      public double getTheoreticalValue() {
-        // this is obviously NOT efficient as we recompute the whole vector
-        // each time we need only one element, but it is only for test
-        // purposes and is simpler to check.
-        // This implementation should NOT be taken as an example, it is ugly!
-        return getResiduals()[index];
+      public boolean checkTheoreticalMinCost(double rms) {
+          double threshold = costAccuracy * (1.0 + theoreticalMinCost);
+          return Math.abs(Math.sqrt(m) * rms - theoreticalMinCost) <= threshold;
       }
 
-      public double getPartial(EstimatedParameter parameter) {
-        // this is obviously NOT efficient as we recompute the whole jacobian
-        // each time we need only one element, but it is only for test
-        // purposes and is simpler to check.
-        // This implementation should NOT be taken as an example, it is ugly!
-        for (int j = 0; j < n; ++j) {
-          if (parameter == parameters[j]) {
-            return getJacobian()[index][j];
+      public boolean checkTheoreticalMinParams(VectorialPointValuePair optimum) {
+          double[] params = optimum.getPointRef();
+          if (theoreticalMinParams != null) {
+              for (int i = 0; i < theoreticalMinParams.length; ++i) {
+                  double mi = theoreticalMinParams[i];
+                  double vi = params[i];
+                  if (Math.abs(mi - vi) > (paramsAccuracy * (1.0 + Math.abs(mi)))) {
+                      return false;
+                  }
+              }
           }
-        }
-        return 0;
+          return true;
       }
 
-      private int index;
-      private static final long serialVersionUID = 1L;
+      public abstract double[][] jacobian(double[] variables, double[] value);
 
-    }
-
-    protected int                  n;
-    protected int                  m;
-    protected EstimatedParameter[] parameters;
-    protected double               theoreticalStartCost;
-    protected double               theoreticalMinCost;
-    protected double[]             theoreticalMinParams;
-    protected double               costAccuracy;
-    protected double               paramsAccuracy;
+      public abstract double[] objective(double[] variables);
 
   }
 
   private static class LinearFullRankFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -9030323226268039536L;
+
     public LinearFullRankFunction(int m, int n, double x0,
                                   double theoreticalStartCost,
                                   double theoreticalMinCost) {
-      super(m, buildArray(n, x0), theoreticalStartCost,
-            theoreticalMinCost, buildArray(n, -1.0));
+      super(m, buildArray(n, x0), theoreticalMinCost,
+            buildArray(n, -1.0));
     }
 
-    protected double[][] getJacobian() {
+    public double[][] jacobian(double[] variables, double[] value) {
       double t = 2.0 / m;
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
@@ -664,15 +626,15 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
+    public double[] objective(double[] variables) {
       double sum = 0;
       for (int i = 0; i < n; ++i) {
-        sum += parameters[i].getEstimate();
+        sum += variables[i];
       }
       double t  = 1 + 2 * sum / m;
       double[] f = new double[m];
       for (int i = 0; i < n; ++i) {
-        f[i] = parameters[i].getEstimate() - t;
+        f[i] = variables[i] - t;
       }
       Arrays.fill(f, n, m, -t);
       return f;
@@ -682,13 +644,15 @@
 
   private static class LinearRank1Function extends MinpackFunction {
 
+    private static final long serialVersionUID = 8494863245104608300L;
+
     public LinearRank1Function(int m, int n, double x0,
                                   double theoreticalStartCost,
                                   double theoreticalMinCost) {
-      super(m, buildArray(n, x0), theoreticalStartCost, theoreticalMinCost, null);
+      super(m, buildArray(n, x0), theoreticalMinCost, null);
     }
 
-    protected double[][] getJacobian() {
+    public double[][] jacobian(double[] variables, double[] value) {
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         jacobian[i] = new double[n];
@@ -699,11 +663,11 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
+    public double[] objective(double[] variables) {
       double[] f = new double[m];
       double sum = 0;
       for (int i = 0; i < n; ++i) {
-        sum += (i + 1) * parameters[i].getEstimate();
+        sum += (i + 1) * variables[i];
       }
       for (int i = 0; i < m; ++i) {
         f[i] = (i + 1) * sum - 1;
@@ -715,14 +679,15 @@
 
   private static class LinearRank1ZeroColsAndRowsFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -3316653043091995018L;
+
     public LinearRank1ZeroColsAndRowsFunction(int m, int n, double x0) {
       super(m, buildArray(n, x0),
-            Math.sqrt(m + (n+1)*(n-2)*(m-2)*(m-1) * ((n+1)*(n-2)*(2*m-3) - 12) / 24.0),
             Math.sqrt((m * (m + 3) - 6) / (2.0 * (2 * m - 3))),
             null);
     }
 
-    protected double[][] getJacobian() {
+    public double[][] jacobian(double[] variables, double[] value) {
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         jacobian[i] = new double[n];
@@ -741,11 +706,11 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
+    public double[] objective(double[] variables) {
       double[] f = new double[m];
       double sum = 0;
       for (int i = 1; i < (n - 1); ++i) {
-        sum += (i + 1) * parameters[i].getEstimate();
+        sum += (i + 1) * variables[i];
       }
       for (int i = 0; i < (m - 1); ++i) {
         f[i] = i * sum - 1;
@@ -758,18 +723,20 @@
 
   private static class RosenbrockFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 2893438180956569134L;
+
     public RosenbrockFunction(double[] startParams, double theoreticalStartCost) {
-      super(2, startParams, theoreticalStartCost, 0.0, buildArray(2, 1.0));
+      super(2, startParams, 0.0, buildArray(2, 1.0));
     }
 
-    protected double[][] getJacobian() {
-      double x1 = parameters[0].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double x1 = variables[0];
       return new double[][] { { -20 * x1, 10 }, { -1, 0 } };
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
       return new double[] { 10 * (x2 - x1 * x1), 1 - x1 };
     }
 
@@ -777,15 +744,16 @@
 
   private static class HelicalValleyFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 220613787843200102L;
+
     public HelicalValleyFunction(double[] startParams,
                                  double theoreticalStartCost) {
-      super(3, startParams, theoreticalStartCost, 0.0,
-            new double[] { 1.0, 0.0, 0.0 });
+      super(3, startParams, 0.0, new double[] { 1.0, 0.0, 0.0 });
     }
 
-    protected double[][] getJacobian() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double x1 = variables[0];
+      double x2 = variables[1];
       double tmpSquare = x1 * x1 + x2 * x2;
       double tmp1 = twoPi * tmpSquare;
       double tmp2 = Math.sqrt(tmpSquare);
@@ -796,10 +764,10 @@
       };
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
       double tmp1;
       if (x1 == 0) {
         tmp1 = (x2 >= 0) ? 0.25 : -0.25;
@@ -823,16 +791,18 @@
 
   private static class PowellSingularFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 7298364171208142405L;
+
     public PowellSingularFunction(double[] startParams,
                                   double theoreticalStartCost) {
-      super(4, startParams, theoreticalStartCost, 0.0, buildArray(4, 0.0));
+      super(4, startParams, 0.0, buildArray(4, 0.0));
     }
 
-    protected double[][] getJacobian() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
-      double x4 = parameters[3].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
+      double x4 = variables[3];
       return new double[][] {
         { 1, 10, 0, 0 },
         { 0, 0, sqrt5, -sqrt5 },
@@ -841,11 +811,11 @@
       };
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
-      double x4 = parameters[3].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
+      double x4 = variables[3];
       return new double[] {
         x1 + 10 * x2,
         sqrt5 * (x3 - x4),
@@ -861,25 +831,27 @@
 
   private static class FreudensteinRothFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 2892404999344244214L;
+
     public FreudensteinRothFunction(double[] startParams,
                                     double theoreticalStartCost,
                                     double theoreticalMinCost,
                                     double[] theoreticalMinParams) {
-      super(2, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(2, startParams, theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
-      double x2 = parameters[1].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double x2 = variables[1];
       return new double[][] {
         { 1, x2 * (10 - 3 * x2) -  2 },
         { 1, x2 * ( 2 + 3 * x2) - 14, }
       };
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
       return new double[] {
        -13.0 + x1 + ((5.0 - x2) * x2 -  2.0) * x2,
        -29.0 + x1 + ((1.0 + x2) * x2 - 14.0) * x2
@@ -890,17 +862,19 @@
 
   private static class BardFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 5990442612572087668L;
+
     public BardFunction(double x0,
                         double theoreticalStartCost,
                         double theoreticalMinCost,
                         double[] theoreticalMinParams) {
-      super(15, buildArray(3, x0), theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(15, buildArray(3, x0), theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
-      double   x2 = parameters[1].getEstimate();
-      double   x3 = parameters[2].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x2 = variables[1];
+      double   x3 = variables[2];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double tmp1 = i  + 1;
@@ -913,10 +887,10 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double   x1 = parameters[0].getEstimate();
-      double   x2 = parameters[1].getEstimate();
-      double   x3 = parameters[2].getEstimate();
+    public double[] objective(double[] variables) {
+      double   x1 = variables[0];
+      double   x2 = variables[1];
+      double   x3 = variables[2];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         double tmp1 = i + 1;
@@ -937,23 +911,25 @@
 
   private static class KowalikOsborneFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -4867445739880495801L;
+
     public KowalikOsborneFunction(double[] startParams,
                                   double theoreticalStartCost,
                                   double theoreticalMinCost,
                                   double[] theoreticalMinParams) {
-      super(11, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(11, startParams, theoreticalMinCost,
+            theoreticalMinParams);
       if (theoreticalStartCost > 20.0) {
         setCostAccuracy(2.0e-4);
         setParamsAccuracy(5.0e-3);
       }
     }
 
-    protected double[][] getJacobian() {
-      double   x1 = parameters[0].getEstimate();
-      double   x2 = parameters[1].getEstimate();
-      double   x3 = parameters[2].getEstimate();
-      double   x4 = parameters[3].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x1 = variables[0];
+      double   x2 = variables[1];
+      double   x3 = variables[2];
+      double   x4 = variables[3];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double tmp = v[i] * (v[i] + x3) + x4;
@@ -966,11 +942,11 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
-      double x4 = parameters[3].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
+      double x4 = variables[3];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         f[i] = y[i] - x1 * (v[i] * (v[i] + x2)) / (v[i] * (v[i] + x3) + x4);
@@ -991,22 +967,24 @@
 
   private static class MeyerFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -838060619150131027L;
+
     public MeyerFunction(double[] startParams,
                          double theoreticalStartCost,
                          double theoreticalMinCost,
                          double[] theoreticalMinParams) {
-      super(16, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(16, startParams, theoreticalMinCost,
+            theoreticalMinParams);
       if (theoreticalStartCost > 1.0e6) {
         setCostAccuracy(7.0e-3);
         setParamsAccuracy(2.0e-2);
       }
     }
 
-    protected double[][] getJacobian() {
-      double   x1 = parameters[0].getEstimate();
-      double   x2 = parameters[1].getEstimate();
-      double   x3 = parameters[2].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x1 = variables[0];
+      double   x2 = variables[1];
+      double   x3 = variables[2];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double temp = 5.0 * (i + 1) + 45.0 + x3;
@@ -1018,10 +996,10 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         f[i] = x1 * Math.exp(x2 / (5.0 * (i + 1) + 45.0 + x3)) - y[i];
@@ -1040,15 +1018,17 @@
 
   private static class WatsonFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -9034759294980218927L;
+
     public WatsonFunction(int n, double x0,
                           double theoreticalStartCost,
                           double theoreticalMinCost,
                           double[] theoreticalMinParams) {
-      super(31, buildArray(n, x0), theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(31, buildArray(n, x0), theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
+    public double[][] jacobian(double[] variables, double[] value) {
 
       double[][] jacobian = new double[m][];
 
@@ -1057,7 +1037,7 @@
         double s2  = 0.0;
         double dx  = 1.0;
         for (int j = 0; j < n; ++j) {
-          s2 += dx * parameters[j].getEstimate();
+          s2 += dx * variables[j];
           dx *= div;
         }
         double temp= 2 * div * s2;
@@ -1073,34 +1053,34 @@
       jacobian[m - 2][0] = 1;
 
       jacobian[m - 1]   = new double[n];
-      jacobian[m - 1][0]= -2 * parameters[0].getEstimate();
+      jacobian[m - 1][0]= -2 * variables[0];
       jacobian[m - 1][1]= 1;
 
       return jacobian;
 
     }
 
-    protected double[] getResiduals() {
+    public double[] objective(double[] variables) {
      double[] f = new double[m];
      for (int i = 0; i < (m - 2); ++i) {
        double div = (i + 1) / 29.0;
        double s1 = 0;
        double dx = 1;
        for (int j = 1; j < n; ++j) {
-         s1 += j * dx * parameters[j].getEstimate();
+         s1 += j * dx * variables[j];
          dx *= div;
        }
        double s2 =0;
        dx =1;
        for (int j = 0; j < n; ++j) {
-         s2 += dx * parameters[j].getEstimate();
+         s2 += dx * variables[j];
          dx *= div;
        }
        f[i] = s1 - s2 * s2 - 1;
      }
 
-     double x1 = parameters[0].getEstimate();
-     double x2 = parameters[1].getEstimate();
+     double x1 = variables[0];
+     double x2 = variables[1];
      f[m - 2] = x1;
      f[m - 1] = x2 - x1 * x1 - 1;
 
@@ -1112,15 +1092,17 @@
 
   private static class Box3DimensionalFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 5511403858142574493L;
+
     public Box3DimensionalFunction(int m, double[] startParams,
                                    double theoreticalStartCost) {
-      super(m, startParams, theoreticalStartCost,
-            0.0, new double[] { 1.0, 10.0, 1.0 });
+      super(m, startParams, 0.0,
+            new double[] { 1.0, 10.0, 1.0 });
    }
 
-    protected double[][] getJacobian() {
-      double   x1 = parameters[0].getEstimate();
-      double   x2 = parameters[1].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x1 = variables[0];
+      double   x2 = variables[1];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double tmp = (i + 1) / 10.0;
@@ -1133,10 +1115,10 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         double tmp = (i + 1) / 10.0;
@@ -1150,17 +1132,19 @@
 
   private static class JennrichSampsonFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -2489165190443352947L;
+
     public JennrichSampsonFunction(int m, double[] startParams,
                                    double theoreticalStartCost,
                                    double theoreticalMinCost,
                                    double[] theoreticalMinParams) {
-      super(m, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(m, startParams, theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
-      double   x1 = parameters[0].getEstimate();
-      double   x2 = parameters[1].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x1 = variables[0];
+      double   x2 = variables[1];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double t = i + 1;
@@ -1169,9 +1153,9 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         double temp = i + 1;
@@ -1184,19 +1168,21 @@
 
   private static class BrownDennisFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 8340018645694243910L;
+
     public BrownDennisFunction(int m, double[] startParams,
                                double theoreticalStartCost,
                                double theoreticalMinCost,
                                double[] theoreticalMinParams) {
-      super(m, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(m, startParams, theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
-      double   x1 = parameters[0].getEstimate();
-      double   x2 = parameters[1].getEstimate();
-      double   x3 = parameters[2].getEstimate();
-      double   x4 = parameters[3].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x1 = variables[0];
+      double   x2 = variables[1];
+      double   x3 = variables[2];
+      double   x4 = variables[3];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double temp = (i + 1) / 5.0;
@@ -1210,11 +1196,11 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
-      double x4 = parameters[3].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
+      double x4 = variables[3];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         double temp = (i + 1) / 5.0;
@@ -1229,6 +1215,8 @@
 
   private static class ChebyquadFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = -2394877275028008594L;
+
     private static double[] buildChebyquadArray(int n, double factor) {
       double[] array = new double[n];
       double inv = factor / (n + 1);
@@ -1242,11 +1230,11 @@
                              double theoreticalStartCost,
                              double theoreticalMinCost,
                              double[] theoreticalMinParams) {
-      super(m, buildChebyquadArray(n, factor), theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(m, buildChebyquadArray(n, factor), theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
+    public double[][] jacobian(double[] variables, double[] value) {
 
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
@@ -1256,7 +1244,7 @@
       double dx = 1.0 / n;
       for (int j = 0; j < n; ++j) {
         double tmp1 = 1;
-        double tmp2 = 2 * parameters[j].getEstimate() - 1;
+        double tmp2 = 2 * variables[j] - 1;
         double temp = 2 * tmp2;
         double tmp3 = 0;
         double tmp4 = 2;
@@ -1275,13 +1263,13 @@
 
     }
 
-    protected double[] getResiduals() {
+    public double[] objective(double[] variables) {
 
       double[] f = new double[m];
 
       for (int j = 0; j < n; ++j) {
         double tmp1 = 1;
-        double tmp2 = 2 * parameters[j].getEstimate() - 1;
+        double tmp2 = 2 * variables[j] - 1;
         double temp = 2 * tmp2;
         for (int i = 0; i < m; ++i) {
           f[i] += tmp2;
@@ -1309,15 +1297,17 @@
 
   private static class BrownAlmostLinearFunction extends MinpackFunction {
 
+    private static final long serialVersionUID = 8239594490466964725L;
+
     public BrownAlmostLinearFunction(int m, double factor,
                                      double theoreticalStartCost,
                                      double theoreticalMinCost,
                                      double[] theoreticalMinParams) {
-      super(m, buildArray(m, factor), theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(m, buildArray(m, factor), theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
+    public double[][] jacobian(double[] variables, double[] value) {
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         jacobian[i] = new double[n];
@@ -1325,7 +1315,7 @@
 
       double prod = 1;
       for (int j = 0; j < n; ++j) {
-        prod *= parameters[j].getEstimate();
+        prod *= variables[j];
         for (int i = 0; i < n; ++i) {
           jacobian[i][j] = 1;
         }
@@ -1333,14 +1323,13 @@
       }
 
       for (int j = 0; j < n; ++j) {
-        EstimatedParameter vj = parameters[j];
-        double temp = vj.getEstimate();
+        double temp = variables[j];
         if (temp == 0) {
           temp = 1;
           prod = 1;
           for (int k = 0; k < n; ++k) {
             if (k != j) {
-              prod *= parameters[k].getEstimate();
+              prod *= variables[k];
             }
           }
         }
@@ -1351,16 +1340,16 @@
 
     }
 
-    protected double[] getResiduals() {
+    public double[] objective(double[] variables) {
       double[] f = new double[m];
       double sum  = -(n + 1);
       double prod = 1;
       for (int j = 0; j < n; ++j) {
-        sum  += parameters[j].getEstimate();
-        prod *= parameters[j].getEstimate();
+        sum  += variables[j];
+        prod *= variables[j];
       }
       for (int i = 0; i < n; ++i) {
-        f[i] = parameters[i].getEstimate() + sum;
+        f[i] = variables[i] + sum;
       }
       f[n - 1] = prod - 1;
       return f;
@@ -1370,19 +1359,21 @@
 
   private static class Osborne1Function extends MinpackFunction {
 
+    private static final long serialVersionUID = 4006743521149849494L;
+
     public Osborne1Function(double[] startParams,
                             double theoreticalStartCost,
                             double theoreticalMinCost,
                             double[] theoreticalMinParams) {
-      super(33, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(33, startParams, theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
-      double   x2 = parameters[1].getEstimate();
-      double   x3 = parameters[2].getEstimate();
-      double   x4 = parameters[3].getEstimate();
-      double   x5 = parameters[4].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x2 = variables[1];
+      double   x3 = variables[2];
+      double   x4 = variables[3];
+      double   x5 = variables[4];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double temp = 10.0 * i;
@@ -1395,12 +1386,12 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x1 = parameters[0].getEstimate();
-      double x2 = parameters[1].getEstimate();
-      double x3 = parameters[2].getEstimate();
-      double x4 = parameters[3].getEstimate();
-      double x5 = parameters[4].getEstimate();
+    public double[] objective(double[] variables) {
+      double x1 = variables[0];
+      double x2 = variables[1];
+      double x3 = variables[2];
+      double x4 = variables[3];
+      double x5 = variables[4];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         double temp = 10.0 * i;
@@ -1421,26 +1412,28 @@
 
   private static class Osborne2Function extends MinpackFunction {
 
+    private static final long serialVersionUID = -8418268780389858746L;
+
     public Osborne2Function(double[] startParams,
                             double theoreticalStartCost,
                             double theoreticalMinCost,
                             double[] theoreticalMinParams) {
-      super(65, startParams, theoreticalStartCost,
-            theoreticalMinCost, theoreticalMinParams);
+      super(65, startParams, theoreticalMinCost,
+            theoreticalMinParams);
     }
 
-    protected double[][] getJacobian() {
-      double   x01 = parameters[0].getEstimate();
-      double   x02 = parameters[1].getEstimate();
-      double   x03 = parameters[2].getEstimate();
-      double   x04 = parameters[3].getEstimate();
-      double   x05 = parameters[4].getEstimate();
-      double   x06 = parameters[5].getEstimate();
-      double   x07 = parameters[6].getEstimate();
-      double   x08 = parameters[7].getEstimate();
-      double   x09 = parameters[8].getEstimate();
-      double   x10 = parameters[9].getEstimate();
-      double   x11 = parameters[10].getEstimate();
+    public double[][] jacobian(double[] variables, double[] value) {
+      double   x01 = variables[0];
+      double   x02 = variables[1];
+      double   x03 = variables[2];
+      double   x04 = variables[3];
+      double   x05 = variables[4];
+      double   x06 = variables[5];
+      double   x07 = variables[6];
+      double   x08 = variables[7];
+      double   x09 = variables[8];
+      double   x10 = variables[9];
+      double   x11 = variables[10];
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         double temp = i / 10.0;
@@ -1465,18 +1458,18 @@
       return jacobian;
     }
 
-    protected double[] getResiduals() {
-      double x01 = parameters[0].getEstimate();
-      double x02 = parameters[1].getEstimate();
-      double x03 = parameters[2].getEstimate();
-      double x04 = parameters[3].getEstimate();
-      double x05 = parameters[4].getEstimate();
-      double x06 = parameters[5].getEstimate();
-      double x07 = parameters[6].getEstimate();
-      double x08 = parameters[7].getEstimate();
-      double x09 = parameters[8].getEstimate();
-      double x10 = parameters[9].getEstimate();
-      double x11 = parameters[10].getEstimate();
+    public double[] objective(double[] variables) {
+      double x01 = variables[0];
+      double x02 = variables[1];
+      double x03 = variables[2];
+      double x04 = variables[3];
+      double x05 = variables[4];
+      double x06 = variables[5];
+      double x07 = variables[6];
+      double x08 = variables[7];
+      double x09 = variables[8];
+      double x10 = variables[9];
+      double x11 = variables[10];
       double[] f = new double[m];
       for (int i = 0; i < m; ++i) {
         double temp = i / 10.0;



Mime
View raw message