{
"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",
" Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"# Approximation par balayage (corrigé) \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On considère la fonction $f$ définie sur $[0;+\\infty[$ par $f(x)=x^2$.\n",
"\n",
"![Fonction carré](img/Approximation_par_balayage_carre.png)\n",
"\n",
"On admet que la fonction $f$ est croissante sur $[0;+\\infty[$ et que l’équation $f(x)=2$ \n",
"a une unique solution sur $[0;+\\infty[$, notée $\\sqrt{2}$. \n",
"Le but de l’exercice est d’obtenir des valeurs approchées de $\\sqrt{2}$.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__1. Ecrire une fonction Python $f$ qui reçoit une valeur $x$ en argument et renvoie l’image de $x$ par la fonction $f$.__\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"# Ecrire la fonction\n",
"def f(x):\n",
" return x**2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__2.\tLa fonction ci-dessous permet d’obtenir des images successives par la fonction $f$ sur l’intervalle $[1;2]$, avec un pas de $10^{-1}=0,1$.__\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"def balayage(f):\n",
" \n",
" x=1\n",
" while x<2:\n",
" print(\"f(\",x,\")=\",f(x))\n",
" x = x+0.1\n",
" \n",
" return None"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__Utiliser cette fonction pour compléter le tableau :__\n",
"\n",
"| $x$ | $1 $ | $1.1$ |$1.2$ |$1.3$ |$1.4$ |$1.5$ |$1.6$ |$1.7$ |$1.8$ |$1.9$ |$2 $ |\n",
"| :-------: |:--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |\n",
"| $f$$($$x$$)$ | | | | | | | | | | | |\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"f( 1 )= 1\n",
"f( 1.1 )= 1.2100000000000002\n",
"f( 1.2000000000000002 )= 1.4400000000000004\n",
"f( 1.3000000000000003 )= 1.6900000000000006\n",
"f( 1.4000000000000004 )= 1.960000000000001\n",
"f( 1.5000000000000004 )= 2.2500000000000013\n",
"f( 1.6000000000000005 )= 2.560000000000002\n",
"f( 1.7000000000000006 )= 2.890000000000002\n",
"f( 1.8000000000000007 )= 3.2400000000000024\n",
"f( 1.9000000000000008 )= 3.610000000000003\n"
]
}
],
"source": [
"# Effectuer les saisies nécessaires\n",
"balayage(f)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__Pour quelle valeur $x_1$ du tableau a-t-on $x_1 \\leqslant \\sqrt{2} \\leqslant x_1+0,1$ ? Justifier.__\n",
"\n",
"__Modifier la fonction précédente pour qu’elle renvoie cette valeur $x_1$.__\n",
"\n",
"\n",
"\n",
"\n",
"Aides : On pourra, entre autres, modifier la condition de la boucle while.\n",
"On pourra supprimer les affichages réalisés avec l’instruction print. \n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.4000000000000004"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Fonction modifiée:\n",
"\n",
"def balayage(f):\n",
" \n",
" x=1\n",
" while f(x)<2:\n",
" x = x+0.1\n",
" \n",
" return x-0.1\n",
"\n",
"# Appel à la fonction modifiée:\n",
"balayage(f)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__3. Compléter la fonction pour qu’elle effectue, à partir de cette valeur $x_1$, un nouveau balayage de pas $10^{-2}=0,01$.__\n",
"\n",
"__La fonction renverra une valeur $x_2$ telle que $x_2 \\leqslant \\sqrt{2} \\leqslant x_2+0,01$.__"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.4100000000000004"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Fonction modifiée:\n",
"\n",
"def balayage(f):\n",
" \n",
" x=1\n",
" while f(x)<2:\n",
" x = x+0.1\n",
" \n",
" x=x-0.1\n",
" while f(x)<2:\n",
" x = x+0.01\n",
" \n",
" return x-0.01\n",
" \n",
"# Appel à la fonction modifiée:\n",
"balayage(f)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__4. Compléter la fonction pour qu’elle renvoie une valeur $x_3$ telle que $x_3 \\leqslant \\sqrt{2} \\leqslant x_3+0,001$.__"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.414"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Fonction modifiée:\n",
"\n",
"def balayage(f):\n",
" \n",
" x=1\n",
" while f(x)<2:\n",
" x = x+0.1\n",
" \n",
" x=x-0.1\n",
" while f(x)<2:\n",
" x = x+0.01\n",
"\n",
" x=x-0.01\n",
" while f(x)<2:\n",
" x = x+0.001\n",
" \n",
" return x-0.001\n",
" \n",
"# Appel à la fonction modifiée:\n",
"balayage(f)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__5. \tEn ajoutant une boucle, modifier la fonction précédente pour qu’elle renvoie une valeur $x_n$ telle que $x_n \\leqslant \\sqrt{2} \\leqslant x_n+10^{-n}$, où $n$ est une valeur donnée en argument de la fonction.__"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"# Fonction modifiée:\n",
"\n",
"def balayage(f,n):\n",
" \n",
" x=1\n",
" for k in range(n+1):\n",
" while f(x)<2:\n",
" x = x+10**-k\n",
" x=x-10**-k\n",
" \n",
" return x\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__Donner une valeur approchée de $\\sqrt{2}$ à $10^{-7}$ près.__"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.4142135"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Appel à la fonction modifiée:\n",
"balayage(f,7)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"__6. Prolongement :__\n",
"\n",
"__On admet que l’équation $x^3=5$ admet une unique solution sur $[0;+\\infty[$, notée $\\sqrt[3]{5}$.__\n",
"\n",
"__Déterminer une valeur approchée de $\\sqrt[3]{5}$ à $10^{-8}$ près.__\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.7099759399999999"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# on peut proposer une amélioration de la fonction balayage:\n",
"\n",
"def balayage(f,val,n):\n",
" \n",
" x=1\n",
" for k in range(n+1):\n",
" while f(x) Jérôme Cardan (1501-1576) fut un des premiers à justifier la méthode d'approximation par balayage."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*"
]
}
],
"metadata": {
"celltoolbar": "Raw Cell Format",
"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.10"
}
},
"nbformat": 4,
"nbformat_minor": 2
}