import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> points) {
    final int len = points.size();
    final double[] target  = new double[len];
    final double[] weights = new double[len];
    final double[] initialGuess = { 1.0, 1.0 };

    int i = 0;
    for(WeightedObservedPoint point : points) {
        target[i]  = point.getY();
        weights[i] = point.getWeight();
        i += 1;
    }

    AbstractCurveFitter.TheoreticalValuesFunction model = new AbstractCurveFitter.TheoreticalValuesFunction(func, points);

    return new LeastSquaresBuilder().
        maxEvaluations(Integer.MAX_VALUE).
        maxIterations(Integer.MAX_VALUE).
        start(initialGuess).
        target(target).
        weight(new DiagonalMatrix(weights)).
        model(model.getModelFunction(), model.getModelFunctionJacobian()).
        build();
}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
private LeastSquaresBuilder createLeastSquaresBuilder(List<Double> startValues, int maxIterations) {
	LeastSquaresBuilder builder = new LeastSquaresBuilder()
			.model(optimizerFunction, optimizerFunction.createJacobian()).maxEvaluations(Integer.MAX_VALUE)
			.maxIterations(maxIterations).target(Doubles.toArray(targetValues)).start(Doubles.toArray(startValues));

	if (!minValues.isEmpty() || !maxValues.isEmpty()) {
		builder.parameterValidator(params -> {

			for (int i = 0; i < parameters.size(); i++) {
				double value = params.getEntry(i);
				Double min = minValues.get(parameters.get(i));
				Double max = maxValues.get(parameters.get(i));

				if (min != null && value < min) {
					value = min;
				}

				if (max != null && value > max) {
					value = max;
				}

				params.setEntry(i, value);
			}

			return params;
		});
	}

	return builder;
}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
/**
     * Builder least squares builder.
     *
     * @param problem the problem
     *
     * @return the least squares builder
     */
    public LeastSquaresBuilder builder(CircleProblem problem) {
        return new LeastSquaresBuilder()
//                .checkerPair(new SimpleVectorValueChecker(1e-6, 1e-6))
                .maxEvaluations(100)
                .maxIterations(getMaxIterations())
                .model(problem.getModelFunction(), problem.getModelFunctionJacobian())
                .target(problem.target());
//                .weight(new DiagonalMatrix(problem.weight()));  不涉及权重的问题
    }
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> observations) {
    // Prepare least-squares problem.
    final int len = observations.size();
    final double[] target  = new double[len];
    final double[] weights = new double[len];

    int i = 0;
    for (WeightedObservedPoint obs : observations) {
        target[i]  = obs.getY();
        weights[i] = obs.getWeight();
        ++i;
    }

    final AbstractCurveFitter.TheoreticalValuesFunction model =
            new AbstractCurveFitter.TheoreticalValuesFunction(FUNCTION, observations);

    if (initialGuess == null) {
        throw new MathInternalError();
    }

    // Return a new least squares problem set up to fit a polynomial curve to the
    // observed points.
    return new LeastSquaresBuilder().
            maxEvaluations(Integer.MAX_VALUE).
            maxIterations(maxIter).
            start(initialGuess).
            target(target).
            weight(new DiagonalMatrix(weights)).
            model(model.getModelFunction(), model.getModelFunctionJacobian()).
            build();

}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> observations) {

    // Prepare least-squares problem.
    final int len = observations.size();
    final double[] target  = new double[len];
    final double[] weights = new double[len];

    int i = 0;
    for (WeightedObservedPoint obs : observations) {
        target[i]  = obs.getY();
        weights[i] = obs.getWeight();
        ++i;
    }

    final AbstractCurveFitter.TheoreticalValuesFunction model =
            new AbstractCurveFitter.TheoreticalValuesFunction(FUNCTION, observations);

    final double[] startPoint = initialGuess != null ?
        initialGuess :
        // Compute estimation.
        new ParameterGuesser(observations).guess();

    // Return a new least squares problem set up to fit a Gaussian curve to the
    // observed points.
    return new LeastSquaresBuilder().
            maxEvaluations(Integer.MAX_VALUE).
            maxIterations(maxIter).
            start(startPoint).
            target(target).
            weight(new DiagonalMatrix(weights)).
            model(model.getModelFunction(), model.getModelFunctionJacobian()).
            build();

}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> observations) {
    // Prepare least-squares problem.
    final int len = observations.size();
    final double[] target  = new double[len];
    final double[] weights = new double[len];

    int count = 0;
    for (WeightedObservedPoint obs : observations) {
        target[count]  = obs.getY();
        weights[count] = obs.getWeight();
        ++count;
    }

    final AbstractCurveFitter.TheoreticalValuesFunction model
        = new AbstractCurveFitter.TheoreticalValuesFunction(function,
                                                            observations);

    // Create an optimizer for fitting the curve to the observed points.
    return new LeastSquaresBuilder().
            maxEvaluations(Integer.MAX_VALUE).
            maxIterations(maxIter).
            start(initialGuess).
            target(target).
            weight(new DiagonalMatrix(weights)).
            model(model.getModelFunction(), model.getModelFunctionJacobian()).
            build();
}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> observations) {
    // Prepare least-squares problem.
    final int len = observations.size();
    final double[] target  = new double[len];
    final double[] weights = new double[len];

    int i = 0;
    for (WeightedObservedPoint obs : observations) {
        target[i]  = obs.getY();
        weights[i] = obs.getWeight();
        ++i;
    }

    final AbstractCurveFitter.TheoreticalValuesFunction model
        = new AbstractCurveFitter.TheoreticalValuesFunction(FUNCTION,
                                                            observations);

    final double[] startPoint = initialGuess != null ?
        initialGuess :
        // Compute estimation.
        new ParameterGuesser(observations).guess();

    // Return a new optimizer set up to fit a Gaussian curve to the
    // observed points.
    return new LeastSquaresBuilder().
            maxEvaluations(Integer.MAX_VALUE).
            maxIterations(maxIter).
            start(startPoint).
            target(target).
            weight(new DiagonalMatrix(weights)).
            model(model.getModelFunction(), model.getModelFunctionJacobian()).
            build();

}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
private double[] optimiseLeastSquares(float[] x, float[] y, double[] initialSolution)
{
	// Least-squares optimisation using numerical gradients
	final SkewNormalDifferentiableFunction function = new SkewNormalDifferentiableFunction(initialSolution);
	function.addData(x, y);

	LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();

	//@formatter:off
	LeastSquaresProblem problem = new LeastSquaresBuilder()
			.maxEvaluations(Integer.MAX_VALUE)
			.maxIterations(3000)
			.start(initialSolution)
			.target(function.calculateTarget())
			.weight(new DiagonalMatrix(function.calculateWeights()))
			.model(function, new MultivariateMatrixFunction() {
				public double[][] value(double[] point) throws IllegalArgumentException
				{
					return function.jacobian(point);
				}} )
			.build();
	//@formatter:on

	Optimum optimum = optimizer.optimize(problem);

	double[] skewParameters = optimum.getPoint().toArray();
	return skewParameters;
}
 

import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder; //导入依赖的package包/类
/**
 * Find an ellipse that optimises the fit to the polygon detected edges.
 * 
 * @param roi
 * @param params
 * @param weightMap
 * @param angle
 * @return
 */
private double[] fitPolygonalCell(PolygonRoi roi, double[] params, FloatProcessor weightMap, FloatProcessor angle)
{
	// Get an estimate of the starting parameters using the current polygon
	double[] startPoint = params;
	startPoint = estimateStartPoint(roi, weightMap.getWidth(), weightMap.getHeight());

	int maxEval = 2000;
	final DifferentiableEllipticalFitFunction func = new DifferentiableEllipticalFitFunction(roi, weightMap);

	double relativeThreshold = 100 * Precision.EPSILON;
	double absoluteThreshold = 100 * Precision.SAFE_MIN;
	ConvergenceChecker<PointVectorValuePair> checker = new SimplePointChecker<PointVectorValuePair>(
			relativeThreshold, absoluteThreshold);
	double initialStepBoundFactor = 10;
	double costRelativeTolerance = 1e-10;
	double parRelativeTolerance = 1e-10;
	double orthoTolerance = 1e-10;
	double threshold = Precision.SAFE_MIN;

	LevenbergMarquardtOptimizer optimiser = new LevenbergMarquardtOptimizer(initialStepBoundFactor,
			costRelativeTolerance, parRelativeTolerance, orthoTolerance, threshold);

	try
	{
		//@formatter:off
		LeastSquaresProblem problem = new LeastSquaresBuilder()
				.maxEvaluations(Integer.MAX_VALUE)
				.maxIterations(maxEval)
				.start(startPoint)
				.target(func.calculateTarget())
				.weight(new DiagonalMatrix(func.calculateWeights()))
				.model(func, new MultivariateMatrixFunction() {
					public double[][] value(double[] point) throws IllegalArgumentException
					{
						return func.jacobian(point);
					}} )
				.checkerPair(checker)
				.build();
		//@formatter:on

		Optimum solution = optimiser.optimize(problem);

		if (debug)
			IJ.log(String.format("Eval = %d (Iter = %d), RMS = %f", solution.getEvaluations(),
					solution.getIterations(), solution.getRMS()));
		return solution.getPoint().toArray();
	}
	catch (Exception e)
	{
		IJ.log("Failed to find an elliptical solution, defaulting to polygon");
		e.printStackTrace();
	}

	return null;
}