org.apache.commons.math3.analysis.polynomials

## Class PolynomialFunctionNewtonForm

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

- All Implemented Interfaces:
    UnivariateFunction

      public class PolynomialFunctionNewtonForm
      extends Object
      implements UnivariateFunction

  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 1244107 2012-02-14 16:17:55Z erans $

- - ### Constructor Summary

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

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `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`

- - ### 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.

    - #### 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[])`

Copyright © 2003-2012 The Apache Software Foundation. All Rights Reserved.