classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -1,6 +1,4 @@
-from typing import Optional
-
-from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.evaluators.qmod_annotated_expression import (
     QmodAnnotatedExpression,
@@ -8,37 +6,61 @@ from classiq.evaluators.qmod_annotated_expression import (
 )
 
 
-def rename_handles_in_expression(
+def replace_expression_vars(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[HandleBinding, HandleBinding],
-) -> str:
+) -> QmodAnnotatedExpression:
+    expr_val = expr_val.clone()
     if len(renaming) == 0:
-        return expr_val.to_qmod_expr()
-    all_vars = expr_val.get_classical_vars() | expr_val.get_quantum_vars()
+        expr_val.lock()
+        return expr_val
+    all_vars = dict(expr_val.get_classical_vars()) | dict(expr_val.get_quantum_vars())
     for node_id, var in all_vars.items():
-        renamed_var = _rename_var(renaming, var)
-        if renamed_var is not None:
-            expr_val.set_var(node_id, renamed_var)
-    return expr_val.to_qmod_expr()
+        renamed_var = var
+        for source, target in renaming.items():
+            if renamed_var.name == source.name:
+                renamed_var = renamed_var.replace_prefix(source, target)
+        if renamed_var is var:
+            continue
+        node_type = expr_val.get_type(node_id)
+        expr_val.clear_node_data(node_id)
+        expr_val.set_type(node_id, node_type)
+        expr_val.set_var(node_id, renamed_var)
+    expr_val.lock()
+    return expr_val
 
 
-def _rename_var(
-    renaming: dict[HandleBinding, HandleBinding], var: HandleBinding
-) -> Optional[HandleBinding]:
-    if (renamed_var := renaming.get(var)) is not None:
-        return renamed_var
-    if not isinstance(var, NestedHandleBinding):
-        return None
-    renamed_inner = _rename_var(renaming, var.base_handle)
-    if renamed_inner is None:
-        return None
-    return var.model_copy(update=dict(base_handle=renamed_inner))
+def replace_expression_type_attrs(
+    expr_val: QmodAnnotatedExpression,
+    renaming: dict[tuple[HandleBinding, str], HandleBinding],
+) -> QmodAnnotatedExpression:
+    expr_val = expr_val.clone()
+    if len(renaming) == 0:
+        expr_val.lock()
+        return expr_val
+    type_attrs = dict(expr_val.get_quantum_type_attributes())
+    for node_id, ta in type_attrs.items():
+        var = expr_val.get_var(ta.value)
+        renamed_var = var
+        renamed_attr = ta.attr
+        for (source, attr), target in renaming.items():
+            if renamed_attr == attr and renamed_var.name == source.name:
+                renamed_var = renamed_var.replace_prefix(source, target)
+        if renamed_var is var:
+            continue
+        node_type = expr_val.get_type(node_id)
+        expr_val.clear_node_data(node_id)
+        expr_val.set_type(node_id, node_type)
+        expr_val.set_var(node_id, renamed_var)
+    expr_val.lock()
+    return expr_val
 
 
-def rename_nodes_in_expression(
+def replace_expression_nodes(
     expr_val: QmodAnnotatedExpression,
-    renaming: dict[QmodExprNodeId, HandleBinding],
+    renaming: dict[QmodExprNodeId, str],
 ) -> str:
+    expr_val = expr_val.clone()
     for node_id, renamed_var in renaming.items():
-        expr_val.set_var(node_id, renamed_var)
-    return expr_val.to_qmod_expr()
+        expr_val.set_var(node_id, HandleBinding(name=f"{renamed_var}"))
+    return str(expr_val)

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -1,22 +1,20 @@
 import ast
-from typing import Any, Optional, cast
+from typing import Any, Callable, TypeVar, cast
 
 import sympy
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_type import (
-    QuantumBit,
-    QuantumNumeric,
-    QuantumType,
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
 )
 
 from classiq.evaluators.qmod_annotated_expression import (
     QmodAnnotatedExpression,
     QmodExprNodeId,
 )
+from classiq.evaluators.qmod_expression_visitors.out_of_place_node_transformer import (
+    OutOfPlaceNodeTransformer,
+)
 from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     BitwiseAnd,
     BitwiseNot,
@@ -25,7 +23,7 @@ from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     LShift,
     RShift,
 )
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType
+from classiq.model_expansions.atomic_expression_functions_defs import do_div
 
 _SYMPY_WRAPPERS = {
     wrapper.__name__: wrapper
@@ -37,15 +35,19 @@ _SYMPY_WRAPPERS = {
         LShift,
         RShift,
     ]
+} | {
+    do_div.__name__: do_div,
 }
 
+_PY_NODE = TypeVar("_PY_NODE", bound=ast.AST)
+
 
-class _VarMaskTransformer(ast.NodeTransformer):
+class _VarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(self, expr_val: QmodAnnotatedExpression) -> None:
         self._expr_val = expr_val
         self._mask_id = 0
         self.masks: dict[str, QmodExprNodeId] = {}
-        self._assigned_masks: dict[HandleBinding, str] = {}
+        self._assigned_masks: dict[Any, str] = {}
 
     def _create_mask(self) -> str:
         mask = f"x{self._mask_id}"
@@ -54,29 +56,46 @@ class _VarMaskTransformer(ast.NodeTransformer):
 
     def visit(self, node: ast.AST) -> ast.AST:
         if self._expr_val.has_value(node):
-            return ast.parse(str(self._expr_val.get_value(node)))
+            val = self._expr_val.get_value(node)
+            if not isinstance(val, (list, QmodStructInstance)):
+                return ast.Constant(value=val)
+            mask = self._create_mask()
+            self.masks[mask] = id(node)
+            return ast.Name(id=mask)
         if self._expr_val.has_var(node):
             var = self._expr_val.get_var(node)
-            if var in self._assigned_masks:
-                mask = self._assigned_masks[var]
-            else:
-                mask = self._create_mask()
-                self._assigned_masks[var] = mask
-                self.masks[mask] = id(node)
-            return ast.Name(id=mask)
-        if self._expr_val.has_quantum_subscript(node):
+            var_str = str(var.collapse())
+            if var_str in self._assigned_masks:
+                return ast.Name(id=self._assigned_masks[var_str])
             mask = self._create_mask()
+            self._assigned_masks[var_str] = mask
             self.masks[mask] = id(node)
             return ast.Name(id=mask)
-        return self.generic_visit(node)
-
-    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
-        mask = self._create_mask()
+        return super().visit(node)
+
+    def _reduce_node(
+        self, node: _PY_NODE, inner_node: ast.AST, key: Callable[[_PY_NODE], str]
+    ) -> ast.AST:
+        new_value = self.visit(inner_node)
+        if isinstance(new_value, ast.Name):
+            mask_key = (new_value.id, key(node))
+            if mask_key in self._assigned_masks:
+                return ast.Name(self._assigned_masks[mask_key])
+            mask = self._create_mask()
+            self._assigned_masks[mask_key] = mask
+        else:
+            mask = self._create_mask()
         self.masks[mask] = id(node)
         return ast.Name(id=mask)
 
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        return self._reduce_node(node, node.value, lambda n: n.attr)
 
-class _InverseVarMaskTransformer(ast.NodeTransformer):
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        return self._reduce_node(node, node.value, lambda n: ast.unparse(node.slice))
+
+
+class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(
         self, expr_val: QmodAnnotatedExpression, masks: dict[str, QmodExprNodeId]
     ) -> None:
@@ -93,7 +112,7 @@ class _InverseVarMaskTransformer(ast.NodeTransformer):
         return node
 
 
-class _SympyCompatibilityTransformer(ast.NodeTransformer):
+class _SympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
         if len(node.values) != 2:
             raise ClassiqInternalExpansionError
@@ -151,6 +170,12 @@ class _SympyCompatibilityTransformer(ast.NodeTransformer):
             sympy_func = BitwiseXor.__name__
         elif isinstance(node.op, ast.BitAnd):
             sympy_func = BitwiseAnd.__name__
+        elif isinstance(node.op, ast.Div):
+            return ast.Call(
+                func=ast.Name(id=do_div.__name__),
+                args=[node.left, node.right],
+                keywords=[],
+            )
         else:
             return node
         return ast.Call(
@@ -158,7 +183,7 @@ class _SympyCompatibilityTransformer(ast.NodeTransformer):
         )
 
 
-class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
+class _InverseSympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_Call(self, node: ast.Call) -> Any:
         node = cast(ast.Call, self.generic_visit(node))
         if not isinstance(node.func, ast.Name):
@@ -183,12 +208,12 @@ class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
             and (len(node.args) != 2 or len(node.keywords) > 0)
         ) or (
             func in {BitwiseNot.__name__}
-            and (len(node.args) != 2 or len(node.keywords) > 0)
+            and (len(node.args) != 1 or len(node.keywords) > 0)
         ):
             raise ClassiqInternalExpansionError
 
         if func == BitwiseNot.__name__:
-            return ast.UnaryOp(op=ast.Invert, operand=node.args[0])
+            return ast.UnaryOp(op=ast.Invert(), operand=node.args[0])
 
         if func == "Eq":
             return ast.Compare(
@@ -226,6 +251,15 @@ class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
         if func == BitwiseAnd.__name__:
             return ast.BinOp(left=node.args[0], op=ast.BitAnd(), right=node.args[1])
 
+        if func == "Abs":
+            node.func.id = "abs"
+        if func == "Max":
+            node.func.id = "max"
+        elif func == "Min":
+            node.func.id = "min"
+        if func == "Mod":
+            return ast.BinOp(left=node.args[0], op=ast.Mod(), right=node.args[1])
+
         return node
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
@@ -247,46 +281,12 @@ class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
         return node
 
 
-def _get_numeric_type(
-    expr_val: QmodAnnotatedExpression,
-    expr_type: QmodType,
-    simplified_expr: str,
-    masks: dict[str, QmodExprNodeId],
-    machine_precision: int,
-) -> Optional[QuantumNumeric]:
-    if isinstance(expr_type, QuantumBit):
-        return QuantumNumeric(
-            size=Expression(expr="1"),
-            is_signed=Expression(expr="False"),
-            fraction_digits=Expression(expr="0"),
-        )
-    if not isinstance(expr_type, QuantumNumeric):
-        return None
-    if expr_type.is_evaluated:
-        return expr_type
-    var_types = {
-        var_name: expr_val.get_type(node_id) for var_name, node_id in masks.items()
-    }
-    if not all(
-        isinstance(var_type, QuantumBit)
-        or (isinstance(var_type, QuantumNumeric) and var_type.is_instantiated)
-        for var_type in var_types.values()
-    ):
-        return None
-    return compute_arithmetic_result_type(
-        simplified_expr, cast(dict[str, QuantumType], var_types), machine_precision
-    )
-
-
-def simplify_qmod_expression(
-    expr_val: QmodAnnotatedExpression, machine_precision: int
-) -> tuple[str, Optional[QuantumNumeric]]:
+def simplify_qmod_expression(expr_val: QmodAnnotatedExpression) -> str:
     if expr_val.has_value(expr_val.root):
         raise ClassiqInternalExpansionError(
             "This expression is a constant value. No need for simplification"
         )
     var_mask_transformer = _VarMaskTransformer(expr_val)
-    masks = var_mask_transformer.masks
     mask_expr = var_mask_transformer.visit(expr_val.root)
     sympy_expr = _SympyCompatibilityTransformer().visit(mask_expr)
     simplified_expr = str(
@@ -295,14 +295,7 @@ def simplify_qmod_expression(
     restored_expr = _InverseSympyCompatibilityTransformer().visit(
         ast.parse(simplified_expr, mode="eval")
     )
-    expr_type = _get_numeric_type(
-        expr_val,
-        expr_val.get_type(expr_val.root),
-        ast.unparse(restored_expr),
-        masks,
-        machine_precision,
-    )
     restored_expr = _InverseVarMaskTransformer(
         expr_val, var_mask_transformer.masks
     ).visit(restored_expr)
-    return ast.unparse(restored_expr), expr_type
+    return ast.unparse(restored_expr)

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -23,7 +23,7 @@ from classiq.interface.model.quantum_type import (
 )
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_qmod_type_name
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType
 
 
 def _eval_type_attribute(
@@ -42,7 +42,7 @@ def _eval_type_attribute(
         return
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)) and attr == "len":
         expr_val.set_type(node, Integer())
-        if subject_type.has_length:
+        if subject_type.has_constant_length:
             expr_val.set_value(node, subject_type.length_value)
         elif isinstance(subject_type, QuantumType):
             expr_val.set_quantum_type_attr(node, subject, attr)
@@ -71,7 +71,7 @@ def _eval_type_attribute(
                 expr_val.set_quantum_type_attr(node, subject, attr)
             return
     raise ClassiqExpansionError(
-        f"{get_qmod_type_name(subject_type)} has no attribute {attr!r}"
+        f"{subject_type.raw_qmod_type_name} has no attribute {attr!r}"
     )
 
 
@@ -94,7 +94,7 @@ def eval_attribute(expr_val: QmodAnnotatedExpression, node: ast.Attribute) -> No
         raise ClassiqInternalExpansionError
     if attr not in subject_fields:
         raise ClassiqExpansionError(
-            f"{get_qmod_type_name(subject_type)} has no field {attr!r}"
+            f"{subject_type.raw_qmod_type_name} has no field {attr!r}"
         )
     expr_val.set_type(node, subject_fields[attr])
 
@@ -103,9 +103,16 @@ def eval_attribute(expr_val: QmodAnnotatedExpression, node: ast.Attribute) -> No
         if (
             not isinstance(subject_value, QmodStructInstance)
             or attr not in subject_value.fields
-        ):
+        ) and (not isinstance(subject_value, dict) or attr not in subject_value):
             raise ClassiqInternalExpansionError
-        expr_val.set_value(node, subject_value.fields[attr])
+        if isinstance(subject_value, QmodStructInstance):
+            attr_value = subject_value.fields[attr]
+        else:
+            # dicts are supported because our foreign funcs return dicts instead of
+            # QmodStructInstances
+            # FIXME: Remove (CLS-3241)
+            attr_value = subject_value[attr]
+        expr_val.set_value(node, attr_value)
     elif expr_val.has_var(subject):
         subject_var = expr_val.get_var(subject)
         expr_val.set_var(node, FieldHandleBinding(base_handle=subject_var, field=attr))

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -5,10 +5,14 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
 from classiq.interface.model.quantum_type import QuantumNumeric
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.numeric_attrs_utils import (
+    get_classical_value_for_arithmetic,
+    get_numeric_attrs,
+)
 from classiq.evaluators.qmod_node_evaluators.utils import (
     IntegerValueType,
     NumberValueType,
@@ -17,14 +21,38 @@ from classiq.evaluators.qmod_node_evaluators.utils import (
     is_classical_type,
     is_numeric_type,
 )
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_add,
+    compute_result_attrs_bitwise_and,
+    compute_result_attrs_bitwise_or,
+    compute_result_attrs_bitwise_xor,
+    compute_result_attrs_lshift,
+    compute_result_attrs_modulo,
+    compute_result_attrs_multiply,
+    compute_result_attrs_power,
+    compute_result_attrs_rshift,
+    compute_result_attrs_subtract,
+)
 
 
-def _binary_op_allowed(left: QmodType, right: QmodType) -> bool:
-    return is_numeric_type(left) and is_numeric_type(right)
+def _binary_op_allowed(left: QmodType, right: QmodType, op: ast.AST) -> bool:
+    left_numeric = is_numeric_type(left)
+    right_numeric = is_numeric_type(right)
+    if isinstance(op, (ast.BitOr, ast.BitAnd, ast.BitXor)):
+        return (left_numeric or isinstance(left, Bool)) and (
+            right_numeric or isinstance(right, Bool)
+        )
+    return left_numeric and right_numeric
 
 
-def _validate_binary_op(op: ast.AST, left_type: QmodType, right_type: QmodType) -> None:
-    if not _binary_op_allowed(left_type, right_type):
+def _validate_binary_op(
+    op: ast.AST,
+    left_type: QmodType,
+    right_type: QmodType,
+    treat_qnum_as_float: bool,
+) -> None:
+    if not _binary_op_allowed(left_type, right_type, op):
         raise ClassiqExpansionError(
             f"Both sides of the binary operator {type(op).__name__!r} must be "
             f"scalar values"
@@ -48,15 +76,132 @@ def _validate_binary_op(op: ast.AST, left_type: QmodType, right_type: QmodType)
             f"Binary operation {type(op).__name__!r} is not supported"
         )
 
-    if not is_classical_type(right_type) and (
-        isinstance(
-            op, (ast.Div, ast.FloorDiv, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+    if not treat_qnum_as_float:
+        if isinstance(op, ast.FloorDiv) and (
+            not is_classical_type(left_type) or not is_classical_type(right_type)
+        ):
+            raise ClassiqExpansionError(
+                f"{type(op).__name__!r} with quantum variables is not supported"
+            )
+
+        if not is_classical_type(right_type) and isinstance(
+            op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+        ):
+            raise ClassiqExpansionError(
+                f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+            )
+
+
+def _infer_binary_op_type(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.BinOp,
+    left_type: QmodType,
+    right_type: QmodType,
+    machine_precision: int,
+    treat_qnum_as_float: bool,
+) -> QmodType:
+    op = node.op
+
+    if is_classical_type(left_type) and is_classical_type(right_type):
+        if isinstance(left_type, Bool) and isinstance(right_type, Bool):
+            return Bool()
+        if (
+            not isinstance(op, ast.Div)
+            and (is_classical_integer(left_type) or isinstance(left_type, Bool))
+            and (is_classical_integer(right_type) or isinstance(right_type, Bool))
+        ):
+            return Integer()
+        return Real()
+
+    left_attrs = get_numeric_attrs(
+        expr_val, node.left, left_type, machine_precision, treat_qnum_as_float
+    )
+    right_attrs = get_numeric_attrs(
+        expr_val, node.right, right_type, machine_precision, treat_qnum_as_float
+    )
+
+    if left_attrs is None or right_attrs is None:
+        return QuantumNumeric()
+
+    right_value = get_classical_value_for_arithmetic(
+        expr_val, node.right, right_type, treat_qnum_as_float
+    )
+
+    if isinstance(op, ast.Add):
+        result_attrs = compute_result_attrs_add(
+            left_attrs, right_attrs, machine_precision
         )
-    ):
-        raise ClassiqExpansionError(
-            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+
+    elif isinstance(op, ast.Sub):
+        result_attrs = compute_result_attrs_subtract(
+            left_attrs, right_attrs, machine_precision
         )
 
+    elif isinstance(op, ast.Mult):
+        result_attrs = compute_result_attrs_multiply(
+            left_attrs, right_attrs, machine_precision
+        )
+
+    elif isinstance(op, ast.Div):
+        if right_value is None:
+            return QuantumNumeric()
+        if right_value == 0:
+            raise ClassiqExpansionError("Division by zero")
+        right_attrs = NumericAttributes.from_constant(
+            1 / right_value, machine_precision
+        )
+        result_attrs = compute_result_attrs_multiply(
+            left_attrs, right_attrs, machine_precision
+        )
+    elif isinstance(op, ast.FloorDiv):
+        return QuantumNumeric()
+
+    elif isinstance(op, ast.Mod):
+        if right_value is None or treat_qnum_as_float:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_modulo(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.Pow):
+        if right_value is None or treat_qnum_as_float:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_power(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.LShift):
+        if right_value is None:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_lshift(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.RShift):
+        if right_value is None:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_rshift(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.BitAnd):
+        result_attrs = compute_result_attrs_bitwise_and(
+            left_attrs, right_attrs, machine_precision
+        )
+    elif isinstance(op, ast.BitOr):
+        result_attrs = compute_result_attrs_bitwise_or(
+            left_attrs, right_attrs, machine_precision
+        )
+
+    elif isinstance(op, ast.BitXor):
+        result_attrs = compute_result_attrs_bitwise_xor(
+            left_attrs, right_attrs, machine_precision
+        )
+    else:
+        raise ClassiqInternalExpansionError
+
+    return result_attrs.to_quantum_numeric()
+
 
 def _eval_binary_op_constant(
     op: ast.AST, left_value: NumberValueType, right_value: NumberValueType
@@ -79,9 +224,9 @@ def _eval_binary_op_constant(
         return left_value // right_value
     if isinstance(op, ast.Mod):
         if right_value == 0:
-            raise ClassiqExpansionError("Integer modulu by zero")
+            raise ClassiqExpansionError("Integer modulo by zero")
         if isinstance(left_value, complex) or isinstance(right_value, complex):
-            raise ClassiqExpansionError("Integer modulu with a complex number")
+            raise ClassiqExpansionError("Integer modulo with a complex number")
         return left_value % right_value
     if isinstance(op, ast.Pow):
         return left_value**right_value
@@ -104,27 +249,29 @@ def _eval_binary_op_constant(
     raise ClassiqInternalExpansionError
 
 
-def eval_binary_op(expr_val: QmodAnnotatedExpression, node: ast.BinOp) -> None:
+def eval_binary_op(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.BinOp,
+    treat_qnum_as_float: bool,
+    machine_precision: int,
+) -> None:
     left = node.left
     right = node.right
     op = node.op
 
     left_type = expr_val.get_type(left)
     right_type = expr_val.get_type(right)
-    _validate_binary_op(op, left_type, right_type)
-
-    node_type: QmodType
-    if not is_classical_type(left_type) or not is_classical_type(left_type):
-        node_type = QuantumNumeric()
-    elif (
-        not isinstance(op, ast.Div)
-        and is_classical_integer(left_type)
-        and is_classical_integer(right_type)
-    ):
-        node_type = Integer()
-    else:
-        node_type = Real()
-    expr_val.set_type(node, node_type)
+    _validate_binary_op(op, left_type, right_type, treat_qnum_as_float)
+
+    inferred_type = _infer_binary_op_type(
+        expr_val,
+        node,
+        left_type,
+        right_type,
+        machine_precision,
+        treat_qnum_as_float,
+    )
+    expr_val.set_type(node, inferred_type)
 
     if expr_val.has_value(left) and expr_val.has_value(right):
         left_value = expr_val.get_value(left)