Une variable informatique est l'adresse , dans la mémoire de l'ordinateur , d'un emplacement

permettant de stocker un objet d'un type donné .

Exemples: AB, aB , X1, _var , x[a] sont des noms de variables MAPLE .

Si l'on affecte à une variable une valeur , la variable est dite assignée .

Si elle n'est associée à aucune valeur , la variable est dite non assignée .

La fonction restart permet de réinitialiser toutes les variables de la feuille de calcul.

> restart;

var est une variable assignée, dont la valeur est 3 :

> var:=3;

La variable a et la variable indicée sont non assignées :

> a,x[a];

Une autre manière d'affecter une valeur à une variable est d'utiliser la fonction assign :

> assign(nom,10-var);

> nom;

Pour désaffecter une variable assignée, lui affecter son nom écrit entre deux accents aigus :

> nom:='nom':nom;

On peut aussi utiliser la fonction evaln (évaluer en un nom) :

> var:=evaln(var):var;

true , false (valeurs booléennes vrai , faux) , I (complexe de carré -1) , Pi (nombre pi) ,

infinity (plus l'infini) sont des constantes MAPLE.

E (base des logarithmes népériens) n'est pas une constante MAPLE : faire exp(1).

> eval(exp(1))=evalf(exp(1));

Elles sont évaluées de la gauche vers la droite , avec la priorité usuelle des opérateurs.

Pour afficher une expression, utiliser les fonctions lprint ou print :

> print(1-2/a+(a+1)/(a-5));

Toute expression a un type que l'on peut obtenir grâce à la fonction whattype :

Parmi les types possibles figurent : + (somme) , * (produit) , ^ (puissance) , = (égalité) , <> (non

égalité) , < , <= (inégalité au sens strict ou large) , and , or , not (et,ou,non) , integer (nb entier) ,

fraction (nb rationnel) , float (nb réel en virgule flottante) , complex (nb complexe) , numeric

(numérique) , symbol (symbole), string (chaîne de caractères) , list (liste) , set (ensemble) ,
table (table) , array(tableau) , function (fonction) , name (nom) , .. (intervalle).

> whattype(a+b),whattype(a>b),whattype(-1.2245),whattype(a^7),whattype((a and b) or (c or d));

> whattype(x-2/y),whattype(a/b),whattype(`MAPLE`),whattype("MAPLE"),whattype({a,b});

On peut tester si une expression a un type donné en utilisant la fonction type :

> type(x,name),type(a+3*x-7/5,list);

Autres fonctions :

> expr:=x-3*y+5/(x+y);

nops(expression) donne le nombre d'opérandes de l'expression:

> nops(expr);

op(i,expression) donne le i-ème opérande de l'expression:

> op(2,expr);

op(i..j,expression) donne les opérandes de l'expression, du i-ème au j-ème:

> op(2..3,expr);

Transformation des expressions:

Regrouper certains termes selon une ou plusieurs variables avec collect(expression,v) ; v est une variable ou

une liste de variables :

> expr:=x^3*ln(x)+3*x^2+ln(x)*x-x:collect(expr,ln(x));

> expr:=x^2+5*x-25*y+48*(x-2*y+7)+y^3:collect(expr,[x,y]);

Transformer en un seul terme avec combine(expression,noms) :

Le paramètre noms est optionnel et à choisir par exemple parmi : exp , ln , trig , power .

> combine(2*Sum(i^2,i=1..n)+Sum(i^3,i=1..n));

> combine(exp(sin(a)*cos(b))/exp(cos(a)*sin(b)),[trig,exp]);

Simplifier une expression avec normal(expression) , simplifier une expression contenant des

radicaux avec radsimp(expression) :

> normal( 1/x+x/(x+1) );

> normal( 1/x+x/(x+1), expanded );

> radsimp((x-1)*sqrt(x*x-2*x+1)*(x+1));

Ordonner une expression avec sort(expression,v) ; v est une variable ou une liste de variables :

> sort(expr,y);

Ordonner selon un critère avec sort(liste,paramètre) ; liste est une liste de valeurs ,

paramètre = `<` ou `>` (ordre croissant, décroissant) , lexorder ou string (ordre lexicographique) .

> liste1:=[12,-2,5,1]:liste2:=[s,q,a,g,h,p,z,j,l,m,o,b,i]:

> sort(liste1,`>`),sort(liste2,lexorder);

Transformer une expression selon le modèle forme avec convert(expression,forme) :

> sin(2*x)=convert(sin(2*x),tan);

Faire des substitutions avec subs(eq1,eq2,...,eqn,expression):

> expr;
subs(x=lambda,y=2*t,expr);
expr;

On constate que expr n'a pas changé.

> subsop(1=w,2=-t,4=mu,expr);

L'opérande n°1 a été remplacé par w , l'opérande n°2 a été remplacé par et le n°4 par .

On peut également utiliser use ... in .. end use :

> use x=4*rho, y=h, z=mu in
(x+y-z+3)^7
end use;

Appliquer une fonction à tous les opérandes avec map(fonction,expression) ;

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

Isoler une expression dans une équation avec isolate(equation,expression) ;

> expr:=-x^3+2*(sqrt(y-sin(x))+1):isolate(expr,y);

Obtenir le membre gauche ou droit d'une égalité avec lhs(expression); ou rhs(expression);

> lhs(%);rhs(%%);

Pour définir une fonction , on peut utiliser les syntaxes :

nom := var -> expr; pour une fonction d'une variable var

nom := (var1,var2,...,varN) -> expr; pour une fonction de N variables var1,var2,...,varN .

> f:=x->exp(x)-x;

> f:=(x,y,z,t)->x^2-3*y+4*z-t;

La fonction unapply (expr,var1,var2,...,varN) permet de transformer l'expression expr en une

fonction des N variables var1,var2,...,varN:

> expr:=u^2-3*v+4*w : f:=unapply(expr,u,v,w);

Composition des fonctions: l'opérateur @ , l'opérateur de composition itérée @@

> f:=u->u^3:g:=t->2*t+1:
(f@g)(a);(g@f)(a);

f@@N correspond à f o f o . . . o f (N fois)

> (f@@3)(u);

> (D@@2)(f); # fonction dérivée seconde de f

On peut utiliser la fonction assume pour imposer une condition:
Exemple: on impose à r la condition ( r est alors affiché suivi d'une tilde: r ~ )

> assume(r,positive);r;
sign(r);

La fonction about permet d'obtenir une information sur une variable:

LES ENTIERS : ce sont des objets de typ e integer .

Un entier peut être positive (>0) , (<0), nonneg (>=0) , posint (entier>0) ,

negint (entier<0) , nonnegint (entier>=0) , even (pair) , odd (impair) , primeint (premier).

Ce que l'on peut tester avec type ou is .

> type(-15,negint), is(13,even);

On peut sélectionner des éléments répondant à une condition booléenne avec select(condition,v);
Exemple: sélectionner dans une liste de nombres ceux qui sont entiers >0

> select(x->type(x,posint),[-1/2,-7,Pi,3/4,0.25,18,2^5]);

Quelques fonctions utilisant les entiers:

> q:=iquo(89,-12);r:=irem(89,-12);

( quotient et reste de la division euclidienne de a par b : a =bq +r , avec |r|<|b| , ici

89 = (-12) (-7) + 5 )

54 est-il premier?

> isprime(54);

nombre premier suivant , nombre premier précédent:

> nextprime(215),prevprime(215);

Le 17 ème nombre premier:

> ithprime(17);

Décomposition en facteurs premiers:

> ifactor(117208);

Le ppcm et le pgcd de plusieurs entiers:

> ilcm(20,25,15);igcd(20,25,15);

Le plus petit ou le plus grand:

> min(712,56,100,25,125),max(712,56,100,25,125);

mod ( a modulo n donne le reste de la division de a par n , ici 31=4*7+3 ) :

> 31 mod 4;

rand(n) rend une fonction (appelée ici hasard) calculant un entier aléatoire entre .

> hasard:=rand(100):h:=hasard();

Fonction sign : cette fonction rend : -1 si , 1 si

> n:=-7;sign(n);

Fonction valeur absolue:

> abs(n);

LES RATIONNELS : ce sont des objets de type fraction (ou rational ) .

Un rationnel peut être positive (>0) , negative (<0) , nonneg (>=0) , ce qui peut être testé par

type ou is (comme pour les entiers).

Quelques fonctions utilisant les rationnels:

> q:=21*(144/124);numer(q);denom(q);

Comme pour les entiers , on a aussi les fonctions assume , min , max , sign , abs.

LES REELS : un réel de type float , a une mantisse et un exposant .

Exemple: 1234567=0.1234567*10^7 . La mantisse est 0.1234567 , et l'exposant 7 .

Le nombre s'écrit Float(0.1234567,7);

> evalf(Float(0.1234567,7));

> 1/9=1.0/9;

Digits est une variable d'environnement représentant le nombre de décimales affichées (10 par défaut).

> Digits:=30:evalf(exp(1));

Quelques fonctions utilisant les réels:

abs , sqrt (racine carrée) , exp , ln , log10 , log[a] (logarithme de base a) , sin , cos , tan , cot

(fonctions circulaires) , sinh , cosh , tanh , coth (fonctions hyperboliques) , arcsin ,arccos ,

arctan , arccot (fonctions circulaires réciproques) , arcsinh , arccosh , arctanh , arccoth

(fonctions hyperboliques réciproques).

La fonction partie entière : floor(x) est le plus grand entier inférieur ou égal à x.

> sqrt(1250);ln(exp(7));arctan(1);

> floor(-7.98);floor(7.98);

La fonction Gamma d'Euler :

> GAMMA(x)=Int(t^(x-1)*exp(-t),t=0..infinity);

LES COMPLEXES : de type complex , sont constitués de deux réels , la partie réelle et la partie

imaginaire .

> z:=1-5*I*sqrt(2):z,Re(z),Im(z);

evalc : fonction d'évaluation des nombres complexes

> z:=evalc((1+exp(1)^(I*Pi/6))/(1-I));

> Digits:=10:evalf(z);

> map(evalc,polar(a+I*b));

Quelques fonctions utilisant les complexes:

abs(z) , argument(z) , conjugate(z) : module , argument dans ]-Pi,Pi] , conjugué de z .

> z:=1+sqrt(3)*I:abs(z),argument(z),conjugate(z);

LE TYPE BOOLEAN :

Les booléens sont de type boolean et peuvent prendre 2 valeurs : false et true .

Si MAPLE ne parvient pas à résoudre un problème , il peut rendre le résultat FAIL .

Les opérateurs logiques sont : not (non) , or (ou) , and (et) , xor (ou exclusif) , implies (implication).

Une expression booléenne peut être évaluée par la fonction evalb :

> t:=10:
evalb(t*t>0),evalb(isprime(t) and t>0);

> evalb(evalf(exp(1))<evalf(Pi));

LES TYPES NOM (name), SYMBOLE (symbol), et INDEXÉ (indexed):

Une expression Maple est de type indexé, si elle définie à partir d'indices ou d'index. Elle est alors de

type indexed .
Exemple: est une variable indexée, contrairement à la variable

> type(a[x],`indexed`);

> type(nom_var,`indexed`);

Un nom, de type name , est une expression Maple définie à partir d'une lettre, suivie d'autres lettres
ou de chiffres, ou d'autres symboles, comme _ ,ou si elle est de type indexé.

Un nom peut aussi être formé en entourant une séquence de caractères par des accents graves ` `.

> type(a[x],`name`);

> type(nom_var,`name`);

> type(a/b,`name`);

> type(`12345`,`name`);

> type(12345,`name`);

Un symbole, de type symbol, est une expression Maple qui est un nom, mais n'est pas de type indexé.

> type(a[x],`symbol`);

> type(nom_var,`symbol`);

> type(a/b,`symbol`);

Quelques fonctions utilisant ces types:

length ( c ) retourne la longueur de c ( c étant un nom ou un symbole ) .

L'opérateur de concaténation || ou la fonction cat permettent de rassembler 2 noms ou symboles.

> length(nom_var);

> nom_var || a;

> cat(nom_var,a);

LE TYPE CHAÎNE DE CARACTÈRES (string):

Les chaînes de caractères, de type string , se notent entre guillemets " " :
par exemple , "MAPLE " et "7 pour Linux et Windows" sont 2 chaînes de caractères .

L'opérateur de concaténation || permet de rassembler 2 chaînes de caractères :

> ch:="MAPLE " || "7 pour Linux et Windows";

On peut aussi utiliser la fonction cat :

> ch:=cat("MAPLE ","7 pour Linux et Windows");

Quelques fonctions utilisant les chaînes de caractères:

length ( chaine ) retourne la longueur de la chaîne de caractères chaine .

substring ( chaine,a..b ) retourne la sous-chaîne constituée par les caractères de chaine situés entre

les positions a et b .

> length(ch);

> substring(ch,9..18);

Exercice corrigé 2:

Travail dirigé 2:

TD 2.1:

TD 2.2:

TD 2.3: