Version:

Last Modified: March 15, 2017

Interpolates or extrapolates a function *f* at a specific value using a rational function. The rational function passes through all the points formed by arrays of dependent and independent values.

Dependent value.

This input accepts a double-precision, floating-point number or a 1D array of double-precision, floating-point numbers.

When **x** and **y** are 1D arrays of double-precision, floating-point numbers, if the number of elements in **x** is different from the number of elements in **y**, this node sets **interpolation value** and **interpolation error** to NaN and returns an error.

Independent value.

This input accepts a double-precision, floating-point number or a 1D array of double-precision, floating-point numbers.

When **x** and **y** are 1D arrays of double-precision, floating-point numbers, if the number of elements in **x** is different from the number of elements in **y**, this node sets **interpolation value** and **interpolation error** to NaN and returns an error.

Point at which the interpolation or extrapolation is performed.

If the value of **x value** is in the range of **x**, the node performs interpolation. Otherwise, the node performs extrapolation. If **x value** is too far from the range of **x**, the extrapolation error may be large. It is not a satisfactory extrapolation.

Error conditions that occur before this node runs.

The node responds to this input according to standard error behavior.

Standard Error Behavior

Many nodes provide an **error in** input and an **error out** output so that the node can respond to and communicate errors that occur while code is running. The value of **error in** specifies whether an error occurred before the node runs. Most nodes respond to values of **error in** in a standard, predictable way.

**Default: **No error

Interpolation of the function *f* at the point you specified.

An estimate of the error in the interpolation.

Error information.

The node produces this output according to standard error behavior.

Standard Error Behavior

**error in** input and an **error out** output so that the node can respond to and communicate errors that occur while code is running. The value of **error in** specifies whether an error occurred before the node runs. Most nodes respond to values of **error in** in a standard, predictable way.

The rational function

$\frac{P\left({x}_{i}\right)}{Q\left({x}_{i}\right)}=\frac{{p}_{0}+{p}_{1}{x}_{i}+\mathrm{...}{p}_{m}{x}_{i}^{m}}{{q}_{0}+{q}_{1}{x}_{i}+\mathrm{...}{q}_{m}{x}_{i}^{m}}$

passes through all the points formed by **y** and **x**. *P* and *Q* are polynomials, and the rational function is unique, given a set of *n* points (*x*_{i}*y*_{i}), where *f*(*x*_{i}) = *y*_{i}, *f* is any function, and given a number *x* in the range of the *x*_{i} values.

This node calculates **interpolation value** *y* using

$\frac{P\left(x\right)}{Q\left(x\right)}$

If the number of points is odd, the degrees of freedom of *P* and *Q* are using
$\frac{n-1}{2}$. If the number of points is even, the degrees of freedom of *P* are
$\frac{n}{2}-1$, and the degrees of freedom of *Q* are
$\frac{n}{2}$, where *n* is the total number of points formed by **y** and **x**.

**Where This Node Can Run: **

Desktop OS: Windows

FPGA: This product does not support FPGA devices