Java GaussianRandomGenerator类代码示例

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testRosenbrock() {
    Rosenbrock rosenbrock = new Rosenbrock();
    SimplexOptimizer underlying
        = new SimplexOptimizer(new SimpleValueChecker(-1, 1.0e-3));
    NelderMeadSimplex simplex = new NelderMeadSimplex(new double[][] {
            { -1.2,  1.0 }, { 0.9, 1.2 } , {  3.5, -2.3 }
        });
    underlying.setSimplex(simplex);
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(16069223052l);
    RandomVectorGenerator generator =
        new UncorrelatedRandomVectorGenerator(2, new GaussianRandomGenerator(g));
    MultivariateMultiStartOptimizer optimizer =
        new MultivariateMultiStartOptimizer(underlying, 10, generator);
    PointValuePair optimum =
        optimizer.optimize(1100, rosenbrock, GoalType.MINIMIZE, new double[] { -1.2, 1.0 });

    Assert.assertEquals(rosenbrock.getCount(), optimizer.getEvaluations());
    Assert.assertTrue(optimizer.getEvaluations() > 900);
    Assert.assertTrue(optimizer.getEvaluations() < 1200);
    Assert.assertTrue(optimum.getValue() < 8.0e-4);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
/**
 * Test demonstrating that the user exception is finally thrown if none
 * of the runs succeed.
 */
@Test(expected=TestException.class)
public void testNoOptimum() {
    JacobianMultivariateVectorOptimizer underlyingOptimizer
        = new GaussNewtonOptimizer(true, new SimpleVectorValueChecker(1e-6, 1e-6));
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(12373523445l);
    RandomVectorGenerator generator
        = new UncorrelatedRandomVectorGenerator(1, new GaussianRandomGenerator(g));
    MultiStartMultivariateVectorOptimizer optimizer
        = new MultiStartMultivariateVectorOptimizer(underlyingOptimizer, 10, generator);
    optimizer.optimize(new MaxEval(100),
                       new Target(new double[] { 0 }),
                       new Weight(new double[] { 1 }),
                       new InitialGuess(new double[] { 0 }),
                       new ModelFunction(new MultivariateVectorFunction() {
                               public double[] value(double[] point) {
                                   throw new TestException();
                               }
                           }));
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test(expected=NullPointerException.class)
public void testGetOptimaBeforeOptimize() {

    JacobianMultivariateVectorOptimizer underlyingOptimizer
        = new GaussNewtonOptimizer(true, new SimpleVectorValueChecker(1e-6, 1e-6));
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(16069223052l);
    RandomVectorGenerator generator
        = new UncorrelatedRandomVectorGenerator(1, new GaussianRandomGenerator(g));
    MultiStartMultivariateVectorOptimizer optimizer
        = new MultiStartMultivariateVectorOptimizer(underlyingOptimizer, 10, generator);

    optimizer.getOptima();
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testTrivial() {
    LinearProblem problem
        = new LinearProblem(new double[][] { { 2 } }, new double[] { 3 });
    JacobianMultivariateVectorOptimizer underlyingOptimizer
        = new GaussNewtonOptimizer(true, new SimpleVectorValueChecker(1e-6, 1e-6));
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(16069223052l);
    RandomVectorGenerator generator
        = new UncorrelatedRandomVectorGenerator(1, new GaussianRandomGenerator(g));
    MultiStartMultivariateVectorOptimizer optimizer
        = new MultiStartMultivariateVectorOptimizer(underlyingOptimizer, 10, generator);

    PointVectorValuePair optimum
        = optimizer.optimize(new MaxEval(100),
                             problem.getModelFunction(),
                             problem.getModelFunctionJacobian(),
                             problem.getTarget(),
                             new Weight(new double[] { 1 }),
                             new InitialGuess(new double[] { 0 }));
    Assert.assertEquals(1.5, optimum.getPoint()[0], 1e-10);
    Assert.assertEquals(3.0, optimum.getValue()[0], 1e-10);
    PointVectorValuePair[] optima = optimizer.getOptima();
    Assert.assertEquals(10, optima.length);
    for (int i = 0; i < optima.length; i++) {
        Assert.assertEquals(1.5, optima[i].getPoint()[0], 1e-10);
        Assert.assertEquals(3.0, optima[i].getValue()[0], 1e-10);
    }
    Assert.assertTrue(optimizer.getEvaluations() > 20);
    Assert.assertTrue(optimizer.getEvaluations() < 50);
    Assert.assertEquals(100, optimizer.getMaxEvaluations());
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testIssue914() {
    LinearProblem problem = new LinearProblem(new double[][] { { 2 } }, new double[] { 3 });
    JacobianMultivariateVectorOptimizer underlyingOptimizer =
            new GaussNewtonOptimizer(true, new SimpleVectorValueChecker(1e-6, 1e-6)) {
        @Override
        public PointVectorValuePair optimize(OptimizationData... optData) {
            // filter out simple bounds, as they are not supported
            // by the underlying optimizer, and we don't really care for this test
            OptimizationData[] filtered = optData.clone();
            for (int i = 0; i < filtered.length; ++i) {
                if (filtered[i] instanceof SimpleBounds) {
                    filtered[i] = null;
                }
            }
            return super.optimize(filtered);
        }
    };
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(16069223052l);
    RandomVectorGenerator generator =
            new UncorrelatedRandomVectorGenerator(1, new GaussianRandomGenerator(g));
    MultiStartMultivariateVectorOptimizer optimizer =
            new MultiStartMultivariateVectorOptimizer(underlyingOptimizer, 10, generator);

    optimizer.optimize(new MaxEval(100),
                       problem.getModelFunction(),
                       problem.getModelFunctionJacobian(),
                       problem.getTarget(),
                       new Weight(new double[] { 1 }),
                       new InitialGuess(new double[] { 0 }),
                       new SimpleBounds(new double[] { -1.0e-10 }, new double[] {  1.0e-10 }));
    PointVectorValuePair[] optima = optimizer.getOptima();
    // only the first start should have succeeded
    Assert.assertEquals(1, optima.length);

}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testRosenbrock() {
    Rosenbrock rosenbrock = new Rosenbrock();
    SimplexOptimizer underlying
        = new SimplexOptimizer(new SimpleValueChecker(-1, 1e-3));
    NelderMeadSimplex simplex = new NelderMeadSimplex(new double[][] {
            { -1.2,  1.0 },
            { 0.9, 1.2 } ,
            {  3.5, -2.3 }
        });
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(16069223052l);
    RandomVectorGenerator generator
        = new UncorrelatedRandomVectorGenerator(2, new GaussianRandomGenerator(g));
    int nbStarts = 10;
    MultiStartMultivariateOptimizer optimizer
        = new MultiStartMultivariateOptimizer(underlying, nbStarts, generator);
    PointValuePair optimum
        = optimizer.optimize(new MaxEval(1100),
                             new ObjectiveFunction(rosenbrock),
                             GoalType.MINIMIZE,
                             simplex,
                             new InitialGuess(new double[] { -1.2, 1.0 }));
    Assert.assertEquals(nbStarts, optimizer.getOptima().length);

    Assert.assertEquals(rosenbrock.getCount(), optimizer.getEvaluations());
    Assert.assertTrue(optimizer.getEvaluations() > 900);
    Assert.assertTrue(optimizer.getEvaluations() < 1200);
    Assert.assertTrue(optimum.getValue() < 5e-5);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testNormallyDistributedRandomData() {
  List<Double> values = new ArrayList<>();
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(0L));
  for(int i = 0;i < 1000000;++i) {
    double d = gaussian.nextNormalizedDouble();
    values.add(d);
  }
  validateEquality(values);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testNormallyDistributedRandomDataShifted() {
  List<Double> values = new ArrayList<>();
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(0L));
  for(int i = 0;i < 1000000;++i) {
    double d = gaussian.nextNormalizedDouble() + 10;
    values.add(d);
  }
  validateEquality(values);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testNormallyDistributedRandomDataShiftedBackwards() {
  List<Double> values = new ArrayList<>();
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(0L));
  for(int i = 0;i < 1000000;++i) {
    double d = gaussian.nextNormalizedDouble() - 10;
    values.add(d);
  }
  validateEquality(values);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testNormallyDistributedRandomDataSkewed() {
  List<Double> values = new ArrayList<>();
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(0L));
  for(int i = 0;i < 1000000;++i) {
    double d = (gaussian.nextNormalizedDouble()+ 10000) /1000;
    values.add(d);
  }
  validateEquality(values);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testNormallyDistributedRandomDataAllNegative() {
  List<Double> values = new ArrayList<>();
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(0L));
  for(int i = 0;i < 1000000;++i) {
    double d = -1*gaussian.nextNormalizedDouble();
    values.add(d);
  }
  validateEquality(values);
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
public static void main(String... argv) {
  DescriptiveStatistics perfStats = new DescriptiveStatistics();
  OnlineStatisticsProvider statsProvider = new OnlineStatisticsProvider();
  List<Double> values = new ArrayList<>();
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(0L));
  for(int i = 0;i < NUM_DATA_POINTS;++i) {
    //get the data point out of the [0,1] range
    double d = 1000*gaussian.nextNormalizedDouble();
    values.add(d);
    statsProvider.addValue(d);
  }

  for(int perfRun = 0;perfRun < NUM_RUNS;++perfRun) {
    StellarStatisticsFunctions.StatsBin bin = new StellarStatisticsFunctions.StatsBin();
    long start = System.currentTimeMillis();
    Random r = new Random(0);
    for (int i = 0; i < TRIALS_PER_RUN; ++i) {
      //grab a random value and fuzz it a bit so we make sure there's no cheating via caching in t-digest.
      bin.apply(ImmutableList.of(statsProvider, values.get(r.nextInt(values.size())) - 3.5, PERCENTILES));
    }
    perfStats.addValue(System.currentTimeMillis() - start);
  }
  System.out.println( "Min/25th/50th/75th/Max Milliseconds: "
                    + perfStats.getMin()
                    + " / " + perfStats.getPercentile(25)
                    + " / " + perfStats.getPercentile(50)
                    + " / " + perfStats.getPercentile(75)
                    + " / " + perfStats.getMax()
                    );
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@BeforeClass
public static void beforeClass() {
  Random rng = new Random(0);
  GaussianRandomGenerator gen = new GaussianRandomGenerator(new MersenneTwister(0));
  for(int i = 0;i < SAMPLE_SIZE;++i) {
    double us= 10*rng.nextDouble();
    uniformSample.add(us);
    uniformStats.addValue(us);
    double gs= 10*gen.nextNormalizedDouble();
    gaussianSample.add(gs);
    gaussianStats.addValue(gs);
  }
}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testMergeProviders() throws Exception {
  List<StatisticsProvider> providers = new ArrayList<>();
  /*
  Create 10 providers, each with a sample drawn from a gaussian distribution.
  Update the reference stats from commons math to ensure we are
   */
  GaussianRandomGenerator gaussian = new GaussianRandomGenerator(new MersenneTwister(1L));
  SummaryStatistics sStatistics= new SummaryStatistics();
  DescriptiveStatistics dStatistics = new DescriptiveStatistics();
  for(int i = 0;i < 10;++i) {
    List<Double> sample = new ArrayList<>();
    for(int j = 0;j < 100;++j) {
      double s = gaussian.nextNormalizedDouble();
      sample.add(s);
      sStatistics.addValue(s);
      dStatistics.addValue(s);
    }
    StatisticsProvider provider = (StatisticsProvider)run("STATS_ADD(STATS_INIT(), " + Joiner.on(",").join(sample) + ")"
                                                         , new HashMap<>()
                                                         );
    providers.add(provider);
  }

  /*
  Merge the providers and validate
   */
  Map<String, Object> providerVariables = new HashMap<>();
  for(int i = 0;i < providers.size();++i) {
    providerVariables.put("provider_" + i, providers.get(i));
  }
  StatisticsProvider mergedProvider =
          (StatisticsProvider)run("STATS_MERGE([" + Joiner.on(",").join(providerVariables.keySet()) + "])"
                                 , providerVariables
                                 );
  OnlineStatisticsProviderTest.validateStatisticsProvider(mergedProvider, sStatistics , dStatistics);

}
 

import org.apache.commons.math3.random.GaussianRandomGenerator; //导入依赖的package包/类
@Test
public void testCircleFitting() {
    CircleScalar circle = new CircleScalar();
    circle.addPoint( 30.0,  68.0);
    circle.addPoint( 50.0,  -6.0);
    circle.addPoint(110.0, -20.0);
    circle.addPoint( 35.0,  15.0);
    circle.addPoint( 45.0,  97.0);
    // TODO: the wrapper around NonLinearConjugateGradientOptimizer is a temporary hack for
    // version 3.1 of the library. It should be removed when NonLinearConjugateGradientOptimizer
    // will officially be declared as implementing MultivariateDifferentiableOptimizer
    GradientMultivariateOptimizer underlying
        = new NonLinearConjugateGradientOptimizer(NonLinearConjugateGradientOptimizer.Formula.POLAK_RIBIERE,
                                                  new SimpleValueChecker(1e-10, 1e-10));
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(753289573253l);
    RandomVectorGenerator generator
        = new UncorrelatedRandomVectorGenerator(new double[] { 50, 50 },
                                                new double[] { 10, 10 },
                                                new GaussianRandomGenerator(g));
    MultiStartMultivariateOptimizer optimizer
        = new MultiStartMultivariateOptimizer(underlying, 10, generator);
    PointValuePair optimum
        = optimizer.optimize(new MaxEval(200),
                             circle.getObjectiveFunction(),
                             circle.getObjectiveFunctionGradient(),
                             GoalType.MINIMIZE,
                             new InitialGuess(new double[] { 98.680, 47.345 }));
    Assert.assertEquals(200, optimizer.getMaxEvaluations());
    PointValuePair[] optima = optimizer.getOptima();
    for (PointValuePair o : optima) {
        Vector2D center = new Vector2D(o.getPointRef()[0], o.getPointRef()[1]);
        Assert.assertEquals(69.960161753, circle.getRadius(center), 1e-8);
        Assert.assertEquals(96.075902096, center.getX(), 1e-8);
        Assert.assertEquals(48.135167894, center.getY(), 1e-8);
    }
    Assert.assertTrue(optimizer.getEvaluations() > 70);
    Assert.assertTrue(optimizer.getEvaluations() < 90);
    Assert.assertEquals(3.1267527, optimum.getValue(), 1e-8);
}