{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![En tête general](img/En_tete_general.png)\n",
    "\n",
    "\n",
    "*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*\n",
    "\n",
    "<span style=\"color: #9317B4\"> Pour exécuter une saisie Python, sélectionner la cellule et valider avec </span><span style=\"color: #B317B4\"><strong>SHIFT+Entrée</strong></span>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La planche de Galton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: #7C39C9\">*Le but de l’activité est de :*</span> \n",
    "\n",
    "<ul style=\"color: #7C39C9\">\n",
    "    <li><em>comprendre le principe de la <a href=\"https://fr.wikipedia.org/wiki/Planche_de_Galton\">planche de Galton</a> ;</em></li>\n",
    "    <li><em>simuler son comportement en programmation Python ;</em></li>\n",
    "    <li><em>effectuer les calculs des probabilités liées à ce dispositif.</em></li>\n",
    "</ul>\n",
    "\n",
    "<span style=\"color: #7C39C9\"><strong> Pour une présentation de la planche de Galton, voir la vidéo suivante.</strong></span>\n",
    "\n",
    "\n",
    "<video controls src=\"video/Galton_1(intro).mp4\" width=\"960\" height=\"540\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: #7C39C9\">*On note $N$ le nombre d'étages de la planche de Galton, et on considère le repère tel que ci-dessous, dans lequel les clous de la planche sont à coordonnées entières. L'abscisse initiale d'une bille vaut 0 puis augmente ou diminue de 1 à chaque étage. On modélisera la trajectoire d'une bille sur cette planche à l'aide de la liste des abscisses successives prises par la bille.*</span>\n",
    "\n",
    "![Planche_de_Galton_Avec_Repere](img/Planche_Galton_Repere.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Etude d'une planche de Galton à 5 étages\n",
    "\n",
    "__Dans cette partie, on suppose que $N=5$. La planche est donc composée de 5 rangées de clous.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.1. Créer une liste <mark>abs_bille</mark> correspondant à une trajectoire possible d'une bille sur la planche, dont la première valeur est 0, et comportant 6 valeurs.__\n",
    "\n",
    "<span style=\"color: #888888\"> Pour exécuter la saisie Python, sélectionner la cellule et valider avec </span><span style=\"color: #888888\"><strong>SHIFT+Entrée</strong>. Faire de même au fur et à mesure de l'activité pour les cellules suivantes</span>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Effectuer la saisie pour créer la liste abs_bille\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.2. La fonction Python <mark>Visualisation_Planche_Galton</mark> donnée dans la cellule ci-dessous permet d'observer des trajectoires de billes à partir des listes de leurs abscisses. Exécuter les deux cellules suivantes pour appeler cette fonction <mark>Visualisation_Planche_Galton</mark> avec <mark>abs_bille</mark> précédemment généré.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exécuter cette cellule pour mettre la fonction Visualisation_Planche_Galton en mémoire\n",
    "\n",
    "from copy import deepcopy\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import animation, rc\n",
    "from IPython.display import HTML\n",
    "\n",
    "def Visualisation_Planche_Galton(Positions_billes, attente=3, Temps_total=5000, hauteur=8, resolution=80):\n",
    "    '''\n",
    "    Fonction permettant la visualisation d'une chute de billes sur la planche de Galton\n",
    "    Liste_billes: chaque élément est la liste des abscisses d'une bille (list)\n",
    "    attente: attente entre chaque bille lachée: écart des ordonnées entre deux billes successives (int) \n",
    "    Temps_total: Durée totale de visionnage en ms (int) \n",
    "    hauteur: Hauteur du graphique en pouces (float)\n",
    "    resolution: résolution en dpi (int)\n",
    "    '''\n",
    "    #Duplication profonde de la liste des listes des abscisses\n",
    "    Liste_billes=deepcopy(Positions_billes)\n",
    "    \n",
    "    N=max([len(b) for b in Liste_billes])-1 #hauteur de la planche (Attention: les listes ont normalement la même taille)\n",
    "    M=len(Liste_billes)//2+1 #hauteur du réceptacle pour les billes\n",
    "            \n",
    "    #Réglages de la fenêtre d'affichage\n",
    "    largeur=2*N*hauteur/(N+M+0.25) ; borne_x=N+1/2\n",
    "    plt.figure(num=0, figsize=(largeur,hauteur), dpi=resolution) ; fig,ax = plt.subplots(num=0)    \n",
    "    ax.set_xlim(( -borne_x,borne_x)) ; ax.set_ylim((-M-0.25, N)) ; ax.xaxis.set_ticks(range(-N,N+1))\n",
    "    plt.tick_params(axis = 'x', labelsize = 8) ; plt.yticks([], [])    \n",
    "    \n",
    "    #taille des billes\n",
    "    taille_bille=242//(N+M+0.25)   \n",
    "    \n",
    "    #représentation de la planche de Galton\n",
    "    list_x=[2*k-(L-1) for L in range(N+1) for k in range(L)]\n",
    "    list_y=[N-L for L in range(N+1) for k in range(L)]\n",
    "    Trace_Galton,= ax.plot(list_x,list_y, ls=\"none\", marker=\".\",color=\"black\")\n",
    "    \n",
    "    #Objet pour la représentation des billes descendantes   \n",
    "    Trace_billes,= ax.plot([], [], ls=\"none\", marker=\"o\",color=\"blue\", markersize=taille_bille)  \n",
    "     \n",
    "    #Objet pour la représentation des billes accumulées dans le réceptacle     \n",
    "    Trace_point_acc, = ax.plot([], [], ls=\"none\", marker=\"o\",color=\"blue\", markersize=taille_bille)\n",
    "    \n",
    "    #Liste des effectifs de billes accumulées         \n",
    "    accumulation=[0 for x in range(-N,N+1)]\n",
    "    \n",
    "    #Initialisation des positions des billes\n",
    "    b_x=[None for p in range(len(Liste_billes))] # liste des abscisses des billes à placer           \n",
    "    b_y=[None for p in range(len(Liste_billes))] # liste des ordonnées des billes à placer\n",
    "    \n",
    "    def init():\n",
    "        \"\"\"\n",
    "        Fonction initialisant l'animation\n",
    "        \"\"\"\n",
    "        return (Trace_Galton,Trace_billes,Trace_point_acc,)   \n",
    "    \n",
    "    def animate(i):     \n",
    "        \"\"\"\n",
    "        Fonction définissant la i ème scène de l'animation\n",
    "        \"\"\"\n",
    "        #gestion des billes en descente\n",
    "        for p in range(len(Liste_billes)): #pour chaque bille\n",
    "            if Liste_billes[p] and i>=attente*p:#s'il reste des positions à traiter et qu'on a lâché la bille\n",
    "                if len(Liste_billes[p])>1: #si ce n'est pas la dernière position\n",
    "                    b_x[p],b_y[p] = Liste_billes[p].pop(0),N-i+attente*p #on place la bille à sa position et on efface cette position\n",
    "                elif -M+0.5*(accumulation[N+int(Liste_billes[p][0])]-1)<N-i+attente*p: #sinon si on n'a pas atteint la hauteur accumulée\n",
    "                    b_x[p],b_y[p] = Liste_billes[p][0],N-i+attente*p #on place la bille à sa nouvelle position (descente verticale)\n",
    "                else: #sinon\n",
    "                    accumulation[N+int(Liste_billes[p].pop(0))]+=1 #on compte la bille comme accumulée \n",
    "                    b_x[p],b_y[p] = None,None #et on supprime la position                  \n",
    "        \n",
    "        #Représentation des billes en descente\n",
    "        Trace_billes.set_data(b_x,b_y)  \n",
    "        \n",
    "        #Représentation des billes accumulées dans les réceptacles       \n",
    "        l_x,l_y = [k for k in range(-N,N+1) for y in range(accumulation[N+k])],[-M+0.5*y for k in range(-N,N+1) for y in range(accumulation[N+k])]\n",
    "        Trace_point_acc.set_data(l_x,l_y)    \n",
    "                \n",
    "        return (Trace_Galton,Trace_billes,Trace_point_acc,)\n",
    "      \n",
    "    #Création de l'animation\n",
    "    Nb_images=attente*len(Liste_billes)+N+M\n",
    "    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=Nb_images, interval=Temps_total/Nb_images, blit=False, repeat=False)   \n",
    "    \n",
    "    return HTML(anim.to_jshtml())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exécuter cette cellule pour observer la trajectoire de la bille correspondante à abs_bille\n",
    "\n",
    "Visualisation_Planche_Galton( [abs_bille] )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.3.a. Si lors de sa descente sur la planche l'abscisse de la bille vaut $x$, quelles sont les valeurs possibles pour son abscisse à l'étape suivante ? Quelles sont les probabilités d'obtenir chacune de ces valeurs ?__\n",
    "\n",
    "\n",
    "__1.3.b. Ecrire une fonction Python <mark>suiv</mark>, qui reçoit <mark>x</mark> en argument, et qui renvoie l'abscisse suivante de la bille.__\n",
    "\n",
    "Aide: L'import <mark>from random import random</mark> permet d'utiliser la fonction <mark>random()</mark> qui renvoie une valeur aléatoire de l'intervalle $[0;1[$. La syntaxe <mark>random()<1/2</mark> est donc un test permettant de générer équiprobablement <mark>True</mark> ou <mark>False</mark>.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ecrire ici la fonction suiv d'argument x\n",
    "from random import random\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.4.a. On considère la fonction Python <mark>trajet</mark>ci-dessous. Quelle est son utilité ? Compléter sa description.__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trajet():\n",
    "    '''\n",
    "    Compléter ici\n",
    "    la description\n",
    "    de la fonction\n",
    "    '''\n",
    "    x=0\n",
    "    L=[x]\n",
    "    for k in range(5):\n",
    "        x=suiv(x)\n",
    "        L.append(x)\n",
    "    return L "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.4.b. A l'aide de cette fonction, créer une liste <mark>abs_bille</mark>, puis valider les cellules suivantes pour observer la trajectoire de la bille.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Créer ici une liste abs_bille à l'aide de la fonction trajet précédente\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Valider cette cellule pour voir la liste abs_bille qui a été générée\n",
    "abs_bille\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exécuter cette cellule pour observer le trajet de la bille\n",
    "\n",
    "Visualisation_Planche_Galton( [abs_bille] )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.5.a. On construit ci-dessous une liste en compréhension nommée <mark>liste_trajets</mark> permettant de modéliser 50 trajets de billes différentes sur la planche. Valider les cellules pour afficher les listes d'abscisses et observer ces trajets sur la planche de Galton (Patienter pendant les calculs...).__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Valider la cellule\n",
    "\n",
    "#Création d'une liste de trajets de 50 billes\n",
    "liste_trajets = [ trajet() for b in range(50) ]\n",
    "\n",
    "#Affichage des trajets\n",
    "liste_trajets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Création de l'animation sur la planche de Galton\n",
    "Visualisation_Planche_Galton( liste_trajets )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.5.b. Décrire le résultat. Y a-t-il certaines sorties de la planche de Galton qui semblent moins fréquentes que d'autres ?__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.5.c. Visionner la vidéo ci-dessous. Votre conjecture de la question 1.5.b. semble-t-elle se vérifier?__\n",
    "\n",
    "<video controls src=\"video/Galton_2(chute).mp4\" width=\"960\" height=\"540\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__1.6. On considère l'expérience qui consiste à faire descendre une bille sur la planche de Galton à 5 étages. On note X la variable aléatoire qui correspond au nombre de fois où la bille a tourné à droite.__\n",
    "\n",
    "<ul>\n",
    "    <li type='None'><strong>a. Calculer la probabilité que X soit égal à 5.</strong></li>\n",
    "    <li type='None'><strong>b. Justifier que X suit une loi binomiale et préciser ses paramètres.</strong></li>\n",
    "    <li type='None'><strong>c. Dresser le tableau de la loi de probabilité de X.</strong></li>\n",
    "    <li type='None'><strong>d. Si X=2, quelle est l'abscisse finale de la bille ?</strong></li>\n",
    "    <li type='None'><strong>e. On note Y la variable aléatoire qui correspond à l'abscisse finale de la bille. Dresser le tableau de la loi de probabilité de Y. Comparer les résultats avec les observations des questions 1.5.b. et 1.5.c.</strong></li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Généralisation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.1. On reprend la fonction <mark>trajet</mark> (vue dans la question 1.4.a.). Ajouter un argument <mark>N</mark> pour que la fonction permette de générer une liste correspondant à un trajet d'une bille sur une planche de Galton à <mark>N</mark> étages.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ajouter l'argument N à la fonction trajet\n",
    "\n",
    "def trajet():\n",
    "    '''\n",
    "    (reprendre et adapter la description vue à la question 1.4.a.)\n",
    "    '''\n",
    "    x=0\n",
    "    L=[x]\n",
    "    for k in range(5):\n",
    "        x=suiv(x)\n",
    "        L.append(x)\n",
    "    return L "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.2.a. Dans la cellule ci-dessous, créer une liste <mark>liste_trajets</mark> permettant de modéliser 100 trajets de billes sur une planche de Galton à 10 étages.__\n",
    "\n",
    "Aide: On pourra s'inspirer de la syntaxe utilisée dans la question 1.5.a."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Créer liste_trajets correspondant à 100 trajets de billes sur une planche de Galton à 10 étages\n",
    "liste_trajets = [ trajet(10) for b in range(100) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.2.b. Valider les cellules pour afficher les listes d'abscisses et observer ces trajets sur la planche de Galton (Patienter pendant les calculs...).__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Valider cette cellule pour afficher les listes de trajets\n",
    "liste_trajets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Création de l'animation sur la planche de Galton\n",
    "Visualisation_Planche_Galton( liste_trajets )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.3.a. Exécuter les cellules ci-dessous. Dans chaque cas, indiquer ce que permet d'obtenir la syntaxe proposée.__\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "liste_trajets[0] #permet d'obtenir la liste des abscisses de la bille de rang 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_trajets[0][-1] #permet d'obtenir l'abscisse finale de la bille de rang 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "liste_trajets[1] #permet d'obtenir la liste des abscisses de la bille de rang 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_trajets[1][-1] #permet d'obtenir l'abscisse finale de la bille de rang 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.3.b. Ecrire une fonction <mark>decompte</mark> qui compte, dans une liste <mark>liste_trajets</mark>, le nombre de billes qui ont pour abscisse finale 4.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ecrire la fonction decompte\n",
    "\n",
    "def decompte(liste_trajets):\n",
    "    compteur=0\n",
    "    for k in range(len(liste_trajets)):\n",
    "        if liste_trajets[k][-1]==4:\n",
    "            compteur=compteur+1\n",
    "    return compteur\n",
    "\n",
    "#test avec la liste précédemment générée\n",
    "decompte(liste_trajets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.3.c. Modifier la fonction <mark>decompte</mark> pour qu'elle compte le nombre de billes qui ont pour abscisse finale <mark>a</mark> où <mark>a</mark> est donné en argument de la fonction.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ecrire la fonction decompte modifiée\n",
    "\n",
    "def decompte(liste_trajets,a):\n",
    "    compteur=0\n",
    "    for k in range(len(liste_trajets)):\n",
    "        if liste_trajets[k][-1]==a:\n",
    "            compteur=compteur+1\n",
    "    return compteur\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.3.d. Ecrire une fonction <mark>frequence</mark> qui reçoit un entier <mark>a</mark> en argument et renvoie la fréquence de billes qui ont pour abscisse finale <mark>a</mark>.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ecrire la fonction frequence\n",
    "\n",
    "def frequence(liste_trajets,a):\n",
    "    return decompte(liste_trajets,a)/len(liste_trajets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.3.e A l'aide de cette fonction <mark>frequence</mark>, déterminer la fréquence de billes dont l'abscisse finale vaut 4 pour les trajets stockés dans <mark>liste_trajets</mark>.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Effectuer l'appel à la fonction frequence\n",
    "f=frequence(liste_trajets,4)\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.4.a. Calculer la probabilité qu'une bille ait pour abscisse finale 4 sur la planche de Galton à 10 étages. Calculer l'écart entre cette valeur et la valeur obtenue à la question 2.3.e.__\n",
    "\n",
    "On pourra utiliser la fonction <mark>combinaison</mark> ci-dessous, qui permet de calculer le coefficient binomial <font size=\"1\"> $\\displaystyle \\left( \\begin{array}{} n \\\\ k \\end{array} \\right)$ </font>.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import factorial\n",
    "\n",
    "def combinaison(n,k): \n",
    "    \"fonction qui calcule le coefficient binomial de paramètres n et k\"\n",
    "    return factorial(n)//(factorial(k)*factorial(n-k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Effectuer une saisie pour le calcul de la probabiltié\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.4.b. Calculer l'écart entre les valeurs obtenues aux questions 2.3.e. et 2.4.a.__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Effectuer une saisie pour la comparaison des deux valeurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Galton](img/Sir_Francis_Galton.jpg)\n",
    "\n",
    "<center><a href=\"https://fr.wikipedia.org/wiki/Francis_Galton\">Sir Francis Galton (1822-1911)</a></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}