dqcsim 0.0.4

DQCsim: Delft Quantum Classical Simulator
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

use super::*;

/// Creates a new set of qubit measurement results.
///>
///> Returns the handle of the newly created set. The set is initially empty.
#[no_mangle]
pub extern "C" fn dqcs_mset_new() -> dqcs_handle_t {
    insert(QubitMeasurementResultSet::new())
}

/// Returns the number of qubits measurements in the given measurement set.
///>
///> This function returns -1 to indicate failure.
#[no_mangle]
pub extern "C" fn dqcs_mset_len(mset: dqcs_handle_t) -> ssize_t {
    api_return(-1, || {
        resolve!(mset as &mut QubitMeasurementResultSet);
        Ok(mset.len() as ssize_t)
    })
}

/// Returns whether the given qubit measurement set contains data for the given
/// qubit.
#[no_mangle]
pub extern "C" fn dqcs_mset_contains(
    mset: dqcs_handle_t,
    qubit: dqcs_qubit_t,
) -> dqcs_bool_return_t {
    api_return_bool(|| {
        resolve!(mset as &mut QubitMeasurementResultSet);
        let qubit = QubitRef::from_foreign(qubit)
            .ok_or_else(oe_inv_arg("0 is not a valid qubit reference"))?;
        Ok(mset.contains_key(&qubit))
    })
}

/// Adds a measurement result to a measurement result set.
///>
///> If there was already a measurement for the specified qubit, the previous
///> measurement result is overwritten. The measurement result object is deleted
///> if and only if the function succeeds.
#[no_mangle]
pub extern "C" fn dqcs_mset_set(mset: dqcs_handle_t, meas: dqcs_handle_t) -> dqcs_return_t {
    api_return_none(|| {
        resolve!(mset as &mut QubitMeasurementResultSet);
        resolve!(meas as pending QubitMeasurementResult);
        let meas_ob: &QubitMeasurementResult = meas.as_ref()?;
        mset.insert(meas_ob.qubit, meas_ob.clone());
        delete!(resolved meas);
        Ok(())
    })
}

/// Returns a copy of the measurement result for the given qubit from a
/// measurement result set.
#[no_mangle]
pub extern "C" fn dqcs_mset_get(mset: dqcs_handle_t, qubit: dqcs_qubit_t) -> dqcs_handle_t {
    api_return(0, || {
        resolve!(mset as &QubitMeasurementResultSet);
        let qubit = QubitRef::from_foreign(qubit)
            .ok_or_else(oe_inv_arg("0 is not a valid qubit reference"))?;
        Ok(insert(
            mset.get(&qubit)
                .ok_or_else(oe_inv_arg("qubit not included in measurement set"))?
                .clone(),
        ))
    })
}

/// Returns the measurement result for the given qubit from a measurement
/// result set and removes it from the set.
#[no_mangle]
pub extern "C" fn dqcs_mset_take(mset: dqcs_handle_t, qubit: dqcs_qubit_t) -> dqcs_handle_t {
    api_return(0, || {
        resolve!(mset as &mut QubitMeasurementResultSet);
        let qubit = QubitRef::from_foreign(qubit)
            .ok_or_else(oe_inv_arg("0 is not a valid qubit reference"))?;
        Ok(insert(
            mset.remove(&qubit)
                .ok_or_else(oe_inv_arg("qubit not included in measurement set"))?
                .clone(),
        ))
    })
}

/// Removes the measurement result for the given qubit from a measurement
/// result set.
#[no_mangle]
pub extern "C" fn dqcs_mset_remove(mset: dqcs_handle_t, qubit: dqcs_qubit_t) -> dqcs_return_t {
    api_return_none(|| {
        resolve!(mset as &mut QubitMeasurementResultSet);
        let qubit = QubitRef::from_foreign(qubit)
            .ok_or_else(oe_inv_arg("0 is not a valid qubit reference"))?;
        mset.remove(&qubit)
            .ok_or_else(oe_inv_arg("qubit not included in measurement set"))?;
        Ok(())
    })
}

/// Returns the measurement result for any of the qubits contained in a
/// measurement result set and removes it from the set.
///>
///> This is useful for iteration.
#[no_mangle]
pub extern "C" fn dqcs_mset_take_any(mset: dqcs_handle_t) -> dqcs_handle_t {
    api_return(0, || {
        resolve!(mset as &mut QubitMeasurementResultSet);
        let qubit = *mset
            .keys()
            .next()
            .ok_or_else(oe_inv_arg("measurement set is empty"))?;
        Ok(insert(mset.remove(&qubit).unwrap().clone()))
    })
}