lafrite/2019-2020
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Feat: algo de seuil

Browse Source
This commit is contained in:
Bertrand Benjamin 2020-05-25 09:07:25 +02:00
parent 81433a50f5
commit bea0350c9c
2 changed files with 88 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
1ST/Programmation/2-Fonctions.html
View File

@ -13470,7 +13470,7 @@ $$</p>
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<ul>
<li>Approcher le maximum de la fonction $g$.</li>
<li>Calculer toutes les valeurs de $g(x)$ pour $x$ allant de -10 à 10.</li>
</ul>
</div>
@ -13492,22 +13492,42 @@ $$</p>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>On peut aussi utiliser une boucle <code>while</code> (tant que).</p>
<p>Ici, on va calculer les images par la fonction $f$ des nombres entre 2 et 4 avec un pas de 0,1.</p>
<h2 id="Algortihme-de-seuil">Algortihme de seuil<a class="anchor-link" href="#Algortihme-de-seuil">&#182;</a></h2><p>Dans cette partie, nous allons voir un algorithme "classique" dit algorithme de seuil. Le but de cet algorithme est de chercher à partir de quelle valeur de $x$ une fonction dépasse une certaine valeur.</p>
<p>Par exemple, on pourrait vouloir savoir à partir de quelle valeur de $x$, $f(x)$ est plus petit que -100 en partant de $x=0$ et avec une précision de 0,1.</p>
<ul>
<li>Faire cette recherche à la main en essayant de détailler votre démarche.</li>
</ul>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>L'algorithme pourrait s'écrire en pseudo-code:</p>
<pre><code>x &lt;- 0
pas &lt;- 0,1
tant que f(x) &gt; -100 faire
x &lt;- x + pas
afficher x
</code></pre>
<p><strong>Tant que</strong> se traduit en python par <code>while</code>. Ainsi l'algorithme précédent s'écrit en Python:</p>
</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[3]:</div>
<div class="prompt input_prompt">In&nbsp;[8]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="mi">2</span>
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">pas</span> <span class="o">=</span> <span class="mf">0.1</span>
<span class="k">while</span> <span class="n">x</span> <span class="o">&lt;=</span> <span class="mi">4</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Quand x vaut&quot;</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="s2">&quot;f(x) vaut &quot;</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mf">0.1</span>
<span class="k">while</span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mi">100</span><span class="p">:</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">pas</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Quand x dépasse&quot;</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="s2">&quot;,f(x) passe en dessous de -100&quot;</span><span class="p">,</span> <span class="p">)</span>
</pre></div>
</div>
@ -13524,26 +13544,7 @@ $$</p>
<div class="output_subarea output_stream output_stdout output_text">
<pre>Quand x vaut 2 f(x) vaut 5
Quand x vaut 2.1 f(x) vaut 5.190000000000001
Quand x vaut 2.2 f(x) vaut 5.359999999999999
Quand x vaut 2.3000000000000003 f(x) vaut 5.51
Quand x vaut 2.4000000000000004 f(x) vaut 5.640000000000001
Quand x vaut 2.5000000000000004 f(x) vaut 5.75
Quand x vaut 2.6000000000000005 f(x) vaut 5.84
Quand x vaut 2.7000000000000006 f(x) vaut 5.91
Quand x vaut 2.8000000000000007 f(x) vaut 5.960000000000001
Quand x vaut 2.900000000000001 f(x) vaut 5.99
Quand x vaut 3.000000000000001 f(x) vaut 6.000000000000002
Quand x vaut 3.100000000000001 f(x) vaut 5.989999999999998
Quand x vaut 3.200000000000001 f(x) vaut 5.959999999999999
Quand x vaut 3.300000000000001 f(x) vaut 5.91
Quand x vaut 3.4000000000000012 f(x) vaut 5.839999999999998
Quand x vaut 3.5000000000000013 f(x) vaut 5.749999999999998
Quand x vaut 3.6000000000000014 f(x) vaut 5.639999999999999
Quand x vaut 3.7000000000000015 f(x) vaut 5.509999999999998
Quand x vaut 3.8000000000000016 f(x) vaut 5.359999999999999
Quand x vaut 3.9000000000000017 f(x) vaut 5.189999999999996
<pre>Quand x dépasse 13.299999999999969 ,f(x) passe en dessous de -100
</pre>
</div>
</div>
@ -13557,34 +13558,30 @@ Quand x vaut 3.9000000000000017 f(x) vaut 5.189999999999996
<div class="text_cell_render border-box-sizing rendered_html">
<p>Les nombreux chiffres après la virgules (qui sont faux!) viennent de la façon de stocker les nombres à virgules dans l'ordinateur. Ils sont présents dans la majorité des programmes et il est difficile de les éviter. C'est une des raison pour laquelle on ne peut pas faire aveuglément confiance à un ordinateur.</p>
<ul>
<li>Écrire toutes les conversions de -100 à 100 degrés farhenheit vers les degrés celcius avec un pas de 10.</li>
<li>Affiner votre recherche de maximum de la fonction $g$ avec un pas de 0,1 puis de 0,01.</li>
<li>Trouver le plus petit $x$ tel que $g(x)$ passe en dessous 100 avec une précision de 0,1.</li>
</ul>
</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[&nbsp;]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="Re&#231;ut/Recal&#233;/mentions-au-bac">Re&#231;ut/Recal&#233;/mentions au bac<a class="anchor-link" href="#Re&#231;ut/Recal&#233;/mentions-au-bac">&#182;</a></h2><p>Au bac, on applique le barème suivant:</p>
<ul>
<li>Note strictement inférieure à 10: recalé</li>
<li>Note supérieure à 10: reçut</li>
</ul>
<p>On peut y voir une fonction qui transforme une <em>note</em> en l'un des deux mots <em>recalé</em> ou <em>reçut</em>.</p>
<ul>
<li>Programmer cette fonction (aller voir du coté des <code>if</code> dans le mémo).</li>
</ul>
<p>Parmi les reçuts, certains peuvent avoir des mentions:</p>
<ul>
<li>$10 \leq note &lt; 12 $: pas de mentions</li>
<li>$12 \leq note &lt; 14 $: Assez Bien</li>
<li>$14 \leq note &lt; 16 $: Bien</li>
<li><p>$16 \leq note $: Très Bien</p>
</li>
<li><p>Programmer cette fonction qui transforme une note en la mention.</p>
</li>
<li>Trouver le plus petit 𝑥 tel que 𝑔(𝑥) passe en dessous 100 avec une précision de 0,01.</li>
</ul>
</div>

93
1ST/Programmation/2-Fonctions.ipynb
View File

@ -306,7 +306,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"* Approcher le maximum de la fonction $g$."
"- Calculer toutes les valeurs de $g(x)$ pour $x$ allant de -10 à 10."
]
},
{
@ -320,49 +320,51 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut aussi utiliser une boucle `while` (tant que).\n",
"## Algortihme de seuil\n",
"\n",
"Ici, on va calculer les images par la fonction $f$ des nombres entre 2 et 4 avec un pas de 0,1."
"Dans cette partie, nous allons voir un algorithme \"classique\" dit algorithme de seuil. Le but de cet algorithme est de chercher à partir de quelle valeur de $x$ une fonction dépasse une certaine valeur.\n",
"\n",
"Par exemple, on pourrait vouloir savoir à partir de quelle valeur de $x$, $f(x)$ est plus petit que -100 en partant de $x=0$ et avec une précision de 0,1.\n",
"\n",
"- Faire cette recherche à la main en essayant de détailler votre démarche."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'algorithme pourrait s'écrire en pseudo-code:\n",
"\n",
" x <- 0\n",
" pas <- 0,1\n",
" tant que f(x) > -100 faire\n",
" x <- x + pas\n",
" afficher x\n",
"\n",
"**Tant que** se traduit en python par `while`. Ainsi l'algorithme précédent s'écrit en Python:\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"execution_count": 8,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Quand x vaut 2 f(x) vaut 5\n",
"Quand x vaut 2.1 f(x) vaut 5.190000000000001\n",
"Quand x vaut 2.2 f(x) vaut 5.359999999999999\n",
"Quand x vaut 2.3000000000000003 f(x) vaut 5.51\n",
"Quand x vaut 2.4000000000000004 f(x) vaut 5.640000000000001\n",
"Quand x vaut 2.5000000000000004 f(x) vaut 5.75\n",
"Quand x vaut 2.6000000000000005 f(x) vaut 5.84\n",
"Quand x vaut 2.7000000000000006 f(x) vaut 5.91\n",
"Quand x vaut 2.8000000000000007 f(x) vaut 5.960000000000001\n",
"Quand x vaut 2.900000000000001 f(x) vaut 5.99\n",
"Quand x vaut 3.000000000000001 f(x) vaut 6.000000000000002\n",
"Quand x vaut 3.100000000000001 f(x) vaut 5.989999999999998\n",
"Quand x vaut 3.200000000000001 f(x) vaut 5.959999999999999\n",
"Quand x vaut 3.300000000000001 f(x) vaut 5.91\n",
"Quand x vaut 3.4000000000000012 f(x) vaut 5.839999999999998\n",
"Quand x vaut 3.5000000000000013 f(x) vaut 5.749999999999998\n",
"Quand x vaut 3.6000000000000014 f(x) vaut 5.639999999999999\n",
"Quand x vaut 3.7000000000000015 f(x) vaut 5.509999999999998\n",
"Quand x vaut 3.8000000000000016 f(x) vaut 5.359999999999999\n",
"Quand x vaut 3.9000000000000017 f(x) vaut 5.189999999999996\n"
"Quand x dépasse 13.299999999999969 ,f(x) passe en dessous de -100\n"
]
}
],
"source": [
"x = 2\n",
"x = 0\n",
"pas = 0.1\n",
"while x <= 4:\n",
" print(\"Quand x vaut\", x, \"f(x) vaut \", f(x))\n",
" x = x + 0.1"
"while f(x) > -100:\n",
" x = x + pas\n",
"print(\"Quand x dépasse\", x, \",f(x) passe en dessous de -100\", )"
]
},
{
@ -371,33 +373,22 @@
"source": [
"Les nombreux chiffres après la virgules (qui sont faux!) viennent de la façon de stocker les nombres à virgules dans l'ordinateur. Ils sont présents dans la majorité des programmes et il est difficile de les éviter. C'est une des raison pour laquelle on ne peut pas faire aveuglément confiance à un ordinateur.\n",
"\n",
"* Écrire toutes les conversions de -100 à 100 degrés farhenheit vers les degrés celcius avec un pas de 10.\n",
"* Affiner votre recherche de maximum de la fonction $g$ avec un pas de 0,1 puis de 0,01."
"\n",
"- Trouver le plus petit $x$ tel que $g(x)$ passe en dessous 100 avec une précision de 0,1.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Reçut/Recalé/mentions au bac\n",
"\n",
"Au bac, on applique le barème suivant:\n",
"\n",
"* Note strictement inférieure à 10: recalé\n",
"* Note supérieure à 10: reçut\n",
"\n",
"On peut y voir une fonction qui transforme une *note* en l'un des deux mots *recalé* ou *reçut*.\n",
"\n",
"* Programmer cette fonction (aller voir du coté des `if` dans le mémo).\n",
"\n",
"Parmi les reçuts, certains peuvent avoir des mentions:\n",
"\n",
"* $10 \\leq note < 12 $: pas de mentions\n",
"* $12 \\leq note < 14 $: Assez Bien\n",
"* $14 \\leq note < 16 $: Bien\n",
"* $16 \\leq note $: Très Bien\n",
"\n",
"* Programmer cette fonction qui transforme une note en la mention."
"- Trouver le plus petit 𝑥 tel que 𝑔(𝑥) passe en dessous 100 avec une précision de 0,01."
]
},
{
@ -424,7 +415,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.2"
"version": "3.8.3"
}
},
"nbformat": 4,