{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "06e7bcdb-1ecc-4bd2-9aa9-7fb025fc63cd",
   "metadata": {},
   "source": [
    "## MT09 - TP4 - Automne 2025\n",
    "### Calcul approché de valeurs propres, puissances itérées, puissances inverses, déflation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668fd69c-d772-469c-a611-76e49a3797d4",
   "metadata": {},
   "source": [
    "### 1. Algorithme des puissances itérées\n",
    "\n",
    "Programmer l'algorithme des puissances itérées \n",
    "\n",
    "```\n",
    "xsol, lambdasol, kout, boolcvg = puissancesIterees(A, x0, tol, kmax)\n",
    "```\n",
    "\n",
    "pour une matrice $A$ et un vecteur initial $x_0\\neq 0$, une tolérance de précision $tol$ et un nombre maximal d'itérations $k_{max}$. La sortie ```boolcvg``` retournera 1 si la tolérance est atteinte, 0 sinon. Le critère de convergence à l'itération $k$ sera\n",
    "\n",
    "$$\n",
    "\\|A x^{(k)} - \\lambda^{(k)} x^{(k)}\\|_2\\, < tol.\n",
    "$$\n",
    "L'entier $k_{out}$ est l'indice d'itération de sortie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5adc3ca8-8334-440d-8639-ca3719def520",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numpy.linalg as la\n",
    "\n",
    "def puissancesIterees(A, x0, tol, kmax):\n",
    "    # ...\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7bee834-9014-4442-9ce8-feb93a346dc2",
   "metadata": {},
   "source": [
    "Codez une matrice générique $A$ de taille $n$ définie par\n",
    "$$\n",
    "A = \\text{tridiag}(-1, 2, -1).\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "2de7ec55-6104-4e7f-a078-35599fce28b1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "n = 10;\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f4a0519-5a11-4948-9885-afbc8297017e",
   "metadata": {
    "tags": []
   },
   "source": [
    "Appliquer l'algorithme de puissances itérées à la matrice $A$ en choisissant $x_0=(1,0,...,0)^T=\\mathbf{e}_1$, $kmax=1000$ et $tol=10^{-8}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f86faf0-6a32-453e-89af-e156ef7ca5b6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ab425569-5195-4efb-afdc-052c60104a1c",
   "metadata": {
    "tags": []
   },
   "source": [
    "En fait, dans ce cas particulier, on peut calculer analytiquement les valeurs propres de $A$, elles sont données par la formule\n",
    "\n",
    "$$\n",
    "\\lambda_j = 4\\sin^2\\left(\\frac{j\\pi}{2(n+1)}\\right), \\quad 1\\leq j\\leq n.\n",
    "$$\n",
    "Vérifiez que l'algorithme de puissances itérées approche bien la plus grande valeur propre de $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e41ede6c-52c5-4ad6-8d35-0b121b2cafc8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b07f1ff2-4633-4fec-b1ef-a70471440fb9",
   "metadata": {},
   "source": [
    "### 2. Algorithme des puissances itérées inverses\n",
    "\n",
    "Programmer l'algorithme des puissances itérées inverses\n",
    "\n",
    "```\n",
    "xsol, lambdasol, kout, boolcvg = puissancesItereesInverses(A, x0, tol, kmax)\n",
    "```\n",
    "\n",
    "pour une matrice $A$ et un vecteur initial $x_0\\neq 0$, une tolérance de précision $tol$ et un nombre maximal d'itérations $k_{max}$. La sortie ```boolcvg``` retournera 1 si la tolérance est atteinte, 0 sinon. Le critère de convergence à l'itération $k$ sera\n",
    "\n",
    "$$\n",
    "\\|A x^{(k)} - \\lambda^{(k)} x^{(k)}\\|< tol.\n",
    "$$\n",
    "\n",
    "On utilisera ```la.solve()``` pour résoudre les systèmes linéaires de l'algorithme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e2f392f-724e-446c-a99e-0ac9715e2ae9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def puissancesItereesInverses(A, x0, tol, kmax):\n",
    "    # ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75893490-2456-49bc-984d-ed8d11353003",
   "metadata": {},
   "source": [
    "Appliquer l'algorithme de puissances itérées à la matrice tridiagonale $A$ en choisissant $x_0=(1,0,...,0)^T$, $kmax=1000$ et $tol=10^{-5}$. Vérifiez que l'algorithme de puissances itérées inverses approche bien la plus petite valeur propre de $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ff1366b4-8b6f-4aeb-b9c2-a27701cf3b27",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "kmax = 200\n",
    "x0 = np.zeros(n)\n",
    "x0[0] = 1\n",
    "tol = 1e-5\n",
    "xsol, lambdasol, kout, boolcvg = puissancesItereesInverses(A, x0, tol, kmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7a34f67-4c4c-4ada-96f5-8249f749acb4",
   "metadata": {},
   "source": [
    "### 3. Méthode de déflation pour une matrice symétrique\n",
    "\n",
    "La méthode de déflation permet de calculer toutes les valeurs propres d'une matrice. Dans le cas d'une matrice symétrique, l'algorithme de déflation est particulièrement simple. Une fois calculé la plus grande valeur propre $\\lambda_n$ (en valeur absolue) avec le vecteur propre associé $\\mathbf{x}_n$, on considère la matrice \"retranchée\"\n",
    "\n",
    "$$\n",
    "A \\leftarrow A - \\lambda_n\\, \\mathbf{x}_n \\mathbf{x}_n^T,\n",
    "$$\n",
    "\n",
    "et on réapplique la méthode de puissances itérées. On itère jusqu'à obtenir la matrice nulle.\n",
    "Programmer une méthode \n",
    "\n",
    "```\n",
    "D, V = deflation(A)\n",
    "```\n",
    "\n",
    "qui calcule le tableau $D$ constitué des valeurs propres de $A$ et la matrice $V$ des vecteurs propres en faisant appel à ```puissancesIterees()```. Appliquer à la matrice tridiagonale précédente. Comparer les valeurs propres calculées aux valeurs propres exactes. Pour cette matrice $A$ symétrique, vérifiez que la matrice $V$ est une matrice orthogonale aux erreurs d'approximation près (on prendra $k_{max}=1000$ et $tol=10^{-8}$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3a75ddc1-ff0d-4b0d-be34-fa2e41b1193b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def deflation(Ainput):\n",
    "    A = np.copy(Ainput)\n",
    "    # ...\n",
    "    return D, V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "653fb0b4-72ba-4cde-820b-90f338d9e1f8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "D, V = deflation(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f78d65ed-ca96-4d5b-9332-59f194fdfde3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(D,\"\\n\")\n",
    "print(D - lambdaj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a40392b4-40cc-417a-91c0-c438810778f8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "f454e604-5e2b-494d-95c8-e36f682a6955",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6639457442208882e-07"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.norm(V.T@V - np.eye(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "213e0c1b-9006-4a1b-8d0e-a6d0d6e30a2f",
   "metadata": {},
   "source": [
    "### 4. \"Visualisation\" des vecteurs proppres\n",
    "\n",
    "Tracez les $n$ vecteurs propres  de $A$ comme s'il s'agissait de fonctions discrétisées sur un intervalle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b72f3e64-3dca-4824-9d01-0dbc99df08ac",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, axs = plt.subplots(5, 2)\n",
    "axs[0,0].plot(V[:,0], '-k')\n",
    "axs[0,1].plot(V[:,1], '-k')\n",
    "axs[1,0].plot(V[:,2], '-k')\n",
    "axs[1,1].plot(V[:,3], '-k')\n",
    "axs[2,0].plot(V[:,4], '-k')\n",
    "axs[2,1].plot(V[:,5], '-k')\n",
    "axs[3,0].plot(V[:,6], '-k')\n",
    "axs[3,1].plot(V[:,7], '-k')\n",
    "axs[4,0].plot(V[:,8], '-k')\n",
    "axs[4,1].plot(V[:,9], '-k')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ed12de2-105e-4e2b-ab84-4e3f6e2d5c42",
   "metadata": {},
   "source": [
    "### 5. Vibrations propres d'un système masses-ressorts\n",
    "\n",
    "#### 5.a Solution harmonique\n",
    "\n",
    "On considère une chaîne horizontale constituée de $N$ masses-ressorts de masse $m$ et de coefficient de raideur $k$ identiques. La chaîne est de longueur $L$ et fixée à ses deux extrémités. On néglige les frottements au sol. Le mouvement global peut être représenté par les équations de la cinématique et de la dynamique :\n",
    "\n",
    "\\begin{align*}\n",
    "& \\frac{d\\mathbf{u}}{dt} = \\mathbf{v},\\\\[1.3ex]\n",
    "& m \\frac{d\\mathbf{v}}{dt} = - k\\, A\\mathbf{u}\n",
    "\\end{align*}\n",
    "\n",
    "où $A\\in\\mathcal{M}_N(\\mathbb{R})$ est la matrice\n",
    "\n",
    "$$\n",
    "A=\\frac{1}{h^2}\\,\\text{tridiag}(-1,2,-1)\n",
    "$$\n",
    "\n",
    "avec $h=\\frac{L}{N+1}$. Les vecteur $\\mathbf{u}\\in\\mathbb{R}^N$ est le vecteur des déplacements, $\\mathbf{v}\\in\\mathbb{R}^N$ le vecteur des vitesses. \n",
    "\n",
    "En regroupant les deux systèmes d'équations, on obtient\n",
    "\n",
    "$$\n",
    "m\\,\\frac{d^2\\mathbf{u}}{dt^2} + k\\,A\\mathbf{u} = 0.\n",
    "$$\n",
    "\n",
    "Sur brouillon, cherchez une solution de la forme\n",
    "\n",
    "$$\n",
    "\\mathbf{u}(t) =  \\varphi(t) \\,\\, \\mathbf{w}\n",
    "$$\n",
    "\n",
    "pour une certaine fonction temporelle $\\varphi(t)$ et un vecteur constant $\\mathbf{w}\\in\\mathbb{R}^N$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "a466a250-cd51-4ebb-a31c-932b894f6f0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A w_1 = lambda_1 w_1\n",
    "# varphi(t) = sin(sqrt(\\lambda_1 \\sqrt(k/m) t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02b3687f-485e-4d10-b9ad-1db56bf12a11",
   "metadata": {},
   "source": [
    "#### 5.b Mode basse fréquence\n",
    "\n",
    "On considère $N=20$, $L=m=k=1$. Avec l'aide de la méthode des puissances itérées inverses, calculez le mode vibratoire de plus basse fréquence : on calculera\n",
    "la valeur propre et le vecteur propre associé, ainsi que la fonction temporelle $\\varphi(t)$ associée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "b37dbe06-395c-4ab0-9b2e-5cf9d9731b84",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 20;\n",
    "L = 1.0\n",
    "h = L / (N+1.0)\n",
    "A = 2*np.diag(np.ones(N)) - np.diag(np.ones(N-1),-1) - np.diag(np.ones(N-1),1)\n",
    "A = A / (h*h)\n",
    "# ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "a9a13170-c5a7-467b-bf8a-471860e7b18a",
   "metadata": {},
   "outputs": [],
   "source": [
    "m, k = 1.0, 1.0\n",
    "def varphi(t):\n",
    "   # ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c7bcb9-ecdb-4a95-9fd6-5a6b226c2416",
   "metadata": {},
   "source": [
    "#### 5.c Animation d'une fonction temporelle\n",
    "\n",
    "Le snippet ```python'' suivant permet d'animer une fonction dépendant du temps.\n",
    "Exécutez-le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "acae3414-4430-40c7-a84d-65fdf2412aa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import display, clear_output\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "\n",
    "I=60\n",
    "x = np.linspace(0, 1, 200)\n",
    "\n",
    "fig = plt.figure(figsize = (5,4))\n",
    "ax = fig.subplots() \n",
    "\n",
    "for i in range(I):\n",
    "    ax.clear()\n",
    "    clear_output(wait=True)\n",
    "    t = 0.2*i\n",
    "    y = np.sin(t)*np.sin(4*np.pi*x)\n",
    "    ax.plot(x, y, '.-g'); ax.grid()\n",
    "    plt.ylim([-1.0,1.0])\n",
    "    display(fig)\n",
    "    time.sleep(0.001)\n",
    "\n",
    "clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5004edc-0e9b-4c7c-9337-01a64b4c421f",
   "metadata": {},
   "source": [
    "#### 5.d Animation du mode vibratoire basse fréquence de la chaîne\n",
    "\n",
    "Utilisez un code similaire pour animer le mode vibratoire basse fréquence de la chaîne de masses-ressorts. On prendra\n",
    "\n",
    "```\n",
    "t = 0.5 * np.linspace(0,40)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2ddd34a-1107-4097-8525-0adbc7c39db6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1dd0b6c-f3ff-4cae-a23c-00de88b0f825",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c3e0918b-f551-4dad-82b1-74de0c4b8ce9",
   "metadata": {},
   "source": [
    "### 6. (Optionnel) Mesure d'incertitude sur un résultat\n",
    "\n",
    "Un système est gouverné par un système algébrique\n",
    "\n",
    "$$\n",
    "\\mathbf{F}(\\mathbf{u}) = \\mathbf{b}\n",
    "$$\n",
    "\n",
    "où $\\mathbf{b}$ est le vecteur représentant une force extérieure et $\\mathbf{u}$ est la variable d'état du système (par exemple le vecteur de déplacement). On suppose que $\\mathbf{F}$ est continûment différentiable et \n",
    "qu'il existe un unique $\\mathbf{u}^\\star$ tel que $\\mathbf{F}(\\mathbf{u}^\\star)=\\mathbf{b}$.\n",
    "\n",
    "Un système de capteurs permet de mesurer $b$ avec une certaine incertitude. La certification des\n",
    "capteurs de mesure garantit une erreur relative\n",
    "\n",
    "$$\n",
    "\\frac{\\|\\delta \\mathbf{b}\\|_2}{\\|\\mathbf{b}\\|_2}\n",
    "$$\n",
    "\n",
    "inférieure à $\\eta$. Si une erreur $\\delta \\mathbf{b}$ est commise sur $\\mathbf{b}$, on a une réponse $\\mathbf{u}$ telle que $\\mathbf{F}(\\mathbf{u}) = \\mathbf{b}+\\delta \\mathbf{b}$. Sous l'hypothèse de petites perturbations, on peut linéariser $\\mathbf{F}$ selon\n",
    "\n",
    "$$\n",
    "\\mathbf{F}(\\mathbf{u}) \\approx \\mathbf{F}(\\mathbf{u}^\\star) + DF(\\mathbf{u}^\\star)(\\mathbf{u}-\\mathbf{u}^\\star) = \\mathbf{b} + DF(\\mathbf{u}^\\star)(\\mathbf{u}-\\mathbf{u}^\\star) = \\mathbf{b}+\\delta \\mathbf{b}.\n",
    "$$\n",
    "\n",
    "En notant $\\delta \\mathbf{u} = \\mathbf{u}-\\mathbf{u}^\\star$. On peut donc raisonnablement considérer que\n",
    "\n",
    "$$\n",
    "DF(\\mathbf{u}^\\star) \\delta \\mathbf{u} = \\delta \\mathbf{b}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7200bce-7611-41e3-9056-28b25d8646cf",
   "metadata": {},
   "source": [
    "Q : Comment évaluer numériquement une majoration optimale de $\\dfrac{\\|\\delta \\mathbf{u}\\|_2}{\\|\\mathbf{u}\\|_2}$ ('optimale' au sens où la borne de majoration peut être atteinte) ?."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8f63619-1f72-4ed8-90a7-9d9876ffd91e",
   "metadata": {},
   "source": [
    "**Application** : on considérera $\\mathbf{F}$ linéaire :\n",
    "\n",
    "$$\n",
    "\\mathbf{F}(\\mathbf{u}) = A\\mathbf{u}\n",
    "$$\n",
    "\n",
    "avec\n",
    "\n",
    "$$\n",
    "A = \\frac{1}{\\sqrt{\\varepsilon}} \\begin{pmatrix} 1 & 1 \\\\ 1-\\varepsilon & 1 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "avec $\\varepsilon = 10^{-7}$. Evaluer numériquement une majoration $M$ (optimale) de\n",
    "$\\dfrac{\\|\\delta \\mathbf{u}\\|_2}{\\|\\mathbf{u}\\|_2}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5f758f6-5002-4fe1-b93c-ffca14372a0b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04e01cea-1767-48eb-8405-9ae50287234f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:base] *",
   "language": "python",
   "name": "conda-base-py"
  },
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}