{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*ENSAM-Bordeaux, Mathématiques et informatique. Date : le 17/10/19. Auteur : Éric Ducasse. Version : 1.1*"
]
},
{
"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°1, seconde 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 4* "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.1 Objectifs "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Savoir dériver symboliquement des expressions mathématiques et remplacer dans celle-ci un symbole par un autre symbole ou une expression. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.2 Exemples "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### On peut récrire une expression en remplaçant un symbole par un autre symbole ou une expression, à l'aide de la méthode $~$replace :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a,t = sb.symbols(\"a,t\")\n",
"T = 3+2*a*sb.sin(t)-4*sb.sin(a*t)\n",
"T"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Syntaxe : expression.replace(old, new) , où $\\mathtt{old}$ désigne un symbole ou une fonction."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[T, T.replace(t,0), T.replace(t,sb.pi) ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n = sb.symbols(\"n\", integer=True)\n",
"[ T, T.replace(t,sb.pi).replace(a,n) ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[ T, T.replace(t,sb.pi).replace(a,sb.symbols(\"n\", integer=True)+sb.S(1)/2) ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[ T, T.replace(sb.sin, sb.cos), T.replace(sb.sin, sb.exp) ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"T.replace(sb.sin, lambda x:x ) # Fonction identité"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ne fonctionne pas lorsque que $\\mathtt{old}$ est un nombre ou une partie de sous-expression* :
\n",
" $(*)$ Pour certaines sous-expressions, cela fonctionne néanmoins mais le pourquoi du comment n'est pas exigible."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[ T.replace(2*a,10), T.replace(4,a) ]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### On dérive une expression à l'aide de la méthode $~$diff :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x,y,a,b,c,t,w = sb.symbols(\"x,y,a,b,c,t,omega\")\n",
"wave = sb.cos(a*x+b*y)*sb.exp(sb.I*w*t)\n",
"wave"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Dérivée première par rapport à $x$ :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"wave.diff(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Dérivée seconde par rapport à $x$ :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"wave.diff(x,2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Laplacien $\\displaystyle\\Delta=\\frac{\\partial^2}{\\partial x^2}+\\frac{\\partial^2}{\\partial y^2}$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"lap = (wave.diff(x,2)+wave.diff(y,2)).factor() ; lap"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Opérateur de propagation acoustique $\\displaystyle\\frac{1}{c^2}\\,\\frac{\\partial^2}{\\partial t^2}-\\Delta$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(wave.diff(t,2)/c**2-lap).simplify()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.3 Travail à faire "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$a)$ Définir l'expression $\\displaystyle \\mathtt{D0}=(x+b)\\,\\exp(-a\\,x)$. Faire afficher les dérivées première et seconde de $\\mathtt{D0}$ par rapport à $x$, notées respectivement $\\mathtt{D1}$ et $\\mathtt{D2}$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$b)$ Vérifier que la fonction $\\displaystyle x\\mapsto (x+b)\\,\\exp(-a\\,x)$ est solution de l'équation différentielle $\\displaystyle f^{\\prime\\prime}(x)+2\\,a\\,f^{\\prime}(x)+a^2\\,f(x)=0$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$c)$ Calculer $\\displaystyle f^{\\prime\\prime}(x)+2\\,a\\,f^{\\prime}(x)+a^2\\,f(x)$ **sous forme factorisée** pour les fonctions $f$ suivantes:
$\\hspace{6cm}$\n",
"$\\displaystyle x\\mapsto\\exp(-c\\,x)\\quad$ et $\\displaystyle \\quad x\\mapsto(a^2-d^2)\\,\\cos(d\\,x)+2\\,a\\,d\\,\\sin(d\\,x)$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$d)$ Même question pour $x\\mapsto f(x-x_0)$ et $x\\mapsto f(-x)$, où $f(x)=\\mathtt{D0}=(x+b)\\,\\exp(-a\\,x)$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## *Exercice 5* "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.1 Objectifs "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Savoir intégrer symboliquement des expressions mathématiques et déterminer la valeur exacte d’une intégrale. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.2 Exemples "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Primitives"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Calcul direct"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"t = sb.symbols(\"t\")\n",
"[ (t**n).integrate(t) for n in range(10) ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = sb.symbols(\"alpha\")\n",
"sb.integrate(t**a,t) # équivalent à (t**a).integrate(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Si on spécifie que $\\beta>0$ :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"b = sb.symbols(\"beta\", positive=True)\n",
"(t**b).integrate(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Calcul en 2 temps : définition de l'intégrale sans la calculer, puis calcul (déconseillé en général)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pne = sb.Integral(sb.log(t)/t**2,t) ; pne"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pev = pne.doit() ; pev.together()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pev.diff(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Intégrales"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n,m = sb.symbols(\"n,m\", integer=True, positive=True)\n",
"ps = sb.integrate(sb.cos(2*sb.pi*n*t)*sb.cos(2*sb.pi*m*t),(t,0,1)) ; ps"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Intégrales généralisées"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Transformées de Laplace : $\\displaystyle F(p)=\\int_0^{\\infty}f(t)\\,\\exp(-p\\,t)\\;\\mathbb{d}t$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"p,w,a = sb.symbols(\"p,omega,a\", positive=True)\n",
"sb.integrate(sb.sin(w*t)*sb.exp(-p*t),(t,0,sb.oo)).together()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[ (f_de_t*sb.exp(-p*t)).integrate( (t,0,sb.oo) ).simplify() \\\n",
" for f_de_t in [sb.sin(w*t),sb.cos(w*t),sb.sin(w*t)*sb.exp(-a*t)] ]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* $\\displaystyle \\int_{-1}^{1}\\frac{1}{\\sqrt{1-t^2}}\\;\\mathbb{d}t$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(1/sb.sqrt(1-t**2)).integrate( (t,-1,1) )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.3 Travail à faire "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$a)$ Déterminer une primitive de $\\displaystyle t\\mapsto\\frac{1}{\\sqrt{2\\,\\pi}}\\,\\exp\\!\\left(\\frac{-t^2}{2}\\right)$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$b)$ Déterminer pour tout réel $x$ : $\\displaystyle \\frac{1}{\\sqrt{2\\,\\pi}}\\int_{-\\infty}^{x}\\exp\\!\\left(\\frac{-t^2}{2}\\right)\\,\\mathbb{d}t$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$c)$ Vérifier que $\\displaystyle \\frac{1}{\\sqrt{2\\,\\pi}}\\int_{-\\infty}^{\\infty}t^2\\,\\exp\\!\\left(\\frac{-t^2}{2}\\right)\\,\\mathbb{d}t=1$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$d)$ Plus généralement, déterminer $\\displaystyle I_n=\\frac{1}{\\sqrt{2\\,\\pi}}\\int_{-\\infty}^{\\infty}t^{2\\,n}\\,\\exp\\!\\left(\\frac{-t^2}{2}\\right)\\,\\mathbb{d}t$, où $n$ est un entier naturel."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$e)$ Vérifier que $\\displaystyle I_n=\\frac{(2\\,n)!}{2^n\\,n!}$, en utilisant la fonction $\\mathtt{sympy.factorial}$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## *Exercice 6* "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 6.1 Objectifs "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Savoir créer une fonction indéfinie et la manipuler. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 6.2 Exemples "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x,y,z,t = sb.symbols(\"x,y,z,t\")\n",
"f = sb.Function(\"f\")\n",
"[ f(e) for e in [x,y,z,t,1,sb.S(2)/5] ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"f(x).diff(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sb.integrate(f(x),x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[ sb.integrate(f(x).diff(x),x), sb.integrate(f(x),x).diff(x) ]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"f(x,y,z).diff(x,3,y,2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"g = sb.Function(\"g\")\n",
"f(g(x)).diff(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"f(sb.sqrt(1-x**2)).diff(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sb.sqrt(1-f(x)**2).diff(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 6.3 Travail à faire "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'objet de cet exercice est de retrouver l'expression du Laplacien en corrdonnées polaires"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$a)$ Définir les symboles réels $x$, $y$ et $a$, le symbole $r$ positif ou nul (« non négatif ») , ainsi que les fonctions F_c et F_p."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le Laplacien en coordonnées cartésiennes s'écrit :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try :\n",
" delta_Fc = F_c(x,y).diff(x,2)+F_c(x,y).diff(y,2) ; delta_Fc\n",
"except Exception as e :\n",
" print(\"Erreur :\",e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$b)$ Définir les expressions $R=\\sqrt{x^2+y^2}$ et $A=\\mathrm{arctan}_2(y,x))$ (fonction $\\mathtt{sympy.atan2}$),
$\\hspace{4mm}$ puis en déduire $\\displaystyle\n",
"\\Delta F_p(R,A) = \\frac{\\partial^2}{\\partial x^2}\\,F_p(R,A)+\\frac{\\partial^2}{\\partial y^2}\\,F_p(R,A)$.
$\\hspace{6mm}$Une fois le résultat obtenu, le développer, puis le simplifier, puis le développer à nouveau."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$c)$ Arranger le résultat précédent en remplaçant dans l'ordre $\\mathtt{A}$ par $\\mathtt{a}$, $x$ par $r\\,\\cos(a)$ et $y$ par $r\\,\\sin(a)$, puis en simplifiant deux fois de suite. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try : D.doit() # Simplification ultime du résultat nommé ici D (compréhension non exigible)\n",
"except Exception as e : print(\"Erreur :\",e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## *Exercice 7* "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 7.1 Objectifs "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Savoir obtenir le développement limité d’une expression par rapport à l’un de ses paramètres,
au voisinage d’une valeur donnée et à un ordre donné. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 7.2 Exemples "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### *Développement limité en zéro*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x,h =sb.symbols(\"x,h\")\n",
"sb.exp(x).series(x,0,4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"f =sb.Function(\"f\")\n",
"f(x).series(x,0,3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### *Développement limité ailleurs qu'en zéro*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le résultat est un peu lourd :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sb.log(x).series(x,1,4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut préférer plutôt :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sb.log(1+h).series(h,0,4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### *Développements limités généralisés*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(1/(1-sb.cos(x))).series(x,0,4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"((1+x**2)/(x-2)**2).series(x,sb.oo,4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### *Récupérer le résultat sans le $O(h^n)$ :*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il faut utiliser la méthode $\\mathtt{replace}$ de la façon suivante :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n = sb.symbols(\"n\", integrer=True, positive=True)\n",
"[sb.O(x**2), sb.O(h**n,h)]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[ e.replace(sb.O, lambda *X:0) for e in [sb.O(x**2), sb.O(h**n,h)] ]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* « $\\mathtt{lambda\\;*X:0}$ » désigne la fonction qui renvoie l'entier 0 et qui prend un nombre quelconque d'arguments :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fonction_nulle = lambda *X:0\n",
"[fonction_nulle(), fonction_nulle(3), fonction_nulle(x,n), fonction_nulle(1,2,n), fonction_nulle(1,2,3,n)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Enlever le $O(h^n)$ peut faciliter la manipulation du résultat : "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"DL_en1_ord4 = sb.log(x).series(x,1,4)\n",
"DL_en1_ord4 "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[DL_en1_ord4 .expand(),DL_en1_ord4 .factor()]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"DL_en1_ord4_sans_O = DL_en1_ord4.replace(sb.O, lambda *X:0)\n",
"DL_en1_ord4_sans_O"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"[DL_en1_ord4_sans_O.expand(), DL_en1_ord4_sans_O.factor()]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 7.3 Travail à faire "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'objet de cet exercice est l'étude d'une courbe paramétrée définie par $\\displaystyle\\left\\lbrace\\begin{array}{lll}\n",
"x(t) & = & 7\\,\\sin^2(t) \\\\ y(t) & = & 2\\,\\sin(t)\\,(1+\\cos(3\\,t))\n",
"\\end{array}\\right .$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$a)$ Définir les expressions symboliques $\\mathtt{X}=x(t)$ et $\\mathtt{Y}=y(t)$. Vérifier que ces expressions sont $2\\,\\pi$-périodiques et étudier leurs parités.
$\\hspace{5mm}$Montrer que la courbe paramétrée passe par un même point en $t=0$ et en $t=\\pi$, ainsi que pour $\\displaystyle t=\\frac{\\pi}{6}$ et $\\displaystyle t=\\frac{5\\,\\pi}{6}$."
]
},
{
"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": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$b)$ Définir les expressions symboliques $\\mathtt{dX}=x^{\\prime}(t)$ et $\\mathtt{dY}=y^{\\prime}(t)$. Vérifier que $\\mathtt{dX}$ s'annule pour $\\displaystyle t\\in\\left\\lbrace 0,\\frac{\\pi}{2},\\pi\\right\\rbrace$ et que
$\\mathtt{dY}$ s'annule pour $\\displaystyle t\\in\\left\\lbrace \\mathrm{arccos}\\!\\left(\\frac{1+\\sqrt{7}}{4}\\right),\\frac{\\pi}{3},\\mathrm{arccos}\\!\\left(\\frac{1-\\sqrt{7}}{4}\\right),\\pi\\right\\rbrace$ (fonction $\\mathtt{sympy.acos}$)."
]
},
{
"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": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Tracé de la courbe paramétrée (la fonction $\\mathtt{sympy.lambdify}$ sera détaillée plus tard) :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"try :\n",
" X_num,Y_num = sb.lambdify(t, X, \"numpy\"),sb.lambdify(t, Y, \"numpy\")\n",
" def tracer() :\n",
" T = np.linspace(-np.pi,np.pi,510)\n",
" plt.plot(X_num(T),Y_num(T),\"-m\",linewidth=2)\n",
" plt.grid() ; plt.axis(\"equal\")\n",
" tracer()\n",
"except Exception as e :\n",
" print(\"Erreur : X et Y non définis correctement,\",e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$c)$ Faire des développements limités de $X$ et $Y$ à l'ordre 4 lorsque $t$ est au voisinage de $0$. Faire tracer ensuite la courbe paramétrée correspondante, pour $t$ dans l'intervalle $[-0.6,0.6]$. On rappellera la fonction $\\mathtt{tracer}$ pour superposer les deux courbes."
]
},
{
"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": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$d)$ Faire de même lorque $t$ est au voisinage de $\\pi$ (point singulier)."
]
},
{
"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": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## *Exercice 8* "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 8.1 Objectifs "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Savoir déterminer une limite et aussi calculer une somme finie ou infinie. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 8.2 Exemples "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### *Limites* "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = sb.symbols(\"x\", real=True)\n",
"a = sb.symbols(\"a\", positive=True)\n",
"F = (1+a*x)/(2-3*x) ; F"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"F.limit(x,sb.oo)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"F.limit(x,sb.S(2)/3)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(sb.limit.__doc__[:749])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"F.limit(x,sb.S(2)/3,dir=\"+\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"F.limit(x,sb.S(2)/3,dir=\"-\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Limite calculée en 2 temps (déconseillé en général)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"limite_non_evaluee = sb.Limit(F,x,sb.S(2)/3,dir=\"-\") ; limite_non_evaluee"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"limite_non_evaluee.doit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### *Sommes* "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"r = sb.symbols(\"r\", positive=True)\n",
"k,n = sb.symbols(\"k,n\", integer=True, nonnegative=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"somme = sb.summation(r**n,(n,0,sb.oo)) ; somme"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"un_moins_r = sb.symbols(\"umr\", positive=True)\n",
"somme.replace(r,1-un_moins_r).simplify().replace(un_moins_r,1-r)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"somme_partielle = sb.summation(r**k,(k,0,n)) ; somme_partielle"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"rm1 = sb.symbols(\"rm1\",nonzero=True)\n",
"S = somme_partielle.replace(r,rm1+1).simplify().replace(rm1,r-1) ; S"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tous les algorithmes ne sont pas implémentés :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try :\n",
" somme_partielle.limit(n,sb.oo)\n",
"except Exception as e :\n",
" print(\"Erreur :\",e)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try :\n",
" S.limit(n,sb.oo)\n",
"except Exception as e :\n",
" print(\"Erreur :\",e)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"logr = sb.symbols(\"lambda\", negative=True) # log(p) < 0, pour spécifier que p = exp(log(p)) < 1\n",
"etape1 = S.replace(r,sb.exp(logr)) ; etape1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"etape2 = etape1.limit(n,sb.oo) ; etape2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"etape3 = etape2.replace(logr,sb.log(r)) ; etape3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"etap4 = etape3.together() ; etap4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Somme calculée en 2 temps (déconseillé en général)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"somme_non_evaluee = sb.Sum(r**n,(n,0,sb.oo)) ; somme_non_evaluee"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"somme_non_evaluee.doit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 8.3 Travail à faire "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Lois de probabilités discrètes : loi de Poisson et loi géométrique"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$a)$ Définir $\\displaystyle \\mathtt{P_k}=\\frac{\\mu^k}{k!}\\,\\exp(-\\mu)$, en spécifiant que $\\mu$ est un nombre strictement positif et que $k$ est un entier naturel."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$b)$ Vérifier que $\\displaystyle \\sum_{k=0}^{\\infty}\\mathtt{P_k}=1$ et calculer $\\displaystyle \\;\\mathtt{EP}=\\sum_{k=0}^{\\infty}k\\,\\mathtt{P_k}\\;$, $\\displaystyle \\;\\mathtt{VP}=\\sum_{k=0}^{\\infty}(k-\\mathtt{EP})^2\\,\\mathtt{P_k}\\;$, ainsi que $\\displaystyle \\mathtt{R_n}=\\sum_{k=n+1}^{\\infty}\\mathtt{P_k}=1-\\sum_{k=0}^{n}\\mathtt{P_k}$ pour $n$ entier naturel non nul."
]
},
{
"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": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(sb.lowergamma.__doc__[:413])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$c)$ Faire de même pour la loi géométrique de paramètre $p$ dans l'intervalle $]0,1[$, en remplaçant $\\mathtt{Pk}$ par $\\displaystyle \\mathtt{G_k}=p\\,(1-p)^{k-1}$, où $k$ est un entier naturel non nul. On posera $\\lambda=\\log(1-p)$ en spécifiant que $\\lambda<0$."
]
},
{
"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": []
},
{
"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.6.5"
}
},
"nbformat": 4,
"nbformat_minor": 2
}