\documentclass[a4paper,11pt]{book}
\textheight 23 cm
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais]{babel}
\usepackage{latexsym}
\usepackage{amsfonts}
\usepackage{amssymb}
\title{Algorithmique et traduction pour\\ calculatrices et autres langages\\
{\small MapleV, Mathematica, Maxima, MuPAD, Pascal, C++, xcas}\\
{\normalsize surnomm\'e}\\
"Le gros rouge d'Algorithmique"}
\author{Ren\'ee De Graeve}

\begin{document}
\maketitle
{\bf \centerline{Remerciements}}

\vspace{1cm}

Je  remercie :
 \begin{itemize}
\item Claire Helmstetter pour ses pr\'ecieux conseils et ses remarques 
sur ce texte,
\item Paul Perret pour avoir coanim\'e efficacement le premier
stage IREM d'arithm\'etique, stage  qui a donn\'e naissance \`a ce document, et aussi
pour avoir \'ecrit la partie consacr\'ee \`a {\tt MapleV}, 
\item Lionel Dari\'e pour avoir \'ecrit la partie consacr\'ee \`a {\tt Mathematica},
 \item Bernard Parisse pour avoir compl\'et\'e les parties consacr\'ees \`a 
{\tt Maxima, MuPAD, C++} et pour avoir \'ecrit l'annexe indiquant comment on
 r\'ecup\`ere des logiciels sur Internet,
 \item Jean Pierre Douris et Christiane Serret pour leur  relecture,
 \item Marc Legrand pour l'int\'er\^et port\'e \`a l'ach\`evement de ce
document,
 \item Serge Cecconi pour son illustration,
 \item Ghislaine Richer pour la conception de la couverture,
\item et tous mes coll\`egues de l'IREM de Grenoble .
 \end{itemize}

Je  remercie aussi les repr\'esentants de  Hewlett Packard, Sharp et  
Texas Instruments qui m'ont donn\'e, lors du congr\`es national de l'APMEP 
(Association des Professeurs de Math\'ematiques de l'Enseignement Public) \`a 
G\'erardmer, les  calculatrices qui me manquaient pour compl\'eter ce manuel 
(une HP49G, une TI83+ et une Sharp EL9600).

\vfill

\begin{center}
      Copyright (c)  2000, Ren\'ee De Graeve
\end{center}

      Permission is granted to copy, distribute and/or modify this document
      under the terms of the GNU Free Documentation License, Version 1.1
      or any later version published by the Free Software Foundation;
      with no Invariant Sections  with no Front-Cover Texts and 
      with no Back-Cover Texts.
      A copy of the license is included in the section entitled "GNU
      Free Documentation License".

\chapter*{Introduction}
Avec la d\'emocratisation du calcul formel on pourrait croire qu'il
devient inutile d'apprendre les algorithmes fondamentaux de
l'arithm\'etique. Nous pensons pourtant que la compr\'ehension
de ces algorithmes aide \`a comprendre le concept math\'ematique
sous-jacent et que le but de la formation n'est pas de transformer
nos \'el\`eves en presse-boutons. Nous proposons donc d'impl\'ementer
ces algorithmes dans des langages largement accessibles aux \'el\`eves,
ils pourront ensuite utiliser des logiciels de calcul formel lorsque
les donn\'ees d\'epassent les capacit\'es des calculatrices  ne faisant
pas de calcul formel.
Nous avons voulu dans ce qui suit \'ecrire les algorithmes d'arithm\'etique
du programme de sp\'ecialit\'e maths~: tout d'abord en langage algorithmique, puis
dans les diff\'erents langages des diff\'erentes marques de calculatrices.\\
On remarquera qu'une fois que l'on s'est mis d'accord sur le langage 
algorithmique, la traduction en langage calculatrice (ou autre) se fait de 
fa\c{c}on (presque) syst\'ematique.\\
Nous esp\'erons que ce fascicule facilitera la gestion des diff\'erents mod\`eles de
calculatrices dans les classes, et sera un premier pas vers l'introduction 
d'un langage algorithmique commun \`a tous.\\
Vous trouverez chapitre 4, les programmes regroup\'es selon les mod\`eles de
 calculatrices, pour faire facilement les photocopies destin\'ees aux \'el\`eves.\\
La nouvelle \'edition de cette brochure a \'et\'e compl\'et\'ee par une 
introduction aux langages de calcul formel comme 
{\tt Maple, Mathematica, Maxima} et
{\tt MuPAD}. En effet, un logiciel de calcul formel permet d'effectuer des manipulations alg\'ebriques sans avoir \`a effectuer d'approximation num\'erique,
par exemple calculer la d\'eriv\'ee ou la primitive d'une fonction,
r\'esoudre certaines \'equations diff\'erentielles, etc.\\
 {\tt MuPAD} et  {\tt Maple} sont les deux logiciels de calculs formel 
autoris\'es \`a la 3eme \'epreuve orale de l'agr\'egation de math\'ematiques. 
{\tt Mathematica} est un autre logiciel de calcul formel souvent utilis\'e mais
malheureusement assez cher.\\
{\tt Maxima} est aussi un logiciel de calcul formel : il  est devenu
r\'ecemment un logiciel libre donc gratuit. Il est maintenu par William F. Schelter 
(dont l'adresse est  \verb|wfs@math.utexas.edu|).\\
 {\tt Maple} est plus ancien que {\tt MuPAD} et contient plus de commandes, mais vous devrez payer une
licence d'utilisation si vous voulez l'utiliser chez vous
(cf \\\verb|www.maplesoft.com|). La version \'etudiante de  {\tt Maple} co\^ute
environ 100 euros, les versions compl\`etes de  {\tt Maple} et de {\tt Mathematica} co\^utent plus de 1000 euros.\\
Par contre, {\tt Maxima} est libre et gratuit  se reporter \`a l'adresse :\\
\verb|http://www.ma.utexas.edu/users/wfs/maxima.html|\\
Quant \`a {\tt MuPAD}, il  est disponible gratuitement pour un usage \'educatif
 se reporter \`a 
\verb|www.mupad.de| et \`a \verb|www.sciface.com|. \\
Les commandes qui existent dans les diff\'erents  syst\`emes sont suffisament 
proches pour que le passage de l'un \`a l'autre se fasse en douceur.\\ 
Enfin, le dernier chapitre est consacr\'e \`a une introduction \`a {\tt Pascal}
 et \`a {\tt C++} qui sont des langages proches de ceux utilis\'es dans les calculatrices. \`A la fin de ce chapitre vous trouverez comment vous pouvez programmer en {\tt C++} en utilisant des types symboliques et ainsi faire du calcul formel... encore merci \`a Bernard Parisse!!!\\
\ \\
\ \\
{\bf Resum\'e}\\
Ce document introduit les bases du langage algorithmique et permet de traduire
un m\^eme programme en diff\'erents langages de programmation :\\
{\tt Pascal, C++, Maple, Mathematica, Maxima, MuPAD} \\
et \\
en langages utilis\'es par diff\'erents types de calculatrices :
{\tt CASIO, HP, SHARP, TI}\\
Les exemples de programmation ont pour th\`eme l'arithm\'etique.\\
\ \\
{\bf Mots Cl\'es}
\begin{verbatim}
Algorithme
Algorithmique
Arithmétique
Bézout
Calculatrice
Calcul Formel
C++
Nombre premier
Maple
Mathematica
Maxima
MuPAD
Pascal
PGCD
Premier
xcas
\end{verbatim}
\chapter{Pour commencer}
\section{Comment \'editer et sauver un programme}
\subsection{Traduction Casio}
Appuyer sur la touche {\tt MENU}, puis ouvrir le menu {\tt PRGM} (en mettant
 en surbrillance {\tt PRGM} avec les fl\`eches, puis en appuyant sur la touche 
{\tt EXE}).\\
Cela vous donne la liste des programmes (\'ecran {\tt Program List}) et un
 bandeau contenant :
{\tt EXE EDIT NEW DEL DEL.A SRC REN}\\
Avec {\tt F3} vous s\'electionnez {\tt NEW} pour \'editer 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\^{\i}tre  un bandeau contenant 
les diff\'erentes instructions et la touche {\tt OPTN} fait appara\^itre  un 
bandeau contenant les diff\'erentes fonctions math\'ematiques.\\
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 \`a l'\'ecran {\tt Program List}.
\subsection{Traduction HP38G HP40G}
Pour avoir acc\`es au catalogue de programmes, on appuie sur les touches
 {\tt shift 0 (PROGRAM)}.\\
 Il apparait alors un \'ecran 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\'e.  
\subsection{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\'esultats sont mis sur une 
pile, ou le mode alg\'ebrique qui est la notation habituelle (voir \ref{sec:49alg}).\\
Un programme s'\'ecrit dans la ligne de commande entre les d\'elimiteurs ${\tt \ll \; \gg}$\\ 
Pour le  sauver, il suffit de faire suivre le dernier $\gg$ par :
 $${\tt \ 'NOMDUPROGRAMME'\ STO\triangleright}$$
\subsection{Traduction HP49G mode Alg\'ebrique}\label{sec:49alg}
Un programme s'\'ecrit dans la ligne de commande entre les d\'elimiteurs ${\tt \ll \; \gg}$\\ 
Pour le  sauver, il suffit de faire suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOMDUPROGRAMME}$$
\subsection{Traduction TI 80} 
On appuie sur la touche {\tt PRGM} et on met en surbrillance {\tt NEW} avec la 
fl\`eche $\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'\'editeur et vous pouvez taper votre programme :\\
- les {\tt :} sont mis automatiquement en d\'ebut de ligne.\\
- les diff\'erentes instructions sont disponibles en appuyant sur {\tt PRGM} :
en effet, depuis l'\'editeur le menu de {\tt PRGM} n'est pas le m\^eme ({\tt CTL}
 pour les diff\'erentes instructions, {\tt I/O} pour les instructions 
d'entr\'ees et de sorties, et enfin {\tt EXEC} pour afficher la liste des noms 
des programmes ce qui permet d'\'ecrire {\tt prgmNOMDUPROG} dans une ligne de
 programme pour appeler un sous programme).\\
- les fonctions math\'ematiques sont accessibles en appuyant sur {\tt MATH} et 
les fonctions bool\'eennes en appuyant sur {\tt 2nd MATH (TEST)}.\\
Pour sauver votre programme, il suffit de taper {\tt 2nd MODE (QUIT)} et vous
 revenez \`a l'\'ecran {\tt HOME}.
\subsection{Traduction TI 83+} 
On appuie sur la touche {\tt PRGM} et on met en surbrillance {\tt NEW} avec la 
fl\`eche $\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'\'editeur et vous pouvez taper votre programme :\\
- les {\tt :} sont mis automatiquement en d\'ebut de ligne.\\
- les diff\'erentes instructions sont disponibles en appuyant sur {\tt PRGM} :
en effet, depuis l'\'editeur le menu de {\tt PRGM} n'est pas le m\^eme ({\tt CTL}
  pour les diff\'erentes instructions, {\tt I/O} pour les instructions 
d'entr\'ees et de sorties, et enfin {\tt EXEC} pour afficher la liste des noms 
des programmes ce qui permet d'\'ecrire {\tt prgmNOMDUPROG} dans une ligne de
 programme pour appeler un sous programme).\\
- les fonctions math\'ematiques sont accessibles en appuyant sur {\tt MATH} et 
les fonctions bool\'eennes en appuyant sur {\tt 2nd MATH (TEST)}.\\
Pour sauver votre programme, il suffit de taper {\tt 2nd MODE (QUIT)} et vous
 revenez \`a l'\'ecran {\tt HOME}.
\subsection{Traduction TI89, 92}
Pour avoir acc\`es \`a l'\'editeur, 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 \'ecrire une fonction (qui renvoie une valeur 
gr\^ace \`a {\tt Return}) ou un programme (appuyer {\tt ->} puis faites votre
 choix {\tt 1} ou  {\tt 2}) puis {\tt ENTER} pour valider votre choix.\\
On \'ecrit ensuite le nom du programme dans la case {\tt Variable} puis 
{\tt ENTER} pour valider le nom, puis {\tt ENTER} pour entrer dans l'\'editeur.\\
Vous \^etes pr\^et \`a taper votre programme.\\
 Vous pouvez ajouter \'eventuellement les noms des param\`etres dans la premi\`ere 
ligne (en d\'epla\c{c}ant le curseur avec les fl\`eches).\\
Les touches {\tt F1 F2 F3 F4} vous facilitent l'\'edition.\\
En appuyant sur ${\tt \blacklozenge\ Q\ (HOME)}$ vous sauvez votre programme 
et vous revenez \`a l'\'ecran {\tt HOME}.
\subsection{Traduction SHARP EL9600}
On appuie sur la touche {\tt 2nd MATRIX (PRGM)} et on met en surbrillance {\tt NEW}  avec la fl\`eche $\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'\'editeur et vous pouvez taper votre programme :\\
- les diff\'erentes instructions sont disponibles en appuyant sur 
{\tt 2nd MATRIX (PRGM)} :
en effet, depuis l'\'editeur le menu de {\tt 2nd MATRIX (PRGM)} n'est pas le 
m\^eme ({\tt PRGM} pour les instructions d'entr\'ees et de sorties, {\tt BRNCH} 
 pour les diff\'erentes instructions de programmation etc...).\\
- les fonctions math\'ematiques 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\'egalit\'es et {\tt LOGIC} donne  les fonctions
 bool\'eennes).\\
Pour sauver votre programme, il suffit de taper {\tt 2nd CL (QUIT)} et on
 revient \`a l'\'ecran {\tt HOME}. 
\section{Comment corriger un programme} 
\subsection{Traduction Casio}
Si la syntaxe est mauvaise, la machine vous indique :
{\tt Go ERROR}
 si vous voulez aller l\`a o\`u se trouve l'erreur appuyer sur l'une des fl\`eches
 ($\leftarrow ,\rightarrow$).\\
Vous \^etes alors dans l'\'editeur pr\^et \`a 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\'eplacement du curseur).
\subsection{Traduction HP38G HP40G}
Si la syntaxe est mauvaise, la machine vous  dit :\\
{\tt Invalid Syntax Edit program?} Vous r\'epondez {\tt F6 (YES)}.\\
La machine vous met automatiquement le curseur l\`a
o\`u le compilateur a d\'etect\'e l'erreur. Il suffit donc de corriger!!!
\subsection{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\'etect\'e l'erreur. Il suffit donc de corriger!!!\\
Si l'erreur est d\'etect\'ee au cours de l'ex\'ecution du programme il faut taper :\\
{\tt 'NOMDUPROGRAMME'  VISIT}\index{VISIT} qui \'edite votre programme.\\
 On corrige, puis 
{\tt ENTER}  sauve votre programme corrig\'e. 
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 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. 
\subsection{Traduction HP49G mode Alg\'ebrique} 
Si la syntaxe est mauvaise, la machine vous met automatiquement le curseur l\`a
o\`u le compilateur a d\'etect\'e l'erreur. Il suffit donc de corriger!!!\\
Si l'erreur est d\'etect\'ee au cours de l'ex\'ecution du programme il faut taper :\\
{\tt VISIT('NOMDUPROGRAMME')}\index{VISIT} qui \'edite votre programme.\\
 On corrige, puis 
{\tt ENTER}  sauve votre programme corrig\'e. 
\subsection{Traduction TI 80}
Si la syntaxe est mauvaise, la machine vous demande si vous voulez aller l\`a o\`u se trouve l'erreur 
({\tt 1:GOTO})  ou si vous voulez arr\^eter 
({\tt 2:QUIT}).\\
Vous r\'epondez : 1 \\
Vous \^etes alors dans l'\'editeur pr\^et \`a corriger votre erreur.\\
Puis {\tt 2nd MODE (QUIT)} vous fait revenir \`a l'\'ecran {\tt HOME} en
 sauvant votre correction.
\subsection{Traduction TI 83+}
Si la syntaxe est mauvaise, la machine vous demande si vous voulez arr\^eter 
({\tt1:QUIT}), ou si vous voulez aller l\`a o\`u se trouve l'erreur 
({\tt 2:GOTO}).\\
Vous r\'epondez : 2 \\
Vous \^etes alors dans l'\'editeur pr\^et \`a corriger votre erreur.\\
Puis {\tt 2nd MODE (QUIT)} vous fait revenir \`a l'\'ecran {\tt HOME} en
 sauvant votre correction.
\subsection{Traduction TI89 92}
Si la syntaxe est mauvaise, la machine vous demande  si vous voulez aller l\`a 
o\`u se trouve l'erreur ({\tt ENTER=GOTO}) ou si vous voulez arr\^eter 
({\tt ESC=CANCEL}).\\
Vous r\'epondez : {\tt ENTER}. \\
Vous \^etes alors dans l'\'editeur pr\^et \`a corriger votre erreur.\\
Puis  ${\tt \blacklozenge\ Q\ (HOME)}$ vous fait revenir \`a l'\'ecran {\tt HOME} 
en sauvant votre correction.\\
Si l'erreur est d\'etect\'ee au cours de l'ex\'ecution du programme il faut taper :\\
 {\tt APPS} puis {\tt 7 (Program Editor)} puis {\tt 1 (Current)} et {\tt ENTER}
qui \'edite votre programme.
\subsection{Traduction SHARP EL9600}
Si la syntaxe est mauvaise, la machine vous demande si vous voulez aller l\`a 
o\`u se trouve l'erreur \`a l'aide des fl\`eches ($\leftarrow ,\rightarrow$ {\tt :Goto error}) ou si vous voulez arr\^eter 
({\tt CL :Quit}),.\\
Vous r\'epondez en appuyant sur une fl\`eche : 
vous \^etes alors dans l'\'editeur pr\^et \`a 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\'ee en changeant de ligne  
en appuyant par exemple sur $ \downarrow$.\\ 
Puis {\tt 2nd CL (QUIT)} vous fait revenir \`a l'\'ecran {\tt HOME}.
\section{Comment ex\'ecuter un programme}
\subsection{Traduction Casio}
Dans l'\'ecran {\tt Program List} (au d\'epart de l'\'ecran {\tt HOME}
touche  {\tt MENU PRGM EXE} ou apr\`es avoir tap\'e le programme {\tt 2nd EXIT (QUIT)}), il suffit de mettre en surbrillance le nom du 
programme \`a ex\'ecuter et de taper sur {\tt F1} pour {\tt EXE} du bandeau 
(derni\`ere ligne de l'\'ecran o\`u se trouve un menu). 
\subsection{Traduction HP38G HP40G}
Pour ex\'ecuter un programme, on ouvre le catalogue de programmes en appuyant sur
 les touches {\tt shift 0 (PROGRAM)}.\\
 Il apparait alors un \'ecran contenant la 
liste des programmes disponibles et un bandeau ({\tt EDIT NEW SEND RECV RUN}).\\
On met le nom du programme \`a ex\'ecuter en surbrillance et on appuie sur 
{\tt F6 (RUN)}.
\subsection{Traduction HP48 HP49G mode RPN}
Si le programme n'a pas de param\`etres, il suffit de taper son nom dans la ligne de commande ou d'utiliser le menu {\tt VAR}.\\
S'il y a des param\`etres, on met  les valeurs des param\`etres sur la pile puis on
 tape le nom du programme.\\
Exemple :\\
{\tt 45 75 PGCD} 
\subsection{Traduction HP49G mode Alg\'ebrique} 
Si le programme n'a pas de param\`etres, il suffit de taper son nom dans la ligne de commande ou d'utiliser le menu {\tt VAR}.\\
S'il y a des param\`etres, on fait suivre le nom du programme de parenth\`eses
dans lesquelles on met  les valeurs des param\`etres s\'epar\'ees par une virgule.\\
Exemple :\\
{\tt PGCD(45,75)}
\subsection{Traduction TI 80}
On appuie sur la touche {\tt PRGM}, on laisse en surbrillance {\tt EXEC}, et
on tape le num\'ero du programme \`a ex\'ecuter. 
\subsection{Traduction TI 83+}
On appuie sur la touche {\tt PRGM}, on laisse en surbrillance {\tt EXEC}, et
on tape le num\'ero du programme \`a ex\'ecuter. 
\subsection{Traduction TI89 92}
Si le programme n'a pas de param\`etres, il suffit de taper son nom dans la ligne de commande.\\
S'il y a des param\`etres, on fait suivre le nom du programme de parenth\`eses
dans lesquelles on met  les valeurs des param\`etres s\'epar\'ees par une virgule.\\
Exemple :\\
{\tt PGCD(45,75)}
\subsection{Traduction SHARP EL9600}
On appuie sur la touche {\tt 2nd MATRIX (PRGM)}, on met en surbrillance {\tt EXEC}, et le programme \`a ex\'ecuter avec le stylet ou on utilise les fl\`eches ou
on tape le num\'ero (\`a deux chiffres) du programme \`a ex\'ecuter. 
\section{Comment am\'eliorer puis  sauver sous un autre nom un programme}
\subsection{Traduction Casio}
Dans l'\'ecran {\tt Program List} ({\tt MENU PRGM EXE}), il suffit de mettre en 
surbrillance le nom du 
programme \`a 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\'eliorer...
\subsection{Traduction HP38G 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 \'ecran contenant la 
liste des programmes disponibles et un bandeau ({\tt EDIT NEW SEND RECV RUN}).\\
On met le nom du programme \`a modifier en surbrillance et on appuie sur 
{\tt F1 (EDIT)}.\\
Si vous voulez avoir \`a 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\'e puis 
{\tt F6 (OK)}.\\
 L'\'editeur 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. 
\subsection{Traduction HP48 HP49G mode RPN}
On tape :\\
   {\tt 'NOMDUPROGRAMME' RCL} puis {\tt edit} du bandeau.\\
On fait les am\'eliorations et on fait suivre le dernier $\gg$ par :
 $${\tt 'NOUVEAUNOM'\ STO\triangleright}$$
\subsection{Traduction HP49G mode Alg\'ebrique} 
On tape :\\
   {\tt RCL('NOMDUPROGRAMME')} puis {\tt edit} du bandeau.\\
On fait les am\'eliorations et on fait suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOUVEAUNOM}$$
\subsection{Traduction TI 80}
Je n'ai pas trouv\'e comment faire...
\subsection{Traduction TI 83+}
Vous commencez comme si vous alliez \'ecrire un nouveau programme 
({\tt PRGM NEW} puis le nom du nouveau programme).\\
Vous \^etes alors dans l'\'editeur, vous avez la possibilit\'e d'\'editer n'importe
 quel programme avec :\\
{\tt 2nd STO (RCL)} puis {\tt PRGM}, puis, mettre en surbrillance {\tt EXEC}
puis, le num\'ero du programme \`a rappeler.\\
 En bas de l'\'editeur il s'\'ecrit :
{\tt Rcl prgmPGCD} (par exemple).\\
 {\tt ENTER} ram\`ene alors toutes les lignes du programme {\tt PGCD} dans 
l'\'editeur. 
\subsection{Traduction TI89 92}
Vous ouvrez l'\'editeur avec le programme que vous voulez am\'eliorer puis  sauver
 sous un autre nom :\\
 {\tt APPS} puis {\tt 7 (Program Editor)} puis 
{\tt 2 (Open)} puis mettre le nom du programme \`a modifier dans  {\tt Variable} 
(appuyer sur {\tt ->} pour avoir acc\`es \`a tous les noms de vos programmes, s\'electionner celui \`a modifier avec les fl\`eches et {\tt ENTER}),  puis {\tt ENTER}.\\
Ensuite, il suffit de taper sur  ${\tt \blacklozenge\ S}$ pour sauver cet \'editeur 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\'e sous le nouveau nom, 
et vous revenez \`a l'\'ecran {\tt HOME}.
\subsection{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\'eliorer...
\chapter{Les diff\'erentes instructions}
\section{Les commentaires}
Il faut prendre l'habitude de commenter les programmes. 
En algorithmique un commentaire commence par 
{\tt // } et se termine par un passage \`a la ligne.
\subsection{Traduction Casio}
Il n'y en a pas!!!
\subsection{Traduction HP38G HP40G HP48 HP49G}
Le commentaire commence par :\\
{\tt @} et se termine par un passage \`a la ligne.\\
Pour la {\tt HP49G}, un commentaire commence par {\tt @} et se termine par un 
passage \`a la ligne ou est entour\'e de deux {\tt @}.\\
Le caract\`ere {\tt @} est
obtenu en tapant {\tt shift-rouge ENTER}\\ 
Attention!!! le compilateur efface les commentaires... donc pour garder vos 
commentaires, il faut \'ecrire votre programme sous la forme d'un texte qu'il 
faut ensuite compiler avec ${\tt STR\rightarrow}$ ce qui complique un peu...
\subsection{Traduction TI80 83+}
Il n'y en a pas!!!
\subsection{Traduction TI89 92}
Le commentaire commence par

{\tt {\copyright}} (F2 9) et se termine par un passage \`a la ligne.

\subsection{Traduction SHARP EL9600} 
Les commentaires sont pr\'ec\'ed\'es 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'\'editer un 
programme).
\section{Les variables}
\subsection{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\'ed\'efinis soit plus libres.\\
Par exemple chez {\tt CASIO, HP38G, HP40G, TI80, TI83+ et SHARP-EL9600} on n'a droit qu'aux 26 lettres de l'alphabet pour stocker des nombres r\'eels.\\
Mais avec 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\`eres.
\subsection{Notion de variables locales}
Cette notion n'existe pas pour les calculatrices {\tt CASIO, HP38, HP40G, TI80, TI83+ et SHARP-EL9600}.\\
Pour la  {\tt TI92} il faut d\'efinir les variables locales en d\'ebut de programme en \'ecrivant :\\
{\tt :local a,b}\\
La {\tt HP48} ou {\tt HP49G} peut utiliser des variables locales.\\ 
Les  variables locales sont d\'eclar\'ees et initialis\'ees (initialisation
 obligatoire!) gr\^ace \`a \  ${\tt \ \rightarrow}$ {\tt (shift-rouge 0)}\\
Pour la {\tt HP48} ou {\tt HP49G mode RPN} il faut d\'efinir et initialiser les variables locales en \'ecrivant :
$${\tt \ll 1\ 2\ \rightarrow\  A\ B \ll corps\ du\  programme \gg \gg }$$
pour initialiser {\tt A} \`a 1 et {\tt B} \`a 2.\\
En mode {\tt RPN} on peut d\'efinir et initialiser plusieurs variables locales
\`a la fois (cf  exemple  ci-dessus).\\
Pour la  {\tt HP49G mode Alg\'ebrique}  chaque d\'eclaration doit \^etre suivie par un sous programme (d\'elimiteurs ${\tt \ll \gg}$) en \'ecrivant :
$${\tt \ll 1\ \rightarrow\  A \ll 2\ \rightarrow\ B \ll corps\ du\  programme \gg \gg \gg}$$
La fl\`eche doit \^etre entour\'ee 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 \'ecrit le programme {\tt PER}.\\ {\tt PI} est une variable locale qui est d\'eclar\'ee et
 affect\'ee par ${\tt 3.14 \ \rightarrow \ PI} $. Cette variable est locale pour le 
programme qui suit sa d\'eclaration (ici ${\tt \ll 2*PI*R \gg}$). \\
Par contre, {\tt R} est une variable globale (qui doit exister avant
l'ex\'ecution 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}$.
\subsection{Notion de param\`etres}
Quand on \'ecrit une fonction il est possible d'utiliser des param\`etres.\\
Par exemple si {\tt A} et {\tt B} sont les param\`etres de la fonction {\tt PGCD}  on \'ecrit :\\
{\tt PGCD(A,B)}\\
Ces param\`etres se comportent comme des variables locales, la seule diff\'erence 
est qu'ils sont initialis\'es lors de l'appel de la fonction. 
L'ex\'ecution  se fait en demandant par exemple :
{\tt PGCD(15,75)}\\
Il n'est pas possible d'\'ecrire des fonctions sur toutes les calculatrices. \\
Pour les {\tt TI 89 92} on met le nom des param\`etres 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\`etre de la fonction {\tt PER}  on \'ecrit :
$${\tt \ll\ \rightarrow\ R \ll  3.14\ \rightarrow\ PI \ll 2\ PI\ *\ R\ *\ \gg \gg \gg 'PER'\ STO\triangleright}$$
L'ex\'ecution  se fait en demandant par exemple :
{\tt 5 PER}.\\
Pour la  {\tt HP49G mode Alg\'ebrique} si on veut que {\tt R} soit le param\`etre 
de la fonction {\tt PER}  on \'ecrit :
 $${\tt \ll\ \rightarrow\ R \ll  3.14\ \rightarrow\ PI \ll 2*PI*R \gg \gg \gg STO\triangleright \  PER}$$
L'ex\'ecution  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\'ebrique} est :
$${\tt  \ll\ \ \rightarrow\ A \ B  \ll\ ...\gg \gg }$$
pour \'ecrire une fonction \`a deux param\`etres. 
{\bf Remarque}
Le langage des {\tt HP48/49} est fonctionnel puisque on peut 
passer des programmes ou des fonctions en param\`etre.
\section{Les Entr\'ees}
Pour que l'utilisateur puisse entrer une valeur dans la variable {\tt A} au 
cours de l'ex\'ecution d'un programme, on \'ecrira, en algorithmique :\\
{\tt saisir A}  \\
Et pour entrer des valeurs dans {\tt A} et {\tt B} on \'ecrira :\\
{\tt saisir A,B}
\subsection{Traduction Casio}
\noindent{\tt "A="?->A:}
\subsection{Traduction HP38G HP40G}
\noindent{\tt INPUT A;"TITRE";"A=";;0:}\\
 pour la {\tt HP 40G} on a aussi :\\
{\tt PROMPT A:}
\subsection{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} 
\subsection{Traduction HP49G mode Alg\'ebrique} 
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\'eer une variable locale {\tt A}.\\
% On utilise, si {\tt A} doit contenir une chaine de caract\`eres : 
%$${\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  }$
\subsection{Traduction TI 80, 82, 83, 83+, 89, 92}
\noindent {\tt:Prompt A}\\
{\tt :Prompt A,B}\\
ou encore  :\\
{\tt:Input ``A='',A}
\subsection{Traduction SHARP EL9600}
\noindent{\tt Input A}\\
ou \\
{\tt Input A}\\
{\tt Input B}\\
La machine met alors automatiquement {\tt A=?} (ou {\tt A=?} puis {\tt B=?}).
\section{Les Sorties}
En algorithmique on \'ecrit :\\
{\tt Afficher "A=",A}
\subsection{Traduction Casio}
\noindent{\tt "A=":A $\triangle$}\\ 
{\tt ClrText} efface l'\'ecran.\\
{\tt $\triangle$ }
 arr\^ete l'affichage et sert aussi de fin d'instruction.
\subsection{Traduction HP38G HP40G}
\noindent{\tt DISP 3;"A="A:} 3 repr\'esente le num\'ero de la ligne o\`u {\tt A} sera affich\'e \\
ou\\
{\tt MSGBOX "A="A:}\\
{\tt ERASE:}  efface l'\'ecran.\\
{\tt FREEZE:} g\`ele l'affichage. 
\subsection{Traduction HP48 ou HP49G mode RPN}
En g\'en\'eral on affiche simplement les r\'esultats sur la pile pour une
 r\'eutilisation \'eventuelle, on \'ecrira simplement :\\
{\tt A B}\\
On peut aussi afficher le r\'esultat tagu\'e, on \'ecrira alors :\\
{\tt A "A=" ->TAG}\\
{\tt HALT} arr\^ete le programme et {\tt Shift-rouge ON (CONT)} le continue.
\subsection{Traduction HP49G mode Alg\'ebrique} 
Seul le dernier r\'esultat s'inscrit dans l'historique.\\
Pour des r\'esultats interm\'ediaires on tape :
$$ {\tt DISP("A="+A,3)}$$\index{DISP}
 3 repr\'esente le num\'ero de la ligne\\
ou\\
$${\tt MSGBOX( "A="+\rightarrow STR(A))}$$\index{MSGBOX}
(ici le {\tt +} effectue la concat\'enation de deux chaines de caract\`eres)\\
{\tt CLLCD()}  efface l'\'ecran.\index{CLEAR}\\
{\tt FREEZE(7)}  g\`ele l'affichage et permet de visualiser les 7 lignes de l'affichage.\index{FREEZE}
\subsection{Traduction TI 80 82 83 83+ 89 92}
\noindent{\tt :Disp "A=",A}\\
{\tt :ClrIO} efface l'\'ecran.\\
{\tt :ClrHome} efface l'\'ecran pour la {\tt TI 83+}.\\
{\tt :Pause} arr\^ete le programme (on appuie sur {\tt ENTER} pour reprendre l'ex\'ecution).
\subsection{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}
\section{La s\'equence d'instructions ou action}
Une action est une s\'equence d'une ou plusieurs instructions.\\
En langage algorithmique, on utilisera l'espace ou le passage \`a la ligne pour 
terminer une instruction.
\subsection{Traduction Casio}
A la fin d'une instruction, il faut mettre un s\'eparateur qui peut \^etre :\\
{\tt  le retour \`a la ligne} ou {\tt :} ou ${\tt \triangle}$
\subsection{Traduction HP38G HP40G}
\noindent {\tt:} indique la fin d'une instruction.
\subsection{Traduction HP48 ou HP49G mode RPN}
Comme en algorithmique, le s\'eparateur est soit {\tt l'espace} soit {\tt le retour \`a la ligne}.
\subsection{Traduction HP49G mode Alg\'ebrique} 
Pour la {\tt HP49G}, le {\tt\ ;\ } est un s\'eparateur d' instructions.\\ 
Le {\tt ;} s'obtient
en tapant en m\^eme temps sur {\tt shift-rouge SPC}.
\subsection{Traduction TI 83+ 89 92}
\noindent {\tt:} indique la fin d'une instruction. Il faut noter qu'\`a chaque passage \`a la ligne le  {\tt:} est mis automatiquement.
\subsection{Traduction SHARP EL9600}
C'est {\tt ENTER} qui est utilis\'e comme s\'eparateur d'instructions.\\
Chaque instruction doit \^etre \'ecrite  sur une seule ligne.
\section{L'instruction d'affectation}
L'affectation est utilis\'ee pour stocker une valeur ou une expression dans une 
variable.\\
En algorithmique on \'ecrira par exemple :
{\tt 2*A->B}\\
pour stocker {\tt 2*A} dans {\tt B}\\
Les calculatrices {\tt CASIO, HP38G, HP40G, TI80, TI83+, TI89, TI92 et SHARP-EL9600} utilisent cette notation.\\ 
Selon les cas, la fl\`eche est obtenue \`a 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\'ee et la commande {\tt STO} :\\
{\tt 2 A * 'B' STO}\\
Pour la {\tt HP49G mode Alg\'ebrique}, on utilise  la touche ${\tt STO}$ qui se 
traduit \`a l'\'ecran  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 \`a 
l'\'ecran  de la calculatrice par : 
$ \Rightarrow $ 
\section{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}
\subsection{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:}
\subsection{Traduction HP38G 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'\'egalit\'e) :\\
{\tt IF A == 10 OR A < B THEN B-A->B : ELSE A-B->A : END:}
\subsection{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\'ee et == pour traduire la 
condition d'\'egalit\'e.\\
On \'ecrit 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  \'ecrire :\\
{\tt IF '(A==10) OR (A < B)' THEN ...}
\subsection{Traduction HP49G mode Alg\'ebrique} 
\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'\'egalit\'e) :\\
{\tt IF A == 10 OR A < B THEN B-A STO$\triangleright$ B  ELSE A-B STO$\triangleright$ A  END}
\subsection{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 \'ecrire (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}
\subsection{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}
\subsection{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}
\subsection{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}
\section{Les instructions "Pour" }
\noindent{\tt Pour I de A \`a B faire \emph{action} fpour}\\
{\tt Pour I de A \`a B (pas P) faire \emph{action} fpour}
\subsection{Traduction Casio}
\noindent{\tt For A->I To B : \emph{action} : Next}\\
{\tt For A->I To B  Step P : \emph{action} : Next}
\subsection{Traduction HP38G HP40G}
\noindent{\tt FOR I = A TO B STEP 1 ; \emph{action} : END:}\\
{\tt FOR I = A TO B STEP P ; \emph{action} : END:} 
\subsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt A B FOR I  \emph{action} NEXT}\\ 
{\tt A B FOR I  \emph{action} P STEP}
\subsection{Traduction HP49G mode Alg\'ebrique} 
\noindent{\tt FOR (I, A, B) \emph{action} NEXT}\\
{\tt FOR (I, A, B ) \emph{action} STEP P}\\ 
L'instruction {\tt FOR} d\'eclare {\tt I} comme  variable locale et l'initialise
 automatiquement. 
\subsection{Traduction TI80 TI82 83+}
\noindent{\tt :For (I,A,B ): \emph{action} : End}\\
{\tt:For (I,A,B,P ): \emph{action} : End}
\subsection{Traduction TI89 92}
\noindent{\tt :For I,A,B : \emph{action} : EndFor}\\ 
{\tt:For I,A,B,P : \emph{action} : EndFor}
\subsection{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}
\section{L'instruction ``Repeter''}
\noindent{\tt Repeter
\emph{action}
 jusqua \emph{ condition}} 

\subsection{Traduction Casio}
\noindent{\tt Do : 
\emph{action}: 
LpWhile \emph{ condition}}
\subsection{Traduction HP38 HP40G}
\noindent{\tt DO  
\emph{action} : 
UNTIL \emph{condition} 
END:}
\subsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt DO  
\emph{action} 
UNTIL \emph{condition} 
END}
\subsection{Traduction HP49G mode Alg\'ebrique} 
\noindent{\tt DO 
\emph{action} 
UNTIL \emph{condition} 
END}
\subsection{Traduction TI80}
\noindent{\tt :LBL 1}\\
{\tt :\emph{action} :IF  \emph{non condition} :THEN 
:GOTO 1\\ :END} 
\subsection{Traduction TI82 83+}
\noindent{\tt :Repeat \emph{condition}  :
\emph{action} : 
End}
\subsection{Traduction TI89 92}
\noindent{\tt :Loop  
:\emph{action} 
:If \emph{condition}  :Exit 
:EndLoop}
\subsection{Traduction SHARP EL9600} 
\noindent{\tt Label REPETER}\\
{\tt \emph{action}}\\
{\tt If \emph{non condition} Goto REPETER}
\section{L'instruction ``Tant que''}
\noindent{\tt Tant que \emph{condition} faire
\emph{action}
ftantque}
\subsection{Traduction Casio}
\noindent{\tt While  \emph{condition} : 
\emph{action} : 
WhileEnd:}
\subsection{Traduction HP38G HP40G}
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} : 
END:}
\subsection{Traduction HP48 ou HP49G mode RPN}
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsection{Traduction HP49G mode Alg\'ebrique} 
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsection{Traduction TI80}
\noindent{\tt :LBL 1}\\
{\tt :IF  \emph{condition} :THEN :\emph{action}\\
:GOTO 1\\ :END} 
\subsection{Traduction TI82 83+}
\noindent{\tt :While  \emph{condition}  :
\emph{action} : 
End}
\subsection{Traduction TI89 92}
\noindent{\tt :While  \emph{condition}  :
\emph{action} : 
EndWhile} 
\subsection{Traduction SHARP EL9600} 
\noindent{\tt Label DTANTQUE}\\
{\tt If \emph{non condition} Goto FTANTQUE}\\
{\tt \emph{action}}\\
{\tt Goto DTANTQUE }\\
{\tt Label FTANTQUE}
\section{Les conditions ou expressions bool\'eennes }
Une condition est une fonction qui a comme valeur un bool\'een, \`a savoir elle
est soit {\tt vraie} soit {\tt fausse}.
\subsection{Les op\'erateurs relationnels}
Pour exprimer une condition simple on utilise les op\'erateurs :\\
{\tt = > > $\leq$  $\geq$  $\neq$}\\
Attention pour les calculatrices HP l'\'egalit\'e se traduit  comme en langage {\tt C} par :\\
{\tt ==}
\subsection{Les op\'erateurs logiques}
Pour traduire des conditions complexes, on utilise les op\'erateurs logiques :\\
{\tt ou et non} \\
qui se traduisent sur les calculatrices par :\\
{\tt or and not} \\
Attention!!! \label{sec:oplog}
Je ne les ai pas trouv\'es 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\'eser et \'ecrire (A) or (B) par exemple.
\section{Les fonctions}
Dans une fonction on ne fait pas de saisie de donn\'ees :
on utilise des param\`etres qui seront initialis\'es lors de l'appel.\\
Dans une fonction on veut pouvoir r\'eutiliser le r\'esultat :\\
on n'utilise pas la commande {\tt affichage} mais la commande {\tt retourne}.\\
On \'ecrit par exemple en algorithmique :
\begin{verbatim}
fonction addition(A,B)
retourne A+B
ffonction
\end{verbatim}
Cela signifie que :\\
- Si on fait ex\'ecuter la fonction, ce qui se trouve juste apr\`es {\tt retourne} sera affich\'e, mais les instructions qui suivent {\tt retourne} seront ignor\'ees.\\
- On peut utiliser la fonction dans une expression.\\
On ne peut pas \'ecrire de fonctions avec les calculatrices {\tt Casio SHARPEL9600 HP38G, HP40G TI83+}.
\subsection{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'\'ecriture de la fonction les arguments sont  des variables locales
qui seront initialis\'ees par les \'elements mis sur la pile. Le r\'esultat 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\'es 
l'ex\'ecution d'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}   
\subsection{Traduction HP49G mode Alg\'ebrique} 
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)}$$
\subsection{Traduction TI89 92}
\begin{verbatim}
:addition(a,b)
:Func
:Return a+b
:EndFunc
\end{verbatim}
\section{Les listes}
On utilise les \{ \} pour d\'elimiter une liste.\\
Attention!!!
En algorithmique on a choisit cette notation car c'est celle qui est employ\'ee
par les calculatrices...\`a ne pas confondre avec la notion d'ensemble en
 math\'ematiques : dans un ensemble l'ordre des \'el\'ements n'a pas d'importance
mais dans une liste l'ordre est important...
 Par exemple \{\} d\'esigne la liste vide et \{1, 2, 3\} est une liste de 3 \'el\'ements.\\
Concat sera utilis\'e pour concat\'ener 2 listes ou une liste et un \'el\'ement ou 
un \'el\'ement et une liste :\\
{\tt \{1, 2, 3\}->TAB}\\
{\tt Concat(TAB, 4) ->TAB}  (maintenant {\tt TAB} d\'esigne \{1, 2, 3, 4\} \\
{\tt TAB[2]} d\'esigne le deuxi\`eme \'el\'ement de {\tt TAB} ici 2.
\subsection{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\'epart le nombre d'\'el\'ements
 de la liste avec la commande {\tt Dim List} par exemple :\\
{\tt 10->Dim List 1} ({\tt List 1} d\'esigne alors une liste de 10 \'el\'ements nuls).\\
On peut utiliser les commandes suivantes :\\
{\tt seq(i*i, i, 1, 10, 2)} d\'esigne la liste des carr\'es des 5 premiers entiers impairs. \\
{\tt List 1[i]} d\'esigne le i\`eme \'el\'ement de la liste {\tt List 1}.
\subsection{Traduction HP38G HP40G}
Ici les listes peuvent avoir des longueurs non d\'efinies \`a l'avance.\\
Les variables listes ont pour noms : {\tt L0, L1, L2, ... L9}.\\
On utilise les \{ \} pour d\'elimiter une liste.\\
Par exemple \{1, 2, 3\} est une liste de 3 \'el\'ements.\\
 Mais \{\} ne d\'esigne pas la liste vide :\\
- avec la {\tt HP38G} il faut utiliser la commande {\tt CLEAR L1} pour initialiser la liste {\tt L1} \`a vide.\\
- avec la {\tt HP40G} il faut utiliser la commande 
{\tt SYSEVAL 259588} pour initialiser la liste {\tt L0} \`a vide ({\tt SYSEVAL 259589} pour initialiser {\tt L1} \`a vide etc...).\\
On peut aussi utiliser la commande {\tt SUB}:\\
{\tt SUB L0;L0;2;1} initialise la liste {\tt L0} \`a vide.\\
Voici quelques commandes utiles :\\
{\tt MAKELIST(I*I, I , 1, 10, 2)}  d\'esigne la liste des carr\'es des 5 premiers entiers impairs ( 2 indique le pas de {\tt I}). \\
{\tt L1(I)}  d\'esigne le {\tt I}\`eme \'el\'ement de la liste.\\
{\tt CONCAT (L1, \{5\})} d\'esigne une liste ayant l'\'el\'ement 5 en plus des \'el\'ements de la liste {\tt L1}.\\
{\tt SUB L1;L0;2;4} met dans {\tt L1} la suite extraite de {\tt L0} compos\'ee des \'el\'ements d'indice allant de 2 \`a 4 (si {\tt L0=\{1,2,3,4,5\}} on aura
{\tt L1=\{2,3,4\}}.
\subsection{Traduction HP48 ou HP49G mode RPN}
Ici les listes peuvent avoir des longueurs non d\'efinies \`a l'avance.\\
On utilise les \{\} pour d\'elimiter une liste.\\
Par exemple \{1 2 3\} est une liste de 3 \'el\'ements et \{\} d\'esigne la liste vide.\\
On obtient le {\tt P}i\`eme \'el\'ement de {\tt L} sur la pile  avec :\\
{\tt L P GET}\\
Si on veut modifier le {\tt P}i\`eme \'el\'ement de {\tt L} (par exemple le mettre \`a 0)  on \'ecrira :\\
{\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\'ee alors que :\\
{\tt 'L' P 0 PUT}
modifie la liste {\tt L}.\\
Pour concat\'ener deux listes ou une liste et un \'el\'ement on utilise le {\tt +}
ou  on utilise la commande {\tt AUGMENT}.\\
Remarque : c'est la commande {\tt ADD}) qui permet d'ajouter deux listes de m\^emes longueurs.
\subsection{Traduction HP49G mode Alg\'ebrique} 
Pour la {\tt HP49G} en mode alg\'ebrique, les listes peuvent avoir des longueurs non d\'efinies \`a l'avance.\\
On utilise les \{\} pour d\'elimiter une liste.\\
Par exemple \{1 2 3\} est une liste de 3 \'el\'ements et \{\} d\'esigne la liste vide.\\
On obtient le {\tt P}i\`eme \'el\'ement 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\`eme \'el\'ement de {\tt L} (par exemple le mettre \`a 0)  on \'ecrira :\\
{\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\'ee (sans modifier {\tt L}) 
alors que :\\
{\tt PUT ('L', P, 0) } modifie la liste {\tt L}.\\
Pour concat\'ener deux listes ou une liste et un \'el\'ement on utilise le  {\tt +} 
(et pour ajouter deux listes de m\^emes longueurs on utilise la commande {\tt ADD}).\\
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\}}$$
\subsection{Traduction TI80}
Les variables listes ont comme noms {\tt L1, L2, L3, L4, L5, L6}.\\
La commande {\tt DIM} permet de cr\'eer une nouvelle liste (faite de z\'eros) ou 
de redimensionner une liste existante (num\'ero 3 du menu {\tt OPS} de la 
touche {\tt 2nd STAT (LIST)}), par exemple :\\
${\tt N ->DIM\ L1}$  : il y a deux possibilit\'es,\\
soit ${\tt L_1}$ n'existait pas alors ${\tt L_1}$ est cr\'e\'ee  et contient une liste de z\'eros de longueur {\tt N}, \\ 
 soit  ${\tt L_1}$ existait, cette commande donne  alors \`a  ${\tt L_1}$ la dimension
{\tt N}  (soit en supprimant des termes, soit en rajoutant des z\'eros).\\
La commande {\tt SEQ} permet de g\'en\'erer une liste (num\'ero 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\'eer la liste :\\
\{0, 4, 16, 36, 64, 100\} c'est \`a dire la liste des carr\'es de 0 \`a 10 avec un 
pas de 2 que l'on stocke dans {\tt L1}.\\
\subsection{Traduction TI83+}
Les variables listes ont des noms pr\'ed\'efinis ${\tt L_1, L_2, L_3, L_4, L_5, L_6}$ ou bien peuvent avoir
un nom de 1 \`a 5 caract\`eres mais alors il faudra faire pr\'ec\'eder ce nom du 
symbole $\llcorner$ (que l'on trouve dans {\tt 2nd LIST OPS B}) pour d\'esigner
 cette variable.\\ 
Mais \{\} ne d\'esigne 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}$ \`a vide).\\
La commande {\tt dim} permet de cr\'eer une nouvelle liste (faite de z\'eros) 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\'es,\\
soit ${\tt L_1}$ n'existait pas alors ${\tt L_1}$ est cr\'e\'ee  et contient une liste de z\'eros de longueur {\tt N}, \\ 
 soit  ${\tt L_1}$ existait, cette commande donne  alors \`a  ${\tt L_1}$ la dimension
{\tt N}  (soit en supprimant des termes, soit en rajoutant des z\'eros).\\
La commande {\tt seq} permet de g\'en\'erer 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\'eer la liste :\\
\{0, 4, 16, 36, 64, 100\} c'est \`a dire la liste des carr\'es de 0 \`a 10 avec un 
pas de 2 que l'on stocke dans {\tt TAB}.\\
${\tt \llcorner TAB(2)}$ d\'esigne le deuxi\`eme \'el\'ement de {\tt TAB} ici 4.\\
On peut aussi \'ecrire :\\
${\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 \'el\'ement (par 
exemple 25) \`a  ${\tt L_1}$ en \'ecrivant :\\
${\tt 25 -> L_1(N+1)}$ \\
{\tt augment} permet de concat\'ener deux listes (en position 9 du menu
 {\tt OPS} de la touche {\tt 2nd STAT (LIST)}).
\subsection{Traduction TI89-92}
{\tt augment} permet de concat\'ener deux listes.\\
\{\}  d\'esigne la liste vide.
Pour travailler avec des listes, on peut  initialiser une  liste de
 {\tt n} \'el\'ements  avec la commande {\tt newlist},  par exemple :\\
{\tt newlist(10)->L} ({\tt L} est alors une liste de 10 \'el\'ements nuls).\\
On peut utiliser les commandes suivantes :\\
{\tt seq(i*i, i, 1, 10)} qui d\'esigne la liste des carr\'es des 10 premiers entiers, ou {\tt seq(i*i, i, 0, 10, 2)} qui d\'esigne la liste des carr\'es des 5 premiers entiers pairs (le pas est ici \'egal \`a 2). \\
Exemple :\\
${\tt seq(i*i, i, 0, 10, 2) ->L}$  va par exemple cr\'eer la liste :\\
\{0, 4, 16, 36, 64, 100\} c'est \`a dire la liste des carr\'es de 0 \`a 10 avec un 
pas de 2 que l'on stocke dans {\tt L}.\\
{\tt L[i] } qui d\'esigne le i\`eme \'el\'ement de la liste {\tt L}.\\
On peut aussi \'ecrire :\\
{\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 \'el\'ement (par 
exemple 121) \`a  ${\tt L}$ en \'ecrivant :\\
{\tt 121 -> L[n+1]} \\
Dans l'exemple pr\'ec\'edent {\tt n=6} on peut donc \'ecrire :\\
{\tt 121 -> L[7]} ({\tt L} est alors \'egale \`a \{0, 2, 16, 36, 64, 100, 121\}).\\
{\tt left (L, 5)} d\'esigne les 5 premiers \'el\'ements de la liste {\tt L}.
\subsection{Traduction SHARP EL9600} 
Ici les listes peuvent avoir des longueurs non d\'efinies \`a l'avance.\\
Les variables listes ont pour noms : {\tt L1, L2, L3...L6}.\\
On utilise les \{ \} pour d\'elimiter une liste.\\
Par exemple \{1, 2, 3\} est une liste de 3 \'el\'ements.\\
 Mais \{\} ne d\'esigne 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} \`a 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\'esigne la liste des carr\'es des 5 premiers 
entiers impairs ( 2 indique le pas de la variable qui est toujours {\tt X}). \\
{\tt L1(I)}  d\'esigne le {\tt I}\`eme \'el\'ement de la liste.\\
{\tt augment(L1, \{5\})}  d\'esigne une liste ayant l'\'el\'ement 5 en plus des \'el\'ements 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\'eer une nouvelle liste (faite de z\'eros) ou 
de redimensionner une liste existante :\\
{\tt N ->dim(L1)} cr\'ee {\tt L1} une liste de z\'eros de longueur {\tt N}.\\  
mais si {\tt L1} existait, cette commande donne \`a {\tt L1}  la dimension 
{\tt N} (soit en supprimant des termes, soit en rajoutant des z\'eros).\\
Si {\tt L1} est de longueur {\tt N}  on peut rajouter un \'el\'ement (par exemple
 25) \`a {\tt L1} en \'ecrivant :\\
{\tt 25 -> L1(N+1)} 
\section{Un exemple : le crible d'Eratosth\`ene}
\subsection{Description}
Pour trouver les nombres premiers inf\'erieurs ou \'egaux \`a $N$ :
\begin{enumerate}
\item On \'ecrit les nombres de 1 \`a $N$ dans une liste.
\item On barre 1 et on met 2 dans la case $P$ .\\
Si $P \times P \leq N$ il faut traiter les \'el\'ements de $P$ \`a $N$. 
\item On barre tous les multiples de $P$ \`a partir de $P . P$.
\item On augmente $P$ de 1.\\
Si $P\times P$ est inf\'erieur ou \'egal \`a $N$, il reste \`a traiter les \'el\'ements non barr\'es de $P$ \`a $N$. 
\item On appelle $P$ le plus petit \'el\'ement non barr\'e de la liste.
\item On refait les points 3 4 5 tant que $P \times P$ reste inf\'erieur ou \'egal \`a $N$.
\end{enumerate}
\subsection{\'Ecriture de l'algorithme}
\begin{verbatim}
Fonction crible(N)
local TAB PREM I P
// TAB et PREM sont des listes
{} ->TAB
{} ->PREM
pour I de 2 \`a N faire 
  concat(TAB, I) -> TAB
fpour
concat(0, TAB) -> TAB
2 -> P
// On a fait les points 1 et 2
//barrer 1 a \'et\'e r\'ealis\'e en le rempla\c{c}ant par 0
//TAB est la liste 0 2 3 4 ...N \end{verbatim}
{\tt tant que P*P $\leq$ N faire}\begin{verbatim}
  pour I de P \`a E(N/P) faire
//E(N/P) d\'esigne la partie enti\`ere de N/P
    0 -> TAB[I*P]
  fpour
// On a barr\'e tous les multiples de P \`a partir de P*P
  P+1 -> P
//On cherche le plus petit nombre <= N non barr\'e (non nul) entre P et N\end{verbatim}
 {\tt {\  }  tant que (P*P $\leq$ N) et (TAB[P]=0) faire}
\begin{verbatim}
    P+1 -> P
  ftantque
ftantque
//on \'ecrit le r\'esultat dans une liste PREM
pour I de 2 \`a N faire\end{verbatim}
 {\tt {\  } si TAB[I]  $\neq$ 0 alors} 
\begin{verbatim}      
    concat(PREM, I) -> PREM
  fsi
fpour
r\'esultat: PREM
\end{verbatim}
\subsection{Traduction Casio}
Voici le programme CRIBLE :\\
\begin{verbatim}
``N''?->N
N->Dim List 1
N->Dim List 2
Seq(I,I,1,N,1)->List 1
0->List 1[1]
2->P\end{verbatim}
{\tt While P*P$\leq$N}\begin{verbatim}
For P->I To Int (N/P)
0->List 1[I*P]
Next
P+1->P\end{verbatim}
{\tt While P*P$\leq$N And List 1[P]=0}\begin{verbatim}
P+1->P
WhileEnd
WhileEnd
0->P
For 2->I To N\end{verbatim}
{\tt If List 1[I]$\neq$0}\begin{verbatim}
Then P+1->P
I->List 2[P]
IfEnd
Next\end{verbatim}
{\tt P$\triangle$\\
List 2$\triangle$}
\subsection{Traduction HP38G HP40G}
Voici le programme CRIBLE :\\
L'utilisateur doit entrer la valeur de N.\\
A la fin la liste L2 contient les nombres premiers inf\'erieurs ou \'egaux \`a N.
\begin{verbatim}
INPUT N;"CRIBLE";"N=";;10:
ERASE:
MAKELIST(I,I,1,N,1) -> L1:
0 -> L1(1):
2->P:\end{verbatim}
{\tt WHILE P*P $\leq$ N REPEAT}\begin{verbatim}
  FOR I = P TO INT(N/P) STEP 1;
    0->L1(I*P):
  END: 
  DISP 3;""L1:
  P+1->P:\end{verbatim}
{\tt {\  } WHILE P*P $\leq $ N AND L1(P) == 0 REPEAT}\begin{verbatim}
    P+1->P:
  END:
END:
{2}->L2:
@ on sait que 2 est premier
FOR I=3 TO N  STEP 1;\end{verbatim}
{\tt {\  }IF L1(I) $\neq$ 0 THEN}\begin{verbatim}
  CONCAT(L2,{I}) ->L2:
  END:
END:
DISP 3 ;"PREM" L2:
FREEZE:
\end{verbatim}
\subsection{Traduction HP48 ou HP49G mode RPN}
Voici le programme CRIBLE :\\
N est le param\`etre qui doit \^etre mis sur la pile.\\
Les variables locales sont :\\
P et I qui sont des entiers,\\
TA et PREM qui sont des listes.\\
${\tt \ll \ \{\}\ \{\}\ 2\ 1\  \rightarrow\ N \ TA\ PREM\ P\ I }$\\
\hspace*{0.5cm}${\tt \ll\ 0\ 'X'\ 'X'\ 2\ N\ 1\ SEQ\ +\ 'TA'\ STO}$\\ 
\hspace*{1cm}{\tt WHILE P P * N  $\leq$ REPEAT \\
\hspace*{1.5cm}    P N P / FLOOR FOR I \\
\hspace*{2cm}      TA I P * 0 PUT 'TA' STO\\
\hspace*{1.5cm}    NEXT\\ 
 \hspace*{1.5cm}   1 'P' STO+\\
\hspace*{1.5cm} WHILE P P *  N $\leq$  TA P GET 0 == AND REPEAT \\
 \hspace*{2cm}     1 'P' STO+\\
 \hspace*{1.5cm}   END\\
\hspace*{1cm}  END \\
 \hspace*{1cm} 2 N FOR I\\
 \hspace*{1.5cm} IF TA I GET 0 $\neq$ THEN\\
  \hspace*{2cm}     I 'PREM' STO+\\
 \hspace*{1.5cm}    END\\
 \hspace*{1cm}  NEXT \\
 \hspace*{1cm}  PREM} \\
 \hspace*{.5cm}${\tt \gg}$\\
 ${\tt \gg}$\\
Puis on stocke ce programme dans {\tt CRIBLE ('CRIBLE' STO)}.
\subsection{Traduction HP49G mode Alg\'ebrique} 
Voici le programme CRIBLE \'ecrit pour la {\tt HP49G mode Alg\'ebrique} :\\
L'utilisateur doit taper par exemple :\\
{\tt CRIBLE(100)}.\\
\noindent
${\tt \ll \ \rightarrow\ N \  }$\\
\hspace*{0.5cm}${\tt \ll}${\tt\ 0+SEQ('I','I',1,N,1) $\rightarrow$ TA}\\
\hspace*{1cm}${\tt \ll \ 2\ \rightarrow\ P}$\\
\hspace*{1.5cm}${\tt \ll WHILE\ P*P \leq  N\ REPEAT}$\\
\hspace*{2cm}{\tt  FOR (I , P , FLOOR(N/P))}\\
\hspace*{2.5cm}{\tt    PUT('TA',I*P,0)}\\
\hspace*{2cm}{\tt  NEXT;}\\
\hspace*{2cm} ${\tt P+1\  STO\triangleright P;}$\\
\hspace*{2cm}{\tt  WHILE P*P $\leq $ N AND TA[P] == 0 REPEAT}\\
\hspace*{2.5cm}   ${\tt  P+1\ STO \triangleright \ P}$\\
\hspace*{2cm}{\tt  END}\\
\hspace*{1.5cm}{\tt END;}\\
\hspace*{1.5cm}${\tt \{2\} \ \rightarrow\ PREM}$\\
\hspace*{2cm}${\tt \ll FOR\ (I,3 , N) }$\\
\hspace*{2.5cm}{\tt {\  }IF TA[I] $\neq$ 0 THEN}\\
\hspace*{3cm} $ {\tt PREM+I \  STO\triangleright PREM;}$\\
\hspace*{2.5cm}  {\tt END}\\
\hspace*{2cm}{\tt NEXT;}\\
\hspace*{2cm}{\tt PREM }\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1.5cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ CRIBLE}$
\subsection{Traduction TI80}
Voici le programme CRIBLE : on entre N et ensuite la liste $L_2$  est \'egale \`a la liste des nombres premiers inf\'erieurs ou \'egaux \`a N.\\
{\tt PROGRAM:CRIBLE\\
:INPUT N}\\
${\tt :SEQ(I,I,1,N,1) ->L1}$\\
${\tt :0 -> L1(1)}$\\
{\tt :2 -> P }\\
{\tt :LBL 1}\\
{\tt :IF P*P $\leq$ N}\\
{\tt :THEN}\\
{\tt :FOR (I,P,INT(N/P))}\\
${\tt :0 -> L1(I*P)}$\\
{\tt:END\\
:P+1 -> P\\
:LBL 2}\\
${\tt :IF\  (P*P) \leq N }$\\
{\tt :THEN}\\
${\tt :IF\  L1(P)=0}$\\
{\tt :THEN}\\
{\tt :P+1 -> P\\
:GOTO 2\\
:END\\
:END\\
:GOTO 1\\
:END\\
:0 -> P\\
:FOR (I,2,N)}\\
${\tt :IF\  L1(I) \neq 0 }$\\
{\tt :THEN\\
:P+1 ->P}\\
${\tt :I -> L2(P)}$\\
{\tt :END\\
:END\\
:L2}\\
Il n'y a pas ici de notion de variables locales ou de programmes avec des
param\`etres : toutes les variables sont globales.\\
Je n'ai pas trouv\'e la fonction bool\'eenne {\tt AND} : j'ai donc mis deux 
{\tt IF} successifs.
La derni\`ere instruction permet d'afficher la liste $L2$ des nombres premiers
inf\'erieurs ou \'egaux \`a N. Si   \`a l'affichage  la liste 
$L2$ n'est pas visible en entier, il faut appuyer sur $\triangleright$
pour faire d\'efiler la liste.
\subsection{Traduction TI83+}
Voici le programme CRIBLE : on entre N et ensuite la liste $L_2$  est \'egale \`a la liste des nombres premiers inf\'erieurs ou \'egaux \`a N.\\
{\tt PROGRAM:CRIBLE\\
:Input N}\\
${\tt :seq(I,I,1,N) ->L_1}$\\
${\tt :0 -> L_1(1)}$\\
{\tt :2 -> P }\\
{\tt :While P*P $\leq$ N}\\
{\tt :For (I,P,int(N/P))}\\
${\tt :0 -> L_1(I*P)}$\\
{\tt:End\\
:P+1 -> P}\\
${\tt :While\  (P*P) \leq N \ and\  L_1(P)=0}$\\
{\tt :P+1 -> P\\
:End\\
:End\\
:0 -> P\\
:For (I,2,N)}\\
${\tt :If\  L_1(I) \neq 0 }$\\
{\tt :Then\\
:P+1 ->P}\\
${\tt :I -> L_2(P)}$\\
{\tt :End\\
:End}\\
${\tt :P->dim( L_2)}$\\
${\tt :Disp\ L_2}$\\
Il n'y a pas ici de notions de variables locales ou de programmes avec des
param\`etres : toutes les variables sont globales.\\
La derni\`ere instruction permet d'afficher la liste $L_2$ des nombres premiers
inf\'erieurs ou \'egaux \`a N. Si   \`a l'affichage  la liste 
$L_2$ n'est pas visible en entier, il faut appuyer sur $\triangleright$
pour faire d\'efiler la liste ou encore il faut se servir de la 
touche {\tt STAT} puis {\tt EDIT} qui permet d'afficher les listes $L_i$ 
\subsection{Traduction TI89 92}
Voici la fonction crible :\\
- n est le param\`etre de cette fonction.\\
- crible(n) est \'egal \`a la liste des nombres premiers inf\'erieurs ou \'egaux \`a n.
\begin{verbatim}:crible(n)
:Func
:local tab,prem,i,p
:newList(n)->tab
:newList(n)->prem
:seq(i,i,1,n) ->tab
:0 -> tab[1]
:2 -> p \end{verbatim}
:{\tt While p*p $\leq$ n}\begin{verbatim}
:For i,p,floor(n/p)
:0 -> tab[i*p]
:EndFor
:p+1 -> p\end{verbatim}
:{\tt While p*p $\leq$ n and tab[p]=0}\begin{verbatim}
:p+1 -> p
:EndWhile
:EndWhile
:0 -> p
:For i,2,n\end{verbatim}
:{\tt If tab[i] $\neq$ 0 Then}\begin{verbatim}
:p+1 ->p
:i ->prem[p]
:EndIf
:EndFor
:Return left(prem,p)
:EndFunc\end{verbatim}
\subsection{Traduction SHARP EL9600}
L'\'ecriture du programme CRIBLE est ici assez fastidieux : on a choisi des 
noms de labels courts mais parlant....(DTQ1 veut dire D\'ebut du TantQue $n^{o}1$)\\
{\tt CRIBLE}\\
{\tt Input N}\\
${\tt \{2\} \Rightarrow L2}$\\
${\tt seq(X,1,N) \Rightarrow L1}$\\
${\tt 0 \Rightarrow L1}$\\
${\tt 2 \Rightarrow P}$\\   
{\tt Label DTQ1}\\
{\tt If P*P>N Goto FTQ1}\\
${\tt P \Rightarrow I}$\\
{\tt Label DP1}\\
 {\tt If I>int (N/P) Goto FP1}\\
${\tt 0 \Rightarrow L1(I*P)}$\\
${\tt I+1 \Rightarrow I}$\\
{\tt Goto DP1}\\
{\tt Label FP1}\\
${\tt P+1 \Rightarrow P}$\\
{\tt Label DTQ2}\\
${\tt If\ (P*P>N)\ or\ (L1(P) \neq 0)\ Goto\ FTQ2}$\\
 ${\tt P+1 \Rightarrow P}$\\
{\tt Goto DTQ2}\\ 
{\tt Label FTQ2}\\
{\tt Goto DTQ1}\\ 
{\tt Label FTQ1}\\
${\tt 3 \Rightarrow I}$\\
${\tt 1 \Rightarrow P}$\\ 
{\tt Label DP2}\\
{\tt If I>N Goto FP2}\\
${\tt If\ L1(I) = 0)\ Goto\ FSI}$\\
${\tt P+1 \Rightarrow P}$\\
${\tt I \Rightarrow L2(P)}$\\ 
{\tt Label FSI}\\
${\tt I+1 \Rightarrow I}$\\
{\tt Label FP2}\\
{\tt Print L2}\\
{\tt End}\\
Il n'y a pas ici de notions de variables locales ou de programmes avec des
param\`etres : toutes les variables sont globales.\\
La derni\`ere instruction permet d'afficher la liste $L2$ des nombres premiers
inf\'erieurs ou \'egaux \`a N. Si   \`a l'affichage  la liste 
L2 n'est pas visible en entier, il faut retourner dans l'\'ecran {\tt HOME},
puis taper L2, puis appuyer sur $\triangleright$
pour faire d\'efiler la liste ou encore il faut se servir de la 
touche {\tt STAT} puis {\tt EDIT} et {\tt ENTER} qui permet d'afficher les listes $Li$ 
\subsection{Exercice}
Pour am\'eliorer l'algorithme ci-dessus, on n'\'ecrit dans le crible que les
 nombres impairs.\\
Refaire alors l'algorithme puis, \'ecrire le programme correspondant pour votre calculatrice.
\chapter{Les programmes d'arithm\'etique}
\section{Calcul du PGCD par l'algorithme d'Euclide}
Soient $A$ et $B$ deux entiers positifs dont on cherche le $PGCD$.\\
L'algorithme d'Euclide est bas\'e sur la d\'efinition r\'ecursive 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\'esigne 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\`es un nombre fini d'\'etapes, 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\'erative\\
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'\`a 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\'esultat A
ffonction
\end{verbatim}

 -Version r\'ecursive\\
On \'ecrit simplement la d\'efinition r\'ecursive vue plus haut.
\begin{verbatim}
Fonction PGCD(A,B)\end{verbatim}
{\tt Si B $\neq$ 0 alors}\begin{verbatim}
  r\'esultat PGCD(B,A mod B) 
  sinon
  r\'esultat A
fsi
ffonction\end{verbatim}
\subsection{Traduction Casio}
-Version it\'erative :\\
On d\'efinit 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\'ecursive.
\subsection{Traduction HP38G HP40G}
-Version it\'erative

On \'ecrit 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 \'ecrit 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\'ecursive...mais on peut \'ecrire 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\'ediaires qui sont calcul\'es.
L'appel r\'ecursif  PGCDR renvoie  au programme PGCDR qu'il  faut faire
 ex\'ecuter en appuyant sur le RUN du bandeau.
\subsection{Traduction HP48 HP49G mode RPN}
-Version it\'erative\\
${\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\'ecursive\\
${\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\'ebrique}
-Version it\'erative\\
\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\'ecuter.\\

-Version r\'ecursive\\
\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\'ecuter.\\
Remarque :\\
Si on utilise la fonction du calcul symbolique {\tt IREMAINDER} \`a la place de
{\tt MOD} dans les programmes pr\'ec\'edents, {\tt PGCD} (ou {\tt PGCDR}) peut alors avoir comme 
param\`etres des entiers de Gauss (c'est \`a dire les nombres $a+i\cdot b$ avec $a$ et $b$ entiers relatifs).  
\subsection{Traduction TI80}
-Version it\'erative\\
{\tt PROGRAM:PGCD\\
:INPUT A\\
:INPUT B\\
:LBL 1}\\
{\tt :IF B $\neq$ 0 }
\begin{verbatim}
:THEN
:A-INT(A/B)*B->R
:B->A
:R->B
:GOTO 1
:END
:DISP A
\end{verbatim}

-Pas de version r\'ecursive.
\subsection{Traduction TI83+}
-Version it\'erative\\
{\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\'ecursive.
\subsection{Traduction TI89 92}
-Version it\'erative
\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\'ecursive
\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\'erative :\\
{\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\'ecursive.
\section{Identit\'e de B\'ezout par l'algorithme d'Euclide}
 Dans ce paragraphe la fonction Bezout(A,B) renvoie  la liste $\{U, V, PGCD(A,B)\}$
o\`u $U$ et $V$ v\'erifient :
   
$ A \times U + B \times V = PGCD(A,B). $ 
\subsection{Version it\'erative sans les listes}
L'algorithme d'Euclide permet de trouver un couple $U$ et $V$ v\'erifiant:

$ A \times U + B \times V= PGCD(A,B) $

En effet, si on note $ A_0$ et$ B_0 $ les valeurs de $A$ et de $B$ du d\'ebut on a :
\begin{eqnarray*}
 A & =A_0 \times U+B_0 \times V \ \  avec \  U=1 \ et\  V=0 \\ 
 B & =A_0 \times W+B_0 \times X  \ \ avec \  W=0 \ et \  X=1 
\end{eqnarray*}

 Puis on fait \'evoluer $A,\ B,\ U,\ V,\ W,\ X$ de fa\c{c}on que les deux relations
 ci-dessus soient toujours v\'erifi\'ees.

Si:

$ A=B \times Q+R \ \ \  0 \leq R < B \ \ ( R = A \ mod \ B \ et \  Q = E(A / B )) $

On \'ecrit alors :
\begin{eqnarray*}
R=A-B \times Q=A_0 \times (U-W \times Q)+B_0 \times (V-X \times Q)=A_0 \times S+B_0 \times T \\
avec \  S=U-W \times Q \   et \   T=V-X \times Q
\end{eqnarray*}
Il reste alors \`a recommencer avec $B$ dans le r\^ole de $A$ ({\tt B->A\  W->U \ X->V}) et $R$ dans le r\^ole de $B$ ({\tt R->B \ S->W \ T->X} ) d'o\`u l'algorithme:

\begin{verbatim}
fonction Bezout (A,B)
local U,V,W,X,S,T,Q,R
1->U 0->V 0->W 1->X\end{verbatim}
{\tt tant que B $\neq$ 0 faire}\begin{verbatim}
A mod B->R 
E(A/B)->Q
//R=A-B*Q
U-W*Q->S
V-X*Q->T
B->A W->U X->V
R->B S->W T->X
ftantque
r\'esultat {U, V, A}
ffonction
\end{verbatim}
\subsection{Version it\'erative avec les listes}
On peut simplifier l'\'ecriture de l'algorithme ci-dessus en utilisant moins de
 variables : pour cela on utilise des listes LA LB LR pour m\'emoriser les
 triplets \{U, V, A\} \{W, X, B\} et \{S, T, R\}.
Ceci est tr\`es commode car les calculatrices savent ajouter des listes de m\^eme
 longueur (en ajoutant les \'el\'ements de m\^eme indice) et savent aussi 
multiplier une liste par un nombre (en multipliant chacun des \'el\'ements de la 
liste par ce nombre).\\
\begin{verbatim}
fonction Bezout (A,B)
local LA LB LR
{1, 0, A}->LA
{0, 1, B}->LB\end{verbatim}
{\tt tant que LB[3] $\neq$ 0 faire}\begin{verbatim}
LA-LB*E(LA[3]/LB[3])->LR 
LB->LA 
LR->LB 
ftantque
r\'esultat LA
ffonction
\end{verbatim}
\subsection{Version r\'ecursive sans les listes}\label{sec:recsl}
Si on utilise des variables globales pour {\tt A B D U V T}, on peut voir la fonction {\tt Bezout} comme calculant \`a partir de {\tt A B}, des valeurs 
qu'elle met dans {\tt U V D (AU+BV=D)}  gr\^ace \`a une variable locale {\tt Q}.\\
On \'ecrit donc une fonction sans param\`etre : seule la variable {\tt Q} doit \^etre locale \`a la foncton alors que les autres variables {\tt A, B ...} 
peuvent \^etre  globales.\\
{\tt  Bezout} fabrique {\tt U, V, D}  v\'erifiant  {\tt A*U+B*V=D} \`a partir de {\tt A} et {\tt B}.
Avant l'appel r\'ecursif (on pr\'es\'erve {\tt E(A/B)=Q} et on  met {\tt A} et 
{\tt B} \`a jour ( nouvelles valeurs), apr\`es l'appel les variables  {\tt U, V, D}  v\'erifient 
 {\tt A*U+B*V=D} (avec {\tt A} et {\tt B} les nouvelles valeurs), il suffit 
alors de revenir aux premi\`eres valeurs de
{\tt A} et {\tt B} en \'ecrivant :   
{\tt B*U+(A-B*Q)*V=A*V+B*(U-V*Q)}  
On \'ecrit alors :
\begin{verbatim}
fonction Bezout
local Q \end{verbatim}
{\tt Si B $\neq$ 0 faire}\begin{verbatim}
E(A/B)->Q
A-B*Q->R
B->A
R->B
Bezout
U-V*Q->W
V->U
W->V
sinon 
1->U
0->V
A->D
fsi
ffonction
\end{verbatim}
\subsection{Version r\'ecursive avec les listes}
On peut d\'efinir r\'ecursivement la fonction Bezout par:

$ Bezout(A,0)=\{1,\ 0,\ A\} $  
   
Si $ B \neq 0 $ il faut d\'efinir $ Bezout(A,B)$ en fonction de $ Bezout(B,R)$ lorsque

$ R=A-B \times Q \ et \  Q=E(A/B).$

On a:
\begin{eqnarray*} Bezout(B,R)=LT=\{W, X, pgcd(B,R)\} \\
avec\  W \times B+X \times R=pgcd(B,R)
\end{eqnarray*}
Donc:
\begin{eqnarray*}
 W \times B+X \times (A-B \times Q) & = & pgcd(B,R) \  ou\  encore \\ 
X \times A+(W-X \times Q) \times B & = & pgcd(A,B).
\end{eqnarray*}
D'o\`u si $B \neq 0$ et si $ Bezout(B,R)=LT \  on \  a :$

$ Bezout(A,B)=\{LT[2],\ LT[1]-LT[2] \times Q,\ LT[3]\}.$

\begin{verbatim}
fonction Bezout (A,B)
local LT Q R\end{verbatim}
{\tt Si B $\neq$ 0 faire}\begin{verbatim}
E(A/B)->Q
A-B*Q->R
Bezout(B,R)->LT
R\'esultat {LT[2], LT[1]-LT[2]*Q, LT[3]}
sinon R\'esultat {1, 0, A} 
fsi
ffonction
\end{verbatim}
\subsection{Traduction Casio}
-Version it\'erative avec les listes\\
On d\'efinit 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 BEZOUT:
\begin{verbatim}
Prog ``INAB''
{1, 0, A}->List 1
{0, 1, B}->List 2\end{verbatim}
{\tt While List 2[3] $\neq$ 0 }\begin{verbatim}
List 1-List 2 * Int (List 1[3]/List 2[3])->List 3 
List 2->List 1
List 3->List 2
WhileEnd
``U V PGCD''\end{verbatim}
{\tt List\  1[1] $\triangle$\\
 List\ 1[2] $\triangle$\\
 List\ 1[3] $\triangle$\\}

-Pas de version r\'ecursive
\subsection{Traduction HP38G HP40G}
-Version it\'erative avec les listes

On utilise ici aussi le programme  IN qui permet de rentrer deux entiers A et
 B :
%HP38AscD 2 IN
\begin{verbatim}INPUT A;"A";;;1:
INPUT B;"B";;;1:
ERASE:\end{verbatim} 
%HP38AscD 6 BEZOUT
Puis on tape le programme BEZOUT :

\begin{verbatim}RUN IN:
DISP 3;"BEZOUT "{A,B}:
{1,0,A} ->L1:
{0,1,B} ->L2:\end{verbatim}
{\tt WHILE L2(3) $\neq$ 0 REPEAT} 
\begin{verbatim}L1-L2*FLOOR(L1(3)/L2(3)) ->L3:
L2 ->L1:
L3 ->L2:
END:
DISP 4;"U V PGCD "L1:
FREEZE:
\end{verbatim}
  
- Pour la {\tt HP40G}, version r\'ecursive sans les listes.\\
On \'ecrit le programme {\tt  BEZOUR}, gr\^ace aux commandes :\\
{\tt PUSH}\index{PUSH} ({\tt PUSH(A)} pour mettre le contenu de {\tt A} dans l'historique du {\tt CAS})\\
 et {\tt POP}\index{POP} (pour r\'ecup\'erer les valeurs mises dans l'historique du {\tt CAS})\\ 
{\tt PUSH} et {\tt POP} permettent de simuler la variable locale {\tt Q}
On a remplac\'e dans la  traduction (cf \ref{sec:recsl}) les variables {\tt R} et {\tt W} par la variable temporaire {\tt T}.\\
\noindent{\tt  PROGRAM BEZOUR}\\
{\tt IF B $\neq$ 0 THEN}\begin{verbatim}
PUSH (FLOOR(A/B)):
A MOD B->T:
B->A:
T->B:
RUN BEZOUR:
U-V*POP->T:
V->U:
T->V:
ELSE
 1->U:
 0->V:
 A->D: 
END:
\end{verbatim}

{\tt PUSH (FLOOR(A/B))} a pour effet de mettre les diff\'erentes valeurs de 
{\tt FLOOR(A/B)} sur une pile, et {\tt POP} de les r\'ecuperer.\\
{\tt T} est une variable auxillaire.\\
{\tt  BEZOUR} prend comme entr\'ee les valeurs des variables globales {\tt A} et
 {\tt B} et remplit les variables globales {\tt U} et {\tt V} de fa\c{c}on que :\\
${\tt A\cdot U+B\cdot V=PGCD(A,B)}$. \\
On \'ecrit ensuite le programme final {\tt  BEZOURT} permettant l'entr\'ee de 
{\tt A} et {\tt B} et la sortie de {\tt \{U, V, D\}}.\\

\noindent{\tt  PROGRAM BEZOURT}
\begin{verbatim}
PROMPT A:
PROMPT B:
RUN BEZOUR:
ERASE:
MSGBOX {U,V,D}:
\end{verbatim}
\noindent{\sc Remarque} :\\
Si on utilise la fonction de calcul symbolique {\tt IREMAINDER} \`a la place de
{\tt MOD} et {\tt IQUOT(A,B)} \`a la place de {\tt FLOOR(A/B)} dans les programmes pr\'ec\'edents, {\tt BEZOUT} ou {\tt BEZOUR} peut alors avoir comme 
param\`etres des entiers de Gauss \`a condition de remplacer les noms des variables {\tt A, B, R...} par {\tt Z1, Z2, Z3...}.\\  
{\sc Remarque} :\\
Si on utilise la fonction du calcul symbolique {\tt REMAINDER} \`a la place de
{\tt MOD} dans les programmes pr\'ec\'edents, {\tt BEZOUT} (ou {\tt BEZOUR}) peut alors avoir comme param\`etres des polyn\^omes\ \`a condition de remplacer les noms des variables {\tt A, B, R...} par {\tt E1, E2, E3...} et de changer le test d'arr\^et.
\subsection{Traduction HP48 ou HP49G mode RPN}
-Version it\'erative avec les listes

Au d\'ebut  A et B contiennent les deux nombres pour lesquels on cherche
l'identit\'e de B\'ezout, puis A et B d\'esignent les listes LA et LB de l'algorithme.
%%HP: T(3)A(R)F(.);
\begin{verbatim}
<< {} -> A B R   
  << {1 0} 'A' STO+
{0 1} 'B' STO+\end{verbatim}
{\tt WHILE  B 3 GET 0 $\neq$ REPEAT}
\begin{verbatim} A B A 3 GET B 3 GET / FLOOR * - 'R' STO
 B 'A' STO
 R 'B' STO  
END
A
   >> 
 >>
\end{verbatim}
Puis on stocke ce programme dans {\tt BEZOUT ('BEZOUT' STO)}.\\

-Version r\'ecursive avec les listes
%%HP: T(3)A(R)F(.);
\begin{verbatim}
<< {} -> A B T\end{verbatim}
{\tt \ \ << IF B 0 $\neq$ THEN}
\begin{verbatim}B A B MOD BEZOUR 'T' STO
 T 2 GET DUP A B / FLOOR *  
T 1 GET SWAP -
T 3 GET {} + + +
ELSE
 {1 0} A +
END
  >> 
 >>
\end{verbatim}
Puis on stocke ce programme dans {\tt BEZOUR ('BEZOUR' STO)}.
\subsection{Traduction HP49G mode Alg\'ebrique}
-Version it\'erative avec les listes

Au d\'ebut  A et B contiennent les deux nombres pour lesquels on cherche
l'identit\'e de B\'ezout, puis A et B d\'esignent les listes LA et LB de l'algorithme.\\
\noindent
${\tt \ll \ \rightarrow\ A,B \  }$\\
\hspace*{0.5cm}${\tt \ll \{\}\ \rightarrow\ R}$\\
\hspace*{1cm}${\tt \ll  \{1,0,A\}\ STO \triangleright \ A;}$\\
\hspace*{1.5cm}${\tt \{0,1,B\}\ STO \triangleright \ B;}$\\
\hspace*{1.5cm}${\tt WHILE \ B[3]\ \neq \  0 \ REPEAT}$\\
\hspace*{2cm}${\tt A-B*FLOOR(A[3]/B[3])\ 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 \ BEZOUT}$\\
Puis par exemple {\tt BEZOUT(45,75)} pour l'ex\'ecuter.\\

-Version r\'ecursive avec les listes\\
\noindent
${\tt \ll \ \rightarrow\ A,B \  }$\\
\hspace*{0.5cm}${\tt \ll \{\}\ \rightarrow\ T}$\\
\hspace*{1cm}${\tt \ll IF \ B \ \neq \ 0 \ THEN}$\\
\hspace*{2cm}${\tt BEZOUR(B,A \ MOD \ B)\ STO \triangleright \ T;}$\\
\hspace*{2cm}${\tt \{T[2],T[1]-T[2]*FLOOR(A/B),T[3]\}}$\\
\hspace*{1.5cm}${\tt ELSE}$\\
\hspace*{2cm}${\tt \{1,0,A\}}$\\
\hspace*{1.5cm}${\tt END}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ BEZOUR}$\\
Puis par exemple {\tt BEZOUR(45,75)} pour l'ex\'ecuter.
\subsection{Traduction TI80}
-Version it\'erative avec les listes\\
Au d\'ebut  A et B contiennent les deux nombres pour lesquels on cherche
l'identit\'e de B\'ezout.
 $LA,\ LB$ et $LR$ de l'algorithme sont ici $L_1$, $L_2$ et $L_3$.\\
{\tt PROGRAM:BEZOUT\\
:INPUT A\\
:INPUT B}\\ 
${\tt :\{1, 0, A\}->L1}$\\
${\tt :\{0, 1, B\}->L2}$\\
{\tt :LBL 1}\\
${\tt :IF\ L2(3)\ \neq\ 0 }$\\
{\tt :THEN}\\
${\tt :L1-L2*INT(L1(3)/L2(3))->L3}$\\
${\tt :L2->L1}$\\
${\tt :L3->L2}$\\
{\tt :GOTO 1\\
:END}\\
${\tt :L1}$\\

-Pas de version r\'ecursive.
\subsection{Traduction TI83+}
-Version it\'erative avec les listes\\
Au d\'ebut  A et B contiennent les deux nombres pour lesquels on cherche
l'identit\'e de B\'ezout.
 $LA,\ LB$ et $LR$ de l'algorithme sont ici $L_1$, $L_2$ et $L_3$.\\
{\tt PROGRAM:BEZOUT\\
:INPUT A\\
:INPUT B}\\ 
${\tt :\{1, 0, A\}->L_1}$\\
${\tt :\{0, 1, B\}->L_2}$\\
${\tt :While\ L_2(3)\ \neq\ 0 }$\\
${\tt :L_1-L_2*int(L_1(3)/L_2(3))->L_3}$\\
${\tt :L_2->L_1}$\\
${\tt :L_3->L_2}$\\
{\tt :End}\\
${\tt :L_1}$\\

-Pas de version r\'ecursive.
\subsection{Traduction TI89 92}
-Version it\'erative avec les listes

Au d\'ebut  a et b contiennent les deux nombres pour lesquels on cherche
l'identit\'e de B\'ezout, puis a et b d\'esignent les listes
 LA et LB de l'algorithme.
\begin{verbatim}
:bezout (a,b)
:Func
:local r
:{1, 0, a}->a
:{0, 1, b}->b\end{verbatim}
{\tt :While b[3] $\neq$ 0 }\begin{verbatim}
:a-b*floor(a[3]/b[3])->r 
:b->a 
:r->b 
:EndWhile
:Return a
:EndFunc
\end{verbatim}

-Version r\'ecursive avec les listes
\begin{verbatim}
:bezout (a,b)
:local L, q, r\end{verbatim}
{\tt :If b $\neq$ 0 Then}\begin{verbatim}
:floor(a/b)->q
:a-b*q->r
:bezout(b,r)->L
:Return {L[2], L[1]-L[2]*q, L[3]}
:Else
:Return {1, 0, a} 
:EndIf
:EndFunc
\end{verbatim}
\subsection{Traduction SHARP EL9600} 
-Version it\'erative avec les listes\\
{\tt BEZOUT}\\
{\tt Input A}\\
{\tt Input B}\\
${\tt \{1,0,A\}\Rightarrow L1}$\\
${\tt \{0,1,B\}\Rightarrow L2}$\\
{\tt Label DTQ}\\
{\tt If L2(3)=0 Goto FTQ}\\
${\tt L1-\ int\ (L1(3)/L2(3))*L2(3) \Rightarrow L3}$\\
${\tt L2 \Rightarrow L1}$\\
 ${\tt L3 \Rightarrow L2}$\\
{\tt Goto DTQ}\\
{\tt Label FTQ}\\ 
{\tt Print ''BEZOUT}\\
{\tt Print L1}\\
{\tt End}\\

-Pas de version r\'ecursive.
\section{D\'ecomposition en facteurs premiers d'un entier}
\subsection{Les algorithmes et leurs traductions algorithmiques}
- Premier algorithme\\
Soit $N$ un entier.\\
On teste, pour tous les nombres  $D$ de 2 \`a $N$, la divisibilit\'e de $N$ par $D$.\\
Si $D$ divise $N$, on cherche alors les diviseurs de $N/D$ etc...$N/D$ joue le 
r\^ole de $N$ et on s'arr\^ete quand $N=1$ \\
On met les diviseurs trouv\'es dans la liste {\tt FACT}.

\begin{verbatim}
fonction facprem(N)
local D FACT 
2 -> D
{} -> FACT\end{verbatim}
{\tt tant que N $\neq$ 1 faire}
\begin{verbatim}  si N mod D = 0 alors
    FACT + D -> FACT
    N/D -> N
   sinon
    D+1 -> D
 fsi
ftantque
r\'esultat FACT
ffonction
\end{verbatim}

- Premi\`ere am\'elioration\\
On ne teste que les diviseurs D entre 2 et $E(\sqrt N)$.\\
En effet si $N=D1*D2$ alors on a :\\
soit $D1 \leq E(\sqrt N)$, soit $D2 \leq E(\sqrt N)$ car sinon on aurait :\\
$D1*D2 \geq  (E(\sqrt N)+1)^2 >N$.

\begin{verbatim}
fonction facprem(N)
local D FACT
2 -> D
{} -> FACT\end{verbatim}
{\tt tant que D*D $\leq$ N faire}
\begin{verbatim}  si N mod D = 0 alors
    FACT + D -> FACT
    N/D-> N
   sinon
    D+1 -> D
 fsi
ftantque
FACT + N -> FACT
r\'esultat FACT
ffonction
\end{verbatim}

- Deuxi\`eme am\'elioration
On cherche si 2 divise N, puis on teste les diviseurs impairs D entre 3 et $E(\sqrt N).$
 
Dans la liste {\tt FACT} on fait suivre  chaque diviseur par son exposant:

 decomp(12)=\{2,2,3,1\}.

\begin{verbatim}
fonction  facprem(N)
local K D FACT
{}->FACT
0 -> K
tant que N mod 2 = 0 faire
    K+1 -> K
    N/2 -> N
ftantque\end{verbatim}
 {\tt  si K $\neq$0 alors}
\begin{verbatim}    FACT + {2 K} -> FACT
fsi
3 ->D \end{verbatim}
{\tt tant que D*D $\leq$ N faire}
\begin{verbatim}  0 -> K
  tant que N mod D = 0 faire
    K+1 -> K
    N/D -> N
  ftantque\end{verbatim}
 {\tt \ \  si K $\neq$0 alors}
\begin{verbatim}    FACT + {D K} -> FACT
  fsi
  D+2 -> D
ftantque\end{verbatim}
{\tt si N $ \neq 1$ alors}
\begin{verbatim}FACT + {N 1} -> FACT
fsi
r\'esultat FACT
ffonction
\end{verbatim}
\subsection{Traduction Casio}
Voici le programme FACTPREM :
\begin{verbatim}
``N''?->N
100->Dim List 1
0->K
0->I
While N-Int(N/2)*2 =0
K+1->K
N/2->N
WhileEnd\end{verbatim}
{\tt If K $\neq$0} \begin{verbatim}
Then 2->List 1[1]
K->List 1[2]
2->I
IfEnd
3->D\end{verbatim}
{\tt While D*D $\leq$N}\begin{verbatim}
0->K
While N-Int(N/D)*D=0
K+1->K
N/D->N
WhileEnd\end{verbatim}
{\tt If K $\neq$0} \begin{verbatim}
Then I+2->I
D->List 1[I-1]
K->List 1[I]
IfEnd
D+2->D\end{verbatim}
{\tt If N $\neq$1} \begin{verbatim}
Then I+2->I
N->List 1[I-1]
1->List 1[I]
IfEnd\end{verbatim}
{\tt I $\triangle$\\
List 1 $\triangle$}
\subsection{Traduction HP38G HP40G}
On traduit le dernier algorithme.\\
La {\tt HP38G} ne connait pas la liste \{\}, donc pour initialiser L1 avec la liste vide on \'ecrit : {\tt CLEAR L1}.\\
La {\tt HP40G} ne connait pas la liste \{\}, donc pour initialiser L1 avec la liste vide on \'ecrit :{\tt SYSEVAL 259589}.\\
Voici le programme FACTPREM :
%HP38AscD 7 FACPREM 
\begin{verbatim}
INPUT N;"N";;;1:
ERASE:
0 ->K:
CLEAR L1:  @ou SYSEVAL 259589:
WHILE N MOD 2 == 0 REPEAT
1+K -> K:
N/2 -> N:
END:\end{verbatim}
{\tt IF K $\neq$ 0 THEN}\begin{verbatim}
{2,K} ->L1:
END:
3 ->D:\end{verbatim}
{\tt WHILE D*D $\leq$ N REPEAT}\begin{verbatim}
0 -> K:
WHILE N MOD D == 0 REPEAT
K+1 -> K:
N/D -> N:
END:\end{verbatim}
{\tt IF K $\neq$ 0 THEN}\begin{verbatim}
CONCAT (L1,{D,K}) -> L1:
END:
2+D -> D:
END:\end{verbatim}
{\tt IF N $\neq$ 1 THEN}\begin{verbatim}
CONCAT (L1, {N,1}) -> L1:
END:
DISP 3; "FACT" L1:
FREEZE:
\end{verbatim}
\subsection{Traduction HP48 ou HP49G mode RPN}
%%HP: T(1)A(R)F(.);
On traduit le dernier algorithme en utilisant une liste {\tt FACT} contenant
 les facteurs premiers avec leur multiplicit\'e.\\
Voici le programme FACTPREM :
\begin{verbatim}
<< 0 3 {} -> N K D FACT
  << WHILE N 2 MOD 0 ==
        REPEAT
        1 'K' STO+ 
        'N' 2 STO/
    END\end{verbatim} 
{\tt \ \ \ \ IF K 0 $\neq$ THEN}
\begin{verbatim}
      {2 K} 'FACT' STO
   END\end{verbatim}
{\tt \ \ \ \     WHILE N D D * $\geq$}
\begin{verbatim}      REPEAT
      0 'K' STO  
      WHILE N D MOD 0 ==
        REPEAT
        1 'K' STO+ 
        'N' D STO/
      END \end{verbatim}
     {\tt \ \ \ \ \ \ IF K 0 $\neq$ THEN}
\begin{verbatim}
       {D K} 'FACT' STO+
      END 
      2 'D' STO+
    END\end{verbatim}
{\tt \ \ \ \     IF N 1 $\neq$ THEN}\begin{verbatim}
      {N 1} 'FACT' STO+
    END  
  >>
>>\end{verbatim}
Puis on stocke ce programme dans {\tt FACTPREM ('FACTPREM' STO)}.
\subsection{Traduction HP49G mode Alg\'ebrique}
On traduit le dernier algorithme en utilisant une liste {\tt FACT} contenant
 les facteurs premiers avec leur multiplicit\'e.\\
Voici le programme FACTPREM :\\
\noindent
${\tt \ll \ \rightarrow\ N \  }$\\
\hspace*{0.5cm}${\tt \ll 0 \ \rightarrow\ K}$\\
\hspace*{1cm}${\tt \ll  WHILE \ N\ MOD\ 2 \ ==\  0 \ REPEAT}$\\ 
\hspace*{2cm}${\tt K+1 \ STO \triangleright \ K;}$\\
\hspace*{2cm}${\tt N/2\ STO \triangleright \ N}$\\
\hspace*{1.5cm}${\tt END;}$\\
\hspace*{1.5cm}${\tt \{\} \ \rightarrow\ FACTO}$\\
\hspace*{2cm}${\tt \ll IF \ K \neq \ 0\ THEN}$\\
\hspace*{3cm}${\tt FACTO+\{2,K\} \ STO  \triangleright \ FACTO}$\\
\hspace*{2.5cm}${\tt END;}$\\
\hspace*{2.5cm}${\tt 3 \ \rightarrow\ D}$\\
\hspace*{3cm}${\tt \ll  WHILE\ D*D \leq N  \ REPEAT}$\\ 
\hspace*{4cm}${\tt 0 \ STO \triangleright \ K;}$\\
\hspace*{4cm}${\tt  WHILE\ N \ MOD \ D\ == 0 \ REPEAT}$\\ 
\hspace*{4.5cm}${\tt K+1 \ STO \triangleright \ K;}$\\
\hspace*{4.5cm}${\tt N/D \ STO \triangleright \ N;}$\\
\hspace*{4cm}${\tt END;}$\\
\hspace*{4cm}${\tt IF \ K \neq \ 0\ THEN}$\\
\hspace*{4.5cm}${\tt FACTO+\{D,K\} \ STO \triangleright \ FACTO}$\\
\hspace*{4cm}${\tt END;}$\\
\hspace*{4cm}${\tt D+2 \ STO  \triangleright \ D}$\\
\hspace*{3.5cm}${\tt END;}$\\
\hspace*{3.5cm}${\tt IF \ N \neq \ 1\  THEN}$\\
\hspace*{4cm}${\tt FACTO+\{N,1\} \ STO  \triangleright \ FACTO}$\\
\hspace*{3.5cm}${\tt END;}$\\
\hspace*{3.5cm}${\tt FACTO;}$\\
\hspace*{3cm}${\tt \gg}$\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ FACTPREM}$\\
Puis par exemple {\tt FACTPREM(45)} pour l'ex\'ecuter.
\subsection{Traduction TI80}
-Version it\'erative avec les listes\\
La liste ${\tt L1}$ joue le r\^ole de la liste {\tt FACT}.\\

\noindent{\tt PROGRAM:FACTPRE}\\
{\tt :INPUT N\\
:CLRLIST L1}\\
{\tt :0->K}\\
{\tt :1->I}\\
{\tt :LBL 1}\\
{\tt :IF FPART(N/2)=0\\
:THEN}\\
{\tt :K+1->K}\\
{\tt :N/2->N\\
:GOTO 1}\\
{\tt :END}\\
${\tt :IF\ K \neq 0}$\\
{\tt :THEN}\\
{\tt :2->L1(1)}\\
{\tt :K->L1(2)\\
:I+2->I}\\
{\tt :END}\\
{\tt :3->D}\\
{\tt :LBL 2}\\
${\tt :IF\ D*D \leq N}$\\
{\tt :THEN}\\
{\tt :0->K}\\
{\tt :LBL 3}\\
{\tt :IF FPART(N/D)=0}\\ 
{\tt :K+1->K}\\
{\tt :N/D->N\\
:GOTO 3}\\
{\tt :END}\\
${\tt :If\ K \neq 0}$\\
{\tt :THEN}\\
{\tt :D->L1(I)}\\
{\tt :K->L1(I+1)\\
:I->I+2}\\
{\tt :END}\\
{\tt :D+2->D\\
:GOTO 2}\\
{\tt :END}\\
${\tt :IF\ N \neq 1}$\\
{\tt :THEN}\\
{\tt :N->L1(I)}\\
{\tt:I+1->I\\ 
:1->L1(I)}\\
{\tt :END}\\
{\tt :DISP L1}
\subsection{Traduction TI83+}
-Version it\'erative avec les listes\\
La liste ${\tt L_1}$ joue le r\^ole de la liste {\tt FACT}.\\
On initialise la liste ${\tt L_1}$ \`a $\{0\}$ car la liste vide n'est pas
 admise...\\
Puis on rajoute au fur et \`a mesure les diviseurs avec leur multiplicit\'e en 
d\'ebut de liste de fa\c{c}on \`a laisser le z\'ero en fin de liste...puis en fin de 
programme, on supprime ce z\'ero g\'enant en enlevant 1 \`a la dimension de 
${\tt L_1}$ : je n'ai pas trouv\'e d'autres moyens  si on veut utiliser
{\tt augment} (car ${\tt ClrList L_1}$ n'initialise pas ${\tt L_1}$ \`a vide !)\\
sinon il faut \'ecrire ${\tt 100 -> dim(L1)}$ puis g\'erer l'indice 
{\tt I} qui compte les \'el\'ements pertinents de {\tt L1} (cf \ref{sec:factprem1} le programme facprem1 de la {\tt TI89}) \\
\noindent{\tt PROGRAM:FACTPREM}\\
{\tt :Input N}\\
{\tt :0->K}\\
${\tt :{0}->L_1}$\\
{\tt :While fPart(N/2)=0}\\
{\tt :K+1->K}\\
{\tt :N/2->N}\\
{\tt :End}\\
${\tt :If\ K \neq 0}$\\
{\tt :Then}\\
${\tt :augment(\{2,K\},L_1)->L_1}$\\
{\tt :End}\\
{\tt :3->D}\\
${\tt :While\ D*D \leq N}$\\
{\tt :0->K}\\
{\tt :While fPart(N/D)=0}\\ 
{\tt :K+1->K}\\
{\tt :N/D->N}\\
{\tt :End}\\
${\tt :If\ K \neq 0}$\\
{\tt :Then}\\
${\tt :augment(\{D,K\},L_1)->L_1}$\\
{\tt :End}\\
{\tt :D+2->D}\\
{\tt :End}\\
${\tt :If\ N \neq 1}$\\
{\tt :Then}\\
${\tt :augment(\{N,1\},L_1)->L_1}$\\
{\tt :End}\\
${\tt :dim(L_1)-1->dim(L_1)}$\\
${\tt :Disp L_1}$
\subsection{Traduction TI89 92}\label{sec:factprem1}
On traduit le dernier algorithme en utilisant une liste {\tt fact} de 100 
\'el\'ements :
on ne peut donc factoriser que des nombres qui n'ont pas plus de 50 diviseurs
 premiers.(Exercice : Quel est le plus petit nombre ayant 50 diviseurs premiers ?)

On utilise un indice {\tt i} pour compter les \'el\'ements pertinents de {\tt fact}.

\begin{verbatim}:factprem1(n)
:Func
:Local fact,k,d,i
:newList(100)->fact
:0->k
:0->i
:While mod(n,2)=0
:k+1->k
:n/2->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:2->fact[1]
:k->fact[2]
:2->i
:EndIf
:3->d\end{verbatim}
:{\tt While d*d $\leq$n}\begin{verbatim}
:0->k
:While mod(n,d)=0
:k+1->k
:n/d->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:i+2->i
:d->fact[i-1]
:k->fact[i]
:EndIf
:d+2->d
:EndWhile\end{verbatim}
:{\tt If n $\neq$1 Then}\begin{verbatim}
:i+2->i
:n->fact[i-1]
:1->fact[i]
:EndIf
:Return left(fact,i)
:EndFunc
\end{verbatim}
ou bien \\
on construit la liste {\tt fact} au fur et \`a mesure et on obtient le
 programme :
\begin{verbatim}:factprem2(n)
:Func
:Local fact,k,d,i
:0->k
:{}->fact
:While mod(n,2)=0
:k+1->k
:n/2->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:augment({2,k},fact)->fact
:EndIf
:3->d\end{verbatim}
:{\tt While d*d $\leq$n}\begin{verbatim}
:0->k
:While mod(n,d)=0
:k+1->k
:n/d->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:augment({2,k},fact)->fact
:EndIf
:d+2->d
:EndWhile\end{verbatim}
:{\tt If n $\neq$1 Then}\begin{verbatim}
:augment({2,k},fact)->fact
:EndIf
:Return fact
:EndFunc
\end{verbatim}
\subsection{Traduction SHARP EL9600} 
-Version it\'erative avec les listes\\
On initialise la liste L1 \`a $\{0\}$ car la liste vide n'est pas admise...\\
Puis on rajoute au fur et \`a mesure les diviseurs avec leur multiplicit\'e en 
d\'ebut de liste de fa\c{c}on \`a laisser le z\'ero en fin de liste...puis en fin de 
programme, on supprime ce z\'ero g\^enant en enlevant 1 \`a la dimension de L1 (je
 n'ai pas trouv\'e d'autres moyens car si on veut utiliser
{\tt augment} (car  {\tt ClrList L1} n'initialise pas {\tt L1} \`a vide !!!)\\
sinon il faut \'ecrire ${\tt 100 \Rightarrow dim(L1)}$ puis g\'erer l'indice 
{\tt I} qui compte les \'el\'ements pertinents de {\tt L1} (cf \ref{sec:factprem1} le programme facprem1 de la {\tt TI89})\\ 
{\tt FACTPREM}\\
{\tt Input N}\\
${\tt \{0\} \Rightarrow L1}$\\
${\tt 0 \Rightarrow K}$\\
{\tt Label DTQ1}\\
${\tt If\ fpart(N/2) \neq 0\ Goto\ FTQ1}$\\
${\tt K+1 \Rightarrow K}$\\
${\tt N/2 \Rightarrow N}$\\
{\tt Goto DTQ1}\\
{\tt Label FTQ1}\\
{\tt If K = 0 Goto FS1}\\
${\tt augment(\{2,K\},L1) \Rightarrow L1}$\\
{\tt Label FS1}\\
${\tt 3 \Rightarrow D}$\\ 
{\tt Label DTQ2}\\
{\tt If D*D>N  Goto FTQ2}\\
${\tt 0 \Rightarrow K}$\\
{\tt Label DTQ3}\\
${\tt If\ fpart(N/D) \neq 0\ Goto\ FTQ3}$\\
${\tt K+1 \Rightarrow K}$\\
${\tt N/D \Rightarrow N}$\\
{\tt Goto DTQ3}\\
{\tt Label FTQ3}\\ 
{\tt If K = 0 Goto FS2}\\
${\tt augment(\{D,K\},L1) \Rightarrow L1}$\\
{\tt Label FS2}\\
${\tt D+2 \Rightarrow D}$\\
{\tt Goto DTQ2}\\
{\tt Label FTQ2}\\ 
{\tt If N = 1 Goto FS3}\\
${\tt augment(\{N,1\},L1) \Rightarrow L1}$\\
{\tt Label FS3}\\
${\tt dim(L1)-1 \Rightarrow dim(L1)}$\\
{\tt Print L1}\\
{\tt End} 
\section{Calcul de $ A^P \  mod\ N$}\label {sec:puimod}
\subsection{Traduction Algorithmique}
-Premier algorithme\\
On utilise deux variables locales PUIS et I.\\
On fait un programme it\'eratif de fa\c{c}on qu'\`a chaque \'etape PUIS repr\'esente
$A^I \ mod \ N$
\begin{verbatim}
fonction puimod1 (A, P, N)
local PUIS, I
1->PUIS
pour I de 1 a P faire
  A*PUIS mod N ->PUIS 
fpour
resultat PUIS
ffonction
\end{verbatim} 
-Deuxi\`eme algorithme\\
On utilise une seule variable locale PUI mais on fait varier P de fa\c{c}on qu'\`a 
chaque \'etape de l'it\'eration on ait :\\
$ resultat= PUI * A^P \ mod \ N $
\begin{verbatim}
fonction puimod2 (A, P, N)
local PUI
1->PUI
tant que  P>0  faire
  A*PUI mod N ->PUI 
  P-1->P
ftantque
resultat PUI
ffonction
\end{verbatim} 
-Troisi\`eme algorithme\\
 On peut ais\'ement modifier ce programme en remarquant que :\\
$A^{2*P} = (A*A)^P $.\\
Donc quand P est pair on a la relation :\\
$PUI*A^P = PUI*(A*A)^{P/2} \ mod \ N$\\
et quand P est impair on a la relation :\\
$PUI*A^P = PUI*A*A^{P-1}\ mod \ N$.\\
On obtient  alors un calcul rapide de $ A^P \ mod \ N $.
\begin{verbatim}
fonction puimod3 (A, P, N)
local PUI
1->PUI
tant que  P>0  faire
  si P mod 2 =0 alors
    P/2->P
    A*A mod N->A
  sinon
    A*PUI mod N ->PUI 
    P-1->P
  fsi
ftantque
resultat PUI
ffonction
\end{verbatim} 
On peut remarquer que si P est impair, P-1 est pair.

On peut donc \'ecrire:
\begin{verbatim}
fonction puimod4 (A, P, N)
local PUI
1->PUI
tant que  P>0  faire
  si P mod 2 =1 alors
    A*PUI mod N ->PUI 
    P-1->P
  fsi   
P/2->P
A*A mod N->A
ftantque
resultat PUI
ffonction
\end{verbatim} 

 -Programme r\'ecursif

On peut d\'efinir la puissance par les relations de r\'ecurrence :
$A^0=1\\
A^{P+1} \ mod \ N =(A^P \ mod\ N )*A \ mod \ N$ 
\begin{verbatim}
fonction puimod5(A, P, N)
si P>0 alors
resultat puimod5(A, P-1, N)*A mod N
sinon
resultat 1
fsi
ffonction
\end{verbatim}

-Programme r\'ecursif rapide
\begin{verbatim}
fonction puimod6(A, P, N)
si P>0 alors
  si P mod 2 =0 alors
    resultat puimod6((A*A mod N), P/2, N)
  sinon
    resultat puimod6(A, P-1, N)*A mod N
  fsi 
sinon
resultat 1
fsi
ffonction
\end{verbatim}
\subsection{Traduction HP48 ou HP49G mode RPN}
L'utilisateur doit mettre sur la pile :
A, P, N pour obtenir $A^P mod\ N$.
Voici la traduction de l'algorithme rapide it\'eratif: 

{\tt << 1-> A P N PUI }

 {\tt << WHILE P 0 > REPEAT}
\begin{verbatim}
      IF P 2 MOD 1 == THEN
      A PUI * N MOD 'PUI' STO
      'P' STO- 
      END
    P 2 / 'P' STO
    A A * N MOD 'A' STO
    END
    PUI\end{verbatim}

{\tt >>}

{\tt >>}

Puis on stocke ce programme dans {\tt PUIMOD ('PUIMOD' STO)}.
\subsection{Traduction HP49G mode Alg\'ebrique}
\noindent
${\tt \ll \ \rightarrow\ A\ P\ N \  }$\\
\hspace*{0.5cm}${\tt \ll 1 \ \rightarrow\ PUI}$\\
\hspace*{1cm}${\tt \ll  WHILE \ P  > 0 \ REPEAT}$\\
\hspace*{2cm}${\tt IF \ P\ MOD\ 2\ == 1\ THEN}$\\
\hspace*{2.5cm}${\tt A*PUI\ MOD\ N \ STO \triangleright \ PUI}$\\
\hspace*{2.5cm}${\tt P-1 \ STO \triangleright \ P;}$\\
\hspace*{2cm}${\tt END;}$\\ 
\hspace*{2cm}${\tt P/2 \ STO \triangleright \ P;}$\\
\hspace*{2cm}${\tt A*A \ MOD \ N \ STO \triangleright \ A;}$\\
\hspace*{1.5cm}${\tt END;}$\\
\hspace*{1.5cm}${\tt PUI}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ PUIMOD}$\\
Puis par exemple {\tt PUIMOD(45,32,13)} pour l'ex\'ecuter.
\subsection{Traduction TI 89-92}
Voici la traduction de l'algorithme rapide it\'eratif: 
\begin{verbatim}
:puimod(a,p,n)
:Func
:Local pui
:1->pui
:While p>0 
:If p mod 2 = 1 Then
:mod(a*pui,n)->pui
:p-1->p
:EndIf
:p/2->p
:mod(a*a,n)->a
:EndWhile
:Return pui
:EndFunc
\end{verbatim}
\subsection{Traduction Casio, HP38G, HP40G, TI80, TI83+ ou SHARP-EL9600}
Les calculatrices {\tt Casio, HP38G, HP40G, TI80, TI83+} ou {\tt SHARP-EL9600} ne permettent pas d'\'ecrire 
des fonctions et n'ont pas la notion de param\`etres : on est donc oblig\'e 
d'ins\'erer le programme de ce calcul quand on en a besoin avec les variables
 pertinentes du programme principal.\\
Pour la traduction on se reportera page \pageref{sec:casiorabin} pour la {\tt Casio}, page \pageref{sec:hp38rabin} pour la {\tt HP 38}, 
page \pageref{sec:TI80rabin} pour la  {\tt TI80}, page \pageref{sec:TI83rabin} pour la  {\tt TI83+} et \`a la page \pageref{sec:sharprabin} pour la {\tt SHARP-EL9600} o\`u ce programme est utilis\'e.
%\section{Les nombres premiers}
\section{La fonction ``estpremier''}
\subsection{Traduction Algorithmique}
- Premier algorithme\\
On va \'ecrire un fonction bool\'eenne de param\`etre N, qui sera \'egale \`a  VRAI 
quand N est premier et \`a FAUX sinon.\\
Pour cela, on cherche si N poss\'ede un diviseur $\neq$ 1 et $\leq$ \`a $ E(\sqrt{N})$ (partie enti\`ere de racine de N).\\
On traite le cas N=1 \`a part !\\
On utilise une variable bool\'eenne PREM qui est au d\'epart \`a VRAI, et qui  passe 
\`a FAUX d\`es que l'on rencontre un diviseur de N.\\
\begin{verbatim}
Fonction estpremier(N)
local PREM, I, J\end{verbatim}
{\tt  E($\sqrt{N}$) ->J}
\begin{verbatim}Si N = 1 alors
  FAUX->PREM
  sinon
  VRAI->PREM
fsi
2->I\end{verbatim}
{\tt tant que PREM et I $\leq$J faire}
\begin{verbatim}  si N mod I = 0 alors
     FAUX->PREM
     sinon
     I+1->I
  fsi 
ftantque
r\'esultat PREM
ffonction
\end{verbatim}
-Premi\`ere am\'elioration\\
On peut remarquer que l'on peut tester si N est pair, et sinon regarder si N 
poss\'ede un diviseur impair.
\begin{verbatim}
Fonction estpremier(N)
local PREM, I, J\end{verbatim}
{\tt  E($\sqrt{N}$) ->J \\
 Si (N = 1) ou (N mod 2 = 0) et N$\neq$2 alors}\begin{verbatim}
  FAUX->PREM
  sinon
  VRAI->PREM
fsi
3->I\end{verbatim}
{\tt tant que PREM et I $\leq$J faire}
\begin{verbatim}  si N mod I = 0 alors
     FAUX->PREM
     sinon
     I+2->I
  fsi 
ftantque
r\'esultat PREM
ffonction
\end{verbatim}
- Deuxi\`eme am\'elioration\\
On regarde si N est divisible par 2 ou par 3,  sinon on regarde si N poss\'ede un diviseur de la forme $6 \times k-1 $ ou  $6 \times k+1 $.
\begin{verbatim}
Fonction estpremier(N)
local PREM, I, J\end{verbatim}
{\tt  E($\sqrt{N}$) ->J}
\begin{verbatim}Si (N = 1) ou (N mod 2 = 0) ou ( N mod 3 = 0) alors
  FAUX->PREM
  sinon
  VRAI->PREM
fsi
si N=2 ou N=3 alors 
VRAI->PREM
fsi
5->I\end{verbatim}
{\tt tant que PREM et I $\leq$J faire}
\begin{verbatim}  si (N mod I = 0) ou (N mod I+2 =0) alors
     FAUX->PREM
     sinon
     I+6->I
  fsi 
ftantque
r\'esultat PREM
ffonction
\end{verbatim}
\subsection{Traduction Casio}
Voici le programme ESTPREM :\\
\begin{verbatim}
``N''?->N
If Frac(N/2)*2=0 Or N=1 Or Frac(N/3)*3=0
Then 0->P
Else 1->P
IfEnd
If N=2 Or N=3
Then 1->P
IfEnd
5->I\end{verbatim}
{\tt Int($\sqrt{N}$)->J \\
While I$\leq$J And P}\begin{verbatim}
If Frac(N/I)*I=0 Or Frac(N/(I+2)*(I+2)=0
Then 0->P
Else I+6->I
IfEnd
WhileEnd\end{verbatim}
{\tt P $\triangle$}
\subsection{Traduction HP38G HP40G}
On traduit le dernier algorithme : le r\'esultat est 0 (FAUX) ou 1 (VRAI).
%HP38AscD 12 PR000000.000
Voici le programme ESTPREM :\\
\begin{verbatim}INPUT N;"N";;;1:
IF N MOD 2== 0 OR N MOD 3==0 OR N==1 THEN
0 ->P:
ELSE
1->P:
END:
IF N==2 OR N==3 THEN
1->P:
END:
5->I:\end{verbatim}
{\tt FLOOR($\sqrt {N}$)->J:\\
WHILE I $\leq$ J AND P REPEAT}\begin{verbatim}
IF N MOD I==0 OR N MOD (I+2)==0 THEN 
0 ->P:
ELSE
I+6 ->I:
END:
END:
ERASE:
DISP 5;P:
FREEZE: 
\end{verbatim}
\subsection{Traduction HP48 ou HP49G mode RPN}
On traduit le dernier algorithme : le r\'esultat est 0 (FAUX) ou 1 (VRAI).\\
Voici le programme ESTPREM :\\
{\tt << DUP $ \sqrt{\ }  $ FLOOR 0 5 -> N J PREM I}

{\tt \ \ << IF N 1 == N 2 MOD 0 == OR N 3 MOD 0 == OR THEN}  
\begin{verbatim}
    0 'PREM' STO 
  ELSE
    1 'PREM' STO
  END
  IF N 2 == N 3 == OR THEN
    1 'PREM' STO
  END
 \end{verbatim}
{\tt  WHILE PREM I J $\leq$ AND REPEAT}\begin{verbatim}
  IF N I MOD 0 == N I 2 + MOD 0 == OR THEN
     0 'PREM' STO
  ELSE 
     I 6 + 'I' STO
  END
END
PREM\end{verbatim}
{\tt \ \ >>\\
\ \ \ \ >>}\\
Puis on stocke ce programme dans {\tt ESTPREM ('ESTPREM' STO)}.
\subsection{Traduction HP49G mode Alg\'ebrique}
Voici le programme ESTPREM :\\
\noindent
${\tt \ll \ \rightarrow\  N \  }$\\
\hspace*{0.5cm}${\tt \ll 0 \ \rightarrow\ P}$\\
\hspace*{1cm}${\tt \ll  IF \ N\ MOD\ 2\ == 0\ OR \ N\ MOD\ 3\ == 0\ OR \ N==1 THEN}$\\
\hspace*{2cm}${\tt 0 \ STO \triangleright \ P}$\\
\hspace*{1.5cm}${\tt ELSE;}$\\
\hspace*{2cm}${\tt 1 \ STO \triangleright \ P;}$\\
\hspace*{1.5cm}${\tt END;}$\\ 
\hspace*{1.5cm}${\tt   IF \ N  == 2\ OR \ N == 3\ THEN}$\\
\hspace*{2cm}${\tt 1 \ STO \triangleright \ P;}$\\
\hspace*{1.5cm}${\tt END;}$\\ 
\hspace*{1.5cm}${\tt FLOOR( \sqrt N ) \ \rightarrow\ J}$\\
\hspace*{2cm}${\tt \ll 5 \ \rightarrow\ I}$\\
\hspace*{2.5cm}${\tt \ll  WHILE \ I \leq  J \ AND\ P \ REPEAT}$\\
\hspace*{3.5cm}${\tt IF \ N\ MOD\ I\ == 0 \ OR\ N\ MOD\ (I+2)\ == 0 \  \ THEN}$\\
\hspace*{4cm}${\tt 0 \ STO \triangleright \ P;}$\\
\hspace*{3.5cm}${\tt ELSE;}$\\
\hspace*{4cm}${\tt I+6 \ STO \triangleright \ I;}$\\
\hspace*{3.5cm}${\tt END;}$\\ 
\hspace*{3cm}${\tt END;}$\\ 
\hspace*{3cm}${\tt P}$\\
\hspace*{2.5cm}${\tt \gg}$\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ ESTPREM}$\\
Puis par exemple {\tt ESTPREM(45789)} pour l'ex\'ecuter.
\subsection{Traduction TI80}
On traduit le dernier algorithme : le r\'esultat est 0 (FAUX) ou 1 (VRAI).
\noindent{\tt PROGRAM:ESTPREM}\\
{\tt :INPUT N}\\
{\tt :0->K}\\
${\tt :INT( \sqrt N)->J}$\\
{\tt :1->P}\\
{\tt :IF FPART(N/2)=0}\\
{\tt :THEN}\\
${\tt :IF \ N \neq 2}$\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :END}\\
{\tt :ELSE}\\
{\tt :IF FPART(N/3)=0}\\
{\tt :THEN}\\
${\tt :IF \ N \neq 3}$\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :END}\\
{\tt :ELSE}\\
{\tt :IF N=1}\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :END}\\
{\tt :END}\\
{\tt :END}\\
{\tt :5->I\\
:LBL 1}\\
{\tt :IF\ P}\\
{\tt :THEN}\\
${\tt :IF\ I\ \leq J}$\\
{\tt :THEN}\\ 
{\tt :FOR (S,1,2)}\\
${\tt :IF\  FPART(N/I)=0}$\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :ELSE}\\
{\tt :I+2->I}\\
{\tt :END\\
:END\\
:I+2->I\\
:GOTO 1}\\
{\tt :END}\\
{\tt :END}\\
{\tt :DISP P}
\subsection{Traduction TI83+}
On traduit le dernier algorithme : le r\'esultat est 0 (FAUX) ou 1 (VRAI).
\noindent{\tt PROGRAM:ESTPREM}\\
{\tt :Input N}\\
{\tt :0->K}\\
${\tt :int( \sqrt N)->J}$\\
${\tt :If\ N=1\ or\ fPart(N/2)=0\ or\  fPart(N/3)=0}$\\
{\tt :Then}\\
{\tt :0->P}\\
{\tt :Else}\\
{\tt :1->P}\\
{\tt :End}\\
${\tt :If\ N=2\ or\ N=3}$\\
{\tt :Then}\\
{\tt :1->P}\\
{\tt :End}\\
{\tt :5->I}\\
${\tt :While\ P\ and\ I \leq J}$\\
${\tt :If\ fPart(N/(I+2))=0\ or\ fPart(N/I)=0}$\\
{\tt :Then}\\
{\tt :0->P}\\
{\tt :Else}\\
{\tt :I+6->I}\\
{\tt :End}\\
{\tt :End}\\
{\tt :Disp P}
\subsection{Traduction TI89-92}
On traduit le dernier algorithme : le r\'esultat est false (FAUX) ou true (VRAI).
\begin{verbatim}
:estprem(n)
:Func
:Local i, j, prem
:If mod(n,2)=0 or mod(n,3)=0 or n=1 Then
:false->prem
:Else
:true->prem
:EndIf
:If n=2 or n=3 Then
:true->prem
:EndIf
:5->i\end{verbatim}
:{\tt Floor($ \sqrt{n}$)->j \\}
:{\tt While i $\leq $j and prem}\begin{verbatim}
:If mod(n,i)=0 or mod(n,i+2)=0 Then
:false->prem
:Else
:i+6->i
:EndIf
:EndWhile
:Return prem
:EndFunc
\end{verbatim}
\subsection{Traduction SHARP EL9600} 
\noindent{\tt ESTPREM}\\
{\tt Input N}\\
${\tt int\ ( \sqrt N) \Rightarrow J}$\\
${\tt If\ (N \neq 1)\ and \ (fpart(N/2) \neq 0)\ and \ (fpart(N/3) \neq 0)\ Goto\ SINON1}$\\
${\tt 0 \Rightarrow P}$\\
{\tt Goto FSI1}\\
{\tt Label SINON1}\\
${\tt 1 \Rightarrow P}$\\
{\tt Label FSI1}\\
${\tt If\ (N \neq 2)\ and\ (N \neq 3)\   Goto\ FSI2}$\\
${\tt 1 \Rightarrow P}$\\
{\tt Label FSI2}\\
${\tt 5 \Rightarrow I}$\\
{\tt Label DTQ}\\
{\tt If (P=0) or (I>J) Goto FTQ}\\
${\tt If \ (fpart(N/I) \neq 0)\ and \ (fpart(N/(I+2)) \neq 0)\ Goto\ SINON3}$\\
${\tt 0 \Rightarrow P}$\\
{\tt Goto FSI3}\\
{\tt Label SINON3}\\
${\tt I+6 \Rightarrow I}$\\
{\tt Label FSI3}\\
{\tt Goto DTQ}\\
{\tt Label FTQ}\\
{\tt Print P}\\
{\tt End}
\section{M\'ethode probabiliste  de Mr Rabin}
Si $N$ est premier alors tous les nombres $K$ strictement inf\'erieurs \`a $N$ sont
premiers avec $N$, donc d'apr\`es le petit th\'eor\`eme de Fermat on a :\\
$ K^{N-1} = 1 \  mod\  N$ \\
Si $N$ n'est pas premier, les entiers $K$ v\'erifiant :\\
$ K^{N-1} = 1 \  mod\  N$ \\
sont tr\`es peu nombreux.\\
 Plus pr\'ecisement on peut montrer que si $ N>4 $, la probabilit\'e d'obtenir
 un tel nombre est inf\'erieure \`a 0.25.\\
La m\'ethode probabiliste de Rabin consiste \`a tirer au hasard un nombre $K$ (
$1< K < N $) et de calculer :\\
$ K^{N-1}  \  mod\  N$  \\
Si $ K^{N-1} = 1 \  mod\  N$ on refait un autre tirage et, si 
$ K^{N-1} \neq  1 \  mod\  N$ on est s\^ur que $N$ n'est pas premier.\\
Si on obtient $ K^{N-1} = 1 \  mod\  N$  pour 20 tirages  de $K$ on peut conclure
 que $N$ est premier avec une probabilit\'e d'erreur tr\`es faible inf\'erieure \`a $0.25^{20}$ soit de l'ordre de $10^{-12}$ (on dit alors que $N$ est
 pseudo-premier).\\
Bien s\^ur cette m\'ethode est employ\'ee pour savoir  si de  grands nombres sont pseudo-premiers.
\subsection{Traduction Algorithmique}
  On suppose que :\\
{\tt Hasard(N)} donne un nombre entier au hasard entre 0 et $N-1$.\\
 Le calcul de :\\
$ K^{N-1}  \  mod\  N$\\  
se fait gr\^ace \`a l'algorithme de la puissance rapide (cf page \pageref{sec:puimod}).\\
On notera :\\
{\tt puismod(K, P, N)} la fonction qui calcule $ K^P  \  mod\  N$  
\begin{verbatim}
Fonction estprem(N)
local K, I, P
1->I
1->P
Tant que P = 1 et I < 20 faire
hasard(N-2)+2->K
puismod(K, N-1, N)->P
I+1->I
ftantque
Si P =1 alors
resultat VRAI
sinon
resultat FAUX
fsi
ffonction
\end{verbatim}
\subsection{Traduction Casio} \label{sec:casiorabin}
Voici le programme RABIN :
\begin{verbatim}
``N''?->N
1->P
1->I
While (I<20) And (P=1)\end{verbatim}
{\tt Int(Rand\#*(N-2))+2->K}\begin{verbatim}
N-1->M
1->P
While 0<M
If M-Int(M/2)*2=1
Then K*P-Int(K*P/N)*N->P
M-1->M
IfEnd
M/2->M
K*K-Int(K*K/N)*N->K
WhileEnd
I+1->I
WhileEnd
If P=1\end{verbatim}
{\tt Then ''PREMIER'':N $\triangle$ \\
Else ''NONPREMIER'':N $\triangle$}\begin{verbatim}
IfEnd
\end{verbatim}
\subsection{Traduction HP38G HP40G}\label{sec:hp38rabin}
%HP38AscD 7 RABIN38 
Voici le programme RABIN :
\begin{verbatim}
INPUT N;"N";;;1:
RANDSEED TIME:
1->I:
1->P:
WHILE I < 20 AND P==1 REPEAT
  FLOOR( RANDOM * (N-2))+2->K:
  N-1->M:

  @ Calcul de K puissance M mod N dans P.
  1->P:
  WHILE  0 < M REPEAT
    IF M MOD 2 == 0 THEN
      M / 2 -> M :
      (K * K)  MOD N ->K :
    ELSE
      K*P MOD N -> P:
      M - 1 -> M:
    END:
  END: 
  @ P contient K puissance M mod N et M=N-1.
  I+1 ->I:
END:
ERASE:
IF P==1 THEN
  DISP 3;"PREMIER " N: 
ELSE 
  DISP 3;"NON PREMIER " N:
END:
FREEZE:
\end{verbatim}
\subsection{Traduction HP48 ou HP49G mode RPN}
%%HP: T(3)A(R)F(.);
On suppose que l'on a \'ecrit la fonction {\tt PUIMOD} qui prend sur la pile 
trois arguments {\tt A, K, N} et qui renvoie ${\tt A^K\ mod \ N}$.
\begin{verbatim}
<< 1 0 1 ->  N I K P   
  << 0 RDZ
WHILE P 1 == 20 I > AND REPEAT
 1 'I' STO+
RAND N 2 - * FLOOR 2 + 'K' STO 
K N 1 - N PUIMOD  'P' STO
END 
IF P 1 ==  THEN 1 ELSE 0
END
 >>
>>
\end{verbatim}
Puis on stocke ce programme dans {\tt RABIN ('RABIN' STO)}.
\subsection{Traduction HP49G mode Alg\'ebrique}
On suppose que l'on a \'ecrit la fonction {\tt PUIMOD} qui a trois 
arguments {\tt A, K, N} et qui renvoie ${\tt A^K mod \ N}$.\\
\noindent
${\tt \ll \ \rightarrow\ N \  }$\\
\hspace*{0.5cm}${\tt \ll 1 \ \rightarrow\ I}$\\
\hspace*{1cm}${\tt \ll 0 \ \rightarrow\ K}$\\
\hspace*{1.5cm}${\tt \ll 1 \ \rightarrow\ P}$\\
\hspace*{2cm}${\tt \ll  RDZ(0);}$\\
\hspace*{2.5cm}${\tt WHILE \ P  == 0 \ AND \ I<20 \ REPEAT}$\\
\hspace*{3cm}${\tt 1+I \ STO \triangleright \ I;}$\\
\hspace*{3cm}${\tt FLOOR((N-2)*RAND)+2 \ STO \triangleright \ K;}$\\
\hspace*{3cm}${\tt PUIMOD(K,N-1,N) \ STO \triangleright \ P;}$\\
\hspace*{2.5cm}${\tt END;}$\\ 
\hspace*{2.5cm}${\tt IF \ P == 1\ THEN}$\\
\hspace*{3cm}${\tt 1}$\\
\hspace*{2.5cm}${\tt ELSE}$\\ 
\hspace*{3cm}${\tt 0}$\\ 
\hspace*{2.5cm}${\tt END;}$\\
\hspace*{2.5cm}${\tt P}$\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1.5cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ RABIN}$\\
Puis par exemple {\tt RABIN(45313)} pour l'ex\'ecuter.\\
Remarque : \\
On peut aussi utiliser la commande du calcul formel {\tt POWMOD} et on \'ecrit alors :\\
En mode {\tt RPN} :\\
{\tt N MODSTO\\
 K N 1 - POWMOD 'P' STO}\\
\`a la place de :\\
{\tt K N 1 - N PUIMOD 'P' STO}\\
En mode {\tt Alg\`ebrique} :\\
{\tt MODSTO(N);\\
POWMOD(K,N-1) STO$\triangleright$ P}\\
\`a la place de :\\
{\tt PUIMOD(K,N-1,N) STO$\triangleright$ P}
\subsection{Traduction TI80}\label{sec:TI80rabin}
// Calcul de ${\tt  K^M  \  mod\  N}$  dans {\tt P}.\\
\noindent{\tt PROGRAM:PUIMOD}\\
{\tt :1->P}\\
{\tt :LBL 1}\\  
{\tt :IF 0 < M}\\
{\tt :THEN}\\ 
{\tt :IF FPART(M/2)=0}\\   
{\tt :THEN}\\
{\tt :M/2->M}\\     
{\tt :K*K-N*INT(K*K/N)->K}\\   
{\tt :ELSE}\\   
{\tt :K*P-N*INT(K*P/N)->P}\\     
{\tt :M-1->M}\\      
{\tt :END}\\
{\tt GOTO 1}\\
{\tt :END}\\
{\tt :RETURN}\\
 // {\tt P} contient ${\tt K^P  \  mod\  N}$  et {\tt M=N-1}.\\
\noindent{\tt PROGRAM:RABIN}\\
{\tt :INPUT N}\\
{\tt :1->I}\\
{\tt :1->P}\\
{\tt :LBL 1}\\
{\tt :IF P=1\\
:THEN\\
:IF I < 20}\\
{\tt :THEN}\\ 
{\tt :RANDINT(2,N-1)->K}\\
{\tt :N-1->M}\\ 
{\tt :PRGM\_PUIMOD}\\ 
{\tt :I+1->I\\
:GOTO 1}\\
{\tt :END}\\
{\tt :END}\\
{\tt :IF P=1}\\
{\tt :THEN}\\
{\tt :DISP ''PREMIER''}\\
{\tt :ELSE}\\
{\tt :DISP ''NONPREMIER''}\\
{\tt :END}
\subsection{Traduction TI83+}\label{sec:TI83rabin}
  @ Calcul de ${\tt  K^M  \  mod\  N}$  dans {\tt P}.\\
\noindent{\tt PROGRAM:PUIMOD}\\
{\tt :1->P}\\  
{\tt :While 0 < M}\\ 
{\tt :If fPart(M/2)=0}\\   
{\tt :Then}\\
{\tt :M/2->M}\\     
{\tt :K*K-N*int(K*K/N)->K}\\   
{\tt :Else}\\   
{\tt :K*P-N*int(K*P/N)->P}\\     
{\tt :M-1->M}\\      
{\tt :End}\\
{\tt :End}\\
{\tt :Return}\\
  @ {\tt P} contient ${\tt K^P  \  mod\  N}$  et {\tt M=N-1}.\\
\noindent{\tt PROGRAM:RABIN}\\
{\tt :Input N}\\
{\tt :1->I}\\
{\tt :1->P}\\
{\tt :While P=1 and I < 20}\\
{\tt :randInt(2,N-1)->K}\\
{\tt :N-1->M}\\ 
{\tt :prgmPUIMOD}\\ 
{\tt :I+1->I}\\
{\tt :End}\\
{\tt :If P=1}\\
{\tt :Then}\\
{\tt :Disp ''PREMIER''}\\
{\tt :Else}\\
{\tt :Disp ''NONPREMIER''}\\
{\tt :End}
\subsection{Traduction TI89 92}
\begin{verbatim}
:rabin(n)
:Func
:Local k,i,p
:1->p
:1->i
:RandSeed 1147
:While p=1 and i<20
:rand(n-1)+1->k
:puimod(k,n-1,n)->p
:i+1->i
:EndWhile
:If p=1 Then
:Return true
:Else
:Return false
:EndIf
:EndFunc 
\end{verbatim}
\subsection{Traduction SHARP EL9600}\label{sec:sharprabin}
\noindent{\tt RABIN}\\
{\tt Input N}\\
${\tt 1\Rightarrow I}$\\
${\tt 1\Rightarrow P}$\\
{\tt Label DTQ1}\\
${\tt If \ (I=20)\ or\ (P \neq 1)\  Goto\ FTQ1}$\\
${\tt int(random*(N-2))+2\Rightarrow K}$\\
${\tt N-1\Rightarrow M}$\\
{\tt Gosub PUIMOD}\\
${\tt I+1\Rightarrow I}$\\
{\tt Goto DTQ1}\\
{\tt Label FTQ1}\\
${\tt If\ P \neq 1\ Goto\ SINON2}$\\
{\tt Print ''premier}\\
{\tt  Goto FSI2} \\
{\tt Label SINON2}\\
{\tt Print ''nonpremier}\\
{\tt Label FSI2}\\ 
{\tt End}\\
{\tt Label PUIMOD}\\
{\tt Rem Calcul de K puissance M mod N dans P.}\\
${\tt 1\Rightarrow P}$\\
{\tt Label DTQ2}\\
{\tt If M=0 Goto FTQ2}\\
${\tt If\ fpart (M/2) \neq   0\ Goto\ SINON1}$\\
${\tt M/2\Rightarrow M}$\\
${\tt K*K-int(K*K/N)*N\Rightarrow K}$\\
  {\tt  Goto FSI1} \\
{\tt Label SINON1}\\
${\tt K*P-int(K*P/N)*N\Rightarrow P}$\\
${\tt M-1\Rightarrow M}$\\
{\tt Label FSI1}\\ 
{\tt Goto DTQ2}\\
{\tt Label FTQ2}\\
{\tt Rem P contient K puissance M mod N et M=N-1.}\\ 
{\tt Return}


\chapter{Les programmes selon les mod\`eles}
\section{Les programmes selon la Casio} 
\subsection{Les Entr\'ees}
\noindent{\tt "A="?->A:}
\subsection{Les Sorties}
\noindent{\tt "A=":A $\triangle$} 
\subsection{La s\'equence d'instructions ou action}
A la fin d'une instruction, il faut mettre un s\'eparateur qui peut \^etre 
{\tt  le retour \`a la ligne ou : ou $\triangle$}
\subsection{L'instruction d'affectation}
La fl\`eche est obtenue \`a l'aide de la touche  ${\tt \rightarrow}$.
\subsection{Les instructions conditionnelles}
\noindent{\tt If \emph{condition}
 :Then 
\emph{action} : 
IfEnd:}\\
{\tt If \emph{condition} :Then 
\emph{action1} : Else :
\emph{action2}:
IfEnd:}
\subsection{Les instructions "Pour"}
\noindent{\tt For A->I To B : \emph{action} : Next}\\
{\tt For A->I To B  Step P : \emph{action} : Next}
\subsection{L'instruction "Tant que"}
\noindent{\tt While  \emph{condition} : 
\emph{action} : 
WhileEnd:}
\subsection{L'instruction ``Repeter''}
\noindent{\tt Do : 
\emph{action}: 
LpWhile \emph{ condition}}
\subsection{Un exemple : le crible d'Eratosth\`ene}
\begin{verbatim}
``N''?->N
N->Dim List 1
N->Dim List 2
Seq(I,I,1,N,1)->List 1
0->List 1[1]
2->P\end{verbatim}
{\tt While P*P$\leq$N}\begin{verbatim}
For P->I To Int (N/P)
0->List 1[I*P]
Next
P+1->P\end{verbatim}
{\tt While P*P$\leq$N And List 1[P]=0}\begin{verbatim}
P+1->P
WhileEnd
WhileEnd
0->P
For 2->I To N\end{verbatim}
{\tt If List 1[I]$\neq$0}\begin{verbatim}
Then P+1->P
I->List 2[P]
IfEnd
Next\end{verbatim}
{\tt P$\triangle$\\
List 2$\triangle$}
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
On d\'efinit 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$}
\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
\begin{verbatim}
Prog ``INAB''
{1, 0, A}->List 1
{0, 1, B}->List 2\end{verbatim}
{\tt While List 2[3] $\neq$ 0 }\begin{verbatim}
List 1-List 2 * Int (List 1[3]/List 2[3])->List 3 
List 2->List 1
List 3->List 2
WhileEnd
``U V PGCD''\end{verbatim}
{\tt List\  1[1] $\triangle$\\
 List\ 1[2] $\triangle$\\
 List\ 1[3] $\triangle$}
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
\begin{verbatim}
``N''?->N
100->Dim List 1
0->K
0->I
While N-Int(N/2)*2 =0
K+1->K
N/2->N
WhileEnd\end{verbatim}
{\tt If K $\neq$0} \begin{verbatim}
Then 2->List 1[1]
K->List 1[2]
2->I
IfEnd
3->D\end{verbatim}
{\tt While D*D $\leq$N}\begin{verbatim}
0->K
While N-Int(N/D)*D=0
K+1->K
N/D->N
WhileEnd\end{verbatim}
{\tt If K $\neq$0} \begin{verbatim}
Then I+2->I
D->List 1[I-1]
K->List 1[I]
IfEnd
D+2->D\end{verbatim}
{\tt If N $\neq$1} \begin{verbatim}
Then I+2->I
N->List 1[I-1]
1->List 1[I]
IfEnd\end{verbatim}
{\tt I $\triangle$\\
List 1 $\triangle$}
\subsection{Calcul de $ A^P \  mod\ N$}
Voir le sous-programme du programme de la m\'ethode probabiliste  de Mr Rabin.
\subsection{La fonction "estpremier"}
\begin{verbatim}
``N''?->N
If Frac(N/2)*2=0 Or N=1 Or Frac(N/3)*3=0
Then 0->P
Else 1->P
IfEnd
If N=2 Or N=3
Then 1->P
IfEnd
5->I\end{verbatim}
{\tt Int($\sqrt{N}$)->J \\
While I$\leq$J And P}\begin{verbatim}
If Frac(N/I)*I=0 Or Frac(N/(I+2)*(I+2)=0
Then 0->P
Else I+6->I
IfEnd
WhileEnd\end{verbatim}
{\tt P $\triangle$}
\subsection{M\'ethode probabiliste  de Mr Rabin}
\begin{verbatim}
``N''?->N
1->P
1->I
While (I<20) And (P=1)\end{verbatim}
{\tt Int(Rand\#*(N-2))+2->K}\begin{verbatim}
N-1->M
1->P
While 0<M
If M-Int(M/2)*2=1
Then K*P-Int(K*P/N)*N->P
M-1->M
IfEnd
M/2->M
K*K-Int(K*K/N)*N->K
WhileEnd
I+1->I
WhileEnd
If P=1\end{verbatim}
{\tt Then ''PREMIER'':N $\triangle$ \\
Else ''NONPREMIER'':N $\triangle$}\begin{verbatim}
IfEnd
\end{verbatim}
\newpage
\section{Les programmes selon la HP38G HP40G}
\subsection{Les Entr\'ees}
\noindent{\tt INPUT A;"TITRE";"A=";;0:}\\
 pour la {\tt HP 40G} on a aussi :\\
{\tt PROMPT A:}
\subsection{Les Sorties}
\noindent{\tt DISP 3;"A="A:} 3 repr\'esente le num\'ero de la ligne o\`u {\tt A} sera affich\'e \\
ou\\
{\tt MSGBOX "A="A:}
\subsection{La s\'equence d'instructions ou action}
\noindent {\tt:} indique la fin d'une instruction.
\subsection{L'instruction d'affectation}
La fl\`eche est obtenue \`a l'aide de la touche ${\tt STO}$ du bandeau. 
\subsection{Les instructions conditionnelles}
\noindent{\tt IF \emph{condition} THEN 
\emph{action} : 
END:}\\
{\tt IF \emph{condition} THEN 
\emph{action1} : ELSE
\emph{action2}:
END:}\\
 (Attention au == pour traduire la condition d'\'egalit\'e)
\subsection{Les instructions "Pour"}
\noindent{\tt FOR I = A TO B STEP 1 ; \emph{action} : END:}\\
{\tt FOR I = A TO B STEP P ; \emph{action} : END:} 
\subsection{L'instruction "Tant que"}
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} : 
END:}
\subsection{L'instruction ``Repeter''}
\noindent{\tt DO  
\emph{action} : 
UNTIL \emph{condition} 
END:}
\subsection{Un exemple : le crible d'Eratosth\`ene}
\begin{verbatim}
INPUT N;"CRIBLE";"N=";;10:
ERASE:
MAKELIST(I,I,1,N,1) -> L1:
0 -> L1(1):
2->P:\end{verbatim}
{\tt WHILE P*P $\leq$ N REPEAT}\begin{verbatim}
  FOR I = P TO INT(N/P) STEP 1;
    0->L1(I*P):
  END: 
  DISP 3;""L1:
  P+1->P:\end{verbatim}
{\tt {\  } WHILE P*P $\leq $ N AND L1(P) == 0 REPEAT}\begin{verbatim}
    P+1->P:
  END:
END:
{2}->L2:
FOR I=3 TO N  STEP 1;\end{verbatim}
{\tt {\  }IF L1(I) $\neq$ 0 THEN}\begin{verbatim}
  CONCAT(L2,{I}) ->L2:
  END:
END:
DISP 3 ;"PREM" L2:
FREEZE:
\end{verbatim}
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
On \'ecrit 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 \'ecrit 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}
\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
\begin{verbatim}RUN IN:
DISP 3;"BEZOUT "{A,B}:
{1,0,A} ->L1:
{0,1,B} ->L2:\end{verbatim}
{\tt WHILE L2(3) $\neq$ 0 REPEAT} 
\begin{verbatim}L1-L2*FLOOR(L1(3)/L2(3)) ->L3:
L2 ->L1:
L3 ->L2:
END:
DISP 4;"U V PGCD "L1:
FREEZE:
\end{verbatim}
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
Attention pour la {\tt HP 40G} il faut remplacer dans ce qui suit 
{\tt CLEAR L1} par {\tt SYSEVAL 259589}.
\begin{verbatim}
INPUT N;"N";;;1:
ERASE:
0 ->K:
CLEAR L1: @ou  SYSEVAL 259589:
WHILE N MOD 2 == 0 REPEAT
1+K -> K:
N/2 -> N:
END:\end{verbatim}
{\tt IF K $\neq$ 0 THEN}\begin{verbatim}
{2,K} ->L1:
END:
3 ->D:\end{verbatim}
{\tt WHILE D*D $\leq$ N REPEAT}\begin{verbatim}
0 -> K:
WHILE N MOD D == 0 REPEAT
K+1 -> K:
N/D -> N:
END:\end{verbatim}
{\tt IF K $\neq$ 0 THEN}\begin{verbatim}
CONCAT (L1,{D,K}) -> L1:
END:
2+D -> D:
END:\end{verbatim}
{\tt IF N $\neq$ 1 THEN}\begin{verbatim}
CONCAT (L1, {N,1}) -> L1:
END:
DISP 3; "FACT" L1:
FREEZE:
\end{verbatim}
 \subsection{Calcul de $ A^P \  mod\ N$}
Voir le sous-programme du programme de la m\'ethode probabiliste  de Mr Rabin.   
\subsection{La fonction "estpremier"}
\begin{verbatim}INPUT N;"N";;;1:
IF N MOD 2== 0 OR N MOD 3==0 OR N==1 THEN
0 ->P:
ELSE
1->P:
END:
IF N==2 OR N==3 THEN
1->P:
END:
5->I:\end{verbatim}
{\tt FLOOR($\sqrt {N}$)->J:\\
WHILE I $\leq$ J AND P REPEAT}\begin{verbatim}
IF N MOD I==0 OR N MOD (I+2)==0 THEN 
0 ->P:
ELSE
I+6 ->I:
END:
END:
ERASE:
DISP 5;P:
FREEZE: 
\end{verbatim}

%HP38AscD 7 RABIN38 
\subsection{M\'ethode probabiliste  de Mr Rabin}
\begin{verbatim}
INPUT N;"N";;;1:
RANDSEED TIME:
1->I:
1->P:
WHILE I < 20 AND P==1 REPEAT
  FLOOR( RANDOM * (N-2))+2->K:
  N-1->M:
  @ Calcul de K puissance M mod N dans P.
  1->P:
  WHILE  0 < M REPEAT
    IF M MOD 2 == 0 THEN
      M / 2 -> M :
      (K * K)  MOD N ->K :
    ELSE
      K*P MOD N -> P:
      M - 1 -> M:
    END:
  END: 
  @ P contient K puissance M mod N et M=N-1.
  I+1 ->I:
END:
ERASE:
IF P==1 THEN
  DISP 3;"PREMIER " N: 
ELSE 
  DISP 3;"NON PREMIER " N:
END:
FREEZE:\end{verbatim}
\newpage
\section{Les programmes selon la HP48 ou HP49G mode RPN}
\subsection{Les Entr\'ees}
\noindent{\tt 'A' PROMPTSTO}
\subsection{Les Sorties}
En g\'en\'eral on affiche simplement les r\'esultats sur la pile pour une
 r\'eutilisation \'eventuelle, on \'ecrira simplement :\\
{\tt A B}\\
On peut aussi afficher le r\'esultat tagu\'e, on \'ecrira alors :\\
{\tt A "A=" ->TAG}
\subsection{La s\'equence d'instructions ou action}
Le s\'eparateur est soit l'espace soit le retour \`a la ligne.
\subsection{L'instruction d'affectation}
Il faut utiliser la notation postfix\'ee et la commande {\tt STO} :\\
{\tt 2 A * 'B' STO}
\subsection{Les instructions conditionnelles}
\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\'ee et == pour traduire la 
condition d'\'egalit\'e.
\subsection{Les instructions "Pour"}
\noindent{\tt A B FOR I  \emph{action} NEXT}\\ 
{\tt A B FOR I  \emph{action} P STEP}
\subsection{L'instruction "Tant que"}
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsection{L'instruction ``Repeter''}
\noindent{\tt DO  
\emph{action} 
UNTIL \emph{condition} 
END}
\subsection{Un exemple : le crible d'Eratosth\`ene}
${\tt \ll \ \{\}\ \{\}\ 2\ 1\  \rightarrow\ N \ TA\ PREM\ P\ I }$\\
\hspace*{0.5cm}${\tt \ll\ 0\ 'X'\ 'X'\ 2\ N\ 1\ SEQ\ +\ 'TA'\ STO}$\\ 
\hspace*{1cm}{\tt WHILE P P * N  $\leq$ REPEAT \\
\hspace*{1.5cm}    P N P / FLOOR FOR I \\
\hspace*{2cm}      TA I P * 0 PUT 'TA' STO\\
\hspace*{1.5cm}    NEXT\\ 
 \hspace*{1.5cm}   1 'P' STO+\\
\hspace*{1.5cm} WHILE P P *  N $\leq$  TA P GET 0 == AND REPEAT \\
 \hspace*{2cm}     1 'P' STO+\\
 \hspace*{1.5cm}   END\\
\hspace*{1cm}  END \\
 \hspace*{1cm} 2 N FOR I\\
 \hspace*{1.5cm} IF TA I GET 0 $\neq$ THEN\\
  \hspace*{2cm}     I 'PREM' STO+\\
 \hspace*{1.5cm}    END\\
 \hspace*{1cm}  NEXT \\
 \hspace*{1cm}  PREM} \\
 \hspace*{.5cm}${\tt \gg}$\\
 ${\tt \gg}$\\
Puis on stocke ce programme dans {\tt CRIBLE ('CRIBLE' STO)}.
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
-Version it\'erative\\
${\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\'ecursive\\
${\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)}.

\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
-Version it\'erative\\
\begin{verbatim}
<< {} -> A B R   
  << {1 0} 'A' STO+
{0 1} 'B' STO+\end{verbatim}
{\tt WHILE  B 3 GET 0 $\neq$ REPEAT}
\begin{verbatim} A B A 3 GET B 3 GET / FLOOR * - 'R' STO
 B 'A' STO
 R 'B' STO  
END
A
   >> 
 >>
\end{verbatim}
Puis on stocke ce programme dans {\tt BEZOUT ('BEZOUT' STO)}.

-Version r\'ecursive avec les listes
%%HP: T(3)A(R)F(.);
\begin{verbatim}
<< {} -> A B T\end{verbatim}
{\tt \ \ << IF B 0 $\neq$ THEN}
\begin{verbatim}B A B MOD BEZOUR 'T' STO
 T 2 GET DUP A B / FLOOR *  
T 1 GET SWAP -
T 3 GET {} + + +
ELSE
 {1 0} A +
END
  >> 
 >>\end{verbatim}
Puis on stocke ce programme dans {\tt BEZOUR ('BEZOUR' STO)}.

\subsection{D\'ecomposition en facteurs premiers d'un entier N}
\begin{verbatim}
<< 0 3 {} -> N K D FACT
  << WHILE N 2 MOD 0 ==
        REPEAT
        1 'K' STO+ 
        'N' 2 STO/
    END\end{verbatim} 
{\tt \ \ \ \ IF K 0 $\neq$ THEN}
\begin{verbatim}
      {2 K} 'FACT' STO
   END\end{verbatim}
{\tt \ \ \ \     WHILE N D D * $\geq$}
\begin{verbatim}      REPEAT
      0 'K' STO  
      WHILE N D MOD 0 ==
        REPEAT
        1 'K' STO+ 
        'N' D STO/
      END \end{verbatim}
     {\tt \ \ \ \ \ \ IF K 0 $\neq$ THEN}
\begin{verbatim}
       {D K} 'FACT' STO+
      END 
      2 'D' STO+
    END\end{verbatim}
{\tt \ \ \ \     IF N 1 $\neq$ THEN}\begin{verbatim}
      {N 1} 'FACT' STO+
    END  
  >>
>>
\end{verbatim}
Puis on stocke ce programme dans {\tt FACTPREM ('FACTPREM' STO)}.

\subsection{Calcul de $ A^P \  mod\ N$}
{\tt << 1-> A P N PUI }

 {\tt << WHILE P 0 > REPEAT}
\begin{verbatim}
      IF P 2 MOD 1 == THEN
      A PUI * N MOD 'PUI' STO
      'P' STO- 
      END
    P 2 / 'P' STO
    A A * N MOD 'A' STO
    END
    PUI\end{verbatim}

{\tt >>}

{\tt >>}\\
Puis on stocke ce programme dans {\tt PUIMOD ('PUIMOD' STO)}.
\subsection{La fonction "estpremier"}
{\tt << DUP $ \sqrt{\ }  $ FLOOR 0 5 -> N J PREM I}

{\tt \ \ << IF N 1 == N 2 MOD 0 == OR N 3 MOD 0 == OR THEN}  
\begin{verbatim}
    0 'PREM' STO 
  ELSE
    1 'PREM' STO
  END
  IF N 2 == N 3 == OR THEN
    1 'PREM' STO
  END
 \end{verbatim}
{\tt  WHILE PREM I J $\leq$ AND REPEAT}\begin{verbatim}
  IF N I MOD 0 == N I 2 + MOD 0 == OR THEN
     0 'PREM' STO
  ELSE 
     I 6 + 'I' STO
  END
END
PREM\end{verbatim}
{\tt \ \ >>\\
\ \ \ \ >>}\\
Puis on stocke ce programme dans {\tt ESTPREM ('ESTPREM' STO)}.

\subsection{M\'ethode probabiliste  de Mr Rabin}
%%HP: T(3)A(R)F(.);
On suppose que l'on a \'ecrit la fonction {\tt PUIMOD} qui prend sur la pile 
trois arguments {\tt A, K, N} et qui renvoie ${\tt A^K\ mod \ N}$.
\begin{verbatim}
<< 1 0 1 ->  N I K P   
  << 0 RDZ
WHILE P 1 == 20 I > AND REPEAT
 1 'I' STO+
RAND N 2 - * FLOOR 2 + 'K' STO 
K N 1 - N PUIMOD  'P' STO
END 
IF P 1 ==  THEN 1 ELSE 0
END
 >>
>>
\end{verbatim}
Puis on stocke ce programme dans {\tt RABIN ('RABIN' STO)}.
\newpage
\section{Les programmes selon la HP49G mode Alg\'ebrique}
\subsection{Les Entr\'ees}
Pour entrer une variable locale {\tt A},  on tape :\\
${\tt ....0\ \rightarrow \ A \ll\  PROMPTSTO('A')... \gg}$
\subsection{Les Sorties}
Seul le dernier r\'esultat s'inscrit dans l'historique.\\
Pour des r\'esultats interm\'ediaires on tape :
$$ {\tt DISP("A="+A,3)}$$
 3 repr\'esente le num\'ero de la ligne\\
ou\\
$${\tt MSGBOX( "A="+\rightarrow STR(A))}$$
\subsection{La s\'equence d'instructions ou action}
Le {\tt\ ;\ } est un s\'eparateur d'instructions.\\ 
Le {\tt ;} s'obtient
en tapant en m\^eme temps sur {\tt shift-rouge SPC}.
\subsection{L'instruction d'affectation}
On utilise  la touche ${\tt STO}$ qui se 
traduit \`a l'\'ecran  de la calculatrice par : 
$ \triangleright $  (que l'on  notera : ${\tt STO\triangleright}$
\subsection{Les instructions conditionnelles}\
noindent{\tt IF \emph{condition} THEN 
\emph{action}  
END}\\
{\tt IF \emph{condition} THEN 
\emph{action1}  ELSE
\emph{action2}
END}\\
(Attention au == pour traduire la condition d'\'egalit\'e)
\subsection{Les instructions "Pour"}
\noindent{\tt FOR (I, A, B) \emph{action} NEXT}\\
{\tt FOR (I, A, B ) \emph{action} STEP P} 
\subsection{L'instruction "Tant que"}
{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsection{L'instruction ``Repeter''}
\noindent{\tt DO 
\emph{action} 
UNTIL \emph{condition} 
END}
\subsection{Un exemple : le crible d'Eratosth\`ene}
\noindent
${\tt \ll \ \rightarrow\ N \  }$\\
\hspace*{0.5cm}${\tt \ll}${\tt\ 0+SEQ('I','I',1,N,1) $\rightarrow$ TA}\\
\hspace*{1cm}${\tt \ll \ 2\ \rightarrow\ P}$\\
\hspace*{1.5cm}${\tt \ll WHILE\ P*P \leq  N\ REPEAT}$\\
\hspace*{2cm}{\tt  FOR (I , P , FLOOR(N/P))}\\
\hspace*{2.5cm}{\tt    PUT('TA',I*P,0)}\\
\hspace*{2cm}{\tt  NEXT;}\\
\hspace*{2cm} ${\tt P+1\  STO\triangleright P;}$\\
\hspace*{2cm}{\tt  WHILE P*P $\leq $ N AND TA[P] == 0 REPEAT}\\
\hspace*{2.5cm}   ${\tt  P+1\ STO \triangleright \ P}$\\
\hspace*{2cm}{\tt  END}\\
\hspace*{1.5cm}{\tt END;}\\
\hspace*{1.5cm}${\tt \{2\} \ \rightarrow\ PREM}$\\
\hspace*{2cm}${\tt \ll FOR\ (I,3 , N) }$\\
\hspace*{2.5cm}{\tt {\  }IF TA[I] $\neq$ 0 THEN}\\
\hspace*{3cm} $ {\tt PREM+I \  STO\triangleright PREM;}$\\
\hspace*{2.5cm}  {\tt END}\\
\hspace*{2cm}{\tt NEXT;}\\
\hspace*{2cm}{\tt PREM }\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1.5cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ CRIBLE}$
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
-Version it\'erative\\
\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\'ecuter.\\

-Version r\'ecursive\\
\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}$
\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
-Version it\'erative\\
\noindent
${\tt \ll \ \rightarrow\ A,B \  }$\\
\hspace*{0.5cm}${\tt \ll \{\}\ \rightarrow\ R}$\\
\hspace*{1cm}${\tt \ll  \{1,0,A\}\ STO \triangleright \ A;}$\\
\hspace*{1.5cm}${\tt \{0,1,B\}\ STO \triangleright \ B;}$\\
\hspace*{1.5cm}${\tt WHILE \ B[3]\ \neq \  0 \ REPEAT}$\\
\hspace*{2cm}${\tt A-B*FLOOR(A[3]/B[3])\ 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 \ BEZOUT}$\\
Puis par exemple {\tt BEZOUT(45,75)} pour l'ex\'ecuter.\\

-Version r\'ecursive avec les listes\\
\noindent
${\tt \ll \ \rightarrow\ A,B \  }$\\
\hspace*{0.5cm}${\tt \ll \{\}\ \rightarrow\ T}$\\
\hspace*{1cm}${\tt \ll IF \ B \ \neq \ 0 \ THEN}$\\
\hspace*{2cm}${\tt BEZOUR(B,A \ MOD \ B)\ STO \triangleright \ T;}$\\
\hspace*{2cm}${\tt \{T[2],T[1]-T[2]*FLOOR(A/B),T[3]\}}$\\
\hspace*{1.5cm}${\tt ELSE}$\\
\hspace*{2cm}${\tt \{1,0,A\}}$\\
\hspace*{1.5cm}${\tt END}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ BEZOUR}$
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
\noindent
${\tt \ll \ \rightarrow\ N \  }$\\
\hspace*{0.5cm}${\tt \ll 0 \ \rightarrow\ K}$\\
\hspace*{1cm}${\tt \ll  WHILE \ N\ MOD\ 2 \ ==\  0 \ REPEAT}$\\ 
\hspace*{2cm}${\tt K+1 \ STO \triangleright \ K;}$\\
\hspace*{2cm}${\tt N/2\ STO \triangleright \ N}$\\
\hspace*{1.5cm}${\tt END;}$\\
\hspace*{1.5cm}${\tt \{\} \ \rightarrow\ FACTO}$\\
\hspace*{2cm}${\tt \ll IF \ K \neq \ 0\ THEN}$\\
\hspace*{3cm}${\tt FACTO+\{2,K\} \ STO  \triangleright \ FACTO}$\\
\hspace*{2.5cm}${\tt END;}$\\
\hspace*{2.5cm}${\tt 3 \ \rightarrow\ D}$\\
\hspace*{3cm}${\tt \ll  WHILE\ D*D \leq N  \ REPEAT}$\\ 
\hspace*{4cm}${\tt 0 \ STO \triangleright \ K;}$\\
\hspace*{4cm}${\tt  WHILE\ N \ MOD \ D\ == 0 \ REPEAT}$\\ 
\hspace*{4.5cm}${\tt K+1 \ STO \triangleright \ K;}$\\
\hspace*{4.5cm}${\tt N/D \ STO \triangleright \ N;}$\\
\hspace*{4cm}${\tt END;}$\\
\hspace*{4cm}${\tt IF \ K \neq \ 0\ THEN}$\\
\hspace*{4.5cm}${\tt FACTO+\{D,K\} \ STO \triangleright \ FACTO}$\\
\hspace*{4cm}${\tt END;}$\\
\hspace*{4cm}${\tt D+2 \ STO  \triangleright \ D}$\\
\hspace*{3.5cm}${\tt END;}$\\
\hspace*{3.5cm}${\tt IF \ N \neq \ 1\  THEN}$\\
\hspace*{4cm}${\tt FACTO+\{N,1\} \ STO  \triangleright \ FACTO}$\\
\hspace*{3.5cm}${\tt END;}$\\
\hspace*{3.5cm}${\tt FACTO;}$\\
\hspace*{3cm}${\tt \gg}$\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ FACTPREM}$
\subsection{Calcul de $ A^P \  mod\ N$}
\noindent
${\tt \ll \ \rightarrow\ A\ P\ N \  }$\\
\hspace*{0.5cm}${\tt \ll 1 \ \rightarrow\ PUI}$\\
\hspace*{1cm}${\tt \ll  WHILE \ P  > 0 \ REPEAT}$\\
\hspace*{2cm}${\tt IF \ P\ MOD\ 2\ == 1\ THEN}$\\
\hspace*{2.5cm}${\tt A*PUI\ MOD\ N \ STO \triangleright \ PUI}$\\
\hspace*{2.5cm}${\tt P-1 \ STO \triangleright \ P;}$\\
\hspace*{2cm}${\tt END;}$\\ 
\hspace*{2cm}${\tt P/2 \ STO \triangleright \ P;}$\\
\hspace*{2cm}${\tt A*A \ MOD \ N \ STO \triangleright \ A;}$\\
\hspace*{1.5cm}${\tt END;}$\\
\hspace*{1.5cm}${\tt PUI}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ PUIMOD}$
\subsection{La fonction "estpremier"}
\noindent
${\tt \ll \ \rightarrow\  N \  }$\\
\hspace*{0.5cm}${\tt \ll 0 \ \rightarrow\ P}$\\
\hspace*{1cm}${\tt \ll  IF \ N\ MOD\ 2\ == 0\ OR \ N\ MOD\ 3\ == 0\ OR \ N==1 THEN}$\\
\hspace*{2cm}${\tt 0 \ STO \triangleright \ P}$\\
\hspace*{1.5cm}${\tt ELSE;}$\\
\hspace*{2cm}${\tt 1 \ STO \triangleright \ P;}$\\
\hspace*{1.5cm}${\tt END;}$\\ 
\hspace*{1.5cm}${\tt   IF \ N  == 2\ OR \ N == 3\ THEN}$\\
\hspace*{2cm}${\tt 1 \ STO \triangleright \ P;}$\\
\hspace*{1.5cm}${\tt END;}$\\ 
\hspace*{1.5cm}${\tt FLOOR( \sqrt N ) \ \rightarrow\ J}$\\
\hspace*{2cm}${\tt \ll 5 \ \rightarrow\ I}$\\
\hspace*{2.5cm}${\tt \ll  WHILE \ I \leq  J \ AND\ P \ REPEAT}$\\
\hspace*{3.5cm}${\tt IF \ N\ MOD\ I\ == 0 \ OR\ N\ MOD\ (I+2)\ == 0 \  \ THEN}$\\
\hspace*{4cm}${\tt 0 \ STO \triangleright \ P;}$\\
\hspace*{3.5cm}${\tt ELSE;}$\\
\hspace*{4cm}${\tt I+6 \ STO \triangleright \ I;}$\\
\hspace*{3.5cm}${\tt END;}$\\ 
\hspace*{3cm}${\tt END;}$\\ 
\hspace*{3cm}${\tt P}$\\
\hspace*{2.5cm}${\tt \gg}$\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ ESTPREM}$\\
Puis par exemple {\tt ESTPREM(45789)} pour l'ex\'ecuter.
\subsection{M\'ethode probabiliste  de Mr Rabin}
On suppose que l'on a \'ecrit la fonction {\tt PUIMOD} qui a trois 
arguments {\tt A, K, N} et qui renvoie ${\tt A^K mod \ N}$.\\
\noindent
${\tt \ll \ \rightarrow\ N \  }$\\
\hspace*{0.5cm}${\tt \ll 1 \ \rightarrow\ I}$\\
\hspace*{1cm}${\tt \ll 0 \ \rightarrow\ K}$\\
\hspace*{1.5cm}${\tt \ll 1 \ \rightarrow\ P}$\\
\hspace*{2cm}${\tt \ll  RDZ(0);}$\\
\hspace*{2.5cm}${\tt WHILE \ P  == 0 \ AND \ I<20 \ REPEAT}$\\
\hspace*{3cm}${\tt 1+I \ STO \triangleright \ I;}$\\
\hspace*{3cm}${\tt FLOOR((N-2)*RAND)+2 \ STO \triangleright \ K;}$\\
\hspace*{3cm}${\tt PUIMOD(K,N-1,N) \ STO \triangleright \ P;}$\\
\hspace*{2.5cm}${\tt END;}$\\ 
\hspace*{2.5cm}${\tt IF \ P == 1\ THEN}$\\
\hspace*{3cm}${\tt 1}$\\
\hspace*{2.5cm}${\tt ELSE}$\\ 
\hspace*{3cm}${\tt 0}$\\ 
\hspace*{2.5cm}${\tt END;}$\\
\hspace*{2.5cm}${\tt P}$\\
\hspace*{2cm}${\tt \gg}$\\
\hspace*{1.5cm}${\tt \gg}$\\
\hspace*{1cm}${\tt \gg}$\\
\hspace*{0.5cm}${\tt \gg}$\\
${\tt \gg \ STO \triangleright \ RABIN}$\\
Puis par exemple {\tt RABIN(45313)} pour l'ex\'ecuter.\\
Remarque : \\
On peut aussi utiliser la commande du calcul formel {\tt POWMOD} et on \'ecrit alors :\\
En mode {\tt RPN} :\\
{\tt N MODSTO\\
 K N 1 - POWMOD 'P' STO}\\
\`a la place de :\\
{\tt K N 1 - N PUIMOD 'P' STO}\\
En mode {\tt Alg\`ebrique} :\\
{\tt MODSTO(N);\\
POWMOD(K,N-1) STO$\triangleright$ P}\\
\`a la place de :\\
{\tt PUIMOD(K,N-1,N) STO$\triangleright$ P}
\newpage
\section{Les programmes selon la TI80}
\subsection{Les Entr\'ees}
\noindent {\tt:Prompt A}\\
{\tt :Prompt A,B}\\
ou encore  :\\
{\tt:Input ``A='',A}
\subsection{Les Sorties}
\noindent{\tt :Disp "A=",A}
\subsection{La s\'equence d'instructions ou action}
\noindent {\tt:} indique la fin d'une instruction. Il faut noter qu'\`a chaque passage \`a la ligne le  {\tt:} est mis automatiquement.
\subsection{L'instruction d'affectation}
On utilise  la touche ${\tt STO}$ qui se traduit \`a 
l'\'ecran  de la calculatrice par : 
$ \rightarrow $ 
\subsection{Les instructions conditionnelles}
\noindent{\tt:If \emph{condition} :Then :
\emph{action} : 
End}\\
{\tt :IF \emph{condition} :THEN :
\emph{action1} : ELSE :
\emph{action2}:
END}
\subsection{Les instructions "Pour"}
\noindent{\tt :FOR (I,A,B ): \emph{action} : END}\\
{\tt:FOR (I,A,B,P ): \emph{action} : END}
\subsection{L'instruction "Tant que"}
\noindent{\tt :LBL 1}\\
{\tt :IF  \emph{condition} :THEN :\emph{action}\\
:GOTO 1\\ :END} 
\subsection{L'instruction ``Repeter''}
\noindent{\tt :LBL 1}\\
{\tt :\emph{action} :IF  \emph{non condition} :THEN 
:GOTO 1\\ :END} 
\subsection{Un exemple : le crible d'Eratosth\`ene}
Voici le programme CRIBLE : on entre N et ensuite la liste $L_2$  est \'egale \`a la liste des nombres premiers inf\'erieurs ou \'egaux \`a N.\\
{\tt PROGRAM:CRIBLE\\
:INPUT N}\\
${\tt :SEQ(I,I,1,N,1) ->L1}$\\
${\tt :0 -> L1(1)}$\\
{\tt :2 -> P }\\
{\tt :LBL 1}\\
{\tt :IF P*P $\leq$ N}\\
{\tt :THEN}\\
{\tt :FOR (I,P,INT(N/P))}\\
${\tt :0 -> L1(I*P)}$\\
{\tt:END\\
:P+1 -> P\\
:LBL 2}\\
${\tt :IF\  (P*P) \leq N }$\\
{\tt :THEN}\\
${\tt :IF\  L1(P)=0}$\\
{\tt :THEN}\\
{\tt :P+1 -> P\\
:GOTO 2\\
:END\\
:END\\
:GOTO 1\\
:END\\
:0 -> P\\
:FOR (I,2,N)}\\
${\tt :IF\  L1(I) \neq 0 }$\\
{\tt :THEN\\
:P+1 ->P}\\
${\tt :I -> L2(P)}$\\
{\tt :END\\
:END\\
:L2}\\
Il n'y a pas ici de notions de variables locales ou de programmes avec des
param\`etres : toutes les variables sont globales.\\
Je n'ai pas trouv\'e la fonction bool\'eenne {\tt AND} : j'ai donc mis deux 
{\tt IF} successifs.
La derni\`ere instruction permet d'afficher la liste $L2$ des nombres premiers
inf\'erieurs ou \'egaux \`a N. Si   \`a l'affichage  la liste 
$L2$ n'est pas visible en entier, il faut appuyer sur $\triangleright$
pour faire d\'efiler la liste.
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
-Version it\'erative\\
{\tt PROGRAM:PGCD\\
:INPUT A\\
:INPUT B\\
:LBL 1}\\
{\tt :IF B $\neq$ 0 }
\begin{verbatim}
:THEN
:A-INT(A/B)*B->R
:B->A
:R->B
:GOTO 1
:END
:DISP A
\end{verbatim}

-Pas de version r\'ecursive.
\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
-Version it\'erative avec les listes\\
Au d\'ebut  A et B contiennent les deux nombres pour lesquels on cherche
l'identit\'e de B\'ezout.
 $LA,\ LB$ et $LR$ de l'algorithme sont ici $L_1$, $L_2$ et $L_3$.\\
{\tt PROGRAM:BEZOUT\\
:INPUT A\\
:INPUT B}\\ 
${\tt :\{1, 0, A\}->L1}$\\
${\tt :\{0, 1, B\}->L2}$\\
{\tt :LBL 1}\\
${\tt :IF\ L2(3)\ \neq\ 0 }$\\
{\tt :THEN}\\
${\tt :L1-L2*INT(L1(3)/L2(3))->L3}$\\
${\tt :L2->L1}$\\
${\tt :L3->L2}$\\
{\tt :GOTO 1\\
:END}\\
${\tt :L1}$\\

-Pas de version r\'ecursive.
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
-Version it\'erative avec les listes\\
La liste ${\tt L1}$ joue le r\^ole de la liste {\tt FACT}.\\
\noindent{\tt PROGRAM:FACTPRE}\\
{\tt :INPUT N\\
:CLRLIST L1}\\
{\tt :0->K}\\
{\tt :1->I}\\
{\tt :LBL 1}\\
{\tt :IF FPART(N/2)=0\\
:THEN}\\
{\tt :K+1->K}\\
{\tt :N/2->N\\
:GOTO 1}\\
{\tt :END}\\
${\tt :IF\ K \neq 0}$\\
{\tt :THEN}\\
{\tt :2->L1(1)}\\
{\tt :K->L1(2)\\
:I+2->I}\\
{\tt :END}\\
{\tt :3->D}\\
{\tt :LBL 2}\\
${\tt :IF\ D*D \leq N}$\\
{\tt :THEN}\\
{\tt :0->K}\\
{\tt :LBL 3}\\
{\tt :IF FPART(N/D)=0}\\ 
{\tt :K+1->K}\\
{\tt :N/D->N\\
:GOTO 3}\\
{\tt :END}\\
${\tt :If\ K \neq 0}$\\
{\tt :THEN}\\
{\tt :D->L1(I)}\\
{\tt :K->L1(I+1)\\
:I+2->I}\\
{\tt :END}\\
{\tt :D+2->D\\
:GOTO 2}\\
{\tt :END}\\
${\tt :IF\ N \neq 1}$\\
{\tt :THEN}\\
{\tt :N->L1(I)}\\
{\tt:I+1->I\\ 
:1->L1(I)}\\
{\tt :END}\\
{\tt :DISP L1}
\subsection{Calcul de $ A^P \  mod\ N$}
Voir le sous-programme du programme de la m\'ethode probabiliste  de Mr Rabin.
\subsection{La fonction "estpremier"}
On traduit le dernier algorithme : le r\'esultat est 0 (FAUX) ou 1 (VRAI).\\
\noindent{\tt PROGRAM:ESTPREM}\\
{\tt :INPUT N}\\
{\tt :0->K}\\
${\tt :INT( \sqrt N)->J}$\\
{\tt :1->P}\\
{\tt :IF FPART(N/2)=0}\\
{\tt :THEN}\\
${\tt :IF \ N \neq 2}$\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :END}\\
{\tt :ELSE}\\
{\tt :IF FPART(N/3)=0}\\
{\tt :THEN}\\
${\tt :IF \ N \neq 3}$\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :END}\\
{\tt :ELSE}\\
{\tt :IF N=1}\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :END}\\
{\tt :END}\\
{\tt :END}\\
{\tt :5->I\\
:LBL 1}\\
{\tt :IF\ P}\\
{\tt :THEN}\\
${\tt :IF\ I\ \leq J}$\\
{\tt :THEN}\\ 
{\tt :FOR (S,1,2)}\\
${\tt :IF\  FPART(N/I)=0}$\\
{\tt :THEN}\\
{\tt :0->P}\\
{\tt :ELSE}\\
{\tt :I+2->I}\\
{\tt :END\\
:END\\
:I+2->I\\
:GOTO 1}\\
{\tt :END}\\
{\tt :END}\\
{\tt :DISP P}
\subsection{M\'ethode probabiliste  de Mr Rabin}
 // Calcul de ${\tt  K^M  \  mod\  N}$  dans {\tt P}.\\
\noindent{\tt PROGRAM:PUIMOD}\\
{\tt :1->P}\\
{\tt :LBL 1}\\  
{\tt :IF 0 < M}\\
{\tt :THEN}\\ 
{\tt :IF FPART(M/2)=0}\\   
{\tt :THEN}\\
{\tt :M/2->M}\\     
{\tt :K*K-N*INT(K*K/N)->K}\\   
{\tt :ELSE}\\   
{\tt :K*P-N*INT(K*P/N)->P}\\     
{\tt :M-1->M}\\      
{\tt :END}\\
{\tt GOTO 1}\\
{\tt :END}\\
{\tt :RETURN}\\
  // {\tt P} contient ${\tt K^P  \  mod\  N}$  et {\tt M=N-1}.\\
\noindent{\tt PROGRAM:RABIN}\\
{\tt :INPUT N}\\
{\tt :1->I}\\
{\tt :1->P}\\
{\tt :LBL 1}\\
{\tt :IF P=1\\
:THEN\\
:IF I < 20}\\
{\tt :THEN}\\ 
{\tt :RANDINT(2,N-1)->K}\\
{\tt :N-1->M}\\ 
{\tt :PRGM\_PUIMOD}\\ 
{\tt :I+1->I\\
:GOTO 1}\\
{\tt :END}\\
{\tt :END}\\
{\tt :IF P=1}\\
{\tt :THEN}\\
{\tt :DISP ''PREMIER''}\\
{\tt :ELSE}\\
{\tt :DISP ''NONPREMIER''}\\
{\tt :END}
\newpage
\section{Les programmes selon la TI83+}
\subsection{Les Entr\'ees}
\noindent {\tt:Prompt A}\\
{\tt :Prompt A,B}\\
ou encore  :\\
{\tt:Input ``A='',A}
\subsection{Les Sorties}
\noindent{\tt :Disp "A=",A}
\subsection{La s\'equence d'instructions ou action}
\noindent {\tt:} indique la fin d'une instruction. Il faut noter qu'\`a chaque passage \`a la ligne le  {\tt:} est mis automatiquement.
\subsection{L'instruction d'affectation}
On utilise  la touche ${\tt STO}$ qui se traduit \`a 
l'\'ecran  de la calculatrice par : 
$ \rightarrow $ 
\subsection{Les instructions conditionnelles}
\noindent{\tt:If \emph{condition} :Then :
\emph{action} : 
End}\\
{\tt :If \emph{condition} :Then :
\emph{action1} : Else :
\emph{action2}:
End}
\subsection{Les instructions "Pour"}
\noindent{\tt :For (I,A,B ): \emph{action} : End}\\
{\tt:For (I,A,B,P ): \emph{action} : End}
\subsection{L'instruction "Tant que"}
\noindent{\tt :While  \emph{condition}  :
\emph{action} : 
End}
\subsection{L'instruction ``Repeter''}
\noindent{\tt :Repeat \emph{condition}  :
\emph{action} : 
End}
\subsection{Un exemple : le crible d'Eratosth\`ene}
\noindent{\tt PROGRAM:CRIBLE\\
:Input N}\\
${\tt :seq(I,I,1,N) ->L_1}$\\
${\tt :0 -> L_1(1)}$\\
{\tt :2 -> P }\\
{\tt :While P*P $\leq$ N}\\
{\tt :For (I,P,int(N/P))}\\
${\tt :0 -> L_1(I*P)}$\\
{\tt:End\\
:P+1 -> P}\\
${\tt :While\  (P*P) \leq N \ and\  L_1(P)=0}$\\
{\tt :P+1 -> P\\
:End\\
:End\\
:0 -> P\\
:For (I,2,N)}\\
${\tt :If\  L_1(I) \neq 0 }$\\
{\tt :Then\\
:P+1 ->P}\\
${\tt :I -> L_2(P)}$\\
{\tt :End\\
:End}\\
${\tt :P->dim( L_2)}$\\
${\tt :Disp\ L_2}$
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
\noindent{\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}
\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
\noindent{\tt PROGRAM:BEZOUT\\ 
:Prompt A,B}\\
${\tt :\{1, 0, A\}->L_1}$\\
${\tt :\{0, 1, B\}->L_2}$\\
${\tt :While\ L_2(3)\ \neq\ 0 }$\\
${\tt :L_1-L_2*int(L_1(3)/L_2(3))->L_3}$\\
${\tt :L_2->L_1}$\\
${\tt :L_3->L_2}$\\
{\tt :End}\\
${\tt :L_1}$
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
\noindent{\tt PROGRAM:FACTPREM}\\
{\tt :Input N}\\
{\tt :0->K}\\
${\tt :{0}->L_1}$\\
{\tt :While fPart(N/2)=0}\\
{\tt :K+1->K}\\
{\tt :N/2->N}\\
{\tt :End}\\
${\tt :If\ K \neq 0}$\\
{\tt :Then}\\
${\tt :augment(\{2,K\},L_1)->L_1}$\\
{\tt :End}\\
{\tt :3->D}\\
${\tt :While\ D*D \leq N}$\\
{\tt :0->K}\\
{\tt :While fPart(N/D)=0}\\ 
{\tt :K+1->K}\\
{\tt :N/D->N}\\
{\tt :End}\\
${\tt :If\ K \neq 0}$\\
{\tt :Then}\\
${\tt :augment(\{D,K\},L_1)->L_1}$\\
{\tt :End}\\
{\tt :D+2->D}\\
{\tt :End}\\
${\tt :If\ N \neq 1}$\\
{\tt :Then}\\
${\tt :augment(\{N,1\},L_1)->L_1}$\\
{\tt :End}\\
${\tt :dim(L_1)-1->dim(L_1)}$\\
${\tt :Disp L_1}$
\subsection{Calcul de $ A^P \  mod\ N$}
Voir le sous-programme du programme de la m\'ethode probabiliste  de Mr Rabin.
\subsection{La fonction "estpremier"}
\noindent{\tt PROGRAM:ESTPREM}\\
{\tt :Input N}\\
{\tt :0->K}\\
${\tt :int( \sqrt N)->J}$\\
${\tt :If\ N=1\ or\ fPart(N/2)=0\ or\  fPart(N/3)=0}$\\
{\tt :Then}\\
{\tt :0->P}\\
{\tt :Else}\\
{\tt :1->P}\\
{\tt :End}\\
${\tt :If\ N=2\ or\ N=3}$\\
{\tt :Then}\\
{\tt :1->P}\\
{\tt :End}\\
{\tt :5->I}\\
${\tt :While\ P\ and\ I \leq J}$\\
${\tt :If\ fPart(N/(I+2))=0\ or\ fPart(N/I)=0}$\\
{\tt :Then}\\
{\tt :0->P}\\
{\tt :Else}\\
{\tt :I+6->I}\\
{\tt :End}\\
{\tt :End}\\
{\tt :Disp P}
\subsection{M\'ethode probabiliste  de Mr Rabin}
  @ Calcul de ${\tt  K^M  \  mod\  N}$  dans {\tt P}.\\
\noindent{\tt PROGRAM:PUIMOD}\\
{\tt :1->P}\\  
{\tt :While 0 < M}\\ 
{\tt :If fPart(M/2)=0}\\   
{\tt :Then}\\
{\tt :M/2->M}\\     
{\tt :K*K-N*int(K*K/N)->K}\\   
{\tt :Else}\\   
{\tt :K*P-N*int(K*P/N)->P}\\     
{\tt :M-1->M}\\      
{\tt :End}\\
{\tt :End}\\
{\tt :Return}\\
  @ {\tt P} contient${\tt K^P  \  mod\  N}$  et {\tt M=N-1}.\\
\noindent{\tt PROGRAM:RABIN}\\
{\tt :Input N}\\
{\tt :1->I}\\
{\tt :1->P}\\
{\tt :While P=1 and I < 20}\\
{\tt :randInt(2,N-1)->K}\\
{\tt :N-1->M}\\ 
{\tt :prgmPUIMOD}\\ 
{\tt :I+1->I}\\
{\tt :End}\\
{\tt :If P=1}\\
{\tt :Then}\\
{\tt :Disp ''PREMIER''}\\
{\tt :Else}\\
{\tt :Disp ''NONPREMIER''}\\
{\tt :End}
\newpage
\section{Les programmes selon la TI89 92}
\subsection{Les Entr\'ees}
\noindent {\tt:Prompt A}\\
{\tt :Prompt A,B}\\
ou encore  :\\
{\tt:Input ``A='',A}
\subsection{Les Sorties}
\noindent{\tt :Disp "A=",A}
\subsection{La s\'equence d'instructions ou action}
\noindent {\tt:} indique la fin d'une instruction. Il faut noter qu'\`a chaque passage \`a la ligne le  {\tt:} est mis automatiquement.
\subsection{L'instruction d'affectation}
on utilise  la touche ${\tt STO}$ qui se traduit \`a 
l'\'ecran  de la calculatrice par : 
$ \rightarrow $ 
\subsection{Les instructions conditionnelles}
\noindent{\tt:If \emph{condition} Then :
\emph{action} : 
EndIf}\\
{\tt :If \emph{condition} Then :
\emph{action1} : Else :
\emph{action2}:
EndIf}
\subsection{Les instructions "Pour"}
\noindent{\tt :For I,A,B : \emph{action} : EndFor}\\ 
{\tt:For I,A,B,P : \emph{action} : EndFor}
\subsection{L'instruction "Tant que"}
\noindent{\tt :While  \emph{condition}  :
\emph{action} : 
EndWhile}
\subsection{L'instruction ``Repeter''}
\noindent{\tt :Loop  
:\emph{action} 
:If \emph{condition}  :Exit 
:EndLoop}
\subsection{Un exemple : le crible d'Eratosth\`ene}
\begin{verbatim}:crible(n)
:Func
:local tab,prem,i,p
:newList(n)->tab
:newList(n)->prem
:seq(i,i,1,n) ->tab
:0 -> tab[1]
:2 -> p \end{verbatim}
:{\tt While p*p $\leq$ n}\begin{verbatim}
:For i,p,floor(n/p)
:0 -> tab[i*p]
:EndFor
:p+1 -> p\end{verbatim}
:{\tt While p*p $\leq$ n and tab[p]=0}\begin{verbatim}
:p+1 -> p
:EndWhile
:EndWhile
:0 -> p
:For i,2,n\end{verbatim}
:{\tt If tab[i] $\neq$ 0 Then}\begin{verbatim}
:p+1 ->p
:i ->prem[p]
:EndIf
:EndFor
:Return left(prem,p)
:EndFunc\end{verbatim} 
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
-Version it\'erative
\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\'ecursive
\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{Identit\'e de B\'ezout par l'algorithme d'Euclide}
-Version it\'erative
\begin{verbatim}
:bezout (a,b)
:Func
:local r
:{1, 0, a}->a
:{0, 1, b}->b\end{verbatim}
{\tt :While b[3] $\neq$ 0 }\begin{verbatim}
:a-b*floor(a[3]/b[3])->r 
:b->a 
:r->b 
:EndWhile
:Return a
:EndFunc
\end{verbatim}

-Version r\'ecursive avec les listes
\begin{verbatim}
:bezout (a,b)
:local L, q, r\end{verbatim}
{\tt :If b $\neq$ 0 Then}\begin{verbatim}
:floor(a/b)->q
:a-b*q->r
:bezout(b,r)->L
:Return {L[2], L[1]-L[2]*q, L[3]}
:Else
:Return {1, 0, a} 
:EndIf
:EndFunc
\end{verbatim}
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
\begin{verbatim}:factprem1(n)
:Func
:Local fact,k,d,i
:newList(100)->fact
:0->k
:0->i
:While mod(n,2)=0
:k+1->k
:n/2->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:2->fact[1]
:k->fact[2]
:2->i
:EndIf
:3->d\end{verbatim}
:{\tt While d*d $\leq$n}\begin{verbatim}
:0->k
:While mod(n,d)=0
:k+1->k
:n/d->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:i+2->i
:d->fact[i-1]
:k->fact[i]
:EndIf
:d+2->d
:EndWhile\end{verbatim}
:{\tt If n $\neq$1 Then}\begin{verbatim}
:i+2->i
:n->fact[i-1]
:1->fact[i]
:EndIf
:Return left(fact,i)
:EndFunc
\end{verbatim}
ou bien \\
on construit la liste {\tt fact} au fur et \`a mesure et on obtient le
 programme :
\begin{verbatim}:factprem2(n)
:Func
:Local fact,k,d,i
:0->k
:{}->fact
:While mod(n,2)=0
:k+1->k
:n/2->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:augment({2,k},fact)->fact
:EndIf
:3->d\end{verbatim}
:{\tt While d*d $\leq$n}\begin{verbatim}
:0->k
:While mod(n,d)=0
:k+1->k
:n/d->n
:EndWhile\end{verbatim}
:{\tt If k $\neq$0 Then}\begin{verbatim}
:augment({2,k},fact)->fact
:EndIf
:d+2->d
:EndWhile\end{verbatim}
:{\tt If n $\neq$1 Then}\begin{verbatim}
:augment({2,k},fact)->fact
:EndIf
:Return fact
:EndFunc
\end{verbatim}
\subsection{Calcul de $ A^P \  mod\ N$}
\begin{verbatim}
:puismod(a,p,n)
:Func
:Local pui
:1->pui
:While p>0 
:If p mod 2 = 1 Then
:mod(a*pui,n)->pui
:p-1->p
:EndIf
:p/2->p
:mod(a*a,n)->a
:EndWhile
:Return pui
:EndFunc
\end{verbatim}
\subsection{La fonction "estpremier"}
On traduit le dernier algorithme : le r\'esultat est false (FAUX) ou true (VRAI).
\begin{verbatim}:estprem(n)
:Func
:Local i, j, prem
:If mod(n,2)=0 or mod(n,3)=0 or n=1 Then
:false->prem
:Else
:true->prem
:EndIf
:If n=2 or n=3 Then
:true->prem
:EndIf
:5->i\end{verbatim}
:{\tt Floor($ \sqrt{n}$)->j \\}
:{\tt While i $\leq $j and prem}\begin{verbatim}
:If mod(n,i)=0 or mod(n,i+2)=0 Then
:false->prem
:Else
:i+6->i
:EndIf
:EndWhile
:Return prem
:EndFunc
\end{verbatim}
\subsection{M\'ethode probabiliste  de Mr Rabin}
\begin{verbatim}
:rabin(n)
:Func
:Local k,i,p
:1->p
:1->i
:RandSeed 1147
:While p=1 and i<20
:rand(n-1)+1->k
:puimod(k,n-1,n)->p
:i+1->i
:EndWhile
:If p=1 Then
:Return true
:Else
:Return false
:EndIf
:EndFunc 
\end{verbatim}
\newpage
\section{Les programmes selon la SHARP EL9600}
\subsection{Les Entr\'ees}
\noindent{\tt Input A}\\
ou \\
{\tt Input A}\\
{\tt Input B}
\subsection{Les Sorties}
\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\'equence d'instructions ou action}
C'est {\tt ENTER} qui est utilis\'e comme s\'eparateur d'instructions.\\
Chaque instruction doit \^etre \'ecrite  sur une seule ligne.
\subsection{L'instruction d'affectation}
On utilise  la touche ${\tt STO}$ qui se traduit \`a 
l'\'ecran  de la calculatrice par : 
$ \Rightarrow $ 
\subsection{Les instructions conditionnelles}
\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 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 "Tant que"}
\noindent{\tt Label DTANTQUE}\\
{\tt If \emph{non condition} Goto FTANTQUE}\\
{\tt \emph{action}}\\
{\tt Goto DTANTQUE }\\
{\tt Label FTANTQUE}
\subsection{L'instruction ``Repeter''}
\noindent{\tt Label REPETER}\\
{\tt \emph{action}}\\
{\tt If \emph{non condition} Goto REPETER}
\subsection{Un exemple : le crible d'Eratosth\`ene}
\noindent{\tt CRIBLE}\\
{\tt Input N}\\
${\tt \{2\} \Rightarrow L2}$\\
${\tt seq(X,1,N) \Rightarrow L1}$\\
${\tt 0 \Rightarrow L1}$\\
${\tt 2 \Rightarrow P}$\\   
{\tt Label DTQ1}\\
{\tt If P*P>N Goto FTQ1}\\
${\tt P \Rightarrow I}$\\
{\tt Label DP1}\\
 {\tt If I>int (N/P) Goto FP1}\\
${\tt 0 \Rightarrow L1(I*P)}$\\
${\tt I+1 \Rightarrow I}$\\
{\tt Goto DP1}\\
{\tt Label FP1}\\
${\tt P+1 \Rightarrow P}$\\
{\tt Label DTQ2}\\
${\tt If\ (P*P>N)\ or\ (L1(P) \neq 0)\ Goto\ FTQ2}$\\
 ${\tt P+1 \Rightarrow P}$\\
{\tt Goto DTQ2}\\ 
{\tt Label FTQ2}\\
{\tt Goto DTQ1}\\ 
{\tt Label FTQ1}\\
${\tt 3 \Rightarrow I}$\\
${\tt 1 \Rightarrow P}$\\ 
{\tt Label DP2}\\
{\tt If I>N Goto FP2}\\
${\tt If\ L1(I) = 0)\ Goto\ FSI}$\\
${\tt P+1 \Rightarrow P}$\\
${\tt I \Rightarrow L2(P)}$\\ 
{\tt Label FSI}\\
${\tt I+1 \Rightarrow I}$\\
{\tt Label FP2}\\
{\tt Print L2}\\
{\tt End}
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
\noindent{\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} 
\subsection{Identit\'e de B\'ezout par l'algorithme d'Euclide}
\noindent{\tt BEZOUT}\\
{\tt Input A}\\
{\tt Input B}\\
${\tt \{1,0,A\}\Rightarrow L1}$\\
${\tt \{0,1,B\}\Rightarrow L2}$\\
{\tt Label DTQ}\\
{\tt If L2(3)=0 Goto FTQ}\\
${\tt L1-\ int\ (L1(3)/L2(3))*L2(3) \Rightarrow L3}$\\
${\tt L2 \Rightarrow L1}$\\
 ${\tt L3 \Rightarrow L2}$\\
{\tt Goto DTQ}\\
{\tt Label FTQ}\\ 
{\tt Print ''BEZOUT}\\
{\tt Print L1}\\
{\tt End} 
\subsection{D\'ecomposition en facteurs premiers d'un entier N}
\noindent{\tt FACTPREM}\\
{\tt Input N}\\
${\tt \{0\} \Rightarrow L1}$\\
${\tt 0 \Rightarrow K}$\\
{\tt Label DTQ1}\\
${\tt If\ fpart(N/2) \neq 0\ Goto\ FTQ1}$\\
${\tt K+1 \Rightarrow K}$\\
${\tt N/2 \Rightarrow N}$\\
{\tt Goto DTQ1}\\
{\tt Label FTQ1}\\
{\tt If K = 0 Goto FS1}\\
${\tt augment(\{2,K\},L1) \Rightarrow L1}$\\
{\tt Label FS1}\\
${\tt 3 \Rightarrow D}$\\ 
{\tt Label DTQ2}\\
{\tt If D*D>N  Goto FTQ2}\\
${\tt 0 \Rightarrow K}$\\
{\tt Label DTQ3}\\
${\tt If\ fpart(N/D) \neq 0\ Goto\ FTQ3}$\\
${\tt K+1 \Rightarrow K}$\\
${\tt N/D \Rightarrow N}$\\
{\tt Goto DTQ3}\\
{\tt Label FTQ3}\\ 
{\tt If K = 0 Goto FS2}\\
${\tt augment(\{D,K\},L1) \Rightarrow L1}$\\
{\tt Label FS2}\\
${\tt D+2 \Rightarrow D}$\\
{\tt Goto DTQ2}\\
{\tt Label FTQ2}\\ 
{\tt If N = 1 Goto FS3}\\
${\tt augment(\{N,1\},L1) \Rightarrow L1}$\\
{\tt Label FS3}\\
${\tt dim(L1)-1 \Rightarrow dim(L1)}$\\
{\tt Print L1}\\
{\tt End} 
\subsection{Calcul de $ A^P \  mod\ N$}
Voir le sous-programme du programme de la m\'ethode probabiliste  de Mr Rabin.
\subsection{La fonction "estpremier"}
\noindent{\tt ESTPREM}\\
{\tt Input N}\\
${\tt int\ ( \sqrt N) \Rightarrow J}$\\
${\tt If\ (N \neq 1)\ and \ (fpart(N/2) \neq 0)\ and \ (fpart(N/3) \neq 0)\ Goto\ SINON1}$\\
${\tt 0 \Rightarrow P}$\\
{\tt Goto FSI1}\\
{\tt Label SINON1}\\
${\tt 1 \Rightarrow P}$\\
{\tt Label FSI1}\\
${\tt If\ (N \neq 2)\ and\ (N \neq 3)\   Goto\ FSI2}$\\
${\tt 1 \Rightarrow P}$\\
{\tt Label FSI2}\\
${\tt 5 \Rightarrow I}$\\
{\tt Label DTQ}\\
{\tt If (P=0) or (I>J) Goto FTQ}\\
${\tt If \ (fpart(N/I) \neq 0)\ and \ (fpart(N/(I+2)) \neq 0)\ Goto\ SINON3}$\\
${\tt 0 \Rightarrow P}$\\
{\tt Goto FSI3}\\
{\tt Label SINON3}\\
${\tt I+6 \Rightarrow I}$\\
{\tt Label FSI3}\\
{\tt Goto DTQ}\\
{\tt Label FTQ}\\
{\tt Print P}\\
{\tt End} 
\subsection{M\'ethode probabiliste  de Mr Rabin}
\noindent{\tt RABIN}\\
{\tt Input N}\\
${\tt 1\Rightarrow I}$\\
${\tt 1\Rightarrow P}$\\
{\tt Label DTQ1}\\
${\tt If \ (I=20)\ or\ (P \neq 1)\  Goto\ FTQ1}$\\
${\tt int(random*(N-2))+2\Rightarrow K}$\\
${\tt N-1\Rightarrow M}$\\
{\tt Gosub PUIMOD}\\
${\tt I+1\Rightarrow I}$\\
{\tt Goto DTQ1}\\
{\tt Label FTQ1}\\
${\tt If\ P \neq 1\ Goto\ SINON2}$\\
{\tt Print ''premier}\\
{\tt  Goto FSI2} \\
{\tt Label SINON2}\\
{\tt Print ''nonpremier}\\
{\tt Label FSI2}\\ 
{\tt End}\\
{\tt Label PUIMOD}\\
{\tt Rem Calcul de K puissance M mod N dans P.}\\
${\tt 1\Rightarrow P}$\\
{\tt Label DTQ2}\\
{\tt If M=0 Goto FTQ2}\\
${\tt If\ fpart (M/2) \neq   0\ Goto\ SINON1}$\\
${\tt M/2\Rightarrow M}$\\
${\tt K*K-int(K*K/N)*N\Rightarrow K}$\\
  {\tt  Goto FSI1} \\
{\tt Label SINON1}\\
${\tt K*P-int(K*P/N)*N\Rightarrow P}$\\
${\tt M-1\Rightarrow M}$\\
{\tt Label FSI1}\\ 
{\tt Goto DTQ2}\\
{\tt Label FTQ2}\\
{\tt Rem P contient K puissance M mod N et M=N-1.}\\ 
{\tt Return}

\chapter{ Algorithmique et Maple}
\section{Pour commencer}
 {\bf Attention} \\
{\tt Maple} est sensible \`a la diff\'erence entre majuscules et minuscules.
\subsection{Comment \'editer et sauver un programme}
\subsubsection{Traduction Maple sous Linux}
On lance \verb|Maple| depuis une fen\^etre \verb|xterm| en tapant :\\
\verb|xmaple &|.\\
Nous allons \'ecrire une fonction appel\'ee \verb|ma_procedure|
qui calculera la moyenne de deux nombres.
Votre texte doit ressembler \`a:
\begin{verbatim}
ma_procedure:=proc (x1,x2)
RETURN((x1+x2)/2);  
end: #End of ma_procedure 
\end{verbatim}
\subsubsection{Traduction Maple sous Windows}
Sur un PC lancer {\tt Maple} par un double clic sur l'ic\^one appropri\'e.\\ 
Pour \'editer un programme, on est alors dans un \'editeur plein \'ecran, avec des {\tt zones d'entr\'ees (ou de saisie d'ordres)}, des {\tt zones de textes}
 et des {\tt zones de sorties}.\\ 
 Les zones d'entr\'ees d\'ebutent par les symboles {\tt [>}.\\
Sur une ligne d'entr\'ee, on \'ecrit des ordres, ou commandes {\tt Maple}, qui peuvent \^etre imm\'ediatement ex\'ecut\'es.\\
Apr\`es chaque ordre, termin\'e par {\tt ;} et envoy\'e par la touche 
{\tt Entr\'ee}, la sortie correspondante est affich\'ee dans une zone de 
sortie, g\'er\'ee par {\tt Maple} et une nouvelle zone d'entr\'ee est automatiquement cr\'e\'ee.\\
Un ordre, termin\'e par {\tt :} et envoy\'e par la touche {\tt Entr\'ee} sera 
ex\'ecut\'e sans entra\^iner de sortie.\\
On peut cr\'eer, des lignes d'entr\'ee,  au-dessous de la position du curseur, en faisant un clic, dans la barre des ic\^ones, sur {\tt [>}.\\
Pour \'ecrire un texte, on peut transformer une ligne d'entr\'ee en ligne de texte, gr\^ace \`a l'ic\^one {\tt T}.\\
On dispose alors de plusieurs styles, disponibles dans un menu d\'eroulant.\\
On peut aussi \'ecrire un commentaire dans une ligne d'entr\'ee, en utilisant 
le caract\`ere {\tt \#}. (la fin de la ligne est alors consid\'er\'ee comme un texte.

{\tt ...
\par [> ma\_procedure := proc(x1, x2) ; 
\par      RETURN((x1 + x2)/2) ;
\par     end ; \# fin de ma\_procedure}\\

\`A la fin de chaque ligne, taper Majuscule-Entr\'ee (2 touches enfonc\'ees ensemble)\\
Apr\`es la derni\`ere ligne, on tapera simplement sur {\tt Entr\'ee}.\\
Le {\tt ;} apr\`es {\tt end} entra\^inera l'affichage du texte de la procedure, si la syntaxe est correct.
\subsection{Comment corriger un programme} 
%\subsubsection{Traduction Maple}
Pour modifier un programme existant, ou pour corriger une erreur de syntaxe, on revient dans le texte m\^eme, \`a l'endroit voulu (avec un clic de la souris). On r\'ealise les modifications du texte, et on termine en tapant {\tt Entr\'ee} (sans forc\'ement revenir en fin de texte).\\
La proc\'edure est de nouveau analys\'ee et affich\'ee (si elle est correcte).\subsection{Comment ex\'ecuter un programme}
%\subsubsection{Traduction Maple}
Les proc\'edures de {\tt Maple} sont essentiellement des fonctions.\\  
{\tt ma\_procedure(5,13)} est un nombre simplement 
affich\'e ou utilis\'e dans d'autres proc\'edures...
\subsection{Comment am\'eliorer puis  sauver sous un autre nom un programme}
%\subsubsection{Traduction Maple}
En g\'en\'eral on sauvegarde toute une feuille de travail (worksheet), contenant des proc\'edures \'eventuellement, et peut-\^etre aussi des ordres \'ex\'ecut\'es en mode imm\'ediat.
\\L'environnement habituel, menu d\'eroulant Fichier (ou File), options Enregistrer (Save) ou Enregistrer sous (Save As...), permet de cr\'eer des fichiers au format mws (fichiers sources {\tt Maple})
\\
\section{Les diff\'erentes 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 \`a la ligne.
\subsubsection{Traduction MapleV}
Un commentaire commence par {\tt \#} et se termine  par un passage \`a la ligne.
\subsection{Les variables}
\subsubsection{Leurs noms}
Ce sont les endroits o\`u l'on peut stocker des valeurs, des nombres, des expressions.\\
Un nom doit commencer par une lettre, ne pas contenir d'espace, de symbole 
op\'eratoire (+, -, ...) et ne pas \^etre un mot r\'eserv\'e (D, I, ... pour {\tt MapleV})\\
Avec {\tt MapleV} on peut utiliser des noms ayant plus de  8 caract\`eres.
\subsubsection{Notion de variables locales}
Pour {\tt MapleV},  il faut d\'efinir les variables locales en d\'ebut de programme en \'ecrivant :\\
{\tt local a,b}
\subsubsection{Notion de param\`etres}
Quand on \'ecrit une fonction il est possible d'utiliser des param\`etres.\\
Par exemple si {\tt A} et {\tt B} sont les param\`etres de la fonction {\tt PGCD}  on \'ecrit :\\
 {\tt fonction PGCD(A,B)....ffonction} 
\subsubsection{Traduction MapleV}
\noindent {\tt PGCD:=proc(A,B)}\\
....\\
....\\
{\tt end:}\\
Ces param\`etres NE se comportent PAS comme des variables locales : ils sont 
initialis\'es lors de l'appel de la fonction mais ne peuvent pas \^etre
chang\'es au cours de la proc\'edure. 
L'ex\'ecution  se fait en demandant par exemple :
{\tt PGCD(15,75)}
\subsection{Les Entr\'ees}
Pour que l'utilisateur puisse entrer une valeur dans la variable {\tt A} au 
cours de l'ex\'ecution d'un programme, on \'ecrira, en algorithmique :\\
{\tt saisir A}  \\
Et pour entrer des valeurs dans {\tt A} et {\tt B} on \'ecrira :\\
{\tt saisir A,B}
\subsubsection{Traduction MapleV}
On peut utiliser :\\
{\tt A := readline() ;} ou\\
{\tt A:=readstat('A=?');}
mais la plupart des entr\'ees se font par passage de param\`etres.
\subsection{Les Sorties}
En algorithmique on \'ecrit :\\
{\tt Afficher "A=",A}
\subsubsection{Traduction MapleV}
\noindent {\tt print('A='.A):}\\
On pr\'ef\'erera ` (accent grave) \`a " (guillemet), comme d\'elimiteur de cha\^ine, car le premier n'est pas affich\'e, alors que le deuxi\`eme l'est.
\subsection{La s\'equence d'instructions ou action}
Une action est une s\'equence d'une ou plusieurs instructions.\\
En langage algorithmique, on utilisera l'espace ou le passage \`a la ligne pour 
terminer une instruction.
\subsubsection{Traduction MapleV}
\noindent {\tt \ :\ } ou {\tt \ ;\ } indique la fin d'une instruction.\\
Une instruction termin\'ee par ( {\tt \ ;\ } ) g\'en\'ere  une sortie et celle termin\'ee par ( {\tt \ :\ } ) n'en g\'en\'ere pas.
\subsection{L'instruction d'affectation}
L'affectation est utilis\'ee pour stocker une valeur ou une expression dans une 
variable.\\
En algorithmique on \'ecrira par exemple :
{\tt 2*A->B}\\
pour stocker {\tt 2*A} dans {\tt B}\\
{\sc Attention}\\
Avec  {\tt Maple} 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 MapleV}
 Si ... alors\\
{\tt if <\emph{condition}> 
then <\emph{action}> 
fi};\\
Si ... alors ... sinon ...\\
{\tt if <\emph{condition}> 
then <\emph{action1>} 
else <\emph{action2>}
fi};\\ 
Le sch\'ema g\'en\'eral \`a n cas :\\
{\tt if  <\emph{condition\_1}> then <\emph{action\_1}> \\elif  <\emph{condition\_2}> then <\emph{action\_2}> 
\\... elif  <\emph{condition\_n-1}> then <\emph{action\_n-1}> else <\emph{action\_n}> fi ;}
\subsection{Les instructions "Pour" }
\noindent{\tt Pour I de A \`a B faire <\emph{action}> fpour}\\
{\tt Pour I de A \`a B (pas P) faire <\emph{action}> fpour}
\subsubsection{Traduction MapleV}
Voici la syntaxe exacte :\\
{\tt for <\emph{nom}> from <\emph{expr}> by <\emph{expr}> to <\emph{expr}> 
\\                         do <\emph{action}> od ;}\\
Par exemple\\
{\tt for i from 1 to n do 
<\emph{action}:> 
od}\\
{\tt for i from 1 by p to n do 
<\emph{action}:> 
od}
\subsection{L'instruction ``Repeter''}
\noindent{\tt Repeter
<\emph{action}>
 jusqua <\emph{ condition}>} 

\subsubsection{Traduction MapleV}
Pas de sch\'ema r\'ep\'eter en {\tt MapleV}
%{\tt while  \emph{condition} do 
%\emph{action}: 
%od}: 
\subsection{L'instruction ``Tant que''}
\noindent{\tt Tant que <\emph{condition}> faire
<\emph{action}>
ftantque}
\subsubsection{Traduction MapleV}
{\tt while  <\emph{condition}> do 
<\emph{action}> 
od}: 

\subsection{Les conditions ou expressions bool\'eennes }
Une condition est une fonction qui a comme valeur un bool\'een, \`a savoir elle
est soit {\tt vraie} soit {\tt fausse}.
\subsubsection{Les op\'erateurs relationnels}
Pour exprimer une condition simple on utilise les op\'erateurs :\\
{\tt = < > $\leq$  $\geq$  $\neq$}
\subsubsection{Les op\'erateurs logiques}
Pour traduire des conditions complexes, on utilise les op\'erateurs logiques :\\
{\tt ou et non} \\
qui se traduisent sur les calculatrices et en   {\tt MapleV} par :\\
{\tt or and not} 
\subsection{Les fonctions}
Dans une fonction on ne fait pas de saisie de donn\'ees :
on utilise des param\`etres qui seront initialis\'es lors de l'appel.\\
Dans une fonction on veut pouvoir r\'eutiliser le r\'esultat :\\
on n'utilise pas la commande {\tt affichage} mais la commande {\tt retourne}.\\
On \'ecrit par exemple en algorithmique :\\
\begin{verbatim}
fonction addition(A,B)
retourne A+B
ffonction
\end{verbatim}
Cela signifie que :\\
-Si on fait ex\'ecuter la fonction, ce qui se trouve juste apr\`es {\tt retourne}
  sera affich\'e. Les instructions qui suivent {\tt retourne} seront ignor\'ees.
\subsubsection{Traduction MapleV}
\begin{verbatim}addition:= proc(a,b)
RETURN(a+b);
end:\end{verbatim}
\subsection{Les listes}
On utilise les \{ \} pour d\'elimiter une liste.\\
Attention!!!
En algorithmique on a choisit cette notation car c'est celle qui est employ\'ee
par les calculatrices...\`a ne pas confondre avec la notion d'ensemble en
 math\'ematiques : dans un ensemble l'ordre des \'el\'ements n'a pas d'importance
mais dans une liste l'ordre est important...\\
 Par exemple \{\} d\'esigne la liste vide et \{1, 2, 3\} est une liste de 3 \'el\'ements.\\
{\tt append} sera utilis\'e pour concat\'ener 2 listes ou une liste et un \'el\'ement ou 
un \'el\'ement et une liste :\\
{\tt \{1, 2, 3\}->TAB}\\
{\tt append(TAB, 4) ->TAB}  (maintenant {\tt TAB} d\'esigne {\tt \{1, 2, 3, 4\}} \\
{\tt TAB[2]} d\'esigne le deuxi\`eme \'el\'ement de {\tt TAB} ici {\tt 2}.
\subsubsection{Traduction MapleV}
En {\tt Maple} on utilise {\tt \{ \}}, comme en math\'ematiques, pour repr\'esenter un {\bf ensemble}.\\
Exemple :  {\tt De := \{1, 2, 3, 4, 5, 6\}}
\\Dans un ensemble, l'ordre n'a pas d'importance. La r\'ep\'etition est interdite.
\\
\\Pour d\'elimiter une {\bf liste}, on utilise {\tt [ ]}.
\\L'ordre est pris en compte, la r\'ep\'etition est possible.
\\Exemple :  {\tt [Pile, Face, Pile]}
\\
\\Une {\bf s\'equence} est une suite d'objets, s\'epar\'es par une virgule.
\\
\\Si {\tt C} est un ensemble ou une liste, {\tt op(C)} est la s\'equence des objets de  {\tt C}.
\\ {\tt nops(C)} est le nombre d'\'el\'ements de  {\tt C}.
\\Ainsi, si  {\tt L} est une liste, {\tt \{op(L)\}} est l'ensemble des objets (non r\'ep\'et\'es) de  {\tt L}.\\
Exemples \\
On \'ecrit :\\
{\tt S:=NULL:} (pour la s\'equence vide)\\
{\tt S:=S,A:} (pour ajouter un \'el\'ement \`a {\tt S})\\
Une liste est une s\'equence entour\'ee de crochets :\\
{\tt L:=[S]:}\\
{\tt L[i]} est le i\'eme \'el\'ement de la liste {\tt L}.\\
On peut aussi revenir \`a la s\'equence :
{\tt S:=op(L):}
%{\tt nops(L)} est \'egal \`a la longueur de la liste L.
\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\'e sur la d\'efinition r\'ecursive 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\'esigne le reste de la division euclidienne de $A$ par $B$.\\
Voici la d\'escription 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\`es un nombre fini d'\'etapes, 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\'erative\\
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'\`a 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\'esultat A
ffonction
\end{verbatim}

 -Version r\'ecursive\\
On \'ecrit simplement la d\'efinition r\'ecursive vue plus haut.
\begin{verbatim}
Fonction PGCD(A,B)\end{verbatim}
{\tt Si B $\neq$ 0 alors}\begin{verbatim}
  r\'esultat PGCD(B,A mod B) 
  sinon
  r\'esultat A
fsi
ffonction\end{verbatim}
\subsubsection{Traduction MapleV}
-Version it\'erative :
\begin{verbatim}
pgcd:=proc(x,y)
local a,b,r:
a:=x:
b:=y:
While (b>0) do
r:=irem(a,b):
a:=b:
b:=r:
od:
RETURN(a):
end:
\end{verbatim}

-Version r\'ecursive :
\begin{verbatim}
pgcd:=proc(a,b)
if (b=0) then
RETURN(a)
 else 
RETURN(pgcd(b,irem(a,b))):
fi:
end:
\end{verbatim}
\chapter{Algorithmique et Mathematica}
\section{Pour commencer}
\subsection{Comment \'editer et sauver un programme}
Sur un PC sous Windows ou sur un Mac, double-cliquer sur l'ic\^one 
{\tt Mathematica}. Un nouveau notebook (fichier {\tt Mathematica}) est 
automatiquement ouvert. Taper les commandes du programme.
 Elles s'inscrivent dans une 
cellule {\tt Input} : un crochet de type {\tt Input}, \`a droite, enserre 
les lignes de commandes. La touche {\tt retour chariot} permet d'aller \`a la 
ligne .
La touche {\tt Enter} du pav\'e num\'erique ou {\tt Maj-Retour chariot} valide le programme.

Nous n'utiliserons pas l'\'editeur d'\'equations de {\tt Mathematica} qui 
permet d'entrer les commandes directement en notation math\'ematique.\\
Exemple :\\
{\tt maProcedure[x1\_,x2\_]:=(x1+x2)/2}\\
Sauvegarder le fichier comme n'importe quel fichier Windows ou Mac (Menu File puis Save). Le suffixe .nb (notebook) est automatiquement ajout\'e aux fichiers
{\tt Mathematica}.
\subsection{Comment corriger un programme} 
{\tt Mathematica} dispose d'un proc\'ed\'e qui suit les \'evaluations pas \`a
 pas : {\tt On[]} d\'eclenche le m\'ecanisme d'\'evaluation pas \`a pas. 
{\tt Off[]} l'arr\^ete. On peut aussi utiliser {\tt Trace[expr]} qui fournit une liste d'expressions interm\'ediaires g\'en\'er\'ees par l'\'evaluation
 d'expressions.\\
Exemple :\\
{\tt On[]; maProcedure[5, 7]\\
 Off[]}\\
La r\'eponse est :\\
{\tt On::trace : On[ ] {- -}> Null.\\
maProcedure::trace : maProcedure[5, 7]  {- -}> $\displaystyle \frac{5+7}{2}$.\\
Plus::trace : 5+7 {- -}>12.\\
Power::trace : $\displaystyle \frac{1}{2}$ {- -}> $\displaystyle \frac{1}{2}$.\\
Times::trace : $\displaystyle \frac{5+7}{2}$ {- -}> $\displaystyle \frac{12}{2}$.\\
Times::trace :  $\displaystyle \frac{12}{2}$  {- -}> 6.\\
ConpoundExpression:trace :  On[ ]; maProcedure[5, 7] {- -}> 6.\\
6}\\

{\tt Trace[maProcedure[5, 7]]}\\
La r\'eponse est :\\
{\tt \{maProcedure[5, 7], $\displaystyle \frac{5+7}{2}$, \{5+7,12\}, \{ $\displaystyle \frac{1}{2}$, $\displaystyle \frac{1}{2}$\}, $\displaystyle \frac{12}{2}$, 6\}}.
\subsection{Comment \'ex\'ecuter un programme}
{\tt Mathematica} est un syst\`eme interactif : pour ins\'erer une commande, on
 clique dans le {\tt notebook}, un trait horizontal s'affiche dans la largeur de la 
page, et on tape la commande. \\
Par exemple pour obtenir la moyenne de 5 et 13 on tape :\\
{\tt maProcedure[5, 13]}\\
la r\'eponse est :\\
9

\subsection{Comment am\'eliorer un programme}
Il suffit de modifier le code puis de valider le programme.
\section{Les diff\'erentes instructions}
\subsection{Les commentaires}
Un commentaire commence par {\tt (*} et se termine par {\tt *)}.\\
On peut aller \`a la ligne \`a l'int\'erieur d'un commentaire.\\
 Un commentaire comporte autant de lignes que l'on veut.\\
Exemple :\\
{\tt (* Ceci est un commentaire\\
qui peut faire plusieurs lignes *)} 
\subsection{Les variables}
\subsubsection{Leurs noms}
Les variables {\tt Mathematica} sont des symboles repr\'esent\'es par toute 
cha\^{\i}ne alphanum\'erique, sans limitation de longueur ne commen\c{c}ant
pas par un chiffre. Le symbole ne doit bien s\^ur pas \^etre utilis\'e par le
syst\`eme, auquel cas un message d'erreur pr\'evient l'utilisateur.
\subsubsection{Notion de variables locales}
Deux niveaux de localisation des variables sont possibles :
\begin{itemize}
\item La localisation dynamique (ou par valeurs)\\
Elle se fait \`a l'aide de la commande {\tt Block}. Le premier argument de 
{\tt Block} est \'ecrit \`a l'int\'erieur de crochets : il d\'esigne la liste des variables locales et ces variables peuvent 
\^etre eventuellement initialis\'ees.\\
Exemple :\\
{\tt f[x1\_, x2\_,..]:=Block[\{a,b,...\}, sequence d'instructions]}\\
Ici {\tt a} et {\tt b} sont des variables locales. \`A l'appel de {\tt f}, si 
{\tt a} (ou {\tt b}) \'etait d\'ej\`a affect\'e {\tt Block} met sa valeur de cot\'e et la restitue apr\`es l'execution de la proc\'edure {\tt f}.
Mais il reste des possibilit\'es de conflit entre les symboles d\'esignant 
ces variables. La localistion dynamique sera donc restreinte au cas o\`u la
proc\'edure n'op\`ere que sur les valeurs des variables.\\
Les fonctions  :\\
{\tt Do, Table Sum, NSum, Product,NProduct, NIntegrate} (mais 
pas {\tt Integrate}) b\'en\'eficient d'une localisation dynamique des indices 
d'it\'eration.  
\item La localisation statique (ou lexicale)\\
On utilise {\tt Module}, dont la syntaxe est similaire \`a celle de 
{\tt Block}. Mais {\tt Module} renomme les variables locales, r\'eduisant 
quasiment \`a n\'eant les risques de conflit avec une variable non locale qui
aurait la m\^eme d\'esignation. Cependant, {\tt Module} est plus lent que 
{\tt Block}.\\
Exemple :\\
{\tt f[x1\_, x2\_,..]:=Module[\{a,b,...\}, sequence d'instructions]}
\end{itemize}
\subsubsection{Notion de param\`etres}
Une fonction {\tt Mathematica} comporte la plupart du temps un ou plusieurs 
param\`etres.\\
Exemple :\\
{\tt PGCD[a\_,b\_]:=(...;...;...)}\\
Ces param\`etres sont initialis\'es lors de l'appel de la fonction.\\
Attention : si {\tt a} ou {\tt b} sont affect\'es \`a l'int\'erieur de la
proc\'edure, les arguments de la fonction (\`a son appel) seront n\'ecessairement des variables symboliques.
\subsection{Les Entr\'ees}
On peut utiliser :\\
{\tt A=Input[]}\\
ou encore\\
{\tt A=Input[''A=?'']}\\
Si on utilise l'interface utilisateur normale, une bo\^{\i}te de dialogue s'ouvre.
\subsection{Les Sorties}
{\tt Print[''A= '',A]}\\
\subsection{La s\'equence d'instructions ou action}
On encha\^{\i}ne les instructions sur une m\^eme ligne (ou pas) en les s\'eparant par un point virgule ({\tt ;}). Mais les instructions suivies d'un {\tt ;}
 ne provoquent pas de sortie.
Pour obtenir une sortie pour chaque instruction, il faut les encha\^{\i}ner
par un passage \`a la ligne (touche ''retour chariot'').
\subsection{L'instruction d'affectation}
Deux affectations sont possibles : l'affectation imm\'ediate ({\tt =}) et 
l'affectation diff\'er\'ee  ({\tt :=}).\\
Si on utilise {\tt =} {\tt Mathematica} \'evalue le membre de droite et 
affecte le r\'esultat au membre de gauche.\\
Si on utilise {\tt :=} l'affectation est diff\'er\'ee, {\tt Mathematica} 
n'\'evalue le membre de droite qu'\`a l'appel du membre de gauche et produit l'affectation.\\
On retiendra que la d\'efinition d'une fonction se fait plut\^ot avec une affectation diff\'er\'ee. 
\subsection{Les instructions conditionnelles}
Toutes les instructions sont des fonctions \`a plusieurs variables.\\
La commande {\tt If} autorise une logique \`a 3 \'etats.\\
{\tt If[condition,action si vrai, action si faux,(optionnel) action si ind\'etermin\'e]}\\
Exemple :\\
{\tt signe[n\_]:= If[n>=0,Print[''positif''],Print[''negatif''], Print[''je ne sais pas'']}\\
Ainsi,  la r\'eponse de  {\tt signe[''maths'']} est {\tt je ne sais pas }.
\subsection{Les instructions "Pour" }
{\tt For[initialisation,test,increment,instructions]}\\
\`A l'appel de {\tt For}, {\tt Mathematica} \'evalue l'initialisation de la variable, puis \'evalue les instructions et incr\'emente la variable (selon les
sp\'ecifications du programmeur) jusqu'\`a ce que le test ne soit plus vrai.\\
Exemple :\\
{\tt For[i=0,i<3,i++,Print[i]]}\\
La r\'eponse est :\\
0\\
1\\
2
\subsection{L'instruction ``Repeter''}
Il n'y a pas vraiement de sch\'ema ''r\'ep\'eter jusqu'\`a'' mais il existe une commande ''r\'ep\'eter''.\\
{\tt Do[instructions,\{n\}}] : r\'ep\'ete {\tt n} fois les instructions.\\
{\tt Do[instructions,\{n, nmax\}}] : r\'ep\'ete les instructions pour {\tt n}
variant de 1 \`a {\tt nmax}, par {\tt pas} de 1.\\ 
{\tt Do[instructions,\{n, nmin, nmax\}}] : r\'ep\'ete  les instructions pour 
{\tt n} variant de  {\tt nmin} \`a {\tt nmax}, par {\tt pas} de 1.\\
{\tt Do[instructions,\{n, nmin, nmax, p\}}] : r\'ep\'ete {\tt n} fois les instructions pour {\tt n} variant de  {\tt nmin} \`a {\tt nmax},par {\tt pas} de  {\tt p}.\\
La boucle n'est plus  effectu\'ee quand {\tt n} d\'epasse {\tt nmax}.\\
Exemple :\\
{\tt Do[Print[i],\{i, 1.2, 3.3, 0.5\}]}\\
La r\'eponse est :\\
{\tt 1.2\\
1.7\\
2.2\\
2.7\\
3.2}
\subsection{L'instruction ``Tant que''}
{\tt While[test,instructions]} \\
{\tt test} est \'evalu\'e, si le {\tt test} est 
vrai, on effectue les instructions, puis on recommence (on \'evalue  {\tt test} ...) jusqu'\`a ce que ce {\tt test} ne soit plus vrai.\\ 
Exemple :\\
{\tt i=0;While[i<3,Print[i];i++]}\\
La r\'eponse est :\\
{\tt 0\\
1\\
2}
\subsection{Les conditions ou expressions bool\'eennes }
Les op\'erateurs relationnels sont :\\
${\tt == \ \  < \ \  >\ \   <= \ \  >=\ \  \neq}$\\
Les op\'erateurs logiques sont :\\
${\tt Or(\vee),\ \  And(\wedge),\ \ Not(\neg),\ \ Xor,\ \ Implies(\Rightarrow)}$\\
Ce sont des op\'erateurs pr\'efix\'es.\\
Exemple :\\
{\tt And[2<5, 3<8]}\\
La r\'eponse est :\\
{\tt True}
\subsection{Les fonctions}
En {\tt Mathematica}, il n'est pas necessaire d'employer {\tt Return} pour 
afficher un r\'esultat, mais {\tt Return} permet de d\'efinir la valeur d'une
fonction.
Ainsi, {\tt Return[<r\'esultat>]} force l'\'evaluation de ce r\'esultat
 et fait sortir imm\'ediatement de la fonction.\\
Exemple :\\
{\tt addition[a\_, b\_] := Return[a+b]}
puis on tape :\\
{\tt addition[2,3]}\\
la r\'eponse est : 5\\
On remarquera l'utilisation des crochets pour mettre les param\`etres.
\subsection{Les listes}
Une liste est une suite d'objets s\'epar\'es par des virgules, \`a l'int\'erieur de deux accolades.\\
{\tt \{\}} est la liste vide.\\
De nombreuses fonctions op\`erent sur les listes.\\
 Exemple :\\
{\tt l = \{1, 2, 2, 3\}}\\
{\tt Length[l]} est le nombre d'\'el\'ements de {\tt l},
dans l'exemple la r\'eponse est :
4 \\
{\tt l[[4]]} d\'esigne le quatri\`eme \'el\'ement ici 3.\\
{\tt Append[l,4]} d\'esigne la liste form\'ee par {\tt l} et {\tt 4} ici c'est la
liste :\\
 {\tt \{1, 2, 2, 3, 4\}} (la liste {\tt l} n'est pas modifi\'ee).\\
{\tt AppendTo[l,4]} modifie la liste {\tt l} en mettant l'\'el\'ement {\tt 4} \`a la fin de la liste : dans l'exemple {\tt l} est alors \'egale \`a :\\
{\tt \{1, 2, 2, 3, 4\}}\\
{\tt Prepend[l,0]} et {\tt PrependTo[l,0]} met de la m\^eme fa\c{c}on l'\'el\'ement {\tt 0} au d\'ebut de la liste {\tt l}.\\
{\tt Join[\{1, 2, 3\},\{2, 3, 4, 5\}]} concat\'ene les deux listes en :\\
{\tt \{1, 2, 3, 2, 3, 4, 5\}}\\
{\tt Union[\{1, 2, 3\},\{2, 3, 4, 5\}]} concat\'ene les deux listes en :\\
{\tt \{1, 2, 3, 4, 5\}} en \'eliminant les doublons.\\
{\tt Union[ \{1, 5, 3, 2, 3, 4, 5\}]}  appliqu\'e \`a une seule liste \'elimine
 les doublons et trie la liste, dans la mesure du possible (dans l'exemple la r\'eponse est {\tt \{1, 3, 4, 5\}}).\\
{\tt Intersection[\{1, 2, 2\},\{5, 4, 2, 2\}]} donne l'intersection de deux listes, ces listes sont interpr\'et\'ees comme des ensembles et les doublons sont \'elimin\'es (dans l'exemple la r\'eponse est {\tt \{2\}}).\\

On peut aussi faire d'autres op\'erations sur les listes :\\
\begin{itemize}
\item le produit scalaire est obtenu avec {\tt .} entre les deux listes :\\
{\tt \{1, 2, 3\}.\{4, 2, 1\}} donne {\tt 11}
\item le produit terme \`a terme  est obtenu avec {\tt *} entre les deux listes :\\
{\tt \{1, 2, 3\}*\{4, 2, 1\}} donne {\tt \{4, 4, 3\}}
\item la somme terme \`a terme  est obtenue avec {\tt +} entre les deux listes :\\
{\tt \{1, 2, 3\}+\{4, 2, 1\}} donne {\tt \{5, 4, 4\}}
\item le produit terme \`a terme  d'une liste avec un r\'eel est obtenu avec {\tt *} 
entre le r\'eel et la liste :\\
{\tt 2*\{1, 2, 3\}} donne {\tt \{2, 4, 6\}}
\item la somme terme \`a terme d'une liste  avec un r\'eel est obtenue avec {\tt +} entre le r\'eel et la liste :\\
{\tt 5+\{1, 2, 3\}} donne {\tt \{6, 7, 8\}}
\item la puissance d'une  liste avec un r\'eel est obtenue avec 
{\tt \circonflexe} entre 
la liste et le r\'eel  :\\
{\tt \{1, 2, 3\}\circonflexe 2} donne {\tt \{1, 4, 9\}}
\item la puissance d'un r\'eel avec une  liste est obtenue avec {\tt \circonflexe} entre 
le r\'eel et la liste:\\
{\tt 5\circonflexe \{1, 2, 3\}} donne {\tt \{5, 25, 125\}}
\end{itemize}  
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
-Version it\'erative proc\'edurale\\
%\begin{verbatim}
{\tt pgcd[x\_,y\_] :=Module[\{a=x,b=y,r\},While[b>0,r=Mod[a,b];a=b;b=r];a]}\\
%\end{verbarim}

-Version r\'ecursive proc\'edurale\\
%\begin{verbatim}
{\tt pgcd2[a\_,b\_] :=If[b==0,a,pgcd2[b,Mod[a,b]]]}\\

%\end{verbarim}
-Version r\'ecursive d\'eclarative\\
%\begin{verbatim}
{\tt pgcd3[a\_,0] :=a;\\
pgcd3[a\_,b\_] :=pgcd3[b,Mod[a,b]]}
%\end{verbarim}

\chapter{Algorithmique et Maxima}
\section{Installation} \label{sec:recup}

Site home:
\verb|http://www.ma.utexas.edu/users/wfs/maxima.html|

Installation Linux: binaires au format RPM (distributions 
Red Hat, Mandrake, ...)\\
\verb|http://rpmfind.net/linux/RPM/sourceforge/symaxx/maxima-5.6-1.i386.html|\\
Au format DEB (distribution Debian)\\
\verb|ftp://ftp.lip6.fr/pub/linux/distributions/debian/pool/main/m/maxima/maxima_5.6-5_i386.deb|\\
Compilation depuis le source\\
Il faut d'abord installer le compilateur Lisp GCL, disponible sur~:\\
\verb|ftp://ftp.ma.utexas.edu/pub/gcl|\\
puis maxima 5.6 disponible sur~:\\
\verb|ftp://ftp.ma.utexas.edu/pub/maxima/|

Installation Windows, r\'ecuperez et ex\'ecutez le programme d'installation:
\verb|http://www.ma.utexas.edu/users/wfs/maxima-download/maxima55l-setup.exe|


\section{Pr\'esentation} \label{sec:intro}
{\tt Maxima} est un logiciel de calcul formel g\'en\'eraliste: il permet de
manipuler de mani\`ere exacte des expressions symboliques: par exemple
d\'evelopper, factoriser une expression, d\'eriver, trouver une primitive,
calculer une limite, r\'esoudre une \'equation de mani\`ere exacte si 
c'est possible ou de mani\`ere approch\'ee sinon. Il sait tracer des graphes 
de fonctions d'une variable, mais aussi de fonctions de 2 variables. Il peut 
\^etre utilis\'e dans le sup\'erieur aussi bien que dans le secondaire.

Ce logiciel est d\'evelopp\'e depuis les ann\'ees 1970, il est devenu
r\'ecemment un logiciel libre et est maintenu par William F. Schelter 
(dont l'adresse est \verb|wfs@math.utexas.edu|).
\subsection{Lancement} \label{sec:lancement}
Tapez \verb|xmaxima| dans une fen\^etre de commandes. La fen\^etre 
\verb|xmaxima| se d\'ecompose en 4 parties de haut en bas:
\begin{itemize}
\item une barre de menu (\verb|file|, \verb|edit|, \verb|help|)
\item la feuille de calcul qui contient les commandes et les r\'esultats 
de \verb|Maxima|
\item une barre de boutons de navigation de l'aide de {\tt Maxima}
\item l'aide de {\tt Maxima}
\end{itemize}
\subsection{Exemples} \label{sec:exemples}
Voici quelques exemples de commandes de {\tt Maxima}:
\begin{itemize}
\item d\'evelopper une expression: \verb|ratsimp((1+x)^10);|
\item factoriser une expression sur les entiers: \verb|factor(x^100-1);|
\item d\'eriver une fonction: \verb|diff(sin(x^2),x);|
\item trouver une primitive: \verb|integrate(1/(x^4+1),x);|
\item calculer la limite d'une fonction en un point:\\
\verb|limit(sin(x)/x,x,0);|
\item r\'esoudre une \'equation polynomiale: \verb|solve(x^5+x+1=0);|
\item r\'esoudre un syst\`eme d'\'equations lin\'eaires:\\
\verb|solve([x+y+z=5,3*x-5*y=10,y+2*z=3],[x,y,z]);|
\item tracer le graphe d'une fonction:\\
\verb|plot2d(sin(x),[x,0,2*%Pi]);|
\item tracer le graphe d'une fonction de 2 variables:\\
\verb|plot3d(x^2-y^2,[x,-2,2],[y,-2,2]);|
\end{itemize}
\subsection{Forces et faiblesses} \label{sec:rem}
Les points forts:
\begin{itemize}
\item l'aide en ligne se trouve dans la m\^eme fen\^etre,
\item les graphes de fonctions sont int\'egr\'es \`a la feuille de calcul
\item les commandes et les r\'eponses de {\tt Maxima} sont num\'erot\'ees
automatiquement, il est donc tr\`es facile de r\'eutiliser un r\'esultat
pr\'ec\'edent (inutile de le stocker explicitement dans une variable)
\item le navigateur de l'aide permet de lancer \verb|netmath| qui
devrait pouvoir lancer d'autres logiciels libres ou gratuits plus 
sp\'ecialis\'es dans d'autres domaines, par exemple \verb|PARI/GP| 
pour les th\'eoriciens des nombres.
\end{itemize}
La principale faiblesse de {\tt Maxima} est qu'il ne sait pas bien g\'erer les
extensions alg\'ebriques, mais ceci ne devrait pas \^etre g\^enant avant 
la maitrise de math\'ematiques.
\section{Pour commencer}
\subsection{Comment lancer  Maxima ?}
Sur un PC, sous Linux, lancer {\tt Maxima} en tapant :\\
{\tt xmaxima}
\subsection{Comment \'editer et sauver un programme}
Sur une ligne d'entr\'ee, on \'ecrit des ordres (ou commandes) {\tt Maxima} qui peuvent \^etre imm\'ediatement ex\'ecut\'ees.\\
Apr\`es chaque ordre, termin\'e par ; et envoy\'e par la touche {\tt Entr\'ee},
 la sortie correspondante est affich\'ee dans une zone de sortie, g\'er\'ee par
{\tt Maxima} et la r\'eponse numerot\'ee par un label ; une nouvelle zone d'entr\'ee (elle aussi numerot\'ee) est automatiquement cr\'e\'ee.\\
Un ordre, termin\'e par \$ et envoy\'e par la touche {\tt Entr\'ee} sera \'ex\'ecut\'e sans entra\^iner de sortie.\\
Pour {\tt Maxima} un programme est une fonction.\\
On \'ecrira par exemple :\\
{\tt ma\_procedure(x1,x2):=(x1+x2)/2;}\\
ou encore\\
{\tt f(x):=cos(x)-x;}\\
{\tt newton(f,x0):= block([dfx0,numer], \\
local (df),\\
numer:true;
define(df(x),diff(f(x),x)),\\
do (dfx0:df(x0),\\
if dfx0=0.0 then diplay(``division par zero''),\\
x0:x0-f(x0)/dfx0,\\
if abs(f(x0))<1.1E-6 then return(x0)));}\\ 
Apr\`es la derni\`ere ligne, on tapera simplement sur {\tt Entr\'ee}.\\
Le ; entra\^inera l'affichage du texte de la procedure, qui aura alors \'et\'e analys\'e et consid\'er\'e comme correct, syntaxiquement. \\

On peut aussi taper son programme dans son \'editeur pr\'ef\'er\'e (par exemple emacs) puis on le sauve par exemple sous le nom {\tt essai.mc}\\
Puis dans {\tt Maxima} il faut taper :\\
{\tt batch(``essai.mc'');} 
pour valider le programme.\\
Si l'on veut traduire un programme \'ecrit en {\tt Maxima} en {\tt Lisp} il faut taper :\\
{\tt translate\_file(``essai.mc'')} et cela cr\'ee un fichier {\tt essai.LISP}.Ce fichier  peut alors \^etre utiliser dans {\tt Maxima} en tapant : {\tt loadfile(``essai.LISP'')}\\

Si le programme pgcdr a \'et\'e traduit en {\tt Lisp} la commande :\\
{\tt dispfun(pgcdr)} re\'ecrit ce programme en {\tt Maxima}.
\subsection{Comment corriger un programme} 
Pour modifier un programme existant, ou pour corriger une erreur de syntaxe, 
on revient dans le texte m\^eme, \`a l'endroit voulu (avec un clic de la 
souris). \\
On r\'ealise les modifications du texte, et on termine en tapant {\tt Entr\'ee} (sans forc\'ement revenir en fin de texte).\\
La proc\'edure est de nouveau analys\'ee et affich\'ee (si elle est correcte).\\
On peut aussi faire les corrections et les am\'eliorations dans l'\'editeur,
puis refaire la commande {\tt batch(``  ``);}
 \subsection{Comment \'ex\'ecuter un programme}
Les proc\'edures de {\tt Maxima} sont essentiellement des fonctions.\\
Comme en {\tt MuPAD},  {\tt ma\_procedure(5, 13)} est un nombre qui peut \^etre simplement 
affich\'e ou utilis\'e dans d'autres fonctions...
\subsection{Comment sauver une session de travail}
Pour sauver la session au complet il faut taper :\\
{\tt save(``travail.LISP'',all)}\\
pour sauver la valeur d'une variable ou une fonction il faut taper les noms
de variables ou de fonctions s\'epar\'es par des virgules \`a la place de {\tt all}  
\section{Les diff\'erentes instructions}
\subsection{Les commentaires}
Les commentaires sont parenth\'es\'es par {\tt /*} et {\tt  */}
\subsection{Les variables}
\subsubsection{Leurs noms}
Ce sont les endroits o\`u l'on peut stocker des valeurs, des nombres, des expressions.\\
Un nom doit commencer par une lettre, ne pas contenir d'espace, de symbole 
op\'eratoire (+, -, ...) et ne pas \^etre un mot r\'eserv\'e.\\
Avec {\tt Maxima} on peut utiliser des noms ayant plus de  8 caract\`eres.
\subsubsection{Notion de variables locales}
Le  {\tt block} permet de d\'efinir et aussi d'initialiser des variables locales qui seront locales pour la suite d'instructions situ\'ee dams le {\tt block}.\\
La syntaxe est :\\
{\tt block([v1:val1,v2:val2,v3,v4:val4],inst1,inst2,... instn)}\\
La valeur du  {\tt block} est alors la derni\`ere instruction.\\
Exemple 1: \\
\verb| block([w:0], for i:1 thru 10 do (w:w+i^2));| \\
La r\'eponse est :
{\tt DONE}\\
Si l'on veut obtenir comme r\'eponse la valeur de {\tt w} il faut \'ecrire 
{\tt w} comme derni\`ere instruction :\\ 
\verb| block([w:0], for i:1 thru 10 do (w:w+i^2),w);|\\
Cette fois la r\'eponse est :
{\tt 385}\\
Attention \`a la place des parenth\`eses  car pour :\\
\verb| block([w:0], for i:1 thru 10 do (w:w+i^2,w));|\\
La r\'eponse est :
{\tt DONE}\\

Exemple 2: \\
\verb| g(x):=block([u:x+3,w], u:u^2, w:(y+2)^2, u+w);|\\
La r\'eponse est :\\
\verb| g(x) := block([u : x + 3, w], u : u^2 , w : (y + 2)^2 , u + w)|\\
Alors :\\
{\tt g(2)} donne  \verb| (y + 2)^2 + 25|\\

Exemple 3: \\
\verb| h(x):=block([u:x+3,w], u:u^2,|\\
\verb|               if (u<3) then  w:(y+2)^2 else w:(y+2)^2+1,|\\
\verb|               u+w);|\\
La r\'eponse est :\\
\verb| h(x) :=block([u : x + 3, w], u : u^2 ,|\\ 
\verb|   if (u<3) then w : (y + 2)^2  else  w : (y + 2)^2  + 1, u + w)|\\
 Alors :\\
{\tt [h(-2),h(2)]} donne \verb| [(y+2)^2+1,(y+2)^2+26]|  \\

\subsubsection{Notion de param\`etres}
Quand on \'ecrit une fonction il est possible d'utiliser des param\`etres.\\
Par exemple si {\tt a} et {\tt b} sont les param\`etres de la fonction {\tt pgcd}  on \'ecrit :\\
{\tt pgcd(a,b)}\\
Ces param\`etres se comportent comme des variables locales, la seule diff\'erence 
est qu'ils sont obligatoirement initialis\'es lors de l'appel de la fonction. 
L'ex\'ecution  se fait en demandant par exemple :
{\tt pgcd(15,75)}\\
\subsection{Les Entr\'ees}
\noindent{\tt read(string1, ...)} \'ecrit ses arguments puis lit et \'evalue ce que l'utilisteur a entr\'e.\\ 
Par exemple:\\ 
{\tt a:read("entrez le nbre d'iterations")}\\  
{\tt readonly (string1,...)} 
 \'ecrit ses arguments puis lit  ce que l'utilisateur a entr\'e sans
l'\'evaluer.
\subsection{Les Sorties}
\noindent{\tt disp(expr1,expr2, ...)} affiche les valeurs de ses arguments.\\  
{\tt display(expr1, expr2, ...)} affiche les valeurs de ses arguments sous la forme {\tt expr1=valeur(expr1)...}.\\
{\tt ldisplay(expr1, expr2, ...)} affiche comme {\tt display} mais donne aux r\'esultats interm\'ediaires  un label ({\tt E11...}). 
\subsection{La s\'equence d'instructions ou action}
Une action est une s\'equence d'une ou plusieurs instructions.\\
Dans un {\tt block} ou dans la d\'efinition d'une fonction les
diff\'erentes instructions sont s\'epar\'ees par  des virgules ({\tt ,})\\
Lorsque l'on veut ex\'ecuter une commande il faut terminer cette commande par 
un point-virgule ({\tt ;}) ou par un dollar ({\tt \$}) (par un point-virgule 
({\tt ;}) si on veut avoir en \'echo la r\'eponse ou par un dollar ({\tt \$}) 
pour ne pas avoir d'\'echo).
\subsection{L'instruction d'affectation}
L'affectation se traduit par le signe {\tt :} (deux points).\\
Quand on utilise l'affectation (par exemple {\tt a:2;}) {\tt Maxima} \'evalue le membre de droite et 
affecte le r\'esultat au membre de gauche.\\
%On peut aussi utiliser ${\tt ::}$ pour des affectations simples.\\
Exemple : \\
Pour stocker 2 dans la variable {\tt a } on \'ecrit {\tt a:2;}.\\
% ou ${\tt a::2;}$\\
Pour stocker la valeur contenue dans {\tt b} dans la variable {\tt a } on 
\'ecrit {\tt a:b;}\\
% ou ${\tt a::b;}$ mais 
et pour stocker {\tt b+2} dans {\tt a} on \'ecrit {\tt a:b+2;} 

Attention!!!\\
{\tt :=} sert \`a d\'efinir une fonction.\\ 
Exemples :\\
{\tt f(x):=2*x+1}\\
alors {\tt f(2)} donne 5\\
{\tt factorielle(n):=block([f:1],for i:1 thru n do (f:f*i),f);}\\ 
alors \\
{\tt factorielle(4)} donne {\tt 24}.
\subsection{Les instructions conditionnelles}
\noindent{\tt if   \emph{condition} then  \emph{expression1}}\\
{\tt if   \emph{condition} then  \emph{expression1} else  \emph{expression2}}\\
  Exemple :\\
{\tt if (a = 10) or (a < b) then  b:b-a  else a:a-b}
\subsection{Les instructions "do" }\label{sec:do}
Il y a trois types d'instructions {\tt do} :\\
Le premier type est semblable \`a l'instruction ``pour'' (cf \ref{sec:pour}).\\
Le deuxi\`eme  type est semblable \`a l'instruction ``r\'ep\'eter'' (cf \ref{sec:repeter}).\\
Le troisi\`eme  type est semblable \`a l'instruction ``tant que'' (cf \ref{sec:tantque}).

\subsection{Les instructions "Pour" }\label{sec:pour}
La syntaxe est :\\
{\tt for i:1 step 2 thru 10 do (i1,i2,i3)}\\
Exemples :\\
{\tt block([w:0], for i:1 thru 10 do (w:w+i*i))}\\
r\'eponse : {\tt  DONE}\\ 
{\tt block([w:0], for i:1 thru 10 do (w:w+i*i),w)}\\ 
r\'eponse : {\tt 385}\\ 
{\tt (x:1,for i from 1 thru 10 do (x:x*i),x);}\\
r\'eponse  {\tt 3628800}
On remarquera que {\tt step 1} peut \^etre omis.\\
\begin{verbatim}
 (C1)for a:1 thru 6 step 2 do ldisplay (i);
 (E1)         a = 1
 (E2]         a = 3 
 (E2)         a = 5 
\end{verbatim}  
 La fonction {\tt ldisplay} donne des labels (ici {\tt E1, E2, E3}) aux r\'eponses
interm\'ediaires.\\
On peut aussi \'ecrire :\\
{\tt for f in [log, atan] do ldisp(f(1));}\\
On obtient :\\
{\tt 0}\\
$\displaystyle{\tt \frac{\% \mbox{PI}}{4}}$
\subsection{L'instruction ``Repeter''}\label{sec:repeter}
La syntaxe est :\\
{\tt for i:1 step 2 unless \emph{condition} do (i1,i2,i3)}\\
Exemples :\\
{\tt for p:1 unless p>7 do\\
          (t:diff(t,x)/p,}\\
        \verb| s:s+subst(x=0,t)*x^p)|\\
On remarquera que {\tt step 1} peut \^etre omis.\\

\noindent{\tt f(x):=cos(x)-x;}\\
{\tt newton(f,x0):= block([dfxn,numer], \\
local (df,xn),\\
numer:true;
define(df(x),diff(f(x),x)),\\
for xn:x0 unless abs(f(xn))<1.1E-6 do \\
(dfx0:df(xn),\\
if dfx0=0.0 then diplay(``division par zero''),\\
xn:xn-f(xn)/dfxn));}\\ 

\noindent On peut aussi omettre ``for...unless  condition '' en utilisant la fonction 
{\tt return}\\
{\tt f(x):=cos(x)-x;}\\
{\tt newton(f,x0):= block([dfx0,numer], \\
local (df),\\
numer:true;
define(df(x),diff(f(x),x)),\\
do (dfx0:df(x0),\\
if dfx0=0.0 then diplay(``division par zero''),\\
x0:x0-f(x0)/dfx0,\\
if abs(f(x0))<1.1E-6 then return(x0)));}\\ 
\subsection{L'instruction ``Tant que''} \label{sec:tantque}
La syntaxe est :\\
{\tt for i:1 step 2 while \emph{condition} do (i1,i2,i3)}\\
Exemples :\\
{\tt (s:1, for i:1 while i<10 do (s:s+i))}\\
On remarquera que {\tt step 1} peut \^etre omis.\\
\begin{verbatim}
s:0$
for i:1 while i<=10 do s:s+i;
          DONE
s;
          55
\end{verbatim}
Autre forme permise (lorsque l'indice n'apparait pas dans les instructions ):\\
{\tt x=20\$}\\
{\tt (while x>10 do (x:x-1),x);}\\
la r\'eponse est : {\tt 10}\\
ou encore\\
{\tt x=20\$}\\
{\tt (thru 10 while x>-20 do (x:x-1),x);}\\
la r\'eponse est : {\tt  10}  (la boucle while est effectu\'ee au plus 10 fois)\\
\subsection{Les conditions ou expressions bool\'eennes }
 \noindent{\tt ou} se traduit par {\tt or}\\
{\tt et} se traduit par {\tt and}\\
{\tt non} se traduit par {\tt not}(op\'erateur pr\'efix\'e)\\
{\tt \'egalit\'e} se traduit par {\tt =}\\
{\tt diff\'erent} se traduit par  {\tt \#}\\
{\tt inf\'erieur} se traduit par {\tt <}\\
{\tt sup\'erieur} se traduit par {\tt >}\\
{\tt inf\'erieur ou \'egal} se traduit par {\tt <=}\\
{\tt sup\'erieur ou \'egal} se traduit par {\tt >=}\\   
Exemple :\\
\verb|x:20;$|
\verb|a:(if (x >17) then 2 else 4);|\\
r\'eponse {\tt 4}\\
\verb|a:(if (x >17) then x:2 else a:4,a+x);|\\
r\'eponse {\tt 24}\\
\verb|a:(x:1,for i from 1 thru 10 do (x:x*i));|\\
r\'eponse {\tt DONE}
\subsection{Les fonctions}
\noindent{\tt :=} sert \`a d\'efinir les fonctions.\\
Exemples :\\
{\tt f(x):=x+2;} 
{\tt f(2)} donne {\tt 4}\\
{\tt g(a, b) := (if a= 10 or a<b then b:b - a else a:a - b, [a, b]);}\\
{\tt g(2,5)} donne {\tt [2,3]}\\
La fonction {\tt return} permet de sortir d'un block en renvoyant son argument.\\
Exemple :\\
{\tt heron(n):=block([r:2],\\
for i:1 thru 10 do (r:0.5*(r+n/r),\\
\  if abs(r*r-n)<0.000001 then return(r)),}\\
{\tt [r,10]);}\\
{\tt heron(n)} renvoie la valeur approch\'ee de ${\tt \sqrt(n)}$ \`a $10^{-6}$ 
pr\'es si on a fait moins de 10 it\'erations et sinon renvoie ${\tt [U_{10},10]}$ o\`u ${\tt U_{0}=2, U_{i}=0.5*(U_{i-1}+n/U_{i-1})}$ . 
\subsection{Les listes}
On utilise les [] pour d\'elimiter une liste.\\
Par exemple [1, 2, 7, x+y] est une liste de 4 \'el\'ements.\\
Voici quelques commandes utiles :\\  
{\tt append(liste1, liste2, ...)} renvoie la concat\'enation des listes plac\'ees en argument (faire {\tt example(append);} pour avoir un exemple.\\  
{\tt cons(expr, liste1)} renvoie la liste o\`u on a mis en premier {\tt expr}
dans {\tt liste1}.\\  
{\tt endcons(expr, liste1)} renvoie la liste o\`u on a mis en dernier {\tt expr}
dans {\tt liste1}.\\  
      %{\tt copylist(l) cr\'ee la copy de la liste {\tt l} 
{\tt first(expr)} renvoie le premier \'el\'ement de {\tt expr}.\\  
 {\tt last(expr)} renvoie le dernier \'el\'ement de {\tt expr}.\\  
{\tt delete(expr1, expr2)} enl\`eve dans {\tt expr2} toutes les occurrences de {\tt expr1}.\\
 {\tt delete(expr1, expr2, n)} enl\`eve dans {\tt expr2} toutes les {\tt n} premi\`eres occurrences de {\tt expr1}.\\
{\tt length(expr)} renvoie la longueur de l'expression {\tt expr}.\\
{\tt listp(expr)} renvoie {\tt true} si {\tt expr} est une liste et {\tt false}
sinon.\\
{\tt makelist(expr,var,i1,i2)} renvoie une liste constitu\'ee par les diff\'erentes valeurs prises par {\tt expr} lorsque {\tt var} varie entre {\tt i1} et {\tt i2}.\\ 
 Exemples:\\ 
{\tt makelist(i*i,i,2,8);} renvoie \\
{\tt [4, 9, 16, 25, 36, 49, 64]}\\
{\tt  makelist(concat(X,i),i,1,6)} renvoie \\
{\tt [X1,X2,X3,X4,X5,X6]}\\
{\tt  makelist(X=Y,Y,[A,B,C])}  renvoie \\
{\tt [X=A,X=B,X=C]} \\ 
  
\noindent {\tt menber(expr, liste)} renvoie {\tt true} ou {\tt false} selon que
  {\tt expr} est dans {\tt liste} ou pas.\\
{\tt rest(expr, n) } renvoie {\tt expr} sans ses {\tt n} premiers termes si {\tt n} est positif ou sans ses {\tt n} derniers termes si {\tt n} est negatif.\\ 
{\tt reverse(liste)} renvoie la liste dans l'ordre inverse.\\  
On peut aussi d\'efinir des matrices par exemple :\\
{\tt A:matrix([1,2],[3,4]);}\\ 
\subsection{Calcul du PGCD par l'algorithme d'Euclide}
Version it\'erative \\
{\tt pgcd(a,b):=(local(r),do (if b=0 then return(abs(a)),\\r:mod(a,b), a:b,b:r));\\
pgcd1(a,b):=block([r],do (if b=0 then return(abs(a)),\\r:mod(a,b),
 a:b,b:r));\\
pgcd2(a,b):=(local(r),while b\#0 do (r:mod(a,b), a:b,b:r),\\abs(a));\\
pgcd3(a,b):=block([r],while b\#0 do (r:mod(a,b), a:b,b:r),\\abs(a));\\
}
Version r\'ecursive\\
{\tt pgcd4(a,b):=block([],if b=0 then return(abs(a)),return(pgcd4(b,mod(a,b))));}\\
ou encore\\
{\tt pgcd5(a,b):=if b=0 then abs(a) else pgcd5(b,mod(a,b));}
\chapter{ Algorithmique et MuPAD}
\section{Pour commencer}
 {\bf Attention} \\
{\tt MuPAD} est  sensible \`a la diff\'erence entre majuscules et minuscules.
\subsection{Comment \'editer 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);| \  ce 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.

\subsection{Comment corriger un programme} 
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/|

\subsection{Comment ex\'ecuter 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|.

\subsection{Comment am\'eliorer puis  sauver sous un autre nom un programme}
%\subsubsection{Traduction MuPAD}
Si vous voulez avoir \`a 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\'eliorer 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|.
\section{Les diff\'erentes 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 \`a la ligne.
\subsubsection{Traduction MuPAD}
 un commentaire est entour\'e de deux {\tt \#} ou \\
commence par {\tt /*} et se termine par  {\tt */}.\\
\# ceci est un commentaire \#\\
/* ceci est un commentaire */
\subsection{Les variables}
\subsubsection{Leurs noms}
Ce sont les endroits o\`u l'on peut stocker des valeurs, des nombres, des expressions.\\
Un nom doit commencer par une lettre, ne pas contenir d'espace, de symbole 
op\'eratoire (+, -, ...) et ne pas \^etre un mot r\'eserv\'e.\\
Avec {\tt MuPAD} on peut utiliser des noms ayant m\^eme plus 
de  8 caract\`eres.
\subsubsection{Notion de variables locales}
Pour {\tt MuPAD},  il faut d\'efinir les variables locales en d\'ebut de programme en \'ecrivant :\\
{\tt local a,b}
\subsubsection{Notion de param\`etres}
Quand on \'ecrit une fonction il est possible d'utiliser des param\`etres.\\
Par exemple si {\tt A} et {\tt B} sont les param\`etres de la fonction {\tt PGCD}  on \'ecrit :\\
 {\tt fonction PGCD(A,B)....ffonction} 
\subsubsection{Traduction MuPAD}
\noindent {\tt PGCD:=proc(A,B)}\\
{\tt begin}\\
....\\
{\tt end\_proc:}\\

Ces param\`etres se comportent comme des variables locales, la seule diff\'erence 
est qu'ils sont initialis\'es lors de l'appel de la fonction. 
L'ex\'ecution  se fait en demandant par exemple :
{\tt PGCD(15,75)}
\subsection{Les Entr\'ees}
Pour que l'utilisateur puisse entrer une valeur dans la variable {\tt A} au 
cours de l'ex\'ecution d'un programme, on \'ecrira, en algorithmique :\\
{\tt saisir A}  \\
Et pour entrer des valeurs dans {\tt A} et {\tt B} on \'ecrira :\\
{\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.
\subsection{Les Sorties}
En algorithmique on \'ecrit :\\
{\tt Afficher "A=",A}
\subsubsection{Traduction MuPAD}
\noindent {\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.

\subsection{La s\'equence d'instructions ou action}
Une action est une s\'equence d'une ou plusieurs instructions.\\
En langage algorithmique, on utilisera l'espace ou le passage \`a la ligne pour
terminer une instruction.
\subsubsection{Traduction MuPAD}
\noindent Le {\tt \ :\ } ou {\tt\ ;\ } est un s\'eparateur d' instructions.\\ 
Le {\tt \ ;\ }  g\'en\'ere une sortie alors que le {\tt\ :\ } n'en g\'en\'ere pas. 
\subsection{L'instruction d'affectation}
L'affectation est utilis\'ee pour stocker une valeur ou une expression dans une 
variable.\\
En algorithmique on \'ecrira par exemple :
{\tt 2*A->B}\\
pour stocker {\tt 2*A} dans {\tt B}\\
{\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}.
\subsection{Les instructions "Pour" }
\noindent{\tt Pour I de A \`a B faire <\emph{action}> fpour}\\
{\tt Pour I de A \`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}.
\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}
\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}.
\subsection{Les conditions ou expressions bool\'eennes }
Une condition est une fonction qui a comme valeur un bool\'een, \`a savoir elle
est soit {\tt vraie} soit {\tt fausse}.
\subsubsection{Les op\'erateurs relationnels}
Pour exprimer une condition simple on utilise les op\'erateurs :\\
{\tt = < >  $\leq$  $\geq$  $\neq$}
\subsubsection{Les op\'erateurs logiques}
Pour traduire des conditions complexes, on utilise les op\'erateurs logiques :\\
{\tt ou et non} \\
qui se traduisent sur les calculatrices et en {\tt MuPAD}  par :\\
{\tt or and not} 
\subsection{Les fonctions}
Dans une fonction on ne fait pas de saisie de donn\'ees :
on utilise des param\`etres qui seront initialis\'es lors de l'appel.\\
Dans une fonction on veut pouvoir r\'eutiliser le r\'esultat :\\
on n'utilise pas la commande {\tt affichage} mais la commande {\tt retourne}.\\
On \'ecrit par exemple en algorithmique :\\
\begin{verbatim}
fonction addition(A,B)
retourne A+B
ffonction
\end{verbatim}
Cela signifie que :\\
-Si on fait ex\'ecuter la fonction, ce qui se trouve juste apr\`es {\tt retourne}
  sera affich\'e. Les instructions qui suivent {\tt retourne} seront ignor\'ees.
\subsubsection{Traduction MuPAD}
On \'ecrit 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.
\subsection{Les listes}
On utilise les \{ \} pour d\'elimiter une liste.\\
Attention!!!
En algorithmique on a choisit cette notation car c'est celle qui est employ\'ee
par les calculatrices...\`a ne pas confondre avec la notion d'ensemble en
 math\'ematiques : dans un ensemble l'ordre des \'el\'ements n'a pas d'importance
mais dans une liste l'ordre est important...\\
 Par exemple \{\} d\'esigne la liste vide et \{1, 2, 3\} est une liste de 3 \'el\'ements.\\
{\tt append} sera utilis\'e pour concat\'ener 2 listes ou une liste et un \'el\'ement ou 
un \'el\'ement et une liste :\\
{\tt \{1, 2, 3\}->TAB}\\
{\tt append(TAB, 4) ->TAB}  (maintenant {\tt TAB} d\'esigne \{1, 2, 3, 4\} \\
{\tt TAB[2]} d\'esigne le deuxi\`eme \'el\'ement de {\tt TAB} ici 2.
\subsubsection{Traduction MuPAD}
Une liste est une suite d'expressions entre un crochet ouvrant {\tt [} et un crochet 
fermant {\tt ]}.\\
{\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 {\tt 4} \`a la fin de la liste {\tt l}.\\
De plus, les listes peuvent \^etre concat\'en\'ees  avec le signe {\tt .} 
(un point), par exemple {\tt [1,2].[2,3]=[1,2,2,3]}.\\
{\tt Attention} une suite d'expressions entre une accolade ouvrante \{ et une 
accolade fermante \} d\'esigne 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\}}
\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\'e sur la d\'efinition r\'ecursive 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\'esigne le reste de la division euclidienne de $A$ par $B$.\\
Voici la d\'escription 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\`es un nombre fini d'\'etapes, 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\'erative\\
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'\`a 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\'esultat A
ffonction
\end{verbatim}

 -Version r\'ecursive\\
On \'ecrit simplement la d\'efinition r\'ecursive vue plus haut.
\begin{verbatim}
Fonction PGCD(A,B)\end{verbatim}
{\tt Si B $\neq$ 0 alors}\begin{verbatim}
  r\'esultat PGCD(B,A mod B) 
  sinon
  r\'esultat A
fsi
ffonction\end{verbatim}
\subsection{Traduction MuPAD}
-Version it\'erative :
\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\'ecursive :
\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}
\chapter{Algorithmique, Pascal, C++ et calcul formel}
\section{Aspects non math\'ematiques}
\subsection{O\`u trouver un compilateur.} \label{sec:compilo}
Le mieux est d'utiliser les compilateurs libres du projet GNU.
Ils peuvent \^etre t\'el\'echarg\'es \`a partir du site \verb|www.gnu.org|,
ou plus simplement~:
\begin{itemize}
\item sous Linux, vous avez toujours un compilateur {\tt C++} sur le CD-ROM
de votre distribution. Il faut juste v\'erifier qu'il est install\'e,
il vous faut des packages nomm\'es \verb|gcc|, \verb|gcc-c++|, \verb|glibc|,
\verb|glibc-devel|, \verb|libstdc++|, \verb|libstdc++-devel|. Il
existe aussi des compilateurs {\tt Pascal} (\verb|gpc|  et {\tt Free\\ Pascal Compiler} par exemple)
\item sous Windows, procurez-vous \verb|CYGWIN|, sur 
\verb|sourceware.redhat.com|
\end{itemize}
Il existe aussi des environnements de d\'eveloppement {\tt Pascal} et {\tt C++}
commerciaux.

\subsection{Comment \'editer, corriger et sauver un programme ?}
On utilise un \'editeur de texte par exemple :\\
{\tt emacs, notepade, nedit}\\
Attention, un \'editeur de texte n'est pas un traitement de texte : il ne faut
pas par exemple utiliser {\tt Word} qui rajoute des informations de
mises en page incompr\'ehensibles pour le compilateur.\\
On tape donc le programme \`a l'aide de son  \'editeur de texte pr\'ef\'er\'e
et on le sauve sous un nom de fichier ayant comme extention {\tt .pas} pour les
programmes  {\tt Pascal} et {\tt .cc} pour les
programmes  {\tt C++}.
Pour sauver, on utilise bien s\^ur la commande de sauvegarde de l'\'editeur.\\
Pour corriger une erreur, il suffit de r\'e\'editer le programme.
 L'\'editeur permet aussi de sauver sous un autre nom ce qui permet facilement 
d'avoir deux versions d'un programme ou de r\'eutiliser un morceau de programme.\\
\newpage
La forme d'un programme {\tt {\tt Pascal}}\\
%\begin{verbatim}
{\tt program <\emph{idendificateur>;\\
partie inclusion de fichiers} (uses ...)\\ 
\emph {directives de compilation\\
partie declaration de variables et de fonctions}}\\
{\tt begin\\
\emph {partie instructions}\\
end.}\\
%\end{verbatim}
La partie d\'eclaration consiste en la d\'eclaration des variables et la 
d\'efinition des fonctions utilis\'ees dans le programme.\\
Par exemple on d\'eclare dans ce qui suit deux variables enti\`eres (x et y)
et une fonction (la fonction pgcd) :
\begin{verbatim}
var x,y:integer;
pgcd(a,b:integer):integer;
var r:integer;
begin
while (b<>0)
  begin
   r:=a mod b;
   a:=b;
   b:=r
 end;
pgcd:=a;
end;
\end{verbatim}
\ \\
La forme d'un programme {\tt C++} :\\
%\begin{verbatim}
{\tt /* commentaires indiquant ce que fait le programme*/\\
\emph{partie inclusion de fichiers} (\#include <iostream>)\\
\emph{partie declaration de variables et de fonctions}\\
int main()\{ \\
 \emph{partie instructions;}\\
return(0);\\
\}}\\
%\end{verbatim}
La partie d\'eclaration consiste en la d\'eclaration des variables et la 
d\'efinition des fonctions utilis\'ees dans le programme.\\
Par exemple on d\'eclare dans ce qui suit deux variables enti\`eres (x et y)
et une fonction (la fonction pgcd) :
\begin{verbatim}
int x,y;
int pgcd(int a,int b){
  int r;
  while (b!=0){
    r=a%b;
    a=b;
    b=r;
  }
  return(a);
}
\end{verbatim} 
\subsection{Comment compiler un programme}
Il existe des environnements de d\'eveloppement int\'egr\'e pour {\tt Pascal}
et {\tt C++}, dans ces environnements on peut utiliser la commande de compilation
qui se trouve dans un des menus. Sous Unix ou sous Windows avec
les outils de d\'eveloppement GNU, on tape en ligne de commande~:\\
\verb|gpc essai.pas|\\
ou~:\\
\verb|g++ essai.cc|\\
Si le programme est syntaxiquement correct, on obtient un fichier
ex\'ecutable appel\'e \verb|a.out| sous Unix et \verb|a.exe| sous
Windows.

On peut utiliser des options pour la compilation s\'epar\'ee (\verb|-c|),
pour renommer le fichier ex\'ecutable (\verb|-o nomdufichierexecutable|)
et pour inclure des informations de mise au point (\verb|-g|), ce qui
permet de localiser plus facilement les erreurs d'ex\'ecution avec
un d\'eboggueur comme \verb|gdb|.

Avec certains \'editeurs de texte (par exemple \verb|emacs|), on peut 
automatiser la compilation. Dans l'exemple d'\verb|emacs|, on \'ecrirait
en premi\`ere ligne de \verb|essai.cc|~:\\
\verb|// -*- compile-command: "g++ -g essai.cc" -*-|

\subsection{Comment ex\'ecuter un programme}
Sous Unix, taper dans la fen\^etre de commandes \verb|./a.out|.\\
Sous Windows, on tape \verb|./a.exe|.

\subsection{Remarques}
Les compilateurs {\tt C++} font toujours la diff\'erence entre les majuscules 
et les minuscules. Pour {\tt Pascal}, cela d\'epend des compilateurs.

Lorsqu'on \'ecrit une fonction en {\tt Pascal} ou en {\tt C++} on ne peut pas 
l'utiliser directement, on doit aussi \'ecrire un programme (qu'il faudra
compiler) qui utilise cette fonction (programme qui affiche par exemple la valeur de cette fonction).

En {\tt Pascal et C++} on peut compiler des fonctions seules puis les 
r\'eutilser dans diff\'erents programmes \`a condition de mettre au d\'ebut 
du programme une inclusion de fichiers.\\
Exemple~:
\begin{itemize}
\item 
En {\tt Pascal} : \\ {\tt uses <\emph{nomdufichier}>}
\item 
En {\tt  C++} :\\
{\tt \#include <\emph{nomdufichier}>} si ce fichier 
se trouve dans la biblioth\`eque standard.\\
{\tt \#include "\emph{nomdufichier.h}"} si ce fichier se trouve 
dans le m\^eme r\'epertoire que le programme (en g\'en\'eral vos 
propres fichiers).
Notez que \verb|nomdufichier.h| contient uniquement les d\'eclarations
des fonctions, il faut alors compiler \verb|nomdufichier.cc| avec l'option
\verb|-c|, et rajouter \verb|nomdufichier.o| dans la commande
de compilation du programme utilisant \verb|nomdufichier.h|.
\end{itemize}
\section{Les diff\'erentes instructions}
\subsection{Les commentaires}
\subsubsection{En Pascal}
Les commentaires sont parenth\'es\'es par {\tt (*} et {\tt  *)} ou par 
${\tt \{}$  et ${\tt \}}$
\subsubsection{En C++} 
Les commentaires sont parenth\'es\'es par {\tt /*} et {\tt  */} ou d\'ebutent
par {\tt //} et se terminent \`a la fin de la ligne. 
\subsection{Les variables}
Contrairement aux langages des programmes de calcul formel, les
variables en {\tt C++} et en {\tt Pascal} sont typ\'ees. On doit donc savoir
\`a l'avance si une variable contient un r\'eel, un entier, une
chaine de caract\`eres, etc.
L'inconv\'enient est une certaine perte de souplesse, l'avantage
est que le compilateur d\'etectera plus facilement des erreurs
de typage.

\subsubsection{Leurs noms}
\subsubsection{En Pascal}
On peut utiliser des noms ayant jusqu'\`a 8 caract\`eres, parfois plus
selon les compilateurs.

\subsubsection{En C++}
On peut utiliser des noms ayant jusqu'\`a 32 caract\`eres dans tous
les cas, parfois plus selon les compilateurs.

\subsubsection{Notion de variables locales}
\subsubsection{En Pascal}
Il faut d\'efinir les variables locales au d\'ebut du programme (ou au 
d\'ebut d'une proc\`edure (ou fonction) en \'ecrivant par exemple :\\
{\tt var a,b:real;}\\
La syntaxe est :\\
{\tt var <\emph{identificateurdevariable}>:<\emph{identificateurdetype}>;}
\subsubsection{En C++}
Il faut d\'efinir les variables locales \`a l'int\'erieur du bloc 
d\'efinissant  la  fonction en \'ecrivant par exemple :\\
{\tt float a,b;}\\
La syntaxe est :\\
{\tt <\emph{identificateurdetype}> <\emph{identificateurdevariable}>}\\
Remarque : en {\tt C++} on peut d\'eclarer les variables au moment o\`u on en
 a besoin : leur espace de validit\'e commence l\`a o\`u elles sont 
d\'eclar\'ees jusqu'\`a la fin du bloc.\\
 Par exemple dans :\\ 
{\tt for (int i=0;i<s;i++)\\ \hspace*{1cm}   s=s+i;}\\
la dur\'ee de vie de {\tt i} est  la boucle {\tt for}.\\   

\subsubsection{Notion de param\`etres}
\subsubsection{En Pascal}
Les proc\'edures ou fonctions peuvent avoir des param\`etres : ils se 
comportent comme des variables locales et sont initialis\'es lors de l'appel
de la proc\'edure (ou fonction).\\
Par exemple :\\
l'ent\^ete d'une proc\'edure sera :
{\tt addition(a,b :integer);}\\
l'ent\^ete d'une fonction sera :
{\tt addition(a,b :integer):integer;}
\subsubsection{En C++}
Les proc\'edures ou fonctions peuvent avoir des param\`etres : ils se 
comportent comme des variables locales et sont initialis\'es lors de l'appel
de la proc\'edure (ou fonction).\\
Par exemple :\\
l'ent\^ete d'une proc\'edure sera :
{\tt void addition(int a,int b);}\\
l'ent\^ete d'une fonction sera :
{\tt int addition(int a,int b);}
\subsection{Les Entr\'ees}
\subsubsection{En Pascal}
On \'ecrit pour demander l'entr\'ee de {\tt n} :\\
{\tt readln(n)}
\subsubsection{En C++}
Il faut tout d'abord inclure le fichier {\tt iostream (\#include <iostream>)}.
on \'ecrit alors pour demander l'entr\'ee de {\tt n} :\\
${\tt cin\ \gg \ n;}$
\subsection{Les Sorties}
\subsubsection{En Pascal}
On \'ecrit pour demander l'affichage de {\tt n} :\\
{\tt writeln('n=',n)} si on veut faire passer le curseur au d\'ebut de
la ligne suivante apr\`es l'\'ecriture de {\tt n} ou \\
{\tt write('n=',n)} si on ne veut pas passer \`a la ligne.
\subsubsection{En C++}
Il faut tout d'abord inclure le fichier {\tt iostream (\#include <iostream>)}.
on \'ecrit alors pour demander l'affichage de {\tt n} :\\
${\tt cout\ \ll \  n \ \ll \ endl;}$\\
{\tt  endl} signifie que le curseur sera mis au d\'ebut de
la ligne suivante.\\
\subsection{La s\'equence d'instructions ou action}
\subsubsection{En Pascal}
Le {\tt ;} est un s\'eparateur d'instructions.\\
Une instuction compos\'ee est un groupe d'instuctions parenth\`es\'ees par :\\
{\tt begin  end}
\subsubsection{En C++} 
Le {\tt ;} termine toutes les instructions m\^eme la derni\`ere !\\
Une instuction compos\'ee est un groupe d'instuctions parenth\`es\'ees par :\\
{\tt \{ \}}.\\
Il est inutile de mettre {\tt ;} apr\`es {\tt \}} sauf apr\`es la 
d\'efinition d'une {\tt struct}, d'une {\tt class} ou l'initialisation
d'un tableau.
\subsection{L'instruction d'affectation}
\subsubsection{En Pascal}
L'affectation se traduit par {\tt :=}\\
Exemple : Pour stocker 2 dans la variable {\tt a } on \'ecrit {\tt a:=2}\\
Pour stocker la valeur contenue dans {\tt b} dans la variable {\tt a } on \'ecrit {\tt a:=b}
\subsubsection{En C++}
L'affectation se traduit par {\tt =}\\
Exemple : Pour stocker 2 dans la variable {\tt a } on \'ecrit {\tt a=2;}\\
Pour stocker la valeur contenue dans {\tt b} dans la variable {\tt a } on \'ecrit {\tt a=b;}

\subsection{Les instructions conditionnelles}
\subsubsection{En Pascal}
\noindent{\tt If \emph{condition} then
\{\emph{action}\}}\\
{\tt if \emph{condition} then
\{\emph{action1}\} else 
\{\emph{action2}\}}\\
Exemple :\\
{\tt if (a = 10) or (a < b) then  b:=b-a  else a:=a-b}
\subsubsection{En C++}
\noindent{\tt If \emph{(condition)}
\{\emph{action};\}}\\
{\tt if \emph{(condition)}
\{\emph{action1};\} else 
\{\emph{action2};\}}\\
Exemple :\\
{\tt if ((a == 10) || (a < b))   \{b=b-a;\}  else \{a=a-b;\}}
\subsection{Les instructions "Pour" }
\subsubsection{En Pascal}
\noindent{\tt For i:=a to b do \emph{action}}\\
{\tt For i:=b downto a do \emph{action}}
\subsubsection{En C++}
\noindent{\tt for (int i=a ;i<=b;i++)\{\emph{action};\}}\\
{\tt for (int i=b ;i>= a;i-{-})\{\emph{action};\}}
\subsection{L'instruction ``Repeter''}
\subsubsection{En Pascal}
\noindent{\tt repeat  
\emph{action}
until \emph{ (condition)}}
\subsubsection{En C++}
\noindent{\tt do  \{\emph{action};\}
while \emph{ (condition)};}
\subsection{L'instruction ``Tant que''}
\subsubsection{En Pascal}
\noindent{\tt While  \emph{(condition)} do  
\emph{action}}
\subsubsection{En C++}
\noindent{\tt while  \emph{(condition)}  
\{\emph{action};\}}\\
On peut aussi utiliser l'instruction {\tt for} pour traduire un {\tt tant que}:\\
{\tt for ( ;\emph{condition}; ) \{\emph{action};\}}\\

{\bf Remarques}\\
En {\tt C++} on peut toujours interrompre une boucle gr\^ace \`a l'instruction :\\
{\tt break;}\\
Exemples \\
Sch\'ema {\tt tant que}:\\
{\tt for ( ; ; )  \{ if \ !\emph{(condition)} \{break;\} \emph{action};\}}\\
Sch\'ema {\tt repeter}:\\
{\tt for ( ; ; ) \{ \emph{action}; if \ \emph{(condition)} \{break;\} \}}\\
On peut aussi passer \`a l'it\'eration suivante gr\^ace \`a l'instruction :\\
{\tt continue}\\ 
Exemple \\
{\tt s=0;\\
for (int i=1 ;i<= 11;i++) \{ if (i==6) \{ continue;\}; s=s+i; \}}\\
On obtient alors {\tt s=60} car pour {\tt i=6} l'instruction {\tt s=s+i} n'est pas effectu\'ee.
\subsection{Les conditions ou expressions bool\'eennes }
\subsubsection{En Pascal}
\noindent{\tt ou} se traduit par {\tt or}\\
{\tt et} se traduit par {\tt and}\\
{\tt non} se traduit par {\tt not}\\
{\tt \'egalit\'e} se traduit par {\tt =}\\
{\tt diff\'erent} se traduit par  {\tt <>}\\
{\tt inf\'erieur ou \'egal} se traduit par {\tt <=}\\
{\tt sup\'erieur ou \'egal} se traduit par {\tt >=}
\subsubsection{En C++}
\noindent{\tt ou} se traduit par {\tt ||}\\
{\tt et} se traduit par {\tt \&\&}\\
{\tt non} se traduit par {\tt !}\\
{\tt \'egalit\'e} se traduit par {\tt ==}\\
{\tt diff\'erent} se traduit par {\tt !=}\\
{\tt inf\'erieur ou \'egal} se traduit par {\tt <=}\\
{\tt sup\'erieur ou \'egal} se traduit par {\tt >=}
%\subsection{Les fonctions}
%\subsubsection{En Pascal}
%\subsubsection{En C++}
\subsection{Les listes}
\subsubsection{En Pascal}
On utilise des tableaux. Contrairement aux listes, on doit donner dans la 
d\'eclaration du tableau sa dimension par exemple :\\
{\tt var T : array[5..20] of integer}\\
Dans cet exemple les indices de {\tt T} vont de 5 \`a 20 et {\tt T[10]} d\'esigne l' \'el\'ement de {\tt T} d'indice 10.  
\subsubsection{En C++}
On utilise le type {\tt vector}. Ce type n'est pas un type de base, il faut 
donc \'ecrire au d\'ebut de votre programme : 
\begin{verbatim}
#include <vector>
vector<int> v;
vector<int> w(15);
\end{verbatim}
Dans cet exemple {\tt v} est un vecteur vide et {\tt w} est un vecteur de 15 
\'el\'ements d'indices allant de 0 \`a 14.\\
{\tt w[10]} d\'esigne l' \'el\'ement de {\tt w} d'indice 10.\\ 
{\tt int s=w.size();} met dans {\tt s} la taille du vecteur {\tt w} (ici 15).\\
{\tt w.push\_back(55);} rajoute un \'el\'ement (55 ici) au vecteur {\tt w}.\\
{\tt w.pop\_back();} enl\`eve le dernier \'el\'ement au vecteur {\tt w}.\\
{\tt w.insert(w.begin()+1,55)} ins\`ere un \'el\'ement (55 ici)  avant l'\'el\'ement d'indice 1 (donc avant le 2i\`eme \'el\'ement).\\
{\tt w.erase(w.begin()+2)} enl\`eve l'\'el\'ement d'indice 2
(donc le 3i\`eme \'el\'ement).
%\subsection{Un exemple : le crible d'Eratosth\`ene}
%\subsubsection{En Pascal}
%\subsubsection{En C++}
\section{Exemple: le PGCD par l'algorithme d'Euclide}
\subsubsection{En Pascal}
-Version it\'erative
\begin{verbatim}
program pgcd;
var x,y : integer;
function pgcd(a,b:integer):integer;
  var r: integer;
  begin
  while b <> 0 do
    begin
    r:=a mod b;
    a:=b;
    b:=r
    end;
  pgcd:=a;
  end;
begin
readln(x,y);
writeln('le pgcd est',pgcd(x,y))
end. 
\end{verbatim}

-Version r\'ecursive
\begin{verbatim}
program pgcd;
var x,y : integer;
function pgcd(a,b:integer):integer;
  var r: integer;
  begin
  if  b <> 0 do
    pgcd:=pgcd(b,a mod b)
  else
    pgcd:=a;
  end;
begin
readln(x,y);
writeln('le pgcd est',pgcd(x,y))
end. 
\end{verbatim}
\subsubsection{En C++}
-Version it\'erative
\begin{verbatim}
#include <iostream>
int pgcd(int a,int b){
  int r;
  while (b!=0){
    r=a%b;
    a=b;
    b=r;
  }
  return(a);
}
int main(){
  int x,y;
  cin>>x>>y;
  cout<<pgcd(x,y)<<endl;
  return(0);
}
\end{verbatim}

-Version r\'ecursive
\begin{verbatim}
#include <iostream>
int pgcd(int a,int b){
  if (b!=0)
    return(pgcd(b,a%b);
  else 
    return(a);
}
int main(){
  int x,y;
  cin>>x>>y;
  cout<<pgcd(x,y)<<endl;
  return(0);
}
\end{verbatim}
\section{Programmer en C++ avec du calcul formel}
Il existe actuellement deux projets pour pouvoir programmer en C++
en utilisant des types symboliques: GiNaC (\verb|http://www.ginac.de|)
et Giac: pour installer giac, r\'ecup\'erez le fichier\\
\verb|ftp://fourier.ujf-grenoble.fr/pub/hp48/giac.tgz|\\
puis~:\\
\verb|tar xvfz giac.tgz|\\
\verb|cd giac-0.2.2|\\
\verb|./configure|\\
\verb|make|\\
\verb|make install| \\
(la derni\`ere \'etape n\'ecessite d'\^etre \verb|root|).

\subsection{La classe entier.} \label{sec:integer}
Mettre en en-t\^ete du programme:\\
\verb|#include <giac/gaussint.h>|\\
\verb|using namespace giac;|\\
Ensuite \verb|entier| s'utilise comme le type de base \verb|int| dans
presque toutes les situations. Attention l'op\'erateur de division \verb|/| 
n'est pas d\'efini, utilisez \verb|iquo| pour le quotient euclidien de deux
entiers.

Pour compiler votre programme, vous devrez rajouter \verb|-lgmp -lgiac|
en fin de ligne de commande.

Pour voir la valeur d'un \verb|entier| avec
le d\'eboggueur, cr\'eez un fichier \verb|.gdbinit|  contenant~:\\
\verb|echo Defining v as print command for giac types\n|\\
\verb|define v|\\
\verb|print $arg0.dbgprint()|\\
\verb|end|\\
L'impression se fait par la m\'ethode \verb|dbgprint()| de \verb|$arg0|.

\subsection{Les objets symboliques}
La classe entier de giac permet aussi de stocker des objets non entiers:
par exemple des expressions:
\begin{verbatim}
#include <iostream>
#include <giac/gaussint.h>
#include <giac/sym2poly.h> // pour factor
using namespace giac;

int main(){
  entier e(string("x^2-1"));
  cout << "La factorisation de x^2-1 est: " << factor(e) << endl;
  cout << "Entrez une expression a factoriser ";
  cin >> e;
  cout << factor(e) << endl;
}
\end{verbatim}
Sauvez ce texte par exemple sous le nom {\tt essai.cc} et compilez-le~:\\
{\tt c++ -g essai.cc -lgmp -lgiac}\\
puis ex\'ecutez-le~:\\
{\tt ./a.out}\\
Pour plus de d\'etails, vous pouvez consulter le fichier \verb|doc/classes.tex|
de giac et les fichiers d'en-t\^ete.
\section{xcas : un logiciel de calcul formel \'ecrit en C++}
\subsection{Installation de xcas}
Le programme \verb|xcas| est un logiciel libre \'ecrit en C++,
(disponible sous licence GPL). La version \`a jour se r\'ecup\`ere sur~:\\
${\tt http://www-fourier.ujf-grenoble.fr/\tild  parisse}$ ou\\
{ \tt ftp://fourier.ujf-grenoble.fr/pub/hp48}\\
o\`u l'on trouve le code source (\verb|giac.tgz|) ou des versions 
pr\'ecompil\'ees pour Linux (PC ou ARM) ou Windows ({\tt xcas.zip, xcas\_user.tgz, xcas\_root.tgz}).

\subsection{\'Editer, sauver, ex\'ecuter un programme avec xcas}
On \'edite un programme avec son \'editeur pr\'ef\'er\'e : on peut \'ecrire dans un m\^eme fichier (par exemple {\tt bidon}) la d\'efinition de plusieurs fonctions s\'epar\'ee par des points virgules ({\tt ;})\\
 On sauve ce fichier, puis dans {\tt xcas} on tape :\\
{\tt eval(bidon);}\\ 
cela a pour effet de cr\'eer  des 
fichiers ayant  le m\^eme nom que les fonctions qui sont d\'efinies dans {\tt bidon}.\\
 %On peut aussi définir une proc\'edure ou fonction : celle-ci sera sera interpr\'et\'ee lors de son appel si on a donn\'e au fichier qui la contient le m\^eme nom.\\
En tapant le nom de la fonction dans {\tt xcas} on peut voir le contenu de cette variable (ici la d\'efinition de la fonction).\\
En re\'editant le programme, on peut facilement le corriger, le sauver sous
 un autre nom etc...\\ 
On peut aussi \'ecrire directement le programme dans la ligne de commandes :\\
- si le programme est faux, il est mis dans l'historique en tant que cha\^{i}ne 
de caract\`eres et on peut ainsi le retrouver dans la ligne de commande en cliquant sur {\tt Q}\\
- si le programme est juste il est conserv\'e dans un fichier de m\^eme nom.\\
\subsection{Les instructions avec xcas}
Les commentaires sont des cha\^{i}nes de caract\`eres : ils sont donc
parenth\`es\'es par {\tt "} et {\tt "}\\

Les variables sont les endroits o\`u l'on peut stocker des valeurs, des 
nombres, des expressions, des objets.\\
Le nom des variables est form\'e par une suite de caract\`eres et commence par 
une lettre : attention on n'a pas droit aux
 mots r\'eserv\'es ...ne pas utiliser par exemple la variable {\tt i} dans un
 {\tt for} car {\tt i} repr\'esente le nombre complexe de module 1 et d'angle
 $\frac{\pi}{2}$.\\

Un {\tt bloc} est une suite d'instructions s\'epar\'ees
 par {\tt ;} ou {\tt :}\\
Un {\tt bloc} est parenth\`es\'e par {\tt \{} et {\tt \}} et commence eventuellement par la d\'eclaration des variables locales ({\tt local...}). \\
Les variables locales doivent \^etre d\'eclar\'ees au d\'ebut d'un bloc (mot r\'eserv\'e {\tt local} puis on met les noms des variables s\'epar\'es par des virgules ({\tt ,}). 
Ces variables locales peuvent \^etre initialis\'ees lors de leur d\'eclaration.\\
Voici un exemple :\\ 
${\tt idiv2(a,b):=\{ local\ q:=0,r:=a;}$\\
$\hspace*{2cm}{\tt if\ (b!=0)\ \{q:=iquo(a,b);r:=irem(a,b);\}\ [q,r];\}}$\\

Les param\`etres sont utilis\'es dans la d\'efinition de fonctions : ils sont
initialis\'es lors de l'appel de la fonction et se comportent comme des variables locales.\\ 

L'affectation se fait avec {\tt :=} (par exemple {\tt a:=2;b:=a;})\\

 Les entr\'ees se font par passage de param\`etres\\

Les sorties se font en mettant le nom de la variable \`a afficher (ou entre 
crochets  la liste des variables \`a afficher s\'epar\'ees par une virgule)
  comme derni\`ere instruction.\\

Une action (ou bloc) est une s\'equence d'une ou plusieurs instructions.\\
Quand il y a plusieurs instructions il faut les parenth\'eser avec {\tt \{ \}} 
et s\'eparer les instructions par un point virgule ({\tt ;}) ou par deux 
points ({\tt :}) \\
Les tests et boucles ont une syntaxe similaire au langage {\tt C++}.\\
\noindent${\tt testif(a,b):=\{if\ ((a==10)\ or\ (a<b))\ b:=b-a;\ else\ a:=a-b;\ [a,b];\}}$\\

\noindent${\tt testfor1(a,b):=\{local\ s:=0;for\ (j:=a;j<=b;j^{++})\ s:=s+1/j^2;\ s;\}}$\\
\noindent${\tt testfor2(a,b):=\{local\ s:=0;\ for\ (j:=b;j>=a;j^{--})\ s:=s+1/j^2;\ s;\}}$\\

\noindent${\tt testwhile(a,b):=\{while\ ((a==10)\ or\ (a<b))\ b:=b-a;\ [a,b];\}}$\\
\subsection{Le PGCD avec xcas}
- Version it\'erative\\
\noindent${\tt pgcd(a,b):=\{local\ r;\ while\ (b!=0)\ \{r:=irem(a,b);\ a:=b;\ b:=r;\ \}\ a;\}}$\\
-Version r\'ecursive\\
\noindent${\tt pgcdr(a,b):=\{if\ (b==0)\ a;\ else\ pgcdr(b,irem(a,b));\}}$\\
ou\\
\noindent${\tt pgcdr(a,b):=if\ (b==0)\ a;\ else\ pgcdr(b,irem(a,b));}$\\

\newpage
\appendix
\chapter{R\'ecup\'erer et installer un logiciel}
La description qui suit s'applique au navigateur Netscape. Elle
s'applique de mani\`ere identique pour d'autres navigateurs \`a
quelques d\'etails pr\`es.

Lorsqu'un lien mentionne un logiciel que vous voulez t\'el\'echarger, 
maintenez la touche Shift appuy\'ee et cliquez avec la souris sur
ce lien. Une fen\^etre s'ouvre et vous propose de sauvegarder
un fichier sur votre disque dur, changez \'eventuellement le nom
de ce fichier et notez l'emplacement du r\'epertoire o\`u il a \'et\'e
sauvegard\'e.

La m\'ethode d'installation du logiciel d\'epend de votre syst\`eme d'exploitation
et du type de fichier t\'el\'echarg\'e, que l'on d\'etermine en g\'en\'eral par
son extension, c'est-\`a-dire par les lettres (en principe 3) qui
suivent le caract\`ere point dans le nom de ce fichier.

Sous Windows, vous r\'ecup\'ererez en g\'en\'eral un fichier ex\'ecutable \verb|exe|
il suffit alors de cliquer sur son icone pour installer le logiciel.
Ou alors il s'agira d'une archive, il vous faudra alors un logiciel
de d\'ecompression pour l'installer (l'un des plus populaires s'appelle
Winzip et propose une version \`a l'essai gratuitement). Une fois
d\'esarchiv\'e votre logiciel, vous trouverez dans l'archive un fichier
donnant des instructions compl\'ementaires ou vous devrez vous r\'ef\'erer
au site o\`u vous avez t\'el\'echarg\'e l'archive.

Sous Linux, les formats les plus courants sont \verb|rpm|,
\verb|deb| et \verb|tgz| (ou \verb|tar.gz|).

Les deux premiers correspondent \`a des distributions Linux (Red Hat,
Mandrake, Suse par exemple pour \verb|rpm|, Debian pour \verb|deb|)
ils doivent \^etre install\'es par \verb|root| (tapez \verb|su|
dans une fen\^etre de commandes pour passer \verb|root|)
en utilisant respectivement les commandes:\\
\verb|rpm -U nom_de_fichier.rpm| pour Red Hat, Mandrake, Suse\\
\verb|apt-get install nom_de_fichier_deb| pour Debian\\
Regardez bien les \'eventuels messages d'erreurs qui apparaissent. Ils
peuvent signaler que vous devez installer d'autres logiciels de votre
distribution Linux pour faire fonctionner votre nouveau logiciel.
En g\'en\'eral ces logiciels non install\'es se trouvent sur le CD-ROM
de votre distribution Linux. Ils s'installent par la m\^eme commande,
mais vous devrez d'abord vous d\'eplacer dans le r\'epertoire du CD-ROM
qui les contient. Pour cela, introduisez le CD-ROM dans le lecteur,
attendez quelques secondes, tapez : \verb|ls /mnt/cdrom|\\
(si rien n'apparait, tapez : \verb|mount /mnt/cdrom| et recommencez). \\
Ensuite tapez \verb|cd /mnt/cdrom| puis allez dans
le r\'epertoire correct (par exemple \verb|cd Mandrake/RPMS| pour
une distribution Mandrake) et lancez les commandes d'installation
des logiciels manquants (\verb|rpm -U ...| ou \verb|apt ...|).
Certaines distributions Linux proposent des interfaces plus ou moins
conviviales pour installer des logiciels, par exemple \verb|rpmdrake|
pour Mandrake, \verb|dselect| pour Debian...

Les archives \verb|tar.gz| et \verb|tgz| s'installent 
sur toute distribution Linux. Commencez par en
regarder la table des mati\`eres par la commande:\\
\verb|tar tvfz nom_de_fichier.tgz|\\
afin de d\'eterminer depuis quel r\'epertoire il faut d\'ecompacter le fichier
ou lisez la documentation du logiciel disponible en g\'en\'eral sur le site
o\`u vous avez t\'el\'echarg\'e l'archive.
Si vous voyez apparaitre des chemins tels que \verb|usr/local/bin| ou
\verb|usr/bin|, placez vous dans le r\'epertoire racine (\verb|cd /|)
puis tapez:\\
\verb|tar xvfz nom_du_repertoire/nom_de_fichier.tgz|\\
(si vous avez sauvegard\'e l'archive dans votre r\'epertoire, vous pouvez
utiliser \verb|~votre_nom_de_login| comme \verb|nom_de_repertoire|).
Sinon, tapez simplement depuis le r\'epertoire o\`u se trouve l'archive:\\
\verb|tar xvfz nom_de_fichier.tgz|\\
placez-vous dans le r\'epertoire cr\'e\'e et lisez les fichiers \verb|README|
ou/et \verb|INSTALL| qui s'y trouvent sans doute.\\
Remarques :
 
1/ N'oubliez pas de quitter le compte de \verb|root| avant
d'utiliser votre logiciel (en tapant simultan\'ement sur les touches
Ctrl et D).

2/ les archives \verb|.tar.bz2| se traitent de mani\`ere identique,
\`a ceci pr\`es qu'il faut enlever le \verb|z| de \verb|tvfz| ou \verb|xvfz|
et rajouter \\
\verb| --use-compress-program bunzip2|, par exemple:\\
\verb|tar tvf nom_de_fichier.tar.bz2 --use-compress-program bunzip2|

3/ les archives \verb|.zip| se visualisent par la commande :\\
\verb|unzip -v nom_de_fichier.zip| et se d\'esarchivent par la commande :\\
\verb|unzip nom_de_fichier.zip|

Sous linux et autres Unix, vous trouverez \'egalement des fichiers
sources qu'il vous faudra compiler avant de pouvoir utiliser le logiciel
correspondant. De nombreux fichiers sources suivent la proc\'edure
d'installation du projet GNU. Pour les compiler la proc\'edure est
la suivante (apr\`es avoir d\'ecompress\'e l'archive):\\
\verb|cd nom_d_archive|\\
\verb|./configure|\\
\verb|make|\\
Puis on passe \verb|root| en tapant \verb|su|, puis : \verb|make install-strip|\\
puis quittez le compte \verb|root| (en tapant simultan\'ement 
sur les touches \verb|Ctrl| et \verb|D|).
Vous pourrez alors utiliser le logiciel nouvellement install\'e 
(\'eventuellement
apr\`es avoir tap\'e la commande \verb|rehash| si votre interpr\'eteur de
commandes est \verb|tcsh|).

Si cela ne fonctionne pas vous devriez trouver un fichier \verb|README|
ou \verb|INSTALL| qui explique la proc\'edure \`a suivre.


{\tiny
\chapter{GNU Free Documentation License}

Version 1.1, March 2000

Copyright (C) 2000  Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other written
document "free" in the sense of freedom: to assure everyone the effective
freedom to copy and redistribute it, with or without modifying it, either
commercially or noncommercially. Secondarily, this License preserves for the
author and publisher a way to get credit for their work, while not being
considered responsible for modifications made by others.

This License is a kind of "copyleft", which means that derivative works of
the document must themselves be free in the same sense. It complements the
GNU General Public License, which is a copyleft license designed for free
software.

We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free program
should come with manuals providing the same freedoms that the software does.
But this License is not limited to software manuals; it can be used for any
textual work, regardless of subject matter or whether it is published as a
printed book. We recommend this License principally for works whose purpose
is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work that contains a notice
placed by the copyright holder saying it can be distributed under the terms
of this License. The "Document", below, refers to any such manual or work.
Any member of the public is a licensee, and is addressed as "you".

A "Modified Version" of the Document means any work containing the Document
or a portion of it, either copied verbatim, or with modifications and/or
translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the
Document that deals exclusively with the relationship of the publishers or
authors of the Document to the Document's overall subject (or to related
matters) and contains nothing that could fall directly within that overall
subject. (For example, if the Document is in part a textbook of mathematics,
a Secondary Section may not explain any mathematics.) The relationship could
be a matter of historical connection with the subject or with related
matters, or of legal, commercial, philosophical, ethical or political
position regarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are
designated, as being those of Invariant Sections, in the notice that says
that the Document is released under this License.

The "Cover Texts" are certain short passages of text that are listed, as
Front-Cover Texts or Back-Cover Texts, in the notice that says that the
Document is released under this License.

A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the general
public, whose contents can be viewed and edited directly and
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or for
automatic translation to a variety of formats suitable for input to text
formatters. A copy made in an otherwise Transparent file format whose markup
has been designed to thwart or discourage subsequent modification by readers
is not Transparent. A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII
without markup, Texinfo input format, LaTeX input format, SGML or XML using
a publicly available DTD, and standard-conforming simple HTML designed for
human modification. Opaque formats include PostScript, PDF, proprietary
formats that can be read and edited only by proprietary word processors,
SGML or XML for which the DTD and/or processing tools are not generally
available, and the machine-generated HTML produced by some word processors
for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such
following pages as are needed to hold, legibly, the material this License
requires to appear in the title page. For works in formats which do not have
any title page as such, "Title Page" means the text near the most prominent
appearance of the work's title, preceding the beginning of the body of the
text.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially
or noncommercially, provided that this License, the copyright notices, and
the license notice saying this License applies to the Document are
reproduced in all copies, and that you add no other conditions whatsoever to
those of this License. You may not use technical measures to obstruct or
control the reading or further copying of the copies you make or distribute.
However, you may accept compensation in exchange for copies. If you
distribute a large enough number of copies you must also follow the
conditions in section 3.

You may also lend copies, under the same conditions stated above, and you
may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies of the Document numbering more than 100, and
the Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover Texts:
Front-Cover Texts on the front cover, and Back-Cover Texts on the back
cover. Both covers must also clearly and legibly identify you as the
publisher of these copies. The front cover must present the full title with
all words of the title equally prominent and visible. You may add other
material on the covers in addition. Copying with changes limited to the
covers, as long as they preserve the title of the Document and satisfy these
conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly,
you should put the first ones listed (as many as fit reasonably) on the
actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more
than 100, you must either include a machine-readable Transparent copy along
with each Opaque copy, or state in or with each Opaque copy a
publicly-accessible computer-network location containing a complete
Transparent copy of the Document, free of added material, which the general
network-using public has access to download anonymously at no charge using
public-standard network protocols. If you use the latter option, you must
take reasonably prudent steps, when you begin distribution of Opaque copies
in quantity, to ensure that this Transparent copy will remain thus
accessible at the stated location until at least one year after the last
time you distribute an Opaque copy (directly or through your agents or
retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to give them
a chance to provide you with an updated version of the Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under the
conditions of sections 2 and 3 above, provided that you release the Modified
Version under precisely this License, with the Modified Version filling the
role of the Document, thus licensing distribution and modification of the
Modified Version to whoever possesses a copy of it. In addition, you must do
these things in the Modified Version:

   * A. Use in the Title Page (and on the covers, if any) a title distinct
     from that of the Document, and from those of previous versions (which
     should, if there were any, be listed in the History section of the
     Document). You may use the same title as a previous version if the
     original publisher of that version gives permission.
   * B. List on the Title Page, as authors, one or more persons or entities
     responsible for authorship of the modifications in the Modified
     Version, together with at least five of the principal authors of the
     Document (all of its principal authors, if it has less than five).
   * C. State on the Title page the name of the publisher of the Modified
     Version, as the publisher.
   * D. Preserve all the copyright notices of the Document.
   * E. Add an appropriate copyright notice for your modifications adjacent
     to the other copyright notices.
   * F. Include, immediately after the copyright notices, a license notice
     giving the public permission to use the Modified Version under the
     terms of this License, in the form shown in the Addendum below.
   * G. Preserve in that license notice the full lists of Invariant Sections
     and required Cover Texts given in the Document's license notice.
   * H. Include an unaltered copy of this License.
   * I. Preserve the section entitled "History", and its title, and add to
     it an item stating at least the title, year, new authors, and publisher
     of the Modified Version as given on the Title Page. If there is no
     section entitled "History" in the Document, create one stating the
     title, year, authors, and publisher of the Document as given on its
     Title Page, then add an item describing the Modified Version as stated
     in the previous sentence.
   * J. Preserve the network location, if any, given in the Document for
     public access to a Transparent copy of the Document, and likewise the
     network locations given in the Document for previous versions it was
     based on. These may be placed in the "History" section. You may omit a
     network location for a work that was published at least four years
     before the Document itself, or if the original publisher of the version
     it refers to gives permission.
   * K. In any section entitled "Acknowledgements" or "Dedications",
     preserve the section's title, and preserve in the section all the
     substance and tone of each of the contributor acknowledgements and/or
     dedications given therein.
   * L. Preserve all the Invariant Sections of the Document, unaltered in
     their text and in their titles. Section numbers or the equivalent are
     not considered part of the section titles.
   * M. Delete any section entitled "Endorsements". Such a section may not
     be included in the Modified Version.
   * N. Do not retitle any existing section as "Endorsements" or to conflict
     in title with any Invariant Section.

If the Modified Version includes new front-matter sections or appendices
that qualify as Secondary Sections and contain no material copied from the
Document, you may at your option designate some or all of these sections as
invariant. To do this, add their titles to the list of Invariant Sections in
the Modified Version's license notice. These titles must be distinct from
any other section titles.

You may add a section entitled "Endorsements", provided it contains nothing
but endorsements of your Modified Version by various parties--for example,
statements of peer review or that the text has been approved by an
organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list of
Cover Texts in the Modified Version. Only one passage of Front-Cover Text
and one of Back-Cover Text may be added by (or through arrangements made by)
any one entity. If the Document already includes a cover text for the same
cover, previously added by you or by arrangement made by the same entity you
are acting on behalf of, you may not add another; but you may replace the
old one, on explicit permission from the previous publisher that added the
old one.

The author(s) and publisher(s) of the Document do not by this License give
permission to use their names for publicity for or to assert or imply
endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified versions,
provided that you include in the combination all of the Invariant Sections
of all of the original documents, unmodified, and list them all as Invariant
Sections of your combined work in its license notice.

The combined work need only contain one copy of this License, and multiple
identical Invariant Sections may be replaced with a single copy. If there
are multiple Invariant Sections with the same name but different contents,
make the title of each such section unique by adding at the end of it, in
parentheses, the name of the original author or publisher of that section if
known, or else a unique number. Make the same adjustment to the section
titles in the list of Invariant Sections in the license notice of the
combined work.

In the combination, you must combine any sections entitled "History" in the
various original documents, forming one section entitled "History"; likewise
combine any sections entitled "Acknowledgements", and any sections entitled
"Dedications". You must delete all sections entitled "Endorsements."

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents
released under this License, and replace the individual copies of this
License in the various documents with a single copy that is included in the
collection, provided that you follow the rules of this License for verbatim
copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it
individually under this License, provided you insert a copy of this License
into the extracted document, and follow this License in all other respects
regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate and
independent documents or works, in or on a volume of a storage or
distribution medium, does not as a whole count as a Modified Version of the
Document, provided no compilation copyright is claimed for the compilation.
Such a compilation is called an "aggregate", and this this License does not
apply to the other self-contained works thus compiled with the Document, on
account of their being thus compiled, if they are not themselves derivative
works of the Document. If the Cover Text requirement of section 3 is
applicable to these copies of the Document, then if the Document is less
than one quarter of the entire aggregate, the Document's Cover Texts may be
placed on covers that surround only the Document within the aggregate.
Otherwise they must appear on covers around the whole aggregate.

8. TRANSLATION

Translation is considered a kind of modification, so you may distribute
translations of the Document under the terms of section 4. Replacing
Invariant Sections with translations requires special permission from their
copyright holders, but you may include translations of some or all Invariant
Sections in addition to the original versions of these Invariant Sections.
You may include a translation of this License provided that you also include
the original English version of this License. In case of a disagreement
between the translation and the original English version of this License,
the original English version will prevail.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except as
expressly provided for under this License. Any other attempt to copy,
modify, sublicense or distribute the Document is void, and will
automatically terminate your rights under this License. However, parties who
have received copies, or rights, from you under this License will not have
their licenses terminated so long as such parties remain in full compliance.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions of the GNU
Free Documentation License from time to time. Such new versions will be
similar in spirit to the present version, but may differ in detail to
address new problems or concerns. See http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the
Document specifies that a particular numbered version of this License "or
any later version" applies to it, you have the option of following the terms
and conditions either of that specified version or of any later version that
has been published (not as a draft) by the Free Software Foundation. If the
Document does not specify a version number of this License, you may choose
any version ever published (not as a draft) by the Free Software Foundation.

How to use this License for your documents

To use this License in a document you have written, include a copy of the
License in the document and put the following copyright and license notices
just after the title page:

      Copyright (c)  YEAR  YOUR NAME.
      Permission is granted to copy, distribute and/or modify this document
      under the terms of the GNU Free Documentation License, Version 1.1
      or any later version published by the Free Software Foundation;
      with the Invariant Sections being LIST THEIR TITLES, with the
      Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
      A copy of the license is included in the section entitled "GNU
      Free Documentation License".

If you have no Invariant Sections, write "with no Invariant Sections"
instead of saying which ones are invariant. If you have no Front-Cover
Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being
LIST"; likewise for Back-Cover Texts.

If your document contains nontrivial examples of program code, we recommend
releasing these examples in parallel under your choice of free software
license, such as the GNU General Public License, to permit their use in free
software.

}
\newpage
\tableofcontents
\end{document}




















