 \documentclass[a4paper,10pt]{article}
%\documentclass{article}
\if@twoside \oddsidemargin 44pt \evensidemargin 82pt \marginparwidth 107pt
\else \oddsidemargin -0.29cm \evensidemargin -0.29cm
 \marginparwidth 0cm
\fi
\marginparsep 0cm
 \topmargin 0.36cm \headheight 0pt \headsep 0pt \footskip 30pt
%\topmargin 0.46cm
\baselineskip = 15pt
\textheight 24cm
\textwidth 17cm \columnsep 10pt \columnseprule 0pt
%\textheight 25 cm
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais]{babel}
\usepackage{latexsym}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage[pdftex]{hyperref}

%\author{Renée De Graeve}

\begin{document}
\begin{center}
{\Large Algorithmique \\et traduction pour calculatrices\\et MuPAD}
\end{center}

\vspace{1cm}
\section{Pour commencer}
\subsection{Comment éditer et sauver un programme}
\subsubsection{Traduction MuPAD}
Il est commode d'utiliser \verb|emacs| comme interface, et d'avoir deux
{\em Buffers\/} ouverts: l'un deux sera le texte du programme, l'autre
sera une session \verb|*MuPAD*| qui permettra de tester que le programme
est correct (il faudra parfois ouvrir un troisi\`eme Buffer
pour une session de mise au point lorsqu'il se produit une erreur
un peu r\'ecalcitrante).\\
%Un exemple : \label{sec:exemple}
Lancez \verb|emacs| puis tapez sur la touche
\verb|Echap| puis, tapez  \verb|x| \verb|mupad| {\bf $<$ Return$>$}\\
puis \verb|Start MuPAD| du menu \verb|MuPAD| ce qui lance une session
\verb|*MuPAD*| comme d'habitude. Dans le menu \verb|Files| s\'electionnez
\verb|Open File| et donnez, par exemple, comme nom de fichier \verb|prog1.mu|.
Dans le menu \verb|Buffers| vous devez avoir les buffers suivants
\verb|*MuPAD*| et \verb|prog1.mu|, il suffit de cliquer sur le nom
de buffer pour passer de la session \verb|*MuPAD*| \`a l'\'edition
du programme. 

Nous allons \'ecrire une fonction appel\'ee \verb|ma_procedure|
qui calculera la moyenne de deux nombres.

S\'electionnez le buffer \verb|prog1.mu|, puis dans le
menu \verb|MuPAD| s\'electionnez \verb|Shapes| puis \verb|Procedure|.
On vous demande dans l'ordre d'entrer le nom de la proc\'edure,
par exemple \verb|ma_procedure|, puis les arguments (ou param\`etres) qu'il 
faudra lui passer, par exemple \verb|x1,x2|, puis les options 
(tapez sur {\bf $<$ Return$>$}
pour ne pas donner d'options). Votre texte doit ressembler \`a:
\begin{verbatim}
ma_procedure:=
proc (x1,x2)
begin
  
end_proc: /* End of ma_procedure */
\end{verbatim}
Il ne reste plus qu'\`a entrer entre \verb|begin| et \verb|end_proc|:\\
\verb|return (x1+x2)/2;|\\
et \`a sauvegarder le fichier (\verb|Save Buffer| du menu \verb|Files|).

S\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure|. Vous pouvez maintenant calculer la moyenne des
deux entiers 5 et 13 en tapant:\\
\verb|ma_procedure(5,13);|\\
qui doit vous renvoyer \verb|9|.
%{\bf Exemple de traduction \LaTeX}
%\begin{verbatim}
%tex:=proc (e)
%begin
%print(Unquoted,generate::TeX(e);  
%end_proc: /* End of ma_procedure */
%\end{verbatim}
%Sauvez ce programme sous le nom : {\tt tex.mu} et
%dans votre session \verb|*MuPAD*| tapez :\\
%{\tt read(''tex.mu'');}\\
%Ainsi la commande {\tt tex} vous transformera l'\'ecriture de votre r\'esultat en \LaTeX.
\subsubsection{Traduction Casio}
Appuyer sur la touche {\tt MENU}, puis ouvrir le menu {\tt PRGM} (en mettant
 en surbrillance {\tt PRGM} avec les flèches, puis en appuyant sur la touche 
{\tt EXE}).\\
Cela vous donne la liste des programmes (écran {\tt Program List}) et un
 bandeau contenant :
{\tt EXE EDIT NEW DEL DEL.A SRC REN}\\
Avec {\tt F3} vous sélectionnez {\tt NEW} pour éditer un nouveau programme.\\
On vous demande {\tt Program Name} : il  suffit de taper le nom de votre 
programme (vous \^etes en mode Alpha!).\\
Les touches {\tt SHIFT VARS (PRGM)} font appara\^itre  un bandeau contenant 
les différentes instructions et la touche {\tt OPTN} fait appara\^itre  un 
bandeau contenant les différentes fonctions mathématiques.\\
La touche {\tt EXIT} permet de sortir d'une application.\\
 Pour sauver votre programme, il suffit de taper {\tt 2nd EXIT (QUIT)} et on
 revient à l'écran {\tt Program List}.
\subsubsection{Traduction HP38 HP40G}
Pour avoir accès au catalogue de programmes, on appuie sur les touches
 {\tt shift 0 (PROGRAM)}.\\
 Il apparait alors un écran contenant la liste des programmes disponibles et un bandeau ({\tt EDIT NEW SEND RECV RUN}).\\
Pour taper un nouveau programme, on appuie sur {\tt F2 (NEW)}.\\
On vous demande le nom du programme : attention ! vous n'\^etes pas en mode 
{\tt Alpha} appuyer sur {\tt F4 (A..Z)} pour y \^etre!!!.\\
Tapez son nom puis {\tt F6 (OK)}.\\
Vous entrez votre programme et votre travail est automatiquement sauvegardé.  
\subsubsection{Traduction HP48 HP49G mode RPN} 
La {\tt HP49G} peut travailler selon deux modes : le mode RPN qui est la 
notation polonaise inverse et o\`u  les diff\'erents résultats sont mis sur une 
pile, ou le mode algébrique qui est la notation habituelle (cf \ref{sec:alg}).\\
Un programme s'écrit dans la ligne de commande entre les délimiteurs ${\tt \ll \; \gg}$\\ 
Pour le  sauver, il suffit de faire suivre le dernier $\gg$ par :
 $${\tt \ 'NOMDUPROGRAMME'\ STO\triangleright}$$
\subsubsection{Traduction HP49G mode Algébrique}\label{sec:alg} 
Un programme s'écrit dans la ligne de commande entre les délimiteurs ${\tt \ll \; \gg}$\\ 
Pour le  sauver, il suffit de faire suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOMDUPROGRAMME}$$
\subsubsection{Traduction TI 80} 
On appuie sur la touche {\tt PRGM} et on met en surbrillance {\tt NEW} avec la 
flèche $\rightarrow$, puis {\tt ENTER}.\\
On obtient :\\
{\tt 1:CREATE NEW}\\
Il suffit de taper {\tt ENTER}.\\
On obtient :{\tt NAME=}\\
Il suffit de taper le nom du programme (vous \^etes en mode {\tt ALPHA}!), puis
{\tt ENTER}.\\
Vous \^etes dans l'éditeur et vous pouvez taper votre programme (cf \ref{sec:ti83}).
\subsubsection{Traduction TI 83+}\label{sec:ti83} 
On appuie sur la touche {\tt PRGM} et on met en surbrillance {\tt NEW} avec la 
flèche $\rightarrow$, puis {\tt ENTER}.\\
On obtient :\\
{\tt PROGRAM Name=}\\
Il suffit de taper le nom du programme (vous \^etes en mode {\tt ALPHA}!), puis
{\tt ENTER}.\\
Vous \^etes dans l'éditeur et vous pouvez taper votre programme :\\
- les {\tt :} sont mis automatiquement en début de ligne.\\
- les différentes instructions sont disponibles en appuyant sur {\tt PRGM} :
en effet, depuis l'éditeur le menu de {\tt PRGM} n'est pas le m\^eme ({\tt CTL}
  pour les différentes instructions, {\tt I/O} pour les instructions 
d'entrées et de sorties, et enfin {\tt EXEC} pour afficher la liste des noms 
des programmes ce qui permet d'écrire {\tt prgmNOMDUPROG} dans une ligne de
 programme pour appeler un sous programme).\\
- les fonctions mathématiques sont accessibles en appuyant sur {\tt MATH} et 
les fonctions booléennes en appuyant sur {\tt 2nd MATH (TEST)}.\\
Pour sauver votre programme, il suffit de taper {\tt 2nd MODE (QUIT)} et vous
 revenez à l'écran {\tt HOME}.
\subsubsection{Traduction TI89, 92}
Pour avoir accès à l'éditeur, on appuie sur la touche {\tt APPS} puis {\tt 7 (Program Editor)} puis {\tt 3 (New)} et {\tt ENTER}.\\
On vous demande, dans {\tt Type}, si on veut écrire une fonction (qui renvoie une valeur 
gr\^ace à {\tt Return}) ou un programme (appuyer {\tt ->} puis faites votre
 choix {\tt 1} ou  {\tt 2}) puis {\tt ENTER} pour valider votre choix.\\
On écrit ensuite le nom du programme dans la case {\tt Variable} puis 
{\tt ENTER} pour valider le nom, puis {\tt ENTER} pour entrer dans l'éditeur.\\
Vous \^etes pr\^et à taper votre programme.\\
 Vous pouvez ajouter éventuellement les noms des paramètres dans la première 
ligne (en déplaçant le curseur avec les flèches).\\
Les touches {\tt F1 F2 F3 F4} vous facilitent l'édition.\\
En appuyant sur ${\tt \blacklozenge\ Q\ (HOME)}$ vous sauvez votre programme 
et vous revenez à l'écran {\tt HOME}.
\subsubsection{Traduction SHARP EL9600}
On appuie sur la touche {\tt 2nd MATRIX (PRGM)} et on met en surbrillance {\tt NEW}  avec la flèche $\downarrow$ et {\tt ENTER}  (ou bien avec le stylet il 
suffit de toucher {\tt NEW} deux fois).\\
On obtient :\\
{\tt TITLE?}\\
Il suffit de taper le nom du programme (vous \^etes en mode {\tt ALPHA}!), puis
{\tt ENTER}.\\
Vous \^etes dans l'éditeur et vous pouvez taper votre programme :\\
- les différentes instructions sont disponibles en appuyant sur 
{\tt 2nd MATRIX (PRGM)} :
en effet, depuis l'éditeur le menu de {\tt 2nd MATRIX (PRGM)} n'est pas le 
m\^eme ({\tt PRGM} pour les instructions d'entrées et de sorties, {\tt BRNCH} 
 pour les différentes instructions de programmation etc...).\\
- les fonctions mathématiques sont accessibles en appuyant sur {\tt MATH} 
 ({\tt CALC} et {\tt NUM} donnent les fonctions de calculs et d'arrondis,
 {\tt INEQ} donne les symboles d'inégalités et {\tt LOGIC} donne  les fonctions
 booléennes).\\
Pour sauver votre programme, il suffit de taper {\tt 2nd CL (QUIT)} et on
 revient à l'écran {\tt HOME}. 
\subsection{Comment corriger un programme} 
\subsubsection{Traduction MuPAD}
Si la syntaxe est mauvaise, la machine vous indique un message d'erreurs.\\
Faites appara\^itre le texte de votre programme : ouvrir le menu 
\verb|Buffers| et  s\'electionner le nom de votre programme (\verb|prog1.mu|).\\
Vous pouvez corriger votre erreur, puis  sauvegarder votre correction dans le fichier \verb|prog1.mu|
(\verb|Save Buffer| du menu \verb|Files|).
S\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure|.\\
Si vous ne voyez pas quelle peut \^etre la source d'une erreur,
vous pouvez utiliser le d\'ebuggueur \verb|mdx|. Le programme \verb|mdx|  permet de stopper
l'ex\'ecution d'un programme \verb|MuPAD| \`a une ligne donn\'ee
et continuer l'ex\'ecution ligne apr\`es ligne avec la possibilit\'e
d'examiner le contenu des variables.

Pour lancer \verb|mdx|, choisissez \verb|Debug| du menu \verb|MuPAD|
ou tapez dans la fen\^etre \verb|emacs|
la touche \verb|Echap| puis \verb|x mdx| puis {\bf $<$ Return$>$}.\\
Vous devez voir apparaitre :\\
\verb|Run mdx (like this): mupad prog1.mu|\\
Tapez \verb|Entree| (apr\`es avoir chang\'e le nom du fichier si n\'ecessaire).

Vous devez voir apparaitre un buffer qui ressemble fortement au
buffer \verb|*MuPAD*|. Vous pouvez maintenant ex\'ecuter en mode
pas \`a pas n'importe quelle proc\'edure de votre fichier en tapant
par exemple :\\
\verb|debug(ma_procedure(5,13));|\\
La fen\^etre \verb|emacs| doit maintenant \^etre divis\'ee en deux
parties, avec le texte source d'une part et le buffer \verb|*gud-prog1.mu*|
d'autre part. Les commandes de mise au point doivent \^etre \'ecrites
dans le buffer \verb|*gud-prog1.mu*|.\\
 Les principales sont :
\begin{itemize}
\item \verb|p| affiche la valeur d'une variable
\item \verb|n| ex\'ecute la ligne courante du source
\item \verb|s| comme \verb|n| mais en ex\'ecutant les appels de proc\'edure
de la ligne courante en mode pas-\`a-pas
\item \verb|c| continue l'ex\'ecution jusqu'au prochain point d'arr\^et.
Il est possible de mettre un point d'arr\^et en mettant dans le texte source,
le curseur l\`a o\`u on
veut arr\^eter l'ex\'ecution du programme puis en tapant \verb|Ctrl-X|
\verb|Ctrl-A| \verb|Ctrl-B| dans la fen\^etre source (ce qui ex\'ecute la
commande \verb|S| dans la fen\^etre du debuggeur).
\end{itemize}
Pour en savoir plus sur la programmation, vous pouvez par exemple consulter
avec Netscape les notes de B. Ycart et P. Zimmermann~:\\
\verb|http://www.math-info.univ-paris5.fr/Enseignements/demarre_mupad/|
\subsubsection{Traduction Casio}
Si la syntaxe est mauvaise, la machine vous indique :
{\tt Go ERROR}
 si vous voulez aller là o\`u se trouve l'erreur appuyer sur l'une des flèches
 ($\leftarrow ,\rightarrow$).\\
Vous \^etes alors dans l'éditeur pr\^et à corriger votre erreur.\\
Attention!!!\\
- vous n'\^etes pas en mode insertion automatiquement (appuyer sur 
{\tt 2nd DEL (INS)} pour \^etre en mode insertion jusqu'au prochain 
déplacement du curseur).
\subsubsection{Traduction HP38 HP40G}
Si la syntaxe est mauvaise, la machine vous  dit :\\
{\tt Invalid Syntax Edit program?} Vous répondez {\tt F6 (YES)}.\\
La machine vous met automatiquement le curseur l\`a
o\`u le compilateur a détecté l'erreur. Il suffit donc de corriger!!!
\subsubsection{Traduction HP48 HP49G mode RPN} 
Si la syntaxe est mauvaise, la machine vous met automatiquement le curseur l\`a
o\`u le compilateur a détecté l'erreur. Il suffit donc de corriger!!!\\
Si l'erreur est détectée au cours de l'exécution du programme il faut taper :\\
{\tt 'NOMDUPROGRAMME'  VISIT}\index{VISIT} qui édite votre programme.\\
 On corrige, puis 
{\tt ENTER}  sauve votre programme corrigé. \\
Si vous ne voyez pas quelle peut \^etre la source d'une erreur,
vous pouvez utiliser le d\'ebuggueur : \\
- sur la {\tt HP49G} taper {\tt shift-bleu CAT (PRG)} et s\'el\'ectionner le menu
{\tt 14 RUN \& DEBUG} puis {\tt ENTER}.\\
 - sur la {\tt HP48G} taper {\tt PRG} puis {\tt NXT} puis ouvrir le 
r\'ep\'ertoire {\tt RUN} du bandeau.\\ 
Le bandeau ${\tt DEBUG\ SST\ SST\downarrow\ NEXT\ HALT2\ KILL}$ s'affiche.\\
 {\tt DEBUG} lance le programme et ex\'ecute la premi\`ere instruction
puis, {\tt NEXT} affiche l'\'etape suivante sans l'ex\'ecuter et
{\tt SST} l'ex\'ecute  ({\tt NEXT  SST} ex\'ecute le programme au pas \`a pas).\\ 
Si l'on veut faire l'ex\'ecution du programme en pas \`a pas \`a partir du milieu du programme
il faut mettre un point d'arr\^et \`a cet endroit en ins\'erant la commande 
{\tt HALT} dans le programme. On lance alors le programme qui s'arr\^ete au niveau du {\tt HALT}, on fait l'ex\'ecution en pas \`a pas comme pr\'ec\'edemment
avec  {\tt NEXT} {\tt SST} etc..\\
On utilise {\tt KILL} pour arr\^eter le debugger quand on a compris o\`u etait l'erreur et {\tt Shift-rouge ON (CONT)} pour continuer l'ex\'ecution du programme. 
\subsubsection{Traduction HP49G mode Algébrique} 
Si la syntaxe est mauvaise, la machine vous met automatiquement le curseur l\`a
o\`u le compilateur a détecté l'erreur. Il suffit donc de corriger!!!\\
Si l'erreur est détectée au cours de l'exécution du programme il faut taper :\\
{\tt VISIT('NOMDUPROGRAMME')}\index{VISIT} qui édite votre programme.\\
 On corrige, puis 
{\tt ENTER}  sauve votre programme corrigé. 
\subsubsection{Traduction TI 80 TI 83+}
Si la syntaxe est mauvaise, la machine vous demande si vous voulez aller là o\`u se trouve l'erreur 
({\tt 1:GOTO})  ou si vous voulez arr\^eter 
({\tt 2:QUIT}).\\
Vous répondez : 1 \\
Vous \^etes alors dans l'éditeur pr\^et à corriger votre erreur.\\
Puis {\tt 2nd MODE (QUIT)} vous fait revenir à l'écran {\tt HOME} en
 sauvant votre correction.
\subsubsection{Traduction TI89 92}
Si la syntaxe est mauvaise, la machine vous demande  si vous voulez aller là 
o\`u se trouve l'erreur ({\tt ENTER=GOTO}) ou si vous voulez arr\^eter 
({\tt ESC=CANCEL}).\\
Vous répondez : {\tt ENTER}. \\
Vous \^etes alors dans l'éditeur pr\^et à corriger votre erreur.\\
Puis  ${\tt \blacklozenge\ Q\ (HOME)}$ vous fait revenir à l'écran {\tt HOME} 
en sauvant votre correction.\\
Si l'erreur est détectée au cours de l'exécution du programme il faut taper :\\
 {\tt APPS} puis {\tt 7 (Program Editor)} puis {\tt 1 (Current)} et {\tt ENTER}
qui édite votre programme.
\subsubsection{Traduction SHARP EL9600}
Si la syntaxe est mauvaise, la machine vous demande si vous voulez aller là 
o\`u se trouve l'erreur à l'aide des flèches ($\leftarrow ,\rightarrow$ {\tt :Goto error}) ou si vous voulez arr\^eter 
({\tt CL :Quit}),.\\
Vous répondez en appuyant sur une flèche : 
vous \^etes alors dans l'éditeur pr\^et à corriger votre erreur.\\
Attention!!!\\
- vous n'\^etes pas en mode insertion automatiquement (appuyer sur 
{\tt 2nd DEL (INS)} pour \^etre en mode insertion jusqu'au prochain
 {\tt 2nd DEL (INS)}).\\
-  il faut valider la ligne corrigée en changeant de ligne  
en appuyant par exemple sur $ \downarrow$.\\ 
Puis {\tt 2nd CL (QUIT)} vous fait revenir à l'écran {\tt HOME}.
\subsection{Comment exécuter un programme}
\subsubsection{Traduction MuPAD}
Vous s\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure| (qui calcule par exemple la moyenne de deux nombres cf exemple \ref{sec:exemple}). Vous pouvez maintenant calculer la moyenne des
deux entiers 5 et 13 en tapant:\\
\verb|ma_procedure(5,13);|\\
qui doit vous renvoyer \verb|9|.
\subsubsection{Traduction Casio}
Dans l'écran {\tt Program List} (au départ de l'écran {\tt HOME}
touche  {\tt MENU PRGM EXE} ou après avoir tapé le programme {\tt 2nd EXIT (QUIT)}), il suffit de mettre en surbrillance le nom du 
programme à exécuter et de taper sur {\tt F1} pour {\tt EXE} du bandeau 
(dernière ligne de l'écran o\`u se trouve un menu). 
\subsubsection{Traduction HP38 HP40G}
Pour exécuter un programme, on ouvre le catalogue de programmes en appuyant sur
 les touches {\tt shift 0 (PROGRAM)}.\\
 Il apparait alors un écran contenant la 
liste des programmes disponibles et un bandeau ({\tt EDIT NEW SEND RECV RUN}).\\
On met le nom du programme à exécuter en surbrillance et on appuie sur 
{\tt F6 (RUN)}.
\subsubsection{Traduction HP48 HP49G mode RPN}
Si le programme n'a pas de paramètres, il suffit de taper son nom dans la ligne de commande ou d'utiliser le menu {\tt VAR}.\\
S'il y a des paramètres, on met  les valeurs des paramètres sur la pile puis on
 tape le nom du programme.\\
Exemple :\\
{\tt 45 75 PGCD} 
\subsubsection{Traduction HP49G mode Algébrique} 
Si le programme n'a pas de paramètres, il suffit de taper son nom dans la ligne de commande ou d'utiliser le menu {\tt VAR}.\\
S'il y a des paramètres, on fait suivre le nom du programme de parenthèses
dans lesquelles on met  les valeurs des paramètres séparées par une virgule.\\
Exemple :\\
{\tt PGCD(45,75)}
\subsubsection{Traduction TI 80}
On appuie sur la touche {\tt PRGM}, on laisse en surbrillance {\tt EXEC}, et
on tape le numéro du programme à exécuter. 
\subsubsection{Traduction TI 83+}
On appuie sur la touche {\tt PRGM}, on laisse en surbrillance {\tt EXEC}, et
on tape le numéro du programme à exécuter. 
\subsubsection{Traduction TI89 92}
Si le programme n'a pas de paramètres, il suffit de taper son nom dans la ligne de commande.\\
S'il y a des paramètres, on fait suivre le nom du programme de parenthèses
dans lesquelles on met  les valeurs des paramètres séparées par une virgule.\\
Exemple :\\
{\tt PGCD(45,75)}
\subsubsection{Traduction SHARP EL9600}
On appuie sur la touche {\tt 2nd MATRIX (PRGM)}, on met en surbrillance {\tt EXEC}, et le programme à exécuter avec le stylet ou on utilise les flèches ou
on tape le numéro (à deux chiffres) du programme à exécuter. 
\subsection{Comment améliorer puis  sauver sous un autre nom un programme}
\subsubsection{Traduction MuPAD}
Si vous voulez avoir à la fois l'ancien et le nouveau programme il faut :\\
faire appara\^itre le texte de votre programme en ouvrant le menu 
\verb|Buffers| et  s\'electionner le nom de votre programme (\verb|prog1.mu|).\\
Vous pouvez corriger améliorer votre programme (pensez \`a changer le nom de la
 proc\'edure (par exemple \verb|ma_procedure2|), puis  sauvegarder votre correction dans le fichier \verb|prog2.mu| (par exemple) 
avec \verb|Save Buffer As...| du menu \verb|Files| : il faut alors donner le nom du nouveau fichier (ici \verb|prog2.mu|).\\
S\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog2.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure2|.
\subsubsection{Traduction Casio}
Dans l'écran {\tt Program List} ({\tt MENU PRGM EXE}), il suffit de mettre en 
surbrillance le nom du 
programme à changer et de taper sur {\tt F6} puis  {\tt F2} pour {\tt REN} 
(REName) du bandeau.\\ 
Mais cela ne duplique pas le programme!!! on doit donc tout retaper pour améliorer...
\subsubsection{Traduction HP38 HP40G}
Pour modifier un programme (sans vouloir sauver l'ancien) on ouvre le 
catalogue de programmes, en appuyant sur
 les touches {\tt shift 0 (PROGRAM)}. Il apparait alors un écran contenant la 
liste des programmes disponibles et un bandeau ({\tt EDIT NEW SEND RECV RUN}).\\
On met le nom du programme à modifier en surbrillance et on appuie sur 
{\tt F1 (EDIT)}.\\
Si vous voulez avoir à la fois l'ancien et le nouveau programme il faut :\\
-ouvrir le catalogue de programmes ({\tt shift 0 (PROGRAM)})\\
-appuyer sur {\tt F2 (NEW)} et taper le nom du programme modifié puis 
{\tt F6 (OK)}.\\
 L'éditeur s'ouvre, on appuie alors sur {\tt VAR} puis {\tt A..Z 5 (P)} pour mettre {\tt Program} en surbrillance.\\ Avec les fl\`eches mettre le nom du programme \`a modifier en surbrillance et appuyer sur {\tt F4 (VALUE)}
(pour cocher {\tt VALUE} du bandeau) puis {\tt F6 (OK)}.\\
 Cela recopie le texte du programme dans l'\'editeur. 
\subsubsection{Traduction HP48 HP49G mode RPN}
On tape :\\
   {\tt 'NOMDUPROGRAMME' RCL} puis {\tt edit} du bandeau.\\
On fait les améliorations et on fait suivre le dernier $\gg$ par :
 $${\tt 'NOUVEAUNOM'\ STO\triangleright}$$
\subsubsection{Traduction HP49G mode Algébrique} 
On tape :\\
   {\tt RCL('NOMDUPROGRAMME')} puis {\tt edit} du bandeau.\\
On fait les améliorations et on fait suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOUVEAUNOM}$$
\subsubsection{Traduction TI 80}
Je n'ai pas trouvé comment faire...
\subsubsection{Traduction TI 83+}
Vous commencez comme si vous alliez écrire un nouveau programme 
({\tt PRGM NEW} puis le nom du nouveau programme).\\
Vous \^etes alors dans l'éditeur, vous avez la possibilité d'éditer n'importe
 quel programme avec :\\
{\tt 2nd STO (RCL)} puis {\tt PRGM}, puis, mettre en surbrillance {\tt EXEC}
puis, le numéro du programme à rappeler.\\
 En bas de l'éditeur il s'écrit :
{\tt Rcl prgmPGCD} (par exemple).\\
 {\tt ENTER} ramène alors toutes les lignes du programme {\tt PGCD} dans 
l'éditeur. 
\subsubsection{Traduction TI89 92}
Vous ouvrez l'éditeur avec le programme que vous voulez améliorer puis  sauver
 sous un autre nom :\\
 {\tt APPS} puis {\tt 7 (Program Editor)} puis 
{\tt 2 (Open)} puis mettre le nom du programme à modifier dans  {\tt Variable} 
(appuyer sur {\tt ->} pour avoir accès à tous les noms de vos programmes, sélectionner celui à modifier avec les flèches et {\tt ENTER}),  puis {\tt ENTER}.\\
Ensuite, il suffit de taper sur  ${\tt \blacklozenge\ S}$ pour sauver cet éditeur sous un autre nom : {\tt SAVE COPY AS} (on met le nouveau nom dans 
{\tt Variable}).\\
Vous pouvez faire vos modifications puis   ${\tt \blacklozenge\ Q\ (HOME)}$
 vous sauve votre programme modifié sous le nouveau nom, 
et vous revenez à l'écran {\tt HOME}.
\subsubsection{Traduction SHARP EL9600}
On peut copier une ligne gr\^ace au sous menu {\tt COPY} du menu {\tt 2nd MATRIX (PRGM)} \\
On ne peut pas dupliquer un programme...on doit donc retaper pour améliorer...
\section{Les différentes instructions}
\subsection{Les commentaires}
Il faut prendre l'habitude de commenter les programmes. 
En algorithmique un commentaire commence par
{\tt // } et se termine par un passage à la ligne.
\subsubsection{Traduction MuPAD}
 un commentaire est entouré de deux {\tt \#} ou \\
commence par {\tt /*} et se termine par  {\tt */} ou\\
commence par {\tt //} et se termine par un passage à la ligne.\\
\# ceci est un commentaire \#\\
/* ceci est un commentaire */
//ceci est un commentaire
\subsubsection{Traduction Casio}
Il n'y en a pas!!!
\subsubsection{Traduction HP38 HP40G 48 49}
Le commentaire commence par :\\
{\tt @} et se termine par un passage à la ligne.\\
Pour la {\tt HP49G}, un commentaire commence par {\tt @} et se termine par un 
passage à la ligne ou est entouré de deux {\tt @}.\\
Le caractère {\tt @} est
obtenu en tapant {\tt shift-rouge ENTER}\\ 
Attention!!! le compilateur efface les commentaires... donc pour garder vos 
commentaires, il faut écrire votre programme sous la forme d'un texte qu'il 
faut ensuite compiler avec ${\tt STR\rightarrow}$ ce qui complique un peu...
\subsubsection{Traduction TI80 83+}
Il n'y en a pas!!!
\subsubsection{Traduction TI89 92}
Le commentaire commence par

{\tt {\copyright}} (F2 9) et se termine par un passage à la ligne.
%\subsubsection{Traduction Maple5}
%Un commentaire commence par {\tt \#} et se termine  par un passage à la lign
\subsubsection{Traduction SHARP EL9600} 
Les commentaires sont précédés de {\tt Rem} (que l'on trouve dans le sous menu
{\tt PRGM} du menu {\tt 2nd MATRIX (PRGM)} lorsqu'on est en train d'éditer un 
programme).
\subsection{Les variables}
\subsubsection{Leurs noms}
Ce sont les endroits o\`u l'on peut stocker des valeurs, des nombres, des expressions. Les noms des variables sont soit prédéfinis soit plus libres.\\
Par exemple chez {\tt CASIO, HP38 HP40G, TI80, TI83+ et SHARP-EL9600} on n'a droit qu'aux 26 lettres de l'alphabet pour stocker des nombres réels.\\
Mais avec {\tt MuPAD}, la {\tt TI 89}, la {\tt TI92}, la {\tt HP48} ou la {\tt HP49G} on peut utiliser des noms parfois limit\'es \`a  8 caractères.
\subsubsection{Notion de variables locales}
Cette notion n'existe pas pour les calculatrices {\tt CASIO, HP38 HP40G, TI80, TI83+ et SHARP-EL9600}.\\
Pour {\tt MuPAD} et les {\tt TI92 TI89} il faut définir les variables locales en début de programme en écrivant :\\
{\tt local a,b}\\
La {\tt HP48} ou {\tt HP49G} peut utiliser des variables locales.\\ 
Les  variables locales sont déclarées et initialisées (initialisation
 obligatoire!) gr\^ace à \  ${\tt \ \rightarrow}$ {\tt (shift-rouge 0)}\\
Pour la {\tt HP48} ou {\tt HP49G mode RPN} il faut définir et initialiser les variables locales en écrivant :
$${\tt \ll 1\ 2\ \rightarrow\  A\ B \ll corps\ du\  programme \gg \gg }$$
pour initialiser {\tt A} à 1 et {\tt B} à 2.\\
En mode {\tt RPN} on peut définir et initialiser plusieurs variables locales
à la fois (cf  exemple  ci-dessus).\\
Pour la  {\tt HP49G mode Algébrique}  chaque déclaration doit \^etre suivie par un sous programme (délimiteurs ${\tt \ll \gg}$) en écrivant :
$${\tt \ll 1\ \rightarrow\  A \ll 2\ \rightarrow\ B \ll corps\ du\  programme \gg \gg \gg}$$
La flèche doit \^etre entourée d'espaces, ces espaces sont mis automatiquement quand on n'est pas en mode {\tt Alpha}.\\
Exemple :
$${\tt \ll   3.14\  \rightarrow\  PI \ll 2*PI*R \gg \gg STO\triangleright \  PER}$$
Dans cet exemple, on a écrit le programme {\tt PER}.\\ {\tt PI} est une variable locale qui est déclarée et
 affectée par ${\tt 3.14 \ \rightarrow \ PI} $. Cette variable est locale pour le 
programme qui suit sa déclaration (ici ${\tt \ll 2*PI*R \gg}$). \\
Par contre, {\tt R} est une variable globale (qui doit exister avant
l'exécution du programme  {\tt PER}). Si, au cours d'un programme, on veut 
stocker une valeur dans une variable (locale ou globale) il faut bien s\^ur utiliser ${\tt STO\triangleright}$.
\subsubsection{Notion de paramètres}
Quand on écrit une fonction il est possible d'utiliser des paramètres.\\
Par exemple si {\tt A} et {\tt B} sont les paramètres de la fonction {\tt PGCD}  on écrit :\\
avec {\tt MuPAD}\\
 {\tt PGCD:=proc(A,B)}\\
{\tt begin}\\
....\\
{\tt end\_proc}\\
avec les calculatrices l'en t\^ete sera de la forme {\tt PGCD(A,B)}\\
Ces paramètres se comportent comme des variables locales, la seule différence 
est qu'ils sont initialisés lors de l'appel de la fonction. 
L'exécution  se fait en demandant par exemple :
{\tt PGCD(15,75)}\\
Il n'est pas possible d'écrire des fonctions sur toutes les calculatrices. \\
Pour les {\tt TI 89 92} on met le nom des paramètres dans le nom de la 
fonction  par exemple :\\
{\tt :addition(a,b)}\\
Par exemple, pour la {\tt HP48} ou {\tt HP49G mode RPN} si on veut que {\tt R}
 soit le paramètre de la fonction {\tt PER}  on écrit :
$${\tt \ll\ \rightarrow\ R \ll  3.14\ \rightarrow\ PI \ll 2\ PI\ *\ R\ *\ \gg \gg \gg 'PER'\ STO\triangleright}$$
L'exécution  se fait en demandant par exemple :
{\tt 5 PER}.\\
Pour la  {\tt HP49G mode Algébrique} si on veut que {\tt R} soit le paramètre 
de la fonction {\tt PER}  on écrit :
 $${\tt \ll\ \rightarrow\ R \ll  3.14\ \rightarrow\ PI \ll 2*PI*R \gg \gg \gg STO\triangleright \  PER}$$
L'exécution  se fait en demandant par exemple :
{\tt PER(5)}.\\
La  syntaxe des {\tt HP48} et {\tt HP49G} en mode {\tt RPN} et  en {\tt Algébrique} est :
$${\tt  \ll\ \ \rightarrow\ A \ B  \ll\ ...\gg \gg }$$
pour écrire une fonction à deux paramètres. 
{\bf Remarque}
Le langage de {\tt MuPAD} et des {\tt HP48/49} est fonctionnel puisque on peut 
passer des programmes ou des fonctions en param\`etre.
\subsection{Les Entrées}
Pour que l'utilisateur puisse entrer une valeur dans la variable {\tt A} au 
cours de l'exécution d'un programme, on écrira, en algorithmique :\\
{\tt saisir A}  \\
Et pour entrer des valeurs dans {\tt A} et {\tt B} on écrira :\\
{\tt saisir A,B}
\subsubsection{Traduction MuPAD}
\noindent{\tt input(''a='',a)}\\
{\tt input(''a='',a,''b='',b )}\\
mais la plupart des entr\'ees se font par passage de param\`etres.
\subsubsection{Traduction Casio}
\noindent{\tt "A="?->A:}
\subsubsection{Traduction HP38 HP40G}
\noindent{\tt INPUT A;"TITRE";"A=";;0:}
\subsubsection{Traduction HP48 HP49G mode RPN}
\noindent{\tt "A" "" INPUT STR-> EVAL 'A' STO}\\
ou pour la {\tt HP49G mode RPN}\\
{\tt 'A' PROMPTSTO}\index{PROMPTSTO} 
\subsubsection{Traduction HP49G mode Algébrique} 
Pour entrer une variable {\tt A},  on \'ecrit :\\
{\tt ...PROMPTSTO('A')}
%Pour entrer une variable locale {\tt A},  on tape :\\
%${\tt ....0\ \rightarrow \ A \ll\  PROMPTSTO('A')... \gg}$ ou\\
%$ {\tt....0\ \rightarrow \ A \ll \  PROMPTSTO('A');0\ \rightarrow \ B \ll PROMPTSTO('B').....\gg \ \gg}$\\
%Si on tape seulement:\\
%{\tt ...PROMPTSTO('A')} alors {\tt A} est une variable globale ou\\
% {\tt ...PROMPTSTO('A'); PROMPTSTO('B')}, alors {\tt A} et {\tt B} sont des variables globales.\\
%On peut aussi utiliser {\tt INPUT}\index{INPUT} pour créer une variable locale {\tt A}.\\
 %On utilise, si {\tt A} doit contenir une chaine de caractères : 
%$${\tt INPUT(''A='',''\ '')\ \rightarrow\ A}$$
%ou  si {\tt A} doit contenir un nombre :\\
%${\tt .....INPUT(''A='',''\ '')\rightarrow A}$\\
 %        ${\tt \ll OBJ\rightarrow(A)\ \rightarrow\ A}$\\
 %          ${\tt \ll .....\gg }$\\
  %       ${\tt \gg  }$
\subsubsection{Traduction TI 80, 82, 83, 83+, 89, 92}
\noindent {\tt:Prompt A}\\
{\tt :Prompt A,B}\\
ou encore  :\\
{\tt:Input ``A='',A}
\subsubsection{Traduction SHARP EL9600}
\noindent{\tt Input A}\\
%Pour faire deux entr\'ees cons\'ecutives on doit \'ecrire :\\ {\tt Input A}\\{\tt Input B}\\
La machine met alors automatiquement {\tt A=?} (ou {\tt A=?} puis {\tt B=?}).
\subsection{Les Sorties}
En algorithmique on écrit :\\
{\tt Afficher "A=",A}
\subsubsection{Traduction MuPAD}
{\tt print("A=",A)}\\
Il fait savoir que lorsqu'une proc\`edure est appel\'ee, la suite d'instructions entre 
{\tt begin} et {\tt end\_proc} est ec\'ecut\'ee, et le r\'esultat est \'egal au
 r\'esultat de la derni\`ere \'evaluation.
 
\subsubsection{Traduction Casio}
\noindent{\tt "A=":A $\triangle$}\\ 
{\tt ClrText} efface l'écran.\\
{\tt $\triangle$ }
 arr\^ete l'affichage et sert aussi de fin d'instruction.
\subsubsection{Traduction HP38 HP40G}
\noindent{\tt DISP 3;"A="A:} 3 représente le numéro de la ligne o\`u {\tt A} sera affiché \\
ou\\
{\tt MSGBOX "A="A:}\\
{\tt ERASE:}  efface l'écran.\\
{\tt FREEZE:} g\`ele l'affichage.
\subsubsection{Traduction HP48 ou HP49G mode RPN}
En général on affiche simplement les résultats sur la pile pour une
 réutilisation éventuelle, on écrira simplement :\\
{\tt A B}\\
On peut aussi afficher le résultat tagué, on écrira alors :\\
{\tt A "A=" ->TAG}\\
{\tt HALT} arr\^ete le programme et {\tt Shift-rouge ON (CONT)} le continue.
\subsubsection{Traduction HP49G mode Algébrique} 
Seul le dernier résultat s'inscrit dans l'historique.\\
Pour des résultats intermédiaires on tape :
$$ {\tt DISP("A="+A,3)}$$\index{DISP}
 3 représente le numéro de la ligne\\
ou\\
$${\tt MSGBOX( "A="+\rightarrow STR(A))}$$\index{MSGBOX}
(ici le {\tt +} effectue la concaténation de deux chaines de caractères)\\
{\tt CLLCD()}  efface l'écran.\index{CLEAR}\\
{\tt FREEZE(7)}  g\`ele l'affichage et permet de visualiser les 7 lignes de l'affichage.\index{FREEZE}
\subsubsection{Traduction TI 80 82 83 83+ 89 92}
\noindent{\tt :Disp "A=",A}\\
{\tt :ClrIO} efface l'écran.\\
{\tt :ClrHome} efface l'écran pour la {\tt TI 83+}.\\
{\tt :Pause} arr\^ete le programme (on appuie sur {\tt ENTER} pour reprendre l'exécution).
%\subsubsection{Traduction Maple}
%{\tt print(A):}
\subsubsection{Traduction SHARP EL9600}
\noindent{\tt Print A} affiche la valeur de {\tt A}\\
ou {\tt Print ''A} affiche {\tt A}, puis\\
{\tt Print A} affiche la valeur de {\tt A}
\subsection{La séquence d'instructions ou action}
Une action est une séquence d'une ou plusieurs instructions.\\
En langage algorithmique, on utilisera l'espace ou le passage à la ligne pour 
terminer une instruction.
\subsubsection{Traduction MuPAD}
Le {\tt\ ;\ } est un séparateur d' instructions.\\ 
\subsubsection{Traduction Casio}
A la fin d'une instruction, il faut mettre un séparateur qui peut \^etre :\\
{\tt  le retour à la ligne} ou {\tt :} ou ${\tt \triangle}$
\subsubsection{Traduction HP38 HP40G}
\noindent {\tt:} indique la fin d'une instruction.
\subsubsection{Traduction HP48 ou HP49G mode RPN}
Comme en algorithmique, le séparateur est soit {\tt l'espace} soit {\tt le retour à la ligne}.
\subsubsection{Traduction HP49G mode Algébrique} 
Pour la {\tt HP49G}, le {\tt\ ;\ } est un séparateur d' instructions.\\ 
Le {\tt ;} s'obtient
en tapant en m\^eme temps sur {\tt shift-rouge SPC}.
\subsubsection{Traduction TI 83+ 89 92}
\noindent {\tt:} indique la fin d'une instruction. Il faut noter qu'à chaque passage à la ligne le  {\tt:} est mis automatiquement.
\subsubsection{Traduction SHARP EL9600}
C'est {\tt ENTER} qui est utilisé comme séparateur d'instructions.\\
Chaque instruction doit \^etre écrite  sur une seule ligne.
%\subsubsection{Traduction Maple5}
%: indique la fin d'une instruction
\subsection{L'instruction d'affectation}
L'affectation est utilisée pour stocker une valeur ou une expression dans une 
variable.\\
En algorithmique on écrira par exemple :
{\tt 2*A->B}\\
pour stocker {\tt 2*A} dans {\tt B}\\
Les calculatrices {\tt CASIO, HP38 HP40G, TI80, TI83+, TI89, TI92 et SHARP-EL9600} utilisent cette notation.\\ 
Selon les cas, la flèche est obtenue à l'aide de la touche  ${\tt STO}$ ou de la
touche ${\tt \rightarrow}$\\
Avec la {\tt HP48} ou {\tt  HP49G mode RPN}, il faut utiliser la notation postfixée et la commande {\tt STO} :\\
{\tt 2 A * 'B' STO}\\
Pour la {\tt HP49G mode Algébrique}, on utilise  la touche ${\tt STO}$ qui se 
traduit à l'écran  de la calculatrice par : 
$ \triangleright $  (que l'on  notera : ${\tt STO\triangleright}$)\\
Pour la {\tt SHARP EL9600}, on utilise  la touche ${\tt STO}$ qui se traduit à 
l'écran  de la calculatrice par : 
$ \Rightarrow $ \\
%Avec Maple on écrira :
%{\tt B:=2*A}
{\sc Attention}\\
Avec {\tt MuPAD} on \'ecrit :\\
{\tt b:=2*a} pour stocker {\tt 2*a} dans {\tt b}.
\subsection{Les instructions conditionnelles}
\noindent{\tt Si \emph{condition} alors
\emph{action}
fsi}\\
{\tt Si \emph{condition} alors
\emph{action1} sinon
\emph{action2}
fsi}\\ 
Exemple :\\
{\tt Si A = 10 ou A < B alors B-A->B sinon A-B->A fsi}
\subsubsection{Traduction MuPAD}
\noindent{\tt if \emph{condition}
 then 
\emph{action}  
end\_if}\\
{\tt if \emph{condition} then 
\emph{action1}  else 
\emph{action2}
end\_if}\\
Exemple :\\
{\tt if a = 10 or A < B then  b:=b-a else  a:=a-b end\_if}\\
Lorsque il y a plusiuers {\tt if else} \`a la suite on \'ecrit {\tt elif} au
lieu de  {\tt else if}.
\subsubsection{Traduction Casio}
\noindent{\tt If \emph{condition}
 :Then 
\emph{action} : 
IfEnd:}\\
{\tt If \emph{condition} :Then 
\emph{action1} : Else :
\emph{action2}:
IfEnd:}\\
Exemple :\\
{\tt If A = 10 Or A < B :Then  B-A->B : Else : A-B->A : IfEnd:}
\subsubsection{Traduction HP38 HP40G}
\noindent{\tt IF \emph{condition} THEN 
\emph{action} : 
END:}\\
{\tt IF \emph{condition} THEN 
\emph{action1} : ELSE
\emph{action2}:
END:}\\
Exemple (Attention au == pour traduire la condition d'égalité) :\\
{\tt IF A == 10 OR A < B THEN B-A->B : ELSE A-B->A : END:}
\subsubsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt IF \emph{condition} THEN 
\emph{action}  
END}\\
{\tt IF \emph{condition} THEN 
\emph{action1}  ELSE
\emph{action2}
END}\\
Attention on utilise la notation postfixée et == pour traduire la 
condition d'égalité.\\
On écrit pour traduire l'exemple :\\
{\tt IF A 10 ==  A B < OR THEN
 B A - 'B' STO 
ELSE A B - 'A' STO END}\\
on peut aussi  écrire :\\
{\tt IF '(A==10) OR (A < B)'  THEN ...}
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt IF \emph{condition} THEN 
\emph{action}  
END}\\
{\tt IF \emph{condition} THEN 
\emph{action1}  ELSE
\emph{action2}
END}\\
Exemple (Attention au == pour traduire la condition d'égalité) :\\
{\tt IF A == 10 OR A < B THEN B-A STO$\triangleright$ B  ELSE A-B STO$\triangleright$ A  END}
\subsubsection{Traduction TI80}
\noindent{\tt:If \emph{condition} :Then :
\emph{action} : 
End}\\
{\tt :If \emph{condition} :Then :
\emph{action1} : Else :
\emph{action2}:
End}\\
Exemple :\\
Attention {\tt or} n'existepas il faut donc écrire (cf p \pageref{sec:oplog}) :
{\tt :IF A = 10 :THEN : B-A->B :ELSE :IF A<B :THEN : B-A->B :ELSE : A-B->A :END :END}
\subsubsection{Traduction  TI82 83+}
\noindent{\tt:If \emph{condition} :Then :
\emph{action} : 
End}\\
{\tt :If \emph{condition} :Then :
\emph{action1} : Else :
\emph{action2}:
End}\\
Exemple :\\
{\tt :If A = 10 or A < B : Then : B-A->B : Else : A-B->A : End}
\subsubsection{Traduction TI89 92}
\noindent{\tt:If \emph{condition} Then :
\emph{action} : 
EndIf}\\
{\tt :If \emph{condition} Then :
\emph{action1} : Else :
\emph{action2}:
EndIf}\\
Exemple :\\
{\tt :If A = 10 or A < B Then : B-A->B : Else : A-B->A : EndIf}
%\subsubsection{Traduction Maple5}
%{\tt if \emph{condition} 
%then \emph{action}: 
%fi};
%{\tt if \emph{condition} 
%then \emph{action1}: 
%else \emph{action2}:
%fi}; 
\subsubsection{Traduction SHARP EL9600}
\noindent{\tt If \emph{non condition} Goto FSI}\\
{\tt \emph{action}}\\
{\tt Label FSI}\\

\noindent{\tt If \emph{non condition} Goto SINON}\\
{\tt \emph{action1}}\\ 
{\tt Goto FSI}\\
{\tt Label SINON}\\
{\tt \emph{action2}}\\
{\tt Label FSI}
\subsection{Les instructions "Pour" }
\noindent{\tt Pour I de A à B faire \emph{action} fpour}\\
{\tt Pour I de A à B (pas P) faire \emph{action} fpour}
\subsubsection{Traduction MuPAD}
\noindent{\tt for i from a to b do \emph{action} end\_for}\\
{\tt for i from b downto a do \emph{action} end\_for}\\
{\tt for i from a to b step p do  \emph{action} end\_for }\\
Vous pouvez aussi ouvrir le menu {\tt MuPAD} sous menu {\tt Shapes} et 
s\'el\'ectionner {\tt for}.
\subsubsection{Traduction Casio}
\noindent{\tt For A->I To B : \emph{action} : Next}\\
{\tt For A->I To B  Step P : \emph{action} : Next}
\subsubsection{Traduction HP38 HP40G}
\noindent{\tt FOR I = A TO B STEP 1 ; \emph{action} : END:}\\
{\tt FOR I = A TO B STEP P ; \emph{action} : END:} 
\subsubsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt A B FOR I  \emph{action} NEXT}\\ 
{\tt A B FOR I  \emph{action} P STEP}
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt FOR (I, A, B) \emph{action} NEXT}\\
{\tt FOR (I, A, B ) \emph{action} STEP P}\\ 
L'instruction {\tt FOR} déclare {\tt I} comme  variable locale et l'initialise
 automatiquement. 
\subsubsection{Traduction TI80 TI82 83+}
\noindent{\tt :For (I,A,B ): \emph{action} : End}\\
{\tt:For (I,A,B,P ): \emph{action} : End}
\subsubsection{Traduction TI89 92}
\noindent{\tt :For I,A,B : \emph{action} : EndFor}\\ 
{\tt:For I,A,B,P : \emph{action} : EndFor}
%\subsubsection{Traduction Maple5}
%{\tt for I from A to B do 
%\emph{action}: 
%od}
\subsubsection{Traduction SHARP EL9600} 
\noindent${\tt A \Rightarrow I}$\\
{\tt Label DPOUR}\\
{\tt If I>B Goto FPOUR}\\
{\tt \emph{action1}}\\
${\tt I+1 \Rightarrow I}$\\ 
{\tt Goto DPOUR}\\
{\tt Label FPOUR}
\subsection{L'instruction ``Repeter''}
\noindent{\tt Repeter
\emph{action}
 jusqua \emph{ condition}} 
\subsubsection{Traduction MuPAD}
\noindent{\tt repeat  
\emph{action} 
until \emph{ condition} end\_repeat}
\subsubsection{Traduction Casio}
\noindent{\tt Do : 
\emph{action}: 
LpWhile \emph{ condition}}
\subsubsection{Traduction HP38 HP40G}
\noindent{\tt DO  
\emph{action} : 
UNTIL \emph{condition} 
END:}
\subsubsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt DO  
\emph{action} 
UNTIL \emph{condition} 
END}
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt DO 
\emph{action} 
UNTIL \emph{condition} 
END}
\subsubsection{Traduction TI80}
\noindent{\tt :LBL 1}\\
{\tt :\emph{action} :IF  \emph{non condition} :THEN 
:GOTO 1\\ :END} 
\subsubsection{Traduction TI82 83+}
\noindent{\tt :Repeat \emph{condition}  :
\emph{action} : 
End}
\subsubsection{Traduction TI89 92}
\noindent{\tt :Loop  
:\emph{action} 
:If \emph{condition}  :Exit 
:EndLoop}
%\subsubsection{Traduction Maple5}
%{\tt while  \emph{condition} do 
%\emph{action}: 
%od}: 
\subsubsection{Traduction SHARP EL9600} 
\noindent{\tt Label REPETER}\\
{\tt \emph{action}}\\
{\tt If \emph{non condition} Goto REPETER}
\subsection{L'instruction ``Tant que''}
\noindent{\tt Tant que \emph{condition} faire
\emph{action}
ftantque}
\subsubsection{Traduction MuPAD}
\noindent{\tt while  \emph{condition} do
\emph{action}  
end\_while}
Vous pouvez aussi ouvrir le menu {\tt MuPAD} sous menu {\tt Shapes} et 
s\'el\'ectionner {\tt while}.
\subsubsection{Traduction Casio}
\noindent{\tt While  \emph{condition} : 
\emph{action} : 
WhileEnd:}
\subsubsection{Traduction HP38 HP40G}
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} : 
END:}
\subsubsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsubsection{Traduction TI80}
\noindent{\tt :LBL 1}\\
{\tt :IF  \emph{condition} :THEN :\emph{action}\\
:GOTO 1\\ :END} 
\subsubsection{Traduction TI82 83+}
\noindent{\tt :While  \emph{condition}  :
\emph{action} : 
End}
\subsubsection{Traduction TI89 92}
\noindent{\tt :While  \emph{condition}  :
\emph{action} : 
EndWhile}
%\subsubsection{Traduction Maple5}
%{\tt while  \emph{condition} do 
%\emph{action}: 
%od}: 
\subsubsection{Traduction SHARP EL9600} 
\noindent{\tt Label DTANTQUE}\\
{\tt If \emph{non condition} Goto FTANTQUE}\\
{\tt \emph{action}}\\
{\tt Goto DTANTQUE }\\
{\tt Label FTANTQUE}
\subsection{Les conditions ou expressions booléennes }
Une condition est une fonction qui a comme valeur un booléen, à savoir elle
est soit {\tt vraie} soit {\tt fausse}.
\subsubsection{Les opérateurs relationnels}
Pour exprimer une condition simple on utilise les opérateurs :\\
{\tt = > > $\leq$  $\geq$  $\neq$}\\
Attention pour les calculatrices HP l'égalité se traduit comme en langage {\tt C} par :\\
{\tt ==}
\subsubsection{Les opérateurs logiques}
Pour traduire des conditions complexes, on utilise les opérateurs logiques :\\
{\tt ou et non} \\
qui se traduisent sur les calculatrices et en {\tt MuPAD} par :\\
{\tt or and not} \\
Attention!!! \label{sec:oplog}
Je ne les ai pas trouvés sur la {\tt TI80} et il faut alors traduire :\\
{\tt Si \emph{condition1} et \emph{condition2} alors
\emph{action1} sinon
\emph{action2}
fsi}\\ 
par :\\
{\tt :IF \emph{condition1} :THEN :IF \emph{condition2}  :THEN \\
:\emph{action1} :ELSE :\emph{action2} :END \\
:ELSE :\emph{action2} :END}\\
{\tt Si \emph{condition1} ou \emph{condition2} alors
\emph{action1} sinon
\emph{action2}
fsi}\\ 
par :\\
{\tt :IF \emph{condition1} :THEN  \\
:\emph{action1} :ELSE :IF \emph{condition2}  :THEN :\emph{action1} \\
:ELSE :\emph{action2} :END :END}\\
Chez {\tt Sharp} il faut parenthéser et écrire (A) or (B) par exemple.
\subsection{Les fonctions}
Dans une fonction on ne fait pas de saisie de données :
on utilise des paramètres qui seront initialisés lors de l'appel.\\
Dans une fonction on veut pouvoir réutiliser le résultat :\\
on n'utilise pas la commande {\tt affichage} mais la commande {\tt retourne}.\\
On écrit par exemple en algorithmique :
\begin{verbatim}
fonction addition(A,B)
retourne A+B
ffonction
\end{verbatim}
Cela signifie que 
%-Si on fait exécuter la fonction, ce qui se trouve apr\`es {\tt retourne} sera affiché.\\
l'on peut utiliser la fonction dans une expression.\\
On ne peut pas écrire de fonctions avec les calculatrices {\tt Casio SHARPEL9600 HP38 HP40G TI83+}.
\subsubsection{Traduction MuPAD}
On écrit par exemple en {\tt MuPAD} ({\tt retourne} se traduit par {\tt return}) :
\begin{verbatim}
addition:=proc(a,b)
begin
return(a+b)
end_proc:
\end{verbatim}
{\sc Remarque} : {\tt return} fait sortir imm\'ediatement de la fonction.
\subsubsection{Traduction HP48 ou HP49G mode RPN}
Pour la  {\tt HP48} ou la {\tt HP49G mode RPN}, on suppose que les arguments de la fonction
 sont mis sur la pile avant l'appel de la fonction.\\
Dans l'écriture de la fonction les arguments sont  des variables locales
qui seront initialisées par les élements mis sur la pile. Le résultat de la 
fonction est alors mis sur la pile.\\
 L'exemple se traduit par :\\
${\tt \ll \rightarrow\ A\ B}$\\
${\tt \ \ \ll\ A\ B\ +\ \gg}$\\
${\tt  \gg}$\\
{\tt 'ADDITION' STO}\\ 
puis on met les valeurs de A et B au niveau 1 et 2 de  la pile, aprés 
l'exécution d'{\tt ADDITION} leur somme se trouvera au niveau 1 de la pile.\\
{\bf N.B.}pour des fonctions simples, on peut \'eviter les variables locales 
par exemple ${\tt \ll\  +\ \gg}$ {\tt 'ADDITION' STO}   
\subsubsection{Traduction HP49G mode Algébrique} 
Pour la {\tt HP49G} :\\
 L'exemple se traduit par :\\
${\tt \ll \rightarrow\ A\ B} $\\
${\tt \ \ \ll A +B \gg}$\\ 
${\tt  \gg}$\\
${\tt  STO\triangleright\ ADDITION}$\\
Puis, on tape : $${\tt ADDITION(4,5)}$$
\subsubsection{Traduction TI89 92}
\begin{verbatim}
:addition(a,b)
:Func
:Return a+b
:EndFunc
\end{verbatim}
%\subsubsection{Traduction Maple5}
%\begin{verbatim}addition:= proc(a,b):
%RETURN a+b:
%end:\end{verbatim}
\subsection{Les listes}
On utilise les \{ \} pour délimiter une liste.\\
Attention!!!
En algorithmique on a choisit cette notation car c'est celle qui est employée
par les calculatrices...à ne pas confondre avec la notion d'ensemble en
 mathématiques : dans un ensemble l'ordre des éléments n'a pas d'importance
mais dans une liste l'ordre est important...
 Par exemple \{\} désigne la liste vide et \{1, 2, 3\} est une liste de 3 éléments.\\
{\tt append} sera utilis\'e pour concaténer 2 listes ou une liste et un élément ou 
un élément et une liste :\\
{\tt \{1, 2, 3\}->TAB}\\
{\tt append(TAB, 4) ->TAB}  (maintenant {\tt TAB} désigne \{1, 2, 3, 4\} \\
{\tt TAB[2]} désigne le deuxième élément de {\tt TAB} ici 2.
\subsubsection{Traduction MuPAD}
Une liste est une suite d'expressions entre un crochet ouvrant [ et un crochet 
fermant ].\\
{\tt [ ]} d\'esigne la liste vide.\\
Exemple :\\
{\tt l:=[1,2,2,3]}\\
{\tt nops(l)} renvoie le nombre d'\'elements de la liste {\tt l}.\\
{\tt l[1]} ou {\tt op(l,1)} renvoie le premier \'element de la liste {\tt l} : les 
\'elements sont num\'erot\'es de 1 \`a {\tt nops(l)}.\\
{\tt op(l)} renvoie {\tt 1,2,2,3}\\
{\tt append(l,4)} ajoute l'\'element 4 \`a la fin de la liste {\tt l}.\\
De plus les listes peuvent \^etre concat\'en\'ees  avec {\tt .} ([1,2].[2,3]=[1,2,2,3]).\\
{\tt Attention} une suite d'expressions entre une accolade ouvrante \{ et une 
accolade fermante \} désigne un ensemble.\\
Exemple :\\
{\tt A:=\{a,b,c\} B:=\{a,d\}} alors {\tt A union B} d\'esigne {\tt \{a,b,c,d\}}\\
{\tt A intersect B} d\'esigne {\tt \{a\}}\\
{\tt A minus B} d\'esigne {\tt \{b,c\}}
\subsubsection{Traduction Casio}
Les variables listes ont pour noms : {\tt List 1, List 2, ... List 6}.\\
Pour travailler avec des listes, il faut donner au départ le nombre d'éléments
 de la liste avec la commande {\tt Dim List} par exemple :\\
{\tt 10->Dim List 1} ({\tt List 1} désigne alors une liste de 10 éléments nuls).\\
On peut utiliser les commandes suivantes :\\
{\tt seq(i*i, i, 1, 10, 2)} désigne la liste des carrés des 5 premiers entiers impairs. \\
{\tt List 1[i]} désigne le ième élément de la liste {\tt List 1}.
\subsubsection{Traduction HP38 HP40G}
Ici les listes peuvent avoir des longueurs non définies à l'avance.\\
Les variables listes ont pour noms : {\tt L0, L1, L2, ... L9}.\\
On utilise les \{ \} pour délimiter une liste.\\
Par exemple \{1, 2, 3\} est une liste de 3 éléments.\\
 Mais \{\} ne désigne pas la liste vide, il faut utiliser la commande :\\
{\tt CLEAR L1} pour initialiser la liste {\tt L1} à vide pour la {\tt HP38G}) et\\
{\tt SYSEVAL 259588} pour initialiser la liste {\tt L0}  à vide  (ou {\tt SYSEVAL 259589} pour initialiser {\tt L1} à vide  etc pour la ({\tt HP40G}).\\
Voici quelques commandes utiles :\\
{\tt MAKELIST(I*I, I , 1, 10, 2)}  désigne la liste des carrés des 5 premiers entiers impairs ( 2 indique le pas de {\tt I}). \\
{\tt L1(I)}  désigne le {\tt I}ème élément de la liste.\\
{\tt CONCAT (L1, \{5\})} désigne une liste ayant l'élément 5 en plus des éléments de la liste {\tt L1}.\\
{\tt AUGMENT} n'existe que sur la {\tt HP40G} et concat\'ene deux listes ou une liste et un élément.
\subsubsection{Traduction HP48 ou HP49G mode RPN}
Ici les listes peuvent avoir des longueurs non définies à l'avance.\\
On utilise les \{\} pour délimiter une liste.\\
Par exemple \{1 2 3\} est une liste de 3 éléments et \{\} désigne la liste vide.\\
On obtient le {\tt P}ième élément de {\tt L} sur la pile  avec :\\
{\tt L P GET}\\
Si on veut modifier le {\tt P}ième élément de {\tt L} (par exemple le mettre à 0)  on écrira :\\
{\tt 'L' P 0 PUT} ou {\tt L P 0 PUT 'L' STO}\\
En effet {\tt L P 0 PUT} renvoie sur la pile la liste modifiée alors que :\\
{\tt 'L' P 0 PUT}
modifie la liste {\tt L}.\\
Pour concaténer deux listes ou une liste et un élément on utilise le {\tt +}
 ou  on utilise la commande {\tt AUGMENT}.
\subsubsection{Traduction HP49G mode Algébrique} 
Pour la {\tt HP49G} en mode algébrique, les listes peuvent avoir des longueurs non définies à l'avance.\\
On utilise les \{\} pour délimiter une liste.\\
Par exemple \{1 2 3\} est une liste de 3 éléments et \{\} désigne la liste vide.\\
On obtient le {\tt P}ième élément de {\tt L } sur la pile  avec :\\
 {\tt L[P]} ou {\tt L(P)} ou
{\tt GET (L, P )}\\
Si on veut modifier le {\tt P}ième élément de {\tt L} (par exemple le mettre à 0)  on écrira :\\
{\tt PUT(L, P, 0) STO$\triangleright$ L }\\
ou\\
{\tt  PUT('L', P, 0)}\\
En effet {\tt PUT(L, P, 0)} renvoie  la liste modifiée (sans modifier {\tt L}) 
alors que :\\
{\tt PUT ('L', P, 0) } modifie la liste {\tt L}.\\
Pour concaténer deux listes ou une liste et un élément on utilise le  {\tt +} 
(et pour ajouter deux listes de m\^emes longueurs on utilise la commande {\tt ADD}) ou  on utilise la commande {\tt AUGMENT}..\\
La commade {\tt SEQ} permet de constituer une liste, on tape :
$${\tt SEQ('X*X','X',4,10,1)}$$
on obtient :
$${\tt \{16,25,36,49,64,81,100\}}$$
\subsubsection{Traduction TI80}
Les variables listes ont comme noms {\tt L1, L2, L3, L4, L5, L6}.\\
La commande {\tt DIM} permet de créer une nouvelle liste (faite de zéros) ou 
de redimensionner une liste existante (numéro 3 du menu {\tt OPS} de la 
touche {\tt 2nd STAT (LIST)}), par exemple :\\
${\tt N ->DIM\ L1}$  : il y a deux possibilités,\\
soit ${\tt L_1}$ n'existait pas alors ${\tt L_1}$ est créée  et contient une liste de zéros de longueur {\tt N}, \\ 
 soit  ${\tt L_1}$ existait, cette commande donne  alors à  ${\tt L_1}$ la dimension
{\tt N}  (soit en supprimant des termes, soit en rajoutant des zéros).\\
La commande {\tt SEQ} permet de générer une liste (numéro 4 du menu 
{\tt OPS} de la touche {\tt 2nd STAT (LIST)}) :\\
${\tt SEQ(X^2, X, 0, 10, 2) ->L1}$  va par exemple créer la liste :\\
\{0, 4, 16, 36, 64, 100\} c'est à dire la liste des carrés de 0 à 10 avec un 
pas de 2 que l'on stocke dans {\tt L1}.\\
\subsubsection{Traduction TI83+}
Les variables listes ont des noms prédéfinis ${\tt L_1, L_2, L_3, L_4, L_5, L_6}$ ou bien peuvent avoir
un nom de 1 à 5 caractères mais alors il faudra faire précéder ce nom du 
symbole $\llcorner$ (que l'on trouve dans {\tt 2nd LIST OPS B}) pour désigner
 cette variable.\\ 
Mais \{\} ne désigne pas la liste vide, il faut utiliser la commande :\\
${\tt ClrList L_1}$ (en position 4 du menu {\tt EDIT} de la touche {\tt STAT})
 vide la liste ${\tt L_1}$ (attention !!! dans un programme cela
n'initialise pas la liste ${\tt L_1}$ à vide).\\
La commande {\tt dim} permet de créer une nouvelle liste (faite de zéros) ou 
de redimensionner une liste existante (en position 3 du menu {\tt OPS} de la 
touche {\tt 2nd STAT (LIST)}) :\\
${\tt N ->dim(L_1)}$ : il y a deux possibilités,\\
soit ${\tt L_1}$ n'existait pas alors ${\tt L_1}$ est créée  et contient une liste de zéros de longueur {\tt N}, \\ 
 soit  ${\tt L_1}$ existait, cette commande donne  alors à  ${\tt L_1}$ la dimension
{\tt N}  (soit en supprimant des termes, soit en rajoutant des zéros).\\
La commande {\tt seq} permet de générer une liste (en position 5 du menu 
{\tt OPS} de la touche {\tt 2nd STAT (LIST)}) :\\
${\tt seq(X^2, X, 0, 10, 2) ->TAB}$  va par exemple créer la liste :\\
\{0, 4, 16, 36, 64, 100\} c'est à dire la liste des carrés de 0 à 10 avec un 
pas de 2 que l'on stocke dans {\tt TAB}.\\
${\tt \llcorner TAB(2)}$ désigne le deuxième élément de {\tt TAB} ici 4.\\
On peut aussi écrire :\\
${\tt 2->\llcorner TAB(2)}$ \\
La liste {\tt TAB} est alors \{0, 2, 16, 36, 64, 100\}\\
ou si  ${\tt L_1}$ est de longueur {\tt N}  on peut rajouter un élément (par 
exemple 25) à  ${\tt L_1}$ en écrivant :\\
${\tt 25 -> L_1(N+1)}$ \\
{\tt augment} permet de concaténer deux listes (en position 9 du menu
 {\tt OPS} de la touche {\tt 2nd STAT (LIST)}).
\subsubsection{Traduction TI89-92}
{\tt augment} permet de concaténer deux listes.\\
\{\}  désigne la liste vide.
Pour travailler avec des listes, on peut  initialiser une  liste de
 {\tt n} éléments  avec la commande {\tt newlist},  par exemple :\\
{\tt newlist(10)->L} ({\tt L} est alors une liste de 10 éléments nuls).\\
On peut utiliser les commandes suivantes :\\
{\tt seq(i*i, i, 1, 10)} qui désigne la liste des carrés des 10 premiers entiers, ou {\tt seq(i*i, i, 0, 10, 2)} qui désigne la liste des carrés des 5 premiers entiers pairs (le pas est ici égal à 2). \\
Exemple :\\
${\tt seq(i*i, i, 0, 10, 2) ->L}$  va par exemple créer la liste :\\
\{0, 4, 16, 36, 64, 100\} c'est à dire la liste des carrés de 0 à 10 avec un 
pas de 2 que l'on stocke dans {\tt L}.\\
{\tt L[i] } qui désigne le ième élément de la liste {\tt L}.\\
On peut aussi écrire :\\
{\tt 2->L[2]} \\
La liste {\tt L} est alors \{0, 2, 16, 36, 64, 100\}\\
ou si  ${\tt L}$ est de longueur {\tt n}  on peut rajouter un élément (par 
exemple 121) à  ${\tt L}$ en écrivant :\\
{\tt 121 -> L[n+1]} \\
Dans l'exemple précédent {\tt n=6} on peut donc écrire :\\
{\tt 121 -> L[7]} ({\tt L} est alors égale à \{0, 2, 16, 36, 64, 100, 121\}).\\
{\tt left (L, 5)} désigne les 5 premiers éléments de la liste {\tt L}.
%\subsubsection{Traduction Maple5}
%On utilise la notion de séquence : une séquence est une suite d'éléments
% séparés par des virgules.\\
%On écrit :\\
%{\tt S:=NULL:} (pour la séquence vide)
%{\tt S:=S,A:} (pour ajouter un élément à S)
%Une liste est une séquence entourée de crochets :\\
%{\tt L:=[S]:}
%{\tt L[i]} est le iéme élément de la liste L.\\
%On peut aussi revenir à la séquence :
%{\tt S:=op(L):}
%{\tt nops(L)} est égal à la longueur de la liste L.
\subsubsection{Traduction SHARP EL9600} 
Ici les listes peuvent avoir des longueurs non définies à l'avance.\\
Les variables listes ont pour noms : {\tt L1, L2, L3...L6}.\\
On utilise les \{ \} pour délimiter une liste.\\
Par exemple \{1, 2, 3\} est une liste de 3 éléments.\\
 Mais \{\} ne désigne pas la liste vide, il faut utiliser la commande :\\
{\tt ClrList L1} (en position 4 dansle menu {\tt OPE} de {\tt STAT}) qui vide
 la liste {\tt L1} (attention !!! dans un programme cela
n'initialise pas la liste {\tt L1} à vide).\\
Voici quelques commandes utiles :\\
{\tt seq} qui se trouve en position 5 dans le sous menu {\tt OPE} de ${\tt 2nd \times (LIST)}$ :\\
{\tt seq(X*X, 1, 10, 2)} qui désigne la liste des carrés des 5 premiers 
entiers impairs ( 2 indique le pas de la variable qui est toujours {\tt X}). \\
{\tt L1(I)}  désigne le {\tt I}ème élément de la liste.\\
{\tt augment(L1, \{5\})}  désigne une liste ayant l'élément 5 en plus des éléments de la liste {\tt L1} ({\tt augment} se trouve en position 8 dans le sous menu {\tt OPE} de ${\tt 2nd \times (LIST)}$.\\
La commande {\tt dim} permet de créer une nouvelle liste (faite de zéros) ou 
de redimensionner une liste existante :\\
{\tt N ->dim(L1)} crée {\tt L1} une liste de zéros de longueur {\tt N}.\\  
mais si {\tt L1} existait, cette commande donne à {\tt L1}  la dimension 
{\tt N} (soit en supprimant des termes, soit en rajoutant des zéros).\\
Si {\tt L1} est de longueur {\tt N}  on peut rajouter un élément (par exemple
 25) à {\tt L1} en écrivant :\\
{\tt 25 -> L1(N+1)} 
\section{Exemple : le  PGCD par l'algorithme d'Euclide}
Soient $A$ et $B$ deux entiers positifs dont on cherche le $PGCD$.\\
L'algorithme d'Euclide est basé sur la définition récursive du $PGCD$ :
\begin{eqnarray*}
PGCD(A,0) & = & A \\
PGCD(A,B) & = & PGCD(B,A \ \bmod \  B) \  si \  B \neq 0
\end{eqnarray*}
o\`u $A\ \bmod \ B$ désigne le reste de la division euclidienne de $A$ par $B$.\\
Voici la description de cet algorithme :\\
on effectue des divisions euclidiennes successives :
\begin{eqnarray*}
A=& B \times Q_1+R_1  &  0 \leq R_1 < B \\
B=& R_1 \times Q_2+R_2  & 0 \leq R_2 < R_1 \\
R_1=& R_2 \times Q_3+R_3 & 0 \leq R_3 < R_2 \\
.......
\end{eqnarray*}
Après un nombre fini d'étapes, il existe un entier n tel que : 
$R_n = 0.$ \\
on a alors :
$PGCD(A,B)= PGCD(B,R_1) =...=$ 
$PGCD(R_{n-1},R_n) = PGCD(R_{n-1},0) = R_{n-1}$
\subsection{Traduction algorithmique}
-Version itérative\\
Si B $\neq$ 0 on calcule R=A mod B, puis   avec B dans le r\^ole 
de A (en mettant  B dans A ) et R dans le r\^ole de B ( en mettant R dans B)
on recommence jusqu'à ce que B=0, le PGCD est alors A.
\begin{verbatim}
Fonction PGCD(A,B)
Local R\end{verbatim}
{\tt tant que B $\neq$ 0 faire}\begin{verbatim}
  A mod B->R
  B->A
  R->B
ftantque
résultat A
ffonction
\end{verbatim}

 -Version récursive\\
On écrit simplement la définition récursive vue plus haut.
\begin{verbatim}
Fonction PGCD(A,B)\end{verbatim}
{\tt Si B $\neq$ 0 alors}\begin{verbatim}
  résultat PGCD(B,A mod B) 
  sinon
  résultat A
fsi
ffonction\end{verbatim}
\subsection{Traduction MuPAD}
-Version itérative :
\begin{verbatim}
pgcd:=proc(a,b)
local r:
begin
While (b>0) do
r:=a mod b:
a:=b:
b:=r:
end_while:
return(a):
end_proc;
\end{verbatim}

-Version récursive :
\begin{verbatim}
pgcd:=proc(a,b)
begin
if (b>0) then
 return(a)
 else 
return(pgcd(b,a mod b)):
end_if:
end_proc;
\end{verbatim}
\subsection{Traduction Casio}
-Version itérative :\\
On définit le programme INAB qui permet de rentrer deux nombres A et B:
\begin{verbatim}
``A''?->A
``B''?->B
ClrText
Return
\end{verbatim}
Puis on tape le programme PGCD:
\begin{verbatim}
Prog ``INAB''
\end{verbatim}
{\tt While B $\neq$ 0 }\begin{verbatim}
  A-B*Intg(A/B)->R
  B->A
  R->B
WhileEnd
\end{verbatim}
{\tt A$\triangle$}

-Pas de version récursive.
\subsection{Traduction HP38G HP40G}
-Version itérative

On écrit tout d'abord le sous-programme IN qui permet d'entrer deux nombres 
A et B:
%HP38AscD 2 IN
\begin{verbatim}INPUT A;"A";;;1:
INPUT B;"B";;;1:
ERASE:\end{verbatim}

puis on écrit le programme PGCD: 

%HP38AscD 5 LGCD1
\begin{verbatim}RUN IN:
DISP 3;"PGCD "{A,B}:\end{verbatim}
{\tt WHILE B $\neq$ 0 REPEAT }
\begin{verbatim}A MOD B ->R:
B ->A:
R ->B:
END:
DISP 4;"PGCD "A:
FREEZE:
\end{verbatim}
  
-il n'y a pas de version récursive...mais on peut écrire le programme PGCDR:
%HP38AscD 5 PGCDR 
\begin{verbatim}DISP 3;"PGCD "{A,B}:
FREEZE:\end{verbatim}
{\tt IF B $\neq$ 0 THEN}
\begin{verbatim}A MOD B ->R:
B ->A:
R ->B:
PGCDR:
ELSE
DISP 3;"PGCD "A:
FREEZE:
END:\end{verbatim}

Il faut tout d'abord appeler le programme IN.
Le programme PGCDR affiche les  PGCD intermédiaires qui sont calculés.
L'appel récursif  PGCDR renvoie  au programme PGCDR qu'il  faut faire
 exécuter en appuyant sur le RUN du bandeau.
\subsection{Traduction HP48 HP49G mode RPN}
-Version itérative\\
${\tt \ll \ 0 \rightarrow\ A\  B\  R}$ \\ 
\hspace*{0.5cm}${\tt \ll WHILE\ B\ 0 \ \neq REPEAT}$\\
\hspace*{1.5cm}{\tt A B MOD 'R' STO}\\
\hspace*{1.5cm}{\tt B 'A' STO}\\
\hspace*{1.5cm}{\tt R 'B' STO}\\
\hspace*{1cm}{\tt END}\\
\hspace*{1cm}{\tt A}\\
\hspace*{0.5cm}${\tt \gg}$\\
 ${\tt \gg}$\\
Puis on stocke ce programme dans {\tt PGCD ('PGCD' STO)}.\\

-Version récursive\\
${\tt \ll \ 0 \rightarrow\ A\  B\ }$\\   
\hspace*{0.5cm}${\tt \ll IF\ B\ 0\ \neq\ THEN}$\\
\hspace*{1.5cm}{\tt B A B MOD PGCDR}\\
\hspace*{1cm}{\tt ELSE}\\
\hspace*{1.5cm}{\tt A}\\ 
\hspace*{1cm}{\tt END}\\
\hspace*{0.5cm}${\tt \gg}$\\ 
 ${\tt \gg}$\\ 
Puis on stocke ce programme dans {\tt PGCDR ('PGCDR' STO)}.\\
{\bf N.B.} il est possible de ne travailler qu'avec la pile sans variables locales en \'ecrivant :\\
${\tt \ll\ IF\  DUP\ 0\ \neq\ THEN}$

{\tt SWAP\ OVER\ MOD\ PGCDR

 ELSE\ DROP

 END} ${\tt \gg}$ 
\subsection{Traduction HP49G mode Algébrique}
-Version itérative\\
\noindent
${\tt \ll \ \rightarrow\ A,B \  }$\\
\hspace*{0.5cm}${\tt \ll 0\ \rightarrow\ R}$\\
\hspace*{1cm}${\tt \ll \  WHILE \ B\ \neq \  0 \ REPEAT}$\\
\hspace*{2cm}${\tt A\ MOD \ B \ STO \triangleright R;}$\\
\hspace*{2cm}${\tt  B \ STO \triangleright A;}$\\
\hspace*{2cm}${\tt R \ STO \triangleright B}$\\
\hspace*{1.5cm}${\tt END;}$\\
\hspace*{1.5cm}${\tt A}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ PGCD}$\\
Puis par exemple, {\tt PGCD(45,75)} pour l'exécuter.\\

-Version récursive\\
\noindent
${\tt \ll \ \rightarrow\ A,B \  }$\\
\hspace*{0.5cm}${\tt \ll IF \ B \ \neq \ 0\ THEN}$\\
\hspace*{1.5cm}${\tt PGCDR(B,A\ MOD \ B)}$\\
\hspace*{1cm}${\tt ELSE }$\\
\hspace*{1.5cm}${\tt A}$\\
\hspace*{1cm}${\tt END}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ PGCDR}$\\
Puis par exemple, {\tt PGCDR(45,75)} pour l'exécuter.\\
Remarque :\\
Si on utilise la fonction du calcul symbolique {\tt IREMAINDER} à la place de
{\tt MOD} dans les programmes précédents, {\tt PGCD} (ou {\tt PGCDR}) peut alors avoir comme 
paramètres des entiers de Gauss (c'est à dire les nombres $a+i\cdot b$ avec $a$ et $b$ entiers relatifs).  
\subsection{Traduction TI80}
-Version itérative\\
{\tt PROGRAM:PGCD\\
:INPUT A\\
:INPUT B\\
:LBL 1}\\
{\tt :IF B $\neq$ 0 }
\begin{verbatim}
:A-INT(A/B)*B->R
:B->A
:R->B
:GOTO 1
:END
:DISP A
\end{verbatim}

-Pas de version récursive.
\subsection{Traduction TI83+}
-Version itérative\\
{\tt PROGRAM:PGCD\\
:Prompt A,B}\\
{\tt :While B $\neq$ 0 }
\begin{verbatim}
:A-int(A/B)*B->R
:B->A
:R->B
:End
:A
\end{verbatim}

-Pas de version récursive.
\subsection{Traduction TI89 92}
-Version itérative
\begin{verbatim}
:pgcd(a,b)
:Func 
:Local r\end{verbatim}
{\tt :While b $\neq$ 0 }\begin{verbatim}
:mod(a,b)->r
:b->a
:r->b
:EndWhile
:Return a
:EndFunc
\end{verbatim}

-Version récursive
\begin{verbatim}
:pgcd(a,b)
:Func \end{verbatim}
{\tt :If  b $\neq$ 0 Then}\begin{verbatim}
:Return  pgcd(b, mod(a,b)) 
:Else
:Return a
:EndIf
:EndFunc
\end{verbatim}
\subsection{Traduction SHARP EL9600} 
-Version itérative :\\
{\tt PGCD}\\
{\tt Input A}\\
{\tt Input B}\\
{\tt Label DTQ}\\
{\tt If B=0 Goto FTQ}\\
${\tt  A-\ int\ (A/B)*B \Rightarrow R}$\\
${\tt B \Rightarrow A}$\\
 ${\tt R \Rightarrow B}$\\
{\tt Goto DTQ}\\
{\tt Label FTQ}\\ 
{\tt Print ''PGCD}\\
{\tt Print A}\\
{\tt End}\\ 

-Pas de version récursive.

%\tableofcontents
%\select@language {frenchb}
\section{TABLE DES MATI\`ERES}

\begin{itemize}
\item \contentsline {section}{\numberline {1}Pour commencer}{1}
\contentsline {subsection}{\numberline {1.1}Comment \'editer et sauver un programme}{1}
\contentsline {subsection}{\numberline {1.2}Comment corriger un programme}{3}
\contentsline {subsection}{\numberline {1.3}Comment ex\'ecuter un programme}{5}
\contentsline {subsection}{\numberline {1.4}Comment am\'eliorer puis sauver sous un autre nom un programme}{6}
\contentsline {section}{\numberline {2}Les diff\'erentes instructions}{7}
\contentsline {subsection}{\numberline {2.1}Les commentaires}{7}
\contentsline {subsection}{\numberline {2.2}Les variables}{8}
\contentsline {subsection}{\numberline {2.3}Les Entr\'ees}{9}
\contentsline {subsection}{\numberline {2.4}Les Sorties}{9}
\contentsline {subsection}{\numberline {2.5}La s\'equence d'instructions ou action}{10}
\contentsline {subsection}{\numberline {2.6}L'instruction d'affectation}{11}
\contentsline {subsection}{\numberline {2.7}Les instructions conditionnelles}{11}
\contentsline {subsection}{\numberline {2.8}Les instructions "Pour" }{13}
\contentsline {subsection}{\numberline {2.9}L'instruction ``Repeter''}{13}
\contentsline {subsection}{\numberline {2.10}L'instruction ``Tant que''}{14}
\contentsline {subsection}{\numberline {2.11}Les conditions ou expressions bool\'eennes }{15}
\contentsline {subsection}{\numberline {2.12}Les fonctions}{15}
\contentsline {subsection}{\numberline {2.13}Les listes}{16}
\contentsline {section}{\numberline {3}Exemple : le PGCD par l'algorithme d'Euclide}{19}
\contentsline {subsection}{\numberline {3.1}Traduction algorithmique}{20}
\contentsline {subsection}{\numberline {3.2}Traduction MuPAD}{20}
\contentsline {subsection}{\numberline {3.3}Traduction Casio}{20}
\contentsline {subsection}{\numberline {3.4}Traduction HP38G HP40G}{21}
\contentsline {subsection}{\numberline {3.5}Traduction HP48 HP49G mode RPN}{21}
\contentsline {subsection}{\numberline {3.6}Traduction HP49G mode Alg\'ebrique}{22}
\contentsline {subsection}{\numberline {3.7}Traduction TI80}{22}
\contentsline {subsection}{\numberline {3.8}Traduction TI83+}{23}
\contentsline {subsection}{\numberline {3.9}Traduction TI89 92}{23}
\contentsline {subsection}{\numberline {3.10}Traduction SHARP EL9600}{23}
\end{itemize}
\end{document}








