{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size:8pt\">*ENSAM-Bordeaux, Mathématiques et informatique. Date : le 18/10/19. Auteur : Éric Ducasse. Version : 1.2*</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\"> <span style=\"color:#800000\"> *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}$.* </span> </div>"
   ]
  },
  {
   "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": [
    "# <span style=\"color:#0066BB\"> **Calcul formel : TD n°1, première partie** </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color: #0000BB\"> *Exercice 1* </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 1.1 Objectifs </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *<span style=\"color:#005500\"> Savoir faire du calcul exact avec des entiers, des fractions, des nombres transcendants<br /> et les fonctions mathématiques usuelles ; savoir vérifier une égalité. </span>*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 1.2 Exemples </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fractions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ne_marche_pas = 2/5 ; ne_marche_pas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F1 = sb.Rational(2,5) ; F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F2 = sb.S(2)/5 ; F2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F1 == F2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Remarque : si la fraction contient d'autres symboles que des entiers, l'utilisation de l'opérateur / fonctionne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[sb.pi/3,3/(1+sb.I),2/sb.E,sb.sqrt(3)/2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nombres irrationnels :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [sb.pi,sb.E,sb.I,sb.sqrt(2)] ; L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (-sb.S(1)/2+sb.I*sb.sqrt(3)/2)**3\n",
    "[sb.cos(sb.pi/4),sb.E**(sb.I*sb.pi),a]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Égalités :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ a == 1 , a.equals(1) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.simplify() == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 1.3 Travail à faire </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$a)$ Définir le nombre $\\displaystyle g=\\frac{1}{2} + \\frac{\\sqrt{5}}{2}$. Vérifier ensuite que $\\displaystyle g=\\frac{1}{g-1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = sb.S(1)/2 + sb.sqrt(5)/2 ; g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.equals(1/(g-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(g*(g-1)).equals(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$b)$ Définir le nombre complexe $\\displaystyle z=\\exp\\!\\left(\\frac{2\\,\\mathbb{i}\\,\\pi}{7}\\right)$. Vérifier ensuite que $z^7=1$ et que $\\displaystyle\\sum_{k=0}^{6}z^k=0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = sb.exp(2*sb.I*sb.pi/7) ; z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(z**7).equals(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = sum( [ z**k for k in range(7) ] ) ; s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.equals(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color: #0000BB\"> *Exercice 2* </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 2.1 Objectifs </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *<span style=\"color:#005500\"> Savoir définir et manipuler des expressions littérales simples (développer, factoriser,<br /> simplifier, extraire des coefficients, etc).</span>*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 2.2 Exemples </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Définition de symboles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b,c,X,Y = sb.symbols(\"a,b,c,X,Y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Définition d'expressions littérales :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ecart = Y - (a*X+b) ; ecart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = (ecart**2).simplify() ; q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Développer et regrouper des termes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = q.expand() ; d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.collect(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.collect(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extraire des coefficients à partir d'une expression développée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B = d.coeff(X**2),d.coeff(X)\n",
    "C = (d - A*X**2 - B*X).expand()\n",
    "A,B,C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* <span style=\"color:#600000\"> *Si l'expression n'est pas développée, cela ne marche pas :* </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q,q.coeff(X**2),q.coeff(X) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* *Variante, qui utilise la définition de polynômes par le type* **sympy.Poly** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sb.Poly(d,X).all_coeffs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sb.Poly(q,X) # Fait le développement sur la forme factorisée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sb.Poly((X**2-a)**2,X).all_coeffs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Factoriser :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X**4-1).factor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X**4+1).factor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X**4+1).factor(extension=sb.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "polynome = sb.Poly(X**4+1,X) ; polynome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "racines = [ polynome.root(i).factor() for i in range(polynome.degree()) ] ; racines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ x_0.simplify() for x_0 in polynome.all_roots() ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "polynome_factorise = 1\n",
    "for x_0 in racines : \n",
    "    polynome_factorise *= (X-x_0)\n",
    "polynome_factorise    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X**4+1).equals(polynome_factorise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Définir des symboles en faisant des hypothèses sur ceux-ci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = sb.symbols(\"theta\", real=True)\n",
    "k = sb.symbols(\"k\", integer=True)\n",
    "[sb.sin(theta+2*sb.pi*k).simplify(),sb.sin(theta+2*sb.pi*k).trigsimp()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sb.cos(sb.pi*k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = sb.symbols(\"m\", positive=True)\n",
    "sb.sin(theta+sb.pi*m).equals( (-1)**m * sb.sin(theta) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = sb.symbols(\"m\", integer=True)\n",
    "sb.sin(theta+sb.pi*m).equals( (-1)**m * sb.sin(theta) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 2.3 Travail à faire </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$a)$ Définir $z=x+\\mathbb{i}\\,y$ en spécifiant que $x$ et $y$ sont réels, puis définir la liste $\\mathtt{LP}=\\left[z^2,z^3,z^4\\right]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = sb.symbols(\"x,y\", real=True)\n",
    "z = x + sb.I*y\n",
    "LP = [(z**n) for n in (2,3,4) ]\n",
    "LP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$b)$ Développer chaque élément de la liste $\\mathtt{LP}$ et déterminer le coefficient de $\\mathbb{i}$. <br />En déduire les parties réelle et imaginaire de chacun de ces éléments si $x$, $y$ et $a$ sont réels (hypothèse non formulée en $\\mathtt{sympy}$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Noter que la liste $\\mathtt{LP}$ n'est pas un objet $\\mathtt{sympy}$ et que $\\mathtt{LP.expand()}$ renvoie donc une erreur :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try :\n",
    "    LP.expand()\n",
    "except Exception as e :\n",
    "    print(\"Erreur :\",e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LP_dev = [ e.expand() for e in LP ] ; LP_dev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Liste des parties imaginaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_imag = [ e.expand().coeff(sb.I) for e in LP ]\n",
    "L_imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Liste des parties réelles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_real = [ (Z - sb.I*Y).simplify() \\\n",
    "                     for (Z,Y) in zip(LP_dev,L_imag) ]\n",
    "L_real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Vérification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ Z.equals(X+sb.I*Y) for (Z,X,Y) in zip(LP,L_real,L_imag) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* En une seule cellule :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re_im = []\n",
    "for n,zpn in enumerate(LP,2) :\n",
    "    zpn_dev = zpn.expand().collect(sb.I)\n",
    "    print(f\"Forme développée de z^{n} :\",zpn_dev)\n",
    "    zpn_imag = zpn_dev.coeff(sb.I)\n",
    "    zpn_real = zpn_dev - sb.I*zpn_imag\n",
    "    re_im.append([zpn_real,zpn_imag])\n",
    "re_im"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$c)$ Factoriser chacune des expressions trouvées à la question précédente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re_im_factorisees = [ [T.factor() for T in couple] \\\n",
    "                                    for couple in re_im ]\n",
    "re_im_factorisees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$d)$ Reprendre l'exercice par une méthode différente, en utilisant la fonction $\\mathtt{conjugate}$ de $\\mathtt{sympy}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LP_conj = [ sb.conjugate(T) for T in LP ]\n",
    "LP_conj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re_im_factorisees_bis = [ [ ((T+sb.conjugate(T))/2).expand().factor(),\\\n",
    "                            ((T-sb.conjugate(T))/(2*sb.I)).expand().factor() ] for T in LP ] ;\n",
    "re_im_factorisees_bis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ X1.equals(X2) and Y1.equals(Y2) for (X1,Y1),(X2,Y2) in zip(re_im_factorisees_bis,re_im_factorisees) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color: #0000BB\"> *Exercice 3* </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 3.1 Objectifs </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *<span style=\"color:#005500\"> Savoir créer et manipuler des expressions fractionnaires.</span>*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 3.2 Exemples </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numérateur et dénominateur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = sb.symbols(\"x\", real=True)\n",
    "F = (x+sb.sqrt(x**2-1))/(x-sb.sqrt(x**2-1)) ; F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N,D = F.as_numer_denom() ; (N,D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Une simplification pour laquelle sympy n'est pas programmé :*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N2,D2 = [ (X*N).expand() for X in (N,D) ]\n",
    "F2 = N2/D2 ; F2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F.equals(F2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Écriture sous forme d'une unique fraction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = sb.symbols(\"x,y\", real=True)\n",
    "S = 1/x + y/(x+2*y) ; S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = S.together() ; T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S.factor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Décomposition en éléments simples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T.apart(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T.apart(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:purple\"> 3.3 Travail à faire </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$a)$ Définir les expressions symboliques suivantes : $\\displaystyle G=\\frac{\\frac{5}{2}}{1+\\frac{1}{2}\\,p}$ et $\\displaystyle R=\\frac{a}{p}$, où $p$ et $a$ sont des symboles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p,a = sb.symbols(\"p,a\")\n",
    "G = 5/(2*(1+p/2)) ; R = a/p ; (G,R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$b)$ On pose : $\\displaystyle H=\\frac{G}{1+R\\,G}$. Montrer que le dénominateur de H peut s'écrire : $D = (p+1+\\sqrt{1-5\\,a})\\,(p+1-\\sqrt{1-5\\,a})$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = (G/(1+R*G)).simplify() ; H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N,D = H.as_numer_denom() ; N,D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_factorise = (p+1+sb.sqrt(1-5*a))*(p+1-sb.sqrt(1-5*a)) ; D_factorise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D.equals(D_factorise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$c)$ On pose : $\\displaystyle H_0=\\frac{G}{1+R_0\\,G}$, où $\\displaystyle R_0=\\frac{3}{20\\,p}$. Calculer $H_0$ sous forme factorisée puis décomposer $H_0$ en éléments simples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R_0 = 3/(20*p) ; H_0 = (G/(1+R_0*G)).factor() ; H_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H.replace(a,sb.S(3)/20).factor() # Variante introduisant la méthode replace présentée à l'exercice 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_0.apart(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$d)$ Essayer de décomposer $H$ en éléments simples, puis écrire **<span style=\"font-family:Courier New\">H.apart(p,full=True).doit()</span>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_factorise = N/D_factorise ; H_factorise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_factorise.apart(p) # Ne fonctionne pas, hélas..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dcp = H.apart(p,full=True).doit() ; dcp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Non demandé (<span style=\"color:#900000\">**hors programme**</span>, voir https://docs.sympy.org/latest/tutorial/manipulation.html) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operateur, termes = dcp.func, dcp.args ; operateur, termes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operateur(*[T.simplify() for T in termes]) # Reconstitution en simplifiant séparément chaque terme"
   ]
  },
  {
   "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
}