{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c4331c00-5ffe-4430-a558-29c39b04fd6e",
   "metadata": {},
   "source": [
    "Notebook Jupyter      UTC MT12 \n",
    "$$  \\text{UTC MT12} \\quad \\quad  \\text{TP} 1 $$\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6d9e633-0c32-47ff-980a-db17e5c9dc3b",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "Ce document est un exemple de notebook jupyter; il liste des éléments de base qui permettent de manipuler les outils en python pour aller vers plus de subtilités afin que vous soyez préparés pour les TPs suivants.\n",
    "\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a01159c-ec9a-4260-8541-a7a800aaf82c",
   "metadata": {},
   "source": [
    "L’objectif de ce TP est de se familiariser avec le notebook Jupyter, les éléments de base et quelques fonctions mathématiques en python\n",
    "\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98cb5903-ef1a-499b-bbbc-664619383e0e",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "\n",
    "[1. Notebook Jupyter : différentes cellules et commandes magiques](#1.-Notebook-Jupyter-:-différentes-cellules-et-commandes-magiques)\n",
    "\n",
    "[2. Eléments de base de python](#2.-Eléments-de-base-de-python)\n",
    "\n",
    "[3. Graphes de fonctions réelles à valeurs réelles](#3.-Graphes-de-fonctions-réelles-à-valeurs-réelles)\n",
    "\n",
    "[4. Mesure du temps d’exécution d’un programme, calcul mathématiques, vecteurs, itération](#4.-Mesure-du-temps-d-execution-d-un-programme-,-calcul-mathématiques-,-vecteurs-,-itération)\n",
    "\n",
    "[5. Fonctions définies par morceaux](#5.-Fonctions-définies-par-morceaux)\n",
    "\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98c9701c-622f-45eb-8af2-9277558c0938",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# 1. Notebook Jupyter : différentes cellules et commandes magiques\n",
    "\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b3db839d-1d9d-4405-8cc2-6a155a820912",
   "metadata": {},
   "source": [
    "1.0. Cellules `raw`\n",
    "Cette cellule est une cellule Raw"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "148c83f4-d70a-461e-b414-668f9ddf509f",
   "metadata": {},
   "source": [
    "## 1.1 Cellules Markdown \n",
    "\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5036be2-ebe3-4e3e-a574-2540f0c664a9",
   "metadata": {},
   "source": [
    "1. Hello\n",
    "2. *Italic Hello*\n",
    "3. `verbatim Hello`\n",
    "4. **Bold Hello**\n",
    "\n",
    "* listes avec indentations\n",
    "    *  sous-listes\n",
    "        * sous-sous-listes\n",
    "\n",
    "## 1.2. Sous-titre\n",
    "### 1.2.1 Sous-sous-titre\n",
    "#### etc ....\n",
    " \n",
    "Une image :\n",
    "\n",
    "##### un simple copier coller d'une image retourne l'image telle que définie dans le fichier source\n",
    "<img src=\"mandrill.bmp\"/>\n",
    "\n",
    "\n",
    "##### dimensions de l'image réduites, à gauche \n",
    "<img src=\"mandrill.bmp\" width=30% height=30% /> \n",
    "\n",
    "\n",
    "##### dimensions de l'image réduites, centrée \n",
    "<img src=\"mandrill.bmp\" width=30% height=30% style=\"margin:auto\" />\n",
    "\n",
    "##### dimensions de l'image réduites, à droite \n",
    "<div style=\"text-align: right;\">\n",
    "<img src=\"mandrill.bmp\" width=30% height=30% />\n",
    "</div>\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9c19810-9e22-4d74-8166-bce24b4694b8",
   "metadata": {},
   "source": [
    "Une partie de $\\LaTeX$ est dans `Jupyterlab` :\n",
    "\n",
    "$$\n",
    "\\left\\{\n",
    "\\begin{aligned}\n",
    "\\dfrac{d\\mathbf{x}(t)}{dt} & =  -\\,A\\, \\mathbf{x}(t),\\quad t>0, \\\\[2ex]\n",
    "\\mathbf{x}(0)&  =  \\mathbf{x}_0\n",
    "\\end{aligned}\\right.\n",
    "$$\n",
    "\n",
    "\n",
    "$$\n",
    "\\text{avec} \\quad A = \\begin{pmatrix}\n",
    "2 & -1 & 0 \\\\\n",
    "-1 & 2 & -1 \\\\\n",
    "0 & -1 & 2\n",
    "\\end{pmatrix}.\n",
    "$$\n",
    "\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e97154b3-b192-4fe1-974e-7813e4dd6df3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## 1.3. Cellules `python`\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b3266ee9-3d8a-4673-a1b9-3f998eab0e3b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Cette cellule est une cellule python : commentaires après un \n",
    "# De manière générale, Python ignore tout ce qui, sur une ligne, suit la commande #\n",
    "# type de cellule par défaut "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9a04ff33-8308-4ea3-8bd5-a36224429d2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"Module\" ou \"library\" (contient des fonctions prédéfinies) \n",
    "## \"numpy\" (tableaux, vecteurs, matrices)\n",
    "## \"math\" (fonctions et nombres)\n",
    "## \"cmath\" (complexe)\n",
    "## \"scipy\" (calcul matriciel)\n",
    "## \"matpotlib\" (graphiques) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a91e1ee-c919-4c77-835e-4529e015b49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "today = date.today()\n",
    "print(\"Date : \", today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa205c5a-6bc3-413e-a6bf-09efe8e72120",
   "metadata": {},
   "outputs": [],
   "source": [
    "date.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04b822db-6ac6-48a0-99fc-032f87b8dfe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np  # import du module \"numpy\" \n",
    "np.pi # appel du  réel \"pi\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d53bd5b2-9e34-4ede-a2be-461f8b45dc8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "pi=np.pi # la valeur de \"pi\" ne s'affiche pas \n",
    "print('pi=', pi) # affiche la variable et sa valeur "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff8c5e8a-8fd9-4438-bf1f-928cd6a71ef2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## 1.4. Commandes magiques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08c97fc7-da3d-47a6-91ad-963ea00c7d24",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "%pwd   #retourne le répertoire courant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b7a9996-84b8-462b-893d-1a8fbf508d43",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "%ls "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80444db8-95c5-4b3f-92c5-02e32987d43f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "%run PrintBienvenue.py\n",
    "# execute un fichier python qui se trouve à l'extérieur \n",
    "# du notebook mais de la répertoire courant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86ff5b52-46b5-4e2f-bb96-a974945cda96",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "%whos "
   ]
  },
  {
   "cell_type": "raw",
   "id": "67b194a1-49b2-4318-91eb-546fa0fbd88b",
   "metadata": {
    "collapsed": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Cette cellule est une cellule Raw\n",
    "MAIS la commande \"%magic\" dans une cellule pyton liste toutes les commandes magiques \n",
    "possibles ! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7dcfa44-4637-4283-aac3-39ac8f2d3022",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# 2. Eléments de base de python\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f8ad957-a768-4b41-9c10-cb05cf941109",
   "metadata": {},
   "source": [
    "## 2.1. Vecteurs, matrices, booléens et boucles\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aba3b2a7-5c66-457f-8b6a-427500808ee9",
   "metadata": {},
   "source": [
    "### Attention en python, les indices commencent en \"0\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5c21b70-3955-4fcd-b998-402d03195c98",
   "metadata": {},
   "source": [
    "### 2.1.1. Vecteurs, matrices et listes\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e535c5-c9ae-46e5-ba96-cec7d709b20f",
   "metadata": {},
   "source": [
    "#### Vecteurs et matrices "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82e26a90-eb83-4344-b07f-396ae7321a0a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#### Matrices pré-définies \n",
    "import numpy as np\n",
    "M1=np.eye(3) #matrice identité de taille 3\n",
    "M11=np.ones((2,3))  #matrice 1 de taille 2×3\n",
    "M0=np.zeros((2,3)) # matrice nulle de taille 2×3\n",
    "MV=np.empty((2,3)) # matrcie vide de taille 2x3 \n",
    "print(M1)\n",
    "print(M11)\n",
    "print(M0)\n",
    "print(MV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a694227-2758-4639-80b8-e93498dd783f",
   "metadata": {},
   "outputs": [],
   "source": [
    "N1=np.arange(1, 6, 2)  # np.arange(debut, fin(non inclus), pas) suites entiers \n",
    "N2=np.linspace(0, 100, 50) # suite de  50 points entre 0 et 100 espacement régulier\n",
    "N3=np.diag(N1) # matrice diagonale à partir d'un vecteur \n",
    "N3.reshape([1,9])\n",
    "print(N3.reshape([1,9])) # re-dimensionne la matrice N3 \n",
    "print(N3.shape) # dimension de la matrice N3\n",
    "print(N1)\n",
    "print(N2)\n",
    "print(N3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a37688d-deef-4a08-aec1-37d17a2dcede",
   "metadata": {},
   "outputs": [],
   "source": [
    "## quelques opérations prédéifnies sur les matrices \n",
    "np.sum(N3)  # somme tous les éléments de N3 (IDEM AVEC 'MEAN')\n",
    "np.sum(N3,axis=0)  # somme tous les éléments de N3 par ligne (IDEM AVEC 'MEAN')\n",
    "np.sum(N3,axis=1) # somme tous les éléments de N3 par colonne   (IDEM AVEC 'MEAN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f96f8abb-b989-4de1-8bc9-4658b1020db7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### écriture de matrice, vecteur\n",
    "u = np.array([1, 2, 3], dtype=np.float64) # vecteur déclaration du type !\n",
    "v = np.array([-1, 0, 1], dtype=np.float64)\n",
    "w = np.outer(u,v) # produit tensoriel de deux vecteurs\n",
    "W= np.array([[-1,0,1],[-2,0,2],[-3,0,3]],dtype=np.float64) # matrice \n",
    "print('u=',u)\n",
    "print('w = \\n', w) # retour à la ligne pour l'écriture de la matrice\n",
    "np.save('w',w) # sauve la variable \"w\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0eff38f-9ccc-4761-9772-2d9721e1a1b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "w.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "908e8a56-7813-4441-9d8b-ab839954cf88",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "%pinfo w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4995e30a-00f8-415d-b53c-c3804d559486",
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrice et sa transposée\n",
    "t = np.transpose(W) # transposée de W\n",
    "tt= W.T # transposée de W\n",
    "print('t=',t)\n",
    "print('tt=',tt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac0e6550-7ccd-4d99-91a9-5350d9c274c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1, 2, 3]) # pas de déclaration de type \n",
    "y = np.array([-1, 0, 1])\n",
    "z= np.outer(x,y) # produit externe \n",
    "print('z = \\n', z)\n",
    "np.save('z',z) # sauve la variable \"z\" \n",
    "z.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d923b3f5-cdaf-4cea-899c-d4986c6c11e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "z*=0.5  # Attention message d'erreur \n",
    "print('z:',z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e5fc441-ab9a-4a74-82a2-4407530a2389",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Opérations simples sur un vecteur \n",
    "a = np.array([1, 2, 3, 4],dtype=np.float64)\n",
    "a1=a[-1] # dernier élément de a # [] est un masque qui filtre  \n",
    "a2=a[:-1] #supprime le dernier élément de a \n",
    "b=a+1.5\n",
    "c=a*(-2.5)\n",
    "c_abs=np.abs(c) #opérations pré-définies comme np.log, np.sin,... \n",
    "c_exp=np.exp(a) \n",
    "d=b+c\n",
    "e=b**4 #puissance 4\n",
    "f=a%2 # reste de la division Euclidienne de 'a' par '2' (chaque composante)\n",
    "x,y=2025,2026\n",
    "print('x,y=',x,y)\n",
    "x,y=y,x\n",
    "print('x,y=',x,y)\n",
    "print('a=',a)\n",
    "print('b=',b)\n",
    "print('c=',c)\n",
    "print('d=',d)\n",
    "print('e=',e)\n",
    "print('f=',f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b810bafb-710b-48f3-90f5-d78e6df2e043",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Produit matriciel/ produit terme à terme matrice\n",
    "C=np.array([[1, 2, 3],[10.4,5.6, 4]],dtype=np.float64)\n",
    "D=np.ones((3,2))\n",
    "E=C.dot(D) #produit matriciel \n",
    "F=C*D.T # produit termes à termes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f2e3fe0-cfd4-49b4-a84b-8eecf243f26f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Opérations  et actualisation : ATTENTION \n",
    "print('a_previous=',a)\n",
    "g=a\n",
    "g+=2 # ATTENTION actualise la valeur de e et de a --> a+2 (idem pour \"*\",\"/\",\"-\")\n",
    "print('a_after=',a)\n",
    "print('g=',g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbb61e11-239b-4d3b-835a-e5d04493dcde",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(b)\n",
    "b=np.insert(b, 3, 6) #insère \"6\" à la position '3' du vecteur b\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c94fe41-4f98-4ec2-8ed5-7fae8566f967",
   "metadata": {},
   "source": [
    "#### Nombres aléatoires "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "930adb8b-deb4-4237-a4ab-71e245199c5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Importer le module loi de probabilités \n",
    "import numpy.random as rd #loi de proba\n",
    "X=rd.randn(2,3) # réalisations  de variable aléatoire Gaussienne standard\n",
    "Y=rd.random(5) # réalisations de variable aléatoire uniforme sur [0,1]\n",
    "print('X=',X)\n",
    "print('Y',Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b575171-665f-417c-86bf-f5cd389a5b07",
   "metadata": {},
   "source": [
    "#### Liste "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a9612311-9f95-46c4-973b-7219db13600a",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste=[2026,'Printemps','MT12']\n",
    "correction=[2027,'Automne','MT12']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfcd332e-bd2d-4af1-b631-bc8579a52e73",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(liste)) # taille de la liste\n",
    "print(liste[0]) #premier élément de 'liste'\n",
    "liste.append('TP') # ajoute un élément à 'liste'\n",
    "print(liste) \n",
    "print(liste[-1]) #dernier élement de la liste\n",
    "print(liste[3]) #dernier élément de la liste\n",
    "liste[1:3] # [start:stop] extrait tous les éléments en \"start' et \"stop-1\"\n",
    "liste.insert(1,\"mars\") # insère l'élément \"mars\" en position 1 \n",
    "print(liste)\n",
    "liste.remove('TP') #supprime l'élément 'TP'\n",
    "print(liste)\n",
    "liste.extend(correction)\n",
    "print(liste)\n",
    "A=set(liste) #supprime tous les doublons de la liste \n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f81b9e4-aca3-4166-922f-94b63b53b908",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaaa41a4-affb-4ce9-9069-b3281a05a99c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#range(start, stop[, step]) \n",
    "R=list(range(5)) #liste tous les entiers de start à (stop-1) \n",
    "print(R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28b1a887-03de-49c0-9c49-472289b72d13",
   "metadata": {},
   "outputs": [],
   "source": [
    "L=[x**2 for x in range(3)] #créé une liste \n",
    "print(L)\n",
    "type(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5b5bf88-ecb9-49d9-a911-98c200318cb0",
   "metadata": {},
   "source": [
    "### 2.1.2. Opérations logiques et Booléens\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f919dec-14e3-464f-91bc-1b7f889a832d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a==e #égalité (composante par composante) \n",
    "a!=d # différent\n",
    "a >= d # relation d'ordre  (composante par composante) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a44fd57-eca8-4e56-87d8-62d9a96a77fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Masque pour sélectionner\n",
    "print('a=',a)\n",
    "a[a>=2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "148583c6-0f1b-47bb-9ee4-73a07fd984c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "nombres=np.arange(0,33)\n",
    "div_par_3 = all(num % 3 == 0 for num in nombres) #booléen=1 si tous sont div par 3\n",
    "au_moins_un_div_par_3 = any(num % 3 == 0 for num in nombres)# booléen=1 si au moins un est div par 3\n",
    "print(nombres)\n",
    "print(div_par_3)\n",
    "print(au_moins_un_div_par_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0ae89d9-e994-47a0-8407-87b84125a7ea",
   "metadata": {},
   "source": [
    "### 2.1.3. Boucles\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "914690f4-1986-440f-978a-75870ae76818",
   "metadata": {},
   "source": [
    "#### if else ou if elif ..elif.. else\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7b899b4-d90d-44b4-9d08-c84e856403e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "## fonction if  : l'indentation indique la fin d'une boucle\n",
    "if all(x>3 for x in a): \n",
    "    h = b+2 \n",
    "else: \n",
    "    h= a +2\n",
    "print('b=',b)\n",
    "print('a=',a)\n",
    "print('h=',h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a4d1b8c-7760-4cd7-b7a9-7f10b09ae848",
   "metadata": {},
   "source": [
    "#### while\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83e11947-8440-4f18-b9d7-87f463d69cbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "## fonction  while : l'indentation  indique la fin d'une boucle\n",
    "x,ztemp=0,0\n",
    "while (x in np.arange(0,5)):\n",
    "    zz=ztemp +x\n",
    "    ztemp=zz\n",
    "    x+=1  \n",
    "print(ztemp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ba3bcd6-154d-431d-b80b-b814c9669174",
   "metadata": {},
   "source": [
    "#### for\n",
    "###### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0c462c0-842e-4588-8b95-eb8aa67e010a",
   "metadata": {},
   "outputs": [],
   "source": [
    "## fonction  for : l'indentation indique la fin d'une boucle \n",
    "for i in range(4):\n",
    "    print('i_ordre_croissant',i)\n",
    "for i in range(4)[::-1]:\n",
    "    print('i_ordre_decroissant:',i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "076af7a2-9113-4751-a277-acc8e4ce6297",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Booléens \n",
    "nombres = np.array([1, 3, 5, 7, 9],dtype=np.float64)\n",
    "tous_impairs = all(num % 2 == 1 for num in nombres)\n",
    "au_moins_un_pair = any(num % 2 == 0 for num in nombres)\n",
    "sup_cinq_boo=(nombres > 5)  # booléen \n",
    "sup_cinq=nombres[nombres > 5] # extraction des composantes qui satisfont une condition\n",
    "print(\"tous_impairs:\",tous_impairs)\n",
    "print(\"au_moins_un_pair:\",au_moins_un_pair)\n",
    "print(\"booléen supérieur à 5:\",sup_cinq_boo)\n",
    "print(\"supérieur à 5:\",sup_cinq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0486c0b-97a5-43c9-8591-dc6ccee5aa92",
   "metadata": {},
   "source": [
    "## 2.2. Fonctions\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5268f829-72b2-47bc-bca1-df2d3bce03a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "## exemple de fonction\n",
    "def SOMME (a, b):\n",
    "    \"\"\" Additionne deux réels\n",
    "    \"\"\"\n",
    "    # CE QUI EST ENTRE \"\"\"DOCUMENTATION DE LA FONCTION \"\"\" \n",
    "    c= a+b\n",
    "    return c  #c'est la commande 'return BIDULE\" qui met fin à la fonction et retourne BIDULE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d8445ec-9a53-46da-bfd2-3a36ffcaf7fc",
   "metadata": {},
   "source": [
    "## 2.3. Questions \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af0aa814-b113-473b-b8d6-1b1900a2f871",
   "metadata": {},
   "source": [
    "### Q1 Ecrire une fonction qui retourne la somme et la différence entre deux réels\n",
    "Cette cellule est une cellule Markdown¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a8be981-d556-428f-94b9-b97be607e3cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "import numpy as np\n",
    "def OPERATION (a, b):\n",
    "    \"\"\" Addition et Différence de deux réels\n",
    "    \"\"\" \n",
    "    c= a+bimport numpy as np \n",
    "Ope = lambda a,b:[a+b,a-b]\n",
    "    d= a-b\n",
    "    return [c,d]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "906af5d5-4e81-4804-a2df-63d3ce229eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "OPERATION1 = lambda a,b:[a+b,a-b] #fonction alternative à la précédente "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e52ad9-632d-4aed-a1b3-976acc970a21",
   "metadata": {},
   "source": [
    "### Q2 Ecrire un code qui à partir d'une boucle for calcule \"factoriel 6\"\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4434468-57a2-4932-a6c5-da17b8c2b466",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "import numpy as np\n",
    "a= np.arange(7).reshape(1, 7) # crée le vecteur des 7 premiers entiers de dimension 7 \n",
    "aa=np.delete(a, 0) # on enlève la valeur '0' situé sur le premier indice de \"a_alt_1\"\n",
    "n=aa.size-1\n",
    "a_fact=aa[n] # opération factoriel \n",
    "for i in range(n)[::-1]:\n",
    "    a_fact*=aa[i]\n",
    "print(\"a_fact=\",a_fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38ac9ad7-f8d7-4e4f-8068-7dd2893146d3",
   "metadata": {},
   "source": [
    "# 3. Graphes de fonctions réelles à valeurs réelles\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "076a6583-9948-4768-a3f6-2f97ce70a7f9",
   "metadata": {},
   "source": [
    "### 3.1 Affichage "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "291c2a6e-a257-4040-974a-ffbeeb36c892",
   "metadata": {},
   "source": [
    "#### Pour afficher une fonction, il faut préalablement importer le sous module \"pyplot\" du module \"matplotlib\"\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df7ac4a-c48d-44df-8535-8c95a490a3c2",
   "metadata": {},
   "source": [
    "#### Affichage de la fonction exponentielle sur l'intervalle $[-1,1]$, son DL en $0$ à l'ordre 1 et à l'ordre 2 et le calcul d’erreur d'approximation\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bb00017d-333d-4c57-9c78-081d1b89541f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3490cfcb-230d-494c-a2e3-c906e1831a73",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Exemple du tracé des  fonctions cos et sin  sur [-pi, pi] \n",
    "t=np.linspace(-np.pi, np.pi,50)\n",
    "z_cos=np.cos(t)\n",
    "z_sin=np.sin(t)\n",
    "plt.figure(1)\n",
    "plt.subplot(211)\n",
    "plt.plot(t, z_cos,'-r',linewidth = 3,label='cos')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.subplot(212)\n",
    "plt.plot(t,z_sin,'.-.b',linewidth = 3,label='sin')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c3b1e6-8728-4a15-beb1-cbd49c0297f5",
   "metadata": {},
   "source": [
    "### 3.2 Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c625d80f-66b0-4d6d-b17c-d0be88b4c4b2",
   "metadata": {},
   "source": [
    "#### Q3 Afficher  la fonction exponentielle et son dl \n",
    "* Créer un vecteur $X$ qui contient  $100$ réels uniformément répartis entre $-1$ et $1$\n",
    "*  Créer un vecteur $Y$ image de $X$ par la fonction exponentielle\n",
    "*  Créer un vecteur $Z1$ image de $X$ par le dl en $0$ de la fonction exponentielle à l'ordre 1\n",
    "*    Créer un vecteur $Z2$ image de $X$ par le dl en $0$ de la fonction exponentielle à l'ordre 2\n",
    "* Afficher le graphe de la fonction exponentielle en utilisant la commande \"plt.plot(abscisses,ordonnées)\n",
    "    * Vous pouvez améliorer l'affichage en précisant le type des points, la couleur du graphe, la taille du trait, ajouter un titre, ...\n",
    "* Ajouter au graphe existant le graphe du dl d'ordre 1 et d'ordre 2 de la fonction exponentielle\n",
    "* Dans une autre cellule, afficher les erreurs d'approximation des développements limités de l'exponentielle\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a741754-f5e3-49ea-b611-1ad9838647bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 100\n",
    "X = np.linspace(-1, 1, N)\n",
    "Y= np.exp(X) \n",
    "Z1=1+X\n",
    "# Z2=1+X + (X**2)/2 # carré de X \n",
    "Z2=1+X + np.square(X)/2 # ecriture alternative \n",
    "#plt.plot(X, Y, '.-r', linewidth = 3, alpha=0.3,label='exp')\n",
    "#plt.plot(X, Z1, '.-b', linewidth = 3, alpha=0.3,label='dl 1')\n",
    "#plt.plot(X, Z2, '.-g', linewidth = 3, alpha=0.3,label='dl 2')\n",
    "plt.plot(X, Y, '.-r', linewidth = 3,label='exp')\n",
    "plt.plot(X, Z1, '.-b', linewidth = 3,label='dl 1')\n",
    "plt.plot(X, Z2, '.-g', linewidth = 3,label='dl 2')\n",
    "plt.title(\"$f(x)=exp (x)$ et des dl en 0 à l'odre 1 et 2\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.legend()\n",
    "plt.show()\n",
    "#plt.axis('equal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4801511-d1ff-44fc-9f3c-f968fc32905e",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(X, abs(Y-Z1), '.-b', linewidth = 3,label='dl 1')\n",
    "plt.plot(X, abs(Y-Z2), '.-g', linewidth = 3,label='dl 2')\n",
    "plt.title(\"Erreur d'approximation des dl de l'exponentielle en 0 à l'odre 1 et 2\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "220cf4be-6ec6-4fd9-97f8-43827165d54d",
   "metadata": {},
   "source": [
    "#### Q4 Disposer les deux précédents graphiques sur une même fenêtre graphique \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15c926e3-c1f7-4d22-ade8-b92cb672ff8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 100\n",
    "X = np.linspace(-1, 1, N)\n",
    "Y= np.exp(X) \n",
    "Z1=1+X\n",
    "# Z2=1+X + (X**2)/2 # carré de X \n",
    "Z2=1+X + np.square(X)/2 # ecriture alternative \n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(X, Y, '.-r', linewidth = 3,label='exp')\n",
    "plt.plot(X, Z1, '.-b', linewidth = 3,label='dl 1')\n",
    "plt.plot(X, Z2, '.-g', linewidth = 3,label='dl 2')\n",
    "plt.title(\"$f(x)=exp (x)$ et des dl en 0 à l'odre 1 et 2\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(X, abs(Y-Z1), '.-b', linewidth = 3,label='dl 1')\n",
    "plt.plot(X, abs(Y-Z2), '.-g', linewidth = 3,label='dl 2')\n",
    "plt.title(\"Erreur d'approximation des dl de l'exponentielle en 0 à l'odre 1 et 2\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()      # Sans cette ligne, il y a des chevauchements dans les étiquettes\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f01eff-aa8d-4fc3-a97a-354ed8380e13",
   "metadata": {},
   "source": [
    "# 4. Mesure du temps d’exécution d’un programme, calculs mathématiques, vecteurs, itération\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29bbcf7b-387b-4bf8-b7ff-6db2795ebf2c",
   "metadata": {},
   "source": [
    "#### La commande \"%time calcul\"  permet de déterminer le temps d'exécution de calcul \n",
    "\n",
    "##### Cette cellule est une cellule Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69971d6e-f75f-4de0-bbfd-4cdff1b623a9",
   "metadata": {},
   "source": [
    "#### Dans les 4 exemples suivants, on s'intéresse à comparer le temps d'exécution de deux fonctions qui produisent le même résultat : l'une des deux fonctions dépend d'une boucle \"for\" et l'autre s'en affranchit. \n",
    "* L'idée est d'éviter l'utilisation de \"boucle\"  quand cela est possible.\n",
    " \n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "295aaaaa-333e-4e62-979d-c3e9e76eaa90",
   "metadata": {},
   "source": [
    "## 4.1. Questions \"Produit scalaire\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "939dd669-d4e8-42b9-8013-25f7c118dccd",
   "metadata": {},
   "source": [
    "#### On rappelle que le produit scalaire (canonique) de deux vecteurs $X = (x_1, x_2,\\ldots,x_n)$ et $Y = (y_1, y_2, \\ldots,y_n)$ de $\\mathbb{R}^n$ est calculé comme : $$ < X, Y >= X \\cdot Y^{\\intercal}= x_1 \\cdot y_1 + x_2 \\cdot y_2 +\\cdot + x_n \\cdot y_n$$\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dce1592e-4827-4e45-b51d-a8a2c6941dbe",
   "metadata": {},
   "source": [
    "#### Q5 Proposer une fonction scalaire(a, b) qui calcule le produit scalaire de deux vecteurs sans utiliser de boucle for\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfb19fe4-83c7-49a2-ac20-8e5d582c7ffa",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "import numpy as np\n",
    "import numpy.random as rd #loi de proba\n",
    "def scalaire (a, b):\n",
    "    return(np.sum(a*b))\n",
    "    #d=a@b #produit scalaire\n",
    "a =rd.randn(4)\n",
    "b =rd.randn(4)\n",
    "print('scalaire(a,b)=',scalaire(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "403d4496-8349-4c94-ab33-f34c30287d97",
   "metadata": {},
   "source": [
    "#### Q6 Proposer une fonction scalaire1(a, b) qui calcule le produit scalaire de deux vecteurs en utilisant une boucle for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ffa664a-16ed-4e04-86db-b93316b58b9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scalaire1 (a, b):\n",
    "    c=0\n",
    "    for i in range(len(a)): \n",
    "        c=(a[i]*b[i])+c\n",
    "    return c\n",
    "a =rd.randn(2)\n",
    "b =rd.randn(2)\n",
    "\n",
    "print(scalaire1(a,b))\n",
    "print(scalaire(a,b))\n",
    "print([a,b])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180e5972-e9ff-415c-bcd0-d0667ce8609f",
   "metadata": {},
   "source": [
    "#### Q7\n",
    "* Comparer le temps d'exécution des fonctions scalaire et scalaire1 pour des vecteurs de taille $n=4000$\n",
    "\n",
    "* Proposer une nouvelle fonction orthogonal(vect1, vect2) qui prend deux vecteurs de même dimension et retourne True si ils sont orthogonaux, False sinon.\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66c7483e-7056-4026-8224-adf8ce2e5fd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=4000\n",
    "a =rd.randn(n)\n",
    "b =rd.randn(n)\n",
    "\n",
    "%time scalaire(a, b);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b947cd9-0a2d-4de6-8c6b-d9d470807414",
   "metadata": {},
   "outputs": [],
   "source": [
    "time(scalaire(a,b)) ; #commande alternative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9819bcf-f4d2-4dcb-a90a-acb1dd0e9e51",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time scalaire1(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ba70811-8bfb-473c-a3f3-6fa90cf49a57",
   "metadata": {},
   "outputs": [],
   "source": [
    "time(scalaire1(a,b)) ;  #commande alternative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "036b8b9a-63ea-4767-9b59-59daaa1e4982",
   "metadata": {},
   "outputs": [],
   "source": [
    "def orthogonal (a, b):\n",
    "    d=a@b\n",
    "    e=(d == 0)\n",
    "    return e\n",
    "a =rd.randn(4)\n",
    "b =rd.randn(4)\n",
    "print('orthogonal(a,b)=',orthogonal(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22259b7e-4633-4a63-ab6d-707f6fad90a0",
   "metadata": {},
   "source": [
    "## 4.2. Questions \"Série des inverses des carrés\"\n",
    "* Série qui converge vers $\\frac{\\pi^2}{6}$\n",
    "* Pour cela on se propose d’afficher les milles premiers termes de la série des inverses des carrés"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1513da7d-857c-4c3e-904a-be7b0f355b44",
   "metadata": {},
   "source": [
    "#### Q8\n",
    "* On considère la suite  $\\frac{1}{1^2}, \\frac{1}{2^2},\\ldots,\\frac{1}{n^2},\\ldots$ qui peut être définie à partir d'opérations élémentaire sur les éléments de la suite $1,2,\\ldots,n$\n",
    "* Proposer une fonction \"suite(n)\" qui crée un tableau contenant les $n$ premiers éléments de la suite en utilisant un vecteur de taille $n$ sans utiliser de boucle \"for\"\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6c2c6f8a-4922-4a64-b681-43f48aba2a8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #si jamais le module n'a pas été importé\n",
    "def suite (n):\n",
    "    return (1/(np.arange(1,n+1)**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3c1da9a-e046-4c3e-975a-b3ed64eda4fd",
   "metadata": {},
   "source": [
    "#### Q9 Proposer une fonction serie(n) qui somme les $n$ premiers éléments de la suite précédente \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1a52dd3-0425-4387-b3b5-a951f5bbfb60",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def serie (n):\n",
    "    return np.sum(suite(n))\n",
    "  \n",
    "serie(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5836400c-be00-4654-b5d5-518206002c51",
   "metadata": {},
   "source": [
    "#### Q10 Proposer une autre fonction serie1(n) qui somme les $n$ premiers éléments de la suite précédente à partir d'une boucle for\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d125a22-f07b-46c6-a971-4ebd69ad7708",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def serie2 (n):\n",
    "    W=suite(n)\n",
    "    S=0\n",
    "    for i in range(n):\n",
    "        S=W[i]+S\n",
    "    return S\n",
    "serie2(5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "126f3e0c-e8a8-46ea-9402-c831f927632e",
   "metadata": {},
   "source": [
    "#### Q11 Proposez un code qui permet de comparer les temps d’exécution de vos deux fonctions serie(1000) et serie1(1000). \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0469465-1feb-4e7e-a593-c5f08db0d0b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time serie(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8886ed7c-62c7-463c-90b0-05e9ef24ed79",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time serie2(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f516e51-5f5c-4a56-82a4-9baa358e3345",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.pi**2/6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48e652d4-b5b1-4993-a593-7cadac871f22",
   "metadata": {},
   "source": [
    "## 4.3. Question \"Médiane d'une suite de valeurs réelles\" \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c015e2-2af3-4242-871d-5e209aedea54",
   "metadata": {},
   "source": [
    "#### Q12\n",
    "* Proposer deux fonctions (l'une avec boucle for l'autre sans boucle for) qui prend en argument un vecteur/tableau et renvoie deux vecteurs/tableaux, l'un contenant toutes les valeurs en dessous de la médiane et l'autre contenant toutes les valeurs au dessus de la médiane. Importer la library \"statistics\" pour obtenir la médiane d'un tableau à partir de la commande statistics.median\n",
    "* Comparer le temps d'exécution de vos deux fonctions\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "57f53bb7-1fa8-40fa-b0d4-5e5699d780a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numpy.random as rd #loi de proba\n",
    "import statistics as sta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93cfa4ab-b812-416c-9d52-c47a0cf0e4f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "## la commande qui permet de déterminer la médiane d'une suite de valeurs\n",
    "Ta=rd.randn(5)\n",
    "print([Ta,sta.median(Ta)])\n",
    "Ta[Ta<=sta.median(Ta)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "eaab1249-c167-4811-987a-b6e15a2b8185",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mediane (T):\n",
    "    \"\"\" sorties deux vecteurs : valeurs < médiane et valeurs > mediane \n",
    "    \"\"\"\n",
    "    c= sta.median(T)\n",
    "    d_inf=[]\n",
    "    d_sup=[]\n",
    "    for i in range(len(T)): \n",
    "        d_inf=np.append(d_inf,T[i]*(T[i]<=sta.median(T)))\n",
    "        d_sup=np.append(d_sup,T[i]*(T[i]>sta.median(T))) \n",
    "    return[d_inf,d_sup]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ed268218-9631-4486-8395-84b4b1f39e7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def mediane1 (T):\n",
    "    \"\"\" sorties deux  vecteurs: valeurs < médiane et valeurs > mediane \n",
    "    \"\"\"\n",
    "    c= sta.median(T)\n",
    "    Tab=Ta[Ta<sta.median(Ta)]\n",
    "    Tau=Ta[Ta>sta.median(Ta)]\n",
    "    return[Tab,Tau]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1113b28-cea7-424b-9016-62d973b5f380",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# comparaison des  temps d'exécution \n",
    "Ta=rd.randn(1000)\n",
    "%time Res=mediane(Ta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bff73a7c-0a7b-499c-b782-2236fd28f25a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# comparaison des  temps d'exécution \n",
    "%time Res1=mediane1(Ta)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4e1ef1b-40b3-48f6-90df-06b8a1bfbfd4",
   "metadata": {},
   "source": [
    "## 4.4. Questions \"Approximation des dérivées\" \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe04151a-284d-4964-aa54-a600499c509c",
   "metadata": {},
   "source": [
    "#### Q13 Soient deux vecteurs $X$ et $Y$ tels que  $Y=f(X)$ pour $f$ une fonction connue. \n",
    "\n",
    "* Proposer une fonction \"deriv\", qui prend en entrée les vecteur $(X,Y)$ et renvoie un vecteur contenant une approximation de la dérivée définie comme $f'(X_n) = \\frac{f(X_{n+1} )−f (X_n )}{X_{n+1}−X_{n}}$ en utilisant une boucle for.\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4d828834-4fc6-4ec9-9347-bc5f1ff5746b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def deriv (X,Y):\n",
    "    n =len(Y)\n",
    "    Z =np.zeros(n-1)\n",
    "    for i in range(n-1):\n",
    "        Z[i]=(Y[i+1]-Y[i])/(X[i+1]-X[i])\n",
    "    return(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94dccc50-a835-4665-820b-56369d817ac9",
   "metadata": {},
   "source": [
    "#### Q14\n",
    "* Créez un vecteur $X$ de $4000$ points répartis uniformément dans l’intervalle $[−10, 10]$.\n",
    "* Représenter sur un même graphique la fonction de terme général $f(x) = x^4$ et ses quatre premières dérivées approchées\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5579eca9-f5ae-4733-bee6-75e5289fd6aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "N = 400\n",
    "X = np.linspace(-10, 10, N)\n",
    "Y= X**4 \n",
    "# Première dérivée\n",
    "Z1=deriv(X,Y)\n",
    "# Deuxième  dérivée\n",
    "X1=np.delete(X,len(X)-1)\n",
    "Z2=deriv(X1,Z1)\n",
    "# Troisième  dérivée\n",
    "X2=np.delete(X1,len(X1)-1)\n",
    "Z3=deriv(X2,Z2)\n",
    "# Quatrième dérivée\n",
    "X3=np.delete(X2,len(X2)-1)\n",
    "Z4=deriv(X3,Z3)\n",
    "X4=np.delete(X3,len(X3)-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a937940-ab85-4ead-b0f2-7e5c54db3a86",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import  matplotlib.pyplot as plt\n",
    "plt.plot(X,Y,label='f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c621658a-a01e-4b49-affb-7b5b14125a21",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "import numpy as np\n",
    "import  matplotlib.pyplot as plt\n",
    "plt.plot(X,Y, '.-r', linewidth = 3,label='f')\n",
    "plt.plot(X1,Z1, '.-b', linewidth = 3,label='deriv 1')\n",
    "plt.plot(X2,Z2, '.-g', linewidth = 3,label='deriv 2')\n",
    "plt.plot(X3,Z3, '.-y', linewidth = 3,label='deriv 3')\n",
    "plt.plot(X4,Z4, '.-c', linewidth = 3,label='deriv 4')\n",
    "plt.title(\"f et ses dérivées approchées\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbb1f220-790d-458e-9095-dd4da0c63821",
   "metadata": {},
   "source": [
    "#### Q15 Proposer un code qui calcule le temps écoulé pour calculer la dérivée approchée d’un vecteur donné.\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee2cf806-ff5a-4910-affa-a2a2704b9a9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cette cellule est une cellule python\n",
    "import numpy as np\n",
    "N = 10\n",
    "X = np.linspace(-10, 10, N)\n",
    "Y= X**4 \n",
    "# Première dérivée\n",
    "%time  Z1=deriv(X,Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b158e58-f659-4518-99fc-fb078e9802af",
   "metadata": {},
   "source": [
    "#### Q16 Proposer une fonction qui calcule la dérivée approchée d’un vecteur sans utiliser de boucle for. La commande \"np.diff\" du module numpy retourne les différences entre deux composantes successives d'un vecteur. \n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b128d0f9-5e47-460a-b57b-dd20287fa99d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def deriv2 (X,Y):\n",
    "    X1=np.append(0,X)\n",
    "    X2=np.delete(X1,len(X1)-1)\n",
    "    Den= X-X2\n",
    "    D=np.delete(Den,0)\n",
    "    Y1=np.append(0,Y)\n",
    "    Y2=np.delete(Y1,len(Y1)-1)\n",
    "    Num= Y-Y2\n",
    "    N=np.delete(Num,0)\n",
    "    Z=N/D\n",
    "    return(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de25170e-006f-4a97-8e05-140e6c40ab23",
   "metadata": {},
   "source": [
    "#### Q17\n",
    "* Comparer les temps d’exécution de vos deux méthodes avec la fonction $f$ définie par $f (x) = x^3 + x^2$ en utilisant comme vecteur de départ un vecteur à $n$ points répartis dans l’intervalle $[−1000, 1000].$\n",
    "* Commencer avec un $n$ petit et augmenter-le jusqu’à obtenir une différence significative (cela dépend de la puissance de votre machine). Ne pas trop l'augmenter sinon le programme risque de manger la mémoire de votre machine\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "c6419cb2-a61a-4dce-a406-437aa5c105a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "n=50\n",
    "X=np.linspace(-1000,1000,n)\n",
    "Y=X**3+X**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e33a6a8b-245b-451e-9b9a-cea2fa1c2ebf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "%time  Z=deriv(X,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64c17481-3c63-4af5-9508-75b0281f4cf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time  Z2=deriv2(X,Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06e67271-26fd-4266-a57c-b680e7dc4978",
   "metadata": {},
   "source": [
    "# 5. Fonctions définies par morceaux\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5bfd722-8578-4d3f-96fe-6bf913416e54",
   "metadata": {},
   "source": [
    "#### Fonction Heaviside $H(x) =1$ si $x> 0$ et $H(x) =0$ sinon\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2f2c8bb-1ab1-46d4-94c8-0f3d7dfe1480",
   "metadata": {},
   "source": [
    "#### Soit $f$ la fonction réelle définie par \n",
    "* $f(x) = \\exp(x)− \\exp(−1)\\;  \\text{si} \\;   − 1 \\leq x < 0$\n",
    "* $f(x) =\\exp(−x)− \\exp(−1)\\;  \\text{si} \\;   0 \\leq  x < 1$\n",
    "* $f(x)=0 \\; \\text{si} \\; x<-1 \\;\\text{ou}\\; x\\geq 1$\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df5c1a2-0bc8-4a12-9818-f9ac7b2e305a",
   "metadata": {},
   "source": [
    "### 5.1 Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08994973-2954-479d-968b-089a0b1b8255",
   "metadata": {},
   "source": [
    "#### Q1 Définir en une ligne la fonction Heaviside et la tracer\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "4104d3ca-fa0e-4bd8-8bd2-ef485265fdc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def heaviside (x):\n",
    "    y=1*(x>0)+0*(x<=0)\n",
    "    return(y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b541dd02-db80-4bdf-bfd3-f8da0b27fe1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import  matplotlib.pyplot as plt\n",
    "x= np.linspace(-10,10,100)\n",
    "y=heaviside(x)\n",
    "plt.plot(x,y, '.-r', linewidth = 3)\n",
    "plt.title(\"fonction heaviside\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f26db3-13f2-4df5-9ced-5febce1a3815",
   "metadata": {},
   "source": [
    "#### Q21 Représenter $f$ pour $x\\in [-10,10]$\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19b0e381-27f8-4639-b1de-9ed55d17426f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def g (x):\n",
    "    y=(np.exp(x)-np.exp(-1))*(-1 <=x)*(x<0)+(np.exp(-x)-np.exp(-1))*(0 <=x)*(x<1) +0*(x>=1)+ 0*(x<-1)\n",
    "    return(y)\n",
    "\n",
    "import  matplotlib.pyplot as plt\n",
    "x= np.linspace(-10,10,100)\n",
    "y=g(x)\n",
    "plt.plot(x,y, '.-r', linewidth = 3)\n",
    "plt.title(\"fonction g\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0743d209-c98f-4bb2-a053-ea762b6ebe01",
   "metadata": {},
   "source": [
    "#### Q22 Modifier uniquement la commande d’affichage pour restreindre celui-ci au support de la fonction\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79198615-4c49-4a5e-b5b1-7388fe3993a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import  matplotlib.pyplot as plt\n",
    "x= np.linspace(-1,1,100)\n",
    "y=g(x)\n",
    "plt.plot(x,y, '.-r', linewidth = 3)\n",
    "plt.title(\"fonction g\")\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.grid(); \n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}