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

classiq/interface/generator/arith/binary_ops.py

@@ -8,6 +8,7 @@ from typing import (
     Literal,
     Optional,
     Tuple,
+    Type,
     TypeVar,
     Union,
 )
@@ -28,6 +29,7 @@ from classiq.interface.generator.arith.unary_ops import Negation
 from classiq.interface.generator.function_params import get_zero_input_name
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 LeftDataT = TypeVar("LeftDataT")
 RightDataT = TypeVar("RightDataT")
@@ -61,23 +63,36 @@ class BinaryOpParams(
         left_arg = values.get("left_arg")
         right_arg = values.get("right_arg")
         if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
-            raise ValueError("One argument must be a register")
+            raise ClassiqValueError("One argument must be a register")
         if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
             # In case both arguments refer to the same object, copy it.
             # This prevents changes performed on one argument to affect the other.
             values["right_arg"] = left_arg.copy(deep=True)
         return values
 
+    def garbage_output_size(self) -> pydantic.NonNegativeInt:
+        return 0
+
     def _create_ios(self) -> None:
         self._inputs = dict()
         if isinstance(self.left_arg, RegisterArithmeticInfo):
             self._inputs[self.left_arg_name] = self.left_arg
         if isinstance(self.right_arg, RegisterArithmeticInfo):
             self._inputs[self.right_arg_name] = self.right_arg
-        zero_input_name = get_zero_input_name(self.output_name)
-        self._zero_inputs = {zero_input_name: self.result_register}
         self._outputs = {**self._inputs, self.output_name: self.result_register}
 
+        garbage_size = self.garbage_output_size()
+        if garbage_size > 0:
+            self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
+                size=garbage_size
+            )
+
+        zero_input_name = get_zero_input_name(self.output_name)
+        zero_input_size = self.result_register.size + garbage_size
+        self._zero_inputs = {
+            zero_input_name: RegisterArithmeticInfo(size=zero_input_size)
+        }
+
     def is_inplaced(self) -> bool:
         return False
 
@@ -96,18 +111,17 @@ class InplacableBinaryOpParams(
         right_arg = values.get("right_arg")
         inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
         if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
-            raise ValueError(_NumericArgumentInplaceErrorMessage.format(right_arg))
+            raise ClassiqValueError(
+                _NumericArgumentInplaceErrorMessage.format(right_arg)
+            )
         elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
-            raise ValueError(_NumericArgumentInplaceErrorMessage.format(left_arg))
+            raise ClassiqValueError(
+                _NumericArgumentInplaceErrorMessage.format(left_arg)
+            )
         return values
 
     def _create_ios(self) -> None:
         BinaryOpParams._create_ios(self)
-        garbage_size = self.garbage_output_size()
-        if garbage_size > 0:
-            self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
-                size=garbage_size
-            )
         if self.inplace_arg is None:
             return
         inplace_arg_name = (
@@ -117,7 +131,7 @@ class InplacableBinaryOpParams(
         )
         self._outputs.pop(inplace_arg_name)
 
-        self._set_inplace_zero_inputs(inplace_arg_name, garbage_size)
+        self._set_inplace_zero_inputs(inplace_arg_name, self.garbage_output_size())
 
     def _set_inplace_zero_inputs(
         self, inplace_arg_name: str, garbage_size: int
@@ -193,7 +207,7 @@ class BinaryOpWithIntInputs(BinaryOpParams[RegisterOrInt, RegisterOrInt]):
             and right_arg.fraction_places > 0
         )
         if is_left_arg_float_register or is_right_arg_float_register:
-            raise ValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
+            raise ClassiqValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
         return values
 
     @staticmethod
@@ -251,19 +265,28 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         ub = argument_utils.upper_bound(self.left_arg) + argument_utils.upper_bound(
             self.right_arg
         )
-        integer_part_size = number_utils.bounds_to_integer_part_size(lb, ub)
         fraction_places = max(
-            self._compute_fraction_places(self.left_arg),
-            self._compute_fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.left_arg),
+            argument_utils.fraction_places(self.right_arg),
         )
-        size_needed = integer_part_size + fraction_places
         return RegisterArithmeticInfo(
-            size=self.output_size or size_needed,
+            size=self.output_size or self._get_output_size(ub, lb, fraction_places),
             fraction_places=fraction_places,
             is_signed=self._include_sign and lb < 0,
             bounds=(lb, ub) if self._include_sign else None,
         )
 
+    def _get_output_size(self, ub: float, lb: float, fraction_places: int) -> int:
+        if isinstance(self.left_arg, float) and self.left_arg == 0.0:
+            assert isinstance(self.right_arg, RegisterArithmeticInfo)
+            return self.right_arg.size
+        elif isinstance(self.right_arg, float) and self.right_arg == 0.0:
+            assert isinstance(self.left_arg, RegisterArithmeticInfo)
+            return self.left_arg.size
+
+        integer_part_size = number_utils.bounds_to_integer_part_size(lb, ub)
+        return integer_part_size + fraction_places
+
 
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
@@ -275,19 +298,28 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             argument_utils.upper_bound(self.left_arg)
             - argument_utils.lower_bound(self.right_arg),
         )
-        integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
         fraction_places = max(
-            self._compute_fraction_places(self.left_arg),
-            self._compute_fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.left_arg),
+            argument_utils.fraction_places(self.right_arg),
         )
-        size_needed = integer_part_size + fraction_places
+
         return RegisterArithmeticInfo(
-            size=self.output_size or size_needed,
+            size=self.output_size or self._get_output_size(bounds, fraction_places),
             fraction_places=fraction_places,
             is_signed=self._include_sign and min(bounds) < 0,
             bounds=self._legal_bounds(bounds),
         )
 
+    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
+        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):
             adder_params = Adder(
@@ -327,7 +359,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return self.inplace_arg == ArgToInplace.LEFT
 
     def _expected_negation_output_size(self) -> int:
-        return self._compute_fraction_places(self.right_arg) + min(
+        return argument_utils.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))
@@ -356,31 +388,80 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class Multiplier(BinaryOpWithFloatInputs):
     output_name = "product"
 
-    def _get_result_register(self) -> RegisterArithmeticInfo:
-        fraction_places = self._compute_fraction_places(
-            self.left_arg
-        ) + self._compute_fraction_places(self.right_arg)
+    def expected_fraction_places(self) -> int:
+        return argument_utils.fraction_places(
+            argument_utils.limit_fraction_places(
+                self.left_arg, machine_precision=self.machine_precision
+            )
+        ) + argument_utils.fraction_places(
+            argument_utils.limit_fraction_places(
+                self.right_arg, machine_precision=self.machine_precision
+            )
+        )
+
+    @staticmethod
+    def _get_bounds(
+        args: Tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
+    ) -> Tuple[float, float]:
         extremal_values = [
             left * right
-            for left in argument_utils.bounds(self.left_arg)
-            for right in argument_utils.bounds(self.right_arg)
+            for left in argument_utils.bounds(args[0])
+            for right in argument_utils.bounds(args[1])
         ]
-        bounds = (min(extremal_values), max(extremal_values))
-        largest_bound = max(bounds, key=abs)
-        integer_places = int(largest_bound).bit_length() + int(largest_bound < 0)
-        extra_sign_bit = int(
-            argument_utils.is_signed(self.left_arg)
-            and argument_utils.is_signed(self.right_arg)
-            and largest_bound > 0
+        return (
+            number_utils.limit_fraction_places(
+                min(extremal_values), machine_precision=machine_precision
+            ),
+            number_utils.limit_fraction_places(
+                max(extremal_values), machine_precision=machine_precision
+            ),
+        )
+
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        fraction_places = min(self.machine_precision, self.expected_fraction_places())
+        left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, machine_precision=self.machine_precision
         )
+        right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, machine_precision=self.machine_precision
+        )
+        bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+
         return RegisterArithmeticInfo(
             size=self.output_size
-            or max(1, integer_places + fraction_places + extra_sign_bit),
+            or self._get_output_size(bounds, fraction_places, left_arg, right_arg),
             fraction_places=fraction_places,
             is_signed=self._include_sign and min(bounds) < 0,
             bounds=self._legal_bounds(bounds),
         )
 
+    @staticmethod
+    def _get_output_size(
+        bounds: Tuple[float, float],
+        fraction_places: int,
+        left_arg: Union[RegisterArithmeticInfo, float],
+        right_arg: Union[RegisterArithmeticInfo, float],
+    ) -> int:
+        if isinstance(left_arg, float) and left_arg == 1.0:
+            assert isinstance(right_arg, RegisterArithmeticInfo)
+            return right_arg.size
+        elif isinstance(right_arg, float) and right_arg == 1.0:
+            assert isinstance(left_arg, RegisterArithmeticInfo)
+            return left_arg.size
+        largest_bound = max(bounds, key=abs)
+        integer_places = int(largest_bound).bit_length() + int(largest_bound < 0)
+        extra_sign_bit = int(
+            argument_utils.is_signed(left_arg)
+            and argument_utils.is_signed(right_arg)
+            and largest_bound > 0
+        )
+        return max(1, integer_places + fraction_places + extra_sign_bit)
+
+    def garbage_output_size(self) -> pydantic.NonNegativeInt:
+        return max(
+            0, self.expected_fraction_places() - self.result_register.fraction_places
+        )
+
 
 class Comparator(BinaryOpWithFloatInputs):
     output_size: Literal[1] = 1
@@ -419,26 +500,53 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
     @pydantic.validator("right_arg", pre=True)
     def _validate_legal_power(cls, right_arg: Any) -> pydantic.PositiveInt:
         if not float(right_arg).is_integer():
-            raise ValueError("Power must be an integer")
+            raise ClassiqValueError("Power must be an integer")
         if right_arg <= 0:
-            raise ValueError("Power must be greater than one")
+            raise ClassiqValueError("Power must be greater than one")
         return int(right_arg)
 
+    def expected_fraction_places(self) -> int:
+        return (
+            argument_utils.fraction_places(
+                argument_utils.limit_fraction_places(
+                    self.left_arg, machine_precision=self.machine_precision
+                )
+            )
+            * self.right_arg
+        )
+
     def _get_result_bounds(self) -> Tuple[float, float]:
-        if (self.right_arg % 2) or min(self.left_arg.bounds) >= 0:
+        bounds = [
+            number_utils.limit_fraction_places(
+                bound, machine_precision=self.machine_precision
+            )
+            for bound in self.left_arg.bounds
+        ]
+        if (self.right_arg % 2) or min(bounds) >= 0:
             return (
-                self.left_arg.bounds[0] ** self.right_arg,
-                self.left_arg.bounds[1] ** self.right_arg,
+                number_utils.limit_fraction_places(
+                    bounds[0] ** self.right_arg,
+                    machine_precision=self.machine_precision,
+                ),
+                number_utils.limit_fraction_places(
+                    bounds[1] ** self.right_arg,
+                    machine_precision=self.machine_precision,
+                ),
             )
-        return 0.0, max(abs(bound) for bound in self.left_arg.bounds) ** self.right_arg
+        return 0.0, number_utils.limit_fraction_places(
+            max(abs(bound) for bound in bounds) ** self.right_arg,
+            machine_precision=self.machine_precision,
+        )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
         if self.output_size:
             return RegisterArithmeticInfo(size=self.output_size)
 
-        fraction_places: int = self.left_arg.fraction_places * self.right_arg
+        fraction_places = min(self.machine_precision, self.expected_fraction_places())
         bounds = self._get_result_bounds()
         size = number_utils.bounds_to_integer_part_size(*bounds) + fraction_places
+        if bounds[0] == bounds[1]:
+            size = 1
         return RegisterArithmeticInfo(
             size=size,
             is_signed=self.left_arg.is_signed and (self.right_arg % 2 == 1),
@@ -446,6 +554,50 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
             bounds=bounds,
         )
 
+    def _get_inner_action_garbage_size(
+        self,
+        action_type: Union[Type["Power"], Type[Multiplier]],
+        *,
+        arg: RegisterArithmeticInfo,
+        action_right_arg: RegisterOrConst,
+        compute_power: int
+    ) -> pydantic.NonNegativeInt:
+        inner_compute_power_params = Power(
+            left_arg=arg,
+            right_arg=compute_power,
+            output_size=self.output_size,
+            machine_precision=self.machine_precision,
+        )
+        return action_type(
+            left_arg=inner_compute_power_params.result_register,
+            right_arg=action_right_arg,
+            output_size=self.output_size,
+            machine_precision=self.machine_precision,
+        ).garbage_output_size()
+
+    def garbage_output_size(self) -> pydantic.NonNegativeInt:
+        arg = self.left_arg
+        power = self.right_arg
+        if power == 1:
+            return 0
+        if (
+            power == 2
+            or (arg.size == 1 and arg.fraction_places == 0)
+            or self.output_size == 1
+        ):
+            return max(
+                0,
+                self.expected_fraction_places() - self.result_register.fraction_places,
+            )
+
+        if power % 2 == 0:
+            return self._get_inner_action_garbage_size(
+                Power, arg=arg, action_right_arg=power // 2, compute_power=2
+            )
+        return self._get_inner_action_garbage_size(
+            Multiplier, arg=arg, action_right_arg=arg, compute_power=power - 1
+        )
+
 
 class EffectiveUnaryOpParams(
     InplacableBinaryOpParams[RegisterArithmeticInfo, RightDataT], Generic[RightDataT]
@@ -465,9 +617,9 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         arg = values.get("left_arg")
         shift = values.get("right_arg")
         if not isinstance(arg, RegisterArithmeticInfo):
-            raise ValueError("left arg must be a RegisterArithmeticInfo")
+            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
-            raise ValueError("Shift must be an integer")
+            raise ClassiqValueError("Shift must be an integer")
         assert arg.fraction_places - shift <= 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
         return values
 
@@ -506,9 +658,9 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         arg = values.get("left_arg")
         shift = values.get("right_arg")
         if not isinstance(arg, RegisterArithmeticInfo):
-            raise ValueError("left arg must be a RegisterArithmeticInfo")
+            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
-            raise ValueError("Shift must be an integer")
+            raise ClassiqValueError("Shift must be an integer")
         assert (
             cls._shifted_fraction_places(arg=arg, shift=shift) == 0
         ), _FLOATING_POINT_MODULO_ERROR_MESSAGE
@@ -549,7 +701,7 @@ class CyclicShift(EffectiveUnaryOpParams[int]):
             return values
         arg = values.get("left_arg")
         if not isinstance(arg, RegisterArithmeticInfo):
-            raise ValueError("left arg must be a RegisterArithmeticInfo")
+            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         assert arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
         return values
 
@@ -590,11 +742,7 @@ class Modulo(EffectiveUnaryOpParams[int]):
         values["output_size"] = None
         return 2 ** (repr_qubits)
 
-    @property
-    def result_size(self) -> int:
-        return round(math.log2(self.right_arg))
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
         return RegisterArithmeticInfo(
-            size=self.result_size, is_signed=False, fraction_places=0
+            size=round(math.log2(self.right_arg)), is_signed=False, fraction_places=0
         )

classiq/interface/generator/arith/extremum_operations.py

@@ -15,6 +15,8 @@ from classiq.interface.generator.arith.binary_ops import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.exceptions import ClassiqValueError
+
 Numeric = (float, int)
 
 
@@ -27,7 +29,7 @@ class Extremum(ArithmeticOperationParams):
         left_arg = values.get("left_arg")
         right_arg = values.get("right_arg")
         if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
-            raise ValueError("One argument must be a register")
+            raise ClassiqValueError("One argument must be a register")
         if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
             # In case both arguments refer to the same object, copy it.
             # This prevents changes performed on one argument from affecting the other.
@@ -61,8 +63,8 @@ class Extremum(ArithmeticOperationParams):
             argument_utils.integer_part_size(self.right_arg),
         )
         fraction_places = max(
-            self._compute_fraction_places(self.left_arg),
-            self._compute_fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.left_arg),
+            argument_utils.fraction_places(self.right_arg),
         )
         required_size = integer_part_size + fraction_places
         bounds = (

classiq/interface/generator/arith/logical_ops.py

@@ -9,6 +9,8 @@ from classiq.interface.generator.arith.arithmetic_operations import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.exceptions import ClassiqValueError
+
 
 def get_arg_name(idx: int) -> str:
     return f"arg_{idx}"
@@ -25,7 +27,7 @@ class LogicalOps(ArithmeticOperationParams):
     @pydantic.validator("output_size")
     def _validate_output_size(cls, output_size: Optional[int]) -> int:
         if output_size is not None and output_size != 1:
-            raise ValueError("logical operation output size must be 1")
+            raise ClassiqValueError("logical operation output size must be 1")
         return 1
 
     @pydantic.validator("args")
@@ -34,7 +36,7 @@ class LogicalOps(ArithmeticOperationParams):
     ) -> List[RegisterOrConst]:
         for arg_idx, arg in enumerate(arguments):
             if isinstance(arg, RegisterArithmeticInfo) and not arg.is_boolean_register:
-                raise ValueError(
+                raise ClassiqValueError(
                     f"All inputs to logical and must be of size 1 (at argument #{arg_idx})"
                 )
         return arguments

classiq/interface/generator/arith/machine_precision.py

@@ -0,0 +1,3 @@
+from typing import Final
+
+DEFAULT_MACHINE_PRECISION: Final[int] = 8

classiq/interface/generator/arith/number_utils.py

@@ -1,7 +1,6 @@
-from typing import Tuple, Union
+from typing import Final, Tuple, Union
 
-MAXIMAL_MACHINE_PRECISION: int = 20
-MAX_FRACTION_PLACES: int = 8
+MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
 
 def signed_int_to_unsigned(number: int) -> int:
@@ -32,8 +31,8 @@ def binary_to_float_or_int(
     return binary_to_float(bin_rep, fraction_part_size, is_signed)
 
 
-def _get_fraction_places(*, binary_value: str, machine_precision: int) -> int:
-    fraction_places = machine_precision
+def _get_fraction_places(*, binary_value: str) -> int:
+    fraction_places = MAXIMAL_MACHINE_PRECISION
     for bit in reversed(binary_value):
         if bit == "1" or fraction_places == 0:
             return fraction_places
@@ -41,79 +40,70 @@ def _get_fraction_places(*, binary_value: str, machine_precision: int) -> int:
     return fraction_places
 
 
-def get_int_representation_and_fraction_places(
-    float_value: float, *, machine_precision: int
-) -> Tuple[int, int]:
-    int_val = signed_int_to_unsigned(int(float_value * 2**machine_precision))
+def get_int_representation_and_fraction_places(float_value: float) -> Tuple[int, int]:
+    int_val = signed_int_to_unsigned(int(float_value * 2**MAXIMAL_MACHINE_PRECISION))
     if int_val == 0:
         return 0, 0
-    fraction_places = _get_fraction_places(
-        binary_value=bin(int_val)[2:], machine_precision=machine_precision
-    )
-    int_val = int_val >> (machine_precision - fraction_places)
+    fraction_places = _get_fraction_places(binary_value=bin(int_val)[2:])
+    int_val = int_val >> (MAXIMAL_MACHINE_PRECISION - fraction_places)
     return int_val, fraction_places
 
 
-def fraction_places(float_value: float, *, machine_precision: int) -> int:
-    int_val = signed_int_to_unsigned(int(float_value * 2**machine_precision))
+def fraction_places(float_value: float) -> int:
+    int_val = signed_int_to_unsigned(int(float_value * 2**MAXIMAL_MACHINE_PRECISION))
     if int_val == 0:
         return 0
-    return _get_fraction_places(
-        binary_value=bin(int_val)[2:], machine_precision=machine_precision
-    )
+    return _get_fraction_places(binary_value=bin(int_val)[2:])
 
 
 def _bit_length(integer_representation: int) -> int:
     return 1 if integer_representation == 0 else integer_representation.bit_length()
 
 
-def binary_string(
-    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
-    )
+def binary_string(float_value: float) -> str:
+    int_val, _ = get_int_representation_and_fraction_places(float_value)
     bin_rep = bin(int_val)[2:]
-    size_diff = size(
-        float_value=float_value, machine_precision=machine_precision
-    ) - len(bin_rep)
+    size_diff = size(float_value=float_value) - len(bin_rep)
     extension_bit = "0" if float_value >= 0 else "1"
     return bin_rep[::-1] + extension_bit * size_diff
 
 
 def integer_part_size(float_value: float) -> int:
-    int_val, fraction_places = get_int_representation_and_fraction_places(
-        float_value=float_value, machine_precision=MAXIMAL_MACHINE_PRECISION
-    )
+    int_val, fraction_places = get_int_representation_and_fraction_places(float_value)
     return max(_bit_length(int_val) - fraction_places, 0)
 
 
-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
-    )
+def size(float_value: float) -> int:
+    int_val, fraction_places = get_int_representation_and_fraction_places(float_value)
     return max(_bit_length(int_val), fraction_places)
 
 
+def _is_extra_sign_bit_needed(*, lb: float, ub: float) -> bool:
+    integer_lb = lb * 2 ** fraction_places(lb)
+    max_represented_number = (
+        2 ** (len(binary_string(integer_lb)) - 1) - 1
+    ) / 2 ** fraction_places(lb)
+    return ub > max_represented_number
+
+
 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)
     lb_integer_part_size: int = integer_part_size(float_value=lb)
-    if lb == 0:
+    if lb >= 0:
         return ub_integer_part_size
-    if ub == 0:
+    if ub <= 0:
         return lb_integer_part_size
-    is_extra_bit_needed = lb < 0 < ub and ub_integer_part_size >= lb_integer_part_size
-    return max(ub_integer_part_size + 1 * is_extra_bit_needed, lb_integer_part_size)
+    return max(
+        ub_integer_part_size + 1 * _is_extra_sign_bit_needed(lb=lb, ub=ub),
+        lb_integer_part_size,
+    )
 
 
 def limit_fraction_places(number: float, *, machine_precision: int) -> float:
-    orig_bin_rep = binary_string(number, machine_precision=MAXIMAL_MACHINE_PRECISION)[
-        ::-1
-    ]
-    orig_fractions = fraction_places(
-        number, machine_precision=MAXIMAL_MACHINE_PRECISION
-    )
+    orig_bin_rep = binary_string(number)[::-1]
+    orig_fractions = fraction_places(number)
+
     removed_fractions = max(orig_fractions - machine_precision, 0)
     return binary_to_float(
         bin_rep=orig_bin_rep[: len(orig_bin_rep) - removed_fractions],

classiq/interface/generator/arith/register_user_input.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, Optional
 
 import pydantic
 
+from classiq.interface.generator.arith import number_utils
 from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
@@ -29,7 +30,17 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         if bounds is not None:
             if min(bounds) < 0:
                 assert values.get("is_signed")
-            return tuple(bounds)  # type: ignore[return-value]
+            fraction_places = values.get("fraction_places")
+            if not isinstance(fraction_places, int):
+                raise ClassiqValueError(
+                    "RegisterUserInput must have an integer fraction_places"
+                )
+            return number_utils.limit_fraction_places(
+                min(bounds), machine_precision=fraction_places
+            ), number_utils.limit_fraction_places(
+                max(bounds), machine_precision=fraction_places
+            )
+
         size = values.get("size")
         if not isinstance(size, int):
             raise ClassiqValueError("RegisterUserInput must have an integer size")
@@ -39,6 +50,15 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         fraction_factor = float(2 ** -values.get("fraction_places", 0))
         return (lb * fraction_factor, ub * fraction_factor)
 
+    def limit_fraction_places(self, machine_precision: int) -> "RegisterArithmeticInfo":
+        truncated_bits: int = max(self.fraction_places - machine_precision, 0)
+        return RegisterArithmeticInfo(
+            size=self.size - truncated_bits,
+            is_signed=self.is_signed,
+            fraction_places=self.fraction_places - truncated_bits,
+            bounds=self.bounds,
+        )
+
     @property
     def is_boolean_register(self) -> bool:
         return (not self.is_signed) and (self.size == 1) and (self.fraction_places == 0)