@Override public double applyAsDouble(double x) { return (DoubleFunction1D.this.applyAsDouble(x + eps) - DoubleFunction1D.this.applyAsDouble(x - eps)) / 2 / eps; }
/** * Returns a function that calculates the first derivative. * <p> * The method used is central finite difference, with $\epsilon = 10^{-5}$. * Implementing classes can override this method to return a function that * is the exact functional representation of the first derivative. * * @return a function that calculates the first derivative of this function */ public default DoubleFunction1D derivative() { return derivative(FiniteDifferenceType.CENTRAL, 1e-5); }
/** * 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; }
@Override public DoubleFunction1D[] getPolynomials(int n) { ArgChecker.isTrue(n >= 0); DoubleFunction1D[] polynomials = new DoubleFunction1D[n + 1]; for (int i = 0; i <= n; i++) { if (i == 0) { polynomials[i] = F0; } else if (i == 1) { polynomials[i] = polynomials[0].multiply(Math.sqrt(2)).multiply(getX()); } else { polynomials[i] = polynomials[i - 1].multiply(getX()).multiply(Math.sqrt(2. / i)) .subtract(polynomials[i - 2].multiply(Math.sqrt((i - 1.) / i))); } } return polynomials; }
p1 = polynomials[j].getFirst(); p2 = polynomials[j - 1].getFirst(); DoubleFunction1D temp1 = p1.multiply(getB(alpha, beta, j)); DoubleFunction1D temp2 = p1.multiply(getX()).multiply(getC(alpha, beta, j)); DoubleFunction1D temp3 = p2.multiply(getD(alpha, beta, j)); p = (temp1.add(temp2).add(temp3)).divide(getA(alpha, beta, j)); dp = p.derivative(); polynomials[i] = Pair.of(p, dp);
@Test public void testConversion() { final Function<Double, Double> f1 = x -> x * x * x + 2 * x * x - 7 * x + 12; final DoubleFunction1D f2 = DoubleFunction1D.from(f1); for (int i = 0; i < 100; i++) { final double x = Math.random(); assertEquals(f2.applyAsDouble(x), F1.applyAsDouble(x), 0); assertEquals(f2.derivative().applyAsDouble(x), F1.derivative().applyAsDouble(x), 0); } } }
/** * Calculates polynomials. * @param n the n value * @param alpha the alpha value * @param beta the beta value * @return the result */ public DoubleFunction1D[] getPolynomials(int n, double alpha, double beta) { 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[] {(alpha - beta) / 2, (alpha + beta + 2) / 2}); } else { int j = i - 1; polynomials[i] = (polynomials[j].multiply(getB(alpha, beta, j)).add(polynomials[j].multiply(getX()).multiply(getC(alpha, beta, j)) .add(polynomials[j - 1].multiply(getD(alpha, beta, j))))) .divide(getA(alpha, beta, j)); } } return polynomials; }
@Override public Pair<DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n) { ArgChecker.isTrue(n >= 0); @SuppressWarnings("unchecked") Pair<DoubleFunction1D, DoubleFunction1D>[] polynomials = new Pair[n + 1]; DoubleFunction1D p, dp; for (int i = 0; i <= n; i++) { if (i == 0) { polynomials[i] = Pair.of(getOne(), getZero()); } else if (i == 1) { polynomials[i] = Pair.of(getX(), getOne()); } else { p = (polynomials[i - 1].getFirst() .multiply(getX()) .multiply(2 * i - 1) .subtract(polynomials[i - 2].getFirst().multiply(i - 1))).multiply(1. / i); dp = p.derivative(); polynomials[i] = Pair.of(p, dp); } } return polynomials; }
@Test public void testDerivative() { assertEquals(F1.derivative().applyAsDouble(X), DF1.applyAsDouble(X), 1e-3); assertEquals(F2.derivative().applyAsDouble(X), DF2.applyAsDouble(X), 1e-3); assertEquals(F1.derivative(FiniteDifferenceType.CENTRAL, 1e-5).applyAsDouble(X), DF1.applyAsDouble(X), 1e-3); assertEquals(F2.derivative(FiniteDifferenceType.CENTRAL, 1e-5).applyAsDouble(X), DF2.applyAsDouble(X), 1e-3); assertEquals(F1.derivative(FiniteDifferenceType.FORWARD, 1e-5).applyAsDouble(X), DF1.applyAsDouble(X), 1e-3); assertEquals(F2.derivative(FiniteDifferenceType.FORWARD, 1e-5).applyAsDouble(X), DF2.applyAsDouble(X), 1e-3); assertEquals(F1.derivative(FiniteDifferenceType.BACKWARD, 1e-5).applyAsDouble(X), DF1.applyAsDouble(X), 1e-3); assertEquals(F2.derivative(FiniteDifferenceType.BACKWARD, 1e-5).applyAsDouble(X), DF2.applyAsDouble(X), 1e-3); assertEquals(F3.derivative().applyAsDouble(X), DF1.applyAsDouble(X), 1e-15); assertEquals(F4.derivative().applyAsDouble(X), DF2.applyAsDouble(X), 1e-15); }
public Double getRoot(Function<Double, Double> function, Double x) { ArgChecker.notNull(function, "function"); ArgChecker.notNull(x, "x"); DoubleFunction1D f = DoubleFunction1D.from(function); return getRoot(f, f.derivative(), x); }
@Test public void testAdd() { assertEquals(F1.add(F2).applyAsDouble(X), F1.applyAsDouble(X) + F2.applyAsDouble(X), EPS); assertEquals(F1.add(A).applyAsDouble(X), F1.applyAsDouble(X) + A, EPS); }
@Test public void testSubtract() { assertEquals(F1.subtract(F2).applyAsDouble(X), F1.applyAsDouble(X) - F2.applyAsDouble(X), EPS); assertEquals(F1.subtract(A).applyAsDouble(X), F1.applyAsDouble(X) - A, EPS); }
@Test public void testDivide() { assertEquals(F1.divide(F2).applyAsDouble(X), F1.applyAsDouble(X) / F2.applyAsDouble(X), EPS); assertEquals(F1.divide(A).applyAsDouble(X), F1.applyAsDouble(X) / A, EPS); }
@Test public void testMultiply() { assertEquals(F1.multiply(F2).applyAsDouble(X), F1.applyAsDouble(X) * F2.applyAsDouble(X), EPS); assertEquals(F1.multiply(A).applyAsDouble(X), F1.applyAsDouble(X) * A, EPS); }
/** * Uses the function and its derivative. This method uses an initial guess for the root, rather than bounds. * @param function The function, not null * @param derivative The derivative, not null * @param x The initial guess for the root, not null * @return The root * @throws MathException If the root is not found in 1000 attempts. */ public Double getRoot(Function<Double, Double> function, Function<Double, Double> derivative, Double x) { return getRoot(DoubleFunction1D.from(function), DoubleFunction1D.from(derivative), x); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testMultiplyNull() { F1.multiply(null); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testSubtractNull() { F1.subtract(null); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testAddNull() { F1.add(null); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testDivideNull() { F1.divide(null); }
@Override public DoubleFunction1D[] getPolynomials(int n) { 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] = TWO_X; } else { polynomials[i] = polynomials[i - 1] .multiply(2) .multiply(getX()) .subtract(polynomials[i - 2].multiply(2 * i - 2)); } } return polynomials; }