Estimate delay(s) between signals

`D = finddelay(X,Y)`

D = finddelay(...,MAXLAG)

`D = finddelay(X,Y)`

, where `X`

and `Y`

are
row or column vectors, returns an estimate of the delay `D`

between `X`

and `Y`

,
where `X`

serves as the reference vector. If `Y`

is
delayed with respect to `X`

, then `D`

is
positive. If `Y`

is advanced with respect to `X`

,
then `D`

is negative. Delays in `X`

and `Y`

can
be introduced by pre-pending zeros.

`X`

and `Y`

need not be exact
delayed copies of each other, as `finddelay(X,Y)`

returns
an estimate of the delay via cross-correlation. However this estimated
delay has a useful meaning only if there is sufficient correlation
between delayed versions of `X`

and `Y`

.
Also, if several delays are possible, as in the case of periodic signals,
the delay with the smallest absolute value is returned. In the case
that both a positive and a negative delay with the same absolute value
are possible, the positive delay is returned.

`D = finddelay(X,Y)`

, where `X`

is
a matrix of size *MX*-by-*NX* (*MX*>1
and *NX*>1) and `Y`

is a matrix
of size *MY*-by-*NY* (*MY*>1
and *NY*>1), returns a row vector `D`

of
estimated delays between each column of `X`

and the
corresponding column of `Y`

. With this usage the
number of columns of `X`

must be equal to the number
of columns of `Y`

(i.e., *NX*=*NY*).

`D = finddelay(...,MAXLAG)`

,
uses `MAXLAG`

as the maximum correlation window size
used to find the estimated delay(s) between `X`

and `Y`

.
The usage of `MAXLAG`

is detailed in the table below.

By default, `MAXLAG`

is equal to MAX(*LX*, *LY*)-1
for two vector inputs (where *LX* and *LY* are
the lengths of `X`

and `Y`

, respectively),
MAX(*MX*, *MY*)-1 for two matrix
inputs, and MAX(*LX*, *MY*)-1
or MAX(*MX*, *LY*)-1 for one
vector input and one matrix input. If `MAXLAG`

is
input as `[]`

, it is replaced by the default value.
If any element of `MAXLAG`

is negative, it is replaced
by its absolute value. If any element of `MAXLAG`

is
not integer-valued, or is complex, `Inf`

, or `NaN`

,
then `finddelay`

returns an error.

The calculation of the vector of estimated delays, `D`

,
depends on `X`

, `Y`

, and `MAXLAG`

as
shown in the following table.

`MAXLAG` | `X` | `Y` | `D` is calculated by... |
---|---|---|---|

Integer-valued scalar | Row or column vector or matrix | Row or column vector or matrix | Cross-correlating the columns of `X` and `Y` over
a range of lags -`MAXLAG` :`MAXLAG` . |

Integer-valued row or column vector | Row or column vector of length $$LX\ge 1$$ | Matrix of size MY-by-NY (MY>1, NY>1) | Cross-correlating `X` and column j of `Y` over
a range of lags -`MAXLAG` (j):`MAXLAG` (j),
for j=1:NY. |

Integer-valued row or column vector | Matrix of size MX-by-NX (MX>1, NX>1) | Row or column vector of length $$LY\ge 1$$ | Cross-correlating column j of `X` and `Y` over
a range of lags -`MAXLAG` (j):`MAXLAG` (j),
for j=1:NX. |

Integer-valued row or column vector | Matrix of size MX-by-NX (MX>1, NX>1) | Matrix of size MY-by-NY (MY>1, NY=NX>1) | Cross-correlating column j of `X` and
column j of `Y` over a range
of lags -`MAXLAG` (j):`MAXLAG` (j),
for j=1:NY. |

`X`

as Multiple ChannelsIf you wish to treat a row vector `X`

of length *LX* as
comprising one sample from *LX* different channels,
you need to append one or more rows of zeros to `X`

so
that it appears as a matrix. Then each column of `X`

will
be considered a channel.

For example, `X = [1 1 1 1]`

is considered
a single channel comprising four samples. To treat it as four different
channels, each channel comprising one sample, define a new matrix *Xm*:

Xm = [1 1 1 1; 0 0 0 0];

Each column of *Xm* corresponds to a single
channel, each one containing the samples `1`

and `0`

.

The following shows `Y`

being delayed with
respect to `X`

by two samples.

X = [1 2 3]; Y = [0 0 1 2 3]; D = finddelay(X,Y)

The result is `D = 2`

.

Here is a case of `Y`

advanced with respect
to `X`

by three samples.

X = [0 0 0 1 2 3 0 0]'; Y = [1 2 3 0]'; D = finddelay(X,Y)

The result is `D = -3`

.

The following illustrates a case where `Y`

is
aligned with `X`

but is noisy.

X = [0 0 1 2 3 0]; Y = [0.02 0.12 1.08 2.21 2.95 -0.09]; D = finddelay(X,Y)

The result is `D = 0`

.

If `Y`

is a periodic version of `X`

,
the smallest possible delay is returned.

X = [0 1 2 3]; Y = [1 2 3 0 0 0 0 1 2 3 0 0]; D = finddelay(X,Y)

The result is `D = -1`

.

`MAXLAG`

is specified as a scalar (same maximum
window sizes).

X = [0 1 2]; Y = [0 1 0 0; 1 2 0 0; 2 0 1 0; 0 0 2 1]; MAXLAG = 3; D = finddelay(X,Y,MAXLAG)

The result is `D = [0 -1 1 1]`

.

X = [0 1 0 0; 1 2 0 0; 2 0 1 0; 1 0 2 1; 0 0 0 2]; Y = [0 0 1 0; 1 1 2 0; 2 2 0 1; 1 0 0 2; 0 0 0 0]; D = finddelay(X,Y)

The result is `D = [0 1 -2 -1]`

.

X = [0 1 0 0; 1 2 0 0; 2 0 1 0; 1 0 2 1; 0 0 0 2]; Y = [0 0 1 0; 1 1 2 0; 2 2 0 1; 1 0 0 2; 0 0 0 0]; MAXLAG = [10 10 20 20]; D = finddelay(X,Y,MAXLAG)

The result is `D = [0 1 -2 -1]`

.

`alignsignals`

| `biterr`

| `symerr`

| `xcorr`

Was this topic helpful?