Version:

Last Modified: December 18, 2017

Computes the Chirp-Z transform of a sequence. The Chirp-Z transform algorithm is also known as Bluestein's FFT algorithm.

A real vector.

This input can be a 1D array of double-precision, floating-point numbers or a 1D array of complex double-precision, floating-point numbers.

The length of the sequence after the Chirp-Z transform.

If **number of bins** is less than or equal to 0, this node sets **number of bins** to the length of **x**.

**Default: **-1

The point at which this node begins evaluating the Chirp-Z transform.

If **starting point** is 0, the node returns an error.

**Default: **1 + 0i

The increment between each point to evaluate for the Chirp-Z transform.

**increment** cannot be 0.

**Default: **1 + 0i

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

Transform method to use.

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

direct | 0 | Computes the Chirp-Z transform using the direct form method. Use this method if the size of x or the number of bins is small. |

frequency domain | 1 | Computes the Chirp-Z transform using an FFT-based technique. Use this method if the size of x or the number of bins is large. |

Computing the Chirp-Z Transform Using the Direct Form Method

The direct form method computes the Chirp-Z transform as follows:

${Y}_{k}=\underset{i=0}{\overset{N-1}{\sum}}{x}_{i}{\left(A{W}^{-k}\right)}^{-i}$

for *k* = 0, 1, ..., *M*-1

where *N* is the length of **X**.

Computing the Chirp-Z Transform Using the Frequency Domain Method

The direct form can be reformulated with the convolution between *g*_{i} and
${W}^{-{i}^{2}/2}$ as follows:

${Y}_{k}={W}^{{k}^{2}/2}\underset{i=0}{\overset{N-1}{\sum}}{g}_{i}{W}^{-{(k-i)}^{2}/2}$

where ${g}_{i}={x}_{i}{A}^{-i}{W}^{-{i}^{2}/2}$. You can perform the convolution operation using an FFT-based technique.

**Default: **frequency domain

The Chirp-Z transform of the input sequence.

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.

This node evaluates the z transform along a spiral in the z-plane at the following points:

${z}_{k}=A{W}^{-k}$

for *k* = 0, 1, ..., *M*-1

where

*M*is**number of bins***A*is**starting point***W*is**increment**

The following illustration shows samples in the z-plane.

You can use the Chirp-Z transform to calculate the FFT result. Set **starting point** and **increment** as follows:

$\mathrm{starting}\text{\hspace{0.17em}}\mathrm{point}=1$

$\mathrm{increment}={e}^{-j\frac{2\pi}{N}}$

where *N* is the length of **X**. Let **number of bins** equal *N*. When the samples are evenly distributed on the unit circle, as shown in the following image, the Chirp-Z transform is the same as the fast Fourier transform (FFT).

You also can use the Chirp-Z transform to calculate the partial FFT result. Set **starting point** and **increment** as follows:

$\mathrm{starting}\text{\hspace{0.17em}}\mathrm{point}={e}^{j\frac{2\pi}{N}s}$

$\mathrm{increment}={e}^{-j\frac{2\pi}{N}}$

where *s* is the start bin and *N* is the length of **X**. This is useful when you are interested in only a small portion of a spectrum of a very long signal, as shown in the following image.

**Where This Node Can Run: **

Desktop OS: Windows

FPGA: This product does not support FPGA devices

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