WOLFRAM

Wolfram Language & System Documentation Center

InverseFourier[list]

finds the discrete inverse Fourier transform of a list of complex numbers.

InverseFourier[list,{p1,p2,…}]

returns the specified positions of the discrete inverse Fourier transform.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Options  
FourierParameters  
Applications  
Properties & Relations  
Possible Issues  
See Also
Tech Notes
Related Guides
History
Cite this Page

InverseFourier

InverseFourier[list]

finds the discrete inverse Fourier transform of a list of complex numbers.

InverseFourier[list,{p1,p2,…}]

returns the specified positions of the discrete inverse Fourier transform.

Details and Options

  • The inverse Fourier transform of a list of length is defined to be . »
  • Note that the zero frequency term must appear at position 1 in the input list.
  • Other definitions are used in some scientific and technical fields.
  • Different choices of definitions can be specified using the option FourierParameters.
  • With the setting FourierParameters->{a,b} the discrete Fourier transform computed by InverseFourier is .
  • Some common choices for {a,b} are {0,1} (default), {-1,1} (data analysis), {1,-1} (signal processing).
  • The setting b=-1 effectively corresponds to conjugating both input and output lists.
  • To ensure a unique discrete Fourier transform, Abs[b] must be relatively prime to .
  • The list of data need not have a length equal to a power of two.
  • The list given in InverseFourier[list] can be nested to represent an array of data in any number of dimensions.
  • The array of data must be rectangular.
  • InverseFourier[list,{p1,p2,…}] is typically equivalent to Extract[InverseFourier[list],{p1,p2,…}]. Cases with just a few positions p are computed using an algorithm that takes less time and memory but is more subject to numerical error, particularly when the length of list is long.
  • If the elements of list are exact numbers, InverseFourier begins by applying N to them.

Examples

open all close all

Basic Examples  (2)

Inverse Fourier transform of a real list:

Wolfram Language code: InverseFourier[{1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1}]

Inverse Fourier transform of a complex list:

Wolfram Language code: InverseFourier[{1 + 2I, 3 + 4I}]

Scope  (3)

x is a list of real values:

Wolfram Language code: x = {0, 0, 0, 1, 0, 0, 0};

Compute the inverse Fourier transform with machine arithmetic:

Wolfram Language code: InverseFourier[x]

Compute using 24-digit precision arithmetic:

Wolfram Language code: InverseFourier[N[x, 24]]

Compute a 2D inverse Fourier transform:

Wolfram Language code: InverseFourier[RandomComplex[1 + I, {4, 5}]]

x is a rank-4 tensor with a single nonzero entry:

Wolfram Language code: x = ConstantArray[0, {2, 3, 3, 2}];x[[1, 1, 1, 1]] = 1;

Compute the 4D inverse Fourier transform:

Wolfram Language code: InverseFourier[x]

Options  (3)

FourierParameters  (3)

No normalization:

Wolfram Language code: a = InverseFourier[{1, 0, 1, 0, 0, 1, 0, 0, 0, 1}, FourierParameters -> {1, 1}]

Normalization by :

Wolfram Language code: InverseFourier[{1, 0, 1, 0, 0, 1, 0, 0, 0, 1}]
Wolfram Language code: % * Sqrt[10]

Normalization by :

Wolfram Language code: InverseFourier[{1, 0, 1, 0, 0, 1, 0, 0, 0, 1}, FourierParameters -> {-1, 1}]

InverseFourier is the same as Fourier with parameter :

Wolfram Language code: v = RandomVariate[NormalDistribution[], {8, 2}].{1, I}
Wolfram Language code: InverseFourier[v]
Wolfram Language code: Fourier[v, FourierParameters -> {0, -1}]

Data from a sinc function with noise:

Wolfram Language code: x = Table[Sinc[x - 10], {x, 100}] + RandomReal[{-.05, .05}, {100}];
Wolfram Language code: ListPlot[x, PlotRange -> All]

Get the Fourier transform:

Wolfram Language code: f = Fourier[x, FourierParameters -> {-1, 1}];
Wolfram Language code: ListPlot[Abs[f]]

Reconstruct the signal from part of the spectrum:

Wolfram Language code: s = 2 InverseFourier[Take[f, 20], FourierParameters -> {-1, .2}];
Wolfram Language code: Show[ListPlot[Re[s], PlotStyle -> Red], ListPlot[x]]

Applications  (1)

Some Gaussian data:

Wolfram Language code: data = Table[Exp[-((x - 50) / 10) ^ 2], {x, 100}]; ListPlot[data, PlotRange -> All]

The multiplication of each mode to get the first derivative:

Wolfram Language code: k = -I * (2 * Pi / 100) * Join[{0}, Range[49], {0}, -Reverse[Range[49]]]; ListPlot[Abs[k]]

Approximate the first derivative of the data:

Wolfram Language code: d = InverseFourier[Fourier[data] * k];
Wolfram Language code: Show[ListPlot[Re[d], PlotRange -> All], Plot[Evaluate[D[Exp[-((x - 50) / 10) ^ 2], x]], {x, 0, 100}]]

Note the derivative approximation implicitly assumes periodicity:

Wolfram Language code: ListLinePlot[Re[InverseFourier[Fourier[Range[100]] * k]]]

Properties & Relations  (2)

is given by :

Wolfram Language code: x = N[{1, 2, 3, 4, 5, 6, 7}]; n = Length[x]; u/:Subscript[u, r_] := x[[r]]
Wolfram Language code: v = Table[(1/Sqrt[``n``])Underoverscript[∑, ``r`` = 1, ``n``]Subscript[``u``, ``r``]``E``^-2π I(``r`` - 1)(``s`` - 1) / ``n``, {s, 1, n}]
Wolfram Language code: Chop[v - InverseFourier[x]]

InverseFourier is equivalent to multiplication with FourierMatrix with specified parameters:

Wolfram Language code: m[n_] := FourierMatrix[n, FourierParameters -> {0, -1}]
Wolfram Language code: v = m[6].N[{1, 2, 3, 4, 5, 6}]
Wolfram Language code: Chop[v - InverseFourier[{1, 2, 3, 4, 5, 6}]]

The conjugate transpose of the matrix is equivalent to Fourier:

Wolfram Language code: Chop[ConjugateTranspose[m[6]].N[{1, 2, 3, 4, 5, 6}] - Fourier[{1, 2, 3, 4, 5, 6}]]

Possible Issues  (1)

InverseFourier uses an efficient algorithm when only a small number of coefficients is needed:

Wolfram Language code: bdata = RandomReal[1, 2 ^ 20, WorkingPrecision -> 50];data = N[bdata];pos = {{1}, {3}, {2 ^ 20 - 5}}; AbsoluteTiming[res = Extract[InverseFourier[bdata], pos]]

The fast and efficient implementation may result in significant numerical error:

Wolfram Language code: AbsoluteTiming[Extract[InverseFourier[data], pos] - res]
Wolfram Language code: AbsoluteTiming[InverseFourier[data, pos] - res]
Wolfram Research (1988), InverseFourier, Wolfram Language function, https://reference.wolfram.com/language/ref/InverseFourier.html (updated 2012).

Text

Wolfram Research (1988), InverseFourier, Wolfram Language function, https://reference.wolfram.com/language/ref/InverseFourier.html (updated 2012).

CMS

Wolfram Language. 1988. "InverseFourier." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2012. https://reference.wolfram.com/language/ref/InverseFourier.html.

APA

Wolfram Language. (1988). InverseFourier. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/InverseFourier.html

BibTeX

@misc{reference.wolfram_2026_inversefourier, author="Wolfram Research", title="{InverseFourier}", year="2012", howpublished="\url{https://reference.wolfram.com/language/ref/InverseFourier.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_inversefourier, organization={Wolfram Research}, title={InverseFourier}, year={2012}, url={https://reference.wolfram.com/language/ref/InverseFourier.html}, note=[Accessed: 13-June-2026]}