Version:

Last Modified: March 15, 2017

Computes the auto-correlation of a signal.

The normalization method to use to compute the auto correlation of the input signal.

This input is available only if **x** is a waveform or an array.

Name | Description |
---|---|

none | Does not apply normalization. |

unbiased | Applies unbiased normalization. |

biased | Applies biased normalization. |

**Default: **none

Length of each set of x-values. This node computes each set of values separately.

**sample length x** must be greater than 0.

This input is available only if **x** is a double-precision, floating-point number.

**Default: **100

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

A Boolean that specifies whether to use the data points before the current block to compute the auto-correlation.

True | Uses the data points before the current block to compute the auto-correlation. |

False | Does not use the data points before the current block to compute the auto-correlation. |

This input is available only if **x** is a double-precision, floating-point number.

**Default: **True

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 auto-correlation Rxx(*t*) of a function *x*(*t*) is defined as

$Rxx(t)=x(t)\otimes x(t)={\int}_{-\infty}^{\infty}{x}^{*}(\tau )\cdot x(t+\tau )d\tau $

where the symbol $\otimes $ denotes correlation.

For the discrete implementation of this node, let *Y* represent a sequence whose indexing can be negative, let *N* be the number of elements in the input sequence **x**, and assume that the indexed elements of **x** that lie outside its range are equal to zero, as shown in the following relationship:

${x}_{j}=0,\text{\hspace{0.17em}}j<0\text{\hspace{0.17em}}\text{\hspace{0.17em}}orj\ge N$

Then this node obtains the elements of *Y* using the following formula:

${Y}_{j}=\underset{k=0}{\overset{N-1}{\sum}}{{x}_{k}}^{*}\cdot {x}_{j+k}$

for $j=-(N-1),-(N-2),\text{\hspace{0.17em}}\mathrm{...}\text{\hspace{0.17em}},-1,0,1,\text{\hspace{0.17em}}\mathrm{...}\text{\hspace{0.17em}},(N-2),(N-1)$

The elements of the output sequence Rxx are related to the elements in the sequence *Y* by

${Rxx}_{i}={y}_{i-(N-1)}$

for $i=0,1,2,\mathrm{...}\text{\hspace{0.17em}},2N-2$

Notice that the number of elements in the output sequence Rxx is
$2N-1$. Because you cannot use negative numbers to index arrays, the corresponding correlation value at *t* = 0 is the *N*th element of the output sequence Rxx. Therefore, Rxx represents the correlation values that this node shifts *N* times in indexing.

This node applies unbiased normalization as follows:

${y}_{j}=\frac{1}{N-\left|j\right|}\underset{k=0}{\overset{N-1}{\sum}}{x}_{k}^{*}\cdot {x}_{j+k}$

for *j* = -(*N*-1), -(*N*-2), ..., -1, 0, 1, ..., (*N*-2), (*N*-1), and

${Rxx\left(unbiased\right)}_{i}={y}_{i-(N-1)}$

for *i* = 0, 1, 2, ..., 2*N*-2

This node applies biased normalization as follows:

${y}_{j}=\frac{1}{N}\underset{k=0}{\overset{N-1}{\sum}}{x}_{k}^{*}\cdot {x}_{j+k}$

for *j* = -(*N*-1), -(*N*-2), ..., -1, 0, 1, ..., (*N*-2), (*N*-1), and

${Rxx\left(biased\right)}_{i}={y}_{i-(N-1)}$

for *i* = 0, 1, 2, ..., 2*N*-2

**Where This Node Can Run: **

Desktop OS: Windows

FPGA: This product does not support FPGA devices