Une séquence , de type exprseq , est une suite d'éléments séparés par une virgule . On accède à

chaque élément par son rang , mais l'affectation est interdite :

> restart:
    s:=a,b,-1,2*p-q,r;

> s[4];s[2..5];s[3]:=0;

> v:=NULL;

Pour répéter un élément , utiliser l'opérateur dollar $ :

> t:=a$2,y$5;

> u:=s,t;

op(expr) retourne la séquence formée des opérandes de l'expression expr :

> op(a-y*(a+y+z)+3*z);

La fonction seq permet de créer une séquence

pour un indice i variant de a à b avec un pas de 1 : syntaxe seq(expr,i=a..b) , ou

pour un indice décrivant les opérandes d'une expression e : syntaxe seq(expr,i=e) :

> seq(i^3,i=-1/2..2);

> e:=a-y*(a+y+z)+3*z:op(e);
    seq(mu+i,i=e);

> seq(seq(a||i||j,j=1..3),i=1..3);

Une liste , de type list , est obtenue en plaçant une séquence entre les crochets [ et ] .

La liste vide se note [] .

> s:=a$2,b$3,alpha,beta;L:=[s];

On accède à chaque élément d'une liste par son rang , l'affectation est autorisée:

> L[6];L[2..5];L[3]:=delta;

op transforme une liste en séquence , nops donne le nombre d'éléments d'une liste .

Les fonctions op et nops ne peuvent agir sur une séquence s : faire ops([s]) et nops([s])

> op(L);

> nops(L);

Pour modifier une liste, on peut aussi utiliser subs ou subsop :

> L:=subs(b=b1,L);

> L:=subsop(3=gamma,L);

La fonction booléenne member permet de savoir si une expression est membre d'une liste:

> member(gamma,L), member(epsilon,L);

Un ensemble , de type set , est obtenu en plaçant une séquence entre les accolades { et }.

Les éléments sont rangés par adresse , donc l'ordre initial n'est pas nécessairement conservé et les éléments en

double sont supprimés. L'ensemble vide se note {} .

> s:=a$2,b$3,alpha,beta;e:={s};

On accède à chaque élément d'un ensemble par son rang , mais l'affectation est interdite :

> e[2];e[2..3];e[3]:=delta;

> op(e);nops(e);

Pour modifier un ensemble , l'affectation étant interdite , utiliser sub s ou subsop :

> e:=subs(b=b1,e);

> e:=subsop(3=delta,e);

La fonction booléenne member permet de savoir si une expression est membre d'un ensemble:

> member(delta,e), member(epsilon,e);

Convertir un ensemble en somme, en produit, en liste, ou convertir une liste en

ensemble avec convert :

> convert(e,`+`);convert(e,`*`);
    e:=convert(e,list);e:=convert(e,set);

Opérations sur les ensembles:

union (union) , intersect (intersection) , minus (différence) .
la fonction booléenne a indique si a est un sous-ensemble de b .

> e:={alpha,beta,gamma,delta}:f:={beta,delta,epsilon,phi,lambda}:
    u:=e union f;i:=e intersect f;m:=f minus e;

> i subset e, i subset m;

> with(combinat,choose):

(appel de l'outil choose , qui génère les sous-listes ordonnées d'une liste donnée)

> choose([a,b,c]);

Génération de toutes les sous-listes de longueur 2 ordonnées d'une liste de longueur 3:

> choose([a,b,c],2);

choose ( n , p ) avec n , p entiers , génère toutes les sous-listes de longueur p ordonnées de [1,2,.., n ]

> choose(4,3);

> with(combinat,permute):

(appel de l'outil permute , qui génère les listes de permutation d'une liste donnée)

> permute([a,b,c]);

Génération de toutes les sous-listes de permutation de longueur 2 de [a,b,c] :

> permute([a,b,c],2);

permute ( n ) , avec n entier , donne les listes de permutation de [1,2,..., n ]

> permute(3);

permute ( n , p ) , avec n , p entiers , donne les sous-listes de permutation de de longueur p de [1,2,..., n ]

> permute(3,2);

> restart;

Une table est une structure indexée dont les indices (ou index ) peuvent être de n'importe quel type.

La fonction table permet de créer une table :

Création d'une table vide:

> v:=table();

Création d'une table T avec une liste de valeurs:

> T:=table([valeur1,valeur2]);

Création d'une table U avec liste d'index (ici ° . *) et de valeurs:

> U:=table([`°`=valeur1,`.`=valeur2,`*`=valeur3]);

Pour afficher le contenu d'une table , utiliser print ou eval

> print(T),eval(U);

On peut modifier , créer un nouvel élément , ou supprimer un élément par affectation :

> T[a]:=valeur3:U[~]:=valeur4:print(T),eval(U);

Une table peut être directement créée par assignation :

> V[a]:=1:V[b]:=2:V[c]:=3:eval(V);

Fonctions agissant sur des tables:

> op(op(V));

> indices(V);

> entries(V);

La fonction map permet d'appliquer une fonction sur les valeurs d'une table:

> V:=map(sqrt,V);

La fonction copy permet d'effectuer une copie d'une table:

> W:=copy(V);

Un tableau est une structure indexée, de type array , de plusieurs dimensions, dont les indices

sont des entiers appartenant à un intervalle a..b (de type range ) .

La fonction array permet de créer un tableau :

Des fonctions analogues à celles utilisées pour les tables existent :

Création d'un tableau à une dimension:

> T:=array(1..3);

Création d'un tableau à une dimension avec initialisation partielle:

> U:=array(1..5,[a,b,c]);

Création d'un tableau à 2 dimensions avec initialisation complète:

> V:=array([[a,b,c],[d,e,f]]);

Création d'un tableau rectangulaire d'entiers par affectation à l'aide de boucles imbriquées:

> T:=array(1..2,1..3):
    for i to 2 do
        for j to 3 do
            T[i,j]:=(i-1)*3+j;
        end do;
    end do:
    print(T);

> op(op(T));

> indices(T);

> entries(T);

> map(x->x^2,T);

Conversion d'un tableau en liste (si la dimension est 1) ou en liste de listes (si la dimension est >1):

> convert(U,list);convert(T,listlist);

Conversion d'un tableau de dimension quelconque en ensemble:

> convert(T,set);

> T:=convert([a,b,c,d],array);

> U:=copy(T);

> restart;
    listeinverse:= proc(L::list)
        local i;
            [seq(op(nops(L)-i,L),i=0..nops(L)-1)];
    end proc:

> listeinverse([a,b,c,d,e,f]);

> VDM:=proc(n::posint)
        local i,j,a,V;
            a:=array(1..n):V:=array(1..n,1..n):
            for i to n do for j to n do V[i,j]:=a[i]^(j-1) end do end do;
            print(V);
    end proc:

> VDM(4);

ligne( T , p , i ) qui calcule la somme des éléments de T situés en ligne i .

2° Un tableau T à n lignes et p colonnes étant donné , écrire une procédure

colonne( T , n , j ) qui calcule la somme des éléments de T situés en colonne j .

3° Un tableau carré T à n lignes et n colonnes étant donné , écrire une procédure

diagonale1( T , n ) qui calcule la somme des éléments de T situés sur la première diagonale.

4° Un tableau carré T à n lignes et n colonnes étant donné , écrire une procédure

diagonale2( T , n ) qui calcule la somme des éléments de T situés sur la seconde diagonale.

5° Un tableau T carré à n lignes et n colonnes est dit magique si la somme des éléments de

n'importe quelle ligne , de n'importe quelle colonne , et de n'importe quelle diagonale est

la même .

Utiliser les procédures précédentes pour écrire une fonction booléenne magique( T , n )

rendant la valeur true si T est magique, et false sinon .

Exemples:

> magique(T,3);

> magique(U,3);

(écrite en lettres minuscules) en un nombre.

On code : , , etc ... , .

Exemple: si alors , , 6 , , .

> coder("maple");

Aide: pour écrire cette procédure , on construira un alphabet puis une table T de conversion

et on utilisera au besoin les fonctions de Maple suivantes:

length(st) qui donne la longueur de la chaîne de caractères st .

substring(st,m..n) qui extrait de st la sous-chaîne des caractères situés entre les positions m et n .