Java tutorial
/** * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.strata.math.impl.function; import java.util.Arrays; import com.google.common.math.DoubleMath; import com.opengamma.strata.collect.ArgChecker; /** * Class representing a polynomial that has real coefficients and takes a real * argument. The function is defined as: * $$ * \begin{align*} * p(x) = a_0 + a_1 x + a_2 x^2 + \ldots + a_{n-1} x^{n-1} * \end{align*} * $$ */ public class RealPolynomialFunction1D implements DoubleFunction1D { private final double[] _coefficients; private final int _n; /** * Creates an instance. * * The array of coefficients for a polynomial * $p(x) = a_0 + a_1 x + a_2 x^2 + ... + a_{n-1} x^{n-1}$ * is $\\{a_0, a_1, a_2, ..., a_{n-1}\\}$. * * @param coefficients the array of coefficients, not null or empty */ public RealPolynomialFunction1D(double... coefficients) { ArgChecker.notNull(coefficients, "coefficients"); ArgChecker.isTrue(coefficients.length > 0, "coefficients length must be greater than zero"); _coefficients = coefficients; _n = _coefficients.length; } //------------------------------------------------------------------------- @Override public double applyAsDouble(double x) { ArgChecker.notNull(x, "x"); double y = _coefficients[_n - 1]; for (int i = _n - 2; i >= 0; i--) { y = x * y + _coefficients[i]; } return y; } /** * Gets the coefficients of this polynomial. * * @return the coefficients of this polynomial */ public double[] getCoefficients() { return _coefficients; } /** * Adds a function to the polynomial. * If the function is not a {@link RealPolynomialFunction1D} then the addition takes * place as in {@link DoubleFunction1D}, otherwise the result will also be a polynomial. * * @param f the function to add * @return $P+f$ */ @Override public DoubleFunction1D add(DoubleFunction1D f) { ArgChecker.notNull(f, "function"); if (f instanceof RealPolynomialFunction1D) { RealPolynomialFunction1D p1 = (RealPolynomialFunction1D) f; double[] c1 = p1.getCoefficients(); double[] c = _coefficients; int n = c1.length; boolean 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.super.add(f); } /** * Adds a constant to the polynomial (equivalent to adding the value to the constant * term of the polynomial). The result is also a polynomial. * * @param a the value to add * @return $P+a$ */ @Override public RealPolynomialFunction1D add(double a) { double[] c = Arrays.copyOf(getCoefficients(), _n); c[0] += a; return new RealPolynomialFunction1D(c); } /** * Returns the derivative of this polynomial (also a polynomial), where * $$ * \begin{align*} * P'(x) = a_1 + 2 a_2 x + 3 a_3 x^2 + 4 a_4 x^3 + \dots + n a_n x^{n-1} * \end{align*} * $$ * * @return the derivative polynomial */ @Override public RealPolynomialFunction1D derivative() { int n = _coefficients.length - 1; double[] coefficients = new double[n]; for (int i = 1; i <= n; i++) { coefficients[i - 1] = i * _coefficients[i]; } return new RealPolynomialFunction1D(coefficients); } /** * Divides the polynomial by a constant value (equivalent to dividing each coefficient by this value). * The result is also a polynomial. * * @param a the divisor * @return the polynomial */ @Override public RealPolynomialFunction1D divide(double a) { double[] c = Arrays.copyOf(getCoefficients(), _n); for (int i = 0; i < _n; i++) { c[i] /= a; } return new RealPolynomialFunction1D(c); } /** * Multiplies the polynomial by a function. * If the function is not a {@link RealPolynomialFunction1D} then the multiplication takes * place as in {@link DoubleFunction1D}, otherwise the result will also be a polynomial. * * @param f the function by which to multiply * @return $P \dot f$ */ @Override public DoubleFunction1D multiply(DoubleFunction1D f) { ArgChecker.notNull(f, "function"); if (f instanceof RealPolynomialFunction1D) { RealPolynomialFunction1D p1 = (RealPolynomialFunction1D) f; double[] c = _coefficients; double[] c1 = p1.getCoefficients(); 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.super.multiply(f); } /** * Multiplies the polynomial by a constant value (equivalent to multiplying each * coefficient by this value). The result is also a polynomial. * * @param a the multiplicator * @return the polynomial */ @Override public RealPolynomialFunction1D multiply(double a) { double[] c = Arrays.copyOf(getCoefficients(), _n); for (int i = 0; i < _n; i++) { c[i] *= a; } return new RealPolynomialFunction1D(c); } /** * Subtracts a function from the polynomial. * <p> * If the function is not a {@link RealPolynomialFunction1D} then the subtract takes place * as in {@link DoubleFunction1D}, otherwise the result will also be a polynomial. * * @param f the function to subtract * @return $P-f$ */ @Override public DoubleFunction1D subtract(DoubleFunction1D f) { ArgChecker.notNull(f, "function"); if (f instanceof RealPolynomialFunction1D) { RealPolynomialFunction1D p1 = (RealPolynomialFunction1D) f; double[] c = _coefficients; double[] c1 = p1.getCoefficients(); 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.super.subtract(f); } /** * Subtracts a constant from the polynomial (equivalent to subtracting the value from the * constant term of the polynomial). The result is also a polynomial. * * @param a the value to add * @return $P-a$ */ @Override public RealPolynomialFunction1D subtract(double a) { double[] c = Arrays.copyOf(getCoefficients(), _n); c[0] -= a; return new RealPolynomialFunction1D(c); } /** * Converts the polynomial to its monic form. If * $$ * \begin{align*} * P(x) = a_0 + a_1 x + a_2 x^2 + a_3 x^3 \dots + a_n x^n * \end{align*} * $$ * then the monic form is * $$ * \begin{align*} * P(x) = \lambda_0 + \lambda_1 x + \lambda_2 x^2 + \lambda_3 x^3 \dots + x^n * \end{align*} * $$ * where * $$ * \begin{align*} * \lambda_i = \frac{a_i}{a_n} * \end{align*} * $$ * * @return the polynomial in monic form */ public RealPolynomialFunction1D toMonic() { double an = _coefficients[_n - 1]; if (DoubleMath.fuzzyEquals(an, (double) 1, 1e-15)) { return new RealPolynomialFunction1D(Arrays.copyOf(_coefficients, _n)); } double[] rescaled = new double[_n]; for (int i = 0; i < _n; i++) { rescaled[i] = _coefficients[i] / an; } return new RealPolynomialFunction1D(rescaled); } //------------------------------------------------------------------------- @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } RealPolynomialFunction1D other = (RealPolynomialFunction1D) obj; if (!Arrays.equals(_coefficients, other._coefficients)) { return false; } return true; } @Override public int hashCode() { int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(_coefficients); return result; } }