org.apache.commons.math3.analysis.polynomials

## Class PolynomialFunctionLagrangeForm

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

- All Implemented Interfaces:
    UnivariateFunction

      public class PolynomialFunctionLagrangeForm
      extends Object
      implements UnivariateFunction

  Implements the representation of a real polynomial function in Lagrange Form. For reference, see Introduction to Numerical Analysis, ISBN 038795452X, chapter 2.

  The approximated function should be smooth enough for Lagrange polynomial to work well. Otherwise, consider using splines instead.

  Since:
    1.2
  Version:
    $Id: PolynomialFunctionLagrangeForm.java 1455194 2013-03-11 15:45:54Z luc $

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `PolynomialFunctionLagrangeForm(double[] x, double[] y)` Construct a Lagrange polynomial with the given abscissas and function values.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `computeCoefficients()` Calculate the coefficients of Lagrange polynomial from the interpolation data.
    `int` | `degree()` Returns the degree of the polynomial.
    `static double` | `evaluate(double[] x, double[] y, double z)` Evaluate the Lagrange polynomial using Neville's Algorithm.
    `double[]` | `getCoefficients()` Returns a copy of the coefficients array.
    `double[]` | `getInterpolatingPoints()` Returns a copy of the interpolating points array.
    `double[]` | `getInterpolatingValues()` Returns a copy of the interpolating values array.
    `double` | `value(double z)` Calculate the function value at the given point.
    `static boolean` | `verifyInterpolationArray(double[] x, double[] y, boolean abort)` Check that the interpolation arrays are valid.

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

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

- - ### Constructor Detail

    - #### PolynomialFunctionLagrangeForm

          public PolynomialFunctionLagrangeForm(double[] x,
                                        double[] y)
                                         throws DimensionMismatchException,
                                                NumberIsTooSmallException,
                                                NonMonotonicSequenceException

      Construct a Lagrange polynomial with the given abscissas and function values. The order of interpolating points are not important.

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

      Parameters:
        `x` - interpolating points
        `y` - function values at interpolating points
      Throws:
        `DimensionMismatchException` - if the array lengths are different.
        `NumberIsTooSmallException` - if the number of points is less than 2.
        `NonMonotonicSequenceException` - if two abscissae have the same value.

  - ### 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.
      Throws:
        `DimensionMismatchException` - if `x` and `y` have different lengths.
        `NonMonotonicSequenceException` - if `x` is not sorted in strictly increasing order.
        `NumberIsTooSmallException` - if the size of `x` is less than 2.

    - #### degree

          public int degree()

      Returns the degree of the polynomial.
      Returns:
        the degree of the polynomial

    - #### getInterpolatingPoints

          public double[] getInterpolatingPoints()

      Returns a copy of the interpolating points array.

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

      Returns:
        a fresh copy of the interpolating points array

    - #### getInterpolatingValues

          public double[] getInterpolatingValues()

      Returns a copy of the interpolating values array.

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

      Returns:
        a fresh copy of the interpolating values array

    - #### getCoefficients

          public double[] getCoefficients()

      Returns a copy of the coefficients array.

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

      Note that coefficients computation can be ill-conditioned. Use with caution and only when it is necessary.

      Returns:
        a fresh copy of the coefficients array

    - #### evaluate

          public static double evaluate(double[] x,
                        double[] y,
                        double z)
                                 throws DimensionMismatchException,
                                        NumberIsTooSmallException,
                                        NonMonotonicSequenceException

      Evaluate the Lagrange polynomial using Neville's Algorithm. It takes O(n^2) time.
      Parameters:
        `x` - Interpolating points array.
        `y` - Interpolating values array.
        `z` - Point at which the function value is to be computed.
      Returns:
        the function value.
      Throws:
        `DimensionMismatchException` - if `x` and `y` have different lengths.
        `NonMonotonicSequenceException` - if `x` is not sorted in strictly increasing order.
        `NumberIsTooSmallException` - if the size of `x` is less than 2.

    - #### computeCoefficients

          protected void computeCoefficients()

      Calculate the coefficients of Lagrange polynomial from the interpolation data. It takes O(n^2) time. Note that this computation can be ill-conditioned: Use with caution and only when it is necessary.

    - #### verifyInterpolationArray

          public static boolean verifyInterpolationArray(double[] x,
                                         double[] y,
                                         boolean abort)
                                                  throws DimensionMismatchException,
                                                         NumberIsTooSmallException,
                                                         NonMonotonicSequenceException

      Check that the interpolation arrays are valid. The arrays features checked by this method are that both arrays have the same length and this length is at least 2.
      Parameters:
        `x` - Interpolating points array.
        `y` - Interpolating values array.
        `abort` - Whether to throw an exception if `x` is not sorted.
      Returns:
        `false` if the `x` is not sorted in increasing order, `true` otherwise.
      Throws:
        `DimensionMismatchException` - if the array lengths are different.
        `NumberIsTooSmallException` - if the number of points is less than 2.
        `NonMonotonicSequenceException` - if `x` is not sorted in strictly increasing order and `abort` is `true`.
      See Also:
        `evaluate(double[], double[], double)`, `computeCoefficients()`

Copyright © 2003–2014 The Apache Software Foundation. All rights reserved.