nlcpy.fft.rfft

nlcpy.fft.rfft(a, n=None, axis=- 1, norm=None)[source]

Computes the one-dimensional discrete fourier transform for a real array.

This function computes the one-dimensional n-point discrete fourier transform (DFT) of a real-valued array by means of an efficient algorithm called the fast fourier transform (FFT).

Parameters

aarray_like: Input array.
nint,optional: Number of points along transformation axis in the input to use. If n is smaller than the length of the input, the input is cropped. If it is larger, the input is padded with zeros. If n is not given, the length of the input along the axis specified by axis is used.
axisint,optional: Axis over which to compute the FFT. If not given, the last axis is used. If axes is larger than the last axis of a, IndexError occurs.
norm{None, “ortho”},optional: Normalization mode. By default(None), the transforms are unscaled. It norm is set to “ortho”, the return values will be scaled by $1/\sqrt{n}$ .

Returns

outcomplex ndarray: The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. If n is even, the length of the transformed axis is (n/2)+1. If n is odd, the length is (n+1)/2.

See also

irfft: Computes the inverse of the n-point DFT for a real array.
fft: Computes the one-dimensional discrete fourier transform.
fftn: Computes the n-dimensional discrete fourier transform.
rfftn: Computes the n-dimensional discrete fourier transform for a real array.

Note

When the DFT is computed for purely a real array, the output is Hermitian-symmetric, i.e. the negative frequency terms are just the complex conjugates of the corresponding positive-frequency terms, and the negative-frequency terms are therefore redundant. This function does not compute the negative frequency terms, and the length of the transformed axis of the output is therefore n//2 + 1.

When A = rfft(a) and fs is the sampling frequency, A[0] contains the zero-frequency term 0*fs, which is real due to Hermitian symmetry.

If n is even, A[-1] contains the term representing both positive and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely real. If n is odd, there is no term at fs/2; A[-1] contains the largest positive frequency (fs/2*(n-1)/n), and is complex in the general case.

If the input a contains an imaginary part, it is silently discarded.

Examples

>>> import nlcpy as vp
>>> vp.fft.fft([0, 1, 0, 0])   
array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j])  # may vary
>>> vp.fft.rfft([0, 1, 0, 0])  
array([ 1.+0.j,  0.-1.j, -1.+0.j])   # may vary

Notice how the final element of the fft() output is the complex conjugate of the second element, for a real array. For rfft, this symmetry is exploited to compute only the non-negative frequency terms.