public virtual GaussianQuadratureData generate(int n) { ArgChecker.isTrue(n > 0); double[] x = new double[n]; double[] w = new double[n]; bool odd = n % 2 != 0; int m = (n + 1) / 2 - (odd ? 1 : 0); Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = HERMITE.getPolynomialsAndFirstDerivative(n); Pair <DoubleFunction1D, DoubleFunction1D> pair = polynomials[n]; DoubleFunction1D function = pair.First; DoubleFunction1D derivative = pair.Second; double root = 0; for (int i = 0; i < m; i++) { root = getInitialRootGuess(root, i, n, x); root = ROOT_FINDER.getRoot(function, derivative, root).Value; double dp = derivative.applyAsDouble(root); x[i] = -root; x[n - 1 - i] = root; w[i] = 2.0 / (dp * dp); w[n - 1 - i] = w[i]; } if (odd) { double dp = derivative.applyAsDouble(0.0); w[m] = 2.0 / dp / dp; } return(new GaussianQuadratureData(x, w)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testAlpha1() public virtual void testAlpha1() { DoubleFunction1D[] l1, l2; const 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); } } const double alpha = 3.45; l1 = LAGUERRE.getPolynomials(6, alpha); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.math.impl.function.DoubleFunction1D f0 = d -> 1d; DoubleFunction1D f0 = d => 1d; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.math.impl.function.DoubleFunction1D f1 = d -> 1 + alpha - d; DoubleFunction1D f1 = d => 1 + alpha - d; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.math.impl.function.DoubleFunction1D f2 = d -> d * d / 2 - (alpha + 2) * d + (alpha + 2) * (alpha + 1) / 2.0; DoubleFunction1D f2 = d => d * d / 2 - (alpha + 2) * d + (alpha + 2) * (alpha + 1) / 2.0; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.math.impl.function.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; 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); }
/// <summary> /// Subtracts a function from the polynomial. /// <para> /// If the function is not a <seealso cref="RealPolynomialFunction1D"/> then the subtract takes place /// as in <seealso cref="DoubleFunction1D"/>, otherwise the result will also be a polynomial. /// /// </para> /// </summary> /// <param name="f"> the function to subtract </param> /// <returns> $P-f$ </returns> public override DoubleFunction1D subtract(DoubleFunction1D f) { ArgChecker.notNull(f, "function"); if (f is RealPolynomialFunction1D) { RealPolynomialFunction1D p1 = (RealPolynomialFunction1D)f; double[] c = _coefficients; double[] c1 = p1.Coefficients; int m = c.Length; int n = c1.Length; int min = Math.Min(m, n); int max = Math.Max(m, n); double[] c3 = new double[max]; for (int i = 0; i < min; i++) { c3[i] = c[i] - c1[i]; } for (int i = min; i < max; i++) { if (m == max) { c3[i] = c[i]; } else { c3[i] = -c1[i]; } } return(new RealPolynomialFunction1D(c3)); } return(DoubleFunction1D.this.subtract(f)); }
public override Pair <DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n) { ArgChecker.isTrue(n >= 0); //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") com.opengamma.strata.collect.tuple.Pair<com.opengamma.strata.math.impl.function.DoubleFunction1D, com.opengamma.strata.math.impl.function.DoubleFunction1D>[] polynomials = new com.opengamma.strata.collect.tuple.Pair[n + 1]; Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = new Pair[n + 1]; DoubleFunction1D p, dp, p1, p2; double sqrt2 = Math.Sqrt(2); DoubleFunction1D x = X; for (int i = 0; i <= n; i++) { if (i == 0) { polynomials[i] = Pair.of((DoubleFunction1D)F0, Zero); } else if (i == 1) { polynomials[i] = Pair.of(polynomials[0].First.multiply(sqrt2).multiply(x), (DoubleFunction1D)DF1); } else { p1 = polynomials[i - 1].First; p2 = polynomials[i - 2].First; p = p1.multiply(x).multiply(Math.Sqrt(2.0 / i)).subtract(p2.multiply(Math.Sqrt((i - 1.0) / i))); dp = p1.multiply(Math.Sqrt(2 * i)); polynomials[i] = Pair.of(p, dp); } } return(polynomials); }
/// <summary> /// Calculates polynomials and derivative. </summary> /// <param name="n"> the n value </param> /// <param name="alpha"> the alpha value </param> /// <param name="beta"> the beta value </param> /// <returns> the result </returns> public virtual Pair <DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n, double alpha, double beta) { ArgChecker.isTrue(n >= 0); //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") com.opengamma.strata.collect.tuple.Pair<com.opengamma.strata.math.impl.function.DoubleFunction1D, com.opengamma.strata.math.impl.function.DoubleFunction1D>[] polynomials = new com.opengamma.strata.collect.tuple.Pair[n + 1]; 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(One, Zero); } else if (i == 1) { double a1 = (alpha + beta + 2) / 2; polynomials[i] = Pair.of((DoubleFunction1D) new RealPolynomialFunction1D(new double[] { (alpha - beta) / 2, a1 }), (DoubleFunction1D) new RealPolynomialFunction1D(new double[] { a1 })); } else { int j = i - 1; p1 = polynomials[j].First; p2 = polynomials[j - 1].First; DoubleFunction1D temp1 = p1.multiply(getB(alpha, beta, j)); DoubleFunction1D temp2 = p1.multiply(X).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); } } return(polynomials); }
//------------------------------------------------------------------------- public virtual double?getRoot(System.Func <double, double> function, double?x) { ArgChecker.notNull(function, "function"); ArgChecker.notNull(x, "x"); DoubleFunction1D f = DoubleFunction1D.from(function); return(getRoot(f, f.derivative(), x)); }
/// <summary> /// Uses the function and its derivative. </summary> /// <param name="function"> The function, not null </param> /// <param name="derivative"> The derivative, not null </param> /// <param name="x1"> The first bound of the root, not null </param> /// <param name="x2"> The second bound of the root, not null </param> /// <returns> The root </returns> /// <exception cref="MathException"> If the root is not found in 1000 attempts; if the Newton /// step takes the estimate for the root outside the original bounds. </exception> public virtual double?getRoot(DoubleFunction1D function, DoubleFunction1D derivative, double?x1, double?x2) { checkInputs(function, x1, x2); ArgChecker.notNull(derivative, "derivative function"); double y1 = function.applyAsDouble(x1); if (Math.Abs(y1) < _accuracy) { return(x1); } double y2 = function.applyAsDouble(x2); if (Math.Abs(y2) < _accuracy) { return(x2); } double x = (x1 + x2) / 2; double x3 = y2 < 0 ? x2.Value : x1.Value; double x4 = y2 < 0 ? x1.Value : x2.Value; double xLower = x1 > x2 ? x2 : x1; double xUpper = x1 > x2 ? x1 : x2; for (int i = 0; i < MAX_ITER; i++) { double y = function.applyAsDouble(x); double dy = derivative.applyAsDouble(x); double dx = -y / dy; if (Math.Abs(dx) <= _accuracy) { return(x + dx); } x += dx; if (x < xLower || x > xUpper) { dx = (x4 - x3) / 2; x = x3 + dx; } if (y < 0) { x3 = x; } else { x4 = x; } } throw new MathException("Could not find root in " + MAX_ITER + " attempts"); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testConversion() public virtual void testConversion() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.function.Function<double, double> f1 = x -> x * x * x + 2 * x * x - 7 * x + 12; System.Func <double, double> f1 = x => x * x * x + 2 * x * x - 7 * x + 12; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final DoubleFunction1D f2 = DoubleFunction1D.from(f1); DoubleFunction1D f2 = DoubleFunction1D.from(f1); for (int i = 0; i < 100; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double x = Math.random(); double x = GlobalRandom.NextDouble; assertEquals(f2.applyAsDouble(x), F1.applyAsDouble(x), 0); assertEquals(f2.derivative().applyAsDouble(x), F1.derivative().applyAsDouble(x), 0); } }
/// <summary> /// Adds a function to the polynomial. /// If the function is not a <seealso cref="RealPolynomialFunction1D"/> then the addition takes /// place as in <seealso cref="DoubleFunction1D"/>, otherwise the result will also be a polynomial. /// </summary> /// <param name="f"> the function to add </param> /// <returns> $P+f$ </returns> public override DoubleFunction1D add(DoubleFunction1D f) { ArgChecker.notNull(f, "function"); if (f is RealPolynomialFunction1D) { RealPolynomialFunction1D p1 = (RealPolynomialFunction1D)f; double[] c1 = p1.Coefficients; double[] c = _coefficients; int n = c1.Length; bool longestIsNew = n > _n; double[] c3 = longestIsNew ? Arrays.copyOf(c1, n) : Arrays.copyOf(c, _n); for (int i = 0; i < (longestIsNew ? _n : n); i++) { c3[i] += longestIsNew ? c[i] : c1[i]; } return(new RealPolynomialFunction1D(c3)); } return(DoubleFunction1D.this.add(f)); }
/// <summary> /// Uses the function and its derivative. This method uses an initial guess for the root, rather than bounds. </summary> /// <param name="function"> The function, not null </param> /// <param name="derivative"> The derivative, not null </param> /// <param name="x"> The initial guess for the root, not null </param> /// <returns> The root </returns> /// <exception cref="MathException"> If the root is not found in 1000 attempts. </exception> public virtual double?getRoot(DoubleFunction1D function, DoubleFunction1D derivative, double?x) { ArgChecker.notNull(function, "function"); ArgChecker.notNull(derivative, "derivative function"); ArgChecker.notNull(x, "x"); double root = x.Value; for (int i = 0; i < MAX_ITER; i++) { double y = function.applyAsDouble(root); double dy = derivative.applyAsDouble(root); double dx = y / dy; if (Math.Abs(dx) <= _accuracy) { return(root - dx); } root -= dx; } throw new MathException("Could not find root in " + MAX_ITER + " attempts"); }
/// <summary> /// Gets the polynomials. /// </summary> /// <param name="n"> the n value </param> /// <param name="alpha"> the alpha value </param> /// <returns> the result </returns> public virtual 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] = One; } else if (i == 1) { polynomials[i] = new RealPolynomialFunction1D(new double[] { 1 + alpha, -1 }); } else { polynomials[i] = (polynomials[i - 1].multiply(2.0 * i + alpha - 1).subtract(polynomials[i - 1].multiply(X)).subtract(polynomials[i - 2].multiply((i - 1.0 + alpha))).divide(i)); } } return(polynomials); }
public override 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] = One; } else if (i == 1) { polynomials[i] = TWO_X; } else { polynomials[i] = polynomials[i - 1].multiply(2).multiply(X).subtract(polynomials[i - 2].multiply(2 * i - 2)); } } return(polynomials); }
public override 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(X); } else { polynomials[i] = polynomials[i - 1].multiply(X).multiply(Math.Sqrt(2.0 / i)).subtract(polynomials[i - 2].multiply(Math.Sqrt((i - 1.0) / i))); } } return(polynomials); }
/// <summary> /// Multiplies the polynomial by a function. /// If the function is not a <seealso cref="RealPolynomialFunction1D"/> then the multiplication takes /// place as in <seealso cref="DoubleFunction1D"/>, otherwise the result will also be a polynomial. /// </summary> /// <param name="f"> the function by which to multiply </param> /// <returns> $P \dot f$ </returns> public override DoubleFunction1D multiply(DoubleFunction1D f) { ArgChecker.notNull(f, "function"); if (f is RealPolynomialFunction1D) { RealPolynomialFunction1D p1 = (RealPolynomialFunction1D)f; double[] c = _coefficients; double[] c1 = p1.Coefficients; int m = c1.Length; double[] newC = new double[_n + m - 1]; for (int i = 0; i < newC.Length; i++) { newC[i] = 0; for (int j = Math.Max(0, i + 1 - m); j < Math.Min(_n, i + 1); j++) { newC[i] += c[j] * c1[i - j]; } } return(new RealPolynomialFunction1D(newC)); } return(DoubleFunction1D.this.multiply(f)); }
/// <summary> /// Calculates polynomials. </summary> /// <param name="n"> the n value </param> /// <param name="alpha"> the alpha value </param> /// <param name="beta"> the beta value </param> /// <returns> the result </returns> public virtual 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] = One; } 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(X).multiply(getC(alpha, beta, j)).add(polynomials[j - 1].multiply(getD(alpha, beta, j))))).divide(getA(alpha, beta, j)); } } return(polynomials); }
/// <summary> /// {@inheritDoc} /// </summary> public virtual GaussianQuadratureData generate(int n) { ArgChecker.isTrue(n > 0, "n > 0"); Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = JACOBI.getPolynomialsAndFirstDerivative(n, _alpha, _beta); Pair <DoubleFunction1D, DoubleFunction1D> pair = polynomials[n]; DoubleFunction1D previous = polynomials[n - 1].First; DoubleFunction1D function = pair.First; DoubleFunction1D derivative = pair.Second; double[] x = new double[n]; double[] w = new double[n]; double root = 0; for (int i = 0; i < n; i++) { double d = 2 * n + _c; root = getInitialRootGuess(root, i, n, x); root = ROOT_FINDER.getRoot(function, derivative, root).Value; x[i] = root; w[i] = GAMMA_FUNCTION.applyAsDouble(_alpha + n) * GAMMA_FUNCTION.applyAsDouble(_beta + n) / CombinatoricsUtils.factorialDouble(n) / GAMMA_FUNCTION.applyAsDouble(n + _c + 1) * d * Math.Pow(2, _c) / (derivative.applyAsDouble(root) * previous.applyAsDouble(root)); } return(new GaussianQuadratureData(x, w)); }
/// <summary> /// {@inheritDoc} /// </summary> public virtual GaussianQuadratureData generate(int n) { ArgChecker.isTrue(n > 0); int mid = (n + 1) / 2; double[] x = new double[n]; double[] w = new double[n]; Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = LEGENDRE.getPolynomialsAndFirstDerivative(n); Pair <DoubleFunction1D, DoubleFunction1D> pair = polynomials[n]; DoubleFunction1D function = pair.First; DoubleFunction1D derivative = pair.Second; for (int i = 0; i < mid; i++) { double root = ROOT_FINDER.getRoot(function, derivative, getInitialRootGuess(i, n)).Value; x[i] = -root; x[n - i - 1] = root; double dp = derivative.applyAsDouble(root); w[i] = 2 / ((1 - root * root) * dp * dp); w[n - i - 1] = w[i]; } return(new GaussianQuadratureData(x, w)); }
/// <summary> /// Uses the function and its derivative. This method uses an initial guess for the root, rather than bounds. </summary> /// <param name="function"> The function, not null </param> /// <param name="derivative"> The derivative, not null </param> /// <param name="x"> The initial guess for the root, not null </param> /// <returns> The root </returns> /// <exception cref="MathException"> If the root is not found in 1000 attempts. </exception> public virtual double?getRoot(System.Func <double, double> function, System.Func <double, double> derivative, double?x) { return(getRoot(DoubleFunction1D.from(function), DoubleFunction1D.from(derivative), x)); }
/// <summary> /// {@inheritDoc} </summary> /// <exception cref="MathException"> If the root is not found in 1000 attempts; if the Newton /// step takes the estimate for the root outside the original bounds. </exception> public override double?getRoot(System.Func <double, double> function, double?x1, double?x2) { ArgChecker.notNull(function, "function"); return(getRoot(DoubleFunction1D.from(function), x1, x2)); }
/// <summary> /// Uses the <seealso cref="DoubleFunction1D#derivative()"/> method. <i>x<sub>1</sub></i> and /// <i>x<sub>2</sub></i> do not have to be increasing. /// </summary> /// <param name="function"> The function, not null </param> /// <param name="x1"> The first bound of the root, not null </param> /// <param name="x2"> The second bound of the root, not null </param> /// <returns> The root </returns> /// <exception cref="MathException"> If the root is not found in 1000 attempts; if the Newton /// step takes the estimate for the root outside the original bounds. </exception> public virtual double?getRoot(DoubleFunction1D function, double?x1, double?x2) { ArgChecker.notNull(function, "function"); return(getRoot(function, function.derivative(), x1, x2)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testConvertNull() public virtual void testConvertNull() { DoubleFunction1D.from(null); }
/// <summary> /// Uses the function and its derivative. </summary> /// <param name="function"> The function, not null </param> /// <param name="derivative"> The derivative, not null </param> /// <param name="x1"> The first bound of the root, not null </param> /// <param name="x2"> The second bound of the root, not null </param> /// <returns> The root </returns> /// <exception cref="MathException"> If the root is not found in 1000 attempts; if the Newton /// step takes the estimate for the root outside the original bounds. </exception> public virtual double?getRoot(System.Func <double, double> function, System.Func <double, double> derivative, double?x1, double?x2) { checkInputs(function, x1, x2); ArgChecker.notNull(derivative, "derivative"); return(getRoot(DoubleFunction1D.from(function), DoubleFunction1D.from(derivative), x1, x2)); }