Java ExponentialDistribution类代码示例

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
public void generateVMsRandom(int totalVmNum) {
	int vmCount = 0;
	double lastStartTime = 0;
	
	double startMean = 1800; // sec = 30min
	double durScale=14400; // sec = 4 hours
	double durShape=1.2;
	
	Random rVmNum = new Random(seed);
	ExponentialDistribution rStartTime = new ExponentialDistribution(new Well19937c(seed), startMean, ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);	
	ParetoDistribution rDuration = new ParetoDistribution(new Well19937c(seed), durScale, durShape);
	
	while(vmCount < totalVmNum) {
		int vmsInGroup = rVmNum.nextInt(4)+2;
		double duration = Math.floor(rDuration.sample());
		
		vmGenerator.generateVMGroup(vmsInGroup, lastStartTime, lastStartTime+duration, null);
		lastStartTime += Math.floor(rStartTime.sample());
		
		vmCount += vmsInGroup;
		
	}
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
public List<VMSpec> generateVMs(int totalVmNum) {
	double lastStartTime = 0;
	
	double startMean = 1800; // sec = 30min
	double durScale=14400; // sec = 4 hours
	double durShape=1.2;
	
	Random rVmNum = new Random(seed);
	ExponentialDistribution rStartTime = new ExponentialDistribution(new Well19937c(seed), startMean, ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);	
	ParetoDistribution rDuration = new ParetoDistribution(new Well19937c(seed), durScale, durShape);
	
	List<VMSpec> vms = new ArrayList<VMSpec>();

	while(this.vmId < totalVmNum) {
		int vmsInGroup = rVmNum.nextInt(4)+2;
		double duration = Math.floor(rDuration.sample());
		
		vms.addAll(generateVMGroup(vmsInGroup, lastStartTime, lastStartTime+duration));
		lastStartTime += Math.floor(rStartTime.sample());
	}
	
	return vms;
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
@Override
public DistributionFactory getFactory(List<String> params)
{
    if (params.size() != 1)
        throw new IllegalArgumentException("Invalid parameter list for gaussian distribution: " + params);
    try
    {
        String[] bounds = params.get(0).split("\\.\\.+");
        final long min = parseLong(bounds[0]);
        final long max = parseLong(bounds[1]);
        if (min == max)
            return new FixedFactory(min);
        ExponentialDistribution findBounds = new ExponentialDistribution(1d);
        // max probability should be roughly equal to accuracy of (max-min) to ensure all values are visitable,
        // over entire range, but this results in overly skewed distribution, so take sqrt
        final double mean = (max - min) / findBounds.inverseCumulativeProbability(1d - Math.sqrt(1d/(max-min)));
        return new ExpFactory(min, max, mean);
    } catch (Exception ignore)
    {
        throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params);
    }
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
public void generateVMsRandom(int totalVmNum) {
	int vmCount = 0;
	double lastStartTime = 0;
	
	double startMean = 1800; // sec = 30min
	double durScale=14400; // sec = 4 hours
	double durShape=1.2;
	
	Random rVmNum = new Random(seed);
	ExponentialDistribution rStartTime = new ExponentialDistribution(new Well19937c(seed), startMean, ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);	
	ParetoDistribution rDuration = new ParetoDistribution(new Well19937c(seed), durScale, durShape);
	
	int vmGroup=0;
	while(vmCount < totalVmNum) {
		int vmsInGroup = rVmNum.nextInt(4)+2;
		double duration = Math.floor(rDuration.sample());
		
		vmGenerator.generateVMGroup(vmsInGroup, lastStartTime, lastStartTime+duration, null, vmGroup, -1);
		lastStartTime += Math.floor(rStartTime.sample());
		
		vmCount += vmsInGroup;
		vmGroup++;			
	}
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的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.ExponentialDistribution; //导入依赖的package包/类
@Override
public DistributionFactory getFactory(List<String> params)
{
    if (params.size() != 1)
        throw new IllegalArgumentException("Invalid parameter list for gaussian distribution: " + params);
    try
    {
        String[] bounds = params.get(0).split("\\.\\.+");
        final long min = parseLong(bounds[0]);
        final long max = parseLong(bounds[1]);
        ExponentialDistribution findBounds = new ExponentialDistribution(1d);
        // max probability should be roughly equal to accuracy of (max-min) to ensure all values are visitable,
        // over entire range, but this results in overly skewed distribution, so take sqrt
        final double mean = (max - min) / findBounds.inverseCumulativeProbability(1d - Math.sqrt(1d/(max-min)));
        return new ExpFactory(min, max, mean);
    } catch (Exception e)
    {
        throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params);
    }
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
private static void computeSCMOSWeights(double[] weights, double[] noise)
{
	// Per observation read noise.
	weights = new double[size * size];
	RandomGenerator randomGenerator = new Well19937c(42);
	ExponentialDistribution ed = new ExponentialDistribution(randomGenerator, variance,
			ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
	for (int i = 0; i < weights.length; i++)
	{
		double pixelVariance = ed.sample();
		double pixelGain = Math.max(0.1, gain + randomGenerator.nextGaussian() * gainSD);
		// weights = var / g^2
		weights[i] = pixelVariance / (pixelGain * pixelGain);
	}
	// Convert to standard deviation for simulation
	noise = new double[weights.length];
	for (int i = 0; i < weights.length; i++)
		noise[i] = Math.sqrt(weights[i]);
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
public SCMOSLikelihoodWrapperTest()
{
	int n = maxx * maxx;
	var = new float[n];
	g = new float[n];
	o = new float[n];
	sd = new float[n];
	RandomGenerator rg = new Well19937c(30051977);
	PoissonDistribution pd = new PoissonDistribution(rg, O, PoissonDistribution.DEFAULT_EPSILON,
			PoissonDistribution.DEFAULT_MAX_ITERATIONS);
	ExponentialDistribution ed = new ExponentialDistribution(rg, VAR,
			ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
	for (int i = 0; i < n; i++)
	{
		o[i] = (float) pd.sample();
		var[i] = (float) ed.sample();
		sd[i] = (float) Math.sqrt(var[i]);
		g[i] = (float) (G + rg.nextGaussian() * G_SD);
	}
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
@Override
public DistributionFactory getFactory(List<String> params)
{
    if (params.size() != 1)
        throw new IllegalArgumentException("Invalid parameter list for gaussian distribution: " + params);
    try
    {
        String[] bounds = params.get(0).split("\\.\\.+");
        final long min = Long.parseLong(bounds[0]);
        final long max = Long.parseLong(bounds[1]);
        ExponentialDistribution findBounds = new ExponentialDistribution(1d);
        // max probability should be roughly equal to accuracy of (max-min) to ensure all values are visitable,
        // over entire range, but this results in overly skewed distribution, so take sqrt
        final double mean = (max - min) / findBounds.inverseCumulativeProbability(1d - Math.sqrt(1d/(max-min)));
        return new ExpFactory(min, max, mean);
    } catch (Exception _)
    {
        throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params);
    }
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param distribution Distribution as String
 * @param para1 Parameter 1
 * @param para2 Parameter 2 (only needed when applicable)
 */
public IATGen(String distribution, double para1, double para2) {

    logger.trace("Distribution selected: {} with Parameters {} & {}", distribution, para1, para2);

    switch (distribution) {
        case "ChiSquared":
            this.distri = new ChiSquaredDistribution(para1);
            break;
        case "Exponential":
            this.distri = new ExponentialDistribution(para1);
            break;
        case "Gamma":
            this.distri = new GammaDistribution(para1, para2);
            break;
        case "Poisson":
            this.intDistri = new PoissonDistribution(para1, para2);
            break;
        default:
            this.distri = new NormalDistribution(para1, para2);
            break;
    }
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
public EdgeTask(int _mobileDeviceId, APP_TYPES _taskType, double _startTime, ExponentialDistribution[][] expRngList) {
   	mobileDeviceId=_mobileDeviceId;
   	startTime=_startTime;
   	taskType=_taskType;
   	
   	inputFileSize = (long)expRngList[_taskType.ordinal()][0].sample();
   	outputFileSize =(long)expRngList[_taskType.ordinal()][1].sample();
   	length = (long)expRngList[_taskType.ordinal()][2].sample();
   	
   	pesNumber = (int)SimSettings.getInstance().getTaskLookUpTable()[_taskType.ordinal()][8];
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
@Setup
public void setUp() {
    exponentialDistribution = new ExponentialDistribution(
            new ThreadLocalRandomGenerator(),
            1.0,
            ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
private void testGoodnessOfFitByTwoLevelTesting(final ExponentialRNG exponentialRNG, final double theta) {
    TwoLevelTester tester = new TwoLevelTester(N, K);
    TwoLevelTester.RealRng rng = new TwoLevelTester.RealRng() {
        @Override
        public double generate(Random random) {
            return exponentialRNG.generate(random, theta);
        }
    };
    ExponentialDistribution distribution = new ExponentialDistribution(theta);
    tester.test(rng, distribution);
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
/**
 * Creates a new sampler, given a random number generator, a continuous, univariate, unimodal, unnormalized
 * log probability density function, hard limits on the random variable, and a step width.
 * @param rng      random number generator
 * @param logPDF   continuous, univariate, unimodal log probability density function (up to additive constant)
 * @param xMin     minimum allowed value of the random variable
 * @param xMax     maximum allowed value of the random variable
 * @param width    step width for slice expansion
 */
public SliceSampler(final RandomGenerator rng, final Function<Double, Double> logPDF,
                    final double xMin, final double xMax, final double width) {
    Utils.nonNull(rng);
    Utils.nonNull(logPDF);
    Utils.validateArg(xMin < xMax, "Maximum bound must be greater than minimum bound.");
    ParamUtils.isPositive(width, "Slice-sampling width must be positive.");
    this.rng = rng;
    this.logPDF = logPDF;
    this.xMin = xMin;
    this.xMax = xMax;
    this.width = width;
    exponentialDistribution = new ExponentialDistribution(rng, 1.);
}
 

import org.apache.commons.math3.distribution.ExponentialDistribution; //导入依赖的package包/类
private void filter1IsSameAsFilter2(GFilter f1, GFilter f2, boolean weighted, double tolerance)
{
	Random rand = new Random(-30051976);
	float[] data = createData(rand, size, size);
	float[] w = null;
	if (weighted)
	{
		ExponentialDistribution ed = new ExponentialDistribution(rand, 57,
				ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);

		w = new float[data.length];
		for (int i = 0; i < w.length; i++)
		{
			w[i] = (float) (1.0 / Math.max(0.01, ed.sample()));
			//w[i] = (float) (1.0 / Math.max(0.01, rand.nextGaussian() * 0.2 + 2));
			//w[i] = 0.5f;
		}
		f1.setWeights(w);
		f2.setWeights(w);
	}

	for (double sigma : sigmas)
	{
		float[] e = data.clone();
		f2.run(e, sigma);
		float[] o = data.clone();
		f1.run(o, sigma);

		double max = 0;
		for (int i = 0; i < e.length; i++)
		{
			double d = DoubleEquality.relativeError(e[i], o[i]);
			if (max < d)
				max = d;
		}

		System.out.printf("%s vs %s w=%b @ %.1f = %g\n", f1.getName(), f2.getName(), weighted, sigma, max);
		Assert.assertTrue(max < tolerance);
	}
}