qoqo 1.19.5

Quantum computing circuit toolkit. Python interface of roqoqo
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

// Copyright © 2021-2024 HQS Quantum Simulations GmbH. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the
// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing permissions and
// limitations under the License.

#[cfg(feature = "unstable_operation_definition")]
use crate::{convert_into_circuit, CircuitWrapper};
use pyo3::exceptions::PyRuntimeError;
use pyo3::prelude::*;
use pyo3::types::PySet;
use qoqo_macros::*;
use roqoqo::operations::*;
#[cfg(feature = "unstable_operation_definition")]
use roqoqo::Circuit;
#[cfg(feature = "json_schema")]
use roqoqo::ROQOQO_VERSION;
use std::collections::HashMap;

#[wrap(Operate, Define, JsonSchema)]
#[derive(Eq)]
/// DefinitionFloat is the Definition for a Float type register.
///
/// Args:
///     name (string): The name of the register that is defined.
///     length (int): The length of the register that is defined, usually the number of qubits to be measured.
///     is_output (bool): True/False if the variable is an output to the program.
pub struct DefinitionFloat {
    name: String,
    length: usize,
    is_output: bool,
}

#[wrap(Operate, Define, JsonSchema)]
#[derive(Eq)]
/// DefinitionComplex is the Definition for a Complex type register.
///
/// Args:
///     name (string): The name of the register that is defined.
///     length (int): The length of the register that is defined, usually the number of qubits to be measured.
///     is_output (bool): True/False if the variable is an output to the program.
pub struct DefinitionComplex {
    name: String,
    length: usize,
    is_output: bool,
}

#[wrap(Operate, Define, JsonSchema)]
#[derive(Eq)]
/// DefinitionUsize is the Definition for an Integer type register.
///
/// Args:
///     name (string): The name of the register that is defined.
///     length (int): The length of the register that is defined, usually the number of qubits to be measured.
///     is_output (bool): True/False if the variable is an output to the program.
pub struct DefinitionUsize {
    name: String,
    length: usize,
    is_output: bool,
}

#[wrap(Operate, Define, JsonSchema)]
#[derive(Eq)]
/// DefinitionBit is the Definition for a Bit type register.
///
/// Args:
///     name (string): The name of the register that is defined.
///     length (int): The length of the register that is defined, usually the number of qubits to be measured.
///     is_output (bool): True/False if the variable is an output to the program.
pub struct DefinitionBit {
    name: String,
    length: usize,
    is_output: bool,
}

#[wrap(Operate, Define, JsonSchema)]
/// InputSymbolic is the Definition for a Float which will replace a certain symbolic parameter.
///
/// Args:
///     name (string): The name of the register that is defined.
///     input (float): The float by which to replace the quantities marked as "name".
pub struct InputSymbolic {
    name: String,
    input: f64,
}

#[wrap(Operate, Define, JsonSchema)]
#[derive(Eq)]
/// InputBit sets a certain bit in an existing BitRegister of the circuit.
///
/// Args:
///     name (string): The name of the register that is defined.
///     index (int): The index in the register that is set.
///     value (int): The value the bit is set to.
pub struct InputBit {
    name: String,
    index: usize,
    value: bool,
}

#[cfg(feature = "unstable_operation_definition")]
#[wrap(Operate, Define, OperateMultiQubit, JsonSchema)]
/// GateDefinition is the Definition of a new custom gate.
///
/// Args:
///     circuit (Circuit): The circuit where the definition is stored.
///     name (str): The name of the gate that is defined.
///     qubits (List[int]): The indices of the qubits used in the internal definition.
///     free_parameter (List[str]): Names of the free CalculatorFloat variables in the internal definition.
pub struct GateDefinition {
    circuit: Circuit,
    name: String,
    qubits: Vec<usize>,
    free_parameters: Vec<String>,
}