fft

func Bartlett ¶

func Bartlett(n int) []float64

Bartlett returns the length-n Bartlett (triangular) window:

w[k] = (2/(n-1)) · ((n-1)/2 - |k - (n-1)/2|),  k = 0 .. n-1,

which rises linearly from 0 to 1 at the center and back to 0. This matches numpy.bartlett(n).

func Blackman ¶

func Blackman(n int) []float64

Blackman returns the length-n Blackman window:

w[k] = 0.42 - 0.5·cos(2π·k/(n-1)) + 0.08·cos(4π·k/(n-1)).

This matches numpy.blackman(n).

func BlackmanHarris ¶

func BlackmanHarris(n int) []float64

BlackmanHarris returns the length-n (4-term) Blackman–Harris window with the standard coefficients a0..a3 = 0.35875, 0.48829, 0.14128, 0.01168:

w[k] = a0 - a1·cos(2π·k/(n-1)) + a2·cos(4π·k/(n-1)) - a3·cos(6π·k/(n-1)).

This matches scipy.signal.windows.blackmanharris(n, sym=True).

func DCT ¶ added in v0.5.0

func DCT(x []float64, typ int, norm Norm) []float64

DCT returns the discrete cosine transform of type typ (1, 2, 3 or 4) of x, scaled by norm, as scipy.fft.dct(x, type=typ, norm=norm). The definitions are those of scipy (see the DCTPlan methods); NormOrtho also applies scipy's default orthogonalisation. x is not modified.

It panics if typ is not 1..4, if len(x) is below the type's minimum (2 for DCT-I, 1 otherwise) or if norm is unknown.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round4 rounds to 4 decimals and turns the rounding residue of an exact zero
// (which may print as -0.0000 on one architecture and 0.0000 on another) into 0.
func round4(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = math.Round(v*1e4) / 1e4
		if out[i] == 0 {
			out[i] = 0
		}
	}
	return out
}

func main() {
	x := []float64{1, 2, 3, 4}
	y := fft.DCT(x, 2, fft.NormOrtho)
	fmt.Println(round4(y))
	fmt.Println(round4(fft.IDCT(y, 2, fft.NormOrtho)))
}

Output:
[5 -2.2304 0 -0.1585]
[1 2 3 4]

func DCT32 ¶ added in v0.9.0

func DCT32(x []float32, typ int, norm Norm) []float32

DCT32 returns the DCT of type typ (1, 2, 3 or 4) of the float32 signal x, scaled by norm, in single precision: scipy.fft.dct(x, type=typ, norm=norm) for a float32 x, which scipy returns as float32. x is not modified. The same panics as DCT apply.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round4f32 rounds v to four decimals for printing, with positive zeros: a value
// that cancels exactly, or rounds to zero, may carry either sign depending on
// the CPU's fused multiply-add, and the sign carries no information here.
func round4f32(v []float32) []float64 {
	out := make([]float64, len(v))
	for i, x := range v {
		out[i] = math.Round(float64(x)*1e4)/1e4 + 0
	}
	return out
}

func main() {
	x := []float32{1, 2, 3, 4}
	y := fft.DCT32(x, 2, fft.NormOrtho)
	fmt.Println(round4f32(y))
	fmt.Println(round4f32(fft.IDCT32(y, 2, fft.NormOrtho)))
}

Output:
[5 -2.2304 0 -0.1585]
[1 2 3 4]

func DCTN ¶ added in v0.5.0

func DCTN(x []float64, shape []int, typ int, norm Norm) []float64

DCTN returns the N-dimensional DCT of type typ of x, a row-major array of the given shape, as scipy.fft.dctn(x, type=typ, norm=norm). x is not modified. It panics if the shape does not match len(x), if an axis is below the type's minimum length, or on an unknown type or norm.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round4 rounds to 4 decimals and turns the rounding residue of an exact zero
// (which may print as -0.0000 on one architecture and 0.0000 on another) into 0.
func round4(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = math.Round(v*1e4) / 1e4
		if out[i] == 0 {
			out[i] = 0
		}
	}
	return out
}

func main() {
	img := []float64{
		1, 1, 1,
		1, 1, 1,
	}
	fmt.Println(round4(fft.DCTN(img, []int{2, 3}, 2, fft.NormOrtho)))
}

Output:
[2.4495 0 0 0 0 0]

func DCTN32 ¶ added in v0.9.0

func DCTN32(x []float32, shape []int, typ int, norm Norm) []float32

DCTN32 is DCTN in single precision: the DCT of type typ along every axis of the row-major float32 array x, as scipy.fft.dctn(x, type=typ, norm=norm). The same rules as DCTN apply.

func DST ¶ added in v0.5.0

func DST(x []float64, typ int, norm Norm) []float64

DST returns the discrete sine transform of type typ (1, 2, 3 or 4) of x, scaled by norm, as scipy.fft.dst(x, type=typ, norm=norm); NormOrtho also applies scipy's default orthogonalisation. x is not modified.

It panics if typ is not 1..4, if x is empty or if norm is unknown.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round4 rounds to 4 decimals and turns the rounding residue of an exact zero
// (which may print as -0.0000 on one architecture and 0.0000 on another) into 0.
func round4(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = math.Round(v*1e4) / 1e4
		if out[i] == 0 {
			out[i] = 0
		}
	}
	return out
}

func main() {
	x := []float64{0.5, 0.8660254037844386, 1, 0.8660254037844386, 0.5} // sin(π(n+1)/6)
	fmt.Println(round4(fft.DST(x, 1, fft.NormBackward)))
}

Output:
[6 0 0 0 0]

func DST32 ¶ added in v0.9.0

func DST32(x []float32, typ int, norm Norm) []float32

DST32 returns the DST of type typ (1, 2, 3 or 4) of x in single precision, as scipy.fft.dst(x, type=typ, norm=norm) for a float32 x. The same panics as DST apply.

func DSTN ¶ added in v0.5.0

func DSTN(x []float64, shape []int, typ int, norm Norm) []float64

DSTN returns the N-dimensional DST of type typ of x, a row-major array of the given shape, as scipy.fft.dstn(x, type=typ, norm=norm). The same rules as DCTN apply.

func DSTN32 ¶ added in v0.9.0

func DSTN32(x []float32, shape []int, typ int, norm Norm) []float32

DSTN32 is DSTN in single precision, as scipy.fft.dstn(x, type=typ, norm=norm). The same rules as DCTN apply.

func FFT ¶

func FFT(x []complex128) []complex128

FFT returns the forward discrete Fourier transform of x, using the unnormalized convention

X[k] = sum_{n=0}^{N-1} x[n] * exp(-2πi·k·n/N).

Highly-composite lengths (whose prime factors are all small) use mixed-radix Cooley–Tukey; a length with a large prime factor falls back to Bluestein's chirp-z algorithm. Twiddle factors are cached per length in an internal plan cache, so repeated transforms of the same length recompute no sin/cos. The input is not modified. Empty input returns an empty (non-nil) slice; length 1 returns a copy.

func FFT2 ¶

func FFT2(data []complex128, shape [2]int) []complex128

FFT2 is the two-dimensional FFTN: it transforms data as a row-major shape[0]×shape[1] matrix (rows then columns), matching numpy.fft.fft2.

func FFT2With ¶ added in v0.4.0

func FFT2With(data []complex128, shape [2]int, o Options) []complex128

FFT2With is FFT2 with numpy.fft.fft2's axes and norm arguments: FFTNWith on a two-axis shape.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	x := []complex128{1, 1, 1, 1}
	fmt.Println(roundC(fft.FFT2With(x, [2]int{2, 2}, fft.Options{Norm: fft.NormOrtho})))
}

Output:
[(2+0i) (0+0i) (0+0i) (0+0i)]

func FFT2_32 ¶ added in v0.9.0

func FFT2_32(data []complex64, shape [2]int) []complex64

FFT2_32 is the two-dimensional FFTN32: FFT2 in single precision (scipy.fft.fft2 on complex64 input).

func FFT2_32With ¶ added in v0.9.0

func FFT2_32With(data []complex64, shape [2]int, o Options) []complex64

FFT2_32With is FFT2_32 with numpy.fft.fft2's axes and norm arguments: FFTN32With on a two-axis shape.

func FFT32 ¶ added in v0.6.0

func FFT32(x []complex64) []complex64

FFT32 returns the forward discrete Fourier transform of x in single precision, unnormalized like FFT. The input is not modified; empty input returns an empty (non-nil) slice. Plans are cached per length.

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

// tidy turns the zeros of v positive for printing: whether an exactly
// cancelling sum comes out +0 or -0 depends on the CPU's fused multiply-add
// (loong64 and amd64 differ), and the sign of zero carries no information here.
func tidy(v []complex64) []complex64 {
	out := make([]complex64, len(v))
	for i, z := range v {
		out[i] = complex(real(z)+0, imag(z)+0)
	}
	return out
}

func main() {
	x := []complex64{1, 2, 3, 4}
	X := fft.FFT32(x)
	fmt.Println(tidy(X))
	fmt.Println(tidy(fft.IFFT32(X)))
}

Output:
[(10+0i) (-2+2i) (-2+0i) (-2-2i)]
[(1+0i) (2+0i) (3+0i) (4+0i)]

func FFT32With ¶ added in v0.9.0

func FFT32With(x []complex64, o Options) []complex64

FFT32With is FFT32 with numpy.fft.fft's n and norm arguments, as FFTWith: the input is truncated or zero-padded to o.N points (len(x) when o.N is zero) and the transform is scaled as o.Norm says. The input is not modified. o.Axes must be nil.

x := []complex64{4, 4}
X := fft.FFT32With(x, fft.Options{N: 4, Norm: fft.NormForward})
fmt.Println(tidy(X))

Output:
[(2+0i) (1-1i) (0+0i) (1+1i)]

func FFTFreq ¶

func FFTFreq(n int, d float64) []float64

FFTFreq returns the n sample frequencies of an FFT of length n, given the sample spacing d (the inverse of the sampling rate). The result matches numpy.fft.fftfreq(n, d) exactly:

f = [0, 1, ..., (n-1)//2, -(n//2), ..., -1] / (d·n).

The DC bin is first, then the positive frequencies in increasing order, then the negative frequencies. For even n the Nyquist bin appears as -n/2; for odd n the largest positive bin is (n-1)/2. n <= 0 returns an empty (non-nil) slice.

func FFTN ¶

func FFTN(data []complex128, shape []int) []complex128

FFTN returns the forward N-dimensional discrete Fourier transform of data, interpreted as a row-major (C-order) array of the given shape. The result is a new slice of the same length; the input is not modified.

The transform is separable and unnormalized: it applies the 1-D FFT along each axis in turn, matching numpy.fft.fftn. shape must contain only positive lengths whose product equals len(data); FFTN panics otherwise (consistent with numpy raising on a mismatched shape). An empty shape transforms the single scalar unchanged.

func FFTN32 ¶ added in v0.9.0

func FFTN32(data []complex64, shape []int) []complex64

FFTN32 returns the forward N-dimensional DFT of the complex64 row-major array data of the given shape, in single precision and unnormalized, like FFTN (scipy.fft.fftn on complex64 input). The input is not modified; the same shape rules as FFTN apply.

x := []complex64{1, 2, 3, 4} // a 2×2 matrix, row-major
X := fft.FFTN32(x, []int{2, 2})
fmt.Println(tidy(X))
fmt.Println(tidy(fft.FFT2_32(x, [2]int{2, 2})))
fmt.Println(tidy(fft.IFFTN32(X, []int{2, 2})))

Output:
[(10+0i) (-2+0i) (-4+0i) (0+0i)]
[(10+0i) (-2+0i) (-4+0i) (0+0i)]
[(1+0i) (2+0i) (3+0i) (4+0i)]

func FFTN32With ¶ added in v0.9.0

func FFTN32With(data []complex64, shape []int, o Options) []complex64

FFTN32With is FFTN32 with numpy.fft.fftn's axes and norm arguments, as FFTNWith: only the axes in o.Axes are transformed (every axis when nil) and the result is scaled as o.Norm says. o.N must be zero.

func FFTNWith ¶ added in v0.4.0

func FFTNWith(data []complex128, shape []int, o Options) []complex128

FFTNWith is FFTN with numpy.fft.fftn's axes and norm arguments: data is a row-major array of the given shape, only the axes in o.Axes are transformed (every axis when o.Axes is nil), and the result is scaled as o.Norm says. FFTNWith(data, shape, Options{}) equals FFTN(data, shape). The output has the input's shape; the input is not modified. o.N must be zero.

With o.Axes = []int{-1} it is the batched 1-D transform: every row of a matrix of signals is transformed with one plan.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	// Three signals of four points, one per row: transforming the last axis
	// alone is numpy's fft(x, axis=-1), the batched 1-D transform.
	rows := []complex128{
		1, 0, 0, 0,
		1, 1, 1, 1,
		0, 1, 0, 0,
	}
	out := fft.FFTNWith(rows, []int{3, 4}, fft.Options{Axes: []int{-1}})
	for r := 0; r < 3; r++ {
		fmt.Println(roundC(out[r*4 : (r+1)*4]))
	}
}

Output:
[(1+0i) (1+0i) (1+0i) (1+0i)]
[(4+0i) (0+0i) (0+0i) (0+0i)]
[(1+0i) (0-1i) (-1+0i) (0+1i)]

func FFTReal ¶

func FFTReal(x []float64) []complex128

FFTReal returns the forward discrete Fourier transform of a real-valued signal as the full complex spectrum (length len(x)). It is a convenience wrapper that promotes x to complex128 and calls FFT.

func FFTShift ¶ added in v0.4.0

func FFTShift[T any](x []T) []T

FFTShift returns x with its zero-frequency element moved to the centre: x rotated right by len(x)/2, numpy.fft.fftshift on a 1-D array. For FFTFreq(n, d) it returns the frequencies in increasing order. The input is not modified; the result is a new slice (empty, not nil, for empty input).

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

func main() {
	// Bin frequencies in increasing order, the zero frequency in the middle.
	fmt.Println(fft.FFTShift(fft.FFTFreq(5, 1)))
	fmt.Println(fft.FFTShift([]int{0, 1, 2, 3, 4, 5}))
}

Output:
[-0.4 -0.2 0 0.2 0.4]
[3 4 5 0 1 2]

func FFTShiftN ¶ added in v0.4.0

func FFTShiftN[T any](x []T, shape []int, axes []int) []T

FFTShiftN is numpy.fft.fftshift on a row-major array of the given shape: every axis in axes (every axis when axes is nil; negative axes count from the end) is rotated by its length/2, which moves the zero-frequency bin of an N-D spectrum to the centre. shape must hold positive lengths whose product is len(x), and an axis may not be listed twice; FFTShiftN panics otherwise. The input is not modified.

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

func main() {
	x := []int{
		0, 1, 2,
		3, 4, 5,
		6, 7, 8,
	}
	fmt.Println(fft.FFTShiftN(x, []int{3, 3}, nil))
	fmt.Println(fft.FFTShiftN(x, []int{3, 3}, []int{-1})) // the rows only
}

Output:
[8 6 7 2 0 1 5 3 4]
[2 0 1 5 3 4 8 6 7]

func FFTWith ¶ added in v0.4.0

func FFTWith(x []complex128, o Options) []complex128

FFTWith is FFT with numpy.fft.fft's n and norm arguments: the input is truncated or zero-padded to o.N points (len(x) when o.N is zero) and the forward transform is scaled as o.Norm says. FFTWith(x, Options{}) equals FFT(x). The input is not modified. o.Axes must be nil.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	x := []complex128{1, 1, 1, 1, 1, 1}
	// Truncate to 4 points and scale by 1/sqrt(4) (numpy norm="ortho").
	fmt.Println(roundC(fft.FFTWith(x, fft.Options{N: 4, Norm: fft.NormOrtho})))
}

Output:
[(2+0i) (0+0i) (0+0i) (0+0i)]

func HFFT ¶ added in v0.4.0

func HFFT(x []complex128, n int) []float64

HFFT returns the DFT of a signal with Hermitian symmetry, given its first half x (x[0] .. x[n/2]; the rest is conj(x[n-k])), as a real slice of n values: numpy.fft.hfft(x, n). It is the forward transform, unscaled:

X[k] = sum_{j=0}^{n-1} y[j] * exp(-2πi·k·j/n),  y[j] = x[j], y[n-j] = conj(x[j]).

numpy defines it as irfft(conj(x), n) multiplied by n; HFFT computes the same. n is the length of the output, as for IRFFT (n and n-1 share the same half); n <= 0 returns an empty slice. x is read up to n/2+1 values and missing ones are zero. The input is not modified.

See https://numpy.org/doc/stable/reference/generated/numpy.fft.hfft.html.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	// The first half of a Hermitian-symmetric signal y = [1, 2, 3, 2]; its DFT
	// is real.
	fmt.Println(roundR(fft.HFFT([]complex128{1, 2, 3}, 4)))
}

Output:
[8 -2 0 -2]

func HFFT32 ¶ added in v0.9.0

func HFFT32(x []complex64, n int) []float32

HFFT32 is HFFT in single precision: the real DFT, of n points, of the Hermitian-symmetric signal whose first half is x (numpy.fft.hfft(x, n)). n <= 0 returns an empty slice. The input is not modified.

func HFFT32With ¶ added in v0.9.0

func HFFT32With(x []complex64, o Options) []float32

HFFT32With is HFFTWith in single precision: o.N is the output length (zero selects 2*(len(x)-1)) and o.Norm scales it as a forward transform. o.Axes must be nil.

func HFFTWith ¶ added in v0.4.0

func HFFTWith(x []complex128, o Options) []float64

HFFTWith is HFFT with numpy.fft.hfft's n and norm arguments: o.N is the length of the real output (zero selects numpy's default 2*(len(x)-1)) and o.Norm scales it as a FORWARD transform — unscaled under the default NormBackward, 1/sqrt(n) under NormOrtho, 1/n under NormForward. numpy implements this as irfft(conj(x), n, norm=<the opposite direction>), which is the same thing. o.Axes must be nil.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	// The same transform scaled as a forward transform under NormForward: 1/n.
	fmt.Println(roundR(fft.HFFTWith([]complex128{1, 2, 3}, fft.Options{N: 4, Norm: fft.NormForward})))
}

Output:
[2 -0.5 0 -0.5]

func Hamming ¶

func Hamming(n int) []float64

Hamming returns the length-n Hamming window:

w[k] = 0.54 - 0.46·cos(2π·k/(n-1)),  k = 0 .. n-1.

This matches numpy.hamming(n).

func Hann ¶

func Hann(n int) []float64

Hann returns the length-n Hann (Hanning) window:

w[k] = 0.5 - 0.5·cos(2π·k/(n-1)),  k = 0 .. n-1.

This matches numpy.hanning(n).

func IDCT ¶ added in v0.5.0

func IDCT(x []float64, typ int, norm Norm) []float64

IDCT returns the inverse discrete cosine transform of type typ of x, as scipy.fft.idct(x, type=typ, norm=norm), so that IDCT(DCT(x, t, m), t, m) reproduces x. The same panics as DCT apply.

func IDCT32 ¶ added in v0.9.0

func IDCT32(x []float32, typ int, norm Norm) []float32

IDCT32 returns the inverse DCT of type typ of x in single precision, as scipy.fft.idct(x, type=typ, norm=norm). The same panics as DCT apply.

func IDCTN ¶ added in v0.5.0

func IDCTN(x []float64, shape []int, typ int, norm Norm) []float64

IDCTN inverts DCTN, as scipy.fft.idctn(x, type=typ, norm=norm).

func IDCTN32 ¶ added in v0.9.0

func IDCTN32(x []float32, shape []int, typ int, norm Norm) []float32

IDCTN32 inverts DCTN32, as scipy.fft.idctn(x, type=typ, norm=norm).

func IDST ¶ added in v0.5.0

func IDST(x []float64, typ int, norm Norm) []float64

IDST returns the inverse discrete sine transform of type typ of x, as scipy.fft.idst(x, type=typ, norm=norm), so that IDST(DST(x, t, m), t, m) reproduces x. The same panics as DST apply.

func IDST32 ¶ added in v0.9.0

func IDST32(x []float32, typ int, norm Norm) []float32

IDST32 returns the inverse DST of type typ of x in single precision, as scipy.fft.idst(x, type=typ, norm=norm). The same panics as DST apply.

func IDSTN ¶ added in v0.5.0

func IDSTN(x []float64, shape []int, typ int, norm Norm) []float64

IDSTN inverts DSTN, as scipy.fft.idstn(x, type=typ, norm=norm).

func IDSTN32 ¶ added in v0.9.0

func IDSTN32(x []float32, shape []int, typ int, norm Norm) []float32

IDSTN32 inverts DSTN32, as scipy.fft.idstn(x, type=typ, norm=norm).

func IFFT ¶

func IFFT(x []complex128) []complex128

IFFT returns the inverse discrete Fourier transform of x, normalized by N so that IFFT(FFT(x)) ≈ x to floating-point tolerance:

x[n] = (1/N) * sum_{k=0}^{N-1} X[k] * exp(+2πi·k·n/N).

The input is not modified.

func IFFT2 ¶

func IFFT2(data []complex128, shape [2]int) []complex128

IFFT2 is the two-dimensional IFFTN, the inverse of FFT2, normalized by shape[0]*shape[1]. It matches numpy.fft.ifft2.

func IFFT2With ¶ added in v0.4.0

func IFFT2With(data []complex128, shape [2]int, o Options) []complex128

IFFT2With is IFFT2 with numpy.fft.ifft2's axes and norm arguments: IFFTNWith on a two-axis shape.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	X := []complex128{2, 0, 0, 0}
	fmt.Println(roundC(fft.IFFT2With(X, [2]int{2, 2}, fft.Options{Norm: fft.NormOrtho})))
}

Output:
[(1+0i) (1+0i) (1+0i) (1+0i)]

func IFFT2_32 ¶ added in v0.9.0

func IFFT2_32(data []complex64, shape [2]int) []complex64

IFFT2_32 is the two-dimensional IFFTN32, the inverse of FFT2_32, normalized by shape[0]*shape[1].

func IFFT2_32With ¶ added in v0.9.0

func IFFT2_32With(data []complex64, shape [2]int, o Options) []complex64

IFFT2_32With is IFFT2_32 with numpy.fft.ifft2's axes and norm arguments: IFFTN32With on a two-axis shape.

func IFFT32 ¶ added in v0.6.0

func IFFT32(x []complex64) []complex64

IFFT32 returns the inverse discrete Fourier transform of x in single precision, normalized by N like IFFT. The input is not modified.

func IFFT32With ¶ added in v0.9.0

func IFFT32With(x []complex64, o Options) []complex64

IFFT32With is IFFT32 with numpy.fft.ifft's n and norm arguments, as IFFTWith (1/n under the default NormBackward). o.Axes must be nil.

func IFFTN ¶

func IFFTN(data []complex128, shape []int) []complex128

IFFTN returns the inverse N-dimensional discrete Fourier transform of data, the inverse of FFTN. It applies the 1-D IFFT along each axis, so the result is normalized by the product of the transformed axis lengths and IFFTN(FFTN(x), shape) ≈ x. The input is not modified; the same shape rules as FFTN apply.

func IFFTN32 ¶ added in v0.9.0

func IFFTN32(data []complex64, shape []int) []complex64

IFFTN32 returns the inverse N-dimensional DFT of data in single precision, normalized by the product of the shape, like IFFTN. The input is not modified.

func IFFTN32With ¶ added in v0.9.0

func IFFTN32With(data []complex64, shape []int, o Options) []complex64

IFFTN32With is IFFTN32 with numpy.fft.ifftn's axes and norm arguments; see FFTN32With.

func IFFTNWith ¶ added in v0.4.0

func IFFTNWith(data []complex128, shape []int, o Options) []complex128

IFFTNWith is IFFTN with numpy.fft.ifftn's axes and norm arguments; see FFTNWith. Under the default NormBackward the result is divided by the product of the transformed axis lengths.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	X := []complex128{4, 0, 0, 0}
	// Inverse along axis 0 only, of a 2×2 array.
	fmt.Println(roundC(fft.IFFTNWith(X, []int{2, 2}, fft.Options{Axes: []int{0}})))
}

Output:
[(2+0i) (0+0i) (2+0i) (0+0i)]

func IFFTShift ¶ added in v0.4.0

func IFFTShift[T any](x []T) []T

IFFTShift is the inverse of FFTShift: x rotated left by len(x)/2, numpy.fft.ifftshift on a 1-D array. IFFTShift(FFTShift(x)) == x for every length; for an even length the two functions coincide. The input is not modified.

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

func main() {
	shifted := fft.FFTShift([]int{0, 1, 2, 3, 4})
	fmt.Println(shifted, fft.IFFTShift(shifted))
}

Output:
[3 4 0 1 2] [0 1 2 3 4]

func IFFTShiftN ¶ added in v0.4.0

func IFFTShiftN[T any](x []T, shape []int, axes []int) []T

IFFTShiftN is numpy.fft.ifftshift on a row-major array of the given shape, the inverse of FFTShiftN: every axis in axes (every axis when nil) is rotated back by its length/2. The same rules as FFTShiftN apply.

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

func main() {
	x := []int{0, 1, 2, 3, 4, 5}
	s := fft.FFTShiftN(x, []int{2, 3}, nil)
	fmt.Println(s, fft.IFFTShiftN(s, []int{2, 3}, nil))
}

Output:
[5 3 4 2 0 1] [0 1 2 3 4 5]

func IFFTWith ¶ added in v0.4.0

func IFFTWith(x []complex128, o Options) []complex128

IFFTWith is IFFT with numpy.fft.ifft's n and norm arguments: the input is truncated or zero-padded to o.N points (len(x) when o.N is zero) and the inverse transform is scaled as o.Norm says (1/n under the default NormBackward). IFFTWith(x, Options{}) equals IFFT(x). The input is not modified. o.Axes must be nil.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	X := []complex128{4, 0, 0, 0}
	// Under NormForward the inverse is unscaled.
	fmt.Println(roundC(fft.IFFTWith(X, fft.Options{Norm: fft.NormForward})))
}

Output:
[(4+0i) (4+0i) (4+0i) (4+0i)]

func IHFFT ¶ added in v0.4.0

func IHFFT(x []float64) []complex128

IHFFT is the inverse of HFFT: it returns the first n/2+1 values of the Hermitian-symmetric signal whose real DFT is x (n = len(x)), normalized by 1/n — numpy.fft.ihfft(x), which numpy defines as conj(rfft(x))/n. Empty input returns an empty slice. The input is not modified.

See https://numpy.org/doc/stable/reference/generated/numpy.fft.ihfft.html.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	// IHFFT inverts HFFT: back to the half signal.
	fmt.Println(roundC(fft.IHFFT([]float64{8, -2, 0, -2})))
}

Output:
[(1+0i) (2+0i) (3+0i)]

func IHFFT32 ¶ added in v0.9.0

func IHFFT32(x []float32) []complex64

IHFFT32 is IHFFT in single precision: the first n/2+1 values of the Hermitian signal whose real DFT is x, normalized by 1/n (numpy.fft.ihfft(x)). The input is not modified.

func IHFFT32With ¶ added in v0.9.0

func IHFFT32With(x []float32, o Options) []complex64

IHFFT32With is IHFFTWith in single precision: the input is truncated or zero-padded to o.N points (len(x) when zero) and o.Norm scales the result as an inverse transform. o.Axes must be nil.

func IHFFTWith ¶ added in v0.4.0

func IHFFTWith(x []float64, o Options) []complex128

IHFFTWith is IHFFT with numpy.fft.ihfft's n and norm arguments: the input is truncated or zero-padded to o.N points (len(x) when o.N is zero) and o.Norm scales the result as an INVERSE transform — 1/n under the default NormBackward, 1/sqrt(n) under NormOrtho, unscaled under NormForward — so that HFFTWith(IHFFTWith(x, o), Options{N: len(x), Norm: o.Norm}) ≈ x for every o.Norm. o.Axes must be nil.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	x := []float64{8, -2, 0, -2}
	h := fft.IHFFTWith(x, fft.Options{Norm: fft.NormOrtho})
	// The pair round-trips under any Norm, given the same one both ways.
	fmt.Println(roundR(fft.HFFTWith(h, fft.Options{N: len(x), Norm: fft.NormOrtho})))
}

Output:
[8 -2 0 -2]

func IRFFT ¶

func IRFFT(spectrum []complex128, n int) []float64

IRFFT inverts RFFT, reconstructing a real-valued signal of length n from the n/2+1 non-redundant spectral bins produced by RFFT. The caller passes the desired output length n explicitly, because n and n-1 yield the same number of kept bins so the half spectrum alone is ambiguous; this mirrors numpy.fft.irfft(spectrum, n).

spectrum is read up to min(len(spectrum), n/2+1) bins; any bins beyond that (or beyond what the Hermitian mirror needs) are treated as zero. The result is normalized by n so that IRFFT(RFFT(x), len(x)) ≈ x.

The input is not modified. n <= 0 returns an empty (non-nil) slice.

The output has n values whatever the spectrum's length, so n sets the allocation, as it would for make: bound it when it comes from untrusted input (see SECURITY.md).

func IRFFT2 ¶

func IRFFT2(data []complex128, shape [2]int) []float64

IRFFT2 inverts RFFT2, reconstructing a real row-major matrix of shape shape[0]×shape[1] from a spectrum laid out as shape[0]×(shape[1]/2+1) complex bins (the layout RFFT2 produces). The complex inverse is applied down the columns first, then the real inverse (irfft) along each row, with the target row length shape[1] supplied explicitly (since shape[1] and shape[1]-1 share a bin count). The result is normalized by shape[0]*shape[1] so that IRFFT2(RFFT2(x, shape), shape) ≈ x. This matches numpy.fft.irfft2.

shape lengths must be positive; IRFFT2 panics otherwise. data is read up to shape[0]*(shape[1]/2+1) bins; any beyond that are treated as zero. The input is not modified. The output has shape[0]*shape[1] values whatever the spectrum's length: bound the shape when it comes from untrusted input (see SECURITY.md).

func IRFFT2With ¶ added in v0.4.0

func IRFFT2With(data []complex128, shape [2]int, o Options) []float64

IRFFT2With is IRFFT2 with numpy.fft.irfft2's axes and norm arguments. With o.Axes nil it runs IRFFT2's plan and rescales the result; with axes it is IRFFTNWith on a two-axis shape.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	spec := []complex128{1, 0, 0, 0}
	fmt.Println(roundR(fft.IRFFT2With(spec, [2]int{2, 2}, fft.Options{Norm: fft.NormForward})))
}

Output:
[1 1 1 1]

func IRFFT2_32 ¶ added in v0.9.0

func IRFFT2_32(data []complex64, shape [2]int) []float32

IRFFT2_32 inverts RFFT2_32, as IRFFT2 inverts RFFT2: shape is the real output's, data is read up to shape[0]*(shape[1]/2+1) bins (missing ones are zero) and the result is normalized by shape[0]*shape[1]. The output has shape[0]*shape[1] values whatever the spectrum's length: bound the shape when it comes from untrusted input (see SECURITY.md).

func IRFFT2_32With ¶ added in v0.9.0

func IRFFT2_32With(data []complex64, shape [2]int, o Options) []float32

IRFFT2_32With is IRFFT2_32 with numpy.fft.irfft2's axes and norm arguments. With o.Axes nil it runs IRFFT2_32's plan; with axes it is IRFFTN32With on a two-axis shape.

func IRFFT32 ¶ added in v0.6.0

func IRFFT32(spectrum []complex64, n int) []float32

IRFFT32 inverts RFFT32, returning n real samples normalized by n like IRFFT. n <= 0 returns an empty (non-nil) slice. n sets the allocation: bound it when it comes from untrusted input (see SECURITY.md).

func IRFFT32With ¶ added in v0.9.0

func IRFFT32With(spectrum []complex64, o Options) []float32

IRFFT32With is IRFFT32 with numpy.fft.irfft's n and norm arguments, as IRFFTWith: o.N is the length of the real output, zero selecting numpy's default 2*(len(spectrum)-1). o.Axes must be nil. The output length is the caller's o.N whatever the spectrum's length: bound it when it comes from untrusted input (see SECURITY.md).

func IRFFTN ¶ added in v0.4.0

func IRFFTN(data []complex128, shape []int) []float64

IRFFTN inverts RFFTN: shape is the shape of the REAL output (its last length n cannot be recovered from the n/2+1 bins it keeps, as for IRFFT), and data is the spectrum laid out as RFFTN produces it, that shape with the last length replaced by n/2+1. The complex inverse runs along every axis but the last, then the real inverse along the last; the result is normalized by the product of the shape. This is numpy.fft.irfftn(data, s=shape).

data is read up to the spectrum's size and missing bins are zero, as for IRFFT2. shape must hold at least one axis and every length must be positive; IRFFTN panics otherwise. The input is not modified. The output has the product of shape values whatever the spectrum's length: bound the shape when it comes from untrusted input (see SECURITY.md).

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	x := []float64{1, 2, 3, 4, 5, 6}
	// The shape is the real output's: its last length cannot be recovered
	// from the bins alone.
	back := fft.IRFFTN(fft.RFFTN(x, []int{2, 3}), []int{2, 3})
	fmt.Println(roundR(back))
}

Output:
[1 2 3 4 5 6]

func IRFFTN32 ¶ added in v0.9.0

func IRFFTN32(data []complex64, shape []int) []float32

IRFFTN32 inverts RFFTN32, as IRFFTN inverts RFFTN: shape is the REAL output's, and the result is normalized by its product. The output has the product of shape values whatever the spectrum's length: bound the shape when it comes from untrusted input (see SECURITY.md).

func IRFFTN32With ¶ added in v0.9.0

func IRFFTN32With(data []complex64, shape []int, o Options) []float32

IRFFTN32With is IRFFTN32 with numpy.fft.irfftn's axes and norm arguments, as IRFFTNWith: the real inverse runs along the LAST axis in o.Axes, the complex inverse along the others. o.Axes must name at least one axis; o.N must be zero.

func IRFFTNWith ¶ added in v0.4.0

func IRFFTNWith(data []complex128, shape []int, o Options) []float64

IRFFTNWith is IRFFTN with numpy.fft.irfftn's axes and norm arguments: the real inverse runs along the LAST axis in o.Axes (every axis when nil), whose spectrum holds shape[axis]/2+1 bins, the complex inverse along the others, and the result is scaled as o.Norm says. o.Axes must name at least one axis; o.N must be zero.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	x := []float64{1, 2, 3, 4, 5, 6}
	o := fft.Options{Axes: []int{0}, Norm: fft.NormOrtho}
	fmt.Println(roundR(fft.IRFFTNWith(fft.RFFTNWith(x, []int{3, 2}, o), []int{3, 2}, o)))
}

Output:
[1 2 3 4 5 6]

func IRFFTWith ¶ added in v0.4.0

func IRFFTWith(spectrum []complex128, o Options) []float64

IRFFTWith is IRFFT with numpy.fft.irfft's n and norm arguments. o.N is the length of the real output; zero selects numpy's default 2*(len(spectrum)-1), which reconstructs an even-length signal (pass the length explicitly for an odd one: n and n-1 keep the same number of bins). The spectrum is read up to o.N/2+1 bins and missing bins are zero, as for IRFFT; the imaginary parts of the zero-frequency bin and, for an even length, of the Nyquist bin are ignored, as numpy does. The result is scaled as o.Norm says (1/n under the default NormBackward). A length of zero (a spectrum of fewer than two bins and o.N zero) gives an empty result, where numpy raises. The input is not modified. o.Axes must be nil.

The output length is the caller's o.N whatever the spectrum's length: bound it when it comes from untrusted input (see SECURITY.md).

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundR(x []float64) []float64 {
	out := make([]float64, len(x))
	for i, v := range x {
		out[i] = round(v)
	}
	return out
}

func main() {
	spectrum := []complex128{6, -2 - 2i, 2}
	// N = 0 takes numpy's default length 2*(3-1) = 4.
	fmt.Println(roundR(fft.IRFFTWith(spectrum, fft.Options{})))
}

Output:
[1 2 3 0]

func NextFastLen ¶ added in v0.4.0

func NextFastLen(target int, real bool) int

NextFastLen returns the smallest length >= target that this package transforms fast, the counterpart of scipy.fft.next_fast_len(target, real) (https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.next_fast_len.html): zero-pad a signal to it before transforming (FFTWith/RFFTWith with Options{N: NextFastLen(len(x), ...)}).

What is fast depends on the library, so the rule differs from scipy's:

• complex (real == false): the 7-smooth lengths, 2^a·3^b·5^c·7^d. Every such length runs entirely on the Stockham engine's specialized radix 2/3/4/5/7/8 passes. A factor 11 or 13 also stays on the mixed-radix path but through its general O(p²) radix pass, and a larger prime factor goes to Rader or Bluestein. Measured on Apple M4 Max (2026-10-05, ns per point): 1001 = 7·11·13 cost 20 and 1100 = 2²·5²·11 cost 11, against 2.5 for 1008 and 1120; 2197 = 13³ cost 33 and 4067 = 7²·83 (Bluestein) 15, against 2.7 for 4096. scipy, whose pocketfft has specialized radix-11 passes, accepts 11-smooth lengths here.
• real (real == true): the EVEN 7-smooth lengths. An even length packs into a half-length complex transform; an odd one runs the full complex transform: as a real transform 1125 = 3²·5³ cost 4.7 ns per point against 1.6 for 1134 = 2·3⁴·7. scipy's real rule is 5-smooth, odd lengths included.

Targets 0 and 1 are returned unchanged (such transforms are trivial). A negative target panics, as does a target above the largest qualifying length that fits in an int.

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

func main() {
	fmt.Println(fft.NextFastLen(1009, false)) // 1009 is prime; the next 7-smooth length is 1024
	fmt.Println(fft.NextFastLen(1001, true))  // 1001 = 7·11·13 is not; 1008 = 2⁴·3²·7 is even and 7-smooth
}

Output:
1024
1008

func PSD ¶

func PSD(x []float64, d float64) []float64

PSD returns the one-sided power spectral density (periodogram) of the real-valued signal x sampled at spacing d, using the non-redundant RFFT bins. The result has length len(x)/2+1.

Each bin is scaled to a density: |X[k]|² / (fs·N) where fs = 1/d is the sampling rate and N = len(x). To conserve total power, every bin except DC (and the Nyquist bin for even N) is doubled to fold in the discarded mirror half. This matches scipy.signal.periodogram(x, fs, window="boxcar", scaling="density", return_onesided=True). The companion frequency axis is RFFTFreq(len(x), d). The input is not modified; an empty x returns an empty (non-nil) slice.

func RFFT ¶

func RFFT(x []float64) []complex128

RFFT returns the forward discrete Fourier transform of a real-valued signal, keeping only the non-redundant spectrum. For input of length N the result has length N/2+1 (integer division): bins 0..N/2. The discarded upper half is the conjugate mirror of the lower half (X[N-k] = conj(X[k])), so it carries no new information. This matches numpy.fft.rfft.

The transform is unnormalized, consistent with FFT:

X[k] = sum_{n=0}^{N-1} x[n] * exp(-2πi·k·n/N),  k = 0 .. N/2.

For even N the real signal is packed into an N/2-point complex transform and untangled — about twice as fast as a full complex FFT — using twiddle tables cached per length. The input is not modified. Empty input returns an empty (non-nil) slice.

func RFFT2 ¶

func RFFT2(data []float64, shape [2]int) []complex128

RFFT2 returns the forward 2-D DFT of a real row-major matrix of the given shape (shape[0] rows × shape[1] columns). The real transform is applied along the last axis, so each output row keeps shape[1]/2+1 non-redundant bins; the result is a row-major matrix of shape shape[0]×(shape[1]/2+1). The full complex transform is then applied down the columns. This matches numpy.fft.rfft2.

shape lengths must be positive and shape[0]*shape[1] must equal len(data); RFFT2 panics otherwise. The input is not modified.

func RFFT2With ¶ added in v0.4.0

func RFFT2With(data []float64, shape [2]int, o Options) []complex128

RFFT2With is RFFT2 with numpy.fft.rfft2's axes and norm arguments. With o.Axes nil it runs RFFT2's plan and scales the result; with axes it is RFFTNWith on a two-axis shape.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	img := []float64{1, 1, 1, 1}
	fmt.Println(roundC(fft.RFFT2With(img, [2]int{2, 2}, fft.Options{Norm: fft.NormForward})))
}

Output:
[(1+0i) (0+0i) (0+0i) (0+0i)]

func RFFT2_32 ¶ added in v0.9.0

func RFFT2_32(data []float32, shape [2]int) []complex64

RFFT2_32 is RFFT2 in single precision: the forward 2-D DFT of a real row-major float32 matrix of shape shape[0]×shape[1], keeping shape[1]/2+1 bins per row (scipy.fft.rfft2 on float32 input). The same shape rules as RFFT2 apply; the input is not modified.

func RFFT2_32With ¶ added in v0.9.0

func RFFT2_32With(data []float32, shape [2]int, o Options) []complex64

RFFT2_32With is RFFT2_32 with numpy.fft.rfft2's axes and norm arguments. With o.Axes nil it runs RFFT2_32's plan; with axes it is RFFTN32With on a two-axis shape.

func RFFT32 ¶ added in v0.6.0

func RFFT32(x []float32) []complex64

RFFT32 returns the N/2+1 non-redundant bins of the real signal x in single precision, unnormalized like RFFT. Empty input returns an empty (non-nil) slice. Plans are cached per length.

package main

import (
	"fmt"

	"github.com/go-fft/fft"
)

// tidy turns the zeros of v positive for printing: whether an exactly
// cancelling sum comes out +0 or -0 depends on the CPU's fused multiply-add
// (loong64 and amd64 differ), and the sign of zero carries no information here.
func tidy(v []complex64) []complex64 {
	out := make([]complex64, len(v))
	for i, z := range v {
		out[i] = complex(real(z)+0, imag(z)+0)
	}
	return out
}

func main() {
	x := []float32{1, 2, 3, 4}
	X := fft.RFFT32(x)
	fmt.Println(tidy(X))
	fmt.Println(fft.IRFFT32(X, len(x)))
}

Output:
[(10+0i) (-2+2i) (-2+0i)]
[1 2 3 4]

func RFFT32With ¶ added in v0.9.0

func RFFT32With(x []float32, o Options) []complex64

RFFT32With is RFFT32 with numpy.fft.rfft's n and norm arguments, as RFFTWith: the result holds n/2+1 bins of the input truncated or zero-padded to n = o.N points (len(x) when o.N is zero). o.Axes must be nil.

func RFFTFreq ¶

func RFFTFreq(n int, d float64) []float64

RFFTFreq returns the n/2+1 sample frequencies of a real FFT (RFFT) of input length n, given the sample spacing d. The result matches numpy.fft.rfftfreq(n, d) exactly:

f = [0, 1, ..., n//2] / (d·n),  length n//2+1.

All frequencies are non-negative because RFFT keeps only the non-redundant lower half of the spectrum. n <= 0 returns an empty (non-nil) slice.

func RFFTN ¶ added in v0.4.0

func RFFTN(data []float64, shape []int) []complex128

RFFTN returns the forward N-dimensional DFT of the real row-major array data of the given shape, keeping only the non-redundant half of the last axis: the result is a row-major array of the same shape except that the last length n becomes n/2+1. The real transform runs along the last axis and the complex one along the others, unnormalized. This is numpy.fft.rfftn; RFFT2 is its two-dimensional case.

shape must hold at least one axis, every length must be positive and their product must equal len(data); RFFTN panics otherwise. The input is not modified.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	// A 2×2×4 real array: the last axis keeps 4/2+1 = 3 bins.
	x := make([]float64, 16)
	for i := range x {
		x[i] = 1
	}
	s := fft.RFFTN(x, []int{2, 2, 4})
	fmt.Println(len(s), roundC(s[:3]))
}

Output:
12 [(16+0i) (0+0i) (0+0i)]

func RFFTN32 ¶ added in v0.9.0

func RFFTN32(data []float32, shape []int) []complex64

RFFTN32 is RFFTN in single precision: the forward N-dimensional DFT of the real row-major float32 array data, the real transform along the last axis (which keeps n/2+1 bins) and the complex one along the others (scipy.fft.rfftn on float32 input). The same rules as RFFTN apply.

func RFFTN32With ¶ added in v0.9.0

func RFFTN32With(data []float32, shape []int, o Options) []complex64

RFFTN32With is RFFTN32 with numpy.fft.rfftn's axes and norm arguments, as RFFTNWith: the real transform runs along the LAST axis listed. o.Axes must name at least one axis; o.N must be zero.

rows := []float32{
	1, 1, 1, 1,
	1, 0, -1, 0,
}
S := fft.RFFTN32With(rows, []int{2, 4}, fft.Options{Axes: []int{-1}})
fmt.Println(tidy(S))

Output:
[(4+0i) (0+0i) (0+0i) (0+0i) (2+0i) (0+0i)]

func RFFTNWith ¶ added in v0.4.0

func RFFTNWith(data []float64, shape []int, o Options) []complex128

RFFTNWith is RFFTN with numpy.fft.rfftn's axes and norm arguments: only the axes in o.Axes are transformed (every axis when nil), the real transform runs along the LAST axis listed — that axis of the output keeps n/2+1 bins — and the result is scaled as o.Norm says. o.Axes must name at least one axis; o.N must be zero.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	x := []float64{
		1, 2,
		3, 4,
		5, 6,
	}
	// The real transform along axis 0 (the last axis listed): 3 rows keep
	// 3/2+1 = 2 bins, and the output is 2×2.
	fmt.Println(roundC(fft.RFFTNWith(x, []int{3, 2}, fft.Options{Axes: []int{0}})))
}

Output:
[(9+0i) (12+0i) (-3+1.7321i) (-3+1.7321i)]

func RFFTWith ¶ added in v0.4.0

func RFFTWith(x []float64, o Options) []complex128

RFFTWith is RFFT with numpy.fft.rfft's n and norm arguments: the real input is truncated or zero-padded to o.N points (len(x) when o.N is zero), the result holds o.N/2+1 bins, and the transform is scaled as o.Norm says. RFFTWith(x, Options{}) equals RFFT(x). The input is not modified. o.Axes must be nil.

package main

import (
	"fmt"
	"math"

	"github.com/go-fft/fft"
)

// round keeps four decimals and turns -0 into 0, so the examples print stable
// output across architectures.
func round(v float64) float64 {
	r := math.Round(v*1e4) / 1e4
	if r == 0 {
		return 0
	}
	return r
}

func roundC(x []complex128) []complex128 {
	out := make([]complex128, len(x))
	for i, v := range x {
		out[i] = complex(round(real(v)), round(imag(v)))
	}
	return out
}

func main() {
	r := []float64{1, 2, 3}
	// Zero-pad to 4 points: 4/2+1 = 3 bins.
	fmt.Println(roundC(fft.RFFTWith(r, fft.Options{N: 4})))
}

Output:
[(6+0i) (-2-2i) (2+0i)]

func Spectrogram ¶

func Spectrogram(x []float64, segment, overlap int, window []float64, d float64) [][]float64

Spectrogram computes a sequence of one-sided power spectra over successive, optionally overlapping segments of the real signal x, the building block of a time–frequency display. segment is the segment length (window size) and overlap is the number of samples shared between consecutive segments (0 <= overlap < segment). Each segment is multiplied by window (which must have length segment) before its PSD is taken.

The return value is a slice of frames, each a []float64 of length segment/2+1 (the RFFTFreq(segment, d) axis); frame t covers samples [t·step, t·step+segment) with step = segment-overlap. Segments are taken only while a full window fits, so trailing samples shorter than segment are dropped (the common STFT convention). The input is not modified.

Spectrogram panics if segment <= 0, len(window) != segment, or overlap is out of range, mirroring the contract of scipy.signal.spectrogram.