{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Comparaison de tutormagic et nbtutor pour visualiser du code Python et C dans un notebook Jupyter\n",
    "\n",
    "Je viens de découvrir ces deux projets très chousettes : [tutormagic](https://github.com/kikocorreoso/tutormagic/) et [nbtutor](https://github.com/lgpage/nbtutor), tous les deux lias bres, gratuits, en Python, et proposant d'intégrer des visualisations intéractives, venant ou inspirées du merveilleux [PythonTutor.com](http://pythontutor.com/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### But : je souhaite savoir laquelle des deux extensions est la meilleure, et pour quels usages\n",
    "\n",
    "- Peut-on utiliser l'un des deux en mode offline (sans une *iframe* vers PythonTutor) ? Je pense que non pour tutormagic, je pense que oui pour nbtutor.\n",
    "\n",
    "- Est-ce que ça marche bien pour tous les types de Python de base : booléens/entiers/flottants, chaînes, objets, nombres complexes, tableau/`list`, dictionnaire/ensemble ? Probablement ! Réponse : oui !\n",
    "\n",
    "- Et avec des tableaux numpy ? Probablement !. Réponse : oui pour `tutormagic` avec ma nouvelle version qui ajoute le mode \"py3anaconda\" (à voir si [cette PR](https://github.com/kikocorreoso/tutormagic/pull/11) est acceptée !)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Et avec matplotlib ? Probablement pas. Réponse : avec `tutormagic` peut-être, tant qu'on ne génère pas de figure... avec `nbtutor` apparemment oui.\n",
    "- Et avec *truc ésotérique* ? Probablement pas.. Réponse : probablement non ! Mais `tutormagic` en mode \"py3anaconda\" [supporte plein de modules scientifiques](https://docs.anaconda.com/anaconda/packages/old-pkg-lists/5.2.0/py2.7_linux-32/) puisque Anaconda 5.2 supporte plein de trucs : scipy, sympa, scikit-learn, et j'en passe !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Attention ? Projets pas récents !\n",
    "\n",
    "Jupyter a beaucoup changé ces dernières anneés, entre 2018 et 2021..\n",
    "\n",
    "Mais ave jupyter classique, normalement ça va les \"vieilles\" extensions fonctionnent encore.\n",
    "Jupyter Lab, c'est une autre histoire !\n",
    "\n",
    "- [tutormagic](https://github.com/kikocorreoso/tutormagic/) n'a pas été mis à jour depuis 2017, probablement plus très fiable ! Et pas de documentation Sphinx sur ReadTheDocs, ça sent le projet assez expérimental. Mais c'est distribué proprement sur `pip`, et s'installe en une commande !\n",
    "- [nbtutor](https://github.com/lgpage/nbtutor) n'a pas été mis à jour depuis 2016, probablement plus très fiable ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### A propos de ce document\n",
    "\n",
    "- C'est un [notebook Jupyter](https://jupyter.org/), écrit en [Python 3](https://www.python.org/) (mais j'expérimente avec le [Kernel C](https://github.com/brendan-rius/jupyter-c-kernel) plus bas) ;\n",
    "- Auteur : [Lilian Besson](https://github.com/Naereen/notebooks) ;\n",
    "- Date : 21/02/2021 ;\n",
    "- License : [MIT](https://lbesson.mit-license.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dépendances\n",
    "\n",
    "Dans mon installation de Python 3, j'ai installé les deux paquets `tutormagic` et `nbtutor`\n",
    "\n",
    "Où installer ?\n",
    "- dans l'installation globale avec `sudo pip install` ;\n",
    "- ou dans une installation locale dans un virtualenv ou pyenv ou autre, avec `pip install` (ou avec `conda install` mais pas testé)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:30:12.725034Z",
     "start_time": "2021-02-21T00:30:12.664624Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Démonstration (pas exécutée)\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "echo \"Démonstration (pas exécutée)\"\n",
    "exit 0  # enlevez ça pour refaire ça chez vous\n",
    "\n",
    "# tapez ça dans votre terminal\n",
    "pip install tutormagic nbtutor\n",
    "# si ça marche pas, rajoutez sudo\n",
    "sudo pip install tutormagic nbtutor\n",
    "\n",
    "# il faut manuellement installer et activer nbtutor\n",
    "jupyter nbextension install --overwrite --py nbtutor\n",
    "jupyter nbextension enable --py nbtutor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Et donc ce notebook peut déclarer ses dépendances :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:19.036061Z",
     "start_time": "2021-02-21T01:55:18.864081Z"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext watermark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:19.652188Z",
     "start_time": "2021-02-21T01:55:19.592706Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lilian Besson (Naereen) \n",
      "\n",
      "tutormagic 0.3.0\n",
      "nbtutor 1.0.4\n",
      "numpy 1.19.2\n",
      "matplotlib 3.3.2\n"
     ]
    }
   ],
   "source": [
    "watermark -a \"Lilian Besson (Naereen)\" -p tutormagic,nbtutor,numpy,matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-20T21:46:42.863870Z",
     "start_time": "2021-02-20T21:46:42.856247Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Première comparaison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:30:14.771680Z",
     "start_time": "2021-02-21T00:30:14.767023Z"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Démo de jupyter notebook\n",
      "Somme des 10 premiers cubes = 2025\n"
     ]
    }
   ],
   "source": [
    "test = \"Démo de jupyter notebook\"\n",
    "print(test)\n",
    "\n",
    "somme = 0\n",
    "MAX_I = 10\n",
    "for i in range(1, MAX_I):\n",
    "    somme += i**3\n",
    "print(f\"Somme des {MAX_I} premiers cubes = {somme}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Un petit programme à tester avec les deux interfaces\n",
    "\n",
    "Je vais emprunter le petit problème arithmético-algorithmique suivant, posé à mes élèves au début de février 2021 :\n",
    "\n",
    "> Mini challenge algorithmique pour les passionnés en manque de petits exercices de code : (optionnel) Vous avez dû observer que ce mois de février est spécial parce que le 1er février est un lundi, et qu'il a exactement 4 lundis, 4 mardis, 4 mercredis, 4 jeudis, 4 vendredis, 4 samedis et 4 dimanches.\n",
    ">\n",
    "> Question : Comptez le nombre de mois de février répondant à ce critère (je n'ai pas trouvé de nom précis), depuis l'année de création de l'ENS Rennes (1994, enfin pour Cachan antenne Bretagne) jusqu'à 2077 (1994 et 2077 inclus).\n",
    "\n",
    "\n",
    "Pour plus d'informations, cf [ce notebook](https://perso.crans.org/besson/notebooks/F%c3%a9vrier%202021%20un%20mini%20challenge%20arithm%c3%a9tico-algorithmique.html#R%C3%A9ponse-en-Python-(par-Lilian-Besson)) (aussi sur GitHub et nbviewer)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Avec le module calendar on pourrait faire comme en Bash : imprimer les calendriers, et rechercher des chaînes particulières... mais ce n'est pas très propre. Essayons avec ce même module mais en écrivant une solution fonctionnelle !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:27.487957Z",
     "start_time": "2021-02-21T01:55:27.479126Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True, False)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import calendar\n",
    "\n",
    "def filter_annee(annee):\n",
    "    return (\n",
    "        set(calendar.Calendar(annee).itermonthdays2(annee, 2))\n",
    "        & {(1,0), (28, 6), (29, 0)}\n",
    "    ) == {(1, 0), (28, 6)}\n",
    "\n",
    "filter_annee(2020), filter_annee(2021), filter_annee(2022)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "C'est un bon exemple car il utilise des listes, des ensembles etc.\n",
    "Peut-être restreindre le nombre d'année considérées, pour simplifier ?\n",
    "\n",
    "Et donc on a juste à compter les années, de 1994 à 2077 inclus, qui ne sont pas des années bissextiles et qui satisfont le filtre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:28.788844Z",
     "start_time": "2021-02-21T01:55:28.776770Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.16 ms, sys: 696 µs, total: 1.85 ms\n",
      "Wall time: 1.87 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "len(list(filter(filter_annee, ( annee\n",
    "        for annee in range(1994, 2077 + 1)\n",
    "        # if not calendar.isleap(annee) # en fait c'est inutile\n",
    "    )\n",
    ")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avec `tutormagic`\n",
    "\n",
    "Je suis le tutoriel présent [sur la documentation](https://github.com/kikocorreoso/tutormagic/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:30.297096Z",
     "start_time": "2021-02-21T01:55:30.291178Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tutormagic extension is already loaded. To reload it, use:\n",
      "  %reload_ext tutormagic\n"
     ]
    }
   ],
   "source": [
    "%load_ext tutormagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:31.940422Z",
     "start_time": "2021-02-21T01:55:31.933230Z"
    },
    "code_folding": [
     0
    ],
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"500\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%0AURL%20%3D%20%22http%3A//PythonTutor.com%22%0Atest%20%3D%20%22D%C3%A9mo%20de%20tutormagic%22%0Aexplication%20%3D%20f%22avec%20un%20iframe%20vers%20%7BURL%7D%22%0Aprint%28test%2C%20explication%29%0A%0Asomme%20%3D%200%0AMAX_I%20%3D%2010%0Afor%20i%20in%20range%281%2C%20MAX_I%29%3A%0A%20%20%20%20somme%20%2B%3D%20i%2A%2A3%0Aprint%28f%22Somme%20des%20%7BMAX_I%7D%20premiers%20cubes%20%3D%20%7Bsomme%7D%22%29%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&curInstr=0&&verticalStack=false&py=3&rawInputLstJSON=%5B%5D&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f337c199400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3 --height 500\n",
    "\n",
    "URL = \"http://PythonTutor.com\"\n",
    "test = \"Démo de tutormagic\"\n",
    "explication = f\"avec un iframe vers {URL}\"\n",
    "print(test, explication)\n",
    "\n",
    "somme = 0\n",
    "MAX_I = 10\n",
    "for i in range(1, MAX_I):\n",
    "    somme += i**3\n",
    "print(f\"Somme des {MAX_I} premiers cubes = {somme}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ca marche bien pour ce petit exemple !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Essayons plus solide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:55:40.321780Z",
     "start_time": "2021-02-21T01:55:40.308506Z"
    },
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"500\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%0Aimport%20calendar%0A%0Adef%20filter_annee%28annee%29%3A%0A%20%20%20%20return%20%28%0A%20%20%20%20%20%20%20%20set%28calendar.Calendar%28annee%29.itermonthdays2%28annee%2C%202%29%29%0A%20%20%20%20%20%20%20%20%26%20%7B%281%2C0%29%2C%20%2828%2C%206%29%2C%20%2829%2C%200%29%7D%0A%20%20%20%20%29%20%3D%3D%20%7B%281%2C%200%29%2C%20%2828%2C%206%29%7D%0A%0Anb_bonnes_annees%20%3D%20len%28list%28filter%28filter_annee%2C%20%28%20annee%0A%20%20%20%20%20%20%20%20for%20annee%20in%20range%281994%2C%202077%20%2B%201%29%0A%20%20%20%20%20%20%20%20%23%20if%20not%20calendar.isleap%28annee%29%20%23%20en%20fait%20c%27est%20inutile%0A%20%20%20%20%29%0A%29%29%29%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&curInstr=11&&verticalStack=false&py=3&rawInputLstJSON=%5B%5D&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f337c199240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3 --run --height 500 --curInstr 11\n",
    "\n",
    "import calendar\n",
    "\n",
    "def filter_annee(annee):\n",
    "    return (\n",
    "        set(calendar.Calendar(annee).itermonthdays2(annee, 2))\n",
    "        & {(1,0), (28, 6), (29, 0)}\n",
    "    ) == {(1, 0), (28, 6)}\n",
    "\n",
    "nb_bonnes_annees = len(list(filter(filter_annee, ( annee\n",
    "        for annee in range(1994, 2077 + 1)\n",
    "        # if not calendar.isleap(annee) # en fait c'est inutile\n",
    "    )\n",
    ")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Whooo! Ca a pris 763 étapes, on était pas loin de la limite des 1000 étapes sur PythonTutor.com, mais ça marche !\n",
    "\n",
    "Ca marche **vraiment bien** !\n",
    "\n",
    "En repliant le code (avec une extension, [Codefolding](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/codefolding/readme.html)), on peut montrer juste le début (la \"magic\" `%%tutor`) et l'iframe !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bonus : ça fonctionne si on ferme le notebook et qu'on le rouvre, sans même avoir à réexécuter la cellule !\n",
    "Très pratique pour préparer son cours !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avec `nbtutor`\n",
    "\n",
    "Je suis aussi la documentation sur [la page GitHub de nbtutor](https://github.com/lgpage/nbtutor)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:41:38.690381Z",
     "start_time": "2021-02-21T00:41:38.672805Z"
    }
   },
   "outputs": [],
   "source": [
    "%reload_ext nbtutor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ca semble bien chargé, essayons !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:56:17.140568Z",
     "start_time": "2021-02-21T01:56:16.991874Z"
    },
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "nbtutor",
     "output_type": "stream",
     "text": [
      "Démo de nbtutor, normalement sans iframe vers PythonTutor.com\n",
      "Somme des 10 premiers cubes = 2025\n"
     ]
    }
   ],
   "source": [
    "%%nbtutor --reset --force --debug\n",
    "\n",
    "explication = \"Démo de nbtutor, normalement sans iframe vers PythonTutor.com\"\n",
    "print(explication)\n",
    "\n",
    "somme = 0\n",
    "MAX_I = 10\n",
    "for i in range(1, MAX_I):\n",
    "    somme += i**3\n",
    "print(f\"Somme des {MAX_I} premiers cubes = {somme}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "~~Ca marche pas :(~~ Apparemment ça marche pas bien si tutormagic a aussi été exécuté...\n",
    "\n",
    "Je vois sur la documentation du projet que l'installation de l'extension ajoute une \"barre d'outil de cellule\", ~~mais je ne l'ai pas~~... je l'ai désormais, en rechargeant le notebook !\n",
    "\n",
    "Elle prend la place de la barre d'outil pour les [slides RISE](https://rise.readthedocs.io/en/stable/), mais ce n'est pas grave, on peut passer de l'un à l'autre.\n",
    "\n",
    "Je rencontre le même problème que [ce ticket](https://github.com/lgpage/nbtutor/issues/29)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Essayons de comprendre ce problème de nbtutor !!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:32:35.453766Z",
     "start_time": "2021-02-21T00:32:34.058390Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: nbtutor\r\n",
      "Version: 1.0.4\r\n",
      "Summary: Visualize Python code execution in Jupyter Notebook cells\r\n",
      "Home-page: https://github.com/lgpage/nbtutor\r\n",
      "Author: Logan Page\r\n",
      "Author-email: page.lg@gmail.com\r\n",
      "License: BSD 3-Clause\r\n",
      "Location: /usr/local/lib/python3.6/dist-packages\r\n",
      "Requires: notebook\r\n",
      "Required-by: \r\n"
     ]
    }
   ],
   "source": [
    "!pip show nbtutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:32:37.264645Z",
     "start_time": "2021-02-21T00:32:36.948283Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      nbtutor/js/nbtutor.min \u001b[32m enabled \u001b[0m\r\n",
      "      - Validating: \u001b[32mOK\u001b[0m\r\n",
      "    tree section\r\n"
     ]
    }
   ],
   "source": [
    "!jupyter-nbextension list 2>&1 | grep -A 2 nbtutor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bon, le package semble installé, et ajouté comme une extension Jupyter, qui le reconnaît et la valide...\n",
    "\n",
    "Chargez l'extension avec `%load_ext nbtutor` a fonctionné... juste la magic `%%nbtutor` ne marche pas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:32:38.213689Z",
     "start_time": "2021-02-21T00:32:38.204082Z"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-20T22:48:57.412441Z",
     "start_time": "2021-02-20T22:48:57.396135Z"
    }
   },
   "source": [
    "Sa documentation se charge bien !\n",
    "\n",
    "```\n",
    "Docstring:\n",
    "::\n",
    "\n",
    "  %nbtutor [-r] [-f] [-i] [-d N] [--digits D] [--max_size S] [--step_all]\n",
    "               [--expand_arrays] [--nolies] [--debug]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais rien ne se passe ! Même en mode `--debug`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:42:28.381542Z",
     "start_time": "2021-02-21T00:42:28.310305Z"
    }
   },
   "outputs": [
    {
     "name": "nbtutor",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "%%nbtutor --reset --force --debug\n",
    "\n",
    "x = sum([i**3 for i in range(1, 10)])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aucun message d'erreur, rien dans la console qui a lancé Jupyter...\n",
    "\n",
    "Je pense que l'extension est cassée avec les nouvelles variantes de Python ou de Jupyter, qui comme je le suspectais a beaucoup changé depuis 2016 (dernier commit de ce projet)...\n",
    "\n",
    "J'ai demandé au développeur [s'il maintenait encore son projet](https://github.com/lgpage/nbtutor/issues/41)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Et pour l'exemple plus gros :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:56:56.794841Z",
     "start_time": "2021-02-21T01:56:55.691223Z"
    },
    "code_folding": [],
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "nbtutor",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "%%nbtutor --reset --force\n",
    "\n",
    "import calendar\n",
    "\n",
    "def filter_annee(annee):\n",
    "    return (\n",
    "        set(calendar.Calendar(annee).itermonthdays2(annee, 2))\n",
    "        & {(1,0), (28, 6), (29, 0)}\n",
    "    ) == {(1, 0), (28, 6)}\n",
    "\n",
    "nb_bonnes_annees = len(list(filter(filter_annee, ( annee\n",
    "        for annee in range(1994, 2077 + 1)\n",
    "        # if not calendar.isleap(annee) # en fait c'est inutile\n",
    "    )\n",
    ")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ca marche ! Wooo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "---\n",
    "## Avec numpy et matplotlib ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:57:09.947877Z",
     "start_time": "2021-02-21T01:57:09.784589Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:57:18.017437Z",
     "start_time": "2021-02-21T01:57:17.663614Z"
    },
    "code_folding": [
     10
    ],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.linspace(-10, 10)\n",
    "\n",
    "def f1(x): return np.cos(x**2)\n",
    "def f2(x): return np.sin(x**2)\n",
    "def f3(x): return f1(x)+f2(x) \n",
    "Y1 = f1(X)\n",
    "Y2 = f2(X)\n",
    "Y3 = f3(X)\n",
    "\n",
    "# avec la police \"Humour Sans\", téléchargée depuis https://aur.archlinux.org/packages/ttf-humor-sans/\n",
    "with plt.xkcd():\n",
    "    plt.figure(figsize=(14,8))\n",
    "    plt.plot(X, Y1, \"+-r\", label=\"$f_1(x)$\", ms=10, lw=3)\n",
    "    plt.plot(X, Y2, \"o-b\", label=\"$f_2(x)$\", ms=10, lw=3)\n",
    "    plt.plot(X, Y3, \"d-y\", label=\"$f_3(x)$\", ms=10, lw=3)\n",
    "    plt.legend()\n",
    "    plt.xlabel(\"Axe $x$\")\n",
    "    plt.ylabel(\"Axe $y$\")\n",
    "    plt.title(\"Trois fonctions de la variable réelle\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avec `tutormagic` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-20T23:54:53.726568Z",
     "start_time": "2021-02-20T23:54:53.720254Z"
    },
    "code_folding": [
     15
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"100\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%0Aimport%20numpy%20as%20np%0Aimport%20matplotlib.pyplot%20as%20plt%0A%25matplotlib%20inline%0A%0AX%20%3D%20np.linspace%28-10%2C%2010%29%0A%0Adef%20f1%28x%29%3A%20return%20np.cos%28x%2A%2A2%29%0Adef%20f2%28x%29%3A%20return%20np.sin%28x%2A%2A2%29%0Adef%20f3%28x%29%3A%20return%20f1%28x%29%2Bf2%28x%29%20%0AY1%20%3D%20f1%28X%29%0AY2%20%3D%20f2%28X%29%0AY3%20%3D%20f3%28X%29%0A%0Awith%20plt.xkcd%28%29%3A%0A%20%20%20%20plt.figure%28figsize%3D%2814%2C8%29%29%0A%20%20%20%20plt.plot%28X%2C%20Y1%2C%20%22%2B-r%22%2C%20label%3D%22%24f_1%28x%29%24%22%2C%20ms%3D10%2C%20lw%3D3%29%0A%20%20%20%20plt.plot%28X%2C%20Y2%2C%20%22o-b%22%2C%20label%3D%22%24f_2%28x%29%24%22%2C%20ms%3D10%2C%20lw%3D3%29%0A%20%20%20%20plt.plot%28X%2C%20Y3%2C%20%22d-y%22%2C%20label%3D%22%24f_3%28x%29%24%22%2C%20ms%3D10%2C%20lw%3D3%29%0A%20%20%20%20plt.legend%28%29%0A%20%20%20%20plt.xlabel%28%22Axe%20%24x%24%22%29%0A%20%20%20%20plt.ylabel%28%22Axe%20%24y%24%22%29%0A%20%20%20%20plt.title%28%22Trois%20fonctions%20de%20la%20variable%20r%C3%A9elle%22%29%0A%20%20%20%20plt.show%28%29%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&curInstr=0&&verticalStack=false&py=3&rawInputLstJSON=%5B%5D&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f66c50fc4a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3 --height 100\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "X = np.linspace(-10, 10)\n",
    "\n",
    "def f1(x): return np.cos(x**2)\n",
    "def f2(x): return np.sin(x**2)\n",
    "def f3(x): return f1(x)+f2(x) \n",
    "Y1 = f1(X)\n",
    "Y2 = f2(X)\n",
    "Y3 = f3(X)\n",
    "\n",
    "with plt.xkcd():\n",
    "    plt.figure(figsize=(14,8))\n",
    "    plt.plot(X, Y1, \"+-r\", label=\"$f_1(x)$\", ms=10, lw=3)\n",
    "    plt.plot(X, Y2, \"o-b\", label=\"$f_2(x)$\", ms=10, lw=3)\n",
    "    plt.plot(X, Y3, \"d-y\", label=\"$f_3(x)$\", ms=10, lw=3)\n",
    "    plt.legend()\n",
    "    plt.xlabel(\"Axe $x$\")\n",
    "    plt.ylabel(\"Axe $y$\")\n",
    "    plt.title(\"Trois fonctions de la variable réelle\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, le problème vient de la \"cell magic\" `%matplotlib` en ligne 4 !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Et si on essaie sans cette cell magic ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-20T23:55:03.549895Z",
     "start_time": "2021-02-20T23:55:03.543801Z"
    },
    "code_folding": [
     15
    ],
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"500\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%0Aimport%20numpy%20as%20np%0Aimport%20matplotlib.pyplot%20as%20plt%0A%0AX%20%3D%20np.linspace%28-10%2C%2010%29%0A%0Adef%20f1%28x%29%3A%20return%20np.cos%28x%2A%2A2%29%0Adef%20f2%28x%29%3A%20return%20np.sin%28x%2A%2A2%29%0Adef%20f3%28x%29%3A%20return%20f1%28x%29%2Bf2%28x%29%20%0AY1%20%3D%20f1%28X%29%0AY2%20%3D%20f2%28X%29%0AY3%20%3D%20f3%28X%29%0A%0Aprint%28Y1%29%0Aprint%28Y2%29%0Aprint%28Y3%29%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&curInstr=0&&verticalStack=false&py=3&rawInputLstJSON=%5B%5D&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f66c53af828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3 --height 500\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.linspace(-10, 10)\n",
    "\n",
    "def f1(x): return np.cos(x**2)\n",
    "def f2(x): return np.sin(x**2)\n",
    "def f3(x): return f1(x)+f2(x) \n",
    "Y1 = f1(X)\n",
    "Y2 = f2(X)\n",
    "Y3 = f3(X)\n",
    "\n",
    "print(Y1)\n",
    "print(Y2)\n",
    "print(Y3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evidemment, ça ne marche pas ! Numpy et matplotlib ne sont PAS supportés dans PythonTutor.com...\n",
    "\n",
    "Seul les modules suivants sont disponibles avec le mode \"Python3\" basique :\n",
    "\n",
    "    Only these modules can be imported:\n",
    "    __future__, abc, array, bisect, calendar, cmath,\n",
    "    collections, copy, datetime, decimal, doctest, fractions,\n",
    "    functools, hashlib, heapq, io, itertools, json,\n",
    "    locale, math, operator, pickle, pprint, random,\n",
    "    re, string, time, types, typing, unittest\n",
    "\n",
    "> Ca allait être un avantage de nbtutor... au moins la partie numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Bon, et bien on peut essayer \"Python 3.6 with Anaconda (experimental)\".\n",
    "\n",
    "Depuis le site web, j'arrive à utiliser Python 3.6 + Anaconda 5.2 EXPERIMENTAL! pour le code suivant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:57:58.518874Z",
     "start_time": "2021-02-21T01:57:58.487264Z"
    },
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "py33anaconda not supported. Only the following options are allowed: 'python2', 'python3', 'java', 'javascript', 'typescript', 'ruby', 'c', 'c++', 'py3anaconda'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-f2046576b7cf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'tutor'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'--lang py33anaconda --height 500'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'\\nimport numpy as np\\n\\nX = np.linspace(-10, 10)\\n\\ndef f1(x): return np.cos(x**2)\\ndef f2(x): return np.sin(x**2)\\ndef f3(x): return f1(x)+f2(x) \\nY1 = f1(X)\\nY2 = f2(X)\\nY3 = f3(X)\\n\\nprint(Y1)\\nprint(Y2)\\nprint(Y3)\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_cell_magic\u001b[0;34m(self, magic_name, line, cell)\u001b[0m\n\u001b[1;32m   2369\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuiltin_trap\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2370\u001b[0m                 \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mmagic_arg_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcell\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2371\u001b[0;31m                 \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2372\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2373\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<decorator-gen-126>\u001b[0m in \u001b[0;36mtutor\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/magic.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(f, *a, **k)\u001b[0m\n\u001b[1;32m    185\u001b[0m     \u001b[0;31m# but it's overkill for just that one bit of state.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    186\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmagic_deco\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 187\u001b[0;31m         \u001b[0mcall\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    188\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    189\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tutormagic.py\u001b[0m in \u001b[0;36mtutor\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n\u001b[1;32m    150\u001b[0m                     \u001b[0;34m\"{} not supported. Only the following options are allowed: \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    151\u001b[0m                     \u001b[0;34m\"'python2', 'python3', 'java', 'javascript', \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 152\u001b[0;31m                     \"'typescript', 'ruby', 'c', 'c++', 'py3anaconda'\".format(args.lang[0]))\n\u001b[0m\u001b[1;32m    153\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    154\u001b[0m             \u001b[0mlang\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"python3\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: py33anaconda not supported. Only the following options are allowed: 'python2', 'python3', 'java', 'javascript', 'typescript', 'ruby', 'c', 'c++', 'py3anaconda'"
     ]
    }
   ],
   "source": [
    "%%tutor --lang py3anaconda --height 500\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "X = np.linspace(-10, 10)\n",
    "\n",
    "def f1(x): return np.cos(x**2)\n",
    "def f2(x): return np.sin(x**2)\n",
    "def f3(x): return f1(x)+f2(x) \n",
    "Y1 = f1(X)\n",
    "Y2 = f2(X)\n",
    "Y3 = f3(X)\n",
    "\n",
    "print(Y1)\n",
    "print(Y2)\n",
    "print(Y3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ah zut, pour l'instant la magic cell `%%tutor` ne connaît pas d'autres modes pour Python 3.\n",
    "En effet elle date de 2017, mais le nouveau mode de PythonTutor est plus récent !\n",
    "\n",
    "J'ai ouvert [ce ticket](https://github.com/kikocorreoso/tutormagic/issues/10) pour suggérer le support de ce nouveau mode ! Et [cette PR](https://github.com/kikocorreoso/tutormagic/pull/11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T01:58:06.844866Z",
     "start_time": "2021-02-21T01:58:06.839160Z"
    },
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"500\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%23%20https%3A//docs.scipy.org/doc/scipy/reference/tutorial/integrate.html%0A%0Ax%20%3D%204%0Aprint%28%22Hello%20world%21%22%20%2A%20x%29%0A%0Aimport%20numpy%20as%20np%0A%0AI%20%3D%20np.sqrt%282/np.pi%29%2A%2818.0/27%2Anp.sqrt%282%29%2Anp.cos%284.5%29%20-%204.0/27%2Anp.sqrt%282%29%2Anp.sin%284.5%29%29%0A%0Aprint%28I%29%0A%0Aimport%20scipy.integrate%20as%20integrate%0Aimport%20scipy.special%20as%20special%0Aresult%20%3D%20integrate.quad%28lambda%20x%3A%20special.jv%282.5%2Cx%29%2C%200%2C%204.5%29%0Aprint%28result%29%0A%0AI%20%2B%3D%20np.sqrt%282%2Anp.pi%29%20%2A%20special.fresnel%283/np.sqrt%28np.pi%29%29%5B0%5D%0Aprint%28I%29%0A%0Aprint%28abs%28result%5B0%5D-I%29%29%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&curInstr=0&&verticalStack=false&py=py3anaconda&rawInputLstJSON=%5B%5D&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f337c661748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang py3anaconda --height 500\n",
    "# https://docs.scipy.org/doc/scipy/reference/tutorial/integrate.html\n",
    "\n",
    "x = 4\n",
    "print(\"Hello world!\" * x)\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "I = np.sqrt(2/np.pi)*(18.0/27*np.sqrt(2)*np.cos(4.5) - 4.0/27*np.sqrt(2)*np.sin(4.5))\n",
    "\n",
    "print(I)\n",
    "\n",
    "import scipy.integrate as integrate\n",
    "import scipy.special as special\n",
    "result = integrate.quad(lambda x: special.jv(2.5,x), 0, 4.5)\n",
    "print(result)\n",
    "\n",
    "I += np.sqrt(2*np.pi) * special.fresnel(3/np.sqrt(np.pi))[0]\n",
    "print(I)\n",
    "\n",
    "print(abs(result[0]-I))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "POUF ça marche, merci à ma [petite modification (trois lignes changées)](https://github.com/kikocorreoso/tutormagic/pull/11).\n",
    "\n",
    "> C'est quand même beau les logiciels open-source..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Une remarque en passant : avoir PythonTutor offline? semble possible !\n",
    "\n",
    "Au fait, [PythonTutor n'est plus libre](https://github.com/pgbovine/OnlinePythonTutor/), mais [un fork récent existe](https://github.com/seamile/PyTutor) : c'est peut-être un vol de propriété intellectuelle, mais bon, ça peut dépanner !\n",
    "\n",
    "TODO: l'installer chez moi, et faire en sorte que tutormagic fonctionne en local aussi ! Regardez [ce ticket](https://github.com/kikocorreoso/tutormagic/issues/8) assez récent, mais pas avancé (mais très détaillé), et [celui là sur un clone de PythonTutor](https://github.com/seamile/PyTutor/issues/4).\n",
    "\n",
    "=> J'ai réussi à avoir PyTutor (v5-unity) mais juste pour Python3... pas C ou Java... et je sais pas comment faire !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avec `nbtutor` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:50:29.274865Z",
     "start_time": "2021-02-21T00:49:43.023427Z"
    },
    "code_folding": [
     0,
     14
    ],
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "BdbQuit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/debugger.py\u001b[0m in \u001b[0;36mrun_cell\u001b[0;34m(self, cell)\u001b[0m\n\u001b[1;32m     47\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mredirect_stdout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstdout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcell\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mglobals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     49\u001b[0m         \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3.6/bdb.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, cmd, globals, locals)\u001b[0m\n\u001b[1;32m    433\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 434\u001b[0;31m             \u001b[0mexec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcmd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mglobals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    435\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mBdbQuit\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<string>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    352\u001b[0m     \u001b[0m_warn_if_gui_out_of_main_thread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 353\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_backend_mod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    354\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m     42\u001b[0m                 \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m                 \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     44\u001b[0m             )\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m    312\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m             \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    314\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m    179\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m                 \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m             \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<decorator-gen-9>\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    223\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    225\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    340\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    342\u001b[0m             \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m    247\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 248\u001b[0;31m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    249\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m    131\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 132\u001b[0;31m     \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    133\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m   2192\u001b[0m                     \u001b[0;32mwith\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2193\u001b[0;31m                         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   1863\u001b[0m             mimage._draw_list_compositing_images(\n\u001b[0;32m-> 1864\u001b[0;31m                 renderer, self, artists, self.suppressComposite)\n\u001b[0m\u001b[1;32m   1865\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    130\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 131\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    132\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    410\u001b[0m                 **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, inframe)\u001b[0m\n\u001b[1;32m   2746\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2747\u001b[0;31m         \u001b[0mmimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_draw_list_compositing_images\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2748\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    130\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 131\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    132\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1163\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1164\u001b[0;31m         \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1165\u001b[0m         ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_update_ticks\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1022\u001b[0m         \u001b[0mmajor_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1023\u001b[0;31m         \u001b[0mmajor_ticks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_major_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1024\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_locs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_major_ticks\u001b[0;34m(self, numticks)\u001b[0m\n\u001b[1;32m   1381\u001b[0m             \u001b[0;31m# Update the new tick label properties from the old.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1382\u001b[0;31m             \u001b[0mtick\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1383\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajorTicks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtick\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_get_tick\u001b[0;34m(self, major)\u001b[0m\n\u001b[1;32m   2012\u001b[0m             \u001b[0mtick_kw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_minor_tick_kw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2013\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mXTick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmajor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mtick_kw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2014\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    430\u001b[0m             \u001b[0mxdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mydata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 431\u001b[0;31m             \u001b[0mtransform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_xaxis_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwhich\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"grid\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    432\u001b[0m         )\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mset\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m   1087\u001b[0m         \u001b[0;34m\"\"\"A property batch setter.  Pass *kwargs* to set properties.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1088\u001b[0;31m         \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1089\u001b[0m         \u001b[0mmove_color_to_start\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    410\u001b[0m                 **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m    385\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 386\u001b[0;31m         \u001b[0marguments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marguments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    387\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mis_varargs\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0marguments\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3.6/inspect.py\u001b[0m in \u001b[0;36mbind\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   2996\u001b[0m         \"\"\"\n\u001b[0;32m-> 2997\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_bind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2998\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3.6/inspect.py\u001b[0m in \u001b[0;36m_bind\u001b[0;34m(self, args, kwargs, partial)\u001b[0m\n\u001b[1;32m   2934\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2935\u001b[0;31m                     \u001b[0;32mif\u001b[0m \u001b[0mparam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2936\u001b[0m                         raise TypeError(\n",
      "\u001b[0;32m/usr/lib/python3.6/inspect.py\u001b[0m in \u001b[0;36m_bind\u001b[0;34m(self, args, kwargs, partial)\u001b[0m\n\u001b[1;32m   2934\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2935\u001b[0;31m                     \u001b[0;32mif\u001b[0m \u001b[0mparam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2936\u001b[0m                         raise TypeError(\n",
      "\u001b[0;32m/usr/lib/python3.6/bdb.py\u001b[0m in \u001b[0;36mtrace_dispatch\u001b[0;34m(self, frame, event, arg)\u001b[0m\n\u001b[1;32m     50\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mevent\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'line'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispatch_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mevent\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'call'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3.6/bdb.py\u001b[0m in \u001b[0;36mdispatch_line\u001b[0;34m(self, frame)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_here\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbreak_here\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 69\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     70\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquitting\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mBdbQuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/debugger.py\u001b[0m in \u001b[0;36muser_line\u001b[0;34m(self, frame)\u001b[0m\n\u001b[1;32m     62\u001b[0m         \u001b[0;34m\"\"\"This function is called when we stop or break at this line.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_stack_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'step_line'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/debugger.py\u001b[0m in \u001b[0;36mget_stack_data\u001b[0;34m(self, frame, traceback, event_type)\u001b[0m\n\u001b[1;32m    122\u001b[0m             \u001b[0mstack_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlineno\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevent_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muser_locals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 123\u001b[0;31m             \u001b[0mheap_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muser_locals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/history.py\u001b[0m in \u001b[0;36madd\u001b[0;34m(self, filtered_locals)\u001b[0m\n\u001b[1;32m    298\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfiltered_locals\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 299\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_add\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    300\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/history.py\u001b[0m in \u001b[0;36m_add\u001b[0;34m(self, obj, **kwargs)\u001b[0m\n\u001b[1;32m    289\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mtype_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'array'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 290\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_add_array_object\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtype_info\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    291\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mtype_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'class'\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mtype_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mendswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'instance'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/history.py\u001b[0m in \u001b[0;36m_add_array_object\u001b[0;34m(self, obj, type_info, **kwargs)\u001b[0m\n\u001b[1;32m    149\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_arrays\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_add_array_data_object\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtype_info\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    151\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'type'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'{} ({})'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/history.py\u001b[0m in \u001b[0;36m_add_array_data_object\u001b[0;34m(self, obj, type_info, **kwargs)\u001b[0m\n\u001b[1;32m    120\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 121\u001b[0;31m             \u001b[0mdata_values\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    122\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/utils.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(obj, options)\u001b[0m\n\u001b[1;32m    118\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_types\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfmtr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/utils.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m    114\u001b[0m     formatters = {\n\u001b[0;32m--> 115\u001b[0;31m         \u001b[0mfloat_types\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'{:.{}g}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdigits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    116\u001b[0m     }\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: ",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mBdbQuit\u001b[0m                                   Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-72b13d736f51>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'nbtutor'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'--reset --force --debug'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\nX = np.linspace(-10, 10, 40)\\n\\ndef f1(x): return np.cos(x**2)\\ndef f2(x): return np.sin(x**2)\\ndef f3(x): return f1(x)+f2(x) \\nY1 = f1(X)\\nY2 = f2(X)\\nY3 = f3(X)\\n\\nwith plt.xkcd():\\n    plt.figure(figsize=(14,8))\\n    plt.plot(X, Y1, \"+-r\", label=\"$f_1(x)$\", ms=10, lw=3)\\n    #plt.plot(X, Y2, \"o-b\", label=\"$f_2(x)$\", ms=10, lw=3)\\n    #plt.plot(X, Y3, \"d-y\", label=\"$f_3(x)$\", ms=10, lw=3)\\n    plt.legend()\\n    #plt.xlabel(\"Axe $x$\")\\n    #plt.ylabel(\"Axe $y$\")\\n    plt.title(\"Trois fonctions de la variable réelle\")\\n    plt.show()\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_cell_magic\u001b[0;34m(self, magic_name, line, cell)\u001b[0m\n\u001b[1;32m   2369\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuiltin_trap\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2370\u001b[0m                 \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mmagic_arg_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcell\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2371\u001b[0;31m                 \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2372\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2373\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<decorator-gen-126>\u001b[0m in \u001b[0;36mnbtutor\u001b[0;34m(self, line, cell)\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/IPython/core/magic.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(f, *a, **k)\u001b[0m\n\u001b[1;32m    185\u001b[0m     \u001b[0;31m# but it's overkill for just that one bit of state.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    186\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmagic_deco\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 187\u001b[0;31m         \u001b[0mcall\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    188\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    189\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/magic.py\u001b[0m in \u001b[0;36mnbtutor\u001b[0;34m(self, line, cell)\u001b[0m\n\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m         \u001b[0mbdb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBdb\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshell\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m         \u001b[0mbdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcell\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshell\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_cell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcell\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/nbtutor/ipython/debugger.py\u001b[0m in \u001b[0;36mrun_cell\u001b[0;34m(self, cell)\u001b[0m\n\u001b[1;32m     50\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcode_error\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 52\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mBdbQuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     53\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfinalize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mBdbQuit\u001b[0m: "
     ]
    }
   ],
   "source": [
    "%%nbtutor --reset --force --debug\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.linspace(-10, 10, 40)\n",
    "\n",
    "def f1(x): return np.cos(x**2)\n",
    "def f2(x): return np.sin(x**2)\n",
    "def f3(x): return f1(x)+f2(x) \n",
    "Y1 = f1(X)\n",
    "Y2 = f2(X)\n",
    "Y3 = f3(X)\n",
    "\n",
    "with plt.xkcd():\n",
    "    plt.figure(figsize=(14,8))\n",
    "    plt.plot(X, Y1, \"+-r\", label=\"$f_1(x)$\", ms=10, lw=3)\n",
    "    #plt.plot(X, Y2, \"o-b\", label=\"$f_2(x)$\", ms=10, lw=3)\n",
    "    #plt.plot(X, Y3, \"d-y\", label=\"$f_3(x)$\", ms=10, lw=3)\n",
    "    plt.legend()\n",
    "    #plt.xlabel(\"Axe $x$\")\n",
    "    #plt.ylabel(\"Axe $y$\")\n",
    "    plt.title(\"Trois fonctions de la variable réelle\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Je suspectais que ça n'allait pas marcher avec nbtutor ~~puisque ça ne marchait pas avant !!~~ puisque nbtutor a les mêmes limitations que tutormagic !\n",
    "\n",
    "Mais ça marche pour du numpy pur !\n",
    "\n",
    "Et ça marche aussi pour des petits codes utilisant Matplotlib, mais très vite mon CPU prend 100%, ça rame, je ne vais pas chercher davantage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T02:04:03.749968Z",
     "start_time": "2021-02-21T02:04:03.479353Z"
    },
    "code_folding": [],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "nbtutor",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "%%nbtutor --reset --force\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "X = np.linspace(-10, 10, 400)\n",
    "\n",
    "def f1(x): return np.cos(x**2)\n",
    "def f2(x): return np.sin(x**2)\n",
    "def f3(x): return f1(x)+f2(x) \n",
    "Y1 = f1(X)\n",
    "Y2 = f2(X)\n",
    "Y3 = f3(X)\n",
    "Y = [Y1, Y2, Y3]\n",
    "\n",
    "for i, y in enumerate(Y):\n",
    "    for f in [np.min, np.max, np.mean]:\n",
    "        name_f = str(f.__name__)\n",
    "        print(f\"{name_f} of Y{i+1}, result = {f(y)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cet exemple fonctionne !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "---\n",
    "## Et pour exécuter du code C ??\n",
    "\n",
    "Je vais écrire un programme C qui fait un petit truc intéressant, et essayer les choses suivantes :\n",
    "\n",
    "- l'exécuter depuis ce notebook, avec le kernel [jupyter-c-kernel](https://github.com/brendan-rius/jupyter-c-kernel) ;\n",
    "- essayer `tutormagic` ! Je pense que ça devrait fonctionner, car c'est une *iframe* vers [PythonTutor.com, qui supporte le C](http://pythontutor.com/c.html) (version C11 ou C17) avec gcc ;\n",
    "- essayer `nbtutor` ! Si ça marche, c'est que ça utilise le serveur PythonTutor sans le montrer, sinon ça ne devrait pas marcher."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exemple de programme C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T00:57:20.130957Z",
     "start_time": "2021-02-21T00:57:20.082009Z"
    },
    "code_folding": [
     9,
     15
    ],
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "- Pour i = 1 :\n",
      "\ti^1 = 1\n",
      "\ti^2 = 1\n",
      "\ti^3 = 1\n",
      "\ti^4 = 1\n",
      "\ti^5 = 1\n",
      "- Pour i = 2 :\n",
      "\ti^1 = 2\n",
      "\ti^2 = 4\n",
      "\ti^3 = 8\n",
      "\ti^4 = 16\n",
      "\ti^5 = 32\n",
      "- Pour i = 3 :\n",
      "\ti^1 = 3\n",
      "\ti^2 = 9\n",
      "\ti^3 = 27\n",
      "\ti^4 = 81\n",
      "\ti^5 = 243\n",
      "- Pour i = 4 :\n",
      "\ti^1 = 4\n",
      "\ti^2 = 16\n",
      "\ti^3 = 64\n",
      "\ti^4 = 256\n",
      "\ti^5 = 1024\n",
      "- Pour i = 5 :\n",
      "\ti^1 = 5\n",
      "\ti^2 = 25\n",
      "\ti^3 = 125\n",
      "\ti^4 = 625\n",
      "\ti^5 = 3125\n",
      "- Pour i = 6 :\n",
      "\ti^1 = 6\n",
      "\ti^2 = 36\n",
      "\ti^3 = 216\n",
      "\ti^4 = 1296\n",
      "\ti^5 = 7776\n",
      "- Pour i = 7 :\n",
      "\ti^1 = 7\n",
      "\ti^2 = 49\n",
      "\ti^3 = 343\n",
      "\ti^4 = 2401\n",
      "\ti^5 = 16807\n",
      "- Pour i = 8 :\n",
      "\ti^1 = 8\n",
      "\ti^2 = 64\n",
      "\ti^3 = 512\n",
      "\ti^4 = 4096\n",
      "\ti^5 = 32768\n",
      "- Pour i = 9 :\n",
      "\ti^1 = 9\n",
      "\ti^2 = 81\n",
      "\ti^3 = 729\n",
      "\ti^4 = 6561\n",
      "\ti^5 = 59049\n",
      "- Pour i = 10 :\n",
      "\ti^1 = 10\n",
      "\ti^2 = 100\n",
      "\ti^3 = 1000\n",
      "\ti^4 = 10000\n",
      "\ti^5 = 100000"
     ]
    }
   ],
   "source": [
    "/* Cette cellule est écrite en langage C, il ne faut pas l'exécuter avec le kernel Python */\n",
    "/* Installez le kernel https://github.com/brendan-rius/jupyter-c-kernel */\n",
    "\n",
    "#include <stdio.h>\n",
    "#define MIN_I 1\n",
    "#define MAX_I 10\n",
    "#define MIN_POWER 1\n",
    "#define MAX_POWER 5\n",
    "\n",
    "unsigned long power(int n, unsigned long acc, unsigned long x) {\n",
    "    if (n == 0) { return acc; }\n",
    "    if (n % 2 == 0) { return power(n/2, acc, x*x); }\n",
    "    else { return power((n-1)/2, acc * x, x*x); }\n",
    "}\n",
    "\n",
    "int main(void) {\n",
    "    for (int i = MIN_I; i <= MAX_I; i++) {\n",
    "        printf(\"\\n- Pour i = %i :\", i);\n",
    "        for (int n = MIN_POWER; n <= MAX_POWER; ++n) {\n",
    "            printf(\"\\n\\ti^%i = %li\", n, power(n, 1, i));\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avec `tutormagic`\n",
    "\n",
    "Alors évidemment, la \"cell magic\" `%%tutor` ne marche pas depuis le kernel C, mais en repassant au kernel Python 3, on peut faire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T02:00:38.008130Z",
     "start_time": "2021-02-21T02:00:37.993248Z"
    }
   },
   "outputs": [],
   "source": [
    "%reload_ext tutormagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-21T02:00:38.669571Z",
     "start_time": "2021-02-21T02:00:38.662596Z"
    },
    "code_folding": [
     0
    ],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"600\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%0A/%2A%20Cette%20cellule%20est%20%C3%A9crite%20en%20langage%20C%2C%20il%20ne%20faut%20pas%20l%27ex%C3%A9cuter%20avec%20le%20kernel%20Python%20%2A/%0A/%2A%20Installez%20le%20kernel%20https%3A//github.com/brendan-rius/jupyter-c-kernel%20%2A/%0A%0A%23include%20%3Cstdio.h%3E%0A%23define%20MIN_I%201%0A%23define%20MAX_I%2010%0A%23define%20MIN_POWER%201%0A%23define%20MAX_POWER%205%0A%0Aunsigned%20long%20power%28int%20n%2C%20unsigned%20long%20acc%2C%20unsigned%20long%20x%29%20%7B%0A%20%20%20%20if%20%28n%20%3D%3D%200%29%20%7B%20return%20acc%3B%20%7D%0A%20%20%20%20if%20%28n%20%25%202%20%3D%3D%200%29%20%7B%20return%20power%28n/2%2C%20acc%2C%20x%2Ax%29%3B%20%7D%0A%20%20%20%20else%20%7B%20return%20power%28%28n-1%29/2%2C%20acc%20%2A%20x%2C%20x%2Ax%29%3B%20%7D%0A%7D%0A%0Aint%20main%28void%29%20%7B%0A%20%20%20%20for%20%28int%20i%20%3D%20MIN_I%3B%20i%20%3C%3D%20MAX_I%3B%20i%2B%2B%29%20%7B%0A%20%20%20%20%20%20%20%20printf%28%22%5Cn-%20Pour%20i%20%3D%20%25i%20%3A%22%2C%20i%29%3B%0A%20%20%20%20%20%20%20%20for%20%28int%20n%20%3D%20MIN_POWER%3B%20n%20%3C%3D%20MAX_POWER%3B%20%2B%2Bn%29%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20printf%28%22%5Cn%5Cti%5E%25i%20%3D%20%25li%22%2C%20n%2C%20power%28n%2C%201%2C%20i%29%29%3B%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%7D%0A%7D%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&curInstr=0&&verticalStack=false&py=c&rawInputLstJSON=%5B%5D&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f337bb9c208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang c --height 600\n",
    "\n",
    "/* Cette cellule est écrite en langage C, il ne faut pas l'exécuter avec le kernel Python */\n",
    "/* Installez le kernel https://github.com/brendan-rius/jupyter-c-kernel */\n",
    "\n",
    "#include <stdio.h>\n",
    "#define MIN_I 1\n",
    "#define MAX_I 10\n",
    "#define MIN_POWER 1\n",
    "#define MAX_POWER 5\n",
    "\n",
    "unsigned long power(int n, unsigned long acc, unsigned long x) {\n",
    "    if (n == 0) { return acc; }\n",
    "    if (n % 2 == 0) { return power(n/2, acc, x*x); }\n",
    "    else { return power((n-1)/2, acc * x, x*x); }\n",
    "}\n",
    "\n",
    "int main(void) {\n",
    "    for (int i = MIN_I; i <= MAX_I; i++) {\n",
    "        printf(\"\\n- Pour i = %i :\", i);\n",
    "        for (int n = MIN_POWER; n <= MAX_POWER; ++n) {\n",
    "            printf(\"\\n\\ti^%i = %li\", n, power(n, 1, i));\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conclusion ?**\n",
    "\n",
    "tutormagic marche TROP bien pour du C !\n",
    "\n",
    "> Il faudrait ajouter le OCaml... Cf [discussion initiée ici](https://github.com/seamile/PyTutor/issues/6) !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Avec `nbtutor`\n",
    "\n",
    "Il n'y a pas pour l'instant la possibilité d'utiliser nbtutor pour d'autres langages, [mais ce ticket en parle](https://github.com/lgpage/nbtutor/issues/31)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "---\n",
    "## Conclusion\n",
    "\n",
    "Bilan de ces expériences..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Bilan de `tutormagic`\n",
    "- c'est trop cool ;\n",
    "- avec tutormagic, tout marche sans soucis,\n",
    "- ? et c'est des iframe donc l'export en HTML ~~se passe bien~~ [non ça ne marche pas](https://perso.crans.org/besson/notebooks/Comparaison_de_tutormagic_et_nbtutor_pour_visualiser_du_code_Python_et_C_dans_un_notebook_Jupyter.html), comme prévu... c'est des iframe dynamiquement généré à coup de `IPython.display(...)`, donc pas moyen de les garder... et même en \"Save notebook widget state\" ça ne fonctionne pas, je m'en doutais ;\n",
    "- ça supporte tous les langages supportés par <http://PythonTutor.com>, donc Python2, Python3, Java, JavaScript, TypeScript, Ruby, C, C++, et Python3 avec Anaconda pour des modules scientifiques (mais pas de figures Matplotlib, évidement) !\n",
    "- trivial d'ajouter un autre langage, s'il est ajouté dans PythonTutor,\n",
    "- [TODO: ajouter OCaml ?](https://github.com/seamile/PyTutor/issues/6)\n",
    "- devrait pouvoir utiliser une version locale de PythonTutor, cf [ma discussion lancée ici](https://github.com/seamile/PyTutor/issues/4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Bilan de `nbtutor`\n",
    "\n",
    "- c'est aussi très cool !\n",
    "- ça supporte que Python, mais discussion lancée pour ajouter les autres langages... j'ai des doutes que ce soit aussi facile qu'avec `tutormagic` !\n",
    "- avantage de pouvoir voir la mémoire et le temps sépare, mais est-ce un avantage ?\n",
    "- pas de iframe donc pas possible d'utiliser les \"points de débug\" (breakpoint) de PythonTutor qui sont très pratiques !\n",
    "- pas facile d'utiliser une version locale de PythonTutor...\n",
    "- et l'interface demande d'utiliser une \"barre d'outil de cellule\" spécifique, ça me saoule, j'utilise celle de [Jupyter live slides RISE](https://rise.readthedocs.io/en/stable/) par défaut, parce que présenter des notebooks dans des slides, c'est TROP COOL !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Autres questions\n",
    "\n",
    "- Est-ce que ça marche bien depuis un [slide live RISE](https://rise.readthedocs.io/) ? ~~Je pense que oui !~~ Oui !\n",
    "  + avec `tutormagic`, ça marche sans aucun problème ! Pour Python et C !\n",
    "  + avec `nbtutor`, ça marche mais les contrôles ne s'affichent pas... [j'ai ouvert ce ticket](https://github.com/lgpage/nbtutor/issues/42), à voir si le développeur du projet répondra à mes questions !\n",
    "  + maaaaais j'ai trouvé [une solution](https://github.com/lgpage/nbtutor/issues/42) [cet userstyle](https://perso.crans.org/besson/publis/firefox/stylus-show-Jupyter-celltoolbar-when-RISE-live-show-mode-is-enabled.user.css).\n",
    "\n",
    "- Qu'est-ce que ça donnerait une fois le notebook transformé en page web HTML statique ?\n",
    "  + tutormagic avec son iframe devrait marcher, mais pas si la page est vue hors-ligne ;\n",
    "  + nbtutor ne devrait pas marcher !\n",
    "  \n",
    "- Et si je transforme en PDF, ça donne quoi ?\n",
    "  + évidemment l'interactivité sera perdue ;\n",
    "  + mais ce serait 😍 d'avoir une image PNG représentant l'interface... probablement pas le cas, mais on peut bidouiller si besoin (avec une capture d'écran faite à la main ?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Plus de notebooks ?**\n",
    "Merci d'avoir lu ! Allez voir [d'autres notebooks intéressants](https://github.com/Naereen/notebooks) dans ma collection qui grandit depuis 2016.\n",
    "Plein de notebooks en Python niveau L2/L3 mais aussi en OCaml et Python niveau agrégation, et bien plus ! En Java, Rust, Julia, Bash, GNUPlot et GNU Octave et des démonstrations d'extensions peu connues mais super intéressantes !"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Visualize",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "244.45px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}