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

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -57,6 +57,7 @@ def get_params(
     *,
     node_id: str,
     args: List[RegisterOrFloat],
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None
@@ -64,35 +65,52 @@ def get_params(
     operation = id2op(node_id)
     if target and not operation_allows_target(operation):
         raise ClassiqArithmeticError(_TARGET_ERROR_MESSAGE)
-    validate_operation_arg_types(operation, args)
+    validate_operation_arg_types(operation, args, machine_precision)
     return params_getter_map[operation](
-        *args, output_size=output_size, inplace_arg=inplace_arg, target=target
+        *args,
+        machine_precision=machine_precision,
+        output_size=output_size,
+        inplace_arg=inplace_arg,
+        target=target,
     )
 
 
 def or_params_getter(
     left_arg: RegisterOrInt,
     right_arg: RegisterOrInt,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return BitwiseOr(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+    return BitwiseOr(
+        left_arg=left_arg,
+        right_arg=right_arg,
+        output_size=output_size,
+        machine_precision=machine_precision,
+    )
 
 
 def and_params_getter(
     left_arg: RegisterOrInt,
     right_arg: RegisterOrInt,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return BitwiseAnd(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+    return BitwiseAnd(
+        left_arg=left_arg,
+        right_arg=right_arg,
+        output_size=output_size,
+        machine_precision=machine_precision,
+    )
 
 
 def xor_params_getter(
     left_arg: RegisterOrInt,
     right_arg: RegisterOrInt,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -100,6 +118,7 @@ def xor_params_getter(
     return BitwiseXor(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         output_size=output_size,
         inplace_arg=inplace_arg,
     )
@@ -107,12 +126,14 @@ def xor_params_getter(
 
 def invert_params_getter(
     arg: RegisterOrInt,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     return BitwiseInvert(
         arg=arg,
+        machine_precision=machine_precision,
         output_size=output_size,
         inplace=inplace_arg is not None,
     )
@@ -120,12 +141,14 @@ def invert_params_getter(
 
 def usub_params_getter(
     arg: RegisterOrInt,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     return Negation(
         arg=arg,
+        machine_precision=machine_precision,
         output_size=output_size,
         inplace=inplace_arg is not None,
     )
@@ -134,6 +157,7 @@ def usub_params_getter(
 def adder_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -141,6 +165,7 @@ def adder_params_getter(
     return Adder(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         inplace_arg=inplace_arg,
         output_size=output_size,
     )
@@ -149,46 +174,71 @@ def adder_params_getter(
 def multiplier_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return Multiplier(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+    return Multiplier(
+        left_arg=left_arg,
+        right_arg=right_arg,
+        machine_precision=machine_precision,
+        output_size=output_size,
+    )
 
 
 def power_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return Power(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+    return Power(
+        left_arg=left_arg,
+        right_arg=right_arg,
+        machine_precision=machine_precision,
+        output_size=output_size,
+    )
 
 
 def min_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return Min(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+    return Min(
+        left_arg=left_arg,
+        right_arg=right_arg,
+        machine_precision=machine_precision,
+        output_size=output_size,
+    )
 
 
 def max_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return Max(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+    return Max(
+        left_arg=left_arg,
+        right_arg=right_arg,
+        machine_precision=machine_precision,
+        output_size=output_size,
+    )
 
 
 def sub_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -196,6 +246,7 @@ def sub_params_getter(
     return Subtractor(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         inplace_arg=inplace_arg,
         output_size=output_size,
     )
@@ -204,84 +255,105 @@ def sub_params_getter(
 def equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return Equal(left_arg=left_arg, right_arg=right_arg)
+    return Equal(
+        left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
+    )
 
 
 def not_equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return NotEqual(left_arg=left_arg, right_arg=right_arg)
+    return NotEqual(
+        left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
+    )
 
 
 def greater_than_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return GreaterThan(left_arg=left_arg, right_arg=right_arg)
+    return GreaterThan(
+        left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
+    )
 
 
 def greater_equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return GreaterEqual(left_arg=left_arg, right_arg=right_arg)
+    return GreaterEqual(
+        left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
+    )
 
 
 def less_than_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return LessThan(left_arg=left_arg, right_arg=right_arg)
+    return LessThan(
+        left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
+    )
 
 
 def less_equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
-    return LessEqual(left_arg=left_arg, right_arg=right_arg)
+    return LessEqual(
+        left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
+    )
 
 
 def logical_and_params_getter(
     *arg: List[RegisterOrFloat],
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None
 ) -> ArithmeticOperationParams:
-    return LogicalAnd(args=arg, target=target)
+    return LogicalAnd(args=arg, target=target, machine_precision=machine_precision)
 
 
 def logical_or_params_getter(
     *arg: List[RegisterOrFloat],
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None
 ) -> ArithmeticOperationParams:
-    return LogicalOr(args=arg, target=target)
+    return LogicalOr(args=arg, target=target, machine_precision=machine_precision)
 
 
 def lshift_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -289,6 +361,7 @@ def lshift_params_getter(
     return LShift(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         inplace_arg=inplace_arg,
         output_size=output_size,
     )
@@ -297,6 +370,7 @@ def lshift_params_getter(
 def rshift_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -304,6 +378,7 @@ def rshift_params_getter(
     return RShift(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         inplace_arg=inplace_arg,
         output_size=output_size,
     )
@@ -312,6 +387,7 @@ def rshift_params_getter(
 def clshift_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -319,6 +395,7 @@ def clshift_params_getter(
     return CyclicShift(
         left_arg=left_arg,
         right_arg=-right_arg,
+        machine_precision=machine_precision,
         inplace_arg=inplace_arg,
         output_size=output_size,
     )
@@ -327,6 +404,7 @@ def clshift_params_getter(
 def crshift_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -334,6 +412,7 @@ def crshift_params_getter(
     return CyclicShift(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         inplace_arg=inplace_arg,
         output_size=output_size,
     )
@@ -342,6 +421,7 @@ def crshift_params_getter(
 def modulo_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
+    machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
     target: Optional[RegisterArithmeticInfo] = None,
@@ -349,6 +429,7 @@ def modulo_params_getter(
     return Modulo(
         left_arg=left_arg,
         right_arg=right_arg,
+        machine_precision=machine_precision,
         output_size=output_size,
         inplace_arg=inplace_arg,
     )

classiq/interface/generator/arith/arithmetic_result_builder.py

@@ -80,18 +80,28 @@ class ArithmeticResultBuilder:
                 for predecessor_node in graph.predecessors(node)
             ]
             if graph.out_degree(node) == 0:
-                return cls._get_node_result(graph, args, node)
-            node_results[node] = cls._get_node_result(graph, args, node)
+                return cls._get_node_result(
+                    graph, args, node, machine_precision=machine_precision
+                )
+            node_results[node] = cls._get_node_result(
+                graph, args, node, machine_precision=machine_precision
+            )
         raise ClassiqArithmeticError("Expression has no result")
 
     @classmethod
     def _get_node_result(
-        cls, graph: nx.DiGraph, args: List[RegisterOrConst], node: str
+        cls,
+        graph: nx.DiGraph,
+        args: List[RegisterOrConst],
+        node: str,
+        *,
+        machine_precision: int,
     ) -> RegisterArithmeticInfo:
         return arithmetic_param_getters.get_params(
             node_id=node,
             args=args,
             output_size=graph.nodes[node].get(OUTPUT_SIZE, None),
+            machine_precision=machine_precision,
         ).result_register
 
     @staticmethod

classiq/interface/generator/arith/binary_ops.py

@@ -253,8 +253,8 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         )
         integer_part_size = number_utils.bounds_to_integer_part_size(lb, ub)
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            self._compute_fraction_places(self.left_arg),
+            self._compute_fraction_places(self.right_arg),
         )
         size_needed = integer_part_size + fraction_places
         return RegisterArithmeticInfo(
@@ -277,8 +277,8 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         )
         integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            self._compute_fraction_places(self.left_arg),
+            self._compute_fraction_places(self.right_arg),
         )
         size_needed = integer_part_size + fraction_places
         return RegisterArithmeticInfo(
@@ -327,7 +327,7 @@ 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 self._compute_fraction_places(self.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))
@@ -357,9 +357,9 @@ class Multiplier(BinaryOpWithFloatInputs):
     output_name = "product"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        fraction_places = argument_utils.fraction_places(
+        fraction_places = self._compute_fraction_places(
             self.left_arg
-        ) + argument_utils.fraction_places(self.right_arg)
+        ) + self._compute_fraction_places(self.right_arg)
         extremal_values = [
             left * right
             for left in argument_utils.bounds(self.left_arg)
@@ -583,9 +583,7 @@ class Modulo(EffectiveUnaryOpParams[int]):
     ) -> int:
         repr_qubits_float = math.log2(right_arg)
         repr_qubits = round(repr_qubits_float)
-        assert (
-            abs(repr_qubits - repr_qubits_float) < 10**-8
-        ), NOT_POWER_OF_TWO_ERROR_MSG
+        assert abs(repr_qubits - repr_qubits_float) < 10**-8, NOT_POWER_OF_TWO_ERROR_MSG
         output_size = values.get("output_size")
         if output_size is not None:
             repr_qubits = min(repr_qubits, output_size)

classiq/interface/generator/arith/extremum_operations.py

@@ -61,8 +61,8 @@ class Extremum(ArithmeticOperationParams):
             argument_utils.integer_part_size(self.right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            self._compute_fraction_places(self.left_arg),
+            self._compute_fraction_places(self.right_arg),
         )
         required_size = integer_part_size + fraction_places
         bounds = (

classiq/interface/generator/arith/number_utils.py

@@ -1,6 +1,6 @@
 from typing import Tuple, Union
 
-_MAXIMAL_MACHINE_PRECISION: int = 20
+MAXIMAL_MACHINE_PRECISION: int = 20
 MAX_FRACTION_PLACES: int = 8
 
 
@@ -42,7 +42,7 @@ def _get_fraction_places(*, binary_value: str, machine_precision: int) -> int:
 
 
 def get_int_representation_and_fraction_places(
-    float_value: float, *, machine_precision: int = MAX_FRACTION_PLACES
+    float_value: float, *, machine_precision: int
 ) -> Tuple[int, int]:
     int_val = signed_int_to_unsigned(int(float_value * 2**machine_precision))
     if int_val == 0:
@@ -54,9 +54,7 @@ def get_int_representation_and_fraction_places(
     return int_val, fraction_places
 
 
-def fraction_places(
-    float_value: float, *, machine_precision: int = MAX_FRACTION_PLACES
-) -> int:
+def fraction_places(float_value: float, *, machine_precision: int) -> int:
     int_val = signed_int_to_unsigned(int(float_value * 2**machine_precision))
     if int_val == 0:
         return 0
@@ -70,7 +68,7 @@ def _bit_length(integer_representation: int) -> int:
 
 
 def binary_string(
-    float_value: float, *, machine_precision: int = _MAXIMAL_MACHINE_PRECISION
+    float_value: float, *, machine_precision: int = MAXIMAL_MACHINE_PRECISION
 ) -> str:
     int_val, _ = get_int_representation_and_fraction_places(
         float_value=float_value, machine_precision=machine_precision
@@ -83,32 +81,24 @@ def binary_string(
     return bin_rep[::-1] + extension_bit * size_diff
 
 
-def integer_part_size(
-    float_value: float, *, machine_precision: int = MAX_FRACTION_PLACES
-) -> int:
+def integer_part_size(float_value: float) -> int:
     int_val, fraction_places = get_int_representation_and_fraction_places(
-        float_value=float_value, machine_precision=machine_precision
+        float_value=float_value, machine_precision=MAXIMAL_MACHINE_PRECISION
     )
     return max(_bit_length(int_val) - fraction_places, 0)
 
 
-def size(float_value: float, *, machine_precision: int = MAX_FRACTION_PLACES) -> int:
+def size(float_value: float, *, machine_precision: int) -> int:
     int_val, fraction_places = get_int_representation_and_fraction_places(
         float_value=float_value, machine_precision=machine_precision
     )
     return max(_bit_length(int_val), fraction_places)
 
 
-def bounds_to_integer_part_size(
-    lb: float, ub: float, *, machine_precision: int = MAX_FRACTION_PLACES
-) -> int:
+def bounds_to_integer_part_size(lb: float, ub: float) -> int:
     lb, ub = min(lb, ub), max(lb, ub)
-    ub_integer_part_size: int = integer_part_size(
-        float_value=ub, machine_precision=machine_precision
-    )
-    lb_integer_part_size: int = integer_part_size(
-        float_value=lb, machine_precision=machine_precision
-    )
+    ub_integer_part_size: int = integer_part_size(float_value=ub)
+    lb_integer_part_size: int = integer_part_size(float_value=lb)
     if lb == 0:
         return ub_integer_part_size
     if ub == 0:
@@ -118,8 +108,15 @@ def bounds_to_integer_part_size(
 
 
 def limit_fraction_places(number: float, *, machine_precision: int) -> float:
-    bin_rep = binary_string(number, machine_precision=machine_precision)[::-1]
-    frac_places = fraction_places(number, machine_precision=machine_precision)
+    orig_bin_rep = binary_string(number, machine_precision=MAXIMAL_MACHINE_PRECISION)[
+        ::-1
+    ]
+    orig_fractions = fraction_places(
+        number, machine_precision=MAXIMAL_MACHINE_PRECISION
+    )
+    removed_fractions = max(orig_fractions - machine_precision, 0)
     return binary_to_float(
-        bin_rep=bin_rep, fraction_part_size=frac_places, is_signed=number < 0
+        bin_rep=orig_bin_rep[: len(orig_bin_rep) - removed_fractions],
+        fraction_part_size=orig_fractions - removed_fractions,
+        is_signed=number < 0,
     )

classiq/interface/generator/arith/register_user_input.py

@@ -7,6 +7,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt
@@ -30,7 +32,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             return tuple(bounds)  # type: ignore[return-value]
         size = values.get("size")
         if not isinstance(size, int):
-            raise ValueError("RegisterUserInput must have an integer size")
+            raise ClassiqValueError("RegisterUserInput must have an integer size")
         is_signed: bool = values.get("is_signed", False)
         lb = 0 if not is_signed else -(2 ** (size - 1))
         ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1

classiq/interface/generator/arith/unary_ops.py

@@ -19,13 +19,12 @@ class UnaryOpParams(ArithmeticOperationParams):
     arg: RegisterArithmeticInfo
     inplace: bool = False
 
-    @classmethod
     @abc.abstractmethod
-    def _expected_result_size(cls, arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
+    def _expected_result_size(self) -> pydantic.PositiveInt:
         pass
 
     def actual_result_size(self) -> int:
-        return self.output_size or self._expected_result_size(self.arg)
+        return self.output_size or self._expected_result_size()
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         return int(self.is_inplaced()) * max(
@@ -73,9 +72,8 @@ class UnaryOpParams(ArithmeticOperationParams):
 class BitwiseInvert(UnaryOpParams):
     output_name = "inverted"
 
-    @classmethod
-    def _expected_result_size(cls, arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
-        return arg.size
+    def _expected_result_size(self) -> pydantic.PositiveInt:
+        return self.arg.size
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
         return RegisterArithmeticInfo(
@@ -88,12 +86,11 @@ class BitwiseInvert(UnaryOpParams):
 class Negation(UnaryOpParams):
     output_name = "negated"
 
-    @classmethod
-    def _expected_result_size(cls, arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
-        if arg.size == 1:
+    def _expected_result_size(self) -> pydantic.PositiveInt:
+        if self.arg.size == 1:
             return 1
-        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in arg.bounds)
+        return self.arg.fraction_places + number_utils.bounds_to_integer_part_size(
+            *(-bound for bound in self.arg.bounds)
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
@@ -118,8 +115,7 @@ class Sign(UnaryOpParams):
             raise ValueError("Sign output size must be 1")
         return 1
 
-    @classmethod
-    def _expected_result_size(cls, arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
+    def _expected_result_size(self) -> pydantic.PositiveInt:
         return 1
 
     def _get_result_register(self) -> RegisterArithmeticInfo:

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -11,6 +11,8 @@ 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",

classiq/interface/generator/expressions/expression.py

@@ -4,6 +4,9 @@ from typing import Any, Mapping, Optional, Type
 import pydantic
 from pydantic import PrivateAttr
 
+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,
 )
@@ -32,8 +35,10 @@ class Expression(HashablePydanticBaseModel):
 
     @pydantic.validator("expr")
     def validate_expression(cls, expr: str) -> str:
-        supported_functions = SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS | set(
-            SYMPY_SUPPORTED_EXPRESSIONS
+        supported_functions = (
+            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS
+            | set(SYMPY_SUPPORTED_EXPRESSIONS)
+            | set(DEFAULT_SUPPORTED_FUNC_NAMES)
         )
         validate_expression_str(expr, supported_functions=supported_functions)
         return expr