% 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 des logiciels de calcul formel MuPAD et Maple.
}
\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.

\section{Aspects non math\'ematiques.} \label{sec:mupad}
Mupad et Maple sont les deux logiciels de calculs formel autoris\'es
\`a la 3eme \'epreuve orale de l'agr\'egation de math\'ematiques. 
Maple est plus ancien
que Mupad et contient plus de commandes mais vous devrez payer une
licence d'utilisation si vous voulez l'utiliser chez vous
(\verb|www.maplesoft.com|, la version \'etudiante de Maple co\^ute
par exemple 652F TTC prix au catalogue Springer Mars 1999), 
par contre Mupad est disponible gratuitement pour un usage \'educatif
(\verb|www.mupad.de| et \verb|www.sciface.com|). 
Les commandes qui existent dans les 2 syst\`emes sont suffisament 
proches pour que le passage de l'un \`a l'autre se fasse en douceur. 

Maple et MuPAD sont install\'es sur tous les PC linux de la salle 11
de l'Institut Fourier et sur \verb|carismat|, MuPAD est install\'e sur
tous les PC linux de la salle B118 du DSU.\\
Mathematica est un autre logiciel de calcul formel souvent utilis\'e
malheureusement indisponible sur nos machines.

\subsection{Ouvrir une session.} \label{sec:open}
\begin{itemize}
\item \verb|MuPAD| :\\
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|xterm|, taper
la commande {\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 \verb|MuPAD| et s\'electionner
\verb|Start MuPAD|.

\item \verb|Maple| :\\
On lance \verb|Maple| depuis une fen\^etre \verb|xterm| en tapant :\\
\verb|xmaple &|
\end{itemize}


\subsection{Chercher (et trouver) de l'aide.} \label{sec:aide}
\begin{itemize}
\item \verb|MuPAD| :\\ 
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,
\item depuis le navigateur Internet \verb|Netscape| (\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}
\item \verb|Maple| :\\
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.
\end{itemize}
\subsection{Utiliser et recopier des exemples}
\begin{itemize}
\item \verb|MuPAD| :\\ 
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|.
\item \verb|Maple| :\\
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)
\end{itemize}
\begin{rem} \label{rem:direct_help}
On peut \'egalement ouvrir une fen\^etre d'aide directement
depuis la fen\^etre MuPAD ou Maple. 
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.\\
 Pour \verb|maple|,
on peut taper sur les touches Alt et F4 simultan\'ement.

\subsection{Recopier avec la souris.} \label{sec:mouse}
MuPAD sous emacs et Maple utilisent 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}, 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}
\begin{itemize}
\item \verb|Maple| :\\
Maple est capable d'afficher les graphiques directement dans la
feuille de calcul.
\item \verb|MuPAD| :\\ 
 \verb|xmupad| lance une fenetre distincte 
appel\'ee \verb|vcam|.
Lorsqu'on ex\'ecute une commande avec sortie graphique depuis mupad sous 
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|xterm|.
\end{itemize}

\subsection{Sauver une session.} 

\begin{itemize}
\item  \verb|MuPAD| :\\ 
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 \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, pour conserver uniquement
les commandes \verb|MuPAD| de la session, il faut filtrer le fichier 
de la mani\`ere suivante :\\
\verb|mufilter > session.mu|\\
o\`u \verb|session.mu| d\'esigne le nom de fichier o\`u on souhaite
sauvegarder la session filtr\'ee.
\item \verb|Maple| :\\ 
{\bf Save as} dans le menu Files.
\end{itemize}

\subsection{Fermer une session.} 
Cliquer sur {\bf Quit} dans Mupad ou \\
Exit du menu File dans Maple.

\subsection{Arr\^eter un calcul} 
Cliquer sur \verb|Interrupt| du menu \verb|MuPAD| (\verb|emacs|)
ou sur \verb|Interrupt| (\verb|xmupad|) ou \\
sur le bouton \verb|STOP| (\verb|maple|).\\
 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| et \verb|maple|
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| 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|


\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 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 \^tre 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 
\verb|lib/GCDLIB/gcdheu.mu| pour l'algorithme du PGCD heuristique).

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

\section{Aspects math\'ematiques.}

\subsection{Les bases des langages Maple et MuPAD} \label{sec:basic}

\begin{itemize}
\item 
 MuPAD et Maple sont sensibles \`a la diff\'erence entre majuscules 
et minuscules.
\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$>$} ,\\
{\tt 1+1:} {\bf $<$Return$>$} ,\\
 {\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!:} {\bf $<$Return$>$} 
(donne la valeur 300! \`a la variable $x$, sans afficher le r\'esultat)\\
{\tt ifactor(x);} {\bf $<$Return$>$} 
(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)|\\
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).
\item Constantes utiles : {\tt PI} (Maple: {\tt Pi})
pour $\pi$, {\tt I} pour $i=\sqrt{-1}$
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 $f$ se d\'efinit par {\tt f:= 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)}).
\item Mupad et Maple sont des langages de programmation complets
permettant d'\'ecrire des boucles: {\tt for i from 1 by a to b do
  .. od;} 
des instructions condidionnelles: {\tt if (a<b) then .. else .. fi;} 
etc. 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 utiles Maple et MuPAD.} \label{sec:base_command}

\subsubsection{Commandes scalaires} \label{sec:scalaires}
\begin{itemize}
\item {\tt binomial(n,k)} (coefficient binomial 
${n\choose k}=C_n^k={n!\over k!(n-k)!}$),
\item {\tt int(f,x=a..b)} (int\`egre $f(x)$ de $a$ \`a $b$),
\item {\tt int(f,x)} (primitive de $f$ par rapport \`a la variable $x$),
\item {\tt diff(f,x)} (d\'erive $f$ par rapport \`a $x$),
{\tt diff(f,x\$ k)} (d\'erive $f$ $k-$fois ($0<k$ un entier) par rapport 
\`a $x$),
\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))}
(cherche la solution g\'en\'erale
de l'\'equation diff\'erentielle $y''+y=0$),
\item {\tt float(f)} (mupad) {\tt evalf(f)} (Maple)
(donne l'\'evaluation num\'erique avec pr\'ecision machine
de $f$),
\item {\tt DIGITS:=k: float(f)}, Maple: {\tt evalf(f,k)}
(donne l'\'evaluation num\'erique de $f$ avec $k$ chiffres significatives),
\item {\tt combine(f)} (regroupe les termes d'une expression $f$),
\item {\tt expand(f)} (d\'eveloppe $f$), 
\item {\tt normal(f)} (\'ecrit $f$ sous forme d'une fraction rationnelle)
\item {\tt factor(f)} (factorise $f$),
\item {\tt simplify(f)} (essaie de simplifier $f$),
\item {\tt float(hold(solve)(f=0,x))} (Maple: {\tt fsolve(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 limit(f(x),x=a)} (limite de $f(x)$ lorsque $x\longrightarrow a$),
\item {\tt mod} ({\tt a mod n} calcule le reste de $a$ modulo $n$),
\item {\tt plotfunc(f(x),x=a..b)} Maple: {\tt plot(f(x),x=a..b)}
(graphe $(x,f(x))$ pour $x\in [a,b]$),
\item {\tt reset}/{\tt restart} (r\'einitialise la session), 
\item {\tt series(f,x=a,k)} (d\'eveloppement \`a l'ordre $k$ de $f$ autour de 
$a$),
\item {\tt solve(f=0,x)} (cherche les solutions en $x$ de $f(x)=0$), 
\item {\tt subs(f,x=a)} Maple: {\tt subs(x=a,f)} 
(remplace $x$ par $a$ dans $f$), 
\item {\tt sum(f,i=a..b)} (calcule $\sum_{i=a}^b f(i)$ pour $a,b$ entiers ou 
$\pm \infty$)
\end{itemize}


\subsubsection{Le package {\tt linalg}.} \label{sec:linalg}
Les commandes sont donn\'ees sous la forme Mupad/Maple.
\begin{itemize}
\item {\tt export(linalg)}/{\tt with(linalg);}
(charge les commandes du \lq\lq package''linalg (alg\`ebre lin\'eaire))
\item {\tt A+B}/{\tt evalm(A\&+B)} ou {\tt add(A,B)} 
(addition de matrices ou de vecteurs),
\item {\tt charPolynomial(A,x)}/{\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 scalarProduct(A,B)}/{\tt dotprod(A,B)} 
(produit scalaire des deux vecteurs $A$ et $B$),
\item {\tt eigenValues(A)}/{\tt eigenvals(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)}/{\tt eigenvects(A)} (vecteurs propres de $A$),
\item {\tt 1/A}/{\tt inverse(A)} (calcule l'inverse d'une matrice inversible $A$),
\item {\tt linearSolve(A,b)}/linsolve(A,b) (r\'esout l'\'equation lin\'eaire $Ax=b$, $A$ une
matrice, $b$ un vecteur), 
\item {\tt Dom::Matrix}/{\tt matrix()} (cr\'eation d'une matrice)\\
 Exemples:\\
{\tt Dom::Matrix()(2,2,[[5,4],[6,3]])}/{\tt matrix(2,2,[5,4,6,3]])}, \\
{\tt Dom::Matrix()([[5,4],[6,3]])}/{\tt matrix([[5,4],[6,3]])}, \\
{\tt f:=(i,j)->(1/(i+j-1));Dom::Matrix()(2,2,f)}/
{\tt f:=(i,j)->(1/(i+j-1));matrix(2,2,f)}
\item {\tt A*B}/{\tt evalm(A\&*B)} ou {\tt multiply(A,B)} 
(multiplication de deux matrices),
\item {\tt f*A}/{\tt scalarmul(A,f)} (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~: c'est une matrice $n \times 1$. \\
Exemples~:\\
{\tt Dom::Matrix()(3,1,[1,2,3])}/{\tt vector(3,[1,2,3])},\\
 {\tt Dom::Matrix([1,2,3])}/{\tt vector([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}, \quad \ln(1+i) \]
\item Factoriser sur $I\!\!R $ et $I\!\!\!\!C $:
\[ 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
\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 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)\]
\end{enumerate}


\section{Programmer avec MuPAD.} \label{sec:progmupad}
Les programmes \verb|MuPAD| sont des fichiers texte qui sont lus
par la commande \verb|read|, par convention leur nom se termine
par \verb|.mu|, par exemple \verb|essai.mu|. Un programme \verb|MuPAD|
consiste en une suite de commandes usuelles \verb|MuPAD| que l'on articule
avec des commandes de controle (tests, boucles, ...) pour augmenter
les possibilit\'es du syst\`eme en d\'efinissant de nouvelles fonctions.

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


\subsection{Un exemple.} \label{sec:exemple}
Lancez \verb|emacs| puis tapez
\verb|Echap| \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 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 $<$ 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|.


\subsection{Instructions de controle.} \label{sec:controle}
Voici sur quelques exemple les principales instructions de controle de
\verb|MuPAD|
\begin{itemize}
\item cr\'eer des variables locales : 
utiliser \verb|Local| dans le menu \verb|Shape|
\item test: \\
\verb|if x2>x1 then max:=x2; else max:=x1; end_if;|
\item boucle ind\'efinie (menu \verb|Shape|, item \verb|While|):\\
\verb|while (x=0) do x=x-1; end_while;|
\item boucle d\'efinie (menu \verb|Shape|, item \verb|For|):\\
\verb|for i from 1 to 15 do x=i+x; end_for;|
\end{itemize}


\subsection{Le d\'ebuggueur mdx.} \label{sec:mdx}
Si vous ne voyez pas quelle peut \^etre la source d'une erreur,
vous pouvez utiliser le programme \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 \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 tapant \verb|Ctrl-X|
\verb|Ctrl-A| \verb|Ctrl-B| dans la fen\^etre source (ou avec la
commande \verb|S|).
\end{itemize}

\subsection{Compl\'ements} \label{sec:types}
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/|\\

\pagebreak 

\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}

