{
 "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": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "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",
    "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": "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\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\n",
    "a = 2.3\n",
    "b = -5\n",
    "print('somme=',SOMME(a,b))"
   ]
  },
  {
   "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": "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": "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": 41,
   "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 à l'ordre 2\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": "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": "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": "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": "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": "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": "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": "markdown",
   "id": "5836400c-be00-4654-b5d5-518206002c51",
   "metadata": {},
   "source": [
    "#### Q10 Proposer une autre fonction serie2(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": "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 serie2(1000). Quelle est la fonction la plus rapide ? À votre avis, pourquoi ?\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "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": 56,
   "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": "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": "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": "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": "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.\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "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",
    "* À votre avis, pourquoi ces résultats sont-ils différents des précédents ?\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "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": [
    "#### Q18 Définir en une ligne la fonction Heaviside et la tracer\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f26db3-13f2-4df5-9ced-5febce1a3815",
   "metadata": {},
   "source": [
    "#### Q19 Représenter $f$ pour $x\\in [-10,10]$\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0743d209-c98f-4bb2-a053-ea762b6ebe01",
   "metadata": {},
   "source": [
    "#### Q20 Modifier uniquement la commande d’affichage pour restreindre celui-ci au support de la fonction\n",
    "\n",
    "###### Cette cellule est une cellule Markdown "
   ]
  }
 ],
 "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
}