{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "*ENSAM-Bordeaux, Mathématiques et informatique. Date : le 04/11/19. Auteur : Éric Ducasse. Version : 1.1*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
*On pourra faire exécuter ce notebook cellule par cellule $\\left(\\mathtt{Maj+Entrée}\\right)$ ou intégralement par $\\mathtt{\\;Kernel\\rightarrow Restart\\;\\&\\;Run\\;All}$.*
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import sympy as sb\n", "sb.init_printing()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(f\"Version de sympy : {sb.__version__}\") " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# **Calcul formel : TD n°2, première partie** " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
**Pour chaque exercice, faire exécuter la partie *exemples* cellule par cellule $\\left(\\mathtt{Maj+Entrée}\\right)$, avant de passer à la partie *Travail à faire*.**
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## *Exercice 9* " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 9.1 Objectifs " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### * Savoir créer, modifier et utiliser des dictionnaires $($classe $\\mathtt{dict}\\,)$ dans le cadre général de la programmation en Python. *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 9.2 Exemples de manipulation de dictionnaires " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Voir aussi : https://docs.python.org/fr/3/tutorial/datastructures.html#dictionaries" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### $a)$ Création et ajout d'items" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ensemble non ordonné d'associations **Clef$~/~$Objet**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Définition directe " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico = {\"c\":\"truc\",\"b\":sb.pi,\"a\":[-2.34,5.67]} ; dico" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Définition par conversion d'une liste de couples " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dict( ((\"c\",\"truc\"),(\"b\",sb.pi),(\"a\",[-2.34,5.67])) ) # équivalent" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Définition par ajout progressif de chaque couple clef$\\;/\\;$valeur " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico = dict() # ou dico = {}\n", "for key,val in ((\"c\",\"truc\"),(\"b\",sb.pi),(\"a\",[-2.34,5.67])) :\n", " dico[key] = val\n", "dico" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### $b)$ **Méthodes disponibles**" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[m for m in dir(dico) if not m.startswith(\"__\")]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Copie d'un dictionnaire (voir l'effet plus bas) " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico_1 = dico.copy() ; dico_1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Création d'un dictionnaire où toutes les clefs sont associées à la même valeur " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico_2 = dict.fromkeys([1,2,3],sb.symbols(\"x\")) ; dico_2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Intégration d'un dictionnaire dans un autre " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "help(dict.update)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico_1.update(dico_2) ; dico_1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico_1.update({'c':\"bidule\", 4: sb.symbols(\"y\")}) ; dico_1 # Remplacement de la valeur associée à la clef 'c'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Comme $\\mathtt{dico\\underline{\\phantom{m}}1}$ est une copie de $\\mathtt{dico}$, ce dernier n'est pas modifié : " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Nombre d'items dans un dictionnaire : " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "(len(dico), len(dico_1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### $c)$ Accès à la *valeur* par la *clef* " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico[\"b\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Si la clef n'existe pas, soulève une erreur : " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try :\n", " dico[\"d\"]\n", "except :\n", " print(\"Erreur d'exécution !\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Si la clef n'existe pas, renvoie $\\mathtt{None}$ : " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[ dico.get(k) for k in [\"a\",\"b\",\"c\",\"d\"] ]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Suppression d'une entrée du dictionnaire : " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "del dico['a']\n", "dico" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### $d)$ Itérables" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### i/ *Différentes manières d'accéder à la liste des clefs*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Attention** : un dictionnaire n'est pas ordonné !" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico.keys()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"d\" in dico.keys()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sorted(dico.keys())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(dico)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### ii/ *Liste des valeurs*" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico.values()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(dico.values())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### iii/ *Itérations sur un dictionnaire*" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dico.items()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for k,v in dico.items() :\n", " print(f\"'{k}' -> {v}\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "list(dico.items())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 9.3 Travail à faire " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$a)$ Définir un dictionnaire qui associe à chaque caractère de la chaîne \"onde élastodynamique\" son rang en partant de la fin." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "chaine = \"onde élastodynamique\"\n", "couples = [[c,i] for i,c in enumerate(chaine[::-1],1)]\n", "print(couples)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mon_dico = dict(couples) ; mon_dico" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$b)$ Comparer le nombre d'éléments de la chaîne et le nombre d'items du dictionnaire. Expliquer la différence." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "(len(chaine),len(mon_dico))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Certaines lettres sont en double :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print( [ (c,n) for (c,n) in [ (c,chaine.count(c)) for c in mon_dico.keys() ] if n>1 ] )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$c)$ Écrire une fonction $\\mathtt{coder}$ de deux arguments, une chaine de caractères $\\mathtt{p}$ et un dictionnaire dont les clefs sont des caractères, qui renvoie la liste des valeurs associées aux caractères de $\\mathtt{p}$.\n", "Si un caractère ne fait pas partie des clefs du dictionnaire, ce dernier est modifié en lui rajoutant le caractère comme nouvelle clef et en lui associant un entier ne faisant pas parties des valeurs du dictionnaire. Tester cette fonction sur le mot $\\mathtt{{\"}mécanique{\"}}$ et le dictionnaire précédemment défini." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def coder(p,dico) :\n", " L = []\n", " for c in p :\n", " if c in dico.keys() :\n", " L.append(dico[c])\n", " else :\n", " new_num = max(dico.values())+1\n", " L.append(new_num)\n", " dico[c] = new_num\n", " return L" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "L_test = coder(\"mécanique\",mon_dico) ; L_test" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(mon_dico) # le dictionnaire a bien été modifié" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$d)$ Écrire une fonction $\\mathtt{decoder}$ de deux arguments, une liste d'entiers et un dictionnaire, qui renvoie la chaîne de caractères codée initialement." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def decoder(L,dico) :\n", " dico_inverse = dict( [ (v,k) for (k,v) in dico.items() ] )\n", " return \"\".join( [dico_inverse[n] for n in L] )" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "decoder(L_test,mon_dico)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## *Exercice 10* " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 10.1 Objectifs " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### * Savoir récrire des expressions mathématiques par substitution de symboles ou de sous-expressions,
en maîtrisant l’utilisation des méthodes $\\mathtt{replace}$ et $\\mathtt{xreplace}$. *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "https://docs.sympy.org/latest/modules/core.html#sympy.core.basic.Basic.replace
et
https://docs.sympy.org/latest/modules/core.html#sympy.core.basic.Basic.xreplace" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 10.2 Exemples " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### $a)$ Remplacement de symboles" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,h,a_0,a_1,a_2 = sb.symbols(\"x,h,a_0,a_1,a_2\")\n", "f = sb.Function(\"f\")\n", "D = a_0*f(x) + a_1*f(x+h) + a_2*f(x+2*h) ; D" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La méthode $\\mathtt{replace}$ renvoie une nouvelle expression :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D = D.replace(a_0,-3/(2*h)) ; new_D" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si on veut faire plusieurs remplacements, on fait soit des $\\mathtt{replace}$ en cascade :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D = D.replace(a_0,-3/(2*h)).replace(a_1,2/h).replace(a_2,-1/(2*h)).factor() ; new_D" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "soit on utilise la méthode $\\mathtt{xreplace}$ :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "regle = {a_0:-3/(2*h), a_1:2/h, a_2:-1/(2*h)} ; regle" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D2 = D.xreplace(regle).factor() ; new_D2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D.equals(new_D2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Remarque sur l'exemple : il s'agit de « *l'approximation par différences finies* » décentrée d'ordre 2 de $f^{\\prime}(x)$ :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D.series(h,0,2).doit()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### $b)$ Remplacement de fonction (méthode $\\mathtt{replace}$ uniquemement)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "D.replace(f,sb.cos)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a,b,c = sb.symbols(\"a,b,c\")\n", "def P(x) : return a*x**2 + b*x + c\n", "P(h)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D.replace(f,P)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D.replace(f,P).simplify()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_D.replace(f,P).equals( P(x).diff(x) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 10.3 Travail à faire " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "L'objectif de cette exercice est de déterminer $\\displaystyle \\int_{-\\pi}^{\\pi}\\cos(m\\,t)\\,\\cos(n\\,t)\\,w(t)\\;\\mathbb{d}t$ dans différents cas de figure, $m$ et $n$ étant deux entiers naturels." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$a)$ Vérifier que $\\displaystyle\\cos(x)\\,\\cos(y)=\\frac{\\cos(x+y)+\\cos(x-y)}{2}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,y =sb.symbols(\"x,y\")\n", "(sb.cos(x)*sb.cos(y)).equals( (sb.cos(x+y)+sb.cos(x-y))/2 )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On a donc $\\displaystyle \\int_{-\\pi}^{\\pi}\\cos(m\\,t)\\,\\cos(n\\,t)\\,w(t)\\;\\mathbb{d}t=\\frac{1}{2}\\,\\left(I_{m+n}+I_{m-n}\\right)$, où $\\displaystyle I_{k}= \\int_{-\\pi}^{\\pi}\\cos(k\\,t)\\,w(t)\\;\\mathbb{d}t$.
$b)$ Définir l'expression symbolique $C = \\cos(k\\,t)\\,w(t)$, où $k$ est un entier et $w$ une fonction indéfinie. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = sb.symbols(\"t\")\n", "k = sb.symbols(\"k\", integer=True)\n", "w = sb.Function(\"w\")\n", "C = sb.cos(k*t)*w(t) ; C" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$b)$ En utilisant l'expression C, déterminer $I_{0}$ lorsque $w(t)=\\frac{1}{2\\,\\pi}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "C0 = C.replace(k,0).replace(w(t),1/(2*sb.pi)) ; C0" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Variante\n", "C.xreplace({k:0, w(t):1/(2*sb.pi)})" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "I0 = C0.integrate( (t,-sb.pi,sb.pi) ) ; I0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$c)$ En utilisant l'expression C, déterminer $I_{j}$ lorsque $j$ est un entier naturel non nul et $w(t)=\\frac{1}{2\\,\\pi}$. Conclure sur la valeur de l'intégrale recherchée lorsque $w(t)=\\frac{1}{2\\,\\pi}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "j = sb.symbols(\"j\", integer=True, nonzero=True)\n", "Cj = C.xreplace({k:j, w(t):1/(2*sb.pi)}) ; Cj" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ij = Cj.integrate( (t,-sb.pi,sb.pi) ) ; Ij" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# La conclusion de nécessite pas d'outil de calcul\n", "cases = {\"m=n=0\":(I0+I0)/2, \"m=n!=0\":(I0+Ij)/2, \"m!=n\":(Ij+Ij)/2}\n", "print(cases)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$d)$ Déterminer $I_k$ lorsque $\\displaystyle w(t)=\\frac{1}{4}\\,\\cos\\!\\left(\\frac{t}{2}\\right)$. En déduire la valeur de l'intégrale recherchée au départ, en fonction des entiers naturels $m$ et $n$, lorsque $\\displaystyle w(t)=\\frac{1}{4}\\,\\cos\\!\\left(\\frac{t}{2}\\right)$.
$\\hspace{6mm}$Faire afficher le tableau correspondant pour $0\\leqslant m\\leqslant n\\leqslant 5$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Dk = C.replace(w(t),sb.cos(t/2)/4) ; Dk" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ik = sb.integrate(Dk, (t,-sb.pi,sb.pi)) ; Ik" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "m,n = sb.symbols(\"m,n\", integer=True, nonnegative=True) # entiers naturels\n", "Pmn = ( ( Ik.replace(k,m+n) + Ik.replace(k,m-n) )/2 )\n", "Pmn" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Pmn_fact = Pmn.replace((-1)**(m-n),(-1)**(m+n)).simplify() ; Pmn_fact" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Présentation bien évidemment non exigible :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "vide = sb.symbols(\"{}\")\n", "T = sb.Matrix([[vide for j in range(7)] for i in range(7)])\n", "for vm in range(6) :\n", " T[0,vm+1] = sb.Eq(n,vm)\n", " T[vm+1,0] = sb.Eq(m,vm)\n", " for vn in range(vm,6) :\n", " T[vm+1,vn+1] = Pmn.xreplace({m:vm,n:vn})\n", "T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## *Exercice 11* " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 11.1 Objectifs " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### * Savoir récrire des expressions mathématiques par substitution de fonctions par d'autres fonctions,
en maîtrisant la définition de « fonctions lambda » $($$\\mathtt{lambda}$$)$ et l’utilisation de la méthode $\\mathtt{replace}$. *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plus généralement, on apporte ici des compléments sur la définition des fonctions.
Voir aussi le tutoriel : https://docs.python.org/3/tutorial/controlflow.html#more-on-defining-functions " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 11.2 Exemples " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Définition usuelle de fonctions :" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
*Noter que l'on prend garde à ne pas utiliser, dans le bloc de définition de la fonction, de variable extérieure à ce bloc.
Pour ce faire, on utilise des arguments supplémentaires avec des valeurs par défaut.*
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,x_0 = sb.symbols(\"x,x_0\")\n", "def f0(t) : \n", " return 1\n", "# t0 sert à récupérer ce que désigne x_0 AU MOMENT des définitions des fonctions.\n", "def f1(t,t0=x_0) : \n", " return t-t0 \n", "def f2(t,t0=x_0) : \n", " return (t-t0)**2\n", "def f3(t,t0=x_0) : \n", " return (t-t0)**3\n", "[ f(x) for f in [f0,f1,f2,f3] ]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Utilisation de fonctions lambda :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "LF = [ lambda t,t0=x_0,p=n : (t-t0)**p for n in range(9) ]\n", "LF" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[ f(x) for f in LF ]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "LF[3](x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Fonction dont le nombre d'arguments est variable (non exigible, peut être passé dans un premier temps)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def som_puis1(p,*args) : \n", " \"\"\" *args représente tous les arguments passés à la fonction\n", " après l'argument p et jusqu'à rencontrer un éventuel\n", " argument nommé (avec une valeur par défaut, absent ici).\"\"\"\n", " return sum( [t**p for t in args] ) \n", "a,b,c = sb.symbols(\"a,b,c\")\n", "[ som_puis1(2,a), som_puis1(2,a,b), som_puis1(2,a,b,c,x+1) ]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "som_puis2 = lambda *args,p=2 : sum( [t**p for t in args] )\n", "[ som_puis2(a), som_puis2(a,b), som_puis2(a,b,c,x+1,p=4) ]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 11.3 Travail à faire " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*** À propos des différences finies centrées d'ordre 2. ***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$a)$ Définir l'expression $\\mathtt{DF}=a_{-1}\\,T(x-h)+a_{0}\\,T(x)+a_{1}\\,T(x+h)$, $T$ désignant une fonction indéfinie.\n", "
$\\hspace{6mm}$On pourra nommer les symboles $a_{-1}$, $a_{0}$ et $a_{1}$ respectivement $\\mathtt{am}$, $\\mathtt{a0}$ et $\\mathtt{ap}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,h,am,a0,ap = sb.symbols(\"x,h,a_-1,a_0,a_1\")\n", "T = sb.Function(\"T\")\n", "DF = am*T(x-h) + a0*T(x) + ap*T(x+h) ; DF" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$b)$ Remplacer dans l'expression $\\mathtt{DF}$ $a_{-1}$ par $\\displaystyle\\frac{-1}{2\\,h}$, $a_0$ par 0 et $a_1$ par $\\displaystyle\\frac{1}{2\\,h}$, pour obtenir une expression $\\mathtt{DF1}$.
$\\hspace{5mm}$ Faire ensuite un développement limité de $\\mathtt{DF1}$ en $h=0$ à l'ordre 2.
$\\hspace{5mm}$ Pour améliorer la lisibilité du résultat, on pourra faire appel à la fin à la méthode $\\mathtt{doit()}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "regle1 = {am:-1/(2*h), a0:0, ap:1/(2*h)} ; regle1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF1 = DF.xreplace(regle1).together() ; DF1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF1.series(h,0,2) # sans .doit()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF1.series(h,0,2).doit() # avec" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Vérification avec la fonction $\\mathtt{as\\underline{\\phantom{m}}finite\\underline{\\phantom{m}}difference}$ :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "T(x).diff(x).as_finite_difference([x-h,x,x+h])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF1.equals(T(x).diff(x).as_finite_difference([x-h,x,x+h]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$c)$ Faire de même pour $\\mathtt{DF2}$, obtenu en remplaçant $a_{-1}$ par $\\displaystyle\\frac{1}{h^2}$, $a_0$ par $\\displaystyle\\frac{-2}{h^2}$ et $a_1$ par $\\displaystyle\\frac{1}{h^2}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "regle2 = {am:1/h**2, a0:-2/h**2, ap:1/h**2} ; regle2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF2 = DF.xreplace(regle2).together() ; DF2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF2.series(h,0,2).doit()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Vérification avec la fonction $\\mathtt{as\\underline{\\phantom{m}}finite\\underline{\\phantom{m}}difference}$ :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "T(x).diff(x,2).as_finite_difference([x-h,x,x+h])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "DF2.equals(T(x).diff(x,2).as_finite_difference([x-h,x,x+h]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$d)$ Déterminer ce que valent $\\mathtt{DF1}$ et $\\mathtt{DF2}$ lorsque $T$ est la fonction $x\\mapsto x^n$, pour $n$ entier variant de 0 à 4. Faire afficher également $T^{\\prime}(x)$ et $T^{\\prime\\prime}(x)$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Dérivée $1^{\\mathrm{ère}}$ : correspondance pour les polynomes de degré au plus 2 :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[ (n,DF1.replace(T, lambda t,p=n : t**p ).expand(),(x**n).diff(x)) for n in range(5) ]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Dérivée $2^{\\mathrm{nde}}$ : correspondance pour les polynomes de degré au plus 3 :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[ (n,DF2.replace(T,lambda t,p=n : t**p ).simplify(),(x**n).diff(x,2)) for n in range(5) ]" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }