tenflowers-core 0.1.1

//! GPU FFT kernel implementations
//!
//! This module provides GPU-accelerated FFT operations using WGPU compute shaders
//! for 1D, 2D, and 3D transforms with optimized kernel dispatch.

// NOTE(v0.2): Add back imports when GPU FFT kernels are implemented
#[allow(unused_imports)]
use crate::{Result, Tensor, TensorError};
#[allow(unused_imports)]
use num_complex::Complex;
#[allow(unused_imports)]
use scirs2_core::numeric::{Float, FromPrimitive, Signed};
#[allow(unused_imports)]
use std::fmt::Debug;

// NOTE(v0.2): Add back imports when GPU FFT kernels are implemented
#[cfg(feature = "gpu")]
use wgpu::util::DeviceExt;

// NOTE(v0.2): Move complete GPU implementation from original fft.rs (lines 700-2879, ~2179 lines)
// This includes:
// - gpu_fft_dispatch, gpu_ifft_dispatch, gpu_rfft_dispatch
// - gpu_fft2_dispatch, gpu_ifft2_dispatch
// - gpu_fft3_dispatch, gpu_ifft3_dispatch
// - FFTInfo struct and WGPU buffer management
// - Compute shader creation and execution
// - Power-of-2 optimization and bit reversal

/// FFT info structure for GPU kernels
#[cfg(feature = "gpu")]
#[repr(C)]
#[derive(Debug, Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub struct FFTInfo {
    pub n: u32,
    pub log2_n: u32,
    pub batch_size: u32,
    pub is_inverse: u32,
}

/// GPU dispatch function for 1D FFT
#[cfg(feature = "gpu")]
pub fn gpu_fft_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU FFT dispatch (from original lines 701-820)
    Err(TensorError::unsupported_operation_simple(
        "GPU FFT dispatch not yet implemented in refactored module".to_string(),
    ))
}

/// GPU dispatch function for 1D inverse FFT
#[cfg(feature = "gpu")]
pub fn gpu_ifft_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU IFFT dispatch
    Err(TensorError::unsupported_operation_simple(
        "GPU IFFT dispatch not yet implemented in refactored module".to_string(),
    ))
}

/// GPU dispatch function for 1D real FFT
#[cfg(feature = "gpu")]
pub fn gpu_rfft_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU RFFT dispatch
    Err(TensorError::unsupported_operation_simple(
        "GPU RFFT dispatch not yet implemented in refactored module".to_string(),
    ))
}

/// GPU dispatch function for 2D FFT
#[cfg(feature = "gpu")]
pub fn gpu_fft2_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU 2D FFT dispatch
    Err(TensorError::unsupported_operation_simple(
        "GPU 2D FFT dispatch not yet implemented in refactored module".to_string(),
    ))
}

/// GPU dispatch function for 2D inverse FFT
#[cfg(feature = "gpu")]
pub fn gpu_ifft2_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU 2D IFFT dispatch
    Err(TensorError::unsupported_operation_simple(
        "GPU 2D IFFT dispatch not yet implemented in refactored module".to_string(),
    ))
}

/// GPU dispatch function for 3D FFT
#[cfg(feature = "gpu")]
pub fn gpu_fft3_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU 3D FFT dispatch
    Err(TensorError::unsupported_operation_simple(
        "GPU 3D FFT dispatch not yet implemented in refactored module".to_string(),
    ))
}

/// GPU dispatch function for 3D inverse FFT
#[cfg(feature = "gpu")]
pub fn gpu_ifft3_dispatch<T>(
    gpu_buffer: &crate::gpu::buffer::GpuBuffer<T>,
    shape: &[usize],
) -> Result<Tensor<Complex<T>>>
where
    T: Float
        + Send
        + Sync
        + 'static
        + FromPrimitive
        + Signed
        + Debug
        + Default
        + bytemuck::Pod
        + bytemuck::Zeroable,
    Complex<T>: Default + bytemuck::Pod + bytemuck::Zeroable,
{
    // NOTE(v0.2): Implement complete GPU 3D IFFT dispatch
    Err(TensorError::unsupported_operation_simple(
        "GPU 3D IFFT dispatch not yet implemented in refactored module".to_string(),
    ))
}