commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r758058 - in /commons/proper/math/trunk/src: java/org/apache/commons/math/optimization/general/ test/org/apache/commons/math/optimization/general/
Date Tue, 24 Mar 2009 22:15:09 GMT
Author: luc
Date: Tue Mar 24 22:15:08 2009
New Revision: 758058

URL: http://svn.apache.org/viewvc?rev=758058&view=rev
Log:
updated general algorithms with latest interfaces definitions

Modified:
    commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizer.java
    commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java
    commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java
    commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/MinpackTest.java

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java?rev=758058&r1=758057&r2=758058&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java (original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java Tue Mar 24 22:15:08 2009
@@ -17,17 +17,18 @@
 
 package org.apache.commons.math.optimization.general;
 
+import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.MaxIterationsExceededException;
+import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
+import org.apache.commons.math.analysis.MultivariateMatrixFunction;
 import org.apache.commons.math.linear.InvalidMatrixException;
 import org.apache.commons.math.linear.MatrixUtils;
 import org.apache.commons.math.linear.RealMatrix;
 import org.apache.commons.math.linear.decomposition.LUDecompositionImpl;
-import org.apache.commons.math.optimization.ObjectiveException;
 import org.apache.commons.math.optimization.OptimizationException;
 import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
 import org.apache.commons.math.optimization.VectorialConvergenceChecker;
-import org.apache.commons.math.optimization.VectorialDifferentiableObjectiveFunction;
-import org.apache.commons.math.optimization.VectorialDifferentiableOptimizer;
+import org.apache.commons.math.optimization.DifferentiableMultivariateVectorialOptimizer;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
 
 /**
@@ -38,7 +39,7 @@
  * @since 1.2
  *
  */
-public abstract class AbstractLeastSquaresOptimizer implements VectorialDifferentiableOptimizer {
+public abstract class AbstractLeastSquaresOptimizer implements DifferentiableMultivariateVectorialOptimizer {
 
     /** Serializable version identifier */
     private static final long serialVersionUID = 5413193243329026789L;
@@ -77,7 +78,10 @@
     protected int rows;
 
     /** Objective function. */
-    private VectorialDifferentiableObjectiveFunction f;
+    private DifferentiableMultivariateVectorialFunction f;
+
+    /** Objective function derivatives. */
+    private MultivariateMatrixFunction jF;
 
     /** Target value for the objective functions at optimum. */
     protected double[] target;
@@ -85,8 +89,8 @@
     /** Weight for the least squares cost computation. */
     protected double[] weights;
 
-    /** Current variables set. */
-    protected double[] variables;
+    /** Current point. */
+    protected double[] point;
 
     /** Current objective function value. */
     protected double[] objective;
@@ -156,15 +160,15 @@
 
     /** 
      * Update the jacobian matrix.
-     * @exception ObjectiveException if the function jacobian
+     * @exception FunctionEvaluationException if the function jacobian
      * cannot be evaluated or its dimension doesn't match problem dimension
      */
-    protected void updateJacobian() throws ObjectiveException {
+    protected void updateJacobian() throws FunctionEvaluationException {
         ++jacobianEvaluations;
-        jacobian = f.jacobian(variables, objective);
+        jacobian = jF.value(point);
         if (jacobian.length != rows) {
-            throw new ObjectiveException("dimension mismatch {0} != {1}",
-                                         jacobian.length, rows);
+            throw new FunctionEvaluationException(point, "dimension mismatch {0} != {1}",
+                                                  jacobian.length, rows);
         }
         for (int i = 0; i < rows; i++) {
             final double[] ji = jacobian[i];
@@ -177,17 +181,17 @@
 
     /** 
      * Update the residuals array and cost function value.
-     * @exception ObjectiveException if the function cannot be evaluated
+     * @exception FunctionEvaluationException if the function cannot be evaluated
      * or its dimension doesn't match problem dimension
      */
     protected void updateResidualsAndCost()
-        throws ObjectiveException {
+        throws FunctionEvaluationException {
 
         ++objectiveEvaluations;
-        objective = f.objective(variables);
+        objective = f.value(point);
         if (objective.length != rows) {
-            throw new ObjectiveException("dimension mismatch {0} != {1}",
-                                         objective.length, rows);
+            throw new FunctionEvaluationException(point, "dimension mismatch {0} != {1}",
+                                                  objective.length, rows);
         }
         cost = 0;
         for (int i = 0, index = 0; i < rows; i++, index += cols) {
@@ -234,13 +238,13 @@
     /**
      * Get the covariance matrix of optimized parameters.
      * @return covariance matrix
-     * @exception ObjectiveException if the function jacobian cannot
+     * @exception FunctionEvaluationException if the function jacobian cannot
      * be evaluated
      * @exception OptimizationException if the covariance matrix
      * cannot be computed (singular problem)
      */
     public double[][] getCovariances()
-        throws ObjectiveException, OptimizationException {
+        throws FunctionEvaluationException, OptimizationException {
 
         // set up the jacobian
         updateJacobian();
@@ -273,13 +277,13 @@
      * Guess the errors in optimized parameters.
      * <p>Guessing is covariance-based, it only gives rough order of magnitude.</p>
      * @return errors in optimized parameters
-     * @exception ObjectiveException if the function jacobian cannot b evaluated
+     * @exception FunctionEvaluationException if the function jacobian cannot b evaluated
      * @exception OptimizationException if the covariances matrix cannot be computed
      * or the number of degrees of freedom is not positive (number of measurements
      * lesser or equal to number of parameters)
      */
     public double[] guessParametersErrors()
-        throws ObjectiveException, OptimizationException {
+        throws FunctionEvaluationException, OptimizationException {
         if (rows <= cols) {
             throw new OptimizationException(
                     "no degrees of freedom ({0} measurements, {1} parameters)",
@@ -295,10 +299,10 @@
     }
 
     /** {@inheritDoc} */
-    public VectorialPointValuePair optimize(final VectorialDifferentiableObjectiveFunction f,
+    public VectorialPointValuePair optimize(final DifferentiableMultivariateVectorialFunction f,
                                             final double[] target, final double[] weights,
                                             final double[] startPoint)
-        throws ObjectiveException, OptimizationException, IllegalArgumentException {
+        throws FunctionEvaluationException, OptimizationException, IllegalArgumentException {
 
         if (target.length != weights.length) {
             throw new OptimizationException("dimension mismatch {0} != {1}",
@@ -312,14 +316,15 @@
 
         // store least squares problem characteristics
         this.f         = f;
+        jF             = f.jacobian();
         this.target    = target.clone();
         this.weights   = weights.clone();
-        this.variables = startPoint.clone();
+        this.point     = startPoint.clone();
         this.residuals = new double[target.length];
 
         // arrays shared with the other private methods
         rows      = target.length;
-        cols      = variables.length;
+        cols      = point.length;
         jacobian  = new double[rows][cols];
 
         cost = Double.POSITIVE_INFINITY;
@@ -330,12 +335,12 @@
 
     /** Perform the bulk of optimization algorithm.
      * @return the point/value pair giving the optimal value for objective function
-     * @exception ObjectiveException if the objective function throws one during
+     * @exception FunctionEvaluationException if the objective function throws one during
      * the search
      * @exception OptimizationException if the algorithm failed to converge
      * @exception IllegalArgumentException if the start point dimension is wrong
      */
     abstract protected VectorialPointValuePair doOptimize()
-        throws ObjectiveException, OptimizationException, IllegalArgumentException;
+        throws FunctionEvaluationException, OptimizationException, IllegalArgumentException;
 
 }
\ No newline at end of file

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java?rev=758058&r1=758057&r2=758058&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java (original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java Tue Mar 24 22:15:08 2009
@@ -17,13 +17,13 @@
 
 package org.apache.commons.math.optimization.general;
 
+import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.linear.DenseRealMatrix;
 import org.apache.commons.math.linear.InvalidMatrixException;
 import org.apache.commons.math.linear.RealMatrix;
 import org.apache.commons.math.linear.decomposition.DecompositionSolver;
 import org.apache.commons.math.linear.decomposition.LUDecompositionImpl;
 import org.apache.commons.math.linear.decomposition.QRDecompositionImpl;
-import org.apache.commons.math.optimization.ObjectiveException;
 import org.apache.commons.math.optimization.OptimizationException;
 import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
@@ -63,7 +63,7 @@
 
     /** {@inheritDoc} */
     public VectorialPointValuePair doOptimize()
-        throws ObjectiveException, OptimizationException, IllegalArgumentException {
+        throws FunctionEvaluationException, OptimizationException, IllegalArgumentException {
 
         // iterate until convergence is reached
         VectorialPointValuePair current = null;
@@ -75,7 +75,7 @@
             VectorialPointValuePair previous = current;
             updateResidualsAndCost();
             updateJacobian();
-            current = new VectorialPointValuePair(variables, objective);
+            current = new VectorialPointValuePair(point, objective);
 
             // build the linear problem
             final double[]   b = new double[cols];
@@ -114,7 +114,7 @@
 
                 // update the estimated parameters
                 for (int i = 0; i < cols; ++i) {
-                    variables[i] += dX[i];
+                    point[i] += dX[i];
                 }
 
             } catch(InvalidMatrixException e) {

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizer.java?rev=758058&r1=758057&r2=758058&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizer.java (original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizer.java Tue Mar 24 22:15:08 2009
@@ -18,7 +18,7 @@
 
 import java.util.Arrays;
 
-import org.apache.commons.math.optimization.ObjectiveException;
+import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.optimization.OptimizationException;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
 
@@ -27,8 +27,8 @@
  * This class solves a least squares problem using the Levenberg-Marquardt algorithm.
  *
  * <p>This implementation <em>should</em> work even for over-determined systems
- * (i.e. systems having more variables than equations). Over-determined systems
- * are solved by ignoring the variables which have the smallest impact according
+ * (i.e. systems having more point than equations). Over-determined systems
+ * are solved by ignoring the point which have the smallest impact according
  * to their jacobian column norm. Only the rank of the matrix and some loop bounds
  * are changed to implement this.</p>
  *
@@ -104,7 +104,7 @@
     /** Serializable version identifier */
     private static final long serialVersionUID = 8851282236194244323L;
 
-    /** Number of solved variables. */
+    /** Number of solved point. */
     private int solvedCols;
 
     /** Diagonal elements of the R matrix in the Q.R. decomposition. */
@@ -210,7 +210,7 @@
 
     /** {@inheritDoc} */
     protected VectorialPointValuePair doOptimize()
-        throws ObjectiveException, OptimizationException, IllegalArgumentException {
+        throws FunctionEvaluationException, OptimizationException, IllegalArgumentException {
 
         // arrays shared with the other private methods
         solvedCols  = Math.min(rows, cols);
@@ -220,7 +220,7 @@
         permutation = new int[cols];
         lmDir       = new double[cols];
 
-        // local variables
+        // local point
         double   delta   = 0, xNorm = 0;
         double[] diag    = new double[cols];
         double[] oldX    = new double[cols];
@@ -255,7 +255,7 @@
 
             if (firstIteration) {
 
-                // scale the variables according to the norms of the columns
+                // scale the point according to the norms of the columns
                 // of the initial jacobian
                 xNorm = 0;
                 for (int k = 0; k < cols; ++k) {
@@ -263,7 +263,7 @@
                     if (dk == 0) {
                         dk = 1.0;
                     }
-                    double xk = dk * variables[k];
+                    double xk = dk * point[k];
                     xNorm  += xk * xk;
                     diag[k] = dk;
                 }
@@ -291,7 +291,7 @@
             }
             if (maxCosine <= orthoTolerance) {
                 // convergence has been reached
-                return new VectorialPointValuePair(variables, objective);
+                return new VectorialPointValuePair(point, objective);
             }
 
             // rescale if necessary
@@ -305,7 +305,7 @@
                 // save the state
                 for (int j = 0; j < solvedCols; ++j) {
                     int pj = permutation[j];
-                    oldX[pj] = variables[pj];
+                    oldX[pj] = point[pj];
                 }
                 double previousCost = cost;
                 double[] tmpVec = residuals;
@@ -320,7 +320,7 @@
                 for (int j = 0; j < solvedCols; ++j) {
                     int pj = permutation[j];
                     lmDir[pj] = -lmDir[pj];
-                    variables[pj] = oldX[pj] + lmDir[pj];
+                    point[pj] = oldX[pj] + lmDir[pj];
                     double s = diag[pj] * lmDir[pj];
                     lmNorm  += s * s;
                 }
@@ -384,7 +384,7 @@
                     firstIteration = false;
                     xNorm = 0;
                     for (int k = 0; k < cols; ++k) {
-                        double xK = diag[k] * variables[k];
+                        double xK = diag[k] * point[k];
                         xNorm    += xK * xK;
                     }
                     xNorm = Math.sqrt(xNorm);
@@ -393,7 +393,7 @@
                     cost = previousCost;
                     for (int j = 0; j < solvedCols; ++j) {
                         int pj = permutation[j];
-                        variables[pj] = oldX[pj];
+                        point[pj] = oldX[pj];
                     }
                     tmpVec    = residuals;
                     residuals = oldRes;
@@ -405,7 +405,7 @@
                         (preRed <= costRelativeTolerance) &&
                         (ratio <= 2.0)) ||
                         (delta <= parRelativeTolerance * xNorm)) {
-                    return new VectorialPointValuePair(variables, objective);
+                    return new VectorialPointValuePair(point, objective);
                 }
 
                 // tests for termination and stringent tolerances

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java?rev=758058&r1=758057&r2=758058&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java (original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java Tue Mar 24 22:15:08 2009
@@ -25,12 +25,14 @@
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+import org.apache.commons.math.FunctionEvaluationException;
+import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
+import org.apache.commons.math.analysis.MultivariateMatrixFunction;
+import org.apache.commons.math.analysis.MultivariateVectorialFunction;
 import org.apache.commons.math.linear.DenseRealMatrix;
 import org.apache.commons.math.linear.RealMatrix;
-import org.apache.commons.math.optimization.ObjectiveException;
 import org.apache.commons.math.optimization.OptimizationException;
 import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
-import org.apache.commons.math.optimization.VectorialDifferentiableObjectiveFunction;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
 
 /**
@@ -102,7 +104,7 @@
         super(name);
     }
 
-    public void testTrivial() throws ObjectiveException, OptimizationException {
+    public void testTrivial() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem =
             new LinearProblem(new double[][] { { 2 } }, new double[] { 3 });
         GaussNewtonOptimizer optimizer = new GaussNewtonOptimizer(true);
@@ -115,7 +117,7 @@
         assertEquals(3.0, optimum.getValue()[0], 1.0e-10);
     }
 
-    public void testColumnsPermutation() throws ObjectiveException, OptimizationException {
+    public void testColumnsPermutation() throws FunctionEvaluationException, OptimizationException {
 
         LinearProblem problem =
             new LinearProblem(new double[][] { { 1.0, -1.0 }, { 0.0, 2.0 }, { 1.0, -2.0 } },
@@ -135,7 +137,7 @@
 
     }
 
-    public void testNoDependency() throws ObjectiveException, OptimizationException {
+    public void testNoDependency() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 2, 0, 0, 0, 0, 0 },
                 { 0, 2, 0, 0, 0, 0 },
@@ -156,7 +158,7 @@
         }
     }
 
-    public void testOneSet() throws ObjectiveException, OptimizationException {
+    public void testOneSet() throws FunctionEvaluationException, OptimizationException {
 
         LinearProblem problem = new LinearProblem(new double[][] {
                 {  1,  0, 0 },
@@ -175,7 +177,7 @@
 
     }
 
-    public void testTwoSets() throws ObjectiveException, OptimizationException {
+    public void testTwoSets() throws FunctionEvaluationException, OptimizationException {
         double epsilon = 1.0e-7;
         LinearProblem problem = new LinearProblem(new double[][] {
                 {  2,  1,   0,  4,       0, 0 },
@@ -222,7 +224,7 @@
         }
     }
 
-    public void testIllConditioned() throws ObjectiveException, OptimizationException {
+    public void testIllConditioned() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem1 = new LinearProblem(new double[][] {
                 { 10.0, 7.0,  8.0,  7.0 },
                 {  7.0, 5.0,  6.0,  5.0 },
@@ -303,7 +305,7 @@
         }
     }
 
-    public void testRedundantEquations() throws ObjectiveException, OptimizationException {
+    public void testRedundantEquations() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 1.0,  1.0 },
                 { 1.0, -1.0 },
@@ -322,7 +324,7 @@
 
     }
 
-    public void testInconsistentEquations() throws ObjectiveException, OptimizationException {
+    public void testInconsistentEquations() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 1.0,  1.0 },
                 { 1.0, -1.0 },
@@ -337,7 +339,7 @@
 
     }
 
-    public void testInconsistentSizes() throws ObjectiveException, OptimizationException {
+    public void testInconsistentSizes() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem =
             new LinearProblem(new double[][] { { 1, 0 }, { 0, 1 } }, new double[] { -1, 1 });
         GaussNewtonOptimizer optimizer = new GaussNewtonOptimizer(true);
@@ -366,7 +368,7 @@
                                new double[] { 1 },
                                new double[] { 0, 0 });
             fail("an exception should have been thrown");
-        } catch (ObjectiveException oe) {
+        } catch (FunctionEvaluationException oe) {
             // expected behavior
         } catch (Exception e) {
             fail("wrong exception caught");
@@ -396,7 +398,7 @@
         }
     }
 
-    public void testCircleFitting() throws ObjectiveException, OptimizationException {
+    public void testCircleFitting() throws FunctionEvaluationException, OptimizationException {
         Circle circle = new Circle();
         circle.addPoint( 30.0,  68.0);
         circle.addPoint( 50.0,  -6.0);
@@ -417,7 +419,7 @@
         assertEquals(48.135167894714,   center.y, 1.0e-10);
     }
 
-    public void testCircleFittingBadInit() throws ObjectiveException, OptimizationException {
+    public void testCircleFittingBadInit() throws FunctionEvaluationException, OptimizationException {
         Circle circle = new Circle();
         double[][] points = new double[][] {
                 {-0.312967,  0.072366}, {-0.339248,  0.132965}, {-0.379780,  0.202724},
@@ -477,9 +479,9 @@
 
     }
 
-    private static class LinearProblem implements VectorialDifferentiableObjectiveFunction {
+    private static class LinearProblem implements DifferentiableMultivariateVectorialFunction {
 
-        private static final long serialVersionUID = 703247177355019415L;
+        private static final long serialVersionUID = -8804268799379350190L;
         final RealMatrix factors;
         final double[] target;
         public LinearProblem(double[][] factors, double[] target) {
@@ -487,20 +489,42 @@
             this.target  = target;
         }
 
-        public double[][] jacobian(double[] variables, double[] value) {
-            return factors.getData();
+        public double[] value(double[] variables) {
+            return factors.operate(variables);
         }
 
-        public double[] objective(double[] variables) {
-            return factors.operate(variables);
+        public MultivariateVectorialFunction partialDerivative(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = 1037082026387842358L;
+                public double[] value(double[] point) {
+                    return factors.getColumn(i);
+                }
+            };
         }
 
-    }
+        public MultivariateVectorialFunction gradient(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = -3268626996728727146L;
+                public double[] value(double[] point) {
+                    return factors.getRow(i);
+                }
+            };
+        }
 
-    private static class Circle implements VectorialDifferentiableObjectiveFunction {
+        public MultivariateMatrixFunction jacobian() {
+            return new MultivariateMatrixFunction() {
+                private static final long serialVersionUID = -8387467946663627585L;
+                public double[][] value(double[] point) {
+                    return factors.getData();
+                }
+            };
+        }
 
-        private static final long serialVersionUID = -4711170319243817874L;
+    }
+
+    private static class Circle implements DifferentiableMultivariateVectorialFunction {
 
+        private static final long serialVersionUID = -7165774454925027042L;
         private ArrayList<Point2D.Double> points;
 
         public Circle() {
@@ -523,8 +547,7 @@
             return r / points.size();
         }
 
-        public double[][] jacobian(double[] variables, double[] value)
-                throws ObjectiveException, IllegalArgumentException {
+        private double[][] jacobian(double[] variables) {
 
             int n = points.size();
             Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
@@ -553,8 +576,7 @@
 
         }
 
-        public double[] objective(double[] variables)
-                throws ObjectiveException, IllegalArgumentException {
+        public double[] value(double[] variables) {
 
             Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
             double radius = getRadius(center);
@@ -568,6 +590,38 @@
 
         }
 
+        public MultivariateVectorialFunction partialDerivative(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = -2884159755283203273L;
+                public double[] value(double[] point) {
+                    double[][] m = jacobian(point);
+                    double[] partial = new double[m.length];
+                    for (int j = 0; j < partial.length; ++j) {
+                        partial[i] = m[i][j];
+                    }
+                    return partial;
+                }
+            };
+        }
+
+        public MultivariateVectorialFunction gradient(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = -43357217231860547L;
+                public double[] value(double[] point) {
+                    return jacobian(point)[i];
+                }
+            };
+        }
+
+        public MultivariateMatrixFunction jacobian() {
+            return new MultivariateMatrixFunction() {
+                private static final long serialVersionUID = -4340046230875165095L;
+                public double[][] value(double[] point) {
+                    return jacobian(point);
+                }
+            };
+        }
+
     }
 
     public static Test suite() {

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java?rev=758058&r1=758057&r2=758058&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java (original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java Tue Mar 24 22:15:08 2009
@@ -26,12 +26,14 @@
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+import org.apache.commons.math.FunctionEvaluationException;
+import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
+import org.apache.commons.math.analysis.MultivariateMatrixFunction;
+import org.apache.commons.math.analysis.MultivariateVectorialFunction;
 import org.apache.commons.math.linear.DenseRealMatrix;
 import org.apache.commons.math.linear.RealMatrix;
-import org.apache.commons.math.optimization.ObjectiveException;
 import org.apache.commons.math.optimization.OptimizationException;
 import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
-import org.apache.commons.math.optimization.VectorialDifferentiableObjectiveFunction;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
 
 /**
@@ -103,7 +105,7 @@
         super(name);
     }
 
-    public void testTrivial() throws ObjectiveException, OptimizationException {
+    public void testTrivial() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem =
             new LinearProblem(new double[][] { { 2 } }, new double[] { 3 });
         LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();
@@ -122,7 +124,7 @@
         assertEquals(3.0, optimum.getValue()[0], 1.0e-10);
     }
 
-    public void testQRColumnsPermutation() throws ObjectiveException, OptimizationException {
+    public void testQRColumnsPermutation() throws FunctionEvaluationException, OptimizationException {
 
         LinearProblem problem =
             new LinearProblem(new double[][] { { 1.0, -1.0 }, { 0.0, 2.0 }, { 1.0, -2.0 } },
@@ -140,7 +142,7 @@
 
     }
 
-    public void testNoDependency() throws ObjectiveException, OptimizationException {
+    public void testNoDependency() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 2, 0, 0, 0, 0, 0 },
                 { 0, 2, 0, 0, 0, 0 },
@@ -159,7 +161,7 @@
         }
     }
 
-    public void testOneSet() throws ObjectiveException, OptimizationException {
+    public void testOneSet() throws FunctionEvaluationException, OptimizationException {
 
         LinearProblem problem = new LinearProblem(new double[][] {
                 {  1,  0, 0 },
@@ -176,7 +178,7 @@
 
     }
 
-    public void testTwoSets() throws ObjectiveException, OptimizationException {
+    public void testTwoSets() throws FunctionEvaluationException, OptimizationException {
         double epsilon = 1.0e-7;
         LinearProblem problem = new LinearProblem(new double[][] {
                 {  2,  1,   0,  4,       0, 0 },
@@ -201,7 +203,7 @@
 
     }
 
-    public void testNonInversible() throws ObjectiveException, OptimizationException {
+    public void testNonInversible() throws FunctionEvaluationException, OptimizationException {
 
         LinearProblem problem = new LinearProblem(new double[][] {
                 {  1, 2, -3 },
@@ -223,7 +225,7 @@
 
     }
 
-    public void testIllConditioned() throws ObjectiveException, OptimizationException {
+    public void testIllConditioned() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem1 = new LinearProblem(new double[][] {
                 { 10.0, 7.0,  8.0,  7.0 },
                 {  7.0, 5.0,  6.0,  5.0 },
@@ -257,7 +259,7 @@
 
     }
 
-    public void testMoreEstimatedParametersSimple() throws ObjectiveException, OptimizationException {
+    public void testMoreEstimatedParametersSimple() throws FunctionEvaluationException, OptimizationException {
 
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 3.0, 2.0,  0.0, 0.0 },
@@ -272,7 +274,7 @@
 
     }
 
-    public void testMoreEstimatedParametersUnsorted() throws ObjectiveException, OptimizationException {
+    public void testMoreEstimatedParametersUnsorted() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 1.0, 1.0,  0.0,  0.0, 0.0,  0.0 },
                 { 0.0, 0.0,  1.0,  1.0, 1.0,  0.0 },
@@ -293,7 +295,7 @@
 
     }
 
-    public void testRedundantEquations() throws ObjectiveException, OptimizationException {
+    public void testRedundantEquations() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 1.0,  1.0 },
                 { 1.0, -1.0 },
@@ -310,7 +312,7 @@
 
     }
 
-    public void testInconsistentEquations() throws ObjectiveException, OptimizationException {
+    public void testInconsistentEquations() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem = new LinearProblem(new double[][] {
                 { 1.0,  1.0 },
                 { 1.0, -1.0 },
@@ -323,7 +325,7 @@
 
     }
 
-    public void testInconsistentSizes() throws ObjectiveException, OptimizationException {
+    public void testInconsistentSizes() throws FunctionEvaluationException, OptimizationException {
         LinearProblem problem =
             new LinearProblem(new double[][] { { 1, 0 }, { 0, 1 } }, new double[] { -1, 1 });
         LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();
@@ -350,7 +352,7 @@
                                new double[] { 1 },
                                new double[] { 0, 0 });
             fail("an exception should have been thrown");
-        } catch (ObjectiveException oe) {
+        } catch (FunctionEvaluationException oe) {
             // expected behavior
         } catch (Exception e) {
             fail("wrong exception caught");
@@ -372,7 +374,7 @@
         checkEstimate(circle, 0.1, 20, 1.0e-18, 1.0e-16, 1.0e-10, true);
     }
 
-    private void checkEstimate(VectorialDifferentiableObjectiveFunction problem,
+    private void checkEstimate(DifferentiableMultivariateVectorialFunction problem,
                                double initialStepBoundFactor, int maxCostEval,
                                double costRelativeTolerance, double parRelativeTolerance,
                                double orthoTolerance, boolean shouldFail) {
@@ -388,14 +390,14 @@
             assertTrue(! shouldFail);
         } catch (OptimizationException ee) {
             assertTrue(shouldFail);
-        } catch (ObjectiveException ee) {
+        } catch (FunctionEvaluationException ee) {
             assertTrue(shouldFail);
         } catch (Exception e) {
             fail("wrong exception type caught");
         }
     }
 
-    public void testCircleFitting() throws ObjectiveException, OptimizationException {
+    public void testCircleFitting() throws FunctionEvaluationException, OptimizationException {
         Circle circle = new Circle();
         circle.addPoint( 30.0,  68.0);
         circle.addPoint( 50.0,  -6.0);
@@ -445,7 +447,7 @@
 
     }
 
-    public void testCircleFittingBadInit() throws ObjectiveException, OptimizationException {
+    public void testCircleFittingBadInit() throws FunctionEvaluationException, OptimizationException {
         Circle circle = new Circle();
         double[][] points = new double[][] {
                 {-0.312967,  0.072366}, {-0.339248,  0.132965}, {-0.379780,  0.202724},
@@ -498,7 +500,7 @@
         assertEquals( 0.2075001, center.y,      1.0e-6);
     }
 
-    public void testMath199() throws ObjectiveException, OptimizationException {
+    public void testMath199() throws FunctionEvaluationException, OptimizationException {
         try {
             QuadraticProblem problem = new QuadraticProblem();
             problem.addPoint (0, -3.182591015485607);
@@ -517,7 +519,7 @@
 
     }
 
-    private static class LinearProblem implements VectorialDifferentiableObjectiveFunction {
+    private static class LinearProblem implements DifferentiableMultivariateVectorialFunction {
 
         private static final long serialVersionUID = 703247177355019415L;
         final RealMatrix factors;
@@ -527,17 +529,40 @@
             this.target  = target;
         }
 
-        public double[][] jacobian(double[] variables, double[] value) {
-            return factors.getData();
+        public double[] value(double[] variables) {
+            return factors.operate(variables);
         }
 
-        public double[] objective(double[] variables) {
-            return factors.operate(variables);
+        public MultivariateVectorialFunction partialDerivative(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = 4868131119285501303L;
+                public double[] value(double[] point) {
+                    return factors.getColumn(i);
+                }
+            };
+        }
+
+        public MultivariateVectorialFunction gradient(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = 6280336674474631774L;
+                public double[] value(double[] point) {
+                    return factors.getRow(i);
+                }
+            };
+        }
+
+        public MultivariateMatrixFunction jacobian() {
+            return new MultivariateMatrixFunction() {
+                private static final long serialVersionUID = 556396458721526234L;
+                public double[][] value(double[] point) {
+                    return factors.getData();
+                }
+            };
         }
 
     }
 
-    private static class Circle implements VectorialDifferentiableObjectiveFunction {
+    private static class Circle implements DifferentiableMultivariateVectorialFunction {
 
         private static final long serialVersionUID = -4711170319243817874L;
 
@@ -563,11 +588,10 @@
             return r / points.size();
         }
 
-        public double[][] jacobian(double[] variables, double[] value)
-        throws ObjectiveException, IllegalArgumentException {
+        private double[][] jacobian(double[] point) {
 
             int n = points.size();
-            Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
+            Point2D.Double center = new Point2D.Double(point[0], point[1]);
 
             // gradient of the optimal radius
             double dRdX = 0;
@@ -593,8 +617,8 @@
 
         }
 
-        public double[] objective(double[] variables)
-        throws ObjectiveException, IllegalArgumentException {
+        public double[] value(double[] variables)
+        throws FunctionEvaluationException, IllegalArgumentException {
 
             Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
             double radius = getRadius(center);
@@ -608,11 +632,43 @@
 
         }
 
+        public MultivariateVectorialFunction partialDerivative(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = -2884159755283203273L;
+                public double[] value(double[] point) {
+                    double[][] m = jacobian(point);
+                    double[] partial = new double[m.length];
+                    for (int j = 0; j < partial.length; ++j) {
+                        partial[i] = m[i][j];
+                    }
+                    return partial;
+                }
+            };
+        }
+
+        public MultivariateVectorialFunction gradient(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = -43357217231860547L;
+                public double[] value(double[] point) {
+                    return jacobian(point)[i];
+                }
+            };
+        }
+
+        public MultivariateMatrixFunction jacobian() {
+            return new MultivariateMatrixFunction() {
+                private static final long serialVersionUID = -4340046230875165095L;
+                public double[][] value(double[] point) {
+                    return jacobian(point);
+                }
+            };
+        }
+
     }
 
-    private static class QuadraticProblem implements VectorialDifferentiableObjectiveFunction {
+    private static class QuadraticProblem implements DifferentiableMultivariateVectorialFunction {
 
-        private static final long serialVersionUID = -247096133023967957L;
+        private static final long serialVersionUID = 7072187082052755854L;
         private List<Double> x;
         private List<Double> y;
 
@@ -626,7 +682,7 @@
             this.y.add(y);
         }
 
-        public double[][] jacobian(double[] variables, double[] value) {
+        private double[][] jacobian(double[] variables) {
             double[][] jacobian = new double[x.size()][3];
             for (int i = 0; i < jacobian.length; ++i) {
                 jacobian[i][0] = x.get(i) * x.get(i);
@@ -636,7 +692,7 @@
             return jacobian;
         }
 
-        public double[] objective(double[] variables) {
+        public double[] value(double[] variables) {
             double[] values = new double[x.size()];
             for (int i = 0; i < values.length; ++i) {
                 values[i] = (variables[0] * x.get(i) + variables[1]) * x.get(i) + variables[2];
@@ -644,6 +700,38 @@
             return values;
         }
 
+        public MultivariateVectorialFunction partialDerivative(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = 2371658898687841192L;
+                public double[] value(double[] point) {
+                    double[][] m = jacobian(point);
+                    double[] partial = new double[m.length];
+                    for (int j = 0; j < partial.length; ++j) {
+                        partial[i] = m[i][j];
+                    }
+                    return partial;
+                }
+            };
+        }
+
+        public MultivariateVectorialFunction gradient(final int i) {
+            return new MultivariateVectorialFunction() {
+                private static final long serialVersionUID = 6863958501785879369L;
+                public double[] value(double[] point) {
+                    return jacobian(point)[i];
+                }
+            };
+        }
+
+        public MultivariateMatrixFunction jacobian() {
+            return new MultivariateMatrixFunction() {
+                private static final long serialVersionUID = -8673650298627399464L;
+                public double[][] value(double[] point) {
+                    return jacobian(point);
+                }
+            };
+        }
+
     }
 
     public static Test suite() {

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=758058&r1=758057&r2=758058&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 Tue Mar 24 22:15:08 2009
@@ -19,14 +19,17 @@
 
 import java.util.Arrays;
 
-import org.apache.commons.math.optimization.ObjectiveException;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.apache.commons.math.FunctionEvaluationException;
+import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
+import org.apache.commons.math.analysis.MultivariateMatrixFunction;
+import org.apache.commons.math.analysis.MultivariateVectorialFunction;
 import org.apache.commons.math.optimization.OptimizationException;
-import org.apache.commons.math.optimization.VectorialDifferentiableObjectiveFunction;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
 
-
-import junit.framework.*;
-
 /**
  * <p>Some of the unit tests are re-implementations of the MINPACK <a
  * href="http://www.netlib.org/minpack/ex/file17">file17</a> and <a
@@ -520,13 +523,13 @@
           assertTrue(function.checkTheoreticalMinParams(optimum));
       } catch (OptimizationException lsse) {
           assertTrue(exceptionExpected);
-      } catch (ObjectiveException oe) {
+      } catch (FunctionEvaluationException fe) {
           assertTrue(exceptionExpected);
       }
   }
 
   private static abstract class MinpackFunction
-      implements VectorialDifferentiableObjectiveFunction {
+      implements DifferentiableMultivariateVectorialFunction {
  
       private static final long serialVersionUID = -6209760235478794233L;
       protected int      n;
@@ -597,9 +600,41 @@
           return true;
       }
 
-      public abstract double[][] jacobian(double[] variables, double[] value);
+      public MultivariateVectorialFunction partialDerivative(final int i) {
+          return new MultivariateVectorialFunction() {
+            private static final long serialVersionUID = 2192585229396907068L;
+            public double[] value(double[] point) {
+                  double[][] m = jacobian(point);
+                  double[] partial = new double[m.length];
+                  for (int j = 0; j < partial.length; ++j) {
+                      partial[i] = m[i][j];
+                  }
+                  return partial;
+              }
+          };
+      }
+
+      public MultivariateVectorialFunction gradient(final int i) {
+          return new MultivariateVectorialFunction() {
+            private static final long serialVersionUID = -5562016064510078300L;
+            public double[] value(double[] point) {
+                  return jacobian(point)[i];
+              }
+          };
+      }
+
+      public MultivariateMatrixFunction jacobian() {
+          return new MultivariateMatrixFunction() {
+            private static final long serialVersionUID = -2435076097232923678L;
+            public double[][] value(double[] point) {
+                  return jacobian(point);
+              }
+          };
+      }
+
+      public abstract double[][] jacobian(double[] variables);
 
-      public abstract double[] objective(double[] variables);
+      public abstract double[] value(double[] variables);
 
   }
 
@@ -614,7 +649,7 @@
             buildArray(n, -1.0));
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double t = 2.0 / m;
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
@@ -626,7 +661,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double sum = 0;
       for (int i = 0; i < n; ++i) {
         sum += variables[i];
@@ -652,7 +687,7 @@
       super(m, buildArray(n, x0), theoreticalMinCost, null);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         jacobian[i] = new double[n];
@@ -663,7 +698,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double[] f = new double[m];
       double sum = 0;
       for (int i = 0; i < n; ++i) {
@@ -687,7 +722,7 @@
             null);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         jacobian[i] = new double[n];
@@ -706,7 +741,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double[] f = new double[m];
       double sum = 0;
       for (int i = 1; i < (n - 1); ++i) {
@@ -729,12 +764,12 @@
       super(2, startParams, 0.0, buildArray(2, 1.0));
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double x1 = variables[0];
       return new double[][] { { -20 * x1, 10 }, { -1, 0 } };
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       return new double[] { 10 * (x2 - x1 * x1), 1 - x1 };
@@ -751,7 +786,7 @@
       super(3, startParams, 0.0, new double[] { 1.0, 0.0, 0.0 });
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double tmpSquare = x1 * x1 + x2 * x2;
@@ -764,7 +799,7 @@
       };
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -798,7 +833,7 @@
       super(4, startParams, 0.0, buildArray(4, 0.0));
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -811,7 +846,7 @@
       };
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -841,7 +876,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double x2 = variables[1];
       return new double[][] {
         { 1, x2 * (10 - 3 * x2) -  2 },
@@ -849,7 +884,7 @@
       };
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       return new double[] {
@@ -872,7 +907,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x2 = variables[1];
       double   x3 = variables[2];
       double[][] jacobian = new double[m][];
@@ -887,7 +922,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double   x1 = variables[0];
       double   x2 = variables[1];
       double   x3 = variables[2];
@@ -925,7 +960,7 @@
       }
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x1 = variables[0];
       double   x2 = variables[1];
       double   x3 = variables[2];
@@ -942,7 +977,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -981,7 +1016,7 @@
       }
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x1 = variables[0];
       double   x2 = variables[1];
       double   x3 = variables[2];
@@ -996,7 +1031,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -1028,7 +1063,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
 
       double[][] jacobian = new double[m][];
 
@@ -1060,7 +1095,7 @@
 
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
      double[] f = new double[m];
      for (int i = 0; i < (m - 2); ++i) {
        double div = (i + 1) / 29.0;
@@ -1100,7 +1135,7 @@
             new double[] { 1.0, 10.0, 1.0 });
    }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x1 = variables[0];
       double   x2 = variables[1];
       double[][] jacobian = new double[m][];
@@ -1115,7 +1150,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -1142,7 +1177,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x1 = variables[0];
       double   x2 = variables[1];
       double[][] jacobian = new double[m][];
@@ -1153,7 +1188,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double[] f = new double[m];
@@ -1178,7 +1213,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x1 = variables[0];
       double   x2 = variables[1];
       double   x3 = variables[2];
@@ -1196,7 +1231,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -1234,7 +1269,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
 
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
@@ -1263,7 +1298,7 @@
 
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
 
       double[] f = new double[m];
 
@@ -1307,7 +1342,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double[][] jacobian = new double[m][];
       for (int i = 0; i < m; ++i) {
         jacobian[i] = new double[n];
@@ -1340,7 +1375,7 @@
 
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double[] f = new double[m];
       double sum  = -(n + 1);
       double prod = 1;
@@ -1369,7 +1404,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x2 = variables[1];
       double   x3 = variables[2];
       double   x4 = variables[3];
@@ -1386,7 +1421,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x1 = variables[0];
       double x2 = variables[1];
       double x3 = variables[2];
@@ -1422,7 +1457,7 @@
             theoreticalMinParams);
     }
 
-    public double[][] jacobian(double[] variables, double[] value) {
+    public double[][] jacobian(double[] variables) {
       double   x01 = variables[0];
       double   x02 = variables[1];
       double   x03 = variables[2];
@@ -1458,7 +1493,7 @@
       return jacobian;
     }
 
-    public double[] objective(double[] variables) {
+    public double[] value(double[] variables) {
       double x01 = variables[0];
       double x02 = variables[1];
       double x03 = variables[2];



Mime
View raw message