Tableaux, tables et listes

Tableaux

Les tableaux permettent de mémoriser dans une même structure différentes valeurs. Ils sont utile pour représenter les vecteurs et les matrices. On a coutume d'appeler les indices : index. Les tableaux sont déclarés en Maple par la primitive array.
Appel:
array( indexfcn, limites, valeurs)

Paramètres:
indexfcn - (optional) an indexing function
limites - (optional) sequence of ranges
valeurs - (optional) list of initial values

Exemples

> A:=array(1..4);
>A := array(1 .. 4, []):
> A[1];
                   A[1]
> A[5];
Error, 1st index, 5, larger than upper array bound 4
> B:=array([1,2,3]);
                    B := [ 1, 2, 3 ]
> B[4];
Error, 1st index, 4, larger than upper array bound 3
>v:=array[1..5,1..3,-1..6];

La fonction d'index (indexfcn) permet de définir une initialisation particulière pour la matrice. Certaines fonctions sont déjà définies :

Attention, le nom du tableau représente l'endroit ou est rangé le tableau dans la machine. Si T est un tableau, l'affectation A:=T n'a pas pour effet de recopier T dans A mais seulement d'attribuer à A la même contenance que T. Pour obtenir un tableau de contenu identique à T mais différent de T on écrit A:=copy(T).

La plupart des opérations d'algèbre linéaire existent dans Maple et peuvent éventuellement être faites formellement.

Raccourci Il est possible de définir directement un vecteur à une dimension par la primive vector et une matrice par la primitive matrix.


Tables

Les tables sont des tableaux que l'on peut indexer par des index non entiers. C'est particulièrement utile pour utiliser des indices "plus parlant".
Appel :
table(indexfcn, list )

Paramètres :
indexfcn - (optional) an indexing function
list - (optional) list of initial values
 

Exemples

>T := table(symmetric,[(c,b)=x]);
>T[c,b];
                     x
>v:=table():
>v[dilutionle26]:=array(1..100):
>v[dilutionle30]:=array(1..100):
>i:=26;
                 i := 26
>v[dilutionle.i][45]:=3:
>v[dilutionle26][45];
                   3

Les fonctions indices et entries permettent respectivement d'avoir la liste des index et des contenus d'une table.
Attention, comme pour les tableaux il faut utiliser la fonction copy pour effectuer la copie d'une table la simple affectation ne suffit pas.


Listes

Les listes étant la base de l'implémentation du langage Maple, de nombreuses fonctions existent qui permettent d'effectuer des opérations complexes en peu d'instructions. On peut générer une liste en utilisant la primitive seq. Par exemple, [seq(i^3,i=1..4)] fournira le résultat [1,8,27,64]
Pour remplacer un élément dans une liste, on utilise :
Exemple
>L:=[x,x+y,2*x]:
>subs(x=3,L);
               [3, 3 + y, 6]
>subsop(3=Z,L);
               [x, x + y, Z]
Toute expression maple étant représentée comme une liste, la fonction subs peut être appliquée à toute expression Maple.
Exemple
La primitive map permet d'appliquer une fonction aux éléments d'une liste. La fonction peut avoir plusieurs arguments.
Appel:
map(fcn, expr, arg2, ..., argn)

Paramètres:
fcn - une procédure
expr - une expression
argi - (optionel) autres arguments de fcn

Exemples

>map(sin,[0,Pi,Pi/2,Pi/3]);
                  [0, 0, 1, 1/2 sqrt(3)]
>map(diff,[sin(x+y),cos(x+y),tan(x+y*x)],x);
          [cos(x + y), -sin(x + y), (1 + tan(x + y x)^2) (1 + y)]
>map(x->x^2,[1,2,3,4]);
                     [1, 4, 9, 16]
Attention, on peut appliquer directement une fonction sur une expression Maple puisque celle ci est une liste mais le résultat peut surprendre. Par exemple, map(sin,x+y+z) fournira le résultat sin(x)+sin(y)+sin(z) qui est différent de sin(x+y+z).

La primitive zip permet d'appliquer une fonction binaire à deux listes.

Appel:
zip(f, u, v, d)

Paramètres:
f - fonction binaire
u,v - listes
d - valeur à utiliser si il manque des éléments (optionel)

Exemple

>zip((x,y)->x+y,[1,2,3],[4,5,6]);
                       [5, 7, 9]
Attention, il ne faut pas confondre une liste maple et un tableau maple. Une des différences fondamentales entre une liste et un tableau maple est que les fonctions d'accès par les crochets ne fonctionnent pas de la même manière.
Exemple
>t:=array(1..4,[1,4,9,16]);
                          t := [1, 4, 9, 16]
>t;
                                  t
>nops(t);
                                  1
>t[1..2];
                              t[1 .. 2]
>l:=[1,4,9,16];
                          l := [1, 4, 9, 16]
>l;
                            [1, 4, 9, 16]
>nops(l);
                                  4
>l[1..2];
                                [1, 4]

Principe des algorithmes sur les tableaux

On distingue les parcours simples des autres parcours. Il s'agit d'algorithmes consistant parcourir à l'aide d'une boucle les éléments d'un tableau et à exécuter pour chacun d'eux un nombre borné d'opérations. Ces algorithmes sont linéaires c'est à dire que le nombre d'opérations est proportionnel à n.
Exemple : Algorithme de la recherche du plus petit élément d'un tableau
minimum:=proc(t,n)
          local i,m;
          m:=infinity;
          for i from 1 to n do
              if t[i]<m then m:=t[i] fi;
          od;
          RETURN(m);
end:
Les autres algorithmes consistent à parcourir à l'aide de plusieurs boucles imbriquées les éléments d'un tableau et à exécuter pour chacun d'eux un nombre borné d'opérations. Ces algorithmes ne sont pas linéaires.
Exemple : Algorithme qui détermine l'élément le moins fréquent dans un tableau.
moinsfrequent:=proc(t,n)
           local i,j,x,freq,f;
           freq:=infinity;
           f:=0;
           x:=t[1];
           for i from 1 to n do
              for j from i to n do
                   if (t[i]=t[j]) then f:=f+1 fi;
              od;
              if (f<freq) then freq:=f; x:=t[i]; fi;
           f:=0;
           od;
           RETURN([x,freq]);
end: