{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algèbre linéaire\n",
    "\n",
    "Ce notebook est relatif au second chapitre de cours de Prolégomènes de Mathématiques du [Master Sciences et Numérique pour la Santé](https://sns.edu.umontpellier.fr).\n",
    "\n",
    "> **⚠️ Rappel ⚠️**: Ce chapitre a pour objectif de synthétiser les notions et formules essentielles à l’utilisation\n",
    "de l’algèbre linéaire. Dans le cadre du Master, elle trouve ses applications dans les modules\n",
    "suivants : HAH807E - Chaîne d’Acquisition / Traitement du Signal, HAH710E - Ingénierie :\n",
    "Électronique, HAH802E - Capteurs et Traitement d’Images, HAH808E - Capteurs US pour le\n",
    "Biomédical, HAH805E - Robotique médicale, HAH806E - Neuroprothèse, HAH906E - Acquisition\n",
    "de données et traitement du signal pour le biomédical, HAH908E - Thermographie IR,\n",
    "détecteurs optiques et US, HAH909E - Robotique médicale 2, HAH910E - Neuroprothèse 2, HAH811E9 Sciences des Données.\n",
    "\n",
    "Notebook réalisé par E. Le Clézio, le 21 août 2023.  \n",
    "[Master Sciences et Numérique pour la Santé](https://sns.edu.umontpellier.fr)  \n",
    "[Université de Montpellier](https://www.umontpellier.fr)\n",
    "\n",
    "## Import des bibliothèques nécessaires au fonctionnement du Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1 :\n",
    "\n",
    "Calculer $\n",
    "\t\\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t2 & 1 & 8 \\\\\n",
    "\t\t4 & 4 & 6 \\\\\n",
    "\t\t1 & 3 & 7\n",
    "\t\\end{array}\n",
    "\t\\right] \n",
    "\t+\n",
    "\t\\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t5 & 7 & -6 \\\\\n",
    "\t\t1 & -4 & 3 \\\\\n",
    "\t\t11 & -13 & 2\n",
    "\t\\end{array}\n",
    "\t\\right]. $\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = \n",
      "[[2 1 8]\n",
      " [4 4 6]\n",
      " [1 3 7]]\n",
      "B = \n",
      "[[  5   7  -6]\n",
      " [  1  -4   3]\n",
      " [ 11 -13   2]]\n",
      "A+B = \n",
      "[[  7   8   2]\n",
      " [  5   0   9]\n",
      " [ 12 -10   9]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, 1, 8], [4, 4, 6], [1, 3, 7]])\n",
    "B = np.array([[5, 7, -6], [1, -4, 3], [11, -13, 2]])\n",
    "\n",
    "print(\"A = \")\n",
    "print(A)\n",
    "print(\"B = \")\n",
    "print(B)\n",
    "print(\"A+B = \")\n",
    "print(A+B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2 :\n",
    "\n",
    "Calculer $\n",
    "\t3\n",
    "\t\\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t5 & 7 & -6 \\\\\n",
    "\t\t1 & -4 & 3 \\\\\n",
    "\t\t11 & -13 & 2\n",
    "\t\\end{array}\n",
    "\t\\right]. \n",
    "$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3B = \n",
      "[[ 15  21 -18]\n",
      " [  3 -12   9]\n",
      " [ 33 -39   6]]\n"
     ]
    }
   ],
   "source": [
    "print(\"3B = \")\n",
    "print(3*B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 3 :\n",
    "\n",
    "Quelle est la transposée de $\n",
    "\t\\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t6 & 0 & 9 \\\\\n",
    "\t\t-3 & 4 & -5\n",
    "\t\\end{array}\n",
    "\t\\right]$ ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La transposée de \n",
      "[[ 6  0  9]\n",
      " [-3  4 -5]]\n",
      "est :\n",
      "[[ 6 -3]\n",
      " [ 0  4]\n",
      " [ 9 -5]] .\n"
     ]
    }
   ],
   "source": [
    "print(\"La transposée de \"),\n",
    "print(np.array([[6, 0, 9], [-3, 4, -5]]))\n",
    "print(\"est :\")\n",
    "print(np.transpose([[6, 0, 9], [-3, 4, -5]]), '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 4 :\n",
    "\n",
    "Quelle est la matrice adjointe de $\n",
    "\t\\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t6+i & 0 & 9-i \\\\\n",
    "\t\t-3i & 4 & -5\n",
    "\t\\end{array}\n",
    "\t\\right]$ ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La matrice transposée de la matrice conjuguée de \n",
      "[[ 6.+1.j  0.+0.j  9.-1.j]\n",
      " [-0.-3.j  4.+0.j -5.+0.j]]\n",
      "est :\n",
      "[[ 6.-1.j -0.+3.j]\n",
      " [ 0.-0.j  4.-0.j]\n",
      " [ 9.+1.j -5.-0.j]] .\n",
      "C'est aussi la matrice conjuguée de la matrice transposée : \n",
      "[[ 6.-1.j -0.+3.j]\n",
      " [ 0.-0.j  4.-0.j]\n",
      " [ 9.+1.j -5.-0.j]] .\n"
     ]
    }
   ],
   "source": [
    "print(\"La matrice transposée de la matrice conjuguée de \"),\n",
    "print(np.array([[6 + 1j, 0, 9 - 1j], [-3j, 4, -5]]))\n",
    "print(\"est :\")\n",
    "print(np.transpose(np.conj([[6 + 1j, 0, 9 - 1j], [-3j, 4, -5]])), '.')\n",
    "print(\"C'est aussi la matrice conjuguée de la matrice transposée : \")\n",
    "print(np.conj(np.transpose([[6 + 1j, 0, 9 - 1j], [-3j, 4, -5]])), '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 5 :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Soit le produit de matrices suivant :\n",
    "\\begin{eqnarray} \n",
    "\t\\left[\n",
    "\t\t\\begin{array}{cc} \n",
    "\t\t\ta_{11} & a_{12} \\\\\n",
    "\t\t\ta_{21} & a_{22}\t\t\t\t \n",
    "\t\t\\end{array}\n",
    "\t\t\\right]\n",
    "\t\\left[\n",
    "\t\t\\begin{array}{cc} \n",
    "\t\t\tb_{11} & b_{12} \\\\\n",
    "\t\t\tb_{21} & b_{22}\t\t\t\t \n",
    "\t\t\\end{array}\n",
    "\t\t\\right]\n",
    "\t\t&=&\n",
    "\t\\left[\n",
    "\t\t\\begin{array}{cc} \n",
    "\t\t\tc_{11} & c_{12} \\\\\n",
    "\t\t\tc_{21} & c_{22}\t\t\t\t \n",
    "\t\t\\end{array}\n",
    "\t\t\\right],\n",
    "\\end{eqnarray}\n",
    "\n",
    "1. Déterminer les expressions de $c_{11}$, $c_{12}$, $c_{21}$ et $c_{22}$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{eqnarray}\n",
    "\tc_{11} &=& a_{11}b_{11} + a_{12}b_{21}, \\\\\n",
    "\tc_{12} &=& a_{11}b_{12} + a_{12}b_{22}, \\\\\n",
    "\tc_{21} &=& a_{21}b_{11} + a_{22}b_{21}, \\\\\n",
    "\tc_{22} &=& a_{21}b_{12} + a_{22}b_{22}.\n",
    "\\end{eqnarray}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Faire l'application avec les matrices suivantes :\n",
    "\\begin{eqnarray} \n",
    "\t\\mathbf{A} = \\left[\n",
    "\t\t\\begin{array}{cc} \n",
    "\t\t\t5 & -2 \\\\\n",
    "\t\t\t1 & 3\t\t\t \n",
    "\t\t\\end{array}\n",
    "\t\t\\right] &\\quad&\n",
    "\t\\mathbf{B} = \\left[\n",
    "\t\t\\begin{array}{cc} \n",
    "\t\t\t4 & 7 \\\\\n",
    "\t\t\t6 & 0\t\t\t\t \n",
    "\t\t\\end{array}\n",
    "\t\t\\right].\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A.B = \n",
      "[[ 8 35]\n",
      " [22  7]]\n"
     ]
    }
   ],
   "source": [
    "A = [[5, -2], [1, 3]]\n",
    "B = [[4, 7], [6, 0]]\n",
    "print(\"A.B = \")\n",
    "print(np.dot(A,B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 6 :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une certaine espèce d'insectes se comporte de la manière suivante : en moyenne, la moitié de la population meure à la fin de la première année de vie. Parmi les survivants, les $\\frac{2}{3}$ meurent au bout de la seconde année de vie. Le reste meure à la fin de la troisième année, mais chaque femelle a auparavant donné naissance en moyenne à $6$ individus femelles. Le recensement de la population donne, pour l'année $2012$ : $x_n$ individus dans la première année de vie, $y_n$ individus dans la seconde année de vie et $z_n$ individus dans la dernière année de vie. \n",
    "1. Déterminer la matrice $\\mathbf{A} $ telle que :\n",
    "  \\begin{eqnarray}\n",
    "\t\\left[\n",
    "\t\\begin{array}{c} \n",
    "\t\tx_{n+1} \\\\\n",
    "\t\ty_{n+1} \\\\\n",
    "\t\tz_{n+1}\n",
    "\t\\end{array}\n",
    "\t\\right] \n",
    "\t&=&\\mathbf{A} \n",
    "\t\\left[\n",
    "\t\\begin{array}{c} \n",
    "\t\tx_n \\\\\n",
    "\t\ty_n \\\\\n",
    "\t\tz_n\n",
    "\t\\end{array}\n",
    "\t\\right] .\n",
    "\t\\end{eqnarray}\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   \\begin{eqnarray} \n",
    "\t\\mathbf{A} &=& \\left[\n",
    "\t\t\\begin{array}{ccc} \n",
    "\t\t\t0 & 0 & 6 \\\\\n",
    "\t\t\t1/2 & 0 & 0 \\\\\n",
    "\t\t\t0 & 1/3 & 0\t\t\t \n",
    "\t\t\\end{array}\n",
    "\t\t\\right].\n",
    " \t\\end{eqnarray}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Calculer $\\mathbf{A}^2$ et $\\mathbf{A}^3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A^2 = \n",
      "[[0.         2.         0.        ]\n",
      " [0.         0.         3.        ]\n",
      " [0.16666667 0.         0.        ]]\n",
      "A^3 = \n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[0, 0, 6], [0.5, 0, 0], [0, 1/3, 0]])\n",
    "A2 = np.dot(A,A)\n",
    "print(\"A^2 = \")\n",
    "print(A2)\n",
    "A3 = np.dot(A2,A)\n",
    "print(\"A^3 = \")\n",
    "print(np.dot(A2,A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Quelles conclusions peuvent en être tirées sur l'évolution de la population des insectes ?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La population d'insecte se reproduit à l'identique tous les trois ans. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 7 :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À l'aide des matrices de rotation définies ci-dessus :\n",
    "1. Déterminer les expressions des trois matrices de rotation de $90$\\degre\\, autour des axes principaux. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "Rx90 = np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]])\n",
    "Ry90 = np.array([[0, 0, 1], [0, 1, 0], [-1, 0, 0]])\n",
    "Rz90 = np.array([[0, 0, -1], [0, 1, 0], [0, 0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. En les appliquant successivement au vecteur $\\mathbf{T} = \\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\tx_1 & x_2 & x_3 \\\\\n",
    "\t\\end{array}\n",
    "\t\\right]^T$, quelles sont les conséquences sur ses composantes ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- Rotations de 90° autour de x ----\n",
      "[1 0 0]\n",
      "[0 0 1]\n",
      "[ 0 -1  0]\n",
      "---- Rotations de 90° autour de y ----\n",
      "[ 0  0 -1]\n",
      "[0 1 0]\n",
      "[1 0 0]\n",
      "---- Rotations de 90° autour de z ----\n",
      "[0 0 0]\n",
      "[0 1 0]\n",
      "[-1  0  1]\n"
     ]
    }
   ],
   "source": [
    "x = np.array(np.transpose([1, 0, 0]))\n",
    "y = np.array(np.transpose([0, 1, 0]))\n",
    "z = np.array(np.transpose([0, 0, 1]))\n",
    "\n",
    "print('---- Rotations de 90° autour de x ----')\n",
    "print(np.dot(Rx90,x))\n",
    "print(np.dot(Rx90,y))\n",
    "print(np.dot(Rx90,z))\n",
    "print('---- Rotations de 90° autour de y ----')\n",
    "print(np.dot(Ry90,x))\n",
    "print(np.dot(Ry90,y))\n",
    "print(np.dot(Ry90,z))\n",
    "print('---- Rotations de 90° autour de z ----')\n",
    "print(np.dot(Rz90,x))\n",
    "print(np.dot(Rz90,y))\n",
    "print(np.dot(Rz90,z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Déterminer les expressions des trois matrices de rotation de $60$° autour des axes principaux. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 90*np.pi/180\n",
    "Rxalpha = np.array([[1, 0, 0], [0, np.cos(alpha), -np.sin(alpha)], [0, np.sin(alpha), np.cos(alpha)]])\n",
    "Ryalpha = np.array([[np.cos(alpha), 0, np.sin(alpha)], [0, 1, 0], [-np.sin(alpha) , 0, np.cos(alpha)]])\n",
    "Rzalpha = np.array([[np.cos(alpha), -np.sin(alpha), 0], [np.sin(alpha), np.cos(alpha), 0], [0, 0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. En les appliquant successivement au vecteur $\\mathbf{T} = \\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\tx_1 & x_2 & x_3 \\\\\n",
    "\t\\end{array}\n",
    "\t\\right]^T$, quelles sont les conséquences sur ses composantes ? \t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- Rotations de alpha° autour de x ----\n",
      "[1. 0. 0.]\n",
      "[0.000000e+00 6.123234e-17 1.000000e+00]\n",
      "[ 0.000000e+00 -1.000000e+00  6.123234e-17]\n",
      "---- Rotations de alpha° autour de y ----\n",
      "[ 6.123234e-17  0.000000e+00 -1.000000e+00]\n",
      "[0. 1. 0.]\n",
      "[1.000000e+00 0.000000e+00 6.123234e-17]\n",
      "---- Rotations de alpha° autour de z ----\n",
      "[6.123234e-17 1.000000e+00 0.000000e+00]\n",
      "[-1.000000e+00  6.123234e-17  0.000000e+00]\n",
      "[0. 0. 1.]\n"
     ]
    }
   ],
   "source": [
    "x = np.array(np.transpose([1, 0, 0]))\n",
    "y = np.array(np.transpose([0, 1, 0]))\n",
    "z = np.array(np.transpose([0, 0, 1]))\n",
    "\n",
    "print('---- Rotations de alpha° autour de x ----')\n",
    "print(np.dot(Rxalpha,x))\n",
    "print(np.dot(Rxalpha,y))\n",
    "print(np.dot(Rxalpha,z))\n",
    "print('---- Rotations de alpha° autour de y ----')\n",
    "print(np.dot(Ryalpha,x))\n",
    "print(np.dot(Ryalpha,y))\n",
    "print(np.dot(Ryalpha,z))\n",
    "print('---- Rotations de alpha° autour de z ----')\n",
    "print(np.dot(Rzalpha,x))\n",
    "print(np.dot(Rzalpha,y))\n",
    "print(np.dot(Rzalpha,z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Faire l'application avec les vecteurs (réaliser un schéma) :\n",
    "\n",
    "(a) $\\mathbf{T} = \\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t1 & 0 & 0 \\\\\n",
    "\t\\end{array}\n",
    "\t\\right]^T$,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(b) $\\mathbf{T} = \\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t1 & 1 & 1 \\\\\n",
    "\t\\end{array}\n",
    "\t\\right]^T$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Comment modéliser une rotation autour d'un axe non principal ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On la décompose sous une suite de rotations élémentaires \n",
    "(un produit des matrices correspondantes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 8 :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Calculer $|\\mathbf{A}|$ pour une matrice carrée de dimension $n=2$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$|\\mathbf{A}| = \ta_{11}a_{22}-a_{21}a_{12}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Faire l'application avec $\\mathbf{A} \n",
    "\t=\n",
    "\t\\left[\n",
    "\t\\begin{array}{cc} \n",
    "\t\t3 & 4  \\\\\n",
    "\t\t5 & 6 \n",
    "\t\\end{array}\n",
    "\t\\right]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "[[3 4]\n",
      " [5 6]]\n",
      "|A| = \n",
      "-2.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[3, 4], [5, 6]])\n",
    "print('A =')\n",
    "print(A)\n",
    "print('|A| = ')\n",
    "print(np.linalg.det(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "[[3 4]\n",
      " [6 8]]\n",
      "|A| = \n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[3, 4], [6, 8]])\n",
    "print('A =')\n",
    "print(A)\n",
    "print('|A| = ')\n",
    "print(np.linalg.det(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Calculer $|\\mathbf{A}|$ pour une matrice carrée de dimension $n=3$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$|\\mathbf{A}| =\ta_{11}a_{22}a_{33}+a_{13}a_{32}a_{21}+a_{12}a_{23}a_{31} -a_{11}a_{23}a_{32}-a_{22}a_{13}a_{31}-a_{33}a_{12}a_{21}$.\t\t\t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Faire l'application avec $\\mathbf{A} \n",
    "\t=\n",
    "\t\\left[\n",
    "\t\\begin{array}{ccc} \n",
    "\t\t5 & -5 & 1 \\\\\n",
    "\t\t0,1 & 3 & 2 \\\\\n",
    "\t\t2 & -1 & -0,5\n",
    "\t\\end{array}\n",
    "\t\\right]$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "[[ 5.  -5.   1. ]\n",
      " [ 0.1  3.   2. ]\n",
      " [ 2.  -1.  -0.5]]\n",
      "|A| = \n",
      "-23.85\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[5, -5, 1], [0.1, 3, 2], [2, -1, -0.5]])\n",
    "print('A =')\n",
    "print(A)\n",
    "print('|A| = ')\n",
    "print(np.linalg.det(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "[[ 15  -6  33]\n",
      " [  6   0   9]\n",
      " [-33  -9  -6]]\n",
      "|A| = \n",
      "998.9999999999995\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[15, -6, 33], [6, 0, 9], [-33, -9, -6]])\n",
    "print('A =')\n",
    "print(A)\n",
    "print('|A| = ')\n",
    "print(np.linalg.det(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 9 : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une population de souris contient $100$ individus. Elle est composée de mâles de couleur grise et de femelles blanches. Au bout d'un mois de développement non contrôlé, le nombre d'individus au sein de la population est de $284$. Au cours de l'expérience, $25$\\% des reproductions ont conduit à une souris blanche. Sachant qu'aucune souris n'est morte pendant l'expérience, et que les populations de mâles et de femelles ont été multipliées respectivement par $2$ et $3$ :\n",
    "1. Déterminer le nombre de mâles et le nombre de femelles au début de l'expérience. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 16 \n",
    "f = 84"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Déterminer le nombre de souris grises et le nombre de souris blanches à la fin de l'expérience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = 154\n",
    "b = 130"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 10 : \n",
    "\n",
    "Un agriculteur a livré à sa coopérative $30$ tonnes de blé, $45$ tonnes de tournesol et $75$ tonnes de sorgho. Il a reçu, en échange, $234$ M€. Le prix de la tonne de blé est la moyenne du prix de la tonne de tournesol et du prix de la tonne de sorgho. D'autre part, s'il avait livré une tonne de chacun de ces produits, il aurait reçu $5,1$ M€.\n",
    "\n",
    "1. Quel est le prix payé à la tonne de chacun des produits livrés ? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "[[30.  45.  75. ]\n",
      " [-1.   0.5  0.5]\n",
      " [ 1.   1.   1. ]]\n",
      "|A| = \n",
      "-44.99999999999999\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[30, 45, 75], [-1, 0.5, 0.5], [1, 1, 1]])\n",
    "print('A =')\n",
    "print(A)\n",
    "print('|A| = ')\n",
    "print(np.linalg.det(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "invA = \n",
      "[[-6.93889390e-19 -6.66666667e-01  3.33333333e-01]\n",
      " [-3.33333333e-02  1.00000000e+00  2.00000000e+00]\n",
      " [ 3.33333333e-02 -3.33333333e-01 -1.33333333e+00]]\n"
     ]
    }
   ],
   "source": [
    "invA = np.linalg.inv(A)\n",
    "print('invA = ')\n",
    "print(invA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B = \n",
      "[[234. ]\n",
      " [  0. ]\n",
      " [  5.1]]\n"
     ]
    }
   ],
   "source": [
    "B = np.array([[234], [0], [5.1]])\n",
    "print('B = ')\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la solution est donnée par :\n",
      "[[1.7]\n",
      " [2.4]\n",
      " [1. ]]\n"
     ]
    }
   ],
   "source": [
    "print('la solution est donnée par :')\n",
    "print(np.dot(invA,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 1,7 \n",
    "t = 2,4 \n",
    "s = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 11 : \n",
    "\n",
    "En reprenant l'exercice précédent sur la livraison de céréales par un agriculteur à sa coopérative :\n",
    "\n",
    "1. Déterminer la matrice inverse de la matrice du système résolu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Vérifier la validité de votre calcul et résolvant de nouveau le problème à partir de la matrice inverse. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'inverse de A est : \n",
      "[[-6.93889390e-19 -6.66666667e-01  3.33333333e-01]\n",
      " [-3.33333333e-02  1.00000000e+00  2.00000000e+00]\n",
      " [ 3.33333333e-02 -3.33333333e-01 -1.33333333e+00]]\n",
      "Les prix respectifs sont donc donnés par :\n",
      "[[1.7]\n",
      " [2.4]\n",
      " [1. ]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[30, 45, 75], [-1, 1/2, 1/2], [1, 1, 1]])\n",
    "B = [[234], [0], [5.1]]\n",
    "invA = np.linalg.inv(A)\n",
    "print(\"L'inverse de A est : \")\n",
    "print(invA)\n",
    "print(\"Les prix respectifs sont donc donnés par :\")\n",
    "print(np.dot(invA, B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Quels sont les vecteurs propres et valeurs propres du système ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([30.96871942, -0.96871942,  1.5       ]),\n",
       " array([[-0.99895894,  0.56512077, -0.73194439],\n",
       "        [ 0.03225703,  0.58336889,  0.67001063],\n",
       "        [-0.03225703, -0.58336889, -0.12386751]]))"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eig(A)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Aucun(e)",
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}