Python et Algèbre Linéaire TP4 - FR

SFM-3008 – ESIEE Paris
Python et Algèbre Linéaire
TP4
Jean-Claude GEORGES
1 Objectif
1. . Créer la classe Vecteur et utiliser la classe Matrice , y ajouter et tester deux méthodes
(extraction d’un vecteur colonne et multiplication de deux matrices).
2. . Utiliser la classe Matrice pour obtenir une visualisation "fil de fer" d’un dessin se
transformant en 3D
2 Travail préliminaire
Créez un répertoire TP4.
Lancez Idle par l’intermédiaire d’un terminal (menu AccessoiresTerminal, puis idle3).
Créez une classe Vecteur avec les méthodes suivantes :
__init__(self, c0, c1, *c)
crée et initialise une donnée self.__cordonnées (liste
d’au moins 2 float)
__len__(self)retourne la dimension du vecteur (permettra d’utiliser len(v))
__getitem__(self, i)
retourne la ie coordonnée (permettra d’utiliser la notation v[i] )
__setitem__(self, i, x)
modifie la ie coordonnée par la valeur x (permettra d’utiliser
la notation v[i] =x)
__str__(self)retourne la chaîne correspondante au vecteur self, sous la forme
Vecteur_5<2.0, 3.0, 4.0, 5.0, 6.0>"} (permettra d’utiliser print(v))
3 Composition d’applications linéaires / multiplication matricielle
La composition f◦g de deux applications linéaires f et g est caractérisée par le produit
des matrices associées (pour plus de détails, voir le rappel de cours donné en marge).
L’objectif de cet exercice est d’implémenter cette opération de multiplication matricielle.

2TP4
Pour cela, on s’appuiera sur la décomposition de matrices en vecteurs colonnes et en
vecteurs lignes et sur des produits scalaires.
a. Téléchargez le fichier linalg.py , contenant les définitions complètes d’une classe
Vecteur et d’une classe Matrice . Étudiez-les rapidement (c’est sous forme objet, les
programmes écrits dans les trois premiers TP).
b. Ajoutez à la classe Matrice une méthode vecteurColonne(self, i) retournant un Vecteur
ayant pour coordonnées les coefficients de l’instance courante de la classe Matrice dont
le second indice est égal au paramètre de la méthode. En d’autres termes, le Vecteur
retourné correspond à la colonne de l’entier passé en paramètre. Testez cette méthode
c. Ajoutez à la classe Matrice une méthode produitMatriciel(self, autreMatrice) .
Cette méthode agit de la manière suivante :
- si le nombre de colonnes de self est égal au nombre de lignes de autreMatrice , alors
la méthode retourne une nouvelle Matrice qui est le produit de l’instance courante par
le paramètre.
- sinon, la méthode déclenche une exception ( raise Exception()) pour indiquer que
l’opération ne peut pas être effectuée.
d. Testez votre méthode avec la matrice 2×3 211
423!
et la matrice 3×2
−1 2
3 2
−1 2 
Rappel de cours
Soient n , m et k trois entiers naturels. Soit f une application linéaire
de Rndans Rmet gune application linéaire de Rmdans Rk.
Définition 1(composée). La composée de f et g , notée g◦f , est une
application de Rn dans Rk qui associe à tout vecteur u de Rn le vecteur v
de Rk obtenu en appliquant f à u , puis g au résultat obtenu, c’est-à-dire
v=g(f(u)).
Propriété 1.La composée g◦fde fet gest une application linéaire.
D’après la propriété 1, la composée g◦f est une application linéaire
de Rn dans Rk . Il existe donc une matrice de taille k×n qui
caractérise cette application. Comme indiquée par la propriété 3ci-
dessous, le produit matriciel permet précisément d’obtenir cette matrice
caractéristique à partir des matrices caractéristiques de fet g.
Soient F et G les deux matrices caractéristiques des applications f et g .
Notons que Fet Gsont donc respectivement de taille m×net k×m.
Définition 2(produit matriciel). Le produit (matriciel) de G par F ,
noté G×F , est la matrice de taille k×n telle que, pour tout indice i
compris entre 0 et k−1 et tout indice j compris entre 0 et n−1 , le
coefficient [G×F]i,j est le produit scalaire du ie vecteur ligne de G avec
le jevecteur colonne de F:
[G×F]i,j=Gi,..F.,jT
où Gi,. désigne le ie vecteur ligne de G et F.,j désigne le je vecteur
colonne de F.
Propriété 3. G ×Fest la matrice caractéristique de l’application g◦f.
En d’autres termes, cela signifie que si l’on veut trouver l’image v d’un
vecteur u par la composée g◦f de f et g , on peut procéder de deux
manières différentes :
a. on obtient d’abord l’image w=f(u) de u par f en multipliant F par u
(c’est-à-dire, w=F.u ), puis on obtient l’image v=g(w) de w par g
(donc v=g(f(u))) en multipliant Gpar w(c’est-à-dire, v=G.w) ;
b. on obtient d’abord la matrice H caractéristique de l’application g◦f
en multipliant G par F (c’est-à-dire, H=G×F ), puis on obtient
l’image de upar g◦fen multipliant Hpar u((c’est-à-dire, v=H.u).
Lorsque l’on souhaite trouver l’image d’un unique vecteur par g◦f ,
la méthode (a) est moins coûteuse que la méthode (b). On pourra
notamment vérifier qu’elle nécessite un moins grand nombre d’opérations.
En revanche, la méthode (b) est nettement moins coûteuse que la
méthode (a) pour trouver les images de plusieurs (plus que m ) vecteurs
par g◦f car le produit de F par G ne doit alors être effectué qu’une
seule fois. Cette situation sera illustrée dans l’exercice 3où l’on souhaite
trouver l’image des 8 coins d’un cube (c’est-à-dire, 8 vecteurs de R3 ) par
une composée d’applications linéaires.
4 Applications à la visualisation d’objets animés en 3dimensions
a. Téléchargez le fichier anim3d.py dans votre répertoire de travail.
b. Exécutez-le sous Python. Décrivez ce que vous voyez apparaître dans la fenêtre qui
s’affiche à l’écran ? Expliquez pourquoi ce que vous voyez correspond bien à un cube.
c. L’objectif de cette question et des deux suivantes est de produire d’autres visualisations
(différents angles de vue et facteurs de grossissement) du cube créées par la fonction
dessine3D() . Pour cela, on peut tourner le cube, changer sa taille, ou plus généralement
appliquer à ses sommets n’importe quelle application linéaire.
Écrivez une fonction def applique(matrice, liste_de_points) qui étant donné une
liste de points donnés par leurs coordonnées, retourne la liste des points résultants de la
SFM-3008 JCG

TP43
transformation par l’application linéaire associée à la matrice (on suppose que les points
de la liste sont tous en dimension 3 et que la matrice est de taille 3 ×3) ;
Principe : pour chaque point de la liste, créer le vecteur correspondant, lui appliquer la
matrice et ajouter les coordonnées du vecteur résultant à une liste (vide au départ)
d. Créez une matrice 3×3 de la rotation de π/5 autour de Ox et appliquez-la à une liste
de points : [(0,0,0), (1,1,1), [2,3,1)]. Donne-t-elle le résultat attendu
[[0.00, 0.00, 0.00], [1.00, 0.22, 1.40], [2.00, 1.84, 2.57]] ?
e. La fonction applique_dessin(matrice, dessin) utilise la fonction ci-dessus pour créer
la liste des lignes d’un dessin modifié par la matrice. Elle peut être utilisée pour créer
un dessin complexe ou une animation grâce aux fonctions dessine3D et anime3D.
cube_avant = [((0.5,0,0),(0.5,1,0)),
((0.5,1,0),(1.5,1,0)),
((1.5,1,0),(1.5,0,0)),
((1.5,0,0),(0.5,0,0)),
((0.5,0,1),(0.5,1,1)),
((0.5,1,1),(1.5,1,1)),
((1.5,1,1),(1.5,0,1)),
((1.5,0,1),(0.5,0,1)),
((0.5,0,0),(0.5,0,1)),
((0.5,1,0),(0.5,1,1)),
((1.5,1,0),(1.5,1,1)),
((1.5,0,0),(1.5,0,1)),
]
Éxécutez la fonction applique_dessin avec la matrice précédente et les arêtes du cube
données ci-contre. Stockez le résultat dans cube_apres
f. Exécutez la méthode dessine3D([cube_avant, cube_apres]) . Vérifiez que l’affichage
est conforme à la rotation programmée. Essayez avec une rotation autour de chacun des
axes (programmer celles autour de 0yet Oz).
g. Même question qu’en (f.) mais avec une homothétie.
h. Même question qu’en (f.), mais avec une transformation qui est la composition d’une
rotation de π/4 autour de l’axe Ox et d’une rotation de π/4 autour de l’axe Oy .
Composez ensuite la transformation obtenue avec une rotation autour de l’axe Oz ,
et testez de nouveau l’affichage.
i. L’objectif de cette dernière question est d’obtenir une visualisation animée du cube.
Pour cela, il faut décomposer l’animation en étapes élémentaires et visualiser le cube à
chacune de ces étapes élémentaires. Chaque étape élémentaire correspond à un petit
déplacement du cube, c’est à dire à appliquer au cube une application linéaire qui
déplace très légèrement ses sommets (par exemple, la transformation de la question (f.)
avec une valeur de 0, 01 radian au lieu de π/5 ). Créez dans une variable res la liste
des cubes correspondant à chacun des mini-déplacements. Utilisez anime3D(res) pour
visualiser l’animation. Testez avec différentes applications linéaires.
d’après le sujet écrit par Jean Cousty, Benjamin Perret et Leïla
Reille pour l’unité A3PAL à ESIEE Paris
JCG SFM-3008