SYSTEMS AND METHODS FOR INVERTING THE CHIRP Z-TRANSFORM IN O(n log n) TIME AND O(n) MEMORY

Abstract

Embodiments of the present disclosure describe an efficient O(n log n) method that implements the Inverse Chirp Z-Transform (ICZT). This transform is the inverse of the well-known forward Chirp Z-Transform (CZT), which generalizes the fast Fourier transform (FFT) by allowing the sampling points to fall on a logarithmic spiral contour instead of the unit circle. Thus, the ICZT can be viewed as a generalization of the inverse fast Fourier transform (IFFT).

Description

FIELD OF THE INVENTION

This invention generally relates to the inverse chirp z-transform and more particularly to methods and systems for computing the inverse chirp z-transform in O(n log n) time and O(n) memory.

BACKGROUND OF THE INVENTION

The Chirp Z-Transform (CZT) extends the discrete Fourier transform (DFT) by allowing the samples to be located on a logarithmic spiral contour instead of the unit circle. More specifically, the transform distributes the samples along a logarithmic spiral contour that is defined by the formula A W^−k, where k=0, 1, 2, . . . , M−1. The non-zero complex numbers A and W specify the location and the direction of the spiral contour and also the spacing of the sample points on the contour. More specifically, given an N-element input vector x, the CZT computes an M-element output vector X, where the k-th element of X is given by x_k=Σ_j=0^N−1x_j(AW^−k)^−j.

An efficient algorithm that can compute the forward chirp z-transform has previously been described. That algorithm runs in O(n log n) time, where n is the size of the transform. Because the number of inputs N and the number of outputs M can be different, in the most general case the computational complexity of the CZT algorithm is determined by n=max(M, N).

An efficient CZT algorithm can be derived using an index substitution that was originally proposed by Bluestein in “A linear filtering approach to the computation of discrete Fourier transform,” IEEE Transactions on Audio and Electroacoustics, 18(4):451-455, 1970, which is incorporated in its entirety herein by reference, to express the transform using fast convolutions. Various useful optimizations have been proposed for the CZT algorithm. Nevertheless, its computational complexity remains fixed at O(n log n).

The Inverse Chirp Z-Transform (ICZT) is the inverse of the chirp z-transform (CZT). That is, the ICZT maps the outputs of the CZT back to the inputs. Because the CZT is a linear transform, it can be expressed using a matrix product of the CZT matrix and the input vector. This matrix can be inverted using a standard algorithm. In algorithmic form, however, this process may require up to O(n³) operations.

Even though there are efficient matrix inversion algorithms that run faster than O(n³), at least n² operations are necessary to access each element of an n-by-n matrix. Thus, O(n²) is a lower bound for the computational complexity of any ICZT algorithm that works with a complete n-by-n matrix in memory.

To be efficient, an ICZT algorithm must have the same computational complexity as the CZT algorithm, i.e., O(n log n). This requirement rules out any method that requires storing the transform matrix in memory.

Several attempts to derive an efficient ICZT algorithm have been made. In one case (described in Frickey, “Using the inverse chirp-z transform for time-domain analysis of simulated radar signals,” Technical report, Idaho National Engineering Lab., Idaho Falls, Id., 1995, incorporated in its entirety herein by reference), a modified version of the forward CZT algorithm, in which the logarithmic spiral contour was traversed in the opposite direction, was described as the ICZT algorithm. However, this method does not really invert the CZT. It works only in some special cases, e.g., when A=1 and W=e^−2πi/n. That is, in the cases when the CZT reduces to the DFT. In the general case, i.e., when A, W∈\{0}, this method generates a transform that does not invert the CZT.

BRIEF SUMMARY OF THE INVENTION

Embodiments of the present disclosure describe an efficient O(n log n) method for computing the ICZT. The method uses generating vectors to represent structured matrices (e.g., diagonal, Vandermonde, Toeplitz, circulant, or skew-circulant matrices) more compactly in O(n) memory. The ICZT can be viewed as a generalization of the inverse fast Fourier transform (IFFT) off the unit circle. In other words, the complex parameters A and W of an ICZT describe a logarithmic spiral contour in the complex plane. Unlike IFFT, the ICZT can use contour points off the unit circle that correspond to exponentially growing or exponentially decaying frequency components. Embodiments of the present disclosure also describe a method for improving the numerical accuracy of a CZT or an ICZT for the case when |W|<1, which is given in Appendix A.

To the best of their knowledge, the inventors believe that this disclosure is the first description of an efficient ICZT algorithm. In particular, a working algorithm is described as well as its derivation. Further, the accuracy of the algorithm is verified using automated test cases.

The algorithm was derived by expressing the CZT formula using structured matrix multiplication and then finding a way to invert that formula. The essence of the ICZT computation reduces to inverting a specially constructed Vandermonde matrix W. This problem, in turn, reduces to inverting a specially constructed Toeplitz matrix Ŵ derived from W.

Other aspects, objectives and advantages of the invention will become more apparent from the following detailed description when taken in conjunction with the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings incorporated in and forming a part of the specification illustrate several aspects of the present invention and, together with the description, serve to explain the principles of the invention. In the drawings:

FIGS. 1A-1B depict two examples of logarithmic spiral contours with 32 and 64 points, respectively, where the start of each contour is indicated with an unfilled circle;

FIG. 2 is a chart providing an illustration of the numerical accuracy for performing CZT followed by ICZT for contours with shapes like those shown in FIGS. 1A-1B but with different number of points, M, and for calculations that use different floating-point precisions;

FIG. 3 is a chart providing an illustration of the generating vectors and matrix shapes for different types of structured matrices;

FIGS. 4A-4B give an example that illustrates the difference between the fixed magnitude complex exponentials used by the FFT or the IFFT and the exponentially growing or exponentially decaying complex exponentials that can be used by the CZT or the ICZT, respectively;

FIGS. 5A-5D depict examples of logarithmic spiral contours whose points are located outside the unit circle, inside the unit circle, start outside the unit circle and end inside it, and start inside the unit circle and end outside it, respectively;

FIGS. 6A-6C depict examples of logarithmic spiral contours whose points are located on the unit circle that span 90 degrees, 180 degrees, and 360 degrees, respectively;

FIGS. 7A-7B depict examples of logarithmic spiral contours whose points span two 360-degree revolutions and five 360-degree revolutions, respectively.

While the invention will be described in connection with certain preferred embodiments, there is no intent to limit it to those embodiments. On the contrary, the intent is to cover all alternatives, modifications and equivalents as included within the spirit and scope of the invention as defined by the appended claims.

DETAILED DESCRIPTION OF THE INVENTION

Embodiments of the present disclosure describe an efficient O(n log n) ICZT algorithm that implements the ICZT for A, W∈\{0}. The ICZT generalizes the inverse fast Fourier transform (IFFT) by making it possible to distribute the sample points on a logarithmic spiral contour in the complex plane instead of the unit circle. Two example logarithmic spiral contours are shown in FIGS. 1A-1B. Whenever a sample point is not on the unit circle, the corresponding frequency component is growing or decaying exponentially. FIGS. 4A-4B show some examples of growing, decaying, and constant-magnitude frequency components used by FFT/IFFT and CZT/ICZT.

The ICZT algorithm was derived by expressing the CZT formula as a product of structured matrices and finding a way to invert the matrix equation. More specifically, computing the ICZT reduces to inverting a special case of a Vandermonde matrix W. This can be accomplished by inverting a special case of a Toeplitz matrix Ŵ derived from W.

Structured matrices are matrices that can be described with fewer parameters than their total number of elements. Examples of structured matrices include Toeplitz, Hankel, Vandermonde, and Cauchy matrices. Other examples include circulant, skew-circulant, and DFT matrices. Diagonal matrices can also be viewed as structured matrices. FIG. 3 illustrates the general shape of some of these structured matrices. The examples shown in FIG. 3 are for 3-by-3 matrices. Further, FIG. 3 illustrates the generating vector(s) that can be used to generate each matrix. In most cases, these are denoted with r and c, which specify the first row and the first column of the matrix.

Gohberg and Semencul showed that the inverse of a Toeplitz matrix can be expressed using a difference of two products of Toeplitz matrices. This work can be found in I. Gohberg et al., “On the inversion of finite Toeplitz matrices and their continuous analogs,” Mat. issued, 2(1):201-233, 1972 and William Trench, “An algorithm for inversion of finite Toeplitz matrices,” Journal of the Society for Industrial and Applied Mathematics, 12(3):515-522, 1964, both of the references are incorporated in their entirety herein by reference. In the literature, this result is often referred to as the “Gohberg-Semencul formula.” The four matrices in this formula, which are either upper-triangular or lower-triangular Toeplitz, are generated by two vectors u and v. In the case of the ICZT, the Toeplitz matrix to be inverted is also symmetric. This leads to a simplified version of the Gohberg-Semencul formula that expresses the inverse using only one generating vector, i.e., using only the vector u.

The inventors have determined that in the ICZT case it is possible to derive a formula that defines the generating vector u as a function of the complex number W. This formula led to an efficient ICZT algorithm. This algorithm includes a step of multiplying a Toeplitz matrix by a vector, which can be done in O(n log n), without storing the full Toeplitz matrix in memory. Appendices C, D and E implement three different algorithms based on these references that can compute this product. Each of these algorithms can be used as a building block of the ICZT algorithm. The Fast Fourier Transform (FFT) algorithm, which is stated in Appendix B, is used in each of these three algorithms.

Broader Impacts

The discrete Fourier transform (DFT) and its efficient implementation using the fast Fourier transform (FFT) are deeply embedded in a huge variety of modern-day applications. Because the CZT is a generalization of the DFT and the ICZT is a generalization of the inverse DFT, the number of potential applications of this invention is very large. So far, only the CZT algorithm had the same computational complexity as the FFT, i.e., O(n log n). This disclosure introduces an ICZT algorithm that has the same complexity as the inverse FFT (IFFT), which is also O(n log n).

In other words, this invention is transformative not only because it implements a transform that generalizes the inverse FFT, but also because the new algorithm has the same run-time complexity as the algorithm that it generalizes.

Logarithmic spiral contours that can be used with the ICZT include contours whose points are located outside the unit circle, inside the unit circle, start outside the unit circle and end inside it, start inside the unit circle and end outside it. Examples of such contours are shown in FIGS. 5A-5D. Moreover, the contour points may cover partial arcs on the unit circle, e.g., a 90-degree arc, a 180-degree arc, or even a complete 360-degree turn, in which case the contour can be identical to the contour used by the FFT/IFFT. Examples of such contours are shown in FIGS. 6A-6C. Finally, the contour points may even cover multiple 360-degree revolutions. FIGS. 7A-7B show examples with two and five complete revolutions. In general, the number of revolutions may not even be integer.

Expressing the Chirp Z-Transform Using Structured Matrices

Example 4-by-4 CZT Expressed in Matrix Form

This example describes the CZT for a special case with four inputs and four outputs using the matrix notation. In this case, the CZT is defined using the following formula:

$\begin{array}{cc}{X}_k=\sum _{j=0}^3{x}_j{A}^{-j}{W}^{jk},k\in \left\{0,1,2,3\right\}.& \left(2.1\right)\end{array}$

Let x=(x₀, x₁, x₂, x₃)^T denote the CZT input vector and X=(X₀, X₁, X₂, X₃)^T denote the output vector. Using these two vectors, the 4-by-4 CZT can also be expressed using the following matrix formula:

$\begin{array}{cc}\begin{array}{c}\left[\begin{array}{c}{X}_0\\ X_1\\ X_2\\ X_3\end{array}\right]=\left[\begin{array}{cccc}{A}^{-0}{W}^{0·0}& A^{-1}{W}^{1·0}& A^{-2}{W}^{2·0}& A^{-3}{W}^{3·0}\\ A^{-0}{W}^{0·1}& A^{-1}{W}^{1·1}& A^{-2}{W}^{2·1}& A^{-3}{W}^{3·1}\\ A^{-0}{W}^{0·2}& A^{-1}{W}^{1·2}& A^{-2}{W}^{2·2}& A^{-3}{W}^{3·2}\\ A^{-0}{W}^{0·3}& A^{-1}{W}^{1·3}& A^{-2}{W}^{2·3}& A^{-3}{W}^{3·3}\end{array}\right]\left[\begin{array}{c}{x}_0\\ x_1\\ x_2\\ x_3\end{array}\right]\\ =\underset{\underset{W}{︸}}{\left[\begin{array}{cccc}{W}^{0·0}& W^{1·0}& W^{2·0}& W^{3·0}\\ W^{0·1}& W^{1·1}& W^{2·1}& W^{3·1}\\ W^{0·2}& W^{1·2}& W^{2·2}& W^{3·2}\\ W^{0·3}& W^{1·3}& W^{2·3}& W^{3·3}\end{array}\right]}\underset{\underset{A}{︸}}{\left[\begin{array}{cccc}{A}^{-0}& 0& 0& 0\\ 0& A^{-1}& 0& 0\\ 0& 0& A^{-2}& 0\\ 0& 0& 0& A^{-3}\end{array}\right]}\underset{\underset{x}{︸}}{\left[\begin{array}{c}{x}_0\\ x_1\\ x_2\\ x_3\end{array}\right]}\\ =\mathrm{WAx}.\end{array}\hspace{1em}& \left(2.2\right)\end{array}$

That is, the example CZT can be viewed as multiplying the input vector x by a diagonal matrix generated by the negative powers of the complex parameter A and multiplying the resulting vector by the Vandermonde matrix W, which is determined by the complex parameter W.

In this example, the matrix W has the following form:

$\begin{array}{cc}W=\left[\begin{array}{cccc}{W}^{0·0}& W^{1·0}& W^{2·0}& W^{3·0}\\ W^{0·1}& W^{1·1}& W^{2·1}& W^{3·1}\\ W^{0·2}& W^{1·2}& W^{2·2}& W^{3·2}\\ W^{0·3}& W^{1·3}& W^{2·3}& W^{3·3}\end{array}\right]=\left[\begin{array}{cccc}1& 1& 1& 1\\ 1& W^1& W^2& W^3\\ 1& W^2& W^4& W^6\\ 1& W^3& W^6& W^9\end{array}\right].& \left(2.3\right)\end{array}$

Inverting the matrix W leads to the ICZT.

Expressing the CZT Using the Vandermonde Matrix W

In the general case, the CZT is typically defined using the following formula:

$\begin{array}{cc}{X}_k=\sum _{j=0}^{N-1}{x}_j{A}^{-j}{W}^{jk},k=0,1,\dots ,M-1.& \left(2.4\right)\end{array}$

In this formula, A and Ware the complex parameters for the transform that define the logarithmic spiral contour and the locations of the samples on it. The parameter N is an integer that specifies the size of the input vector x. Finally, the parameter M is an integer that specifies the size of the output vector X. In general, N may not be equal to M. That is, the dimensionality of the input may not be equal to the dimensionality of the output.

The CZT can be also expressed in matrix form:

$\left(2.5\right)\left[\begin{array}{c}{X}_0\\ X_1\\ X_2\\ ⋮\\ X_{M-1}\end{array}\right]=\hspace{1em}\left[\begin{array}{ccccc}{A}^{-0}{W}^{0·0}& A^{-1}{W}^{1·0}& A^{-2}{W}^{2·0}& \dots & A^{-\left(N-1\right)}{W}^{\left(N-1\right)·0}\\ A^{-0}{W}^{0·1}& A^{-1}{W}^{1·1}& A^{-2}{W}^{2·1}& \dots & A^{-\left(N-1\right)}{W}^{\left(N-1\right)·1}\\ A^{-0}{W}^{0·2}& A^{-1}{W}^{1·2}& A^{-2}{W}^{2·2}& \dots & A^{-\left(N-1\right)}{W}^{\left(N-1\right)·2}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ A^{-0}{W}^{0·\left(M-1\right)}& A^{-1}{W}^{1·\left(M-1\right)}& A^{-2}{W}^{2·\left(M-1\right)}& \dots & A^{-\left(N-1\right)}{W}^{\left(N-1\right)\left(M-1\right)}\end{array}\right]\hspace{1em}\left[\begin{array}{c}{x}_0\\ x_1\\ x_2\\ ⋮\\ x_{N-1}\end{array}\right].$

Formula (2.5) can be restated in the following shortened form:

X=W diag(A⁻⁰,A⁻¹,A⁻², . . . ,A^−(N−1))x,  (2.6)

where W is the following M-by-N matrix:

$\begin{array}{cc}W=\underset{\underset{\mathrm{Vandermonde}\mathrm{matrix}}{︸}}{\left[\begin{array}{ccccc}{W}^{0·0}& W^{1·0}& W^{2·0}& \dots & W^{\left(N-1\right)·0}\\ W^{0·1}& W^{1·1}& W^{2·1}& \dots & W^{\left(N-1\right)·1}\\ W^{0·2}& W^{1·2}& W^{2·2}& \dots & W^{\langle N-1)·2}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ W^{0·\left(M-1\right)}& W^{1·\left(M-1\right)}& W^{2·\left(M-1\right)}& \dots & W^{\left(N-1\right)·\left(M-1\right)}\end{array}\right]}.& \left(2.7\right)\end{array}$

It can be seen that W is a Vandermonde matrix. That is, each row of W forms a geometric progression. Moreover, the common ratio of each of these progressions is equal to the corresponding integer power of the parameter W.

The negative integer powers of A in formula (2.6) scale the columns of the Vandermonde matrix W. Because the matrix W is a special case of a Vandermonde matrix, it can be expressed as a product of diagonal matrices and a Toeplitz matrix Ŵ as described below.

Deriving the Toeplitz Matrix Ŵ from the Vandermonde Matrix W

Because the matrix W is a special case of a Vandermonde matrix, it can be expressed as a product of two diagonal matrices and a Toeplitz matrix Ŵ. It is possible to express the power of the parameter Win each element of the matrix W using the following equation:

$\begin{array}{cc}jk=\frac{j^2+k^2-{\left(k-j\right)}^2}{2}.& \left(2.8\right)\end{array}$

Equation (2.8) implies that the right-hand side of (2.4) can be expressed as follows:

$\begin{array}{cc}\begin{array}{c}{X}_k=\sum _{j=0}^{N-1}{x}_j{A}^{-j}{W}^{\mathrm{jk}}\\ =\sum _{j=0}^{N-1}{x}_j{A}^{-j}{W}^{\frac{j^2+k^2-{\left(k-j\right)}^2}{2}}\\ =\sum _{j=0}^{N-1}{x}_j{A}^{-j}{W}^{\frac{j^2}{2}}{W}^{\frac{k^2}{2}}{W}^{-\frac{{\left(k-j\right)}^2}{2}}.\end{array}& \left(2.9\right)\end{array}$

The terms in the last formula can be rearranged so that it can be mapped to matrix products more easily:

$\begin{array}{cc}{X}_k=W^{\frac{k^2}{2}}\left(\sum _{j=0}^{N-1}{W}^{-\frac{{\left(k-j\right)}^2}{2}}\left(W^{\frac{j^2}{2}}{A}^{-j}\right)x_j\right).& \left(2.10\right)\end{array}$

The term

$W^{\frac{k^2}{2}}$

maps to an M-by-M diagonal matrix P. The term

$W^{\frac{j^2}{2}}{A}^{-j}$

maps to the product of two N-by-N diagonal matrices Q and A. Finally, the term

$W^{-\frac{{\left(k-j\right)}^2}{2}}$

maps to an M-by-N Toeplitz matrix Ŵ, which is shown below:

$\left(2.11\right)$ $\hat{W}=\underset{\underset{\mathrm{Toeplitz}\mathrm{matrix}}{︸}}{\left[\begin{array}{ccccc}{W}^{-\frac{{\left(0-0\right)}^2}{2}}& W^{-\frac{{\left(0-1\right)}^2}{2}}& W^{-\frac{{\left(0-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(0-\left(N-1\right)\right)}^2}{2}}\\ W^{-\frac{{\left(1-0\right)}^2}{2}}& W^{-\frac{{\left(1-1\right)}^2}{2}}& W^{-\frac{{\left(1-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(1-\left(N-1\right)\right)}^2}{2}}\\ W^{-\frac{{\left(2-0\right)}^2}{2}}& W^{-\frac{{\left(2-1\right)}^2}{2}}& W^{-\frac{{\left(2-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(2-\left(N-1\right)\right)}^2}{2}}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ W^{-\frac{{\left(\left(M-1\right)-0\right)}^2}{2}}& W^{-\frac{{\left(\left(M-1\right)-1\right)}^2}{2}}& W^{-\frac{{\left(\left(M-1\right)-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(\left(M-1\right)-\left(N-1\right)\right)}^2}{2}}\end{array}\right]}.$

This implies that a product of the matrix Ŵ and a vector can be efficiently computed using one of several O(n log n) algorithms that implement this operation (see Appendices C, D, and E). In other words, Equation (2.10) has the following matrix form:

$\begin{array}{cc}X=\mathrm{diag}\left(W^{\frac{0^2}{2}},W^{\frac{1^2}{2}},\dots ,W^{\frac{{\left(M-1\right)}^2}{2}}\right)\hat{W}\mathrm{diag}\left(W\frac{0^2}{2}{A}^{-0},W^{\frac{1^2}{2}}{A}^{-1},\dots ,W^{\frac{{\left(N-1\right)}^2}{2}}{A}^{-\left(N-1\right)}\right)x,& \left(2.12\right)\end{array}$

in which all matrix-vector products can be computed in O(n log n), where n=max(M, N).

To summarize, the CZT algorithm can be viewed as an efficient implementation of the following matrix equation:

X=W A x=P Ŵ Q A x,  (2.13)

where

$P=\mathrm{diag}\left(W^{\frac{0^2}{2}},W^{\frac{1^2}{2}},\dots ,W^{\frac{{\left(M-1\right)}^2}{2}}\right),Q=\mathrm{diag}\left(W^{\frac{0^2}{2}},W^{\frac{1^2}{2}},\dots ,W^{\frac{{\left(N-1\right)}^2}{2}}\right),A=\mathrm{diag}\left(A^{-0},A^{-1},\dots ,A^{-\left(N-1\right)}\right),$

W is a special case of a Vandermonde matrix defined in (2.7), and Ŵ is a special case of a Toeplitz matrix defined in (2.11). As described previously, x is the input vector to the CZT and X is the output vector from the CZT.

Expressing the Inverse of a Toeplitz Matrix

The Gohberg-Semencul Formula for the 4-by-4 Case

Let T be a 4-by-4 Toeplitz matrix. That is,

$\begin{array}{cc}T=\left[\begin{array}{cccc}a& b& c& d\\ f& a& b& c\\ g& f& a& b\\ h& g& f& a\end{array}\right],& \left(3.1\right)\end{array}$

where a, b, c, d, f, g, and h are the seven complex numbers that generate the matrix T.

The Gohberg-Semencul formula states that a non-singular 4-by-4 Toeplitz matrix T can be inverted using the following equation:

$\left(3.2\right)$ $u_0{T}^{-1}=\underset{\underset{𝒜}{︸}}{\left[\begin{array}{cccc}{u}_0& 0& 0& 0\\ u_1& u_0& 0& 0\\ u_2& u_1& u_0& 0\\ u_3& u_2& u_1& u_0\end{array}\right]}\underset{\underset{𝒞}{︸}}{\left[\begin{array}{cccc}{v}_3& v_2& v_1& v_0\\ 0& v_3& v_2& v_1\\ 0& 0& v_3& v_2\\ 0& 0& 0& v_3\end{array}\right]}-\underset{\underset{ℬ}{︸}}{\left[\begin{array}{cccc}0& 0& 0& 0\\ v_0& 0& 0& 0\\ v_1& v_0& 0& 0\\ v_2& v_1& v_0& 0\end{array}\right]}\underset{\underset{𝒟}{︸}}{\left[\begin{array}{cccc}0& u_3& u_2& u_1\\ 0& 0& u_3& u_2\\ 0& 0& 0& u_3\\ 0& 0& 0& 0\end{array}\right]},$

where u=(u₀, u₁, u₂, u₃) is a four-element vector such that u₀ #0 and v=(v₀, v₁, v₂, v₃) is another four-element vector such that v₃≠0. These two vectors are determined by the numbers a, b, c, d, f, g, and h that generate the matrix T. However, expressing them explicitly as functions of the seven numbers that generate T can be difficult.

To summarize, formula (3.2) expresses the inverse of a 4-by-4 Toeplitz matrix T using four structured matrices: 1) a lower-triangular Toeplitz matrix generated by the vector u, 2) an upper-triangular Toeplitz matrix generated by the reverse of the vector v, 3) a lower-triangular Toeplitz matrix generated by the vector (0, v₀, v₁, v₂), which is obtained by shifting v to the right by one element, and 4) an upper-triangular Toeplitz matrix generated by the vector (0, u₃, u₂, u₁), which is obtained by shifting the reverse of u to the right by one element.

The General Case of the Gohberg-Semencul Formula

Let T be a n-by-n Toeplitz matrix generated by the vector r=(r₀, r₁, r₂, . . . , r_n−1) that specifies its first row and by the vector c=(c₀, c₁, c₂, . . . , c_n−1) that specifies its first column. It is assumed that r₀=c₀. More formally,

$\begin{array}{cc}T=\left[\begin{array}{cccccc}{r}_0& r_1& r_2& \dots & r_{n-2}& r_{n-1}\\ c_1& r_0& r_1& \dots & r_{n-3}& r_{n-2}\\ c_2& c_1& r_0& \dots & r_{n-4}& r_{n-3}\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ c_{n-2}& c_{n-3}& c_{n-4}& \dots & r_0& r_1\\ c_{n-1}& c_{n-2}& c_{n-3}& \dots & c_1& r_0\end{array}\right].& \left(3.3\right)\end{array}$

The inverse matrix T⁻¹ of a Toeplitz matrix T may not be Toeplitz. Nevertheless, the Gohberg-Semencul formula makes it possible to express T⁻¹ using upper-triangular and lower-triangular Toeplitz matrices.

That is, the Gohberg-Semencul formula states that there exist a vector u=(u₀, u₁, u₂, . . . , u_n−1) and a vector v=(v₀, v₁, v₂, . . . , v_n−1) that satisfy the following matrix equation:

$\begin{array}{cc}\begin{array}{c}{u}_0{T}^{-1}=\underset{\underset{𝒜}{︸}}{\left[\begin{array}{cccccc}{u}_0& 0& 0& \dots & 0& 0\\ u_1& u_0& 0& \dots & 0& 0\\ u_2& u_1& u_0& \dots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ u_{n-2}& u_{n-3}& u_{n-4}& \dots & u_0& 0\\ u_{n-1}& u_{n-2}& u_{n-3}& \dots & u_1& u_0\end{array}\right]}\\ \underset{\underset{𝒞}{︸}}{\left[\begin{array}{cccccc}{v}_{n-1}& v_{n-2}& v_{n-3}& \dots & v_1& v_0\\ 0& v_{n-1}& v_{n-2}& \dots & v_2& v_1\\ 0& 0& v_{n-1}& \dots & v_3& v_2\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \dots & v_{n-1}& v_{n-2}\\ 0& 0& 0& \dots & 0& v_{n-1}\end{array}\right]}-\\ \underset{\underset{ℬ}{︸}}{\left[\begin{array}{cccccc}0& 0& 0& \dots & 0& 0\\ v_0& 0& 0& \dots & 0& 0\\ v_1& v_0& 0& \dots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ v_{n-3}& v_{n-4}& v_{n-5}& \dots & 0& 0\\ v_{n-2}& v_{n-3}& v_{n-4}& \dots & v_0& 0\end{array}\right]}\\ \underset{\underset{𝒟}{︸}}{\left[\begin{array}{cccccc}0& u_{n-1}& u_{n-2}& \dots & u_2& u_1\\ 0& 0& u_{n-1}& \dots & u_3& u_2\\ 0& 0& 0& \dots & u_4& u_3\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \dots & 0& u_{n-1}\\ 0& 0& 0& \dots & 0& 0\end{array}\right]}\\ =\mathrm{𝒜𝒞}-\mathrm{ℬ𝒟}.\end{array}& \left(3.4\right)\end{array}$

In other words, the inverse matrix T⁻¹ can be viewed as a structured matrix that is generated by the vector u and the vector v. This analogy extends to multiplying T⁻¹ by a vector. If the generating vectors u and v are determined, then the product of the matrix T⁻¹ and a vector can be computed in O(n log n) by implementing (3.4) using structured matrix multiplication.

Expressing the ICZT Using Structured Matrices

Equation (2.13) showed that the CZT can be reduced to a sequence of matrix-vector multiplications where all matrices are diagonal except for W, which is the following Toeplitz matrix:

$\left(4.1\right)$ $\hat{W}=\hspace{1em}\left[\begin{array}{ccccc}{W}^{-\frac{{\left(0-0\right)}^2}{2}}& W^{-\frac{{\left(0-1\right)}^2}{2}}& W^{-\frac{{\left(0-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(0-\left(N-1\right)\right)}^2}{2}}\\ W^{-\frac{{\left(1-0\right)}^2}{2}}& W^{-\frac{{\left(1-1\right)}^2}{2}}& W^{-\frac{{\left(1-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(1-\left(N-1\right)\right)}^2}{2}}\\ W^{-\frac{{\left(2-0\right)}^2}{2}}& W^{-\frac{{\left(2-1\right)}^2}{2}}& W^{-\frac{{\left(2-2\right)}^2}{2}}& \dots & W^{-\frac{{\left(2-\left(N-1\right)\right)}^2}{2}}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ W^{-\frac{{\left(\left(M-1\right)-0\right)}^2}{2}}& W^{-\frac{{\left(\left(M-1\right)-1\right)}^2}{2}}& W^{-\frac{{\left(\left(M-1\right)-1\right)}^2}{2}}& \dots & W^{-\frac{{\left(\left(M-1\right)-\left(N-1\right)\right)}^2}{2}}\end{array}\right].$

This implies that the ICZT can be viewed as a product of diagonal matrices, the inverse matrix Ŵ⁻¹, and a vector (see formula (2.13)).

Let u and v be the two vectors that generate W using the Gohberg-Semencul formula, i.e.,

u=(u₀,u₁,u₂, . . . ,u_n−1)^T,  (4.2)

v=(v₀,v₁,v₂, . . . ,v_n−1)^T.  (4.3)

Because the matrix Ŵ is symmetric, its inverse Ŵ⁻¹ is also symmetric. The formula for Ŵ⁻¹ is a special case of the Gohberg-Semencul formula. Inspection of the special cases of the inverse matrix Ŵ⁻¹ for the first several values of n suggested making three useful assumptions. First, the vector u is equal to the first column of Ŵ⁻¹. More formally,

u _j−1=(Ŵ⁻¹)_j,l for each j∈{1,2, . . . ,n}.  (4.4)

Second, the vector v is equal to the last column of W⁻¹, i.e.,

v _j−1=(Ŵ⁻¹)_j,n for each j∈{1,2, . . . ,n}.  (4.5)

Third, the vector v is equal to the reverse of the vector u,

v _k =u _n−1−k for each k∈{0,1,2, . . . ,n−1}.  (4.6)

In other words, only the vector u needs to be determined to be able to multiply the inverse matrix Ŵ⁻¹ by a vector using structured matrix multiplication.

One approach to deriving an explicit formula for computing the vector u is to derive it from special cases for the first several values of n. If this induction is successful, then it should be possible to use the resulting formula for each finite n. Because u determines v, this is sufficient to formulate the ICZT algorithm using the Gohberg-Semencul formula and structured matrix multiplication.

Special Cases of the Formula for Inverting the Toeplitz Matrix Ŵ

Special Case for n=1

Suppose that n=1. Then, Ŵ is a 1-by-1 matrix that consists of a single number, which is equal to 1. More formally,

$\begin{array}{cc}\hat{W}=\left[W^{-\frac{{\left(0-0\right)}^2}{2}}\right]=\left[1\right].& \left(4.7\right)\end{array}$

This implies that the inverse matrix Ŵ⁻¹ is also a 1-by-1 matrix that consists of a single number 1, i.e.,

Ŵ ⁻¹=[1].  (4.8)

The first and last row of Ŵ⁻¹ are identical: both consist of a single element that is equal to 1. More formally,

u=(u₀)=(Ŵ_1,1⁻¹)=(1),  (4.9)

v=(v₀)=(Ŵ_1,n⁻¹)=(1).  (4.10)

This leads to a degenerate special case of the Gohberg-Semencul formula:

$\begin{array}{cc}\underset{\underset{1}{︸}}{u_0}\underset{\underset{\left[1\right]}{︸}}{{\hat{W}}^{-1}}=\mathrm{𝒜𝒞}-\mathrm{ℬ𝒟}=\underset{\underset{\left[1\right]}{︸}}{\left[u_0\right]}\underset{\left[1\right]}{\left[v_0\right]}-\left[0\right]\left[0\right]=\left[1\right].& \left(4.11\right)\end{array}$

Special Case for n=2

Suppose that n=2. Then, Ŵ is a 2-by-2 matrix that is specified by the following formula:

$\begin{array}{cc}\hat{W}=\left[\begin{array}{cc}{W}^{-\frac{{\left(0\mathrm{­0}\right)}^2}{2}}& W^{-\frac{{\left(0\mathrm{­1}\right)}^2}{2}}\\ W^{-\frac{{\left(1\mathrm{­0}\right)}^2}{2}}& W^{W^{-\frac{{\left(1-1\right)}^2}{2}}}\end{array}\right]=\left[\begin{array}{cc}{W}^0& W^{-\frac{1}{2}}\\ W^{-\frac{1}{2}}& W^0\end{array}\right]=\left[\begin{array}{cc}1& W^{-\frac{1}{2}}\\ W^{-\frac{1}{2}}& 1\end{array}\right],& \left(4.12\right)\end{array}$

which is well-defined for each W∈\{0}.

In this case, the inverse matrix Ŵ⁻¹ is also a 2-by-2 matrix, which implies that its first column u is a two-element vector, i.e., u=(u₀, u₁)^T. Its elements can be expressed as a function of W by solving the following linear system:

Ŵu=e ₀.  (4.13)

In this formula, e₀ denotes a vector in which the first element is set to one and the remaining elements are set to zero, i.e.,

e ₀=(1,0)^T.  (4.14)

In other words, the dot-product of the first row of Ŵ and the vector u has to be equal to 1 and the dot product of the second row of Ŵ and u has to be equal to 0.

The linear system (4.13) can be expressed in terms of the four elements of Ŵ and the two elements of u. This leads to the following expanded form of (4.13):

$\begin{array}{cc}\underset{\underset{\hat{W}}{︸}}{\left[\begin{array}{cc}1& W^{-\frac{1}{2}}\\ W^{-\frac{1}{2}}& 1\end{array}\right]}\underset{\underset{u}{︸}}{\left[\begin{array}{c}{u}_0\\ u_1\end{array}\right]}=\underset{\underset{e_0}{︸}}{\left[\begin{array}{c}1\\ 0\end{array}\right]}.& \left(4.15\right)\end{array}$

The previous equation can also be viewed as a system of two scalar linear equations:

$\begin{array}{cc}{u}_0+u_1{W}^{-\frac{1}{2}}=1,& \left(4.16\right)\\ u_0{W}^{-\frac{1}{2}}+u_1=0.& \left(4.17\right)\end{array}$

Both of these equations are well-defined whenever W≠0.

The term

$u_0{W}^{-\frac{1}{2}}$

can be subtracted from both sides of (4.17), which leads to a formula for the value of u₁ as a function of W and u₀:

$\begin{array}{cc}{u}_1=-u_0{W}^{-\frac{1}{2}}.& \left(4.18\right)\end{array}$

The right-hand side of the previous equation can be plugged into (4.16). This results in an equation that depends only on u₀ and W. More formally,

$\begin{array}{cc}\begin{array}{c}{u}_0+u_1{W}^{-\frac{1}{2}}=u_0-u_0{W}^{-\frac{1}{2}}{W}^{-\frac{1}{2}}\\ =u_0-u_0{W}^{-1}\\ =\frac{\left(W-1\right)u_0}{W}=1.\end{array}& \left(4.19\right)\end{array}$

Multiplying both sides of the previous equation by

$\frac{W}{W-1}$

leads to a formula for the value of u₀ as a function of W:

$\begin{array}{cc}{u}_0=\frac{W}{W-1}.& \left(4.20\right)\end{array}$

Plugging this value into the right-hand side of (4.18) results in a formula that expresses the value of u₁ as a function of W. More formally,

$\begin{array}{cc}{u}_1=-u_0{W}^{-\frac{1}{2}}=-\frac{W{W}^{-\frac{1}{2}}}{W-1}=-\frac{W^{\frac{1}{2}}}{W-1}.& \left(4.21\right)\end{array}$

To summarize, in the 2-by-2 case a column vector u that specifies the first column of the inverse matrix Ŵ⁻¹ can be expressed as the following function of the parameter W:

$\begin{array}{cc}u={\left[\frac{W}{W-1},-\frac{W^{\frac{1}{2}}}{W-1}\right]}^T.& \left(4.22\right)\end{array}$

The vector v can be obtained by reversing the elements of u, i.e.,

$\begin{array}{cc}v={\left[-\frac{W^{\frac{1}{2}}}{W-1},\frac{W}{W-1}\right]}^T.& \left(4.23\right)\end{array}$

A closed-form expression for the inverse matrix Ŵ⁻¹ can be derived by combining the expressions for u and v. That is,

$\begin{array}{cc}{\hat{W}}^{-1}=\left[\begin{array}{cc}\frac{W}{W-1}& -\frac{W^{\frac{1}{2}}}{W-1}\\ -\frac{W^{\frac{1}{2}}}{W-1}& \frac{W}{W-1}\end{array}\right],W\notin \left\{0,1\right\}.& \left(4.24\right)\end{array}$

In this special case, the Gohberg-Semencul formula can be verified using the following sequence of matrix transformations. It starts from the difference between the left-hand side and the right-hand side of the formula stated in (3.4) and shows that this difference is equal to zero:

$\begin{array}{cc}\begin{array}{c}d=u_0{\hat{W}}^{-1}-\left(\left[\begin{array}{cc}{u}_0& 0\\ u_1& u_0\end{array}\right]\left[\begin{array}{cc}{v}_1& v_0\\ 0& v_1\end{array}\right]-\left[\begin{array}{cc}0& 0\\ v_0& 0\end{array}\right]\left[\begin{array}{cc}0& u_1\\ 0& 0\end{array}\right]\right)\\ =\frac{W}{W-1}\left[\begin{array}{cc}\frac{W}{W-1}& -\frac{W^{\frac{1}{2}}}{W-1}\\ -\frac{W^{\frac{1}{2}}}{W-1}& \frac{W}{W-1}\end{array}\right]-(\left[\begin{array}{cc}{u}_0{v}_1& u_0{v}_0\\ u_1{v}_1& +u_0{v}_1\end{array}\right]-\left[\begin{array}{cc}0& 0\\ 0& \end{array}\right]\\ =\left[\begin{array}{cc}\frac{W^2}{{\left(W-1\right)}^2}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}\\ -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^2}{{\left(W-1\right)}^2}\end{array}\right]-\left[\begin{array}{cc}\frac{W}{W-1}\frac{W}{W-1}& -\frac{W}{W-1}\frac{W^{\frac{1}{2}}}{W-1}\\ -\frac{W^{\frac{1}{2}}}{W-1}\frac{W}{W-1}& \frac{W}{W-1}\frac{W}{W-1}\end{array}\right]=\left[\begin{array}{cc}0& 0\\ 0& 0\end{array}\right].\end{array}& \left(4.25\right)\end{array}$

Special Case for n=3

In this special case, Ŵ is a 3-by-3 Toeplitz matrix. Each element of Ŵ is a function of the transform parameter W. More formally,

$\begin{array}{cc}\hat{W}=\left[\begin{array}{ccc}W-\frac{{\left(0-0\right)}^2}{2}& W-\frac{{\left(0-1\right)}^2}{2}& W-\frac{{\left(0-2\right)}^2}{2}\\ W-\frac{{\left(1-0\right)}^2}{2}& W-\frac{{\left(1-1\right)}^2}{2}& W-\frac{{\left(1-2\right)}^2}{2}\\ W-\frac{{\left(2-0\right)}^2}{2}& W-\frac{{\left(2-1\right)}^2}{2}& W-\frac{{\left(2-2\right)}^2}{2}\end{array}\right]=\hspace{1em}\hspace{1em}\left[\begin{array}{ccc}{W}^0& W^{-\frac{1}{2}}& W^{-2}\\ W^{-\frac{1}{2}}& W_0& W^{-\frac{1}{2}}\\ W^{-2}& W^{-\frac{1}{2}}& W^0\end{array}\right]=\left[\begin{array}{ccc}1& W^{-\frac{1}{2}}& W^{-2}\\ W^{-\frac{1}{2}}& 1& W^{-\frac{1}{2}}\\ W^{-2}& W^{-\frac{1}{2}}& 1\end{array}\right].& \left(4.26\right)\end{array}$

The inverse matrix Ŵ⁻¹ is also a 3-by-3 matrix, but it is no longer Toeplitz, in contrast to the 2-by-2 case. Let u be the first column of Ŵ⁻¹, i.e.,

u=(u₀,u₁,u₂)^T=((Ŵ⁻¹)_1,1,(Ŵ⁻¹)_2,1,(Ŵ⁻¹)_3,1)^T.  (4.27)

Similarly to the 2-by-2 case, the vector u is a solution to the following linear system:

Ŵu=e ₀.  (4.28)

In contrast to the previous case, however, in this case e₀ denotes a column vector that consists of three elements instead of two elements. The first element of e₀ is equal to 1. The remaining two elements of e₀ are equal to 0. In other words,

e ₀=(1,0,0)^T.  (4.29)

The linear system (4.28) can be expressed in terms of the nine elements that constitute Ŵ and of the three elements that constitute u. A result of this expansion is shown below:

$\begin{array}{cc}\underset{\hat{W}}{\underbrace{\left[\begin{array}{ccc}1& W^{-\frac{1}{2}}& W^{-2}\\ W^{-\frac{1}{2}}& 1& W^{-\frac{1}{2}}\\ W^{-2}& W^{-\frac{1}{2}}& 1\end{array}\right]}}\underset{u}{\underbrace{\left[\begin{array}{c}{u}_0\\ u_1\\ u_2\end{array}\right]}}=\underset{e_0}{\underbrace{\left[\begin{array}{c}1\\ 0\\ 0\end{array}\right]}}.& \left(4.30\right)\end{array}$

This linear system can also be expressed in scalar form using a system of three equations with three unknowns. The left-hand side of each of these three equations is equal to a dot product between a row of Ŵ and the vector u. The right-hand side is equal to the corresponding element of e₀. More formally,

$\begin{array}{cc}{u}_0+u_1{W}^{-\frac{1}{2}}+u_2{W}^{-2}=1,& \left(4.31\right)\\ u_0{W}^{-\frac{1}{2}}+u_1+u_2{W}^{-\frac{1}{2}}=0,& \left(4.32\right)\\ u_0{W}^{-2}+u_1{W}^{-\frac{1}{2}}+u_2=0.& \left(4.33\right)\end{array}$

Solving this system of linear equations leads to a formula that expresses the vector u as a function of the parameter W, which is shown below:

$\begin{array}{cc}u=\left[\begin{array}{c}\frac{W^3}{\left(W-1\right)\left(W^2-1\right)}\\ -\frac{W^{\frac{3}{2}}}{\left(W-1\right)\left(W-1\right)}\\ \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}\end{array}\right].& \left(4.34\right)\end{array}$

The inverse matrix Ŵ⁻¹ has the following form

$\begin{array}{cc}{\hat{W}}^{-1}=\left[\begin{array}{ccc}\frac{W^3}{\left(W-1\right)\left(W^2-1\right)}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}\\ -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^2+1}{{\left(W-1\right)}^2}& -\frac{W^{\frac{3}{2}}}{{\left(W\text{'}-1\right)}^2}\\ \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^3}{\left(W-1\right)\left(W^2-1\right)}\end{array}\right].& \left(4.35\right)\end{array}$

Note that the vector v specifies the last column of Ŵ⁻¹ and it is equal to the reverse of the vector u, which specifies the first column of the matrix. In other words, the previous formula confirms the three assumptions (4.4), (4.5), and (4.6).

Repeating this process for other values of n allows us to derive the general formula that determines u. The next section states this formula.

General Formula for Inverting the Toeplitz Matrix Ŵ

In the general case, the elements of the vector u, which specifies the first column of Ŵ⁻¹, can be computed using the following formula:

$\begin{array}{cc}{u}_k={\left({\hat{W}}^{-1}\right)}_{k+1,1}={\left(-1\right)}^k\frac{W^{\frac{2k^2-\left(2n-1\right)k+n\left(n-1\right)}{2}}}{\prod _{s=1}^{n-k-1}\left(W^s-1\right)\prod _{s=1}^k\left(W^s-1\right)},\mathrm{for}\mathrm{each}k\in \left\{0,1,2,\dots ,n-1\right\}.& \left(4.36\right)\end{array}$

For each k, the value of u_k can be computed in O(l) using precomputed values of the products of the polynomials that appear in the denominator of the right-hand side of (4.36). These values are computed in a separate loop, which runs in O(n).

The resulting value of u and its reverse, which is equal to v, can be plugged into the Gohberg-Semencul formula (3.4) to compute the inverse matrix Ŵ⁻¹. It can also be used as a generating vector for efficient algorithms that compute the products of Toeplitz matrices and vectors. These algorithms can be called in a sequence that implements multiplying the matrix Ŵ⁻¹ by a vector without actually storing Ŵ⁻¹ in memory. This results in the ICZT algorithm that runs in O(n log n).

The ICZT in Matrix Form

The following equation shows the ICZT in matrix form:

x=A ⁻¹ Q ⁻¹ Ŵ ⁻¹ P ⁻¹ X,  (4.37)

where

$A^{-1}=\mathrm{diag}\left(A^0,A^1,\dots ,A^{N-1}\right),Q^{-1}=\mathrm{diag}\left(W^{-\frac{0^2}{2}},W^{-\frac{1^2}{2}},\dots ,W^{-\frac{{\left(N-1\right)}^2}{2}}\right),\mathrm{and}{P}^{-1}=\mathrm{diag}\left(W^{-\frac{0^2}{2}},W^{-\frac{1^2}{2}},\dots ,W^{-\frac{{\left(N-1\right)}^2}{2}}\right).$

That is, the formula shows how to compute the CZT input vector x from its output vector X. This equation was derived by inverting the diagonal matrices in the forward transform formula (2.13) and replacing the matrix Ŵ with its inverse Ŵ⁻¹.

Each matrix in formula (4.37) is either a diagonal matrix or it can be expressed as a difference of products of Toeplitz matrices. Implementing the formula leads to an O(n log n) algorithm for computing the ICZT, which is given in Algorithm 5.2, below. The algorithm performs all matrix computations efficiently by using the generating vectors to compute the results of all matrix-vector operations without storing any intermediate matrices in memory. It requires O(n) memory to run.

Example

In the 3-by-3 case, the CZT can be expressed with the following matrix equation:

$\begin{array}{cc}\underset{X}{\underbrace{\left[\begin{array}{c}{X}_0\\ X_1\\ X_2\end{array}\right]}}=\underset{P}{\underbrace{\left[\begin{array}{ccc}{W}^{\frac{0^2}{2}}& 0& 0\\ 0& W^{\frac{1^2}{2}}& 0\\ 0& 0& W^{\frac{2^2}{2}}\end{array}\right]}}\underset{\hat{W}}{\underbrace{\left[\begin{array}{ccc}1& W^{-\frac{1}{2}}& W^{-2}\\ W^{-\frac{1}{2}}& 1& W^{-\frac{1}{2}}\\ W^{-2}& W^{-\frac{1}{2}}& 1\end{array}\right]}}\underset{Q}{\underbrace{\left[\begin{array}{ccc}{W}^{\frac{0^2}{2}}& 0& 0\\ 0& W^{\frac{1^2}{2}}& 0\\ 0& 0& W^{\frac{2^2}{2}}\end{array}\right]}}\underset{A}{\underbrace{\left[\begin{array}{ccc}{A}^{-0}& 0& 0\\ 0& A^{-1}& 0\\ 0& 0& A^{-2}\end{array}\right]}}\underset{x}{\underbrace{\left[\begin{array}{c}{x}_0\\ x_1\\ x_2\end{array}\right]}}.& \left(4.38\right)\end{array}$

In that case, the expanded matrix equation for the ICZT looks like this:

$\begin{array}{cc}\underset{x}{\underbrace{\left[\begin{array}{c}{x}_0\\ x_1\\ x_2\end{array}\right]}}=\underset{A^{-1}}{\underbrace{\left[\begin{array}{ccc}{A}^0& 0& 0\\ 0& A^1& 0\\ 0& 0& A^2\end{array}\right]}}\underset{Q^{-1}}{\underbrace{\left[\begin{array}{ccc}{W}^{-\frac{0^2}{2}}& 0& 0\\ 0& W^{-\frac{1^2}{2}}& 0\\ 0& 0& W^{-\frac{2^2}{2}}\end{array}\right]}}\underset{W^{-1}}{\underbrace{\left[\begin{array}{ccc}{\hat{W}}_{1,1}^{-1}& {\hat{W}}_{1,2}^{-1}& {\hat{W}}_{1,3}^{-1}\\ {\hat{W}}_{1,1}^{-1}& {\hat{W}}_{2,2}^{-1}& {\hat{W}}_{2,3}^{-1}\\ {\hat{W}}_{3,1}^{-1}& {\hat{W}}_{3,2}^{-1}& {\hat{W}}_{3,3}^{-1}\end{array}\right]}}\underset{P^{-1}}{\underbrace{\left[\begin{array}{ccc}{W}^{-\frac{0^2}{2}}& 0& 0\\ 0& W^{-\frac{1^2}{2}}& 0\\ 0& 0& W^{-\frac{2^2}{2}}\end{array}\right]}}\underset{X}{\underbrace{\left[\begin{array}{c}{X}_0\\ X_1\\ X_2\end{array}\right]}}.& \left(4.39\right)\end{array}$

The inverse matrix Ŵ⁻¹ is given in (4.35). The algorithm, however, does not construct this matrix explicitly. As described above, Ŵ⁻¹ can be expressed as follows:

$\begin{array}{cc}{u}_0{\hat{W}}^{-1}=\underset{A}{\underbrace{\left[\begin{array}{ccc}{u}_0& 0& 0\\ u_1& u_0& 0\\ u_2& u_1& u_0\end{array}\right]}}\underset{C}{\underbrace{\left[\begin{array}{ccc}{v}_2& v_1& v_0\\ 0& v_2& v_1\\ 0& 0& v_2\end{array}\right]}}-\underset{B}{\underbrace{\left[\begin{array}{ccc}0& 0& 0\\ v_0& 0& 0\\ v_1& v_0& 0\end{array}\right]}}\underset{D}{\underbrace{\left[\begin{array}{ccc}0& u_2& u_1\\ 0& 0& u_2\\ 0& 0& 0\end{array}\right]}},& \left(4.40\right)\end{array}$

where the vector u=(u₀, u₁, u₂) is given by (4.34) and the vector v=(v₀, v₁, v₂)=(u₂, u₁, u₀) is the reverse of u. For these values of u and v, equation (4.40) has the following form:

$\begin{array}{cc}{u}_0{\hat{W}}^{-1}=\underset{A}{\underbrace{\left[\begin{array}{ccc}\frac{W^3}{\left(W-1\right)\left(W^2-1\right)}& 0& 0\\ -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^3}{\left(W-1\right)\left(W^2-1\right)}& 0\\ \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^3}{\left(W-1\right)\left(W^2-1\right)}\end{array}\right]}}\underset{C}{\underbrace{\left[\begin{array}{ccc}\frac{W^3}{\left(W-1\right)\left(W^2-1\right)}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^3}{\left(W-1\right)\left(W^2-1\right)}\\ 0& \frac{W^3}{\left(W-1\right)\left(W^2-1\right)}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}\\ 0& 0& \frac{W^3}{\left(W-1\right)\left(W^2-1\right)}\end{array}\right]}}-\underset{B}{\underbrace{\left[\begin{array}{ccc}0& 0& 0\\ \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}& 0& 0\\ -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}& \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}& 0\end{array}\right]}}\underset{D}{\underbrace{\left[\begin{array}{ccc}0& \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}& -\frac{W^{\frac{3}{2}}}{{\left(W-1\right)}^2}\\ 0& 0& \frac{W^2}{\left(W-1\right)\left(W^2-1\right)}\\ 0& 0& 0\end{array}\right]}}.& \left(4.41\right)\end{array}$

In addition, the matrix is equal to the transpose of the matrix and the matrix is equal the transpose of the matrix . Thus, the inverse matrix Ŵ⁻¹ can be expressed in the following simplified form:

$\begin{array}{cc}{\hat{W}}^{-1}=\frac{1}{u_0}\left(A{A}^T-D^{T}D\right).& \left(4.42\right)\end{array}$

Furthermore, both and can be generated from the elements of the vector u.

Substituting (4.42) into (4.37) leads to the following matrix equation for the ICZT:

$\begin{array}{cc}x=\frac{1}{u_0}{A}^{-1}{Q}^{-1}\left(A{A}^T-D^{T}D\right)P^{-1}X.& \left(4.43\right)\end{array}$

Instead, equation (4.43) is computed efficiently by exploiting the structure of these matrices. As described above, these four Toeplitz matrices are not constructed explicitly.

The CZT Algorithm and the ICZT Algorithm

Algorithm 5.1 gives the pseudo-code for the CZT algorithm. The algorithm uses the convolution based algorithm TOEPLITZMULTIPLYC, which is described in Appendix E, to multiply a Toeplitz matrix by a vector. Other algorithms for computing the product of a Toeplitz matrix and a vector can be used instead. For example, both TOEPLITZMULTIPLYE described in Appendix C and TOEPLITZMULTIPLYP described in Appendix D can replace TOEPLITZMULTIPLYC in Algorithm 5.1 without changing its computational complexity.

Algorithm 5.1 Algorithm for the CZT. Runs in O(n log n).
1:  CZT                    ⁡                                          (                                              x                        ,                        M                        ,                                                  W                          =                                                      e                                                          -                                                                                                2                                  ⁢                                  π                                  ⁢                                                                                                                                          ⁢                                  i                                                                M                                                                                                                                    ,                                                  A                          =                          1                                                                    )
2:  N ← LENGTH(x);
3:  n ← max(M, N);
4:  ŵ ← EMPTYARRAY(n);
5:  for k ← 0 to n − 1 do
6:  w^⁡[k]←Wk22⁢;
7:  end for
8:  X ← EMPTYARRAY(N);
9:  r ← EMPTYARRAY(N);
10: c ← EMPTYARRAY(M);
11: for k ← 0 to N − 1 do
12: X[k] ← A−k · ŵ[k] · x[k];
13: r⁡[k]←1w^⁡[k]⁢;
14: end for
15: for k ← 0 to M − 1 do
16: c⁡[k]←1w^⁡[k]⁢;
17: end for
18: X ← TOEPLITZMULTIPLYC(r, c, X); // after this line,
    LENGTH(X) = M
19: for k ← 0 to M − 1 do
20: X[k] ← X[k] · ŵ[k];
21  end for
22: return X;

Algorithm 5.2 gives the pseudo-code for the ICZT algorithm. It implements the inverse formula (4.42) without actually storing any matrices in memory. The algorithm runs in O(n log n), where n=max(M, N). This implementation supports only the case n=M=N. As described above, the function TOEPLITZMULTIPLYC, which is used on lines 23-26, can be replaced with TOEPLITZMULTIPLYE or TOEPLITZMULTIPLYP, without changing the computational complexity of the algorithm.

Algorithm 5.2 Algorithm for the ICZT with input and output of equal sizes. Runs in O(n log n).
1:  ICZT                    ⁡                                          (                                              X                        ,                        N                        ,                                                  W                          =                                                      e                                                          -                                                                                                2                                  ⁢                                  π                                  ⁢                                                                                                                                          ⁢                                  i                                                                M                                                                                                                                    ,                                                  A                          =                          1                                                                    )
2:  M ← Length(X);
3:  if M ≠ N then
4:  ERROR(“Only the case when M = N is supported by this algorithm.”);
5:  end if
6:  n ← N;
7:  x ← EMPTYARRAY(n);
8:  //                                        ⁢                                                                                  ⁢                    Multiply                    ⁢                                                                                  ⁢                    X                    ⁢                                                                                  ⁢                    by                    ⁢                                                                                  ⁢                                                                  d                        ⁢                        iag                                            ⁡                                              (                                                                              W                                                          -                                                                                                0                                  2                                                                2                                                                                                              ,                                                      W                                                          -                                                                                                1                                  2                                                                2                                                                                                              ,                          …                          ⁢                                                                                                          ,                                                      W                                                          -                                                                                                                                    (                                                                          n                                      -                                      1                                                                        )                                                                    2                                                                2                                                                                                                                    )                                                              ⁢                                                                                  ⁢                    and                    ⁢                                                                                  ⁢                    store                    ⁢                                                                                  ⁢                    the                    ⁢                                                                                  ⁢                    result                    ⁢                                                                                  ⁢                    in                    ⁢                                                                                  ⁢                                          x                      .
9:  for k ← 0 to n − 1 do
10: x⁡[k]←X⁡[k]·W-k22⁢;
11: end for
12: // Pre-compute the necessary polynomial products.
13: p ← EMPTYARRAY(n);
14: p[0] ← 1;
15: for k ← 1 to n − 1 do
16: p[k] ← p[k − 1] · (Wk − 1);
17: end for
18: // Compute the generating vector u.
19: u ← EMPTYARRAY(n);
20: for k ← 0 to n − 1 do
21: u⁡[k]←(-1)k⁢W2⁢k2-(2⁢⁢n-1)⁢k+n⁡(n-1)2p⁡[n-k-1]·p⁡[k]⁢;
22: end for
23: x                      ′                                        ←                                                                  TOEPLITZMULTIPLYC                        (                                                                              (                                                          0                              ,                                                              u                                ⁡                                                                  [                                                                      n                                    -                                    1                                                                    ]                                                                                            ,                                                              u                                ⁡                                                                  [                                                                      n                                    -                                    2                                                                    ]                                                                                            ,                              …                              ⁢                                                                                                                          ,                                                              u                                ⁡                                                                  [                                  2                                  ]                                                                                            ,                                                              u                                ⁡                                                                  [                                  1                                  ]                                                                                                                      )                                                    ,                                                                                    (                                                              0                                ,                                0                                ,                                …                                ⁢                                                                                                                                  ,                                0                                                            )                                                                                      ︸                                                              n                                ⁢                                                                                                                                  ⁢                                zeros                                                                                                              ,                          x                                                )                                            ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                      𝒟
24: x                      ′                                        ←                                                                  TOEPLITZMULTIPLYC                        (                                                                                                            (                                                              0                                ,                                0                                ,                                …                                ⁢                                                                                                                                  ,                                0                                                            )                                                                                      ︸                                                              n                                ⁢                                                                                                                                  ⁢                                zeros                                                                                                              ,                                                      (                                                          0                              ,                                                              u                                ⁡                                                                  [                                                                      n                                    -                                    1                                                                    ]                                                                                            ,                                                              u                                ⁡                                                                  [                                                                      n                                    -                                    2                                                                    ]                                                                                            ,                              …                              ⁢                                                                                                                          ,                                                              u                                ⁡                                                                  [                                  1                                  ]                                                                                                                      )                                                    ,                                                      x                            ′                                                                          )                                            ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                                              𝒟                        T
25: x                      ″                                        ←                                                                  TOEPLITZMULTIPLYC                        (                                                  u                          ,                                                      (                                                                                          u                                ⁡                                                                  [                                  0                                  ]                                                                                            ,                                                                                                0                                  ,                                  0                                  ,                                  …                                  ⁢                                                                                                                                          ,                                  0                                                                                                  ︸                                                                      n                                    -                                                                          1                                      ⁢                                                                                                                                                          ⁢                                      zeros                                                                                                                                                                                            )                                                    ,                          x                                                )                                            ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                                              𝒜                        T
26: x                      ″                                        ←                                                                  TOEPLITZMULTIPLYC                        (                                                                              (                                                                                          u                                ⁡                                                                  [                                  0                                  ]                                                                                            ,                                                                                                0                                  ,                                  0                                  ,                                  …                                  ⁢                                                                                                                                          ,                                  0                                                                                                  ︸                                                                      n                                    -                                                                          1                                      ⁢                                                                                                                                                          ⁢                                      zeros                                                                                                                                                                                            )                                                    ,                          u                          ,                                                      x                            ″                                                                          )                                            ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                      𝒜
27: for k ← 0 to n − 1 do
28: x⁡[k]←x″⁡[k]-x′⁡[k]u⁡[0]⁢;
29: end for
30: //                                        ⁢                                                                                  ⁢                    Multiply                    ⁢                                                                                  ⁢                    x                    ⁢                                                                                  ⁢                    by                    ⁢                                                                                  ⁢                                          diag                      ⁡                                              (                                                                                                            A                              0                                                        ⁢                                                          W                                                              -                                                                                                      0                                    2                                                                    2                                                                                                                                              ,                                                                                    A                              1                                                        ⁢                                                          W                                                              -                                                                                                      1                                    2                                                                    2                                                                                                                                              ,                                                                                    A                              2                                                        ⁢                                                          W                                                              -                                                                                                      2                                    2                                                                    2                                                                                                                                              ,                          …                          ⁢                                                                                                          ,                                                                                    A                                                              n                                -                                1                                                                                      ⁢                                                          W                                                              -                                                                                                                                            (                                                                              n                                        -                                        1                                                                            )                                                                        2                                                                    2                                                                                                                                                                    )                                                              ⁢                                                                                  ⁢                    in                    ⁢                                                                                  ⁢                                          place                      .
31: for k ← 0 to n − 1 do
32: x⁡[k]←x⁡[k]·Ak·W-k22⁢;
33: end for
34: return x;

FIG. 2 gives the numerical accuracy of the ICZT as a function of the transform size M and the number of bits used by the floating-point numbers during the computations. The two logarithmic spiral contours in FIGS. 1A-1B correspond to M=32 and M=64 in FIG. 2. The value of A was set to 1.1 for all rows of FIG. 2. The value of W was determined using the formula

$\sqrt[M]{1.2}\times \exp \left(\frac{\mathrm{i2\pi }}{M}\right).$

The numerical accuracy was computed by performing the CZT followed by the ICZT and computing the Euclidean distance between the input of the CZT and the output of the ICZT. The final accuracy was averaged over 100 random input vectors. The second column in FIG. 2 shows the condition number of the transformation matrix. Despite the high condition numbers, this problem is solvable even for large values of M when high precision floating-point numbers are used.

Algorithm 5.3 gives the pseudo-code for the ICZT-RECT algorithm, which implements the inverse algorithm for the case when N≤M. This algorithm calls Algorithm 5.2 with the second parameter set to M and then returns only the first N elements of its output vector.

Algorithm 5.3 ICZT algorithm for the case when N ≤ M. Runs in O(n log n).
1: ICZT-RECT(X, N, W, A)
2: M ← LENGTH(X);
3: if N > M then
4: ERROR(“Only the case when N ≤ M is supported by this algorithm.”);
5: end if
6: x ← ICZT(X, M, W, A);
7: return (x[0], x[1], x[2],..., x[N−1]);

Having described the ICZT algorithm, applications for the algorithm are now provided. In that regard, the following is just a partial list of some useful applications of the ICZT algorithm. In embodiments, the ICZT algorithm is used in applications for generating or analyzing the data received from or sent to radar-based sensors. In other embodiments, the ICZT algorithm is used in applications for generating or analyzing the data received from or sent to sonar sensors. In still other embodiments, the ICZT algorithm is used in applications for generating or analyzing the data received from or sent to other range-based sensors.

In yet other embodiments, the ICZT algorithm is used in hardware implementations of the ICZT algorithm. In embodiments, the hardware implementation is a variety of systems including a memory device and a processor, e.g., a personal computer, a chip (e.g., system-on-a-chip), a system comprising an application-specific integrated circuit (ASIC), a system comprising a graphics processing unit (GPU), or a field-programmable gate array (FPGA).

In further embodiments, the ICZT algorithm is used in improving the speed of applications that need to compute the ICZT by replacing slower methods that invert the matrix explicitly or solve an explicitly-formulated linear system. Additionally, the ICZT algorithm can replace the conventionally used FFT and IFFT in whole or in part. This replacement can extend the scope of a computational system to cover points on logarithmic spiral contours that may be located inside or outside the unit circle. Still further, prior to or during computing of the ICZT, the frequency domain vector can be modified such that the time domain vector returned by the ICZT is different from the time domain vector used to generate the frequency domain vector. For example, an operation can be performed on the frequency domain vector, such as filtering certain elements or frequencies from the vector.

Further, in embodiments, the ICZT algorithm is used in medical imaging applications, e.g., CT, PET, or MRI. Additionally, the ICZT algorithm is used in applications in signal processing, signal analysis, signal synthesis, speech and audio processing, and image processing. In signal processing applications, the input vector of the CZT or FFT may be a time-domain vector derived from an audio or image signal, such as by sampling the signal. The output vector of the CZT or FFT may then be a frequency domain vector representation of those signals.

The following Appendices A-E provide additional information regarding the implementation of the ICZT algorithm.

Appendix A: Reversing the Direction of the Logarithmic Spiral Contour to Improve the Numerical Accuracy of the CZT and the ICZT

This appendix describes alternative versions of the CZT and the ICZT algorithms that improve the numerical accuracy of the computed transforms. This is achieved by reversing the direction of the chirp contour when |W|<1 and keeping the original direction when |W|≥1. The parameters for the reversed contour are W¹=W⁻¹ and A¹=AW^−(M−1). Depending on the concrete values of the transform parameters, the improvement of the numerical accuracy may exceed several orders of magnitude.

Algorithm A.1 gives the pseudo-code for the alternative version of the CZT algorithm that performs contour reversal when |W|<1. Algorithm A.2 gives the pseudo-code for the alternative version of the ICZT algorithm that also performs contour reversal in that case.

Using these algorithms, the numerical accuracy of both the CZT and the ICZT can be improved for chirp contours that are growing logarithmic spirals, i.e., when |W|<1. In those cases, Algorithm A.1 and Algorithm A.2 reverse the direction of the chirp contour. Furthermore, this reversal is accompanied by a reversal of the order of the elements in the vector X, which is the CZT output vector in Algorithm A.1 and the ICZT input vector in Algorithm A.2.

Algorithm A.1 | CZT algorithm that reverses the direction of the
chirp contour when |W| < 1. Runs in O(n log n).
1:	CZT-R(x, M, W, A)
2:	if |W| ≥ 1 then
3:	X ← CZT(x, M, W, A);	// original contour
4:	else
5:	// Swap the start and the end point of the chirp contour.
6:	A′ ← AW−(M−1);
7:	W′ ← 1/W;
8:	X′ ← CZT(x, M, W′, A′);	// reversed contour
9:	X ← EMPTYARRAY(M);
10:	for k ← 0 to M−1 do	// reverse the output vector
11:	X[k] ← X′[M−1−k];
12:	end for
13:	end if
14:	return X;

Algorithm A.2 | ICZT algorithm that reverses the direction of the chirp
contour when |W| < 1. Runs in O(n log n).
1:	ICZT-R(X, N, W, A)
2:	M ← LENGTH(X);
3:	if |W| ≥ 1 then
4:	x ← ICZT(X, N, W, A);	// original contour
5:	else
6:	A′ ← AW−(M−1);
7:	W′ ← 1/W;
8:	X′ ← EMPTYARRAY(M);
9:	for k ← 0 to M−1 do	// reverse the input vector
10:	X′[k] ← X[M−1−k];
11:	end for
12:	x ← ICZT(X′, N, W′, A′);	// reversed contour
13:	end if
14:	return x;

Appendix B: FFT and Inverse FFT Algorithms

This appendix states the FFT algorithm and the inverse FFT algorithm. Algorithm B.1 gives pseudo-code for the Fast Fourier Transform (FFT). Algorithm B.2 gives pseudo-code for the inverse Fast Fourier Transform (IFFT). Both the FFT and the IFFT run in O(n log n).

Algorithm B.1 | FFT algorithm. Runs in O(n log n).
1:  FFT(x)
2:  n ← LENGTH(x);
3:  if n = 1 then
4:  return x;
5:  end if
6:  xE ← (x[0], x[2], . . . , x[n − 2]); // even
7:  xO ← (x[1], x[3], . . . , x[n − 1]); // odd
8:  y′ ← FFT(xE);
9:  y″ ← FFT(xO);
10: y ← EMPTYARRAY(n);
11: for k ← 0 to n/2 − 1 do
12: w←e-i⁢⁢2⁢⁢π⁢⁢kn⁢;
13: y[k] ← y′[k] + w · y″[k];
14: y[k + (n/2)] ← y′[k] − w · y″[k];
15: end for
16: return y;

Algorithm B.2 | Inverse FFT algorithm. Runs in O(n log n).
1:  IFFT(y)
2:  n ← LENGTH(y);
3:  if n = 1 then
4:  return y;
5:  end if
6:  yE ← (y[0], y[2], . . . , y[n − 2]); // even
7:  yO ← (y[1], y[3], . . . , y[n − 1]); // odd
8:  x′ ← IFFT(yE);
9:  x″ ← IFFT(yO);
10: x ← EMPTYARRAY(n);
11: for k ← 0 to n/2 − 1 do
12: w←ei⁢⁢2⁢⁢π⁢⁢kn⁢;
13: x[k] ← (x′[k] + w · x″[k])/2;
14: x[k + (n/2)] ← (x′[k] − w · x″[k])/2;
15: end for
16: return x;

Appendix C: Multiplying a Toeplitz Matrix by a Vector

This appendix describes a popular method for multiplying a Toeplitz matrix by a vector. Let A be a n×n Toeplitz matrix and let x be a vector. The matrix A is specified by its first row r and its first column c, where it is assumed that r₀ is equal to c₀. The example in this appendix assumes that n is a power of 2. The approach, however, can be modified to work for other values of n. More formally,

$\begin{array}{cc}A=\left[\begin{array}{cccc}{c}_0& r_1& \text{…}& r_{n-1}\\ c_1& c_0& \text{…}& r_{n-2}\\ ⋮& ⋮& \ddots & ⋮\\ c_{n-1}& c_{n-2}& \text{…}& c_0\end{array}\right],x=\left[\begin{array}{c}{x}_0\\ x_1\\ ⋮\\ x_{n-1}\end{array}\right].& \left(C\mathrm{.1}\right)\end{array}$

To compute the product y=Ax efficiently using an FFT-based algorithm, it is possible to embed A into a 2n×2n circulant matrix A as shown below:

$\begin{array}{cc}\hat{A}=\left[\begin{array}{ccccccccc}{c}_0& r_1& \dots & r_{n-1}& 0& c_{n-1}& c_{n-2}& \dots & c_1\\ c_1& c_0& \dots & r_{n-2}& r_{n-1}& 0& c_{n-1}& \dots & c_2\\ ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮& \ddots & ⋮\\ c_{n-1}& c_{n-2}& \dots & c_0& r_1& r_2& r_3& \dots & 0\\ 0& c_{n-1}& \dots & c_1& c_0& r_1& r_2& \dots & r_{n-1}\\ r_{n-1}& 0& \dots & c_2& c_1& c_0& r_1& \dots & r_{n-2}\\ ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮& \ddots & ⋮\\ r_1& r_2& \dots & 0& c_{n-1}& c_{n-2}& c_{n-3}& \dots & c_0\end{array}\right].& \left(C\mathrm{.2}\right)\end{array}$

The vector x is padded with n zeros at the end, which results in a vector X of length 2n:

$\begin{array}{cc}\hat{x}=\left[\begin{array}{c}{x}_0\\ x_1\\ ⋮\\ x_{n-1}\\ 0\\ 0\\ ⋮\\ 0\end{array}\right].& \left(C\mathrm{.3}\right)\end{array}$

The product of A and X can be computed using an FFT-based algorithm in O(n log n). That is, the goal is to compute a vector ŷ of length 2n, which is equal to  {circumflex over (x)}. More formally,

$\begin{array}{cc}\hat{A}\hat{x}=\hat{y}=\left[\begin{array}{c}{\hat{y}}_0\\ {\hat{y}}_1\\ ⋮\\ {\hat{y}}_{n-1}\\ {\hat{y}}_n\\ {\hat{y}}_{n+1}\\ ⋮\\ {\hat{y}}_{2n-1}\end{array}\right].& \left(C\mathrm{.4}\right)\end{array}$

The first n elements of y are equal to the corresponding elements of y, i.e., y_k=ŷ_k for each k∈{0, 1, 2, . . . , n−1}.

It only remains to show how to multiply a (2n)-by-(2n) circulant matrix B by a vector v of length 2n using FFT and IFFT. The matrix B is generated by its first column vector b. More formally, let

$\begin{array}{cc}B=\left[\begin{array}{cccc}{b}_0& b_{2n-1}& \text{...}& b_1\\ b_1& b_0& \text{...}& b_2\\ ⋮& ⋮& \ddots & ⋮\\ b_{2n-1}& b_{2n-2}& \text{...}& b_0\end{array}\right],v=\left[\begin{array}{c}{v}_0\\ v_1\\ ⋮\\ v_{2n-1}\end{array}\right],b=\left[\begin{array}{c}{b}_0\\ b_1\\ ⋮\\ b_{2n-1}\end{array}\right].& \left(C\mathrm{.5}\right)\end{array}$

This product can be computed using the DFT and the inverse DFT, which follows from the circular convolution theorem. In other words, each element (Bv)_k of the product is equal to the k-th element in the circular convolution of b and v. That is,

DFT(Bv)=DFT(b)×DFT(v),  (C.6)

where x denotes elementwise multiplication. Therefore,

Bv=DFT⁻¹(DFT(b)×DFT(v)).  (C.7)

The DFT and the inverse DFT can be computed using the FFT and the inverse FFT, i.e.,

Bv=FFT⁻¹(FFT(b)×FFT(v)).  (C.8)

To summarize, the product of an n-by-n Toeplitz matrix and a vector, where n is assumed to be a power of two, can be computed using the following six steps: 1) go from Toeplitz to circulant by concatenating the first column, a single zero, and the reverse of the last n−1 elements of the first row; 2) pad the vector with n zeros at the end; 3) compute the DFT of the first column of the circulant matrix; 4) compute the DFT of the padded vector; 5) multiply the two DFTs elementwise; 6) compute the inverse DFT of the elementwise product; and 7) return the first n elements of the result vector computed by the inverse DFT. Use an FFT algorithm to compute the DFT and an IFFT algorithm to compute the inverse DFT. Note that in step 1) neither the Toeplitz matrix nor the circulant matrix is explicitly computed. Instead, only their generating vectors are used to perform the necessary computations.

Algorithm C.1 gives the pseudo-code for the algorithm described above. The computational complexity of this algorithm is O(n log n). The name of the function is TOEPLITZMULTIPLYE, where the ‘E’ abbreviates ‘embedding’.

Instead of including the FFT computations in the algorithms, it is possible to use FCIRCULANTMULTIPLY (see Algorithm D.2, below). However, FCIRCULANTMULTIPLY does O(n) more work than the sequence of FFT computations because it has to compute

$\sqrt[𝔫]{f}\mathrm{and}\sqrt[n]{f^k}$

for each k∈{0, 1, . . . , n−1}.

Algorithm C.1 Multiply a Toeplitz matrix by a vector in O(n log n) operations using the FFT.
1:  TOEPLITZMULTIPLYE(r, c, x)
2:  // Compute the product y = A x of a Toeplitz matrix A and a vector x where A is specified
3:  // by its first row r = (r[0], r[1], r[2], . . . , r[n − 1]) and its first column
4:  // c = (c[0], c[1], c[2], . . . , c[n − 1]). That is, A1,j = r[j − 1] for each j ∈ {1, 2, . . . , n} and
5:  // Ai,1 = c[i − 1] for each i ∈ {1, 2, . . . , n}.
6:  // The algorithm multiplies a circulant matrix derived from A by a vector obtained by
7:  // padding x with zeros, which is computed using the FFT-based convolution approach.
8:  // This algorithm uses Cooley-Tukey FFT, which requires n to be a nonnegative power of two.
9:  n ← LENGTH(r);
10: if LENGTH(x) ≠ n then
11: error(“The length of x must be equal to the length of r.”);
12: end if
13: if LENGTH(c) ≠ n then
14: error(“The length of c must be equal to the length of r.”);
15: end if
16: if r[0] ≠ c[0] then
17: error(“The first element of r must be equal to the first element of c.”);
18: end if
19: // Form an array a by concatenating c, a single zero, and the reverse of the tail of r.
20: a ← (c[0], c[1], c[2], . . . , c[n − 1], 0, r[n − 1], r[n − 2], . . . , r[1]); // the length of a is 2n
21: A ← FFT(a);
22: x                      ^                                        ←                                                                  (                                                                              x                            ⁡                                                          [                              0                              ]                                                                                ,                                                      x                            ⁡                                                          [                              1                              ]                                                                                ,                          …                          ⁢                                                                                                          ,                                                      x                            ⁡                                                          [                                                              n                                -                                1                                                            ]                                                                                ,                                                                                    0                              ,                              0                              ,                              …                              ⁢                                                                                                                          ,                              0                                                                                      ︸                                                              n                                ⁢                                                                                                                                  ⁢                                zeros                                                                                                                                    )                                            ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                      pad                      ⁢                                                                                          ⁢                      x                      ⁢                                                                                          ⁢                      with                      ⁢                                                                                          ⁢                      n                      ⁢                                                                                          ⁢                      zeros                      ⁢                                                                                          ⁢                      and                      ⁢                                                                                          ⁢                      store                      ⁢                                                                                          ⁢                      the                      ⁢                                                                                          ⁢                      result                      ⁢                                                                                          ⁢                      in                      ⁢                                                                                          ⁢                                              x                        ^
23: {circumflex over (X)} ← FFT({circumflex over (x)});
24: Ŷ ← EMPTYARRAY(2n);
25: for k ← 0 to 2n − 1 do
26: Ŷ[k] ← A[k] · {circumflex over (X)}[k]; // elementwise product of A and {circumflex over (X)}
27: end for
28: // Compute the inverse FFT of Ŷ and store the result in the array ŷ.
29: ŷ ← IFFT(Ŷ);
30: // The length of ŷ is equal to 2n. The result is the first half of ŷ.
31: y ← (ŷ[0], ŷ[1], ŷ[2], . . . , ŷ[n − 1]);
32: // Alternatively, y can be computed using FCIRCULANTMULTIPLY(1, a, x).
33: return y;

Appendix D: Toeplitz Vector Product Using Pustylnikov's Decomposition

An algorithm for multiplying a Toeplitz matrix by a vector can be formulated using Pustylnikov's decomposition. This algorithm does not embed a Toeplitz matrix into a circulant matrix as described in Appendix C. Instead, this appendix describes a different version of TOEPLITZMULTIPLY.

An example that illustrates this algorithm is shown below. Let A be the following 4-by-4 Toeplitz matrix, which is generated by its first row r and its first column c.

$\begin{array}{cc}A=\left[\begin{array}{cccc}1& 2& 3& 4\\ 5& 1& 2& 3\\ 6& 5& 1& 2\\ 7& 6& 5& 1\end{array}\right]=\left[\begin{array}{cccc}{c}_0& r_1& r_2& r_3\\ c_1& c_0& r_1& r_2\\ c_2& c_1& c_0& r_1\\ c_3& c_2& c_1& c_0\end{array}\right]=\left[\begin{array}{cccc}{r}_0& r_1& r_2& r_3\\ c_1& r_0& r_1& r_2\\ c_2& c_1& r_0& r_1\\ c_3& c_2& c_1& r_0\end{array}\right]& \left(D\mathrm{.1}\right)\end{array}$

Then, A can be decomposed into the sum of two matrices as follows:

A=A′+A″,  (D.2)

where A′ is a circulant matrix and A″ is an f-circulant matrix with f=−1 (i.e., a skew-circulant matrix). For this example, these two matrices have the following form:

$\begin{array}{cc}{A}^{\prime }=\frac{1}{2}\left[\begin{array}{cccc}2& 9& 9& 9\\ 9& 2& 9& 9\\ 9& 9& 2& 9\\ 9& 9& 9& 2\end{array}\right],A^{″}=\frac{1}{2}\left[\begin{array}{cccc}0& -5& -3& -1\\ 1& 0& -5& -3\\ 3& 1& 0& -5\\ 5& 3& 1& 0\end{array}\right].& \left(D\mathrm{.3}\right)\end{array}$

The formula for computing the values of A′ and A″ is provided below. Let a′=(a′₀, a′₁, a′₂, . . . , a′_n−1) be the first column of A′, i.e.,

$\begin{array}{cc}{A}^{\prime }=\left[\begin{array}{ccccc}{a}_0^{\prime }& a_{n-1}^{\prime }& a_{n-2}^{\prime }& \dots & a_1^{\prime }\\ a_1^{\prime }& a_0^{\prime }& a_{n-1}^{\prime }& \dots & a_2^{\prime }\\ a_2^{\prime }& a_1^{\prime }& a_0^{\prime }& \dots & a_3^{\prime }\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{n-1}^{\prime }& a_{n-2}^{\prime }& a_{n-3}^{\prime }& \dots & a_0^{\prime }\end{array}\right].& \left(D\mathrm{.4}\right)\end{array}$

Similarly, let a″=(a″₀, a″₁, a″₂, . . . , a″_n−1) be the first column of A″. That is,

$\begin{array}{cc}{A}^{″}=\left[\begin{array}{ccccc}{a}_0^{″}& -a_{n-1}^{″}& -a_{n-2}^{″}& \dots & -a_1^{″}\\ a_1^{″}& a_0^{″}& -a_{n-1}^{″}& \dots & -a_2^{″}\\ a_2^{″}& a_1^{″}& a_0^{″}& \dots & -a_3^{″}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{n-1}^{″}& a_{n-2}^{″}& a_{n-3}^{″}& \dots & a_0^{″}\end{array}\right].& \left(D\mathrm{.5}\right)\end{array}$

Then, the elements of a′ and a″ can be computed using the following formulas:

$\begin{array}{cc}{a}_k\prime =\{\begin{array}{cc}{r}_0,& \mathrm{if}k=0,\\ \frac{1}{2}\left(c_k+r_{n-k}\right),& \mathrm{if}k\in \left\{1,2,...,n-1\right\},\end{array}& \left(D\mathrm{.6}\right)\\ a_k^{″}=\{\begin{array}{cc}0,& \mathrm{if}k=0,\\ \frac{1}{2}\left(c_k-r_{n-k}\right)& \mathrm{if}k\in \left\{1,2,...,n-1\right\},\end{array}& \left(D\mathrm{.7}\right)\end{array}$

where r is the first row of A and c is its first column.

Algorithm D.1 gives the pseudo-code for the algorithm described above. The name of the function is TOEPLITZMULTIPLYP, where ‘P’ abbreviates ‘Pustylnikov’. Lines 27 and 28 call Algorithm D.2, which is described below. The algorithm runs in O(n log n) time.

Algorithm D.1 Multiply a Toeplitz matrix by
a vector using Pustylnikov's decomposition.
1:	TOEPLITZMULTIPLYP(r, c, x)
2:	// Compute the product y = A x of a Toeplitz matrix A and a vector x where A is
	specified
3:	// by its first row r = (r[0], r[1], r[2],..., r[n − 1]) and its first column
4:	// c = (c[0], c[1], c[2],..., c[n − 1]). That is, A1, j = r[j − 1] for each j ∈ {1,2,..., n} and
5:	// Ai, 1 = c[i − 1] for each i ∈ {1,2,...,n}.
6:	// The algorithm completes in O(n log n) primitive operations. This is accomplished using
7:	// Pustylnikov's decomposition and an FFT-based algorithm for computing the product of
8:	// an f-circulant matrix and a vector.
9:	n ← LENGTH(r);
10:	if LENGTH(x) ≠ n then
11:	error(“The length of x must be equal to the length of r.”);
12:	end if
13:	if LENGTH(c) ≠ n then
14:	error(“The length of c must be equal to the length of r.”);
15:	end if
16:	if r[0] ≠ c[0] then
17:	error(“The first element of r must be equal to the first element of c.”);
18:	end if
19:	a′ ← EMPTYARRAY(n);
20:	a″ ← EMPTYARRAY(n);
21:	a′[0] = r[0];
22:	a″[0] = 0;
23:	for k ← 1 to n − 1 do
24:	a′[k] = ½(c[k] + r[n − k]);
25:	a″[k] = ½(c[k] − r[n − k]);
26:	end for
27:	y′ ← FCIRCULANTMULTIPLY(1, a′, x);	// see Algorithm D.2
28:	y″ ← FCIRCULANTMULTIPLY(−1, a″, x);
29:	y ← EMPTYARRAY(n);
30:	for k ← 0 to n − 1 do
31:	y[k] − y′[k] + y″[k];
32:	end for
33:	return y;

Algorithm D.2 gives the pseudo-code for the function FCRCULANTMULTIPLY (for multiplying an f-circulant matrix by a vector), which was used in Algorithm D.1. It runs in O(n log n).

Algorithm D.2 FFT-based algorithm for multiplying an f-circulant matrix by a vector.
1:  FCIRCULANTMULTIPLY(f, a, x)
2:  if f = 0 then
3:  error(“f must be non-zero”);
4:  end if
5:  n ← LENGTH(a);
6:  if LENGTH(x) ≠ n then
7:  error(“The length of x must be equal to the length of a.”);
8:  end if
9:  g                    ←                                                                  f                        n                                            ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                      compute                      ⁢                                                                                          ⁢                      the                      ⁢                                                                                          ⁢                      n                      ⁢                                              -                                            ⁢                      th                      ⁢                                                                                          ⁢                      complex                      ⁢                                                                                          ⁢                      root                      ⁢                                                                                          ⁢                      of                      ⁢                                                                                          ⁢                      f                      ⁢                                                                                          ⁢                      and                      ⁢                                                                                          ⁢                      store                      ⁢                                                                                          ⁢                      its                      ⁢                                                                                          ⁢                      value                      ⁢                                                                                          ⁢                      in                      ⁢                                                                                          ⁢                      g
10: g                      ^                                        ←                                                                  EMPTYARRAY                        ⁡                                                  (                          n                          )                                                                    ⁢                                              ;                                            ⁢                                                                                          ⁢                                              //                                            ⁢                      allocate                      ⁢                                                                                          ⁢                      an                      ⁢                                                                                          ⁢                      array                      ⁢                                                                                          ⁢                                              g                        ^                                            ⁢                                                                                          ⁢                      for                      ⁢                                                                                          ⁢                      storing                      ⁢                                                                                          ⁢                      the                      ⁢                                                                                          ⁢                      precomputed                      ⁢                                                                                          ⁢                      values                      ⁢                                                                                          ⁢                      of                      ⁢                                                                                          ⁢                                              f                                                  k                          n
11: ĝ[0] ← 1;
12: for k ← 1 to n − 1 do
13: ĝ[k] ← ĝ[k − 1] · g;
14: end for
15: // Allocate an array â for storing the products of the elements of a and the corresponding
16: //                                            ⁢                                                                                          ⁢                      powers                      ⁢                                                                                          ⁢                      of                      ⁢                                                                                          ⁢                                              f                        n                                                              ,                                          which                      ⁢                                                                                          ⁢                      are                      ⁢                                                                                          ⁢                      stored                      ⁢                                                                                          ⁢                      in                      ⁢                                                                                          ⁢                      the                      ⁢                                                                                          ⁢                      array                      ⁢                                                                                          ⁢                                                                        g                          ^                                                .
17: â ← EMPTYARRAY(n);
18: for k ← 0 to n − 1 do
19: â[k] ← a[k] · ĝ[k];
20: end for
21: Â ← FFT(â); // compute the DFT of â and store it in the array Â
22: // Allocate an array {circumflex over (x)} for storing the products of the elements of a and the corresponding
23: //                                            ⁢                                                                                          ⁢                      powers                      ⁢                                                                                          ⁢                      of                      ⁢                                                                                          ⁢                                              f                        n                                                              ,                                          which                      ⁢                                                                                          ⁢                      are                      ⁢                                                                                          ⁢                      given                      ⁢                                                                                          ⁢                      by                      ⁢                                                                                          ⁢                      the                      ⁢                                                                                          ⁢                      array                      ⁢                                                                                          ⁢                                                                        g                          ^                                                .
24: {circumflex over (x)} ← EMPTYARRAY(n);
25: for k ← 0 to n − 1 do
26: {circumflex over (x)}[k] ← x[k] · ĝ[k];
27: end for
28: {circumflex over (X)} ← FFT({circumflex over (x)}); // compute the DFT of {circumflex over (x)} and store it in the array {circumflex over (X)}
29: Y ← EMPTYARRAY(n);
30: for k ← 0 to n − 1 do
31: Y[k] ← Â[k] · {circumflex over (X)}[k];
32: end for
33: y ← IFFT(Y); // compute the inverse DFT of Y and store the result in an array y
34: for k ← 0 to n − 1 do
35: y⁡[k]←y⁡[k]g^⁡[k]⁢;⁢⁢//⁢divide⁢⁢y⁡[k]⁢⁢by⁢⁢fkn⁢⁢in⁢⁢place
36: end for
37: return y;

Appendix E: Toeplitz Vector Product with FFT-based Convolution

Algorithm E.1 shows the pseudo-code for yet another algorithm for multiplying a Toeplitz matrix by a vector. The function name in this case is TOEPLITZMULTIPLYC, where ‘C’ abbreviates convolution. The computational complexity of the algorithm is O(n log n). This algorithm can be interpreted as a form of circulant embedding, similarly to the approach described in Appendix C.

Algorithm E.1 Multiplies a Toeplitz matrix by
a vector using convolution. Runs in O(n log n).
1:  TOEPLITZMULTIPLYC(r, c, x)
2:  N ← LENGTH(r);
3:  if LENGTH(x) ≠ N then
4:  error(“The length of x must be equal to the length of r.”);
5:  end if
6:  M ← LENGTH(c);
7:  if r[0] ≠ c[0] then
8:  error(“The first element of r must be equal to the first element of c.”);
9:  end if
10: n ← M + N − 1;
11: t ← EMPTYARRAY(n);
12: for k ← 0 to N − 1 do
13: t[k] ← r[N − 1 − k];
14: end for
15: for k ← 0 to M − 2 do
16: t[N + k] ← c[1 + k];
17: end for
18: u ← FFTCONVOLVE(t,x); // see Algorithm E.2
19: y ← EMPTYARRAY(M);
20: for k ← 0 to M − 1 do
21: y[k] − u[N − 1 + k];
22: end for
23: return y;

Algorithm E.2 gives the pseudo-code for an FFT-based convolution algorithm, which is an O(n log n) method for computing discrete convolution. It was used in Algorithm E.1.

Algorithm E.2 FFT-based convolution
algorithm. Runs in O(n log n).
1:	FFTCONVOLVE(a, b)
2:	na ← LENGTH(a);
3:	nb ← LENGTH(b);
4:	L ← na + nb − 1;	// set L to the length of a * b
5:	n ← 2┌log2 L┐;	// set n to the smallest power of 2 that is ≥ L
6:	â ← EMPTYARRAY(n);
7:	for k ← 0 to na − 1 do
8:	â[k] ← a[k];
9:	end for
10:	for k ← na to n − 1 do
11:	â[k] ← 0;
12:	end for
13:	{circumflex over (b)} ← EMPTYARRAY(n);
14:	for k ← 0 to nb − 1 do
15:	{circumflex over (b)}[k] ← b[k];
16:	end for
17:	for k ← nb to n − 1 do
18:	{circumflex over (b)}[k] ← 0;
19:	end for
20:	â ← FFT(â);
21:	{circumflex over (b)} ← FFT({circumflex over (b)});
22:	ŷ ← EMPTYARRAY(n);
23:	for k ← 0 to n − 1 do
24:	ŷ[k] ← â[k] · {circumflex over (b)}[k];
25:	end for
26:	ŷ ← IFFT(ŷ);
27:	y ← EMPTYARRAY(L);
28:	for k ← 0 to L − 1 do
29:	y[k] ← ŷ[k];
30:	end for
31:	return y;

All references, including publications, patent applications, and patents cited herein are hereby incorporated by reference to the same extent as if each reference were individually and specifically indicated to be incorporated by reference and were set forth in its entirety herein.

The use of the terms “a” and “an” and “the” and similar referents in the context of describing the invention (especially in the context of the following claims) is to be construed to cover both the singular and the plural, unless otherwise indicated herein or clearly contradicted by context. The terms “comprising,” “having,” “including,” and “containing” are to be construed as open-ended terms (i.e., meaning “including, but not limited to,”) unless otherwise noted. Recitation of ranges of values herein are merely intended to serve as a shorthand method of referring individually to each separate value falling within the range, unless otherwise indicated herein, and each separate value is incorporated into the specification as if it were individually recited herein. All methods described herein can be performed in any suitable order unless otherwise indicated herein or otherwise clearly contradicted by context. The use of any and all examples, or exemplary language (e.g., “such as”) provided herein, is intended merely to better illuminate the invention and does not pose a limitation on the scope of the invention unless otherwise claimed. No language in the specification should be construed as indicating any non-claimed element as essential to the practice of the invention.

Preferred embodiments of this invention are described herein, including the best mode known to the inventors for carrying out the invention. Variations of those preferred embodiments may become apparent to those of ordinary skill in the art upon reading the foregoing description. The inventors expect skilled artisans to employ such variations as appropriate, and the inventors intend for the invention to be practiced otherwise than as specifically described herein. Accordingly, this invention includes all modifications and equivalents of the subject matter recited in the claims appended hereto as permitted by applicable law. Moreover, any combination of the above-described elements in all possible variations thereof is encompassed by the invention unless otherwise indicated herein or otherwise clearly contradicted by context.

Claims

1. A method of inverting Chirp Z-Transform (CZT) using a computational system comprising a processor and a memory device, wherein the CZT has parameters A and W that define a logarithmic spiral contour in the complex plane through formula A W−k for k=0, 1, 2, . . . , M−1, wherein the CZT is capable of being expressed as X=W A x in which W is a Vandermonde matrix having dimensions M-by-N defined by the parameter Wand its powers, A is a first diagonal matrix defined by the parameter A and its powers, x is a first vector derived from a signal and stored in the memory device, and X is a second vector that is computed from the first vector x using the CZT such that the k-th element of X is given by Xk=Σj=0N−1xj (A W−k)−j, for k=0, 1, 2, . . . , M−1, wherein A and Ware non-zero complex numbers, the method executed by the processor comprising the steps of: representing the matrix Was a product of a second diagonal matrix P, a Toeplitz matrix Ŵ, and a third diagonal matrix Q, such that the CZT is expressed as X=P Ŵ Q A x;expressing an inverse CZT as x=A−1Q−1 Ŵ−1P−1X, wherein A−1, Q−1, Ŵ−1, and P−1 are inverse matrices of A, Q, Ŵ, and P, respectively;computing the inverse CZT by performing the multiplications in the product A−1Q−1Ŵ−1P−1X from right to left to calculate a third vector {circumflex over (x)}.

2. The method of claim 1, wherein each element of the first vector x is substantially equal to a corresponding element of the third vector {circumflex over (x)}.

3. The method of claim 1, wherein at least one element of the first vector x is not equal to a corresponding element of the third vector {circumflex over (x)}.

4. The method of claim 3, wherein, prior to computing step, the method further comprises a step of performing an operation on the second vector X that modifies at least one of its elements.

5. The method of claim 4, wherein the operation is a filtering operation.

6. The method of claim 1, wherein the method has a computational complexity of less than or equal to O(n2), wherein n=max(M, N).

7. The method of claim 6, wherein the computational complexity is O(n log n).

8. The method of claim 1, wherein the matrix Ŵ−1 is capable of being expressed as Ŵ−1=(1/u0)() in which is a first lower-triangular Toeplitz matrix, is a first upper-triangular Toeplitz matrix that is equal to the transpose of , is a second upper-triangular Toeplitz matrix, is a second lower-triangular Toeplitz matrix that is equal to the transpose of , and u0 is equal to

9. The method of claim 8, wherein a generating vector for each of the four matrices , , , and is capable of being derived from a vector u=(u0, u1, . . . , un−1) given by:

10. The method of claim 8, wherein, during the step of computing the product of Ŵ−1=(1/u0) () with a vector, the multiplications are performed from right to left such that no matrix is multiplied by another matrix.

11. The method of claim 10, wherein multiplication of at least one of the Toeplitz matrices , , , or by a vector comprises the steps of: embedding the Toeplitz matrix into a circulant matrix, wherein the circulant matrix is represented by its generating vector, and wherein the dimensions of the circulant matrix are based on at least one of M or N; andpadding the vector with zeros prior to multiplication to produce a padded vector having the same length as the number of columns of the circulant matrix; andcomputing a product vector by multiplying the circulant matrix with the padded vector; andextracting a result vector comprising elements of the product vector corresponding to the rows of the circulant matrix in which the Toeplitz matrix is embedded.

12. The method of claim 11, wherein the circulant matrix is a square matrix and wherein the number of rows of the circulant matrix is a power of two.

13. The method of claim 10, wherein multiplication of at least one of the Toeplitz matrices , , , or by a vector comprises performing a Pustylnikov decomposition of the matrix prior to multiplication with the vector.

14. The method of claim 10, wherein the multiplication of at least one of the Toeplitz matrices , , , or by a vector further comprises the steps of: embedding the Toeplitz matrix into an expanded Toeplitz matrix having dimensions based on at least one of M or N, by padding its generating vector with zeros;padding the vector by which the Toeplitz matrix is multiplied with zeros to produce a padded vector having the same length as the number of columns in the expanded Toeplitz matrix;expressing the expanded Toeplitz matrix as a sum of a circulant matrix and a skew-circulant matrix using Pustylnikov decomposition;multiplying the circulant matrix by the padded vector, multiplying the skew-circulant matrix by the padded vector, and adding the two resulting vectors to produce a padded results vector;extracting a results vector from the padded results vector by retaining the elements of the padded results vector that correspond to the rows of the expanded Toeplitz matrix into which the Toeplitz matrix is embedded.

15. The method of claim 14 wherein the number of rows and the number of columns in the expanded Toeplitz matrix is a power of two.

16. The method of claim 8, wherein none of the matrices A−1, Q−1, , , , , and P−1 are fully stored in a memory during performance of the method.

17. The method of claim 1, wherein no more than O(n) memory is required to perform the method and wherein n=max(M, N).

18. The method of claim 1, wherein M equals N.

19. The method of claim 1, wherein M does not equal N.

20. The method of claim 1, wherein the first vector x is derived from an audio signal.

21. The method of claim 20, wherein the audio signal comprises a speech signal.

22. The method of claim 20, wherein the audio signal comprises at least one of a sonar signal or an ultrasound signal.

23. The method of claim 1, wherein the first vector x is derived from an image signal.

24. The method of claim 23, wherein the image signal comprises at least one of a computed tomography (CT) signal, a positron emission tomography (PET) signal, or a magnetic resonance imaging (MRI) signal.

25. The method of claim 1, wherein the first vector x is derived from a signal received by a radar-based sensor.

26. The method of claim 1, wherein the first vector x is used to generate a signal that is sent to a radar-based sensor.

27. The method of claim 1, wherein the second vector X is not computed from a specific first vector x using the CZT with the same parameters A and W.