Leçons de niveau 14

Introduction à Maple/Listes, tableaux, matrices

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Listes, tableaux, matrices
Icône de la faculté
Chapitre no 5
Leçon : Introduction à Maple
Chap. préc. :Polynômes
Chap. suiv. :Procédures
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Introduction à Maple : Listes, tableaux, matrices
Introduction à Maple/Listes, tableaux, matrices
 », n'a pu être restituée correctement ci-dessus.

Introduction[modifier | modifier le wikicode]

Jusqu'ici, nous avons utilisé Maple pour traiter différents objets simples :

  • des nombres, réels ou complexes ;
  • des fonctions d'une ou plusieurs variables ;
  • des expressions ;
  • des images (tracés de fonction).

Dans ce chapitre, nous allons nous concentrer sur les listes de nombres et objets apparentés (tableaux, matrices). Cela est important pour plusieurs raisons :

  • si nous voulons travailler avec des listes (algorithmes de tri)…
  • si nous voulons travailler avec des matrices ou des tableaux…
  • dans certains cas, Maple nous renvoie des listes (par exemple une liste de solutions avec solve) ;
  • certaines instructions requièrent l’utilisation de listes.

Définir une liste[modifier | modifier le wikicode]

Une « suite » est simplement une suite de nombres (ou de symboles) ordonnés. Un exemple de suite est par exemple une chronologie du XXe siècle, où chaque évènement est repéré par sa date :

  • 1900 : début du XXe siècle ;
  • 1905 : publication des 4 articles révolutionnaires d'Albert Einstein ;
  • 1914 : début de la Première Guerre mondiale ;
  • 1918 : fin de la Première Guerre mondiale ;

Nous allons introduire un type particulier de suite : la liste. La différence est subtile, sachez juste qu'on utilise les listes de préférence.

  • une suite : MaSuite := 1, 2, 3, 4, 12 ;
  • une liste : MaListe := [1, 2, 3, 4, 12] ;
  • ou encore : MaListe := [MaSuite] ;

Dans Maple, une liste peut être définie de deux manières : globalement (en précisant tous les éléments de la liste dans une seule instruction) ou individuellement (en définissant les éléments de la liste un par un). Un exemple valant mille mots :

  • définition globale : MaListe := [3, 1, 4, 5, cos(x), 134];
  • définition individuelle : AutreListe[4] := (x^2 + 3 = 4);
Panneau d’avertissement Avec Maple, on peut créer des listes de n’importe quoi : des listes de nombres, de fonctions, d'expressions, d'images… et même des listes de listes !

Pour sélectionner le ne élément d'une liste, on écrit MaListe[n]. La définition « individuelle » utilise cela : dans l'exemple ci-dessus, seul le 4e élément est donné. Les autres sont inconnus.

Panneau d’avertissement Pour Maple, le premier élément d'une liste est l'élément no 1 — si vous essayez de prendre l'élément no 0, vous aurez une erreur de la forme Invalid subscript selector., voir chapitre 9.

La définition « individuelle » des éléments d'une liste comporte un risque : les éléments que l’on n'a pas précisé peuvent valoir n’importe quoi.

Voici un exemple d’utilisation des listes :

fonctions := [x -> x, x -> x^2, x-> x^3] ;
affiche_fonction := n -> fonctions[n] ;
utilise_fonction := (n,x) -> fonctions[n](x) ;

Nous avons défini une liste de trois fonctions. Si on demande affiche_fonction(2), Maple affiche x -> x² (la deuxième fonction de la liste). Si on demande utilise_fonction(2, 4), Maple affiche 16 (la deuxième fonction de la liste évaluée en 4).

Pour afficher une liste, on utilise l'instruction eval. Par exemple, l'instruction suivante :

eval(fonctions) ;

affiche [x -> x, x -> x², x-> x³].

Exercice rapide : définir la liste Premiers contenant les 8 premiers nombres premiers, afficher le 4e élément de la liste.

Modifier une liste, ajouter, supprimer[modifier | modifier le wikicode]

Une fois notre liste posée, nous pourrions être amenés à la modifier : changer ses éléments, en ajouter, en retirer. Pour modifier un élément, nous l'avons vu, il suffit de le sélectionner et de changer sa valeur :

MaListe := [3, 1, 2, 4] ;
MaListe[2] := 32768 ;
eval(MaListe) ;

Maple affiche, après ces opérations : [3, 32768, 2, 4] (on a modifié le deuxième élément).

Pour ajouter un élément, ou retirer un élément, les choses se compliquent un peu. Pour ajouter un élément, voici la démarche :

  • retirer les crochets autour de la liste (on a une suite) : on utilise l'instruction op ;
  • ajouter l'élément après (ou avant) la suite ;
  • mettre des crochets autour (on retrouve une liste).

Exemple :

MaListe := ["Alice", "Bob"] ;
MaListe := [ op(MaListe), "Eve" ] ;
eval(MaListe) ;

Maple affiche : ["Alice", "Bob", "Eve"].

On aurait pu ajouter l'élément avant en remplaçant la deuxième ligne par : :MaListe := [ "Eve", op(MaListe) ]. Remarquez qu’il est facile d'ajouter un élément avant ou après la liste, mais qu’il est plus difficile de l'ajouter au milieu (« injecter »).

Pour retirer un élément d'une liste, voici la démarche :

  • repérer le numéro de l'élément à supprimer ;
  • remplacer sa valeur par NULL.

Pour effectuer ce remplacement, on peut faire comme précédemment (MaListe[3] := NULL).

Exemple :

MaListe := ["Alice", "Bob", "Eve"] ;
MaListe[2] := NULL ;
eval(MaListe) ;

Maple affiche : ["Alice", "Eve"].

Exercice rapide : reprendre la liste Premiers de la section précédente, retirer le premier élément, remplacer le 5e élément par 42. Pour finir, ajouter à la liste 65537.

Définir un tableau[modifier | modifier le wikicode]

Un tableau est, de manière très simplifiée, une liste d'éléments repérés par un ou plusieurs nombres. Une « liste » est un tableau. Un plateau de bataille navale est encore un tableau. Pour définir un tableau dans Maple, on utilise l'instruction array :

Morpion := array(1..3, 1..3) ;
Cube := array(1..2, 1..2, 1..2) ;

La première instruction crée un tableau 3 × 3, la seconde crée un tableau 2 × 2 × 2. Les tableaux permettent de stocker des nombres (ou des fonctions, ou des images…). Pour récupérer un élément, cela est tout à fait analogue aux listes :

MonTableau[3, 4] ;

retourne l'élément situé dans la 3e ligne, 4e colonne du tableau MonTableau (si cet élément existe). Il est possible de le modifier comme pour les listes. On appelle dimension d'un tableau la quantité de nombres qu’il faut pour caractériser un élément : une liste est de dimension 1, Morpion est de dimension 2 et Cube est de dimension 3.

Panneau d’avertissement On ne peut pas supprimer ni ajouter d'élément à un tableau.

Exercice rapide : créer un tableau EmploiDuTemps qui pourrait enregistrer le contenu de 10 heures de cours quotidiennes sur 6 jours de la semaine.

Introduire les matrices[modifier | modifier le wikicode]

Les matrices sont des objets courants qu’il est possible d’utiliser dans Maple. Cependant, il ne s'agit pas d'une fonctionnalité de base du logiciel : il faut charger une bibliothèque de fonctions afin de pouvoir employer les matrices. Pour ce faire, en début de feuille, on écrit :

with(linalg) ;

Cette instruction charge la bibliothèque de fonctions linalg (algèbre linéaire). On peut alors définir des matrices comme suit :

MaMatrice := matrix([ [1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 1, 2] ]) ;

Remarquez :

  • les double crochets (il s'agit d'une liste de listes de nombres, ou d'autres objets) ;
  • pour former une matrice, on donne la liste de ses lignes.

On a ainsi défini la matrice rectangulaire :

Nous ne sommes pas limités aux matrices de nombres, mais ce sont tout de même les plus utilisées : nous ne discuterons qu'elles.

Exercice rapide : créer une matrice 4 × 7 contenant sur chaque ligne des nombres croissants et sur chaque colonne des nombres décroissants.

Opérations sur les matrices[modifier | modifier le wikicode]

On peut fort aisément additionner ou soustraire des matrices de même dimensions. Pour ce qui est de la multiplication, voici les détails :

  • utiliser &* au lieu de * ;
  • utiliser evalm.

Exemple :

M := matrix([[1,2], [3,4]]) ;
N := matrix([[5,6], [7,8]]) ;
produit := evalm(M &* N)
Panneau d’avertissement Utiliser * au lieu de &* ne marche pas pour les matrices. Oublier evalm aura pour effet de ne pas réaliser le calcul demandé.

Il est également possible d'effectuer un certain nombre d'opérations usuelles :

  • transposer : transpose(M) ;
  • inverser (lorsque c’est possible) : inverse(M) ;
  • calculer le déterminant : det(M) ;
  • calculer la trace : trace(M) ;
  • récupérer les vecteurs et valeurs propres: eigenvectors(M).
Panneau d’avertissement Pour Maple, une matrice 1 × 1 n’est pas un nombre. Il faut garder cela à l'esprit lorsqu'on définit des produits scalaires.

Exemple :

M := matrix([[1,2], [3,4]]) ; (M est une matrice 2 × 2)
N := matrix([[1], [2]]) ; (N est un vecteur colonne)
Pdt := evalm(transpose(N) &* M &* N) ; (le résultat de cette opération, pour Maple, est une matrice) ;
Pdt := trace(Pdt) ; (ici, Pdt est bien un nombre).

Exercice rapide : créer une matrice 3 × 3, notée P, de nombres entiers strictement positifs. Récupérer un vecteur propre V de la matrice, le normer et calculer tr(tVPV) (quel est le signe de cette quantité ?).

Exemples concrets[modifier | modifier le wikicode]

Les principales propriétés des listes ont été évoquées, mais nous sommes restés évasifs sur leur utilité (elles servent à… travailler avec des listes ?). En fait, Maple utilise beaucoup ces objets. Un exemple :

solutions := solve(x^4 = 16) ;

Maple affiche :

[ x = 2, x = -2, x = 2i, x = -2i ]

Il y a quatre solutions différentes à notre problème. Pour en sélectionner une (il s'agit d'une liste), on peut faire comme suit :

SolutionReelle1 := solutions[1] ;
SolutionReelle2 := solutions[2] ;

Un petit détail tout de même : SolutionReelle1 et SolutionReelle2 ne sont pas des nombres. En effet, Maple leur a affecté des expressions. Si on les affiche, voici ce qui apparaît :

x = 2 ;
x = -2 ;

Comment ne récupérer que la partie droite de ces expressions ? On peut le faire avec l'instruction rhs (right hand side, qui signifie « côté droit ») :

rhs(x = 2); renvoie 2
rhs(x^2 = 2*x ); renvoie 2x

Résumé[modifier | modifier le wikicode]

Dans ce long chapitre, nous avons abordé les listes, tableaux et matrices dans Maple. Nous avons vu comment réaliser les opérations suivantes :

  • définir une liste (entre [ et ]) ;
  • définir un tableau (avec array) ;
  • modifier des éléments d'une liste ;
  • ajouter (avec op) ou retirer (avec NULL) des éléments à une liste ;
  • introduire les matrices (avec with(linalg) et matrix) ;
  • réaliser des opérations simples sur des matrices

Dans le chapitre prochain, nous verrons comment Maple nous permet de mettre au point des algorithmes — ce ne sont plus des calculs à résoudre, mais véritablement des opérations à réaliser successivement.