% par Paul Zimmermann, d'un document analogue pour Maple \'ecrit par Roland 
% Bacher, et communiqu\'e par Bernard Parisse.
\documentclass{article}
%\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{times}
\newtheorem{rem}{Remarque}
\usepackage{ifpdf}
\ifpdf
 \usepackage[colorlinks,pdftex]{hyperref}
\fi

\title{Pr\'esentation rapide des logiciels de calcul formel Maple, MuPAD, xcas.}

%\author{Licence 2-Math 249}
\author{Master 1- Calcul formel}
\date{2005/6}

\begin{document}
\textheight 23cm
\textwidth 16.5cm \columnsep 10pt \columnseprule 0pt

\maketitle

%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.

\section{Aspects non math\'ematiques.} \label{sec:mupad}

\subsection{O\`u trouver un logiciel de calcul formel}
Mupad et Maple sont deux logiciels de calculs formel autoris\'es
\`a la 3eme \'epreuve orale de l'agr\'egation de math\'ematiques (par
contre au CAPES ne sont utilis\'es pour l'instant que des
calculatrices).
Maple est un logiciel commercial, si vous voulez l'utiliser chez vous
vous devez payer une licence d'utilisation
(cf. \verb|www.maplesoft.com|, il existe une version de d\'emonstration
Windows\\
\verb|ftp://ftp.maplesoft.com/pub/maple/demo/windows/mvr4demo.exe|,\\
la version \'etudiante de Maple co\^ute
environ 100 euros\footnote{L'utilisation ou la fourniture d'une copie
illicite d'un logiciel expose le contrevenant \`a une amende pouvant
atteindre 150 000 euros ou/et \`a une peine d'emprisonnement
de 1 an.}).

Mupad est disponible gratuitement pour un usage \'educatif
(\verb|www.mupad.de| et \verb|www.sciface.com|). L'interface de mupad
sous Linux est moins aboutie que celle de Maple, Mupad est souvent
plus lent que Maple, et la librairie math\'ematique de Maple
est plus compl\`ete que celle de Mupad, par contre la programmation en 
Mupad est plus agr\'eable qu'en maple, surtout avec le mode
\verb|mupacs| (Mupad sous emacs).

Enfin \verb|xcas| est un logiciel libre (donc gratuit)
de calcul formel qui est (relativement)
compatible avec Maple et MuPAD\\
\verb|www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html|

Les commandes qui existent dans ces syst\`emes sont tr\`es 
proches.

{\bf Remarque~:}\\ 
Mathematica, Axiom et Maxima sont des logiciels de calcul formel 
(respectivement payant, libre, libre)
qui sont aussi disponible \`a l'\'epreuve de mod\'elisation de l'agr\'egation
de math\'ematiques, mais les commandes sont moins proches
de celles des maple/mupad/xcas. Maxima est install\'e sur pcm2
(pour l'essayer, tapez \verb|xmaxima &| ou \\
\verb|ssh -X pcm2 xmaxima|).
Il existe d'autres logiciels
de calcul formel (dont l'interface est différente ou/et plus 
spécialisé dans certains domaines, 
par exemple PARI-GP, Singular, GAP, Magma, ...)

\subsection{Ouvrir une session.} \label{sec:open}
Si votre PC est \'eteint, commencez par appuyer sur les boutons ''power'' 
de l'\'ecran et de la tour et patientez une bonne minute.\\
Si vous ne voyez pas un \'ecran en mode graphique, tapez simultan\'ement sur
les touches Control, Alt et F7. 
%Si vous voyez une liste de machines, s\'electionnez \verb|pcm2.e.ujf-grenoble.fr|.
Vous devez maintenant voir une fen\^etre
de login. Entrez votre login et votre mot de passe.\\
%Tapez la commande~:\\
%\verb|ssh pcm2| ou \verb|slogin pcm2|

Si vous n'avez pas de fen\^etre de commandes ({\tt Konsole} ou {\tt xterm}), 
cliquez sur l'ic\^one repr\'esentant un \'ecran (vers le milieu des
ic\^ones en bas)
ou cliquez avec le bouton droit, s\'electionnez ``Ex\'ecuter une commande''
taper alors {\tt xterm}.
Dans la suite, lorsqu'on demande de taper une commande, il faut saisir
la commande puis valider en tapant sur la touche Entree (ou Enter sur un
clavier qwerty).

Vous pouvez maintenant ouvrir une session en choisissant un logiciel
et une interface parmi les choix suivants~:
\begin{itemize}
\item \verb|texmacs| (Axiom, Maple, Maxima, MuPAD, xcas, ...)~: 
id\'eal pour ins\'erer quelques
calculs dans un texte math\'ematique, il permet d'appeler
plusieurs syst\`emes de calcul formel par une m\^eme interface.
Non disponible \`a l'\'epreuve de mod\'elisation.
Tapez la commande\\
\verb|  texmacs &|\\
puis sélectionnez dans le menu Inserer, sous-menu session, le nom du logiciel
de calcul formel (axiom, giac pour xcas, maple, mupad, maxima, ...).

\item \verb|xmaple| (Maple)~: c'est l'interface la plus facile \`a maitriser.
Mais le langage de programmation a certaines rigidit\'es et
la manipulation des matrices n'est pas intuitive. De plus ce logiciel
n'est pas gratuit si vous voulez l'utiliser chez vous (sauf si
vous vous contentez de vieilles versions sans possibilit\'es de
sauvegarde, cf. \verb|ftp://ftp.maplesoft.com/pub/maple/demo/|)
Tapez la commande\\
\verb|  xmaple &|

\item \verb|xcas| (xcas)~: interface de type calculatrices. 
Peut se programmer avec une syntaxe quasi-identique
au langage C ou avec une syntaxe compatible maple ou mupad ou calculatrices 
TI. 
Non disponible \`a l'\'epreuve de mod\'elisation.
Tapez la commande\\
\verb|  xcas &|

\item (MuPAD)~: interface de type texte \`a l'int\'erieur 
d'emacs efficace surtout pour programmer (cf. la section 
\ref{sec:mupad_emacs}).
Taper la commande\\
\verb|  ssh -X pcm2 emacs|\\
Tapez ensuite sur la touche \verb|Echap| puis tapez \verb|xmupad-run|
et la touche {\bf $<$Entree$>$} deux fois.
Pour les graphiques, 
\verb|emacs| lance une fenêtre distincte appel\'ee \verb|vcam|.\\
Il semble malheureusement que \verb|vcam| ne fonctionne pas 
correctement sur pcm2.e.

\item \verb|xmupad| (MuPAD)~: interface graphique de MuPAD.
Tapez la commande\\
\verb|  xmupad &|


\end{itemize}

\subsection{Recopier avec la souris sous Linux.} \label{sec:mouse}
Sélectionnez l'expression à recopier à la souris
puis utilisez le bouton du milieu pour recopier. Notez
que sur certains PC le bouton du milieu n'existe pas ou
ne fonctionne pas, il faut alors cliquer avec le bouton droit et
le bouton gauche simultan\'ement.

Attention, pour recopier une réponse de MuPAD à la souris, il faut
au préalable exécuter la commande \verb|PRETTYPRINT:=FALSE;|
(menu Environment de MuPAD dans emacs).


\subsection{Chercher (et trouver) de l'aide.} \label{sec:aide}
L'aide en ligne est en anglais pour {\tt maple} et {\tt mupad},
en francais pour {\tt xcas}. Il y a deux mani\`eres
de chercher de l'aide, soit on connait la commande et on cherche
de l'aide sur les arguments, soit on ne connait pas la commande.

Pour obtenir de l'aide sur une commande dont vous connaissez le nom,
tapez {\tt ?} suivi du nom de la commande puis {\tt Entree},
par exemple {\tt ?series} $<$Entree$>$
(pour une aide concernant les d\'eveloppement en s\'erie) 
ou {\tt ?linalg} $<$Entree$>$ pour la liste des fonctions du 
``package'' linalg (alg\`ebre lin\'eaire).

Si vous ne connaissez pas le nom de la commande~:
\begin{itemize}
\item \verb|xmaple| :\\
Dans {\bf Maple}, on ouvre l'aide ({\bf Help})
en cliquant avec le bouton gauche de la souris sur le
menu {\bf Help} en haut \`a droite de la barre de menu.
\item \verb|emacs| (MuPAD)~:\\
Menu \verb|MuPAD|, sélectionnez \verb|Manual| ou \verb|Help on|.
Vous pouvez aussi ouvrir un navigateur (si l'aide
de MuPAD n'apparait pas par d\'efaut, ouvrez le fichier
\verb|/usr/share/doc/HTML/index.html|).
\item \verb|xcas|~:\\
L'aide en ligne est affichée dès qu'on sélectionne une commande
dans un menu. Utiliser le menu {\tt Aide}
ou {\tt Help} et s\'electionnez Calcul formel ou CAS pur un manuel
complet.
\end{itemize}

Notez que (sauf pour xmaple) 
la touche de tabulation joue le même rôle que dans
un shell, elle propose des complétions de noms de commande. Par
exemple, tapez \verb|plotf| puis la touche tabulation, et cliquez
avec le bouton du milieu (ou les 2 boutons simultanément) pour
sélectionner la commande souhaitée parmi celles dont le nom
commence par \verb|plotf|

\subsection{Recopier des exemples}
\begin{itemize}
\item \verb|xmaple| :\\
Avec Maple on peut \'egalement chercher un mot-clef ou chercher par
th\`emes et recopier un exemple avec le copier-coller standard sous
X-Windows (bouton gauche de la souris appuy\'e pour s\'electionner, 
click sur le bouton du milieu ou simultan\'ement sur les 2 boutons pour
recopier)
\item \verb|emacs| (MuPAD):\\
Copier-coller standard sous Unix.
\item \verb|xcas|~:\\
L'aide s'affiche automatiquement si on sélectionne une commande par un menu.
\item \verb|texmacs|~:\\
Utiliser le copier-coller standard (s\'election puis recopie avec
bouton du milieu ou avec les 2 boutons simultan\'ement)
\end{itemize}

\subsection{Sauver une session.} 

\begin{itemize}
\item \verb|xmaple|, \verb|xmupad| :\\ 
{\bf Save as} dans le menu Files.
\item  \verb|emacs| (MuPAD) :\\ 
S\'electionner la commande 
\verb|Save session| du menu \verb|MuPAD|. Cela crée deux fichiers~:
l'un contenant les questions dont le nom est formé par la date et
l'heure du jour, et le fichier {\tt MuPAD-last-session} qui contient 
les questions et les réponses.
\item \verb|xcas| :\\ 
Dans le menu Files. choisir {\bf Save session}.
\end{itemize}

\subsection{Impression.} 
Si la commande Print ou Imprimer (menu File) ne fonctionne pas, choisissez 
l'impression dans un fichier Postscript ou la commande export
au format Postscript, puis donnez un nom de fichier, par exemple
essai.ps. Dans une fenêtre de commandes, tapez alors~:\\
\verb|lpr essai.ps|

\subsection{Arr\^eter un calcul} 
\begin{itemize}
\item xmaple, xmupad et xcas~:\\
Cliquer sur le bouton \verb|STOP|
\item mupad sous emacs~:\\
Cliquer sur 
\verb|break| du menu \verb|MuPAD| d'\verb|emacs|. Attention, cela
tue le processus de calcul. Choisir \verb|reset| du menu \verb|MuPAD|
pour lancer un nouveau calcul.
\end{itemize}
Cette commande est 
importante car la complexit\'e d'un calcul peut vite devenir effrayante 
(m\^eme pour un ordinateur).

\subsection{Fermer une session.} 
\begin{itemize}
\item Cliquer sur {\bf Quitter} ou {\bf Exit}
du menu {\bf Fichier} ou {\bf File}   (Maple/xcas/texmacs).
\item 
Quitter \verb|emacs| en cliquant sur \verb|Exit Emacs| du 
menu \verb|Files|, on vous propose alors de sauvegarder la session.
\end{itemize}
Avant de quitter votre PC, n'oubliez pas de terminer votre session
(logout). 



\section{La ligne de commande} \label{sec:basic}
Les logiciels de calcul formel exécutent des commandes écrites dans
la ligne de commande. La syntaxe d'une commande ressemble à l'écriture
en mode algébrique d'une expression mathématique.
\begin{itemize}
\item 
 MuPAD, Maple et xcas sont sensibles \`a la diff\'erence entre majuscules 
et minuscules.
\item La touche {\bf $<$ Entree$>$} \'evalue les instructions entr\'ees 
depuis le dernier
\lq\lq prompt" (signe $>>$). Pour aller \`a la ligne, utilisez {\bf 
$<$Entree$>$} sur le
pav\'e num\'erique (\verb|xmupad|) ou tapez simultanément sur les
touches Shift et Entree (maple).
\item 
Toute instruction (\`a l'exception des commandes invoquant l'aide) doit se
terminer par ; ou (pour maple et mupad)
par : (le double-point supprime alors l'impression du r\'esultat
sur l'\'ecran).\\
Exemples: \\
{\tt 1+1;} {\bf $<$Entree$>$} ,\\
{\tt 2*(3+5):} {\bf $<$Entree$>$} ,\\
{\tt 2*3;10;} {\bf $<$Entree$>$} .

\item Il faut \'ecrire tous les produits ; 
{\tt 2*x} et non {\tt 2 x} (un espace entre deux symboles n'est pas 
interpr\'et\'e comme une multiplication).\\ 
La puissance $x^a$ se note par {\tt x\^{}a}.
\item L'assignation se fait par :=  \ \ . \\
Exemples:\\ {\tt x:=$300^2$;} {\bf $<$Entree$>$} 
(donne la valeur 90000 \`a la variable $x$ et affiche le r\'esultat)\\
{\tt ifactor(x);} {\bf $<$Entree$>$} 
donne alors la d\'ecomposition de $x=300^2$ en facteurs premiers.\\
Pour enlever une assignation \`a une variable, on utilise la commande
\verb|unassign|, par exemple:\\
\verb|unassign(x)|\\
Il est possible de faire des hypoth\`eses sur une variable sans
lui assigner pour autant une valeur pr\'ecise \`a l'aide de la
commande \verb|assume|.
\item Vous pouvez nommer vos variables selon vos d\'esirs \`a condition
que les noms choisis ne soient pas des commandes MuPAD, Maple ou xcas.
\item Quelques constantes utiles :\\
$\pi$: {\tt PI} (Mupad), {\tt Pi} (Maple), {\tt pi} ou {\tt PI} (xcas)\\
$i=\sqrt{-1}$: {\tt I} (Maple, Mupad), {\tt i} 
(xcas)\footnote{Attention en mode compatibilité maple ou mupad, 
utiliser {\tt I}}\\ 
$\infty$: {\tt infinity} 
\item Exponentielle, logarithme et racine : {\tt 
exp(x), ln(x)} (en base $e$) et {\tt sqrt(x)}.
\item Fonctions trigonom\'etriques :
{\tt sin(x), cos(x), tan(x),
asin(x) ou arcsin(x), acos(x) ou arccos(x)} etc. (les arguments sont en radians).
\item Une fonction $f$ se d\'efinit par {\tt f:= x-$\tt >$ (...) ;}\\
Attention, les parenth\`eses apr\`es \verb|->| sont parfois nécessaires.
 Exemples : \\
{\tt pol:=x-$\tt >$(3*x\^{}2+1);}
\ \  {\tt g:=(u,v)-$\tt >$(u-3*v);}\\
Pour \'evaluer \verb|pol| (resp. \verb|g|) 
en $a$ (resp. en $(a,b)$) on fait 
{\tt pol(a)} (resp. {\tt g(a,b)}).
\item Mupad, Maple et xcas proposent un langages de programmation complet
permettant d'\'ecrire des boucles: 
{\tt for i from 1 by a to b do .. od;} (attention, utiliser {\tt end\_for}
au lieu de {\tt od} pour mupad),
des instructions condidionnelles: {\tt if (a<b) then .. else .. fi;} 
(attention, utiliser {\tt end\_if} pour mupad),
etc. Vous n'obtiendrez par contre jamais des programmes rapides.
Si n\'ecessaire, choisissez un autre langage 
(C, FORTRAN, Pascal ou LISP par exemple)
lorsque c'est possible.
\end{itemize}

\section{Quelques commandes utiles.}
La plupart des commandes ont une syntaxe identique pour les 3 systèmes,
certaines sont malheureusement différentes. Il existe un programme permettant
de traduire de maple vers mupad, et xcas est dans une certaine mesure
capable de traduire la grammaire des 3 systèmes. Dans les commandes données
ci-dessous, on a favorisé l'utilisation de noms de commandes communs
aux 3 systèmes même si sur un système donné il existe parfois une
syntaxe plus simple. Lorsqu'il n'existe pas de nom commun aux 3 systèmes, 
on a indiqué les 3 noms de commande dans l'ordre Mupad/Maple/xcas.

Attention, certaines commandes ne sont pas activées au lancement 
d'une session, par
exemple les commandes d'algèbre linéaire en maple et mupad. Il faut alors
les activer (par exemple {\tt with(linalg);} en maple ou 
{\tt export(linalg);} en mupad).

Les commandes de {\tt xcas} sont regroupées dans des menus et sous-menus,
on peut essayer de les trouver si on ne les connait pas. Pour Maple
et mupad, on utilise l'aide interactive et on apprend quelques 
commandes.

\subsection{Commandes scalaires} \label{sec:scalaires}
Attention, la plupart de ces commandes agissent sur des expressions, et non sur
des fonctions. Par exemple, on peut \'ecrire {\tt diff(sin(x),x)}
car {\tt sin(x)} est une expression, mais pas {\tt diff(sin,x)}. 
Certaines commandes ont des \'equivalents qui agissent sur des fonctions, 
par exemple la commande {\tt D} de d\'erivation.
\begin{itemize}
\item {\tt binomial(n,k)} (coefficient binomial 
${n\choose k}=C_n^k={n!\over k!(n-k)!}$),
\item {\tt combine(f)} (Maple) regroupe les termes d'une expression $f$,
\item {\tt diff(f,x)} (d\'erive $f$ par rapport \`a $x$),
\item {\tt diff(f,x\$ k)}
(d\'erive $f$ $k-$fois ($0<k$ un entier) par rapport \`a $x$),
\item {\tt DIGITS:=k: float(f)}/ Maple/xcas: {\tt Digits:=k : evalf(f)}
(donne l'\'evaluation num\'erique de $f$ avec $k$ chiffres significatives),
\item {\tt eval(f)}: évalue l'expression $f$.
\item {\tt expand(f)} (d\'eveloppe $f$), (maple) utilisez ensuite 
{\tt sort} pour trier les monomes, cf. aussi {\tt normal}, {\tt rationalize}
\item {\tt factor(f)} (factorise $f$),
\item {\tt 300!} (factorielle de $n$),
\item {\tt float(hold(solve)(f=0,x))}/ 
{\tt fsolve(f=0,x)}/{\tt fsolve(f=0,x)}\\
(cherche une solution num\'erique de l'expression $f$ en la variable $x$),
\item {\tt float(f)} /{\tt evalf(f)}/les 2\\
(donne l'\'evaluation num\'erique avec pr\'ecision machine
de $f$). En maple et xcas, on peut indiquer la pr\'ecision en deuxi\`eme
param\'etre.
\item {\tt ifactor(n)} (factorise un entier $n$), 
\item {\tt int(f,x)} (primitive de $f$ par rapport \`a la variable $x$),
\item {\tt int(f,x=a..b)} (int\`egre $f$ de $a$ \`a $b$),
\item {\tt limit(f,x=a)} (limite de $f$ lorsque $x\longrightarrow a$),
\item {\tt mod} ({\tt a mod n} calcule le reste de $a$ modulo $n$),
\item {\tt normal(f)} (\'ecrit $f$ sous forme d'une fraction rationnelle)
\item {\tt plotfunc2d(f,x=a..b)} /{\tt plot(f,x=a..b)}/ les 2\\
(graphe $(x,f)$ pour $x\in [a,b]$, $f$ est vu comme une expression
dépendant de $x$),
\item {\tt hold(f)}/{\tt 'f'}/les 2:\\ empêche l'évaluation de {\tt f}.
\item {\tt rationalize(f)} (maple): supprime les radicaux du d\'enominateur
de {\tt f}
\item {\tt reset}/{\tt restart}/non disponible\\
(r\'einitialise la session), 
\item {\tt series(f,x=a,k)} (d\'eveloppement \`a l'ordre $k$ de $f$ autour de 
$a$),
\item {\tt simplify(f)} (essaie de simplifier $f$),
\item {\tt solve(f=0,x)} (cherche les solutions en $x$ de $f(x)=0$), 
\item {\tt solve(ode(diff(y(x),x\$ 2)+y(x)=0,y(x))))}/\\
Maple: {\tt dsolve(diff(y(x),x\$ 2)+y(x)=0,y(x))}/\\
xcas: {\tt desolve(y''+y=0)}
(cherche la solution g\'en\'erale de l'\'equation diff\'erentielle $y''+y=0$),
\item {\tt subs(f,x=a)}/{\tt subs(x=a,f)} /{\tt subst(f,x=a)}
(remplace $x$ par $a$ dans $f$). En maple, on peut aussi \'ecrire
\verb|eval(f,x=a)|.
\item {\tt sum(f,n=a..b)}:
calcule $\sum_{n=a}^b f(n)$ pour $a,b$ entiers ou $\pm \infty$
\end{itemize}

\subsection{Algèbre linéaire.} \label{sec:linalg}
Attention, pour Mupad/Maple, il faut commencer par activer les commandes
du ``package'' linalg (alg\`ebre lin\'eaire)
par {\tt export(linalg);} (Mupad) ou {\tt with(linalg);} (Maple).
\begin{itemize}
\item {\tt A+B}/{\tt evalm(A\&+B)} ou {\tt add(A,B)} /{\tt A+B}\\
(addition de matrices ou de vecteurs),
\item {\tt 1/A}/{\tt inverse(A)}/les 2
(calcule l'inverse d'une matrice inversible $A$),
\item {\tt A*B}/{\tt evalm(A\&*B)} ou {\tt multiply(A,B)} /{\tt A*B}\\
(multiplication de deux matrices),
\item {\tt f*A}/{\tt scalarmul(A,f)} / {\tt f*A}\\
(multiplication de la matrice ou du vecteur $A$ par le scalaire 
(ou la fonction) $f$),
\item {\tt charpoly(A,x)} \\
(d\'eterminant de $x{\rm Id}-A$ (polyn\^ome 
charact\'eristique))
\item {\tt det(A)}\\ (d\'eterminant d'une matrice $A$),
\item {\tt A=B}/{\tt equal(A,B)} /{\tt A=B} \\
teste l'\'egalit\'e de deux matrices
\item {\tt eigenvalues(A)}/{\tt eigenvals(A)} / les 2\\
(valeurs propres de la matrice $A$. Si vous voulez
des valeurs num\'eriques (et si $A$ est \`a valeurs num\'eriques) 
\'ecrivez au moins un des coefficients de $A$ comme nombre r\'eel ou complexe.
Le calcul se fait alors num\'eriquement et c'est beaucoup plus rapide),
\item {\tt eigenvectors(A)}/{\tt eigenvects(A)}/les 2\\
(vecteurs propres de $A$),
\item {\tt map}~:
ex\'ecute une fonction sur toutes les composantes d'un vecteur
ou d'une matrice, on utilise la commande \verb|map|, par exemple:\\
\verb|map(A,normal)|\\
ex\'ecute la commande \verb|normal| sur toutes les composantes de $A$.
\item {\tt matlinsolve(A,b)}/{\tt linsolve(A,b)}/{\tt linsolve(A,b)}
(r\'esout l'\'equation lin\'eaire $Ax=b$, $A$ une
matrice, $b$ un vecteur), 
\item {\tt matrix()} (cr\'eation d'une matrice):\\
{\tt matrix(2,2,[[5,4],[6,3]])}\\
{\tt f:=(j,k)->(1/(j+k-1));matrix(2,2,f)}\\
{\tt Dom::Matrix()([[5,4],[6,3]])}/{\tt matrix([[5,4],[6,3]])}//{\tt [[5,4],[6,3]]}, 
\item {\tt array(identity,1..n,1..n)}/{\tt identity(n)}: matrice identité
\item {\tt nrows(A)}/{\tt rowdim(A)}/les 2\\ 
nombre de lignes
\item {\tt ncols(A)}/{\tt coldim(A)}/les 2\\
nombre de colonnes
\item {\tt scalarProduct(A,B)}/{\tt dotprod(A,B)}/les 2\\ 
(produit scalaire des deux vecteurs $A$ et $B$),
\item {\tt transpose(A)} (transposée de $A$)
\item Cr\'eation d'un vecteur~: c'est une matrice $n \times 1$ (sauf
s'il s'agit d'une matrice ligne $1 \times n$). \\
Exemples~:\\
{\tt matrix(3,1,[[1,2,3]])}\\
{\tt Dom::Matrix()([1,2,3])}/{\tt vector([1,2,3])}/{\tt [1,2,3]}.
\end{itemize}

Attention en maple~:
\begin{itemize}
\item dans un programme, il est souvent n\'ecessaire d'ex\'ecuter 
\verb|evalm(A)| pour remplacer une variable \verb|A|
par sa valeur si c'est une matrice.
\item les vecteurs et matrices sont des
r\'ef\'erences, si on modifie un \'el\'ement d'une matrice, toutes
les variables ayant \'et\'e affect\'ees \`a cette matrice sont modifi\'ees.
On peut utiliser la commande {\tt copy} pour cr\'eer une matrice
ind\'ependante ayant la m\^eme valeur initiale.
\end{itemize}
 
\section{Conteneurs}
C'est un type d'objet qui peut contenir d'autres objets: les principaux
conteneurs sont les listes, les séquences (ce sont des listes aplaties), 
les ensembles (liste ``tri\'ee''
o\`u les doublons sont supprim\'es), les vecteurs
et les matrices.
En programmation on utilise aussi les tableaux associatifs. 
Les éléments sont séparés
par des virgules, le type du conteneur est indiqué par des délimiteurs:
[] pour les listes, rien pour les s\'equences et \{ \} pour les ensembles (
attention xcas en mode xcas utilise \verb|set[ ]| ou \%\{ \%\}
pour les ensembles, car \{ et \} servent de délimiteurs de bloc 
comme en C/C++). 
L'élément d'indice $k$
d'un conteneur $c$ est désigné par \verb|c[k]| (les indices
commencent \`a 1, sauf pour xcas en mode xcas ou les indices
commencent en 0 comme en C/C++). Pour
un élément de matrice, on écrit \verb|m[j,k]|. On peut acc\'eder
\`a une sous-liste en utilisant d'indices compris entre \verb|j|
et \verb|k| par \verb|l[j..k]|

Quelques instructions:
\begin{itemize}
\item \verb|convert| permet de changer le type de conteneur. On peut aussi
\'ecrire \verb|[s]| pour convertir une s\'equence en liste, ou \verb|op(l)|
pour convertir une liste en s\'equence.
\item \verb|nops(m)| (ou \verb|size(m)| avec xcas): la taille
\item \verb|[e, op(l)]|: place {\tt e} en tête de liste
\item \verb|[op(l),e]|: place {\tt e} en queue de liste
\item \verb|[op(l1),op(l2)]|: concatène 2 listes
\item \verb|seq| ou \$ permettent de cr\'eer des s\'equences.
Par exemple [0\$10] permet de cr\'eer une liste de 10 \'el\'ements.
\item \verb|subsop| permet de remplacer un \'elem\'ent dans une liste
(ou d'en supprimer un en utilisant {\tt NULL})
\end{itemize}
La liste vide s'obtient par \verb|[]|, la s\'equence vide par \verb|NULL|.

Il existe aussi des conteneurs associatifs (appel\'es tables en maple), 
ce sont en quelque sorte
des tableaux dont l'indice est quelconque (pas forc\'ement
un entier, mais dans un ensemble d'indices muni d'une relation
d'ordre, par exemple les chaines de caract\`eres avec l'ordre
lexicographique). Pour cr\'eer ou acc\'eder \`a un \'el\'ement
d'une table, la syntaxe est similaire \`a celle utilis\'ee pour les
listes. Attention, si vous \'ecrivez une instruction d'affectation
du type \verb|a[2]:=5| alors que la variable \verb|a| est libre,
\verb|a| devient une table (ayant un seul \'el\'ement d'indice 2
et de valeur 5) et non pas une liste ayant 2 \'el\'ements.

\section{Programmation.} \label{sec:progmupad}
Un programme consiste en une suite de commandes usuelles 
que l'on articule
avec des commandes de controle (tests, boucles, ...). On augmente ainsi
les possibilit\'es du syst\`eme.

On peut éditer des petits programmes directement
dans la feuille de calcul, c'est souvent le plus simple avec xmaple.
Pour des programmes plus longs, ou dont on veut se servir dans
d'autres sessions, il est commode d'utiliser un \'editeur de texte
(\verb|emacs|, \verb|nedit|, etc.) et de lire le programme pendant une session
par la commande \verb|read| avec comme argument le nom du fichier
texte entre guillements. Pour \'eviter les confusions, on utilisera 
un nom se terminant par \verb|.mu| pour un programme MuPAD, 
\verb|.map| pour un programme maple,et \verb|.cxx| pour xcas (en mode ``C'').

%\subsection{Instructions de controle.} \label{sec:controle}
Voici sur quelques exemple les principales instructions de controle. Notez
que \verb|xcas| accepte aussi la syntaxe Maple et la syntaxe Mupad
\footnote{attention
toutefois en mode xcas, les tableaux commencent à l'indice 0 comme en C
et on ne peut pas utiliser $i=\sqrt{-1}$ comme variable.}
\begin{itemize}
\item en-tête de fonction et création de variables locales~:\\
\verb|f:= proc(x) local n; begin n:= 2; n*x end_proc| (mupad)\\
\verb|f:= proc(x) local n; n:= 2; n*x end;| (maple)\\
\verb|f(x):={ local n; n:=2; return(n*x); }| (xcas)
\item faire un test: \\
\verb|if x2>x1 then max:=x2; else max:=x1; end_if;| (mupad)\\
\verb|if x2>x1 then max:=x2; else max:=x1; fi;| (maple)\\
\verb|if (x2>x1) { max:=x2; } else { max:=x1; }| (xcas)
\item boucle ind\'efinie :\\
\verb|while (x=0) do x:=x-1; end_while;| (mupad)\\
\verb|while (x=0) do x:=x-1; od;| (maple)\\
\verb|while (x==0) { x:=x-1; };| (xcas)
\item boucle d\'efinie :\\
\verb|for j from 1 to 15 do x:=j+x; end_for;| (mupad)\\
\verb|for j from 1 to 15 do x:=j+x; od;| (maple)\\
\verb|for (j:=1;j<=15;j++) { x:=j+x; }| (xcas)
\item {\tt return} (attention {\tt RETURN} pour Maple) permet
de quitter une fonction en renvoyant une valeur de retour.
\item {\tt break} permet de sortir d'une boucle, {\tt continue} passe
immédiatement à l'itération suivante.
\end{itemize}


\section{Mise au point d'un programme.}

\subsection{Maple}
Maple V ne possède pas de déboggueur interactif. On peut toutefois
avoir des informations interm\'ediaires sur le d\'eroulement
d'un programme avec les commandes {\tt debug}/{\tt undebug} et {\tt trace}.

\subsection{xcas}
Le déboggueur interactif est invoqué par la commande {\tt debug()} avec
comme argument la ligne de commande correspondant à l'appel de la
fonction à mettre au point. On peut alors faire afficher des variables
de mani\`ere permanente avec le bouton {\tt watch}, on peut aussi
ex\'ecuter des commandes {\tt xcas} entre deux instructions cons\'ecutives...

\subsection{Mupad et emacs} \label{sec:mupad_emacs}
Pour mupad, on peut par exemple utiliser uniquement {\tt emacs} et 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.

Lancez \verb|emacs| puis tapez
\verb|Echap| \verb|x| \verb|mupad-run| {\bf $<$ Entree$>$}.
Dans le menu \verb|Files| s\'electionnez
\verb|Open File| et donnez 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 qu'il faudra lui
passer, par exemple \verb|x1,x2|, puis les options 
(tapez sur {\bf $<$ Entree$>$}
pour ne pas donner d'options). Votre texte doit ressembler \`a:
\begin{verbatim}
ma_procedure:=
proc (x1,x2)
begin
  
end_proc: /* End of ma_procedure */
\end{verbatim}
Il ne reste plus qu'\`a entrer entre \verb|begin| et \verb|end_proc|:\\
\verb|return (x1+x2)/2;|\\
et \`a sauvegarder le fichier (\verb|Save Buffer| du menu \verb|Files|).

S\'electionnez maintenant le buffer \verb|*MuPAD*| et tapez:\\
\verb|read("prog1.mu");|\\
ce qui charge le fichier texte qui contient la d\'efinition de 
\verb|ma_procedure|. Vous pouvez maintenant calculer la moyenne des
deux entiers 5 et 13 en tapant:\\
\verb|ma_procedure(5,13);|\\
qui doit vous renvoyer \verb|9|.


{\bf Mise au point avec le d\'ebuggueur.}\\
Si vous ne voyez pas quelle peut \^etre la source d'une erreur,
vous pouvez utiliser le d\'ebuggeur (\verb|mdx|) qui 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 le d\'ebuggueur, tapez simplement\\
\verb|debug(ma_procedure(5,13));|\\
La fen\^etre \verb|emacs| doit maintenant \^etre divis\'ee en deux
parties, avec le texte source du programme d'une part et le 
buffer \verb|*MuPAD*| d'autre part. 
Les commandes de mise au point doivent \^etre \'ecrites
dans le buffer \verb|*MuPAD*|.\\
Les principales (\verb|h| pour en avoir la liste) 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 avec la commande \verb|S|.
\end{itemize}


%\end{document}


\section{Ex\'ecution en mode non interactif.} \label{sec:appel}
On peut lancer \verb|MuPAD|, \verb|maple| et \verb|giac| (xcas)
en mode {\em batch} (traitement automatique
de commandes), par exemple depuis un programme \'ecrit en C \`a
condition de sauvegarder les variables contenant les r\'esultats
dans un fichier. On peut ainsi ex\'ecuter un logiciel de calcul
formel \`a partir d'un document \LaTeX\, cf. par exemple pour xcas
\verb|http://alexandre.boisseau.free.fr/calcul.tex|.

Voici un exemple de fichier de commandes qui calcule la primitive
de $\sin(x)$ et sauvegarde le r\'esultat dans le fichier \verb|result.mu|
du r\'epertoire courant (n'importe quel session
filtr\'ee par \verb|mufilter| conviendra \`a condition de se terminer
par \verb|quit| et de sauvegarder les valeurs int\'eressantes)
\begin{verbatim}
/* mupad -S essai.mu */
a:=int(sin(x),x);
fprint(Text,"result.mu",a);
quit;
\end{verbatim}
Si ce fichier a pour nom \verb|essai.mu|, la commande :\\
\verb|mupad -S essai.mu|\\
ex\'ecutera le calcul et sauvegardera le r\'esultat sans intervention
de l'utilisateur. Par exemple un programme C peut se servir de \verb|mupad|
par l'interm\'ediaire de l'appel systeme \verb|system| 
(cf. \verb|man system| pour la syntaxe de cette appel C).

L'\'equivalent \verb|maple| sera le fichier \verb|essai.mpl|
\begin{verbatim}
# maple -i essai.mpl 
a:=int(sin(x),x);
fd:=fopen("result.mpl",WRITE);
fprintf(fd,"%a\n",a);
fclose(fd);
quit;
\end{verbatim}
qu'on ex\'ecute par la commande :\\
\verb|maple -i essai.mpl|

Pour \verb|xcas|, il est plus simple d'utiliser l'interface native C++. 
L'équivalent serait~:\\
\verb|giac 'a:=int(sin(x),x)' > a.cas|\\
qui sauvegarde dans le fichier \verb|a.cas| la réponse.

\section{Informations sur les algorithmes utilis\'es.} 
\label{sec:algorithmes}
La commande \verb|setuserinfo(Any,n)| o\`u $n$ est un entier permet de
faire afficher \`a \verb|MuPAD| des informations sur le d\'eroulement
de certaines commandes.
La commande \verb|Maple| correspondante est \verb|infolevel[all]:=n|. 

Exemple:\\ 
\verb|setuserinfo(Any,5);| ou \verb|infolevel[all]:=5;|
suivi de \verb|int(exp(x^5),x);|

Le code source des commandes de \verb|MuPAD| se trouve dans l'arborescence
de l'installation de \verb|MuPAD| (sous Unix), en g\'en\'eral 
il s'agit du fichier:\\
\verb|/usr/local/MuPAD/share/lib/lib.tar|.\\
Ce fichier \verb|lib.tar| peut \^etre d\'esarchiv\'e\footnote{Ne le faites pas sur pcm2, il est dej\`a d\'esarchiv\'e dans 
{\tt /usr/local/MuPAD/share/lib/lib}} dans le
r\'epertoire courant en tapant la commande:\\
\verb|tar xvf /usr/local/MuPAD/share/lib/lib.tar|\\
ce qui permet ensuite d'examiner les fichiers \verb|.mu| qui sont le
code source des fonctions \verb|MuPAD| (par exemple 
\verb|heu_gcd.mu| pour l'algorithme du PGCD heuristique se trouve
dans le sous-r\'epertoire \verb|lib/POLYLIB/GCD/|).

La commande \verb|interface(verboseproc=2);| de \verb|Maple| donne
acc\`es au code source (sans commentaires) des fonctions. Par exemple:\\
\verb|interface(verboseproc=2): with(numtheory): eval(cyclotomic); |\\
affiche le code source de la fonction \verb|cyclotomic|.

Pour \verb|xcas|, il faut se référer à la documentation et au code source,
la commande Unix \verb|setenv DEBUG_INFOLEVEL 2| (shells de type tcsh) ou\\
\verb|export DEBUG_INFOLEVEL=2| (shells de type bash) n'est pas encore
correctement implémentée.

\pagebreak

\section{TP 1}

\subsection{Utilisation interactive}
\begin{enumerate}
\item \'Ecrire le polyn\^ome $(x+3)^7 \times (x-5)^6$ selon les puissances
d\'ecroissantes de $x$.
\item Simplifier les expressions suivantes:
\[ \quad \sqrt{3+2\sqrt{2}}
\quad \frac{1+\sqrt{2}}{1+2\sqrt{2}}, \quad
e^{i\pi/6}, \quad 4\mbox{atan}(\frac{1}{5})-\mbox{atan}(\frac{1}{239}) \]
\item Factoriser~:
\[ x^8-3x^7-25x^6+99x^5+60x^4-756x^3+1328x^2-960x+256 \]
\[ x^6-2x^3+1, \quad (-y+x)z^2-xy^2+x^2y \]
\item Calculez les int\'egrales et simplifiez le r\'esultat:
\[ \int \frac{1}{e^x-1} \ dx, \quad
\int  \frac{1}{x\ln(x)} \ln(\ln(x)) dx, \quad \int e^{x^2} \ dx,
\quad \int x\sin(x)e^{x} \ dx \]
V\'erifiez en d\'erivant les expressions obtenues.
\item D\'eterminer la valeur de:
\[\int _1^2\frac{1}{(1+x^2)^3}, \quad  \int _1^2 \frac{1}{x^3+1} \ dx \]

\item Calculer les sommes suivantes
\[\sum_{k=1}^N k,\ \sum_{k=1}^N k^2,\ \sum_{k=1}^\infty \frac{1}{k^2}\]

\item D\'evelopper $\sin(3x)$, lin\'eariser l'expression obtenue
et v\'erifier qu'on retrouve l'expression initiale.

\item Calculer le d\'eveloppement de Taylor en $x=0$ \`a l'ordre 4
de:
\[ \ln(1+x+x^2),\quad
\frac{\exp(\sin(x))-1}{x+x^2} , \quad \sqrt{1+e^{x}}, \quad
\frac{\ln(1+x)}{\exp(x)-\sin(x)} \]

\item R\'esoudre le syst\`eme lin\'eaire:
\[ \left\{ \begin{array}{lllllll}
 x &+& y &+& az&=&1\\
 x & +& a y&+& z&=&2 \\
 ax & +&y &+& z&=&3 
\end{array}\right. \]

\item D\'eterminer la liste des diviseurs de 45768. \\
Factoriser 100!

\item D\'eterminer l'inverse et le d\'eterminant de:
\[ A=\left(\begin{array}{llll}
 1 & 1 & 1 & a \\
 1 & 1 & a & 1 \\
 1 & a & 1 & 1 \\
 a & 1 & 1 & 1
\end{array}\right)\]
Diagonaliser la matrice $A$.
\end{enumerate}

\subsection{Types. Calcul exact et approch\'e. Algorithmes de bases}
\begin{enumerate}
\item Utiliser la commande {\tt type} pour déterminer la représentation
utilisée par votre logiciel de calcul formel pour représenter
une fraction, un nombre complexe, un flottant en précision machine, 
un flottant avec 100 décimales, la variable $x$, l'expression $\sin(x)+2$,
la fonction {\tt x->sin(x)}, une liste, une séquence, un vecteur,
une matrice. Essayez d'accéder aux parties de
l'objet pour les objets composites (en utilisant {\tt op} par exemple).

\item Déterminer le plus grand flottant positif $x$ de la forme 
$10^{-n}$ ($n$ entier)
tel que $(1.0+x)-1.0=0.0$. Faites varier le nombre de chiffres
des flottants et observez l'effet.

\item D\'eterminer la valeur et le signe de la fraction rationnelle 
\[ F(x,y)= \frac{1335}{4} y^6 + x^2 (11x^2 y^2-y^6 -121y^4-2) + 
\frac{11}{2} y^8 + \frac{x}{2y}\]
en $x=77617$ et $y=33096$ en faisant deux calculs, l'un en mode approché et 
l'autre en mode exact. Que pensez-vous de ces résultats?
Combien de chiffres significatifs faut-il pour obtenir un r\'esultat
raisonnable en mode approch\'e?

\item \`A quelle vitesse votre logiciel multiplie-t-il des
grands entiers? On pourra tester le temps de calcul du produit
de $a(a+1)$ o\`u $a=10 000!$, $a=15000!$, etc. Comparer avec
le temps asymptotique mis par Karatsuba ou FFT.

\item Comparer le temps de calcul de $a^n \pmod m$ par la méthode rapide et
la méthode prendre le reste modulo $m$ après avoir calculé $a^n$
(vous pouvez aussi programmer la méthode rapide et la méthode lente).

\item Programmation de la m\'ethode de Horner\\
Il s'agit d'évaluer efficacement un polynôme en un point.
On pose $b_0=P(\alpha )$ et on \'ecrit~:
\[ P(X)-b_0=(X-\alpha )Q(X) \]
o\`u~:
\[ Q(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$.
\begin{enumerate}
\item
Donner $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^3-2X+5$ et une valeur de $\alpha $ non nulle.
\item \'Ecrire un fonction effectuant ce calcul:
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 )$.
(On pourra aussi renvoyer les coefficients de $Q$).
\item
En utilisant cette fonction, écrire une fonction qui calcule
le développement de Taylor complet d'un polynôme en un point.
\end{enumerate}

\item Programmer l'algorithme de B\'ezout pour des entiers.
\end{enumerate}


\end{document}

\pagebreak

\section{TP 1}

\subsection{Flottants}
Déterminer le plus grand flottant positif $x$ de la forme 
$2^{-n}$ ($n$ entier)
tel que $(1.0+x)-1.0=0.0$ sur PC et sur calculatrice.

Comparer le calcul par ordre croissant et décroissant pour quelques valeurs 
de $n$ de~:
\[ \sum_{j=1}^n \frac{1}{j} \]

\subsection{Puissance modulaire rapide}
Comparer le temps de calcul de $a^n \pmod m$ par la méthode rapide et
la méthode prendre le reste modulo $m$ après avoir calculé $a^n$
(vous pouvez aussi programmer la méthode rapide et la méthode lente).

\subsection{Représentation des objets (calcul formel)}
Utiliser la commande {\tt type} pour déterminer la représentation
utilisée par votre logiciel de calcul formel pour représenter
une fraction, un nombre complexe, un flottant en précision machine, 
un flottant avec 100 décimales, la variable $x$, l'expression $\sin(x)+2$,
la fonction {\tt x->sin(x)}, une liste, une séquence, un vecteur,
une matrice. Essayez d'accéder aux parties de
l'objet pour les objets composites (en utilisant {\tt op} par exemple).

\subsection{Programmation de la m\'ethode de Horner}.
Il s'agit d'évaluer efficacement un polynôme en un point.
On pose $b_0=P(\alpha )$ et on \'ecrit~:
\[ P(X)-b_0=(X-\alpha )Q(X) \]
o\`u~:
\[ Q(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$.
\begin{enumerate}
\item
Donner $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^3-2X+5$ et une valeur de $\alpha $ non nulle.
\item \'Ecrire un fonction effectuant ce calcul:
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 )$.
(On pourra aussi renvoyer les coefficients de $Q$).

\item
En utilisant cette fonction, écrire une fonction qui calcule
le développement de Taylor complet d'un polynôme en un point.
\end{enumerate}

%\pagebreak 



\subsection{Informations syst\`emes compl\'ementaires} \label{sec:dsu}
L'impression s'effectue vers l'imprimante de la salle sauf pour 
le serveur pcmath1 et pour les nouveaux
PC debian/knoppix o\`u l'impression est dirig\'ee vers l'imprimante
informatique g\'en\'erale. Si l'une des imprimantes ne fonctionne
pas, il est possible d'imprimer sur l'autre en se connectant par
\verb|ssh| sur une machine imprimant vers l'imprimante en service,
par exemple\\
\verb|ssh pcmath1 lpr essai.ps|

La salle B118 dispose de 17 PC linux (\verb|pcmath2.e.ujf-grenoble.fr| 
\`a \verb|pcmath20|) o\`u Mupad, Maple et xcas
sont install\'e. Le login est le même qu'en informatique, par
contre l'espace disque est séparé, il se trouve sur le serveur
\verb|pcmath1|. Le serveur \verb|pcmath1| est accessible depuis
les machines Unix de l'Universit\'e  par l'une des commandes
\verb|ssh pcmath1|,  \verb|ssf pcmath1| ou  \verb|slogin pcmath1|.

Vous pouvez utiliser les commandes Unix habituelles dans la fen\^etre
de commandes sur tous les PC linux et le serveur \verb|pcmath1|
(\verb|ls| liste des fichiers, \verb|cp| copie un fichier,
\verb|rm| efface un fichier, \verb|mv| d\'eplace ou renomme un
fichier, touche de tabulation pour compl\'eter un nom de fichier, ...).
En B118, on peut recopier un fichier sur une disquette, 
pour cela utilisez la commande \verb|mcopy|, par exemple:\\
\verb|mcopy essai.mu a:|\\
recopie le fichier \verb|essai.mu| du répertoire courant sur la disquette,
inversement:\\
\verb|mcopy a:essai.mu .|\\
recopie le fichier \verb|essai.mu| de la disquette sur le disque dur.

Vous pouvez recopier vos fichiers vers un autre serveur en utilisant
la commande \verb|scp| ou la commande \verb|ftp|. 
Par exemple, pour recopier le fichier \verb|essai.mu|
sur la machine \verb|thales|, tapez la commande:\\
\verb|scp essai.mu thales:|\\
Dans l'autre sens:\\
\verb|scp thales:essai.mu .|\\
Vous devrez indiquer un chemins d'acc\`es si le fichier \`a recopier
ne se trouve pas dans votre r\'epertoire principal sur \verb|thales|. 
Par exemple si \verb|essai.mu|
se trouve dans le r\'epertoire \verb|Programmes| sur \verb|thales|, tapez:\\
\verb|scp thales:Programmes/essai.mu .|

