Struct BenchmarkRunner 

pub struct BenchmarkRunner {
    pub iterations: usize,
    pub measure_memory: bool,
    pub warmup_iterations: usize,
}

Benchmark runner for dataset operations

Fields

iterations: usize

Number of iterations for each benchmark

measure_memory: bool

Whether to include memory measurements

warmup_iterations: usize

Warmup iterations before actual benchmarks

Implementations

impl BenchmarkRunner

pub fn new() -> Self

Create a new benchmark runner

Examples found in repository

examples/scikit_learn_benchmark.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2 vs Scikit-Learn Performance Benchmarks");
    println!("================================================\n");

    let runner = BenchmarkRunner::new()
        .with_iterations(5)
        .with_warmup(2)
        .with_memory_measurement(false);

    // Run comprehensive SciRS2 benchmarks
    let scirs2suites = runner.run_comprehensive_benchmarks();

    println!("{}", "\n".to_owned() + &"=".repeat(60));
    println!("DETAILED ANALYSIS");
    println!("{}", "=".repeat(60));

    // Analyze toy dataset performance
    analyze_toy_dataset_performance(&scirs2suites);

    // Analyze data generation performance
    analyze_data_generation_performance(&scirs2suites);

    // Run Python comparison benchmarks (if available)
    run_python_comparison_benchmarks();

    // Generate performance report
    generate_performance_report(&scirs2suites);

    println!("\n🎉 Benchmark suite completed successfully!");
    println!("Check the generated performance report for detailed analysis.");

    Ok(())
}

examples/real_world_datasets.rs (line 358)

fn demonstrate_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ PERFORMANCE COMPARISON");
    println!("{}", "-".repeat(40));

    let runner = BenchmarkRunner::new().with_iterations(3).with_warmup(1);

    // Benchmark real-world dataset loading
    println!("Benchmarking real-world dataset operations...");

    // Titanic loading benchmark
    let titanic_params = HashMap::from([("dataset".to_string(), "titanic".to_string())]);
    let titanic_result =
        runner.run_benchmark("load_titanic", titanic_params, || match load_titanic() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load Titanic: {e}")),
        });

    // California Housing loading benchmark
    let housing_params = HashMap::from([("dataset".to_string(), "california_housing".to_string())]);
    let housing_result = runner.run_benchmark("load_california_housing", housing_params, || {
        match load_california_housing() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load California Housing: {e}")),
        }
    });

    // Heart Disease loading benchmark
    let heart_params = HashMap::from([("dataset".to_string(), "heart_disease".to_string())]);
    let heart_result =
        runner.run_benchmark(
            "load_heart_disease",
            heart_params,
            || match load_heart_disease() {
                Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
                Err(e) => Err(format!("Failed to load Heart Disease: {e}")),
            },
        );

    // Display results
    println!("\nReal-world dataset loading performance:");

    let results = vec![
        ("Titanic", &titanic_result),
        ("California Housing", &housing_result),
        ("Heart Disease", &heart_result),
    ];

    for (name, result) in results {
        if result.success {
            println!(
                "  {}: {} ({} samples, {} features, {:.1} samples/s)",
                name,
                result.formatted_duration(),
                result.samples,
                result.features,
                result.throughput
            );
        } else {
            println!(
                "  {}: Failed - {}",
                name,
                result
                    .error
                    .as_ref()
                    .unwrap_or(&"Unknown error".to_string())
            );
        }
    }

    // Memory usage estimation
    let total_samples = titanic_result.samples + housing_result.samples + heart_result.samples;
    let total_features = titanic_result.features + housing_result.features + heart_result.features;
    let estimated_memory_mb = (total_samples * total_features * 8) as f64 / (1024.0 * 1024.0);

    println!("\nMemory usage estimate:");
    println!("  Total samples: {total_samples}");
    println!("  Total features: {total_features}");
    println!("  Estimated memory: {estimated_memory_mb:.1} MB");

    // Performance recommendations
    println!("\nPerformance recommendations:");
    if estimated_memory_mb > 100.0 {
        println!("  • Consider using streaming for large datasets");
        println!("  • Enable caching for frequently accessed datasets");
    }
    println!("  • Use train/test splitting to reduce memory usage");
    println!("  • Apply feature selection to reduce dimensionality");

    println!();
    Ok(())
}

pub fn with_iterations(self, iterations: usize) -> Self

Set number of iterations

Examples found in repository

examples/scikit_learn_benchmark.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2 vs Scikit-Learn Performance Benchmarks");
    println!("================================================\n");

    let runner = BenchmarkRunner::new()
        .with_iterations(5)
        .with_warmup(2)
        .with_memory_measurement(false);

    // Run comprehensive SciRS2 benchmarks
    let scirs2suites = runner.run_comprehensive_benchmarks();

    println!("{}", "\n".to_owned() + &"=".repeat(60));
    println!("DETAILED ANALYSIS");
    println!("{}", "=".repeat(60));

    // Analyze toy dataset performance
    analyze_toy_dataset_performance(&scirs2suites);

    // Analyze data generation performance
    analyze_data_generation_performance(&scirs2suites);

    // Run Python comparison benchmarks (if available)
    run_python_comparison_benchmarks();

    // Generate performance report
    generate_performance_report(&scirs2suites);

    println!("\n🎉 Benchmark suite completed successfully!");
    println!("Check the generated performance report for detailed analysis.");

    Ok(())
}

examples/real_world_datasets.rs (line 358)

fn demonstrate_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ PERFORMANCE COMPARISON");
    println!("{}", "-".repeat(40));

    let runner = BenchmarkRunner::new().with_iterations(3).with_warmup(1);

    // Benchmark real-world dataset loading
    println!("Benchmarking real-world dataset operations...");

    // Titanic loading benchmark
    let titanic_params = HashMap::from([("dataset".to_string(), "titanic".to_string())]);
    let titanic_result =
        runner.run_benchmark("load_titanic", titanic_params, || match load_titanic() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load Titanic: {e}")),
        });

    // California Housing loading benchmark
    let housing_params = HashMap::from([("dataset".to_string(), "california_housing".to_string())]);
    let housing_result = runner.run_benchmark("load_california_housing", housing_params, || {
        match load_california_housing() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load California Housing: {e}")),
        }
    });

    // Heart Disease loading benchmark
    let heart_params = HashMap::from([("dataset".to_string(), "heart_disease".to_string())]);
    let heart_result =
        runner.run_benchmark(
            "load_heart_disease",
            heart_params,
            || match load_heart_disease() {
                Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
                Err(e) => Err(format!("Failed to load Heart Disease: {e}")),
            },
        );

    // Display results
    println!("\nReal-world dataset loading performance:");

    let results = vec![
        ("Titanic", &titanic_result),
        ("California Housing", &housing_result),
        ("Heart Disease", &heart_result),
    ];

    for (name, result) in results {
        if result.success {
            println!(
                "  {}: {} ({} samples, {} features, {:.1} samples/s)",
                name,
                result.formatted_duration(),
                result.samples,
                result.features,
                result.throughput
            );
        } else {
            println!(
                "  {}: Failed - {}",
                name,
                result
                    .error
                    .as_ref()
                    .unwrap_or(&"Unknown error".to_string())
            );
        }
    }

    // Memory usage estimation
    let total_samples = titanic_result.samples + housing_result.samples + heart_result.samples;
    let total_features = titanic_result.features + housing_result.features + heart_result.features;
    let estimated_memory_mb = (total_samples * total_features * 8) as f64 / (1024.0 * 1024.0);

    println!("\nMemory usage estimate:");
    println!("  Total samples: {total_samples}");
    println!("  Total features: {total_features}");
    println!("  Estimated memory: {estimated_memory_mb:.1} MB");

    // Performance recommendations
    println!("\nPerformance recommendations:");
    if estimated_memory_mb > 100.0 {
        println!("  • Consider using streaming for large datasets");
        println!("  • Enable caching for frequently accessed datasets");
    }
    println!("  • Use train/test splitting to reduce memory usage");
    println!("  • Apply feature selection to reduce dimensionality");

    println!();
    Ok(())
}

pub fn with_memory_measurement(self, measure: bool) -> Self

Enable memory measurement

Examples found in repository

examples/scikit_learn_benchmark.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2 vs Scikit-Learn Performance Benchmarks");
    println!("================================================\n");

    let runner = BenchmarkRunner::new()
        .with_iterations(5)
        .with_warmup(2)
        .with_memory_measurement(false);

    // Run comprehensive SciRS2 benchmarks
    let scirs2suites = runner.run_comprehensive_benchmarks();

    println!("{}", "\n".to_owned() + &"=".repeat(60));
    println!("DETAILED ANALYSIS");
    println!("{}", "=".repeat(60));

    // Analyze toy dataset performance
    analyze_toy_dataset_performance(&scirs2suites);

    // Analyze data generation performance
    analyze_data_generation_performance(&scirs2suites);

    // Run Python comparison benchmarks (if available)
    run_python_comparison_benchmarks();

    // Generate performance report
    generate_performance_report(&scirs2suites);

    println!("\n🎉 Benchmark suite completed successfully!");
    println!("Check the generated performance report for detailed analysis.");

    Ok(())
}

pub fn with_warmup(self, warmupiterations: usize) -> Self

Set warmup iterations

Examples found in repository

examples/scikit_learn_benchmark.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2 vs Scikit-Learn Performance Benchmarks");
    println!("================================================\n");

    let runner = BenchmarkRunner::new()
        .with_iterations(5)
        .with_warmup(2)
        .with_memory_measurement(false);

    // Run comprehensive SciRS2 benchmarks
    let scirs2suites = runner.run_comprehensive_benchmarks();

    println!("{}", "\n".to_owned() + &"=".repeat(60));
    println!("DETAILED ANALYSIS");
    println!("{}", "=".repeat(60));

    // Analyze toy dataset performance
    analyze_toy_dataset_performance(&scirs2suites);

    // Analyze data generation performance
    analyze_data_generation_performance(&scirs2suites);

    // Run Python comparison benchmarks (if available)
    run_python_comparison_benchmarks();

    // Generate performance report
    generate_performance_report(&scirs2suites);

    println!("\n🎉 Benchmark suite completed successfully!");
    println!("Check the generated performance report for detailed analysis.");

    Ok(())
}

examples/real_world_datasets.rs (line 358)

fn demonstrate_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ PERFORMANCE COMPARISON");
    println!("{}", "-".repeat(40));

    let runner = BenchmarkRunner::new().with_iterations(3).with_warmup(1);

    // Benchmark real-world dataset loading
    println!("Benchmarking real-world dataset operations...");

    // Titanic loading benchmark
    let titanic_params = HashMap::from([("dataset".to_string(), "titanic".to_string())]);
    let titanic_result =
        runner.run_benchmark("load_titanic", titanic_params, || match load_titanic() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load Titanic: {e}")),
        });

    // California Housing loading benchmark
    let housing_params = HashMap::from([("dataset".to_string(), "california_housing".to_string())]);
    let housing_result = runner.run_benchmark("load_california_housing", housing_params, || {
        match load_california_housing() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load California Housing: {e}")),
        }
    });

    // Heart Disease loading benchmark
    let heart_params = HashMap::from([("dataset".to_string(), "heart_disease".to_string())]);
    let heart_result =
        runner.run_benchmark(
            "load_heart_disease",
            heart_params,
            || match load_heart_disease() {
                Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
                Err(e) => Err(format!("Failed to load Heart Disease: {e}")),
            },
        );

    // Display results
    println!("\nReal-world dataset loading performance:");

    let results = vec![
        ("Titanic", &titanic_result),
        ("California Housing", &housing_result),
        ("Heart Disease", &heart_result),
    ];

    for (name, result) in results {
        if result.success {
            println!(
                "  {}: {} ({} samples, {} features, {:.1} samples/s)",
                name,
                result.formatted_duration(),
                result.samples,
                result.features,
                result.throughput
            );
        } else {
            println!(
                "  {}: Failed - {}",
                name,
                result
                    .error
                    .as_ref()
                    .unwrap_or(&"Unknown error".to_string())
            );
        }
    }

    // Memory usage estimation
    let total_samples = titanic_result.samples + housing_result.samples + heart_result.samples;
    let total_features = titanic_result.features + housing_result.features + heart_result.features;
    let estimated_memory_mb = (total_samples * total_features * 8) as f64 / (1024.0 * 1024.0);

    println!("\nMemory usage estimate:");
    println!("  Total samples: {total_samples}");
    println!("  Total features: {total_features}");
    println!("  Estimated memory: {estimated_memory_mb:.1} MB");

    // Performance recommendations
    println!("\nPerformance recommendations:");
    if estimated_memory_mb > 100.0 {
        println!("  • Consider using streaming for large datasets");
        println!("  • Enable caching for frequently accessed datasets");
    }
    println!("  • Use train/test splitting to reduce memory usage");
    println!("  • Apply feature selection to reduce dimensionality");

    println!();
    Ok(())
}

pub fn run_benchmark<F>( &self, name: &str, parameters: HashMap<String, String>, benchmark_fn: F, ) -> BenchmarkResult

where F: FnMut() -> Result<(usize, usize), String>,

Run a benchmark function multiple times and return average result

Examples found in repository

examples/real_world_datasets.rs (lines 366-369)

fn demonstrate_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ PERFORMANCE COMPARISON");
    println!("{}", "-".repeat(40));

    let runner = BenchmarkRunner::new().with_iterations(3).with_warmup(1);

    // Benchmark real-world dataset loading
    println!("Benchmarking real-world dataset operations...");

    // Titanic loading benchmark
    let titanic_params = HashMap::from([("dataset".to_string(), "titanic".to_string())]);
    let titanic_result =
        runner.run_benchmark("load_titanic", titanic_params, || match load_titanic() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load Titanic: {e}")),
        });

    // California Housing loading benchmark
    let housing_params = HashMap::from([("dataset".to_string(), "california_housing".to_string())]);
    let housing_result = runner.run_benchmark("load_california_housing", housing_params, || {
        match load_california_housing() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load California Housing: {e}")),
        }
    });

    // Heart Disease loading benchmark
    let heart_params = HashMap::from([("dataset".to_string(), "heart_disease".to_string())]);
    let heart_result =
        runner.run_benchmark(
            "load_heart_disease",
            heart_params,
            || match load_heart_disease() {
                Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
                Err(e) => Err(format!("Failed to load Heart Disease: {e}")),
            },
        );

    // Display results
    println!("\nReal-world dataset loading performance:");

    let results = vec![
        ("Titanic", &titanic_result),
        ("California Housing", &housing_result),
        ("Heart Disease", &heart_result),
    ];

    for (name, result) in results {
        if result.success {
            println!(
                "  {}: {} ({} samples, {} features, {:.1} samples/s)",
                name,
                result.formatted_duration(),
                result.samples,
                result.features,
                result.throughput
            );
        } else {
            println!(
                "  {}: Failed - {}",
                name,
                result
                    .error
                    .as_ref()
                    .unwrap_or(&"Unknown error".to_string())
            );
        }
    }

    // Memory usage estimation
    let total_samples = titanic_result.samples + housing_result.samples + heart_result.samples;
    let total_features = titanic_result.features + housing_result.features + heart_result.features;
    let estimated_memory_mb = (total_samples * total_features * 8) as f64 / (1024.0 * 1024.0);

    println!("\nMemory usage estimate:");
    println!("  Total samples: {total_samples}");
    println!("  Total features: {total_features}");
    println!("  Estimated memory: {estimated_memory_mb:.1} MB");

    // Performance recommendations
    println!("\nPerformance recommendations:");
    if estimated_memory_mb > 100.0 {
        println!("  • Consider using streaming for large datasets");
        println!("  • Enable caching for frequently accessed datasets");
    }
    println!("  • Use train/test splitting to reduce memory usage");
    println!("  • Apply feature selection to reduce dimensionality");

    println!();
    Ok(())
}

pub fn benchmark_toy_datasets(&self) -> BenchmarkSuite

Benchmark toy dataset loading

pub fn benchmark_data_generation(&self) -> BenchmarkSuite

Benchmark synthetic data generation

pub fn benchmark_csv_loading<P: AsRef<Path>>( &self, csvpath: P, ) -> BenchmarkSuite

Benchmark CSV loading performance

pub fn run_comprehensive_benchmarks(&self) -> Vec<BenchmarkSuite>

Run comprehensive benchmarks comparing SciRS2 performance

Examples found in repository

examples/scikit_learn_benchmark.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2 vs Scikit-Learn Performance Benchmarks");
    println!("================================================\n");

    let runner = BenchmarkRunner::new()
        .with_iterations(5)
        .with_warmup(2)
        .with_memory_measurement(false);

    // Run comprehensive SciRS2 benchmarks
    let scirs2suites = runner.run_comprehensive_benchmarks();

    println!("{}", "\n".to_owned() + &"=".repeat(60));
    println!("DETAILED ANALYSIS");
    println!("{}", "=".repeat(60));

    // Analyze toy dataset performance
    analyze_toy_dataset_performance(&scirs2suites);

    // Analyze data generation performance
    analyze_data_generation_performance(&scirs2suites);

    // Run Python comparison benchmarks (if available)
    run_python_comparison_benchmarks();

    // Generate performance report
    generate_performance_report(&scirs2suites);

    println!("\n🎉 Benchmark suite completed successfully!");
    println!("Check the generated performance report for detailed analysis.");

    Ok(())
}

Trait Implementations

impl Default for BenchmarkRunner

fn default() -> Self

Returns the “default value” for a type.