Java RealDistribution.sample方法代码示例

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Test
public void testPolynomialFit() {
    final Random randomizer = new Random(53882150042L);
    final RealDistribution rng = new UniformRealDistribution(-100, 100);
    rng.reseedRandomGenerator(64925784252L);

    final double[] coeff = { 12.9, -3.4, 2.1 }; // 12.9 - 3.4 x + 2.1 x^2
    final PolynomialFunction f = new PolynomialFunction(coeff);

    // Collect data from a known polynomial.
    final WeightedObservedPoints obs = new WeightedObservedPoints();
    for (int i = 0; i < 100; i++) {
        final double x = rng.sample();
        obs.add(x, f.value(x) + 0.1 * randomizer.nextGaussian());
    }

    final ParametricUnivariateFunction function = new PolynomialFunction.Parametric(); 
    // Start fit from initial guesses that are far from the optimal values.
    final SimpleCurveFitter fitter
        = SimpleCurveFitter.create(function,
                                   new double[] { -1e20, 3e15, -5e25 });
    final double[] best = fitter.fit(obs.toList());

    TestUtils.assertEquals("best != coeff", coeff, best, 2e-2);
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Test
public void testFit() {
    final RealDistribution rng = new UniformRealDistribution(-100, 100);
    rng.reseedRandomGenerator(64925784252L);

    final LevenbergMarquardtOptimizer optim = new LevenbergMarquardtOptimizer();
    final PolynomialFitter fitter = new PolynomialFitter(optim);
    final double[] coeff = { 12.9, -3.4, 2.1 }; // 12.9 - 3.4 x + 2.1 x^2
    final PolynomialFunction f = new PolynomialFunction(coeff);

    // Collect data from a known polynomial.
    for (int i = 0; i < 100; i++) {
        final double x = rng.sample();
        fitter.addObservedPoint(x, f.value(x));
    }

    // Start fit from initial guesses that are far from the optimal values.
    final double[] best = fitter.fit(new double[] { -1e-20, 3e15, -5e25 });

    TestUtils.assertEquals("best != coeff", coeff, best, 1e-12);
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Test
public void testFit() {
    final RealDistribution rng = new UniformRealDistribution(-100, 100);
    rng.reseedRandomGenerator(64925784252L);

    final double[] coeff = { 12.9, -3.4, 2.1 }; // 12.9 - 3.4 x + 2.1 x^2
    final PolynomialFunction f = new PolynomialFunction(coeff);

    // Collect data from a known polynomial.
    final WeightedObservedPoints obs = new WeightedObservedPoints();
    for (int i = 0; i < 100; i++) {
        final double x = rng.sample();
        obs.add(x, f.value(x));
    }

    // Start fit from initial guesses that are far from the optimal values.
    final PolynomialCurveFitter fitter
        = PolynomialCurveFitter.create(0).withStartPoint(new double[] { -1e-20, 3e15, -5e25 });
    final double[] best = fitter.fit(obs.toList());

    TestUtils.assertEquals("best != coeff", coeff, best, 1e-12);
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Override
public RandomNumberDistribution<Double> getExponential(
		final RandomNumberStream rng, final Number mean)
{
	final RealDistribution dist = new ExponentialDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			mean.doubleValue());
	return new RandomNumberDistribution<Double>()
	{
		@Override
		public Double draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Override
public RandomNumberDistribution<Double> getGamma(
		final RandomNumberStream rng, final Number shape, final Number scale)
{
	final RealDistribution dist = new GammaDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			shape.doubleValue(), scale.doubleValue());
	return new RandomNumberDistribution<Double>()
	{
		@Override
		public Double draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Override
public RandomNumberDistribution<Double> getLevy(
		final RandomNumberStream rng, final Number mu, final Number c)
{
	final RealDistribution dist = new LevyDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			mu.doubleValue(), c.doubleValue());
	return new RandomNumberDistribution<Double>()
	{
		@Override
		public Double draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Override
public RandomNumberDistribution<Double> getNormal(
		final RandomNumberStream rng, final Number mean, final Number sd)
{
	final RealDistribution dist = new NormalDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			mean.doubleValue(), sd.doubleValue());
	return new RandomNumberDistribution<Double>()
	{
		@Override
		public Double draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Override
public RandomNumberDistribution<Double> getPareto(
		final RandomNumberStream rng, final Number scale, final Number shape)
{
	final RealDistribution dist = new ParetoDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			scale.doubleValue(), shape.doubleValue());
	return new RandomNumberDistribution<Double>()
	{
		@Override
		public Double draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
@Override
public RandomNumberDistribution<Double> getUniformReal(
		final RandomNumberStream rng, final Number lower, final Number upper)
{
	final RealDistribution dist = new UniformRealDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			lower.doubleValue(), upper.doubleValue());
	return new RandomNumberDistribution<Double>()
	{
		@Override
		public Double draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
public static List<List<Double>> getSimulatedScores(int[] n, List<RealDistribution> distributions){
	List<List<Double>> sample_sep=new ArrayList<List<Double>>();
	for(int i=0;i<n.length;i++){
		RealDistribution nd=distributions.get(i);
		List<Double> sample_curr=new ArrayList<Double>();
		for(double d:nd.sample(n[i])){
			sample_curr.add(d);
		}
		sample_sep.add(sample_curr);
	}
	return sample_sep;
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
/**
 * Adds some amount of random data to the given initializer.
 *
 * @param random Random variable distribution.
 * @param orig Original initializer.
 * @return an initializer whose {@link FeatureInitializer#value() value}
 * method will return {@code orig.value() + random.sample()}.
 */
public static FeatureInitializer randomize(final RealDistribution random,
                                           final FeatureInitializer orig) {
    return new FeatureInitializer() {
        /** {@inheritDoc} */
        public double value() {
            return orig.value() + random.sample();
        }
    };
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
/**
 * Generates a random sample of double values.
 * Sample size is random, between 10 and 100 and values are
 * uniformly distributed over [-100, 100].
 *
 * @return array of random double values
 */
private double[] generateSample() {
    final IntegerDistribution size = new UniformIntegerDistribution(10, 100);
    final RealDistribution randomData = new UniformRealDistribution(-100, 100);
    final int sampleSize = size.sample();
    final double[] out = randomData.sample(sampleSize);
    return out;
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
private void doDistributionTest(RealDistribution distribution) {
    double data[];

    data = distribution.sample(VERY_LARGE);
    doCalculatePercentile(50, data, 0.0001);
    doCalculatePercentile(95, data, 0.0001);

    data = distribution.sample(LARGE);
    doCalculatePercentile(50, data, 0.001);
    doCalculatePercentile(95, data, 0.001);

    data = distribution.sample(VERY_BIG);
    doCalculatePercentile(50, data, 0.001);
    doCalculatePercentile(95, data, 0.001);

    data = distribution.sample(BIG);
    doCalculatePercentile(50, data, 0.001);
    doCalculatePercentile(95, data, 0.001);

    data = distribution.sample(STANDARD);
    doCalculatePercentile(50, data, 0.005);
    doCalculatePercentile(95, data, 0.005);

    data = distribution.sample(MEDIUM);
    doCalculatePercentile(50, data, 0.005);
    doCalculatePercentile(95, data, 0.005);

    data = distribution.sample(NOMINAL);
    doCalculatePercentile(50, data, 0.01);
    doCalculatePercentile(95, data, 0.01);

    data = distribution.sample(SMALL);
    doCalculatePercentile(50, data, 0.01);
    doCalculatePercentile(95, data, 0.01);

    data = distribution.sample(TINY);
    doCalculatePercentile(50, data, 0.05);
    doCalculatePercentile(95, data, 0.05);

}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
/**
 * Make sure that permuted arrays do not hash to the same value.
 */
@Test
public void testPermutedArrayHash() {
    double[] original = new double[10];
    double[] permuted = new double[10];
    RandomDataGenerator random = new RandomDataGenerator();

    // Generate 10 distinct random values
    for (int i = 0; i < 10; i++) {
        final RealDistribution u = new UniformRealDistribution(i + 0.5, i + 0.75);
        original[i] = u.sample();
    }

    // Generate a random permutation, making sure it is not the identity
    boolean isIdentity = true;
    do {
        int[] permutation = random.nextPermutation(10, 10);
        for (int i = 0; i < 10; i++) {
            if (i != permutation[i]) {
                isIdentity = false;
            }
            permuted[i] = original[permutation[i]];
        }
    } while (isIdentity);

    // Verify that permuted array has different hash
    Assert.assertFalse(MathUtils.hash(original) == MathUtils.hash(permuted));
}
 

import org.apache.commons.math3.distribution.RealDistribution; //导入方法依赖的package包/类
private RealDistribution substractDistributions(RealDistribution left, RealDistribution right) {
	double[] leftSamples = left.sample(diffDistributionSampleCount);
	double[] rightSamples = left.sample(diffDistributionSampleCount);
	
	for (int i = 0; i < leftSamples.length; i++) {
		leftSamples[i] -= rightSamples[i];
	}
	
	return DistributionUtils.makeEmpirical(leftSamples);
}