Skip to content

expression

Axis

Bases: BaseAxis

The Axis object parses and stores a vector containing 3 elements.

The input vector is always normalized before it is stored.

Source code in opensquirrel/ir/expression.py 
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
class Axis(BaseAxis):
    """The ``Axis`` object parses and stores a vector containing 3 elements.

    The input vector is always normalized before it is stored.
    """

    @staticmethod
    def parse(axis: AxisLike) -> NDArray[np.float64]:
        """Parse and validate an ``AxisLike``.

        Check if the `axis` can be cast to a 1DArray of length 3, raise an error otherwise.
        After casting to an array, the axis is normalized.

        Args:
            axis: ``AxisLike`` to validate and parse.

        Returns:
            Parsed axis represented as a 1DArray of length 3.
        """
        if isinstance(axis, Axis):
            return axis.value

        try:
            axis = np.asarray(axis, dtype=np.float64)
        except (ValueError, TypeError) as e:
            msg = "axis requires an ArrayLike"
            raise TypeError(msg) from e
        axis = axis.flatten()
        if len(axis) != 3:
            msg = f"axis requires an ArrayLike of length 3, but received an ArrayLike of length {len(axis)}"
            raise ValueError(msg)
        if np.all(axis == 0):
            msg = "axis requires at least one element to be non-zero"
            raise ValueError(msg)
        axis = cast("NDArray[np.float64]", axis)
        return axis / np.linalg.norm(axis)

    def accept(self, visitor: IRVisitor) -> Any:
        """Accept the ``Axis``."""
        return visitor.visit_axis(self)

accept(visitor)

Accept the Axis.

Source code in opensquirrel/ir/expression.py 
277
278
279
def accept(self, visitor: IRVisitor) -> Any:
    """Accept the ``Axis``."""
    return visitor.visit_axis(self)

parse(axis) staticmethod

Parse and validate an AxisLike.

Check if the axis can be cast to a 1DArray of length 3, raise an error otherwise. After casting to an array, the axis is normalized.

Parameters:

Name Type Description Default
axis AxisLike

AxisLike to validate and parse.

 required

Returns:

Type Description
NDArray[float64]

Parsed axis represented as a 1DArray of length 3.
Source code in opensquirrel/ir/expression.py 
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
@staticmethod
def parse(axis: AxisLike) -> NDArray[np.float64]:
    """Parse and validate an ``AxisLike``.

    Check if the `axis` can be cast to a 1DArray of length 3, raise an error otherwise.
    After casting to an array, the axis is normalized.

    Args:
        axis: ``AxisLike`` to validate and parse.

    Returns:
        Parsed axis represented as a 1DArray of length 3.
    """
    if isinstance(axis, Axis):
        return axis.value

    try:
        axis = np.asarray(axis, dtype=np.float64)
    except (ValueError, TypeError) as e:
        msg = "axis requires an ArrayLike"
        raise TypeError(msg) from e
    axis = axis.flatten()
    if len(axis) != 3:
        msg = f"axis requires an ArrayLike of length 3, but received an ArrayLike of length {len(axis)}"
        raise ValueError(msg)
    if np.all(axis == 0):
        msg = "axis requires at least one element to be non-zero"
        raise ValueError(msg)
    axis = cast("NDArray[np.float64]", axis)
    return axis / np.linalg.norm(axis)

BaseAxis

Bases: Sequence[float64], Expression, ABC

Source code in opensquirrel/ir/expression.py 
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
class BaseAxis(Sequence[np.float64], Expression, ABC):
    _len = 3

    def __init__(self, *axis: AxisLike) -> None:
        """Init of the ``BaseAxis`` object.

        axis: An ``AxisLike`` to create the axis from.
        """
        self.value = axis[0] if len(axis) == 1 else cast("AxisLike", axis)

    @staticmethod
    @abstractmethod
    def parse(axis: AxisLike) -> NDArray[np.float64]: ...

    @property
    def value(self) -> NDArray[np.float64]:
        """The ``BaseAxis`` data saved as a 1D-Array with 3 elements."""
        return self._value

    @value.setter
    def value(self, axis: AxisLike) -> None:
        """Parse and set a new axis.

        Args:
            axis: An ``AxisLike`` to create the axis from.
        """
        self._value = self.parse(axis)

    @overload
    def __getitem__(self, i: int, /) -> np.float64: ...

    @overload
    def __getitem__(self, s: slice, /) -> list[np.float64]: ...

    def __getitem__(self, index: int | slice, /) -> np.float64 | list[np.float64]:
        """Get the item at `index`."""
        return cast("np.float64", self.value[index])

    def __len__(self) -> int:
        """Length of the axis, which is always 3."""
        return self._len

    def __repr__(self) -> str:
        """String representation of the ``BaseAxis``."""
        return f"{self.__class__.__name__}{self.value}"

    def __array__(self, dtype: DTypeLike = None, *, copy: bool | None = None) -> NDArray[Any]:
        """Convert the ``BaseAxis`` data to an array."""
        return np.array(self.value, dtype=dtype, copy=copy)

    def __eq__(self, other: Any) -> bool:
        """Check if `self` is equal to `other`.

        Two ``BaseAxis`` objects are considered equal if their axes are equal.
        """
        if not isinstance(other, self.__class__):
            return False
        return np.array_equal(self, other)

value property writable

The BaseAxis data saved as a 1D-Array with 3 elements.

__array__(dtype=None, *, copy=None)

Convert the BaseAxis data to an array.

Source code in opensquirrel/ir/expression.py 
226
227
228
def __array__(self, dtype: DTypeLike = None, *, copy: bool | None = None) -> NDArray[Any]:
    """Convert the ``BaseAxis`` data to an array."""
    return np.array(self.value, dtype=dtype, copy=copy)

__eq__(other)

Check if self is equal to other.

Two BaseAxis objects are considered equal if their axes are equal.

Source code in opensquirrel/ir/expression.py 
230
231
232
233
234
235
236
237
def __eq__(self, other: Any) -> bool:
    """Check if `self` is equal to `other`.

    Two ``BaseAxis`` objects are considered equal if their axes are equal.
    """
    if not isinstance(other, self.__class__):
        return False
    return np.array_equal(self, other)

__getitem__(index) 

__getitem__(i: int) -> np.float64

__getitem__(s: slice) -> list[np.float64]

Get the item at index.

Source code in opensquirrel/ir/expression.py 
214
215
216
def __getitem__(self, index: int | slice, /) -> np.float64 | list[np.float64]:
    """Get the item at `index`."""
    return cast("np.float64", self.value[index])

__init__(*axis)

Init of the BaseAxis object.

axis: An AxisLike to create the axis from.

Source code in opensquirrel/ir/expression.py 
183
184
185
186
187
188
def __init__(self, *axis: AxisLike) -> None:
    """Init of the ``BaseAxis`` object.

    axis: An ``AxisLike`` to create the axis from.
    """
    self.value = axis[0] if len(axis) == 1 else cast("AxisLike", axis)

__len__()

Length of the axis, which is always 3.

Source code in opensquirrel/ir/expression.py 
218
219
220
def __len__(self) -> int:
    """Length of the axis, which is always 3."""
    return self._len

__repr__()

String representation of the BaseAxis.

Source code in opensquirrel/ir/expression.py 
222
223
224
def __repr__(self) -> str:
    """String representation of the ``BaseAxis``."""
    return f"{self.__class__.__name__}{self.value}"

Float dataclass

Bases: Expression

Floats used for intermediate representation of Statement arguments.

Attributes:

Name Type Description
value float

value of the Float object.
Source code in opensquirrel/ir/expression.py 
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
@dataclass(init=False)
class Float(Expression):
    """Floats used for intermediate representation of ``Statement`` arguments.

    Attributes:
        value: value of the ``Float`` object.
    """

    value: float

    def __init__(self, value: SupportsFloat) -> None:
        """Init of the ``Float`` object.

        Args:
            value: value of the ``Float`` object.
        """
        if isinstance(value, SupportsFloat):
            self.value = float(value)
            return

        msg = "value must be a float"
        raise TypeError(msg)

    def __float__(self) -> float:
        """Cast the ``Float`` object to a built-in Python ``float``.

        Returns:
            Built-in Python ``float`` representation of the ``Float``.
        """
        return self.value

    def accept(self, visitor: IRVisitor) -> Any:
        return visitor.visit_float(self)

__float__()

Cast the Float object to a built-in Python float.

Returns:

Type Description
float

Built-in Python float representation of the Float.
Source code in opensquirrel/ir/expression.py 
81
82
83
84
85
86
87
def __float__(self) -> float:
    """Cast the ``Float`` object to a built-in Python ``float``.

    Returns:
        Built-in Python ``float`` representation of the ``Float``.
    """
    return self.value

__init__(value)

Init of the Float object.

Parameters:

Name Type Description Default
value SupportsFloat

value of the Float object.

 required
Source code in opensquirrel/ir/expression.py 
68
69
70
71
72
73
74
75
76
77
78
79
def __init__(self, value: SupportsFloat) -> None:
    """Init of the ``Float`` object.

    Args:
        value: value of the ``Float`` object.
    """
    if isinstance(value, SupportsFloat):
        self.value = float(value)
        return

    msg = "value must be a float"
    raise TypeError(msg)

Int dataclass

Bases: Expression

Integers used for intermediate representation of Statement arguments.

Attributes:

Name Type Description
value int

value of the Int object.
Source code in opensquirrel/ir/expression.py 
 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
@dataclass(init=False)
class Int(Expression):
    """Integers used for intermediate representation of ``Statement`` arguments.

    Attributes:
        value: value of the ``Int`` object.
    """

    value: int

    def __init__(self, value: SupportsInt) -> None:
        """Init of the ``Int`` object.

        Args:
            value: value of the ``Int`` object.
        """
        if isinstance(value, SupportsInt):
            self.value = int(value)
            return

        msg = "value must be an int"
        raise TypeError(msg)

    def __int__(self) -> int:
        """Cast the ``Int`` object to a built-in Python ``int``.

        Returns:
            Built-in Python ``int`` representation of the ``Int``.
        """
        return self.value

    def accept(self, visitor: IRVisitor) -> Any:
        return visitor.visit_int(self)

__init__(value)

Init of the Int object.

Parameters:

Name Type Description Default
value SupportsInt

value of the Int object.

 required
Source code in opensquirrel/ir/expression.py 
103
104
105
106
107
108
109
110
111
112
113
114
def __init__(self, value: SupportsInt) -> None:
    """Init of the ``Int`` object.

    Args:
        value: value of the ``Int`` object.
    """
    if isinstance(value, SupportsInt):
        self.value = int(value)
        return

    msg = "value must be an int"
    raise TypeError(msg)

__int__()

Cast the Int object to a built-in Python int.

Returns:

Type Description
int

Built-in Python int representation of the Int.
Source code in opensquirrel/ir/expression.py 
116
117
118
119
120
121
122
def __int__(self) -> int:
    """Cast the ``Int`` object to a built-in Python ``int``.

    Returns:
        Built-in Python ``int`` representation of the ``Int``.
    """
    return self.value

Qubit dataclass

Bases: Expression

Qubit is used for intermediate representation of Statement arguments.

Attributes:

Name Type Description
index int

index of the Qubit object.
Source code in opensquirrel/ir/expression.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
@dataclass(init=False)
class Qubit(Expression):
    """``Qubit`` is used for intermediate representation of ``Statement`` arguments.

    Attributes:
        index: index of the ``Qubit`` object.
    """

    index: int

    def __init__(self, index: QubitLike) -> None:
        if isinstance(index, SupportsInt):
            self.index = int(index)
        elif isinstance(index, Qubit):
            self.index = index.index
        else:
            msg = "index must be a QubitLike"
            raise TypeError(msg)

    def __hash__(self) -> int:
        return hash(str(self.__class__) + str(self.index))

    def __repr__(self) -> str:
        return f"Qubit[{self.index}]"

    def accept(self, visitor: IRVisitor) -> Any:
        return visitor.visit_qubit(self)

String dataclass

Bases: Expression

Strings used for intermediate representation of Statement arguments.

Attributes:

Name Type Description
value str

value of the String object.
Source code in opensquirrel/ir/expression.py 
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
@dataclass(init=False)
class String(Expression):
    """Strings used for intermediate representation of ``Statement`` arguments.

    Attributes:
        value: value of the ``String`` object.
    """

    value: str

    def __init__(self, value: SupportsStr) -> None:
        """Init of the ``String`` object.

        Args:
            value: value of the ``String`` object.
        """
        if isinstance(value, SupportsStr):
            self.value = str(value)
            return

        msg = "value must be a str"
        raise TypeError(msg)

    def __str__(self) -> str:
        """Cast the ``String`` object to a built-in Python ``str``.

        Returns:
            Built-in Python ``str`` representation of the ``String``.
        """
        return self.value

    def accept(self, visitor: IRVisitor) -> Any:
        return visitor.visit_str(self)

__init__(value)

Init of the String object.

Parameters:

Name Type Description Default
value SupportsStr

value of the String object.

 required
Source code in opensquirrel/ir/expression.py 
33
34
35
36
37
38
39
40
41
42
43
44
def __init__(self, value: SupportsStr) -> None:
    """Init of the ``String`` object.

    Args:
        value: value of the ``String`` object.
    """
    if isinstance(value, SupportsStr):
        self.value = str(value)
        return

    msg = "value must be a str"
    raise TypeError(msg)

__str__()

Cast the String object to a built-in Python str.

Returns:

Type Description
str

Built-in Python str representation of the String.
Source code in opensquirrel/ir/expression.py 
46
47
48
49
50
51
52
def __str__(self) -> str:
    """Cast the ``String`` object to a built-in Python ``str``.

    Returns:
        Built-in Python ``str`` representation of the ``String``.
    """
    return self.value