Java NormalDistribution.inverseCumulativeProbability方法代码示例

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
public static Newsvendor solveLognormalNewsvendor (final double price, final double cost, final double mu, final double sigma) {
	final NormalDistribution dist1 = new NormalDistribution();
	final double cv = sigma/mu;
	final double nu = Math.log(mu)-Math.log(Math.sqrt(1+cv*cv));
	final double tau = Math.sqrt(Math.log(1+cv*cv));
	final LogNormalDistribution dist2 = new LogNormalDistribution(nu,tau);
	return new Newsvendor(price,cost) {{
		_safetyfactor = dist1.inverseCumulativeProbability((price-cost)/price);
		_quantity = Math.exp(nu+tau*_safetyfactor);
		_profit = (price-cost)*mu - price*mu*dist1.cumulativeProbability(tau-_safetyfactor)+cost*mu;
	}
	@Override
	public double getProfit(double quantity) {
		double lostSales = quantity*(1-dist2.cumulativeProbability(quantity))-Math.exp(nu+tau*tau/2)*dist1.cumulativeProbability((nu+tau*tau-Math.log(quantity))/tau);
		return _price*mu -_cost*quantity + _price*lostSales;
	}
	};
}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
/** {@inheritDoc} */
public ConfidenceInterval createInterval(int numberOfTrials, int numberOfSuccesses, double confidenceLevel) {
    IntervalUtils.checkParameters(numberOfTrials, numberOfSuccesses, confidenceLevel);
    final double alpha = (1.0 - confidenceLevel) / 2;
    final NormalDistribution normalDistribution = new NormalDistribution();
    final double z = normalDistribution.inverseCumulativeProbability(1 - alpha);
    final double zSquared = FastMath.pow(z, 2);
    final double mean = (double) numberOfSuccesses / (double) numberOfTrials;

    final double factor = 1.0 / (1 + (1.0 / numberOfTrials) * zSquared);
    final double modifiedSuccessRatio = mean + (1.0 / (2 * numberOfTrials)) * zSquared;
    final double difference = z *
                              FastMath.sqrt(1.0 / numberOfTrials * mean * (1 - mean) +
                                            (1.0 / (4 * FastMath.pow(numberOfTrials, 2)) * zSquared));

    final double lowerBound = factor * (modifiedSuccessRatio - difference);
    final double upperBound = factor * (modifiedSuccessRatio + difference);
    return new ConfidenceInterval(lowerBound, upperBound, confidenceLevel);
}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
@Override
public double[] getBreakpoints(int areas) {
    if (areas < 2) {
        throw new NumberIsTooSmallException(areas, 2, true);
    }

    NormalDistribution normalDistribution = new NormalDistribution();
    int len = areas - 1;
    double[] result = new double[len];
    double searchArea = 1.0 / areas;
    for (int i = 0; i < len; i++) {
        result[i] = normalDistribution.inverseCumulativeProbability(searchArea * (i + 1));
    }

    return result;
}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
public static double wilsonApache(int positive, int negative, double confidenceLevel) {
    int numberOfTrials = positive + negative;
    double alpha = (1.0 - confidenceLevel) / 2;
    NormalDistribution normalDistribution = new NormalDistribution();
    double z = normalDistribution.inverseCumulativeProbability(1 - alpha);
    double zSquared = FastMath.pow(z, 2);
    double mean = (double) positive / (double) numberOfTrials;
    double factor = 1.0 / (1 + (1.0 / numberOfTrials) * zSquared);
    double modifiedSuccessRatio = mean + (1.0 / (2 * numberOfTrials)) * zSquared;
    final double difference = z * FastMath.sqrt(1.0 / numberOfTrials * mean * (1 - mean) + (1.0 / (4 * FastMath.pow(numberOfTrials, 2)) * zSquared));
    double lowerBound = factor * (modifiedSuccessRatio - difference);
    double upperBound = factor * (modifiedSuccessRatio + difference);
    System.out.println("lower: "+lowerBound+" upper: "+upperBound+" value: "+(lowerBound+upperBound)/2);
    return (lowerBound+upperBound)/2;

}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
public static Newsvendor solveNormalNewsvendor (final double price, final double cost, final double mu, final double sigma) {
	final NormalDistribution dist = new NormalDistribution();
	return new Newsvendor(price,cost) {{
		_safetyfactor = dist.inverseCumulativeProbability((price-cost)/price);
		_quantity = mu+sigma*_safetyfactor;
		_profit = (price-cost)*mu - price*sigma*dist.density(_safetyfactor);
	}
	@Override
	public double getProfit(double quantity) {
		double z = (quantity-mu)/sigma;
		double lostSales = sigma*(dist.density(z)-z*(1-dist.cumulativeProbability(z)));
		return _price*mu -_cost*quantity - _price*lostSales;
	}
	};
}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
/** {@inheritDoc} */
public ConfidenceInterval createInterval(int numberOfTrials, int numberOfSuccesses, double confidenceLevel) {
    IntervalUtils.checkParameters(numberOfTrials, numberOfSuccesses, confidenceLevel);
    final double alpha = (1.0 - confidenceLevel) / 2;
    final NormalDistribution normalDistribution = new NormalDistribution();
    final double z = normalDistribution.inverseCumulativeProbability(1 - alpha);
    final double zSquared = FastMath.pow(z, 2);
    final double modifiedNumberOfTrials = numberOfTrials + zSquared;
    final double modifiedSuccessesRatio = (1.0 / modifiedNumberOfTrials) * (numberOfSuccesses + 0.5 * zSquared);
    final double difference = z *
                              FastMath.sqrt(1.0 / modifiedNumberOfTrials * modifiedSuccessesRatio *
                                            (1 - modifiedSuccessesRatio));
    return new ConfidenceInterval(modifiedSuccessesRatio - difference, modifiedSuccessesRatio + difference,
                                  confidenceLevel);
}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
/** {@inheritDoc} */
public ConfidenceInterval createInterval(int numberOfTrials, int numberOfSuccesses,
                                         double confidenceLevel) {
    IntervalUtils.checkParameters(numberOfTrials, numberOfSuccesses, confidenceLevel);
    final double mean = (double) numberOfSuccesses / (double) numberOfTrials;
    final double alpha = (1.0 - confidenceLevel) / 2;
    final NormalDistribution normalDistribution = new NormalDistribution();
    final double difference = normalDistribution.inverseCumulativeProbability(1 - alpha) *
                              FastMath.sqrt(1.0 / numberOfTrials * mean * (1 - mean));
    return new ConfidenceInterval(mean - difference, mean + difference, confidenceLevel);
}
 

import org.apache.commons.math3.distribution.NormalDistribution; //导入方法依赖的package包/类
public double getEstimate(double timestamp, double alpha) {
	if (alpha == 0.5 && measurements.size() > 0) {
		return logarithmize ? Math.pow(Math.E, measurements.getLast().runtime) : Math.max(measurements.getLast().runtime, Double.MIN_NORMAL);
	}
	
	if (differences.size() < 2) {
		return 0d;
	}

	Runtime lastMeasurement = measurements.getLast();

	double variance = 0d;
	double avgDifference = sumOfDifferences / differences.size();
	for (double difference : differences) {
		variance += Math.pow(difference - avgDifference, 2d);
	}
	variance /= differences.size() - 1;

	variance *= timestamp - lastMeasurement.timestamp;

	double estimate = lastMeasurement.runtime;
	if (variance > 0d) {
		NormalDistribution nd = new NormalDistribution(lastMeasurement.runtime, Math.sqrt(variance));
		estimate = nd.inverseCumulativeProbability(alpha);
	}

	estimate = logarithmize ? Math.pow(Math.E, estimate) : Math.max(estimate, 0d);

	return estimate;
}