Feat: Algorithmes de seuils

TST/07_Logarithme_et_equation_puissance/4E_algo_seuil.ipynb

@@ -0,0 +1,261 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Algorithme de seuil\n",
+    "\n",
+    "Le but de ce TP est de programmer les algorithmes qui permettent de calculer des **seuil**.\n",
+    "\n",
+    "Vous n'ètes pas autorisé à utiliser votre calculatrice. Il faudra faire les calculs avec Python et forcez vous dès que c'est possible d'utiliser des variables.\n",
+    "\n",
+    "Liens vers les autres TPs de programmation faits:\n",
+    "\n",
+    "- [Initiation avec les suites](https://opytex.org/enseignements/2020-2021/TST/02_Modelisation_suite/3E_python.html)\n",
+    "- [Simulation de variable aléatoire](https://opytex.org/enseignements/2020-2021/TST/03_Variables_aleatoires/3E_esperance_simulation.html)\n",
+    "- [Utilisation des boucles](https://opytex.org/enseignements/2020-2021/TST/04_Formalisation_des_suites/5E_boucles.html) (Je ne suis pas sûr si on avait pris le temps de faire cette séance).\n",
+    "\n",
+    "On rappelle que pour faire une puissance en python, l'opérateur est `**`. \n",
+    "Par exemple:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "16"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "2**4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Population de renards\n",
+    "\n",
+    "Cet exercice reprend l'exercice 9 \"population de renard\" de la fiche d'exercice.\n",
+    "\n",
+    "Dans un parc régional, on étudie une espèce de renards. Cette population était de 1240 renards à la fin de l'année 2016. Les études ont montré que cette population diminue de 15\\% par an. Pour compenser cette diminution, le parc décide d'introduire chaque année 30 renards.\n",
+    "\n",
+    "On modélise alors la population de renard par la suite $(u_n)$ définie par la relation de récurrence suivante $u_{n+1} = 0.85u_n +30$.\n",
+    "\n",
+    "\n",
+    "1. Calculer $u_1$, $u_2$ et $u_{10}$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# u1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# u2\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# u10\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2. Déterminer la plus grand valeur de $n$ pour laquelle $u_n$ est inférieur à 300."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour éviter de tatonner, on peut écrire une programme qui fait des calculs **jusqu'à** ce que $u_n$ soit inférieur à 300. On utilise pour cela une boucle **while**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "15\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialisation\n",
+    "u = 1240\n",
+    "n = 0\n",
+    "# Boucle\n",
+    "while u > 300:\n",
+    "    n = n + 1\n",
+    "    u = 0.85*u + 30\n",
+    "# Valeur de n quand la boucle s'arrête\n",
+    "print(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Adapter le programme précédent pour déterminer la plus grande valeur de $n$ pour que $u_n$ soit inférieur à 201"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Valeur du logarithme\n",
+    "\n",
+    "On a vu dans le cours que $\\log(a)$ était la solution de l'équation $10^x=a$.\n",
+    "\n",
+    "Dans cet exercice, nous allons chercher à donner une valeur approchée de logarithmes.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Valeur approchée de $\\log(700)$\n",
+    "\n",
+    "La valeur de $\\log(700)$ est la valeur qui quant mis dans une puissance de 10 donne 700 en résultat.\n",
+    "\n",
+    "Nous allons faire tatonner l'ordinateur pour qu'il trouve sa valeur.\n",
+    "\n",
+    "1. Écrire une boucle while qui commence à calculer $10^0$, $10^1$... et qui s'arrète quand 700 est dépassé."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La valeur trouvée à la question précédente est le chiffre des unités de $\\log(700)$.\n",
+    "\n",
+    "2. Écrire une boucle while qui commence à calculer $10^0$, $10^{0.1}$, $10^{0.2}$ et qui s'arrète quand 700 est dépassé."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Que signifie la valeur trouvée?\n",
+    "\n",
+    "3. Donner une valeur approchée avec une précision de 4 chiffres après la virgule pour calculer $\\log(700)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Valeur d'autres logarithmes\n",
+    "\n",
+    "Écrire des programmes qui calculs des valeurs de logarithmes"
+   ]
+  },
+  {
+   "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": []
+  }
+ ],
+ "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

TST/07_Logarithme_et_equation_puissance/index.rst

@@ -2,7 +2,7 @@ Logarithme et équation puissance
 ################################
 
 :date: 2020-12-17
-:modified: 2021-01-09
+:modified: 2021-01-17
 :authors: Benjamin Bertrand
 :tags: Logarithme, Fonctions
 :category: TST
@@ -54,5 +54,11 @@ Exercices techniques de manipulations du logarithme pour en particulier résoudr
     :height: 200px
     :alt: Manipulations techniques du logarithme
 
-Étape 4: Résolution d'inéquations et problèmes
+Étape 4: Algorithmes de seuils
-==============================================
+==============================
+
+
+`Programmation des algorithmes de seuils (notebook) <./4E_algo_seuil.ipynb>`_
+
+`Programmation des algorithmes de seuils (html) <./4E_algo_seuil.html>`_
+