Java NewtonRaphson2D類代碼示例

import de.linearbits.newtonraphson.NewtonRaphson2D; //導入依賴的package包/類
/**
 * Solves and prints measures
 * @param object1
 * @param object2
 * @param solver
 */
private static void solve(Function2D object1, Function2D object2, NewtonRaphson2D solver, int repetitions) {
    
    Vector2D result = null;
    long start = System.currentTimeMillis();
    for (int i=0; i< repetitions; i++) {
        result = solver.solve();
    }
    
    System.out.println("\nResults");
    System.out.println("*******");
    
    DecimalFormat format = new DecimalFormat("0.000000");
    double time = (System.currentTimeMillis() - start) / (double)repetitions;
    System.out.println("Time    : " + format.format(time));
    System.out.println(solver.getMeasures());
    System.out.println("Result  : " + result);
}
 

import de.linearbits.newtonraphson.NewtonRaphson2D; //導入依賴的package包/類
/**
 * Creates a new instance
 * 
 * @param model
 * @param histogram
 * @param config
 * @param stop
 */
ModelSNB(final ARXPopulationModel model,
         final RiskModelHistogram histogram,
         final NewtonRaphsonConfiguration<?> config,
         final WrappedBoolean stop) {

    super(histogram, model, stop, new WrappedInteger());

    // Prepare
    int[] _histogram = super.getHistogram().getHistogram();
    double c1 = super.getNumClassesOfSize(1);
    double c2 = super.getNumClassesOfSize(2);
    double k = estimateNonEmptyEquivalenceClasses(_histogram, super.getNumClasses(),
                                                  c1, super.getSamplingFraction());
    double f = getSamplingFraction();

    // Solve the maximum likelihood estimates
    Vector2D result = new NewtonRaphson2D(getObjectFunction(k, f, c1, c2),
                                          getDerivatives(k, f, c1, c2))
                                         .configure(config)
                                         .solve();

    // Compile and store
    this.uniques = k * Math.pow(result.y, result.x);
}
 

import de.linearbits.newtonraphson.NewtonRaphson2D; //導入依賴的package包/類
/**
 * Entry point
 * @param args
 */
public static void main(String[] args) {
    
    // First object function : 3 * x^2 + 2 * y^2 - 35 = 0
    // Second object function: 4 * x^2 - 3 * y^2 - 24 = 0
    //
    // This system has four solutions: (+-3, +-2)
    
    /* ****************************
     *  Solve without derivatives *
     ******************************/

    Function2D object1 = getObjectFunction1();
    Function2D object2 = getObjectFunction2();
    
    NewtonRaphson2D solver = new NewtonRaphson2D(object1, object2)
                                                 .accuracy(1e-6)
                                                 .iterationsPerTry(1000)
                                                 .iterationsTotal(100000);
    
    solve(object1, object2, solver, 1000000);

    /* *************************************************
     *  Solve without derivatives but with constraints *
     ***************************************************/

    // We want a solution in the negative range
    Constraint2D constraint = new Constraint2D(){ 
        public Boolean evaluate(Vector2D input) { 
            return input.x < 0 && input.y < 0; 
        }
    };
    
    solver = new NewtonRaphson2D(object1, object2, constraint)
                                 .accuracy(1e-6)
                                 .iterationsPerTry(1000)
                                 .iterationsTotal(100000);
    
    solve(object1, object2, solver, 1000000);
    
    /* *************************
     *  Solve with derivatives *
     ***************************/
    
    Function2D derivative11 = getDerivativeFunction11();
    Function2D derivative12 = getDerivativeFunction12();
    Function2D derivative21 = getDerivativeFunction21();
    Function2D derivative22 = getDerivativeFunction22();

    solver = new NewtonRaphson2D(object1, object2, 
                                 derivative11, derivative12,
                                 derivative21, derivative22)
                                 .accuracy(1e-6)
                                 .iterationsPerTry(1000)
                                 .iterationsTotal(100000);
    
    Function2DUtil util = new Function2DUtil();
    System.out.println("\nChecking derivatives:");
    System.out.println("Is derivative: " + util.isDerivativeFunction1(object1, derivative11, 0.01, 100, 0.001, 0.1d, 0.01d));
    System.out.println("Is derivative: " + util.isDerivativeFunction2(object1, derivative12, 0.01, 100, 0.001, 0.1d, 0.01d));
    System.out.println("Is derivative: " + util.isDerivativeFunction1(object2, derivative21, 0.01, 100, 0.001, 0.1d, 0.01d));
    System.out.println("Is derivative: " + util.isDerivativeFunction2(object2, derivative22, 0.01, 100, 0.001, 0.1d, 0.01d));
    
    solve(object1, object2, solver, 1000000);
    
    /* *****************************
     *  Solve with master function *
     *******************************/
    
    Function<Vector2D, Pair<Vector2D, SquareMatrix2D>> master = getMasterFunction();
    solver = new NewtonRaphson2D(master)
                                 .accuracy(1e-6)
                                 .iterationsPerTry(1000)
                                 .iterationsTotal(100000);
    
    solve(object1, object2, solver, 1000000);
}
 

import de.linearbits.newtonraphson.NewtonRaphson2D; //導入依賴的package包/類
/**
 * Creates a new instance
 * 
 * @param model
 * @param histogram
 * @param sampleSize
 * @param config
 * @param stop
 */
ModelPitman(final ARXPopulationModel model,
            final RiskModelHistogram histogram,
            final int sampleSize,
            final NewtonRaphsonConfiguration<?> config,
            final WrappedBoolean stop) {
    
    super(histogram, model, sampleSize, stop, new WrappedInteger());

    // Init
    double c1 = getNumClassesOfSize(1);
    double c2 = getNumClassesOfSize(2);
    double u = getNumClasses();
    double p = getPopulationSize();
    double n = sampleSize;

    // Initial guess
    c2 = c2 != 0 ? c2 : 1; // Overestimate
    double c = (c1 * (c1 - 1)) / c2;
    double t = ((n * u * c) - (c1 * (n - 1) * ((2 * u) + c))) /
               (((2 * c1 * u) + (c1 * c)) - (n * c));
    double a = ((t * (c1 - n)) + ((n - 1) * c1)) / (n * u);

    // Prepare
    NewtonRaphson2D solver = null;
    Vector2D result = new Vector2D(Double.NaN, Double.NaN);

    // Solve the Maximum Likelihood Estimates with Polygamma functions
    if (usePolygamma) {
        solver = new NewtonRaphson2D(getMasterFunctionClosed(histogram.getHistogram(), u, n)).configure(config);
        result = solver.solve(new Vector2D(t, a));
    }

    // If no result found, use iterative implementation
    if (Double.isNaN(result.x) || Double.isNaN(result.y)) {

        solver = new NewtonRaphson2D(getMasterFunctionIterative(histogram.getHistogram(), u, n)).configure(config);
        result = solver.solve(new Vector2D(t, a));

        // Else check the result against the iterative implementation
    } else {

        // Run test
        Vector2D test = getObjectFunctionsIterative(histogram.getHistogram(), u, n).evaluate(result);

        // Check result of test
        if (Double.isNaN(test.x) || Double.isNaN(test.y) ||
            Math.abs(test.x) > config.getAccuracy() ||
            Math.abs(test.y) > config.getAccuracy()) {

            // Use iterative implementation
            solver = new NewtonRaphson2D(getMasterFunctionIterative(histogram.getHistogram(),
                                                                    u,
                                                                    n)).configure(config);
            result = solver.solve(new Vector2D(t, a));
        }
    }

    // Compile the result
    this.numUniques = getResult(result, p);
}
 

import de.linearbits.newtonraphson.NewtonRaphson2D; //導入依賴的package包/類
/**
 * Creates a new instance
 * 
 * @param model
 * @param histogram
 * @param config
 * @param stop
 */
ModelPitman(final ARXPopulationModel model,
            final RiskModelHistogram histogram,
            final NewtonRaphsonConfiguration<?> config,
            final WrappedBoolean stop) {

    super(histogram, model, stop, new WrappedInteger());

    // Init
    double c1 = getNumClassesOfSize(1);
    double c2 = getNumClassesOfSize(2);
    double u = getNumClasses();
    double p = getPopulationSize();
    double n = super.getSampleSize();

    // Initial guess
    c2 = c2 != 0 ? c2 : 1; // Overestimate
    double c = (c1 * (c1 - 1)) / c2;
    double t = ((n * u * c) - (c1 * (n - 1) * ((2 * u) + c))) /
               (((2 * c1 * u) + (c1 * c)) - (n * c));
    double a = ((t * (c1 - n)) + ((n - 1) * c1)) / (n * u);

    // Solve the Maximum Likelihood Estimates with Polygamma functions
    NewtonRaphson2D solver = new NewtonRaphson2D(getMasterFunctionClosed(histogram.getHistogram(), u, n),
                                                 getConstraint()).configure(config);
    Vector2D result = solver.solve(new Vector2D(t, a));

    // If no result found, use iterative implementation
    if (Double.isNaN(result.x) || Double.isNaN(result.y)) {

        solver = new NewtonRaphson2D(getMasterFunctionIterative(histogram.getHistogram(), u, n),
                                     getConstraint()).configure(config);
        result = solver.solve(new Vector2D(t, a));

        // Else check the result against the iterative implementation
    } else {

        // Run test
        Vector2D test = getObjectFunctionsIterative(histogram.getHistogram(), u, n).evaluate(result);

        // Check result of test
        if (Double.isNaN(test.x) || Double.isNaN(test.y) ||
            Math.abs(test.x) > config.getAccuracy() ||
            Math.abs(test.y) > config.getAccuracy()) {

            // Use iterative implementation
            solver = new NewtonRaphson2D(getMasterFunctionIterative(histogram.getHistogram(), u, n),
                                                                    getConstraint()).configure(config);
            result = solver.solve(new Vector2D(t, a));
        }
    }

    // Compile the result
    this.numUniques = getResult(result, p);
}