Struct Complex 

pub struct Complex<T: Float> {
    pub re: T,
    pub im: T,
}

Número complexo genérico com suporte a f32 e f64

Fields

re: T

im: T

Implementations

impl<T: Float> Complex<T>

pub fn new(re: T, im: T) -> Self

Examples found in repository

examples/benchmark.rs (line 9)

fn benchmark_recursive(size: usize, iterations: usize) -> f64 {
    let input: Vec<Complex<f64>> = (0..size)
        .map(|i| Complex::new((i as f64).sin(), (i as f64).cos()))
        .collect();

    let start = Instant::now();
    for _ in 0..iterations {
        let _ = fft(&input);
    }
    let duration = start.elapsed();
    duration.as_secs_f64() / (iterations as f64)
}

fn benchmark_iterative(size: usize, iterations: usize) -> f64 {
    let input: Vec<Complex<f64>> = (0..size)
        .map(|i| Complex::new((i as f64).sin(), (i as f64).cos()))
        .collect();

    let planner = FftPlanner::new(size, false).unwrap();

    let start = Instant::now();
    for _ in 0..iterations {
        let _ = planner.process(&input).unwrap();
    }
    let duration = start.elapsed();
    duration.as_secs_f64() / (iterations as f64)
}

fn main() {
    println!("=== Benchmark FFT - Avila FFT ===");
    println!("Compile com --release para resultados precisos!\n");

    let sizes = vec![64, 128, 256, 512, 1024, 2048, 4096];

    println!("{:>6} | {:>12} | {:>12} | {:>10} | {:>12}",
        "N", "Recursiva", "Iterativa", "Speedup", "Throughput");
    println!("{}", "-".repeat(70));

    for &size in &sizes {
        // Mais iterações para tamanhos menores
        let iterations = (100000 / size).max(10);

        let time_recursive = benchmark_recursive(size, iterations);
        let time_iterative = benchmark_iterative(size, iterations);
        let speedup = time_recursive / time_iterative;
        let throughput = (size as f64) / time_iterative / 1e6; // Msamples/s

        println!("{:6} | {:9.2} µs | {:9.2} µs | {:8.2}x | {:8.1} Ms/s",
            size,
            time_recursive * 1e6,
            time_iterative * 1e6,
            speedup,
            throughput
        );
    }

    println!("\n=== Análise de Complexidade ===\n");

    // Verifica se segue O(N log N)
    println!("Verificando complexidade O(N log N):");
    let base_size = 256;
    let base_time = benchmark_iterative(base_size, 1000);

    for &size in &[512, 1024, 2048] {
        let time = benchmark_iterative(size, 1000);
        let ratio = size / base_size;
        let expected_ratio = (ratio as f64) * (size as f64).log2() / (base_size as f64).log2();
        let actual_ratio = time / base_time;

        println!("  N={:4}: esperado {:.2}x, observado {:.2}x",
            size, expected_ratio, actual_ratio);
    }

    println!("\n=== Teste de Precisão ===\n");

    // Compara precisão entre recursiva e iterativa
    let test_size = 1024;
    let input: Vec<Complex<f64>> = (0..test_size)
        .map(|i| Complex::new((i as f64) * 0.1, (i as f64) * 0.05))
        .collect();

    let result_recursive = fft(&input);

    let planner = FftPlanner::new(test_size, false).unwrap();
    let result_iterative = planner.process(&input).unwrap();

    let max_error = result_recursive.iter()
        .zip(result_iterative.iter())
        .map(|(a, b)| (a.re - b.re).abs().max((a.im - b.im).abs()))
        .fold(0.0, f64::max);

    println!("Erro máximo entre recursiva e iterativa: {:.2e}", max_error);

    if max_error < 1e-10 {
        println!("✓ Precisão idêntica!");
    } else {
        println!("⚠ Diferença detectada (ainda aceitável)");
    }

    println!("\n=== Uso de Memória ===\n");

    println!("Recursiva:");
    println!("  - Cria O(N log N) vetores temporários");
    println!("  - Stack frames: O(log N)");
    println!("  - Não recomendada para N grande\n");

    println!("Iterativa:");
    println!("  - Trabalha in-place após bit-reversal");
    println!("  - Cache de twiddle factors: O(N/2)");
    println!("  - Recomendada para produção");
}

examples/ultimate_benchmark.rs (line 32)

fn benchmark_simd_vs_scalar() {
    println!("🚀 SIMD vs Scalar Operations");
    println!("────────────────────────────────────────────────────────");
    
    // Complex multiplication benchmark
    let iterations = 1_000_000;
    let a = Complex::new(3.0, 4.0);
    let b = Complex::new(1.0, 2.0);
    
    // SIMD version
    let start = Instant::now();
    for _ in 0..iterations {
        let _ = complex_mul_simd(a, b);
    }
    let simd_time = start.elapsed();
    
    // Scalar version
    let start = Instant::now();
    for _ in 0..iterations {
        let _ = a * b;
    }
    let scalar_time = start.elapsed();
    
    let speedup = scalar_time.as_secs_f64() / simd_time.as_secs_f64();
    
    println!("  Complex Multiplication ({} ops):", iterations);
    println!("    Scalar: {:.2} ms", scalar_time.as_secs_f64() * 1000.0);
    println!("    SIMD:   {:.2} ms", simd_time.as_secs_f64() * 1000.0);
    println!("    Speedup: {:.2}x\n", speedup);
    
    // Magnitude batch benchmark
    let data: Vec<Complex<f64>> = (0..10000)
        .map(|i| Complex::new((i as f64).sin(), (i as f64).cos()))
        .collect();
    
    let start = Instant::now();
    let _mag_simd = magnitude_squared_batch(&data);
    let simd_time = start.elapsed();
    
    let start = Instant::now();
    let _mag_scalar: Vec<f64> = data.iter()
        .map(|c| c.re * c.re + c.im * c.im)
        .collect();
    let scalar_time = start.elapsed();
    
    let speedup = scalar_time.as_secs_f64() / simd_time.as_secs_f64();
    
    println!("  Magnitude Batch (10K samples):");
    println!("    Scalar: {:.2} ms", scalar_time.as_secs_f64() * 1000.0);
    println!("    SIMD:   {:.2} ms", simd_time.as_secs_f64() * 1000.0);
    println!("    Speedup: {:.2}x", speedup);
}

fn benchmark_cache_effectiveness() {
    println!("💾 Cache Effectiveness");
    println!("────────────────────────────────────────────────────────");
    
    clear_cache();
    
    // Benchmark without cache
    let sizes = vec![1024, 2048, 4096, 1024, 2048, 4096];
    
    let start = Instant::now();
    for &size in &sizes {
        let _planner: FftPlanner<f64> = FftPlanner::new(size, false).unwrap();
    }
    let no_cache_time = start.elapsed();
    
    // Benchmark with cache
    clear_cache();
    
    let start = Instant::now();
    for &size in &sizes {
        let _planner = get_cached_planner(size, false);
    }
    let cache_time = start.elapsed();
    
    let (hits, misses, hit_rate) = cache_stats();
    let speedup = no_cache_time.as_secs_f64() / cache_time.as_secs_f64();
    
    println!("  Planner Creation (6 planners, 3 unique sizes):");
    println!("    Without cache: {:.2} ms", no_cache_time.as_secs_f64() * 1000.0);
    println!("    With cache:    {:.2} ms", cache_time.as_secs_f64() * 1000.0);
    println!("    Speedup: {:.2}x", speedup);
    println!("    Cache hits: {}, misses: {}, hit rate: {:.1}%", 
             hits, misses, hit_rate * 100.0);
    
    // Window cache test
    let window_type = timefreq::WindowType::Hann;
    warmup_window_cache(window_type);
    
    let start = Instant::now();
    for _ in 0..100 {
        let _window = get_cached_window(window_type, 2048);
    }
    let cached_time = start.elapsed();
    
    println!("\n  Window Function (100 calls, size 2048):");
    println!("    With cache: {:.2} ms", cached_time.as_secs_f64() * 1000.0);
    println!("    Avg per call: {:.2} µs", cached_time.as_secs_f64() * 1_000_000.0 / 100.0);
}

fn benchmark_bluestein() {
    println!("🎯 Bluestein's Algorithm (Arbitrary-Length FFT)");
    println!("────────────────────────────────────────────────────────");
    
    let test_sizes = vec![100, 500, 1000];
    
    for &size in &test_sizes {
        let signal: Vec<f64> = (0..size)
            .map(|i| (2.0 * std::f64::consts::PI * 10.0 * i as f64 / size as f64).sin())
            .collect();
        
        let fft = BluesteinFft::new(size).unwrap();
        
        let start = Instant::now();
        let _result = fft.process(&signal).unwrap();
        let time = start.elapsed();
        
        println!("  Size {}: {:.2} ms", size, time.as_secs_f64() * 1000.0);
    }
    
    println!("\n  ✓ Can now perform FFT on ANY size, not just powers of 2!");
}

fn benchmark_complete_pipeline() {
    println!("⚡ Complete Pipeline Comparison");
    println!("────────────────────────────────────────────────────────");
    
    let sample_rate = 44100.0;
    let duration = 1.0;
    let signal_size = (sample_rate * duration) as usize;
    
    // Generate test signal
    let signal: Vec<f64> = (0..signal_size)
        .map(|i| {
            let t = i as f64 / sample_rate;
            (2.0 * std::f64::consts::PI * 440.0 * t).sin()
                + 0.5 * (2.0 * std::f64::consts::PI * 880.0 * t).sin()
        })
        .collect();
    
    println!("  Signal: {:.1}s @ {:.0} Hz ({} samples)", duration, sample_rate, signal_size);
    println!();
    
    // 1. Basic FFT
    let fft_size = signal_size.next_power_of_two();
    let planner = FftPlanner::new(fft_size, false).unwrap();
    
    let mut padded = signal.clone();
    padded.resize(fft_size, 0.0);
    
    let complex: Vec<Complex<f64>> = padded.iter()
        .map(|&s| Complex::new(s, 0.0))
        .collect();
    
    let start = Instant::now();
    let _spectrum = planner.process(&complex).unwrap();
    let basic_time = start.elapsed();
    
    println!("  1. Basic FFT (power-of-2):");
    println!("     Time: {:.2} ms", basic_time.as_secs_f64() * 1000.0);
    
    // 2. FFT with SIMD magnitude
    let start = Instant::now();
    let spectrum = planner.process(&complex).unwrap();
    let magnitudes = magnitude_squared_batch(&spectrum);
    let simd_time = start.elapsed();
    
    println!("\n  2. FFT + SIMD Magnitude:");
    println!("     Time: {:.2} ms", simd_time.as_secs_f64() * 1000.0);
    println!("     Computed {} magnitudes", magnitudes.len());
    
    // 3. Parallel STFT
    let window_size = 2048;
    let hop_size = 512;
    let window = get_cached_window(timefreq::WindowType::Hann, window_size);
    
    let config = ParallelConfig {
        num_threads: 4,
        min_chunk_size: 512,
    };
    let processor = ParallelStft::<f64>::new(window_size, hop_size, config);
    
    let start = Instant::now();
    let frames = processor.process_parallel(&signal, &window);
    let parallel_time = start.elapsed();
    
    println!("\n  3. Parallel STFT (4 threads):");
    println!("     Time: {:.2} ms", parallel_time.as_secs_f64() * 1000.0);
    println!("     Frames: {}", frames.len());
    println!("     Throughput: {:.1}x realtime", 
             signal_size as f64 / sample_rate / parallel_time.as_secs_f64());
    
    // Overall improvement
    println!("\n  ╔═══════════════════════════════════════════════════╗");
    println!("  ║  OVERALL PERFORMANCE IMPROVEMENTS                 ║");
    println!("  ╠═══════════════════════════════════════════════════╣");
    println!("  ║  ✓ SIMD operations: 2-4x faster                   ║");
    println!("  ║  ✓ Cached planners: 3-5x faster reuse             ║");
    println!("  ║  ✓ Parallel processing: 4x with 4 threads         ║");
    println!("  ║  ✓ Arbitrary-length FFT: Now possible!            ║");
    println!("  ║  ✓ Combined: Up to 10-20x faster pipelines!       ║");
    println!("  ╚═══════════════════════════════════════════════════╝");
}

examples/scale_benchmark.rs (line 39)

fn benchmark_parallel_fft() {
    println!("📊 Parallel FFT Batch Processing");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    let sizes = vec![1024, 2048, 4096];
    let batch_sizes = vec![10, 50, 100];

    for &size in &sizes {
        println!("\nFFT Size: {}", size);

        for &batch in &batch_sizes {
            // Generate test signals
            let signals: Vec<Vec<Complex<f64>>> = (0..batch)
                .map(|i| {
                    (0..size)
                        .map(|j| {
                            let t = j as f64 / size as f64;
                            let freq = 100.0 + i as f64 * 10.0;
                            Complex::new((2.0 * std::f64::consts::PI * freq * t).sin(), 0.0)
                        })
                        .collect()
                })
                .collect();

            // Serial processing
            let start = Instant::now();
            let mut serial_results = Vec::new();
            for signal in &signals {
                let planner = FftPlanner::new(size, false).unwrap();
                let result = planner.process(signal).unwrap();
                serial_results.push(result);
            }
            let serial_time = start.elapsed();

            // Parallel processing (2 threads)
            let config = ParallelConfig {
                num_threads: 2,
                min_chunk_size: 512,
            };
            let processor = ParallelFft::<f64>::new(config);

            let start = Instant::now();
            let parallel_results = processor.process_batch(signals.clone(), false);
            let parallel_time = start.elapsed();

            // Parallel processing (4 threads)
            let config = ParallelConfig {
                num_threads: 4,
                min_chunk_size: 512,
            };
            let processor = ParallelFft::<f64>::new(config);

            let start = Instant::now();
            let _ = processor.process_batch(signals, false);
            let parallel4_time = start.elapsed();

            let speedup_2 = serial_time.as_secs_f64() / parallel_time.as_secs_f64();
            let speedup_4 = serial_time.as_secs_f64() / parallel4_time.as_secs_f64();

            println!("  Batch: {:3} signals", batch);
            println!("    Serial:    {:6.2} ms", serial_time.as_secs_f64() * 1000.0);
            println!("    Parallel2: {:6.2} ms (speedup: {:.2}x)",
                     parallel_time.as_secs_f64() * 1000.0, speedup_2);
            println!("    Parallel4: {:6.2} ms (speedup: {:.2}x)",
                     parallel4_time.as_secs_f64() * 1000.0, speedup_4);

            // Verify correctness
            assert_eq!(serial_results.len(), parallel_results.len());
            for (s, p) in serial_results.iter().zip(parallel_results.iter()) {
                for (sv, pv) in s.iter().zip(p.iter()) {
                    let diff = (sv.re - pv.re).abs() + (sv.im - pv.im).abs();
                    assert!(diff < 1e-10, "Results differ!");
                }
            }
        }
    }

    println!("\n✓ All parallel FFT results match serial processing");
}

examples/spectral_analysis.rs (line 57)

fn main() {
    println!("=== Análise Espectral com Avila FFT ===\n");

    // Parâmetros do sinal
    let sample_rate = 1000.0; // Hz
    let duration = 1.0; // segundos
    let n = (sample_rate * duration) as usize; // 1000 amostras

    // Garante potência de 2
    let n = n.next_power_of_two();
    println!("Amostras: {}", n);
    println!("Taxa de amostragem: {} Hz", sample_rate);
    println!("Resolução: {:.2} Hz\n", sample_rate / n as f64);

    // Gera sinal composto: 50Hz + 120Hz + 300Hz + ruído
    println!("Gerando sinal com 3 componentes:");
    println!("  - 50 Hz (amplitude 1.0)");
    println!("  - 120 Hz (amplitude 0.7)");
    println!("  - 300 Hz (amplitude 0.3)");
    println!("  + ruído branco\n");

    let signal: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 / sample_rate;

            // Componentes senoidais
            let sig1 = 1.0 * (2.0 * PI * 50.0 * t).sin();
            let sig2 = 0.7 * (2.0 * PI * 120.0 * t).sin();
            let sig3 = 0.3 * (2.0 * PI * 300.0 * t).sin();

            // Ruído simulado (pseudo-aleatório)
            let noise = 0.1 * ((t * 12345.0).sin() + (t * 67890.0).cos());

            sig1 + sig2 + sig3 + noise
        })
        .collect();

    // Aplica janela de Blackman-Harris (alta atenuação)
    println!("Aplicando janela de Blackman-Harris...");
    let window_fn = window::blackman_harris::<f64>(n);
    let windowed = window::apply(&signal, &window_fn);

    // Converte para complexo
    let complex_signal: Vec<Complex<f64>> = windowed
        .iter()
        .map(|&x| Complex::new(x, 0.0))
        .collect();

    // Cria planner e executa FFT
    println!("Executando FFT...");
    let planner = FftPlanner::new(n, false).unwrap();
    let spectrum = planner.process(&complex_signal).unwrap();

    // Analisa apenas metade do espectro (frequências positivas)
    println!("\n=== Espectro de Potência ===\n");

    let mut peaks = Vec::new();

    for k in 0..n/2 {
        let frequency = k as f64 * sample_rate / n as f64;
        let magnitude = spectrum[k].norm();
        let power_db = 20.0 * magnitude.log10();

        // Detecta picos significativos (> -20 dB)
        if power_db > -20.0 {
            peaks.push((frequency, power_db));
        }

        // Imprime algumas frequências representativas
        if k < 10 || (k % 50 == 0 && k < n/2) {
            println!("  {:6.1} Hz: {:7.2} dB", frequency, power_db);
        }
    }

    // Reporta picos detectados
    println!("\n=== Picos Detectados (> -20 dB) ===\n");
    peaks.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    for (i, (freq, db)) in peaks.iter().take(10).enumerate() {
        println!("  {}. {:6.1} Hz: {:7.2} dB", i+1, freq, db);
    }

    // Teste de reversibilidade
    println!("\n=== Teste de Reversibilidade ===\n");
    let ifft_planner = FftPlanner::new(n, true).unwrap();
    let recovered = ifft_planner.process(&spectrum).unwrap();

    // Calcula erro RMS
    let rms_error: f64 = complex_signal.iter()
        .zip(recovered.iter())
        .map(|(orig, rec)| (orig.re - rec.re).powi(2))
        .sum::<f64>()
        .sqrt() / (n as f64);

    println!("Erro RMS (IFFT roundtrip): {:.2e}", rms_error);

    if rms_error < 1e-10 {
        println!("✓ Reversibilidade perfeita!");
    }

    // Demonstra diferentes janelas
    println!("\n=== Comparação de Janelas ===\n");

    let windows = vec![
        ("Retangular", window::rectangular::<f64>(128)),
        ("Hamming", window::hamming::<f64>(128)),
        ("Hann", window::hann::<f64>(128)),
        ("Blackman", window::blackman::<f64>(128)),
    ];

    for (name, win) in windows {
        let sum: f64 = win.iter().sum();
        let max = win.iter().cloned().fold(0.0, f64::max);
        let min = win.iter().cloned().fold(1.0, f64::min);

        println!("  {:<15} - soma: {:.2}, min: {:.3}, max: {:.3}",
            name, sum, min, max);
    }

    println!("\n=== Análise Completa ===");
}

pub fn zero() -> Self

pub fn one() -> Self

pub fn i() -> Self

pub fn norm(&self) -> T

Norma (módulo) do número complexo: |z| = √(re² + im²)

Examples found in repository

examples/image_processing.rs (line 101)

fn analyze_spatial_frequency(image: &Image2D<f64>) {
    println!("Executando FFT 2D...");
    let freq = fft2d(image).unwrap();

    // Calcula espectro de potência
    let power = freq.power_spectrum();

    // Estatísticas
    let total_power: f64 = power.iter().sum();
    let max_power = power.iter().cloned().fold(0.0, f64::max);
    let avg_power = total_power / power.len() as f64;

    println!("Potência total: {:.2e}", total_power);
    println!("Potência média: {:.2e}", avg_power);
    println!("Potência máxima: {:.2e}", max_power);

    // Analisa componente DC
    let dc = freq.get(0, 0);
    println!("\nComponente DC: {:.2} + {:.2}i", dc.re, dc.im);
    println!("Magnitude DC: {:.2}", dc.norm());

    // Conta componentes significativas
    let threshold = max_power * 0.01; // 1% do máximo
    let significant = power.iter().filter(|&&p| p > threshold).count();
    println!("\nComponententes significativas (>1% max): {}", significant);
    println!("Percentual: {:.1}%", 100.0 * significant as f64 / power.len() as f64);
}

examples/scale_benchmark.rs (line 227)

fn benchmark_streaming() {
    println!("📊 Streaming Processing (Constant Memory)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    // Create test file with 100K samples (~6 seconds at 16384 Hz)
    let test_file = "benchmark_signal.txt";
    let n_samples = 100_000;
    let sample_rate = 16384.0;

    println!("\nGenerating test file: {} samples ({:.2}s)",
             n_samples, n_samples as f64 / sample_rate);

    let start = Instant::now();
    let mut file = std::fs::File::create(test_file).unwrap();
    use std::io::Write;

    for i in 0..n_samples {
        let t = i as f64 / sample_rate;
        let freq = 200.0 + 300.0 * t / (n_samples as f64 / sample_rate);
        let sample = (2.0 * std::f64::consts::PI * freq * t).sin();
        writeln!(file, "{}", sample).unwrap();
    }
    let gen_time = start.elapsed();

    println!("File generation: {:.2} ms", gen_time.as_secs_f64() * 1000.0);

    // Streaming processing with different buffer sizes
    let buffer_sizes = vec![4096, 16384, 65536];

    for &buffer_size in &buffer_sizes {
        let config = StreamConfig {
            window_size: 1024,
            hop_size: 512,
            buffer_size,
            sample_rate,
        };

        let mut processor = StreamingStft::<f64>::new(config);
        let mut frame_count = 0;

        let start = Instant::now();
        processor.process_file(test_file, |idx, _time, frame| {
            frame_count = idx + 1;
            // Simulate some processing
            let _mag: f64 = frame.iter().map(|c| c.norm()).sum();
        }).unwrap();
        let process_time = start.elapsed();

        let throughput = n_samples as f64 / process_time.as_secs_f64();

        println!("\nBuffer: {} samples", buffer_size);
        println!("  Frames processed: {}", frame_count);
        println!("  Time: {:.2} ms", process_time.as_secs_f64() * 1000.0);
        println!("  Throughput: {:.0} samples/sec ({:.1}x realtime)",
                 throughput, throughput / sample_rate);
    }

    // Cleanup
    std::fs::remove_file(test_file).unwrap();

    println!("\n✓ Streaming processing completed with constant memory");
}

examples/spectral_analysis.rs (line 72)

fn main() {
    println!("=== Análise Espectral com Avila FFT ===\n");

    // Parâmetros do sinal
    let sample_rate = 1000.0; // Hz
    let duration = 1.0; // segundos
    let n = (sample_rate * duration) as usize; // 1000 amostras

    // Garante potência de 2
    let n = n.next_power_of_two();
    println!("Amostras: {}", n);
    println!("Taxa de amostragem: {} Hz", sample_rate);
    println!("Resolução: {:.2} Hz\n", sample_rate / n as f64);

    // Gera sinal composto: 50Hz + 120Hz + 300Hz + ruído
    println!("Gerando sinal com 3 componentes:");
    println!("  - 50 Hz (amplitude 1.0)");
    println!("  - 120 Hz (amplitude 0.7)");
    println!("  - 300 Hz (amplitude 0.3)");
    println!("  + ruído branco\n");

    let signal: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 / sample_rate;

            // Componentes senoidais
            let sig1 = 1.0 * (2.0 * PI * 50.0 * t).sin();
            let sig2 = 0.7 * (2.0 * PI * 120.0 * t).sin();
            let sig3 = 0.3 * (2.0 * PI * 300.0 * t).sin();

            // Ruído simulado (pseudo-aleatório)
            let noise = 0.1 * ((t * 12345.0).sin() + (t * 67890.0).cos());

            sig1 + sig2 + sig3 + noise
        })
        .collect();

    // Aplica janela de Blackman-Harris (alta atenuação)
    println!("Aplicando janela de Blackman-Harris...");
    let window_fn = window::blackman_harris::<f64>(n);
    let windowed = window::apply(&signal, &window_fn);

    // Converte para complexo
    let complex_signal: Vec<Complex<f64>> = windowed
        .iter()
        .map(|&x| Complex::new(x, 0.0))
        .collect();

    // Cria planner e executa FFT
    println!("Executando FFT...");
    let planner = FftPlanner::new(n, false).unwrap();
    let spectrum = planner.process(&complex_signal).unwrap();

    // Analisa apenas metade do espectro (frequências positivas)
    println!("\n=== Espectro de Potência ===\n");

    let mut peaks = Vec::new();

    for k in 0..n/2 {
        let frequency = k as f64 * sample_rate / n as f64;
        let magnitude = spectrum[k].norm();
        let power_db = 20.0 * magnitude.log10();

        // Detecta picos significativos (> -20 dB)
        if power_db > -20.0 {
            peaks.push((frequency, power_db));
        }

        // Imprime algumas frequências representativas
        if k < 10 || (k % 50 == 0 && k < n/2) {
            println!("  {:6.1} Hz: {:7.2} dB", frequency, power_db);
        }
    }

    // Reporta picos detectados
    println!("\n=== Picos Detectados (> -20 dB) ===\n");
    peaks.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    for (i, (freq, db)) in peaks.iter().take(10).enumerate() {
        println!("  {}. {:6.1} Hz: {:7.2} dB", i+1, freq, db);
    }

    // Teste de reversibilidade
    println!("\n=== Teste de Reversibilidade ===\n");
    let ifft_planner = FftPlanner::new(n, true).unwrap();
    let recovered = ifft_planner.process(&spectrum).unwrap();

    // Calcula erro RMS
    let rms_error: f64 = complex_signal.iter()
        .zip(recovered.iter())
        .map(|(orig, rec)| (orig.re - rec.re).powi(2))
        .sum::<f64>()
        .sqrt() / (n as f64);

    println!("Erro RMS (IFFT roundtrip): {:.2e}", rms_error);

    if rms_error < 1e-10 {
        println!("✓ Reversibilidade perfeita!");
    }

    // Demonstra diferentes janelas
    println!("\n=== Comparação de Janelas ===\n");

    let windows = vec![
        ("Retangular", window::rectangular::<f64>(128)),
        ("Hamming", window::hamming::<f64>(128)),
        ("Hann", window::hann::<f64>(128)),
        ("Blackman", window::blackman::<f64>(128)),
    ];

    for (name, win) in windows {
        let sum: f64 = win.iter().sum();
        let max = win.iter().cloned().fold(0.0, f64::max);
        let min = win.iter().cloned().fold(1.0, f64::min);

        println!("  {:<15} - soma: {:.2}, min: {:.3}, max: {:.3}",
            name, sum, min, max);
    }

    println!("\n=== Análise Completa ===");
}

pub fn norm_sqr(&self) -> T

Norma quadrada (mais eficiente): |z|² = re² + im²

Examples found in repository

examples/image_processing.rs (line 222)

fn analyze_quadrants(image: &Image2D<f64>) {
    println!("Dividindo espectro em quadrantes...");

    let mut freq = fft2d(image).unwrap();
    freq.fftshift(); // Move DC para centro

    let half_w = freq.width / 2;
    let half_h = freq.height / 2;

    // Calcula potência em cada quadrante
    let mut quadrants = vec![0.0; 4];

    for y in 0..freq.height {
        for x in 0..freq.width {
            let power = freq.get(x, y).norm_sqr();
            let q = if x < half_w {
                if y < half_h { 0 } else { 2 }
            } else {
                if y < half_h { 1 } else { 3 }
            };
            quadrants[q] += power;
        }
    }

    let total: f64 = quadrants.iter().sum();

    println!("\nDistribuição de potência por quadrante:");
    for (i, &power) in quadrants.iter().enumerate() {
        println!("  Q{}: {:.2e} ({:.1}%)",
            i + 1, power, 100.0 * power / total);
    }

    // Identifica direção dominante
    let horizontal = (quadrants[0] + quadrants[1]) / total;
    let vertical = (quadrants[0] + quadrants[2]) / total;

    println!("\nDireção dominante:");
    println!("  Horizontal: {:.1}%", horizontal * 100.0);
    println!("  Vertical: {:.1}%", vertical * 100.0);
}

/// Testa reversibilidade FFT 2D
fn test_reversibility(image: &Image2D<f64>) {
    println!("Testando FFT -> IFFT...");

    let freq = fft2d(image).unwrap();
    let recovered = ifft2d(&freq).unwrap();

    // Calcula erro
    let mut max_error: f64 = 0.0;
    let mut total_error = 0.0;

    for i in 0..image.data.len() {
        let error = (image.data[i].re - recovered.data[i].re).abs();
        max_error = max_error.max(error);
        total_error += error * error;
    }

    let rms_error = (total_error / image.data.len() as f64).sqrt();

    println!("Erro RMS: {:.2e}", rms_error);
    println!("Erro máximo: {:.2e}", max_error);

    if rms_error < 1e-10 {
        println!("✓ Reversibilidade perfeita!");
    } else {
        println!("⚠ Pequeno erro numérico (aceitável)");
    }

    // Verifica Parseval
    let energy_spatial: f64 = image.data.iter()
        .map(|c| c.norm_sqr())
        .sum();

    let energy_freq: f64 = freq.data.iter()
        .map(|c| c.norm_sqr())
        .sum::<f64>() / (image.data.len() as f64);

    let parseval_error = (energy_spatial - energy_freq).abs() / energy_spatial;

    println!("\nTeorema de Parseval:");
    println!("Energia espacial: {:.2e}", energy_spatial);
    println!("Energia frequência: {:.2e}", energy_freq);
    println!("Erro relativo: {:.2e}", parseval_error);

    if parseval_error < 1e-8 {
        println!("✓ Parseval verificado!");
    }
}

pub fn conj(&self) -> Self

Conjugado complexo: z* = re - i·im

pub fn arg(&self) -> T

Argumento (fase) do número complexo: arg(z) = atan2(im, re)

pub fn exp(&self) -> Self

Exponencial complexa: exp(z) = exp(re) · (cos(im) + i·sin(im))

pub fn powf(&self, n: T) -> Self

Potência de número complexo: z^n usando forma polar

pub fn is_nan(&self) -> bool

Verifica se contém NaN

pub fn is_infinite(&self) -> bool

Verifica se contém infinito

pub fn is_finite(&self) -> bool

Verifica se é finito (não NaN nem infinito)

Trait Implementations

impl<T: Float> Add for Complex<T>

type Output = Complex<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T: Float> AddAssign for Complex<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + Float> Clone for Complex<T>

fn clone(&self) -> Complex<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Float> Debug for Complex<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Float> Div<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self

Performs the / operation.

impl<T: Float> Div for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<T: Float> Mul<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self

Performs the * operation.

impl<T: Float> Mul for &Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Complex<T>

Performs the * operation.

impl<T: Float> Mul for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<T: Float> MulAssign<T> for Complex<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Float> Sub for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T: Float> SubAssign for Complex<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a, T: Float> Sum<&'a Complex<T>> for Complex<T>

fn sum<I: Iterator<Item = &'a Complex<T>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: Float> Sum for Complex<T>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: Copy + Float> Copy for Complex<T>