\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais]{babel}
\usepackage{latexsym}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{amsmath,amsfonts,amssymb,a4,epsfig}
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\begin{document}
\begin{center}
{\Huge TP1: Polyn\^omes}
\end{center}

Soit $P$ un polyn\^ome de degr\'e $n$~:
\begin{equation} \label{eq:P}
P(X)=a_n X^n + ... + a_1 X + a_0 
\end{equation}

\section{Arithm\'etique des polyn\^omes.}
\label{sec:entier_poly}
Comme pour les entiers, on peut faire la division euclidienne de deux
polyn\^omes $A$ et $B$ de degr\'es $a$ et $b$, on obtient le quotient 
$Q$ de degr\'e $a-b$ (si $a\geq b$) et le reste $R$ de degr\'e 
strictement inf\'erieur \`a $b$ v\'erifiant l'\'egalit\'e~:
\[ A=BQ+R \]

L'algorithme d'Euclide permet de calculer le PGCD de deux polyn\^omes
exactement comme pour calculer le PGCD de deux entiers.

Algorithme de B\'ezout (dit aussi PGCD \'etendu): lorsque
deux polyn\^omes $A$ et $B$ ont comme PGCD le polyn\^ome $D$,
il existe deux polyn\^omes $U$ et $V$ tels que~:
\[ AU+BV=D\]

{\bf Exercice 1 (à rendre à la fin de la 1ère séance de TP)}~:\\
Application \`a la recherche de racines multiples.\\
Rappel~: Si $x$ est une racine de mulitplicit\'e $n$ de $P$, alors
$x$ est une racine de multiplict\'e $n-1$ de $P'$, $n-2$ de $P'{'}$,
etc. En particulier si $P$ et $P'$ sont premiers entre eux,
toutes les racines de $P$ sont de multiplicit\'e 1.\\
On consid\`ere le polyn\^ome
\[ P(x)=72*x^6+276*x^5+-106*x^4+-217*x^3+72*x^2+44*x-16  \]
Calculer avec un logiciel de calcul formel $P'$ et $P'{'}$, le PGCD de $P$ et 
$P'$ et le PGCD de $P'$ et $P'{'}$. En d\'eduire que $P$ admet un facteur
de multiplicit\'e 3 et un facteur de multiplicit\'e 2.

{\bf Exercice 2 (à rendre à la fin de la 1ère séance de TP)}~:\\
Application au calcul de l'int\'egrale~:
\[ \int \frac{1}{x^4-16} \ dx \]
On factorise le d\'enominateur de la fraction sous la forme 
$(x^2-4) \times (x^2+4)$. D\'eterminer avec un logiciel de calcul
formel deux polyn\^omes $U$ et $V$
tels que~:\\
\[ 1= U (X^2-4) + V (X^2+4) \]
en d\'eduire que l'int\'egrale de d\'epart vaut~:
\[ \int \frac{U(x)}{x^2+4} \ dx + \int \frac{V(x)}{x^2-4} \ dx \]
calculer ces int\'egrales en expliquant quels calculs interm\'ediaires
vous avez effectu\'es avec le logiciel.

{\bf Exercice 3 (à rendre au début de la 3ème séance de TP)}~:\\
Application au calcul de l'int\'egrale
\[ \int \frac{x^6+2}{(x^3+1)^2} \ dx \]
Effectuer la division euclidienne du num\'erateur par le d\'enominateur
pour se ramener \`a l'int\'egrale d'une fraction dont le
num\'erateur $N$ est de degr\'e inf\'erieur au d\'enominateur.
Soit $P=X^3+1$, calculer $P'$ et le PGCD de $P$ et $P'$, en d\'eduire
qu'il existe des polyn\^omes $U$ et $V$ tels que:
\[ N=UP+VP' \]
calculer ces deux polyn\^omes avec un logiciel.
On d\'ecompose alors l'int\'egrale en deux morceaux~:\\
\[ \int \frac{N}{P^2}=\int \frac{U}{P}  + \int V \frac{P'}{P^2}  \]
Faites une int\'egration par parties sur le deuxi\`eme terme
et en d\'eduire la valeur de l'int\'egrale du d\'epart.

%\pagebreak

\section{Valeur d'un polyn\^ome en un point et développement de Taylor.} 
\label{sec:evaluation}
Pour évaluer un polynôme en un point, on peut bien sur remplacer $X$ 
par sa valeur $\alpha $ dans (\ref{eq:P}) mais
cette m\'ethode est tr\`es inefficace car elle n\'ecessite d'effectuer 
beaucoup d'op\'erations.\\
C'est pourquoi on utilise la m\'ethode de Horner d\'etaill\'ee ci-apr\`es. \\
On pose $b_0=P(\alpha )$ et on
\'ecrit~:
\[ P(X)-b_0=(X-\alpha )P_1(X) \]
o\`u~:
\[ P_1(X) = b_n X^{n-1} + ... +b_2 X + b_1 \]
On calcule alors par ordre d\'ecroissant $b_n$, $b_{n-1}$, ..., $b_0$.
On a ainsi déterminé $P(\alpha)$ et le polynôme $P_1$ de degré $n-1$.

On peut effectuer cette opération à nouveau sur $P_1$, on obtient la
valeur de $P_1(\alpha)$ et un polynôme $P_2$, etc. jusqu'à obtenir
un polynôme de degré $P_n$ de degré 0.

{\bf Exercice 4 (à rendre à la fin de la 2ème séance de TP)}~:\\
Pour quelle raison peut-on mettre en facteur $X-\alpha $ dans $P(X)-b_0$?\\
D\'eterminer $b_n$ en fonction de $a_n$ puis pour $i\leq n-1$, $b_i$
en fonction de $a_i$ et $b_{i+1}$. Indiquez le d\'etail des calculs
pour $P(X)=X^4+3X^3+5X^2-2X+7$ et une valeur de $\alpha $ non nulle.\\
Calculer le nombre d'opérations effectuées avec cette méthode et
le nombre d'opérations que l'on effectuerait en évaluant le polynôme
sous forme développée, justifier l'intérêt de cette méthode.

{\bf Exercice 5 (à rendre à la fin de la 2ème séance de TP)}~:\\
\'Ecrire un fonction effectuant ce calcul avec un logiciel de calcul formel~:
on donnera en arguments le polyn\^ome sous forme de la
liste de ces coefficients (dans l'exemple \verb|[1,2,0,-1,5]|) et la
valeur de $\alpha $ et le programme renverra $P(\alpha )$
et la liste des coefficients de $P_1$.

{\bf Exercice 6 (à rendre au début de la 3ème séance de TP)}~:\\
En utilisant la fonction de l'exercice précédent, écrire une fonction
qui prend en argument la liste des coefficients de $P$ et la valeur
de $\alpha$ et renvoie la liste des valeurs {\tt $P_n(\alpha)$, ...,
$P_1(\alpha)$, $P(\alpha)$}. Montrer que~:
\[ P_i(\alpha)=\frac{P^{(i)}(\alpha)}{i!} \ \mbox{o\`u $P^{(i)}$
d\'esigne la dérivée $i$-ième de $P$ en $\alpha$}\]
Que représente la liste des coefficients renvoyée par cette fonction?


\section{Rappel sur les logiciels.} \label{sec:logiciels}
Les logiciels de calcul formel installés sur les PC du DSU
fonctionnent sur le même principe: on écrit une
ligne de commande, on la termine par le signe \verb|;| 
et on valide en tapant sur la touche \verb|Entree|, le logiciel effectue alors
le calcul demandé et affiche la réponse. Une ligne de commande ressemble
à l'écriture algébrique d'une expression mathématique, il faut
toutefois prendre garde à indiquer de manière explicite les
multiplications, par exemple~:\\
\verb|factor(16*x^4-1);|\\
Pour lancer un logiciel sur les PC du DSU,
ouvrez une fen\^etre de commande (l'icone
repr\'esentant un \'ecran noir), puis~:
\begin{itemize}
\item MuPAD (interface emacs)\\
Pour lancer MuPAD tapez~:\\
\verb|mupad|\\
ce qui ouvre {\tt emacs} en mode {\tt MuPAD},
puis s\'electionnez dans le menu \verb|MuPAD| l'option \verb|Start MuPAD|\\

L'aide est accessible en lan\c{c}ant le navigateur \verb|netscape|,
en cliquant sur {\tt Manual} du menu {\tt MuPAD} ou
en tapant {\tt ?} suivi par le nom de la commande pour laquelle vous
cherchez l'aide.

%Attention, quand vous tapez une commande, laissez un espace entre
%le prompt {\tt >>} et le d\'ebut de la commande, par contre ne laissez
%pas d'espace apr\`es le {\tt ;} final.

\item MuPAD (interface xmupad)~:\\
tapez~:\\
\verb|xmupad|\\
L'aide est accesible depuis le menu {\tt Aide}.

\item Maple\\
Pour lancer Maple, tapez~:\\
\verb|xmaple &|\\
L'aide sur une commande s'obtient en tapant {\tt ?} suivi par le 
nom de la commande pour laquelle vous cherchez l'aide.

\item xcas\\
Pour lancer xcas, tapez~:\\
\verb|xcas &|\\

\end{itemize}

\section{Quelques instructions d'arithmétique.}
\begin{itemize}
\item Mupad\\
Les instructions arithm\'etiques de \verb|MuPAD| 
sont dans la librairie standard: \verb|divide| (division euclidienne),
\verb|factor| (factorisation), \verb|gcd| (PGCD),
\verb|gcdex| (B\'ezout), \verb|partfrac| (d\'ecomposition en
\'el\'ements simples).

\item Maple\\
\verb|divide| (division euclidienne),
\verb|factor| (factorisation), \verb|gcd| (PGCD),
\verb|gcdex| (B\'ezout), \verb|convert(.,parfrac)| (d\'ecomposition en
\'el\'ements simples).

\item xcas\\
Aller dans le menu {\tt Alg}, puis sous-menu Arithmétique polynômiale~:
\verb|quorem| (division euclidienne), \verb|factor| (factorisation), 
\verb|gcd| (PGCD), \verb|egcd| (B\'ezout), \verb|partfrac|

\item HP49\\
Les commandes arithm\'etiques sont dans le menu \verb|ARIT|, les
principales sont: \verb|DIV2| (division euclidienne), \verb|GCD|
(PGCD), \verb|EGCD| (PGCD \'etendu $au+bv=d$, \'etant donn\'e
deux polyn\^omes $a$ et $b$, renvoie un pgcd $d$ au niveau 3
et les entiers $u$ et $v$ aux niveaux 2 et 1), 
\verb|FACTOR| factorisation, \verb|FACTORS| (liste
des facteurs alternant avec leur multiplicit\'e), \verb|DIVIS|
(liste des diviseurs),
\verb|PARTFRAC| (d\'ecomposition en \'el\'ements simples),
\verb|HORNER| (\'evaluation d'un polyn\^ome par la m\'ethode
de Horner).


\item Autres calculatrices formelles\\
Les instructions d'arithm\'etique fournies sont moins nombreuses
et il faut souvent les programmer soi-meme. Les TI89, 92 et la
Casio Graph 100 disposent d'une instruction \verb|gcd| pour calculer
le pgcd mais d'entiers uniquement, \verb|factor| permet de factoriser
un entier ou un polyn\^ome. \verb|peval| permet d'\'evaluer un
polyn\^ome en un point sur les TI89/92.

Sur les TI89 et 92 on peut
utiliser l'astuce suivante pour calculer le pgcd de 2 polynomes $p$
et $q$:  \verb|p/getnum(p/q)| (\verb|getnum(p/q)| renvoie le num\'erateur
de la fraction $p/q$ simplifi\'ee). Pour la division euclidienne
des polyn\^omes, on peut se servir de l'instruction \verb|propfrac|
(\`a condition que $p$ et $q$ soient premiers entre eux).
Vous trouverez des programmes d'arithm\'etique 
\`a charger sur votre TI ou Casio \`a l'URL suivante:\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/|\\
cherchez ``Atelier d'arithm\'etique''.

\end{itemize}
Remarque~:\\
En g\'en\'eral les noms de commandes diff\'erent
pour les op\'erations arithm\'etiques sur les polyn\^omes et les
entiers (ces derniers sont pr\'ec\'ed\'es de la lettre \verb|i|, par exemple
\verb|gcdex| et \verb|igcdex| sont les noms de commandes
pour le PGCD \'etendu en Maple et Mupad pour les polyn\^omes et
les entiers).


\end{document}

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

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

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

S\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure|. Vous pouvez maintenant calculer la moyenne des
deux entiers 5 et 13 en tapant:\\
\verb|ma_procedure(5,13);|\\
qui doit vous renvoyer \verb|9|.
\subsubsection{Traduction HP49G mode Algébrique}\label{sec:alg} 
Un programme s'écrit dans la ligne de commande entre les délimiteurs ${\tt \ll \; \gg}$\\ 
Pour le  sauver, il suffit de faire suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOMDUPROGRAMME}$$
\subsection{Comment corriger un programme} 
\subsubsection{Traduction MuPAD}
Si la syntaxe est mauvaise, la machine vous indique un message d'erreurs.\\
Faites appara\^itre le texte de votre programme : ouvrir le menu 
\verb|Buffers| et  s\'electionner le nom de votre programme (\verb|prog1.mu|).\\
Vous pouvez corriger votre erreur, puis  sauvegarder votre correction dans le fichier \verb|prog1.mu|
(\verb|Save Buffer| du menu \verb|Files|).
S\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure|.\\
Si vous ne voyez pas quelle peut \^etre la source d'une erreur,
vous pouvez utiliser le d\'ebuggueur \verb|mdx|. Le programme \verb|mdx|  permet de stopper
l'ex\'ecution d'un programme \verb|MuPAD| \`a une ligne donn\'ee
et continuer l'ex\'ecution ligne apr\`es ligne avec la possibilit\'e
d'examiner le contenu des variables.

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

Vous devez voir apparaitre un buffer qui ressemble fortement au
buffer \verb|*MuPAD*|. Vous pouvez maintenant ex\'ecuter en mode
pas \`a pas n'importe quelle proc\'edure de votre fichier en tapant
par exemple :\\
\verb|debug(ma_procedure(5,13));|\\
La fen\^etre \verb|emacs| doit maintenant \^etre divis\'ee en deux
parties, avec le texte source d'une part et le buffer \verb|*gud-prog1.mu*|
d'autre part. Les commandes de mise au point doivent \^etre \'ecrites
dans le buffer \verb|*gud-prog1.mu*|.\\
 Les principales sont :
\begin{itemize}
\item \verb|p| affiche la valeur d'une variable
\item \verb|n| ex\'ecute la ligne courante du source
\item \verb|s| comme \verb|n| mais en ex\'ecutant les appels de proc\'edure
de la ligne courante en mode pas-\`a-pas
\item \verb|c| continue l'ex\'ecution jusqu'au prochain point d'arr\^et.
Il est possible de mettre un point d'arr\^et en mettant dans le texte source,
le curseur l\`a o\`u on
veut arr\^eter l'ex\'ecution du programme puis en tapant \verb|Ctrl-X|
\verb|Ctrl-A| \verb|Ctrl-B| dans la fen\^etre source (ce qui ex\'ecute la
commande \verb|S| dans la fen\^etre du debuggeur).
\end{itemize}
Pour en savoir plus sur la programmation, vous pouvez par exemple consulter
avec Netscape les notes de B. Ycart et P. Zimmermann~:\\
\verb|http://www.math-info.univ-paris5.fr/Enseignements/demarre_mupad/|
\subsubsection{Traduction HP49G mode Algébrique} 
Si la syntaxe est mauvaise, la machine vous met automatiquement le curseur l\`a
o\`u le compilateur a détecté l'erreur. Il suffit donc de corriger!!!\\
Si l'erreur est détectée au cours de l'exécution du programme il faut taper :\\
{\tt VISIT('NOMDUPROGRAMME')}\index{VISIT} qui édite votre programme.\\
 On corrige, puis 
{\tt ENTER}  sauve votre programme corrigé. 
\subsection{Comment exécuter un programme}
\subsubsection{Traduction MuPAD}
Vous s\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure| (qui calcule par exemple la moyenne de deux nombres cf exemple \ref{sec:exemple}). Vous pouvez maintenant calculer la moyenne des
deux entiers 5 et 13 en tapant:\\
\verb|ma_procedure(5,13);|\\
qui doit vous renvoyer \verb|9|.
\subsubsection{Traduction HP49G mode Algébrique} 
Si le programme n'a pas de paramètres, il suffit de taper son nom dans la ligne de commande ou d'utiliser le menu {\tt VAR}.\\
S'il y a des paramètres, on fait suivre le nom du programme de parenthèses
dans lesquelles on met  les valeurs des paramètres séparées par une virgule.\\
Exemple :\\
{\tt PGCD(45,75)}
\section{Les différentes instructions}
\subsection{Les commentaires}
Il faut prendre l'habitude de commenter les programmes. 
En algorithmique un commentaire commence par
{\tt // } et se termine par un passage à la ligne.
\subsubsection{Traduction MuPAD}
 un commentaire est entouré de deux {\tt \#} ou \\
commence par {\tt /*} et se termine par  {\tt */} ou\\
commence par {\tt //} et se termine par un passage à la ligne.\\
\# ceci est un commentaire \#\\
/* ceci est un commentaire */
//ceci est un commentaire
\subsection{La séquence d'instructions ou action}
Une action est une séquence d'une ou plusieurs instructions.\\
En langage algorithmique, on utilisera l'espace ou le passage à la ligne pour 
terminer une instruction.
\subsubsection{Traduction MuPAD}
Le {\tt\ ;\ } est un séparateur d' instructions.
\subsubsection{Traduction HP49G mode Algébrique} 
Pour la {\tt HP49G}, le {\tt\ ;\ } est un séparateur d' instructions.\\ 
Le {\tt ;} s'obtient
en tapant en m\^eme temps sur {\tt shift-rouge SPC}.
\subsection{L'instruction d'affectation}
L'affectation est utilisée pour stocker une valeur ou une expression dans une 
variable.\\
En algorithmique on écrira par exemple :
{\tt 2*A->B}\\
pour stocker {\tt 2*A} dans {\tt B}\\
{\sc Attention}\\
Avec {\tt MuPAD} on \'ecrit : {\tt b:=2*a} pour stocker {\tt 2*a} dans {\tt b}.\\
Pour la {\tt HP49G mode Algébrique}, on utilise  la touche ${\tt STO}$ qui se 
traduit à l'écran  de la calculatrice par : 
$ \triangleright $ que l'on  notera : ${\tt STO\triangleright}$ ( ${\tt 2*A\ STO\triangleright\ B}$)\\
\subsection{Les instructions conditionnelles}
\noindent{\tt Si \emph{condition} alors
\emph{action}
fsi}\\
{\tt Si \emph{condition} alors
\emph{action1} sinon
\emph{action2}
fsi}\\ 
Exemple :\\
{\tt Si A = 10 ou A < B alors B-A->B sinon A-B->A fsi}
\subsubsection{Traduction MuPAD}
\noindent{\tt if \emph{condition}
 then 
\emph{action}  
end\_if}\\
{\tt if \emph{condition} then 
\emph{action1}  else 
\emph{action2}
end\_if}\\
Exemple :\\
{\tt if a = 10 or A < B then  b:=b-a else  a:=a-b end\_if}\\
Lorsque il y a plusiuers {\tt if else} \`a la suite on \'ecrit {\tt elif} au
lieu de  {\tt else if}.
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt IF \emph{condition} THEN 
\emph{action}  
END}\\
{\tt IF \emph{condition} THEN 
\emph{action1}  ELSE
\emph{action2}
END}\\
Exemple (Attention au == pour traduire la condition d'égalité) :\\
{\tt IF A == 10 OR A < B THEN B-A STO$\triangleright$ B  ELSE A-B STO$\triangleright$ A  END}
\subsection{Les instructions "Pour" }
\noindent{\tt Pour I de A à B faire \emph{action} fpour}\\
{\tt Pour I de A à B (pas P) faire \emph{action} fpour}
\subsubsection{Traduction MuPAD}
\noindent{\tt for i from a to b do \emph{action} end\_for}\\
{\tt for i from b downto a do \emph{action} end\_for}\\
{\tt for i from a to b step p do  \emph{action} end\_for }\\
Vous pouvez aussi ouvrir le menu {\tt MuPAD} sous menu {\tt Shapes} et 
s\'el\'ectionner {\tt for}.
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt FOR (I, A, B) \emph{action} NEXT}\\
{\tt FOR (I, A, B ) \emph{action} STEP P}\\ 
L'instruction {\tt FOR} déclare {\tt I} comme  variable locale et l'initialise
 automatiquement.
\subsection{L'instruction ``Repeter''}
\noindent{\tt Repeter
\emph{action}
 jusqua \emph{ condition}} 
\subsubsection{Traduction MuPAD}
\noindent{\tt repeat  
\emph{action} 
until \emph{ condition} end\_repeat}
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt DO 
\emph{action} 
UNTIL \emph{condition} 
END}
\subsection{L'instruction ``Tant que''}
\noindent{\tt Tant que \emph{condition} faire
\emph{action}
ftantque}
\subsubsection{Traduction MuPAD}
\noindent{\tt while  \emph{condition} do
\emph{action}  
end\_while}
Vous pouvez aussi ouvrir le menu {\tt MuPAD} sous menu {\tt Shapes} et 
s\'el\'ectionner {\tt while}.
\subsubsection{Traduction HP49G mode Algébrique} 
\noindent{\tt WHILE \emph{condition} REPEAT 
\emph{action} 
END}
\subsection{Les listes}
On utilise les \{ \} pour délimiter une liste.\\
Attention!!!
En algorithmique on a choisit cette notation car c'est celle qui est employée
par les calculatrices...à ne pas confondre avec la notion d'ensemble en
 mathématiques : dans un ensemble l'ordre des éléments n'a pas d'importance
mais dans une liste l'ordre est important...
 Par exemple \{\} désigne la liste vide et \{1, 2, 3\} est une liste de 3 éléments.\\
{\tt append} sera utilis\'e pour concaténer 2 listes ou une liste et un élément ou 
un élément et une liste :\\
{\tt \{1, 2, 3\}->TAB}\\
{\tt append(TAB, 4) ->TAB}  (maintenant {\tt TAB} désigne \{1, 2, 3, 4\} \\
{\tt TAB[2]} désigne le deuxième élément de {\tt TAB} ici 2.
\subsubsection{Traduction MuPAD}
Une liste est une suite d'expressions entre un crochet ouvrant [ et un crochet 
fermant ].\\
{\tt [ ]} d\'esigne la liste vide.\\
Exemple :\\
{\tt l:=[1,2,2,3]}\\
{\tt nops(l)} renvoie le nombre d'\'elements de la liste {\tt l}.\\
{\tt l[1]} ou {\tt op(l,1)} renvoie le premier \'element de la liste {\tt l} : les 
\'elements sont num\'erot\'es de 1 \`a {\tt nops(l)}.\\
{\tt op(l)} renvoie {\tt 1,2,2,3}\\
{\tt append(l,4)} ajoute l'\'element 4 \`a la fin de la liste {\tt l}.\\
De plus les listes peuvent \^etre concat\'en\'ees  avec {\tt .} ([1,2].[2,3]=[1,2,2,3]).\\
{\tt Attention} une suite d'expressions entre une accolade ouvrante \{ et une 
accolade fermante \} désigne un ensemble.\\
Exemple :\\
{\tt A:=\{a,b,c\} B:=\{a,d\}} alors {\tt A union B} d\'esigne {\tt \{a,b,c,d\}}\\
{\tt A intersect B} d\'esigne {\tt \{a\}}\\
{\tt A minus B} d\'esigne {\tt \{b,c\}}
\subsubsection{Traduction HP49G mode Algébrique} 
Pour la {\tt HP49G} en mode algébrique, les listes peuvent avoir des longueurs non définies à l'avance.\\
On utilise les \{\} pour délimiter une liste.\\
Par exemple \{1 2 3\} est une liste de 3 éléments et \{\} désigne la liste vide.\\
On obtient le {\tt P}ième élément de {\tt L } sur la pile  avec :\\
 {\tt L[P]} ou {\tt L(P)} ou
{\tt GET (L, P )}\\
Si on veut modifier le {\tt P}ième élément de {\tt L} (par exemple le mettre à 0)  on écrira :\\
{\tt PUT(L, P, 0) STO$\triangleright$ L }\\
ou\\
{\tt  PUT('L', P, 0)}\\
En effet {\tt PUT(L, P, 0)} renvoie  la liste modifiée (sans modifier {\tt L}) 
alors que :\\
{\tt PUT ('L', P, 0) } modifie la liste {\tt L}.\\
Pour concaténer deux listes ou une liste et un élément on utilise le  {\tt +} 
(et pour ajouter deux listes de m\^emes longueurs on utilise la commande {\tt ADD}) ou  on utilise la commande {\tt AUGMENT}..\\
La commade {\tt SEQ} permet de constituer une liste, on tape :\\
${\tt SEQ('X*X','X',4,10,1)}$ et
on obtient :\\
${\tt \{16,25,36,49,64,81,100\}}$