diff --git "a/Chapitre 8 - Valeurs propres, vecteurs propres, diagonalisation/8.1 Valeurs propres et vecteurs propres, d\303\251finitions, exemples.ipynb" "b/Chapitre 8 - Valeurs propres, vecteurs propres, diagonalisation/8.1 Valeurs propres et vecteurs propres, d\303\251finitions, exemples.ipynb" index 8c0e926..e456ccc 100644 --- "a/Chapitre 8 - Valeurs propres, vecteurs propres, diagonalisation/8.1 Valeurs propres et vecteurs propres, d\303\251finitions, exemples.ipynb" +++ "b/Chapitre 8 - Valeurs propres, vecteurs propres, diagonalisation/8.1 Valeurs propres et vecteurs propres, d\303\251finitions, exemples.ipynb" @@ -1,193 +1,1414 @@ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Concept(s)-clé(s) et théorie\n", "\n", "#### Définition: Valeur propre et vecteur propre d'une application linéaire\n", "\n", "Soient $V$ un $\\mathbb{R}$-espace vectoriel et $T: V \\rightarrow V$ une transformation linéaire. On dit que $\\lambda \\in \\mathbb{R}$ est une valeur propre de $T$ s'il existe $v \\in V$ non-nul tel que $T(v)=\\lambda v$. Aussi, si $\\lambda \\in \\mathbb{R}$ est une valeur propre de $T$, alors tout vecteur non-nul $v \\in V$ tel que $T(v)=\\lambda v$ s'appelle un vecteur propre de $T$ correspondant à la valeur propre $\\lambda$.\n", "\n", "#### Définition: Valeur propre et vecteur propre d'une matrice\n", "Soit $A \\in M_{n \\times n} \\ (\\mathbb{R})$ . On dit que $\\lambda \\in \\mathbb{R}$ est une valeur propre de $A$ s'il existe $X \\in M_{n \\times 1} (\\mathbb{R})$ non-nul tel que $A X=\\lambda X$. Aussi, si $\\lambda \\in \\mathbb{R}$ est une valeur propre de $A$, alors toute solution non-nulle de $A X=\\lambda X$ s'appelle un vecteur propre de $A$ correspondant à la valeur propre $\\lambda$." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import numpy as np\n", "import plotly\n", "import plotly.graph_objects as go\n", "import sympy as sp\n", "from IPython.display import display, Latex\n", "from Ch8_lib import *" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notations\n", + "À partir du chapitre 8, nous allons introduire une nouvelle notation pour définir les matrices et les vecteurs. Ceci dans le but de pouvoir faire du calcul symbolique ou littéral: c'est-à-dire avec des paramètres comme c'est le cas lorsque l'on cherche à trouver des valeurs propres $\\lambda$.\n", + "\n", + "On utilisera les notations suivantes pour une matrice $A\\in M_{m\\times n}(\\mathbb{R})$ donnée par\n", + "$$\n", + "A=\\begin{pmatrix}a_{11}& a_{12} & \\ldots & a_{1n}\\\\\n", + "a_{21}& a_{22}& \\ldots & a_{2n}\\\\\n", + "\\vdots & &\\ldots &\\vdots\\\\\n", + "a_{m1}& a_{m2}& \\ldots & a_{mn}\\end{pmatrix}\n", + "$$\n", + "\n", + "Progressivement nous allons remplacer l'ancienne notation \n", + "$$\n", + "A=[ [a_{11},a_{12}, \\ldots, a_{1n}],[a_{21},a_{22},\\ldots, a_{n2}],\\ldots, [a_{m1},a_{m2},\\ldots, a_{mn}]]\n", + "$$\n", + "par la nouvelle notation\n", + "$$A=\\text{sp.Matrix}([[a_{11},a_{12}, \\ldots, a_{1n}],[a_{21},a_{22},\\ldots, a_{n2}],\\ldots, [a_{m1},a_{m2},\\ldots, a_{mn}]])\n", + "$$\n", + "\n", + "**Remarque**: il s'agit juste d'ajouter sp.Matrix() autour de l'ancienne notation. Il ne s'agit pas de la seule manière de déclarer une matrice dans Python. Mais afin de simplifier les notations dans ces Notebooks, nous utiliserons ces deux manières." + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Exemple 1**\n", "\n", - "Pour savoir si un vecteur $v \\in M_{n \\times 1} \\ (\\mathbb{R})$ est un vecteur propre de la matrice $A\\in M_{n \\times n} \\ (\\mathbb{R})$, il suffit de vérifier que les vecteurs $v$ et $b = A \\ v$ sont colinéaires. Il est possible de visualiser cela graphiquement pour des vecteurs de dimension $n=2$ où $n=3$." + "Pour savoir si un vecteur $v \\in M_{n \\times 1} \\ (\\mathbb{R})$ est un vecteur propre de la matrice $A\\in M_{n \\times n} \\ (\\mathbb{R})$, il suffit de vérifier que les vecteurs $v$ et $A \\ v$ sont colinéaires. Dans ce cas on aura l'existence d'un réel $\\lambda$ tel que\n", + "$$\n", + "A\\ v=\\lambda v\n", + "$$Il est possible de visualiser cela graphiquement pour des vecteurs de dimension $n=2$ où $n=3$. \n", + "Prenez par exemple\n", + "$$\n", + "A=\\begin{pmatrix}\n", + "0&1\\\\1&0\n", + "\\end{pmatrix} \\text{ et } v=\\begin{pmatrix}-1\\\\-1\\end{pmatrix}\n", + "$$ " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "line": { + "color": "red", + "width": 4 + }, + "mode": "lines+markers", + "name": "$v$", + "type": "scatter", + "x": [ + 0, + 1 + ], + "y": [ + 0, + 1 + ] + }, + { + "line": { + "color": "royalblue", + "dash": "dash", + "width": 4 + }, + "mode": "lines+markers", + "name": "$A \\ v$", + "type": "scatter", + "x": [ + 0, + 2 + ], + "y": [ + 0, + 2 + ] + } + ], + "layout": { + "autosize": true, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "xaxis": { + "autorange": true, + "range": [ + -0.12521150592216582, + 2.1252115059221657 + ], + "type": "linear" + }, + "yaxis": { + "autorange": true, + "range": [ + -0.1464968152866242, + 2.1464968152866244 + ], + "type": "linear" + } + } + }, + "image/png": "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", + "text/html": [ + "
\n", + " \n", + " \n", + "
\n", + " \n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Definition de la matrice A et du vecteur v\n", "# Les vecteurs et matrices sont par défaut rempli de 1. Vous pouvez changer les valeurs. (2D et 3D)\n", - "v = [1, 1]\n", + "v = [1,1]\n", "A = [[1, 1], [1, 1]]\n", "\n", "# Plot\n", "vector_plot(A, v)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercice 1\n", - "Etant donné une matrice carrée $A \\in M_{n \\times n} \\ (\\mathbb{R})$ et un vecteur $v \\in M_{n \\times 1} \\ (\\mathbb{R})$. Déterminez si $v$ est un vecteur propre de la matrice $A$. Si tel est le cas, trouvez la valeur propre $\\lambda \\in \\mathbb{R}$ associée. \n", + "Soient une matrice carrée $A \\in M_{n \\times n} \\ (\\mathbb{R})$, un vecteur $v\\in M_{n \\times 1} \\ (\\mathbb{R})$, et un paramètre $x\\in \\mathbb{R}$. Déterminez si $v$ est un vecteur propre de la matrice $A$. Si tel est le cas, trouvez la valeur propre $\\lambda \\in \\mathbb{R}$ associée. \n", "\n", "Executez simplement chaque cellule et repondez aux questions.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/latex": [ + "Le vecteur $v=\\left(\\begin{matrix}1\\\\1\\\\1\\end{matrix}\\right)$ est-il un vecteur propre de la matrice $A = \\left(\\begin{matrix}1 & 1 & 1\\\\1 & 1 & 1\\\\1 & 1 & 1\\end{matrix}\\right)$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fb968eab6cb24ea3bf287054381100ea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(description='Réponse: ', options=('Oui', 'Non'), value='Oui')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f2ef0f1a82134ec4abb5c8d9fdf1459b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/latex": [ + "Si vous n'arrivez pas à résoudre l'exercice, vous pouvez afficher la solution détaillée." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "408f9ebd193a44a7af98f89654bc4285", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Ici, les matrices ou/et vecteurs peuvent dépendre du paramètre x\n", - "x = sp.symbols('x')\n", - "\n", "# a)\n", - "A_1 = sp.Matrix([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n", - "v_1 = sp.Matrix([1, 1, 1])\n", + "A = sp.Matrix([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n", + "v = sp.Matrix([1, 1, 1])\n", "\n", - "interactiveEigenVector(A_1, v_1)" + "interactiveEigenVector(A, v)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/latex": [ + "Le vecteur $v=\\left(\\begin{matrix}2\\\\-1\\end{matrix}\\right)$ est-il un vecteur propre de la matrice $A = \\left(\\begin{matrix}4 x & 8 x\\\\1 & 2\\end{matrix}\\right)$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d9277125f3a34f9da352962b5c79a37e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(description='Réponse: ', options=('Oui', 'Non'), value='Oui')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8751d12991db4c15b00d9bf34a0e6426", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/latex": [ + "Si vous n'arrivez pas à résoudre l'exercice, vous pouvez afficher la solution détaillée." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eb697613a99f41d38fbea1cce98446cb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "# Ici, la matrice dépend d'un paramètre réel x\n", + "x = sp.symbols('x')\n", + "\n", "# b)\n", - "A_2 = sp.Matrix([[4*x, 8*x], [1, 2]])\n", - "v_2 = sp.Matrix([2, -1])\n", + "A = sp.Matrix([[4*x, 8*x], [1, 2]])\n", + "v = sp.Matrix([2, -1])\n", "\n", - "interactiveEigenVector(A_2, v_2)" + "interactiveEigenVector(A, v)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/latex": [ + "Le vecteur $v=\\left(\\begin{matrix}0\\\\0\\end{matrix}\\right)$ est-il un vecteur propre de la matrice $A = \\left(\\begin{matrix}1 & 2\\\\1 & 2\\end{matrix}\\right)$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41913ed6657a4769aa6e5d20d3f14650", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(description='Réponse: ', options=('Oui', 'Non'), value='Oui')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "822b02cfa7d34f0dbb1b60ef09162003", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/latex": [ + "Si vous n'arrivez pas à résoudre l'exercice, vous pouvez afficher la solution détaillée." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5215ae4a6b41468ba756659dcb1335dc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# c)\n", - "A_3 = sp.Matrix([[1, 2], [1, 2]])\n", - "v_3 = sp.Matrix([0, 0])\n", + "A = sp.Matrix([[1, 2], [1, 2]])\n", + "v = sp.Matrix([0, 0])\n", "\n", - "interactiveEigenVector(A_3, v_3)" + "interactiveEigenVector(A, v)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercice 2\n", - "En utilisant la définition d'une valeur propre donnée plus haut, vérifiez si un nombre donné $\\lambda$ est une valeur propre de la matrice $A \\in M_{n \\times n} \\ (\\mathbb{R})$. Si oui trouvez un vecteur propre correspondant à $\\lambda$.\n", + "En utilisant la définition d'une valeur propre donnée plus haut, vérifiez si un nombre réel donné $\\lambda$ est une valeur propre de la matrice $A \\in M_{n \\times n} \\ (\\mathbb{R})$. Si oui trouvez un vecteur propre correspondant à $\\lambda$.\n", "\n", "##### Méthode: \n", "Posez $A v = \\lambda v \\Leftrightarrow (A - \\lambda I) v = 0 $ et étudiez le nombre de solutions du système.\n", "\n", "- Si le système a une unique solution ($v$ = 0), alors $\\lambda$ n'est pas une valeur propre de la matrice A.\n", "- Si le système a une infinité de solutions, alors $\\lambda$ est une valeur propre de $A$.\n", "\n", "Si $\\lambda$ est bien une valeur propre de $A$, alors n'importe quelle solution non triviale $v$ du système $A v = \\lambda v$ est un vecteur propre associé à $\\lambda$." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/latex": [ + "$\\lambda = 2$ est-elle une valeur propre de la matrice $A =\\left(\\begin{matrix}2 & 0\\\\1 & 2\\end{matrix}\\right) $ ? " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a7794711cd0d4717a25f3c6b0b37da49", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(description='Réponse: ', options=('Oui', 'Non'), value='Oui')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5a905e8d639e4e22ba3baa5911ba24a8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Button(description='Run Interact', style=ButtonStyle()), Output()), _dom_classes=('widge…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# a)\n", "A = sp.Matrix([[2, 0], [1, 2]])\n", "l = 2\n", "interactiveEigenVal(A, l)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# b)\n", "A = sp.Matrix([[1, 0, 1], [0, -1, 2], [1, 0, -1]])\n", "l = -1\n", "interactiveEigenVal(A, l)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# c)\n", "A = sp.Matrix([[2, 3, 1], [1, 0, 3], [1, 1, 1]])\n", "l = 2\n", "interactiveEigenVal(A, l)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# d)\n", "A = sp.Matrix([[2, 3, 0, 4], [0, -3, 1, 2], [0, 0, 1, 2], [0, 0, 0, 0]])\n", "l = 1\n", "interactiveEigenVal(A, l)" ] } ], "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.7.2" + "version": "3.6.9" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }