Maple : Principe et fonctionnement -2- Rappel
Institut Préparatoire Aux Etudes d'Ingénieurs- El Manar Maple : TD & TP
1
Maple : Principe et fonctionnement -2-
Rappel
Maple : système de calcul numérique et symbolique
Session Maple : Espace mémoire conserve toutes les opérations effectuées dans une feuille
de calcul (restart)
Il faut toujours commencer un nouvel exercice par restart ;
Bloc d’instruction : comporte une ou plusieurs lignes de commande
Ligne de commande : comporte une ou plusieurs instructions
Instruction : expression (commande, fonction, …) terminée par ; ou :
Bloc de texte : comporte une ou plusieurs lignes de texte, non interprété donc non exécuté
Commentaire : texte non interprété donc non exécuté (#)
Maple : Sensible à la casse, c’est-à-dire, il sait faire la différence entre caractères
majuscules et minuscules
Différence entre fonction et commande en fonction de parenthèses et d’arguments
% : fonction spécialisée retourne le dernier résultat (3%), peut être utilisée pour nommer
un objet Maple (seulement au début)
Aide de Maple : ctrl + F1, Menu Help, ?commande,…
Opérateurs : + , - , * , / , ** , ^ , . , := , mod, and , or , ; , : , ! , factorial(5)
Lettres grecques : alpha, beta, gamma, phi, pi, Pi
Fonctions mathématiques : exp, min, max, abs, floor, sqrt, ln
Quitter la feuille de calcul : done, quit, stop
Enregistrer et restaurer une feuille de travail. (File/Save AS, File/Open)
Nombres Entiers
Nombre premier : Est un nombre entier positif qui n’a de diviseurs que 1 et lui-même.
1. Le nombre 97 est-il premier ?
2. Le nombre 259 est-il premier ?
3. Déterminer si les nombres suivants sont premiers : 13 ; 18 ; 23 ; 27 ; 43 ; 89 ; 101
; 197 ; 319 ; 405.
4. Déterminer si les nombres suivants sont premiers : 13 ; 18 ; 23 ; 27 ; 43 ; 89 ; 101
; 197 ; 319 ; 405.
5. Quel est le plus petit nombre non nul divisible par deux nombres premiers distincts ?
Institut Préparatoire Aux Etudes d'Ingénieurs- El Manar Maple : TD & TP
2
IGCD : Plus grand commun diviseur de deux ou plusieurs entiers
y est le IGCD de a et b si : y devise a et y devise b et n’existe pas un nombre y’ plus grand que y
qui vérifie les mêmes propriétés.
ILCM : Plus petit commun multiple de deux ou plusieurs entiers
X est le ILCM de a et b si : a devise x et b devise x et n’existe pas un nombre x’ plus petit que x
qui vérifie les mêmes propriétés.
Générer une valeur aléatoire :
Pour générer un entier de manière aléatoire avec la fonction rand : > rand();
Pour générer aléatoirement un entier entre min et max on utilise d’abord :
> nom := rand (min..max) ;
On obtient ensuite ce nombre par :
> nom ();
Si aucun paramètre n’est spécifié, Maple génère un entier de 12 chiffres positifs
Exemple :
1. Générer un nombre aléatoire
2. Vérifier si ce nombre est premier
3. Générer un nombre aléatoire situé entre le 12ème et le 15ème nombres premiers
4. Vérifier si ce nombre est premier
Nombres rationnels :
Maple propose une simplification de la fraction 300/45 mais ne donne pas une approximation sauf
si on lui demande.
Pour Maple, le nombre 300/45 n’est pas un nombre réel, c’est un nombre rationnel (une fraction
de deux nombres entiers).
Pour avoir une valeur approchée (nombre à virgule) du 300/45 on utilise le point décimal (.)
équivalent de notre virgule décimale (,), donc on écrit 300./45 ; ou bien la fonction evalf (eval to
float).
Syntaxe : evalf (expr) ;
Exemple : > evalf(300/45);
Pour les valeurs approchées, le nombre de chiffres significatifs par défaut égal à 10, y compris la
partie entière. Les nombres réels ainsi approchés sont appelés nombres flottants (float dans la
terminologie Maple).
On peut modifier la précision des nombres réels avec : evalf (expr, précision) ;
Institut Préparatoire Aux Etudes d'Ingénieurs- El Manar Maple : TD & TP
3
Digits :
Digits est une variable d’environnement qui donne le nombre de chiffres significatifs utilisés dans
les calculs faisant intervenir des nombres à virgule.
Par défaut, à la création d’une nouvelle session Maple, Digits = 10; mais on peut modifier sa
valeur, par exemple en passant la commande.
Digits := n ; n le nombre de chiffres significatifs lors de l’appel de evalf.
> Digits := 20;
Par exemple pour obtenir une approximation de sin(Pi) avec 20 chiffres significatifs on tape par
exemple :
> evalf (sin(Pi) ,20);
Ou
[> Digits := 20; evalf (sin (Pi/6));
Essayer :
> evalf (sin (Pi/6));
> evalf (exp (- Pi /2) ,30) ;
> Digits := 4;
> evalf (sin (Pi/6));
> evalf (exp (- Pi /2) ,30) ;
> restart; # ou Digits := 10;
> evalf (sin (Pi/6));
> evalf (exp (- Pi /2) ,30) ;
> evalf ((1+2)/ (3+4)) ;
Le mélange dans une expression de nombres sous forme de fraction et sous forme décimale
entraîne l’écriture du résultat sous forme décimale ;
> 1/2+0.25; 1/2+1/4; sqrt (0.25); sqrt (1/4); 1.024+Pi;
La commande evalf permet de passer d’une fraction à un nombre décimal, on peut aussi effectuer
l’opération inverse :
> evalf (5/2,2);
> convert (2.5, fraction);
On peut utiliser la notation suivante pour les nombres réels :
> 2.5E+6;
2.5
5
2
Institut Préparatoire Aux Etudes d'Ingénieurs- El Manar Maple : TD & TP
4
Fractions rationnelles
Voici un exemple de fraction rationnelle
> F := (3*x^4+4*x^2+2*x+1)/(x**3+2*x+1);
> denom(F);
> numer(F);
Calcul de sommes :
Maple permet de calculer des sommes à l’aide de la fonction sum. Ainsi pour somme une
expression u(i) pour i variant de a à b on écrit :
> sum(u(i),i=1..100);
Exemple :
> sum(i^2,i=1..100);
Maple permet aussi de calculer des sommes indéfinies, c’est-à-dire des sommes dont la borne
supérieure n’est pas fixée.
Exemple :
> sum(i^2,i=1..n);
Pour obtenir une forme inerte, on utilise la commande Sum avec un « S » en majuscule comme
suit :
Exemple :
> Sum(i^2,i=1..n)=sum(i^2,i=1..n);
Si une série diverge, Maple renvoie alors l’infini :
Exemple :
> Sum(i^2,i=1..infinity)=sum(i^2,i=1..infinity);
:= F 3x44x22x1
x32x1
x32x1
3x44x22x1
338350
1
3( )n131
2( )n121
6n1
6
i1
ni2
1
3( )n131
2( )n121
6n1
6
i1
i2
Institut Préparatoire Aux Etudes d'Ingénieurs- El Manar Maple : TD & TP
5
Calcul de produits :
Maple permet de calculer des produits à l’aide de la fonction product. Pour calculer le produit
des u(i) pour i variant de a à b :
> product(u(i),i=a..b);
> product(i^2,i=1..10);
Pour obtenir la forme inerte en entrant la fonction avec un « P » en majuscule :
> Product(i^2,i=1..10);
Nombres complexes :
Un nombre complexe est une expression : a+b*I
a et b : sont rationnels ou réels (dans ce dernier cas les calculs seront donc approchés),
Le symbole I : désigne le nombre complexe noté i dans le cours de Mathématiques. Ce symbole
est réservé comme Pi.
Notons que : i s’écrit en majuscule : I. Maple remplace directement I2 par −1
Exemple : > 3-7*I;
Si le nom z désigne un complexe, alors :
- Re(z) : désigne sa partie réelle,
- Im(z) : désigne sa partie imaginaire,
- conjugate(z) : désigne son conjugué,
- abs(z) : désigne son module, renvoie |z|
- argument(z) : désigne son argument (Attention, sous Maple, 0 est d’argument 0 !).
Exemple :
> z:3+4*I;
> z:= 3 + 4 I
> z*(1+sqrt(2)*I);
> Re(z); Im(z); conjugate(z); abs(z) ; argument(z)
i a
b( )u i
13168189440000
i1
10 i2
6
7
8
1
/
8
100%
