TD — Algèbre II 1 : introduction au langage MATLAB

🔊 Écouter la source audio

Couverture : de 00:00:00 à 01:35:39 sur un audio de 01:35:42. Pause de 00:29:56 à 00:33:29 (3 min 30 s) et à 00:56:49–00:57:52 ; le TD est donc majoritairement du travail d’étudiants, le prof ne parle que par intermittence pour répondre aux questions.

Support : TD1 Introduction Matlab.pdf + main.m (découpé en 5 sections) + permutation.m (fonction à compléter), tous dans Bac 2/ALG II/Exo/td/.

PARTIE 1 — Rappel des commandes de base — [00:00:00]

1. Créer un vecteur avec un incrément — [00:00:00]

1:2:10 : « je vais commencer à 1, par pas de 2 jusqu’à 10, donc je vais faire 1, 3, 6, etc. » — ⚠️ il se trompe oralement et se corrige : ce n’est pas 1, 3, 6 mais 1, 3, 5, 7, 9 (« je zappe le 2 à chaque fois »).
⚠️ Piège : « ici, vous avez vu qu’il n’est pas allé jusqu’à 9… Une fois qu’il arrive à 9, il ne peut pas aller à 11, donc il s’est arrêté avant. » → la borne de la séquence est inclusive quand le pas tombe juste, sinon on s’arrête avant de la dépasser.
10:-2:1 : l’autre sens, « pas de moins de 2 ».
« Je peux aussi créer mon vecteur qui va de, entre guillemets, des croissants » → la syntaxe à trois points, ` $a : pas : b$ , un vecteur croissant si le pas est positif.

2. Vecteur ligne × vecteur colonne : l’orientation par défaut — [00:01:02]

« De base, les vecteurs en MATLAB sont encodés sous un format qui est un format ligne », c’est-à-dire « exactement comme vous avez vu en algèbre, un élément de type $\underline{1 \times n}$ ».
Dans le workspace, on lit 1 × 10, 1 × 5, 1 × 5 pour ses vecteurs, alors que « $D$ , lui, il est encodé en format $2 \times 1$ » (une matrice écrite à la main).
« Quand vous mettez un prime à côté d’un vecteur, ça va juste le transposer ».

a = (1, 2, 5)^{⊤} ⟹ a^{'} = (1, 2, 5) (on t r an s p ose le vecteur, c’est tout)

3. Les trois commandes de création de matrices — [00:01:51]

Le prof fait deviner la syntaxe avant de l’exécuter (« qu’est-ce qu’elle va faire à votre avis ? c’est ça… ») :

Commande	Effet
`zeros(2,2)`	matrice carrée $2 \times 2$ de $0$
`ones(2,3)`	$2$ lignes, $3$ colonnes, que des $1$
`rand(1,3)`	$1$ ligne, $3$ colonnes, nombres aléatoires entre 0 et 1

« Ça fait exactement ce qu’on a mis ici. » → dans le workspace : 2 × 2, 2 × 3, 1 × 3.
⚠️ La forme générale est rand(m,n) = $m$ lignes, $n$ colonnes (et non l’inverse) — c’est exactement l’erreur de la section 4.

4. Écrire une matrice : ligne par ligne — [00:02:43]

« Pour encoder une matrice, vous avez vu qu’on encode une matrice ligne par ligne. Donc si je veux créer la matrice $D$ … 1, 2 et puis 3, 4, on remplit toujours la première ligne. Dès qu’on arrive à la première ligne, point virgule. Deuxième ligne, point virgule. »
⚠️ Le ; a trois fonctions qu’il faut séparer dans sa tête :
1. séparer deux lignes de la saisie d’une matrice ;
2. terminer une instruction sans afficher le résultat (« ça ne s’est pas affiché ») ;
3. ** commenter** la fin d’une ligne de code (quand il est en fin de ligne).

5. L’avantage de MATLAB : le travail vectoriel — [00:03:13]

« MATLAB c’est très avantageux parce qu’on peut travailler vectoriellement. Dans beaucoup de cas, vous faites souvent des boucles quand vous travaillez sur des matrices pour aller chercher les éléments $i$ , $j$ du tableau. »
« L’avantage de MATLAB, c’est qu’on peut sélectionner toute une ligne d’une matrice avec une seule commande. »

6. Sélectionner une ligne : la convention ligne, colonne — [00:03:40]

Avec $E$ une matrice de $0$ :

« Si je fais E(1,2:) — ⚠️ le deux-points a été dicté « points » — « ça veut dire que dans ma matrice $E$ , je vais sélectionner la première ligne ».
La justification est purement mnémotechnique : « une matrice en MATLAB est toujours encodée de la même manière. Quand j’écris $E (\cdot)$ , tout ce qu’il y a ici [avant la virgule], ça concerne les colonnes et tout ce qu’il y a ici [après], les lignes. »

E (1, 2 :) = « premi \overset{e}{ˋ} re ligne, toutes les colonnes »

⚠️ Donc A(i,j) = $i$ est la ligne, $j$ est la colonne. Le prof y revient trois fois dans la séance parce que c’est la source d’erreur numéro un des étudiants (§ 11).

7. Assigner une ligne : la taille doit être compatible — [00:04:18]

« Et dans la première ligne, avec toutes les colonnes, je vais venir mettre ici le vecteur ligne $[1, 1]$ . »
⚠️ « Attention : dans la première ligne, si vous voulez, ça me permet juste de substituer la première ligne. Dans la première ligne, je dois faire attention de mettre des choses qui sont compatibles avec la taille de ma matrice. Ne mettez pas dans la première ligne un élément de la forme $1 \times 3$ , ça ne va pas aller. »

E (1, 1 :) = [11] et surtout pas E (1, 1 :) = [111] ⟹ error

8. Multiplier tout un vecteur par un scalaire — [00:05:02]

« En MATLAB, on peut multiplier tout un vecteur par une commande en faisant $2 \times$ l’élément. Ça va considérer le produit terme à terme, avec le scalaire devant le vecteur. »

2 \cdot v_{1} v_{2} ⋮ v_{n} = 2 v_{1} 2 v_{2} ⋮ 2 v_{n} (pas de produit matriciel, un scalaire ne change rien)

9. `if` / `elseif` / `else` / `end` et `input` — [00:05:32]

« De manière générale, on a des if, des end, mais on peut aussi enchaîner des elseif. » → if … elseif … elseif … else … end.
« Je vais parcourir le premier if, puis je regarde. Tant que je ne vais pas rentrer dans le deuxième, je continue. »
⚠️ « Attention : dans un if, le dernier else… il faut qu’il y ait un else à la fin, et puis un end. »
input('Entrez votre âge : ') : « c’est juste une interface avec l’utilisateur, ça vous permet d’entrer quelque chose ».
Démonstration en direct : il entre 20, et le programme affiche « plus grand que 18 ». → structure if age > 18 … elseif age < 0 … elseif age == 0 … else … end.

10. Les boucles : `for`, `while`, `break`, `continue` — [00:06:41]

« Est-ce que vous avez vu les boucles for et while aussi ? » (les étudiants répondent peu) « Pas spécialement… je ne sais plus comment fonctionnent les boucles en Python, mais les boucles for en MATLAB… »
for i = 1:5 : « rappelez-vous, quand on met 1:2:5, c’est globalement $1, 2, 3, 4, 5$ ». Le nom de la variable d’itération est libre (« fort i, l’indice de mon for »).
⚠️ Le end ferme les deux : « j’ai plusieurs end pour fermer le if, le for et le if ». C’est une question récurrente de la séance (un end de trop ou de moins).

10.1. `continue` vs `break` — [00:07:42]

Boucle de $1$ à $10$ avec deux conditions : if j == 6, continue; end puis if j == 7, break; end.

continue : « on n’exécute que ce qui se passe… on ne va plus dans la boucle, on va directement à l’itération suivante ». Dit autrement : « quand $j$ vaut 6, je ne vais rien faire, je vais directement à l’itération suivante » → le compteur passe à $7$ sans que $6$ soit affiché.
break : « il arrête complètement la boucle ».
Résultat affiché à l’écran : 1 2 3 4 5 7 (le prof s’est d’abord trompé en annonçant 1, 2, 3, 5, puis se corrige en executant).

j = 6 : continue ⟹ 6 non affich \overset{e}{ˊ}, on passe \overset{a}{ˋ} 7; j = 7 : break ⟹ on sort, rien apr \overset{e}{ˋ} s

10.2. `while` : la différence avec `for` — [00:08:48]

« De manière générale, même en Python, while et for, c’est la même chose. Sauf que dans le while, on a un critère d’arrêt. »
while i < 5 : « tant que $i$ est plus petit que 5, je continue ».
⚠️ « Dans une boucle while, on peut faire attention de toujours initialiser l’indice et de l’incrémenter dans le while », sinon la condition ne change jamais.
Synthèse du prof : « le for va tout lister ; le while peut être utilisé quand on a un booléen, quand on veut regarder si quelque chose est vérifié ou pas. Le for, c’est automatiquement avec des indices. »

10.3. `while true` : la boucle infinie et son soupir — [00:09:34]

« Qu’est-ce qui se passe si je mets un while true ? » → « true, je ne sais pas si vous l’avez vu dans votre introduction, mais true c’est juste un booléen. C’est un booléen qui vaut 1 tout le temps. »
⚠️ « Si jamais je mets while true, ça va donner quoi comme programme ? → C’est quelque chose qui tourne à l’infini. Donc, pour éviter que ça tourne à l’infini, on doit venir stopper : un break dans la boucle va venir stopper à un moment donné. »
Démonstration : « si $j$ vaut 5, on va incrémenter $j$ ; sinon, dans tous les cas, on va venir incrémenter la valeur de $j$ ; si on arrive à 7, on va break, sortir de la boucle. »
Traçage : $j = 0$ → $j + = 1$ → affiche $1, 2, 3, 4, 5$ → $j$ incrémenté à $6$ (non affiché, car le if) → affiche $7$ → break.
« Ça va afficher exactement la même chose que la boucle précédente — c’est juste une autre manière de coder. »

11. Ce qu’il faut retenir pour le cours — [00:11:01]

« Ce sont vraiment les grosses choses que vous allez avoir besoin… dans le cadre du cours qui va beaucoup vous être utile, c’est les matrices (notamment de la UEM), les boucles for et while pour accéder aux éléments dans une matrice, et les opérations sur les lignes de la matrice. »
« En MATLAB, on aime bien privilégier des opérations sur des lignes et des colonnes. »

12. Les sous-blocs — [00:11:28]

« Vous pouvez même accéder à des sous-blocs d’une matrice. Si en MATLAB vous mettez A(1:2, 1:2), ça va vous donner, imaginez que vous avez une matrice de taille $3 \times 3$ , ça va vous donner ligne 1 jusqu’à 2, colonne 1 jusqu’à 2 → vos sous-blocs. »

A (1 : 2, 1 : 2) = le coin haut-gauche 2 \times 2 de A

« C’est pour ça que MATLAB c’est quand même bien quand on travaille avec des outils qui sont plutôt vectoriels, comme des matrices, des vecteurs, etc. C’est très facile d’utilisation. »

13. `size` — [00:12:12]

« La fonction end, on ne va pas le faire maintenant, ça ne sert à rien pour le moment. » ⚠️ Attention : le mot dicté « endel » est ici le mot anglais end — et non le end de fermeture des boucles du § 10. C’est le seul usage anglais du cours.
« Alors la fonction size elle est pas mal, parce que vous l’avez vue aussi je pense. size va vous donner la taille d’un objet que vous avez rentré en arrière : le nombre de lignes, le nombre de colonnes. »
⚠️ « Si je renvoie un vecteur, il va aussi me renvoyer le nombre de lignes, et de colonnes → donc il y en aura déjà une qui sera fixée à 1. »
Exemple : x = -2:0.1:2 → « il me dit qu’il a 41 lignes et 1 colonne » (car $\frac{2 - ( - 2 )}{0 , 1} + 1 = 41$ ).

size(x) = [411] car x = - 2 - 1, 9 ⋮ 2

14. `x'x` (scalaire) vs `xx'` (matriciel) vs `x.^2` (terme à terme) — [00:13:00]

C’est le passage le plus important de la partie 1.

« Ce qui est pas mal dans MATLAB, c’est que le produit, pour autant que vos objets ici soient bien définis, il va faire le produit usuel auquel on pense. »
Scalaire : « si je fais x' * x → x' sera un vecteur ligne et x un vecteur colonne → ça va me donner le produit scalaire ».
Terme à terme : « quand on fait x.^2 sur un vecteur ou une matrice, ça va élever tous les éléments au carré ».
« Pour bien venir mettre le point devant, ça va juste élever terme à terme l’élément à la puissance $α$ que vous avez considéré. »

x^{'} x = ligne [x_{1} \dots x_{n}] colonne x_{1} ⋮ x_{n} = i = 1 \sum n x_{i}^{2} = ∥ x ∥^{2} (scalaire)

x x^{'} = colonne x_{1} ⋮ x_{n} ligne [x_{1} \dots x_{n}] = x_{1}^{2} x_{2} x_{1} ⋮ x_{n} x_{1} x_{1} x_{2} x_{2}^{2} ⋮ x_{n} x_{2} \dots \dots ⋱ \dots x_{1} x_{n} x_{2} x_{n} ⋮ x_{n}^{2} = x x^{' ⊤}

x .^{2} = [x_{1}^{2} x_{2}^{2} \dots x_{n}^{2}] (terme \overset{a}{ˋ} terme, PAS le produit matriciel)

« Et bien en effet, [pour $x x^{'}$ ] ça va me donner la matrice résultante du produit de mon vecteur colonne par mon vecteur ligne. »
Généralisation : « si vous faites deux matrices de taille adéquate, donc $M_{n} \times M_{p}$ , ça va bien me donner le produit matriciel des deux matrices. »

rectangulaire M_{n \times p} \cdot rectangulaire P_{p \times q} = R_{n \times q} compatible ⟺ (nb de colonnes de la 1re) = (nb de lignes de la 2re)

15. Sélectionner des colonnes, et le vecteur « tout aplati » — [00:14:38]

« Ici, de nouveau, avec la commande size, on peut aller chercher la taille de ces éléments. » ⚠️ « Mais on se doute qu’elle peut être [faire une erreur] ».
⚠️ Ordre des indices : « Je peux venir chercher trois lignes… je peux venir chercher non pas une seule colonne, mais certaines colonnes. Quand je mets A(:, 2:4), ça veut dire que je prends toutes les lignes et je vais venir chercher ici la colonne 2, 3, 4. »

A (:, 2 : 4) = toutes les lignes, colonnes 2, 3 et 4

« Si j’ai fait les lignes là, j’ai fait $i = 1$ donc je suis sur la première ligne, et quand j’ai la première ligne j’ai fait toutes les colonnes ; puis j’ai passé la deuxième ligne, puis j’ai fait toutes les colonnes. Si j’inverse les deux, j’ai fait la première colonne, puis j’ai fait toutes les lignes. » → l’inversion $A (r, c) \mapsto A (c, r)$ est un cas particulier de la symétrie (§ 20).

16. `help` : la documentation de toute fonction — [00:49:29]

⚠️ Flashback : cette commande est montrée plus tard dans la séance, à 00:49:29, au milieu de l’Exercice 1. Remontée ici pour la cohérence du rappel.

« De manière générale, si vous avez un doute sur comment fonctionne une fonction, pour MATLAB spécifiquement, imaginez size : vous voulez avoir plus d’infos sur size ? Dans votre fenêtre de commandes, vous pouvez écrire help size et Enter, et il va vous donner toute la documentation de cette fonction — y compris les spécificités sur ce qu’on peut faire là-dedans. »
« Et ça marche quelle que soit la fonction : size, max, etc. »

17. Rassurant : « c’est en s’exerçant que ça vient » — [00:15:34]

« C’est vraiment en s’exerçant que vous allez voir que ça va venir, le cotage avec la clé [le repérage de la bonne case]. » ⚠️ Le mot est indistinct ; le sens est clair : lire et écrire dans une matrice via ses indices.
« Vous allez parfois galérer sur certains trucs au premier TD, puis au dernier vous allez dire « comment j’ai bugué sur les premiers TD », comme dans n’importe quel langage. »

PARTIE 2 — Organisation du TD et consignes — [00:15:48]

18. L’énoncé et le fichier `main.m` — [00:15:58]

« Ce que je vais vous proposer, c’est d’attaquer les exercices. Vous avez vu qu’il y a un fichier qui s’appelle « TD1 Introduction Matlab », ça c’est globalement l’énoncé du TD d’aujourd’hui. »
« Si vous n’arrivez pas à faire tout aujourd’hui, il n’y a pas de galère, vous finissez chez vous. »
⚠️ Très important : « Vous ne serez pas évalués sur quelque chose comme ça à l’examen, pas du tout — c’est pour vous familiariser avec MATLAB. »

19. L’arborescence à créer — [00:16:44]

« À travers cette fiche, j’ai repris la liste de certains exercices qui sont pertinents pour vous familiariser avec MATLAB, qui vont beaucoup nous aider à travers MATLAB. »
« Avant toute chose, vous pouvez créer un fichier — un dossier — qui s’appelle mon_fichier, typiquement comme je l’ai fait sur certains, un dossier Algèbre linéaire 2. Et dans ce dossier, vous venez mettre exactement tout ce que vous avez téléchargé. »

mon_fichier/ {main.m (d \overset{e}{ˊ} coup \overset{e}{ˊ} en sections), permutation.m (fonction), Commandes Matlab/, Exercices/

« Dans le même dossier, vous avez les commandes avancées, mais aussi un fichier qui s’appelle exercice. Et dans exercice, vous avez un fichier qui s’appelle main.m. »
« Dans le fichier main.m, vous allez voir que c’est un fichier qui est découpé en différentes sections. Chaque section est attribuée à un exercice. »

20. ⚠️ LA CONSIGNE DE SAUVEGARDE — [00:17:46]

« ⚠️ Ah oui, là, il faut ouvrir vos oreilles. Pour une raison qui m’échappe, ces ordinateurs ne sauvegardent pas vos sessions. Et donc, à chaque fois que vous avez fini un code en TD avec moi, pensez à l’envoyer par mail ou le déposer sur un Dropbox que vous avez, ou un Drive. Parce que quand vous allez rallumer le PC la saison prochaine, vous aurez perdu tout ce que vous avez fait. »

« Et parfois, certains codes qu’on va utiliser — par exemple au TD2, on va pouvoir les réutiliser au TD7. J’essaierai de vous le signaler dans la mesure du possible à chaque fin de TD. Et n’oubliez pas de faire ça. »

21. Le mode « deux fenêtres » du prof — [00:19:00]

« Je ne vais pas forcément (distribuer) la solution des exercices parce que chacun va avancer à un rythme qui lui est propre. Mais j’avais pris une solution de ces exercices sur le campus. »
« Vous n’avez pas à recopier à côté de vous les jeux de commandes que je vous ai montrés. » ⚠️ Le mot est indistinct (« reprendre » ou « exécuter ») ; le sens est : les commandes du § 1 à 17 sont à rejouer de mémoire chez soi.
« Vous pouvez prendre votre fichier main.m, maintenir la touche [gauche] et le descendre → vous allez avoir quelque chose en bleu : si je le mets là, ça veut dire qu’il va me mettre toute cette commande à gauche et la même à droite. » → c’est le split screen (double-clic sur m, puis glisser le séparateur), utile pour « travailler ici pour prendre sur votre droite ce qui vous est en train de faire ».

PARTIE 3 — Exercice 1 : matrice triangulaire supérieure — [00:23:02]

22. L’énoncé — [00:17:30]

⚠️ Flashback : l’énoncé a été distribué et lu à 00:17:30, juste avant la pause ; le travail commence à 00:23.

Exercice 1. Écrivez un code qui permet de construire une matrice triangulaire supérieure $A \in R^{10 \times 10}$ telle que $A_{ij} = i + j$ .

« Ce ne sont pas des exercices qui sont très compliqués [« conflictuels » au sens du dictat] ».

23. La difficulté réelle : `i` = ligne, `j` = colonne — [00:35:57]

C’est le heart du TD ; le prof y revient parce que la moitié du groupe se trompe.

« OK, ça va de 1 à 10. $i$ , ce sont les lignes ; tu as vu que le for travaillait avec les indices ; là aussi tu vas faire quelque chose en for i. »
« Supérieur ou égal à $j$ ? → Non, parce que c’est « $i$ supérieur ou égal à $j$ »… tu sais pas, tu vois ce que je veux dire ? » ⚠️ Le prof se contredit oralement ici (il dit d’abord « $i \geq j$ », puis « $j \geq i$ ») ; la version correcte est donnée ci-dessous et confirmée par le main.m officiel.
« Pour égal, c’est $j$ , parce que ici, $i$ ce sont les lignes… $j$ ce sont les colonnes, on est bien d’accord. »

j \geq i ⟺ on est \overset{a}{ˋ} gauche de la diagonale (ou dessus)

Précision qu’il répète trois fois : « chaque fois que les colonnes sont supérieures aux lignes, tu es dans ce côté-là. Si les colonnes [ne] sont pas supérieures aux lignes, tu es à droite de la diagonale, tu es en dessous. »

A_{ij} \neq = 0 si j \geq i ⟺ \cdot \cdot \cdot \cdot \cdot \cdot \cdot \cdot \cdot avec les 0 en bas \overset{a}{ˋ} droite

⚠️ Le mot « triangulaire » parle de la position des éléments, pas de leur valeur : « Triangulaire, ça parle d’où sont tes éléments. Ils sont en bas. » ⚠️ Attention, la formulation est inversée par rapport à l’usage : ici « ils sont en bas » désigne le fait que ce sont les zéros qui sont en bas.

24. La construction, ligne par ligne — [00:38:04]

« Bah en fait ici, comment est-ce qu’on pourrait définir $A$ mais pas en diagonale, mais juste $A =$ matrice remplie de 0 ? » → A = zeros(10).
« Remplie de 0, bah ici on met juste 0. » → zeros(10) crée une $10 \times 10$ .
Un étudiant demande ce qu’est array → « array, c’est tableau, non ? » ⚠️ Mot mal dicté, sans portée mathématique ici.
Correction de la condition : « tu mets if i supérieur à $j$ tu fais… mais c’est oui voilà, de façon toujours là-bas tu mets… puis pour end… »

A = zeros(10), for i = 1:10, for j = 1:10, if j >= i, A (i, j) = i + j

« Techniquement, je peux mettre 2 $end$ » ⚠️ le dictat dit « 2 IJ » = « deux end ». Il en faut trois (un pour chaque if/for) : c’est exactement le malentendu du § 10.

25. ⚠️ « Triangulaire supérieure » ne veut PAS dire « que des 1 » — [00:39:22]

Un étudiant : « une matrice triangulaire supérieure, c’est une matrice avec des 1 et des 0 en dessous ».
Le prof : « Pas nécessairement des 1. Une triangulaire supérieure, ça veut juste dire que la partie triangulaire inférieure n’a que des zéros. Donc la triangulaire supérieure peut avoir n’importe quel chiffre au-dessus de sa diagonale et sur sa diagonale aussi. Et pas que des $A$ … » ⚠️ le dernier « des $A$ » est un dictat erroné de « des $1$ ».
« C’est pour ça que j’ai mis des zéros, parce qu’après nous on va remplir : on va dire que c’est une matrice de zéros, et sur la diagonale et sur la partie supérieure à la diagonale, $i + j$ … c’est-à-dire $i$ plus $j$ . »

A triangulaire sup \overset{e}{ˊ} rieure ⟺ a_{ij} = 0 pour j < i (valeurs libres pour j \geq i)

26. `break` dans le `if`, ou rien du tout dans le `else` — [00:40:41]

Un étudiant veut commenter toute la première colonne de $A$ → confusion d’indice (« pourquoi tu veux les commenter ? »).
« Donc là, si $j$ — donc si la colonne est supérieure à la ligne, ça veut dire que tu es dans cette partie-là… Alors $a_{ij} = i + j$ . » → il faut écrire A(i,j) = i+j, pas a(i,j).
⚠️ « Et puis il faut mettre else. On met quoi pour else ? — « Il ne faut pas mettre else, non ? On peut dire break : par exemple, break, ça va te sortir de la boucle. Donc l’élément que tu arrives ici va rentrer dans le if, et si tu mets break, ça va directement sortir, donc tu vas seulement remplir un seul. »

if j >= i A(i,j) = i+j else break % sort de la boucle j \to inutile ici end

⚠️ Le break dans le else est en réalité une mauvaise idée (il quitte la boucle $j$ dès la première valeur) ; le prof le présente comme une option, pas comme la bonne solution. La solution propre est un else vide.

27. Les deux boucles `for` : est-il nécessaire d’en écrire deux ? — [00:41:49]

« Là, à ce niveau, si on se pose $i = 1$ , $j = 1$ , on est à ce niveau. Il faut que $i$ soit égal à 1 toujours ; on doit prendre $j$ égal à 1, $j$ égal à 2… »
« Il faut deux if : un pour incrémenter les $i$ , l’autre pour incrémenter les $j$ . »
« En fait, c’est seulement cet élément-là qui va changer… c’est le seul qui se situe après [le end de la boucle $j$ ]. » → c’est-à-dire : le i = i+1 doit être hors de la boucle $j$ , sinon on resterait bloqué sur la ligne 1.

for i = 1:10 for j = 1:10 if j >= i A(i,j) = i+j end end end % les 3 end : if, for j, for i

28. Deux erreurs classiques d’un étudiant — [00:42:26]

Erreur 1 — l’assignation oubliée : un étudiant tape A, 1 2 3 ; 4 5 6 → « Mais ça va rien afficher, ça affiche dans l’air. »

A [123; 456] vs A = [123; 456]

« Y a un truc qui manque : le =. C’est égal. Il faut assigner ça. »

Erreur 2 — crochets vs parenthèses : « Je peux essayer un truc ? — Oui, tu peux. »

A = (1 2 3) ⟵ groupement / parenth \overset{e}{ˋ} ses A = [123] ⟵ crochets = tableau

« Pas un entier, mais genre un chiffre. [Il veut] des crochets. » ⚠️ « un entier » est un dictat de « un vecteur ».
« Comment est-ce qu’on peut définir une matrice de cette taille ? On ne dit pas ce qu’il y a à l’intérieur. » → il faut d’abord la dimensionner avec zeros avant de la remplir (§ 24).

29. Le point culminant : `A(:)` — tout aplatir en colonne — [00:46:23]

Un étudiant : « le problème, c’est que comme tu parcours les lignes et les colonnes, tu devrais mettre un chiffre spécifique — tu as deux points à côté d’un chiffre et ça irait bien. »
Le prof, devant l’écran : « ah, un petit point comme ça, il sera généralisé à $1 \times 10$ … » puis un étudiant ne peut qu’expliquer que « ce sont des points, il faut mettre des points ».

A(:) = a_{11} a_{21} ⋮ a_{m 1} a_{12} ⋮ a_{mn} = tous les \overset{e}{ˊ} l \overset{e}{ˊ} ments de A empil \overset{e}{ˊ} s en une seule colonne (lecture par colonnes)

« Sinon, ce serait : tu ferais… si ça c’est $V$ , le $N$ en question, ce serait $V 2$ . Tu sais que V1, c’est l’une de ces colonnes. » ⚠️ Passage sur la concaténation de vecteurs en § 19 de la partie 4.
Anecdote d’écran : un étudiant obtient une colonne de dizaines de $M$ identiques (« $M$ , $M$ , $M$ … ») → le prof diagnostique « il a l’impression qu’il y a un petit point comme ça, il va être généralisé », c’est-à-dire que sans affecter le résultat, MATLAB réaffiche la variable à chaque tour de boucle (cf. § 33).

PARTIE 4 — Exercice 2 : vecteurs, transposés et produit matriciel — [00:56:49]

30. L’énoncé — [00:58:24]

⚠️ Flashback : l’énoncé est (sans boucle) dans le PDF ; le prof propose ici une variante avec boucle sur les dimensions (voir § 31).

Exercice 2. Construisez (sans utiliser de boucle) les vecteurs de dimension $n = 10$ suivants : $v_{1} = (0, 0, \dots, 0)^{⊤}$ , $v_{2} = (1, 1, \dots, 1)^{⊤}$ , $v_{3} = (1, 2, \dots, 10)^{⊤}$ , $v_{4} = (3, 4, \dots, 12)^{⊤}$ . Pour chacun, calculez son transposé. Calculez la matrice $B = v_{3} v_{4}^{⊤}$ .

« L’exercice 2, ce qu’on choisit, c’est d’utiliser des boucles avec les dimensions. » ⚠️ Contre-intuitif : l’énoncé demande sans boucle ; le prof propose une variante avec boucle sur les dimensions (§ 20), plusivr instructive.

31. Les quatre vecteurs, et pourquoi ils sont des colonnes — [00:58:52]

« Je vais mettre prime [i.e. transposer] », parce que « là, c’est un vecteur colonne » → c’est le point § 2.
⚠️ « Il n’y a pas de façon plus facile ? — « Il y a une autre manière de le faire : c’est une ligne de code, mais il y a une commande qui s’appelle zeros, avec $m$ = nombre de lignes, $n$ = nombre de colonnes, ça va te donner un vecteur ou une matrice avec $m$ lignes, $n$ colonnes, rempli que de 0. »

v_{1} = zeros(10,1), v_{2} = ones(10,1), v_{3} = (1:10)’, v_{4} = (3:12)’

⚠️ Ordre des arguments de zeros : lignes d’abord — c’est l’erreur du § 3. Un étudiant dit « donc c’est lignes par colonnes… c’est comme c'est transposé » ; le prof corrige : « donc c’est dix lignes, donc tu mets dix, c’est un », i.e. zeros(10,1) et non zeros(1,10).
« Normalement, c’est la même chose [que ma méthode par boucle], ça fait exactement la même chose. »

32. Assembler des vecteurs en une matrice : `[ ]` et `'` — [01:00:06]

« Et pourquoi ce n’est pas $1 \times 1 \times 1$ ? » ⚠️ dictat de « pourquoi ce n’est pas ones(1,1) ? » — un étudiant a écrit ones(1,1) au lieu de ones(10,1).
« Mais tu as pris 1 [section], pas sur une section » → c’est le problème des sections de main.m : une variable définie dans une section n’existe pas dans la suivante (« quand tu n’es pas dans la [même] section, ces parties-là ne se rappellent pas des valeurs de $v_{3}$ que tu avais avant »).
Concaténation puis transposition :

L = [v1, v2, v3, v4]’ ⟹ L = [v_{1}^{⊤} v_{2}^{⊤} v_{3}^{⊤} v_{4}^{⊤}] = [v_{1} v_{2} v_{3} v_{4}]^{⊤} \in R^{10 \times 4}

« C’est comme si tu prends une matrice que tu as déjà faite et tu mets la matrice sur la matrice. »
⚠️ Deux formes de transposition coexistent : « il y a deux manières de transposer » → l’apostrophe ' (conjuguée) et le point-apostrophe .' (non conjuguée). Le prof n’explicite pas la différence, mais c’est ce que « deux manières » désigne.
Un étudiant veut écrire $v_{1}$ et $v_{2}$ directement en vecteur colonne, sans passer par la transposition : le prof confirme « c’est un vecteur colonne ? — Oui, c’est justement ça » (via zeros(10,1) et ones(10,1) du § 31), « mais on peut mettre ça en vecteur colonne et utiliser la transposition ».

33. La boucle sur les lignes de $L$ — [01:04:14]

« Là, on peut calculer $v_{3}$ , $v_{4}$ … $v_{3}$ c’est une matrice [ligne, colonne]… mais ça c’est colonne non ? — Là c’est ligne, parce que c’est un transposé. »
« On a transposé la ligne, c’est-à-dire la colonne. Donc, $v_{1}$ , c’est colonne. $v_{3}$ , c’est ligne. Là, tu as la ligne qui est transposée dans $v_{3}$ . »
Sur la taille : « $v_{4}$ transposé, $v_{3}$ … si on prend un chiffre là-bas, ça fait une matrice $10 \times 1$ , et une matrice $1 \times 10$ → du coup ça fait une matrice $10 \times 10$ . »

v_{3} = 12 ⋮ 10 \in R^{10 \times 1}, v_{4}^{'} = [34 \dots 12] \in R^{1 \times 10} ⟹ B = v_{3} v_{4}^{'} = colonne 12 ⋮ 10 ligne [34 \dots 12] \in R^{10 \times 10}

B = 369 ⋮ 30 4812 ⋮ 40 51015 ⋮ 50 \dots \dots \dots \dots 122436 ⋮ 120, b_{ij} = i (j + 2)

« Là, du coup, tu le mets dans ta boucle de corps, tu mets un test à chaque fois, donc il va faire trois tours ici. »
⚠️ « Non mais là, si ça respecte la norme de la multiplication, tu dis voilà, si c’est égal, tu mets break, tu remets ici… » → c’est la vérification de la compatibilité des dimensions de § 14, faite à l’intérieur de la boucle : si les tailles ne correspondent pas, on break.

PARTIE 5 — Exercice 4 : symétrie et caractère triangulaire — [01:10:18]

34. L’énoncé — [01:10:00]

Exercice 4. Soit la matrice $B$ donnée à l’exercice 2. Cette matrice est-elle symétrique ? Triangulaire (supérieur/inférieur) ? Justifiez sans utiliser de fonction connue en MATLAB.

« Si jamais pour ceux qui ont du mal avec la symétrie, je vais vous expliquer brièvement comment on peut le faire. »

35. La méthode naïve, et son défaut — [01:10:32]

« Je pense que beaucoup d’entre vous ont testé le classique : je vais de 1 jusqu’à 10, je vais de $i + 1$ jusqu’à 10, si jamais à un moment donné c’est différent, j’affiche « pas symétrique ». »
⚠️ « Le problème, c’est que si vous faites ça et que vous affichez juste, vous allez quand même continuer à boucler tout. Alors que pour le même prix, dès la première ligne, vous savez que ce n’est pas symétrique → c’est un && [mot indistinct : « un break, un continue »]. »

i = 1, j = 2 : A_{12} = 1 \cdot 4 = 4 \neq = A_{21} = 2 \cdot 3 = 6 ⟹ d \overset{ˋ}{e} s la premi \overset{ˋ}{e} re case, on sait d \overset{ˊ}{e} j \overset{ˋ}{a} que A n’est pas sym \overset{e}{ˊ} trique

36. La bonne méthode : un drapeau `testSymp` — [01:11:02]

« Une manière de faire, ce serait d’imposer une certaine variable qu’on appelle testSymp, que je mets à 1. Parce que la matrice sera symétrique si, quand j’ai vérifié toute ma matrice, j’ai bien à chaque fois obtenu les égalités entre les éléments 2 à 2. »

testSymp = 1 (hypoth \overset{e}{ˋ} se : sym \overset{e}{ˊ} trique)

« Et puis on a le fait de dire : while i est plus petit que 10 ET que testSymp est égal à 1. »
« Pourquoi ? Imagine qu’à un moment donné testSymp vaut 0, c’est-à-dire que j’ai repéré que je n’avais pas une matrice symétrique → testSymp vaut 0 → je ne vais plus rentrer dans [le test], je vais arrêter. »

while i < size(B,1) && testSymp == true

⚠️ Le && (ET logique) est indispensable : c’est le point soulevé à [00:52:33] (« Est-ce que les deux && ont le même [nombre d’]arguments ? »). Un étudiant avait codé while i < 10 & sym == true — le & simple est un & élément par élément (produit logique) et non un court-circuit ; le prof insiste pour le &&.

« On met la valeur de 10 : je vais mettre $j$ égal à [1], $j$ — justement au plus petit de 10, et [il y a] la 1 : ça je vais bien parcourir pour la valeur de 10, parce que ce qui se passe sur ma triangulaire, c’est carrément [de] même (que sur la partie pleine). »

i = 1, while i < size(B,1) && testSymp == true

Le test : « et là je vais tester si $A (i, j)$ est différente de l’élément $A (j, i)$ . À votre avis, qu’est-ce que je vais mettre dans mon if ? »

if B(i,j) ~= B(j,i) (~= = diff \overset{e}{ˊ} rent de, PAS = ni \neq =)

⚠️ ~= et non <> ni != : c’est la négation logique en MATLAB. Le prof ne l’écrit pas mais toute sa discussion (« il est différente ») l’implique.

« Il n’est pas symétrique → donc, je vais dire testSymp = 0. Je n’oublie pas d’incrémenter [le compteur] la valeur de $j$ . »

if B(i,j) ~= B(j,i) testSymp = 0 end j = j+1

« Dès qu’un élément va être différent, dès que $i, j$ va être différent de $j, i$ , testSymp va valoir 0. Ça veut dire que je vais être ici : est-ce que testSymp vaut 1 ? Non. Je sors de ma boucle. Je remonte ici : est-ce que testSymp vaut 1 ? Non. Et après j’ai fini. »

while (i < 10) \land (testSymp = 1) ⟹ tant que tout concorde ; d \overset{e}{ˋ} s le premier d \overset{e}{ˊ} saccord, t es tS y m p \leftarrow 0 et la boucle s’arr \overset{e}{ˆ} te

37. ⚠️ L’argument pédagogique : ne pas tout parcourir — [01:14:19]

« Alors ça, c’est juste pour avoir un code un peu plus joli etc. Le but de cette séance, c’est pas de vous faire avoir un code le plus optimal possible, mais ça permet quand même d’être déjà conscient que parfois, si on code entre guillemets [arbitrairement] quelque chose, même pour le même résultat, on peut éviter dans certains cas [de reparcourir] devis-à-vis de ma liste 3 fois. Ici, elle est $10 \times 10$ ; si elle était un million fois un million, là ça commence à devenir technique de vérifier — alors que pour le même prix, dès cet élément-là, si vous savez qu’il n’y a pas ce [problème], ça ne sert à rien d’aller visiter tout le reste de la matrice. Donc c’est un gain de temps. »

co \overset{u}{ˆ} t na \overset{ı}{¨} f = n^{2} tests vs co \overset{u}{ˆ} t avec drapeau \leq n tests dans le cas non sym \overset{e}{ˊ} trique

38. Le même mécanisme pour le caractère triangulaire — [01:15:10]

« Pour l’aspect triangulaire supérieur et inférieur, le même mécanisme ; la seule chose qui va changer au final, c’est la condition de [l’inégalité]. »

triangulaire sup \overset{e}{ˊ} rieure triangulaire inf \overset{e}{ˊ} rieure sym \overset{e}{ˊ} trique ⟺ ⟺ ⟺ B_{ij} = 0 \forall j < i B_{ij} = 0 \forall j > i B_{ij} = B_{j i} \forall i, j

39. ⚠️ `Ctrl+C` : la sortie d’urgence — [01:15:27]

« Il y en a qui a fait comme ça. Si jamais il y a un petil problème, c’est Ctrl+C en général. C’est là, vraiment, ça n’arrête [rien à la compilation]. »

⚠️ Cette réponse fait suite à un silence d’environ 2 minutes (de 01:15:40 à 01:17:30) pendant lequel un étudiant a un programme qui tourne indéfiniment ; c’est l’application directe du while true du § 10.3.

40. Passage inaudible — [01:17:40]

⚠️ De 01:17:40 à 01:19:17, l’enregistrement ne contient aucun contenu de cours : on n’entend que des bribes d’une conversation de fond (« c’est la même chose que j’ai mis à pied », « Non, non, non — ça doit te donner la direction — c’est pas toi qui devais donner », répété 6 fois) et une discussion sur l’horaire de fin (§ 46). Rien n’est transcrit ni noté de ce passage.

41. Les determinants et les « valeurs aléatoires » — [01:19:17]

« Pour commenter, c’était comment déjà ? » ⚠️ « commenter » = « commenter » au sens de comment (comment ?) — dictat de « comment était » ; le sujet est la ligne % comment… de MATLAB (ligne 17 et suivantes du main.m).
« Ici où il y a trois fois, c’est oui le simple égal pour assigner une valeur. » ⚠️ « trois fois » = « trois points » (le :), et le « simple égal » est le =.
Sur les determinants : « En fait tu as eu le déterminant, il est inconnu… mais ça change parce que c’est ta matrice. Donc la valeur du déterminant change à chaque fois ? — Non. »
« Ah, mais tu mets des $E$ ? — Je mets T, E, J, E. Le mien, ça donne un $T$ ; ça donne $J, E, J, E$ . » ⚠️ Fragment peu intelligible ; le sens dominant est la comparaison de l’affichage de deux $E$ par deux étudiants.
« Je me demande si c’est peut-être parce que j’ai mis des valeurs aléatoires. — Ah oui, c’est parce que là tu es dans la section exercice 3. »
La réponse complète du prof : « Moi ce que j’ai fait ici, j’ai copié-collé les valeurs de $v_{3}$ et $v_{4}$ ici, après les deux % [les lignes de commentaire] — parce que quand tu n’es pas dans la [même] section, ces parties-là ne se rappellent pas des valeurs de $v_{3}$ que tu avais avant. Oui, tu copies ça et tu les mets sur l’horizontale. »

42. Réinitialiser les variables entre deux sections — [01:20:48]

« Est-ce que tu aurais à redonner un autre nom pour la nouvelle matrice que tu vas revoir ? Parce que la première matrice s’appelait $A$ . »
« Imagine : tu mets $A$ , par exemple, tu mets variable $X$ , X = 7 ; et puis après tu mets X = 8 ; tu affiches $X$ , ça va toujours m’afficher 8. »

x = 7; x = 8 ⟹ x affiche 8 (la variable est \overset{e}{ˊ} cras \overset{e}{ˊ} e, pas cumul \overset{e}{ˊ} e)

« Tu peux créer plusieurs variables, comme ça tu as les 3 en même temps pour voir la différence. Mais ici, t’es pas obligé. »
Le main.m officiel confirme le mécanisme : clear; close; clc en tête de chaque bloc d’exercice.

⚠️ Flashback : ces deux échanges ont lieu à 00:52 et 00:54, au milieu de l’Exercice 1 ; ils sont remontés ici parce qu’illustrent le && du § 36 et la méthode « faire tout varier ».

43. La question des boucles : « on fait tout varier » — [00:52:33]

« Est-ce que les deux && ont le même [nombre d’]arguments ? — Mais ils ont la même boucle, alors. &&, OK. » ⚠️ Voir § 36.
« Je fais quand même de 1 à 10 pour être bouclé. En fait, qu’est-ce qu’il se passe ? Tu fais une boucle de 1 à 10. Quand tu le fais en pratique, tu es d’accord que tu fiches à ta commande [tu fixes à la main] et tu fais tout varier. L’idée de faire tout varier, c’est l’idée de boucler. »
« Tu boucles jusque là. Une fois que tu as fini cette boucle-là, tu recommences avec $i$ qui vaut 2. »

(i, j) = (1, 1) \to (1, 2) \to \dots \to (1, 10) \to (2, 1) \to (2, 2) \to \dots \to (2, 10) \to \dots \to (10, 10)

parcours en ligne d’abord, comme MATLAB : A (i, j) se parcourt i croissant, puis j

« Mais est-ce que pour $i$ au niveau 3, il n’y a pas [besoin de savoir] pour $i$ au niveau 7 ? — Voilà, il avait raison. Et tu vois, c’est ça l’idée. Ce n’est pas trop le langage encore, mais c’est ça l’idée, ça marche. »

44. Tester un seul élément et généraliser — [00:54:26]

« Quand tu le fais, tu regardes plus la [forme] là-dessus, et puis tu parcours taille, taille, taille. »
« Imagine que tu as déjà repéré qu’un élément n’était pas bon ici. Tu vas quand même le reparcourir après ? Ce que je veux dire, c’est que tu as testé celui-là. Et après… on pourrait… on va le retester ici, par exemple, en boucle 3, et changer les deux fois — ça fait la même chose. »

m \overset{e}{ˆ} me r \overset{e}{ˊ} sultat pour 1 cas particulier ⟹ g \overset{e}{ˊ} n \overset{e}{ˊ} ralisation « et si c’ \overset{e}{ˊ} tait ailleurs ? »

⚠️ « L’idée de faire tout varier, c’est l’idée de boucler » est la phrase à retenir : un test sur un élément ne prouve rien, il faut soit faire varier, soit justifier par le calcul (ici $b_{ij} = i (j + 2)$ , § 33).

PARTIE 6 — Exercice 3 : `rand`, `size`, `det` — [01:23:07]

45. L’énoncé et les pièges d’affichage — [01:23:07]

Exercice 3. Construisez une matrice $A \in R^{10 \times 10}$ aléatoire à l’aide de la commande rand. (a) Calculez les dimensions de $A$ à l’aide de size. (b) Calculez le déterminant de $A$ à l’aide de det. (c) Remplacez la première ligne de $A$ par $v_{3}$ et la troisième colonne par $v_{2}$ .

« Ici j’ai mis A = ..., disp A, et $A (1, :) = 10$ . » ⚠️ dictat imparfait ; le sens est A = rand(10), disp(A), puis A(1,:) = v3.
« Et ça s’affiche ici, alors que j’ai mis le truc affiché avant… mais tu vois ce que je voulais dire ? Si moi par exemple j’ai mis A(1,:), je vois bien qu’elle n’est pas [écrite]. »

A = rand(10) ⟹ A \in R^{10 \times 10}, a_{ij} \sim ind \overset{e}{ˊ} pendantes U (0, 1)

⚠️ « Tu ne dois pas croire que la triangulaire est supérieure parce que tu testes chaque élément de la triangulaire supérieure par rapport à la [matrice] identité. » → un étudiant avait conclu à tort à une triangularité, parce qu’il ne testait que la diagonale.

PARTIE 7 — Exercice 5 : écrire une fonction — [01:25:15]

46. L’énoncé — [01:25:15]

⚠️ Flashback : l’énoncé a été distribué avec la feuille du TD (00:16:01) ; il est lu à voix haute ici.

Exercice 5. Écrivez un code qui permet de décaler chaque colonne de $A$ vers la droite. Comme on ne peut pas décaler la dernière colonne vers la droite, on supposera que la première colonne devient la dernière. Compléter :
function A_perm = permutation(A)
    % Completer
end
⚠️ « Attention ! Ici, le code doit être général pour n’importe quelle matrice $A$ et n’utilise pas de valeurs numériques d’un exemple particulier. Par exemple, pour faire référence à l’élément $1, 2$ , on utilise A(1,2) de sorte que le code reste valable si $A$ est changée. »

⚠️ « Attention sur quelque chose avant de partir, parce que ça va beaucoup intervenir dans les TD après : c’est sur les fonctions. »

47. La forme générale d’une fonction — [01:25:48]

« Ici, c’est la forme générale d’une fonction. Et comme en Python, vous avez des fonctions : vous pouvez définir en général au début du code. »
« Il calcule le maximum entre trois quantités. Je l’ai créé : with return, le maximum entre trois quantités. C’est pareil. »

function [s] = maximum3(a,b,c)

« Ici vous avez function n [dictat de function]. permutation, c’est le nom de votre fonction. Par exemple, vous calculeriez le maximum entre $a$ , $b$ et $c$ → donc c’est max(a,b,c), et [la] fonction, c’est le résultat. »

function A_perm = permutation(A) ⟺ sortie A_perm = f (entr \overset{e}{ˊ} e A)

« Vous pouvez renvoyer la fonction [via return] : c’est-à-dire le maximum qui se reprend sur le nom de la fonction. » ⚠️ « se reprend » = « se retrouve ».
« Ça, c’est une fonction que vous mettez de manière générale, que vous créez, ok ? Qui prend en argument une matrice et avec laquelle vous travaillez. »

48. Les deux manières de placer une fonction — [01:26:27]

Dans le main.m : « vous mettez votre fonction dans votre code principal. Vous définissez votre fonction, vous implémentez une matrice — je ne sais pas, $10 \times 10$ — et vous faites appel, donc il y a permutation(A), et normalement, ceci devrait fonctionner. »
Dans un fichier séparé : « Ou alors, vous mettez, comme c’est marqué ici, votre fonction dans un code à part. Ma fonction est définie ici, et je l’appelle dans mon main.m. »

main.m : A_perm = permutation(A); ⟺ permutation.m : function A_perm = permutation(A) \dots end

⚠️ « Ceci ne marche pas. Il y aura un correctif, vous n’avez pas à le faire. C’est plus pour l’âme [le cœur], d’avoir de la pratique. » ⚠️ Le propos est incomplet dans l’audio (la raison n’est pas énoncée) ; la raison est celle du § 49.

49. ⚠️⚠️ LA RÈGLE D’OR : même nom, même dossier — [01:27:13]

« Il y a surtout quelque chose auquel vous devez faire très attention. Imaginez que vous travaillez sur un code : si je travaille sur le code main.m, et j’appelle ma fonction qui s’appelle permutation… la première chose à savoir, c’est que la fonction que vous avez créée — permutation.m — quand vous la sauvegardez, doit avoir EXACTEMENT le même nom. »

permutation.m ⟺ function A_perm = permutation(A)

« C’est la première chose. Votre fonction doit avoir le même nom que la fonction [déclarée]. Et quand vous l’appelez ici, vous pouvez appeler permutation — à condition que votre fonction permutation.m et main.m soient dans le MÊME DOSSIER. »

« Je ne veux pas, dans main.m enregistré quelque part sur mon ordinateur, appeler une fonction permutation qui est dans un autre dossier. Il faut qu’elle soit dans le même dossier, obligatoirement. »

« Et là, c’est super important, parce qu’on va beaucoup travailler avec les [systèmes], quand on va calculer des factorisations, quand on va calculer des solutions par la substitution régressive, etc. »
« Donc retenez qu’on peut créer une fonction, elle fait ce qu’elle doit faire… mais quand je l’appelle, la fonction main.m doit obligatoirement [être avec] la fonction d’ici. Pour faire en sorte que main.m et la [dernière] soient dans le même dossier. »

main.m et permutation.m dans le M \hat{E} ME dossier et permutation.m = nom de la fonction.

« Ici, c’est tout mon dossier que j’ai compris… c’est le chemin (« c’est le chemin », le code) — C’est clair pour tout le monde, ça ? » ⚠️ « C’est le chemin » dicté « TV1, le code ».
« En général, vous aurez des codes qui seront pré-complétés en majorité. Ce sera parfait, mais c’est important que vous sachiez ça, parce que ça arrive beaucoup qu’il y ait des erreurs où on compile, on dit que ça ne marche pas — mais en fait, c’est parce qu’on n’a pas enregistré dans le bon dossier, etc. »

50. Le résultat attendu — [01:29:23]

« À la suite du script, initialisez $A$ avec les valeurs de l’exercice 3.c et appelez la fonction avec A = permutation(A). Qu’obtenez-vous ? »
« En fait, je pense que tu pourrais le faire et dès que tu veux l’appeler, tu lui dis d’ajouter un addpath [« un pré-pass pour le pass dans lequel tu situes »], dans le dossier où ta fonction est. »

A = [ligne 1 ⋮] permutation c_{1} c_{2} ⋮ c_{0} \dots \dots c_{1} c_{n - 1} c_{0} ⋮ \dots c_{0} c_{1} ⋮ c_{n - 1} (permutation circulaire des colonnes)

⚠️ Attention à ne pas confondre l’énoncé (« $A$ = permutation( $A$ ) ») avec le main.m fourni (« A_perm = permutation(A) ») : la version du main.m est la bonne, elle préserve $A$ .

PARTIE 8 — Fin de séance et logistique — [01:29:25]

⚠️ La sauvegarde est rappelée une troisième fois ici (§ 53) : c’est le point le plus répété du TD (§ 20, § 53).

51. L’horaire de fin — [01:30:02]

« Tu voulais quoi ? — Voir l’horaire, parce que normalement, ça [finit] à 20 h, non ? C’est deux heures de groupe. On a commencé à 18 h 10. — Moi je pense que c’est 20 h… Je pense que c’est 2 h [après-midi]. »
Discussion parasite sur l’hôpital de Mont : « Tu vois l’hôpital Mus ? Tu peux aller maintenant. — Mais non, je ne vais pas à Berkin. L’hôpital Mus, il est à quelle heure ? — À 20 h… Oui, c’est à 29 h [29 = 20 h 9 ?]. Ah, ok. Les heures, ce qu’il y a de sûr. » ⚠️ Passage sans intérêt mathématique, noté pour la complétude de la transcription.

52. Bilan : les matrices des étudiants — [01:31:32]

« Il y a une matrice qui tourne avec le [vice] de l’hôpital Mus. — C’est peut-être symétrique. — C’est symétrique. » ⚠️ Les étudiants se montrent leurs matrices $10 \times 10$ ; c’est un retour oral de l’Exercice 4. ⚠️ le nom « l’hôpital Mus » est une dicté de « l’hôpital de Mont » (l’un d’eux compte lui rendre visite) ; sans rapport avec le cours.
« Oui, mais c’est marqué sur cette partie-là : le travail que tu as mis dans ce test, c’est pas ce travail-là que tu veux faire. » ⚠️ Fragment peu intelligible.

53. ⚠️ Le pool, les machines personnelles, et la sauvegarde (bis) — [01:33:34]

« C’est enregistré ou pas ? — Non, ça c’est enregistré, mais le problème c’est quand tu vas arrêter le PC, tu vas rallumer et tu te rends compte qu’au moins ça va rester enregistré… mais sur ce sujet-là, je ne m’en [doute] pas. N’oubliez pas : si vous allez travailler sur votre machine, de vous envoyer vos codes, ou de les regarder dans votre Drive, etc. »
« Pour ceux qui travaillent sur la machine du pool : [j’ai pris une photo] → la prochaine fois, il a dit qu’il ne va pas devoir aller au pool. — Non, j’ai pris une photo et j’ai réfléchi [travaillé] sur mon PC [au lieu de le faire sur place]. Tu prends une photo et… — Oui, j’ai fait ça. »

⚠️ C’est la troisième fois que la sauvegarde est rappelée dans la séance (§ 20, § 20 bis, ici). C’est le point le plus répété du TD.

« Moi, je vais rentrer, je vais refaire » (le code) — « T’as déjà pris une photo ? — Oui, j’ai fait un petit message. »

Points clés — [résumé]

Créer un vecteur : a:pas:b (⚠️ borne inclusive, sinon on s’arrête avant) ; 1:2:10 donne $1, 3, 5, 7, 9$ (jamais $1, 3, 6$ ).
Orientation par défaut : un vecteur 1:n est un vecteur ligne $\underline{1 \times n}$ ; ' le transpose en $\underline{n \times 1}$ .
Trois fabriques : zeros(m,n), ones(m,n), rand(m,n) — $m$ = lignes, $n$ = colonnes (⚠️ dans cet ordre).
; = séparer deux lignes / terminer une instruction / commenter.
Travail vectoriel : MATLAB préfère les opérations sur des lignes et des colonnes aux boucles ; A(1,:) = « première ligne, toutes les colonnes ».
⚠️ A(i,j) : $i$ = LIGNE, $j$ = COLONNE. Source d’erreur numéro 1 du TD.
Assigner : A(1,:) = [1 1] — ⚠️ la taille doit être compatible avec la matrice, sinon error.
Trois boucles : for (liste fixe d’indices), while (⚠️ critère d’arrêt ; ⚠️ initialiser et incrémenter l’indice), while true (⚠️ infinie → il faut un break, sinon Ctrl+C).
continue = passer à l’itération suivante sans exécuter le reste ; break = sortir de la boucle.
end ferme chaque if/for/while → 3 end pour for+for+if.
Sous-blocs : A(1:2,1:2) = coin haut-gauche $2 \times 2$ ; A(:,2:4) = toutes les lignes, colonnes 2 à 4 ; A(:) = tout aplati en une colonne.
size = $(nb de lignes, nb de colonnes)$ ; pour un vecteur, une des deux vaut 1 (size(-2:0.1:2) = $41 \times 1$ ).
Trois multiplications à ne jamais confondre : $x^{'} x = \sum x_{i}^{2} = ∥ x ∥^{2}$ (scalaire), $x x^{'}$ = matrice $n \times n$ symétrique, $x .^{2}$ = terme à terme ; $(.)$ avant l’opérateur = terme à terme.
Exercice 1 : $A = zeros (10)$ puis if j >= i → $A_{ij} = i + j$ . ⚠️ « triangulaire supérieure » = les zéros sont en bas à droite ( $a_{ij} = 0$ pour $j < i$ ) ; les $1$ n’ont rien à voir.
Exercice 2 : $v_{1} = zeros(10,1)$ , $v_{2} = ones(10,1)$ , $v_{3} = (1:10)’$ , $v_{4} = (3:12)’$ ; $B = v_{3} v_{4}^{'}$ est $10 \times 10$ avec $b_{ij} = i (j + 2)$ ; non symétrique dès $b_{12} = 4 \neq = 6 = b_{21}$ .
Exercice 3 : A = rand(10), size, det ⚠️ (le déterminant de MATLAB, pas une variable), A(1,:) = v3, A(:,3) = v2.
Exercice 4 : drapeau testSymp + while i < 10 && testSymp == true + if B(i,j) ~= B(j,i) then testSymp = 0 → arrêt au premier désaccord ; même mécanisme pour la triangularité (seule la condition change). ⚠️ && (ET logique) et non &.
Exercice 5 : function A_perm = permutation(A) … end, ⚠️ code général (pas de valeurs numériques en dur), ⚠️ le fichier doit s’appeler permutation.m et être dans le MÊME dossier que main.m.
help nom donne la documentation complète de n’importe quelle fonction.
Organisation : dossier mon_fichier, main.m découpé en sections (⚠️ une variable créée dans une section n’existe pas dans la suivante → la recopier).
⚠️⚠️ SAUVEGARDER : les PC ne sauvegardent pas les sessions → mail / Dropbox / Drive / photo de l’écran (répété 3 fois dans la séance).

Doutes / à vérifier

⚠️ [00:02:12] « $2$ lignes $3$ colonnes avec que des $1$ » puis « … ça va me créer une matrice de nombre aléatoire entre 0 et 1 » : la phrase de transition est mal coupée ; il s’agit de deux commandes distinctes, ones(2,3) puis rand(1,3), comme confirmé par les trois éléments du workspace cités ensuite ( $2 \times 2$ , $2 \times 3$ , $1 \times 3$ ).
⚠️ [00:35:57 – 00:37:39] Le prof se contredit deux fois sur la condition : d’abord « supérieur ou égal à $j$ », puis « supérieur ou égal à $i$ », avant de trancher par « pour égal, c’est $j$ ». La formulation retenue ici ( $j \geq i$ ) est confirmée par le main.m officiel (if j >= i). Le passage est à réécouter si l’on veut la trace exacte de la correction.
⚠️ [00:45:04 – 00:49:29] La démonstration de A(:) est très bruitée (« un petit point comme ça, il sera généralisé à $11, 10, 10$ », puis une colonne de dizaines de $M$ identiques à l’écran). Le sens général (empiler toute la matrice en colonne) est clair et fait l’objet de la § 29, mais l’exemple précis fait par l’étudiant n’est pas identifiable. À réécouter sur l’audio avant de réutiliser l’illustration.
⚠️ [00:52:33] « Est-ce que les deux && ont le même [nombre d’]arguments ? » — la question de l’étudiant porte sur le && ; la réponse du prof (« ils ont la même boucle ») est trop elliptique pour être reconstruite. Ce qui est certain, c’est que le main.m officiel utilise while i < size(B,1) && sym == true avec un &&.
⚠️ [00:58:24] « L’exercice 2, ce qu’on choisit, c’est d’utiliser des boucles avec les dimensions », alors que l’énoncé PDF demande explicitement sans boucle. Le prof propose donc une variante (probablement celle de v4 = (3:12)' écrit en boucle) qui diffère de l’énoncé ; ne pas confondre les deux.
⚠️ [01:12:12 – 01:12:47] La mise en place de la boucle symétrique est très fragmentaire (« je vais mettre $j$ égal à… justement au plus petit de 10, et il y a la 1 »). Le code du § 36 est une reconstitution à partir du main.m officiel (sym = true, i = 1, j = 1, boucle externe sur $i$ , boucle interne sur $j < i$ ) et non une transcription littérale.
⚠️ [01:19:17 – 01:20:30] Fragment très obscur (« tu mets des $E$ ? — je mets T, E, J, E ») : il semble s’agir d’une comparaison entre l’affichage de deux étudiants (le caractère E de la notation scientifique de MATLAB ?), mais ce n’est pas certain. Le seul contenu fiable de ce passage est la règle sur les sections de main.m, reprise au § 41.
⚠️ [01:25:37] « Lpsum » — le mot dicté « Lpsum » (vraisemblablement « lpsum », contraction de « le plus petit… ») n’est pas identifiable ; la phrase exacte sur le return de la fonction reste à réécouter.
⚠️ [01:26:27 – 01:27:13] « Ceci ne marche pas. Il y aura un correctif, vous n’avez pas à le faire » : le prof évoque une méthode de placement de fonction qui ne fonctionne pas, sans en donner la raison (la réponse est de toute façon donnée au § 49 : mauvais dossier / mauvais nom de fichier). Passage à réécouter pour connaître la variante qu’il condemnne.
⚠️ [01:30:02 – 01:31:31] Discussion sur l’horaire de fin et l’hôpital — bruit de fond, aucun contenu mathématique. Conservé pour la complétude de la transcription, à supprimer si l’on ne veut que du contenu utile.
⚠️ [01:30:47] « Il y a une matrice qui tourne avec le [vice] de l’hôpital Mus. — C’est peut-être symétrique. — C’est symétrique. » : hors sujet (les étudiants se montrent leurs matrices), le nom « l’hôpital Mus » est une dicté de « l’hôpital de Mont » (l’un d’eux compte lui rendre visite) ; sans rapport avec le cours.
⚠️ [01:33:51] « C’est parce que tu n’as pas mis le micro » : le mot « micro » est ici un dictat de « m’ [le mot coupé] »** ; le sens exact de la phrase n’est pas reconstituable.

Annexe — l’énoncé du TD (PDF, `Introduction_Matlab.pdf`)

TD 1 : Introduction au langage Matlab

La liste d’exercices ci-dessous a pour objectif de vous familiariser avec les différentes commandes Matlab dont vous allez avoir besoin pour résoudre les exercices en TDs.

Avant toute chose, créez un dossier « mon_fichier » dans lequel vous enregistrerez la fonction main.m disponible sur Webcampus. Une fois cette tâche exécutée, répondez aux questions suivantes dans le script main.m.

Exercice 1. Écrivez un code qui permet de construire une matrice triangulaire supérieure $A \in R^{10 \times 10}$ telle que $A_{ij} = i + j$ .

Exercice 2. Construisez (sans utiliser de boucle) les vecteurs de dimensions $n = 10$ suivants : $v_{1} = (0, 0, \dots, 0)^{⊤}$ , $v_{2} = (1, 1, \dots, 1)^{⊤}$ , $v_{3} = (1, 2, \dots, 10)^{⊤}$ , $v_{4} = (3, 4, \dots, 12)^{⊤}$ . Pour chacun de ces vecteurs, calculez leurs transposés. Calculez également la matrice $B = v_{3} v_{4}^{⊤}$ .

Exercice 3. Construisez une matrice $A \in R^{10 \times 10}$ aléatoire à l’aide de la commande rand de Matlab. Avec la matrice $A$ que vous venez de construire, on vous demande de :

(a) Calculez les dimensions (nombre de colonnes et de lignes) de la matrice à l’aide de la commande size.

(b) Calculez le déterminant de $A$ à l’aide de la commande det.

(c) Remplacez la première ligne de $A$ par $v_{3}$ et la troisième colonne par $v_{2}$ , où $v_{3}$ et $v_{2}$ sont les vecteurs de l’exercice 2.

Exercice 4. Soit la matrice $B$ donnée à l’exercice 2. Cette matrice est-elle symétrique ? Triangulaire (supérieur/inférieur) ? Justifiez sans utiliser de fonction connue en Matlab.

Exercice 5. Écrivez un code qui permet de décaler chaque colonne de $A$ vers la droite. Comme on ne peut pas décaler la dernière colonne vers la droite, on supposera que la première colonne devient la dernière. Pour ce faire, on vous demande de compléter le bout de fonction suivant où $A$ est la matrice de départ et $A_{perm}$ est la matrice où les colonnes ont été décalées :
function A_perm = permutation(A)
    % Completer
end
⚠️ Attention ! Ici, le code doit être général pour n’importe quelle matrice $A$ et n’utilise pas de valeurs numériques d’un exemple particulier. Par exemple, pour faire référence à l’élément $1, 2$ on utilise A(1,2) de sorte que le code reste valable si $A$ est changée.

Une fois la fonction implémentée, sauvegardez-la sous le nom permutation.m dans le dossier « mon_fichier ». À la suite du script dans lequel vous avez effectué les exercices précédents, initialisez $A$ avec les valeurs de l’exercice 3.c et appelez la fonction avec la commande A = permutation(A). Qu’obtenez-vous ?

Le squelette fourni dans `main.m`

%% Exercice 1
clear; close; clc
A = zeros(10)
for i = 1:10
    for j = 1:10
        if j >= i
            A(i,j) = j + i
        end
    end
end
 
%% Exercice 2
v1 = zeros(10,1);  v2 = ones(10,1);  v3 = (1:10)';  v4 = (3:12)'
t4 = v4'
size(v1)
L = [v1,v2,v3,v4]'
for i = 1:size(L,1)
    v = L(i,:)
    fprintf('est de dimension : %d x %d', size(v,1), size(v,2))
end
B = v3*t4
 
%% Exercice 3
A = rand(10);  v3 = (1:10)';  v2 = ones(10,1)
% (a) fprintf('Taille de la matrice: %d x %d \n', size(A,1), size(A,2))
% (b) fprintf('det(A) = %d \n', det(A))
% (c) A(1,:) = v3 ;  A(:,3) = v2
 
%% Exercice 4
B = v3*t4
sym = true;  i = 1;  j = 1
while i < size(B,1) && sym == true
    fprintf('\nligne numéro %d du triangle inferieur : ',i)
    while j < i
        fprintf('%d ', B(i,j));  j = j+1
    end
    i = i+1
end
 
%% Exercice 5
A_perm = permutation(A);

Apuntes de Andres

Explorador

TD1 - ALG II