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

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

- - ### Constructor Detail

    - #### PolynomialFunctionNewtonForm

          public PolynomialFunctionNewtonForm(double[] a,
                                      double[] c)
                                       throws NullArgumentException,
                                              NoDataException,
                                              DimensionMismatchException

      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)
                                 throws NullArgumentException,
                                        DimensionMismatchException,
                                        NoDataException

      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)
                                          throws NullArgumentException,
                                                 NoDataException,
                                                 DimensionMismatchException

      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–2016 The Apache Software Foundation. All rights reserved.