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

classiq/qmod/builtins/operations.py

@@ -1,10 +1,11 @@
 import inspect
+import sys
 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 (
-    REPEAT_OPERATOR,
+    REPEAT_OPERATOR_NAME,
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -19,17 +20,18 @@ 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
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq import Integer
 from classiq.exceptions import ClassiqValueError
 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,24 +64,41 @@ 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:
+    _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,
         )
     )
 
@@ -100,11 +108,13 @@ def inplace_add(
     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 +124,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 +142,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,14 +155,19 @@ 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
+        QuantumOperandDeclaration(
+            name=REPEAT_OPERATOR_NAME, param_decls={"index": Integer()}
+        ),
+        iteration,
     )
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Repeat(
             iter_var=inspect.getfullargspec(iteration).args[0],
             count=Expression(expr=str(count)),
             body=iteration_operand.body,
+            source_ref=source_ref,
         )
     )
 
@@ -159,8 +178,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 +193,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 +265,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
 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
@@ -82,17 +87,6 @@ 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]
-    return ClassicalParameterDeclaration(
-        name=name, classical_type=python_type_to_qmod(py_type, qmodule=qmodule)
-    )
-
-
 def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
     # FIXME: CAD-13409
     qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
@@ -128,8 +122,19 @@ def _extract_positional_args(
         if name == "return":
             continue
         name = unmangle_keyword(name)
-        if get_origin(py_type) is QParam:
-            result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
+        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) == CArray
+        ):
+            result.append(
+                ClassicalParameterDeclaration(
+                    name=name,
+                    classical_type=python_type_to_qmod(py_type, qmodule=qmodule),
+                )
+            )
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))
         else:

classiq/qmod/native/__init__.py

@@ -0,0 +1,9 @@
+from typing import List
+
+from .pretty_printer import DSLPrettyPrinter
+
+__all__ = ["DSLPrettyPrinter"]
+
+
+def __dir__() -> List[str]:
+    return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -1,7 +1,7 @@
 import ast
 import re
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Type
+from typing import Callable, Dict, List, Mapping, Optional, Type
 
 import numpy as np
 
@@ -42,7 +42,7 @@ LIST_FORMAT_CHAR_LIMIT = 20
 @dataclass
 class ASTToQMODCode:
     level: int
-    decimal_precision: int
+    decimal_precision: Optional[int]
     indent_seq: str = "  "
 
     @property
@@ -65,6 +65,8 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):
+            if self.decimal_precision is None:
+                return str(node.n)
             return str(np.round(node.n, self.decimal_precision))
         elif isinstance(node, ast.Str):
             return repr(node.s)
@@ -122,7 +124,7 @@ class ASTToQMODCode:
                 keywords = node.keywords
                 initializer_list = self.indent_items(
                     lambda: [
-                        f"{keyword.arg} = {self._cleaned_ast_to_code(keyword.value)}"
+                        f"{keyword.arg}={self._cleaned_ast_to_code(keyword.value)}"
                         for keyword in keywords
                         if keyword.arg is not None
                     ]
@@ -182,7 +184,9 @@ def _remove_redundant_parentheses(expr: str) -> str:
 
 
 def transform_expression(
-    expr: str, level: int = 0, decimal_precision: int = DEFAULT_DECIMAL_PRECISION
+    expr: str,
+    level: int = 0,
+    decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
 ) -> str:
     return ASTToQMODCode(level=level, decimal_precision=decimal_precision).visit(
         ast.parse(expr)

classiq/qmod/native/pretty_printer.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
@@ -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,
@@ -64,7 +63,9 @@ from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class DSLPrettyPrinter(Visitor):
-    def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
+    def __init__(
+        self, decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION
+    ) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
 
@@ -137,8 +138,6 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_QuantumBitvector(self, qtype: QuantumBitvector) -> str:
         if qtype.length is not None:
-            if qtype.length.is_evaluated() and qtype.length.to_int_value() == 1:
-                return "qbit"
             return f"qbit[{self.visit(qtype.length)}]"
         return "qbit[]"
 
@@ -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/pretty_print/__init__.py

@@ -0,0 +1,9 @@
+from typing import List
+
+from .pretty_printer import PythonPrettyPrinter
+
+__all__ = ["PythonPrettyPrinter"]
+
+
+def __dir__() -> List[str]:
+    return __all__