Version:

Last Modified: June 25, 2019

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{}j<0\text{}\text{}orj\ge N$

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

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

for $j=-(N-1),-(N-2),\text{}\mathrm{...}\text{},-1,0,1,\text{}\mathrm{...}\text{},(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{},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|}\sum _{k=0}^{N-1}{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}\sum _{k=0}^{N-1}{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: Not supported

Web Server: Not supported in VIs that run in a web application