CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-pyfftw

A pythonic wrapper around FFTW, the FFT library, presenting a unified interface for all the supported transforms.

—

Pending
Overview
Eval results
Files

numpy-fft-interface.mddocs/

numpy.fft Interface

Drop-in replacement for numpy.fft functions with additional optimization parameters, enabling existing code to benefit from FFTW performance with minimal changes. This interface maintains full API compatibility while adding FFTW-specific performance options.

Capabilities

Complex FFT Functions

Core complex-to-complex transform functions compatible with numpy.fft.

def fft(
    a, 
    n=None, 
    axis=-1, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    1D discrete Fourier transform.
    
    Parameters:
    - a: Input array
    - n: Length of transform (default: a.shape[axis])  
    - axis: Axis over which to compute FFT (default: -1)
    - norm: Normalization mode ('backward', 'ortho', 'forward', None)
    - overwrite_input: Whether input can be overwritten (default: False)
    - planner_effort: FFTW planning effort (default: 'FFTW_ESTIMATE')
    - threads: Number of threads (default: 1)
    - auto_align_input: Auto-align input for SIMD (default: True)
    - auto_contiguous: Make input contiguous (default: True)
    
    Returns:
    - Complex array containing the transform
    """

def ifft(
    a, 
    n=None, 
    axis=-1, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    1D inverse discrete Fourier transform.
    
    Parameters: Same as fft()
    
    Returns:
    - Complex array containing the inverse transform
    """

def fft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    2D discrete Fourier transform.
    
    Parameters:
    - a: Input array
    - s: Shape of transform (default: a.shape[axes])
    - axes: Axes over which to compute FFT (default: (-2, -1))
    - Other parameters: Same as fft()
    
    Returns:
    - Complex array containing the 2D transform
    """

def ifft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    2D inverse discrete Fourier transform.
    
    Parameters: Same as fft2()
    
    Returns:
    - Complex array containing the 2D inverse transform
    """

def fftn(
    a, 
    s=None, 
    axes=None, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    N-dimensional discrete Fourier transform.
    
    Parameters:
    - a: Input array
    - s: Shape of transform (default: a.shape[axes])
    - axes: Axes over which to compute FFT (default: all axes)
    - Other parameters: Same as fft()
    
    Returns:
    - Complex array containing the N-D transform
    """

def ifftn(
    a, 
    s=None, 
    axes=None, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    N-dimensional inverse discrete Fourier transform.
    
    Parameters: Same as fftn()
    
    Returns:
    - Complex array containing the N-D inverse transform
    """

Real FFT Functions

Real-to-complex and complex-to-real transform functions.

def rfft(
    a, 
    n=None, 
    axis=-1, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    1D real-to-complex discrete Fourier transform.
    
    Parameters: Same as fft()
    
    Returns:
    - Complex array with shape [..., n//2 + 1] along transform axis
    """

def irfft(
    a, 
    n=None, 
    axis=-1, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    1D complex-to-real inverse discrete Fourier transform.
    
    Parameters: Same as fft()
    
    Returns:
    - Real array with specified length n along transform axis
    """

def rfft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    2D real-to-complex discrete Fourier transform.
    
    Parameters: Same as fft2()
    
    Returns:
    - Complex array with last axis shape s[-1]//2 + 1
    """

def irfft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    2D complex-to-real inverse discrete Fourier transform.
    
    Parameters: Same as fft2()
    
    Returns:
    - Real array with specified shape s
    """

def rfftn(
    a, 
    s=None, 
    axes=None, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    N-dimensional real-to-complex discrete Fourier transform.
    
    Parameters: Same as fftn()
    
    Returns:
    - Complex array with last transform axis shape s[-1]//2 + 1
    """

def irfftn(
    a, 
    s=None, 
    axes=None, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    N-dimensional complex-to-real inverse discrete Fourier transform.
    
    Parameters: Same as fftn()
    
    Returns:
    - Real array with specified shape s
    """

Hermitian FFT Functions

Functions for transforms of Hermitian (conjugate-symmetric) data.

def hfft(
    a, 
    n=None, 
    axis=-1, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    FFT of Hermitian (conjugate-symmetric) sequence.
    
    Parameters: Same as fft()
    
    Returns:
    - Real array containing the transform
    """

def ihfft(
    a, 
    n=None, 
    axis=-1, 
    norm=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True
):
    """
    Inverse FFT of Hermitian sequence.
    
    Parameters: Same as fft()
    
    Returns:
    - Complex array containing the inverse transform
    """

Usage Examples

Drop-in Replacement

# Original numpy code
import numpy as np

data = np.random.randn(1024) + 1j * np.random.randn(1024)
result_numpy = np.fft.fft(data)

# Replace with pyFFTW - same interface, better performance
from pyfftw.interfaces import numpy_fft

result_pyfftw = numpy_fft.fft(data)
print(f"Results match: {np.allclose(result_numpy, result_pyfftw)}")

Optimized Parameters

from pyfftw.interfaces import numpy_fft
import numpy as np

# Use additional performance parameters
data = np.random.randn(1024, 512) + 1j * np.random.randn(1024, 512)

# Standard call with optimization
result = numpy_fft.fft2(
    data,
    overwrite_input=True,     # Allow input modification
    planner_effort='FFTW_MEASURE',  # Better planning
    threads=4,                # Use multiple threads
    auto_align_input=True     # Ensure optimal alignment
)

Real Data Processing

from pyfftw.interfaces import numpy_fft
import numpy as np

# Process real signal
signal = np.random.randn(2048)

# Real-to-complex transform
spectrum = numpy_fft.rfft(signal, planner_effort='FFTW_PATIENT')
print(f"Signal shape: {signal.shape}")
print(f"Spectrum shape: {spectrum.shape}")  # (1025,) - n//2 + 1

# Modify spectrum (e.g., filtering)
spectrum[100:] = 0  # Low-pass filter

# Transform back to real
filtered_signal = numpy_fft.irfft(spectrum, n=len(signal))
print(f"Filtered signal shape: {filtered_signal.shape}")

2D Image Processing

from pyfftw.interfaces import numpy_fft
import numpy as np

# Process 2D image data
image = np.random.randn(512, 512)

# 2D real FFT for image processing
freq_domain = numpy_fft.rfft2(
    image, 
    threads=2,
    auto_align_input=True
)

# Apply frequency domain filter
center_y, center_x = np.array(freq_domain.shape) // 2
y, x = np.ogrid[:freq_domain.shape[0], :freq_domain.shape[1]]
mask = (y - center_y)**2 + (x - center_x)**2 > 50**2
freq_domain[mask] = 0

# Transform back
filtered_image = numpy_fft.irfft2(freq_domain, s=image.shape)

Normalization Modes

from pyfftw.interfaces import numpy_fft
import numpy as np

data = np.random.randn(128) + 1j * np.random.randn(128)

# Different normalization modes
forward = numpy_fft.fft(data, norm='forward')    # 1/n scaling on forward
backward = numpy_fft.fft(data, norm='backward')  # 1/n scaling on inverse (default)
ortho = numpy_fft.fft(data, norm='ortho')        # 1/sqrt(n) scaling on both

# Verify orthogonal normalization preserves energy
print(f"Original energy: {np.sum(np.abs(data)**2)}")
print(f"Ortho energy: {np.sum(np.abs(ortho)**2)}")

N-D Processing

from pyfftw.interfaces import numpy_fft
import numpy as np

# 3D volume data
volume = np.random.randn(64, 64, 64) + 1j * np.random.randn(64, 64, 64)

# Transform only specific axes
result_2d = numpy_fft.fftn(volume, axes=(0, 2))  # Transform first and last axes
result_all = numpy_fft.fftn(volume)              # Transform all axes

print(f"2D transform shape: {result_2d.shape}")
print(f"3D transform shape: {result_all.shape}")

Install with Tessl CLI

npx tessl i tessl/pypi-pyfftw

docs

configuration-utilities.md

core-fftw.md

fft-builders.md

index.md

interfaces-cache.md

memory-management.md

numpy-fft-interface.md

scipy-fft-interface.md

scipy-fftpack-interface.md

wisdom-management.md

tile.json