V - TYPES DE DONNÉES EN LANGAGE MAPLE

Table des matières :

Quelques exemples de types
Types de données fondamentaux
Exercices

1. Quelques exemples de types

Maple contient un grand nombre de types de données.Tout comme nous séparons les entiers des fractions des fonctions, Maple aussi sait distinguer les integer des fraction des function... Ces quelques types "faciles" sont les types de base, à partir desquels on peut créer des types plus compliqués. La commande whattype permet en Maple de déterminer le type d'une expression lorsqu'elle est simple et le type de la dernière étape de calcul réalisé dans le cas d'une expression plus compliquée. Les instructions whattype(4);, whattype(1/2); et whattype(exp(x)); donnent respectivement integer, fraction et function. Distinguons alors plusieurs types.

Types numériques : Ils de divisent eux-mêmes en trois grands types de données : les entiers (integer), les fractions (fraction) et les réels (considérés par Maple comme des nombres à virgule flottante, d'où leur nom de float).

	> whattype(4); whattype(4/7); whattype(4.7);
	integer fraction float

Types algébriques : Ici aussi, cette catégorie de types sont divisés en trois types différents : l'addition (+),la multiplication (*) et la puissance (^). En effet, n'oublions pas que dans tout corps (Maple ne travaillant que dans des corps...), la soustraction est définie à partir de l'addition, et la division à partir de la multiplication. Dans les exemples suivants, on est en présence d'une expression un tout petit peu plus compliquée, où le résultat de whattype est le type de la dernière étape effectuée, à savoir l'opération :

	> whattype(x+y); whattype(x-y); whattype(x*y); whattype(x/y); whattype(x^y);
	+ + * * ^

Types d'égalités : Maple considère qu'il y a six types d'égalités : l'égalité (=), la différence (<>), l'infériorité (< ou <=) et la supériorité. (> ou >=).

Types logiques : Les expressions logiques se regroupent en trois types : "et" (and), "ou" (or) et la "négation" (not).

Autres types : Il existe en Maple d'autres types de données. En voici une petite liste non exhaustive, dont quelques uns seront étudiés plus en détail un peu plus loin.
• whattype(sin(x))              :    function ;
• whattype(proc(x) x^2 end)      :   proc ;
• whattype(u[1])                :    indexed ;
• whattype(series(1/(1-x), x=0)) :    series ;
• whattype([a,b])               :    list ;
• whattype({a,b})               :    set ;
• whattype(x::float)            :    :: ;
• whattype(a..b)                :    .. ;
• whattype(''sin(x)'')          :    uneval.

2. Types de données fondamentaux

Nous allons étudier ici plus en détail quatre grands types de données de Maple, fondamentaux même dans le sens où ils font toute la structure du langage. Il s'agit des suites (exprseq, littéralement "expression sequence"), des listes (list), des ensembles (seq) et des tableaux (array). On pourrait ajouter à ces quatre types les tables (table), peu utilisées dans ce cours, mais qui sont une donnée importante de la structure intrinsèque de Maple.

Suites : Parmi l'ensemble des expressions composées de Maple, ce sont les plus simples. En effet, une suite est composée d'un ensemble d'expressions, simplement séparées par des virgules.

	> 1,2,-4.2,a,sin,z; # Une suite whattype(%); a,b,-5.6,6/3,ln(2),'mars'; # Une autre suite whattype(%);
	1, 2, -4.2, a, sin, z exprseq a, b, -5.6, 2, ln(2), mars exprseq

Remarque : Si l'on a plusieurs variables à affecter, on peut le faire en une seule ligne. Par exemple, a,b,c := 1,2,3; va mettre 1 dans a, 2 dans b et 3 dans c.

Listes : Une liste n'est rien d'autre qu'une suite encadrée de crochets. Elle possède les même propriétés qu'une suite, à savoir l'ordre des éléments n'est pas modifié par Maple, et il peut y avoir répétition des éléments.

	> [1,2,-4.2,a,sin,z]; # Une liste whattype(%); [a,b,-5.6,6/3,ln(2),'mars']; # Une autre suite whattype(%);
	[1, 2, -4.2, a, sin, z] list [a, b, -5.6, 2, ln(2), mars] list

Remarque : Par contre, l'instruction [a,b,c] := [1,2,3]; amènera une erreur, comparé aux suites !!!

Quelques opérations sur les suites et les listes :
• Il est possible de passer de l'un à l'autre. En effet, pour transformer une suite en liste, il suffit de l'entourer par des crochets, comme nous l'avons fait dans l'exemple précédent. En revanche, pour passer d'une liste à une suite, il faut utiliser la commande op (qui a plein d'utilités, nous y reviendrons plus tard), comme le montre l'exemple suivant :

	> suite := a,b,c; #On définit une suite... liste := [suite]; # ...que l'on transforme en liste... op(liste); # ...et grâce à op, on retombe sur une liste
	suite := a, b, c liste := [a, b, c] a, b, c

• Pour créer une suite générique (c'est-à-dire dont chaque éléments est fonction d'un entier), on peut utiliser la commande seq. Cette commande possède la syntaxe suivante : seq(f(i), i=n..m);, où n et m > n sont des entiers Cette dernière instruction créé la suite f (n), f (n + 1), ..., f (m) :

	> S := seq(f(i), i=1..10); # de manière générale L := [seq(i^2, i=2..12)]; # la liste des carrés des entiers de 2 à 12 seq(sin(k*Pi/5), k=5..10); # une autre suite
	S := f(1), f(2), f(3), f(4), f(5), f(6), f(7), f(8), f(9), f(10) L := [4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]

• Pour accéder au n-ième élément d'une liste ou d'une suite, il est déjà vivement conseillé de lui donner un nom. Ensuite, on extrait le n-ième élément par l'instruction suite[n]; ou liste[n];, où suite et liste sont les noms de la suite et la liste. En reprenant l'exemple précédent, on aura alors que les instructions S[2]; et L[5]; renvoient respectivement f(2) et 36.

• Il peut être utile (surtout en statistiques) de savoir que nops(L); ou nops([S]); revoie le nombre d'éléments des listes L et [S]. Dans les exemples précédents, ces deux instructions renvoient respectivement 11 et 10. ATTENTION : nops ne prend que des listes en argument, et pas des suites !!!

• À partir d'une suite (ou d'une liste), on peut obtenir une sous-suite (ou une sous-liste). Il y a deux manières d'extraire une sous-suite, selon qu'on souhaite extraire des éléments consécutifs ou non. Si oui, dans ce cas, il suffit de place entre crochets après le nom de la suite (ou de la liste) l'intervalle des indices des éléments qu'on veut extraire (l'exemple sera plus parlant !!), sinon il faut avoir recours à la méthode mathématique (c'est-à-dire que u_p_(n) est une sous-suite de u_n si et seulement si p est une application entière strictement croissante) :

> S := a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z; #une suite
S[5..15];                         #on extraie directement une sous-suite
phi := n -> 1+3*n:                # on définit une application p strictement croissante
seq(S[phi(alpha)], alpha=0..5);   # on extraie les éléments 1 par 1 et on en fait une suite
L := [S];                         # on définit la liste L à partir de la suite S
L[5..15];                         # on extraie directement une sous-liste
[seq(L[phi(alpha)], alpha=0..5)]; # on extraie les éléments 1 par 1 et on en fait une liste

S := a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
e, f, g, h, i, j, k, l, m, n, o
a, d, g, j, m, p
L := [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
[e, f, g, h, i, j, k, l, m, n, o]
[a, d, g, j, m, p]

• Il est possible de créer des listes de listes. Pour avoir une liste de listes, il suffit alors de saisir LdL := [[a,b,c], [d,e,f], [g,h,i]];. On obtient ainsi une liste de trois listes. En langage Maple, une suite de suites n'est rien d'autre qu'une suite. En effet, puisqu'une suite est une liste sans crochets, il suffirait d'ôter tous les crochets de la saisie précédente pour avoir une suite de suites qui serait alors SdS := a,b,c,d,e,f,g,h,i;. Mais n'est-ce pas simplement une suite ??

• On peut aussi concaténer des listes et des suites. Dans le cas de suite, c'est trivial. En effet, il suffit des les inscrire en les séparant par des virgules. Pour les listes, il faut d'abord convertir chaque liste en suite via la commande op, puis concaténer comme vu ci-dessus, et enfin convertir à nouveau le résultat en liste (en entourant le tout par des crochets). En effet, si l'on concatène par exemple trois listes comme les suites, on va obtenir en réalité une suite composée de trois éléments (qui sont des listes), et non une liste. On se réfèrera aux exemples ci-dessous :

	> S1 := a,b,c: S2 := d,e,f: S3 := g,h,i: # Trois suites SdS := S1, S2, S3; # On concatène > L1 := [S1]: L2 := [S2]: L3 := [S3]: # Trois listes LdL1 := L1, L2, L3; # On concatène mal... LdL2 := [op(L1), op(L2), op(L3)]; # On concatène bien...
	SdS := a, b, c, d, e, f, g, h, i LdL1 := [a, b, c], [d, e, f], [g, h, i] LdL2 := [a, b, c, d, e, f, g, h, i]

• Passons alors aux substitutions. Il existe deux manières de substituer un élément dans une liste (attention, pas dans une suite : si l'on veut vraiment le faire, il faut d'abord convertir la suite en liste (en l'entourant de crochets), appliquer cette méthode, puis retransformer la liste obtenue en suite (par op)). La première consiste à remplacer un élément en fonction de son nom : on utilise alors subs(nom=nv, L);, où nom désigne donc l'élément à remplacer par nv (qui peut être de n'importe quel type) dans la liste L. La seconde consiste à remplacer un élément selon sa place dans la liste : la commande subsop(i=nv, L); va alors remplacer le i-ième élément de la liste L par nv. Remarquez (et c'est important) que les deux commandes subs et subsop créent une nouvelle liste et ne modifient en aucun cas la liste L donnée en argument.

	> L := [a,b,c,1,5,c,ln(2)]; subs(c=2, L); # je remplace tous les c par 2... L; # ...mais cela n'affecte pas ma liste L !! subsop(2=2, L); # attention, les deux 2 ne représentent pas la même chose !!
	L := [a, b, c, 1, 5, c, ln(2)] [a, b, 2, 1, 5, 2, ln(2)] [a, b, c, 1, 5, c, ln(2)] [a, 2, c, 1, 5, c, ln(2)]

• On va enfin énumérer le tri d'une liste, qui se fait par la commande sort. Pour des listes exclusivement numériques, Maple les trie par ordre croissant. Pour des liste symboliques, Maple classe par ordre alphabétique. Pour des listes mélangées, Maple trie d'abord par type, puis trie chaque type selon ses critères :

	> L := [1,3,8,5,4,7,2,1,8]; sort(L); > M := ['jambon', 'beurre', 'confiture', 'pain', 'couteau']; sort(M); > N := [a,b,c,1,5,c,ln(2),1/5,sin]; sort(N);
	[1, 3, 8, 5, 4, 7, 2, 1, 8] [1, 1, 2, 3, 4, 5, 7, 8, 8] [jambon, beurre, confiture, pain, couteau] [beurre, confiture, couteau, jambon, pain]

Remarque : Toute cette partie à l'air compliqué, d'un premier abord. Mais il est important de se familiariser avec les manipulations des suites et listes, elles sont des outils puissants de Maple et de sa structure intrinsèque, et sont souvent utilisées dans quelque domaine que ce soit (graphe de plusieurs fonctions, étude statistique, etc.).

Ensembles : Tout comme les liste, les ensembles sont en fait en Maple des suites entourées d'accolades ({ et }). Par rapport aux listes, il n'y a pas d'élément répété dans un ensemble, et l'ordre n'est pas toujours conservé (en particulier lorsque les éléments d'un ensemble ne sont pas ordonnables, et même quand les éléments sont des mots que Maple pourrait pourant classer par ordre alphabétique). On peut passer des suites aux ensembles en les entourant d'accolades, et passer d'un ensemble à une suite se fait via la commande op. On peut aussi créer des ensembles génériques de la même manière (à savoir {seq(...)};).
ATTENTION : Puisque les éléments ne sont pas répétés, il est faux de penser que op({S}) = S, si S est une suite qui comporte plusieurs mêmes éléments !!! Regardons ceci sur quelques exemples :

	> E1 := {2,1,3,3,1,5,1,4}; whattype(%); > E2 := {tan(x), sin(x), cos(x)}; whattype(%);
	E1 := {1, 2, 3, 4, 5} set E2 := {sin(x), cos(x), tan(x)} set
	> S := janvier, fevrier, mars, avril, mai, juin, juillet; E := {S}; op(E); evalb(op({S}) = S);
	S := janvier, fevrier, mars, avril, mai, juin, juillet E := {mai, janvier, fevrier, mars, avril, juin, juillet} mai, janvier, fevrier, mars, avril, juin, juillet false

On peut faire les opérations habituelles sur les ensembles avec Maple, telles que l'union, l'intersection ou la soustraction (la soustraction de deux ensembles E et F est donnée par E \ (E ⊂ F)) :

	> E := {1,2,3,4,5}; F := {2, 4, 6, 8, 10}; E union F; E intersect F; E minus F;
	E := {1, 2, 3, 4, 5} F := {2, 4, 6, 8, 10} {1, 2, 3, 4, 5, 6, 8, 10} {2, 4} {1, 3, 5}

Enfin la commande select permet de sélectionner des éléments d'un ensemble selon un certain critère. La syntaxe est alors la suite : select(critère, ensemble);. Cette fonction renvoie un ensemble. Par exemple, l'instruction select(isprime, {1,2,3,4,5}); renverra l'ensemble {2, 3, 5} comme résultat.

Tableaux : Une tableaux de dimensions l x c est une structure contenant lc données. Un tableau qui a pour dimensions 1 x c peut être vu comme un vecteur ligne de c composantes, un tableau de dimensions l x 1 peut être vu comme un vecteur colonne de l composantes, et un tableau de dimensions l x c peut être vu comme une matrice qui possède les mêmes dimensions. Pour plus de détail sur les matrices, on pourra se référer à l'aide en ligne des commandes de la librairie "LinearAlgebra". Ces matrices, ainsi que les opérations élémentaires dessus, sont étudiées dans le chapitre 6 du pdf dont ce cours a été inspiré. Vous pourrez le télécharger en page d'accueil Maple.

La syntaxe pour déclarer un tableau, et le mémoriser dans la variable T est la suivante : T := array(type, dimensions, valeurs);, où
• type est optionnel qui représente le type du tableau. Il peut être symmetric, antisymmetric, sparse, diagonal et identity ;
• dimensions représente les dimensions du tableau ;
• valeurs est optionnel aussi, et représente les valeurs de chaque "case" du tableau.

Pour afficher un tableau, on fait appel aux commandes print ou, si les valeurs ont été définies, eval. Dans le cas où les valeurs n'auraient pas été définies, eval mettra un point d'interrogation indexé par la case du tableau pour chaque valeur. Regardons les exemples suivants :

	> A := array(1..2, 1..2): #On définit un tableau 2x2 générique : print(A); # On l'affiche en suite de deux manières eval(A); > B := array(1..2, 1..2, [[1,2], [3,4]]): # On définit cette fois des valeurs print(B); # et on affiche à nouveau eval(B);

Même si l'affichage est le même avec ces deux commandes dans le cas où les valeurs ont été définies, il n'en va pas de même pour le type. En effet, en considérant la matrice B ci-dessus créée :

	> whattype(print(B)); whattype(eval(B));
	exprseq array

Notez que lorsque les valeurs sont définies, lorsqu'on sait quel tableau (ou matrice) ont veut définir, il n'est pas nécessaire de préciser ses dimensions, Maple se charge de le faire à votre place. L'argument de la commande array est alors simplement une liste de liste qui représentent les valeurs :

	> array(1..2, 1..2, [[1,2], [3,4]]); whattype(%); array([[1,2], [3,4]]); whattype(%);

On soulignera le fait qu'un tableau ainsi défini n'est pas une liste de listes, même si ces valeurs sont définies en tant que tel. En effet, une liste de listes a pour type list, alors qu'un tableau a pour type array !! Il est cependant possible de passer de l'un a l'autre et vice versae. Cela est rendu possible par la commande convert. Il est ainsi utile de savoir que pour Maple, une liste de listes se dit 'listlist'.

	> TAB := array([[1,2,3,4], [5,6,7,8], [9,a,b,c]]); whattype(%); LdL := convert(TAB, listlist); whattype(%); convert(LdL, array) ; whattype(%);

On peut extraire un élément du tableau. Pour un tableau T de dimensions l x c, la commande T[i,j]; renverra l'élément situé à la i-ième ligne et j-ième colonne (à condition que 1 ≤ i ≤ l et 1 ≤ j ≤ c). Par contre, on ne peut pas extraire de ligne ou de colonne complète, d'où l'utilité de la conversion en liste de listes (car chaque élément de la liste de listes est en fait une liste, qui correspondra à une ligne complète du tableau - pour extraire les colonnes, il faudra alors d'abord créer un tableau, le transposer (cf. package "LinearAlgebra"), le convertir en liste de liste et extraire l'élément désiré).

Les tables : Les tables sont une généralisation des tableaux. La principale différence entre les deux est que dans les tables, les indices peuvent être n'importe quel type d'expression (chaîne, symbole, ...), et non plus des entiers. Les tables sont utiles uniquement dans le cadre de la programmation avancée en Maple, car elles permettent de définir des librairies. Pour plus de précision, veuillez consulter le pdf de ce cours via le lien présent sur la page d'accueil Maple de ce site.

	> data1 := table([masse=`1 kg`, accel=`9.8 m/s^2`, temps=`3 s`]): data1[masse]; data1[temps]; > data2 := table([matos1=`écran`, matos2=`clavier`, matos3=`unité centrale`]): data2[matos3];
	1 kg 3 s unité centrale

3. Exercices

Exercice 21
a. Construisez une liste ordonnée des 100 premiers nombres premiers ;
b. Divisez tous les éléments de cette liste par 23 et appliquer la fonction frac à celle-ci pour obtenir une nouvelle liste de 100 fractions dont la valeur est entre 0 et 1 ;
c. Multipliez tous les éléments de cette liste par 23, et construisez une nouvelle liste qui sera le résultat de cette opération ;
d. Convertissez cette liste en ensemble et donnez le nombre d'éléments de cet ensemble.
Exercice 22
a. Créez une liste L2 comportant tous les carrés compris entre 1000 et 10000 de nombres entiers ;
b. Créez une liste L3 comportant tous les cubes compris entre 1000 et 10000 de nombres entiers ;
c. Créez un seule ensemble à partir de ces deux listes. Combien y a-t-il d'éléments qui sont à la fois dans L2 et L3 ?
d. Créez, sur le même modèle que a. et b., L4 et L6, listes des puissances 4èmes et 6èmes ;
e. Facultatif : Y a-t-il des éléments communs à toutes les 4 listes ?
Exercice 23
a. Construisez une matrice M de quatre lignes et autant de colonnes. Toutes les valeurs de cette matrice sont nulles SAUF celles situées sur la diagonale principale qui valent 1 (i.e. M_{i, i} = 1 pour 1 ≤ i ≤ 4) et celles situées sur la seconde diagonale (celle juste au-dessus de la principale) qui valent –1 (i.e. M_{i, i+1} = 1 pour 1 ≤ i ≤ 3).
b. Créez un tableau 3 x 3, appelé T. Une première fois, effectuez une conversion pour le transformer en liste de listes. Convertissez une seconde fois afin de n'obtenir qu'une seule liste dont les trois premiers éléments correspondront donc à la première ligne de T, les trois suivants à la seconde ligne et les trois derniers à la dernière ligne du tableau T.
c. Trouvez tous les nombres premiers compris entre 1235 et 1270 (indication : utiliser seq, select et isprime).