{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.set_autosave_interval(300000)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Autosaving every 300 seconds\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import display, Latex\n",
    "from IPython.core.display import HTML\n",
    "%reset -f\n",
    "%matplotlib inline\n",
    "%autosave 300\n",
    "from math import *\n",
    "from matplotlib.pylab import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algèbre matricielle\n",
    "\n",
    "L'objectif de ce TP est d'expérimenter le calcul matriciel sous Python.\n",
    "\n",
    "Il faut d'entrée noter que Python n'est pas aussi adapté pour le calcul matriciel que des logiciels spécialement dédiés comme Matlab, Octave (Octave étant un logiciel libre proposant une syntaxe et des fonctionalités proches de celles de Matlab) et Scilab (logiciel libre proche des deux précédents, mais avec une syntaxe légèrement différente, développé à l'INRIA)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Une représentation des matrices sous Python\n",
    "\n",
    "Pour manipuler des matrices sous Python on peut utiliser les commandes de la librairie \"numpy\", mais avant de faire appel à cette librairie on va manipuler les matrices en les représentant sous forme de listes de \"vecteurs lignes\" (qui sont encore des listes !).\n",
    "Ainsi, la  matrice $A=(A_{i,j})_{1 \\leq i \\leq n, 1 \\leq j \\leq k} \\in \\mathbb{R}^{n \\times k}$ qui se représente normalement sous la forme \n",
    "\n",
    "$$\n",
    "A = \\begin{bmatrix} A_{1,1} & \\ldots & A_{1,k} \\\\ \\vdots & \\ddots & \\vdots \\\\ A_{n,1} & \\ldots & A_{n,k} \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "sera représentée dans la suite par\n",
    "\n",
    "$$ A = [ \\,[A_{1,1}, \\ldots, A_{1,k}],\\ldots,[A_{n,1}, \\ldots, A_{n,k}]\\,].$$\n",
    "\n",
    "par exemple la matrice $A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}$ sera représentée de la façon suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [3, 4]]\n"
     ]
    }
   ],
   "source": [
    "A=[[1,2],[3,4]];\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour rappel, en Python les listes sont indexées à partir de $0$, par exemple : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A[1] = [3, 4]\n",
      "A[0][1] = 2\n"
     ]
    }
   ],
   "source": [
    "print(\"A[1] =\",A[1]);\n",
    "print(\"A[0][1] =\",A[0][1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher une matrice de manière plus classique on peut faire appel à la librairie \"numpy\" : la commande \"np.matrix\" permet de transformer une liste de \"vecteurs lignes\" en une matrice, qui s'affiche alors \"normalement\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "matA=np.matrix(A);\n",
    "print(matA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher encore plus facilement une matrice, on crée une commande \"affiche\" qui reprend les lignes précédentes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "def affiche(A):\n",
    "    print(np.matrix(A))\n",
    "\n",
    "affiche(A);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Définition de quelques matrices classiques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons maintenant définir une fonction \"zeros(n,k)\" qui renvoie la matrice nulle de $\\mathbb{R}^{n \\times k}$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0]\n",
      " [0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "def zeros(n,k):\n",
    "    Z=[[0 for t in range(k)] for s in range(n)];\n",
    "    return Z\n",
    "affiche(zeros(2,3));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrire une fonction \"ones(n,k)\" qui renvoie la matrice de $\\mathbb{R}^{n \\times k}$ dont tous les coefficients sont égaux à $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [1 1 1]]\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrire une fonction \"identite(n)\" qui renvoie la matrice identité de $\\mathbb{R}^{n \\times n}$, notée $I_n$ et définie par\n",
    "\n",
    "$$\n",
    "I_n = \\begin{bmatrix} 1 & 0 & \\ldots & 0 \\\\ 0 & 1 & \\ddots & \\vdots \\\\ \\vdots & \\ddots & \\ddots & 0 \\\\\n",
    "0 & \\ldots & 0 & 1 \\end{bmatrix}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0]\n",
      " [0 1 0]\n",
      " [0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "def identite(n):\n",
    "    Z=zeros(n,n);\n",
    "    for t in range(n):\n",
    "        Z[t][t]=1;\n",
    "    return Z\n",
    "affiche(identite(3));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Etant donné un vecteur $x=(x_0,\\ldots,x_n)$ représenté par une liste en Python, écrire une fonction \"compagnon(x)\" qui renvoie la matrice compagnon\n",
    "de ce vecteur, qui est la matrice $C$ de $\\mathbb{R}^{(n+1)\\times(n+1)}$ donnée par : \n",
    "\n",
    "$$\n",
    "C = \\begin{bmatrix}\n",
    "0 & 0 & \\ldots & 0 & -x_0 \\\\\n",
    "1 & 0 & \\ldots & 0 & -x_1 \\\\\n",
    "0 & 1 & \\ddots & 0 & -x_2 \\\\\n",
    "\\vdots & \\ddots & \\ddots & \\vdots & \\vdots \\\\\n",
    "0 & \\ldots & 0 & 1 & -x_n\n",
    "\\end{bmatrix}.\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quelques opérations sur les matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'une des premières opérations qu'on peut effectuer sur une matrice est la transposition. Pour rappel, la matrice\n",
    "$A=(A_{i,j})_{1 \\leq i \\leq n, 1 \\leq j \\leq k}$ de $\\mathbb{R}^{n \\times k}$ a pour matrice transposée la matrice\n",
    "$A^T$ de $\\mathbb{R}^{k \\times n}$ dont les coefficients sont donnés par : $A^T_{i,j} = A_{j,i}$. Ainsi les lignes\n",
    "de $A$ sont les colonnes de $A^T$ (et réciproquement).\n",
    "\n",
    "Par exemple : $\\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}^T = \\begin{bmatrix} 1 & 3 \\\\ 2 & 4 \\end{bmatrix}$.\n",
    "\n",
    "Ecrire une fonction \"transpose(A)\" qui renvoie la transposée de la matrice $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La trace d'une matrice $A \\in \\mathbb{R}^{n \\times n}$ est le nombre réel noté $tr(A)$ et donné par\n",
    "\n",
    "$$\n",
    "tr(A) = \\sum_{i=1}^n A_{i,i}\n",
    "$$\n",
    "\n",
    "Ecrire une fonction \"trace(A)\" qui renvoie la trace de $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Démontrer l'egalité suivante\n",
    "\n",
    "$$ \\forall A \\in \\mathbb{R}^{n \\times n}, \\forall B \\in \\mathbb{R}^{n \\times n}\n",
    "\\qquad tr(A \\times B) = tr( B \\times A)\n",
    "$$\n",
    "\n",
    "et la tester ensuite avec les matrices suivantes et les fonctions définies précédemment :\n",
    "$$\n",
    "A = \\begin{bmatrix} 1 & 2 \\\\ 4 & 6 \\end{bmatrix}, \\qquad\n",
    "B = \\begin{bmatrix} 2 & 5 \\\\ 1& 1 \\end{bmatrix}.\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Démonstration :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le produit d'une matrice $A \\in \\mathbb{R}^{n \\times k}$ par le nombre réel $\\alpha$ donne la matrice\n",
    "$\\alpha A = (\\alpha \\times A_{i,j})_{1 \\leq i \\leq n, 1 \\leq j \\leq k}$.\n",
    "\n",
    "Ecrire une fonction \"scal(A,alpha)\" qui réalise\n",
    "cette opération."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La somme de deux matrices $A$ et $B$ de $\\mathbb{R}^{n \\times k}$ donne la matrice\n",
    "$C \\in \\mathbb{R}^{n \\times k}$ dont les coefficients sont donnés par la formule : \n",
    "\n",
    "$$\n",
    "\\forall i \\in \\{1,\\ldots,n\\}, \\forall j \\in \\{1,\\ldots,k\\}, \\qquad C_{i,j} = A_{i,j} \\times B_{i,j}\n",
    "$$\n",
    "\n",
    "Ecrire une fonction \"somme(A,B)\" qui renvoie la somme des matrices $A$ et $B$, après avoir testé la compatibilité de cette somme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le produit d'une matrice $A \\in \\mathbb{R}^{n \\times k}$ par une matrice $B \\in \\mathbb{R}^{k \\times p}$ donne la matrice\n",
    "$C \\in \\mathbb{R}^{n \\times p}$ dont les coefficients sont donnés par la formule : \n",
    "\n",
    "$$\n",
    "\\forall i \\in \\{1,\\ldots,n\\}, \\forall j \\in \\{1,\\ldots,p\\}, \\qquad C_{i,j} = \\sum_{r=1}^k A_{i,r} \\times B_{r,j}\n",
    "$$\n",
    "\n",
    "Attention, il faut que le nombre de colonnes de $A$ soit égal au nombre de lignes de $B$ !\n",
    "\n",
    "Ecrire une fonction \"produit(A,B)\" qui renvoie le produit des matrices $A$ et $B$, après avoir testé la compatibilité de ce produit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testez l'égalité suivante :\n",
    "\n",
    "$$ \\forall A \\in \\mathbb{R}^{n \\times k}, \\qquad A = I_n \\times A \\times I_k $$\n",
    "\n",
    "avec la matrice et les fonctions définies précédemment\n",
    "\n",
    "$$\n",
    "A = \\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 6 & 8 \\end{bmatrix}.\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Démontrer l'egalité suivante\n",
    "\n",
    "$$ \\forall A \\in \\mathbb{R}^{n \\times k}, \\forall B \\in \\mathbb{R}^{k \\times p}\n",
    "\\qquad (A \\times B)^T = B^T \\times A^T\n",
    "$$\n",
    "\n",
    "et la tester ensuite avec les matrices suivantes et les fonctions définies précédemment :\n",
    "$$\n",
    "A = \\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 6 & 8 \\end{bmatrix}, \\qquad\n",
    "B = \\begin{bmatrix} 2 & 5 \\\\ 1& 1 \\\\ 0 & 4 \\end{bmatrix}.\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Démonstration de la formule :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Norme Euclidienne d'une matrice\n",
    "\n",
    "La norme Euclidienne de la matrice $A \\in \\mathbb{R}^{n \\times k}$ est le nombre noté $\\|A\\|$ et défini par\n",
    "\n",
    "$$\n",
    "\\| A \\| = \\sqrt{\\sum_{i=1}^n \\sum_{j=1}^k A_{i,j}^2}.\n",
    "$$\n",
    "\n",
    "Démontrer la formule : $\\|A \\|^2 = tr(A\\times A^T)$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Démonstration :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programmer la fonction \"norme(A)\" qui renvoie la norme de $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrices et applications linéaires : exemple de la dérivation des polynômes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En représentant un polynôme par la liste des coefficients de chaque monôme, écrire la matrice de la dérivation d'un polynôme de $\\mathbb{R}_n[X]$.\n",
    "\n",
    "L'utiliser pour dériver les polynômes $X^{10}+X+1$ et  $X^9-27X^7+3X^3$ de $\\mathbb{R}_{10}[X]$.\n",
    "\n",
    "En déduire ensuite la matrice de l'application linéaire \"dérivée tierce\" sur $\\mathbb{R}_{10}[X]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}