{ "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.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Dérivation (corrigé) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*But de l’activité : Ecrire des fonctions Python permettant le calcul de taux de variation, de nombres dérivés, du coefficient directeur et de l’ordonnée à l’origine d’une tangente à une courbe.*\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On considère la fonction __$f$__ définie sur $\\mathbb{R}$ par $f(x)=\\frac{1}{4} x^3+x-3$.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__1. Ecrire une fonction Python f qui :__\n", "* __reçoit en argument une valeur $x$ ;__\n", "* __renvoie son image par la fonction $f$.__\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "def f(x):\n", " return 1/4*x**3+x-3" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "33.25" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__2. Ecrire une fonction Python coeff_dir qui :__\n", "* __reçoit en arguments les coordonnées de deux points $A(x_A;y_A )$ et $B(x_B;y_B )$ (avec $x_A≠x_B$) ;__\n", "* __renvoie le coefficient directeur de la droite $(AB)$.__\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def coeff_dir(xA,yA,xB,yB):\n", " return (yB-yA)/(xB-xA)\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-7.0" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "coeff_dir(2,5,3,-2)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__3. A l’aide de la fonction précédente, écrire une fonction Python taux_variation qui :__\n", "* __reçoit en arguments une fonction $f$ et deux valeurs $a$ et $h$ ;__\n", "* __renvoie le taux de variation de la fonction $f$ entre $a$ et $a+h$.__\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def taux_variation(f,a,h):\n", " return coeff_dir(a,f(a),a+h,f(a+h))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__4. A l’aide de cette fonction, calculer le taux de variation de $f$ entre $3$ et $3,000001$. Conjecturer la valeur du nombre dérivé $f'(3)$, puis effectuer un calcul pour vérifier.__\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7.7500022495338925" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "taux_variation(f,3,0.000001)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__5. L’import « from scipy import misc » permet d’utiliser la fonction misc.derivative qui :__\n", "* __reçoit en arguments une fonction $f$ et une valeur $a$;__\n", "* __renvoie le nombre dérivé de $f$ en $a$.__\n", "\n", "__Tester cette fonction pour calculer $f'(3)$.__\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7.749999753059455" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from scipy import misc\n", "ec=10**-9\n", "\n", "misc.derivative(f,3,ec)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__6. Ecrire une fonction Python coeff_tang qui :__\n", "* __reçoit en arguments une fonction $f$ et une valeur $a$ ;__\n", "* __renvoie le coefficient directeur et l’ordonnée à l’origine de la tangente à $f$ en $a$.__\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def coeff_tang(f,a):\n", " derive=misc.derivative(f,a,ec)\n", " return derive , f(a)-derive*a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Tester cette fonction pour déterminer l’équation de la tangente à la courbe de $f$ en $2$.__" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(4.000000330961484, -7.000000661922968)" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "coeff_tang(f,2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__7. La fonction tab_val ci-dessous permet d’obtenir une liste de valeurs de la fonction $f$.__\n", "* __Quelle est la valeur initiale de cette liste ? le pas ? le nombre de valeurs obtenues ?__\n", "* __Adapter cette fonction pour qu’elle reçoive en argument la valeur initiale $x_0$, le pas $p$ et le nombre de valeurs n.__\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "#(Tester puis) modifier la fonction\n", "def tab_val(f,x0,p,n):\n", " t=[]\n", " x=x0\n", " for k in range(n):\n", " t.append(f(x))\n", " x=x+p\n", " return t" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[6.75,\n", " 11.21875,\n", " 17.0,\n", " 24.28125,\n", " 33.25,\n", " 44.09375,\n", " 57.0,\n", " 72.15625,\n", " 89.75,\n", " 109.96875]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Tester la fonction modifiée\n", "tab_val(f,3,0.5,10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__8. Ecrire une fonction Python cdir_secantes qui :__\n", "* __reçoit en arguments une fonction $f$, une valeur $x_0$, un pas $p$ et un entier $n$.__\n", "* __renvoie la liste des $n$ coefficients directeurs des sécantes à la courbe de $f$ à partir de $x_0$ avec un pas en abscisse $p$.__\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[8.9375, 10.25, 11.6875, 13.25, 14.9375, 16.75, 18.6875, 20.75, 22.9375, 25.25]" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Ecrire la fonction\n", "def cdir_secantes(f,x_0,p,n):\n", " t=[]\n", " x=x_0\n", " for k in range(n):\n", " x=x+p #Attention: incrément préalable pour éviter une division par 0\n", " t.append(coeff_dir(x_0,f(x_0),x,f(x)))\n", " return t \n", "\n", "cdir_secantes(f,3,0.5,10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 2. Méthode de Newton (corrigé) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Prérequis : Fonctions Python réalisées dans l’activité « Fonctions élémentaires autour de la dérivation »* \n", "\n", "*But de l’activité : Approcher la solution d’une équation à l’aide de la méthode de Newton.*\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On considère la fonction __$f$__ définie sur $\\mathbb{R}$ par $f(x)=\\frac{1}{4} x^3+x-3$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__1. Démontrer que $f$ est croissante sur $\\mathbb{R}$.__ \n", "__On admettra pour la suite que l’équation $f(x)=0$ a une unique solution sur $\\mathbb{R}$, notée $α$.__\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__2. Justifier que pour toute abscisse $a$, la tangente $T_a$ à la courbe de $f$ en $a$ coupe l’axe des abscisses en un point $P$.__ \n", "\n", "__Déterminer l’expression de l’abscisse de $P$ en fonction de $a$, $f'(a)$ et $f(a)$.__\n", "\n", "__Ecrire une fonction Python etap_Newton qui :__\n", "* __reçoit en argument une fonction $f$ et une valeur $a$__ ;\n", "* __renvoie l’abscisse du point $P$ correspondant.__\n", "\n", "![Graphiques Méthode Newton](img/Derivation_Newton_Dichotomie_1.png)\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "def etap_Newton(f,a):\n", " return a-f(a)/misc.derivative(f,a,ec)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.129032230312612" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Tester la fonction\n", "etap_Newton(f,3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__3. A partir d’un point de l’axe des abscisses, on peut donc construire une suite de points.\n", "On admettra ici que la suite des abscisses de ces points a pour limite $α$.__\n", "\n", "__La fonction Python appl_Newton donnée ci-dessous :__\n", "\n", "* __reçoit en arguments une fonction $f$, une valeur $a$ et un entier $n$;__\n", "* __renvoie une liste de valeurs.__ \n", "\n", "__Expliquer ce que représentent les termes de la liste renvoyée.__\n", "\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def appl_Newton(f,a,n):\n", " t=[a]\n", " for k in range(n): \n", " a=etap_Newton(f,a)\n", " t.append(a) \n", " return t" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__4. Tester cette fonction appl_Newton pour la fonction $f$ de l’énoncé avec $a=3$ et $n=10$.__" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[3,\n", " 2.129032230312612,\n", " 1.7786264005609027,\n", " 1.723683342712288,\n", " 1.7224488102335596,\n", " 1.7224481994793737,\n", " 1.7224481994791472,\n", " 1.7224481994791472,\n", " 1.7224481994791472,\n", " 1.7224481994791472,\n", " 1.7224481994791472]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "appl_Newton(f,3,10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__5. Proposer et coder en Python des fonctions polynomiales $g$ et $h$ à coefficients entiers s’annulant respectivement en $\\sqrt{5}$ et $\\sqrt[3]{7}$.__" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "def g(x):\n", " return x**2-5\n", "\n", "def h(x):\n", " return x**3-7" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__A l’aide des fonctions Python précédentes, proposer des valeurs approchées de ces deux nombres.__" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "([3,\n", " 2.333333388493576,\n", " 2.2380952459752765,\n", " 2.236068895667427,\n", " 2.236067977500065,\n", " 2.23606797749979],\n", " [3,\n", " 2.259259320548418,\n", " 1.9633080713185473,\n", " 1.914212760583598,\n", " 1.9129320407341106,\n", " 1.912931182772846])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Effectuer les saisies nécessaires\n", "appl_Newton(g,3,5) , appl_Newton(h,3,5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 3. Algorithme de Dichotomie (corrigé) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Prérequis : Aucun, mais les question 1)a)b) peuvent être supprimées si l’activité « Méthode de Newton » a été traitée.*\n", "\n", "*But de l’activité : Approcher la solution d’une équation à l’aide d’un algorithme de dichotomie (méthode plus lente que la méthode de Newton, mais pour laquelle la précision du résultat est connue).*\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On considère la fonction __$f$__ définie sur $\\mathbb{R}$ par $f(x)=\\frac{1}{4} x^3+x-3$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__1. Démontrer que $f$ est croissante sur $\\mathbb{R}$.__ \n", "__On admettra pour la suite que l’équation $f(x)=0$ a une unique solution sur $\\mathbb{R}$, notée $α$.__\n", "\n", "__Ecrire une fonction Python $f$ qui:__\n", "* __reçoit en argument une valeur $x$ ;__\n", "* __renvoie son image par la fonction $f$.__\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "def f(x):\n", " return 1/4*x**3+x-3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Déterminer les images de $0$ et $3$ par $f$, et en déduire que $α∈[0;3]$.__\n" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-3.0, 6.75)" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(0) , f(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__2. On considère un intervalle $[a;b]$ contenant $α$ et on pose $m=\\frac{a+b}{2}$.__\n", "\n", "__Justifier que : (*) si $f(a) \\times f(m)<0$ alors $α∈[a;m]$ , et sinon $α∈[m;b]$ .__\n", "\n", "__En utilisant (*), écrire une fonction Python etap_dichoto qui :__\n", "* __reçoit en arguments une fonction $f$ et les bornes $a$ et $b$ d’un intervalle contenant $α$ ;__\n", "* __renvoie les bornes $a$ et $b$ d’un nouvel intervalle contenant $α$.__\n", "\n", "![Graphiques Méthode Newton](img/Derivation_Newton_Dichotomie_2.png)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "def etap_dichoto(f,a,b):\n", " m=(a+b)/2\n", " if f(a)*f(m)<0:\n", " return a,m\n", " else:\n", " return m,b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__A partir de l’intervalle $[a;b]=[0;3]$, obtenir successivement 3 nouveaux intervalles contenant $α$.__\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((1.5, 3), (1.5, 2.25), (1.5, 1.875))" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int1=etap_dichoto(f,0,3)\n", "int2=etap_dichoto(f,*int1)\n", "int3=etap_dichoto(f,*int2)\n", "\n", "int1 , int2 , int3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Que peut-on dire de la longueur de chaque intervalle obtenu par rapport à la précédente ?__" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__3. Ecrire une fonction Python dichoto_iter qui :__\n", "* __reçoit en arguments une fonction $f$, les bornes $a$ et $b$ d’un intervalle contenant $α$ et un entier $n$ ;__\n", "* __renvoie les bornes d’un nouvel intervalle contenant $α$ obtenu en répétant $n$ fois la fonction précédente.__\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "def dichoto_iter(f,a,b,n):\n", " for k in range(n):\n", " a,b=etap_dichoto(f,a,b)\n", " return a,b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Tester avec la fonction $f$ de l’énoncé en partant de l’intervalle $[0;3]$ et en répétant $10$ fois la méthode.__" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1.7197265625, 1.72265625)" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dichoto_iter(f,0,3,10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__4. Ecrire une fonction Python dichoto_test qui :__\n", "* __reçoit en arguments la fonction $f$, les bornes $a$ et $b$ d’un intervalle contenant $α$ et une valeur $h$ ;__\n", "* __renvoie les bornes du premier intervalle de longueur inférieure à $h$ obtenu avec la méthode décrite précédemment.__\n" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "def dichoto_test(f,a,b,h):\n", " while b-a>h:\n", " a,b=etap_dichoto(f,a,b)\n", " return a,b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Tester avec la fonction $f$ de l’énoncé pour obtenir un encadrement de α à $10^{-5}$ près.__\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1.7224445343017578, 1.7224502563476562)" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dichoto_test(f,0,3,10**-5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__5. Proposer et coder en Python des fonctions polynomiales $g$ et $h$ à coefficients entiers s’annulant respectivement en $\\sqrt{5}$ et $\\sqrt[3]{7}$.__" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "def g(x):\n", " return x**2-5\n", "\n", "def h(x):\n", " return x**3-7" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__A l’aide des fonctions Python précédentes, proposer des encadrements de ces deux nombres à $10^{-7}$ près.__" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((2.2360678911209106, 2.236067980527878),\n", " (1.7224481105804443, 1.7224481999874115))" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dichoto_test(g,0,3,10**-7) , dichoto_test(f,0,3,10**-7)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.6.4" } }, "nbformat": 4, "nbformat_minor": 2 }