feature: support integer division

src/autoqasm/converters/arithmetic.py

@@ -0,0 +1,63 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+"""Converters for aritmetic operator nodes"""
+
+import ast
+
+import gast
+from malt.core import ag_ctx, converter
+from malt.pyct import templates
+
+ARITHMETIC_OPERATORS = {
+    gast.FloorDiv: "ag__.fd_",
+}
+
+
+class ArithmeticTransformer(converter.Base):
+    """Transformer for arithmetic nodes."""
+
+    def visit_BinOp(self, node: ast.stmt) -> ast.stmt:
+        """Transforms a BinOp node.
+        Args :
+            node(ast.stmt) : AST node to transform
+        Returns :
+            ast.stmt : Transformed node
+        """
+        node = self.generic_visit(node)
+        op_type = type(node.op)
+        if op_type not in ARITHMETIC_OPERATORS:
+            return node
+
+        template = f"{ARITHMETIC_OPERATORS[op_type]}(lhs_,rhs_)"
+
+        new_node = templates.replace(
+            template,
+            lhs_=node.left,
+            rhs_=node.right,
+            original=node,
+        )[0].value
+
+        return new_node
+
+
+def transform(node: ast.stmt, ctx: ag_ctx.ControlStatusCtx) -> ast.stmt:
+    """Transform arithmetic nodes.
+    Args:
+        node(ast.stmt) : AST node to transform
+        ctx (ag_ctx.ControlStatusCtx) : Transformer context.
+    Returns :
+        ast.stmt : Transformed node.
+    """
+
+    return ArithmeticTransformer(ctx).visit(node)

src/autoqasm/operators/__init__.py

@@ -21,6 +21,7 @@
 from malt.impl.api import autograph_artifact  # noqa: F401
 from malt.operators.variables import Undefined, UndefinedReturnValue, ld, ldu  # noqa: F401
 
+from .arithmetic import fd_  # noqa: F401
 from .assignments import assign_for_output, assign_stmt  # noqa: F401
 from .comparisons import gt_, gteq_, lt_, lteq_  # noqa: F401
 from .conditional_expressions import if_exp  # noqa: F401

src/autoqasm/operators/arithmetic.py

@@ -0,0 +1,74 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+"""Operators for arithmetic operators: // """
+
+from __future__ import annotations
+
+from autoqasm import program
+from autoqasm import types as aq_types
+
+from .utils import _register_and_convert_parameters
+
+
+def fd_(
+    num_: aq_types.IntVar | aq_types.FloatVar | int | float,
+    den_: aq_types.IntVar | aq_types.FloatVar | int | float,
+) -> int | aq_types.IntVar:
+    """Functional form of "//".
+    Args:
+        num_ (aq_types.IntVar | aq_types.FloatVar | int | float) :
+            The numerator of the integer division
+        den_ (aq_types.IntVar | aq_types.FloatVar | int | float) :
+            The denominator of the integer division
+    Returns :
+        int | IntVar : integer division, IntVar if either numerator or denominator
+        are QASM types, else int
+    """
+    if aq_types.is_qasm_type(num_) or aq_types.is_qasm_type(den_):
+        return _oqpy_fd(num_, den_)
+    else:
+        return _py_fd(num_, den_)
+
+
+def _oqpy_fd(
+    num_: aq_types.IntVar | aq_types.FloatVar,
+    den_: aq_types.IntVar | aq_types.FloatVar,
+) -> aq_types.IntVar:
+    num_, den_ = _register_and_convert_parameters(num_, den_)
+    oqpy_program = program.get_program_conversion_context().get_oqpy_program()
+    num_is_float = isinstance(num_, aq_types.FloatVar)
+    den_is_float = isinstance(den_, aq_types.FloatVar)
+
+    # if they are of different types, then one must cast to FloatVar
+    if num_is_float or den_is_float:
+        if num_is_float:
+            float_var = aq_types.FloatVar()
+            oqpy_program.declare(float_var)
+            oqpy_program.set(float_var, den_)
+        if den_is_float:
+            float_var = aq_types.FloatVar()
+            oqpy_program.declare(float_var)
+            oqpy_program.set(float_var, num_)
+
+    result = aq_types.IntVar()
+    oqpy_program.declare(result)
+    oqpy_program.set(result, num_ / den_)
+    return result
+
+
+def _py_fd(
+    num_: int | float,
+    den_: int | float,
+) -> int:
+    return num_ // den_

src/autoqasm/transpiler/transpiler.py

@@ -48,7 +48,13 @@
 from malt.utils import ag_logging as logging
 
 from autoqasm import operators, program, types
-from autoqasm.converters import assignments, break_statements, comparisons, return_statements
+from autoqasm.converters import (
+    arithmetic,
+    assignments,
+    break_statements,
+    comparisons,
+    return_statements,
+)
 
 
 class PyToOqpy(transpiler.PyToPy):
@@ -135,6 +141,7 @@ def transform_ast(
         node = control_flow.transform(node, ctx)
         node = conditional_expressions.transform(node, ctx)
         node = comparisons.transform(node, ctx)
+        node = arithmetic.transform(node, ctx)
         node = logical_expressions.transform(node, ctx)
         node = variables.transform(node, ctx)
 

src/autoqasm/types/types.py

@@ -26,6 +26,7 @@
 from openpulse import ast
 
 from autoqasm import errors, program
+from autoqasm.errors import UnsupportedFeatureError
 
 
 def is_qasm_type(val: Any) -> bool:
@@ -152,10 +153,22 @@
         )
         self.name = program.get_program_conversion_context().next_var_name(oqpy.FloatVar)
 
+    def __floordiv__(self, other):
+        raise UnsupportedFeatureError("Integer division is supported by OpenQASM.")
+
+    def __rfloordiv__(self, other):
+        raise UnsupportedFeatureError("Integer division is supported by OpenQASM.")
+
 
 class IntVar(oqpy.IntVar):
     def __init__(self, *args, annotations: str | Iterable[str] | None = None, **kwargs):
         super(IntVar, self).__init__(
             *args, annotations=make_annotations_list(annotations), **kwargs
         )
         self.name = program.get_program_conversion_context().next_var_name(oqpy.IntVar)
+
+    def __floordiv__(self, other):
+        raise UnsupportedFeatureError("Integer division is supported by OpenQASM.")
+
+    def __rfloordiv__(self, other):
+        raise UnsupportedFeatureError("Integer division is supported by OpenQASM.")

test/unit_tests/autoqasm/test_operators.py

@@ -930,3 +930,52 @@ def test_list_ops():
         assert np.array_equal(c, [[2, 3, 4], [2, 3, 4]])
 
     assert test_list_ops.build().to_ir()
+
+
+class TestFloorDiv:
+    def test_integer_division_on_intvars(self):
+        @aq.main(num_qubits=2)
+        def main():
+            a = aq.IntVar(5)
+            b = aq.IntVar(2)
+            c = a // b  # noqa: F841
+
+        expected_ir = """OPENQASM 3.0;
+int[32] c;
+qubit[2] __qubits__;
+int[32] a = 5;
+int[32] b = 2;
+int[32] __int_2__;
+__int_2__ = a / b;
+c = __int_2__;"""
+        assert main.build().to_ir() == expected_ir
+
+    def test_integer_division_on_mixed_vars(self):
+        @aq.main(num_qubits=2)
+        def main():
+            a = aq.IntVar(5)
+            b = aq.FloatVar(2.3)
+            c = a // b  # noqa: F841
+
+        expected_ir = """OPENQASM 3.0;
+int[32] c;
+qubit[2] __qubits__;
+int[32] a = 5;
+float[64] b = 2.3;
+float[64] __float_2__;
+__float_2__ = a;
+int[32] __int_3__;
+__int_3__ = a / b;
+c = __int_3__;"""
+        assert main.build().to_ir() == expected_ir
+
+    def test_integer_division_on_python_types(self):
+        @aq.main(num_qubits=2)
+        def main():
+            a = 5
+            b = 2.3
+            c = a // b  # noqa: F841
+
+        expected_ir = """OPENQASM 3.0;
+qubit[2] __qubits__;"""
+        assert main.build().to_ir() == expected_ir