@Override public DoubleFunction1D[] getPolynomials(int n) { return getPolynomials(n, 0); }
@Override public Pair<DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n) { return getPolynomialsAndFirstDerivative(n, 0); }
/** * Gets the polynomials and derivative. * * @param n the n value * @param alpha the alpha value * @return the result */ public Pair<DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n, double alpha) { ArgChecker.isTrue(n >= 0); @SuppressWarnings("unchecked") Pair<DoubleFunction1D, DoubleFunction1D>[] polynomials = new Pair[n + 1]; DoubleFunction1D p, dp, p1, p2; for (int i = 0; i <= n; i++) { if (i == 0) { polynomials[i] = Pair.of(getOne(), getZero()); } else if (i == 1) { polynomials[i] = Pair.of(F1, DF1); } else { p1 = polynomials[i - 1].getFirst(); p2 = polynomials[i - 2].getFirst(); p = (p1.multiply(2. * i + alpha - 1).subtract(p1.multiply(getX())).subtract(p2.multiply((i - 1. + alpha))).divide(i)); dp = (p.multiply(i).subtract(p1.multiply(i + alpha))).divide(getX()); polynomials[i] = Pair.of(p, dp); } } return polynomials; }
/** * Gets the polynomials. * * @param n the n value * @param alpha the alpha value * @return the result */ public DoubleFunction1D[] getPolynomials(int n, double alpha) { ArgChecker.isTrue(n >= 0); DoubleFunction1D[] polynomials = new DoubleFunction1D[n + 1]; for (int i = 0; i <= n; i++) { if (i == 0) { polynomials[i] = getOne(); } else if (i == 1) { polynomials[i] = new RealPolynomialFunction1D(new double[] {1 + alpha, -1}); } else { polynomials[i] = (polynomials[i - 1].multiply(2. * i + alpha - 1).subtract(polynomials[i - 1].multiply(getX())) .subtract(polynomials[i - 2].multiply((i - 1. + alpha))).divide(i)); } } return polynomials; }
@Test(expectedExceptions = IllegalArgumentException.class) public void testBadN1() { LAGUERRE.getPolynomials(-3); }
@Test public void testAlpha2() { final int n = 14; final Pair<DoubleFunction1D, DoubleFunction1D>[] polynomialAndDerivative1 = LAGUERRE.getPolynomialsAndFirstDerivative(n); final Pair<DoubleFunction1D, DoubleFunction1D>[] polynomialAndDerivative2 = LAGUERRE.getPolynomialsAndFirstDerivative(n, 0); for (int i = 0; i < n; i++) { assertTrue(polynomialAndDerivative1[i].getFirst() instanceof RealPolynomialFunction1D); assertTrue(polynomialAndDerivative2[i].getFirst() instanceof RealPolynomialFunction1D); final RealPolynomialFunction1D first = (RealPolynomialFunction1D) polynomialAndDerivative1[i].getFirst(); final RealPolynomialFunction1D second = (RealPolynomialFunction1D) polynomialAndDerivative2[i].getFirst(); assertEquals(first, second); } } }
@Test(expectedExceptions = IllegalArgumentException.class) public void testBadN2() { LAGUERRE.getPolynomials(-3, 1); }
/** * {@inheritDoc} */ @Override public GaussianQuadratureData generate(int n) { ArgChecker.isTrue(n > 0); Pair<DoubleFunction1D, DoubleFunction1D>[] polynomials = LAGUERRE.getPolynomialsAndFirstDerivative(n, _alpha); Pair<DoubleFunction1D, DoubleFunction1D> pair = polynomials[n]; DoubleFunction1D p1 = polynomials[n - 1].getFirst(); DoubleFunction1D function = pair.getFirst(); DoubleFunction1D derivative = pair.getSecond(); double[] x = new double[n]; double[] w = new double[n]; double root = 0; for (int i = 0; i < n; i++) { root = ROOT_FINDER.getRoot(function, derivative, getInitialRootGuess(root, i, n, x)); x[i] = root; w[i] = -GAMMA_FUNCTION.applyAsDouble(_alpha + n) / CombinatoricsUtils.factorialDouble(n) / (derivative.applyAsDouble(root) * p1.applyAsDouble(root)); } return new GaussianQuadratureData(x, w); }
@Test public void test() { DoubleFunction1D[] l = LAGUERRE.getPolynomials(0); assertEquals(l.length, 1); final double x = 1.23; assertEquals(l[0].applyAsDouble(x), 1, EPS); l = LAGUERRE.getPolynomials(1); assertEquals(l.length, 2); assertEquals(l[1].applyAsDouble(x), 1 - x, EPS); for (int i = 0; i <= 6; i++) { l = LAGUERRE.getPolynomials(i); for (int j = 0; j <= i; j++) { assertEquals(L[j].applyAsDouble(x), l[j].applyAsDouble(x), EPS); } } }
@Test public void testAlpha1() { DoubleFunction1D[] l1, l2; final double x = 2.34; for (int i = 0; i <= 6; i++) { l1 = LAGUERRE.getPolynomials(i, 0); l2 = LAGUERRE.getPolynomials(i); for (int j = 0; j <= i; j++) { assertEquals(l1[j].applyAsDouble(x), l2[j].applyAsDouble(x), EPS); } } final double alpha = 3.45; l1 = LAGUERRE.getPolynomials(6, alpha); final DoubleFunction1D f0 = d -> 1d; final DoubleFunction1D f1 = d -> 1 + alpha - d; final DoubleFunction1D f2 = d -> d * d / 2 - (alpha + 2) * d + (alpha + 2) * (alpha + 1) / 2.; final DoubleFunction1D f3 = d -> -d * d * d / 6 + (alpha + 3) * d * d / 2 - (alpha + 2) * (alpha + 3) * d / 2 + (alpha + 1) * (alpha + 2) * (alpha + 3) / 6; assertEquals(l1[0].applyAsDouble(x), f0.applyAsDouble(x), EPS); assertEquals(l1[1].applyAsDouble(x), f1.applyAsDouble(x), EPS); assertEquals(l1[2].applyAsDouble(x), f2.applyAsDouble(x), EPS); assertEquals(l1[3].applyAsDouble(x), f3.applyAsDouble(x), EPS); }