Java tutorial
/** * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.analytics.math.function; import java.util.Arrays; import org.apache.commons.lang.Validate; import com.opengamma.util.CompareUtils; /** * 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 extends DoubleFunction1D { private final double[] _coefficients; private final int _n; /** * 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(final double... coefficients) { Validate.notNull(coefficients); Validate.isTrue(coefficients.length > 0, "coefficients length must be greater than zero"); _coefficients = coefficients; _n = _coefficients.length; } @Override public Double evaluate(final Double x) { Validate.notNull(x, "x"); double y = _coefficients[_n - 1]; for (int i = _n - 2; i >= 0; i--) { y = x * y + _coefficients[i]; } return y; } /** * @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$ * @throws IllegalArgumentException If the function is null */ @Override public DoubleFunction1D add(final DoubleFunction1D f) { Validate.notNull(f, "function"); if (f instanceof RealPolynomialFunction1D) { final RealPolynomialFunction1D p1 = (RealPolynomialFunction1D) f; final double[] c1 = p1.getCoefficients(); final double[] c = _coefficients; final int n = c1.length; final boolean longestIsNew = n > _n; final 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 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(final double a) { final 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() { final int n = _coefficients.length - 1; final 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(final double a) { final 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$ * @throws IllegalArgumentException If the function is null */ @Override public DoubleFunction1D multiply(final DoubleFunction1D f) { Validate.notNull(f, "function"); if (f instanceof RealPolynomialFunction1D) { final RealPolynomialFunction1D p1 = (RealPolynomialFunction1D) f; final double[] c = _coefficients; final double[] c1 = p1.getCoefficients(); final int m = c1.length; final 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 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(final double a) { final 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. 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$ * @throws IllegalArgumentException If the function is null */ @Override public DoubleFunction1D subtract(final DoubleFunction1D f) { Validate.notNull(f, "function"); if (f instanceof RealPolynomialFunction1D) { final RealPolynomialFunction1D p1 = (RealPolynomialFunction1D) f; final double[] c = _coefficients; final double[] c1 = p1.getCoefficients(); final int m = c.length; final int n = c1.length; final int min = Math.min(m, n); final int max = Math.max(m, n); final 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 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(final double a) { final 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() { final double an = _coefficients[_n - 1]; if (CompareUtils.closeEquals(an, 1)) { return new RealPolynomialFunction1D(Arrays.copyOf(_coefficients, _n)); } final double[] rescaled = new double[_n]; for (int i = 0; i < _n; i++) { rescaled[i] = _coefficients[i] / an; } return new RealPolynomialFunction1D(rescaled); } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(_coefficients); return result; } @Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final RealPolynomialFunction1D other = (RealPolynomialFunction1D) obj; if (!Arrays.equals(_coefficients, other._coefficients)) { return false; } return true; } }