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

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

\begin{center}
{\Large
Pr\'esentation rapide du logiciel de calcul formel MuPAD.
}
\end{center}

\vspace{1cm}

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.

Mupad est l'un des deux logiciels de calcul formel autoris\'es
\`a la 3eme \'epreuve orale de l'agr\'egation de math\'ematiques.
Il est disponible gratuitement pour un usage \'educatif
(pour obtenir une licence d'utilisation consultez \verb|www.mupad.de| 
ou \verb|www.sciface.com|). 

\section{Mise en route.} \label{sec:mupad}
MuPAD est install\'e sur tous les PC linux de la salle B118 du DSU.\\
Si votre PC est \'etient, 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. Vous devez maintenant voir une fen\^etre
de login. Entrez votre login et votre mot de passe.\\
Si vous n'avez pas de fen\^etre {\tt Konsole}, cliquez sur l'ic\^one 
repr\'esentant un \'ecran (au milieu de la ligne du bas).
\subsection{Ouvrir une session MuPAD.} \label{sec:open}
On peut utiliser deux interfaces :\\
 soit \verb|xmupad|,\\
 soit lancer \verb|mupad| \`a l'int\'erieur d'\verb|emacs|, c'est cette 
derni\`ere m\'ethode qui est la plus conviviale.\\
Dans une fen\^etre \verb|Konsole|, taper :\\
{\tt emacs \&} suivie de la touche {\bf $<$ Return$>$}.\\
Tapez ensuite sur la touche \verb|Echap| puis tapez \verb|x mupad|
et {\bf $<$ Return$>$}.\\
 \verb|MuPAD| appara\^{\i}t alors dans la barre des 
menus.\\ 
Ouvrir le menu \verb|MuPAD| et s\'electionner
\verb|Start MuPAD|.
\subsection{Chercher (et trouver) de l'aide.} \label{sec:aide}
L'aide de \verb|MuPAD| est accessible de trois mani\`eres :
\begin{itemize}
\item si on utilise \verb|MuPAD| depuis \verb|emacs|, \verb|Help On|, dans le
menu \verb|MuPAD|, permet d'obtenir de l'aide
sur un nom de commande alors que \verb|HyTeX Manual| affiche
le manuel complet. Attention il faut quitter \verb|HyTeX Manual| (cliquer sur {\tt Quit} pour pouvoir se servir de  \verb|MuPAD|,
\item depuis le navigateur Internet \verb|Netscape| (cliquez sur l'icone
de \verb|Netscape| ou tapez \verb|netscape &| dans la fen\^etre \verb|Konsole| 
et \verb|Netscape| s'ouvre sur la page d'aide de  \verb|MuPAD|),
\item si on utilise \verb|xmupad|, en allant dans le
menu \verb|Tools| puis \verb|Help| qui affiche le manuel complet
\end{itemize}

Dans la fen\^etre d'aide de MuPAD intitul\'ee HyTeX, choisissez
{\bf Helpindex} pour une recherche par th\`eme ou {\bf Search$\ldots$\ }
pour une recherche par mot-clefs:
\begin{itemize}
\item 
Si vous avez cliqu\'e {\bf Helpindex}, cliquez ensuite par exemple
sur {\bf Standard Library} puis sur {\bf Creation of data structures}, etc.
\item
Si vous avez opt\'e pour {\bf Search$\ldots$\ }, tapez le mot-clef
(en anglais) dans la case {\bf Pattern} puis cliquez dans
{\bf Ok to search}. Vous obtenez ainsi 
une page du manuel contenant le mot d\'esir\'e (si une telle page
existe), qui sera mis en inverse vid\'eo.\\
Exemple:\\ 
Tapez
le mot-clef {\bf integration} (pour les fonctions relatives \`a 
l'int\'egration). Vous obtenez la page sur les fonctions arithm\'etiques~;
les mots soulign\'es sont des pointeurs sur d'autres pages~:
cliquez sur {\bf int}.
\end{itemize}
\subsection{Utiliser et recopier des exemples}
La d\'escription de la fonction s\'electionn\'ee se termine par
des exemples, il suffit de cliquer sur les chevrons \`a gauche des
exemples pour les recopier dans la fen\^etre \verb|xmupad|, d'o\`u l'on peut
les modifier \`a volont\'e.\\
 Pour recopier dans la fen\^etre \verb|MuPAD|
d'\verb|emacs|, on ne peut pas utiliser \verb|HyTeX|, il faut soit directement
faire la recherche par mot-clefs (\verb|Help On| du menu \verb|MuPAD|)
soit utiliser \verb|Netscape|.
\begin{rem} \label{rem:direct_help}
On peut \'egalement ouvrir une fen\^etre d'aide directement
depuis la fen\^etre MuPAD. 
Taper {\tt ?} suivi de $<$Return$>$ (pour des
g\'en\'eralit\'es) ou par exemple {\tt ?int} 
$<$Return$>$ ou {\tt ?series} $<$Return$>$
(pour une aide concernant les commandes int (int\'egrale) 
ou series (d\'eveloppement en s\'erie)) ou encore {\tt ?linalg} 
$<$Return$>$ pour la liste des fonctions du \lq\lq package" linalg 
(alg\`ebre lin\'eaire).
\end{rem}
\medskip
\subsection{Fermer la fen\^etre d'aide.} \label{sec:close_help}
Pour \verb|HyTeX|, cliquer avec la souris (bouton gauche) 
sur le mot {\bf Done} en haut de la fen\^etre d'aide.\\
\subsection{Recopier avec la souris.} \label{sec:mouse}
MuPAD sous emacs  utilise les conventions usuelles pour
copier/coller du texte (bouton du milieu pour recopier). Notez
que sur certains syst\`emes 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.

Par contre le copier-coller sous \verb|xmupad| suit les
conventions \verb|XView| diff\'erentes du standard ci-dessus. 
Pour marquer le d\'ebut de s\'election,
cliquer avec le bouton gauche de la souris, pour marquer la fin
de la s\'election, cliquer avec le bouton {\bf du milieu} (ou  bouton droit et
le bouton gauche simultan\'ement) pour
recopier, il faut ensuite ``tirer'' la s\'election
avec le bouton droit de la souris depuis sa position initiale jusqu'a
la position o\`u l'on souhaite ins\'erer la s\'election.
\subsection{Aspects graphique.} \label{sec:graph_mupad}
 \verb|xmupad| lance une fenetre distincte 
appel\'ee \verb|vcam|.
Lorsqu'on ex\'ecute une commande avec sortie graphique depuis {\tt MuPAD} sous 
{\tt emacs}, le resultat est sauvegard\'e dans un fichier appel\'e \verb|save.mp|.\\
Pour le visualiser, il faut alors lancer la commande:\\
\verb|vcam save.mp|\\
dans la fen\^etre \verb|Konsole|.
\subsection{Sauver une session.} 
Sous \verb|emacs|, il suffit de s\'electionner la commande 
\verb|Save Buffer| du menu \verb|Files|. La session doit \^etre
sauvegard\'ee sous le nom propos\'e \verb|*MuPAD*| pour pouvoir continuer
\`a utiliser \verb|MuPAD|.\\
Avec \verb|xmupad|, cliquer sur {\bf \underbar
Settings} et l\^acher au-dessus de {\bf Save Text} fait appara\^{\i}tre
une fen\^etre de sauvegarde. \'Ecrire dans la case {\bf File}  
le nom de vos r\^eves. Terminer en cliquant sur la case
{\bf Ok}.\\
Attention, tout le texte est sauvegard\'e (commandes et r\'eponses), pour conserver uniquement
les commandes \verb|MuPAD| de la session, il faut filtrer le fichier.\\ 
Pour cela on tape dans une fen\^etre {\tt Konsole} :\\
\verb|mufilter > session.mu| (c'est alors le fichier \verb|*MuPAD*| qui est filtr\'e.\\
o\`u \verb|session.mu| d\'esigne le nom de fichier o\`u on souhaite
sauvegarder la session filtr\'ee.

\subsection{Fermer une session.} 
Cliquer sur {\bf Quit} dans la fen\^etre \verb|MuPAD| (\verb|xmupad|).\\
Cliquer sur {\bf Kill MuPAD session} dans le menu \verb|MuPAD| (\verb|emacs|),
 puis sortir de \verb|emacs| en cliquant sur \verb|Exit Emacs| du menu \verb|Files| .\\
Cliquer sur l'ic\^one representant une croix (au dessus du cadenas) puis
confirmer en cliquant sur {\tt Quitter KDE}. 
\subsection{Arr\^eter un calcul} 
Cliquer sur \verb|Interrupt| du menu \verb|MuPAD| (\verb|emacs|)
ou sur \verb|Interrupt| (\verb|xmupad|).\\
 Cette commande est 
importante car la complexit\'e d'un calcul peut vite devenir effrayante 
(m\^eme pour un ordinateur).
\subsection{Ex\'ecution en mode non interactif.} \label{sec:appel}
Cette section ne concerne que les utilisateurs avanc\'es.
On peut lancer \verb|MuPAD| 
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.

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| peut jouer le r\^ole de \verb|essai.mu| \`a condition d'y rajouter (en l'\`editant des \verb|fprint(...)| pour  sauvegarder les valeurs int\'eressantes et de le terminer par \verb|quit| ).
\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 cet appel C).
\subsection{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 la plupart des commandes.\\
Exemple:\\ 
\verb|setuserinfo(Any,5);|
suivi de \verb|int(x*exp(x^2),x);|
{\tt MuPAD} affiche ce qu'il fait pour chercher une primitive de $x*\exp(x^2)$

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 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 emacs 
\verb|lib/GCDLIB/gcdheu.mu| permet de lire l'algorithme du PGCD heuristique).
\section{Aspects math\'ematiques.}
\subsection{Les bases du langage MuPAD} \label{sec:basic}
\begin{itemize}
\item 
 MuPAD  est sensible \`a la diff\'erence entre majuscules 
et minuscules. Attention \`a laisser toujours un espace entre \verb|>>| 
et le d\'ebut de la commande, et ne jamais mettre d'espace apr\`es
le point-virgule final.
\item La touche {\bf $<$ Return$>$} \'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|).
\item 
Toute instruction (\`a l'exception des commandes invoquant l'aide) doit se
terminer par ; ou par : (le double-point supprime l'impression du r\'esultat
sur l'\'ecran).\\
Exemples: \\
{\tt 1+1;} {\bf $<$Return$>$} affiche 2,\\
{\tt 1+1:} {\bf $<$Return$>$} n'affiche rien,
%\\ {\tt 2*3;10;} {\bf $<$Return$>$} .
\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!:} 
(donne la valeur 300! \`a la variable $x$, sans afficher le r\'esultat)\\
{\tt ifactor(x);} 
(donne la d\'ecomposition de $x=300!$ en facteurs premiers).\\
Pour enlever une assignation \`a une variable, on utilise la commande
\verb|unassign|, par exemple : \verb|unassign(x):|\\
Pour enlever toutes les assignations (en fait r\'einitialiser la
session) taper \verb|reset():|\\
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. Par exemple~:\\
\verb|f:=sin(x)/x;| dans ce cas {\tt f} est une expression et 
{\tt subs(f,x=1);} calcule la valeur de cette expression por {\tt x=1}
\item {\tt \%} repr\'esente le dernier r\'esultat.
\item Constantes utiles : {\tt PI} 
pour $\pi$, {\tt I} pour $i=\sqrt{-1}$,  {\tt E} pour $e$ 
et {\tt infinity} pour $\infty$ (pour les int\'egrales impropres et
les sommations).
\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), acos(x)} etc. (les arguments sont en radians).
\item Une fonction $g$ se d\'efinit par {\tt g:= x-$\tt >$ (...) ;}\\
Attention, les parenth\`eses apr\`es \verb|->| sont indispensables.
 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)}).
Attention \`a la diff\`erence entre expression et fonction si on a d\'efinit
la fonction $g$, {\tt g(x)} a un sens alors que $g$ n'a pas de sens. 
\item {\tt MuPAD} est un langage de programmation complet
permettant d'\'ecrire des boucles,
des instructions condidionnelles etc...(cf le document d'algorithmique)\\
 Vous n'obtiendrez par contre jamais des programmes rapides.
Choisissez un autre langage (C, FORTRAN, Pascal ou LISP par exemple)
pour programmer un tr\`es gros calcul.
\end{itemize}
\subsection{Quelques commandes  MuPAD utiles.} \label{sec:base_command}

\subsubsection{Commandes scalaires} \label{sec:scalaires}
Attention : lorsque $f$ est une fonction il faut remplacer $f$ par $f(x)$ dans la suite.
\begin{itemize}
\item {\tt binomial(n,k)} est le coefficient binomial 
${n\choose k}=C_n^k={n!\over k!(n-k)!}$,
\item {\tt diff(f,x)} d\'erive $f$ par rapport \`a $x$ si $f$ est une expression et {\tt diff(f(x),x)} d\'erive la fonction $f$ par rapport \`a $x$ \\
{\tt diff(f,x\$ k)} d\'erive $f$ $k-$fois ($0<k$ un entier) par rapport 
\`a $x$ si $f$ est une expression et {\tt diff(f(x),x\$ k)} d\'erive la fonction $f$ par rapport \`a $x$,
\item {\tt solve(ode(diff(y(x),x\$ 2)+y(x)=0,y(x))))},
cherche la solution g\'en\'erale
de l'\'equation diff\'erentielle $y''+y=0$,
\item {\tt DIGITS:=k: float(f)}
donne l'\'evaluation num\'erique de $f$ avec $k$ chiffres significatives,
\item {\tt combine(f,sqrt)} regroupe les racines carr\'es 
d'une expression $f$,
\item {\tt expand(f)} d\'eveloppe $f$ si $f$ est une expression et {\tt expand(f(x))} d\'eveloppe $f$ si $f$ est une fonction, 
\item {\tt factor(f)} factorise $f$ si $f$ est une expression et 
{\tt factor(f(x))} factorise $f$ si $f$ est une fonction,
\item {\tt float(f)} donne l'\'evaluation num\'erique avec pr\'ecision machine
de $f$ et {\tt float(hold(solve)(f=0,x))}
cherche une solution num\'erique de l'expression $f$ en la variable $x$,
\item {\tt ifactor(n)} factorise un entier $n$, 
\item {\tt int(f,x=a..b)} int\`egre $f$ de $a$ \`a $b$,
\item {\tt int(f,x)} primitive de $f$ par rapport \`a la variable $x$,
\item {\tt normal(f)} \'ecrit $f$ sous forme d'une fraction rationnelle irr\'eductible
\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 plotfunc(g(x),x=a..b)}
graphe $(x,g(x))$ pour $x\in [a,b]$ (cf section \ref{sec:graph_mupad}),
\item {\tt radsimp(f)}~: simplification des racines carr\'ees contenues
dans $f$
%\item {\tt reset()} 
\item {\tt rewrite(f,exp)}~: r\'e\'ecrit une expression (par exemple
trigonom\'etrique) $f$ \`a l'aide d'exponentielles.
\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 subs(f,x=a)} remplace $x$ par $a$ dans $f$ si $f$ est une expression et  {\tt f(a)} si $f$ est une fonction,
\item {\tt sum(f,i=a..b)} (calcule $\sum_{i=a}^b f$ pour $a,b$ entiers ou 
$\pm \infty$)
\end{itemize}
\subsubsection{Le package {\tt linalg}.} \label{sec:linalg}
Pour avoir acc\`es aux commandes du  ''package'' {\tt linalg}, taper :\\
{\tt export(linalg):}\\

Les commandes sont donn\'ees sous la forme Mupad.
\begin{itemize}
\item {\tt A+B} ou {\tt add(A,B)} 
(addition de matrices ou de vecteurs),
\item {\tt charPolynomial(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 scalarProduct(A,B)} 
(produit scalaire des deux vecteurs $A$ et $B$),
\item {\tt eigenValues(A)} (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)} (vecteurs propres de $A$),
\item {\tt 1/A} (calcule l'inverse d'une matrice inversible $A$),
\item {\tt linsolve(\{x+y=1,x-y=0\},\{x,y\})} r\'esout les  syst\`emes lin\'eaires.
\item {\tt linearSolve(A,b)} (r\'esout l'\'equation lin\'eaire $Ax=b$, $A$ une
matrice, $b$ un vecteur), 
\item {\tt Dom::Matrix} (cr\'eation d'une matrice)\\
 Exemples:\\
{\tt Dom::Matrix()(2,2,[[5,4],[6,3]]):} \\
{\tt Dom::Matrix()([[5,4],[6,3]]):} \\
{\tt f:=(i,j)->(1/(i+j-1));Dom::Matrix()(2,2,f);}
\item {\tt A*B} ou {\tt multiply(A,B)} 
(multiplication de deux matrices),
\item {\tt f*A} (multiplication de la matrice ou du vecteur $A$ par
le scalaire (ou la fonction) $f$),
\item {\tt transpose(A)}
\item Cr\'eation d'un vecteur colonne: c'est une matrice  $n \times 1$. \\
Exemples~:\\
{\tt Dom::Matrix()(3,1,[1,2,3]):}\\
 {\tt Dom::Matrix()([1,2,3]);}.
\end{itemize}
Pour ex\'ecuter une commande 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$.
\section{Exercices}
\begin{enumerate}
\item D\'evelopper les expressions suivantes:
\[ (x+3)^7 \times (x-5)^6, \quad \sqrt{3+2\sqrt{2}},
\quad \frac{1+\sqrt{2}}{1+2\sqrt{2}}, \quad
e^{i\pi/6} \]
\item Factoriser sur $I\!\!R $ :
\[ 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 V\'erifier que
\[ \sin(2x)-2\sin(x)\cos(x)=0\]
en passant en exponentielles complexes.
\item Calculer le d\'eveloppement de Taylor en $x=0$ \`a l'ordre 4
de:
\[ \ln(1+x+x^2),\quad \ln(\frac{sin(x)}{x}),\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 primitive de:
\[ \frac{-e^x \ln(x)^2 + \frac{2(e^x+1)}{x}\times \ln(x)
+e^x+e^{2x} }{1+2e^x+e^{2x}} \]
\item D\'eterminer l'inverse et le d\'eterminant de:
\[ \left(\begin{array}{llll}
 1 & 1 & 1 & a \\
 1 & 1 & a & 1 \\
 1 & a & 1 & 1 \\
 a & 1 & 1 & 1
\end{array}\right)\]
\item 
Factoriser 100!
\end{enumerate}
\section{Informations sur les syst\`emes linux du DSU} \label{sec:dsu}
La salle B118 dispose de 16 PC linux (\verb|pcmath1| \`a \verb|pcmath17|
sauf \verb|pcmath14|) o\`u Mupad est install\'e.
Lors de la cr\'eation des comptes, votre mot de passe sera identique
sur toutes les machines, mais si vous le changez par la suite, il
ne changera que sur la machine o\`u vous tapez \verb|passwd|.

Vos fichiers sont sur le disque dur du PC sur lequel vous \^etes
connect\'es. Vous pouvez recopier d'un PC \`a l'autre \`a l'aide de
la commande \verb|scp|. Par exemple si vous avez travaill\'e sur
\verb|pcmath7| et cr\'e\'e un fichier \verb|essai.mu| et que la semaine
suivante vous \^etes sur un autre PC, tapez la commande:\\
\verb|scp pcmath7: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|pcmath7|. 
Par exemple si \verb|essai.mu|
se trouve dans le r\'epertoire \verb|Programmes| sur \verb|pcmath7|, tapez:\\
\verb|scp pcmath7:Programmes/essai.mu .|

Vous pouvez \'egalement 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 disque dur sur la disquette,
inversement :
\verb|mcopy a:essai.mu .|\\
recopie le fichier \verb|essai.mu| de la disquette sur le disque dur.

Pour \'eviter de faire des erreurs en recopiant un fichier
d'une machine \`a l'autre, essayez de rester sur le m\^eme PC d'une
s\'eance \`a l'autre. Prenez le temps de faire 
des copies de sauvegardes de vos fichiers importants, soit sur un serveur 
du DSU (voire proc\'edure ci-dessous)
soit sur une (voire 2) disquette(s) (commande \verb|mcopy| ci-dessus), 
car vos fichiers sur les PC ne sont pas sauvegard\'es sur bande magn\'etique.

Copie d'un fichier sur un serveur du DSU, par exemple \verb|zenon| :
\verb|ftp zenon|\\
Tapez votre nom d'utilisateur puis la touche Entr\'ee ou simplement
la touche Entr\'ee si le nom d'utilisateur (\verb|Name|)
qui s'affiche entre parenth\`eses est correct,
entrez ensuite votre mot de passe. Pour envoyer le fichier \verb|essai.mu|
depuis le PC sur \verb|zenon|, tapez ensuite :
\verb|send essai.mu|\\
Recommencez pour les autres fichiers \`a sauvegarder. Lorsque vous
avez termin\'e, tapez \verb|bye|.\\
Remarque: pendant le d\'eroulement du programme \verb|ftp|,
vous pouvez utiliser la commande \verb|cd nom-de-repertoire| pour sauvegarder
vos fichiers dans le r\'epertoire \verb|nom-de-repertoire| du
serveur (\verb|zenon|).

\end{document}

