classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,40 +1,37 @@
 from typing import Callable, List, Union
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
-    OPERAND_FIELD_NAME,
-)
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.inplace_binary_operation import (
     BinaryOperation,
     InplaceBinaryOperation,
 )
-from classiq.interface.model.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
+from classiq.interface.model.quantum_function_call import ArgValue
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+from classiq.interface.model.within_apply_operation import WithinApplyOperation
 
-from classiq.qmod.builtins.functions import (
-    apply,
-    compute as compute_operator,
-    uncompute,
-)
-from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.qmod_variable import Input, Output, QNum, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 
-def bind(source: Input[QVar], destination: Output[QVar]) -> None:
+def bind(
+    source: Union[Input[QVar], List[Input[QVar]]],
+    destination: Union[Output[QVar], List[Output[QVar]]],
+) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if not isinstance(source, list):
+        source = [source]
+    if not isinstance(destination, list):
+        destination = [destination]
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         BindOperation(
-            in_handle=source.get_handle_binding(),
-            out_handle=destination.get_handle_binding(),
+            in_handles=[src_var.get_handle_binding() for src_var in source],
+            out_handles=[dst_var.get_handle_binding() for dst_var in destination],
         )
     )
 
@@ -46,22 +43,7 @@ def quantum_if(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         QuantumIfOperation(
             expression=Expression(expr=str(condition)),
-            then=prepare_arg(QuantumOperandDeclaration(name=OPERAND_FIELD_NAME), then),
-        )
-    )
-
-
-def reinterpret_num(
-    is_signed: Union[QParam[bool], bool],
-    fraction_digits: Union[QParam[int], int],
-    target: QNum,
-) -> None:
-    assert QCallable.CURRENT_EXPANDABLE is not None
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        NumericReinterpretationOperation(
-            target=target.get_handle_binding(),
-            is_signed=Expression(expr=str(is_signed)),
-            fraction_digits=Expression(expr=str(fraction_digits)),
+            then=_to_operand(then),
         )
     )
 
@@ -98,15 +80,22 @@ def within_apply(
     compute: Callable[[], None],
     action: Callable[[], None],
 ) -> None:
-    compute_operator(compute)
-    apply(action)
-    uncompute(compute)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        WithinApplyOperation(
+            compute=_to_operand(compute),
+            action=_to_operand(action),
+        )
+    )
+
+
+def _to_operand(callable_: Union[QCallable, Callable[[], None]]) -> ArgValue:
+    return prepare_arg(QuantumOperandDeclaration(name=""), callable_)
 
 
 __all__ = [
     "bind",
     "quantum_if",
-    "reinterpret_num",
     "inplace_add",
     "inplace_xor",
     "within_apply",

classiq/qmod/builtins/structs.py

@@ -2,16 +2,16 @@
 
 from typing import List
 
-from classiq.qmod.qmod_struct import QStruct
+from classiq.qmod.qmod_struct import struct
 
 
-@QStruct
+@struct
 class PauliTerm:
     pauli: List[int]
     coefficient: float
 
 
-@QStruct
+@struct
 class MoleculeProblem:
     mapping: int
     z2_symmetries: bool
@@ -20,27 +20,27 @@ class MoleculeProblem:
     remove_orbitals: List[int]
 
 
-@QStruct
+@struct
 class Molecule:
     atoms: List["ChemistryAtom"]
     spin: int
     charge: int
 
 
-@QStruct
+@struct
 class ChemistryAtom:
     element: int
     position: "Position"
 
 
-@QStruct
+@struct
 class Position:
     x: float
     y: float
     z: float
 
 
-@QStruct
+@struct
 class FockHamiltonianProblem:
     mapping: int
     z2_symmetries: bool
@@ -48,19 +48,19 @@ class FockHamiltonianProblem:
     num_particles: List[int]
 
 
-@QStruct
+@struct
 class LadderTerm:
     coefficient: float
     ops: List["LadderOp"]
 
 
-@QStruct
+@struct
 class LadderOp:
     op: int
     index: int
 
 
-@QStruct
+@struct
 class CombinatorialOptimizationSolution:
     probability: float
     cost: float
@@ -68,7 +68,7 @@ class CombinatorialOptimizationSolution:
     count: int
 
 
-@QStruct
+@struct
 class GaussianModel:
     num_qubits: int
     normal_max_value: float
@@ -78,14 +78,14 @@ class GaussianModel:
     min_loss: int
 
 
-@QStruct
+@struct
 class LogNormalModel:
     num_qubits: int
     mu: float
     sigma: float
 
 
-@QStruct
+@struct
 class FinanceFunction:
     f: int
     threshold: float
@@ -95,13 +95,13 @@ class FinanceFunction:
     tail_probability: float
 
 
-@QStruct
+@struct
 class QsvmResult:
     test_score: float
     predicted_labels: List[float]
 
 
-@QStruct
+@struct
 class QSVMFeatureMapPauli:
     feature_dimension: int
     reps: int

classiq/qmod/cfunc.py

@@ -0,0 +1,42 @@
+from typing import Any, Callable, Dict, Optional, Union, overload
+
+from classiq.qmod.classical_function import CFunc
+
+
+def get_caller_locals() -> Dict[str, Any]:
+    """Print the local variables in the caller's frame."""
+    import inspect
+
+    frame = inspect.currentframe()
+    try:
+        assert frame is not None
+        cfunc_frame = frame.f_back
+        assert cfunc_frame is not None
+        caller_frame = cfunc_frame.f_back
+        assert caller_frame is not None
+
+        return caller_frame.f_locals
+    finally:
+        # See here for information about the `del`
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+
+@overload
+def cfunc(func: Callable) -> CFunc: ...
+
+
+@overload
+def cfunc(func: None = None) -> Callable[[Callable], CFunc]: ...
+
+
+def cfunc(func: Optional[Callable] = None) -> Union[Callable[[Callable], CFunc], CFunc]:
+    caller_locals = get_caller_locals()
+
+    def wrapper(func: Callable) -> CFunc:
+        return CFunc(func, caller_locals)
+
+    if func is not None:
+        return wrapper(func)
+
+    return wrapper

classiq/qmod/classical_function.py

@@ -2,10 +2,9 @@ import ast
 import inspect
 import sys
 from textwrap import dedent
-from typing import Callable
+from typing import Any, Callable, Dict
 
 from classiq.exceptions import ClassiqValueError
-from classiq.qmod.builtins.classical_execution_primitives import sample, save
 
 
 def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
@@ -18,23 +17,16 @@ def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
 
 
 class CFunc:
-    @staticmethod
-    def default_cmain() -> "CFunc":
-        @CFunc
-        def cmain() -> None:
-            result = sample()
-            save({"result": result})
-
-        return cmain
-
-    def __init__(self, py_callable: Callable[[], None]):
+    def __init__(self, py_callable: Callable[[], None], caller_locals: Dict[str, Any]):
         code = dedent(inspect.getsource(py_callable))
         func = ast.parse(code).body[0]
         if not isinstance(func, ast.FunctionDef):
-            raise ClassiqValueError(f"Use @{CFunc.__name__} to decorate a function")
+            raise ClassiqValueError("Use @cfunc to decorate a function")
         if len(func.args.args) > 0:
-            raise ClassiqValueError(f"A @{CFunc.__name__} must receive no arguments")
+            raise ClassiqValueError("A @cfunc must receive no arguments")
         if sys.version_info >= (3, 9):
             self.code = "\n".join([ast.unparse(statement) for statement in func.body])
         else:
             self.code = _unparse_function_body(code, func)
+
+        self._caller_constants = caller_locals

classiq/qmod/declaration_inferrer.py

@@ -1,6 +1,5 @@
 import dataclasses
 import inspect
-import sys
 from typing import Any, Callable, Dict, List, Optional, Type, get_args, get_origin
 
 from typing_extensions import _AnnotatedAlias
@@ -26,25 +25,17 @@ 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_variable import QVar, get_type_hint_expr
 from classiq.qmod.quantum_callable import QCallable, QCallableList
-from classiq.qmod.utilities import unmangle_keyword
+from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 OPERAND_ARG_NAME = "arg{i}"
 
 
-def _version_portable_get_args(py_type: type) -> tuple:
-    if get_origin(py_type) is None:
-        return tuple()
-    if sys.version_info[0:2] < (3, 10):
-        return get_args(py_type)  # The result of __class_getitem__
-    else:
-        return get_args(py_type)[0]
-
-
-def _python_type_to_qmod(
+def python_type_to_qmod(
     py_type: type, *, qmodule: ModelStateContainer
 ) -> Optional[ConcreteClassicalType]:
     if py_type == int:
@@ -55,16 +46,16 @@ def _python_type_to_qmod(
         return Bool()
     elif get_origin(py_type) == list:
         return ClassicalList(
-            element_type=_python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
+            element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
         )
     elif get_origin(py_type) == Array:
-        array_args = _version_portable_get_args(py_type)
+        array_args = version_portable_get_args(py_type)
         if len(array_args) != 2:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
             )
         return ClassicalArray(
-            element_type=_python_type_to_qmod(array_args[0], qmodule=qmodule),
+            element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
             size=get_type_hint_expr(array_args[1]),
         )
     elif inspect.isclass(py_type) and issubclass(py_type, QStructBase):
@@ -78,14 +69,14 @@ def _add_qmod_struct(
 ) -> None:
     if (
         py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
-        or py_type.__name__ in qmodule.type_decls.keys()
+        or py_type.__name__ in qmodule.type_decls
     ):
         return
 
     qmodule.type_decls[py_type.__name__] = StructDeclaration(
         name=py_type.__name__,
         variables={
-            f.name: _python_type_to_qmod(f.type, qmodule=qmodule)
+            f.name: python_type_to_qmod(f.type, qmodule=qmodule)
             for f in dataclasses.fields(py_type)
         },
     )
@@ -95,10 +86,10 @@ def _extract_param_decl(
     name: str, py_type: Any, *, qmodule: ModelStateContainer
 ) -> ClassicalParameterDeclaration:
     if len(get_args(py_type)) != 1:
-        raise ValueError("QParam takes exactly one generic argument")
+        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)
+        name=name, classical_type=python_type_to_qmod(py_type, qmodule=qmodule)
     )
 
 
@@ -118,7 +109,7 @@ def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
 def _extract_operand_decl(
     name: str, py_type: Any, qmodule: ModelStateContainer
 ) -> QuantumOperandDeclaration:
-    qc_args = _version_portable_get_args(py_type)
+    qc_args = version_portable_get_args(py_type)
     arg_dict = {
         OPERAND_ARG_NAME.format(i=i): arg_type for i, arg_type in enumerate(qc_args)
     }

classiq/qmod/expression_query.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, List, Tuple
+
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.symbolic_type import SymbolicTypes
+
+
+def get_expression_numeric_attributes(
+    vars: List[QNum],
+    expr: SymbolicTypes,
+    machine_precision: int = MAXIMAL_MACHINE_PRECISION,
+) -> Tuple[int, bool, int]:
+    res_type = compute_arithmetic_result_type(
+        expr_str=str(expr),
+        var_types={var._name: var.get_qmod_type() for var in vars},
+        machine_precision=machine_precision,
+    )
+    if TYPE_CHECKING:
+        assert isinstance(res_type, QuantumNumeric)
+    return res_type.size_in_bits, res_type.sign_value, res_type.fraction_digits_value

classiq/qmod/model_state_container.py

@@ -1,5 +1,6 @@
 from typing import Dict
 
+from classiq.interface.generator.constant import Constant
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
 from classiq import StructDeclaration
@@ -8,6 +9,7 @@ from classiq import StructDeclaration
 class ModelStateContainer:
     type_decls: Dict[str, StructDeclaration]
     native_defs: Dict[str, NativeFunctionDefinition]
+    constants: Dict[str, Constant]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/expression_to_qmod.py

@@ -0,0 +1,189 @@
+import ast
+import re
+from dataclasses import dataclass
+from typing import Callable, Dict, List, Mapping, Type
+
+import numpy as np
+
+from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+
+IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
+BINARY_OPS: Mapping[Type[ast.operator], str] = {
+    ast.Add: "+",
+    ast.Sub: "-",
+    ast.Mult: "*",
+    ast.Div: "/",
+    ast.Mod: "%",
+    ast.Pow: "**",
+    ast.BitAnd: "&",
+    ast.BitOr: "|",
+    ast.BitXor: "^",
+    ast.LShift: "<<",
+    ast.RShift: ">>",
+}
+BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+    ast.UAdd: "+",
+    ast.USub: "-",
+    ast.Invert: "~",
+    ast.Not: "not",
+}
+COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+}
+LIST_FORMAT_CHAR_LIMIT = 20
+
+
+@dataclass
+class ASTToQMODCode:
+    level: int
+    decimal_precision: int
+    indent_seq: str = "  "
+
+    @property
+    def indent(self) -> str:
+        return self.level * self.indent_seq
+
+    def visit(self, node: ast.AST) -> str:
+        return self.ast_to_code(node)
+
+    def ast_to_code(self, node: ast.AST) -> str:
+        if isinstance(node, ast.Module):
+            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)):
+                raise AssertionError("Error parsing enum attribute access")
+            return f"{node.value.id!s}::{node.attr!s}"
+        elif isinstance(node, ast.Name):
+            return node.id
+        elif isinstance(node, ast.Num):
+            return str(np.round(node.n, self.decimal_precision))
+        elif isinstance(node, ast.Str):
+            return repr(node.s)
+        elif isinstance(node, ast.Constant):
+            return repr(node.value)
+        elif isinstance(node, ast.BinOp):
+            return "({} {} {})".format(
+                self.ast_to_code(node.left),
+                BINARY_OPS[type(node.op)],
+                self.ast_to_code(node.right),
+            )
+        elif isinstance(node, ast.UnaryOp):
+            unary_op = UNARY_OPS[type(node.op)]
+            space = " " if unary_op == "not" else ""
+            return f"({unary_op}{space}{self.ast_to_code(node.operand)})"
+        elif isinstance(node, ast.BoolOp):
+            return "({})".format(
+                (" " + BOOL_OPS[type(node.op)] + " ").join(
+                    self.ast_to_code(value) for value in node.values
+                )
+            )
+        elif isinstance(node, ast.Compare):
+            if len(node.ops) != 1 or len(node.comparators) != 1:
+                raise AssertionError("Error parsing comparison expression.")
+            return "({} {} {})".format(
+                self.ast_to_code(node.left),
+                COMPARE_OPS[type(node.ops[0])],
+                self.ast_to_code(node.comparators[0]),
+            )
+        elif isinstance(node, ast.List):
+            elts = node.elts
+            elements = self.indent_items(
+                lambda: [self.ast_to_code(element) for element in elts]
+            )
+            return f"[{elements}]"
+        elif isinstance(node, ast.Subscript):
+            return f"{self.ast_to_code(node.value)}[{_remove_redundant_parentheses(self.ast_to_code(node.slice))}]"
+        elif isinstance(node, ast.Slice):
+            # A QMOD expression does not support slice step
+            if node.lower is None or node.upper is None or node.step is not None:
+                raise AssertionError("Error parsing slice expression.")
+            return f"{self.ast_to_code(node.lower)}:{self.ast_to_code(node.upper)}"
+        elif isinstance(node, ast.Call):
+            func = self.ast_to_code(node.func)
+            if func == "get_field":
+                if len(node.args) != 2:
+                    raise AssertionError("Error parsing struct field access.")
+                field = str(self.ast_to_code(node.args[1])).replace("'", "")
+                if not IDENTIFIER.match(field):
+                    raise AssertionError("Error parsing struct field access.")
+                return f"{self.ast_to_code(node.args[0])}.{field}"
+            elif func == "struct_literal":
+                if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
+                    raise AssertionError("Error parsing struct literal.")
+                keywords = node.keywords
+                initializer_list = self.indent_items(
+                    lambda: [
+                        f"{keyword.arg} = {self._cleaned_ast_to_code(keyword.value)}"
+                        for keyword in keywords
+                        if keyword.arg is not None
+                    ]
+                )
+                return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
+            else:
+                return "{}({})".format(
+                    func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)
+                )
+        elif isinstance(node, ast.Expr):
+            return self._cleaned_ast_to_code(node.value)
+        else:
+            raise AssertionError("Error parsing expression: unsupported AST node.")
+
+    def indent_items(self, items: Callable[[], List[str]]) -> str:
+        should_indent = (
+            len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
+        )
+        if should_indent:
+            self.level += 1
+            left_ws = "\n" + self.indent
+            inner_ws = ",\n" + self.indent
+        else:
+            left_ws = ""
+            inner_ws = ", "
+        items_ = items()
+        if should_indent:
+            self.level -= 1
+            right_ws = "\n" + self.indent
+        else:
+            right_ws = ""
+        return f"{left_ws}{inner_ws.join(items_)}{right_ws}"
+
+    def _cleaned_ast_to_code(self, node: ast.AST) -> str:
+        return _remove_redundant_parentheses(self.ast_to_code(node))
+
+
+def _remove_redundant_parentheses(expr: str) -> str:
+    if not (expr.startswith("(") and expr.endswith(")")):
+        return expr
+    parentheses_map: Dict[int, int] = dict()
+    stack: List[int] = []
+    for index, char in enumerate(expr):
+        if char == "(":
+            stack.append(index)
+        elif char == ")":
+            parentheses_map[stack.pop()] = index
+    index = 0
+    original_length = len(expr)
+    while (
+        index in parentheses_map
+        and parentheses_map[index] == original_length - index - 1
+    ):
+        expr = expr[1:-1]
+        index += 1
+    return expr
+
+
+def transform_expression(
+    expr: str, level: int = 0, decimal_precision: int = DEFAULT_DECIMAL_PRECISION
+) -> str:
+    return ASTToQMODCode(level=level, decimal_precision=decimal_precision).visit(
+        ast.parse(expr)
+    )