import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
/**
 * @return the model function values.
 */
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            /** {@inheritDoc} */
            public double[] value(double[] point) {
                // compute the residuals
                final double[] values = new double[observations.size()];
                int i = 0;
                for (WeightedObservedPoint observed : observations) {
                    values[i++] = f.value(observed.getX(), point);
                }

                return values;
            }
        });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
protected Molecule fit(ILsqFunctions functions) {
    // init
    double[] weights = functions.calcWeights(useWeighting);
    double[] observations = functions.getObservations();

    // fit
    LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer(
            new SimplePointChecker<PointVectorValuePair>(10e-10, 10e-10, maxIter));

    PointVectorValuePair pv;
    pv = optimizer.optimize(
            MaxEval.unlimited(),
            new MaxIter(MAX_ITERATIONS + 1),
            new ModelFunction(functions.getValueFunction()),
            new ModelFunctionJacobian(functions.getJacobianFunction()),
            new Target(observations),
            new InitialGuess(psfModel.transformParametersInverse(functions.getInitialParams())),
            new Weight(weights));

    // estimate background and return an instance of the `Molecule`
    fittedParameters = pv.getPointRef();
    if (bkgStdColumn >= 0) {
        fittedParameters[bkgStdColumn] = VectorMath.stddev(sub(observations, functions.getValueFunction().value(fittedParameters)));
    }
    return psfModel.newInstanceFromParams(psfModel.transformParameters(fittedParameters), functions.getImageUnits(), true);
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            public double[] value(double[] params) {
                double[] values = new double[time.size()];
                for (int i = 0; i < values.length; ++i) {
                    final double t = time.get(i);
                    values[i] = params[0] +
                        params[1] * FastMath.exp(-t / params[3]) +
                        params[2] * FastMath.exp(-t / params[4]);
                }
                return values;
            }
        });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            public double[] value(double[] params) {
                return factors.operate(params);
            }
        });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            public double[] value(double[] params) {
                Vector2D center = new Vector2D(params[0], params[1]);
                double radius = getRadius(center);
                double[] residuals = new double[points.size()];
                for (int i = 0; i < residuals.length; i++) {
                    residuals[i] = points.get(i).distance(center) - radius;
                }

                return residuals;
            }
    });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            public double[] value(double[] params) {
                final Model line = new Model(params[0], params[1]);

                final double[] model = new double[points.size()];
                for (int i = 0; i < points.size(); i++) {
                    final double[] p = points.get(i);
                    model[i] = line.value(p[0]);
                }

                return model;
            }
        });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            public double[] value(double[] point) {
                return computeValue(point);
            }
        });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            public double[] value(final double[] a) {
                final int n = getNumObservations();
                final double[] yhat = new double[n];
                for (int i = 0; i < n; i++) {
                    yhat[i] = getModelValue(getX(i), a);
                }
                return yhat;
            }
        });
}
 

import org.apache.commons.math3.optim.nonlinear.vector.ModelFunction; //导入依赖的package包/类
public ModelFunction getModelFunction() {
    return new ModelFunction(new MultivariateVectorFunction() {
            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];
                }
                return values;
            }
        });
}