Just as there are multiple conventions for defining the Fourier transform, there are multiple conventions for defining the discrete Fourier transform (DFT), better known as the fast Fourier transform (FFT). [1]

This post will look at two DFT conventions, one used in Python’s NumPy library, and one used in Mathematica. There are more conventions in use, but this post will just look at these two.

In some sense the differences between conventions are trivial, but trivial doesn’t mean unimportant [1]. If you don’t know that there are multiple conventions, you could be quite puzzled when the output of a FFT doesn’t match your expectations.

## NumPy definition

NumPy’s `fft`

and related functions define the discrete Fourier transform of a sequence *a*_{0}, *a*_{1}, …, *a*_{N−1} to be the sequence *A*_{0}, *A*_{1}, …, *A*_{N−1} given by

## Mathematica definition

Mathematica’s `Fourier`

function defines the discrete Fourier transform of a sequence *u*_{1}, *u*_{2}, …, *u*_{N} to be the sequence *v*_{1}, *v*_{2}, …, *v*_{N} given by

This is the default definition in Mathematica, but not the only possibility. More on that below in the discussion of compatibility.

## Motivation

Python arrays are indexed from 0 while Mathematica arrays are indexed starting from 1. This is why the inputs and outputs are numbered as they are.

Subtracting 1 from the *m* and *k* indices makes the two definitions visually less similar, but the terms in the two summations are the same. The only difference between the two implementations is the scaling factor in front of the sum.

Why does Mathematica divide the sum by √*N* while NumPy does not? As is often the case when there are differing conventions for defining the same thing, the differences are a result of which theorems you want to simplify. Mathematica complicates the definition of the DFT slightly, but in exchange makes the DFT and its inverse more symmetric.

The choice of scaling factor is consistent with the user bases of the two languages. Python skews more toward engineering and applied math, while Mathematica skews more toward pure math. In light of this, the choices made by Python and Mathematica seem inevitable.

## Compatibility

Like Mathematica’s continuous Fourier transform function `FourierTransform`

, its discrete Fourier transform function `Fourier`

takes an optional `FourierParameters`

argument for compatibility with other conventions. Setting the *a* parameter to 1 eliminates the √*N* term and produces a result consistent with NumPy.

There are more variations in DFT definitions. For example, some definitions of the DFT do not have a negative sign inside the exponential. Mathematica can accommodate this by setting *b* to −1 in thel `FourierParameters`

argument. There are other possibilities too. In some implementations, for example, the 0 frequency DC term is in the middle rather than at the beginning.

[1] The FFT is an algorithm for computing the DFT, but the transform itself is often called the FFT.

[2] In classical education, the trivium consisted of grammar, logic, and rhetoric. The original meaning of “trivial” is closer to “foundational” than to “insignificant.”