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

classiq/interface/generator/arith/binary_ops.py

@@ -154,7 +154,11 @@ class InplacableBinaryOpParams(
         if self.inplace_arg is None:
             return 0
         arg = self.left_arg if self.inplace_arg == ArgToInplace.LEFT else self.right_arg
-        return max(0, arg.integer_part_size - self.result_register.integer_part_size)  # type: ignore[attr-defined]
+        return max(
+            0, arg.integer_part_size - self.result_register.integer_part_size  # type: ignore[attr-defined]
+        ) + max(
+            0, arg.fraction_places - self.result_register.fraction_places  # type: ignore[attr-defined]
+        )
 
     def _carried_arguments(self) -> Tuple[Optional[LeftDataT], Optional[RightDataT]]:
         if self.inplace_arg == ArgToInplace.RIGHT and isinstance(
@@ -259,15 +263,21 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        lb = argument_utils.lower_bound(self.left_arg) + argument_utils.lower_bound(
-            self.right_arg
+        left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, machine_precision=self.machine_precision
         )
-        ub = argument_utils.upper_bound(self.left_arg) + argument_utils.upper_bound(
-            self.right_arg
+        right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, machine_precision=self.machine_precision
+        )
+        lb = argument_utils.lower_bound(left_arg) + argument_utils.lower_bound(
+            right_arg
+        )
+        ub = argument_utils.upper_bound(left_arg) + argument_utils.upper_bound(
+            right_arg
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(left_arg),
+            argument_utils.fraction_places(right_arg),
         )
         return RegisterArithmeticInfo(
             size=self.output_size or self._get_output_size(ub, lb, fraction_places),
@@ -291,16 +301,47 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
 
+    @staticmethod
+    def _get_effective_arg(
+        arg: RegisterOrConst, machine_precision: int
+    ) -> RegisterOrConst:
+        return argument_utils.limit_fraction_places(
+            arg, machine_precision=machine_precision
+        )
+
+    @property
+    def effective_left_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.left_arg, self.machine_precision)
+
+    @property
+    def effective_right_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.right_arg, self.machine_precision)
+
+    @staticmethod
+    def _is_arg_trimmed_register(arg: RegisterOrConst, machine_precision: int) -> bool:
+        return (
+            isinstance(arg, RegisterArithmeticInfo)
+            and arg.fraction_places > machine_precision
+        )
+
+    @property
+    def left_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.left_arg, self.machine_precision)
+
+    @property
+    def right_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.right_arg, self.machine_precision)
+
     def _get_result_register(self) -> RegisterArithmeticInfo:
         bounds = (
-            argument_utils.lower_bound(self.left_arg)
-            - argument_utils.upper_bound(self.right_arg),
-            argument_utils.upper_bound(self.left_arg)
-            - argument_utils.lower_bound(self.right_arg),
+            argument_utils.lower_bound(self.effective_left_arg)
+            - argument_utils.upper_bound(self.effective_right_arg),
+            argument_utils.upper_bound(self.effective_left_arg)
+            - argument_utils.lower_bound(self.effective_right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.effective_left_arg),
+            argument_utils.fraction_places(self.effective_right_arg),
         )
 
         return RegisterArithmeticInfo(
@@ -313,38 +354,60 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     def _get_output_size(
         self, bounds: Tuple[float, float], fraction_places: int
     ) -> int:
-        if isinstance(self.right_arg, float) and self.right_arg == 0:
-            assert isinstance(self.left_arg, RegisterArithmeticInfo)
-            return self.left_arg.size
+        if isinstance(self.right_arg, float) and self.effective_right_arg == 0:
+            assert isinstance(self.effective_left_arg, RegisterArithmeticInfo)
+            return self.effective_left_arg.size
         integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
         size_needed = integer_part_size + fraction_places
         return size_needed
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        if not isinstance(self.right_arg, RegisterArithmeticInfo):
+        if (
+            not self.left_arg_is_trimmed_register
+            and not self.right_arg_is_trimmed_register
+        ):
+            return self._untrimmed_garbage_output_size()
+        if not self.is_inplaced():
+            return 0
+        inplace_arg_name = (
+            self.left_arg_name
+            if self.inplace_arg == ArgToInplace.LEFT
+            else self.right_arg_name
+        )
+        return max(
+            0,
+            self._inputs[inplace_arg_name].fraction_places
+            - self.result_register.fraction_places,
+        )
+
+    def _untrimmed_garbage_output_size(self) -> pydantic.NonNegativeInt:
+        if not isinstance(self.effective_right_arg, RegisterArithmeticInfo):
             adder_params = Adder(
-                left_arg=self.left_arg,
-                right_arg=-self.right_arg,
+                left_arg=self.effective_left_arg,
+                right_arg=-self.effective_right_arg,
                 output_size=self.output_size,
                 inplace_arg=self.inplace_arg,
             )
             return adder_params.garbage_output_size()
 
         negation_params = Negation(
-            arg=self.right_arg,
+            arg=self.effective_right_arg,
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
         )
         negation_result = negation_params.result_register
-        if self.output_size is None and max(self.right_arg.bounds) > 0:
+        if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
             negation_result = negation_result.copy(
                 update=dict(
                     is_signed=True,
-                    bounds=(-max(self.right_arg.bounds), -min(self.right_arg.bounds)),
+                    bounds=(
+                        -max(self.effective_right_arg.bounds),
+                        -min(self.effective_right_arg.bounds),
+                    ),
                 )
             )
         adder_params = Adder(
-            left_arg=self.left_arg,
+            left_arg=self.effective_left_arg,
             right_arg=negation_result,
             output_size=self.output_size,
             inplace_arg=self.arg_to_inplace_adder,
@@ -359,10 +422,10 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return self.inplace_arg == ArgToInplace.LEFT
 
     def _expected_negation_output_size(self) -> int:
-        return argument_utils.fraction_places(self.right_arg) + min(
+        return argument_utils.fraction_places(self.effective_right_arg) + min(
             self.result_register.integer_part_size,
             number_utils.bounds_to_integer_part_size(
-                *(-bound for bound in argument_utils.bounds(self.right_arg))
+                *(-bound for bound in argument_utils.bounds(self.effective_right_arg))
             ),
         )
 

classiq/interface/generator/arith/unary_ops.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Final, Iterable, Optional
 
 import pydantic
 
@@ -11,7 +11,7 @@ from classiq.interface.generator.function_params import get_zero_input_name
 
 from classiq.exceptions import ClassiqValueError
 
-UNARY_ARG_NAME: str = "arg"
+UNARY_ARG_NAME: Final[str] = "arg"
 
 
 class UnaryOpParams(ArithmeticOperationParams):
@@ -19,17 +19,16 @@ class UnaryOpParams(ArithmeticOperationParams):
     inplace: bool = False
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        return int(self.is_inplaced()) * max(
-            self.arg.size - self.result_register.size, 0
+        return int(self.is_inplaced()) * (
+            max(self.arg.integer_part_size - self.result_register.integer_part_size, 0)
+            + max(self.arg.fraction_places - self.result_register.fraction_places, 0)
         )
 
     def should_add_zero_inputs(self) -> bool:
-        return not self.is_inplaced() or self.should_add_zero_input_for_extension()
+        return not self.is_inplaced() or self.zero_input_for_extension() > 0
 
-    def should_add_zero_input_for_extension(
-        self, output_size: Optional[int] = None
-    ) -> bool:
-        return (output_size or self.result_register.size) > self.arg.size
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        return max(0, self.result_register.size - self.arg.size)
 
     def _create_ios(self) -> None:
         self._inputs = {UNARY_ARG_NAME: self.arg}
@@ -41,8 +40,8 @@ class UnaryOpParams(ArithmeticOperationParams):
             zero_input_register = self.result_register
             self._zero_inputs = {zero_input_name: zero_input_register}
             return
-        if self.should_add_zero_input_for_extension():
-            output_extension_size = self.result_register.size - self.arg.size
+        if self.zero_input_for_extension() > 0:
+            output_extension_size = self.zero_input_for_extension()
             self._create_zero_input_registers({zero_input_name: output_extension_size})
         if self.garbage_output_size() > 0:
             self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
@@ -80,23 +79,33 @@ class BitwiseInvert(UnaryOpParams):
 class Negation(UnaryOpParams):
     output_name = "negated"
 
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        if self.arg.size == 1:
+    @staticmethod
+    def _expected_result_size(arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
+        if arg.size == 1:
             return 1
-        return self.arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in self.arg.bounds)
+        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
+            *(-bound for bound in arg.bounds)
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        is_signed = max(self.arg.bounds) > 0 and self._include_sign
-        bounds = (-max(self.arg.bounds), -min(self.arg.bounds))
+        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
+        is_signed = max(eff_arg.bounds) > 0 and self._include_sign
+        bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
         return RegisterArithmeticInfo(
-            size=self.output_size or self._expected_result_size(),
-            fraction_places=self.arg.fraction_places,
+            size=self.output_size or self._expected_result_size(eff_arg),
+            fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
             bounds=bounds if (is_signed or min(bounds) >= 0) else None,
         )
 
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
+        if (self.output_size or eff_arg.size) == 1:
+            return 0
+        return (
+            self.output_size or self._expected_result_size(self.arg)
+        ) - self.arg.size
+
 
 class Sign(UnaryOpParams):
     output_name = "sign"

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,3 +1,5 @@
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
+
 SUPPORTED_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
@@ -9,8 +11,6 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "get_type",
     "struct_literal",
     "get_field",
-    "fraction_digits",
-    "is_signed",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
@@ -20,3 +20,7 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "BitwiseOr",
     *SUPPORTED_BUILTIN_FUNCTIONS,
 }
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD = (
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS - CLASSICAL_ATTRIBUTES
+)

classiq/interface/generator/expressions/enums/__init__.py

@@ -8,3 +8,13 @@ from .pauli import Pauli
 from .qsvm_feature_map_entanglement import QSVMFeatureMapEntanglement
 
 BUILTIN_ENUMS = dict(filter(lambda pair: isinstance(pair[1], EnumMeta), vars().items()))
+
+__all__ = [
+    "Element",
+    "FermionMapping",
+    "FinanceFunctionType",
+    "LadderOperator",
+    "Optimizer",
+    "Pauli",
+    "QSVMFeatureMapEntanglement",
+]

classiq/interface/generator/expressions/enums/classical_enum.py

@@ -2,4 +2,8 @@ import enum
 
 
 class ClassicalEnum(int, enum.Enum):
-    pass
+    def __str__(self) -> str:
+        return f"{type(self).__name__}.{self.name}"
+
+    def __repr__(self) -> str:
+        return str(self)

classiq/interface/generator/expressions/expression.py

@@ -1,4 +1,5 @@
 import ast
+import sys
 from typing import Any, Mapping, Optional, Type
 
 import pydantic
@@ -9,7 +10,7 @@ from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
 from classiq.interface.generator.expressions.atomic_expression_functions import (
-    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS,
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD,
 )
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -34,13 +35,19 @@ class Expression(HashableASTNode):
     @pydantic.validator("expr")
     def validate_expression(cls, expr: str) -> str:
         supported_functions = (
-            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS
+            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD
             | set(SYMPY_SUPPORTED_EXPRESSIONS)
             | set(DEFAULT_SUPPORTED_FUNC_NAMES)
         )
         validate_expression_str(expr, supported_functions=supported_functions)
         return expr
 
+    @pydantic.validator("expr")
+    def format_expression(cls, expr: str) -> str:
+        if sys.version_info >= (3, 9):
+            expr = ast.unparse(ast.parse(expr))
+        return expr
+
     def is_evaluated(self) -> bool:
         return self._evaluated_expr is not None
 

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -80,3 +80,10 @@ class QmodQArrayProxy(QmodSizedProxy):
             )
 
         return HandleBinding(name=self._name)
+
+    def __len__(self) -> int:
+        if (slice_ := self.slice) is not None:
+            return slice_[1] - slice_[0]
+        elif self.index is not None:
+            return 1
+        return self._size

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -50,5 +50,4 @@ class QmodQNumProxy(QmodQScalarProxy):
             "size": self.size,
             "is_signed": self.is_signed,
             "fraction_digits": self.fraction_digits,
-            "len": self.size,
         }

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -58,7 +58,16 @@ SPECIAL_FUNCTIONS: List[str] = [
     "catalan",
 ]
 PIECEWISE_FUNCTIONS: List[str] = ["Piecewise", "Heaviside"]
-CONSTANTS: List[str] = ["pi", "E", "I", "GoldenRatio", "EulerGamma", "Catalan"]
+NUMERIC_CONSTANTS: List[str] = [
+    "pi",
+    "E",
+    "I",
+    "GoldenRatio",
+    "EulerGamma",
+    "Catalan",
+]
+CONSTANTS: List[str] = NUMERIC_CONSTANTS + ["true", "false"]
+
 DATA_TYPES: List[str] = ["Matrix"]
 LOGIC_OPERATORS: List[str] = [
     "And",

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -1,62 +1,7 @@
-from classiq.interface.generator.functions.builtins.quantum_operators import (
-    get_single_empty_operand_operator,
-)
-from classiq.interface.generator.functions.classical_type import Bool, Integer
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
-)
-
-_CTRL_FIELD_NAME = "ctrl"
-CONTROL_OPERATOR = get_single_empty_operand_operator(
-    operator_name="control",
-    port_declarations={
-        _CTRL_FIELD_NAME: PortDeclaration(
-            name=_CTRL_FIELD_NAME,
-            direction=PortDeclarationDirection.Inout,
-        )
-    },
-)
-
-REPEAT_OPERATOR = QuantumFunctionDeclaration(
-    name="repeat",
-    param_decls={"count": Integer()},
-    operand_declarations={
-        "iteration": QuantumOperandDeclaration(
-            name="iteration", param_decls={"index": Integer()}
-        )
-    },
-)
-POWER_OPERATOR = get_single_empty_operand_operator(
-    operator_name="power", param_decls={"power": Integer()}
-)
-INVERT_OPERATOR = get_single_empty_operand_operator(operator_name="invert")
-
-IF_OPERATOR = QuantumFunctionDeclaration(
-    name="if",
-    param_decls={"condition": Bool()},
-    operand_declarations={
-        "then": QuantumOperandDeclaration(name="then"),
-        "else": QuantumOperandDeclaration(name="else"),
-    },
-)
-COMPUTE = get_single_empty_operand_operator(operator_name="compute")
-UNCOMPUTE = get_single_empty_operand_operator(operator_name="uncompute")
-
-
-INTERNAL_OPERATORS = nameables_to_dict(
-    [
-        CONTROL_OPERATOR,
-        REPEAT_OPERATOR,
-        POWER_OPERATOR,
-        INVERT_OPERATOR,
-        IF_OPERATOR,
-        COMPUTE,
-        UNCOMPUTE,
-    ]
-)
+CTRL_VAR_PREFIX = "ctrl__"
+CONTROL_OPERATOR_NAME = "control"
+INVERT_OPERATOR_NAME = "invert"
+REPEAT_OPERATOR_NAME = "iteration"
+POWER_OPERATOR_NAME = "power"
+COMPUTE_OPERATOR_NAME = "compute"
+UNCOMPUTE_OPERATOR_NAME = "uncompute"