qip 0.7.0

A library for efficient quantum computing simulations.
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

extern crate num;
use crate::types::Precision;
use num::Complex;
use std::fmt;

/// A private version of UnitaryOp with variable precision, this is used so we can change the f64
/// default UnitaryOp to a variable one at the beginning of execution and not at each operation.
pub enum PrecisionUnitaryOp<'a, P: Precision> {
    /// Indices, Matrix data
    Matrix(Vec<u64>, Vec<Complex<P>>),
    /// Indices, per row [(col, value)]
    SparseMatrix(Vec<u64>, Vec<Vec<(u64, Complex<P>)>>),
    /// A indices, B indices
    Swap(Vec<u64>, Vec<u64>),
    /// Control indices, Op indices, Op
    Control(Vec<u64>, Vec<u64>, Box<PrecisionUnitaryOp<'a, P>>),
    /// Function which maps |x,y> to |x,f(x) xor y> where x,y are both m bits.
    Function(
        Vec<u64>,
        Vec<u64>,
        &'a (dyn Fn(u64) -> (u64, f64) + Send + Sync),
    ),
}

impl<'a, P: Precision> fmt::Debug for PrecisionUnitaryOp<'a, P> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let (name, indices) = match self {
            PrecisionUnitaryOp::Matrix(indices, _) => ("Matrix".to_string(), indices.clone()),
            PrecisionUnitaryOp::SparseMatrix(indices, _) => {
                ("SparseMatrix".to_string(), indices.clone())
            }
            PrecisionUnitaryOp::Swap(a_indices, b_indices) => {
                let indices: Vec<_> = a_indices
                    .iter()
                    .cloned()
                    .chain(b_indices.iter().cloned())
                    .collect();
                ("Swap".to_string(), indices)
            }
            PrecisionUnitaryOp::Control(indices, _, op) => {
                let name = format!("C({:?})", *op);
                (name, indices.clone())
            }
            PrecisionUnitaryOp::Function(a_indices, b_indices, _) => {
                let indices: Vec<_> = a_indices
                    .iter()
                    .cloned()
                    .chain(b_indices.iter().cloned())
                    .collect();
                ("F".to_string(), indices)
            }
        };
        let int_strings = indices
            .iter()
            .map(|x| x.clone().to_string())
            .collect::<Vec<String>>();

        write!(f, "{}[{}]", name, int_strings.join(", "))
    }
}

/// Get the number of indices represented by `op`
pub fn precision_num_indices<P: Precision>(op: &PrecisionUnitaryOp<P>) -> usize {
    match &op {
        PrecisionUnitaryOp::Matrix(indices, _) => indices.len(),
        PrecisionUnitaryOp::SparseMatrix(indices, _) => indices.len(),
        PrecisionUnitaryOp::Swap(a, b) => a.len() + b.len(),
        PrecisionUnitaryOp::Control(cs, os, _) => cs.len() + os.len(),
        PrecisionUnitaryOp::Function(inputs, outputs, _) => inputs.len() + outputs.len(),
    }
}

/// Get the `i`th qubit index for `op`
pub fn precision_get_index<P: Precision>(op: &PrecisionUnitaryOp<P>, i: usize) -> u64 {
    match &op {
        PrecisionUnitaryOp::Matrix(indices, _) => indices[i],
        PrecisionUnitaryOp::SparseMatrix(indices, _) => indices[i],
        PrecisionUnitaryOp::Swap(a, b) => {
            if i < a.len() {
                a[i]
            } else {
                b[i - a.len()]
            }
        }
        PrecisionUnitaryOp::Control(cs, os, _) => {
            if i < cs.len() {
                cs[i]
            } else {
                os[i - cs.len()]
            }
        }
        PrecisionUnitaryOp::Function(inputs, outputs, _) => {
            if i < inputs.len() {
                inputs[i]
            } else {
                outputs[i - inputs.len()]
            }
        }
    }
}