{
 "nbformat_minor": 0, 
 "nbformat": 4, 
 "cells": [
  {
   "source": [
    "$$\n", 
    "\\def\\CC{\\bf C}\n", 
    "\\def\\QQ{\\bf Q}\n", 
    "\\def\\RR{\\bf R}\n", 
    "\\def\\ZZ{\\bf Z}\n", 
    "\\def\\NN{\\bf N}\n", 
    "$$\n", 
    "# Calculatrice et arithm\u00e9tique avec SymPy\n", 
    "\n", 
    "[SymPy](http://www.sympy.org/) est une librairie Python de math\u00e9matiques symboliques et un outil de calcul formel. SymPy offre un ensemble riche de fonctions document\u00e9es qui facilite la mod\u00e9lisation de probl\u00e8mes math\u00e9matiques (arithm\u00e9tique, calcul symbolique, r\u00e9solution d'\u00e9quations, recherche de racines, dessin de fonctions, limites et s\u00e9ries, calcul diff\u00e9rentiel et int\u00e9gral, alg\u00e8bre lin\u00e9aire). La librairie offre aussi des fonctionalit\u00e9s de math\u00e9matiques plus avanc\u00e9es (g\u00e9om\u00e9trie diff\u00e9rentielle et alg\u00e9brique, int\u00e9gration num\u00e9rique, th\u00e9orie des cat\u00e9gories) et pour la physique (optique, m\u00e9canique classique, m\u00e9canique et informatique quantique).\n", 
    "\n", 
    "Le projet contient deux applications Web, [SymPy Gamma](http://gamma.sympy.org/) et [SymPy Live](http://live.sympy.org/), permettant aux \u00e9tudiants, enseignants et chercheurs d\u2019effectuer des exp\u00e9riences math\u00e9matiques en ligne. SymPy Gamma est une interface d\u2019apprentissage pour le calcul et la visualisation bas\u00e9e sur des exemples : alg\u00e9brique, g\u00e9om\u00e9trique, trigonom\u00e9trique et combinatoire. SymPy Live offre un terminal en ligne avec des fonctionnalit\u00e9s telle que l\u2019\u00e9criture des \u00e9quations en LaTeX, la manipulation symbolique avec le langage Python.\n", 
    "\n", 
    "Pour plus d'informations sur SymPy:\n", 
    "\n", 
    "> -   Tutoriel sur SymPy en fran\u00e7ais: <http://docs.sympy.org/dev-py3k/tutorial/tutorial.fr.html>\n", 
    "> -   Aper\u00e7u de fonctionalit\u00e9s de SymPy (anglais): <http://www.sympy.org/en/features.html>\n", 
    "> -   Documentation compl\u00e8te sur SymPy (anglais): <http://docs.sympy.org/>\n", 
    "\n", 
    "Les exemples dans les sections qui suivent sont parfois nouveaux sinon inspir\u00e9s de la documentation en ligne de SymPy."
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from __future__ import division, print_function  # Python 3"
   ], 
   "outputs": [], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Nombres rationels\n", 
    "\n", 
    "Les nombres rationnels en SymPy doivent \u00eatre construits \u00e0 l'aide de la fonction `Rational` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import Rational\n", 
    "Rational(53, 9)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "53/9"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "Rational(1,4) + Rational(1,3)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "7/12"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Une autre fa\u00e7on plus courte de construire un nombre rationnel en SymPy est d'utiliser la fonction raccourcie `S` qui traduit des types de Python comme une cha\u00eene de caract\u00e8res ou un entier en des nombres entiers ou rationnels de SymPy:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import S\n", 
    "S(\"5/2\")    # traduction d'une cha\u00eene de caract\u00e8res en un rationel"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "5/2"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "La division d'un nombre entier de sympy par un nombre entier retourne un nombre rationnel plut\u00f4t qu'un nombre \u00e0 virgule flottante:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "S(5)/2      # S(5) transforme 5 (type int) en un nombre entier de sympy"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "5/2"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Nombres complexes\n", 
    "\n", 
    "En SymPy, les nombres complexes s'\u00e9crivent avec la lettre majuscule `I` pour symboliser la partie imaginaire. Il faut d'abord l'importer:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import I"
   ], 
   "outputs": [], 
   "metadata": {}
  }, 
  {
   "source": [
    "Par exemple, le nombre complexe $2+5i$ s'\u00e9crit `2+5*I` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "2 + 5*I"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "2 + 5*I"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On v\u00e9rifie que le carr\u00e9 du nombre imaginaire `I` retourne bien `-1` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "I ** 2"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "-1"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Les op\u00e9rations de base sont d\u00e9finies sur les nombres complexes comme pour les nombres entiers et les nombres d\u00e9cimaux:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "(13 + 34*I) + (3 + 4*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "16 + 38*I"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "**NOTE**: Le r\u00e9sultat n'est pas toujours simplifi\u00e9. Pour ce faire, on peut utiliser la fonction `simplify` de SymPy:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "(13 + 34*I) / (3 + 4*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "(13 + 34*I)/(3 + 4*I)"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import simplify\n", 
    "simplify( (13 + 34*I) / (3 + 4*I) )"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "7 + 2*I"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "La division de nombre complexes entiers de partie imaginaire nulle retourne bien un nombre rationnel:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "(3+0*I) / (2+0*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "3/2"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Pour obtenir les parties r\u00e9elles et imaginaires d'un nombre complexe, on peut utiliser les fonctions `re` et `im` de SymPy:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import re,im\n", 
    "re(3 + 7*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "3"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "im(3 + 7*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "7"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Pour obtenir le module et l'argument d'un nombre complexe, on utilse les fonctions `arg` et `abs` de SymPy. Notez qu'il n'est pas n\u00e9cessaire d'importer `abs`, car cette fonction qui retourne la valeur absolue d'un nombre r\u00e9el est d\u00e9j\u00e0 dans Python et fonctionne pour les nombres complexes:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import arg\n", 
    "arg(3 + 7*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "atan(7/3)"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "abs(3 + 7*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "sqrt(58)"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Quand c'est possible, SymPy proc\u00e8de \u00e0 des simplifications:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "arg(1 + I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "pi/4"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "abs(3 + 4*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "5"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Le conjugu\u00e9 d'un nombre complexe s'obtient avec la fonction `conjugate` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import conjugate\n", 
    "conjugate(3 + 7*I)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "3 - 7*I"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On peut aussi obtenir le conjugu\u00e9 d'un nombre complexe en utilisant la m\u00e9thode `conjugate` de la fa\u00e7on suivante (une *m\u00e9thode* est une fonction d\u00e9finie dans la classe d'un objet, ici dans la classe des nombres complexes):"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "a = 3 + 7*I\n", 
    "a.conjugate()"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "3 - 7*I"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Utiliser la deuxi\u00e8me fa\u00e7on (m\u00e9thode `conjugate`) plut\u00f4t que la premi\u00e8re (fonction globale `conjugate`) permet d'\u00e9viter d'importer la fonction et aussi permet d'utiliser la touche `TAB` (dans IPython ou Jupyter) pour choisir ou compl\u00e9ter l'\u00e9criture du nom de la m\u00e9thode.\n", 
    "\n", 
    "## Calculer une valeur num\u00e9rique\n", 
    "\n", 
    "Calculer la valeur num\u00e9rique d'un `nombre` se fait avec la m\u00e9thode `evalf` ou de fa\u00e7on \u00e9quivalente `n` avec la syntaxe `nombre.n(prec)` o\u00f9 `prec` est le nombre de chiffres \u00e0 afficher:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import pi\n", 
    "pi.evalf(60)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "3.1415926535897932384626433832795028841971693993751"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "pi.n(60)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "3.1415926535897932384626433832795028841971693993751"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Le nombre de chiffres inclut les chiffres \u00e0 gauche et \u00e0 droite de la virgule:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import exp, pi, sqrt\n", 
    "exp(pi * sqrt(163)).evalf(50)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "262537412640768743.99999999999925007259719818568888"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Factoriser un nombre entier\n", 
    "\n", 
    "Pour factoriser un nombre entier, il suffit d'utiliser la fonction `factorint`. La valeur retourn\u00e9e est un dictionnaire qui associe \u00e0 chaque diviseur une valeur qui repr\u00e9sente la multiplicit\u00e9 du diviseur:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import factorint\n", 
    "factorint(240)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "{2: 4, 3: 1, 5: 1}"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Il est possible d'afficher un r\u00e9sultat plus visuel de la factorisation au moyen de la fonction `pprint` et de l'option `visual=True` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import pprint\n", 
    "pprint(factorint(240, visual=True))"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       " 4  1  1\n", 
       "2 \u22c53 \u22c55 "
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Acc\u00e9der \u00e0 la documentation et au code source d'une fonction\n", 
    "\n", 
    "Comme on l'a d\u00e9j\u00e0 vu, pour obtenir de l'aide sur une fonction `f`, il suffit d'\u00e9crire `?f` ou `f?`. Par exemple:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from sympy import Rational\n", 
    "Rational?"
   ], 
   "outputs": [], 
   "metadata": {}
  }, 
  {
   "source": [
    "Comme SymPy est un logiciel libre, on peut aussi acc\u00e9der au **code source** en ajoutant un deuxi\u00e8me point d'interrogation:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "Rational??"
   ], 
   "outputs": [], 
   "metadata": {}
  }
 ], 
 "metadata": {
  "kernelspec": {
   "display_name": "python2", 
   "name": "python2"
  }
 }
}