classiq 0.39.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,6 +1,8 @@
 import inspect
+import sys
+import warnings
 from types import FrameType
-from typing import Any, Callable, Final, List, Mapping, Union
+from typing import Any, Callable, Final, List, Mapping, Union, overload
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
@@ -19,7 +21,6 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIf
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
@@ -30,6 +31,7 @@ from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.utilities import get_source_ref
 
 _MISSING_VALUE: Final[int] = -1
 
@@ -39,6 +41,7 @@ def bind(
     destination: Union[Output[QVar], List[Output[QVar]]],
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     if not isinstance(source, list):
         source = [source]
     if not isinstance(destination, list):
@@ -47,19 +50,7 @@ def bind(
         BindOperation(
             in_handles=[src_var.get_handle_binding() for src_var in source],
             out_handles=[dst_var.get_handle_binding() for dst_var in destination],
-        )
-    )
-
-
-def control(
-    operand: Union[QCallable, Callable[[], None]], ctrl: Union[QBit, QArray[QBit]]
-) -> None:
-    _validate_operand(operand)
-    assert QCallable.CURRENT_EXPANDABLE is not None
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Control(
-            control=ctrl.get_handle_binding(),
-            body=_operand_to_body(operand),
+            source_ref=source_ref,
         )
     )
 
@@ -73,38 +64,90 @@ def if_(
     if else_ != _MISSING_VALUE:
         _validate_operand(else_)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ClassicalIf(
             condition=Expression(expr=str(condition)),
             then=_operand_to_body(then),
             else_=_operand_to_body(else_) if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
+            source_ref=source_ref,
         )
     )
 
 
-def quantum_if(
-    condition: SymbolicExpr, then: Union[QCallable, Callable[[], None]]
+@overload
+def control(
+    ctrl: Union[QBit, QArray[QBit]], operand: Union[QCallable, Callable[[], None]]
 ) -> None:
-    _validate_operand(then)
+    pass
+
+
+@overload
+def control(ctrl: SymbolicExpr, operand: Union[QCallable, Callable[[], None]]) -> None:
+    pass
+
+
+def control(
+    ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
+    operand: Union[QCallable, Callable[[], None]],
+) -> None:
+    if isinstance(operand, (SymbolicExpr, QVar)) and isinstance(
+        control, (QCallable, Callable)
+    ):  # type:ignore[unreachable]
+        warnings.warn(  # type:ignore[unreachable]
+            "The `control` syntax has changed. Switch the `ctrl` and "
+            "`operand` arguments. The old syntax will not be supported in the future.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        ctrl, operand = operand, ctrl
+    if isinstance(ctrl, QNum):
+        warnings.warn(
+            "The `control` semantics has changed. Applying `control` to "
+            "a `QNum` without comparing it to an integer will not be supported in the "
+            "future.\nTips:\n    1. Use a `bind` statement to cast `ctrl` into a "
+            "QArray.\n    2.`control(n, ...)` is equivalent to "
+            "`ctrl(n == 2 ** n.size - 1, ...)` if n>=0 or to `ctrl(n == -1, ...)` if "
+            "n<0.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    _validate_operand(operand)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        QuantumIf(
-            expression=Expression(expr=str(condition)),
-            then=_operand_to_body(then),
+        Control(
+            expression=Expression(expr=str(ctrl)),
+            body=_operand_to_body(operand),
+            source_ref=source_ref,
         )
     )
 
 
+def quantum_if(
+    ctrl: SymbolicExpr, operand: Union[QCallable, Callable[[], None]]
+) -> None:
+    warnings.warn(
+        "`quantum_if` is no longer supported, use `control` instead (with the "
+        "same arguments). `quantum_if` will be removed in a future release.",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+    control(ctrl, operand)
+
+
 def inplace_add(
     value: QNum,
     target: QNum,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         InplaceBinaryOperation(
             target=target.get_handle_binding(),
             value=value.get_handle_binding(),
             operation=BinaryOperation.Addition,
+            source_ref=source_ref,
         )
     )
 
@@ -114,11 +157,13 @@ def inplace_xor(
     target: QNum,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         InplaceBinaryOperation(
             target=target.get_handle_binding(),
             value=value.get_handle_binding(),
             operation=BinaryOperation.Xor,
+            source_ref=source_ref,
         )
     )
 
@@ -130,10 +175,12 @@ def within_apply(
     _validate_operand(compute)
     _validate_operand(action)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         WithinApply(
             compute=_operand_to_body(compute),
             action=_operand_to_body(action),
+            source_ref=source_ref,
         )
     )
 
@@ -141,6 +188,7 @@ def within_apply(
 def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
     _validate_operand(iteration)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     iteration_operand = prepare_arg(
         REPEAT_OPERATOR.operand_declarations["iteration"], iteration
     )
@@ -149,6 +197,7 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
             iter_var=inspect.getfullargspec(iteration).args[0],
             count=Expression(expr=str(count)),
             body=iteration_operand.body,
+            source_ref=source_ref,
         )
     )
 
@@ -159,8 +208,13 @@ def power(
 ) -> None:
     _validate_operand(operand)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Power(power=Expression(expr=str(power)), body=_operand_to_body(operand))
+        Power(
+            power=Expression(expr=str(power)),
+            body=_operand_to_body(operand),
+            source_ref=source_ref,
+        )
     )
 
 
@@ -169,8 +223,9 @@ def invert(
 ) -> None:
     _validate_operand(operand)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        Invert(body=_operand_to_body(operand))
+        Invert(body=_operand_to_body(operand), source_ref=source_ref)
     )
 
 
@@ -240,7 +295,6 @@ __all__ = [
     "control",
     "invert",
     "if_",
-    "quantum_if",
     "inplace_add",
     "inplace_xor",
     "power",

classiq/qmod/builtins/structs.py

@@ -1,113 +1,115 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List
+from classiq.interface.generator.expressions.enums.ladder_operator import LadderOperator
+from classiq.interface.generator.expressions.enums.pauli import Pauli
 
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_struct import struct
 
 
 @struct
 class PauliTerm:
-    pauli: List[int]
-    coefficient: float
+    pauli: CArray[Pauli]
+    coefficient: CReal
 
 
 @struct
 class MoleculeProblem:
-    mapping: int
-    z2_symmetries: bool
+    mapping: CInt
+    z2_symmetries: CBool
     molecule: "Molecule"
-    freeze_core: bool
-    remove_orbitals: List[int]
+    freeze_core: CBool
+    remove_orbitals: CArray[CInt]
 
 
 @struct
 class Molecule:
-    atoms: List["ChemistryAtom"]
-    spin: int
-    charge: int
+    atoms: CArray["ChemistryAtom"]
+    spin: CInt
+    charge: CInt
 
 
 @struct
 class ChemistryAtom:
-    element: int
+    element: CInt
     position: "Position"
 
 
 @struct
 class Position:
-    x: float
-    y: float
-    z: float
+    x: CReal
+    y: CReal
+    z: CReal
 
 
 @struct
 class FockHamiltonianProblem:
-    mapping: int
-    z2_symmetries: bool
-    terms: List["LadderTerm"]
-    num_particles: List[int]
+    mapping: CInt
+    z2_symmetries: CBool
+    terms: CArray["LadderTerm"]
+    num_particles: CArray[CInt]
 
 
 @struct
 class LadderTerm:
-    coefficient: float
-    ops: List["LadderOp"]
+    coefficient: CReal
+    ops: CArray["LadderOp"]
 
 
 @struct
 class LadderOp:
-    op: int
-    index: int
+    op: LadderOperator
+    index: CInt
 
 
 @struct
 class CombinatorialOptimizationSolution:
-    probability: float
-    cost: float
-    solution: List[int]
-    count: int
+    probability: CReal
+    cost: CReal
+    solution: CArray[CInt]
+    count: CInt
 
 
 @struct
 class GaussianModel:
-    num_qubits: int
-    normal_max_value: float
-    default_probabilities: List[float]
-    rhos: List[float]
-    loss: List[int]
-    min_loss: int
+    num_qubits: CInt
+    normal_max_value: CReal
+    default_probabilities: CArray[CReal]
+    rhos: CArray[CReal]
+    loss: CArray[CInt]
+    min_loss: CInt
 
 
 @struct
 class LogNormalModel:
-    num_qubits: int
-    mu: float
-    sigma: float
+    num_qubits: CInt
+    mu: CReal
+    sigma: CReal
 
 
 @struct
 class FinanceFunction:
-    f: int
-    threshold: float
-    larger: bool
-    polynomial_degree: int
-    use_chebyshev_polynomial_approximation: bool
-    tail_probability: float
+    f: CInt
+    threshold: CReal
+    larger: CBool
+    polynomial_degree: CInt
+    use_chebyshev_polynomial_approximation: CBool
+    tail_probability: CReal
 
 
 @struct
 class QsvmResult:
-    test_score: float
-    predicted_labels: List[float]
+    test_score: CReal
+    predicted_labels: CArray[CReal]
 
 
 @struct
 class QSVMFeatureMapPauli:
-    feature_dimension: int
-    reps: int
-    entanglement: int
-    alpha: float
-    paulis: List[List[int]]
+    feature_dimension: CInt
+    reps: CInt
+    entanglement: CInt
+    alpha: CReal
+    paulis: CArray[CArray[Pauli]]
 
 
 __all__ = [

classiq/qmod/declaration_inferrer.py

@@ -9,8 +9,8 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
     ConcreteClassicalType,
+    CStructBase,
     Integer,
-    QStructBase,
     Real,
     Struct,
 )
@@ -27,7 +27,7 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq import StructDeclaration
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import Array, QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CParam, CReal, QParam
 from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
@@ -38,34 +38,39 @@ OPERAND_ARG_NAME = "arg{i}"
 def python_type_to_qmod(
     py_type: type, *, qmodule: ModelStateContainer
 ) -> Optional[ConcreteClassicalType]:
-    if py_type == int:
+    if py_type == int or py_type is CInt:
         return Integer()
-    elif py_type == float:
+    elif py_type == float or py_type is CReal:
         return Real()
-    elif py_type == bool:
+    elif py_type == bool or py_type is CBool:
         return Bool()
     elif get_origin(py_type) == list:
         return ClassicalList(
             element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
         )
-    elif get_origin(py_type) == Array:
+    elif get_origin(py_type) == CArray:
         array_args = version_portable_get_args(py_type)
-        if len(array_args) != 2:
-            raise ClassiqValueError(
-                "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
+        if len(array_args) == 1:
+            return ClassicalList(
+                element_type=python_type_to_qmod(array_args[0], qmodule=qmodule)
             )
-        return ClassicalArray(
-            element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
-            size=get_type_hint_expr(array_args[1]),
+        elif len(array_args) == 2:
+            return ClassicalArray(
+                element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
+                size=get_type_hint_expr(array_args[1]),
+            )
+        raise ClassiqValueError(
+            "CArray accepts one or two generic parameters in the form "
+            "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
         )
-    elif inspect.isclass(py_type) and issubclass(py_type, QStructBase):
+    elif inspect.isclass(py_type) and issubclass(py_type, CStructBase):
         _add_qmod_struct(py_type, qmodule=qmodule)
         return Struct(name=py_type.__name__)
     return None
 
 
 def _add_qmod_struct(
-    py_type: Type[QStructBase], *, qmodule: ModelStateContainer
+    py_type: Type[CStructBase], *, qmodule: ModelStateContainer
 ) -> None:
     if (
         py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
@@ -85,9 +90,10 @@ def _add_qmod_struct(
 def _extract_param_decl(
     name: str, py_type: Any, *, qmodule: ModelStateContainer
 ) -> ClassicalParameterDeclaration:
-    if len(get_args(py_type)) != 1:
-        raise ClassiqValueError("QParam takes exactly one generic argument")
-    py_type = get_args(py_type)[0]
+    if get_origin(py_type) is QParam:
+        if len(get_args(py_type)) != 1:
+            raise ClassiqValueError("QParam takes exactly one generic argument")
+        py_type = get_args(py_type)[0]
     return ClassicalParameterDeclaration(
         name=name, classical_type=python_type_to_qmod(py_type, qmodule=qmodule)
     )
@@ -128,7 +134,13 @@ def _extract_positional_args(
         if name == "return":
             continue
         name = unmangle_keyword(name)
-        if get_origin(py_type) is QParam:
+        if (
+            inspect.isclass(py_type)
+            and issubclass(py_type, CParam)
+            or inspect.isclass(py_type)
+            and issubclass(py_type, CStructBase)
+            or get_origin(py_type) in (QParam, CArray)
+        ):
             result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))

classiq/qmod/native/expression_to_qmod.py

@@ -5,6 +5,8 @@ from typing import Callable, Dict, List, Mapping, Type
 
 import numpy as np
 
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
+
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
@@ -57,11 +59,10 @@ class ASTToQMODCode:
             return self.indent.join(self.ast_to_code(child) for child in node.body)
         elif isinstance(node, ast.Attribute):
             # Enum attribute access
-            if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-                raise AssertionError("Error parsing enum attribute access")
-            if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
+            if not isinstance(node.attr, str):
                 raise AssertionError("Error parsing enum attribute access")
-            return f"{node.value.id!s}::{node.attr!s}"
+            access_operator = "." if node.attr in CLASSICAL_ATTRIBUTES else "::"
+            return f"{self.ast_to_code(node.value)!s}{access_operator}{node.attr!s}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):

classiq/qmod/native/pretty_printer.py

@@ -41,7 +41,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIf
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_type import (
     QuantumBit,
@@ -213,17 +212,11 @@ class DSLPrettyPrinter(Visitor):
         )
         return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}{gen_time_arg_list}({quantum_args});\n"
 
-    def visit_Control(self, control: Control) -> str:
-        control_code = f"{self._indent}control ({self.visit(control.control)}) {{\n"
-        control_code += self._visit_body(control.body)
-        control_code += f"{self._indent}}}\n"
-        return control_code
-
-    def visit_QuantumIf(self, op: QuantumIf) -> str:
-        quantum_if = f"{self._indent}quantum_if ({self.visit(op.expression)}) {{\n"
-        quantum_if += self._visit_body(op.then)
-        quantum_if += f"{self._indent}}}\n"
-        return quantum_if
+    def visit_Control(self, op: Control) -> str:
+        control = f"{self._indent}control ({self.visit(op.expression)}) {{\n"
+        control += self._visit_body(op.body)
+        control += f"{self._indent}}}\n"
+        return control
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
@@ -309,10 +302,10 @@ class DSLPrettyPrinter(Visitor):
         return var_ref.name
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
-        return str(var_ref)
+        return f"{var_ref.name}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
 
     def visit_SubscriptHandleBinding(self, var_ref: SubscriptHandleBinding) -> str:
-        return str(var_ref)
+        return f"{var_ref.name}[{self.visit(var_ref.index)}]"
 
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         op = "^=" if arith_op.inplace_result else "="

classiq/qmod/qmod_constant.py

@@ -6,13 +6,13 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
-    QStructBase,
+    CStructBase,
 )
 
 from classiq.exceptions import ClassiqError
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import QParam, QParamList, QParamStruct
+from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 
 
 class QConstant:
@@ -61,22 +61,22 @@ class QConstant:
                 value=Expression(expr=expr),
             )
 
-    def __getattr__(self, name: str) -> QParam:
+    def __getattr__(self, name: str) -> CParam:
         self.add_to_model()
 
         py_type = type(self._value)
         if (
             QConstant.CURRENT_QMODULE is None
             or not inspect.isclass(py_type)
-            or not issubclass(py_type, QStructBase)
+            or not issubclass(py_type, CStructBase)
         ):
             return self.__getattribute__(name)
 
-        return QParamStruct.get_field(
+        return CParamStruct.get_field(
             QConstant.CURRENT_QMODULE, self.name, py_type.__name__, name
         )
 
-    def __getitem__(self, item: Any) -> QParam:
+    def __getitem__(self, item: Any) -> CParam:
         self.add_to_model()
 
         assert QConstant.CURRENT_QMODULE is not None
@@ -90,7 +90,7 @@ class QConstant:
         if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
             raise ClassiqError("Invalid subscript to non-list constant")
 
-        return QParamList(
+        return CParamList(
             self.name,
             qmod_type,
             QConstant.CURRENT_QMODULE,