org.apache.commons.math3.analysis.polynomials

## Class PolynomialFunctionNewtonForm

- java.lang.Object
- - org.apache.commons.math3.analysis.polynomials.PolynomialFunctionNewtonForm

All Implemented Interfaces:
  UnivariateDifferentiableFunction, UnivariateFunction

    public class PolynomialFunctionNewtonForm
    extends java.lang.Object
    implements UnivariateDifferentiableFunction

Implements the representation of a real polynomial function in Newton Form. For reference, see Elementary Numerical Analysis, ISBN 0070124477, chapter 2.

The formula of polynomial in Newton form is p(x) = a[0] + a[1](x-c[0]) + a[2](x-c[0])(x-c[1]) + ... + a[n](x-c[0])(x-c[1])...(x-c[n-1]) Note that the length of a[] is one more than the length of c[]

Since:
  1.2
Version:
  $Id: PolynomialFunctionNewtonForm.java 1422195 2012-12-15 06:45:18Z psteitz $

### Field Summary

Fields
`private double[]` `a` When all c[i] = 0, a[] becomes normal polynomial coefficients, i.e.
`private double[]` `c` Centers of the Newton polynomial.
`private double[]` `coefficients` The coefficients of the polynomial, ordered by degree -- i.e.
`private boolean` `coefficientsComputed` Whether the polynomial coefficients are available.

### Constructor Summary

Constructors
Constructor and Description
`PolynomialFunctionNewtonForm(double[] a, double[] c)` Construct a Newton polynomial with the given a[] and c[].

### Method Summary

Methods
`protected void` `computeCoefficients()` Calculate the normal polynomial coefficients given the Newton form.
`int` `degree()` Returns the degree of the polynomial.
`static double` `evaluate(double[] a, double[] c, double z)` Evaluate the Newton polynomial using nested multiplication.
`double[]` `getCenters()` Returns a copy of the centers array.
`double[]` `getCoefficients()` Returns a copy of the coefficients array.
`double[]` `getNewtonCoefficients()` Returns a copy of coefficients in Newton form formula.
`DerivativeStructure` `value(DerivativeStructure t)` Simple mathematical function.
`double` `value(double z)` Calculate the function value at the given point.
`protected static void` `verifyInputArray(double[] a, double[] c)` Verifies that the input arrays are valid.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### coefficients

    private double[] coefficients

The coefficients of the polynomial, ordered by degree -- i.e. coefficients[0] is the constant term and coefficients[n] is the coefficient of x^n where n is the degree of the polynomial.

#### c

    private final double[] c

Centers of the Newton polynomial.

#### a

    private final double[] a

When all c[i] = 0, a[] becomes normal polynomial coefficients, i.e. a[i] = coefficients[i].

#### coefficientsComputed

    private boolean coefficientsComputed

Whether the polynomial coefficients are available.

### Constructor Detail

#### PolynomialFunctionNewtonForm

    public PolynomialFunctionNewtonForm(double[] a,
                                double[] c)

Construct a Newton polynomial with the given a[] and c[]. The order of centers are important in that if c[] shuffle, then values of a[] would completely change, not just a permutation of old a[].

The constructor makes copy of the input arrays and assigns them.

Parameters:
  `a` - Coefficients in Newton form formula.
  `c` - Centers.
Throws:
  `NullArgumentException` - if any argument is `null`.
  `NoDataException` - if any array has zero length.
  `DimensionMismatchException` - if the size difference between `a` and `c` is not equal to 1.

### Method Detail

#### value

    public double value(double z)

Calculate the function value at the given point.

Specified by:
  `value` in interface `UnivariateFunction`
Parameters:
  `z` - Point at which the function value is to be computed.
Returns:
  the function value.

#### value

    public DerivativeStructure value(DerivativeStructure t)

Simple mathematical function.

`UnivariateDifferentiableFunction` classes compute both the value and the first derivative of the function.

Specified by:
  `value` in interface `UnivariateDifferentiableFunction`
Parameters:
  `t` - function input value
Returns:
  function result
Since:
  3.1

#### degree

    public int degree()

Returns the degree of the polynomial.

Returns:
  the degree of the polynomial

#### getNewtonCoefficients

    public double[] getNewtonCoefficients()

Returns a copy of coefficients in Newton form formula.

Changes made to the returned copy will not affect the polynomial.

Returns:
  a fresh copy of coefficients in Newton form formula

#### getCenters

    public double[] getCenters()

Returns a copy of the centers array.

Changes made to the returned copy will not affect the polynomial.

Returns:
  a fresh copy of the centers array.

#### getCoefficients

    public double[] getCoefficients()

Returns a copy of the coefficients array.

Changes made to the returned copy will not affect the polynomial.

Returns:
  a fresh copy of the coefficients array.

#### evaluate

    public static double evaluate(double[] a,
                  double[] c,
                  double z)

Evaluate the Newton polynomial using nested multiplication. It is also called Horner's Rule and takes O(N) time.

Parameters:
  `a` - Coefficients in Newton form formula.
  `c` - Centers.
  `z` - Point at which the function value is to be computed.
Returns:
  the function value.
Throws:
  `NullArgumentException` - if any argument is `null`.
  `NoDataException` - if any array has zero length.
  `DimensionMismatchException` - if the size difference between `a` and `c` is not equal to 1.

#### computeCoefficients

    protected void computeCoefficients()

Calculate the normal polynomial coefficients given the Newton form. It also uses nested multiplication but takes O(N^2) time.

#### verifyInputArray

    protected static void verifyInputArray(double[] a,
                        double[] c)

Verifies that the input arrays are valid.

The centers must be distinct for interpolation purposes, but not for general use. Thus it is not verified here.

Parameters:
  `a` - the coefficients in Newton form formula
  `c` - the centers
Throws:
  `NullArgumentException` - if any argument is `null`.
  `NoDataException` - if any array has zero length.
  `DimensionMismatchException` - if the size difference between `a` and `c` is not equal to 1.
See Also:
  `DividedDifferenceInterpolator.computeDividedDifference(double[], double[])`