Cours Maple

5/6/2018 Cours Maple - slidepdf.com

http://slidepdf.com/reader/full/cours-maple 1/126

Découverte des premières fonctionnalités

Tous les ordres passés à l'ordinateur se font dans les zones précédées du signe > .

Ces zones sont des zones d'entrée ( input ).

Presser la touche Entrée pour transmettre l'ordre au logiciel.

Les lignes doivent impérativement se terminer par un point-virgule ; ou par deux points :

Noter la différence entre ces deux possibilités:

> 12+abs(4-3*sqrt(5));

Si la ligne se termine par un point-virgule, l'ordre est validé et le logiciel fournit uneréponsedans une zone de sortie ( output ) .

> 12+abs(4-3*sqrt(5)):

Si la ligne se termine par deux points, l'ordre est simplement validé sans réponse dulogiciel.

Des messages d'erreur peuvent apparaître en cas de mauvaise saisie ou d'opérationsillicites:

> 12+abs(4-3*sqrt(5);

Error, `;` unexpected

> 1/cos(Pi/2);

Error, numeric exception: division by zero

Obtenir de l'aide sur une fonction en utilisant ? ou help:



Ici on cherche de l'aide sur la fonction solve .

> ??solve;

> help(solve);

Voir aussi plus en détail pour les variantes ?? et ??? .

Faire des calculs simples:

> 15!; # ou factorial(15)

>

(1-1/7)*(1+2/3)^2;

Affecter une valeur à une variable en utilisant :=

> p:=2.14;

> expr:=p-ln(p);

Développer , factoriser , ou simplifier une expression:

> f:=(a+b)^6;

> expand(f);

> factor(%);

> %%;



% permet de rappeler la dernière expression calculée (% est le Ditto Operator )

%% permet de rappeler l'avant-dernière expression calculée.

%%% permet de rappeler l'avant-avant-dernière expression calculée.

> simplify(cos(x)^2+sin(x)^2);

Substituer en utilisant la fonction subs(variable=remplacement,expression)

> subs(a=c,f);

Calculer à une précision voulue: evalf(expression) ouevalf(expression,nbdécimales)

> evalf(sqrt(3)); # sqrt désigne la racine carrée

> evalf(sqrt(3),50);

# permet de définir un commentaire dans une ligne (tout ce qui est après le signe # estignoré)

Ecrire une expression avec print ou lprint ou printf

> f:=a-3/a+1/(a*a+1);



> print(f);

> lprint(f);

a-3/a+1/(a^2+1)

La fonction printf est celle du langage C, permettant l'affichage de données selon desformats préétablis et en utilisant des caractères de contrôle.

Exemple: %d : nombre entier, %f : nombre en virgule flottante simple précision, \n :passage à la ligne.Voir également les fonctions: fprintf , sprintf , et nprintf .

> printf("%d %f \n",123,1234/567);

123 2.176367

Définir une fonction à une ou plusieurs variables:

> f:=t->sin(t)-t;

> f(3*x+2);

> g:=(u,v,w)->1/u+exp(u+v)+(u-v+w)^2;

> g(2*a,b,3*c);



Dériver une fonction à une ou plusieurs variables en utilisant la fonction diff :

> diff(f(t),t);

> diff(g(u,v,w),v);

Intégrer une fonction à une variable en utilisant la fonction int:

> int(f(t),t); # donne une primitive de f

> Int(g(u,v,w),v)=int(g(u,v,w),v);

> Int(f(t),t=0..Pi)=int(f(t),t=0..Pi);

Noter la forme inerte Int qui affiche l'intégrale et la forme int qui calcule l'intégrale.

Calcul de limites, de sommes, de produits:

> limit((2*t-3)/(3*t+4),t=infinity);

> limit((2*t-3)/(3*t+4),t=-4/3,right); #limite à droite (left pour une limite àgauche)



> Sum(i^2,i=1..10)=sum(i^2,i=1..10);

> Product(1/i,i=1..10)=product(1/i,i=1..10);

Noter là aussi les formes inertes Sum et Product qui affichent respectivement lessymboles sigma et pi .

Résoudre une équation à une inconnue en utilisant la fonction solve:

> solve(2*t+3=-t+6*sqrt(2));

> solve(t-15/4*u=5/2*(u-t)+3,u);

Résoudre un système d'équations à plusieurs inconnues en utilisant la fonction solve:

> solve({a-b=2,a+3*b=7},{a,b});

Approcher les solutions d'une équation ou d'un système d'équations en utilisant lafonction fsolve:

> fsolve(cos(t)=t);

> fsolve({t^3+u=1,u-(t-1)^3=t},{t,u});



Représenter une fonction à une ou plusieurs variables en utilisant la fonction plot ouplot3d:

> plot(sin(t)/t,t=-20..20,title="fonction t ---> sin t / t");

> plot3d(x*exp(-x^2-y^2),x=-2..2,y=-2..2,color=x,orientation=[120,75]);

Exercice corrigé 1:

1. Définir la fonction f : .

2. Calculer les 3 premières dérivées de f , en les donnant sous forme factorisée .

3. Calculer la valeur numérique de l'intégrale de f sur .

4. Représenter dans un même repère f et la fonction sur .

5. Les deux courbes ont un point commun : calculer une valeur approchée de sonabscisse .



> f:=x->2*exp(-x^2)-x/2;

> diff(f(x),x);

> factor(diff(%,x));

> factor(diff(%,x));

> evalf(int(f(x),x=-1..2));

> plot({f(x),x},x=-1..2);

> fsolve(f(x)=x);



Travail dirigé 1:

TD 1.1:

1° Définir la fonction f qui à x associe .

2° Calculer les 3 premiers nombres dérivés successifs de f au point x

(on les écrira sous forme factorisée)

3° On pose pour : . Calculer (on les écrira sousforme simplifiée)

4° Calculer les racines des polynômes .

5° Représenter dans un même repère pour x compris entre et 2.

6° Calculer l'intégrale de sur .

TD 1.2:

1° Développer en fonction de .

2° Déterminer les polynômes de la variable X tels que



lorsque (polynômes de Tchébychev ) .

3° Représenter sur .

4° Calculer les racines de .



Éléments de base

LES VARIABLES:

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

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 accentsaigus :

> nom:='nom':nom;



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

> var:=evaln(var):var;

LES CONSTANTES:

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));

LES EXPRESSIONS:

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 :

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

1-2/a+(a+1)/(a-5)

> 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 decaractè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 expressioncontenant 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 devariables :

> 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 (ordrelexicographique) .

> 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)^7end 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); ourhs(expression);

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

LES FONCTIONS:

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 expren 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

LES TYPES DE BASE:

LES TYPES NUMÉRIQUES:

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:

> about(r);

Originally r, renamed r~:

is assumed to be: RealRange(Open(0),infinity)

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 êtretesté 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));

L'utilisation du point . déclenche l'affichage en calcul flottant dans le second membre:

> 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é dez .

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



AUTRES TYPES:

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. Elleest alors de

type indexed .

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

> type(a[x],ìndexed`);

> type(nom_var,ìndexed`);



Un nom, de type name , est une expression Maple définie à partir d'une lettre, suivied'autres lettresou 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 accentsgraves ` `.

> 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 pasde 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 nomsou 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);

caractère: x.

> x:=3: x+1,`x`+1,'x'+1;"x";


Ecrire une fonction F qui à n entier naturel non nul , associe le produit des n premiersnombres

premiers.

> F:=n->product(ithprime(k),k=1..n);

> F(5);

En effet, F(5) = 2.3.5.7.11 = 2310.

Travail dirigé 2:



TD 2.1:

Ecrire une fonction F qui à n entier naturel non nul , associe la somme des n premiersentiers

naturels non nuls.

TD 2.2:

Soit l'expression expr définie par :

1° De quel type est cette expression ?

2° Développer expr .

3° Ordonner expr suivant les puissances décroissantes de x .

4° Substituer dans expr : x+1 à x , y-2 à y , z² à z .

TD 2.3:

1° Définir la fonction P qui à x associe :

2° Factoriser et calculer ses racines x .

3° Développer et regrouper ses termes suivant les puissances décroissantes de a .



4° On prend désormais :

a) représenter graphiquement P pour x entre et 1.

b) calculer l'image de par P .

5° Calculer l'intégrale de P entre -1 et 1.

Programmation



Remarque importante: pour pouvoir entrer plusieurs lignes d'instructions Maplesuccessives,sans exécution à la fin de chaque ligne, presser Shift+Entrée à la fin de chaque ligne.

Puis, pour valider l'ensemble des lignes ainsi écrites, presser Entrée en plaçant lecurseur parexemple sur la dernière ligne écrite.

LES STRUCTURES DE CONTRÔLE:

Structure de contrôle if .. then:

if condition1 then instruction 1

elif condition2 then instruction2 elif et else sont optionnels)

elif condition3 then instruction3 ...

else instructionN

end if;

Effectue un test selon certaines conditions:

elif signifie "autrement si" . La dernière instruction à exécuter doit être précédée de else .

Exemple 1: résolution de l'équation du premier degré .Modifiez les valeurs de a et de b , puis validez les lignes suivantes:

> a:=7:b:=3:

> if a<>0 then print(Ùne solution : x `=-b/a)elif b=0 then print(`Tout x est solution`)else print(`Pas de solution`)

end if;



Structure de contrôle while .. do:

while condition do ... end do;Exécute une suite d'instructions, tant que la condition est vraie.

Exemple 2: calcul de la somme des 100 premiers entiers naturels

> somme:=0:k:=-1:while k<100 do k:=k+1:somme:=somme+k end do:`somme `=somme;

Structure de contrôle for .. to:

for variable from initiale to finale by pas do ... end do;

Exécute une boucle pour une variable allant d'une valeur initiale à une valeur finale,

avec un pas donné.

from , by peuvent être omises ou écrites dans un ordre quelconque.

Si l'on omet from , initiale vaut 1. Si l'on omet by , pas vaut 1.

Exemple 3: calcul de la somme des 100 premiers entiers naturels

> somme:=0:for k from 0 to 100 do somme:=somme+k end do:`somme `=somme;

Exemple 4: calcul de la somme des entiers impairs inférieurs à 100Ici, on omet from donc la première valeur de k est 1. La dernière valeur prise par k sera99.

> somme:=0:for k to 100 by 2 do somme:=somme+k end do:

`somme `=somme;



for variable in expression do .. end do;

Exemple 5: donner les nombres premiers de la liste [31,39,47,105]

> for k in [31,39,47,105] doif isprime(k) then print(k,èst premier`) end if

end do;

LES PROCÉDURES:

Un programme MAPLE peut être organisé en sous-programmes appelées procédures .Une procédure, de type procedure , est définie par le mot-clé proc et peut être assignéeàun nom de variable. Pour définir une procédure intitulée nom , on utilisera la syntaxesuivante:

nom := proc (paramètres_formels)

global variables_globales; (la ligne global est optionnelle)

local variables_locales; (la ligne local est optionnelle)

description chaîne_de_description; (la ligne description est optionnelle)

option nom_option; (la ligne option est optionnelle)

. . . instructions . . . (corps de la procédure)

end proc;

Exemple 6:

La procédure intitulée maxi calcule le plus grand de 2 entiers positifs.Elle comporte 2 paramètres formels u et v . Leur type peut être omis, mais si on le veutle préciser,



bien noter la syntaxe u :: posint , v :: posint pour signifier que u et v sont de type posint .Elle ne comporte ni variables globales, ni variables locales, mais une chaîne dedescription

de la procédure et une option de copyright.

> maxi:=proc(u::posint,v::posint)description "calcule le plus grand de 2 entiers positifs";option `Copyright (c) 2001 A.Le Stang`;if u<v then v else u end if;

end proc;

> maxi(5,9);maxi(1.2,Pi);

Error, invalid input: maxi expects its 1st argument, u, to be of type posint, but received1.2

Une variable locale est une variable qui n'est reconnue qu'à l'intérieur de la procédure,

contrairement à une variable globale accessible en dehors de la procédure.

Exemple 7:

> messages:=proc()global message1;local message2;

message1:="Hello, world!";message2:="How are you?";

end proc;

> messages();

La valeur de la variable locale message2 n'a pas été reconnue, contrairement à celle delavariable globale message1 .

Remarque importante:

Un paramètre formel passé à une procédure ne peut être modifié à l'intérieur de cetteprocédure



Exemple 8: Diviser un entier positif x par 2 tant qu'il est pair.

> div:=proc(x::posint)while type(x,even) do x:=x/2 end do;

end proc;

> div(48);

Error, (in div) illegal use of a formal parameter

La tentative d'affecter au paramètre formel x sa valeur divisée par 2 provoque uneerreur.On peut modifier la procédure de la manière suivante:

> div:=proc(x::posint)local y;

y:=x;while type(y,even) do y:=y/2 end do;y

end proc;

> div(48);

On obtient en effet successivement : 48,24,12,6,3.

> div(45);

return met fin à la procédure en donnant un résultat.next permet de passer à la valeur suivante dans une itération.break permet de sortir de la structure de contr ô le en cours.

Exemple 9: On parcourt une liste de nombres. Au premier entier positif trouvé, on sortde la procédureavec pour résultat cet entier, sinon si ce nombre est négatif, on sort de la boucle avecpour résultat -1,

sinon on passe au nombre suivant.



> liste:=proc(L::list(numeric))local k;

for k in L doprint(`lecture de`,k);if type(k,nonnegint) then return k

elif k<0 then break;

else next;end if end do;return -1;

end proc;

> liste([12.56,8.9,7,3.14]);

> liste([12.56,-8.9,7,3.14]);

> liste([12.56,8.9,7.1,3.14]);



Récursivité:

Une procédure qui fait référence à elle même dans sa définition est une procédurerécursive .

Exemple 10: factorielle de n

> factorielle := proc(n::nonnegint)if n>0 then n*factorielle(n-1) else 1 end if;

end proc;

> factorielle(12);

Fonction error : La fonction error permet de définir des messages d'erreur personnalisés.

Exemple 11: racine carrée de x

> racine := proc (x)if x<0 then error "invalide x: %1", x else simplify(x^(1/2)) end if

end proc;

> racine(144);

> racine(-144);

Error, (in racine) invalide x: -144

LES MODULES:

Un module est une collection de procédures et de données.

Un module, de type module , est défini par le mot-clé module et peut être assigné à unnom de variable. Pour définir un module intitulé nom , on utilisera la syntaxe suivante:

nom := module ()



global variables_globales; (la ligne global est optionnelle)

local variables_locales; (la ligne local est optionnelle)

export variables_locales_exportées; (la ligne export est optionnelle)

description chaîne_de_description; (la ligne description est optionnelle)

option nom_option; (la ligne option est optionnelle)

. . . instructions . . . (corps du module)

end module;

Contrairement au cas des procédures, le module ne peut avoir de paramètres formels .On retrouve les notions de variables globales et locales, comme pour les procédures,

mais les modules peuvent exporter des variables locales (celles de la ligne export ),

auxquelles on a accès de l'extérieur du module en utilisant la syntaxe suivante:nom :- var permet d'accéder à la variable locale exportée var du module nom .

En utilisant la terminologie de la programmation orientée objet, les variables déclarées

dans la ligne local s'apparentent à des membres privés du module, tandis que cellesdéclarées dans la ligne export s'apparentent à des membres publics du module.

Exemple 12: Anneau Z/4Z des entiers modulo 4.

> Z4:=module()description "Arithmétique modulo 4";export add,mult,opp;

add := (x,y)-> (x+y) mod 4;mult := (x,y)-> (x*y) mod 4;opp := x-> (-x) mod 4;

end module;

Le module comporte 3 variables locales exportées add , mult , opp .Vérifions que: (2+3) mod 4 = 1 , que (2*3) mod 4 = 2 et opp (1) = -1 mod 4 = 3 :

> Z4:-add(2,3);

> Z4:-mult(2,3);

> Z4:-opp(1);



Exemple 13: Anneau Z/ n Z des entiers modulo n .On désire modifier le programme précédent pour effectuer de l'arithmétique modulo n ,

avec entier quelconque.Un module n'acceptant pas de paramètre formel, écrivons une procédure Construire_Zn

de paramètre formel n , rendant pour résultat un module:

> Construire_Zn:=proc(n::posint)module()

description "Arithmétique modulo n";export add,mult,opp;

add := (x,y)-> (x+y) mod n;mult := (x,y)-> (x*y) mod n;opp := x-> (-x) mod n;

end module;end proc;

> Z7:=Construire_Zn(7);

> Z7:-add(6,5);

> Z7:-mult(5,3);

> Z7:-opp(3);



On peut utiliser la structure de contrôle use pour accéder aux variables locales exportéesdu module nom sans avoir recoursà l'utilisation de :-Exemple: (opp(3) mod 7) = (4 mod 7) = 4 ( (opp(3) mod 7)*5 ) mod 7 = (4*5) mod 7= 6

(2 + ( (opp(3) mod 7)*5 ) mod 7 ) = (2+6) mod 7 = 1

> use Z7 inadd( 2, mult( opp(3), 5) )

end use;

La fonction member permet de savoir si une expression est membre d'un module:

> member(mult,Z7) , member(prod,Z7);

Le constructeur Record: Le constructeur Record crée un enregistrement Maple. Un enregistrement, de type

record , estdéfini par les noms de ses champs (appelés "slots" ou "fields" en anglais).

Exemple 14: On veut créer un enregistrement pour modéliser les nombres complexes.Un nombre complexe z est défini par 2 champs: sa partie réelle et sa partie imaginaire.

> z := Record( 're', 'im' );

On voit qu'un enregistrement est un module particulier, qui a l'option record .

On définit un nouveau type complexe associé et la fonction module d'un nombrecomplexe:

> `type/complexe` := 'record( re, im )':Mon_module:=(z::complexe)->sqrt(z:-re^2+z:-im^2);

> z:-re:=1 : z:-im:=2 :Mon_module(z);



On peut aussi initialiser les valeurs des parties réelle et imaginaire de la façon suivante:

> z:= Record( 're' = 1, 'im' = 2 ):Mon_module(z);

LES LIBRAIRIES ET PACKAGES:

Pour obtenir le listing de certaines fonctions des librairies MAPLE, comme ici la fonctionithprime

utiliser:

> interface(verboseproc=2);print(ithprime);

Les packages regroupent des fonctions utiles dans des domaines particuliers.

La fonction suivante appelle la page d'aide donnant les packages existants :

> ?index,package

La fonction with permet de charger toute ou partie d'un package choisi:

> with(student);#charge toutes les fonctions du package student

Chargement de la fonction binomial du package combinat :



> with(combinat,binomial);

Cette fonction retourne le nombre binomial( ) = appelé aussi C().


Ex 3.1 Ecrire une procédure calculant le plus grand de 3 entiers naturels non nuls a , b , c .

> max3:=proc(a::posint,b::posint,c::posint)local max2;

max2:=proc(x::posint,y::posint)if x>y then x else y end if;

end proc;max2(a,max2(b,c));

end proc;

> max3(5!,5^3,123);

max3 comporte une variable locale max2 à laquelle est affectée une procédure calculantleplus grand de 2 entiers naturels non nuls.

Ex 3.2

1° Écrire un module pnt permettant de modéliser un point du plan, défini par ses

coordonnées x , y . Ce module comportera des variables locales exportées rendant comme résultat



l'abscisseet l'ordonnée du point.

2° Écrire un module cercle permettant de modéliser un cercle du plan, défini par soncentre etson rayon. Ce module comportera des variables locales exportées rendant commerésultat lecentre, le rayon, le diamètre, l'aire, et la circonférence du cercle.

1° Définition de la procédure pnt rendant pour résultat un module:

> pnt:=proc(x,y)module()

export abscisse,ordonnee;

abscisse:=()->x;ordonnee:=()->y;end module

end proc;

Définition d'un point A de coordonnées ( a , b ) :

> A:=pnt(a,b);

> A:-abscisse(), A:-ordonnee();

2° Définition de la procédure cercle rendant pour résultat un module:

> cercle:=proc(c,r)module()

export centre,rayon,diametre,aire,circonference;centre:=()->c;rayon:=()->r;diametre:=()->2*rayon();aire:=()->Pi*r^2;circonference:=()->Pi*diametre();

end moduleend proc;



Définition d'un cercle C de centre A de rayon R :

> C:=cercle(A,R);

> C:-centre(), C:-rayon(), C:-diametre(), C:-aire(), C:-circonference();

Utilisation des deux structures pour obtenir les coordonnées du centre de C :

> C:-centre():-abscisse(), C:-centre():-ordonnee();

Travail dirigé 3:

TD 3.1: Écrire une procédure second_degré(a,b,c) qui résout l'équation du second degré à

coefficients réels: en distinguant 3 cas selon le signe du discriminant.

TD 3.2:

Écrire une procédure somme(n) calculant récursivement la somme des entiers de 0 à n , pour



n entier naturel donné.

TD 3.3:

Écrire une procédure renverser(n) , qui , étant donné un entier naturel n necomportant pas de

0 dans son écriture décimale , rend pour résultat l'écriture renversée de cet entier .

Prévoir un message d'erreur si l'entier comporte le chiffre 0.

Exemple:

> renverser(122564);

> renverser(120325);

Error, (in renverser) le chiffre 0 n'est pas autorisé.

TD 3.4:

Écrire un module segment permettant de modéliser un segment du plan, défini par sesdeuxpoints extrémités.Ce module comportera des variables locales exportées rendant commerésultat la première et la seconde extrémité du segment, sa longueur, et son milieu.On pourra utiliser le module défini par la procédure pnt de l'exercice corrigé 3.2 .



Séquences, listes, ensembles,tables et tableaux

LES SÉQUENCES:

Une séquence , de type exprseq , est une suite d'éléments séparés par une virgule . Onaccè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;

Error, cannot assign to an expression sequence

NULL désigne la séquence vide:

> v:=NULL;

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

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

Pour concaténer 2 séquences ,utiliser l'opérateur virgule ,

> 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);

LES LISTES:

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]) etnops([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'uneliste:

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

LES ENSEMBLES:

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écessairementconservé 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;

Error, cannot assign to a set

op transforme un ensemble en séquence , nops donne le nombre d'éléments d'unensemble .

> 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;

QUELQUES OUTILS DU PACKAGE COMBINAT :

> 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 delongueur p de [1,2,..., n ]

> permute(3,2);

> restart;

LES TABLES:



Une table est une structure indexée dont les indices (ou index ) peuvent être den'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);

LES TABLEAUX: Un tableau est une structure indexée, de type array , de plusieurs dimensions, dont lesindices

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 bouclesimbriquées:

> T:=array(1..2,1..3):for i to 2 do

for j to 3 doT[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 ladimension 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);


Ex 4.1: Ecrire une procédure qui inverse les éléments d'une liste .

> 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]);

Ex 4.2: Créer une matrice de Vandermonde d'ordre n . Exemple , pour :

> 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);

Travail dirigé 4:

TD 4.1:

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

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èrediagonale.

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 secondediagonale.



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

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);

TD 4.2:

Ecrire la procédure intitulée coder(st::string) qui convertit la chaîne de caractères st

(é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 deconversion

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 lespositions m et n .



Polynômes et fractions rationnelles

POLYNÔMES:

> restart;

Un polynôme a le type polynom , et peut avoir plusieurs variables :

> P:=-7*x+5*x^2+75*x^3;Q:=x*(2*x-3*y)^2*(x-y);

> type(P,polynom),whattype(P),whattype(Q);

nops(P) donne le nombre de termes selon la forme , développée ou factorisée , de P :

> nops(P),nops(Q);

op(P) donne sous forme de séquence les termes ou les facteurs de P :

> op(P);op(Q);

Coefficients , degré , valuation:Les 2 syntaxes sont équivalentes:

> coeff(P,x^3);



> coeff(P,x,3);

Obtenir tous les coefficients de P (valable lorsque P est sous forme développée)

> coeffs(P);coeffs(Q);

Error, invalid arguments to coeffs

> coeffs(expand(Q));

Coefficient du terme de plus haut (de plus bas) degré:

> lcoeff(P),tcoeff(P);

> lcoeff(Q,y),tcoeff(Q,y);

Degré et valuation:

> degree(P),degree(Q,x),degree(Q,y);

> ldegree(P),ldegree(Q,x),ldegree(Q,y);

FONCTIONS SUR LES POLYNÔMES:

quo(P,Q,x,'r') : quotient de la division euclidienne de P par Q , variable x , 'r'(optionnel)

variable non assignée recevant le reste .

> quo(x^5-1,x^2+x+1,x, 'r');r;



rem(P,Q,x,'q') : reste de la division euclidienne de P par Q , variable x , 'q' (optionnel)

variable non assignée recevant le quotient .

> rem(x^5-1,x^2+x+1,x, 'q');q;

Discriminant:

> discrim(x^3+a*x+b,x);

Evaluer, ordonner, transformer un polynôme:

> subs(x=1+2*I,y=I,Q);

Ordonner Q selon les puissances décroissantes de y:

> sort(expand(Q),y);

Développer:

> expand((x-3*y+a)*(1-a^2+x+y));

Regrouper les monômes de l'expression en l'indéterminée a :

> collect((x-3*y+a)*(1-a^2+x+y),a);



Mettre P sous la forme de Hörner:

> P;H:=convert(P,horner);

> with(codegen,cost);

Ce qui est moins coûteux en opérations:

> cost(P),cost(H);

Factoriser sur le corps Q des rationnels

> factor(x^3+x^2+x+1);

Normaliser:

> normal((4*x-3)^2+x-1);

RACINES ET FACTORISATION DES POLYNÔMES:

Valeur approchées des zéros réels ou complexes avec fsolve :

> P:=x^3+x+1:fsolve(P);

> fsolve(P,x,complex);



Localiser les zéros réels dans un intervalle de longueur voulue , ici 10^-3 , avec realroot :

> realroot(P,0.001);

Calcul des zéros avec solve(P) :

> solve(x^4+1);

Par la fonction factor , on peut factoriser sur Q ou sur le corps induit par les coefficients:

> factor(x^4-1);

> factor(x^3-I*x-I+1);

Pour obtenir la factorisation complète:

factor (P,{ ,..., }) autorise Maple à factoriser P sur un corps contenant les

nombres algébriques ,...,

> factor(x^4-1,I);

> factor(x^3-x^2+2*x-2);

> factor(x^3-x^2+2*x-2,{I,sqrt(2)});



On peut aussi utiliser Split , qui donne une factorisation complète :

> with(PolynomialTools,Split):P:=Split(x^4-1,x);

RootOf désigne ici toute racine du polynôme _Z²+1, on peut simplifier l'écriture en

utilisant alias :

> alias(alpha=RootOf(_Z^2+1)):P;

Pour calculer les valeurs possibles de alpha :

> allvalues(RootOf(_Z^2+1));

La fonction roots donne les zéros avec leur ordre de multiplicité:

n'a aucun zéro sur Q:

> roots(x^2+1);

On calcule ses zéros sur le corps Q(I) induit par les coefficients:

>

roots(x^2+1,I);

FRACTIONS RATIONNELLES : de type ratpoly

> F:=(2*x^2+x-3)^2/(x^4-1);numer(F),denom(F);



> simplify(F);

Factorisation sur IR ou C:

factorisation sur IR:

> factor(F);

factorisation sur C:

> factor(F,I);

retour à la forme normale:

> normal(%,expanded);

Décomposition en éléments simples sur IR ou C:



convert(F,parfrac, x ) décompose en éléments simples la fraction rationnelle F enl'indéterminée x .

convert(F,parfrac, x, { ,..., } ) autorise Maple à décomposer sur un

corps contenant les nombres algébriques ,...,

Décomposition sur IR:

> convert(F,parfrac,x);

Décomposition sur C:

> convert(F,parfrac,x,I);


Ex 5.1: Décomposer en éléments simples sur

> F:=1/(x^4+1);

> convert(F,parfrac,x);



F n'est pas décomposée. Voyons les racines du dénominateur:

> {solve(denom(F))};

On obtient la décomposition sur IR par:

> convert(F,parfrac,x,sqrt(2));

On obtient la décomposition sur C par:

> convert(F,parfrac,x,{I,sqrt(2)});

Ex 5.2: Soit .

Montrer que les zéros du polynôme dérivé P' sont 3 termes consécutifs d'une suitearithmétique.

> P:=X*(X-1)*(X-2)*(X-3):dP:=diff(expand(P),X);

> zeros:=[solve(dP)];



On trie les éléments de la liste par ordre croissant , sort ne fonctionnant pas ici :

> tri:=proc(L::list)local x,y,Z;

Z:=L;for x to nops(Z)-1 do

for y from x+1 to nops(Z) doif evalf(Z[y]-Z[x])<0 then Z:=subsop(x=Z[y],y=Z[x],Z) end if;

end do;end do;Z;

end proc:

> zeros:=tri(zeros);

On calcule les écarts entre 2 termes consécutifs , la raison est :

> for k to nops(zeros)-1 do print(zeros[k+1]-zeros[k]) end do;

Travail dirigé 5:

TD 5.1:

Soit la fraction rationnelle F définie par :

1° La décomposition de F en éléments simples dans R s'écrit:



On réduit les fractions composant G au même dénominateur et on identifie les

numérateurs de F et de G . En déduire les valeurs de a,b,c,d,e,f,g .

2° Calculer la décomposition de F en éléments simples dans C

TD 5.2:

Soit P un polynôme de K[ x ] , s'écrivant sous la forme :

L'algorithme de Hörner permet d'écrire P( x ) sous la forme :

Exemple:

Ecrire une procédure PolyHorner(P , x ) permettant d'écrire P( x ) sous cette forme ,

P étant un polynôme donné de K[ x ] , x étant le nom de la variable .

NB: il est interdit d'utiliser la fonction horner de MAPLE .



Grace à la fonction cost , évaluer le coût en opérations nécessaires pour évaluer Q etPolyHorner(Q, x ) , Q étant le polynôme donné en exemple.



Graphisme avec Maple

GRAPHIQUES EN DIMENSION 2:

La fonction smartplot constitue la façon la plus simple de représenter une ou plusieursfonctions : Par défaut , le range est -10..10.

> smartplot(cos(2*x)+sin(x),x);

Pour représenter une ou plusieurs fonctions, utiliser plot(f , h , v) ou plot(f, h, v,...) où

f : fonction(s) représentée(s) , h et v : intervalle horizontal et vertical (optionnels).

La syntaxe la plus simple est plot(f) ou plot(f(x),x=a..b) :

> f:=x->cos(2*x)+sin(x):plot(f(x),x=-2*Pi..2*Pi);

Les arguments restants sont des options que l'on peut spécifier par des équations de laforme option = valeur.



scaling = CONSTRAINED (repère orthonormal) ou UNCONSTRAINED (repère non

orthonormal) .Par défaut : UNCONSTRAINED.

axes = Spécifie le type d'axes : FRAMED , BOXED, NORMAL , et NONE.

coords = polar Indique une courbe paramétrique en coordonnées polaires.

numpoints = n Spécifie le nombre minimum de points à être générés (défaut n = 49 ).

resolution = n Spécifie la résolution horizontale en pixels (défaut n = 200 ).

color = n Spécifie la couleur des courbes à tracer .

xtickmarks = n ytickmarks = n Spécifie le nombre de graduations sur l'axe des x oudes y .

style = s Spécifie le style du tracé : par défaut LINE

POINT (tracé point par point) , LINE (points reliés par des segments)

PATCH (style pour les polygones) , SPLINE (points reliés par une courbe spline)

discont = s Mettre s à la valeur booléenne true pour des fonctions discontinues

title = t Spécifie le titre pour le graphique ( t de type string ).

thickness = n Spécifie l'épaisseur du trait , ( n = 0, 1, 2 , ou 3 , défaut : 0 ).

linestyle = n Spécifie le motif des lignes tracées (lignes pleines : 0 et 1, d'autres valeursplus grandes donnent des pointillés par exemple).



symbol = s Spécifie le symbole de représentation d'un point : BOX, CROSS,CIRCLEPOINT, et DIAMOND.

font = liste Polices des caractères affichés . liste est une liste [famille, style, taille] ,

famille : TIMES, COURIER, HELVETICA, SYMBOL.

Pour TIMES, le style est ROMAN, BOLD, ITALIC ou BOLDITALIC.

Pour HELVETICA et COURIER style omis ou BOLD, OBLIQUE, ou

BOLDOBLIQUE. Pour SYMBOL , pas de style .

titlefont = liste , axesfont = liste , labelfont = l iste Polices des caractères affichéspour le titre,les graduations des axes,les légendes des axes (pour liste , voir font = liste).

view =[xmin .. xmax,ymin .. ymax] Spécifie la zone de dessin à représenter à l'écran .

Représenter un ensemble de plusieurs courbes:

> plot({sin(x),x, x-x^3/6}, x=-2..2,thickness=2,scaling=CONSTRAINED);

Intervalle à borne infinie:

> plot(sin(x)/x, x=0..infinity);

Représenter des points: on donne la liste des coordonnées, abscisse puis ordonnée.



> plot([[0,0],[1,1],[2,1],[2,0],[1,-1],[0,0]], x=0..2, style=point);

Représenter des lignes brisées: même principe que pour les points, en enlevant style=point .

> plot([[0,0],[1,1],[2,1],[2,0],[1,-1],[0,0]], x=0..2);

Courbe en coordonnées polaires: plot([r(t),theta(t),t=a..b],coords=polar,...)

> plot([sin(4*t),t,t=-2*Pi..2*Pi],coords=polar,thickness=2,font=[HELVETICA,BOLD,8],title="R=sin4t",color=red);

On obtient le même résultat en utilisant la fonction polarplot du package plots :

> with(plots):polarplot([sin(4*t),t,t=-2*Pi..2*Pi],thickness=2,font=[HELVETICA,BOLD,8],title="R=sin 4t",color=red);

Courbe paramétrée: plot([x(t),y(t),t=a..b],...)

> plot([cos(2*t)+2*cos(t),sin(2*t),t=0..2*Pi],color=blue);



OUTILS 2D DU PACKAGE plots:

Le package plots fournit d'autres outils graphiques pour la dimension 2 :

> with(plots);

Citons , entre autres :

La fonction animate , qui permet de créer des animations dans une fenêtre dont la barre

d'outils

comporte des touches identiques à celles d'un lecteur de cassettes :

Exemple: famille de paraboles dépendant de m

> animate(m*x^2,x=-3..3,m=-10..10);

Tracer des courbes définies implicitement sous la forme f(x,y)=0 avec implicitplot

> implicitplot(x^3+x-y^2+1=0,x=-10..10,y=-10..10);



Visualiser un champ de vecteurs avec fieldplot , ( arrows = LINE,SLIM,THIN ou THICK)

> fieldplot([x*x-y*y,2*x+y^3],x=-1..1,y=-1..1,arrows=SLIM);

gradplot permet de visualiser un champ de gradients .

logplot , loglogplot donnent une graduation logarithmique sur l'axe des y ou les 2 axes

odeplot permet de tracer les courbes intégrales d'une équation différentielle.

textplot permet d'écrire sur un dessin .

densityplot et contourplot permettent de tracer respectivement des graphes dedensité ou

des courbes de niveau.

display permet de représenter plusieurs objets graphiques de nature éventuellementdifférentes



sur un même graphique. L'option insequence=true permet de le transformer enanimation.

Exemple: tracé du cercle c de centre O de rayon 1, de la droite d: , de l'ellipse e

d'équation ,dans un même repère orthonormal.

> c:=plot([cos(t),sin(t),t=0..2*Pi],color=blue):d:=plot(x,x=-2..2,color=black):e:=implicitplot(x^2/4+y^2-1,x=-2..2,y=-1..1):display({c,d,e});

GRAPHIQUES EN DIMENSION 3:

La fonction smartplot3d constitue la façon la plus simple de représenter une ouplusieurs surfaces : Par défaut, le range est [-5..5,-5..5].

> smartplot3d(exp(-(x^2+y^2)));

plot3d(f(x,y),x=a..b,y=c..d,...) ou plot3d(f,a..b,c..d,...) permettent de tracer unesurface.

> f:=(x,y)->exp(-(x^2+y^2)):plot3d(f,-1..1,-1..1,axes=BOXED,orientation=[-45,60],numpoints =1000,color=blue);



Comme pour la dimension 2 , on retrouve les options axes , scaling , tickmarks , title , view ,

numpoints (par défaut 625) et :

labels = [`x`,`y`,`z`]

orientation = [theta,phi] précise les angles de vision en coordonnées sphériques .

projection = r , avec r réel de [0,1] . FISHEYE=0 , NORMAL=0.5 , ORTHOGONAL=1.

grid = [m,n] détermine la grille rectangulaire m x n (par défaut 25 x 25)

style = s ( où s parmi POINT,HIDDEN,PATCH,WIREFRAME,CONTOUR,

PATCHNOGRID,PATCHNOCONTOUR,LINE . Par défaut : HIDDEN )

ambientlight = [r,v,b] fixe l'intensité des couleurs rouge,vert,bleu (valeurs dans [0,1]).

colour = c fixe la couleur à c .

light = [phi,theta,r,v,b] fixe l'éclairage de la surface selon les angles phi,theta encoordonnées

sphériques avec les couleurs r,v,b .

shading = s ( où s parmi XYZ,XY,Z,ZGREYSCALE,ZHUE,NONE ) pour préciser la façon



dont la surface est coloriée .

coords = c ( ou c parmi cartesian,spherical,cylindrical )

Les surfaces peuvent être paramétrées :

>

plot3d([(4+sin(t))*cos(u),(4+sin(t))*sin(u),2*sin(t)],t=0..2*Pi,u=0..2*Pi,axes=framed,shading=ZHUE,ambientlight =[0.85,0.75,0.1]);

> plot3d(z,theta=0..2*Pi,z=0..2,coords=cylindrical,title="Un cône");

>

plot3d(5,theta=0..2*Pi,phi=0..Pi,axes=BOXED,coords=spherical,scaling=constrained,color=blue,title="Une sphère");

OUTILS 3D DU PACKAGE plots:



Le package plots fournit d'autres outils graphiques pour la dimension 3 :

> with(plots);

Warning, the name changecoords has been redefined

Citons entre autres :

animate3d , pour créer des animations graphiques .

fieldplot3d , gradplot3d pour visualiser un champ de vecteurs ou de gradients .

display3d permet de représenter plusieurs objets graphiques de nature éventuellementdifférentes

sur un même graphique. L'option insequence=true permet de le transformer en

animation.

polyhedraplot pour représenter des polyèdres : polyscale = n (taille du polyèdre)

polytype parmi tetrahedron,octahedron,hexahedron,dodecahedron,icosahedron.

> polyhedraplot([0,0,0],polyscale=10,polytype

= icosahedron,scaling=CONSTRAINED,axes=BOXED,title="Icosaèdre");



Tracé de surfaces implicites ou de courbes gauches:

> implicitplot3d(x^2+y^2/4+z^2/4-1=0,x=-1..1,y=-2..2,z=-2..2,title="ellipsoide",color=red);

> spacecurve([cos(t),sin(t),t],t=-4*Pi..4*Pi,numpoints=500,axes=FRAMED,title="Courbe gauche : unehélice",color=black);


Soit S la surface d'équation cartésienne (hyperboloide de révolution àune nappe)



1° Représenter S à partir de son équation implicite , pour z variant entre -1 et 1.

2° Définir S à partir d'une représentation paramétrique et représenter alors S .

> with(plots):implicitplot3d(x^2+y^2-z^2-1,x=-sqrt(2)..sqrt(2),y=-sqrt(2)..sqrt(2),z=-1..1,color=blue);

> S:=[cosh(phi)*cos(theta),cosh(phi)*sin(theta),sin(phi)]:plot3d(S,phi=-arcsinh(1)..arcsinh(1),theta=0..2*Pi,color=blue);

Travail dirigé 6:

TD 6.1:

Écrire une procédure polygone_regulier ( n:: posint) permettant de représenter unpolygône

régulier à n côtés, de centre (0,0) et de rayon 1:

> polygone_regulier(8);



TD 6.2:

1° Paramétrer en coordonnées sphériques une sphère de centre (x,y,z) de rayon R encréant

une fonction sphere des 4 variables x,y,z,R .

2° Représenter sur un même graphique les sphères de centres respectifs(3,0,0) ,

(0,3,0) et (0,0,0) et de rayons respectifs 2,2,1.



Maple en analyse

FONCTIONS NUMÉRIQUES:

Domaine de définition: la fonction singular permet de déterminer les singularités decertaines fonctions:

> restart;singular(tan(x));

Continuité: la fonction iscont permet de déterminer la continuité de certaines fonctions.

closed signifie que l'intervalle est fermé.MAPLE travaille par défaut sur des intervallesouverts.

> iscont(tan(x),x=-Pi/2..Pi/2,closed);

> iscont(tan(x),x=-Pi/2..Pi/2);

Image d'une réunion d'intervalles fermés , avec la fonction evalr :

> evalr((x->x^2)(INTERVAL(-1..-0.5)));

Extrema d'une fonction , avec les fonctions minimize et maximize :

> minimize(x^2+x-3),maximize(-x^4+x^2+1);



Fonctions définies par intervalles: piecewise permet de définir une fonction à partir de conditions sur différentsintervalles: piecewise (cond1,f1, cond2,f2, ..., condN,fN, f_autrement)

> f:=piecewise(x<0,exp(x),x<=4,x/4+1,2);

> plot(f(x),x=-4..8);

Limites: avec la fonction limit(expr, x=a , option) option = left , right .

> limit(sin(x)/x,x=0);

> limit(1/x^3,x=0);

Utilisation de la forme inerte Limit :

> Limit(1/x^3,x=0,right) = limit(1/x^3,x=0,right);



Etude locale: avec taylor(expr , x=a , n) pour les développements limités ou deTaylor,

series(expr , x=a , n) ou asympt(expr , x , n) pour des développementsasymptotiques plus

généraux. L'ordre n est facultatif et vaut 6 par défaut .

> taylor(sin(x),x); # a=0 par défaut

> taylor(x^2/(x^2+1),x=infinity,10);

> series(exp(x)/x,x,9); # a=0 par défaut

> asympt(ln(x+1/x),x,7); # toujours en plus l'infini

> asympt(Sum(1/k,k=1..n)-ln(n),n,10); # la constante d'Euler gamma

> evalf(gamma);

leadterm donne le terme principal d'une série:



> series(leadterm(sin(x^3)/(2*x)),x=0);

Conversion en polynôme de Taylor:

> P:=convert(taylor(exp(x),x=0,5),polynom);

Dérivation:

Pour dériver une fonction , utiliser diff(expr,v1,v2,...,vn) qui calcule la dérivée partiellede expr

par rapport aux variables v1,v2,...,vn .

> Diff(x/(x^2+y^2),x,y)=diff(x/(x^2+y^2),x,y); # équivaut àDiff(x/(x^2+y^2),x,y): % = value(%);

Noter l'absence de parenthèses dans l'écriture du premier membre .

On peut utiliser l'opérateur $ pour éviter de répéter plusieurs fois une variable :

> Diff(x/(x^2+y^2),x$2,y) : % = value(%);

Opérateur différentiel D: D( f ) retourne la fonction dérivée première de f Fonctions dérivées première et seconde:

> D(sin),(D@@2)(sin);



> D(x->x*sin(x)-x);

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

fonction dérivée par rapport à x,y , et z respectivement :

> D[1](f);D[2](f);D[3](f);

D[i,j](f) équivaut à D[i](D[j](f)) :

> D[1,2](f);

SUITES ET SÉRIES:

Suites définies par des sommes ou des produits:

> Sum(k^2,k=1..n) : % = factor(value(%));

> Product(k/(k+1),k=1..n) : % = simplify(value(%));



Développement asymptotique de la somme partielle d'une série:

> series(sum(1/k^2,k=1..n),n=infinity);

Suites récurrentes:

Type :

Exemple: , calcul de , pour ,..,15.

> f:=x->cos(x):n:=15:u[0]:=-1:

for k to n do u[k]:=evalf(f(u[k-1])) end do:

On peut représenter graphiquement la convergence de la suite en construisant une liste Tformée

des points (u(0),0) , (u(0),u(1)) , (u(1),u(1)) , (u(1),u(2)) , etc...

> T:=array(1..4*n,[u[0],0,u[0],f(u[0])]):

for k from 2 to 2*n-1 doT[2*k+1]:=T[2*k]:if is(k,odd) then T[2*(k+1)]:=evalf(f(T[2*k+1])) else

T[2*(k+1)]:=evalf(T[2*k+1])end if

end do:T:=convert(T,list):U:=NULL:for k to nops(T)-1 by 2 do

U:=U,[T[k],T[k+1]]end do: U:=plot([U],color=blue):G:=plot({f(x),x},x=-

1.3..1.3,scaling=constrained):plots[display]({G,U},title="point fixe ducosinus",view=[-1.3..1.3,-1.3..1.3]);



Type :

Exemple: .

> u[0]:=1:v[0]:=4:n:=15:

for k to n dou[k]:=evalf(sqrt(u[k-1]*v[k-1])):v[k]:=(u[k-1]+v[k-1])/2end do:

Type :

Exemple: .

> u[0]:=0:u[1]:=4:n:=15:for k from 2 to n do u[k]:=evalf(sqrt(u[k-1]+u[k-2])) end do:

Résolution de récurrences , avec la fonction rsolve .

Une suite arithmétique de raison -3:



> restart:rsolve(w(n+1) = w(n)-3,w);

Une suite géométrique avec condition initiale:

> rsolve({w(n+1)=w(n)/3,w(0)=-7},w);

La suite de Fibonacci:

> rsolve({fib(n+2)=fib(n+1)+fib(n),fib(0)=0,fib(1)=1},fib);

Séries numériques:

Somme d'une série de Riemann convergente:

> sum(1/k^2,k=1..infinity);

La série harmonique est divergente:

> sum(1/k,k=1..infinity);

Calcul de la somme d'une série de fonctions

> Sum(sin(x)^k,k=1..infinity)=sum(sin(x)^k,k=1..infinity);



Le package powseries contient des fonctions mettant en jeu les séries entières:

Consulter les pages d'aide de powseries pour plus de précision.

> with(powseries);

> sh := evalpow( sinh(x) ): tpsform(sh, x, 9);

INTÉGRATION:

Le calcul des primitives et des intégrales se fait avec la fonction int .

Syntaxes: int(expr , x) et int(expr, x=a..b) .

> Int(x/(x^4+1),x)=int(x/(x^4+1),x);# équivaut à Int(x/(x^4+1),x) : % = value(%);

> Int(x/(x^4+1),x=0..1) : % = value(%);

Intégrale généralisée convergente:

> Int(x/(x^4+1),x=0..infinity) : % = value(%);



Intégrale généralisée divergente:

> Int(exp(x)/x,x=1..infinity) : % = value(%);

Le package inttrans contient quelques outils pour la transformation d'intégrales.

Consulter les pages d'aide de inttrans pour plus de précision.

> with(inttrans);

La transformée de Laplace de f est définie par = .

> laplace(sin(omega*t), t, s);

Quelques outils du package student :

> with(student);



Changement de variables dans les intégrales: changevar(eq , intégrale , u)

eq est l'équation du changement de variable de la forme f(x)=g(u) , intégrale estl'intégrale

et u la nouvelle variable d'intégration :

> J:=Int(t/((t^2+1)*sqrt(1-t^4)),t=0..1);

> changevar(t^2=u,J,u):% = value(%);

Intégration par parties , avec la fonction intparts(intégrale,u) , u est le facteur àdériver.

> J:=Int(x^2*arccos(x),x):intparts(J,arccos(x));

> J:=value(%);



METHODES D'APPROXIMATION D'INTEGRALES:

METHODE DES RECTANGLES: On découpe [a,b] en n intervalles de même longueur

extrémité gauche :

représentation avec leftbox(expr,x=a..b,n) , calcul avec leftsum(expr,x=a..b,n)

extrémité droite :

représentation avec rightbox(expr,x=a..b,n) , calcul avec rightsum(expr,x=a..b,n)

point médian :

représentation avec middlebox(expr,x=a..b,n) , calcul avecmiddlesum(expr,x=a..b,n)

METHODE DES TRAPEZES: calcul avec trapezoid(expr,x=a..b,n)

METHODE DE SIMPSON: calcul avec simpson(expr,x=a..b,n) , avec n pair.

Exemple: avec f:

> middlebox(exp(-x^2),x=-1..1,20);middlesum(exp(-x^2),x=-1..1,20);evalf(%);



> evalf(trapezoid(exp(-x^2),x=-1..1,20));

> evalf(simpson(exp(-x^2),x=-1..1,20));

Calcul d'intégrales doubles ou triples:

> Doubleint(x^3*y-x^2-y*x,x=-a..a,y=-b..b):%=value(%);

> Tripleint(x*y*z*sin(x+y+z),x=0..Pi,y=-Pi..Pi,z=0..Pi):%=value(%);

ÉQUATIONS ET SYSTÈMES DIFFÉRENTIELS:



Equations du premier ordre: MAPLE sait résoudre directement les équations de typeclassique

- linéaire - avec facteur intégrant - séparable - homogène - résolue en x - de Bernoulli -de Clairaut

- de Riccati .

Équation y ' + 3 y =

> restart:eq:=diff(y(x),x)+3*y(x)=exp(-x):dsolve(eq,y(x));

_C1 désigne une constante réelle arbitraire.

La même avec la condition initiale

> dsolve({eq,y(0)=1.5},y(x));

Les solutions y(x) ne sont pas directement utilisables : en assignant la solution à y(x) onpeut utiliser le résultat , par exemple pour représenter les courbes intégrales :

> assign(dsolve(eq,y(x))):y:=unapply(y(x),_C1,x);

> plot({seq(y(_C1,x),_C1=-3..3)},x=-5..5,y=-20..20);



On peut préciser des options de résolution : explicit (pour tenter d'exprimer la solutioncomme

fonction explicite de la variable) , series (chercher les solutions sous forme de séries)

> eq:={diff(z(x),x)+z(x)*cos(x)=1,z(0)=1}:dsolve(eq,z(x));dsolve(eq,z(x),series);

La fonction odeplot du package plots permet de représenter les solutions d'une équationdifférentielle:

> with(plots,odeplot):p:= dsolve({D(z)(x) = z(x),z(0)=1}, z(x),type=numeric):

odeplot(p,[x,z(x)],-2..2,title="Fonction exponentielle");



Equations du second ordre: MAPLE sait résoudre directement les équations de typeclassique

- linéaire - d'Euler - de Bessel .

Équation y " + y ' + y = t

> restart:eq2:=diff(y(t),t$2)+diff(y(t),t)+y(t)=t;

> dsolve(eq2,y(t));

La même avec conditions initiales:

> dsolve({eq2,y(0)=0,D(y)(0)=-1},y(t));

Les options de résolution sont les mêmes qu'à l'ordre 1.

Systèmes différentiels:



Exemple: résoudre x ' =x- 2 y , y ' = 2 x+ 3 y . Représenter la solution vérifiant x (0) = 0 et y( 0) = 1 .

> restart:sys:=diff(x(t),t)=x(t)-2*y(t),diff(y(t),t)=2*x(t)+3*y(t):dsolve({sys},{x(t),y(t)});

> p:=dsolve({sys,x(0)=0,y(0)=1},{x(t),y(t)},numeric):with(plots):odeplot(p,[[t,x(t)],[t,y(t)]],-1..2);

Résolution d'équations aux dérivées partielles:

> edp:=y*diff(U(x,y),x)+x*diff(U(x,y),y)=0;

> pdsolve(edp,U(x,y) );

_F1 désigne une fonction arbitraire de classe C1 de la variable .



Travail dirigé 7:

Soit f la fonction définie pour tout réel x >0 par .

1° Etablir les singularités de la fonction f et vérifier sa continuité.

2° Etudier les limites de f aux bornes des intervalles composant Df.

Quelle est l'asymptote de la courbe Cf de f ?

3° Calculer f '( x ) et étudier son signe ( on aura recours à une fonction auxiliaire g ).

4° Représenter la courbe Cf.

5° Etudier la dérivabilité du prolongement par continuité de f aux points 0 et 1.



Maple en algèbre linéaire

FONCTIONS DE BASE:

> restart;

Les vecteurs et les matrices peuvent être définis comme des tableaux rectangulaires, parla

fonction array , rencontrée dans le chapitre sur les tableaux :

Vecteur-ligne d'ordre 3 sans initialisation:

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

Vecteur-ligne d'ordre 3 avec initialisation:

> B:=array([x,y,z]);

Vecteur-colonne d'ordre 3 sans initialisation:

> U:=array(1..3,1..1);print(U);

Vecteur-colonne d'ordre 3 avec initialisation:

> V:=array([[x],[y],[z]]);



Matrice carrée d'ordre 2 sans initialisation:

> M:=array(1..2,1..2);print(M);

Matrice carrée d'ordre 2 avec initialisation:

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

Opérations sur les vecteurs et les matrices , avec la fonction evalm :

Somme de vecteurs ou de matrices de même dimension avec +

> evalm(A+U);

Multiplication de vecteurs ou de matrices de dimensions compatibles avec &*

> evalm(M &* N);

Calcul de la matrice inverse, lorsque N est inversible, avec ^(-1)

> evalm(N^(-1));



Puissance n-ième avec ^n

> evalm(N^3);

Multiplication par un scalaire avec *

> evalm(2*M-5*N);

LES OUTILS DU PACKAGE linalg:

Le package linalg contient plus d'une centaine d'outils en algèbre linéaire:

> with(linalg);



Les fonctions matrix et vector permettent de définir respectivement une matrice(tableau

rectangulaire d'objets) ou un vecteur (tableau d'objets à une seule ligne) :

Définition d'une matrice 2x4 :

> P:=matrix([[s,t,u,v],[w,x,y,z]]);

Définition d'un vecteur-ligne d'ordre 4 et d'une matrice-colonne d'ordre 3:

> V:=vector([a,b,c,d]);

> C:=matrix([[1],[2],[3]]);

Une matrice a le type matrix , un vecteur a le type vector .

Opérations sur les matrices:

A la place de la fonction evalm , on peut utiliser les outils spécifiques du package linalg :

Multiplication de vecteurs ou de matrices de dimensions compatibles avec multiply

> multiply(M,N);

Calcul de la matrice inverse,lorsque N est inversible, avec inverse



> inverse(N);

Multiplication par un scalaire avec scalarmul

> scalarmul(P,lambda);

Test d'égalité de deux matrices avec equal

> equal(M,N);

Etude d'une matrice:

Déterminant et trace d'une matrice carrée (somme des éléments diagonaux):

> N:=matrix([[1,2],[4,-3]]);det(N);trace(N);

Rang d'une matrice:

> rank(N);

kernel(A); ou nullspace(A); détermine une base du noyau de Acolspace(A); détermine une base du sous-espace engendré par les vecteurs-colonnes de

Arowspace(A); détermine une base du sous-espace engendré par les vecteurs-lignes de A



> A:=matrix([[2,-2],[-1,1]]);kernel(A);

> colspace(A);

> rowspace(A);

Matrice caractéristique: , .

> charmat(A,lambda);

> charpoly(A,lambda);

Valeurs propres de A (ce sont les racines du polynôme caractéristique):

> eigenvals(A);

Un vecteur propre associé à la valeur propre est un vecteur X non nul tel que

.

> eigenvects(A);



Le résultat affiché signifie que est une valeur propre d'ordre 1 de vecteur propreassocié

et que est une valeur propre d'ordre 1 de vecteur propre associé

.

Modification d'une matrice:

> print(P);

row(P,k) permet d'extraire la k-ième ligne de la matrice P. Le résultat est un vecteur.

col(P,k) permet d'extraire la k-ième colonne de la matrice P. Le résultat est un vecteur.

> row(P,2),col(P,3);

rowdim(P) et coldim(P) retournent le nombre de lignes et de colonnes de la matrice P .

> rowdim(P),coldim(P);

augment(M1,M2,...,Mn) permet de concaténer horizontalement les n matricesM1,M2,...,Mn :

> augment(A,P);



stackmatrix(M1,M2,...,Mn) permet de concaténer verticalement les n matricesM1,M2,...,Mn :

> stackmatrix(A,N);

copyinto(M,N,m,n) : copie M dans N , l'élément M[1,1] étant copié en

>

copyinto(N,P,1,2);

swapcol(M,m,n) et swaprow(M,m,n) permettent d'échanger les colonnes (ou leslignes)

m et n de la matrice M :

> swaprow(A,1,2);

transpose(M) permet de transposer la matrice M :

> print(M);transpose(M);

addcol(M,m,n,k) ou addrow(M,m,n,k) rendent une matrice obtenue à partir de M par



l'opération col n := col n + k * col m (respectivement lig n := lig n + k * lig m ) :

> print(N);addcol(N,1,2,mu);

Matrices particulières:

> vandermonde([a,b,c,d]);

> JordanBlock(expr,4);

LES OUTILS DU PACKAGE LinearAlgebra:

A partir de la version 7, existe dans Maple un nouveau package LinearAlgebra avec

des outils similaires à ceux du package linalg et destiné à supplanter l'ancien. En voiciles fonctions:

> with(LinearAlgebra);



On définit une matrice A dont on calcule le déterminant, la matrice et le polynômecaractéristique,

ainsi que les valeurs propres et vecteurs propres associés:

> A:=Matrix([[1,-1,-1],[-2,2,3],[2,-2,-3]]);Determinant(A);CharacteristicMatrix(A,lambda);factor(CharacteristicPolynomial(A,lambda));Eigenvalues(A);Eigenvectors(A);




Rechercher les matrices carrées X d'ordre 2 telles que , où .

> with(linalg):A:=matrix(2,2,1);X:=matrix(2,2):

> Y:=evalm(X^2+X-A);

> Y:={seq(seq(Y[i,j],j=1..2),i=1..2)};



> solutions:={solve(Y)}:for k to nops(solutions) doX:=matrix(2,2):assign(solutions[k]):print(X);

end do:

Donc 4 matrices solutions.

Travail dirigé 8:

TD 8.1:

Ecrire une procédure pcd(L::list) retournant à partir d'une liste donnée L la listeobtenue par

permutation circulaire vers la droite des éléments de L .

Exemple:



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

TD 8.2:

Ecrire une procédure circulante_droite(n::posint) retournant à partir de l'entier n> 0

une matrice carrée d'ordre n telle que

- sa première ligne est constituée par les entiers de 1 à n .

- pour k> 1 , sa k-ième ligne est déduite de la ligne précédente par permutation

circulaire vers la droite de ses éléments.

Exemple:

> circulante_droite(5);

TD 8.3:

Test d'égalité de 2 matrices:

2 matrices M et N sont égales si et seulement si elles ont même nombre de lignes, même

nombre de colonnes, et les mêmes coefficients .

Sans avoir recours à la fonction préexistante equal de Maple, écrire une procédure

egal(M: : matrix , N: : matrix) retournant la valeur booléenne true si M=N et false

sinon.



Maple en géométrie

GEOMETRIE PLANE:

> restart;

Le package geometry contient des outils pour la géométrie plane :

> with(geometry);

La fonction point permet de définir un point du plan:Syntaxes équivalentes: point(P, Px, Py) ou point(P, [Px, Py]).

Exemple: pour définir les points O(0,0) , A(-1,3) et B(4,2).

> point(O,[0,0]):point(A,[-1,3]):point(B,[4,2]):



La fonction detail permet d'obtenir des informations sur un objet géométrique:

> detail(A);

> point(M,X,Y):

La fonction line permet de définir une droite, dont on peut avoir l'équation.

> line(AB,[A,B]):Equation(AB,[x,y]);

La fonction triangle permet de définir un triangle , dont on peut avoir l'orthocentre , oule centre

de gravité.

> triangle(OAB,[O,A,B]):orthocenter(H,OAB):coordinates(H);

> centroid(K,OAB):coordinates(K);

La fonction circle permet de définir un cercle, dont on peut avoir le centre, ou le rayon :

> circle(C,[O,A,B]):omega:=center(C):coordinates(omega);r:=radius(C);



> detail(C);

assume that the names of the horizontal and vertical axes are _x and _y, respectively

Calcul de la distance entre 2 points ou de la distance d'un point à une droite:

> distance(A,B);

> distance(M,AB);

Projeté d'un point sur une droiteprojeté de M sur (AB):

> projection(P,M,AB):coordinates(P);

Equation de la parallèle ou de la perpendiculaire à une droite donnée passant par unpoint donnéd1 est la parallèle à (AB) passant par K, d2 est la perpendiculaire à (AB) passant par K:

> ParallelLine(d1,K,AB):Equation(d1,[x,y]);



> PerpendicularLine(d2,K,AB):Equation(d2,[x,y]);

> ArePerpendicular(d1,d2);

Intersection de 2 droites , d'une droite et d'un cercle , de 2 cercles

> intersection(i1,d1,d2):detail(i1);coordinates(i1);

> intersection(i2,d1,C):detail(i2);

Tracé de la figure:

on remarquera le paramétrage des 2 droites d1 et d2 et du cercle C .

La fonction display du package plots permet de représenter sur un même graphiquedifférents

objets graphiques précédemment définis , tels ici OAB , texte , etc ...

> with(plots):

>

OAB:=plot([[HorizontalCoord(O),VerticalCoord(O)],[HorizontalCoord(A),VerticalCoord(A)],



[HorizontalCoord(B),VerticalCoord(B)],[HorizontalCoord(O),VerticalCoord(O)]],color=green):

> d1:=plot([HorizontalCoord(K)-5*t,VerticalCoord(K)+t,t=-2/3..3/4],numpoints=100,color=red):

> d2:=plot([HorizontalCoord(K)+t,VerticalCoord(K)+5*t,t=-0.5..0.75],numpoints=100,color=red):

>

cercleC:=plot([HorizontalCoord(omega)+r*cos(t),VerticalCoord(omega)+r*sin(t),t=0..2*Pi],

numpoints=100,color=blue):

> texte:=textplot([[-1.15,3,À`],[4+0.15,2,`B`],[1.8,5.2,`D2`],[-2,1.9,`D1`],[1.3,1.9,`K`]],color=black):

> display({OAB,d1,d2,cercleC,texte},scaling=constrained);

AUTRES OUTILS DU PACKAGE LINALG POUR LA GÉOMÉTRIE:

Le package linalg d'algèbre linéaire contient également quelques outils utiles engéométrie

euclidienne, notamment:

dotprod (v1,v2) calcule le produit scalaire(hermitien) des vecteurs v1 et v2.

norm (v) calcule la norme du vecteur v.

crossprod (v1,v2) calcule le produit vectoriel des vecteurs v1 et v2 (en dimension 3).

GramSchmidt ({v1,v2,...,vn}) retourne la base orthogonale déduite de la famille{v1,v2,...,vn}

par le procédé de Gram-Schmidt.



> with(linalg):v1:=vector([x1,y1,z1]);v2:=vector([x2,y2,z2]);

> dotprod(v1,v2);

> norm(v1);

> crossprod(v1,v2);

> v1:=vector([1,2,4]);v2:=vector([-1,6,5]);v3:=vector([2,0,3]);GramSchmidt({v1,v2,v3});

Représentation de polygônes réguliers, et polygônes étoilés:

> opts := filled=true, style=patch, axes=none:point(o,0,0):s1 := draw( RegularPolygon(_r7, 7, o, 3), opts, title="{7}" ):s2 := draw( RegularStarPolygon(_r7_2, 7/2, o, 3), opts, title="{7/2}" ):s3 := draw( RegularStarPolygon(_r7_3, 7/3, o, 3), opts, title="{7/3}" ):s4 := draw( RegularPolygon(_r9, 9, o, 3), opts, title="{9}" ):s5 := draw( RegularStarPolygon(_r9_2, 9/2, o, 3), opts, title="{9/2}" ):s6 := draw( RegularStarPolygon(_r9_4, 9/4, o, 3), opts, title="{9/4}" ):s7 := draw( RegularPolygon(_r11, 11, o, 3),opts, title="{11}" ):s8 := draw( RegularStarPolygon(_r11_3, 11/3, o, 3), opts, title="{11/3}" ):s9 := draw( RegularStarPolygon(_r11_5, 11/4, o, 3), opts, title="{11/5}" ):plots[display](array(1..3,1..3,[[s1,s4,s7],[s2,s5,s8],[s3,s6,s9]]));



GEOMETRIE DE L'ESPACE:

Le package geom3d contient des outils pour travailler la géométrie dans l'espace :

> with(geom3d);



La définition de points , de droites , de plans , se fait comme en dimension 2 par lesfonctions

point , line , et plane .

On définit 4 points O,A,B,C:

> point(O,[0,0,0]):point(A,[-1,2,0]):point(B,[0,1,1]):point(C,[-1,2,1]):

> detail(A);

d est la droite passant par A dirigée par U(1,2,-1)

> U:=[1,2,-1]:line(d,[A,U]):

> plane(P,[A,B,C]):Equation(P,[x,y,z]);# équation du plan P=(ABC)

Un plan a une structure que l'on peut visualiser par detail :



> detail(P);

> parallel(Q, O, P):detail(Q);# Q est le plan passant par O et parallèle à P

> plane(P1,[O,A,B]):intersection(delta,P1,P):detail(delta);# delta est l'intersection des plans P1 et P , définie par un système

paramétrique :

Warning, assume that the parameter in the parametric equations is _t

> ArePerpendicular(P,P1);

> distance(O,P);

> sphere(S,[O,A,B,C]):detail(S);

Warning, assume that the name of the axes are _x, _y and _z



> omega:=center(S):coordinates(omega);

# centre omega de la sphère S

> projection(proj,O,P):coordinates(proj);# projeté de O sur le plan P

AUTRES OUTILS DU PACKAGE GEOM3D:

Des outils existent pour représenter des polyèdres, solides de l'espace éventuellementétoilés:

> octahedron(Oct,point(O,0,0,0),1.):

stellate(StOct,Oct,1):draw( StOct, cutout=7/8, lightmodel=light4);

> point(e1,10,15,0), point(e2,-10,15,0), point(e3,-10,-15,0),point(e4,10,-15,0):r1 := 1.: point(o1,-2,2,r1):tetrahedron(p1,o1,r1):r2 := 2.: point(o2,-4,5,r2):cube(p2,o2,r2):r3 := 5./2: point(o3,-7,8,r3):octahedron(p3,o3,r3):r4 := 3.: point(o4,-3,12,r4):dodecahedron(p4,o4,r4):r5 := 7./2: point(o5,3,18,r5):icosahedron(p5,o5,r5):r6 := 6.: point(o6,15,9,r6):GreatStellatedDodecahedron(p6,o6,r6):r7 := 9./2: point(o7,11,23,r7):GreatDodecahedron(p7,o7,r7):

r8 := 7.: point(o8,17,-9,r8):SmallStellatedDodecahedron(p8,o8,r8):r9 := 15./2: point(o9,2,-11,r9):GreatIcosahedron(p9,o9,r9):



fl := [[25,30,0],[-10,30,0],[-10,-20,0],[25,-20,0]]:pic1 := plots[polygonplot3d](fl,color=sienna):pic2 :=

draw([seq(p||i,i=1..9)],color=COLOR(RGB,.9335294125,.9129411760,.5205882350)):

plots[display]([pic2,pic1],style=patch,orientation=[-97,52],title="Les neuf

polyèdres réguliers",lightmodel=light4);


Déterminer et représenter la surface S, ensemble des points M dont la somme des

carrés des distances aux droites d1: y=x , z= 1 et d2 : y=-x , z=- 1 est égale à 3.

> restart:with(geom3d):

d1 est l'intersection de 2 plans p1 et q1:

> plane(p1,y-x=0,[x,y,z]):plane(q1,z-1=0,[x,y,z]):intersection(d1,p1,q1):

d2 est l'intersection de 2 plans p2 et q2:

> plane(p2,y+x=0,[x,y,z]):plane(q2,z+1=0,[x,y,z]):intersection(d2,p2,q2):



Définition d'un point quelconque M:

> point(M,X,Y,Z):

Equation et représentation de S:

> S:=distance(M,d1)^2+distance(M,d2)^2-3;

> with(plots):

> implicitplot3d(S,X=-1..1,Y=-1..1,Z=-1/sqrt(2)..1/sqrt(2),numpoints=300,color=blue,axes=BOXED);

Il s'agit d'un ellipsoide d'équation de centre O.

Travail dirigé 9:

Soit ABC un triangle du plan affine euclidien , M un point quelconque que l'on projette

orthogonalement en H1,H2,H3 sur (BC) , (CA) , (AB) respectivement .



Montrer que M est sur le cercle circonscrit à ABC si et seulement si H1,H2,H3 sont

alignés, sur la droite dite de Simson associée à M:

On travaillera dans un repère orthonormal tel que A(0,0) , B(1,0) , C(-2,3).

Documents

Cours Maple