simulation_des.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "female-welding",
   "metadata": {},
   "source": [
    "<a id=\"debut\"></a><h1 align=\"center\" style=\"font-size:40px\"> AN : les dés </h1> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alternative-kingdom",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>CONSIGNES GENERALES</b>\n",
    "    <ul>\n",
    "        <li> Lire les consignes dans les cellules bleues. </li>\n",
    "        <li> Les aides (cellules vertes) et les solutions (cellules jaunes) ne sont à utiliser qu'après avoir vraiment essayé de compléter le code. </li>\n",
    "        <li> Pour tracer des graphiques, on trouvera des notices au format pdf <a href=\"https://nuage-creteil.beta.education.fr/s/ztNzcAs8Q8em9k5\">ici</a> et des tutos vidéos <a href=\"https://colibris.link/PC_peerTube\">là</a>. </li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "patient-verification",
   "metadata": {},
   "source": [
    "<p><b>Sommaire : </b></p> \n",
    " \n",
    "<a href=\"#partie1\"> Partie 1 : le temps de demi-vie</a><br>\n",
    "<a href=\"#partie2\"> Partie 2 : la constante de radioactivité</a><br>\n",
    "<a href=\"#partie3\"> Partie 3 : une équation bien conn</a><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "persistent-seller",
   "metadata": {},
   "source": [
    "## Partie 1 : le temps de demi-vie <a id=partie1></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "quick-roller",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> Exécuter la cellule ci-dessous Pour importer les modules nécessaires à cette activité.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dirty-wilderness",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint  #fonction renvoyant aléatoirement en entier\n",
    "from scipy.optimize import curve_fit # Modélisation des fonction non linéaire (ici, exponentielle)\n",
    "from scipy.stats import linregress # Regression linéaire\n",
    "import numpy as np # bibliothèque contenant, entre autre, la fonction exponentielle (la fonction exp du module maths ne fonctionne pas avec curve_fit)\n",
    "import matplotlib.pyplot as plt # Tracer de graphique"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moral-county",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p>\n",
    "         Utiliser la documentation de la fonction <a href=\"https://docs.python.org/fr/3/library/random.html#functions-for-integershttps://docs.python.org/fr/3/library/random.html#functions-for-integers\">randint</a> pour compléter la ligne 7 \n",
    "    </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "european-identifier",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def lancer_des(nb_des_i, nb_faces):\n",
    "    '''Fonction prenant en argument le nombre  de dés initial et le nombre de faces.\n",
    "    On effectue un tirage et chaque dés donnant 1 est supprimé\n",
    "    La fonction renvoie le nombre de dés restant '''\n",
    "    nb_des_rest = nb_des_i\n",
    "    for i in range(nb_des_i):\n",
    "        resultat_lance = randint(..., ...) # tirage aléatoire d'un nombre : dépend du nombre de face du dés\n",
    "        if resultat_lance == 1 :\n",
    "            nb_des_rest = nb_des_rest-1\n",
    "    return nb_des_rest\n",
    "\n",
    "def model(x, a, b):\n",
    "    return a * np.exp(b * x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "amended-python",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <details>\n",
    "        <summary> <b> Aides </b> </summary>\n",
    "        <ul>\n",
    "            <li> Chercher  la fonction randint dans la page (elle n'est pas très loin du haut) </li>\n",
    "            <li> On veut pouvoir modifier la valeur du nombre de face lors de l'appelle de cette fonction </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hawaiian-salmon",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <code>resultat_lance = randint(1,nb_faces) </code>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beautiful-elite",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <ul>\n",
    "        <li> Compléter la ligne 11 pour que le bloc d'instruction s'effectur jusqu'à ce qu'il n'y ai plus de dés</li>\n",
    "        <li> Compléter la ligne 14 pour que la valeur du compteur augmente de 1  </li>\n",
    "        <li> Compléter la ligne 17 pour tracer le graphique représentant le nombre de dés en fonction du nombre de tirage. </li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "female-psychology",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def simul (nb_des_i, nb_faces):\n",
    "    '''Fonction prenant en argument le nombre de dés initiale et leur nombre de \n",
    "    face. elle fait appelle à la fonction lance_des et affiche le graphique \n",
    "    représentant la variation du nombre de dés au cours des lancés.'''\n",
    "    # initialisation des variables\n",
    "    LANCES = [0] # liste comptant les lancés\n",
    "    N = [nb_des_i] # liste contenant les nombre de dés après chaque lancé\n",
    "    N_t = nb_des_i\n",
    "    compteur = 0\n",
    "    # lancé des dés jusqu'à ce qu'il n'en reste plus\n",
    "    while ... :\n",
    "        N_t = lancer_des(N_t, nb_faces)\n",
    "        N.append(N_t)\n",
    "        compteur = ... # On incrémente le compteur\n",
    "        LANCES.append(compteur)\n",
    "    #tracé de la courbe \n",
    "    ...\n",
    "    #quelques éléments graphiques\n",
    "    plt.grid()\n",
    "    plt.xlim(0)\n",
    "    plt.ylim(0)\n",
    "    plt.xlabel(\"Nombre de tirage\")\n",
    "    plt.ylabel(\"Nombre de dés restant\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "elegant-commerce",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <details>\n",
    "        <summary> <b> Aides </b> </summary>\n",
    "        <ul>\n",
    "            <li> <b>ligne 11 :</b> quand il n'y a plus de dés, il en reste 0 </li>\n",
    "            <li> <b>ligne 14 :</b> on affecte à la variable compteur une valeur correspondant à sa valeur + 1 </li>\n",
    "            <li><b>ligne 17 :</b> voir  <a href=\"https://nuage-creteil.beta.education.fr/s/ztNzcAs8Q8em9k5\">la notice</a> </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "respected-youth",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    " <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <ul>\n",
    "            <li> <b> Ligne 11 </b> : <code>while N_t > 0:</code> </li>\n",
    "            <li> <b> Ligne 14 </b> : <code>compteur = compteur + 1</code> </li>\n",
    "            <li> <b> Ligne 17 </b> : <code>plt.plot(LANCES, N, 'bo')</code> </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "subjective-board",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> On peut maintenant faire des simulations en appelant la fonction et en choisissant les valeur du nombre de dés et du nombre de faces.</p>\n",
    "    <p>Faire un essaie avec la cellule suivante et ajouter autant de cellule que necessaire pour effectuer de nouvelles simulations.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "light-justice",
   "metadata": {},
   "outputs": [],
   "source": [
    "simul(1000, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "involved-windows",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Partie 2 : la constante radioactive <a id=partie2></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "excited-repeat",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px\"><a href=\"#debut\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "juvenile-notion",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> On chercher maintenant à modéliser la courbe obtenue par une fonction exponentielle: pour cela, on écrit une fonction qui reprends la précédente, mais en ajoutant \n",
    "    <ul>\n",
    "        <li> Compléter la ligne 18 pour tracer la courbe de modélisation </li>\n",
    "    </ul>\n",
    "<img src=\"https://labolycee.org/sites/default/files/rubon3_0.png\" style=\" display: block; margin-left: auto; margin-right: auto; width:1.8cm \">\n",
    "    <p><b>Remarque :</b> la modélisation d'une fonction exponentielle est plus compliqué qu'une régression linéaire : elle fait appel à la fonction curve_fit dont le fonctionnement n'est pas détaillé cette année. </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "noble-cameroon",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def simul_model (nb_des_i, nb_faces):\n",
    "    # initialisation des variables\n",
    "    LANCES = [0] # liste comptant les lancés\n",
    "    N = [nb_des_i] # liste contenant les nombre de dés après chaque lancé\n",
    "    N_t = nb_des_i\n",
    "    compteur = 0\n",
    "    # lancé des dés jusqu'à ce qu'il n'en reste plus\n",
    "    while N_t> 0:\n",
    "        N_t = lancer_des(N_t, nb_faces)\n",
    "        N.append(N_t)\n",
    "        compteur = compteur + 1\n",
    "        LANCES.append(compteur)\n",
    "    #tracé de la courbe \n",
    "    plt.plot(LANCES, N, 'bo', label='Simulation')\n",
    "    \n",
    "#---------------------- Nouvelle patie -----------------------------------------#\n",
    "    # Modélisation\n",
    "    params, covar = curve_fit(model, LANCES, N, p0=[nb_des_i, -1])\n",
    "    N_mod = []\n",
    "    for val in LANCES:\n",
    "        N_mod.append(model(val, *params))\n",
    "    plt.plot(..., ..., 'r:', label='Modélisation: y = {:.2e} . exp({:.2e} x)'.format(*params))\n",
    "    #quelques éléments graphiques\n",
    "    plt.grid()\n",
    "    plt.xlim(0)\n",
    "    plt.ylim(0)\n",
    "    plt.xlabel(\"Nombre de tirage\")\n",
    "    plt.ylabel(\"Nombre de dés restant\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fundamental-doctrine",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <details>\n",
    "        <summary> <b> Aides </b> </summary>\n",
    "        <p> On pourra s'aider de <a href=\"https://colibris.link/tuto_RegLin\"> cette vidéo (1'45)</a> <p>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dangerous-strap",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    " <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <p>\n",
    "            <b> Ligne 18 </b> : <code>plt.plot(LANCES, N_mod, 'r:', label=...</code> \n",
    "        </p>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "endless-jenny",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "<p> Dans la cellule ci-dessous, utiliser la fonction simul_model pour tracer et modéliser l'évolution du nombre de dés en fonction du nombre de lancés.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "appointed-canada",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "crazy-emphasis",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    " <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <p><code>simul_model(100000, 6)</code> \n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "supreme-rwanda",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px\"><a href=\"#debut\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "weird-apache",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Partie 3 : où l'on retrouve une équation bien connue <a id=partie3></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "substantial-leonard",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<img src=\"https://labolycee.org/sites/default/files/rubon3_0.png\" style=\" display: block; margin-left: auto; margin-right: auto; width:1.8cm \">\n",
    "    <p><b>Remarque :</b> Dans cette partie on réalise le calcul d'une dérivée et une régression linéaire plus classique. N'hésitez pas à consulter la <a href=\"https://colibris.link/noticeGraph\">notice</a>  ou le <a href=\"https://colibris.link/tuto_regLin\">tuto vidéo</a> sur le sujet.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fantastic-syndication",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> Exécuter la cellule suivante qui contient les même instructions que la fonction simul de la <a href=\"#partie1\"> partie 1 </a></p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "informative-malaysia",
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_des_i=100000\n",
    "nb_faces = 6\n",
    "# initialisation des variables\n",
    "LANCES = [0] # liste comptant les lancés\n",
    "N = [nb_des_i] # liste contenant les nombre de dés après chaque lancé\n",
    "N_t = nb_des_i\n",
    "compteur = 0\n",
    "# lancé des dés jusqu'à ce qu'il n'en reste plus\n",
    "while N_t> 0:\n",
    "    N_t = lancer_des(N_t, nb_faces)\n",
    "    N.append(N_t)\n",
    "    compteur = compteur + 1\n",
    "    LANCES.append(compteur)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "super-imperial",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> Compléter et exécuter la cellule suivante pour calculer les valeurs de la dérivé de N en fonction du nombre de lancés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "authentic-magnet",
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_pts = len(N)\n",
    "dN = []\n",
    "for i in range(1, nb_pts - 1):\n",
    "    dN.append((... - ...) / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "agricultural-demographic",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    " <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <ul>\n",
    "            <li> <b> Ligne 4 </b> : <code>dN.append((N[i+1] - N[i-1]) / 2)</code> </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "powerful-knight",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> Exécuter la cellule suivante <b> une seule fois</b></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "breathing-paraguay",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "N = N[1:-1] # On ne prends pas les premières et dernière valeurs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "arabic-fabric",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> Compléter et exécuter la cellule suivante pour tracer le graphique représentant dN en fonction de N </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "immune-spotlight",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "unauthorized-maine",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    " <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <ul>\n",
    "            <li> <b> Ligne 2 </b> : <code>plt.plot(N, dN, 'bo')</code> </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "elementary-decision",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Consignes </b>\n",
    "    <p> Compléter et exécuter la cellule suivante pour réaliser la régression linéaire  </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "gorgeous-graphics",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(N, dN, 'bo', label = 'Simulation')\n",
    "# régression linéaire\n",
    "nb_pts=len(N)\n",
    "params = ...\n",
    "a = params[0]\n",
    "dN_mod = []\n",
    "for i in range(nb_pts):\n",
    "    ...\n",
    "plt.plot(N, dN_mod, 'r-', label=f'Modélisation : dN = {a:.2e} x N')\n",
    "#quelques éléments graphiques\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "demonstrated-violin",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    " <details>\n",
    "        <summary> <b> Solution </b> </summary>\n",
    "        <ul>\n",
    "            <li> <b> Ligne 4 </b> : <code>params = linregress(N, dN)</code> </li>\n",
    "            <li> <b> Ligne 8 </b> : <code>dN_mod.append(a * N[i])</code> </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numeric-darwin",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px\"><a href=\"#debut\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}