Vous êtes sur la page 1sur 17

Initiation à Maple

Initiation à Maple
I— Découverte des premières fonctionnalités de Maple.
1- Définition rapide
Maple est un outil pour faire des calculs scientifiques.
Ces calculs peuvent être des calculs de vue symbolique, numérique, graphique.
Maple est aussi u langage de programmation.
Ce logiciel a été développé par des chercheurs de l’université de Waterloo au Canada et de
l’université ETH de Zurich.

2- Concurrence :
D’autres produits analogues à Maple existent, notamment Derive, Mathematica , ou MuPad.
Actuellement, Maple est très répandu dans l’enseignement en classes préparatoires.

3- Session :
Définition :
Une session de travail type avec Maple commence évidement par le lancement du logiciel sous
Windows, un double clic sur l’icône correspondante suffit.
Une feuille de travail (Worksheet) vide est alors affichée à l’écran, et Maple à travailler en mode
interactif, une session est constituée de toutes les entrées (input) de l’utilisateur, qui apparaissent en
rouges et de toutes les réactions de Maple appelées (output), et qui apparaissent souvent centrées en
bleu à l’écran.
A tout moment, on peut fermer la feuille de travail, après avoir sauvegardé. La session de Maple
se termine par la fermeture de Maple (File, Exit)(Alt F4), on peut également charger une feuille de
travail déjà sauvegardée.

4 – Interface utilisateur :
a- Syntaxe des entrées :
Chaque entrée de l’utilisateur débute après l’invite > (prompt), se termine par un point-virgule (;)
ou deux point (:) et est validée par la touche ENTREE. La terminaison d’une entrée par le symbole
deux-points (:) est réservée pour les calculs intermédiaires, pour lesquels l’affichage du résultat ne
présente pas d’intérêt.
Pour effectuer un retour chariot dans une entrée, sans valider cette entrée, on tape Shift+Entrée,
et forme un groupe qui sera exécuté lorsqu’on tape entrée.

b- Interruption :
On peut interrompre un calcul par le bouton STOP, qui n’est actif que lorsqu’un calcul est en
cours. La réaction peut être sans effet c’est pourquoi il faut sauvegarder régulièrement le travail.

c- Utilisation d’un résultat précèdent :


• Le symbole pourcent (%) désigne le dernier résultat calculé par Maple.
• Le symbole double pourcent (%%) désigne l’avant dernier résultat calculé par Maple.
• O peut enchaîner jusqu’à trois pourcent.
• Un objet peut être conservé dans la mémoire de l’ordinateur en affectant une valeur à une
variable de l’objet. On peut ensuite faire référence à l’objet en utilisant le nom de la
variable.

ENSA Khouribga 1 Professeur : SEHMAOUI


Initiation à Maple

d- Les commentaires :
On peut insérer dans une feuille de calcul des commentaires qui ne seront pas interprétés par
Maple :
• Soit en faisant précéder le commentaire du symbole #.
• Soit en plaçant le curseur dans une zone de texte pur par le menu (Insert/Text) ou (Ctrl+T).

e- Besoin d’aide :
L’utilisation de Maple demande de se conformer à une syntaxe assez stricte.
Aussi il est difficile de retenir le nom de centaines instructions disponibles, ainsi la manière dont il
faut les employer. C’est pourquoi Maple est livré avec un système d’aide complet.
Pour obtenir une aide sur une instruction dont on connaît le nom, comme par exemple expand,
on peut procéder de plusieurs manières :
• ?expand (suivi de entrée) affiche l’écran d’aide complet.
• ??expand (suivi de entrée) affiche le syntaxe : comment appeler expand et avec quels
paramètres.
• Sélectionner l’instruction et taper la touche de fonction F1.
• Pour chercher toutes les instructions qui commencent par f, taper f et taper F1
• Utiliser le menu Help / Fulle Text Search , faire saisir votre instruction et cliquer sur le
bouton Search.

f- Important :
Il faut bien comprendre que c’est l’ordre chronologique de validation des entrées qui

détermine le comportement du logiciel, et non l’ordre sur la feuille de calcul.

Pour réduire le risque de confusion, et pouvoir localiser plus facilement les erreurs on commence
les feuilles de calcul par la commande restart, qui a pour effet de réinitialiser la session. Aussi on
peut ré-exécuter chacune des entrées dans l’ordre de la feuille, et faire coïncider la session et la
feuille de calcul.

5 - Les opérateurs, les fonctions et les constantes:


a- Les opérateurs :
Certains caractères ont des fonctions spéciales dans le langage Maple :( par exemple)
3+5 ; # Calcule de la somme de 3 et de 5

X :=7 ; # (affecter à X la valeur de 7)

X :=‘X’ ; # (libérer X).

restart ; #(toutes les variables sont désassignées c-à-d : n’ont plus de contenue)

alpha ; # ( pour la lettre grecque α ).

ENSA Khouribga 2 Professeur : SEHMAOUI


Initiation à Maple

Principaux opérateurs de Maple :


Opérateurs Description Opérateurs Description
+ Somme >= Supérieur ou égale
- Différence = Egal
* Produit <> Différent
/ Quotient -> (moins flèche) Opérateur flèche
** ou ^ Puissance mod Modulo
$ Opérateur de séquence union Union d’ensembles
:: Déclaration de type intersect Intersection de deux ensembles
.. Intervalle and Et (logique)
, Séparateur d’expression or Ou (logique)
:= Affecation &* Multiplication des matrices
< et > Inférieur et Supérieur [] Délimiteurs de liste
<= Inférieur ou égal {} Délimiteurs d’ensemble

b- Les fonctions
Principales fonctions mathématiques et logiques dans Maple :
Fonctions Description
sin(x), cos(x) , tan(x), arcsin(x) ,
Fonctions trigonométriques
arcos(x), arctan(x)
sinh(x), cosh(x), tanh(x), arcsinh(x),
Fonctions hyperboliques
arcosh(x), arctanh(x)
In(x) ou log(x) Logarithme népérien
log[10](x) ou log10(x) Logarithme décimal (readlib(log10))
sqrt(x) Racine carré de x
issqr(x) Test si l’entier x est un carré parfait
root[n](x) = root(x,n) Racine n-ième de x
floor(x) Partie entière de x
ceil(x) Entier immédiatement supérieur à x
abs(x) Valeur absolue de x
exp(x) Exponentielle de x
log[b](x) Logarithme en base b
n! ou factorial(n) Factorielle de n
iquo(a,b) Quotient de la division euclidienne de a par b
irem(a,b) Reste de la division euclidienne de a par b
min(E) Minimum d’un ensemble
max(E) Maximum d’un ensemble
binomial(n,k) Coefficient binomiaux
ifactor(x) Factorisation de l’entier x
igcd(x1,..,xn) Pgcd des entiers x1 .. xn
ilcm(x1,..,xn) Ppcm des entiers x1..xn
iroot(a,n) Entier plus proche de la racine n-ième entier de l’entier a
isprime(a) Retourne true si l’entier a est premier
nextprime(x) Donne le plus petit no,mbre premier supérieur à x
sign(x) Donne -1 si x<0 et donne 1 si x>=0
rand() Rend un entier positif aléatoire de 12 chiffres
rand(a,b)( ) Rend un entier aléatoire compris entre a et b
rand(a)( ) Rend un entier compris entre 0 et (a-1)
numer(x) Numérateur entier du rationnel x
denom(x) Dénominateur entier du rationnel x
Donne la valeur approchée de exp avec d chiffres
evalf(exp,d)
significatifs
evalb(a=b) Renvoie true si a =b et false si a <>b

ENSA Khouribga 3 Professeur : SEHMAOUI


Initiation à Maple

Sum et sum La valeur et la forme inerte de l’expression d’une somme


Product et product La valeur et la forme inerte de l’expression d’un produit
limit La limite d’une fonction

Pour plus de fonctions consulter le help de Maple par l’instruction : > ?index,function

Principales constantes dans Maple :


true La valeur vrai d’une expression logique
infinity et -infinity Plus et moins l’infinie ( ∞ )
>Catalan ; Constante de Catalan sum((-1)^i/(2*i+1)^2,i=0..infinity) = 0.9159655942
gamma Constante d’Euler limit(sum(1/i,i=1..n) - ln(n) = 0.5772156649
Pi π , valeur approchée: 3.141592654

6 - Majuscules et minuscules :
Dans l’analyse d’une ligne de saisie ; Maple distingue les majuscules des minuscules.
Le mot (Sum) est différent du mot (sum).
> Sum(1/(i+1),i=1..10);
10
1
∑ i+1
i =1

> sum(1/(i+1),i=1..10);
55991
27720
Expand n’est pas une instruction de Maple, mais expand oui.
> expand((x+y)^5);
x 5 + 5 x 4 y + 10 x 3 y 2 + 10 x 2 y 3 + 5 x y 4 + y 5
> Expand((x+y)^5); Maple ne sait quoi
5
Expand ( ( x + y ) ) faire avec Expand
!
La variable A est différente de la variable a.
> restart:A:=3;
A := 3
a n’a pas de valeur
> a;
a

7 –Packages:
Toutes les fonctions définies dans Maple ne peuvent être présentes en même temps dans la
mémoire de l’ordinateur. Les plus utilisées sont chargées d’office au démarrage de Maple avec le
noyau (Kernel), la plus grande partie du savoir de Maple réside dans les packages qui sont des
regroupements de nouvelles fonctionnalités dans un domaine donné. Plusieurs packages font partie
intégrante du logiciel. Consulter le help par l’instruction : > ?index,packages

ENSA Khouribga 4 Professeur : SEHMAOUI


Initiation à Maple

Exemples :
geometry Géométrie euclidienne
linalg Algèbre linéaire
plots Représentations graphiques

Pou pouvoir utiliser tout ou une partie d’un package on utilise l’instruction (with) exemple :

>with(linalg) : #pour charger toutes les fonctions du package linalg sans renseignement.

> with(linalg) ; #pour charger et voir la liste de toutes les fonctions disponibles dans le package.

Par la suite on peut utiliser n’importe quelles fonctions de ce package.

Exemple :

> A := matrix(3,3, [x,1,0,0,0,1,x*y,y,1]);

> rank(A);# donne le rang de la matrice A

>restart : A := matrix(3,3, [x,1,0,0,0,1,x*y,y,1]); rank(A);

Que remarquez vous ?

ENSA Khouribga 5 Professeur : SEHMAOUI


Initiation à Maple

II— Elément de base.


1 Les noms dans Maple :
Les noms servent à former des mots, des messages ou a nommer des objets. On rappelle que
Maple différencie les majuscules des minuscules.
Un nom débute en général par une lettre suivie par des lettres ou des chiffres. Le caractère de
soulignement _ peut également figurer dans un nom, à n’importe quelle position. Mais on évitera de
le placer au début.

Exemples :
Solde1, Prix_unitaire, somme, PrixBrut, ….

2 Utilisation des caractères :


On peut en fait former un nom avec des caractères quelconques notamment des espaces, ou des
caractères particuliers comme *, ?, +,etc. Il suffit de débuter et terminer le nom par le caractère
(accent grave) (` AltGr+7), il est même possible d’utiliser ce caractère ‘ dans le nom à condition
de le doubler ‘‘.

Exemple :

> `expand 1`:=3; expand 1:=3


> `* L``intêret *`:=8; * L``intêret *:=8;

3 Assignation et désassignation
L’opération qui consiste à associer un résultat à un nom est l’assignation (ou affectation) ,
exemples :
somme :=4 ; produit :=3*4 ;trouve :=true ;
Pour désassigner un nom comme somme, on exécutera l’instruction :
> somme:='somme'; on notera l’utilisation des apostrophes, ce qui aura pour conséquence que le
nom somme retrouve son statut de variable formelle.
> somme:=4; # assigner somme
somme := 4
> somme;
4

> somme:='somme';# désassigner somme = libérer


somme
somme := somme
> somme;
somme
Remarque:
L’instruction restart permet de redémarrer la session de travail et de désassigner tous les noms de
variables qu’un utilisateur aurait créé.

ENSA Khouribga 6 Professeur : SEHMAOUI


Initiation à Maple

4 Lettres grecques
Les lettres grecques sont saisies sous la forme alpha, beta, gamma, lambda, mu, epsilon, pi, etc.
mais Maple les affiches avec le caractère correspondant grec.
Par exemple :
> alpha;
α
Taper :
> alpha, beta, delta, gamma, lambda, epsilon, mu, nu, pi, phi, rho,
sigma, theta,tau,xi;
α, β , δ, γ, λ , ε, µ, ν, π, φ, ρ, σ, θ, τ, ξ
5 Les nombres :
5.1 : Nombres entiers :
Maple effectue des calculs sur des nombres relatifs de manière exacte avec autant de chiffres que
nécessaire.
Rappelons qu’un entier long peut être découpé en tranches par des caractères \ :(AltGr+8).
Exemples :
> 7777777777777777777777777777*8888888888888888888888888;
69135802469135802469135795548641975308641975308641976
> a:=44444444444444444444444444444444\
55555555555555555555555555\
777777777777777777777777777;
44444444444444444444444444444444555555555555555555555555557777777777 \
77777777777777777
> a^2;
19753086419753086419753086419753185185185185185185185185187160493950 \
61728395061728394370370864197530864197530864197534074074074074074 \
0740740740395061728395061728395061729

5.2 : Nombres rationnels :


a
Les nombres rationnels sont les quotients q = de deux entiers relatifs, b étant non nul. Quand
b
c
un tel rationnel est évalué, il est automatiquement simplifié en entier si b divise a ou en avec c et
d
d étant premiers entre eux.
Exemples :
> 24/8, 16/12, 2/3+9/12, 5/11*4/5, 4/7/2/3;
4 17 4 2
3, , , ,
3 12 11 21

5.3 : Nombres réels et Evaluation forcée au format réel:


Un nombre au format réel s’il contient un point décimal, éventuellement à la fin : par exemple :
5.est un nombre réel alors que 5 est un nombre entier.

ENSA Khouribga 7 Professeur : SEHMAOUI


Initiation à Maple

Les calculs sur les nombres réels peuvent être effectués avec autant de décimales que nécessaire,
cela dépend de la variable Digits (attention à la majuscule D) qui désigne le nombre de décimales à
utiliser. Par défaut Digits=10, mais on peut modifier cette valeur à tout moment.
On peut créer un nombre réel par Float (mantisse,exposant) ce qui produit le nombre réel
matisse*10exposant.
> Float(4,3);
4000.
Il est possible de forcer le passage en format réel d’une expression dont la valeur est entière ou
rationnelle, ou qui contient des constantes comme Pi par exemple. On utilise pour cela l’instruction
evalf (qui veut dire :eval to floot) ou evalf(expression,n) si on veut une évaluation avec n
décimales.
> evalf(Pi);
3.141592654
> evalf(Pi,20);
3.1415926535897932385
> Digits;
10
> Digits:=30;
Digits := 30
> evalf(Pi);
3.14159265358979323846264338328
> evalf(sin(2),50);
0.90929742682568169539601986591174484270225497144789
> evalf((14/3+5/7)*5,4);
26.90

5.4 : Nombres complexes :


π
Maple nomme I (attention à la majuscule) le complexe de module 1 et argument .
2
Un nombre complexe est alors une expression a+b*I, où a et b sont des réels ou rationnels.
> I:=5; # I est protégé par Maple
Error, illegal use of an object as a name

> I^2;
-1
> sqrt(-3);
3I
> a:=3+2*I;b:=sqrt(2)+(2/3)*I;
a := 3 + 2 I
2
b := 2 + I
3
> whattype(a);
complex
> a+b;

ENSA Khouribga 8 Professeur : SEHMAOUI


Initiation à Maple

8
3+ I+ 2
3
On peut utiliser aussi les fonctions Complex, Im et Re:
> Complex(5,7);
5+7I
> Im(a);# donne la partie imaginaire d'un complexe
2
> Re(a);# donne la partie réelle d'un complexe
3

6 Les fonctions:
Simplement une fonction est un objet f qui agit sur des arguments pour renvoyer un résultat
f (arg1,…,argn) représente l’image par f de la séquence d’arguments arg1,…,argn.
Un nombre peut être considéré comme une fonction constante :
> x:=2; x(4), x(2,6);
x := 2
2, 2

Définir des fonctions :


Le nombre de fonctions intégrées à Maple est important, mais on a souvent besoin de définir ses
propres fonctions. La syntaxe est :
- pour une fonction d’une seule variable :
> f :=var->expr; # (->):les signes moins et supérieur
- pour une fonction de n variables :
> f :=(var1,…,varn)->expr;
> f:=x->x^3+5*x+4;
f := x → x 3 + 5 x + 4
> f(0), f(1), f(-2);
4, 10, -14
> g:=(x,y)->x*y+x-y;
g := ( x, y ) → x y + x − y
> g(0,0), g(5,2), g(-4,-8);
0, 13, 36
> h:=x->x^2+5*x+4;solve(h(x));
h := x → x 2 + 5 x + 4
-1, -4

ENSA Khouribga 9 Professeur : SEHMAOUI


Initiation à Maple

En pratique:
Exercice:

Définir les fonctions suivantes :

1- f(x)=3(x+1)2+5x+2 , calculer f(a) et f(1) ;

2
( −x )
x +e
2- g := x → x−1 , calculer g(0) ,limit de g en + ∞ en 1- et 1+ .

 3 x 2 +2x : si x est pair


3- x ∈ ` , h( x) =  calculer h(2), h(3).
(− x3 + 1) si x est impair
3

4- k ( x, y ) = x3 − y 3 , calculer K(10,2), K(a,b), K(b,a).

ENSA Khouribga 10 Professeur : SEHMAOUI


Initiation à Maple

III—Séquences, listes ; ensembles, tables et tableaux.


3.1 : Séquences :
Une séquence est une suite d’objet séparés par des virgules. On peut donner un nom à une
séquence :
> s1 :=1, 2, f, t^2-3, 2, pi ;
s1 := 1, 2, f , t 2 − 3, 2, π
Le troisième élément de la séquence est obtenu grâce à la commande s1[3].

Si S2 est une séquence, l’expression s1, s2 désigne la séquence obtenue par concaténation des
séquences s1 et s2.
> s1 :=1, 2, f, t^2-3, 2, pi ;
s2 :=5, 4, 7;
s1, s2;
s1 := 1, 2, f , t 2 − 3, 2, π
s2 := 5, 4, 7
1, 2, f , t 2 − 3, 2, π, 5, 4, 7

Maple peut créer des séquences grâce à la commande seq comme :


> seq(k^2,k=10..20) ;
100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400
> seq( i, i="f".."t" );
"f" , "g", "h" , "i", "j", "k" , "l", "m", "n" , "o" , "p" , "q" , "r" , "s", "t"
Le principal inconvénient d’une séquence est que Maple ne dispose pas de commande permettant
de connaître le nombre d’éléments figurant dans une séquence.

3.2 : Listes :
Une liste est presque la même chose qu’une séquence, mais ses éléments sont entourés par des
crochets :
> L1 :=[1, 2, f, t^2-3, 2, pi ];
L1 := [ 1, 2, f , t 2 − 3, 2, π ]
> L2:=[jan,Fév,Mar];
L2 := [ jan , Fév , Mar ]
En particulier si s1 est une séquence, l’expression [s1] désigne la liste dont les éléments sont
ceux de la séquence s1.
Avantage : La commande nops permet de savoir combien une liste comporte d’éléments
> nops(L2);
3
> nops(L1);
6
On ne peut directement concaténer des listes, il faut d’abord les transformer en séquences, par la
commande op (qui récupère les opérandes des listes), faire la concaténation des séquences :
Remarquer la différence entre les deux instructions :

ENSA Khouribga 11 Professeur : SEHMAOUI


Initiation à Maple

> [L1,L2];
[ [ 1, 2, f , t 2 − 3, 2, π ], [ jan, Fév , Mar ] ]
> [op(L1),op(L2)];
[ 1, 2, f , t 2 − 3, 2, π, jan , Fév , Mar ]

3.3 Ensembles :
C’est une collection non ordonnée (contraire ment aux listes et aux séquences) d’objets, séparés
par des virgules et entourés par des accolades :
> E:={1,44,f,tˆ2-3,44,pi};
(Noter la disparition du second « 44 » : les éléments redondants sont supprimés). Même si la
commande.
E [ 3 ] fournit un résultat, elle est à proscrire : du fait que les éléments d’un ensemble ne soient pas
ordonnés ,on ne sait pas a priori quel élément on obtient ainsi. On peut en revanche convertir un
ensemble en liste par la commande >convert(E,list). En donnant un nom à cette liste, on pourra
ensuite récupérer ses éléments, ceux-ci étant écrits dans un ordre immuable. L’autre conversion
(>convert(l,set)) est aussi possible et souvent utile.
On dispose des opérations union (union) et intersection (intersect) sur les ensembles.
> {a,b} union {b,c};
{ a , b, c }

> {a,b} intersect {b,c};


{b}

Un ensemble est de type set.


> a:={un,deux,trois,un,quatre};whattype(a);
a := { un, trois , deux , quatre }
set
> a[2];
trois
L'ensemble vide est {}.
> b:={};
b := { }

ENSA Khouribga 12 Professeur : SEHMAOUI


Initiation à Maple

3.4 Tables et tableaux :


a- Tables :
Une table est un objet permettant de stocker des données repérées par un indice de n'importe quel
type.
On peut créer une table en utilisant la fonction table selon trois syntaxes :
* Création d’une table vide :
> TA :=table() ;
TA := table([])
** Création d’une table avec une liste de valeurs :
> a:=table([un,deux]);
a := table([1 = un, 2 = deux ])
> t:=table([toto,titi,tata]);
t := table([1 = toto , 2 = titi , 3 = tata ])
Les index sont mis par défaut, dans l’ordre de la liste donnée.
*** Création
> b:=table([(pre)=lundi,(deu)=mardi]);
L’ordre de la liste n’est pas obligatoirement respecté.
b := table([pre = lundi , deu = mardi ])
> b[pre];
lundi
On peut définir directement une table par la simple affectation de ses éléments.
> toto[un]:=one; #crée la table toto
toto un := one

> print(toto);
table([un = one])
Une table T étant donnée.
op(T) Donne la structure
op(op(T)) Donne la liste de couples index=valeurs
indices(T) Donne les index
entries Donne les valeurs

b- Tableaux :
Un tableau est un objet permettant de stocker des données repérées par un (ou plusieurs) indices
entier. Un tableau est de types array.
On crée un tableau à l’aide de l’instruction array(i,j) crée un tableau dont l’indice varie de i à j
(entiers).
> a:=array(1..5);
a := array ( 1 .. 5, [ ] )
On peut définir individuellement chaque élément du tableau:
>
a[1]:=Tanger:a[2]:=Casa:a[3]:=Khouribga:a[4]:=Agadir:a[5]:=Laâyoun
e:
> print(a);
[ Tanger , Casa, Khouribga , Agadir , Laâyoune ]

ENSA Khouribga 13 Professeur : SEHMAOUI


Initiation à Maple

On peut définir ses éléments par une liste:


> L:=[un,deux,trois,quatre]:
> b:=array(8..11,L);
b := array( 8 .. 11, [ ])
( 8 ) = un
( 9 ) = deux
( 10 ) = trois
( 11 ) = quatre
> b[9];
deux
Si l'on appelle un élément dont l'indice n'est pas dans l'intervalle i..j, un message d'erreur est
retourné:
> b[4];
Error, 1st index, 4, smaller than lower array bound 8

Si on ne précise pas le domaine de variation de l'indice, la première valeur est 1 par défaut:
> c:=array([2,4,6,8]);c[1];c[4];c[7];
c := [ 2, 4, 6, 8 ]
2
8
Error, 1st index, 7, larger than upper array bound 4

On peut définir des tableau à deux dimensions; toutes les remarques ci-dessus restent valables:
> d:=array(2..4,8..10,[[1,2,3],[4,5,6],[7,8,9]]);
d := array( 2 .. 4, 8 .. 10, [ ( 3, 9 ) = 5 ])
( 2, 8 ) = 1 ( 3, 10 ) = 6
( 2, 9 ) = 2 ( 4, 8 ) = 7
( 2, 10 ) = 3 ( 4, 9 ) = 8
( 3, 8 ) = 4 ( 4, 10 ) = 9
> e:=array([[un,deux],[trois,quatre],[cinq,six],[sept,huit]]);
 un deux 
 
trois quatre 

e :=  

 cinq six 
 
 sept huit 

> e[3,2]; # [ligne,colonne]
six

On peut préciser un modèle de tableau :


Symmetric, antisymmetric, sparse, diagonal, identity
> T1 :=array(sparse, 1..2,1..3, [(1,2)=x,(2,3)=y]) ;
0 x 0
T1 :=  
0 0 y 
> T2 :=array(identity, 1..3,1..3) ;
T2 := array ( identity , 1 .. 3, 1 .. 3, [ ] )

ENSA Khouribga 14 Professeur : SEHMAOUI


Initiation à Maple

> print(T2);
1 0 0
 
0 1 0

 
0 0 1

On affiche un tableau en utilisant soit la fonction print, soit la fonction eval


> print(T1);eval(T1);
Le contenu d’une case peut être modifié par l’affectation, en respectant les dimensions du
tableau.
> T1[1,1]:=8;eval(T1);
Une tableu étant donné:
op(T) Donne la structure, l’affichage est équivalent à celui de print(T) ou de eval(T)
op(op(T)) Donne la liste des éléments constituants
op(1, op(T)) Donne le mode de remplissage éventuellement aucun
op(2, op(T)) Donne les bornes des index
op(3, op(T)) Donne la liste des entrés affectées
indices(T) Donne les index des cases afféctées
entries(T) Donne les entrées effectives

IV—Compléments: Séquences, listes, ensembles tables:


4.1 Séquences, listes, ensembles:
Deux opérateurs permettent de définir une séquence : seq et $.

seq(f(i),i=m..n) retourne la séquence f(m), f(m+1),... , f(n)

> seq(i^2,i=1..7);
1, 4, 9, 16, 25, 36, 49
f(i)$i=m..n retourne la séquence f(m), f(m+1),... , f(n)
> i^2$i=1..8;
1, 4, 9, 16, 25, 36, 49, 64
$m..n est équivalent à $i=m..n
> $10..17;
10, 11, 12, 13, 14, 15, 16, 17
x$n duplique n fois l'objet x.
> `ENSA`$5;
ENSA, ENSA, ENSA, ENSA, ENSA

2. Le nombre d'éléments d'un ensemble ou d'une liste est donné par nops.
> a:=[un,deux,trois];b:={one,two,three,four};nops(a);nops(b);
a := [ un, deux , trois ]
b := { one , four , three , two }

ENSA Khouribga 15 Professeur : SEHMAOUI


Initiation à Maple

3
4

3. Le n-ième élément d'une liste ou d'un ensemble est donné par op(n,nom).
> op(2,a);op(1,b);
deux
one

4. op(nom_liste) et op(nom_ensemble) effectue la conversion d'une liste (resp. d'un ensemble) en


suite.
> op(a);op(b);
un, deux , trois
one , four , three , two

5. Convertir une liste en ensemble, ainsi que l'opération réciproque, est aisé.
> convert(a,set);convert(b,list);
{ deux , trois , un }
[ one , four , three , two ]

6. Convertir une séquence en liste ou en ensemble est immédiat.


> c:=aa,bb,cc,dd,ee;
[c];
{c};
c := aa, bb, cc , dd, ee
[ aa, bb, cc , dd, ee ]
{ bb, cc , dd, ee , aa }

4.2: Tables:
1. Les éléments d'une table peuvent être des fonctions.
> trigo[un]:=cos:trigo[deux]:=sin:trigo[trois]:=tan:
> trigo[un](Pi);trigo[deux](Pi);trigo[trois](Pi/4);
-1
0
1
2. Lorsque l'on écrit le nom d'une table, son contenu n'apparaît pas à l'écran,
> T[un]:=Toto:T[deux]:=Titi:
T;
T
Mais il existe trois possibilités pour qu'il sera affiché: print, eval et op.
> eval(T);print(T);op(T);
table([deux = Titi , un = Toto])
table([deux = Titi , un = Toto])
table([deux = Titi , un = Toto])

ENSA Khouribga 16 Professeur : SEHMAOUI


Initiation à Maple

3. Copions directement la table T dans la table U.


> U:=T:
> eval(U);
table([deux = Titi , un = Toto])
Si nous modifions U, T ne doit a priori pas être modifiée.
> U[deux]:=Tata:eval(U);eval(T);
table([deux = Tata, un = Toto])
table([deux = Tata, un = Toto])
En fait, les deux tables U et T représentent le même objet pour Maple. La preuve : elles ont la
même adresse.
> addressof(U);addressof(T);
6078188
6078188

V—Polynômes et fractions rationnelles


5.1 Les polynômes :
Pour obtenir un polynôme il suffit de l’écrire sous sa forme usuelle :
> P:=x^2-5*x+4;
P := x 2 − 5 x + 4
> Q:=x-1;
Q := x − 1
On peut tester si P divise Q par la fonction divide :
> divide(P,Q,x);
true
On peut avoir des polynômes de plusieurs variables :
> restart;P1:=x+y-x*y;
P1 := x + y − x y
Soit le polynôme p suivant
> A:=x^3-5*x^2+4;
A := x 3 − 5 x 2 + 4
> B:=x+2;
On peut écrire ce polynôme sous la forme A=B.Q+R
> quo(A,B,x);
x 2 − 7 x + 14
> rem(A,B,x);
-24
On peut aussi développer et factoriser les polynômes:
> G:=(x+4)*(5*x+10);
G := ( x + 4 ) ( 5 x + 10 )
> expand(G);
5 x 2 + 30 x + 40

ENSA Khouribga 17 Professeur : SEHMAOUI