classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/interface/generator/arith/binary_ops.py

@@ -617,7 +617,7 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
         *,
         arg: RegisterArithmeticInfo,
         action_right_arg: RegisterOrConst,
-        compute_power: int
+        compute_power: int,
     ) -> pydantic.NonNegativeInt:
         inner_compute_power_params = Power(
             left_arg=arg,
@@ -800,6 +800,7 @@ class Modulo(EffectiveUnaryOpParams[int]):
         return 2 ** (repr_qubits)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        return RegisterArithmeticInfo(
-            size=round(math.log2(self.right_arg)), is_signed=False, fraction_places=0
-        )
+        size = round(math.log2(self.right_arg))
+        if size <= 0:
+            raise ClassiqValueError("Cannot use a quantum expression with zero size")
+        return RegisterArithmeticInfo(size=size, is_signed=False, fraction_places=0)

classiq/interface/generator/arith/extremum_operations.py

@@ -57,38 +57,56 @@ class Extremum(ArithmeticOperationParams):
     def _bound_calculator(cls, arg1: float, arg2: float) -> float:
         pass
 
+    @staticmethod
+    def _less_qubits_arg(
+        arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        if not isinstance(arg1, RegisterArithmeticInfo):
+            return arg1
+        if not isinstance(arg2, RegisterArithmeticInfo):
+            return arg2
+        return arg1 if arg1.size <= arg2.size else arg2
+
     @classmethod
     @abc.abstractmethod
-    def _preferred_arg(
+    def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
     ) -> RegisterOrConst:
         pass
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        if argument_utils.arg_bounds_overlap((self.left_arg, self.right_arg)):
-            return self._get_general_case_result_register()
+        eff_left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, self.machine_precision
+        )
+        eff_right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, self.machine_precision
+        )
+        if argument_utils.arg_bounds_overlap((eff_left_arg, eff_right_arg)):
+            return self._get_general_case_result_register(eff_left_arg, eff_right_arg)
         return argument_utils.as_arithmetic_info(
-            self._preferred_arg(self.left_arg, self.right_arg)
+            self.preferred_arg(eff_left_arg, eff_right_arg)
         )
 
-    def _get_general_case_result_register(self) -> RegisterArithmeticInfo:
+    def _get_general_case_result_register(
+        self, eff_left_arg: RegisterOrConst, eff_right_arg: RegisterOrConst
+    ) -> RegisterArithmeticInfo:
         integer_part_size = max(
-            argument_utils.integer_part_size(self.left_arg),
-            argument_utils.integer_part_size(self.right_arg),
+            argument_utils.integer_part_size(eff_left_arg),
+            argument_utils.integer_part_size(eff_right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(eff_left_arg),
+            argument_utils.fraction_places(eff_right_arg),
         )
         required_size = integer_part_size + fraction_places
         bounds = (
             self._bound_calculator(
-                argument_utils.lower_bound(self.left_arg),
-                argument_utils.lower_bound(self.right_arg),
+                argument_utils.lower_bound(eff_left_arg),
+                argument_utils.lower_bound(eff_right_arg),
             ),
             self._bound_calculator(
-                argument_utils.upper_bound(self.left_arg),
-                argument_utils.upper_bound(self.right_arg),
+                argument_utils.upper_bound(eff_left_arg),
+                argument_utils.upper_bound(eff_right_arg),
             ),
         )
         return RegisterArithmeticInfo(
@@ -107,12 +125,15 @@ class Min(Extremum):
         return min(arg1, arg2)
 
     @classmethod
-    def _preferred_arg(
+    def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
     ) -> RegisterOrConst:
-        if min(argument_utils.bounds(arg1)) < min(argument_utils.bounds(arg2)):
+        min1, min2 = min(argument_utils.bounds(arg1)), min(argument_utils.bounds(arg2))
+        if min1 < min2:
             return arg1
-        return arg2
+        if min2 < min1:
+            return arg2
+        return cls._less_qubits_arg(arg1, arg2)
 
 
 class Max(Extremum):
@@ -123,9 +144,12 @@ class Max(Extremum):
         return max(arg1, arg2)
 
     @classmethod
-    def _preferred_arg(
+    def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
     ) -> RegisterOrConst:
-        if max(argument_utils.bounds(arg1)) > max(argument_utils.bounds(arg2)):
+        max1, max2 = max(argument_utils.bounds(arg1)), max(argument_utils.bounds(arg2))
+        if max1 > max2:
             return arg1
-        return arg2
+        if max2 > max1:
+            return arg2
+        return cls._less_qubits_arg(arg1, arg2)

classiq/interface/generator/constant.py

@@ -1,6 +1,6 @@
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
 
 class Constant(ASTNode):

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -24,6 +24,7 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseXor",
     "BitwiseNot",
     "BitwiseOr",
+    "LogicalXor",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/interface/generator/expressions/expression_constants.py

@@ -1,5 +1,5 @@
 import keyword
-from typing import Set
+from typing import Final, FrozenSet, Set
 
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -18,3 +18,5 @@ SUPPORTED_FUNC_NAMES: Set[str] = (
 )
 BOOLEAN_LITERALS = {"True", "False"}
 FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
+RESERVED_EXPRESSIONS: FrozenSet[str] = frozenset({"i"})

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -1,4 +1,6 @@
-from typing import Any, Callable, Mapping, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Mapping, Union
+
+from sympy import Integer
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
@@ -11,88 +13,81 @@ from classiq.interface.model.handle_binding import (
 
 from classiq.exceptions import ClassiqValueError
 
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
-SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
-QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
+SLICE_OUT_OF_BOUNDS_MSG = "Slice indices out of bounds"
+SUBSCRIPT_OUT_OF_BOUNDS_MSG = "Subscript index out of bounds"
+ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
+ILLEGAL_SLICE_BOUNDS_MSG = (
+    "The quantum array slice start value ({}) must be lower than its stop value ({})."
+)
 
 
 class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def __init__(
         self,
         handle: HandleBinding,
-        element_proxy: Callable[[HandleBinding], QmodSizedProxy],
+        element_type: "QuantumType",
         element_size: int,
         length: int,
     ) -> None:
         super().__init__(handle, element_size * length)
         self._length = length
-        self._element_proxy = element_proxy
+        self._element_type = element_type
         self._element_size = element_size
 
-    def __getitem__(self, key: Union[slice, int]) -> "QmodSizedProxy":
-        if self._index is not None:
-            raise TypeError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+        return (
+            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
+        )
 
-        new_index: Optional[int] = None
+    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
+        if isinstance(index, Integer):
+            index = int(index)
+        if index < 0 or index >= self._length:
+            raise ClassiqValueError(SUBSCRIPT_OUT_OF_BOUNDS_MSG)
 
-        if isinstance(key, slice):
-            if key.step is not None:
-                raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-            new_slice = self._get_new_slice(key.start, key.stop)
-        else:
-            new_slice = self._get_new_slice(key, key + 1)
-            new_index = new_slice[0]
+        return self._element_type.get_proxy(
+            SubscriptHandleBinding(
+                base_handle=self.handle,
+                index=Expression(expr=str(index)),
+            )
+        )
 
-        if (self._slice is not None and new_slice[1] > self._slice[1]) or new_slice[
-            1
-        ] > self._size:
+    def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
+        if slice_.step is not None:
+            raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+        if isinstance(slice_.start, Integer):
+            slice_ = slice(int(slice_.start), slice_.stop)
+        if isinstance(slice_.stop, Integer):
+            slice_ = slice(slice_.start, int(slice_.stop))
+        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
+            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
+        if slice_.start >= slice_.stop:
+            raise ClassiqValueError(
+                ILLEGAL_SLICE_BOUNDS_MSG.format(slice_.start, slice_.stop)
+            )
+        if slice_.start < 0 or slice_.stop > self._length:
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
 
-        new_handle = self._get_new_handle(new_index, new_slice)
-        if new_index is not None:
-            return self._element_proxy(new_handle)
         return QmodQArrayProxy(
-            new_handle,
-            self._element_proxy,
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(slice_.start)),
+                end=Expression(expr=str(slice_.stop)),
+            ),
+            self._element_type,
             self._element_size,
-            self._length,
+            slice_.stop - slice_.start,
         )
 
-    def _get_new_slice(self, start: int, end: int) -> Tuple[int, int]:
-        if self._slice is not None:
-            return self._slice[0] + start, self._slice[0] + end
-        return start, end
-
     @property
     def type_name(self) -> str:
         return "Quantum array"
 
-    @property
-    def _index(self) -> Optional[int]:
-        if not isinstance(self._handle, SubscriptHandleBinding):
-            return None
-        return self._handle.index.to_int_value()
-
-    @property
-    def _slice(self) -> Optional[Tuple[int, int]]:
-        if not isinstance(self._handle, SlicedHandleBinding):
-            return None
-        return self._handle.start.to_int_value(), self._handle.end.to_int_value()
-
-    def _get_new_handle(
-        self, new_index: Optional[int], new_slice: Tuple[int, int]
-    ) -> HandleBinding:
-        if new_index is not None:
-            return SubscriptHandleBinding(
-                name=self.handle.name,
-                index=Expression(expr=str(new_index)),
-            )
-        return SlicedHandleBinding(
-            name=self.handle.name,
-            start=Expression(expr=str(new_slice[0])),
-            end=Expression(expr=str(new_slice[1])),
-        )
-
     @property
     def len(self) -> int:
         return self._length
@@ -105,13 +100,4 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
 
     @property
     def size(self) -> int:
-        if (slice_ := self._slice) is not None:
-            length = slice_[1] - slice_[0]
-        elif self._index is not None:
-            length = 1
-        else:
-            length = self._length
-        return length * self._element_size
-
-    def __str__(self) -> str:
-        return str(self.handle)
+        return self.len * self._element_size

classiq/interface/generator/expressions/qmod_qstruct_proxy.py

@@ -0,0 +1,35 @@
+from typing import TYPE_CHECKING, Mapping
+
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
+class QmodQStructProxy(NonSymbolicExpr, QmodSizedProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        struct_name: str,
+        fields: Mapping[str, "QuantumType"],
+    ) -> None:
+        self._fields = {
+            name: type_.get_proxy(FieldHandleBinding(base_handle=handle, field=name))
+            for name, type_ in fields.items()
+        }
+        size = sum(proxy.size for proxy in self._fields.values())
+        super().__init__(handle, size)
+        self._struct_name = struct_name
+
+    @property
+    def type_name(self) -> str:
+        return self._struct_name
+
+    @property
+    def fields(self) -> Mapping[str, QmodSizedProxy]:
+        return self._fields

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -66,7 +66,8 @@ NUMERIC_CONSTANTS: List[str] = [
     "EulerGamma",
     "Catalan",
 ]
-CONSTANTS: List[str] = NUMERIC_CONSTANTS + ["true", "false"]
+BOOLEAN_CONSTANTS: List[str] = ["true", "false"]
+CONSTANTS: List[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
 
 DATA_TYPES: List[str] = ["Matrix"]
 LOGIC_OPERATORS: List[str] = [

classiq/interface/generator/functions/builtins/core_library/__init__.py

@@ -3,12 +3,14 @@ from classiq.interface.generator.application_apis.combinatorial_optimization_dec
 from classiq.interface.generator.application_apis.finance_declarations import *  # noqa: F403
 from classiq.interface.generator.application_apis.qsvm_declarations import *  # noqa: F403
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
 from .atomic_quantum_functions import *  # noqa: F403
 from .exponentiation_functions import *  # noqa: F403
 
 CORE_LIB_DECLS = [
-    func for func in vars().values() if isinstance(func, QuantumFunctionDeclaration)
+    func
+    for func in vars().values()
+    if isinstance(func, NamedParamsQuantumFunctionDeclaration)
 ]