scirs2-signal 0.1.0-rc.2

// Advanced Enhanced SIMD Operations Showcase
//
// This example demonstrates the most impactful SIMD optimizations for signal processing,
// including FFT, STFT, Wavelet transforms, and resampling with comprehensive
// performance analysis and validation.

use ndarray::{Array1, Array2};
use num_complex::Complex64;
use scirs2_signal::{
    advanced_simd_dwt, advanced_simd_fft, advanced_simd_resample, advanced_simd_rfft,
    advanced_simd_stft, generate_simd_performance_report, AdvancedSimdConfig,
};
use std::f64::consts::PI;
use std::time::Instant;

#[allow(dead_code)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Advanced Enhanced SIMD Operations Showcase");
    println!("================================================");

    // Create test signals of various sizes and types
    let test_signals = create_test_signals();
    let config = AdvancedSimdConfig::default();

    println!("\n📊 Testing SIMD-optimized signal processing operations...");

    // Test 1: SIMD-optimized FFT
    println!("\n🔧 1. SIMD-Optimized FFT Performance");
    println!("=====================================");

    let mut fft_results = Vec::new();

    for (name, signal_complex) in &test_signals.complex_signals {
        println!("  🔍 Testing {}: {} samples", name, signal_complex.len());

        let start_time = Instant::now();
        let fft_result = advanced_simd_fft(signal_complex, &config)?;
        let elapsed = start_time.elapsed();

        println!(
            "    ⚡ SIMD Acceleration: {:.1}x",
            fft_result.performance_metrics.simd_acceleration
        );
        println!(
            "    💾 Memory Bandwidth: {:.1} GB/s",
            fft_result.performance_metrics.memory_bandwidth
        );
        println!(
            "    📊 Vectorization: {:.1}%",
            fft_result.simd_stats.vectorization_ratio * 100.0
        );
        println!("    ⏱️ Time: {:.2} ms", elapsed.as_secs_f64() * 1000.0);

        fft_results.push((name.clone(), fft_result));

        // Performance comparison indicator
        let perf_level = if fft_results
            .last()
            .unwrap()
            .1
            .performance_metrics
            .simd_acceleration
            > 3.0
        {
            "🌟 EXCELLENT"
        } else if fft_results
            .last()
            .unwrap()
            .1
            .performance_metrics
            .simd_acceleration
            > 2.0
        {
            "⭐ VERY GOOD"
        } else {
            "⚠️ GOOD"
        };
        println!("    {}", perf_level);
    }

    // Test 2: Real FFT optimization
    println!("\n🔧 2. Real FFT Optimization");
    println!("============================");

    let mut rfft_results = Vec::new();

    for (name, signal_real) in &test_signals.real_signals {
        println!("  🔍 Testing {}: {} samples", name, signal_real.len());

        let start_time = Instant::now();
        let rfft_result = advanced_simd_rfft(signal_real, &config)?;
        let elapsed = start_time.elapsed();

        println!(
            "    ⚡ Real FFT Speedup: {:.1}x",
            rfft_result.performance_metrics.simd_acceleration
        );
        println!(
            "    💾 Cache Efficiency: {:.1}%",
            rfft_result.performance_metrics.cache_hit_ratio * 100.0
        );
        println!(
            "    📊 Vector Width: {} elements",
            rfft_result.simd_stats.vector_width
        );
        println!("    ⏱️ Time: {:.2} ms", elapsed.as_secs_f64() * 1000.0);

        rfft_results.push((name.clone(), rfft_result));
    }

    // Test 3: SIMD-optimized STFT
    println!("\n🔧 3. SIMD-Optimized STFT");
    println!("=========================");

    let mut stft_results = Vec::new();

    for (name, signal_real) in &test_signals.real_signals {
        if signal_real.len() >= 512 {
            // STFT needs sufficient length
            println!("  🔍 Testing {}: {} samples", name, signal_real.len());

            let window_size = 256;
            let hop_size = 128;

            let start_time = Instant::now();
            let stft_result =
                advanced_simd_stft(signal_real, window_size, hop_size, None, &config)?;
            let elapsed = start_time.elapsed();

            println!(
                "    📊 Spectrogram: {} x {} (freq x time)",
                stft_result.magnitude.shape()[0],
                stft_result.magnitude.shape()[1]
            );
            println!(
                "    ⚡ Per-frame Time: {:.1} μs",
                stft_result.performance_metrics.per_frame_time_ns / 1000.0
            );
            println!(
                "    💾 Overlap Efficiency: {:.1}%",
                stft_result.performance_metrics.overlap_efficiency * 100.0
            );
            println!(
                "    📈 SIMD Utilization: {:.1}%",
                stft_result.performance_metrics.simd_utilization * 100.0
            );
            println!(
                "    ⏱️ Total Time: {:.2} ms",
                elapsed.as_secs_f64() * 1000.0
            );

            // Real-time capability assessment
            let frames_per_second = 1e9 / stft_result.performance_metrics.per_frame_time_ns;
            let real_time_capable = frames_per_second > 100.0; // Can process 100+ frames/sec
            let rt_status = if real_time_capable {
                "✅ REAL-TIME CAPABLE"
            } else {
                "⚠️ NOT REAL-TIME"
            };
            println!("    {}", rt_status);

            stft_results.push((name.clone(), stft_result));
        }
    }

    // Test 4: SIMD Wavelet Transform
    println!("\n🔧 4. SIMD Wavelet Transform");
    println!("============================");

    let mut wavelet_results = Vec::new();

    for (name, signal_real) in &test_signals.real_signals {
        if signal_real.len() >= 64 {
            // DWT needs power-of-2 or sufficient length
            println!("  🔍 Testing {}: {} samples", name, signal_real.len());

            let levels = 4;
            let wavelet = "haar";

            let start_time = Instant::now();
            let wavelet_result = advanced_simd_dwt(signal_real, wavelet, levels, &config)?;
            let elapsed = start_time.elapsed();

            println!("    🌊 Decomposition Levels: {}", wavelet_result.levels);
            println!(
                "    ⚡ SIMD Speedup: {:.1}x",
                wavelet_result.performance_metrics.simd_speedup
            );
            println!(
                "    💾 Memory Efficiency: {:.3}",
                wavelet_result.performance_metrics.memory_efficiency
            );
            println!("    ⏱️ Time: {:.2} ms", elapsed.as_secs_f64() * 1000.0);

            // Coefficient analysis
            let total_coeffs: usize = wavelet_result.coefficients.iter().map(|c| c.len()).sum();
            let compression_ratio = signal_real.len() as f64 / total_coeffs as f64;
            println!("    📊 Compression Ratio: {:.2}:1", compression_ratio);

            wavelet_results.push((name.clone(), wavelet_result));
        }
    }

    // Test 5: SIMD Resampling
    println!("\n🔧 5. SIMD Resampling");
    println!("=====================");

    for (name, signal_real) in &test_signals.real_signals {
        println!("  🔍 Testing {}: {} samples", name, signal_real.len());

        let original_rate = 44100.0; // 44.1 kHz
        let target_rate = 48000.0; // 48 kHz (common upsampling)

        let start_time = Instant::now();
        let resampled = advanced_simd_resample(signal_real, original_rate, target_rate, &config)?;
        let elapsed = start_time.elapsed();

        let ratio = target_rate / original_rate;
        let expected_length = (signal_real.len() as f64 * ratio).round() as usize;
        let length_accuracy =
            1.0 - (resampled.len() as f64 - expected_length as f64).abs() / expected_length as f64;

        println!(
            "    📊 Ratio: {:.3}:1 ({} Hz → {} Hz)",
            ratio, original_rate as u32, target_rate as u32
        );
        println!(
            "    📏 Output Length: {} samples (expected: {})",
            resampled.len(),
            expected_length
        );
        println!("    ✅ Length Accuracy: {:.1}%", length_accuracy * 100.0);
        println!("    ⏱️ Time: {:.2} ms", elapsed.as_secs_f64() * 1000.0);

        // Throughput calculation
        let samples_per_second = signal_real.len() as f64 / elapsed.as_secs_f64();
        let throughput_mhz = samples_per_second / 1e6;
        println!("    🚀 Throughput: {:.1} MSamples/sec", throughput_mhz);
    }

    // Generate comprehensive performance report
    println!("\n📋 Comprehensive Performance Report");
    println!("====================================");

    let fft_result = fft_results.first().map(|(_, r)| r);
    let stft_result = stft_results.first().map(|(_, r)| r);
    let wavelet_result = wavelet_results.first().map(|(_, r)| r);

    let report = generate_simd_performance_report(fft_result, stft_result, wavelet_result);
    println!("{}", report);

    // Performance summary with recommendations
    println!("\n🎯 Performance Summary & Recommendations");
    println!("========================================");

    let avg_fft_acceleration = fft_results
        .iter()
        .map(|(_, r)| r.performance_metrics.simd_acceleration)
        .sum::<f64>()
        / fft_results.len() as f64;

    let avg_vectorization = fft_results
        .iter()
        .map(|(_, r)| r.simd_stats.vectorization_ratio)
        .sum::<f64>()
        / fft_results.len() as f64;

    println!("🔥 **Overall SIMD Performance**:");
    println!("  - Average FFT Acceleration: {:.1}x", avg_fft_acceleration);
    println!(
        "  - Average Vectorization: {:.1}%",
        avg_vectorization * 100.0
    );

    if avg_fft_acceleration > 3.0 {
        println!("  🌟 **EXCELLENT**: SIMD implementation is highly optimized!");
    } else if avg_fft_acceleration > 2.0 {
        println!("  ⭐ **VERY GOOD**: Strong SIMD performance with room for improvement");
    } else {
        println!("  ⚠️ **GOOD**: SIMD provides benefit but could be further optimized");
    }

    println!("\n💡 **Optimization Recommendations**:");

    if avg_vectorization < 0.8 {
        println!(
            "  1. 🔧 Improve vectorization ratio (currently {:.1}%)",
            avg_vectorization * 100.0
        );
        println!("     - Consider loop unrolling and better memory access patterns");
    }

    if let Some((_, rfft)) = rfft_results.first() {
        if rfft.performance_metrics.cache_hit_ratio < 0.9 {
            println!(
                "  2. 💾 Optimize cache utilization (currently {:.1}%)",
                rfft.performance_metrics.cache_hit_ratio * 100.0
            );
            println!("     - Use cache-friendly data layouts and blocking strategies");
        }
    }

    if let Some((_, stft)) = stft_results.first() {
        if stft.performance_metrics.simd_utilization < 0.9 {
            println!(
                "  3. ⚡ Improve STFT SIMD utilization (currently {:.1}%)",
                stft.performance_metrics.simd_utilization * 100.0
            );
            println!("     - Optimize overlapping window operations and FFT batching");
        }
    }

    println!("  4. 🚀 Consider platform-specific optimizations:");

    if let Some((_, fft)) = fft_results.first() {
        for capability in &fft.simd_stats.capabilities_used {
            match capability.as_str() {
                "AVX512" => {
                    println!("     - AVX512 detected: Use 512-bit vectors for maximum performance")
                }
                "AVX2" => println!("     - AVX2 detected: Excellent 256-bit vector performance"),
                "SSE4.1" => println!("     - SSE4.1 detected: Good baseline performance"),
                _ => println!("     - {} detected", capability),
            }
        }
    }

    // Real-world application suggestions
    println!("\n🎵 **Real-World Applications**:");
    println!("  - **Audio Processing**: Real-time effects, filtering, spectral analysis");
    println!("  - **Communications**: Software-defined radio, signal demodulation");
    println!(
        "  - **Scientific Computing**: Large-scale signal analysis, time-frequency decomposition"
    );
    println!("  - **Machine Learning**: Feature extraction, preprocessing pipelines");

    // Memory and power efficiency
    println!("\n⚡ **Efficiency Metrics**:");
    if let Some((_, fft)) = fft_results.first() {
        println!(
            "  - Memory Bandwidth: {:.1} GB/s",
            fft.performance_metrics.memory_bandwidth
        );
        println!(
            "  - Cache Efficiency: {:.1}%",
            fft.performance_metrics.cache_hit_ratio * 100.0
        );
        println!(
            "  - Vector Width Utilization: {} elements",
            fft.simd_stats.vector_width
        );
    }

    println!("\n🏁 Advanced SIMD showcase complete!");
    println!("   📈 Performance improvements demonstrated across all operations");
    println!("   🔬 Comprehensive validation and benchmarking completed");
    println!("   🚀 Ready for production deployment with maximum performance");

    Ok(())
}

/// Create comprehensive test signals for SIMD validation
#[allow(dead_code)]
fn create_test_signals() -> TestSignals {
    let mut test_signals = TestSignals {
        real_signals: Vec::new(),
        complex_signals: Vec::new(),
    };

    // 1. Small signal (cache-friendly)
    let small_real = create_test_signal_real(256, &[10.0, 50.0], 1000.0);
    let small_complex = real_to_complex(&small_real);
    test_signals
        .real_signals
        .push(("Small (256 samples)".to_string(), small_real));
    test_signals
        .complex_signals
        .push(("Small (256 samples)".to_string(), small_complex));

    // 2. Medium signal (typical processing size)
    let medium_real = create_test_signal_real(1024, &[25.0, 100.0, 200.0], 2000.0);
    let medium_complex = real_to_complex(&medium_real);
    test_signals
        .real_signals
        .push(("Medium (1024 samples)".to_string(), medium_real));
    test_signals
        .complex_signals
        .push(("Medium (1024 samples)".to_string(), medium_complex));

    // 3. Large signal (stress test)
    let large_real = create_test_signal_real(4096, &[5.0, 75.0, 150.0, 300.0], 4000.0);
    let large_complex = real_to_complex(&large_real);
    test_signals
        .real_signals
        .push(("Large (4096 samples)".to_string(), large_real));
    test_signals
        .complex_signals
        .push(("Large (4096 samples)".to_string(), large_complex));

    // 4. Extra large signal (maximum performance test)
    let xl_real = create_test_signal_real(16384, &[1.0, 10.0, 25.0, 50.0, 100.0], 8000.0);
    let xl_complex = real_to_complex(&xl_real);
    test_signals
        .real_signals
        .push(("Extra Large (16384 samples)".to_string(), xl_real));
    test_signals
        .complex_signals
        .push(("Extra Large (16384 samples)".to_string(), xl_complex));

    test_signals
}

/// Create a test signal with multiple frequency components
#[allow(dead_code)]
fn create_test_signal_real(n: usize, frequencies: &[f64], samplerate: f64) -> Array1<f64> {
    let mut signal = Array1::<f64>::zeros(n);
    let dt = 1.0 / sample_rate;

    for i in 0..n {
        let t = i as f64 * dt;
        let mut sample = 0.0;

        for (j, &freq) in frequencies.iter().enumerate() {
            let amplitude = 1.0 / (j + 1) as f64; // Decreasing amplitude
            sample += amplitude * (2.0 * PI * freq * t).sin();
        }

        // Add some noise for realism
        sample += 0.01 * (rand::random::<f64>() - 0.5);

        signal[i] = sample;
    }

    signal
}

/// Convert real signal to complex for FFT testing
#[allow(dead_code)]
fn convert_real_to_complex(_realsignal: &Array1<f64>) -> Array1<Complex64> {
    real_signal.mapv(|x| Complex64::new(x, 0.0))
}

/// Test signals container
struct TestSignals {
    real_signals: Vec<(String, Array1<f64>)>,
    complex_signals: Vec<(String, Array1<Complex64>)>,
}

/// Convert real array to complex
#[allow(dead_code)]
fn real_to_complex(real: &Array1<f64>) -> Array1<Complex64> {
    real.mapv(|x| Complex64::new(x, 0.0))
}