1 Résume De Maple 5.0

POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
Maple 5.0
Analyse
1/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
SOMMAIRE
1.
2.
3.
4.
5.
6.
7.
Résumé De Maple
Apprentissage De Maple
Exercice 1
Exercice 2
Exercice 3
TD Les Séries De Fourier
Conclusion Générale
Annexe : Néant.
2/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
1
RESUME DE MAPLE 5.0
Maple est un logiciel de calcul formel.
Les versions utilisées à l’IUT sont des versions bridées pour les étudiants ne donnant « que »
100 chiffres significatifs, alors que la version complète est capable donner jusqu’à 50000
chiffres significatifs.
Rem : Des calculs si précis ne sont utile qu’en Mathématique
Maple possède une puissance de calcul phénoménale.
Il intègre même, ces propres bibliothèques pour agrandir ses fonctionnalités et son propre
langage de programmation pour créer ses propres commandes
Maple possède tout de même des défauts :
- Assez difficile d’accès, assez complexe à utiliser
- Le symbolisme Mathématique utilisé n’est pas forcément aux normes françaises ou
même Mathématique car le logiciel a été conçu par une équipe canadienne (d’où
Maple, la feuille d’érable.)
Maple possède néanmoins un concurrent encore plus puissant appelé Mathématica.
3/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
2
APPRENTISSAGE DE MAPLE
Nous allons présenter ici quelques fonctionnalités de base de Maple :
> a:=x^2-1;
// comment écrire une équation
a := x² - 1
> restart;
// remettre les variables a zéro
// de quel type est l’expression entre parenthèse
> whattype(-7/93);
fraction
> eq:= x^2-63*x+236=0;
eq := x² - 63 x + 236 = 0
> solve(eq);
// résoudre l’équation entre parenthèse
4, 59
// réponse ‘ et 59
> 20!;
// factoriel 20
2432902008176640000
> evalf(sqrt(3));
// evalf : utiliser pour évaluer l’expression entre parenthèse
1.732050808
> Digits:=3:evalf(Pi);
// Digits : pour préciser le nombre de chiffres significatifs
3.14
> Digits:=153:evalf(Pi);
3.14159265358979323846264338327950288419716939937510582097494459
2307816406286208998628034825342117068
// pour montrer la séquence produite par l’expression entre
parenthèse
1, 2, 4, 8, 16, 32
> add(n,n=1..3);
// additionner tous les nombres compris entre 1 et 3
6
> nextprime(456);
// donne le nombre premier immédiatement supérieur
457
>seq(2^k,k=0..5);
> for n from 0 to 10 do
> if isprime(a)=true then
>
print(`p est premier`):
// exemple de programmation
> else
>
print(`p n'est pas premier`);
> fi;
> od;
a := 1
p n'est pas premier
a := 11
p est premier
a := 111
4/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
p n'est pas premier
a := 1111
p n'est pas premier
a := 11111
p n'est pas premier
a := 111111
p n'est pas premier
a := 1111111
p n'est pas premier
a := 11111111
p n'est pas premier
a := 111111111
p n'est pas premier
a := 1111111111
p n'est pas premier
> roots(x^15+1);
[[-1, 1]]
> Roots(x^15+1) mod 2;
[[1, 1]]
// donne les racines de la fonction entre parenthèse
// réponse –1 et 1
// donne les racine MAIS mod 2
// réponse 1
> M2:=matrix(4,9,(i,j) ->i+j);
// comment faire une matrice de 4 lignes et 9 colonnes
dont les éléments sont le résultats de i+j
[2 3 4 5 6 7 8 9 10]
[3 4 5 6 7 8 9 10 11]
M2 [4 5 6 7 8 9 10 11 12]
[5 6 7 8 9 10 11 12 13]
> A:=matrix(2,3,(i,j)->i+j mod 2); // matrice en mod 2
[0 1 0]
A [1 0 1]
> moyenne:=proc(L::list)
> local n,k,s,m;
> n:=nops(L):
> s:=0:
> for k from 1 to n do
>
s:=s+L[k]:
> od:
> m:=s/n;
>end:
// exemple d’algorithme calculant la moyenne d’une liste
Les détails de la création d’un algorithme seront précisé dans
le chapitre 2 Exercice 1
> L:=[-4,0,2,-1,4,-3,-9,-10,-5]:
> moyenne(L);
-26/9
// exemple d’utilisation de l’algorithme
5/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
> allumettes:=proc(f,p::integer)
> local a,b,c,n:
> a:=plot(f,x=0..p,color=blue):
> with(plottools):
> b:=plot([[0,0],[0,subs(x=0,f)]]):
> c:=point([0,subs(x=0,f)],symbol=circle,color=black):
> for n from 1 to p do
>
b:=b,plot([[n,0],[n,subs(x=n,f)]]):
>
c:=c,point([n,subs(x=n,f)],symbol=circle,color=black):
> od:
> with(plots):
> display({a,b,c});
>end:
>allumettes(2*x/(x^2+1),10);
// exemple d’utilisation de l’algorithme
6/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
3
EXERCICE 1
Algorithme d’une suite avec Maple 5.0 :
suite := proc ( n::integer, u::integer)
local k, x, y, L;
y := u;
L := [u];
for k to n do
x := k*(y - 5) :
y := x ;
L := [op(L), x]
od;
L
End
// déclaration de la procédure avec ses paramètres
// déclaration des variables locales
// y prend la valeur de u
// création de la liste avec u pour u(0)
// declaration d’une boucle POUR
//
déclaration même de la suite
//
incrémentation de la suite
//
concaténation de x a la fin de la liste
// fin de la boucle POUR
// affichage de la liste a l’écran
// fin de la procédure
> suite (5,3);
[3, -2, -14, -57, -248, -1265]
// utilisation de l’algorithme
// résultat obtenu
> trace(suite); suite(5,3);
// trace de la suite
suite
//nom de la procédure à tracer
{--> enter suite, args = 5, 3
// paramètres envoyer a la procédure
y := 3
L := [3]
y := -2
L := [3, -2]
y := -14
// trace des résultats obtenus
L := [3, -2, -14]
y := -57
L := [3, -2, -14, -57]
y := -248
L := [3, -2, -14, -57, -248]
y := -1265
L := [3, -2, -14, -57, -248, -1265]
[3, -2, -14, -57, -248, -1265]
<-- exit suite (now at top level) = [3, -2, -14, -57, -248, -1265]}
[3, -2, -14, -57, -248, -1265] // résultat final
7/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
4
EXERCICE 2
Algorithme d’une suite harmonique avec Maple 5.0 :
suiteharmonique := proc (a::positive, m::integer) // déclaration de la procédure
local S, p, comp;
// déclaration des variables
if evalf(a)<0
// vérification a est-il positif ?
then ERROR (à doit être positif` );
//
sinon écrire a l’écran le message
fi;
// fin si
comp := 1;
// comp prend la valeur 1
S := 0;
// et S la valeur 0
while (S < a) and (comp < m) do
// déclaration d’une boucle TANT QUE
S := S + 1/comp;
//
calcule de la somme
comp := comp + 1
//
incrémentation du compteur
od;
// fin TANT QUE
if a < S
// si a < S
then p := comp - 1;
//
alors p prend la valeur de comp-1
p;
//
et afficher p a l’écran
else print(`aucune valeur obtenue dans le cadre donné`) // sinon afficher le message
fi
// fin si
end
// fin procédure
// construction d’un jeu de test
> evalf(add(1/n, n=1..56)) ;
4.611469355
// utilisation du jeu d’essai
> suiteharmonique (4.6114, 80);
56
> suiteharmonique(4.6114,20);
aucune valeur obtenue
// utilisation de l’algorithme
// résultat obtenu
8/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
5
EXERCICE 3
Algorithme de Dichotomie avec Maple 5.0 :
dichotomie:= proc (f, a, b, epsilon :: float) // déclaration de la procédure et de ses paramètres
local u,v,c;
// déclaration des variables locales
u:=a:
// u prend la valeur de a
v:=b:
// v prend celle de b
while (epsilon < evalf(v-u)) do
// déclaration de la boucle TANT QUE
c:=(u+v)/2:
//
c prend la valeur de (u+v)/2
if evalf(f(u)*f(c))<0
//
si (f(u) x f(c)< 0)
then v:=c:
//
alors v prend la valeur de c
else u:=c:
//
sinon u prend celle de c
fi:
//
fin si
od:
// fin TQ
evalf(c);
// approximation de la valeur de c et afficher a l’écran
end:
// fin procédure
> dichotomie(x->x^2-2, 1, 2, 0.000000001); // appel de la procédure dichotomie avec (
f(x)=x²-2, a=1, b=2, epsilon = 0.000000001 (précision du résultat)
>
1.414213561
9/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
6
TD LES SERIES DE FOURIER
Pour l’énoncer du TD voir TD Séries De Fourier, T.Brugère, IUT De Nantes, dpt
Informatique, année 2000-2001 : (TD réaliser sous Maple 5.0)
1-a )
-calcul de la valeur efficace de f
> valeur_efficace := evalf ( sqrt(1/(2*Pi)*int(x^2, x=-Pi..Pi) ) );
>
valeur_efficace := 1.81
-calcul des coefficients de An
// détermination de a
> a:= n-> evalf(int(x*cos(n*x),x=-Pi..Pi)/Pi);
en fonction de n
Pi
/
|
| x cos(n x) dx
|
/
-Pi
a := n -> evalf(-------------------)
Pi
// la fonction a est égale a toute l’expression
// vérification de a
> a(5);
0
// détermination de b
> b:= n-> evalf(int(x*sin(n*x),x=-Pi..Pi)/Pi);
en fonction de n
Pi
/
|
| x sin(n x) dx
|
/
-Pi
b := n -> evalf(-------------------)
Pi
// la fonction b est égale a toute l’expression
//essai de la fonction b
> b(5);
.400
10/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
// calcul de An en fonction de a(n) et b(n)
> A:=n->evalf(sqrt(a(n)^2+b(n)^2));
A := n -> evalf(sqrt(a(n)² + b(n)² ))
// la fonction A prend toute l’expression
// vérifiction de la fonction A gr^ce aux résultat obtenus pour a(5) et b(5)
> A(5);
.400
// c’est bon
1-b ) - Détermination du plus petit entier k
// préparation de l’algorithme
> A(1);
2.00
// utilization d’un algorithme
> c:=evalf(sqrt(2)):
// = evalf (sqrt(A(1))
> v:=1:
> while c< evalf(0.99*valeur_efficace) do // utilisation de la fonction valeur_efficace
>
v:=v+1:
>
c:=evalf(sqrt(add(A(k)^2,k=1..v)/2)):
> od:
>print (`k = `) ;
>v;
k = 31
// résultat obtenu bon
1-c )
- Représentation graphique
//initialisation du graphique
> f := x  x:
> g := x  add((-1)^(d+1)*(2/d)*sin(d*x),d=1..15):
> plot([g(x),f(x)],x=-Pi..Pi,color=[black,green],thickness=2);
Warning, `d` in call to `add` is not local
// dessin du graphique
11/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
1-d ) Extra
Algorithme de récapitulation complet sous forme de tableau :
tabAn := proc (n::integer)
local t, k, a, b, A, B, C ;
t := array(1..n+1, 1..6):
// déclaration des variables locales
// déclaration d’un tableau
Digits := 3 :
t[1,1] := ` n`:
t[1,2] := `a(n)`:
t[1,3] := `b(n)`:
t[1,4] := `A(n)`:
t[1,5] := `1/2Sigma A(n)²`:
t[1,6] := `1/2 SigmaA(n)²/E`:
// nombre de chiffres significatif
//initialisation des entêtes
for k from 2 to n+1 do
// boucle POUR
a:= n-> evalf(int(x*cos(n*x),x=-Pi..Pi)/Pi):
b:= n-> evalf(int(x*sin(n*x),x=-Pi..Pi)/Pi):
A:= n-> evalf(sqrt(a(n)²+b(n)²)):
// calcule des functions a(k), b(k), A(k), B, k), C(k)
B:= n-> evalf(add(A(v)²,v=1..n)/2):
C:= n-> evalf((add(A(v)²,v=1..n)/2) / (valeur_efficace)²):
t[k,1]:=k-1:
t[k,2]:=a(k-1):
t[k,3]:=b(k-1):
t[k,4]:=A(k-1):
t[k,5]:=B(k-1):
t[k,6]:=C(k-1):
od;
//implémentation dans le tableau
// fin POUR
// affichage du tableau à l’écran
// fin de la procedure
eval (t)
end:
// utilisation de l’algorithme
> tabAn (7);
[n,
[1 ,
[2 ,
[3 ,
[4 ,
[5 ,
[6 ,
[7 ,
a(n) ,
0,
0,
0,
0,
0,
0,
0,
b(n) ,
2,
-1,
.667,
-.500,
.400 ,
-.333,
.286,
A(n) , 1/2Sigma A(n)² ,
2.00 ,
2.00 ,
1.00 ,
2.50 ,
.667 ,
2.73 ,
.500 ,
2.85 ,
.400 ,
2.93 ,
.333 ,
2.99 ,
.286 ,
3.03 ,
1/2 Sigma A(n)²/E]
.608]
.760]
.828]
.866]
.891]
.907]
.920]
12/13
POIRIER Mathieu, BOURY Sébastien – info 1 grp 3
Compte Rendu Maple – 6/06/2001
7
CONCLUSION GENERALE
En conclusion,
nous pensons que les TDs sur l’utilisation de Maple 5.0 dans le cadre du module de
mathématiques, nous ont plutôt été profitable et sont loin d’être inutile dans la formation d’un
informaticien.
Aussi, nous avons pu nous apercevoir que Maple 5.0 n’était pas non plus parfait et fait preuve
de certaine lourdeur dans la manipulation du logiciel, surtout pour les jeunes initiés. Ceci
même si nous n’avons rien à dire sur les capacités techniques offertes par Maple5.0 qui sont à
notre niveau d’étude amplement suffisant.
13/13