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

classiq/qmod/symbolic.py

@@ -1,7 +1,9 @@
 import sys
 from typing import Tuple
 
-from classiq.qmod.symbolic_expr import SymbolicExpr, SymbolicTypes
+from classiq.qmod.qmod_parameter import QParamScalar
+from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.symbolic_type import SymbolicTypes
 
 pi = SymbolicExpr("pi")
 E = SymbolicExpr("E")
@@ -11,217 +13,217 @@ EulerGamma = SymbolicExpr("EulerGamma")
 Catalan = SymbolicExpr("Catalan")
 
 
-def _symbolic_function(*args: SymbolicTypes) -> SymbolicExpr:
+def symbolic_function(*args: SymbolicTypes) -> QParamScalar:
     str_args = [str(x) for x in args]
-    return SymbolicExpr(f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})")
+    return QParamScalar(f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})")
 
 
-def sin(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def sin(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def cos(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def cos(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def tan(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def tan(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def cot(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def cot(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def sec(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def sec(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def csc(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def csc(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def asin(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def asin(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def acos(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def acos(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def atan(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def atan(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def acot(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def acot(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def asec(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def asec(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def acsc(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def acsc(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def sinh(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def sinh(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def cosh(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def cosh(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def tanh(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def tanh(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def coth(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def coth(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def sech(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def sech(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def csch(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def csch(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def asinh(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def asinh(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def acosh(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def acosh(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def atanh(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def atanh(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def acoth(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def acoth(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def asech(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def asech(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def exp(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def exp(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def log(x: SymbolicTypes, base: SymbolicTypes = E) -> SymbolicExpr:
-    return _symbolic_function(x, base)
+def log(x: SymbolicTypes, base: SymbolicTypes = E) -> QParamScalar:
+    return symbolic_function(x, base)
 
 
-def ln(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def ln(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def sqrt(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def sqrt(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def abs(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def abs(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def floor(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def floor(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def ceiling(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def ceiling(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def erf(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def erf(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def erfc(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def erfc(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def gamma(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def gamma(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def beta(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def beta(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def besselj(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def besselj(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def bessely(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def bessely(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def besseli(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def besseli(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def besselk(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def besselk(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def dirichlet_eta(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def dirichlet_eta(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def polygamma(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def polygamma(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def loggamma(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def loggamma(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def factorial(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def factorial(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def binomial(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def binomial(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def subfactorial(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def subfactorial(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def primorial(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def primorial(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def bell(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def bell(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def bernoulli(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def bernoulli(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def euler(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def euler(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def catalan(x: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x)
+def catalan(x: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x)
 
 
-def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> SymbolicExpr:  # noqa: N802
-    return _symbolic_function(*args)
+def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> QParamScalar:  # noqa: N802
+    return symbolic_function(*args)
 
 
-def max(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x, y)
+def max(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x, y)
 
 
-def min(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
-    return _symbolic_function(x, y)
+def min(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(x, y)
 
 
 def logical_and(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
@@ -230,3 +232,76 @@ def logical_and(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
 
 def logical_or(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
     return SymbolicExpr._binary_op(x, y, "or")
+
+
+def logical_not(x: SymbolicTypes) -> SymbolicExpr:
+    return SymbolicExpr._unary_op(x, "not")
+
+
+__all__ = [
+    "pi",
+    "E",
+    "I",
+    "GoldenRatio",
+    "EulerGamma",
+    "Catalan",
+    "sin",
+    "cos",
+    "tan",
+    "cot",
+    "sec",
+    "csc",
+    "asin",
+    "acos",
+    "atan",
+    "acot",
+    "asec",
+    "acsc",
+    "sinh",
+    "cosh",
+    "tanh",
+    "coth",
+    "sech",
+    "csch",
+    "asinh",
+    "acosh",
+    "atanh",
+    "acoth",
+    "asech",
+    "exp",
+    "log",
+    "ln",
+    "sqrt",
+    "abs",
+    "floor",
+    "ceiling",
+    "erf",
+    "erfc",
+    "gamma",
+    "beta",
+    "besselj",
+    "bessely",
+    "besseli",
+    "besselk",
+    "dirichlet_eta",
+    "polygamma",
+    "loggamma",
+    "factorial",
+    "binomial",
+    "subfactorial",
+    "primorial",
+    "bell",
+    "bernoulli",
+    "euler",
+    "catalan",
+    "Piecewise",
+    "max",
+    "min",
+    "logical_and",
+    "logical_or",
+    "logical_not",
+]
+
+
+def __dir__():
+    return __all__

classiq/qmod/symbolic_expr.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Tuple, Union
+from typing import Any
 
 
 class Symbolic:
@@ -31,8 +31,12 @@ class SymbolicExpr(Symbolic):
 
         return SymbolicExpr(f"{lhs_str} {op} {rhs_str}")
 
-    def _unary_op(self, op: str) -> SymbolicExpr:
-        return SymbolicExpr(f"{op}({self})")
+    @staticmethod
+    def _unary_op(arg: Any, op: str) -> SymbolicExpr:
+        if not isinstance(arg, (SymbolicExpr, int, float, bool)):
+            raise TypeError(f"Invalid argument {arg!r} for unary operation {op!r}")
+
+        return SymbolicExpr(f"{op}({arg})")
 
     def __add__(self, other: Any) -> SymbolicExpr:
         return SymbolicExpr._binary_op(self, other, "+")
@@ -125,16 +129,16 @@ class SymbolicExpr(Symbolic):
         return SymbolicExpr._binary_op(self, other, ">=")
 
     def __neg__(self) -> SymbolicExpr:
-        return self._unary_op("-")
+        return SymbolicExpr._unary_op(self, "-")
 
     def __pos__(self) -> SymbolicExpr:
-        return self._unary_op("+")
+        return SymbolicExpr._unary_op(self, "+")
 
     def __abs__(self) -> SymbolicExpr:
-        return self._unary_op("abs")
+        return SymbolicExpr._unary_op(self, "abs")
 
     def __invert__(self) -> SymbolicExpr:
-        return self._unary_op("~")
+        return SymbolicExpr._unary_op(self, "~")
 
 
 class SymbolicEquality(SymbolicExpr):
@@ -143,6 +147,3 @@ class SymbolicEquality(SymbolicExpr):
         super().__init__(expr)
         self.lhs = lhs
         self.rhs = rhs
-
-
-SymbolicTypes = Union[SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]]

classiq/qmod/symbolic_type.py

@@ -0,0 +1,8 @@
+from typing import Tuple, Union
+
+from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.symbolic_expr import SymbolicExpr
+
+SymbolicTypes = Union[
+    QParam, SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]
+]

classiq/quantum_functions/decorators.py

@@ -4,13 +4,11 @@ from classiq.quantum_functions.quantum_function import QuantumFunction
 
 
 @overload
-def quantum_function(func: None = None, name: Optional[str] = None) -> Callable:
-    ...
+def quantum_function(func: None = None, name: Optional[str] = None) -> Callable: ...
 
 
 @overload
-def quantum_function(func: Callable, name: Optional[str] = None) -> QuantumFunction:
-    ...
+def quantum_function(func: Callable, name: Optional[str] = None) -> QuantumFunction: ...
 
 
 def quantum_function(

classiq/quantum_functions/function_library.py

@@ -1,4 +1,5 @@
 """Function library module, implementing facilities for adding user defined functions to the Classiq platform."""
+
 from typing import Any, Dict, List, Tuple, Type, Union
 
 from more_itertools import locate

{classiq-0.36.0.dist-info → classiq-0.37.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.36.0
+Version: 0.37.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary