calculsci.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calcul scientifique en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous nous intéressons à l'utilisation de Python dans le cadre du calcul scientifique, en particulier pour construire des représentations graphiques : suites, fonctions, calcul différentiel et intégral. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une remarque technique : ce document est un **notebook jupyter** qui mélange des cellules de texte au format **markdown** et des cellules de code `Python`. Les cellules markdown peuvent contenir du html mais ausiis du $\\LaTeX$. Le $\\LaTeX$ est un langage pour écrire des Mathématiques, il est entre des dollars.\n",
    "Il est utile de savoir qu'on peut **ajouter des cases vides** en allant dans le menu insérer, et qu'on valide une cellule en tapant Shift+Entrée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Suites"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les algorithmes classiques concernant les suites sont\n",
    "* le calcul d'un terme à l'aide d'une relation de récurrence,\n",
    "* le calcul d'une somme de termes,\n",
    "* le calcul du premier terme dépassant un seuil donné"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def terme(n,u0,f):\n",
    "    u=u0\n",
    "    for k in range(n):\n",
    "        u=f(u)\n",
    "    return u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction applique `n` fois la fonction de récurrence `f` en partant du terme initial $u_0$ afin de calculer le terme $u_n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x/2+5\n",
    "\n",
    "print(terme(10,0,f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons modifier légèrement la fonction `terme` afin qu'elle renvoie la liste de tous les termes calculés, et utiliser la bibliothèque `matplotlib` pour construire un graphique $(n;u_n)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def termes(n,u0,f):\n",
    "    u=u0\n",
    "    l=[u]\n",
    "    for k in range(n):\n",
    "        u=f(u)\n",
    "        l.append(u)\n",
    "    return l\n",
    "\n",
    "print(termes(10,0,f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(termes(10,0,f))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par défaut la fonction `plot` relie les point : le style par défaut est `'b-'` ce qui signifie `blue` et relié. Remarquons que les abscisses sont correctes : lorsqu'on ne les précise pas, elles valent 0,1,2 ... ce qui nous convient bien ici.\n",
    "\n",
    "Essayons le style `'ro'`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(termes(10,0,f),'ro')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex0** Quelques styles à essayer : `'g^'`,`'ys'`,`'r--'`,`'b*'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Séries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une série est une suite obtenue en ajoutant les termes d'une autres suite, comme par exemple lorsqu'on calcule des effectifs cumulés croissants ou des probabilités cumulées croissantes.\n",
    "A partir d'une suite $(u_n)$ on peut définir la série $(s_n)$ par $\\displaystyle s_n=u_0+u_1+u_2+\\dots+u_n = \\sum_{k=0}^n u_k$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def somme(n,u0,f):\n",
    "    u=u0\n",
    "    s=u\n",
    "    for k in range(n):\n",
    "        u=f(u)\n",
    "        s=s+u\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le calcul d'une somme est un exemple d'algorithme d'_accumulation_, dans lequel on ajoute les termes d'une suite dans une variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(somme(10,0,f))\n",
    "liste=termes(10,0,f)\n",
    "print('Vérification :')\n",
    "print(liste)\n",
    "print('La somme est : ',sum(liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex1** Construire un graphique $(n;s_n)$ pour la série $(s_n)$ associée à la suite $1,\\dfrac12,\\dfrac14,\\dfrac18\\dots$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seuil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'algorithme classique de bac ou de BTS ; il s'agit de déterminer à partir de quel rang les termes d'une suite dépassent un certain seuil.\n",
    "\n",
    "Si on reprend la suite du début du TP, définie par $u_0=0$ et $u_{n+1} = \\dfrac12 u_n +5$, on constate que les termes se rapprochent de $10$. \n",
    "\n",
    "A partir de quel rang va-t-on dépasser $9,9999$ ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seuil(A):\n",
    "    u=0\n",
    "    n=0\n",
    "    while u<A:\n",
    "        u=u/2+5\n",
    "        n=n+1\n",
    "    return(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(seuil(9.9999)) #attention en Python le séparateur décimal est le point et non la virgule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parfois on \"déroule\" un algorithme dans un tableau, pour illustrer les étapes du calcul.\n",
    "Voici une modification de la fonction, avec un paramètre optionnel `verbeux` qui est faux par défaut.\n",
    "Le mode verbeux affiche de quoi remplir un tableau comme celui ci-dessous.\n",
    "\n",
    "$$\\begin{array}{|c|c|c|}\\hline n&u&u<A\\\\ \\hline 0& 0 &True\\\\ \\hline 1 & 5 & True \\\\ \\hline 2 & 7,5 & True \\\\ \\end{array}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seuil(A,verbeux=False):\n",
    "    u=0\n",
    "    n=0\n",
    "    while u<A:\n",
    "        if verbeux:\n",
    "            print(f\"u({n})={u}<{A} on continue la mission\")\n",
    "        u=u/2+5\n",
    "        n=n+1\n",
    "        if verbeux:\n",
    "            print(f\"maintenant on a u({n})={u}\")\n",
    "    return(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(seuil(9.9999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(seuil(9.9999,True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex2** A partir de quel rang $n$ la suite $(z_n)$ définie par $z_0=0,1$ et $z_{n+1}=z_n+z_n (1-z_n)$ va-t-elle dépasser le seuil $0,99999$ ?\n",
    "\n",
    "Représenter cette suite par un nuage de points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un peu de hasard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La bibliothèque `random` permet de faire intervenir le hasard dans le déroulement de nos algorithmes. Evidemment il devient difficile d'obtenir les mêmes résultats que son voisin, sauf si..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lançons un dé\n",
    "import random\n",
    "d=random.randint(1,6)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lançons trente dés (ou bien trente fois le même)\n",
    "liste=[]  #une liste vide\n",
    "for k in range(30):\n",
    "    liste.append(random.randint(1,6))\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `random.random` renvoit un réel compris dans l'intervalle $[0;1[$ (le sens des crochets est important). Cette fonction va nous permettre de simuler une marche aléatoire.\n",
    "\n",
    "Une particule est initialement positionnée en $x=0$. A chaque unité de temps, la particule se déplace de façon équiprobable vers la gauche ($x$ diminue de 1) ou vers la droite ($x$ augmente de 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=0\n",
    "l=[x]\n",
    "for k in range(2000):\n",
    "    if random.random()<0.5:\n",
    "        x=x+1\n",
    "    else:\n",
    "        x=x-1\n",
    "    l.append(x)\n",
    "plt.plot(l)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex3** Valider plusieurs fois la cellule qui contient le code,en notant à chaque fois la distance maximale dont la particule s'est éloignée de l'origine. \n",
    "Réessayer avec $n=1000$ étapes, avec $n=10000$ étapes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sur le même thème, nous allons représenter plusieurs trajectoires sur un même graphique, puis nous intéresser à la position d'arrivée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(20):\n",
    "    x=0\n",
    "    l=[x]\n",
    "    for i in range(200):\n",
    "        if random.random()<0.5:\n",
    "            x=x+1\n",
    "        else:\n",
    "            x=x-1\n",
    "        l.append(x)\n",
    "    plt.plot(l)\n",
    "\n",
    "\n",
    "#on décore le graphique avant de l'afficher\n",
    "plt.title('20 marches aléatoires de longueur $n=200$')\n",
    "plt.xlabel('le temps')\n",
    "plt.ylabel(\"distance à l'origine\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex4** Modifier le code pour avoir 100 simulations de longueur $n=1000$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def marche(n=100,N=1):\n",
    "    l=[]\n",
    "    for k in range(N):\n",
    "        x=0\n",
    "        for i in range(n):\n",
    "            if random.random()<0.5:\n",
    "                x=x+1\n",
    "            else:\n",
    "                x=x-1\n",
    "        l.append(x)\n",
    "    return(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "marche()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "marche(100,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=marche(100,10000)\n",
    "plt.boxplot(l,vert=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m,M=min(l),max(l)\n",
    "print(m,M)\n",
    "\n",
    "def compte(l):\n",
    "    m,M=min(l),max(l)\n",
    "    nb=[0]*(M-m+1)\n",
    "    for k in l:\n",
    "        nb[-m+k]+=1\n",
    "    return nb\n",
    "\n",
    "plt.bar(range(m,M+1),compte(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex5** Calculer la moyenne $\\displaystyle\\bar x= \\dfrac1n \\sum_{i=1}^n x_i$ et la variance $\\displaystyle \\sigma^{2} =\\dfrac{1}{n} \\sum_{i=1}^n x_i^2 - {\\bar x}^2$ pour une série de $N=10000$ marches de longueur $n=1000$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bilan de quelques constructions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le langage Python\n",
    "* les blocs d'instructions sont reconnus grâce à l'indentation (le décalage du premier caractère par rapport au début de ligne)\n",
    "* l'affectation se fait avec `=`, on peut effectuer plusieurs affectations simultanément\n",
    "* on définit une fonction avec `def(`paramètres`):`\n",
    "* le `:` commence un bloc\n",
    "* l'alternative est `if`condition`:` bloc 1 `else:` bloc 2 (le `else` est optionnel et on peut tester plusieurs conditions avec `elif`)\n",
    "* la boucle définie est `for` variable `in` liste `:` (liste est une liste ou bien n'importe quel type itérable)\n",
    "* en particulier `range(n)` désigne les entiers $0, 1 , 2  \\dots, n-2, n-1$ ce qui fait exactement $n$ entiers\n",
    "* la boucle indéfinie est `while` condition `:` bloc ; attention si la condition reste toujours vraie alors le porgramme ne s'arrête pas\n",
    "* une liste est constituée d'éléments séparés par des virgules, entourés par des `[]`\n",
    "* `l.append(x)` permet d'ajouter un élément contenu dans la variable `x` à la fin de la liste `l`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La bibliothèque `matplotlib`\n",
    "On peut utiliser les fonctions de la bibliothèque `matplotlib` (ou plutôt de `matplotlib.pyplot`) en entrant\n",
    "\n",
    "`import matplotlib.pyplot as plt`\n",
    "\n",
    "puis en préfixant les fonctions avec `plt.`\n",
    "\n",
    "* `show()` affiche le graphique\n",
    "* `plot(y)` ou `plot(x,y)` trace des points à partir de leurs coordonnées (en prenant 0,1,2 etc en abscisse si on donne seulement les ordonnées\n",
    "* `title`,`xlabel`,`ylabel` et `legend` permettent de décorer un peu le graphique ; les chaînes de caractères peuvent inclure du $\\LaTeX$ entre des dollars.\n",
    "* `savefig('nomfichier.png')` permet de sauvegarder un graphique dans un fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a déjà vu que lorsqu'on utilise `plot`, par défaut les points sont reliés. On va alors approcher des courbes de fonctions par des lignes brisées, représentant des fonctions affines par morceaux. Commençons par $f(x)=1-x^2$ définie sur $[-1;1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return 1-x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#avec cinq points\n",
    "a,b=-1,1\n",
    "n=5\n",
    "h=(b-a)/(n-1)\n",
    "x,y=[],[]\n",
    "for k in range(n):\n",
    "    x.append(a+k*h)\n",
    "    y.append(f(a+k*h))\n",
    "plt.title(f\"$f(x)=1-x^2)$ avec {n} points\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Longueur d'un arc de parabole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex6** Quelle est la longueur de la ligne brisée constituée de ces quatre segments ?\n",
    "\n",
    "Bien sûr, quatre segments c'est peu. Vérifier qu'avec $n=100$ segments on trouve une longueur $l \\approx 2,957826$ et n'oubliez pas de refaire le graphique !\n",
    "\n",
    "Voici une occasion idéale pour écrire un algorithme d'accumulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour ceux qui se poseraient la question, la valeur exacte de cette longueur est $\\dfrac 12 \\ln \\left(2+ \\sqrt 5 \\right) + \\sqrt 5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt,log\n",
    "print(0.5*log(2+sqrt(5))+sqrt(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.957885715089194867655812038867828870143394861190016503762424498670766727050137561032428552062867487\n"
     ]
    }
   ],
   "source": [
    "from mpmath import mp #bibliothèque multi-precision math\n",
    "mp.dps=100\n",
    "print(0.5*mp.log(2+mp.sqrt(5))+mp.sqrt(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La bibliothèque mpmath \n",
    "\n",
    "La bibliothèque `mpmath` permet de travailler avec un nombre de décimales quelconque.\n",
    "* `mp.dps=1000` fixe le nombre de décimales (Decimal PlaceS in English) à 1000\n",
    "* `a=mp.mpf(12)` crée un MultiPrecisionFloat qui vaut `12` mais en plus précis\n",
    "* `mp.cos`, `mp.exp`, `mp.log` , `mp.sqrt` sont les fonction mathématiques usuelles mais en multi précision\n",
    "* les opérateurs `+`, `-`, `*`, `/`, `**` sont redéfinis pour travailler en multi précision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068\n"
     ]
    }
   ],
   "source": [
    "print(mp.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex7** Quelle est la 314e décimale de $\\pi$ ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dichotomie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode de la dichotomie permet d'obtenir un encadrement et une valeur approchée d'une solution d'une équation de la forme $f(x)=0$ sous certaines conditions.\n",
    "On supposera que la fonction $f$ est continue sur l'intervalle $[a;b]$ (on peut tracer la courbe sans lever le crayon) et que $f(a) f(b) <0$ (la fonction change de signe)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4.654296875, 4.6552734375)\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    y=x**3-12*x-45\n",
    "    return y\n",
    "    \n",
    "def dicho(a,b,f,eps):\n",
    "    while b-a>eps:\n",
    "        c=(a+b)/2\n",
    "        if f(a)*f(c)<0:\n",
    "            b=c\n",
    "        else:\n",
    "            a=c\n",
    "    return a,b\n",
    "\n",
    "print(dicho(-7,9,f,0.001))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'exemple ci-dessus on cherche à résoudre l'équation $x^3=12 x+45$ dans l'intervalle $[-7;9]$. On remarquera que la précision $0,001$ ne permet pas d'avoir une valeur approchée de la solution au millième.\n",
    "\n",
    "On peut admirer un déroulé pas-à-pas de la méthode <a href='goo.gl/UnaScx'>ici</a>. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex7** Représenter les deux fonctions $x \\mapsto 12 x+45$ et $x \\mapsto x^3$ sur l'intervalle $[-7;9]$. Quel pas choisir pour représenter chacune des deux fonctions ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un balayage décimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On propose ici une autre méthode, de balayage décimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.654049999999998\n"
     ]
    }
   ],
   "source": [
    "def balayage(x,f,eps):\n",
    "    h=1\n",
    "    while h>eps:\n",
    "        while f(x)*f(x+h)>0:\n",
    "            x=x+h\n",
    "        h=h/10\n",
    "    return x+h/2\n",
    "\n",
    "print(balayage(-7,f,0.0001))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex8** Copier le code dans PythonTutor, puis expliquer l'algorithme en Français."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La méthode de descente de la tangente de Newton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Newton](Newton.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'idée est de partir d'une première estimation de la solution, qu'on appelera $x_0$, puis de se laisser glisser le long de la tangente à la courbe de $f$ en $(x_0;f(x_0))$ jusqu'au point $(x_{1};0)$ de l'axe des abscisses. Puis on recommence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff(f,x,h=0.0001):\n",
    "    return (f(x+h)-f(x-h))/(2*h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour estimer numériquement le coefficient directeur de la tangente, c'est-à-dire la vitesse instantanée d'évolution de la fonction, la fonction `diff` utilise une méthode de physicien : on prend un point de la courbe un tout petit peu à gauche de $(x;f(x))$ et un autre un tout petit peu à droite, et on calcule le coefficient directeur de la droite passant par ces deux points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex9** En partant de $x_0=5$ et en utilisant la méthode de Newton avec la fonction $f(x)=x^3-12x-45$, au bout de combien de termes la suite $(x_n)$ stabilise-t-elle les cent premières décimales ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.xkcd(scale=1, length=100, randomness=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `xkcd` permet de faire des graphiques qui ressemblent à des graphiques faits à la main, à la manière de l'excellent **Randall Munroe** dont on peut trouver la production sur son site <a href='http://xkcd.com'>xkcd</a>.\n",
    "\n",
    "On peut revenir en arrière dans ce notebook et revalider toutes les entrées créant des graphiques."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quelques liens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* la bibliothèque mpmath <a href='http://mpmath.org/doc/current/basics.html'> site officiel</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}