numeric
::fft
Fast Fourier Transform
MuPAD® notebooks are not recommended. Use MATLAB® live scripts instead.
MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.
numeric::fft(L
, <mode
>, <ReturnType = t
>, <Clean
>) numeric::fft(M
, <mode
>, <ReturnType = t
>, <Clean
>) numeric::fft(A
, <mode
>, <ReturnType = t
>, <Clean
>)
numeric::fft(data)
returns the discrete Fourier
transform of data
.
The onedimensional discrete Fourier transform F = fft(L) of N data elements L_{j} stored in the list L = [L_{1}, …, L_{N}] is the list F = [F_{1}, …, F_{N}] given by
.
fft
transforms the data by a Fast Fourier
Transform (FFT) algorithm.
The ddimensional discrete Fourier transform F = fft(A) of N = n_{1}×···×n_{d} data elements (A_{j1, …, jd}) stored in the array A is the array F = (F_{k1, …, kd}) given by
with k_{1} = 1, …, n_{1}, …, k_{d} = 1, …, n_{d}.
Data provided by a list, or onedimensional array
, or hfarray
are transformed according to
the onedimensional transform. Data provided by matrices are transformed
according to the twpdimensional transform. Data provided by multidimensional
arrays or hfarrays are transformed according to the multidimensional
transform matching the format of the input array.
If the data size N factorizes as N = p q,
the discrete Fourier transform can be computed by p different
Fourier transforms of subsets of the data, each subset having the
data size q.
The corresponding 'divide and conquer' algorithm is known as FFT ('Fast
Fourier Transform'). The fft
routine employs the
FFT algorithm. It is most efficient, when the data size N is
an integer power of 2 ('radix
2 FFT'). In this case, the algorithm needs elementary
operations.
More generally, FFT is efficient, if the data size is the product of many small factors.
Following Bluestein, the Fourier transform is written as a convolution if the data size N is a prime. The data are zeropadded to a data length that is an integer power of 2. The convolution is then computed via radix 2 FFTs. Thus, the algorithm needs elementary operations even if N is a prime.
Without the option Symbolic
, the function
is sensitive to the environment variable DIGITS
, which determines
the numerical working precision.
Compute onedimensional transformations using lists. By default, numerical expressions are converted to floatingpoint values:
L := [1, 2^(1/2), 3*I, PI]: F := numeric::fft(L)
To use exact arithmetic, specify the option Symbolic
:
F := numeric::fft(L, Symbolic)
numeric::fft
accepts symbolic expressions.
Internally, the default method HardwareFloats
(with DIGITS
< 16
) fails because of the symbolic parameter x
.
The following results are computed with the software arithmetic provided
by the MuPAD^{®} kernel:
L := [x, 2, 3, x]: numeric::fft(L)
numeric::fft(L, Symbolic)
delete L, F
Compute the following multidimensional transformations. First, compute a twodimensional transformation using an array with two indices:
A := array(1..2, 1..4, [[1, 2, 3, 4], [a, b, c, d]]): numeric::fft(A, Symbolic)
Next, compute a transformation for a threedimensional array:
A := array(1..2, 1..4, 1..2, [[[sin(j1*PI/2)*cos(j2*3*PI/4)*sin(j3*PI/2) $ j3 = 1..2 ] $ j2 = 1..4 ] $ j1 = 1..2]): numeric::fft(A)
array(1..2, 1..4, 1..2, (1, 1, 1) = 1.0 (1, 1, 2) = 1.0 (1, 2, 1) =  1.414213562  1.0 I (1, 2, 2) =  1.414213562  1.0 I (1, 3, 1) = 1.0 (1, 3, 2) = 1.0 (1, 4, 1) =  1.414213562 + 1.0 I (1, 4, 2) =  1.414213562 + 1.0 I (2, 1, 1) = 1.0 (2, 1, 2) = 1.0 (2, 2, 1) =  1.414213562  1.0 I (2, 2, 2) =  1.414213562  1.0 I (2, 3, 1) = 1.0 (2, 3, 2) = 1.0 (2, 4, 1) =  1.414213562 + 1.0 I (2, 4, 2) =  1.414213562 + 1.0 I )
delete A
Data of arbitrary length can be transformed:
L := [1, 2 + I, PI/3]: numeric::fft(L)
delete L

A list, or a onedimensional array( 

A 

A ddimensional 

One of the flags 

With With Compared to the If no If the result cannot be computed with hardware floatingpoint values, software arithmetic by the MuPAD kernel is tried. If the current value of There can be several reasons for hardware arithmetic to fail:
If neither If Note that With The trailing digits in floatingpoint results computed with 

This option prevents conversion of the input data to floatingpoint values. Without this option, the floatingpoint converter 

Option, specified as Return the result in a container of domain type This option determines the domain type If no return type is specified by this option, the result if of the same type and format as the input data. If the return type With 

Reduce roundoff garbage in the result. All entries of the result
with absolute values smaller than NoteThe postprocessing of the result is done on the software level. When using hardware floatingpoint values, this option can increase the runtime significantly. This option is ignored when used in conjunction with the option 
List, array, hfarray, or matrix of the same length and format
as the first input parameter L
, A
,
or M
, respectively. The type of the return value
can be changed with the option ReturnType
.