{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n",
" Si c'est votre première visite dans ce TP, lisez attentivement chacun des points détaillé après ce paragraphe.
\n",
" Si vous avez déjà commencer à travailler sur ce TP et que vous souhaiter vous déplacer rapidement dans une partie précise vous pouvez choisir la partie que vous souhaitez rejoindre ci-dessous.
\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
\n",
" La technologie jupyter permet d'exécuter du code python par un simple clique sur Executer ci-dessus.
\n",
" Les morceaux de code de cette page sont interprétées case par case. Pour savoir quelle case a été interprétée avant une autre, il suffit de repérer le numéro devant la case.
\n",
" Une fois qu'une case a été interprétée (=exécutée), la page garde en mémoire les variables et fonctions lues
\n",
" La plateforme propose quelques outils de purge de la mémoire : \n",
"
\n",
" Pour ne pas perdre votre travail pensez à le sauvegarder régulièrement. Par défault, la sauvegarde par un clic sur la disquette en haut à gauche de page, ou par le racourci clavier classique ctrl+S
\n",
" est une sauvegarde en local, sur le serveur de jupyter. Vous pouvez et devez très régulièrement sauvegarder votre travail sur votre support personnel de sauvegarde (clef USB, se l'envoyer par mail etc). Ce faisant vous disposerez d'un fichier .ipynb (IPYthon NoteBook) qu'il vous suffira de recharger pour avancer. Après le rechargement assurez vous que les fonctionnalités anciennement developpées et variables utilisées sont bien dans la mémoire de la page (en rééxecutant les cases, ou plus rapidement par Kernel > Restart & Run All.
A NOTER : vous pouvez travailler sur le tp (et tout autre fichier .ipynb) hors connexion en installant une version local du notebook de jupyter. Il faut que votre machine possède un interpreteur de python et que vous soyez connecter à internet.\n", "
pip install jupyterlab
jupyter notebook
\n", " Informatiquement une matrice sera considérée comme une liste à deux entrées. Le premier indice correspondera au numéro de la ligne et le second au numéro de la colonne. Attention ces numéros sont informatiques : ils commencent à $0$ et non $1$.\n", "
\n", "printM
: permet d'afficher une matrice, comme un print
... mais pour les matricesMat0
: renvoie la matrice nulle\n",
"Cette fonction renvoie la matrice nulle.
ATTENTION : Z=Mat0(3,2)
créera dans la mémoire la matrice Z
. Pour l'utiliser, il suffira de l'utiliser comme n'importe quelle variable. En particulier, pour l'afficher, il faudra appeler printM(Z)
.
Le premier paramètre de cette fonction représente le nombre de ligne et le second le nombre de colonne. Ce second paramètre est optionnelle, cela signifie que s'il n'est pas spécifié, il vaudra -1
. Si vous observez la ligne 8, vous verrez que dans ce cas, la fonction s'appelle elle-même et met comme valeur du second paramètre le nombe de ligne. Cela signifie (que tu vivras ta vie, sans aucun souciiiiis, philosophiiiiiie) que Z=Mat0(5)
renverra une matrice carrée nulle à 5 lignes et 5 colonnes.
MatRand
: Tire une matrice au hasardMatAdd
et MatSous
renvoyant l'addition et la soustraction de matrice. Avec ces fonctions, vérifiez vos calculs précédents."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def MatAdd(A, B) :\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def MatSous(A, B) :\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Correction exercice\n",
"A=[\n",
" [1, 2],\n",
" [3, 4]\n",
"]\n",
"B=[\n",
" [-1, 0], \n",
" [5, 0]\n",
"]\n",
"C=[\n",
" [-1, 0, 2], \n",
" [1, 2, 3], \n",
" [4, 9, 7]\n",
"]\n",
"D=[\n",
" [12, 99, 11], \n",
" [-2, 2, 22], \n",
" [0, 0, -1]\n",
"]\n",
"E=[\n",
" [83, 19, 99], \n",
" [2, 2, -4], \n",
" [1, 1, -2]\n",
"]\n",
"\n",
"print(\"A+B =\")\n",
"printM(MatAdd(A, B))\n",
"\n",
"print(\"A+C =\")\n",
"printM(MatAdd(A, C))\n",
"\n",
"print(\"C+D =\")\n",
"printM(MatAdd(C, D))\n",
"\n",
"print(\"D-C =\")\n",
"printM(MatSous(D, C))\n",
"\n",
"print(\"D-E =\")\n",
"printM(MatSous(D, E))\n",
"\n",
"print(\"E+D =\")\n",
"printM(MatAdd(E, D))\n",
"\n",
"print(\"E-B =\")\n",
"printM(MatSous(E, B))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"MatProd
qui renvoie le produit des matrices passé en paramètre. Avec ces fonctions, vérifiez vos calculs précédents."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def MatProd(A, B) :\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Correction exercice\n",
"print(\"Question 1 :\")\n",
"X=[\n",
" [2, 1], \n",
" [1, -1]\n",
"]\n",
"Y=[\n",
" [1, -1], \n",
" [1, 2]\n",
"]\n",
"printM(MatProd(X, Y))\n",
"\n",
"print(\"Question 2 :\")\n",
"Y=[\n",
" [1, 0, 9], \n",
" [3, 2, 1]\n",
"]\n",
"printM(MatProd(X, Y))\n",
"\n",
"print(\"Question 3 :\")\n",
"Y=[\n",
" [1, 0, 9], \n",
" [3, 2, 1], \n",
" [2, 0, -1]\n",
"]\n",
"printM(MatProd(X, Y))\n",
"\n",
"print(\"Question 4 :\")\n",
"X=[\n",
" [2, 1, 0], \n",
" [1, -1, 1]\n",
"]\n",
"printM(MatProd(X,Y))\n",
"\n",
"print(\"Question 5 :\")\n",
"X=[\n",
" [2, 1, 0], \n",
" [1, -1, 1], \n",
" [3, 1, -1]\n",
"]\n",
"printM(MatProd(X, Y))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"\n",
"MatId(n)
qui renvoie la matrice identité."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def MatId(n) : \n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Tests\n",
"N=[2, 3, 10]\n",
"for n in N : \n",
" print(\"Matrice identité en dimension\", n)\n",
" printM(MatId(n))\n",
"\n",
" \n",
"A=[\n",
" [1, 2],\n",
" [3, 4]\n",
"]\n",
"print(\"Vérification de la proposition :\")\n",
"printM(A)\n",
"print(\"multipliée par l'identité donne\")\n",
"printM(MatProd(A, MatId(len(A))))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Vous voyez flout, vous commencez à trembler et êtes témoin de votre inquiétude grandissante : \"Jusque là, ça allait ! J'arrivais à comprendre... Mais qu'est-ce qui se passe ? Qu'est-ce que c'est que ce charabia.\" Vous avez bien raison de trembler pauvre humain. Vous voilà confronté à une première définition térrifiante. Mais pas d'inquiétude sur ce que vous venez de lire... vous pouvez immédiatement l'oublier.
\n", "\n", "Mais pourquoi avoir fait couler une goute de sueur froide le long de votre dos ? Déjà, parce que ça m'amuse beaucoup mais surtout pour vous montrer que cacher derrière ce que nous allons étudier se trouve une défintion térrifiante mais bien ficelée. Garder en tête que c'est LA définition de déterminant et \"OUI !\" s'il fallait vraiment l'étudier il faudrait qu'on parle de groupe symétrique et de signature. Mais dans le cadre de ce cours nous nous plaçons dans la pratique et dans la pratique, pas la peine de s'embeter avec cette affreuse définition.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Issue de la défintion on montre les propriétés suivantes. Nous verrons que dans la pratique elles sont tout à fait suffisantes.
\n", "\n", "Avant d'arriver au cas pratique du calcul du déterminant, armons-nous d'une petite définition
\n", "\n", "mineur(A, p, q)
qui renvoie le mineur d'ordre $p$, $q$ de $A$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def Mineur(A, p, q) :\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Test\n",
"\n",
"M=[\n",
" [1, 2, 1], \n",
" [2, 0, 1], \n",
" [1, 1, -1]\n",
"]\n",
"\n",
"#Vous pouvez vous \"amusez\" à changer les valeurs de p et q pour vous assurez que votre code est bon\n",
"p=0\n",
"q=1\n",
"\n",
"print(\"Le mineur d'ordre (\", p+1, \", \", q+1, \") de la matrice \")\n",
"printM(M)\n",
"print(\"est la matrice\")\n",
"printM(Mineur(M, p, q))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Voila LE théorème qui va nous permettre de calculer un déterminant
\n", "\n", "det(A)
renvoyant le déterminant de la matrice $A$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def det(A) :\n",
" return 0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Tests\n",
"nombre_de_test=3\n",
"for k in range(nombre_de_test) : \n",
" M=MatRand(randint(2, 3)) #On tire au hasard une matrice carré de taille 2 ou 3\n",
" print(\"Le déterminant de la matrice :\")\n",
" printM(M)\n",
" print(\"vaut\", det(M), end='\\n-----------------------------------------------------\\n')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"MatCofact(A)
qui renvoie la matrice des confacteurs de A
."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def MatCofact(A) :\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Test\n",
"M=[\n",
" [3, 4, 5], \n",
" [-1, 3, 6], \n",
" [3, 4, -5]\n",
"]\n",
"print(\"La matrice des confacteur de\")\n",
"printM(M)\n",
"print(\"est\")\n",
"printM(MatCofact(M))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"MatInv(A)
qui renvoie, lorsque c'est possible, l'inverse de la matrice A
."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def MatInv(A) :\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Test 1\n",
"M=[\n",
" [3, 4, 5], \n",
" [-1, 3, 6], \n",
" [3, 4, -5]\n",
"]\n",
"print(\"L'inverse de\")\n",
"printM(M)\n",
"print(\"est\")\n",
"printM(MatInv(M))\n",
"\n",
"#Test 2\n",
"M=[\n",
" [1, 2, 1],\n",
" [1, 2, -1],\n",
" [-2, -2, -1]]\n",
"print(\"L'inverse de\")\n",
"printM(M)\n",
"print(\"est\")\n",
"printM(MatInv(M))\n",
"\n",
"#Test 3\n",
"M=[\n",
" [1, 2, 1],\n",
" [1, 2, -1],\n",
" [2, 4, 0]\n",
"]\n",
"print(\"L'inverse de\")\n",
"printM(M)\n",
"print(\"est\")\n",
"printM(MatInv(M))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n", "\n", "Si tu es diligent et sage, ô étranger, calcule le nombre de têtes de bétail du troupeau du soleil qui autrefois paissait dans les champs de l'île de Thrinacian... ." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Bon chance !" ] } ], "metadata": { "hide_input": false, "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.0" } }, "nbformat": 4, "nbformat_minor": 2 }
\n", "\n", "Le dieu soleil (Hélios) possède un troupeau de taureaux et de vaches, dont une partie était blanche, une partie noire, une partie pie, et la quatrième jaune.
\n", "Pour les taureaux:\n", "\n", "
\n", "Pour les vaches:\n", "- Le nombre de ceux qui étaient blancs dépassait le nombre des jaunes de la moitié plus un tiers du nombre des taureaux noirs.
\n", "\n", "- Le nombre des taureaux noirs dépassait le nombre des taureaux jaunes d'un quart plus un cinquième du nombre des taureaux pie.
\n", "\n", "- Enfin le nombre des taureaux pie dépassait celui des jaunes d'un sixième plus un septième du nombre des taureaux blancs.
\n", "\n", "
\n", "- Le nombre des blanches était égal au tiers augmenté du quart du nombre total des bovins noirs.
\n", "\n", "- Le nombre des vaches noires, au quart augmenté du cinquième du nombre total des bovins pie.
\n", "\n", "- Le nombre des vaches pie, au cinquième augmenté du sixième du nombre total des bovins jaunes.
\n", "\n", "- Le nombre des vaches jaunes était égal à un sixième plus un septième du nombre des bovins blancs.
\n", "