classiq 0.86.0__py3-none-any.whl → 0.87.0__py3-none-any.whl

classiq/evaluators/argument_types.py

@@ -1,5 +1,6 @@
 from collections.abc import Sequence
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -8,7 +9,9 @@ from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
 from classiq.interface.model.quantum_type import QuantumNumeric
 
-from classiq.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.model_expansions.scope import Evaluated, QuantumVariable
 
 
@@ -36,11 +39,17 @@ def add_information_from_output_arguments(
         if parameter.direction != PortDeclarationDirection.Output:
             continue
 
-        if parameter.quantum_type.is_evaluated:
-            copy_type_information(
-                parameter.quantum_type,
-                argument_as_quantum_symbol.quantum_type,
-                str(argument_as_quantum_symbol),
+        if (
+            parameter.quantum_type.is_evaluated
+            and not inject_quantum_type_attributes_inplace(
+                parameter.quantum_type, argument_as_quantum_symbol.quantum_type
+            )
+        ):
+            raise ClassiqExpansionError(
+                f"Argument {str(argument_as_quantum_symbol)!r} of type "
+                f"{argument_as_quantum_symbol.quantum_type.qmod_type_name} is "
+                f"incompatible with parameter {parameter.name!r} of type "
+                f"{parameter.quantum_type.qmod_type_name}"
             )
 
 

classiq/evaluators/parameter_types.py

@@ -45,11 +45,8 @@ from classiq.evaluators.classical_expression import (
 from classiq.evaluators.classical_type_inference import (
     infer_classical_type,
 )
-from classiq.evaluators.quantum_type_utils import (
-    copy_type_information,
-    set_element_type,
-    set_length,
-    set_size,
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes,
 )
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
@@ -100,7 +97,7 @@ def _update_scope(
     quantum_var = argument.as_type(QuantumVariable)
     casted_argument = _cast(
         parameter.quantum_type,
-        quantum_var.quantum_type,
+        quantum_var,
         parameter.name,
     )
     closure.scope[parameter.name] = Evaluated(
@@ -134,12 +131,17 @@ def _update_operand_signature_environment(
 
 
 def _cast(
-    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
+    parameter_type: QuantumType, argument: QuantumVariable, param_name: str
 ) -> QuantumSymbol:
-    updated_quantum_type = parameter_type.model_copy()
-    _inject_quantum_arg_info_to_type(updated_quantum_type, argument_type, param_name)
+    updated_type = inject_quantum_type_attributes(argument.quantum_type, parameter_type)
+    if updated_type is None:
+        raise ClassiqExpansionError(
+            f"Argument {str(argument)!r} of type "
+            f"{argument.quantum_type.qmod_type_name} is incompatible with parameter "
+            f"{param_name!r} of type {parameter_type.qmod_type_name}"
+        )
     return QuantumSymbol(
-        handle=HandleBinding(name=param_name), quantum_type=updated_quantum_type
+        handle=HandleBinding(name=param_name), quantum_type=updated_type
     )
 
 
@@ -168,11 +170,17 @@ def _evaluate_type_from_arg(
         parameter.quantum_type.model_copy(), inner_scope, parameter.name
     )
     if parameter.direction != PortDeclarationDirection.Output:
-        updated_quantum_type = _inject_quantum_arg_info_to_type(
-            updated_quantum_type,
-            argument.as_type(QuantumVariable).quantum_type,
-            parameter.name,
+        arg_type = argument.as_type(QuantumVariable).quantum_type
+        updated_output_quantum_type = inject_quantum_type_attributes(
+            arg_type, updated_quantum_type
         )
+        if updated_output_quantum_type is None:
+            raise ClassiqExpansionError(
+                f"Argument {str(argument.value)!r} of type "
+                f"{arg_type.qmod_type_name} is incompatible with parameter "
+                f"{parameter.name!r} of type {updated_quantum_type.qmod_type_name}"
+            )
+        updated_quantum_type = updated_output_quantum_type
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
 
@@ -196,7 +204,7 @@ def _evaluate_qarray_in_quantum_symbol(
     new_element_type = evaluate_type_in_quantum_symbol(
         type_to_update.element_type, scope, param_name
     )
-    set_element_type(type_to_update, new_element_type)
+    type_to_update.element_type = new_element_type
     if type_to_update.length is not None:
         new_length = _eval_expr(
             type_to_update.length,
@@ -207,13 +215,26 @@ def _evaluate_qarray_in_quantum_symbol(
             param_name,
         )
         if new_length is not None:
-            set_length(type_to_update, new_length)
+            type_to_update.length = Expression(expr=str(new_length))
     return type_to_update
 
 
 def _evaluate_qnum_in_quantum_symbol(
     type_to_update: QuantumNumeric, scope: Scope, param_name: str
 ) -> QuantumNumeric:
+    if type_to_update.size is None:
+        return type_to_update
+    new_size = _eval_expr(
+        type_to_update.size,
+        scope,
+        int,
+        type_to_update.type_name,
+        "size",
+        param_name,
+    )
+    if new_size is not None:
+        type_to_update.size = Expression(expr=str(new_size))
+
     if type_to_update.is_signed is not None:
         new_is_sign = _eval_expr(
             type_to_update.is_signed,
@@ -225,6 +246,9 @@ def _evaluate_qnum_in_quantum_symbol(
         )
         if new_is_sign is not None:
             type_to_update.is_signed = Expression(expr=str(new_is_sign))
+    else:
+        type_to_update.is_signed = Expression(expr="False")
+
     if type_to_update.fraction_digits is not None:
         new_fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
@@ -236,17 +260,9 @@ def _evaluate_qnum_in_quantum_symbol(
         )
         if new_fraction_digits is not None:
             type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
-    if type_to_update.size is not None:
-        new_size = _eval_expr(
-            type_to_update.size,
-            scope,
-            int,
-            type_to_update.type_name,
-            "size",
-            param_name,
-        )
-        if new_size is not None:
-            set_size(type_to_update, new_size, param_name)
+    else:
+        type_to_update.fraction_digits = Expression(expr="0")
+
     return type_to_update
 
 
@@ -302,18 +318,6 @@ def evaluate_types_in_quantum_symbols(
     ]
 
 
-def _inject_quantum_arg_info_to_type(
-    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
-) -> QuantumType:
-    if argument_type.has_size_in_bits:
-        copy_type_information(
-            argument_type,
-            parameter_type,
-            param_name,
-        )
-    return parameter_type
-
-
 def evaluate_type_in_classical_symbol(
     type_to_update: ClassicalType, scope: Scope, param_name: str
 ) -> ClassicalType:

classiq/evaluators/qmod_annotated_expression.py

@@ -1,10 +1,22 @@
 import ast
 from collections.abc import Sequence
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Union, cast
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalType,
+)
 from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import QuantumType
 
+from classiq.evaluators.qmod_expression_visitors.out_of_place_node_transformer import (
+    OutOfPlaceNodeTransformer,
+)
 from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_classical_type
 
 QmodExprNodeId = int
@@ -27,13 +39,31 @@ class ConcatenationAnnotation:
     elements: list[QmodExprNodeId]
 
 
-class _ExprInliner(ast.NodeTransformer):
+def qmod_val_to_str(val: Any) -> str:
+    if isinstance(val, QmodStructInstance):
+        fields = ", ".join(
+            f"{field_name}={qmod_val_to_str(field_val)}"
+            for field_name, field_val in val.fields.items()
+        )
+        return f"{val.struct_declaration.name}({fields})"
+    if isinstance(val, list):
+        return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
+    if isinstance(val, Enum):
+        return Enum.__str__(val)
+    if isinstance(val, (int, float, bool, complex)):
+        return str(val)
+    raise ClassiqInternalExpansionError(
+        f"Unrecognized value {str(val)!r} of type {type(val)}"
+    )
+
+
+class _ExprInliner(OutOfPlaceNodeTransformer):
     def __init__(self, expr_val: "QmodAnnotatedExpression") -> None:
         self._expr_val = expr_val
 
     def visit(self, node: ast.AST) -> Any:
         if self._expr_val.has_value(node):
-            return ast.Name(id=str(self._expr_val.get_value(node)))
+            return ast.Name(id=qmod_val_to_str(self._expr_val.get_value(node)))
         if self._expr_val.has_var(node):
             return ast.Name(id=str(self._expr_val.get_var(node)))
         return super().visit(node)
@@ -53,7 +83,7 @@ class QmodAnnotatedExpression:
         ] = {}
         self._concatenations: dict[QmodExprNodeId, ConcatenationAnnotation] = {}
 
-    def to_qmod_expr(self) -> str:
+    def __str__(self) -> str:
         return ast.unparse(_ExprInliner(self).visit(self.root))
 
     def has_node(self, node_id: QmodExprNodeId) -> bool:
@@ -91,6 +121,22 @@ class QmodAnnotatedExpression:
             node = id(node)
         return self._types[node]
 
+    def get_quantum_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QuantumType:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        qmod_type = self._types[node]
+        if is_classical_type(qmod_type):
+            raise ClassiqInternalExpansionError
+        return cast(QuantumType, qmod_type)
+
+    def get_classical_type(self, node: Union[ast.AST, QmodExprNodeId]) -> ClassicalType:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        qmod_type = self._types[node]
+        if not is_classical_type(qmod_type):
+            raise ClassiqInternalExpansionError
+        return cast(ClassicalType, qmod_type)
+
     def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
         var = var.collapse()
         if isinstance(node, ast.AST):
@@ -183,14 +229,15 @@ class QmodAnnotatedExpression:
     ) -> None:
         if isinstance(node, ast.AST):
             node = id(node)
-        elements = cast(
-            list[QmodExprNodeId],
-            [
-                id(element) if isinstance(element, ast.AST) else element
-                for element in elements
-            ],
-        )
-        self._concatenations[node] = ConcatenationAnnotation(elements=elements)
+        inlined_elements: list[QmodExprNodeId] = []
+        for element in elements:
+            if isinstance(element, ast.AST):
+                element = id(element)
+            if element not in self._concatenations:
+                inlined_elements.append(element)
+            else:
+                inlined_elements.extend(self._concatenations.pop(element).elements)
+        self._concatenations[node] = ConcatenationAnnotation(elements=inlined_elements)
 
     def has_concatenation(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
         if isinstance(node, ast.AST):
@@ -205,3 +252,33 @@ class QmodAnnotatedExpression:
 
     def get_quantum_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
         return self._quantum_vars
+
+    def clear_node_data(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        self._node_mapping.pop(node, None)
+        self._values.pop(node, None)
+        self._types.pop(node, None)
+        self._classical_vars.pop(node, None)
+        self._quantum_vars.pop(node, None)
+        qs = self._quantum_subscripts.pop(node, None)
+        if qs is not None:
+            self.clear_node_data(qs.value)
+            self.clear_node_data(qs.index)
+        qta = self._quantum_type_attrs.pop(node, None)
+        if qta is not None:
+            self.clear_node_data(qta.value)
+        cnct = self._concatenations.pop(node, None)
+        if cnct is not None:
+            for element in cnct.elements:
+                self.clear_node_data(element)
+
+    def _add_data_from(self, other: "QmodAnnotatedExpression") -> None:
+        self._node_mapping |= other._node_mapping
+        self._values |= other._values
+        self._types |= other._types
+        self._classical_vars |= other._classical_vars
+        self._quantum_vars |= other._quantum_vars
+        self._quantum_subscripts |= other._quantum_subscripts
+        self._quantum_type_attrs |= other._quantum_type_attrs
+        self._concatenations |= other._concatenations

classiq/evaluators/qmod_expression_visitors/out_of_place_node_transformer.py

@@ -0,0 +1,19 @@
+import ast
+from typing import Any
+
+
+class OutOfPlaceNodeTransformer(ast.NodeVisitor):
+    def generic_visit(self, node: ast.AST) -> ast.AST:
+        new_fields: dict[str, Any] = {}
+        for field, field_val in ast.iter_fields(node):
+            if isinstance(field_val, list):
+                new_fields[field] = [
+                    new_val
+                    for item in field_val
+                    if (new_val := self.visit(item)) is not None
+                ]
+            elif isinstance(field_val, ast.AST):
+                new_fields[field] = self.visit(field_val)
+            else:
+                new_fields[field] = field_val
+        return type(node)(**new_fields)

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
 from collections.abc import Mapping, Sequence
 from enum import IntEnum
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -31,13 +31,16 @@ from classiq.evaluators.qmod_node_evaluators.compare_evaluation import eval_comp
 from classiq.evaluators.qmod_node_evaluators.constant_evaluation import (
     eval_constant,
     eval_enum_member,
+    try_eval_qmod_literal,
     try_eval_sympy_constant,
 )
 from classiq.evaluators.qmod_node_evaluators.list_evaluation import eval_list
 from classiq.evaluators.qmod_node_evaluators.measurement_evaluation import (
     eval_measurement,
 )
+from classiq.evaluators.qmod_node_evaluators.min_max_evaluation import eval_min_max_op
 from classiq.evaluators.qmod_node_evaluators.name_evaluation import eval_name
+from classiq.evaluators.qmod_node_evaluators.piecewise_evaluation import eval_piecewise
 from classiq.evaluators.qmod_node_evaluators.struct_instantiation_evaluation import (
     eval_struct_instantiation,
 )
@@ -74,6 +77,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         self,
         expr_val: QmodAnnotatedExpression,
         *,
+        treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
         classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
         enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
@@ -84,6 +88,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         scope: Optional[dict[str, Any]] = None,
     ) -> None:
         self._expr_val = expr_val
+        self._treat_qnum_as_float = treat_qnum_as_float
         self._machine_precision = machine_precision
         self._classical_struct_decls = nameables_to_dict(
             classical_struct_declarations or []
@@ -109,22 +114,19 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         super().generic_visit(node)
-        eval_binary_op(self._expr_val, node)
+        eval_binary_op(
+            self._expr_val, node, self._treat_qnum_as_float, self._machine_precision
+        )
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
         super().generic_visit(node)
-        eval_unary_op(self._expr_val, node)
+        eval_unary_op(self._expr_val, node, self._machine_precision)
 
     def visit_Compare(self, node: ast.Compare) -> None:
         super().generic_visit(node)
         eval_compare(self._expr_val, node)
 
     def visit_Call(self, node: ast.Call) -> None:
-        for arg in node.args:
-            self.visit(arg)
-        for kwarg in node.keywords:
-            self.visit(kwarg)
-
         func = node.func
         if not isinstance(func, ast.Name):
             raise ClassiqExpansionError(
@@ -132,16 +134,37 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
         func_name = func.id
 
+        if func_name == "Piecewise":
+            self._eval_piecewise(node)
+            return
+
+        for arg in node.args:
+            self.visit(arg)
+        for kwarg in node.keywords:
+            self.visit(kwarg)
+
         if func_name == "measure":
             eval_measurement(self._expr_val, node)
             return
 
+        if func_name in ("min", "max"):
+            eval_min_max_op(
+                self._expr_val,
+                node,
+                func_name,
+                self._treat_qnum_as_float,
+                self._machine_precision,
+            )
+            return
+
+        # FIXME: Remove (CLS-3241)
         if func_name in self._classical_struct_decls:
             eval_struct_instantiation(
                 self._expr_val, node, self._classical_struct_decls[func_name]
             )
             return
 
+        # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_callables:
             if func_name not in self._classical_function_declarations:
                 raise ClassiqInternalExpansionError
@@ -167,6 +190,21 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
         raise ClassiqExpansionError(f"{func.id!r} is undefined")
 
+    def _eval_piecewise(self, node: ast.Call) -> None:
+        if (
+            len(node.args) == 0
+            or len(node.keywords) != 0
+            or not all(
+                isinstance(arg, ast.Tuple) and len(arg.elts) == 2 for arg in node.args
+            )
+        ):
+            raise ClassiqExpansionError("Malformed Piecewise expression")
+        args = [(arg.elts[0], arg.elts[1]) for arg in cast(list[ast.Tuple], node.args)]
+        for value, cond in args:
+            self.visit(value)
+            self.visit(cond)
+        eval_piecewise(self._expr_val, node, args)
+
     def visit_Constant(self, node: ast.Constant) -> None:
         eval_constant(self._expr_val, node)
 
@@ -194,12 +232,15 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         eval_subscript(self._expr_val, node)
 
     def visit_Name(self, node: ast.Name) -> None:
+        if node.id in self._scope:
+            eval_name(self._expr_val, node, self._scope[node.id])
+            return
         if try_eval_sympy_constant(self._expr_val, node):
             return
+        if try_eval_qmod_literal(self._expr_val, node):
+            return
 
-        if node.id not in self._scope:
-            raise ClassiqExpansionError(f"Variable {node.id!r} is undefined")
-        eval_name(self._expr_val, node, self._scope[node.id])
+        raise ClassiqExpansionError(f"Variable {node.id!r} is undefined")
 
     def visit_List(self, node: ast.List) -> None:
         super().generic_visit(node)
@@ -209,6 +250,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 def evaluate_qmod_expression(
     expr: str,
     *,
+    treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
     classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
     enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
@@ -222,6 +264,7 @@ def evaluate_qmod_expression(
     expr_value = QmodAnnotatedExpression(expr_ast)
     QmodExpressionEvaluator(
         expr_value,
+        treat_qnum_as_float=treat_qnum_as_float,
         machine_precision=machine_precision,
         classical_struct_declarations=classical_struct_declarations,
         enum_declarations=enum_declarations,

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -1,6 +1,4 @@
-from typing import Optional
-
-from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.evaluators.qmod_annotated_expression import (
     QmodAnnotatedExpression,
@@ -8,37 +6,54 @@ from classiq.evaluators.qmod_annotated_expression import (
 )
 
 
-def rename_handles_in_expression(
+def replace_expression_vars(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[HandleBinding, HandleBinding],
-) -> str:
+) -> None:
     if len(renaming) == 0:
-        return expr_val.to_qmod_expr()
+        return
     all_vars = expr_val.get_classical_vars() | expr_val.get_quantum_vars()
     for node_id, var in all_vars.items():
-        renamed_var = _rename_var(renaming, var)
-        if renamed_var is not None:
-            expr_val.set_var(node_id, renamed_var)
-    return expr_val.to_qmod_expr()
+        renamed_var = var
+        for source, target in renaming.items():
+            if renamed_var.name == source.name:
+                renamed_var = renamed_var.replace_prefix(source, target)
+        if renamed_var is var:
+            continue
+        node_type = expr_val.get_type(node_id)
+        expr_val.clear_node_data(node_id)
+        expr_val.set_type(node_id, node_type)
+        expr_val.set_var(node_id, renamed_var)
+    return
 
 
-def _rename_var(
-    renaming: dict[HandleBinding, HandleBinding], var: HandleBinding
-) -> Optional[HandleBinding]:
-    if (renamed_var := renaming.get(var)) is not None:
-        return renamed_var
-    if not isinstance(var, NestedHandleBinding):
-        return None
-    renamed_inner = _rename_var(renaming, var.base_handle)
-    if renamed_inner is None:
-        return None
-    return var.model_copy(update=dict(base_handle=renamed_inner))
+def replace_expression_type_attrs(
+    expr_val: QmodAnnotatedExpression,
+    renaming: dict[tuple[HandleBinding, str], HandleBinding],
+) -> None:
+    if len(renaming) == 0:
+        return
+    type_attrs = dict(expr_val.get_quantum_type_attributes())
+    for node_id, ta in type_attrs.items():
+        var = expr_val.get_var(ta.value)
+        renamed_var = var
+        renamed_attr = ta.attr
+        for (source, attr), target in renaming.items():
+            if renamed_attr == attr and renamed_var.name == source.name:
+                renamed_var = renamed_var.replace_prefix(source, target)
+        if renamed_var is var:
+            continue
+        node_type = expr_val.get_type(node_id)
+        expr_val.clear_node_data(node_id)
+        expr_val.set_type(node_id, node_type)
+        expr_val.set_var(node_id, renamed_var)
+    return
 
 
-def rename_nodes_in_expression(
+def replace_expression_nodes(
     expr_val: QmodAnnotatedExpression,
-    renaming: dict[QmodExprNodeId, HandleBinding],
+    renaming: dict[QmodExprNodeId, str],
 ) -> str:
     for node_id, renamed_var in renaming.items():
-        expr_val.set_var(node_id, renamed_var)
-    return expr_val.to_qmod_expr()
+        expr_val.set_var(node_id, HandleBinding(name=f"{renamed_var}"))
+    return str(expr_val)