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

FFT Builders

Name: tessl/pypi-pyfftw
Author: tessl

High-level functions that create FFTW objects with numpy-like signatures, supporting complex and real transforms in 1D, 2D, and N-D variants. These functions provide a convenient middle ground between the direct FFTW interface and the drop-in replacement interfaces.

Capabilities

1D Transform Builders

Functions that create FFTW objects for 1D transforms.

def fft(
    a, 
    n=None, 
    axis=-1, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 1D complex-to-complex FFT.
    
    Parameters:
    - a: Input array
    - n: Length of transform (default: a.shape[axis])
    - axis: Axis over which to compute FFT (default: -1)
    - overwrite_input: Whether to overwrite input (default: False)
    - planner_effort: FFTW planner 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)
    - avoid_copy: Avoid copying when possible (default: False)
    - norm: Normalization mode (default: None)
    
    Returns:
    - FFTW object that performs the transform
    """

def ifft(
    a, 
    n=None, 
    axis=-1, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 1D inverse complex-to-complex FFT.
    
    Parameters: Same as fft()
    
    Returns:
    - FFTW object that performs the inverse transform
    """

def rfft(
    a, 
    n=None, 
    axis=-1, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 1D real-to-complex FFT.
    
    Parameters: Same as fft()
    
    Returns:
    - FFTW object that performs real-to-complex transform
    """

def irfft(
    a, 
    n=None, 
    axis=-1, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 1D complex-to-real FFT.
    
    Parameters: Same as fft()
    
    Returns:
    - FFTW object that performs complex-to-real transform
    """

2D Transform Builders

Functions that create FFTW objects for 2D transforms.

def fft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 2D complex-to-complex FFT.
    
    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:
    - FFTW object that performs 2D transform
    """

def ifft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 2D inverse complex-to-complex FFT.
    
    Parameters: Same as fft2()
    
    Returns:
    - FFTW object that performs 2D inverse transform
    """

def rfft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 2D real-to-complex FFT.
    
    Parameters: Same as fft2()
    
    Returns:
    - FFTW object that performs 2D real-to-complex transform
    """

def irfft2(
    a, 
    s=None, 
    axes=(-2, -1), 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for 2D complex-to-real FFT.
    
    Parameters: Same as fft2()
    
    Returns:
    - FFTW object that performs 2D complex-to-real transform
    """

N-D Transform Builders

Functions that create FFTW objects for N-dimensional transforms.

def fftn(
    a, 
    s=None, 
    axes=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for N-D complex-to-complex FFT.
    
    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:
    - FFTW object that performs N-D transform
    """

def ifftn(
    a, 
    s=None, 
    axes=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for N-D inverse complex-to-complex FFT.
    
    Parameters: Same as fftn()
    
    Returns:
    - FFTW object that performs N-D inverse transform
    """

def rfftn(
    a, 
    s=None, 
    axes=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for N-D real-to-complex FFT.
    
    Parameters: Same as fftn()
    
    Returns:
    - FFTW object that performs N-D real-to-complex transform
    """

def irfftn(
    a, 
    s=None, 
    axes=None, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None
):
    """
    Return an FFTW object for N-D complex-to-real FFT.
    
    Parameters: Same as fftn()
    
    Returns:
    - FFTW object that performs N-D complex-to-real transform
    """

Discrete Cosine/Sine Transform Builders

Functions for creating discrete cosine and sine transform objects.

def dct(
    a, 
    n=None, 
    axis=-1, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None, 
    type=2
):
    """
    Return an FFTW object for discrete cosine transform.
    
    Parameters:
    - type: DCT type (1, 2, 3, or 4)
    - Other parameters: Same as fft()
    
    Returns:
    - FFTW object that performs DCT
    """

def dst(
    a, 
    n=None, 
    axis=-1, 
    overwrite_input=False, 
    planner_effort='FFTW_ESTIMATE', 
    threads=1, 
    auto_align_input=True, 
    auto_contiguous=True, 
    avoid_copy=False, 
    norm=None, 
    type=2
):
    """
    Return an FFTW object for discrete sine transform.
    
    Parameters:
    - type: DST type (1, 2, 3, or 4)
    - Other parameters: Same as fft()
    
    Returns:
    - FFTW object that performs DST
    """

Usage Examples

Basic 1D Transform

import numpy as np
import pyfftw.builders as builders

# Create input data
a = np.random.randn(1024) + 1j * np.random.randn(1024)

# Create FFTW object
fft_obj = builders.fft(a, planner_effort='FFTW_MEASURE', threads=4)

# Execute transform multiple times
for i in range(10):
    # Update input data
    a[:] = np.random.randn(1024) + 1j * np.random.randn(1024)
    
    # Execute (reuses existing plan)
    result = fft_obj(a)

2D Real-to-Complex Transform

import numpy as np
import pyfftw.builders as builders

# Create real input data
real_data = np.random.randn(512, 256)

# Create FFTW object for 2D real FFT
rfft2_obj = builders.rfft2(
    real_data, 
    planner_effort='FFTW_PATIENT',
    threads=2,
    auto_align_input=True
)

# Execute transform
result = rfft2_obj()
print(f"Input shape: {real_data.shape}")
print(f"Output shape: {result.shape}")  # (512, 129) - note the reduced last dimension

N-D Transform with Custom Axes

import numpy as np
import pyfftw.builders as builders

# Create 4D data
data = np.random.randn(64, 32, 128, 256) + 1j * np.random.randn(64, 32, 128, 256)

# Transform only the last two dimensions
fftn_obj = builders.fftn(
    data, 
    axes=(-2, -1),
    planner_effort='FFTW_MEASURE',
    threads=4
)

result = fftn_obj()
print(f"Transformed axes: {(-2, -1)}")
print(f"Result shape: {result.shape}")  # Same as input shape

Discrete Cosine Transform

import numpy as np
import pyfftw.builders as builders

# Create real data
data = np.random.randn(1024)

# Create DCT-II object (most common type)
dct_obj = builders.dct(data, type=2, planner_effort='FFTW_MEASURE')

# Execute DCT
result = dct_obj()

# Create inverse DCT (DCT-III)
idct_obj = builders.dct(result, type=3, planner_effort='FFTW_MEASURE')
reconstructed = idct_obj() / len(data)  # Normalize for perfect reconstruction

print(f"Reconstruction error: {np.max(np.abs(data - reconstructed))}")

Performance Optimization

import numpy as np
import pyfftw.builders as builders
import time

# Create large dataset
N = 1024 * 1024
data = np.random.randn(N) + 1j * np.random.randn(N)

# Compare different planning efforts
efforts = ['FFTW_ESTIMATE', 'FFTW_MEASURE', 'FFTW_PATIENT']
results = {}

for effort in efforts:
    # Time planning
    start = time.time()
    fft_obj = builders.fft(data, planner_effort=effort, threads=4)
    plan_time = time.time() - start
    
    # Time execution
    start = time.time()
    for _ in range(100):
        result = fft_obj()
    exec_time = time.time() - start
    
    results[effort] = {'plan': plan_time, 'exec': exec_time}
    print(f"{effort}: Plan {plan_time:.3f}s, Execute {exec_time:.3f}s")

Install with Tessl CLI