Ch7_TP_Convergence_suites.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.1"
    },
    "colab": {
      "name": "Ch7-TP-Convergence_suites.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/othoni-hub/ECG1/blob/main/Ch7_TP_Convergence_suites.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ia3RUJfT6vF"
      },
      "source": [
        "# **CPGE-ECG1** \n",
        "<img src=\"https://drive.google.com/uc?id=12Wo3LubGGT4qOvYFAuLP4CyCuwjKNVuk\" width=\"230\" height=\"150\" align = \"right\"/>\n",
        "\n",
        "## **Ch7 - Notebook : Convergence d'une suite réelle**\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "**O.Thöni - Lycée Saint-Charles Sainte Croix - LE MANS**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_4S9Y8KYEtZy"
      },
      "source": [
        "from math import sqrt, log, pi, e\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ak1hc9aOEtZ6"
      },
      "source": [
        "## 1. Suites et limites classiques\n",
        "\n",
        "### 1.1. Approximations de e "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ltq2r3naEtaZ"
      },
      "source": [
        "**_1.1.b. Deux suites adjacentes de type u<sub>n</sub> = f(n) : u<sub>n</sub> = (1+1/n)<sup>n</sup>   ,   v<sub>n</sub> = (1+1/n)<sup>n+1</sup>_**\n",
        "\n",
        "\n",
        "\n",
        "Ces deux suites convergent vers e, l'une en croissant, l'autre en décroissant (suites adjacentes).\n",
        "\n",
        "(cours : voir http://www.panamaths.net/Documents/TS/A3page103.pdf)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HkUySQQmEtaa"
      },
      "source": [
        "def f(x):\n",
        "    f = (1+1/x)**x\n",
        "    return f\n",
        "\n",
        "def g(x):\n",
        "    g = (1+1/x)**(x+1)\n",
        "    return g"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U9Py0BsqEtae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b91aebca-1b17-495c-c43b-83f7cc78fab1"
      },
      "source": [
        "print(f(2), '< e <', g(2))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.25 < e < 3.375\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B0DTafomEtah",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "520a1aaa-5b09-482a-8fcd-7e39d2876260"
      },
      "source": [
        "for k in range(1,10):\n",
        "    print('n = ',k,' : ',f(k), '< e <', g(k))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "n =  1  :  2.0 < e < 4.0\n",
            "n =  2  :  2.25 < e < 3.375\n",
            "n =  3  :  2.37037037037037 < e < 3.160493827160493\n",
            "n =  4  :  2.44140625 < e < 3.0517578125\n",
            "n =  5  :  2.4883199999999994 < e < 2.9859839999999993\n",
            "n =  6  :  2.5216263717421135 < e < 2.9418974336991326\n",
            "n =  7  :  2.546499697040712 < e < 2.910285368046528\n",
            "n =  8  :  2.565784513950348 < e < 2.8865075781941414\n",
            "n =  9  :  2.5811747917131984 < e < 2.8679719907924426\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xgy5wtZLEtal"
      },
      "source": [
        "La convergence étant très lente, calculons seulement les termes dont le rang est une puissance de 10..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N534REFzEtam",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16329d70-0c6e-41ee-8ad1-428ebe5aca39"
      },
      "source": [
        "for p in range(0,9):\n",
        "    print('n = 10^',p,' : ',f(10**p), '< e <', g(10**p))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "n = 10^ 0  :  2.0 < e < 4.0\n",
            "n = 10^ 1  :  2.5937424601000023 < e < 2.8531167061100025\n",
            "n = 10^ 2  :  2.7048138294215285 < e < 2.731861967715744\n",
            "n = 10^ 3  :  2.7169239322355936 < e < 2.7196408561678287\n",
            "n = 10^ 4  :  2.7181459268249255 < e < 2.718417741417608\n",
            "n = 10^ 5  :  2.7182682371922975 < e < 2.7182954198746696\n",
            "n = 10^ 6  :  2.7182804690957534 < e < 2.718283187376222\n",
            "n = 10^ 7  :  2.7182816941320818 < e < 2.718281965960251\n",
            "n = 10^ 8  :  2.7182817983473577 < e < 2.7182818255301755\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NoV3u9JFEtaq"
      },
      "source": [
        "**_seuil_**\n",
        "\n",
        "Les deux suites u et v étant adjacentes, on peut utiliser l'écart entre elles pour déterminer une valeur approchée de la limite à une précision donnée"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "03PIrlmfEtar",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "665aecf8-561a-440c-8e5b-e691b37cfa51"
      },
      "source": [
        "#Round = lambda x, n: eval('\"%.' + str(int(n)) + 'f\" % ' + repr(x)) \n",
        "# permet d'afficher les valeurs approchées au bon format, avec des 0 complémentaires si besoin\n",
        "\n",
        "n = 1\n",
        "\n",
        "#nb_decimales = int(input('Entrez la précision cherchée, nombre de chiffres après la virgule : '))\n",
        "nb_decimales = 5\n",
        "\n",
        "u = f(n)\n",
        "v = g(n)\n",
        "while abs(u-v) > 10**(-nb_decimales) :\n",
        "    n = n+1\n",
        "    u = f(n)\n",
        "    v = g(n)\n",
        "print('Pour approcher la limite e des deux suites u et v à 10^-',nb_decimales,' près, il faut calculer ', n, 'termes.')\n",
        "print('On a alors pour valeur approchée par défaut de e : ', round(u,nb_decimales)) # résultat formaté selon la précision cherchée\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Pour approcher la limite e des deux suites u et v à 10^- 5  près, il faut calculer  271828 termes.\n",
            "On a alors pour valeur approchée par défaut de e :  2.71828\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WtB-GfBQEtav"
      },
      "source": [
        "**_Représentation graphique_**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qkHgkxT1Etaw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "36f64a3e-1334-4f2e-b32b-6415551fdc20"
      },
      "source": [
        "x = range(1,11)\n",
        "y1 = []\n",
        "y2 = []\n",
        "\n",
        "for k in x :\n",
        "    y1.append(f(k))\n",
        "    y2.append(g(k))\n",
        "    \n",
        "    \n",
        "#print(y)\n",
        "p1 = plt.plot(x,y1,'r',marker = \"+\",linestyle = 'None')\n",
        "p2 = plt.plot(x,y2,'b',marker = \"+\",linestyle = 'None')\n",
        "plt.plot([0,11],[e,e],'k',linewidth=1,linestyle = ':')\n",
        "\n",
        "plt.xlabel('n')\n",
        "plt.axis([0,11,0,5])\n",
        "plt.show()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eqEHroItEtaz"
      },
      "source": [
        "### 1.2 Approximations de racine de 2 \n",
        "\n",
        "**_1.2.a. par la méthode de Héron_**\n",
        "\n",
        "Basé sur une suite récurrente : $ u_{n+1} = \\dfrac {1}{2} \\left(u_n + \\dfrac {A}{u_n} \\right)$, l'algorithme de Babylone, ou algorithme de Héron, converge vers la racine carrée de A, quel que soit le premier terme choisi positif.\n",
        "\n",
        "Le démontrer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ABE_CBDeSIxr"
      },
      "source": [
        "**Programme Python**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1xsekNm-Eta1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d0ed6ded-909b-4746-dad9-dfc90007bda0"
      },
      "source": [
        "def H(A,x):\n",
        "    H = 1/2*(x+A/x)\n",
        "    return H\n",
        "\n",
        "A = 2\n",
        "u = A\n",
        "for k in range (1,10):\n",
        "    u = H(A,u)\n",
        "    print('u',k,' = ',u,'   précision : 10^',round(log(abs(u - sqrt(A)))/log(10)))\n",
        "    # utilisation de la fonction native round (arrondi), de la fonction native abs (valeur absolue)\n",
        "    # utilisation des fonction présentnes dans la bibliothèque \"math\" : log (logarithme népérien) et sqrt (racine carrée)\n",
        "    \n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "u 1  =  1.5    précision : 10^ -1\n",
            "u 2  =  1.4166666666666665    précision : 10^ -3\n",
            "u 3  =  1.4142156862745097    précision : 10^ -6\n",
            "u 4  =  1.4142135623746899    précision : 10^ -12\n",
            "u 5  =  1.414213562373095    précision : 10^ -16\n",
            "u 6  =  1.414213562373095    précision : 10^ -16\n",
            "u 7  =  1.414213562373095    précision : 10^ -16\n",
            "u 8  =  1.414213562373095    précision : 10^ -16\n",
            "u 9  =  1.414213562373095    précision : 10^ -16\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HtAZlmTNEta4"
      },
      "source": [
        "Les \"limites\" de la machine sont atteintes en très peu d'itérations !!! \n",
        "(La précision des nombres flottants est de l'ordre de $10^{-16}$)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aMXnVDWjEta6"
      },
      "source": [
        "**_1.2.b. Approximation de racine de 2 par un développement en fraction continue : formule de Lagrange (1736-1813)_**\n",
        "\n",
        "![...](https://drive.google.com/uc?id=1DXQX0DcYkEfZhnlYvSpDXaEwgLQf1snB)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bBFL_Kj9Eta7"
      },
      "source": [
        "Cette écriture n'est autre que l'écriture sous forme de fraction continue de la suite de l'algorithme de Héron (avec A = 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fs7mlei6Eta8"
      },
      "source": [
        "### 1.3 Approximations de $\\phi$ ###\n",
        "\n",
        "**_1.3.a. Par une suite récurrente simple (aisément généralisable à toute suite récurrente du type u<sub>n+1</sub> = f(u<sub>n</sub>) )_**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UKzaRLhjEta9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "adf01460-a093-41e2-f5d0-61ff0d37107b"
      },
      "source": [
        "def f(x):\n",
        "    f = sqrt(x+1)\n",
        "    return f\n",
        "\n",
        "u = 5\n",
        "for k in range (1,10):\n",
        "    u = f(u)\n",
        "    print('u',k,' = ',u,'   précision : 10^',round(log(abs(u - (1+sqrt(5))/2))/log(10)))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "u 1  =  2.449489742783178    précision : 10^ 0\n",
            "u 2  =  1.8572802003960462    précision : 10^ -1\n",
            "u 3  =  1.6903491356509892    précision : 10^ -1\n",
            "u 4  =  1.640228379114015    précision : 10^ -2\n",
            "u 5  =  1.624877958221483    précision : 10^ -2\n",
            "u 6  =  1.620147511253677    précision : 10^ -3\n",
            "u 7  =  1.6186869713609475    précision : 10^ -3\n",
            "u 8  =  1.6182357588932916    précision : 10^ -4\n",
            "u 9  =  1.6180963379518822    précision : 10^ -4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "foHztGRfEtbB"
      },
      "source": [
        "**_Construction graphique des termes de la suite_**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KqH4T2_FEtbC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "outputId": "9c4da2fa-b19f-4283-f234-f55d53fb4524"
      },
      "source": [
        "xx = np.arange(-1,6,0.1)\n",
        "yy = []\n",
        "ii = []\n",
        "for ix in xx :\n",
        "    yy.append(sqrt(ix+1))\n",
        "    ii.append(ix)\n",
        "    \n",
        "p1 = plt.plot(xx,yy,'r',linewidth=1)\n",
        "p2 = plt.plot(xx,ii,'b',linewidth=1)\n",
        "\n",
        "u = 5\n",
        "x = range(5)\n",
        "\n",
        "for k in x :\n",
        "    y = sqrt(u+1)\n",
        "    plt.plot(u,y,'r')\n",
        "    plt.plot([u,y],[y,y],'g',linewidth=1,linestyle = ':')\n",
        "    plt.plot([u,u],[u,y],'g',linewidth=1,linestyle = ':')\n",
        "    u = sqrt(u+1)\n",
        "\n",
        "\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('y')\n",
        "#plt.axis([-1.5,6,0,4])\n",
        "\n",
        "ax = plt.gca() # récupération du paramétrage des axes\n",
        "\n",
        "ax.spines['left'].set_position('zero') # positionnement de l'axe des ordonnées à x = 0\n",
        "ax.spines['right'].set_color('none')\n",
        "ax.spines['bottom'].set_position('zero') # positionnement de l'axe des abscisses à y = 0\n",
        "ax.spines['top'].set_color('none')\n",
        "\n",
        "plt.xlim(-1.5,6.5) # dimensionnement de l'axe des abscisse, celui des ordonnées sera dimensionné automatiquement\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ed9Fcu_wEtbG"
      },
      "source": [
        "**_1.3.b. Par une suite récurrente linéaire d'ordre 2_**\n",
        "\n",
        "Dans la suite de **Fibonnacci (1170-1240)**, le rapport de deux termes consécutifs tend vers $\\phi$, c'est l'occasion de programmer une telle suite..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KkYE8iZ9EtbH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "195e9fc8-29c6-4777-c0d2-f685bf11356a"
      },
      "source": [
        "a = 1\n",
        "b = 1\n",
        "\n",
        "print('F 0 = 1')\n",
        "print('F 1 = 1  , r 1 = 1')\n",
        "for k in range (2,10):\n",
        "    r = b/a\n",
        "    F = a + b\n",
        "    print('F',k,'=',F,'  , r',k,'=',r)\n",
        "    a = b\n",
        "    b = F\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "F 0 = 1\n",
            "F 1 = 1  , r 1 = 1\n",
            "F 2 = 2   , r 2 = 1.0\n",
            "F 3 = 3   , r 3 = 2.0\n",
            "F 4 = 5   , r 4 = 1.5\n",
            "F 5 = 8   , r 5 = 1.6666666666666667\n",
            "F 6 = 13   , r 6 = 1.6\n",
            "F 7 = 21   , r 7 = 1.625\n",
            "F 8 = 34   , r 8 = 1.6153846153846154\n",
            "F 9 = 55   , r 9 = 1.619047619047619\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IJLDJog2EtbO"
      },
      "source": [
        "**_seuil_**\n",
        "\n",
        "La suite F <sub>n</sub> étant de sens alterné, oscillant autour de $\\phi$, on peut calculer un seuil pour obtenir une précision cherchée en considérant l'écart entre deux termes consécutifs.\n",
        "\n",
        "\n",
        "**<span style=\"color: #26B260\">Python : boucle *while* pour la recherche de seuil</span>**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AanE17Y-EtbQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "788a5c3f-79a6-48f6-a08e-e0a6dd192860"
      },
      "source": [
        "a = 1\n",
        "b = 1\n",
        "r = b/a\n",
        "old = 2\n",
        "k = 2\n",
        "\n",
        "#nb_decimales = int(input('Entrez la précision cherchée, nombre de chiffres après la virgule : '))\n",
        "nb_decimales = 9\n",
        "\n",
        "while abs(old - r)> 10**(-nb_decimales):\n",
        "    old = r\n",
        "    k = k+1\n",
        "    F = a + b\n",
        "    a = b\n",
        "    b = F\n",
        "    r = b/a\n",
        "    #print(r)\n",
        "    \n",
        "print('À 10^-',nb_decimales,' près, une valeur approchée de Phi est : ',round(r,nb_decimales) , ' obtenue après ',k,' itérations.')\n",
        "# résultat formaté selon la précision cherchée"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "À 10^- 9  près, une valeur approchée de Phi est :  1.618033989  obtenue après  25  itérations.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RFcoYF36EtbZ"
      },
      "source": [
        "**_Représentation graphique_**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lqw5ZdarEtba",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "bc4d05a4-b77d-4f42-86f6-7100a5fecc39"
      },
      "source": [
        "a = 1\n",
        "b = 1\n",
        "r = [1]\n",
        "\n",
        "for k in range (2,11):\n",
        "    r.append(b/a)\n",
        "    F = a + b\n",
        "    a = b\n",
        "    b = F\n",
        "#print(r)\n",
        "\n",
        "x = range(1,11)\n",
        "plt.plot(x,r,'r',marker = \"+\",linestyle = 'None')\n",
        "\n",
        "phi = (1+sqrt(5))/2\n",
        "\n",
        "plt.plot([0,11],[phi,phi],'k',linewidth = 1,linestyle = ':')\n",
        "\n",
        "plt.xlabel('n')\n",
        "plt.ylabel('Fn+1/Fn')\n",
        "plt.axis([0,11,0,2.5])\n",
        "plt.show()\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X3z0Bin0Etbd"
      },
      "source": [
        "**_Variante_**\n",
        "\n",
        "On obtient une valeur approchée de $\\phi$ par son développement en fraction continue (qui n'est autre que la méthode précédente écrite autrement...)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "35jAw_hVEtbe"
      },
      "source": [
        "def fc_phi(n):\n",
        "    x = 1\n",
        "    for k in range(n):\n",
        "        x = 1/x\n",
        "        x = x + 1\n",
        "    return x"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dXp_OqTPEtbh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a2cfe2cf-d247-44ae-f8d2-0e7290385866"
      },
      "source": [
        "for k in range(1,11):\n",
        "    print('Après ',k,' itérations, on a pour valeur approchée de Phi : ', fc_phi(k))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Après  1  itérations, on a pour valeur approchée de Phi :  2.0\n",
            "Après  2  itérations, on a pour valeur approchée de Phi :  1.5\n",
            "Après  3  itérations, on a pour valeur approchée de Phi :  1.6666666666666665\n",
            "Après  4  itérations, on a pour valeur approchée de Phi :  1.6\n",
            "Après  5  itérations, on a pour valeur approchée de Phi :  1.625\n",
            "Après  6  itérations, on a pour valeur approchée de Phi :  1.6153846153846154\n",
            "Après  7  itérations, on a pour valeur approchée de Phi :  1.619047619047619\n",
            "Après  8  itérations, on a pour valeur approchée de Phi :  1.6176470588235294\n",
            "Après  9  itérations, on a pour valeur approchée de Phi :  1.6181818181818182\n",
            "Après  10  itérations, on a pour valeur approchée de Phi :  1.6179775280898876\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_c3kvo8BEtbl"
      },
      "source": [
        "### 1.4 Convergences vers $\\pi$  ###"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-WeMgssvEtcC"
      },
      "source": [
        "**_1.4.a. La formule de Brouncker (1620-1684) : décomposition en fraction continue_**\n",
        "\n",
        "![...](https://drive.google.com/uc?id=1GjiTAn_kbPovmPHo80hbHW1GLijjz4UR)\n",
        "\n",
        "Le problème est qu'il faudrait connaître le dernier terme (celui des points de suspension) pour pouvoir, littéralement, remonter au premier.\n",
        "\n",
        "Heureusement, Brouncker a démontré que, pour n \"assez grand\", u<sub>n</sub> était environ égal à 2n+1, ainsi, en remplaçant, on est en mesure de calculer une valeur approchée de $\\pi$  (voir ici : http://serge.mehl.free.fr/anx/pi_brouncker.html)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "612IlfTwEtcD"
      },
      "source": [
        "def brouncker(nmax):\n",
        "    u = 2*nmax + 1\n",
        "    for n in range(nmax,0,-1):\n",
        "        u = (2*n+1)**2/(2+u)\n",
        "    u = 1 / (2+u)\n",
        "    va_pi = 4/(1+u)\n",
        "    return va_pi\n"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i5bUTpOXEtcG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "edbfba26-2087-4794-b645-e1dd380bb44f"
      },
      "source": [
        "brouncker(10)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.1414067184965018"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ouWLAUYeEtcJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f45a9044-1d14-468d-8ff2-18180a7ed02d"
      },
      "source": [
        "brouncker(100)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.1415924109719806"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yn54Jz_oEtcO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2d7c6d14-7d19-4ac6-9585-142e30ef9a7e"
      },
      "source": [
        "brouncker(1000)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592653340542"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FmwCKYxiEtcT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c918725e-2fab-4095-d2ce-488f1653755c"
      },
      "source": [
        "brouncker(10000)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592653589543"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J2jTBIWKEtcW"
      },
      "source": [
        "**_1.4.b. $\\pi$ à partir de la moyenne arithmético-géométrique de 1 et $\\frac{1}{\\sqrt 2}$_**\n",
        "\n",
        "\n",
        "Cette méthode est très très rapide, car on double le nombre de décimales exactes à chaque itération.\n",
        "\n",
        "Elle permet de programmer deux suites définies par des relations de récurrence entrelacées."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yBpZ7nGfEtcX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73178836-6bd0-4529-fc34-c992ea033c65"
      },
      "source": [
        "x = 1\n",
        "c = 1/4\n",
        "u = 1\n",
        "v = 1 / sqrt(2)\n",
        "n = 5\n",
        "\n",
        "for k in range(1,n+1):\n",
        "    y = u # stockage de l'ancienne valeur de u\n",
        "    u = (u+v)/2 # moyenne arithmétique\n",
        "    v = sqrt(v*y)\n",
        "    c = c - x*(u-y)**2\n",
        "    x = 2*x\n",
        "    p = (u+v)**2/(4*c)\n",
        "    print('Itération n°',k,'valeur approchée de Pi : ',p, '   précision 10^',round(log(abs(p - pi))/log(10)))\n",
        "\n"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Itération n° 1 valeur approchée de Pi :  3.1405792505221686    précision 10^ -3\n",
            "Itération n° 2 valeur approchée de Pi :  3.141592646213543    précision 10^ -8\n",
            "Itération n° 3 valeur approchée de Pi :  3.141592653589794    précision 10^ -15\n",
            "Itération n° 4 valeur approchée de Pi :  3.141592653589794    précision 10^ -15\n",
            "Itération n° 5 valeur approchée de Pi :  3.141592653589794    précision 10^ -15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OQFZ5VVxEtca"
      },
      "source": [
        "**_1.4.c. Et un petit produit dû à Wallis (1616-1703)_**\n",
        "\n",
        "![...](https://drive.google.com/uc?id=1lMHGGLmn6uvZJJJTS2E4zMd8_hAdSvgs)\n",
        "(pas très rapide, mais bon... on a vu pire...)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eka3ZuZ_Etca",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fab516d8-10ef-4929-d1ad-2da4269dda42"
      },
      "source": [
        "P = 1\n",
        "N = 20\n",
        "for n in range(1,N+1):\n",
        "    P = P*(1 + 1/(4*n**2 - 1))\n",
        "    print('Itération n°',n,' : ',2*P)\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Itération n° 1  :  2.6666666666666665\n",
            "Itération n° 2  :  2.844444444444444\n",
            "Itération n° 3  :  2.9257142857142853\n",
            "Itération n° 4  :  2.972154195011337\n",
            "Itération n° 5  :  3.0021759545569062\n",
            "Itération n° 6  :  3.0231701920013605\n",
            "Itération n° 7  :  3.038673628883419\n",
            "Itération n° 8  :  3.0505899960555105\n",
            "Itération n° 9  :  3.06003454712689\n",
            "Itération n° 10  :  3.0677038066434985\n",
            "Itération n° 11  :  3.074055160280442\n",
            "Itération n° 12  :  3.0794013431678864\n",
            "Itération n° 13  :  3.083963419231839\n",
            "Itération n° 14  :  3.087902069831113\n",
            "Itération n° 15  :  3.09133688859622\n",
            "Itération n° 16  :  3.0943587232869296\n",
            "Itération n° 17  :  3.09703782174865\n",
            "Itération n° 18  :  3.0994293567461395\n",
            "Itération n° 19  :  3.101577263438271\n",
            "Itération n° 20  :  3.103516961539233\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1kgLXXULEtcf"
      },
      "source": [
        "def wallis(N):\n",
        "    P = 1\n",
        "    for n in range(1,N+1):\n",
        "        P = P*(1 + 1/(4*n**2 - 1))\n",
        "    return 2*P\n"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4l7mIOX2Etci",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4064497b-2848-4b5d-983f-76f6c1335f4b"
      },
      "source": [
        "wallis(1000)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.140807746030402"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ohYOWRN-Etcp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4946173f-abc7-431e-95a2-594f3fced87f"
      },
      "source": [
        "wallis(1000000)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141591868192149"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cxUpmw6pEtcu"
      },
      "source": [
        "C'est poussif, mais on sent bien qu'on y va..."
      ]
    }
  ]
}