Skip to content

expression

Axis

Bases: Sequence[float64], Expression

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 
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
238
239
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
280
281
282
283
284
285
286
class Axis(Sequence[np.float64], Expression):
    """The ``Axis`` object parses and stores a vector containing 3 elements.

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

    _len = 3

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

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

    @property
    def value(self) -> NDArray[np.float64]:
        """The ``Axis`` 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)
        self._value = self.normalize(self._value)

    @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=float)
        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)
        return axis

    @staticmethod
    def normalize(axis: NDArray[np.float64]) -> NDArray[np.float64]:
        """Normalize a NDArray.

        Args:
            axis: NDArray to normalize.

        Returns:
            Normalized NDArray.
        """
        return axis / np.linalg.norm(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 ``Axis``."""
        return f"Axis{self.value}"

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

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

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

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

value property writable

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

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

Convert the Axis data to an array.

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

__eq__(other)

Check if self is equal to other.

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

Source code in opensquirrel/ir/expression.py 
279
280
281
282
283
284
285
286
def __eq__(self, other: Any) -> bool:
    """Check if `self` is equal to `other`.

    Two ``Axis`` objects are considered equal if their axes are equal.
    """
    if not isinstance(other, Axis):
        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 
259
260
261
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 Axis object.

axis: An AxisLike to create the axis from.

Source code in opensquirrel/ir/expression.py 
188
189
190
191
192
193
194
def __init__(self, *axis: AxisLike) -> None:
    """Init of the ``Axis`` object.

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

__len__()

Length of the axis, which is always 3.

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

__repr__()

String representation of the Axis.

Source code in opensquirrel/ir/expression.py 
267
268
269
def __repr__(self) -> str:
    """String representation of the ``Axis``."""
    return f"Axis{self.value}"

accept(visitor)

Accept the Axis.

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

normalize(axis) staticmethod

Normalize a NDArray.

Parameters:

Name Type Description Default
axis NDArray[float64]

NDArray to normalize.

 required

Returns:

Type Description
NDArray[float64]

Normalized NDArray.
Source code in opensquirrel/ir/expression.py 
241
242
243
244
245
246
247
248
249
250
251
@staticmethod
def normalize(axis: NDArray[np.float64]) -> NDArray[np.float64]:
    """Normalize a NDArray.

    Args:
        axis: NDArray to normalize.

    Returns:
        Normalized NDArray.
    """
    return axis / np.linalg.norm(axis)

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 
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
238
239
@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=float)
    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)
    return axis

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