private Double integration(Function<Double, Double> f, Double lower, Double upper) { double res = integrator.integrate(f, lower, upper); return integrationRec(f, lower, upper, res, MAX_IT); }
@Override public Double integrate(BiFunction<Double, Double, Double> f, Double[] lower, Double[] upper) { return _integrator1D.integrate(innerIntegral(f, lower[0], upper[0]), lower[1], upper[1]); }
/** * Creates an instance. * @param n the value */ public GaussLaguerreQuadratureIntegrator1D(int n) { super(n, new GaussLaguerreWeightAndAbscissaFunction()); }
@Test public void testGaussHermite2() { final RungeKuttaIntegrator1D rk = new RungeKuttaIntegrator1D(1e-15); final Double expected = 2 * rk.integrate(COS_EXP, 0., 10.); final GaussHermiteQuadratureIntegrator1D gh = new GaussHermiteQuadratureIntegrator1D(11); final double res1 = gh.integrateFromPolyFunc(COS); assertEquals(expected, res1, 1e-15); //11 points gets you machine precision final double res2 = gh.integrate(COS_EXP, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY); assertEquals(expected, res2, 1e-15); }
/** * */ @Test public void sampleDataTest() { final Integrator1D<Double, Double> localInt = new AdaptiveCompositeIntegrator1D(new SimpsonIntegrator1D(), 10., 1.e-4); assertEquals(-0.368924186060527, localInt.integrate(sampleFunc(), 1.1, 3.), 1.e-6); // answer from quadpack }
@Test public void testCutoff() { final double eps = 1e-9; final int minSteps = 10; final Integrator1D<Double, Double> integrator = new RungeKuttaIntegrator1D(eps, eps, minSteps); final double lower = -1.0; final double upper = 1.0; assertEquals(0.0, integrator.integrate(SIN_INV_X, lower, upper), eps); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullFunction() { getIntegrator().integrate(null, LOWER, UPPER); }
@Test public void test() { assertResults(F.generate(2), X2, W2); assertResults(F.generate(3), X3, W3); assertResults(F.generate(4), X4, W4); assertResults(F.generate(5), X5, W5); }
@Test public void test() { assertResults(F.generate(2), X2, W2); assertResults(F.generate(3), X3, W3); assertResults(F.generate(4), X4, W4); assertResults(F.generate(5), X5, W5); }
@Test public void test() { assertResults(F.generate(2), X2, W2); assertResults(F.generate(3), X3, W3); assertResults(F.generate(4), X4, W4); } }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullFunction() { getFunction().generate(-1); }
@Test public void testGaussLaguerre() { final double upper = Double.POSITIVE_INFINITY; final double lower = 0; final Integrator1D<Double, Double> integrator = new GaussLaguerreQuadratureIntegrator1D(15); assertEquals(0.5, integrator.integrate(DF2, lower, upper), EPS); }
@Test public void testGaussLegendre() { double upper = 2; double lower = -6; final Integrator1D<Double, Double> integrator = new GaussLegendreQuadratureIntegrator1D(6); assertEquals(F1.apply(upper) - F1.apply(lower), integrator.integrate(DF1, lower, upper), EPS); lower = -0.56; upper = 1.4; assertEquals(F1.apply(upper) - F1.apply(lower), integrator.integrate(DF1, lower, upper), EPS); }
/** * The inner integral function of the repeated 1-D integrations. * For a given $y$ it returns $\int_{x_1}^{x_2} f(x,y) dx$. * * @param f the bi-function * @param lower the lower bound (for the inner-first variable) * @param upper the upper bound (for the inner-first variable) * @return the inner integral function */ private Function<Double, Double> innerIntegral(BiFunction<Double, Double, Double> f, Double lower, Double upper) { return y -> _integrator1D.integrate(x -> f.apply(x, y), lower, upper); }
/** * {@inheritDoc} */ @Override public Double integrate(Function<Double, Double> function, Double lower, Double upper) { ArgChecker.notNull(function, "function"); ArgChecker.notNull(lower, "lower"); ArgChecker.notNull(upper, "upper"); Function<Double, Double> integral = getIntegralFunction(function, lower, upper); return integrateFromPolyFunc(integral); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullLowerBound() { getIntegrator().integrate(DF, null, UPPER); }
private double integrationRec(Function<Double, Double> f, double lower, double upper, double res, double counter) { double localTol = gain * tol; double half = 0.5 * (lower + upper); double newResDw = integrator.integrate(f, lower, half); double newResUp = integrator.integrate(f, half, upper); double newRes = newResUp + newResDw; if (Math.abs(res - newRes) < localTol || counter == 0 || (Math.abs(res) < 1.e-14 && Math.abs(newResUp) < 1.e-14 && Math.abs(newResDw) < 1.e-14)) { return newRes + (newRes - res) / gain; } return integrationRec(f, lower, half, newResDw, counter - 1) + integrationRec(f, half, upper, newResUp, counter - 1); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullUpperBoundValue() { INTEGRATOR.integrate(F, L, new Double[] {null }); } }
/** * Creates an instance. * * @param n the value * @param alpha the alpha */ public GaussLaguerreQuadratureIntegrator1D(int n, double alpha) { super(n, new GaussLaguerreWeightAndAbscissaFunction(alpha)); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullUpperBound() { getIntegrator().integrate(DF, LOWER, null); }