Polynomial Interpolation - GNU Octave
Description: GNU Octave

Next: Miscellaneous Functions, Previous: Derivatives / Integrals / Transforms, Up: Polynomial Manipulations

### 27.5 Polynomial Interpolation

Octave comes with good support for various kinds of interpolation, most of which are described in Interpolation. One simple alternative to the functions described in the aforementioned chapter, is to fit a single polynomial to some given data points. To avoid a highly fluctuating polynomial, one most often wants to fit a low-order polynomial to data. This usually means that it is necessary to fit the polynomial in a least-squares sense, which just is what the `polyfit` function does.

— Function File: p = polyfit (x, y, n)
— Function File: [p, s] = polyfit (x, y, n)
— Function File: [p, s, mu] = polyfit (x, y, n)

> Return the coefficients of a polynomial p(x) of degree n that minimizes the least-squares-error of the fit.

> The polynomial coefficients are returned in a row vector.

> The second output is a structure containing the following fields:

> ‘`R`’
>   Triangular factor R from the QR decomposition.
> ‘`X`’
>   The Vandermonde matrix used to compute the polynomial coefficients.
> ‘`df`’
>   The degrees of freedom.
> ‘`normr`’
>   The norm of the residuals.
> ‘`yf`’
>   The values of the polynomial for each value of x.

> The second output may be used by `polyval` to calculate the statistical error limits of the predicted values.

> When the third output, mu, is present the coefficients, p, are associated with a polynomial in xhat = (x-mu(1))/mu(2). Where mu(1) = mean (x), and mu(2) = std (x). This linear transformation of x improves the numerical stability of the fit.

> See also: polyval, residue.

In situations where a single polynomial isn't good enough, a solution is to use several polynomials pieced together. The function `mkpp` creates a piecewise polynomial, `ppval` evaluates the function created by `mkpp`, and `unmkpp` returns detailed information about the function.

The following example shows how to combine two linear functions and a quadratic into one function. Each of these functions is expressed on adjoined intervals.

         x = [-2, -1, 1, 2];
         p = [ 0,  1, 0;
               1, -2, 1;
               0, -1, 1 ];
         pp = mkpp(x, p);
         xi = linspace(-2, 2, 50);
         yi = ppval(pp, xi);
         plot(xi, yi);

— Function File: pp = mkpp (x, p)
— Function File: pp = mkpp (x, p, d)

> Construct a piecewise polynomial structure from sample points x and coefficients p. The i-th row of p, p`(`i`,:)`, contains the coefficients for the polynomial over the i-th interval, ordered from highest to lowest. There must be one row for each interval in x, so `rows (`p`) == length (`x`) - 1`.

> p may also be a multi-dimensional array, specifying a vector-valued or array-valued polynomial. The shape is determined by d. If d is not given, the default is `size (p)(1:end-2)`. If d is given, the leading dimensions of p are reshaped to conform to d.

> See also: unmkpp, ppval, spline.

— Function File: [x, p, n, k, d] = unmkpp (pp)

> Extract the components of a piecewise polynomial structure pp. These are as follows:

> x
>   Sample points.
> p
>   Polynomial coefficients for points in sample interval. p`(`i`, :)` contains the coefficients for the polynomial over interval i ordered from highest to lowest. If d`> 1`, p`(`r`,` i`, :)` contains the coefficients for the r-th polynomial defined on interval i.
> n
>   Number of polynomial pieces.
> k
>   Order of the polynomial plus 1.
> d
>   Number of polynomials defined for each interval.

> See also: mkpp, ppval, spline.

— Function File: yi = ppval (pp, xi)

> Evaluate piecewise polynomial pp at the points xi. If pp is scalar-valued, the result is an array of the same shape as xi. Otherwise, the size of the result is `[pp.d, length(`xi`)]` if xi is a vector, or `[pp.d, size(`xi`)]` if it is a multi-dimensional array. If pp.orient is 1, the dimensions are permuted as in interp1, to `[pp.d, length(`xi`)]` and `[pp.d, size(`xi`)]` respectively.

> See also: mkpp, unmkpp, spline.

— Function File: ppd = ppder (pp)

> Compute the piecewise derivative of the piecewise polynomial struct pp.

> See also: mkpp, ppval, ppint.

— Function File: ppi = ppint (pp)
— Function File: ppi = ppint (pp, c)

> Compute the integral of the piecewise polynomial struct pp. c, if given, is the constant of integration.

> See also: mkpp, ppval, ppder.

— Function File: jumps = ppjumps (pp)

> Evaluate the boundary jumps of a piecewise polynomial. If there are n intervals, and the dimensionality of pp is d, the resulting array has dimensions `[d, n-1]`.

> See also: mkpp.