Struct OptimizationReport 

pub struct OptimizationReport {
    pub initial_metrics: CircuitMetrics,
    pub final_metrics: CircuitMetrics,
    pub applied_passes: Vec<String>,
}

Optimization report

Fields

initial_metrics: CircuitMetrics

Initial circuit metrics

final_metrics: CircuitMetrics

Final circuit metrics

applied_passes: Vec<String>

List of applied optimization passes

Implementations

impl OptimizationReport

pub fn improvement(&self) -> MetricImprovement

Get improvement metrics

Examples found in repository

examples/optimization_demo.rs (line 85)

fn demo_optimization_levels(circuit: &Circuit<4>) {
    println!("Demo 1: Optimization Levels");
    println!("----------------------------");

    let levels = [
        OptimizationLevel::None,
        OptimizationLevel::Light,
        OptimizationLevel::Medium,
        OptimizationLevel::Heavy,
    ];

    for level in levels {
        println!("\nOptimization Level: {:?}", level);

        let start = Instant::now();
        let mut optimizer = CircuitOptimizer2::<4>::with_level(level);

        match optimizer.optimize(circuit) {
            Ok(report) => {
                let duration = start.elapsed();
                println!("  Optimization time: {:?}", duration);
                println!("  Initial gates: {}", report.initial_metrics.gate_count);
                println!("  Final gates: {}", report.final_metrics.gate_count);
                println!("  Gate reduction: {:.1}%", report.improvement().gate_count);
                println!("  Applied passes: {:?}", report.applied_passes);
            }
            Err(e) => {
                println!("  Optimization failed: {:?}", e);
            }
        }
    }
    println!();
}

fn demo_hardware_optimization(circuit: &Circuit<4>) {
    println!("\nDemo 2: Hardware-Specific Optimization");
    println!("--------------------------------------");

    let backends = ["ibm", "google", "aws"];

    for backend in backends {
        println!("\nBackend: {}", backend);

        let mut optimizer = CircuitOptimizer2::<4>::for_hardware(backend);

        match optimizer.optimize(circuit) {
            Ok(report) => {
                println!(
                    "  Initial cost: {:.2}",
                    report.initial_metrics.execution_time
                );
                println!("  Final cost: {:.2}", report.final_metrics.execution_time);
                println!(
                    "  Time reduction: {:.1}%",
                    report.improvement().execution_time
                );
                println!(
                    "  Error reduction: {:.1}%",
                    report.improvement().total_error
                );
            }
            Err(e) => {
                println!("  Optimization failed: {:?}", e);
            }
        }
    }
    println!();
}

pub fn print_summary(&self)

Print a summary of the optimization

Examples found in repository

examples/optimization_demo.rs (line 160)

fn demo_custom_optimization(circuit: &Circuit<4>) {
    println!("\nDemo 3: Custom Optimization Pipeline");
    println!("------------------------------------");

    // Create a custom pass manager
    let mut pass_manager = PassManager::new();

    // Configure with specific passes
    let config = PassConfig {
        max_iterations: 5,
        aggressive: true,
        level: OptimizationLevel::Custom,
        ..Default::default()
    };
    pass_manager.configure(config.clone());

    // Add specific passes in a custom order
    pass_manager.add_pass(Box::new(GateCancellation::new(true)));
    pass_manager.add_pass(Box::new(RotationMerging::new(1e-10)));
    pass_manager.add_pass(Box::new(GateCommutation::new(10)));
    pass_manager.add_pass(Box::new(TemplateMatching::new()));

    // Create optimizer with custom configuration
    let mut optimizer = CircuitOptimizer2::<4>::new();
    optimizer.configure(config);

    match optimizer.optimize(circuit) {
        Ok(report) => {
            println!("Custom optimization results:");
            report.print_summary();
        }
        Err(e) => {
            println!("Custom optimization failed: {:?}", e);
        }
    }
}

pub fn detailed_report(&self) -> String

Generate a detailed report as string

Examples found in repository

examples/optimization_demo.rs (line 267)

fn benchmark_optimization_passes(circuit: &Circuit<4>) {
    println!("\nDemo 5: Pass Benchmarking");
    println!("-------------------------");

    // Benchmark individual passes
    let passes: Vec<(&str, Box<dyn OptimizationPass>)> = vec![
        ("Gate Cancellation", Box::new(GateCancellation::new(false))),
        ("Rotation Merging", Box::new(RotationMerging::new(1e-10))),
        ("Gate Commutation", Box::new(GateCommutation::new(5))),
        ("Template Matching", Box::new(TemplateMatching::new())),
        (
            "Two-Qubit Opt",
            Box::new(TwoQubitOptimization::new(false, true)),
        ),
    ];

    let cost_model = AbstractCostModel::default();

    for (name, pass) in passes {
        let start = Instant::now();

        match pass.apply(circuit, &cost_model) {
            Ok(_) => {
                let duration = start.elapsed();
                println!("  {}: {:?}", name, duration);
            }
            Err(e) => {
                println!("  {} failed: {:?}", name, e);
            }
        }
    }

    // Benchmark full optimization
    println!("\nFull Optimization Benchmark:");
    let start = Instant::now();
    let mut optimizer = CircuitOptimizer2::<4>::with_level(OptimizationLevel::Heavy);

    match optimizer.optimize(circuit) {
        Ok(report) => {
            let duration = start.elapsed();
            println!("  Total time: {:?}", duration);
            println!(
                "  Gates reduced: {} → {}",
                report.initial_metrics.gate_count, report.final_metrics.gate_count
            );

            // Show detailed report
            println!("\nDetailed Report:");
            println!("{}", report.detailed_report());
        }
        Err(e) => {
            println!("  Benchmark failed: {:?}", e);
        }
    }
}

Trait Implementations

impl Debug for OptimizationReport

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

Formats the value using the given formatter.