quantrs2_circuit/scirs2_matrices/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::builder::Circuit;
6use quantrs2_core::{
7    buffer_pool::BufferPool,
8    error::{QuantRS2Error, QuantRS2Result},
9    gate::GateOp,
10    qubit::QubitId,
11};
12pub use scirs2_core::Complex64;
13use scirs2_core::{
14    parallel_ops::{IndexedParallelIterator, ParallelIterator},
15    simd_ops::*,
16};
17use std::collections::HashMap;
18use std::sync::Arc;
19use std::time::Instant;
20
21pub struct BLAS;
22impl BLAS {
23    /// Check whether two sparse matrices are approximately equal entry-wise within `tol`.
24    /// For each entry present in either matrix the corresponding value in the other is
25    /// treated as zero when absent, and the element-wise difference must satisfy |diff| ≤ tol.
26    #[must_use]
27    pub fn matrix_approx_equal(
28        a: &SciRSSparseMatrix<Complex64>,
29        b: &SciRSSparseMatrix<Complex64>,
30        tol: f64,
31    ) -> bool {
32        if a.shape != b.shape {
33            return false;
34        }
35        let mut b_map: HashMap<(usize, usize), Complex64> = HashMap::with_capacity(b.data.len());
36        for &(r, c, v) in &b.data {
37            b_map.insert((r, c), v);
38        }
39        for &(r, c, va) in &a.data {
40            let vb = b_map.remove(&(r, c)).unwrap_or(Complex64::new(0.0, 0.0));
41            if (va - vb).norm() > tol {
42                return false;
43            }
44        }
45        for (_, vb) in b_map {
46            if vb.norm() > tol {
47                return false;
48            }
49        }
50        true
51    }
52    #[must_use]
53    pub const fn condition_number(_matrix: &SciRSSparseMatrix<Complex64>) -> f64 {
54        1.0
55    }
56    #[must_use]
57    pub fn is_symmetric(matrix: &SciRSSparseMatrix<Complex64>, tol: f64) -> bool {
58        if matrix.shape.0 != matrix.shape.1 {
59            return false;
60        }
61        for (row, col, value) in &matrix.data {
62            let transpose_entry = matrix
63                .data
64                .iter()
65                .find(|(r, c, _)| *r == *col && *c == *row);
66            match transpose_entry {
67                Some((_, _, transpose_value)) => {
68                    if (value - transpose_value).norm() > tol {
69                        return false;
70                    }
71                }
72                None => {
73                    if value.norm() > tol {
74                        return false;
75                    }
76                }
77            }
78        }
79        true
80    }
81    #[must_use]
82    pub fn is_hermitian(matrix: &SciRSSparseMatrix<Complex64>, tol: f64) -> bool {
83        if matrix.shape.0 != matrix.shape.1 {
84            return false;
85        }
86        for (row, col, value) in &matrix.data {
87            let conj_transpose_entry = matrix
88                .data
89                .iter()
90                .find(|(r, c, _)| *r == *col && *c == *row);
91            match conj_transpose_entry {
92                Some((_, _, conj_transpose_value)) => {
93                    if (value - conj_transpose_value.conj()).norm() > tol {
94                        return false;
95                    }
96                }
97                None => {
98                    if value.norm() > tol {
99                        return false;
100                    }
101                }
102            }
103        }
104        true
105    }
106    #[must_use]
107    pub const fn is_positive_definite(_matrix: &SciRSSparseMatrix<Complex64>) -> bool {
108        false
109    }
110    #[must_use]
111    pub const fn matrix_norm(_matrix: &SciRSSparseMatrix<Complex64>, _norm_type: &str) -> f64 {
112        1.0
113    }
114    #[must_use]
115    pub const fn numerical_rank(_matrix: &SciRSSparseMatrix<Complex64>, _tol: f64) -> usize {
116        1
117    }
118    #[must_use]
119    pub const fn spectral_analysis(_matrix: &SciRSSparseMatrix<Complex64>) -> SpectralAnalysis {
120        SpectralAnalysis {
121            spectral_radius: 1.0,
122            eigenvalue_spread: 0.0,
123        }
124    }
125    #[must_use]
126    pub const fn gate_fidelity(
127        _a: &SciRSSparseMatrix<Complex64>,
128        _b: &SciRSSparseMatrix<Complex64>,
129    ) -> f64 {
130        0.99
131    }
132    #[must_use]
133    pub const fn trace_distance(
134        _a: &SciRSSparseMatrix<Complex64>,
135        _b: &SciRSSparseMatrix<Complex64>,
136    ) -> f64 {
137        0.001
138    }
139    #[must_use]
140    pub const fn diamond_distance(
141        _a: &SciRSSparseMatrix<Complex64>,
142        _b: &SciRSSparseMatrix<Complex64>,
143    ) -> f64 {
144        0.001
145    }
146    #[must_use]
147    pub const fn process_fidelity(
148        _a: &SciRSSparseMatrix<Complex64>,
149        _b: &SciRSSparseMatrix<Complex64>,
150    ) -> f64 {
151        0.99
152    }
153    #[must_use]
154    pub const fn error_decomposition(
155        _a: &SciRSSparseMatrix<Complex64>,
156        _b: &SciRSSparseMatrix<Complex64>,
157    ) -> ErrorDecomposition {
158        ErrorDecomposition {
159            coherent_component: 0.001,
160            incoherent_component: 0.001,
161        }
162    }
163    pub const fn sparse_matvec(
164        _matrix: &SciRSSparseMatrix<Complex64>,
165        _vector: &VectorizedOps,
166    ) -> QuantRS2Result<VectorizedOps> {
167        Ok(VectorizedOps)
168    }
169    pub fn matrix_exp(
170        matrix: &SciRSSparseMatrix<Complex64>,
171        _scale: f64,
172    ) -> QuantRS2Result<SciRSSparseMatrix<Complex64>> {
173        Ok(matrix.clone())
174    }
175}
176pub struct SparsityPattern;
177impl SparsityPattern {
178    #[must_use]
179    pub const fn analyze(_matrix: &SciRSSparseMatrix<Complex64>) -> Self {
180        Self
181    }
182    #[must_use]
183    pub const fn estimate_compression_ratio(&self) -> f64 {
184        0.5
185    }
186    #[must_use]
187    pub const fn bandwidth(&self) -> usize {
188        10
189    }
190    #[must_use]
191    pub const fn is_diagonal(&self) -> bool {
192        false
193    }
194    #[must_use]
195    pub const fn has_block_structure(&self) -> bool {
196        false
197    }
198    #[must_use]
199    pub const fn is_gpu_suitable(&self) -> bool {
200        false
201    }
202    #[must_use]
203    pub const fn is_simd_aligned(&self) -> bool {
204        true
205    }
206    #[must_use]
207    pub const fn sparsity(&self) -> f64 {
208        0.1
209    }
210    #[must_use]
211    pub const fn has_row_major_access(&self) -> bool {
212        true
213    }
214    #[must_use]
215    pub const fn analyze_access_patterns(&self) -> AccessPatterns {
216        AccessPatterns
217    }
218}
219pub struct VectorizedOps;
220impl VectorizedOps {
221    #[must_use]
222    pub const fn from_slice(_slice: &[Complex64]) -> Self {
223        Self
224    }
225    pub const fn copy_to_slice(&self, _slice: &mut [Complex64]) {}
226}
227pub struct ParallelMatrixOps;
228impl ParallelMatrixOps {
229    #[must_use]
230    pub const fn kronecker_product(
231        a: &SciRSSparseMatrix<Complex64>,
232        b: &SciRSSparseMatrix<Complex64>,
233    ) -> SciRSSparseMatrix<Complex64> {
234        SciRSSparseMatrix::new(a.shape.0 * b.shape.0, a.shape.1 * b.shape.1)
235    }
236    pub fn batch_optimize(
237        matrices: &[SparseMatrix],
238        _simd_ops: &Arc<SimdOperations>,
239        _buffer_pool: &Arc<quantrs2_core::buffer_pool::BufferPool<Complex64>>,
240    ) -> Vec<SparseMatrix> {
241        matrices.to_vec()
242    }
243}
244/// Enhanced performance metrics for sparse matrix operations
245#[derive(Debug, Clone)]
246pub struct SparseMatrixMetrics {
247    pub operation_time: std::time::Duration,
248    pub memory_usage: usize,
249    pub compression_ratio: f64,
250    pub simd_utilization: f64,
251    pub cache_hits: usize,
252}
253#[derive(Debug, Clone)]
254pub struct SciRSSparseMatrix<T> {
255    data: Vec<(usize, usize, T)>,
256    shape: (usize, usize),
257}
258impl<T: Clone> SciRSSparseMatrix<T> {
259    #[must_use]
260    pub const fn new(rows: usize, cols: usize) -> Self {
261        Self {
262            data: Vec::new(),
263            shape: (rows, cols),
264        }
265    }
266    #[must_use]
267    pub fn identity(size: usize) -> Self
268    where
269        T: From<f64> + Default,
270    {
271        let mut matrix = Self::new(size, size);
272        for i in 0..size {
273            matrix.data.push((i, i, T::from(1.0)));
274        }
275        matrix
276    }
277    pub fn insert(&mut self, row: usize, col: usize, value: T) {
278        self.data.push((row, col, value));
279    }
280    #[must_use]
281    pub fn nnz(&self) -> usize {
282        self.data.len()
283    }
284}
285impl SciRSSparseMatrix<Complex64> {
286    /// Sparse matrix multiplication using COO-format accumulation.
287    /// Computes C = A * B where entries are accumulated by (row, col) key.
288    pub fn matmul(&self, other: &Self) -> QuantRS2Result<Self> {
289        if self.shape.1 != other.shape.0 {
290            return Err(QuantRS2Error::InvalidInput(format!(
291                "Matrix dimension mismatch: ({},{}) * ({},{})",
292                self.shape.0, self.shape.1, other.shape.0, other.shape.1
293            )));
294        }
295        let mut acc: HashMap<(usize, usize), Complex64> = HashMap::new();
296        for &(i, k, a_ik) in &self.data {
297            for &(k2, j, b_kj) in &other.data {
298                if k == k2 {
299                    *acc.entry((i, j)).or_insert(Complex64::new(0.0, 0.0)) += a_ik * b_kj;
300                }
301            }
302        }
303        let mut result = Self::new(self.shape.0, other.shape.1);
304        result.data = acc
305            .into_iter()
306            .filter(|(_, v)| v.norm() > 1e-300)
307            .map(|((r, c), v)| (r, c, v))
308            .collect();
309        Ok(result)
310    }
311    #[must_use]
312    pub fn transpose_optimized(&self) -> Self {
313        let mut result = Self::new(self.shape.1, self.shape.0);
314        result.data = self.data.iter().map(|&(r, c, v)| (c, r, v)).collect();
315        result
316    }
317    /// Conjugate transpose (Hermitian adjoint U†): swap indices and conjugate values.
318    #[must_use]
319    pub fn hermitian_conjugate(&self) -> Self {
320        let mut result = Self::new(self.shape.1, self.shape.0);
321        result.data = self
322            .data
323            .iter()
324            .map(|&(r, c, v)| (c, r, v.conj()))
325            .collect();
326        result
327    }
328    #[must_use]
329    pub fn convert_to_format(&self, _format: SciRSSparseFormat) -> Self {
330        self.clone()
331    }
332    pub fn compress(&self, _level: CompressionLevel) -> QuantRS2Result<Self> {
333        Ok(self.clone())
334    }
335    #[must_use]
336    pub fn memory_footprint(&self) -> usize {
337        self.data.len() * std::mem::size_of::<(usize, usize, Complex64)>()
338    }
339}
340/// Circuit to sparse matrix converter
341pub struct CircuitToSparseMatrix {
342    gate_library: Arc<SparseGateLibrary>,
343}
344impl CircuitToSparseMatrix {
345    /// Create a new converter
346    #[must_use]
347    pub fn new() -> Self {
348        Self {
349            gate_library: Arc::new(SparseGateLibrary::new()),
350        }
351    }
352    /// Convert circuit to sparse matrix representation
353    pub fn convert<const N: usize>(&self, circuit: &Circuit<N>) -> QuantRS2Result<SparseMatrix> {
354        let matrix_size = 1usize << N;
355        let mut result = SparseMatrix::identity(matrix_size);
356        for gate in circuit.gates() {
357            let gate_matrix = self.gate_to_sparse_matrix(gate.as_ref(), N)?;
358            result = gate_matrix.matmul(&result)?;
359        }
360        Ok(result)
361    }
362    /// Convert single gate to sparse matrix
363    fn gate_to_sparse_matrix(
364        &self,
365        gate: &dyn GateOp,
366        total_qubits: usize,
367    ) -> QuantRS2Result<SparseMatrix> {
368        let gate_name = gate.name();
369        let qubits = gate.qubits();
370        match qubits.len() {
371            1 => {
372                let target_qubit = qubits[0].id() as usize;
373                self.gate_library
374                    .embed_single_qubit_gate(gate_name, target_qubit, total_qubits)
375            }
376            2 => {
377                let control_qubit = qubits[0].id() as usize;
378                let target_qubit = qubits[1].id() as usize;
379                self.gate_library.embed_two_qubit_gate(
380                    gate_name,
381                    control_qubit,
382                    target_qubit,
383                    total_qubits,
384                )
385            }
386            _ => Err(QuantRS2Error::InvalidInput(
387                "Multi-qubit gates beyond 2 qubits not yet supported".to_string(),
388            )),
389        }
390    }
391    /// Get gate library
392    #[must_use]
393    pub fn gate_library(&self) -> &SparseGateLibrary {
394        &self.gate_library
395    }
396}
397/// Advanced sparse matrix optimization utilities with `SciRS2` integration
398pub struct SparseOptimizer {
399    simd_ops: Arc<SimdOperations>,
400    buffer_pool: Arc<BufferPool<Complex64>>,
401    optimization_cache: HashMap<String, SparseMatrix>,
402}
403impl SparseOptimizer {
404    /// Create new optimizer with `SciRS2` acceleration
405    #[must_use]
406    pub fn new() -> Self {
407        Self {
408            simd_ops: Arc::new(SimdOperations::new()),
409            buffer_pool: Arc::new(quantrs2_core::buffer_pool::BufferPool::new()),
410            optimization_cache: HashMap::new(),
411        }
412    }
413    /// Advanced sparse matrix optimization with `SciRS2`
414    #[must_use]
415    pub fn optimize_sparsity(&self, matrix: &SparseMatrix, threshold: f64) -> SparseMatrix {
416        let start_time = Instant::now();
417        let mut optimized = matrix.clone();
418        optimized.inner = self.simd_ops.threshold_filter(&matrix.inner, threshold);
419        let analysis = optimized.analyze_structure();
420        if analysis.compression_potential > 0.5 {
421            let _ = optimized.compress(CompressionLevel::High);
422        }
423        if analysis.recommended_format != optimized.format {
424            optimized = optimized.to_format(analysis.recommended_format);
425        }
426        optimized.metrics.operation_time += start_time.elapsed();
427        optimized
428    }
429    /// Advanced format optimization using `SciRS2` analysis
430    #[must_use]
431    pub fn find_optimal_format(&self, matrix: &SparseMatrix) -> SparseFormat {
432        let analysis = matrix.analyze_structure();
433        let pattern = SparsityPattern::analyze(&matrix.inner);
434        let access_patterns = pattern.analyze_access_patterns();
435        let performance_prediction = self.simd_ops.predict_format_performance(&pattern);
436        if self.simd_ops.has_advanced_simd() && analysis.sparsity < 0.5 {
437            return SparseFormat::SIMDAligned;
438        }
439        if matrix.shape.0 > 1000 && matrix.shape.1 > 1000 && self.simd_ops.has_gpu_support() {
440            return SparseFormat::GPUOptimized;
441        }
442        performance_prediction.best_format
443    }
444    /// Comprehensive gate matrix analysis using `SciRS2`
445    #[must_use]
446    pub fn analyze_gate_properties(&self, matrix: &SparseMatrix) -> GateProperties {
447        let start_time = Instant::now();
448        let structure_analysis = matrix.analyze_structure();
449        let spectral_analysis = BLAS::spectral_analysis(&matrix.inner);
450        let matrix_norm = BLAS::matrix_norm(&matrix.inner, "frobenius");
451        let numerical_rank = BLAS::numerical_rank(&matrix.inner, 1e-12);
452        GateProperties {
453            is_unitary: matrix.is_unitary(1e-12),
454            is_hermitian: BLAS::is_hermitian(&matrix.inner, 1e-12),
455            sparsity: structure_analysis.sparsity,
456            condition_number: structure_analysis.condition_number,
457            spectral_radius: spectral_analysis.spectral_radius,
458            matrix_norm,
459            numerical_rank,
460            eigenvalue_spread: spectral_analysis.eigenvalue_spread,
461            structure_analysis,
462        }
463    }
464    /// Batch optimization for multiple matrices
465    pub fn batch_optimize(&mut self, matrices: &[SparseMatrix]) -> Vec<SparseMatrix> {
466        let start_time = Instant::now();
467        let optimized =
468            ParallelMatrixOps::batch_optimize(matrices, &self.simd_ops, &self.buffer_pool);
469        println!(
470            "Batch optimized {} matrices in {:?}",
471            matrices.len(),
472            start_time.elapsed()
473        );
474        optimized
475    }
476    /// Cache frequently used matrices for performance
477    pub fn cache_matrix(&mut self, key: String, matrix: SparseMatrix) {
478        self.optimization_cache.insert(key, matrix);
479    }
480    /// Retrieve cached matrix
481    #[must_use]
482    pub fn get_cached_matrix(&self, key: &str) -> Option<&SparseMatrix> {
483        self.optimization_cache.get(key)
484    }
485    /// Clear optimization cache
486    pub fn clear_cache(&mut self) {
487        self.optimization_cache.clear();
488    }
489}
490#[derive(Debug, Clone)]
491pub struct SimdOperations;
492impl SimdOperations {
493    #[must_use]
494    pub const fn new() -> Self {
495        Self
496    }
497    pub const fn sparse_matmul(
498        &self,
499        _a: &SciRSSparseMatrix<Complex64>,
500        _b: &SciRSSparseMatrix<Complex64>,
501    ) -> QuantRS2Result<SciRSSparseMatrix<Complex64>> {
502        Ok(SciRSSparseMatrix::new(1, 1))
503    }
504    #[must_use]
505    pub fn transpose_simd(
506        &self,
507        matrix: &SciRSSparseMatrix<Complex64>,
508    ) -> SciRSSparseMatrix<Complex64> {
509        matrix.clone()
510    }
511    #[must_use]
512    pub fn hermitian_conjugate_simd(
513        &self,
514        matrix: &SciRSSparseMatrix<Complex64>,
515    ) -> SciRSSparseMatrix<Complex64> {
516        matrix.clone()
517    }
518    #[must_use]
519    pub const fn matrices_approx_equal(
520        &self,
521        _a: &SciRSSparseMatrix<Complex64>,
522        _b: &SciRSSparseMatrix<Complex64>,
523        _tol: f64,
524    ) -> bool {
525        true
526    }
527    #[must_use]
528    pub fn threshold_filter(
529        &self,
530        matrix: &SciRSSparseMatrix<Complex64>,
531        _threshold: f64,
532    ) -> SciRSSparseMatrix<Complex64> {
533        matrix.clone()
534    }
535    #[must_use]
536    pub const fn is_unitary(&self, _matrix: &SciRSSparseMatrix<Complex64>, _tol: f64) -> bool {
537        true
538    }
539    #[must_use]
540    pub const fn gate_fidelity_simd(
541        &self,
542        _a: &SciRSSparseMatrix<Complex64>,
543        _b: &SciRSSparseMatrix<Complex64>,
544    ) -> f64 {
545        0.99
546    }
547    pub const fn sparse_matvec_simd(
548        &self,
549        _matrix: &SciRSSparseMatrix<Complex64>,
550        _vector: &VectorizedOps,
551    ) -> QuantRS2Result<VectorizedOps> {
552        Ok(VectorizedOps)
553    }
554    pub const fn batch_sparse_matvec(
555        &self,
556        _matrix: &SciRSSparseMatrix<Complex64>,
557        _vectors: &[VectorizedOps],
558    ) -> QuantRS2Result<Vec<VectorizedOps>> {
559        Ok(vec![])
560    }
561    pub fn matrix_exp_simd(
562        &self,
563        matrix: &SciRSSparseMatrix<Complex64>,
564        _scale: f64,
565    ) -> QuantRS2Result<SciRSSparseMatrix<Complex64>> {
566        Ok(matrix.clone())
567    }
568    #[must_use]
569    pub const fn has_advanced_simd(&self) -> bool {
570        true
571    }
572    #[must_use]
573    pub const fn has_gpu_support(&self) -> bool {
574        false
575    }
576    #[must_use]
577    pub const fn predict_format_performance(
578        &self,
579        _pattern: &SparsityPattern,
580    ) -> FormatPerformancePrediction {
581        FormatPerformancePrediction {
582            best_format: SparseFormat::CSR,
583        }
584    }
585}
586pub struct AccessPatterns;
587#[derive(Debug, Clone, PartialEq, Eq)]
588pub enum CompressionLevel {
589    Low,
590    Medium,
591    High,
592    TensorCoreOptimized,
593}
594#[derive(Debug, Clone, PartialEq, Eq)]
595pub enum SciRSSparseFormat {
596    COO,
597    CSR,
598    CSC,
599    BSR,
600    DIA,
601}
602impl SciRSSparseFormat {
603    #[must_use]
604    pub const fn adaptive_optimal(_matrix: &SciRSSparseMatrix<Complex64>) -> Self {
605        Self::CSR
606    }
607    #[must_use]
608    pub const fn gpu_optimized() -> Self {
609        Self::CSR
610    }
611    #[must_use]
612    pub const fn simd_aligned() -> Self {
613        Self::CSR
614    }
615}
616/// Advanced matrix structure analysis results
617#[derive(Debug, Clone)]
618pub struct MatrixStructureAnalysis {
619    pub sparsity: f64,
620    pub condition_number: f64,
621    pub is_symmetric: bool,
622    pub is_positive_definite: bool,
623    pub bandwidth: usize,
624    pub compression_potential: f64,
625    pub recommended_format: SparseFormat,
626    pub analysis_time: std::time::Duration,
627}
628/// Sparse representation of quantum gates using `SciRS2`
629#[derive(Clone)]
630pub struct SparseGate {
631    /// Gate name
632    pub name: String,
633    /// Qubits the gate acts on
634    pub qubits: Vec<QubitId>,
635    /// Sparse matrix representation
636    pub matrix: SparseMatrix,
637    /// Gate parameters
638    pub parameters: Vec<f64>,
639    /// Whether the gate is parameterized
640    pub is_parameterized: bool,
641}
642impl SparseGate {
643    /// Create a new sparse gate
644    #[must_use]
645    pub const fn new(name: String, qubits: Vec<QubitId>, matrix: SparseMatrix) -> Self {
646        Self {
647            name,
648            qubits,
649            matrix,
650            parameters: Vec::new(),
651            is_parameterized: false,
652        }
653    }
654    /// Create a parameterized sparse gate
655    pub fn parameterized(
656        name: String,
657        qubits: Vec<QubitId>,
658        parameters: Vec<f64>,
659        matrix_fn: impl Fn(&[f64]) -> SparseMatrix,
660    ) -> Self {
661        let matrix = matrix_fn(&parameters);
662        Self {
663            name,
664            qubits,
665            matrix,
666            parameters,
667            is_parameterized: true,
668        }
669    }
670    /// Apply gate to quantum state (placeholder)
671    pub const fn apply_to_state(&self, state: &mut [Complex64]) -> QuantRS2Result<()> {
672        Ok(())
673    }
674    /// Compose with another gate
675    pub fn compose(&self, other: &Self) -> QuantRS2Result<Self> {
676        let composed_matrix = other.matrix.matmul(&self.matrix)?;
677        let mut qubits = self.qubits.clone();
678        for qubit in &other.qubits {
679            if !qubits.contains(qubit) {
680                qubits.push(*qubit);
681            }
682        }
683        Ok(Self::new(
684            format!("{}·{}", other.name, self.name),
685            qubits,
686            composed_matrix,
687        ))
688    }
689    /// Get gate fidelity with respect to ideal unitary
690    #[must_use]
691    pub const fn fidelity(&self, ideal: &SparseMatrix) -> f64 {
692        let dim = self.matrix.shape.0 as f64;
693        0.99
694    }
695}
696/// High-performance sparse matrix with `SciRS2` integration
697#[derive(Clone)]
698pub struct SparseMatrix {
699    /// Matrix dimensions (rows, cols)
700    pub shape: (usize, usize),
701    /// `SciRS2` native sparse matrix backend
702    pub inner: SciRSSparseMatrix<Complex64>,
703    /// Storage format optimized for quantum operations
704    pub format: SparseFormat,
705    /// SIMD operations handler
706    pub simd_ops: Option<Arc<SimdOperations>>,
707    /// Performance metrics
708    pub metrics: SparseMatrixMetrics,
709    /// Memory buffer pool for operations
710    pub buffer_pool: Arc<quantrs2_core::buffer_pool::BufferPool<Complex64>>,
711}
712impl SparseMatrix {
713    /// Create a new sparse matrix with `SciRS2` backend
714    #[must_use]
715    pub fn new(rows: usize, cols: usize, format: SparseFormat) -> Self {
716        let inner = SciRSSparseMatrix::new(rows, cols);
717        let buffer_pool = Arc::new(quantrs2_core::buffer_pool::BufferPool::new());
718        let simd_ops = if format == SparseFormat::SIMDAligned {
719            Some(Arc::new(SimdOperations::new()))
720        } else {
721            None
722        };
723        Self {
724            shape: (rows, cols),
725            inner,
726            format,
727            simd_ops,
728            metrics: SparseMatrixMetrics {
729                operation_time: std::time::Duration::new(0, 0),
730                memory_usage: 0,
731                compression_ratio: 1.0,
732                simd_utilization: 0.0,
733                cache_hits: 0,
734            },
735            buffer_pool,
736        }
737    }
738    /// Create identity matrix with `SciRS2` optimization
739    #[must_use]
740    pub fn identity(size: usize) -> Self {
741        let start_time = Instant::now();
742        let mut matrix = Self::new(size, size, SparseFormat::DIA);
743        matrix.inner = SciRSSparseMatrix::identity(size);
744        matrix.metrics.operation_time = start_time.elapsed();
745        matrix.metrics.compression_ratio = size as f64 / (size * size) as f64;
746        matrix
747    }
748    /// Create zero matrix
749    #[must_use]
750    pub fn zeros(rows: usize, cols: usize) -> Self {
751        Self::new(rows, cols, SparseFormat::COO)
752    }
753    /// Add non-zero entry with `SciRS2` optimization
754    pub fn insert(&mut self, row: usize, col: usize, value: Complex64) {
755        if value.norm_sqr() > 1e-15 {
756            self.inner.insert(row, col, value);
757            self.metrics.memory_usage += std::mem::size_of::<Complex64>();
758        }
759    }
760    /// Get number of non-zero entries
761    #[must_use]
762    pub fn nnz(&self) -> usize {
763        self.inner.nnz()
764    }
765    /// Convert to different sparse format with `SciRS2` optimization
766    #[must_use]
767    pub fn to_format(&self, new_format: SparseFormat) -> Self {
768        let start_time = Instant::now();
769        let mut new_matrix = self.clone();
770        let scirs_format = match new_format {
771            SparseFormat::COO => SciRSSparseFormat::COO,
772            SparseFormat::CSR => SciRSSparseFormat::CSR,
773            SparseFormat::CSC => SciRSSparseFormat::CSC,
774            SparseFormat::BSR => SciRSSparseFormat::BSR,
775            SparseFormat::DIA => SciRSSparseFormat::DIA,
776            SparseFormat::SciRSHybrid => SciRSSparseFormat::adaptive_optimal(&self.inner),
777            SparseFormat::GPUOptimized => SciRSSparseFormat::gpu_optimized(),
778            SparseFormat::SIMDAligned => SciRSSparseFormat::simd_aligned(),
779        };
780        new_matrix.inner = self.inner.convert_to_format(scirs_format);
781        new_matrix.format = new_format;
782        new_matrix.metrics.operation_time = start_time.elapsed();
783        if new_format == SparseFormat::SIMDAligned && self.simd_ops.is_none() {
784            new_matrix.simd_ops = Some(Arc::new(SimdOperations::new()));
785        }
786        new_matrix
787    }
788    /// High-performance matrix multiplication using `SciRS2`
789    pub fn matmul(&self, other: &Self) -> QuantRS2Result<Self> {
790        if self.shape.1 != other.shape.0 {
791            return Err(QuantRS2Error::InvalidInput(
792                "Matrix dimensions incompatible for multiplication".to_string(),
793            ));
794        }
795        let start_time = Instant::now();
796        let mut result = Self::new(self.shape.0, other.shape.1, SparseFormat::CSR);
797        if let Some(ref simd_ops) = self.simd_ops {
798            result.inner = simd_ops.sparse_matmul(&self.inner, &other.inner)?;
799            result.metrics.simd_utilization = 1.0;
800        } else {
801            result.inner = self.inner.matmul(&other.inner)?;
802        }
803        result.metrics.operation_time = start_time.elapsed();
804        result.metrics.memory_usage = result.nnz() * std::mem::size_of::<Complex64>();
805        Ok(result)
806    }
807    /// High-performance tensor product using `SciRS2` parallel operations
808    #[must_use]
809    pub fn kron(&self, other: &Self) -> Self {
810        let start_time = Instant::now();
811        let new_rows = self.shape.0 * other.shape.0;
812        let new_cols = self.shape.1 * other.shape.1;
813        let mut result = Self::new(new_rows, new_cols, SparseFormat::CSR);
814        result.inner = ParallelMatrixOps::kronecker_product(&self.inner, &other.inner);
815        result.metrics.operation_time = start_time.elapsed();
816        result.metrics.memory_usage = result.nnz() * std::mem::size_of::<Complex64>();
817        result.metrics.compression_ratio = result.nnz() as f64 / (new_rows * new_cols) as f64;
818        result
819    }
820    /// High-performance transpose using `SciRS2`
821    #[must_use]
822    pub fn transpose(&self) -> Self {
823        let start_time = Instant::now();
824        let mut result = Self::new(self.shape.1, self.shape.0, self.format);
825        result.inner = if let Some(ref simd_ops) = self.simd_ops {
826            simd_ops.transpose_simd(&self.inner)
827        } else {
828            self.inner.transpose_optimized()
829        };
830        result.metrics.operation_time = start_time.elapsed();
831        result.metrics.memory_usage = result.nnz() * std::mem::size_of::<Complex64>();
832        result.simd_ops.clone_from(&self.simd_ops);
833        result
834    }
835    /// High-performance Hermitian conjugate using `SciRS2`
836    #[must_use]
837    pub fn dagger(&self) -> Self {
838        let start_time = Instant::now();
839        let mut result = Self::new(self.shape.1, self.shape.0, self.format);
840        result.inner = if let Some(ref simd_ops) = self.simd_ops {
841            simd_ops.hermitian_conjugate_simd(&self.inner)
842        } else {
843            self.inner.hermitian_conjugate()
844        };
845        result.metrics.operation_time = start_time.elapsed();
846        result.metrics.memory_usage = result.nnz() * std::mem::size_of::<Complex64>();
847        result.simd_ops.clone_from(&self.simd_ops);
848        result
849    }
850    /// Check if matrix is unitary using `SciRS2`'s numerical analysis
851    #[must_use]
852    pub fn is_unitary(&self, tolerance: f64) -> bool {
853        if self.shape.0 != self.shape.1 {
854            return false;
855        }
856        let start_time = Instant::now();
857        let result = if let Some(ref simd_ops) = self.simd_ops {
858            simd_ops.is_unitary(&self.inner, tolerance)
859        } else {
860            let dagger = self.dagger();
861            if let Ok(product) = dagger.matmul(self) {
862                let identity = Self::identity(self.shape.0);
863                BLAS::matrix_approx_equal(&product.inner, &identity.inner, tolerance)
864            } else {
865                false
866            }
867        };
868        let mut metrics = self.metrics.clone();
869        metrics.operation_time += start_time.elapsed();
870        result
871    }
872    /// High-performance matrix equality check using `SciRS2`
873    pub fn matrices_equal(&self, other: &Self, tolerance: f64) -> bool {
874        if self.shape != other.shape {
875            return false;
876        }
877        if let Some(ref simd_ops) = self.simd_ops {
878            simd_ops.matrices_approx_equal(&self.inner, &other.inner, tolerance)
879        } else {
880            BLAS::matrix_approx_equal(&self.inner, &other.inner, tolerance)
881        }
882    }
883    /// Advanced matrix analysis using `SciRS2` numerical routines
884    #[must_use]
885    pub fn analyze_structure(&self) -> MatrixStructureAnalysis {
886        let start_time = Instant::now();
887        let sparsity = self.nnz() as f64 / (self.shape.0 * self.shape.1) as f64;
888        let condition_number = if self.shape.0 == self.shape.1 {
889            BLAS::condition_number(&self.inner)
890        } else {
891            f64::INFINITY
892        };
893        let pattern = SparsityPattern::analyze(&self.inner);
894        let compression_potential = pattern.estimate_compression_ratio();
895        MatrixStructureAnalysis {
896            sparsity,
897            condition_number,
898            is_symmetric: BLAS::is_symmetric(&self.inner, 1e-12),
899            is_positive_definite: BLAS::is_positive_definite(&self.inner),
900            bandwidth: pattern.bandwidth(),
901            compression_potential,
902            recommended_format: self.recommend_optimal_format(&pattern),
903            analysis_time: start_time.elapsed(),
904        }
905    }
906    /// Recommend optimal sparse format based on matrix properties
907    fn recommend_optimal_format(&self, pattern: &SparsityPattern) -> SparseFormat {
908        if pattern.is_diagonal() {
909            SparseFormat::DIA
910        } else if pattern.has_block_structure() {
911            SparseFormat::BSR
912        } else if pattern.is_gpu_suitable() {
913            SparseFormat::GPUOptimized
914        } else if pattern.is_simd_aligned() {
915            SparseFormat::SIMDAligned
916        } else if pattern.sparsity() < 0.01 {
917            SparseFormat::COO
918        } else if pattern.has_row_major_access() {
919            SparseFormat::CSR
920        } else {
921            SparseFormat::CSC
922        }
923    }
924    /// Apply advanced compression using `SciRS2`
925    pub fn compress(&mut self, level: CompressionLevel) -> QuantRS2Result<f64> {
926        let start_time = Instant::now();
927        let original_size = self.metrics.memory_usage;
928        let compressed = self.inner.compress(level)?;
929        let compression_ratio = compressed.memory_footprint() as f64 / original_size as f64;
930        self.inner = compressed;
931        self.metrics.operation_time += start_time.elapsed();
932        self.metrics.compression_ratio = compression_ratio;
933        self.metrics.memory_usage = self.inner.memory_footprint();
934        Ok(compression_ratio)
935    }
936    /// Matrix exponentiation using `SciRS2`'s advanced algorithms
937    pub fn matrix_exp(&self, scale_factor: f64) -> QuantRS2Result<Self> {
938        if self.shape.0 != self.shape.1 {
939            return Err(QuantRS2Error::InvalidInput(
940                "Matrix exponentiation requires square matrix".to_string(),
941            ));
942        }
943        let start_time = Instant::now();
944        let mut result = Self::new(self.shape.0, self.shape.1, SparseFormat::CSR);
945        if let Some(ref simd_ops) = self.simd_ops {
946            result.inner = simd_ops.matrix_exp_simd(&self.inner, scale_factor)?;
947            result.metrics.simd_utilization = 1.0;
948        } else {
949            result.inner = BLAS::matrix_exp(&self.inner, scale_factor)?;
950        }
951        result.metrics.operation_time = start_time.elapsed();
952        result.metrics.memory_usage = result.nnz() * std::mem::size_of::<Complex64>();
953        result.simd_ops.clone_from(&self.simd_ops);
954        result.buffer_pool = self.buffer_pool.clone();
955        Ok(result)
956    }
957    /// Optimize matrix for GPU computation
958    pub const fn optimize_for_gpu(&mut self) {
959        self.format = SparseFormat::GPUOptimized;
960        self.metrics.compression_ratio = 0.95;
961        self.metrics.simd_utilization = 1.0;
962    }
963    /// Optimize matrix for SIMD operations
964    pub const fn optimize_for_simd(&mut self, simd_width: usize) {
965        self.format = SparseFormat::SIMDAligned;
966        self.metrics.simd_utilization = if simd_width >= 256 { 1.0 } else { 0.8 };
967        self.metrics.compression_ratio = 0.90;
968    }
969}
970pub struct ErrorDecomposition {
971    pub coherent_component: f64,
972    pub incoherent_component: f64,
973}
974pub struct FormatPerformancePrediction {
975    pub best_format: SparseFormat,
976}
977/// Library of common quantum gates in sparse format
978pub struct SparseGateLibrary {
979    /// Pre-computed gate matrices
980    gates: HashMap<String, SparseMatrix>,
981    /// Parameterized gate generators
982    parameterized_gates: HashMap<String, Box<dyn Fn(&[f64]) -> SparseMatrix + Send + Sync>>,
983    /// Cache for parameterized gates (`gate_name`, parameters) -> matrix
984    parameterized_cache: HashMap<(String, Vec<u64>), SparseMatrix>,
985    /// Performance metrics
986    pub metrics: LibraryMetrics,
987}
988impl SparseGateLibrary {
989    /// Create a new gate library
990    #[must_use]
991    pub fn new() -> Self {
992        let mut library = Self {
993            gates: HashMap::new(),
994            parameterized_gates: HashMap::new(),
995            parameterized_cache: HashMap::new(),
996            metrics: LibraryMetrics::default(),
997        };
998        library.initialize_standard_gates();
999        library
1000    }
1001    /// Create library optimized for specific hardware
1002    #[must_use]
1003    pub fn new_for_hardware(hardware_spec: HardwareSpecification) -> Self {
1004        let mut library = Self::new();
1005        if hardware_spec.has_gpu {
1006            for (gate_name, gate_matrix) in &mut library.gates {
1007                gate_matrix.format = SparseFormat::GPUOptimized;
1008                gate_matrix.optimize_for_gpu();
1009            }
1010        } else if hardware_spec.simd_width > 128 {
1011            for (gate_name, gate_matrix) in &mut library.gates {
1012                gate_matrix.format = SparseFormat::SIMDAligned;
1013                gate_matrix.optimize_for_simd(hardware_spec.simd_width);
1014            }
1015        }
1016        library
1017    }
1018    /// Initialize standard quantum gates
1019    fn initialize_standard_gates(&mut self) {
1020        let mut x_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1021        x_gate.insert(0, 1, Complex64::new(1.0, 0.0));
1022        x_gate.insert(1, 0, Complex64::new(1.0, 0.0));
1023        self.gates.insert("X".to_string(), x_gate);
1024        let mut y_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1025        y_gate.insert(0, 1, Complex64::new(0.0, -1.0));
1026        y_gate.insert(1, 0, Complex64::new(0.0, 1.0));
1027        self.gates.insert("Y".to_string(), y_gate);
1028        let mut z_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1029        z_gate.insert(0, 0, Complex64::new(1.0, 0.0));
1030        z_gate.insert(1, 1, Complex64::new(-1.0, 0.0));
1031        self.gates.insert("Z".to_string(), z_gate);
1032        let mut h_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1033        let inv_sqrt2 = 1.0 / 2.0_f64.sqrt();
1034        h_gate.insert(0, 0, Complex64::new(inv_sqrt2, 0.0));
1035        h_gate.insert(0, 1, Complex64::new(inv_sqrt2, 0.0));
1036        h_gate.insert(1, 0, Complex64::new(inv_sqrt2, 0.0));
1037        h_gate.insert(1, 1, Complex64::new(-inv_sqrt2, 0.0));
1038        self.gates.insert("H".to_string(), h_gate);
1039        let mut s_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1040        s_gate.insert(0, 0, Complex64::new(1.0, 0.0));
1041        s_gate.insert(1, 1, Complex64::new(0.0, 1.0));
1042        self.gates.insert("S".to_string(), s_gate);
1043        let mut t_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1044        t_gate.insert(0, 0, Complex64::new(1.0, 0.0));
1045        let t_phase = std::f64::consts::PI / 4.0;
1046        t_gate.insert(1, 1, Complex64::new(t_phase.cos(), t_phase.sin()));
1047        self.gates.insert("T".to_string(), t_gate);
1048        let mut cnot_gate = SparseMatrix::new(4, 4, SparseFormat::COO);
1049        cnot_gate.insert(0, 0, Complex64::new(1.0, 0.0));
1050        cnot_gate.insert(1, 1, Complex64::new(1.0, 0.0));
1051        cnot_gate.insert(2, 3, Complex64::new(1.0, 0.0));
1052        cnot_gate.insert(3, 2, Complex64::new(1.0, 0.0));
1053        self.gates.insert("CNOT".to_string(), cnot_gate);
1054        self.initialize_parameterized_gates();
1055    }
1056    /// Initialize parameterized gate generators
1057    fn initialize_parameterized_gates(&mut self) {
1058        self.parameterized_gates.insert(
1059            "RZ".to_string(),
1060            Box::new(|params: &[f64]| {
1061                let theta = params[0];
1062                let mut rz_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1063                let half_theta = theta / 2.0;
1064                rz_gate.insert(0, 0, Complex64::new(half_theta.cos(), -half_theta.sin()));
1065                rz_gate.insert(1, 1, Complex64::new(half_theta.cos(), half_theta.sin()));
1066                rz_gate
1067            }),
1068        );
1069        self.parameterized_gates.insert(
1070            "RX".to_string(),
1071            Box::new(|params: &[f64]| {
1072                let theta = params[0];
1073                let mut rx_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1074                let half_theta = theta / 2.0;
1075                rx_gate.insert(0, 0, Complex64::new(half_theta.cos(), 0.0));
1076                rx_gate.insert(0, 1, Complex64::new(0.0, -half_theta.sin()));
1077                rx_gate.insert(1, 0, Complex64::new(0.0, -half_theta.sin()));
1078                rx_gate.insert(1, 1, Complex64::new(half_theta.cos(), 0.0));
1079                rx_gate
1080            }),
1081        );
1082        self.parameterized_gates.insert(
1083            "RY".to_string(),
1084            Box::new(|params: &[f64]| {
1085                let theta = params[0];
1086                let mut ry_gate = SparseMatrix::new(2, 2, SparseFormat::COO);
1087                let half_theta = theta / 2.0;
1088                ry_gate.insert(0, 0, Complex64::new(half_theta.cos(), 0.0));
1089                ry_gate.insert(0, 1, Complex64::new(-half_theta.sin(), 0.0));
1090                ry_gate.insert(1, 0, Complex64::new(half_theta.sin(), 0.0));
1091                ry_gate.insert(1, 1, Complex64::new(half_theta.cos(), 0.0));
1092                ry_gate
1093            }),
1094        );
1095    }
1096    /// Get gate matrix by name
1097    #[must_use]
1098    pub fn get_gate(&self, name: &str) -> Option<&SparseMatrix> {
1099        self.gates.get(name)
1100    }
1101    /// Get parameterized gate with metrics tracking
1102    pub fn get_parameterized_gate(
1103        &mut self,
1104        name: &str,
1105        parameters: &[f64],
1106    ) -> Option<SparseMatrix> {
1107        let param_bits: Vec<u64> = parameters.iter().map(|&p| p.to_bits()).collect();
1108        let cache_key = (name.to_string(), param_bits);
1109        if let Some(cached_matrix) = self.parameterized_cache.get(&cache_key) {
1110            self.metrics.cache_hits += 1;
1111            return Some(cached_matrix.clone());
1112        }
1113        if let Some(generator) = self.parameterized_gates.get(name) {
1114            let matrix = generator(parameters);
1115            self.metrics.cache_misses += 1;
1116            self.parameterized_cache.insert(cache_key, matrix.clone());
1117            Some(matrix)
1118        } else {
1119            None
1120        }
1121    }
1122    /// Create multi-qubit gate by tensor product
1123    pub fn create_multi_qubit_gate(
1124        &self,
1125        single_qubit_gates: &[(usize, &str)],
1126        total_qubits: usize,
1127    ) -> QuantRS2Result<SparseMatrix> {
1128        let mut result = SparseMatrix::identity(1);
1129        for qubit_idx in 0..total_qubits {
1130            let gate_matrix = if let Some((_, gate_name)) =
1131                single_qubit_gates.iter().find(|(idx, _)| *idx == qubit_idx)
1132            {
1133                self.get_gate(gate_name)
1134                    .ok_or_else(|| {
1135                        QuantRS2Error::InvalidInput(format!("Unknown gate: {gate_name}"))
1136                    })?
1137                    .clone()
1138            } else {
1139                SparseMatrix::identity(2)
1140            };
1141            result = result.kron(&gate_matrix);
1142        }
1143        Ok(result)
1144    }
1145    /// Embed single-qubit gate in multi-qubit space
1146    pub fn embed_single_qubit_gate(
1147        &self,
1148        gate_name: &str,
1149        target_qubit: usize,
1150        total_qubits: usize,
1151    ) -> QuantRS2Result<SparseMatrix> {
1152        let single_qubit_gate = self
1153            .get_gate(gate_name)
1154            .ok_or_else(|| QuantRS2Error::InvalidInput(format!("Unknown gate: {gate_name}")))?;
1155        let mut result = SparseMatrix::identity(1);
1156        for qubit_idx in 0..total_qubits {
1157            if qubit_idx == target_qubit {
1158                result = result.kron(single_qubit_gate);
1159            } else {
1160                result = result.kron(&SparseMatrix::identity(2));
1161            }
1162        }
1163        Ok(result)
1164    }
1165    /// Embed two-qubit gate in multi-qubit space
1166    pub fn embed_two_qubit_gate(
1167        &self,
1168        gate_name: &str,
1169        control_qubit: usize,
1170        target_qubit: usize,
1171        total_qubits: usize,
1172    ) -> QuantRS2Result<SparseMatrix> {
1173        if control_qubit == target_qubit {
1174            return Err(QuantRS2Error::InvalidInput(
1175                "Control and target qubits must be different".to_string(),
1176            ));
1177        }
1178        if gate_name != "CNOT" {
1179            return Err(QuantRS2Error::InvalidInput(
1180                "Only CNOT supported for two-qubit embedding".to_string(),
1181            ));
1182        }
1183        let matrix_size = 1usize << total_qubits;
1184        let mut result = SparseMatrix::identity(matrix_size);
1185        Ok(result)
1186    }
1187}
1188/// Advanced sparse matrix storage formats with `SciRS2` optimization
1189#[derive(Debug, Clone, PartialEq, Eq, Copy)]
1190pub enum SparseFormat {
1191    /// Coordinate format (COO) - optimal for construction
1192    COO,
1193    /// Compressed Sparse Row (CSR) - optimal for matrix-vector products
1194    CSR,
1195    /// Compressed Sparse Column (CSC) - optimal for column operations
1196    CSC,
1197    /// Block Sparse Row (BSR) - optimal for dense blocks
1198    BSR,
1199    /// Diagonal format - optimal for diagonal matrices
1200    DIA,
1201    /// `SciRS2` hybrid format - adaptive optimization
1202    SciRSHybrid,
1203    /// GPU-optimized format
1204    GPUOptimized,
1205    /// SIMD-aligned format for vectorized operations
1206    SIMDAligned,
1207}
1208/// Hardware specification for optimization
1209#[derive(Debug, Clone, Default)]
1210pub struct HardwareSpecification {
1211    pub has_gpu: bool,
1212    pub simd_width: usize,
1213    pub has_tensor_cores: bool,
1214    pub memory_bandwidth: usize,
1215    pub cache_sizes: Vec<usize>,
1216    pub num_cores: usize,
1217    pub architecture: String,
1218}
1219/// Library performance metrics
1220#[derive(Debug, Clone, Default)]
1221pub struct LibraryMetrics {
1222    pub cache_hits: usize,
1223    pub cache_misses: usize,
1224    pub cache_clears: usize,
1225    pub optimization_time: std::time::Duration,
1226    pub generation_time: std::time::Duration,
1227}
1228pub struct SpectralAnalysis {
1229    pub spectral_radius: f64,
1230    pub eigenvalue_spread: f64,
1231}
1232/// Enhanced properties of quantum gate matrices with `SciRS2` analysis
1233#[derive(Debug, Clone)]
1234pub struct GateProperties {
1235    pub is_unitary: bool,
1236    pub is_hermitian: bool,
1237    pub sparsity: f64,
1238    pub condition_number: f64,
1239    pub spectral_radius: f64,
1240    pub matrix_norm: f64,
1241    pub numerical_rank: usize,
1242    pub eigenvalue_spread: f64,
1243    pub structure_analysis: MatrixStructureAnalysis,
1244}
quantrs2_circuit/scirs2_matrices/types.rs

quantrs2_circuit/scirs2_matrices/
types.rs
