MAT231 TP du heure

De
Publié par

MAT231 TP du 18-09-2007 (1 heure 30) Premiers pas avec MAPLE - Boucles et instructions conditionnelles - Exercices d'application - Références Avertissement Premiers pas avec Maple Boucles et instructions conditionnelles Exercices d'application Références bibliographiques

  • maple

  • maple version

  • remarque ignorée dans l'exécution de maple

  • exercices d'application - références

  • références bibliographiques

  • nom de commande


Publié le : mardi 19 juin 2012
Lecture(s) : 50
Source : www-fourier.ujf-grenoble.fr
Nombre de pages : 7
Voir plus Voir moins
MAT231 TP du 18-09-2007
(1 heure 30)
Premiers pas avec MAPLE - Boucles et instructions conditionnelles - Exercices d'application -
Références
Avertissement
Premiers pas avec Maple
Boucles et instructions conditionnelles
Exercices d'application
Références bibliographiques
MAT231 TP du 18-09-2007
(1 heure 30)
Premiers pas avec MAPLE - Boucles et instructions conditionnelles - Exercices d'application -
Références
Avertissement
La version de Maple utilisée en TP est la version V, release 5.
Les lignes de codes ci-dessous sont données en Maple version 6.01
L'objectif des TP n'est pas de donner une formation à l'utilisation de MAPLE, mais d'illustrer le
cours de l'UE MAT231 au moyen d'un logiciel de calcul formel. Nous donnerons donc le
minimum d'information sur Maple pour pouvoir travailler sur le cours et en particulier sur les
parties Arithmétique et Polynômes.
Premiers pas avec Maple
MAPLE est un logiciel de
calcul formel
.
>
# Le symbole > est le "prompt" de Maple : à vous la main !
Derrière ce symbole # figure une remarque ignorée dans
l'exécution de Maple. Ceci permet de commenter un programme.
Dans Maple,
l'exécution d'une commande
est déclenchée par le caractère
:
ou par le caractère
;
suivi de la touche "Retour chariot / Entrée" du clavier.
>
Bonjour : a:=2:
>
Bonjour ; print(a) ;
Opérations élémentaires
1. La virgule décimale française est remplacée par un point.
2. Les opérations arithmétiques élémentaires se notent :
+
,
-
,
*
,
^
(ou
**
)
.
>
1+2; sqrt(2); (sqrt(2))^2;
>
sqrt(2.0);evalf(sqrt(2));
Nombres et symboles
: Dans Maple, les nombres
2
et
2.0
sont traités différemment.
>
whattype(2); whattype(2.0);
whattype(sqrt(2));whattype(a);whattype(b);
>
Pi; evalf(Pi);
>
Digits:=50; evalf(Pi);
>
Digits:=5; evalf(10.345645); evalf(0.0000004556);
Variables et affectation
Les noms de variables doivent commencer par une lettre, suivie éventuellement de
lettres et de chiffres. Certains noms, comme
Pi, Digits, D
, sont réservés à l'usage interne
de Maple.
La commande
whattype
utilisée ci-dessus permet de connaître le type de la variable.
L'affectation d'une variable se fait à l'aide de
:=
alors que le signe
=
est un symbole de
comparaison.
>
a:=3; A:=2; a+A; b:= a*Pi+A; evalf(b);
>
a:='a'; a; # La commande a:='a' libère la variable a
>
restart; b:=3*Pi+2;evalf(b);
>
d:=8; D:=9;
Error, attempting to assign to `D` which is protected
Aide en ligne
Pour savoir à quoi Maple destine le symbole
D
il suffit de consulter l'aide en ligne, soit en
utilisant
le menu
Help,
soit en tapant la ligne suivante (synthaxe générale,
?
suivi du nom de
commande).
Cette aide est très bien faite, elle contient des exemples explicatifs. Il ne faut pas hésiter à y
avoir recours.
>
? D
>
? whattype
>
? sqrt
>
? Pi
>
? restart
Note
Les apostrophes ' ' ("quotes" en anglais) ont pour rôle d'empêcher Maple de calculer.
Il ne faut pas les confondre avec le caractère ` accent grave (back quotes en anglais) qui permet
de délimiter une chaîne de caractères ou avec les apostrophes français ". Ces caractères sont en
particulier utilisés avec la commande
print
.
>
restart; a:=2; b:=3;
print(`a+b `,a+b);
print("la valeur de a+b est ", `a+b `,a+b);
Expressions
Une variable peut contenir une expression que l'on pourra évaluer.
>
restart;
A:=x^2+y^2;
x:=1; A;
>
x:='x': A;
>
subs(x=2,A); subs(x=a,A); subs(x=1,y=2,A);
Fonctions
Maple permet de définir des fonctions.
>
restart;
f:= (x,y) -> x^2+y^2;
f(2,y^2+z^3);f(2,1);
>
? ->
>
? unapply # Autre manière de définir des fonctions
Procédures
Avoir recours aux procédures est une autre manière de définir des fonctions. Une procédure
comporte des variables, une liste d'instructions séparées par des ; ou des : et elle se termine par
end;
ou
end:
.
A titre d'exemple, une procédure pour calculer a^n à partir de la multiplication.
>
puissance:=proc(a,n)
local A,k;# Voir commentaire ci-dessous
A:=1;
for k from 1 to n do A:=A*a od;
end:
>
puissance(a,5);
>
puissance(2.1,5);
>
puissance(2.1,5)-2.1^5;
Commentaires
1. La déclaration
local A,k
permet d'éviter que les valeurs prises par ces variables
interfèrent avec une autre partie du programme. Voir l'aide.
2. Ce programme utilise une boucle du type [Pour k de/
from
1 à/
to
n, Faire/
do
, FinFaire/
od
].
Voir le paragraphe suivant.
Tableaux
Maple propose plusieurs manières de structurer des données :
sequence, list, set,
array, table, matrix
.
Nous considérons uniquement
array
sur quelques exemples en vue d'une utilisation dans les
programmes.
>
carres:=array(1..3);
carres[1]:=1;carres[2]:=2^2;carres[3]:=3^2;
carres;
print(carres);
>
cubes:=array(0..4,[0,1,2^3,3^3,4^4]);
cubes;
print(cubes);
>
cubes:=array(1..4,[1,2^3,3^3,4^4]);
cubes;
print(cubes);
>
cubes2:=array(1..2,1..4,[[1,2,3,4],[1,2^3,3^3,4^3]]);
cubes2;
print(cubes2);
>
cubes3:=array(1..2,1..5,[[`Nombres :`,1,2,3,4],["Cubes
:",1,2^3,3^3,4^3]]);
cubes3;
print(cubes3);
>
Boucles et instructions conditionnelles
Nous avons déjà utilisé une boucle dans le paragraphe précédent.e manière générale, les boucles
et les instructions conditionnelles permettent de contrôler le déroulement d'un programme.
Quelques exemples ci-dessous. Pour plus de détails, consulter l'aide en ligne.
Boucle
for - from - to - by - do - od
Cette boucle permet d'exécuter une suite d'instructions indexées.
>
for k from 0 to 7 by 2 do print(k) od;
L'utilisation de
from
est facultative ; par défaut, le point de départ est 1.
L'utilisation de
by
est facultative ; par défaut, l'incrément est 1.
>
for k to 7 do print(`k vaut `,k) od;
Boucle conditionnelle
while
Cette boucle soumet l'exécution d'une instruction à une condition (vraie ou fausse).
>
k:=5 ;
while (k>= 2) do print(k): k:=k-1: od;
>
k:=5 ;
while (k>= 2) do print(k): k:=k-1: od:
Commentaires
.
1. Noter les deux affichages différents et la dernière valeur prise par k.
2. Les opérateurs de comparaison -- (k>= 2) dans l'exemple précédent -- sont :
= ; < ; > ; <= (inférieur ou égal) ; >= (supérieur ou égal); <> (différent).
Boucle conditionnelle
if
- the - elif - then - else - fi
Cette boucle soumet l'exécution d'une instruction à une série de conditions.
>
for k from 0 to 5
do
if (irem(k,2)=0) then print(k, " est pair")
# irem(k,2) est le reste de la division
# euclidienne de k par 2
else print(k, " est impair") fi:
od:
>
for k from 0 to 9
do
if is(irem(k,4)=0) then print(k, " reste div_eucl / 4",0)
elif is(irem(k,4)=1) then print(k, " reste div_eucl / 4",1)
elif is(irem(k,4)=2) then print(k, " reste div_eucl / 4",2)
else print(k, " reste div_eucl / 4",3)
fi;
od:
>
Exercices d'application
Exercice 1
(cacul de factorielle n)
Donner une procédure pour calculer factorielle n (y compris pour n=0).
Exercice 2
(Nombres premiers)
Ecrire des programmes pour déterminer les nombres premiers inférieurs ou égaux à un
nombre donné N :
(i) dans un premier temps avec la fonction Maple
isprime(p)
qui retourne
true
si le
nombre est premier,
false
sinon ;
(ii) dans un second temps en utilisant l'algorithme d'Erathostène et la fonction Maple
irem(a,b)
qui retourne le reste de la division euclidienne de
a
par
b
(voir l'Exercice 4).
Exercice 3
(Décomposition en facteurs premiers)
Ecrire un programme factorisant un nombre donné N en facteurs premiers en utilisant la
fonction
nextprime
de Maple.
Exercice 4
(Division euclidienne)
(i) Ecrire un programme donnant le quotient et le reste de la division euclidienne de a par b
et vérifiez vos résultats à l'aide des fonctions Maple
iquo(a,b)
et
irem(a,b)
.
(ii) Ecrire ce programme sous forme de procédure. Introduire un contrôle de temps
d'exécution en utilisant la fontion Maple
time()
.
(iii) On suppose que le nombre a est très grand devant le nombre b (par exemple a/b >
10.000.000). Donner une estimation du nombre d'opérations (addition / soustractions /
multiplications) nécessaires pour exécuter votre procédure.
Exercice 5
(Division euclidienne revisitée)
Pour réduire le temps de calcul dans l'algorithme de division euclidienne, on cherche le
quotient q de la division euclidienne de a par b sous forme binaire.
1. Donner un algorithme mettant en oeuvre cette idée.
2. Donner une estimation du nombre d'opérations nécessaires.
Références bibliographiques
Cornil, Jack-Michel - Testud, Philippe -- Maple, Introduction raisonnée à l'usage de l'étudiant, de
l'ingéneiur et du chercheur. Springer 1995
Soyez le premier à déposer un commentaire !

17/1000 caractères maximum.