import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
/**
 * Compute the n-th stage integral.
 *
 * @param n Number of steps.
 * @return the value of n-th stage integral.
 * @throws TooManyEvaluationsException if the maximum number of evaluations
 * is exceeded.
 */
private double stage(final int n)
    throws TooManyEvaluationsException {
    // Function to be integrated is stored in the base class.
    final UnivariateFunction f = new UnivariateFunction() {
            public double value(double x)
                throws MathIllegalArgumentException, TooManyEvaluationsException {
                return computeObjectiveValue(x);
            }
        };

    final double min = getMin();
    final double max = getMax();
    final double step = (max - min) / n;

    double sum = 0;
    for (int i = 0; i < n; i++) {
        // Integrate over each sub-interval [a, b].
        final double a = min + i * step;
        final double b = a + step;
        final GaussIntegrator g = FACTORY.legendreHighPrecision(numberOfPoints, a, b);
        sum += g.integrate(f);
    }

    return sum;
}
 

import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
public static double integrate2d(final ToDoubleBiFunction<Double, Double> getIntegrand,
                          final double xLowerBound, final double xUpperBound, final int xNumPoints,
                          final double yLowerBound, final double yUpperBound, final int yNumPoints){
    final GaussIntegrator xIntegrator = integratorFactory.legendre(xNumPoints, xLowerBound, xUpperBound);
    final GaussIntegrator yIntegrator = integratorFactory.legendre(yNumPoints, yLowerBound, yUpperBound);

    final double[] xIntegrationWeights = new IndexRange(0, xNumPoints).mapToDouble(xIntegrator::getWeight);
    final double[] xAbscissas = new IndexRange(0, xNumPoints).mapToDouble(xIntegrator::getPoint);

    final double[] yIntegrationWeights = new IndexRange(0, yNumPoints).mapToDouble(yIntegrator::getWeight);
    final double[] yAbscissas = new IndexRange(0, yNumPoints).mapToDouble(yIntegrator::getPoint);

    double integral = 0;
    for (int i = 0; i < xNumPoints; i++) {
        final double x = xAbscissas[i];
        for (int j = 0; j < yNumPoints; j++) {
            final double y = yAbscissas[j];
            final double integrand = getIntegrand.applyAsDouble(x, y);
            integral += xIntegrationWeights[i] * yIntegrationWeights[j] * integrand;
        }
    }

    return integral;
}
 

import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
/**
 * Initilizes the quadrature for calculating allele ratio integrals in
 * {@link HeterogeneousHeterozygousPileupPriorModel#getHetLogLikelihood(List)}
 *
 * @param numIntegPoints  number of points in the quadrature
 */
private void initializeIntegrationQuadrature(final int numIntegPoints) {
    /* get Gauss-Legendre quadrature factory of order @numIntegPoints */
    final GaussIntegratorFactory integratorFactory = new GaussIntegratorFactory();
    final GaussIntegrator gaussIntegrator = integratorFactory.legendre(numIntegPoints,
            minHetAlleleFraction, 1.0 - minHetAlleleFraction);

    /* abscissas */
    gaussIntegrationAbscissas.clear();
    gaussIntegrationAbscissas.addAll(IntStream.range(0, numIntegPoints).
            mapToDouble(gaussIntegrator::getPoint).boxed().collect(Collectors.toList()));

    /* weights */
    gaussIntegrationWeights.clear();
    gaussIntegrationWeights.addAll(IntStream.range(0, numIntegPoints).
            mapToDouble(gaussIntegrator::getWeight).boxed().collect(Collectors.toList()));

    /* log of weights */
    gaussIntegrationLogWeights.clear();
    gaussIntegrationLogWeights.addAll(gaussIntegrationWeights.stream().
            mapToDouble(FastMath::log).boxed().collect(Collectors.toList()));
}
 

import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
/**
 * Compute the n-th stage integral.
 *
 * @param n Number of steps.
 * @return the value of n-th stage integral.
 * @throws TooManyEvaluationsException if the maximum number of evaluations
 * is exceeded.
 */
private double stage(final int n)
    throws TooManyEvaluationsException {
    // Function to be integrated is stored in the base class.
    final UnivariateFunction f = new UnivariateFunction() {
            public double value(double x) {
                return computeObjectiveValue(x);
            }
        };

    final double min = getMin();
    final double max = getMax();
    final double step = (max - min) / n;

    double sum = 0;
    for (int i = 0; i < n; i++) {
        // Integrate over each sub-interval [a, b].
        final double a = min + i * step;
        final double b = a + step;
        final GaussIntegrator g = FACTORY.legendreHighPrecision(numberOfPoints, a, b);
        sum += g.integrate(f);
    }

    return sum;
}
 

import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
/**
 * Compute the n-th stage integral.
 *
 * @param n Number of steps.
 * @return the value of n-th stage integral.
 * @throws TooManyEvaluationsException if the maximum number of evaluations
 * is exceeded.
 */
private double stage(final int n)
    throws TooManyEvaluationsException {
    // Function to be integrated is stored in the base class.
    final UnivariateFunction f = new UnivariateFunction() {
            /** {@inheritDoc} */
            public double value(double x)
                throws MathIllegalArgumentException, TooManyEvaluationsException {
                return computeObjectiveValue(x);
            }
        };

    final double min = getMin();
    final double max = getMax();
    final double step = (max - min) / n;

    double sum = 0;
    for (int i = 0; i < n; i++) {
        // Integrate over each sub-interval [a, b].
        final double a = min + i * step;
        final double b = a + step;
        final GaussIntegrator g = FACTORY.legendreHighPrecision(numberOfPoints, a, b);
        sum += g.integrate(f);
    }

    return sum;
}
 

import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
public static double integrate(final DoubleFunction<Double> getIntegrand,
                               final double lowerBound,
                               final double upperBound,
                               final int numPoints) {
    final GaussIntegrator integrator = integratorFactory.legendre(numPoints, lowerBound, upperBound);

    final double[] gaussIntegrationWeights = new IndexRange(0, numPoints).mapToDouble(integrator::getWeight);
    final double[] gaussIntegrationAbscissas = new IndexRange(0, numPoints).mapToDouble(integrator::getPoint);
    final double[] integrands = MathUtils.applyToArrayInPlace(gaussIntegrationAbscissas,getIntegrand::apply);

    return GATKProtectedMathUtils.dotProduct(gaussIntegrationWeights, integrands);
}
 

import org.apache.commons.math3.analysis.integration.gauss.GaussIntegrator; //导入依赖的package包/类
public static double integrate(final DoubleFunction<Double> getIntegrand,
                               final double lowerBound,
                               final double upperBound,
                               final int numPoints) {
    final GaussIntegrator integrator = integratorFactory.legendre(numPoints, lowerBound, upperBound);

    final double[] gaussIntegrationWeights = new IndexRange(0, numPoints).mapToDouble(integrator::getWeight);
    final double[] gaussIntegrationAbscissas = new IndexRange(0, numPoints).mapToDouble(integrator::getPoint);
    final double[] integrands = MathUtils.applyToArrayInPlace(gaussIntegrationAbscissas,getIntegrand::apply);

    return MathUtils.dotProduct(gaussIntegrationWeights, integrands);
}