Make qint as generic (#24)

* make qint as generic

* use qintimp instead of qint, update test and docs

README.md

@@ -23,10 +23,10 @@ pip install qlasskit
 For a quickstart, read the _quickstart_ and _examples_ notebooks from the documentation: [https://dakk.github.io/qlasskit](https://dakk.github.io/qlasskit).
 
 ```python
-from qlasskit import qlassf, Qint4 
+from qlasskit import qlassf, Qint 
 
 @qlassf
-def h(k: Qint4) -> bool:
+def h(k: Qint[4]) -> bool:
     h = True
     for i in range(4):
         h = h and k[i]
@@ -65,11 +65,11 @@ You can also use other functions inside a qlassf:
 
 ```python
 @qlassf
-def equal_8(n: Qint4) -> bool:
+def equal_8(n: Qint[4]) -> bool:
   return equal_8 == 8
 
 @qlassfa(defs=[equal_8])
-def f(n: Qint4) -> bool:
+def f(n: Qint[4]) -> bool:
   n = n+1 if equal_8(n) else n
   return n
 ```
@@ -78,13 +78,13 @@ Qlasskit supports complex data types, like tuples and fixed size lists:
 
 ```python
 @qlassf
-def f(a: Tuple[Qint8, Qint8]) -> Tuple[bool, bool]:
+def f(a: Tuple[Qint[8], Qint[8]]) -> Tuple[bool, bool]:
   return a[0] == 42, a[1] == 0
 ```
 
 ```python
 @qlassf
-def search(alist: Qlist[Qint2, 4], to_search: Qint2):
+def search(alist: Qlist[Qint[2], 4], to_search: Qint[2]):
   for x in alist:
     if x == to_search:
       return True

docs/source/algorithms.ipynb

@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
@@ -41,18 +41,18 @@
        "4"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "from typing import Tuple\n",
-    "from qlasskit import qlassf, Qint4\n",
+    "from qlasskit import qlassf, Qint, Qint4\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def test_tools(a: Qint4) -> Qint4:\n",
+    "def test_tools(a: Qint[4]) -> Qint[4]:\n",
     "    return a + 1\n",
     "\n",
     "\n",
@@ -68,7 +68,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -77,7 +77,7 @@
        "'0100'"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -95,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -133,15 +133,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "from qlasskit.algorithms import Simon\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def f(a: Qint4) -> Qint4:\n",
+    "def f(a: Qint[4]) -> Qint[4]:\n",
     "    return (a >> 3) + 1\n",
     "\n",
     "\n",
@@ -167,15 +167,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "from qlasskit.algorithms import DeutschJozsa\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def f(b: Qint4) -> bool:\n",
+    "def f(b: Qint[4]) -> bool:\n",
     "    return b < 16\n",
     "\n",
     "\n",

docs/source/example_bqm_polynomial.ipynb

@@ -38,14 +38,14 @@
     }
    ],
    "source": [
-    "from qlasskit import qlassf, qlassfa, Qmatrix, Qint2, Qint3, Qint4, Qfixed\n",
-    "from qlasskit.types.qfixed import Qfixed2_4\n",
+    "from qlasskit import qlassf, Qfixed\n",
     "\n",
     "\n",
     "@qlassf\n",
     "def poly(x: Qfixed[3, 3], y: Qfixed[3, 3]) -> Qfixed[3, 3]:\n",
     "    return x * 3 - y * 2 + 1\n",
     "\n",
+    "\n",
     "poly.expressions"
    ]
   },
@@ -70,14 +70,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'x': 7.875, 'y': 3.375} DecodedSample(-640.0, {'x': 7.875, 'y': 3.375})\n"
+      "{'x': 7.875, 'y': 7.375}\n"
      ]
     }
    ],

docs/source/example_deutsch_jozsa.ipynb

@@ -13,11 +13,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qlasskit import qlassf, Qint4\n",
+    "from qlasskit import qlassf, Qint\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def f(a: Qint4) -> bool:\n",
+    "def f(a: Qint[4]) -> bool:\n",
     "    return a > 7"
    ]
   },

docs/source/exporter.ipynb

@@ -20,11 +20,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qlasskit import Qint2, qlassf\n",
+    "from qlasskit import Qint, qlassf\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def hello_world(a: bool, b: Qint2) -> Qint2:\n",
+    "def hello_world(a: bool, b: Qint[2]) -> Qint[2]:\n",
     "    return b + (1 if a else 0)"
    ]
   },
@@ -213,18 +213,7 @@
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Gate(hello_world, targets=[0, 1, 2, 3, 4], controls=None, classical controls=None, control_value=None, classical_control_value=None)]"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Disabled on docs for a depencency problem\n",
     "# qc = hello_world.export(\"qutip\")\n",

docs/source/how_it_works.ipynb

@@ -28,12 +28,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qlasskit import qlassf, Qint2, Qint4\n",
+    "from qlasskit import qlassf\n",
     "from qiskit import QuantumCircuit\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def f_comp(b: bool, n: Qint2) -> Qint2:\n",
+    "def f_comp(b: bool, n: Qint[2]) -> Qint[2]:\n",
     "    for i in range(3):\n",
     "        n += 1 if b else 2\n",
     "    return n"
@@ -72,7 +72,7 @@
    ],
    "source": [
     "@qlassf\n",
-    "def f1(b: bool, n: Qint2) -> Qint2:\n",
+    "def f1(b: bool, n: Qint[2]) -> Qint[2]:\n",
     "    return n + (1 if b else 2)\n",
     "\n",
     "\n",
@@ -151,7 +151,7 @@
    "outputs": [],
    "source": [
     "@qlassf\n",
-    "def f(n: Qint4) -> bool:\n",
+    "def f(n: Qint[4]) -> bool:\n",
     "    return n == 3"
    ]
   },

docs/source/parameters.ipynb

@@ -67,11 +67,11 @@
     }
    ],
    "source": [
-    "from qlasskit import Qlist, Qint2, Qint4\n",
+    "from qlasskit import Qlist, Qint, Qint4\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def test(a: Parameter[Qlist[Qint2, 4]], b: Qint4) -> Qint4:\n",
+    "def test(a: Parameter[Qlist[Qint[2], 4]], b: Qint[4]) -> Qint[4]:\n",
     "    s = Qint4(0)\n",
     "    for n in a:\n",
     "        s += n\n",

docs/source/quickstart.ipynb

@@ -19,11 +19,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qlasskit import qlassf, Qint2\n",
+    "from qlasskit import qlassf, Qint, Qint2\n",
     "\n",
     "\n",
     "@qlassf\n",
-    "def sum_two_numbers(a: Qint2, b: Qint2) -> Qint2:\n",
+    "def sum_two_numbers(a: Qint[2], b: Qint[2]) -> Qint[2]:\n",
     "    return a + b"
    ]
   },
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -75,7 +75,7 @@
        "<Figure size 789.163x618.722 with 1 Axes>"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -95,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -105,7 +105,7 @@
        "<Figure size 700x500 with 1 Axes>"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -136,7 +136,15 @@
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
    "version": "3.10.13"
   }
  },

docs/source/supported.rst

@@ -29,14 +29,15 @@ Boolean type.
 Qint
 ^^^^
 
-Unsigned integers; this type has subtypes for different Qint sizes (Qint2, Qint4, Qint8, Qint12, Qint16). 
+Unsigned integers; `Qint[2]` has 2 bits, and there other sizes are supported.
 Single bit of the Qint are accessible by the subscript operator `[]`.
-
+All the supported sizes have a constructor `Qintn()` defined in `qlasskit.types`.
 
 Qfixed
 ^^^^^^
 
 Fixed point rational number; `Qfixed[2,3]` has 2 bits for the integer part and 3 bits for the fractional.
+All the supported sizes have a constructor `Qfixedn_m()` defined in `qlasskit.types`.
 
 Qchar
 ^^^^^
@@ -53,14 +54,14 @@ List
 ^^^^
 
 Qlist[T, size] denotes a fixed-size list in qlasskit. 
-For example, the list `[1,2,3]` is typed as `Qlist[Qint2,3]`.
+For example, the list `[1,2,3]` is typed as `Qlist[Qint[2],3]`.
 
 
 Matrix
 ^^^^
 
 Qmatrix[T, m, n] denotes a fixed-size list in qlasskit. 
-For example, the matrix `[[1,2],[3,4]]` is typed as `Qmatrix[Qint2,2,2]`.
+For example, the matrix `[[1,2],[3,4]]` is typed as `Qmatrix[Qint[2],2,2]`.
 
 
 
@@ -243,7 +244,7 @@ Function def
 
 .. code-block:: python
 
-   def f(t: Qlist[Qint4,2]) -> Qint4:
+   def f(t: Qlist[Qint[4],2]) -> Qint[4]:
       return t[0] + t[1]
 
 

qlasskit/ast2logic/t_arguments.py

@@ -25,7 +25,10 @@ def to_name(a):
         if isinstance(a, ast.Attribute):
             return a.attr
         elif isinstance(a, ast.Subscript):  # for Qfixed and similar
-            t = "_".join(f"{e.value}" for e in a.slice.elts)
+            if isinstance(a.slice, ast.Constant):
+                t = f"{a.slice.value}"
+            else:
+                t = "_".join(f"{e.value}" for e in a.slice.elts)
             return f"{a.value.id}{t}"
         else:
             return a.id