import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的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.WeightedObservedPoint; //导入依赖的package包/类
public static void main(String[] args) {
    MyFuncFitter fitter = new MyFuncFitter(new LogFunction());
    ArrayList<WeightedObservedPoint> points = new ArrayList<WeightedObservedPoint>();

    double[] values = new double[]  {-1.01,-1.145,-1.231,-1.307,-1.369,-1.422,-1.468,-1.51,-1.547,-1.581};
    int i = 1;
    for (double d : values) {
        points.add( new WeightedObservedPoint(1.0,i++,d));
    }

    final double coeffs[] = fitter.fit(points);
    System.out.println(Arrays.toString(coeffs));
    
    LogFunction func = new LogFunction();
    for (int t = 1; t < 11; t++) {
    	 System.out.printf("%d %.3f%n", t, func.value(t, coeffs));
    }
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
public static void mainExp(String[] args) {
    MyFuncFitter fitter = new MyFuncFitter(new ExpFunction());
    ArrayList<WeightedObservedPoint> points = new ArrayList<WeightedObservedPoint>();

    double[] values = new double[] {9.086,7.852,6.941,6.441,6.108,5.841,5.641,5.472,5.381,5.251};
    int i = 1;
    for (double d : values) {
        points.add( new WeightedObservedPoint(1.0,i++,d));
    }
    
    final double coeffs[] = fitter.fit(points);
    System.out.println(Arrays.toString(coeffs));
    
    LogFunction func = new LogFunction();
    for (int t = 1; t < 11; t++) {
    	 System.out.printf("%d %f%n", t, func.value(t, coeffs));
    }
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * TODO
 * 
 * @return
 */
public double process() {
	Collection<WeightedObservedPoint> points = new LinkedList<WeightedObservedPoint>();

	// TODO We might need to change the behavior due to the fact that cell that are not in a track might still be in the metaXml file
	for (MIFrame frame : forest.getMetaxml().getAllFrames()) {
		// For the growth rate to be correct we need elapsed time in hours
		double elapsedTime = frame.getElapsedTime() / 60;
		double cellNumber = (double) frame.getAllCellsInFrame().size();

		// The points are uniformly weighted
		points.add(new WeightedObservedPoint(1d, elapsedTime, Math.log(cellNumber)));
	}

	final AbstractCurveFitter fitter = PolynomialCurveFitter.create(1);
	double[] coeffs = fitter.fit(points);

	growthRate = coeffs[1];

	return growthRate;
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * TODO
 * 
 * @return
 */
public double processNew() {
	Collection<WeightedObservedPoint> points = new LinkedList<WeightedObservedPoint>();

	// TODO We might need to change the behavior due to the fact that cell that are not in a track might still be in the metaXml file
	for (MIFrame frame : forest.getMetaxml().getAllFrames()) {
		// For the growth rate to be correct we need elapsed time in hours
		double elapsedTime = frame.getElapsedTime() / 60;
		double cellNumber = (double) frame.getAllCellsInFrame().size();

		// The points are uniformly weighted
		points.add(new WeightedObservedPoint(elapsedTime/forest.getMetaxml().getExperimentDuration(), elapsedTime, Math.log(cellNumber)));
	}

	final AbstractCurveFitter fitter = PolynomialCurveFitter.create(1);
	double[] coeffs = fitter.fit(points);
	
	factor = coeffs[0];
	growthRate = coeffs[1];

	return growthRate;
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
@Override
public File store(File folder) {
    File file = getFile(folder);
    Utils.mkdirs(file.getParentFile());
    try (PrintWriter out = new PrintWriter(Utils.createFileWriter(file))) {
        List<WeightedObservedPoint> points = obs.toList();
        int size = points.size();
        for (int i = 0; i < size; i++) {
            WeightedObservedPoint pt = points.get(i);
            out.println(pt.getX() + SEPARATOR + pt.getY() + SEPARATOR + pt.getWeight());
        }
        out.close();
    } catch (IOException e) {
        getLogger().warn("While storing approximator: " + e.getMessage());
    }
    return file;
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Loads persistent last recent weighted observed points from <code>folder</code>.
 * 
 * @param folder the folder
 * @param obs the observed points to be filled as a side effect
 * @throws IOException in case of any loading problems
 */
private void doLoad(File folder, LastRecentWeightedObservedPoints obs) throws IOException {
    File file = getFile(folder);
    if (file.exists()) {
        try (LineNumberReader in = new LineNumberReader(new FileReader(file))) {
            String line;
            do {
                line = in.readLine();
                if (null != line) {
                    WeightedObservedPoint pt = readPoint(file, line);
                    if (null != pt) {
                        obs.add(pt);
                    }
                }
            } while (null != line);
            in.close();
        } catch (IOException e) {
            throw e;
        }
    }
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Returns a snapshot of observed points.
 * 
 * @return x in the first array, y in the second array, length of both arrays is {@link #size()}.
 */
protected double[][] getPointArrays() {
    double[][] result = new double[2][];
    int count = observations.size();
    double[] x = new double[count];
    double[] y = new double[count];
    result[0] = x;
    result[1] = y;
    
    count = 0;
    for (WeightedObservedPoint p : observations.values()) {
        x[count] = p.getX(); 
        y[count] = p.getY(); 
        count++;
    }
    return result;
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Returns whether this and the given data set contains the same data.
 * 
 * @param approx the approximator to compare with
 * @return <code>true</code> for the same data, <code>false</code> else
 */
public boolean containsSameData(LastRecentWeightedObservedPoints approx) {
    boolean equals = false;
    if (null != approx) {
        Collection<WeightedObservedPoint> o1 = observations.values();
        Collection<WeightedObservedPoint> o2 = approx.observations.values();
        if (o1.size() == o2.size()) {
            Iterator<WeightedObservedPoint> i1 = o1.iterator();
            Iterator<WeightedObservedPoint> i2 = o2.iterator();
            equals = true;
            while (equals && i1.hasNext()) { // o1.size() == o2.size()
                WeightedObservedPoint p1 = i1.next();
                WeightedObservedPoint p2 = i2.next();
                equals = Math.abs(p1.getX() - p2.getX()) < 0.005;
                equals = Math.abs(p1.getY() - p2.getY()) < 0.005;
                equals = Math.abs(p1.getWeight() - p2.getWeight()) < 0.005;
            }
        }
    }
    return equals;
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
public static PolynomialFunction getStageEstimationFunction(
		List<Double> trainingSizes, List<Long> trainingDurations, int degree)
		throws SmallDataException {

	if (trainingSizes.size() <= degree)
		throw new SmallDataException();

	PolynomialCurveFitter fitter = PolynomialCurveFitter.create(degree);
	List<WeightedObservedPoint> points = new ArrayList<>();

	for (int i = 0; i < trainingSizes.size(); i++)
		points.add(new WeightedObservedPoint(1, trainingSizes.get(i),
				new Long(trainingDurations.get(i)).doubleValue()));

	return new PolynomialFunction(fitter.fit(points));

}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Updates the coefficients and calls {@link #updated()}.
 */
@Override
protected void updateApproximator() {
    List<WeightedObservedPoint> points = getPoints();
    if (points.size() >= getMinSampleSize()) {
        try {
            coeff = fitter.fit(points);
            updated();
        } catch (Throwable t) {
            LogManager.getLogger(getClass()).warn("During update: " + t.getMessage());
        }
    }
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Adds a point to the sample.
 *
 * @param observed Observed point to add.
 *
 * @see #add(double, double)
 * @see #add(double, double, double)
 * @see #toList()
 */
public void add(WeightedObservedPoint observed) {
    if (null != observed) {
        double x = observed.getX();
        int key = (int) x;
        observations.put(key, observed);
    }
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Gets a <em>snapshot</em> of the observed points.
 * The list of stored points is copied in order to ensure that
 * modification of the returned instance does not affect this
 * container.
 * Conversely, further modification of this container (through
 * the {@code add} or {@code clear} methods) will not affect the
 * returned list.
 *
 * @return the observed points, in the order they were added to this
 * container.
 *
 * @see #add(double, double)
 * @see #add(double, double, double)
 * @see #add(WeightedObservedPoint)
 */
public List<WeightedObservedPoint> toList() {
    // The copy is necessary to ensure thread-safety because of the
    // "clear" method (which otherwise would be able to empty the
    // list of points while it is being used by another thread).
    return new ArrayList<WeightedObservedPoint>(observations.values());
}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
public static long estimateStageDuration(List<Double> trainingSizes,
		List<Long> trainingDurations, double newSize, int degree) {

	PolynomialCurveFitter fitter = PolynomialCurveFitter.create(degree);
	List<WeightedObservedPoint> points = new ArrayList<>();

	for (int i = 0; i < trainingSizes.size(); i++)
		points.add(new WeightedObservedPoint(1, trainingSizes.get(i),
				new Long(trainingDurations.get(i)).doubleValue()));

	PolynomialFunction function = new PolynomialFunction(fitter.fit(points));

	return new Double(function.value(newSize)).longValue();

}
 

import org.apache.commons.math3.fitting.WeightedObservedPoint; //导入依赖的package包/类
/**
 * Returns the points as list.
 * 
 * @return the points
 */
protected List<WeightedObservedPoint> getPoints() {
    return obs.toList();
}