import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
private void cumulativeProbabilityIsOneWithRealData(final double mu, double min, double max, boolean test)
{
	double p = 0;

	UnivariateIntegrator in = new SimpsonIntegrator();

	p = in.integrate(20000, new UnivariateFunction()
	{
		public double value(double x)
		{
			double v;
			v = PoissonCalculator.likelihood(mu, x);
			//v = pgf.probability(x, mu);
			//System.out.printf("x=%f, v=%f\n", x, v);
			return v;
		}
	}, min, max);

	System.out.printf("mu=%f, p=%f\n", mu, p);
	if (test)
	{
		Assert.assertEquals(String.format("mu=%f", mu), P_LIMIT, p, 0.02);
	}
}
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
private void cumulativeProbabilityIsOneWithRealData(final double mu, int max)
{
	double p = 0;

	SimpsonIntegrator in = new SimpsonIntegrator();

	p = in.integrate(20000, new UnivariateFunction()
	{
		public double value(double x)
		{
			return PoissonLikelihoodWrapper.likelihood(mu, x);
		}
	}, 0, max);

	System.out.printf("mu=%f, p=%f\n", mu, p);
	Assert.assertEquals(String.format("mu=%f", mu), 1, p, 0.02);
}
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
protected double calcEffectiveAlpha(final double[] effectivePhis) {

        final QAlphaUnivariateFunction qAlpha = new QAlphaUnivariateFunction(effectivePhis);
        final AQAlphaUnivariateFunction aQAlpha = new AQAlphaUnivariateFunction(effectivePhis);
        final BaseAbstractUnivariateIntegrator integrator = new SimpsonIntegrator();

        final double numerator = integrator.integrate(10, aQAlpha, MIN_E_ELPHA_INTEGRATION_RANGE, MAX_E_ELPHA_INTEGRATION_RANGE);
        final double denominator = integrator.integrate(10, qAlpha, MIN_E_ELPHA_INTEGRATION_RANGE, MAX_E_ELPHA_INTEGRATION_RANGE);

        return numerator/denominator;
    }
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
/**
 * Calculates the integral of the given time series using the simpson integrator of commons math lib
 *
 * @param timeSeries       the time series as argument for the chronix function
 * @param functionValueMap the analysis and values result map
 */
@Override
public void execute(MetricTimeSeries timeSeries, FunctionValueMap functionValueMap) {

    if (timeSeries.isEmpty()) {
        functionValueMap.add(this, Double.NaN);
        return;
    }

    SimpsonIntegrator simpsonIntegrator = new SimpsonIntegrator();
    double integral = simpsonIntegrator.integrate(Integer.MAX_VALUE, x -> timeSeries.getValue((int) x), 0, timeSeries.size() - 1);

    functionValueMap.add(this, integral);
}
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
public double getVelocity(double startSpeed, double startTime, double endTime){
    UnivariateIntegrator integrator = new SimpsonIntegrator();
    double integralAddition = 0;
    if (!dEqual(startTime,endTime)) {
        try {
            integralAddition = startTime * integrator.integrate(10, v -> getAccel(v), startTime, endTime);
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
    return startSpeed + integralAddition;
}
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
private void cumulativeProbabilityIsOneWithRealAbove4(final double gain, final double mu, int min, int max)
{
	final double o = mu * gain;

	final PoissonFunction f = new PoissonFunction(1.0 / gain, true);
	double p = 0;
	SimpsonIntegrator in = new SimpsonIntegrator(3, 30);

	try
	{
		p = in.integrate(Integer.MAX_VALUE, new UnivariateFunction()
		{
			public double value(double x)
			{
				return f.likelihood(x, o);
			}
		}, min, max);

		System.out.printf("g=%f, mu=%f, o=%f, p=%f\n", gain, mu, o, p);
		Assert.assertEquals(String.format("g=%f, mu=%f", gain, mu), 1, p, 0.02);
	}
	catch (TooManyEvaluationsException e)
	{
		//double inc = max / 20000.0;
		//for (double x = 0; x <= max; x += inc)
		//{
		//	final double pp = f.likelihood(x, o);
		//	//System.out.printf("g=%f, mu=%f, o=%f, p=%f\n", gain, mu, o, pp);
		//	p += pp;
		//}
		//System.out.printf("g=%f, mu=%f, o=%f, p=%f\n", gain, mu, o, p);
		Assert.assertFalse(e.getMessage(), true);
	}
}
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
private void cumulativeProbabilityIsOneWithRealData(final double mu, double min, double max, boolean test)
{
	double p = 0;

	// Test using a standard Poisson-Gaussian convolution
	//min = -max;
	//final PoissonGaussianFunction pgf = PoissonGaussianFunction.createWithVariance(1, 1, VAR);

	UnivariateIntegrator in = new SimpsonIntegrator();

	p = in.integrate(20000, new UnivariateFunction()
	{
		public double value(double x)
		{
			double v;
			v = SCMOSLikelihoodWrapper.likelihood(mu, VAR, G, O, x);
			//v = pgf.probability(x, mu);
			//System.out.printf("x=%f, v=%f\n", x, v);
			return v;
		}
	}, min, max);

	//System.out.printf("mu=%f, p=%f\n", mu, p);
	if (test)
	{
		Assert.assertEquals(String.format("mu=%f", mu), P_LIMIT, p, 0.02);
	}
}
 

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator; //导入依赖的package包/类
private static synchronized void createAiryDistribution()
{
	if (spline != null)
		return;
	
	final double relativeAccuracy = 1e-4;
	final double absoluteAccuracy = 1e-8;
	final int minimalIterationCount = 3;
	final int maximalIterationCount = 32;

	UnivariateIntegrator integrator = new SimpsonIntegrator(relativeAccuracy, absoluteAccuracy,
			minimalIterationCount, maximalIterationCount);
	UnivariateFunction f = new UnivariateFunction()
	{
		public double value(double x)
		{
			// The pattern profile is in one dimension. 
			// Multiply by the perimeter of a circle to convert to 2D volume then normalise by 4 pi
			//return AiryPattern.intensity(x) * 2 * Math.PI * x / (4 * Math.PI);
			return AiryPattern.intensity(x) * 0.5 * x;
		}
	};

	// Integrate up to a set number of dark rings
	int samples = 1000;
	final double step = RINGS[SAMPLE_RINGS] / samples;
	double to = 0, from = 0;
	r = new double[samples + 1];
	sum = new double[samples + 1];
	for (int i = 1; i < sum.length; i++)
	{
		from = to;
		r[i] = to = step * i;
		sum[i] = integrator.integrate(2000, f, from, to) + sum[i - 1];
	}

	if (DoubleEquality.relativeError(sum[samples], POWER[SAMPLE_RINGS]) > 1e-3)
		throw new RuntimeException("Failed to create the Airy distribution");

	SplineInterpolator si = new SplineInterpolator();
	spline = si.interpolate(sum, r);
}