{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbsphinx": "hidden"
   },
   "source": [
    "[prev: *Data Types*](stdlib-data-types.ipynb) | [home](../index.ipynb) | [next: *File and Directory Access*](stdlib-file-directory.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Numeric tools*\n",
    "Ensemble de modules utiles au traitement numérique et mathématique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module *math*\n",
    "\n",
    "Comprend les fonctions mathématiques de base, et 2 flottants: *pi* et *e*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "148.4131591025766\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "# Exponentielle\n",
    "print(math.exp(5))\n",
    "print(math.exp(5) == math.exp(2)*math.exp(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.302585092994046\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# Log\n",
    "print(math.log(10))\n",
    "print(math.log(10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5773502691896257\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Trigonométrie\n",
    "t=math.tan(math.pi/6)\n",
    "print(t)\n",
    "print(math.atan(t) == math.pi/6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module *cmath*\n",
    "Etant le domaine de validité des fonctions du module *math* aux nombres complexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1j\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python admet un type de données 'complex'\n",
    "complex1 = complex(0.,1.)\n",
    "print(complex1)\n",
    "type(complex1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Un entier/flottant accompagné de la lettre 'j' est automatiquement interprété comme un nombre complexe\n",
    "complex2 = -5+18j\n",
    "type(complex2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-5.0\n",
      "18.0\n"
     ]
    }
   ],
   "source": [
    "# Les parties réelle et imaginaire sont accessibles séparément\n",
    "print(complex2.real)\n",
    "print(complex2.imag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-5+19j)\n",
      "(-18-5j)\n"
     ]
    }
   ],
   "source": [
    "# L'arithmétique de base est prise en charge nativement\n",
    "print(complex1 + complex2)\n",
    "print(complex1 * complex2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.5403023058681398+0.8414709848078965j)\n",
      "(2.9275359611012135+1.8417431771333173j)\n"
     ]
    }
   ],
   "source": [
    "# cmath permet de traiter les onctions complexes\n",
    "print(cmath.exp(complex1))\n",
    "print(cmath.log(complex2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module *random*\n",
    "\n",
    "Traite les nombres aléatoires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.13484883369952094, 0.9020293810800457, 0.7848925714114228, 0.19127230774902915, 0.8887251865365928]\n",
      "[-0.9301816284842389, 0.422877012978363, 0.8100489451767664, 0.512158683146731, -1.8614993820726016]\n"
     ]
    }
   ],
   "source": [
    "# Génère des flottants selon une certaines distribution statistique\n",
    "uniforme = [random.uniform(0,1) for i in range(5)]\n",
    "normale = [random.gauss(0,1) for i in range(5)]\n",
    "print(uniforme)\n",
    "print(normale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "['Python', 'Ruby', 'C++', 'Java']\n"
     ]
    }
   ],
   "source": [
    "# Traitement de séquences\n",
    "echantillon = ['Python','C++','Java','Ruby']\n",
    "print(random.choice(echantillon))\n",
    "random.shuffle(echantillon)\n",
    "print(echantillon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}