quantrs2-sim 0.2.0

Quantum circuit simulators for the QuantRS2 framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Benchmarks for SIMD-accelerated single-qubit gate kernels.
//!
//! Compares `apply_h_simd` (SIMD path) against the scalar reference
//! `apply_gate_2x2_scalar` for state vectors of various sizes.
//!
//! Run with: `cargo bench --bench simd_state_vector -p quantrs2-sim`

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use quantrs2_sim::state_vector_simd::{apply_gate_2x2_scalar, apply_h_simd};
use scirs2_core::Complex64;
use std::time::Duration;

// ============================================================================
// State helpers
// ============================================================================

fn make_state(n_qubits: u32) -> Vec<Complex64> {
    let size = 1usize << n_qubits;
    let mut state = vec![Complex64::new(0.0, 0.0); size];
    state[0] = Complex64::new(1.0, 0.0);
    state
}

// ============================================================================
// Benchmark: H gate SIMD vs scalar
// ============================================================================

fn bench_h_gate_simd(c: &mut Criterion) {
    let mut group = c.benchmark_group("simd_h_gate");
    group
        .measurement_time(Duration::from_secs(5))
        .sample_size(20);

    for &n in &[16u32, 18, 20] {
        // SIMD path
        group.bench_with_input(BenchmarkId::new("simd", n), &n, |b, &n| {
            let mut state = make_state(n);
            b.iter(|| {
                apply_h_simd(black_box(&mut state), 0, n as usize);
                black_box(&state);
            });
        });

        // Scalar reference
        group.bench_with_input(BenchmarkId::new("scalar", n), &n, |b, &n| {
            use std::f64::consts::FRAC_1_SQRT_2;
            let h_mat = [
                [
                    Complex64::new(FRAC_1_SQRT_2, 0.0),
                    Complex64::new(FRAC_1_SQRT_2, 0.0),
                ],
                [
                    Complex64::new(FRAC_1_SQRT_2, 0.0),
                    Complex64::new(-FRAC_1_SQRT_2, 0.0),
                ],
            ];
            let mut state = make_state(n);
            b.iter(|| {
                apply_gate_2x2_scalar(black_box(&mut state), h_mat, 0, n as usize);
                black_box(&state);
            });
        });
    }

    group.finish();
}

// ============================================================================
// Benchmark: H gate across different target qubits
// ============================================================================

fn bench_h_gate_target_qubit(c: &mut Criterion) {
    let mut group = c.benchmark_group("simd_h_gate_targets");
    group
        .measurement_time(Duration::from_secs(3))
        .sample_size(20);

    let n = 18u32;

    for &target in &[0usize, 5, 10, 17] {
        // SIMD
        group.bench_with_input(
            BenchmarkId::new("simd_target", target),
            &target,
            |b, &target| {
                let mut state = make_state(n);
                b.iter(|| {
                    apply_h_simd(black_box(&mut state), target, n as usize);
                    black_box(&state);
                });
            },
        );

        // Scalar
        group.bench_with_input(
            BenchmarkId::new("scalar_target", target),
            &target,
            |b, &target| {
                use std::f64::consts::FRAC_1_SQRT_2;
                let h_mat = [
                    [
                        Complex64::new(FRAC_1_SQRT_2, 0.0),
                        Complex64::new(FRAC_1_SQRT_2, 0.0),
                    ],
                    [
                        Complex64::new(FRAC_1_SQRT_2, 0.0),
                        Complex64::new(-FRAC_1_SQRT_2, 0.0),
                    ],
                ];
                let mut state = make_state(n);
                b.iter(|| {
                    apply_gate_2x2_scalar(black_box(&mut state), h_mat, target, n as usize);
                    black_box(&state);
                });
            },
        );
    }

    group.finish();
}

// ============================================================================
// Criterion entry-point
// ============================================================================

criterion_group!(benches, bench_h_gate_simd, bench_h_gate_target_qubit);
criterion_main!(benches);