essai

notebooks/qistest.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Total count are: {'00': 505, '11': 495}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 911.6x292.4 with 1 Axes>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from qiskit import(\n",
+    "  QuantumCircuit,\n",
+    "  execute,\n",
+    "  Aer)\n",
+    "from qiskit.visualization import plot_histogram\n",
+    "\n",
+    "# Use Aer's qasm_simulator\n",
+    "simulator = Aer.get_backend('qasm_simulator')\n",
+    "\n",
+    "# Create a Quantum Circuit acting on the q register\n",
+    "circuit = QuantumCircuit(2,2)\n",
+    "\n",
+    "circuit.h(0)\n",
+    "circuit.barrier()\n",
+    "circuit.h(0)\n",
+    "circuit.h(1)\n",
+    "circuit.cx(1,0)\n",
+    "circuit.h(0)\n",
+    "circuit.h(1)\n",
+    "circuit.barrier()\n",
+    "circuit.measure([0,1], [0,1])\n",
+    "\n",
+    "# Execute the circuit on the qasm simulator\n",
+    "job = execute(circuit, simulator, shots=1000)\n",
+    "\n",
+    "# Grab results from the job\n",
+    "result = job.result()\n",
+    "\n",
+    "# Returns counts\n",
+    "counts = result.get_counts(circuit)\n",
+    "print(\"\\nTotal count are:\",counts)\n",
+    "\n",
+    "# Draw the circuit\n",
+    "circuit.draw(output='mpl',scale=1)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x360 with 1 Axes>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Plot a histogram\n",
+    "plot_histogram(counts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on method draw in module qiskit.circuit.quantumcircuit:\n",
+      "\n",
+      "draw(scale=0.7, filename=None, style=None, output=None, interactive=False, line_length=None, plot_barriers=True, reverse_bits=False, justify=None, vertical_compression='medium', idle_wires=True, with_layout=True, fold=None, ax=None) method of qiskit.circuit.quantumcircuit.QuantumCircuit instance\n",
+      "    Draw the quantum circuit\n",
+      "    \n",
+      "    **text**: ASCII art TextDrawing that can be printed in the console.\n",
+      "    \n",
+      "    **latex**: high-quality images compiled via latex.\n",
+      "    \n",
+      "    **latex_source**: raw uncompiled latex output.\n",
+      "    \n",
+      "    **matplotlib**: images with color rendered purely in Python.\n",
+      "    \n",
+      "    Args:\n",
+      "        scale (float): scale of image to draw (shrink if < 1)\n",
+      "        filename (str): file path to save image to\n",
+      "        style (dict or str): dictionary of style or file name of style\n",
+      "            file. This option is only used by the ``mpl`` output type. If a\n",
+      "            str is passed in that is the path to a json file which contains\n",
+      "            that will be open, parsed, and then used just as the input\n",
+      "            dict. See: :ref:`Style Dict Doc <style-dict-circ-doc>` for more\n",
+      "            information on the contents.\n",
+      "        output (str): Select the output method to use for drawing the\n",
+      "            circuit. Valid choices are ``text``, ``latex``,\n",
+      "            ``latex_source``, or ``mpl``. By default the `'text`' drawer is\n",
+      "            used unless a user config file has an alternative backend set\n",
+      "            as the default. If the output kwarg is set, that backend\n",
+      "            will always be used over the default in a user config file.\n",
+      "        interactive (bool): when set true show the circuit in a new window\n",
+      "            (for `mpl` this depends on the matplotlib backend being used\n",
+      "            supporting this). Note when used with either the `text` or the\n",
+      "            `latex_source` output type this has no effect and will be\n",
+      "            silently ignored.\n",
+      "        line_length (int): Deprecated, see `fold` which supersedes this\n",
+      "            option. Sets the length of the lines generated by `text` output\n",
+      "            type. This useful when the drawing does not fit in the console.\n",
+      "            If None (default), it will try to guess the console width using\n",
+      "            ``shutil.get_terminal_size()``. However, if you're running in\n",
+      "            jupyter the default line length is set to 80 characters. If you\n",
+      "            don't want pagination at all, set ``line_length=-1``.\n",
+      "        reverse_bits (bool): When set to True reverse the bit order inside\n",
+      "            registers for the output visualization.\n",
+      "        plot_barriers (bool): Enable/disable drawing barriers in the output\n",
+      "            circuit. Defaults to True.\n",
+      "        justify (string): Options are ``left``, ``right`` or\n",
+      "            ``none``, if anything else is supplied it defaults to left\n",
+      "            justified. It refers to where gates should be placed in the\n",
+      "            output circuit if there is an option. ``none`` results in\n",
+      "            each gate being placed in its own column.\n",
+      "        vertical_compression (string): ``high``, ``medium`` or ``low``. It\n",
+      "            merges the lines generated by the ``text`` output so the\n",
+      "            drawing will take less vertical room.  Default is ``medium``.\n",
+      "            Only used by the ``text`` output, will be silently ignored\n",
+      "            otherwise.\n",
+      "        idle_wires (bool): Include idle wires (wires with no circuit\n",
+      "            elements) in output visualization. Default is True.\n",
+      "        with_layout (bool): Include layout information, with labels on the\n",
+      "            physical layout. Default is True.\n",
+      "        fold (int): Sets pagination. It can be disabled using -1.\n",
+      "            In `text`, sets the length of the lines. This useful when the\n",
+      "            drawing does not fit in the console. If None (default), it will\n",
+      "            try to guess the console width using ``shutil.\n",
+      "            get_terminal_size()``. However, if running in jupyter, the\n",
+      "            default line length is set to 80 characters. In ``mpl`` is the\n",
+      "            number of (visual) layers before folding. Default is 25.\n",
+      "        ax (matplotlib.axes.Axes): An optional Axes object to be used for\n",
+      "            the visualization output. If none is specified a new matplotlib\n",
+      "            Figure will be created and used. Additionally, if specified\n",
+      "            there will be no returned Figure since it is redundant. This is\n",
+      "            only used when the ``output`` kwarg is set to use the ``mpl``\n",
+      "            backend. It will be silently ignored with all other outputs.\n",
+      "    \n",
+      "    Returns:\n",
+      "        :class:`PIL.Image` or :class:`matplotlib.figure` or :class:`str` or\n",
+      "        :class:`TextDrawing`:\n",
+      "    \n",
+      "        * `PIL.Image` (output='latex')\n",
+      "            an in-memory representation of the image of the circuit\n",
+      "            diagram.\n",
+      "        * `matplotlib.figure.Figure` (output='mpl')\n",
+      "            a matplotlib figure object for the circuit diagram.\n",
+      "        * `str` (output='latex_source')\n",
+      "            The LaTeX source code for visualizing the circuit diagram.\n",
+      "        * `TextDrawing` (output='text')\n",
+      "            A drawing that can be printed as ascii art\n",
+      "    \n",
+      "    Raises:\n",
+      "        VisualizationError: when an invalid output method is selected\n",
+      "        ImportError: when the output methods requires non-installed\n",
+      "            libraries.\n",
+      "    \n",
+      "    .. _style-dict-circ-doc:\n",
+      "    \n",
+      "    **Style Dict Details**\n",
+      "    \n",
+      "    The style dict kwarg contains numerous options that define the style of\n",
+      "    the output circuit visualization. The style dict is only used by the\n",
+      "    ``mpl`` output. The options available in the style dict are defined\n",
+      "    below:\n",
+      "    \n",
+      "    Args:\n",
+      "        textcolor (str): The color code to use for text. Defaults to\n",
+      "            `'#000000'`\n",
+      "        subtextcolor (str): The color code to use for subtext. Defaults to\n",
+      "            `'#000000'`\n",
+      "        linecolor (str): The color code to use for lines. Defaults to\n",
+      "            `'#000000'`\n",
+      "        creglinecolor (str): The color code to use for classical register\n",
+      "            lines. Defaults to `'#778899'`\n",
+      "        gatetextcolor (str): The color code to use for gate text. Defaults\n",
+      "            to `'#000000'`\n",
+      "        gatefacecolor (str): The color code to use for gates. Defaults to\n",
+      "            `'#ffffff'`\n",
+      "        barrierfacecolor (str): The color code to use for barriers.\n",
+      "            Defaults to `'#bdbdbd'`\n",
+      "        backgroundcolor (str): The color code to use for the background.\n",
+      "            Defaults to `'#ffffff'`\n",
+      "        fontsize (int): The font size to use for text. Defaults to 13\n",
+      "        subfontsize (int): The font size to use for subtext. Defaults to 8\n",
+      "        displaytext (dict): A dictionary of the text to use for each\n",
+      "            element type in the output visualization. The default values\n",
+      "            are::\n",
+      "    \n",
+      "                {\n",
+      "                    'id': 'id',\n",
+      "                    'u0': 'U_0',\n",
+      "                    'u1': 'U_1',\n",
+      "                    'u2': 'U_2',\n",
+      "                    'u3': 'U_3',\n",
+      "                    'x': 'X',\n",
+      "                    'y': 'Y',\n",
+      "                    'z': 'Z',\n",
+      "                    'h': 'H',\n",
+      "                    's': 'S',\n",
+      "                    'sdg': 'S^\\dagger',\n",
+      "                    't': 'T',\n",
+      "                    'tdg': 'T^\\dagger',\n",
+      "                    'rx': 'R_x',\n",
+      "                    'ry': 'R_y',\n",
+      "                    'rz': 'R_z',\n",
+      "                    'reset': '\\left|0\\right\\rangle'\n",
+      "                }\n",
+      "    \n",
+      "            You must specify all the necessary values if using this. There\n",
+      "            is no provision for passing an incomplete dict in.\n",
+      "        displaycolor (dict): The color codes to use for each circuit\n",
+      "            element. The default values are::\n",
+      "    \n",
+      "                {\n",
+      "                    'id': '#F0E442',\n",
+      "                    'u0': '#E7AB3B',\n",
+      "                    'u1': '#E7AB3B',\n",
+      "                    'u2': '#E7AB3B',\n",
+      "                    'u3': '#E7AB3B',\n",
+      "                    'x': '#58C698',\n",
+      "                    'y': '#58C698',\n",
+      "                    'z': '#58C698',\n",
+      "                    'h': '#70B7EB',\n",
+      "                    's': '#E0722D',\n",
+      "                    'sdg': '#E0722D',\n",
+      "                    't': '#E0722D',\n",
+      "                    'tdg': '#E0722D',\n",
+      "                    'rx': '#ffffff',\n",
+      "                    'ry': '#ffffff',\n",
+      "                    'rz': '#ffffff',\n",
+      "                    'reset': '#D188B4',\n",
+      "                    'target': '#70B7EB',\n",
+      "                    'meas': '#D188B4'\n",
+      "                }\n",
+      "    \n",
+      "           Also, just like  `displaytext` there is no provision for an\n",
+      "           incomplete dict passed in.\n",
+      "    \n",
+      "        latexdrawerstyle (bool): When set to True enable latex mode which\n",
+      "            will draw gates like the `latex` output modes.\n",
+      "        usepiformat (bool): When set to True use radians for output\n",
+      "        fold (int): The number of circuit elements to fold the circuit at.\n",
+      "            Defaults to 20\n",
+      "        cregbundle (bool): If set True bundle classical registers\n",
+      "        showindex (bool): If set True draw an index.\n",
+      "        compress (bool): If set True draw a compressed circuit\n",
+      "        figwidth (int): The maximum width (in inches) for the output figure.\n",
+      "        dpi (int): The DPI to use for the output image. Defaults to 150\n",
+      "        margin (list): A list of margin values to adjust spacing around\n",
+      "            output image. Takes a list of 4 ints:\n",
+      "            [x left, x right, y bottom, y top].\n",
+      "        creglinestyle (str): The style of line to use for classical\n",
+      "            registers. Choices are `'solid'`, `'doublet'`, or any valid\n",
+      "            matplotlib `linestyle` kwarg value. Defaults to `doublet`\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(circuit.draw)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Diaporama",
+  "kernelspec": {
+   "display_name": "qiskitenv",
+   "language": "python",
+   "name": "qiskitenv"
+  },
+  "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}