\documentclass{article}
\usepackage{graphicx}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{stmaryrd}
\usepackage{makeidx}
\usepackage{times}
\usepackage{mathptmx}
%Uncomment next line for pdflatex and use includegraphics with eps file
% for latex2html don't use the option [width=\textwidth]
% check that xfig files are exported magnif 100%
\usepackage{ifpdf}
\ifpdf
 \usepackage[pdftex]{hyperref}
\fi
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
%\DeclareGraphicsExtensions{.pdf, .png, .mps, .eps}
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\begin{document}

\title{Tutoriel xcas}
\author{Bernard Parisse\\ Institut Fourier\\CNRS UMR5582 \\ 
Université Grenoble I}

\maketitle

\begin{abstract}
Ce texte a pour but une prise en main rapide de {\tt xcas}, logiciel
libre de calcul formel généraliste qui combine dans une m\^eme interface
un historique pour le calcul formel, un petit tableur et des fonctionnalit\'es
de géométrie dynamique.
\end{abstract}

\tableofcontents

\pagebreak

\section{Introduction}
{\tt xcas} est un logiciel qui rassemble dans une même interface
plusieurs aspects des mathématiques~: calcul numérique, calcul
formel (ou symbolique), représentation graphique de fonctions,
géométrie dynamique, tableur. Il possède un langage de programmation
de haut niveau qui peut lire et exécuter des programmes simples écrits pour
les logiciels Maple, MuPAD ou pour les calculatrices TI89/TI92/Voyage 200.
On peut partager l'écran pour avoir différentes vues d'un même objet
mathématique (par exemple coordonnées d'un point géométrique,
vue numérique et graphique pour des données statistiques, ...).
{\tt xcas} génère des fichiers \LaTeX\ et permet ainsi très facilement
la création et l'insertion de figures et graphes de fonctions
dans vos fichiers \LaTeX. \\
%\includegraphics[width=\textwidth]{xcas9.png}
\includegraphics[width=\textwidth]{xcas9}

\section{Installation.} \label{sec:install}
La page home de {\tt xcas} est~:\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html|\\
Vous y trouverez toutes les instructions nécessaires pour installer
{\tt xcas} selon votre système d'exploitation.

\subsection{Installation de xcas avec Windows}
Sur un PC avec Windows, r\'ecup\'erez le fichier~:\\
\verb|ftp://ftp-fourier.ujf-grenoble.fr/xcas/xcaszip.exe|\\
double-cliquez sur ce fichier, le programme d'extraction
de l'archive {\tt xcas} se lance et vous propose de désarchiver {\tt xcas}
dans le répertoire de {\tt xcaszip.exe}, vous devriez ici remplacer 
ce répertoire par \verb|C:\| ce qui désarchivera {\tt xcas} dans le répertoire
\verb|C:\xcas| qui sera créé si nécessaire. Si vous désarchivez
{\tt xcas} dans un autre répertoire vous devrez modifier les fichiers
\verb|xcasfr.bat| et \verb|runxcas.fr| pour refléter les chemins
d'accès sur votre disque dur (voir ci-dessous).
Vous pouvez r\'ealiser une installation globale en ajoutant
le répertoire d'installation à la variable \verb|PATH| ou en désarchivant
{\tt xcas} dans un répertoire pointé par cette variable.
Dans ce cas, vous devrez modifier \verb|xcasfr.bat| et \verb|runxcas.fr|
en indiquant respectivement les variables d'environnement correctes,
par exemple si vous avez désarchivé {\tt xcas} sur le disque dur \verb|D:|
dans le répertoire {\tt Maths}\\
\verb|xcasfr.bat: set PATH=%PATH%;d:\Maths\xcas|\\
\verb|runxcas.fr: export XCAS_ROOT=/cygdrive/d/Maths/xcas|\\
Pour une installation en r\'eseau avec Altair ou Harp, choisissez \verb|j:|
comme disque d'installation (\verb|Extract to:|) et d\'eclarez 
\verb|j:\xcas\altair.bat| dans la base de donn\'ee de logiciels avec
comme r\'epertoire de d\'emarrage le r\'epertoire personnel \verb|p:|

Pour disposer de toutes les fonctionnalit\'es d'impression, 
il est conseill\'e d'installer une distribution
\LaTeX, cf. par exemple \verb|http://www.fptex.org/|.

L'aide en ligne HTML est affichée par défaut par Internet Explorer, vous
pouvez modifier le navigateur internet en ajoutant la commande
\verb|export BROWSER=nom_de_navigateur| dans le fichier
{\tt runxcas.fr}. Attention, sur certaines versions de Windows, l'affichage
automatique de l'aide HTML ne fonctionne pas, vous pouvez malgr\'e tout
ouvrir votre navigateur Internet et consulter la documentation qui se trouve 
par d\'efaut dans le r\'epertoire \verb|c:\xcas\doc|.

\subsection{Installation de xcas avec Mac OS X}
Récupérez le fichier~\\
\verb|ftp://ftp-fourier.ujf-grenoble.fr/xcas/xcas\_image.dmg.gz|\\
Le fichier devrait se d\'esarchiver automatiquement, puis l'image
disque se monter et un disque {\tt xcas} doit apparaitre sur
le bureau du Finder, si ce n'est pas le cas, double-cliquez
sur le fichier {\tt xcas\_image.dmg}. \`A pr\'esent, double-cliquez sur
l'icone disque {\tt xcas}. Pour lancer {\tt xcas}, double-cliquez sur 
le programme {\tt xcas} du disque {\tt xcas}.
L'aide en ligne en HTML n'est pas encore activ\'ee par d\'efaut,
(sauf si vous avez un navigateur nomm\'e mozilla qui se lance en ligne
de commande).

\subsection{Installation de xcas avec Linux}
\subsubsection{Si vous utilisez Gnu/Debian, Mandrake Linux ou RedHat Linux}
Vous pouvez récupérer et installer une archive debian ou RPM,
cf. lien sur la page home de {\tt xcas}\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html|\\
Si vous avez des probl\`emes pour r\'esoudre les d\'ependances lors
de l'installation du paquetage giac, r\'ef\'erez-vous \`a la section
suivante.

\subsubsection{Si vous avez le mot de passe de {\tt root}}
R\'ecup\'erez le fichier~:\\
\verb|ftp://ftp-fourier.ujf-grenoble.fr/xcas/xcas_root.tgz|\\
et sauvegardez ce fichier dans le r\'epertoire \verb|/tmp|.
Tapez ensuite dans une fen\^etre de 
commande\footnote{Parfois appel\'e ``xterm'' ou ``kterm'' ou ``shell'', 
une fen\^etre de commandes permet d'ex\'ecuter des commandes Unix telles 
que {\tt ls}, {\tt cd}, .... Sur de nombreuses installations Linux, il 
faudra d'abord lancer une fen\^etre de commandes. Par exemple 
avec l'environnement graphique KDE, s\'electionnez dans le menu K ex\'ecuter 
une commande, tapez l'un des noms de programme suivants
{\tt xterm } ou {\tt kterm} ou {\tt rxvt}
puis la touche {\tt Entree}.}~:\\
\verb|su|\\
puis votre mot de passe \verb|root|, puis la touche \verb|Entree|.
Tapez ensuite~:\\
\verb|cd /|\\
\verb|tar xvfz /tmp/xcas_root.tgz|\\
\verb|ldconfig|\\
\verb|exit|\\
Pour lancer le programme, tapez ensuite~:\\
\verb|xcas &|\\
Si le programme n'est pas trouv\'e, d\'elogguez-vous et relogguez-vous
et tapez \`a nouveau~: \verb|xcas &|. Si cela ne fonctionne toujours
pas, v\'erifiez que les fichiers suivants sont install\'es:
\begin{itemize}
\item \verb|xcas| dans le r\'epertoire \verb|/usr/local/bin|, 
\item \verb|aide_cas| dans \verb|/usr/local/share/giac|. 
\end{itemize}
Si ce n'est pas le cas, recommencez
l'installation, sinon rajoutez la ligne~:\\
{\tt export PATH = "\$PATH:/usr/local/bin/" } \\
dans le fichier \verb|/etc/profile| ou dans votre fichier \verb|~/.bashrc|.

\subsubsection{Si vous n'avez pas le mot de passe {\tt root}}
R\'ecup\'erez le fichier~:\\
\verb|ftp://ftp-fourier.ujf-grenoble.fr/xcas/xcas_user.tgz|\\
et sauvegardez ce fichier dans votre r\'epertoire courant.
Tapez ensuite dans une fen\^etre de commande~:\\
\verb|cd ~|\\
\verb|tar xvfz xcas_user.tgz|\\
Pour lancer le programme, tapez ensuite~:\\
\verb|./xcas &|

\subsubsection{Aide en ligne}
L'aide en ligne est affichée en utilisant le navigateur Internet
lu dans la variable d'environnement {\tt BROWSER} ou par
{\tt mozilla} si cette variable n'est pas déclarée. Pour changer
de navigateur, lancez xcas, cliquez sur le bouton rouge gen et
remplissez le champ Browser, testez (menu Aide->Tutoriel), 
puis sauvegardez les pr\'ef\'erences (menu Fich).
Vous pouvez aussi éditer votre fichier \verb|~/.bashrc|
ou le fichier global {\tt /etc/profile} et d'y ajouter la ligne~:\\
{\tt export BROWSER=konqueror}\\
(remplacez {\tt knoqueror} par le nom de votre navigateur habituel).
Si cela ne fonctionne pas à la prochaine connexion, cela signifie
probablement que vous utilisez {\tt tcsh}, changez alors votre
fichier \verb|~/.tcshrc| et ajoutez la ligne~:\\
{\tt setenv BROWSER konqueror}

Par exemple, sur une machine aux ressources limit\'ees,
vous pouvez utiliser le navigateur {\tt lynx} en mode texte,
en mettant comme navigateur {\tt xterm -e lynx}.

\subsubsection{Impression}
Pour disposer de toutes les fonctionnalit\'es d'impression, 
il est conseill\'e d'installer une distribution
\LaTeX. Si ce n'est pas fait, 
le plus simple est d'installer les paquetages \verb|tetex*| de votre
distribution~: tetex, tetex-latex, tetex-xdvi, tetex-dvips.

\subsubsection{Version en ligne de commande}
Elle se lance par la commande {\tt giac} ou {\tt ./giac}.
Elle peut s'utiliser de manière autonome, dans une session du logiciel
TeXmacs ({\tt http://www.texmacs.org}) ou dans {\tt mupacs}.

\section{Mise à jour de {\tt xcas} (Windows et Linux)}
Pour mettre à jour {\tt xcas}:
\begin{itemize}
\item Si vous utilisez Linux, Windows NT, windows 2000, windows XP 
vérifiez que vous avez les droits d'écriture
dans le répertoire d'installation de {\tt xcas} 
\item Si nécessaire, activez votre connexion Internet
\item Sous Windows, cliquez sur le fichier {\tt update.bat} du
r\'epertoire {\tt xcas}. Sous Linux, lancez {\tt xcas} puis choisissez 
dans le menu {\tt Fich->Mettre a jour xcas}
\end{itemize}

\section{Note pour les utilisateurs de Maple.}
{\tt giac/xcas} propose une compatibilité avec les fonctions Maple utiles
jusqu'au niveau licence de mathématiques environ. 
Pour l'activer, il suffit au premier
lancement de {\tt xcas} de cliquer sur {\tt Maple} lorsqu'on vous
demande {\tt Choose initial configuration}. Vous pouvez aussi
l'activer au cours d'une session par le menu \\
{\tt Edit->Préférences->Configuration cas}\\
en cliquant sur {\tt Prog style} et en choisissant {\tt Maple},
si n\'ecessaire 
d\'es\'electionnez la case Recompute hist et d\'es\'electionner
la case Pretty in,
puis valider le choix par {\tt OK}.

Pour charger une session Maple dans {\tt xcas}, 
allez dans le menu {\tt Fich->Import session->Maple worksheet} puis
s\'electionnez le nom du fichier.

Pour charger un programme \'ecrit en langage Maple,
utilisez le menu {\tt Fich->Import session->Maple text}
puis s\'electionnez le nom du fichier.

Il est fortement conseillé de lire la section \ref{sec:premier_pas}
(Premiers pas) ci-dessous, l'interface de {\tt xcas} étant
un peu différente de celle de Maple, en particulier~:
\begin{itemize}
\item les commandes sont numérotées, la commande
est alignée à gauche juste après son numéro,
et la réponse alignée à droite par défaut. 
\item l'entrée d'une nouvelle commande peut se faire directement
dans l'historique comme dans
maple (mode 1-d) ou dans l'historique en mode 2-d 
(selon la valeur de la case Pretty in dans le menu
Edit->Pr\'ef\'erences->Configuration g\'en\'erale),
ou en mode 1-d dans la ligne de commande 
(cf. la figure section \ref{sec:premier_pas}).
Si vous modifiez l'historique en mode 2-d, utilisez la touche fl\`eche
vers le haut pour valider le changement en cours et faire un changement
ailleurs, lorsque vous avez fait tous les changements souhait\'es
sur un niveau de l'historique, appuyez sur la touche Entree. 
Si la case Recompute hist du menu de configuration g\'en\'erale est coch\'ee,
Entree r\'eexe\'ecute la feuille de calcul
modifi\'ee \`a partir de la premi\`ere modification, sinon seul le niveau
actuel sera recalcul\'e (comme dans maple).
Attention, si vous faites de la g\'eom\'etrie interactive,
xcas passera automatiquement en mode pretty input et recompute history.
\item Pour modifier une commande de l'historique, 
vous pouvez aussi s\'electionner le
niveau souhait\'e et cliquer sur le bouton {\tt modif} pour modifier
dans la ligne de commande.
\item l'affichage par {\tt print} n'est pas fait dans l'historique
interactif mais dans l'historique io (input/output). Utilisez le
bouton {\tt io} ou {\tt ia} pour basculer du mode interactif au
mode io de l'historique ou de la g\'eom\'etrie.
L'historique n'affiche que la valeur de retour d'un programme 
(renvoyée par {\tt RETURN}). Ceci permet de bien distinguer valeur
de retour et affichage dans un programme.
\item le signe \% est reconnu, mais pas \%\% ou \%\%\%, utiliser
{\tt ans(-2)} ou {\tt ans(-3)} à la place.
\item Certaines commandes Maple ne sont pas encore impl\'ement\'ees,
ou ont un comportement un peu diff\'erent. 
D'autre part, certains identificateurs
sont des mots-clefs r\'eserv\'es de \verb|xcas| et ne peuvent \^etre
utilis\'es comme nom de variable (par exemple \verb|base|, \verb|list|, ...)
ni \^etre {\tt unprotect}-ed.
\end{itemize}
Si vous ne pensez pas utiliser le tableur ou la géométrie interactive,
vous pouvez aussi utiliser {\tt texmacs/giac} qui ressemble plus
\`a l'interface de Maple.

\section{Note pour les utilisateurs de TI89/TI92/TI Voyage 200.}
{\tt xcas} propose un mode de compatibilité avec les calculatrices
graphiques formelles de Texas Instrument. 
Pour l'activer, il suffit au premier
lancement de {\tt xcas} de cliquer sur {\tt TI89} lorsqu'on vous
demande {\tt Choose initial configuration}. Vous pouvez aussi
l'activer au cours d'une session par le menu \\
{\tt Edit->Préférences->Configuration cas}\\
en cliquant sur {\tt Prog style} et en choisissant {\tt TI89}
puis valider le choix par {\tt OK}.

Vous pouvez charger des programmes pour TI89/TI92 ou Voyage 200
au format archive groupe (noms de fichiers terminant
par {\tt .89g} ou {\tt .92g}), au format programme ou fonction
({\tt .89f}, {\tt .92f}, {\tt .89p}, {\tt .92p}), ou au format
texte.
Si vous recopiez un programme dans un livre, utilisez un éditeur
de texte (par exemple Wordpad, Blocnote, Ultraedit, emacs sous windows
ou emacs ou vi sous linux) et recopiez le texte tel quel y compris
les {\tt :} en début de ligne. Si le programme est dans votre
calculatrice, vous pouvez utiliser le logiciel GraphLink de Texas Instrument
pour le transférer vers votre ordinateur.
Allez alors dans le menu {\tt Fich->Executer fichier} et s\'electionnez
le nom du fichier.

Il est fortement conseillé de lire la section \ref{sec:premier_pas}
(Premiers pas) ci-dessous, l'interface de {\tt xcas} étant
un peu différente de celle des calculatrices TI, en particulier
pour les commandes graphiques.

\pagebreak

\section{Premiers pas et aide en ligne} \label{sec:premier_pas}
On suppose maintenant que {\tt xcas} est installé sur votre ordinateur.
Sous Unix, tapez dans une fenêtre de commandes~:\\
\verb|xcas &|\\
Sous Windows, utiliser l'explorateur pour aller dans le répertoire
où est installé {\tt xcas} puis cliquez sur le fichier {\tt xcasfr.bat}
(vous pouvez aussi créer un raccourci et le mettre sur le bureau).

Lors de votre première exécution de {\tt xcas}, on vous propose de
choisir une configuration initiale parmi Xcas, Maple ou TI89 (il
s'agit de la syntaxe pour le langage de programmation). Si vous
avez déja utilisé Maple ou la TI89 choisissez le mode correspondant.

Vous devez voir une fenêtre ressemblant à l'une des figures ci-dessous
(pour passer de l'une \`a l'autre,
il faut cliquer sur le bouton {\tt kbd},
le 3ème bouton en bas en partant de la droite)~:\\
\includegraphics[width=\textwidth]{xcas_tut0bis}\\
%\includegraphics[width=\textwidth]{xcas0.png}
\includegraphics[width=\textwidth]{xcas0}\\
La fenêtre est divisée de haut en bas en~:
\begin{itemize}
\item la barre de menu
\item selon le mode, l'éditeur d'équation (eqw), 
le graphique (geo), l'aide en ligne (help),
l'historique (hist), les messages (msg),
l'éditeur de programmes (prg),  le tableur (mtrw), ou
le débuggeur (Linux et Mac OS X). 
Plusieurs vues peuvent être affichées simultanément
(menu Edit->Fen\^etres->1/2/3 Fen\^etres).
\item la barre de boutons du mode (sauf pour les modes help et msg), 
avec \`a gauche un bouton sauver (pour les modes eqw, hist, prg, mtrw) 
pour pouvoir enregistrer rapidement
les modifications du mode en cours,
\item l'\'etat de sauvegarde de la session et du tableur
(qui peut \^etre remplac\'e par un bandeau dont la fonction est 
analogue au bandeau des calculatrices HP et Casio
\item une ligne de boutons jaunes qui permet de changer le mode 
(hist, eqw, mtrw, etc.)
\item la ligne de commande
\item la ligne d'état et les boutons pour changer l'état du logiciel
\item la ligne de message (le bouton msg permet de la voir en entier)
\item selon la configuration,
le clavier de calculatrice scientifique, les touches de direction
et le pavé numérique. 
\end{itemize}
Le déroulement normal d'une session consiste à entrer des commandes
dans la ligne de commande (ou directement dans l'historique), en s'aidant 
au besoin des menus, des éditeurs (d'équation,
de matrice, de programme) et de l'aide en ligne.

Par exemple, pour calculer {\tt 123*567} on tape dans 
la ligne de commande {\tt 123*567} 
puis la touche {\tt Enter} ou {\tt Entrée}. Ce mode de
saisie est semblable à celui des logiciels de calcul formel usuels
ou des calculatrices, voir la section \ref{sec:examples} pour quelques
exemples.

Les commandes du logiciel sont regroupées par thème dans la barre
de menu. Par exemple pour factoriser un entier,
on ouvre le menu {\tt Math}, sous-menu {\tt Entier}, item
{\tt ifactor}. Une courte aide en ligne apparait alors dans la
ligne de messages indiquant la syntaxe (cette commande attend un
argument entier) et la commande {\tt ifactor}
est saisie. On indique l'argument entre parenth\`eses puis on valide
par la touche {\tt Enter}.

Pour avoir des exemples sur une commande, on peut cliquer sur le bouton
jaune {\tt help}, ce qui fait apparaitre des champs de saisie pour chaque
argument, puis de gauche \`a droite, l'index global de toutes les 
commandes de {\tt xcas}, une liste
d'exemples pour la commande actuelle
(que l'on peut recopier dans les champs de saisie
en cliquant dessus, et que l'on peut ensuite modifier), et une liste
de commandes sur le même thème\\
%\includegraphics[width=\textwidth]{xcas1.png}
\includegraphics[width=\textwidth]{xcas1}\\
On peut rechercher un nom de commande dans le champ \verb|?|, si
la commande n'existe pas, des noms de commande approchant sont affich\'ees.
Si la commande existe, elle est alors s\'electionn\'ee (on peut alors
cliquer sur le bouton HTML pour faire apparaitre une documentation 
plus compl\`ete de cette commande).
Vous pouvez aussi rechercher dans l'aide HTML compl\`ete
en francais un mot-clef en utilisant le menu Aide->Rechercher.

L'éditeur d'équation ({\tt eqw}, pour EquationWriter, 
cf. section \ref{sec:eqw})
sert à saisir des expressions mathématiques
un peu compliquées en évitant d'avoir à saisir des parenthèses gr\^ace
à un affichage 2-d des expressions mathématiques. Ce mode de saisie
existe aussi dans l'historique. 

Le mode graphique ({\tt geo}, pour Geometry, cf. section \ref{sec:geo})
permet d'afficher des courbes dans le plan, et
de tracer des figures géométriques. Ce mode est interactif,
on peut cr\'eer de nouveaux points ou segments \`a la souris
ou faire bouger un point et observer comment les constructions
qui en d\'ependent se modifient.

Le tableur ({\tt mtrw}, pour MatrixWriter, cf. section \ref{sec:tableur})
est un tableur minimal comparé aux tableurs des suites bureautiques.
Mais c'est un tableur dont les cellules peuvent être des expressions
formelles et on peut utiliser le langage de programmation de {\tt xcas}
pour calculer le contenu d'une cellule. On peut aussi s'en servir pour avoir 
des tables de valeurs de fonctions ou de suites recurrentes (menu
{\tt Edit->mtrw->tablefunc} et {\tt ->tableseq}).
Il peut enfin faire office d'éditeur de 
matrice (on peut \'egalement utiliser l'éditeur d'équation 
si une matrice contient des expressions mathématiques complexes). 

Le mode programme ({\tt prg}, pour Program, cf.
section \ref{sec:prog})
est destiné à écrire des petits programmes avec le
langage de programmation de {\tt xcas}. Pour des programmes plus
conséquents, on préférera utiliser un éditeur comme {\tt emacs}
ou {\tt nedit} puis on importera les programmes 
dans une session {\tt xcas} avec la commande {\tt read} 
(ou menu Fich->Lire fichier).
Taper votre programme puis cliquez sur le bouton
{\tt tester} pour voir s'il est correct, si c'est le cas, cliquez
sur le bouton {\tt ->hist} pour le recopier dans l'historique.
Pour activer correctement la coloration syntaxique des mots clefs,
on commencera chaque ligne par un caractère espace au moins.

Sous Linux et Mac OS X, on peut exécuter un programme en pas-à-pas avec
le débuggeur (commande {\tt debug}), et regarder l'évolution des variables, 
ce qui permet de corriger des erreurs.

\section{La barre de menu}
Elle se divise en trois parties: 
\begin{itemize}
\item {\tt Fich} et {\tt Edit}, pour sauvegarder ou charger une session,
une feuille de calcul, imprimer, faire des op\'erations d'\'edition, ...
\item les commandes mathématiques ({\tt Math}: fonctions g\'en\'erales, 
{\tt Alg}: alg\`bre, polyn\^omes, alg\`ebre lin\'eaire, 
{\tt Calc}: integration,
d\'erivation, limites, d\'eveloppement en s\'eries, etc., {\tt Geo}:
g\'eom\'etrie dans le plan), les commandes
de gestion d'unités physique ({\tt Phys}), les commandes de programmation
({\tt Prg})
\item l'{\tt Aide}
\end{itemize} 
La sélection d'un sous-menu dans les commandes mathématiques a pour effet
d'afficher la commande correspondante dans la ligne de commande,
qu'il faut alors compléter par les arguments (en syntaxe
algébrique standard).
Les commandes du menu Phys ont le même effet, les unités
physiques s'écrivent sous la forme nombre réel, puis le signe \_, suivi
par les unités, en ajoutant des parenthèses s'il y a des produits
ou des quotients d'unités, par exemple \verb|1.5e3_(kg*s)|.

Le menu {\tt Fich} permet de sauvegarder et charger des données dans
les différents modes (historique, tableur, éditeur d'équation, programme).
On peut aussi imprimer l'historique, changer la langue de l'aide en
ligne, sauvegarder la configuration courante et mettre à jour
{\tt xcas} (à condition d'avoir une connexion Internet fonctionnelle).

Le menu {\tt Edit}~:
\begin{itemize}
\item Copier vers : permet de copier de ou vers la ligne de commande 
de l'historique
\item Effacer : au choix 
l'historique, toutes les variables à 1 lettre, la ligne de commande
(raccourci clavier Escape)
\item Copier : le contenu du presse-papier, 
\item Annuler : permet d'annuler les modifications faites
dans le mode hist
\item Fen\^etres : commande de changement de vue analogue aux boutons jaunes
du bandeau, ainsi que commandes de partage d'écran
\item Voir hist dans msg comme : écrit dans la fenêtre de message le niveau
actuel de l'historique en utilisant une syntaxe proche de Maple, MuPAD
TI89 ou xcas
\item Préférences : permet le réglage de la configuration par thème (cas, 
géométrie/graphique, général). \'Equivalents aux boutons rouges de la 
ligne d'état.
\item mtrw (Tableur): commandes d'édition spécifiques au tableur. \`A noter
les commandes {\tt tablefunc} et {\tt tableseq} qui permettent
de créer facilement le tableau de valeurs d'une fonction ou d'une suite
récurrente.
\item prg: commandes de recherche/remplacement de l'éditeur de
programmes.
\item Préférences: permet de changer la configuration
\end{itemize}


\section{Graphes de fonctions}
Les graphes de fonction s'affichent toujours dans l'\'ecran de g\'eom\'etrie
(cf. section \ref{sec:geo}). De plus les commandes de trac\'e
commencant par {\tt plot} (cf. le menu {\tt Maths->Graphes}) 
s'affichent directement dans l'historique. On peut changer les
param\`etres de visualisation des graphes de l'historique en
cliquant \`a proximit\'e imm\'ediate d'un bord du graphe (d\'eplacement),
en s\'electionnant une zone \`a zoomer \`a la souris ou en cliquant
dans la zone bleue d'affichage des coordonn\'ees de la souris (zoom out).
En cliquant sur la figure on fait apparaitre les coordonn\'ees du click
de la souris dans la zone bleue.

Lorsque vous donnez un nom \`a un graphe de fonction pour l'utiliser
ult\'erieurement, il n'apparait pas dans l'historique. Pour le faire
apparaitre, cliquez sur le bouton jaune geo, puis sur le bouton {\tt ->hist},
puis sur le bouton jaune hist.

\section{L'éditeur d'équation} \label{sec:eqw}
Pour lancer l'éditeur d'équation, cliquez sur le bouton jaune {\tt eqw}.
Vous pouvez aussi sélectionner une expression dans l'historique
et la copier dans l'\'editeur d'\'equation avec le bouton bleu {\tt ->eqw}.\\
%\includegraphics[width=\textwidth]{xcas2.png}
\includegraphics[width=\textwidth]{xcas2}

L'éditeur d'équation stocke l'objet à éditer sous forme d'un
graphe dont les noeuds sont les opérateurs et les feuilles
les arguments des opérateurs.
On peut éditer directement les arguments en cliquant à
l'endroit désiré, on effectue la modification et on valide en
tapant sur la touche flèche vers le haut ou en cliquant ailleurs
avec la souris. On peut aussi éditer une sous-expression
en la sélectionnant, ce qui la recopie en ligne de commande,
on modifie alors la ligne de commande et lorsqu'on tape la touche
Entree, la sélection est remplacée par la ligne de commande.
Notez que les flèches de direction permettent de modifier la
sélection en se déplaçant dans le graphe représentant l'équation.
On peut aussi~:
\begin{itemize} 
\item \'echanger la sélection vers la droite ou la gauche (boutons
de la barre de boutons) si
elle est l'argument d'une somme ou d'un produit, 
\item appliquer un opérateur à la sélection (par exemple
le bouton {\tt eval} permet d'évaluer une sous-expression en place,
{\tt simplify} pour simplifier la sélection,
{\tt factor} pour factoriser la sélection ou sur le même principe,
toutes les commandes de réécriture).
\item supprimer un opérateur unaire en cliquant sur
{\tt backspace}
\item lorsque le curseur est actif, l'appui sur la touche \verb|"| permet
de basculer d'une chaine de caractères à l'expression qu'elle représente.
\end{itemize}
Pour copier une sous-expression ailleurs, la sélectionner, cliquer
sur {\tt copier}, sélectionner l'endroit où la recopier et cliquer
sur {\tt coller/paste}.

Pour quitter l'éditeur d'équation, taper le bouton {\tt ->cmd} qui recopie 
toute l'expression en ligne de commande ou les boutons
shift (bouton {\tt abc} vert du clavier) puis {\tt ->cmd} 
ce qui ne recopie que la sélection.

Exemple~: entrer dans l'éditeur d'équation, tapez \verb|x| puis flèche
vers le haut, puis la touche \verb|^|, puis \verb|100|, puis flèche vers
le haut, puis à nouveau flèche vers le haut pour sélectionner
toute l'expression $x^{100}$, puis la touche \verb|-| puis 1, puis
flèche vers le haut deux fois pour sélectionner $x^{100}-1$
(remarque~: il est aussi possible d'entrer directement \verb|x^{100}-1|
puis flèche vers le haut, mais le mode décrit précédemment permet
de saisir des expressions plus complexes sans jamais devoir utiliser
des parenthèses).
Sélectionnez {\tt factor} dans le menu {\tt Cas}, puis
flèche vers le bas, flèche à droite, etc. pour déplacer la sélection.
Sélectionnez $x^2+1$ au curseur ou à la souris, appuyez sur la touche \verb|^|
puis \verb|2| puis la touche flèche vers le haut deux fois.

Remarque~: on peut éditer l'historique de la même façon que
dans l'éditeur d'équation. L'appui sur la touche Entree (ou Enter) valide
alors tous les changements effectués et recalcule l'historique
à partir de la première modification effectuée. L'appui sur la
touche Echap (ou Esc) annule tous les changements effectués.

\section{La géométrie} \label{sec:geo}
Pour faire de la g\'eom\'etrie dans le plan, il faut cliquer 
sur le bouton jaune {\tt geo} (attention ce mode est exclusif
du mode tortue logo d\'ecrit dans la section \ref{sec:logo}).
Les constructions de g\'eom\'etrie dans 
l'espace apparaissent par contre dans une autre fen\^etre 
(la visualisation est faite par le logiciel gnuplot)\\
%\includegraphics[width=\textwidth]{xcas3.png}
\includegraphics[width=\textwidth]{xcas3}\\
Dans le mode {\tt geo}, 
on peut interagir avec l'historique de manière graphique.
On peut aussi faire varier des paramètres scalaires définis par la commande
{\tt element} (ici {\tt a:=element(1..2)})
et observer de manière interactive comment varient les
objets graphiques qui dépendent de ces paramètres.
On peut facilement zoomer sur une partie de l'\'ecran graphique.

\subsection{Construction géométrique dans le plan}
Lorsqu'on déplace la souris, la position du curseur dans le
système de coordonnées est mise à jour dans
le coin supérieur droit. On peut red\'efinir le système de coordonnées en
cliquant sur le bouton rouge {\tt geo} de la ligne d'état.

Un click de souris permet de tracer un point. On peut aussi tracer
un segment en enfonçant un bouton de la souris à une extrémité et en
le relachant à l'autre extrémité. On peut déplacer un point existant
(et toutes les constructions géométriques qui en dépendent) en cliquant
sur un objet géométrique pour le sélectionner puis en enfonçant un
bouton de la souris sur cet objet et en déplaçant la souris bouton
enfoncé. Relâcher la souris lorsque la nouvelle position de l'objet
est atteinte. Pour annuler un mouvement relâcher le bouton de la souris
au-dehors de la zone d'affichage géométrique.

Exemple 1~:\\
Enfoncez un bouton de la souris, d\'eplacez la souris et
relachez la souris, vous avez trac\'e un segment: le syst\`eme
nomme automatiquement les deux extr\'emit\'es et le segment et
affiche le segment ainsi que les noms des points (en principe $A$, $B$).
Recommencez \`a partir d'une des extr\'emit\'es $A$ ou $B$, le syst\`eme
reconnait que l'origine est $A$ ou $B$. Il est donc assez simple
de tracer un triangle \`a la souris (en principe votre triangle
\`a pour sommets $A$, $B$ et $C$ et pour c\^ot\'es $AB$, $BC$ et $CA$).
Cliquez sur $A$ puis d\'eplacez $A$ avec la souris (enfoncez le bouton
de la souris en $A$ et d\'eplacez la souris), vous verrez 
bouger les segments $AB$ et $CA$.

Les autres constructions se font en tapant des commandes, \`a l'aide
du menu ou du bandeau de g\'eom\'etrie (\verb|Geo|).

Exemple 2~:\\
Pour tracer le cercle de centre $A$ et de rayon 2, saisissez
dans le menu {\tt Geo->Cercles} la fonction {\tt cercle} et passez
en argument {\tt A,2}, puis validez.

Exemple 3~:\\
Tra\c{c}ons le triangle ABC avec la souris puis le
cercle circonscrit \`a $ABC$ sans utiliser la commande
\verb|circonscrit|~:
\begin{itemize}
\item tapez \verb|D:=|, puis dans le menu \verb|Geo|, sous-menu \verb|Lignes|
s\'electionnez alors \verb|mediatrice| puis tapez \verb|AB| (ou \verb|A,B|)~:\\
\verb|D:=mediatrice(AB)|\\
tapez \verb|Enter| ce qui trace la m\'ediatrice de $[AB]$ et la nomme $D0$
(attention en mode Maple, on ne peut pas utiliser la lettre $D$ seule, car 
{\tt D} est un mot
clef réservé pour la dérivée en tant qu'opérateur, remplacez {\tt D} par
exemple par {\tt D0})
\item de m\^eme pour $E$ m\'ediatrice de $[BC]$:\\
\verb|E:=mediatrice(BC)|
\item cliquez \`a l'intersection des deux m\'ediatrices: en principe
le syst\`eme d\'etecte votre intention et d\'efinit le point $F$~: 
en cliquant sur la touche jaune
\verb|hist| vous devez voir dans l'historique~:\\
\verb|F:= head(D intersect E)|\\
revenez alors dans l'\'ecran graphique en cliquant 
sur la touche jaune \verb|geo|. Notez que l'intersection de 2 objets 
g\'eom\'etriques est un ensemble ici constitu\'e d'un seul point, 
la commande \verb|head| renvoie le premier (ici unique) point de l'intersection
et stocke le r\'esultat dans $F$
\item tapez alors~:\\
\verb|G:=cercle(F,A-F)|\\
la commande \verb|cercle|
trace un cercle \'etant donn\'e par deux points (son diam\`etre)
ou donné par son centre (\verb|F|) et son rayon (\verb|A-F|).
\end{itemize} 
Vous pouvez \`a nouveau tester l'aspect g\'eom\'etrie dynamique en
faisant bouger le point $A$ (note: un Pentium 166 est capable de 
recalculer plus de 20 fois par seconde cette construction, mais on verra
moins de 20 images par seconde \`a cause du temps d'affichage).

\subsection{Les param\`etres.}  \label{sec:quad_explorer}
En mode géométrie/graphique, la fen\^etre est d\'ecompos\'ee en deux
parties: sur presque toute la fen\^etre on affiche des objets 
g\'eom\'etriques, dans une colonne \`a droite, on voit en haut
\verb|x:| et \verb|y:| suivis
des coordonn\'ees courantes de la souris (remarque~: il se peut
que les valeurs affich\'ees apr\`es \verb|x| et \verb|y| ne soient pas
correctes, parce que \verb|xcas| n'a pas pu localiser la souris
par exemple \`a la suite d'un changement de taille de la fen\^etre,
cliquez alors sur le bouton jaune \verb|geo|
pour resynchroniser \verb|xcas|).

Le reste de cette colonne \`a droite de la fen\^etre graphique sert
\`a afficher des param\`etres et \`a faire varier leur valeur
dans un intervalle. Par exemple, effectuez les commandes suivantes~:\\
\verb|a:=element(-2..2,1)|\\
\verb|b:=element(-3..3)|\\
\verb|c:=element(-1..1)|\\
\verb|plotfunc(a*x^2+b*x+c)|\\
(\verb|element| se trouve dans le menu \verb|Geo|).
Vous pouvez maintenant faire varier \verb|a|, \verb|b| et \verb|c| \`a
la souris et observer la modification de la parabole d'\'equation
$y=ax^2+bx+c$ en temps r\'eel (avec une r\'esolution horizontale de 300 pixels
on peut calculer une vingtaine d'images par seconde sur un pentium 166).

\subsection{Réglage de la fenêtre graphique} \label{sec:config_graph}
On peut zoomer ou déplacer la fenêtre graphique à l'aide des
boutons de la barre de boutons. On peut aussi zoomer de manière
interactive: on clique d'abord sur le bouton {\tt io} pour passer
en mode io. Lorsqu'on clique
sur ce bouton, les coordonn\'ees de la souris apparaissent sur
fond vert\footnote{Ce mode est en r\'ealit\'e un mode de compatibilit\'e
TI89/92, il permet de faire des sorties graphiques non interactives
dans un programme}, 
on peut alors s\'electionner un rectangle \`a la souris
pour zoomer sur cette zone.

Enfin, on peut régler la fenêtre graphique en utilisant le bouton
rouge {\tt geo} de configuration graphique.\\
%\includegraphics[width=\textwidth]{xcas8.png}
\includegraphics[width=\textwidth]{xcas8} 

\subsection{La géométrie dans l'espace} \label{sec:geo3d}
Les commandes de g\'eom\'etrie dans l'espace doivent \^etre saisies
dans la ligne de commande, par exemple {\tt P:=plan(x=y+z)},
de mani\`ere analogue aux commandes de g\'eom\'etrie du plan, mais
on ne peut pas faire bouger les points dans l'espace comme dans le
plan et voir la figure se modifier, sauf en utilisant des param\`etres
(il faut alors prendre soin de commencer par l'instruction {\tt erase3d()}
avant de d\'eclarer des param\`etres).

\subsection{La tortue logo} \label{sec:logo}
En s\'electionnant bonjour dans le menu 
{\tt Scolaire->Tortue->bonjour et au revoir}, l'\'ecran de
g\'eom\'etrie dans le plan est remplac\'e par un \'ecran graphique
o\`u l'on peut guider un robot muni d'un crayon pour dessiner des
figures, d'une mani\`ere analogue au langage Logo.
Pour revenir au mode g\'eom\'etrie dans le plan, utiliser {\tt au revoir}
du m\^eme menu.

\section{Le tableur} \label{sec:tableur}
Cliquer sur le bouton jaune {\tt mtrw} du bandeau.\\
%\includegraphics[width=\textwidth]{xcas4.png}
\includegraphics[width=\textwidth]{xcas4}

{\tt mtrw} est par d\'efaut en mode tableur, on peut basculer du mode
tableur au mode matrice en cliquant \`a nouveau sur {\tt mtrw}. 

Pour sauvegarder ou charger un tableur, utiliser le menu {\tt Fich->mtrw io}
ou le bouton {\tt sauver}.
Remarques~: 
\begin{itemize}
\item la premi\`ere fois que vous cliquez sur le bouton {\tt sauver}, 
un nom de fichier vous sera demand\'e,
ce nom sera utilis\'e pour les sauvegardes ult\'erieures.
\item en mode matrice, seules les valeurs seront sauvegard\'ees. En mode
tableur, les formules et les valeurs sont sauvegard\'ees.
\item la sauvegarde d'une session de calcul dans l'historique est
ind\'ependante de la sauvegarde du tableur.
\end{itemize}

La syntaxe de remplissage d'une cellule en fonction d'autres cellules
est similaire à celle des tableurs usuels. On utilise des lettres
pour repérer la colonne, des nombres pour la ligne, le signe \$ devant
le nom d'une colonne ou d'une ligne désigne une référence absolue 
pour les opérations de recopie d'une cellule, le signe {\tt =} en
début d'expression indique une formule de tableur. Par exemple,
si on met dans la cellule A3 {\tt =\$A\$1+A2},
(additionne un pas plac\'e dans la cellule fixe A1 \`a la cellule mobile A2),
on peut ensuite recopier vers le bas la cellule A3 (en utilisant
le menu {\tt remplir->remplir vers le bas}) et on obtient
une suite de r\'eels espac\'es du pas plac\'e en A1.
Pour faire référence à une plage de cellule, on écrit la cellule en haut
à gauche, le signe {\tt :} et la cellule en bas à droite, par
exemple {\tt =mean(A1:B4)} désigne la moyenne des cellules
lignes 1 à 4, colonnes A et B.

Le tableur permet aussi d'obtenir des tableaux de valeurs
de fonction ou de suites récurrentes facilement (instructions
{\tt tablefunc} et {\tt tableseq} du menu {\tt Edit->mtrw}). Ces instructions
remplissent la colonne courante ou la colonne courante et la colonne
suivante.

On peut aussi sélectionner à la souris une sous-matrice et la 
coller par exemple dans l'historique (avec le bouton {\tt coller}). Pour
copier le contenu d'une seule cellule, il faut utiliser le bouton 
{\tt copier} avant le bouton {\tt coller}
car il n'est pas possible de s\'electionner directement
\`a la souris une seule case du tableur.

Le bouton {\tt recalc} permet de recalculer le tableur (pour de
grands tableurs, il est conseill\'e de d\'ecocher Recalculer dans le menu
de configuration g\'en\'eral et recalculer \`a la demande). Pendant
le calcul du tableur, on peut interrompre
un calcul trop long en cliquant sur le bouton rouge Stop.

La case de s\'election peut servir \`a se d\'eplacer dans le tableur
en indiquant une cellule cible, si cette cellule n'existe pas,
le tableur est agrandi en cons\'equence. Cette zone sert
aussi \`a extraire une sous-matrice en indiquant des lignes consécutives et des
colonnes dans la case de s\'election de la barre de boutons
(par exemple {\tt B3:B7,D,E}). On peut appliquer des op\'erations
\`a la sous-matrice s\'electionn\'ee (par exemple de statistiques
ou de tri).

\section{Les scripts}
Il est souvent interessant de pouvoir exécuter plusieurs
fois une même suite de commandes. Par exemple, pour générer une figure
géométrique ou pour affecter certaines variables ou pour expliquer
un calcul par étapes. On peut bien sur exécuter un fichier qui contient ces
commandes, toutes les commandes sont alors exécutées en une étape. 
On peut aussi exécuter ces commandes l'une après l'autre
en exécutant un script~: menu {\tt File->Charger script dans eqw}. Ceci
va activer le partage d'écran et charger le script dans l'éditeur
d'équations, il suffit alors de cliquer sur le bouton {\tt exec}
pour exécuter la ligne sélectionnée et passer à la ligne suivante.

\section{Le mode programme} \label{sec:prog}
Dans ce mode, activé par un click sur le bouton jaune {\tt prg} du
bandeau, on accède à un éditeur simple
qui permet d'écrire plusieurs lignes de texte constituant
un petit programme. Pour des programmes de taille importante il est
conseillé d'utiliser un éditeur de texte en association avec
la commande {\tt read} de {\tt xcas}. \\
%\includegraphics[width=\textwidth]{xcas5.png}
\includegraphics[width=\textwidth]{xcas5}

Une ligne de boutons permet de saisir efficacement les formes syntaxiques
(groupe d'instruction \verb|{}|, fin d'instruction \verb|;|, saut de
ligne, test \verb|if|, boucle \verb|for|, sortie de fonction \verb|return|).
Le bouton \verb|tester| vous permet de vérifier que le programme
actuel est syntaxiquement correct.
Le bouton \verb|->hist| sauve votre programme, quitte le mode programme, 
et ex\'ecute dans l'historique la commande {\tt read} qui permet
de charger le programme dans l'historique. Si vous avez d\'ej\`a 
ex\'ecut\'e la commande {\tt read} de chargement de votre programme,
dans l'historique,
{\tt xcas} effectue alors un remplacement de ce niveau de l'historique
(les niveaux suivants de l'historique sont éventuellement modifiés).

Par défaut (en style de programmation {\tt xcas}), 
la syntaxe de programmation est proche de celle du langage C.
Les principales différences sont~:
\begin{itemize}
\item les variables sont non typées,
les variables sont par défaut globales sauf si elles sont déclarées
locales par {\tt local } en début de définition d'une fonction. 
\item l'affectation se fait par {\tt :=} 
\item une fonction se déclare par la syntaxe\\
\verb|f(x,y):={ local z; instructions; }|. 
\end{itemize}

Attention aux priorités respectives de {\tt :=} et {\tt ,} qui nécéssitent
l'usage de parenthèses si vous affectez lors de la déclaration des variables
locales~:\\  
\verb|f(x,y):={ local (z:=0),v,w; ... }|. 

On peut aussi choisir dans l'écran de configuration général d'utiliser
une syntaxe similaire à celle de Maple, MuPAD ou d'une TI89/92. Ceci
affecte alors tout le logiciel, par exemple $\sqrt{-1}=I$ en mode 
Maple/MuPAD et $\sqrt{-1}=i$ en mode xcas.

L'instruction \verb|debug| 
avec comme argument l'appel à une fonction
à mettre au point permet d'exécuter un programme en pas-à-pas, de
voir et de modifier des variables, de placer des points d'arrêt.
Par exemple, chargez le fichier \verb|bezout| du répertoire
{\tt examples/arit} et exécutez \verb|debug(pgcd(15,25))|.
Attention, cette fonctionnalité n'est pas disponible sous Windows.


\section{Imprimer, générer des fichiers {\tt tex}.}
L'historique de {\tt xcas} peut être imprimé si on dispose d'une
installation \LaTeX\ standard. Pour imprimer l'écran graphique\footnote{Ceci 
ne concerne pas les commandes de tracé de graphe qui commencent par {\tt plot}
car ils insèrent automatiquement une sortie graphique}
il faut utiliser la commande {\tt graph2tex()} (ou {\tt graph3d2tex()}
pour imprimer une figure 3-d). Pour imprimer le tableur, il faut
recopier le tableau dans l'historique 
(menu {\tt Edit->Copier vers->mtrw2hist} puis validez la ligne
de commande). 

L'option de prévisualisation du menu {\tt Fich->Imprimer}
génère un fichier d'extension {\tt .tex} du nom de la session choisie,
ce fichier est autonome, on peut en insérer des extraits dans un autre 
fichier {\tt tex}. Lorsqu'on quitte {\tt xcas}, le fichier \\
{\tt nom\_de\_session.tex} contient la traduction \LaTeX\ de l'historique.
Par d\'efaut, la sauvegarde se fait dans le fichier {\tt session.tex}.

\section{Configuration}
On peut changer la configuration du logiciel en cliquant sur l'un des
3 boutons de la ligne d'état, ou depuis le menu {\tt Edit->Préférences}.
L'écran de configuration graphique a été présenté dans la section
\ref{sec:config_graph}, on obtient pour la configuration du calcul formel\\
%\includegraphics[width=\textwidth]{xcas6.png}
\includegraphics[width=\textwidth]{xcas6} \\
et pour la configuration générale\\
%\includegraphics[width=\textwidth]{xcas7.png}
\includegraphics[width=\textwidth]{xcas7} 

On peut aussi changer la configuration par des commandes comme\\
{\tt epsilon:=1e-10}\\
(cf. le guide du calcul formel).
On peut sauvegarder la configuration courante dans le menu File. La
configuration se trouve dans le fichier \verb|~/.xcasrc| (ou \verb|xcas.rc|
sous Windows) et est chargée au lancement de \verb|xcas|.

Remarque~:\\
Certaines variables d'environement ont une influence sur xcas, par
exemple le langage utilisé, ou l'affichage d'information de mise au
point, on peut les modifier soit dans une fenêtre de commande avant
d'appeler xcas (avec la commande export pour bash ou setenv pour
tcsh, pour plus de détails cf. la section sur le changement
de navigateur pour l'aide), soit en modifiant le fichier de lancement de xcas 
({\tt runxcas.fr} sous Windows).
Voici la liste de ces variables~:
\begin{itemize}
\item {\tt BROWSER}: (giac et xcas), nom du navigateur internet à
  utiliser pour l'aide en ligne
\item {\tt LANG} ou {\tt LANGUAGE}: langue utilisée pour les menus
\item \verb|PARI_SIZE|: taille du buffer mémoire alloué à PARI-GP
(utilisé en interne par giac et xcas par exemple pour la factorisation 
d'entiers)
\item \verb|XCAS_HELP|: (giac et xcas) répertoire racine pour l'aide en ligne
\item \verb|XCAS_TMP|: (xcas) répertoire des fichiers temporaires
\item \verb|XCAS_LOCALE|: (xcas) répertoire des fichiers de
  localisation (traduction en français des menus)
\item \verb|XCAS_RPN|: (xcas) permet de basculer directement xcas en
  mode RPN
\item \verb|XCAS_ROOT|: (xcas) répertoire racine de xcas et des
  fichiers d'aide et de localisation
\item \verb|GIAC_DEBUG|: (giac et xcas) affiche des informations de
mise au point
\item \verb|GIAC_MAPLEMODE|: (giac et xcas) bascule giac ou xcas en
\verb|maple_mode| correspondant à la valeur de la variable.
\item \verb|GIAC_TIME|: (giac) affiche ou non le temps d'exéution d'une
  commande 
\item \verb|GIAC_TEX|: (giac) crée un fichier tex pour les réponses de
  la session giac.
\item \verb|GIAC_SHOWCOMMAND|: (giac) affiche la commande tapée avant
le résultat
\end{itemize}

\pagebreak

\section{Quelques commandes.} \label{sec:examples}
La plupart des commandes ont une syntaxe identique pour Maple, MuPAD et xcas,
certaines sont malheureusement différentes. {\tt xcas} est dans une 
certaine mesure capable de traduire la {\em grammaire\/} des 3 systèmes
mais pas forcément toutes les instructions. Dans les commandes données
ci-dessous, on a favorisé l'utilisation de noms de commandes communs
à Maple, MuPAD et xcas même si sur un système donné il existe parfois une
syntaxe plus simple. 

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

\subsection{Commandes scalaires} \label{sec:scalaires}
Lorsqu'il n'existe pas de nom de commande commun 
aux 3 systèmes, on a indiqué les 3 noms de commande dans l'ordre 
{\bf MuPAD/Maple/xcas}.
Dans ces exemples, {\tt f} désigne une expression (par exemple
\verb|f:=x^2-1;|), \`a ne pas confondre avec une fonction
(\verb|f:=x->x^2-1|).

\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)}/ {\tt Digits:=k; evalf(f);}/ les 2
(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$), 
\item {\tt factor(f)} (factorise $f$ vu comme un polyn\^ome),
\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$),
\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 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 reset}/{\tt restart}/{\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 simplify(f)} (essaie de simplifier $f$),
\item {\tt solve(f=0,x)} (cherche les solutions en $x$ de $f(x)=0$), 
\item MuPAD: {\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,y)}\\
(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)} / syntaxe pr\'ec\'edente
selon le mode ou {\tt subst(f,x=a)}~:
(remplace $x$ par $a$ dans $f$), 
\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 \lq\lq package'' linalg (alg\`ebre lin\'eaire)
par {\tt export(linalg)} (MuPAD) ou {\tt with(linalg);} (Maple).

Lorsqu'il n'existe pas de nom de commande commun aux 3 systèmes, 
on a indiqué les 3 noms de commande dans l'ordre {\bf MuPAD/Maple/xcas}
\begin{itemize}
\item {\tt A[j,k]}: accède à l'élément ligne $j$ et colonne $k$ de
la matrice $A$. xcas accepte aussi la notation C {\tt A[j][k]}
\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 
caract\'eristique))
\item {\tt det(A)}\\ (d\'eterminant d'une matrice $A$),
\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 A=B}/{\tt equal(A,B)}/les 2: teste l'égalité de 2 matrices
\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)}\\
\verb|Dom::Matrix()([[5,4],[6,3]])|/{\tt matrix([[5,4],[6,3]])}/\\
{\tt [[5,4],[6,3]]}, \\
\item {\tt ncols(A)}/{\tt coldim(A)}/les 2\\
nombre de colonnes
\item {\tt nrows(A)}/{\tt rowdim(A)}/les 2\\ 
nombre de lignes
\item {\tt scalarProduct(A,B)}/{\tt dotprod(A,B)}/les 2 ou {\tt *}\\ 
(produit scalaire des deux vecteurs $A$ et $B$),
\item {\tt trace}/{\tt tr}/{\tt trace}: trace d'une matrice
\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]])}\\
\verb|Dom::Matrix()([1,2,3])|/{\tt vector([1,2,3])}/{\tt [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{Conteneurs}
C'est un type d'objet qui peut contenir d'autres objets: les principaux
conteneurs sont les listes, les séquences, les ensembles, les vecteurs
et les matrices (on utilise aussi les tableaux associatifs, c'est-à-dire
des tableaux indiciés par n'importe quelle valeur et pas forcément
par des entiers). 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 suites et \{ \} pour les ensembles 
(attention en mode {\tt xcas}, {\tt 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]| (attention, {\tt xcas}
utilise l'indexage commençant en 0 en mode {\tt xcas}, comme en C/C++). Pour
un élément de matrice, on écrit \verb|m[j,k]|.

Quelques instructions:
\begin{itemize}
\item \verb|nops(m)| (ou \verb|size(m)| avec {\tt xcas})~: la taille
\item \verb|op(l)|~: transforme la liste en suite
\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 {\tt convert} (Maple, xcas) ou {\tt coerce} (MuPAD) permettent
de convertir un conteneur d'un type en un conteneur d'un autre type.
\item {\tt subsop}~: permet de remplacer un indice dans une liste
par une valeur, on peut utiliser la valeur {\tt NULL} si on veut 
supprimer l'élément ayant cet indice.
\end{itemize}


\subsection{Programmation.} \label{sec:controle}
Les programmes sont des fichiers texte qui sont lus pendant une session
par la commande \verb|read| avec comme argument le nom du fichier
texte entre guillements. Par convention, on utilisera un nom se terminant
par \verb|.mu| pour un programme MuPAD, \verb|.map| pour un programme
Maple\footnote{Attention, les fichiers de type session Maple {\tt .mws}
sont différents des fichiers programme Maple, {\tt xcas} permet
d'effectuer la conversion {\tt .mws} vers {\tt .map} par {\tt read}},
et \verb|.cxx| pour xcas.
Par exemple \verb|essai.mu| pour un programme \verb|MuPAD|.

Voici sur quelques exemples les principales instructions de contrôle. Notez
que \verb|xcas| accepte aussi la syntaxe Maple ou MuPAD ou TI89/92
\footnote{attention
toutefois en mode xcas, les tableaux commencent à l'indice 0 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)\\
\verb|:f(x) :Func :Local n :2 => n :Return n*x :EndFunc| (TI89)
\item faire un test: \\
\verb|if x2>x1 then m:=x2; else m:=x1; end_if;| (MuPAD)\\
\verb|if x2>x1 then m:=x2; else m:=x1; fi;| (Maple)\\
\verb|if (x2>x1) { m:=x2; } else { m:=x1; }| (xcas)\\
\verb|:If x2>x1 Then: x2 => m :Else : x1 => m :EndIf| (TI89)
\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)\\
\verb|:While x=0 :x-1 => x :EndWhile| (TI89)
\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)\\
\verb|:For j,1,15 :j+x => x :EndFor| (TI89)
\item {\tt break} permet de sortir d'une boucle, {\tt continue} passe
immédiatement à l'itération suivante.
\end{itemize}

\subsection{Exercices}
{\bf Utilisation interactive}
\begin{enumerate}
\item D\'eterminer la liste des diviseurs de 45768. \\
Factoriser 100!
\item D\'evelopper $(x+3)^7 \times (x-5)^6$.
\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 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 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,
\quad \int_0^x \frac{t}{\sqrt{1-t}} \ dt \]

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

\vspace{0.2cm}

{\bf Programmation de la m\'ethode de Horner}. 
\begin{enumerate}
\item
\'Ecrire un fonction évaluant un polynôme en un point,
on représente le polyn\^ome sous forme de la
liste de ces coefficients.

\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

\section{Installation de la librairie giac sous Linux}
Les programmeurs qui souhaitent utiliser les fonctionnalités
de calcul formel dans du code C++, doivent installer la librairie
compil\'ee et les fichiers en-t\^ete. 
La licence d'utilisation est la GPL 2.0 ou ultérieure (si vous diffusez
du code lié à {\tt giac}, ce code doit donc être diffusé sous license GPL).

Sous Linux, le plus simple
est d'installer un paquetage rpm ou debian selon votre distribution.
Vous pouvez aussi compiler le code source de la librairie
{\tt giac} qui est disponible à l'adresse~:\\
{\tt ftp://ftp-fourier.ujf-grenoble.fr/xcas/giac.tgz}\\
Avant de configurer {\tt giac}, vous devrez d'abord compiler et
installer des librairies telle que FLTK, FLVW, GSL, etc. 
Vous pouvez récupérer des librairies statiques précompilées pour gcc 2.95
et les fichiers en-tête correspondants à l'adresse suivante:
\verb|ftp://ftp-fourier.ujf-grenoble.fr/xcas/devel/|\\
Par exemple pour les installer sous Linux, logguez-vous en 
utilisateur \verb|root|
désarchivez le fichier \verb|libs295.tgz| 
depuis le répertoire \verb|/usr/local|,
ajoutez si n\'ecessaire dans votre fichier \verb|/etc/ld.so.conf| la ligne~:\\ 
\verb|/usr/local/lib|\\
puis tapez \verb|ldconfig|.

D\'ecompressez maintenant l'archive contentant {\tt giac}~:\\
\verb|tar xvfz giac.tgz|\\
\verb|cd giac-0.3.0|\\
compilez-le~:\\
\verb|./configure|\\
\verb|make|\\
et enfin installez-le~:\\
\verb|su|\\
tapez le mot de passe de \verb|root|, puis la touche \verb|Entree| puis~:\\
\verb|make install|\\
puis~:\\
\verb|exit|\\
pour revenir \`a la session normale
(vous pouvez lire les fichiers \verb|README| et \verb|INSTALL| pour plus
de d\'etails et changer la configuration par d\'efaut).

Remarque~: vous pouvez installer giac sous Windows de la même manière
avec le compilateur {\tt gcc} sous Windows \verb|cygwin|. Installez
\verb|cygwin| puis GMP, GSL, FLTK, FLVW puis Giac comme sous Unix (sauf
pour FLTK qui a une procédure d'installation spécifique décrite
dans son source).


\section{Programmation en C++ avec giac}
L'ensemble des fonctions et des types de {\tt giac} sont placés dans
l'espace de nom {\tt giac}. Un source C++ utilisant {\tt giac}
devra donc précéder les identificateurs et fonctions de \verb|giac::|
ou devra exporter l'espace de noms {\tt giac} par la ligne de source\\
{\tt using namespace giac;}.

\subsection{Le type {\tt gen}}
La librairie {\tt giac} utilise un type générique {\tt gen} pour représenter 
les différents types (entiers, réels, vecteurs, matrices, polynômes, etc.). 
{\tt gen} est un type {\tt struct}uré, composé d'un champ {\tt type}, dont la 
valeur détermine le type de l'objet, d'un champ {\tt subtype} qui permet
de distinguer par exemple un vecteur d'une matrice ou d'une liste lorsqu'ils
utilisent la même représentation interne (un {\tt vecteur}, c'est-à-dire
un \verb|std::vector<gen>| ici),
et d'un champ union anonyme pour la valeur de l'objet (ou un pointeur).
Les {\tt double} et les petits entiers sont représentés par des objets
immédiats, les autres types par des pointeurs sur des objets alloués 
dynamiquement (avec un compteur de référence). Pour accéder à la représentation
interne, on commence par tester que le type du {\tt gen} considéré est
bien le type prévu, puis on copie l'objet pointé. 

Exemple~:\\
{\tt gen g("[1,2]");}\\
déclare une variable {\tt g} de type {\tt gen} qui sera compilé comme
une ligne de commande contenant \verb|[1,2]|, donc {\tt g}
contiendra le vecteur {\tt [1,2]}. 
On a alors {\tt g.type==\_VECT}, et le vecteur
sous-jacent est {\tt vecteur v(*g.\_VECTptr);} (copie du vecteur)
ou {\tt vecteur \& v = *g.\_VECTptr;} (référence sans copie).
On a alors {\tt v.size()==2} et {\tt v[0]==gen(1)} et {\tt v[1]==gen(2)}.

Les noms de variables sont de type 
{\tt identificateur *g.\_IDNTptr} (si {\tt g.type==\_IDNT}). Ce type
structuré comporte un nom et peut avoir une valeur (ou une hypothèse assume)
locale ou globale. Les identificateurs de noms {\tt a} à {\tt z} sont 
prédéfinis.

Un objet symbolique est de type {\tt symbolic *g.\_SYMBptr}.
Ce type est composé d'un {\tt sommet} (de type {\tt unary\_function\_ptr})
qui est la fonction au sommet du graphe représentant l'objet symbolique
et d'une {\tt feuille} qui est l'argument de la fonction, s'il s'agit
d'une fonction non unaire, les arguments sont regroupés en un vecteur.
Les fonctions usuelles sont prédéfinies dans le système et ont comme
valeur {\tt at\_} suivi par le nom de la fonction.\\
Par exemple $\sin(x)$
est un objet symbolique de sommet {\tt at\_sin} et de feuille l'identificateur
prédéfini $x$ ({\tt x\_\_IDNT\_e}).

\subsection{Programmes et modules dynamiques.}
Vous pouvez créer des programmes dont vous définissez l'interface, ou
vous pouvez créer des fonctions qui s'ajoutent à la librairie {\tt giac}
ou à {\tt xcas} (que l'on charge pendant l'exécution avec l'instruction
{\tt insmod}). Dans le deuxième cas, on crée une librairie dynamique.

\section{Exemples en C++.}
\subsection{Programme (pgcd de 2 entiers).}
\begin{verbatim}
#include <giac/giac.h>
using namespace std;
using namespace giac;

gen pgcd(gen a,gen b){
  gen q,r;
  for (;b!=0;){
    r=irem(a,b,q);
    a=b;
    b=r;
  }
  return a;
}

int main(){
  cout << "Enter 2 integers";
  gen a,b;
  cin >> a >> b;
  cout << pgcd(a,b) << endl;
  return 0;
}
\end{verbatim}
Pour compiler ce programme (fichier \verb|pgcd.cc| du répertoire
\verb|doc/en|), tapez la commande~:\\
\verb|g++ -g pgcd.cc -lgiac -lgmp|

Pour ex\'ecuter le programme, tapez \verb|./a.out|.
Pour ex\'ecuter le programme en pas-\`a-pas, il est conseill\'e de recopier
le fichier \verb|.gdbinit| du r\'epertoire \verb|src| vers le r\'epertoire
courant, ce qui d\'efinit la macro \verb|v| dans \verb|gdb| pour
voir le contenu d'une variable de type \verb|gen|.

\subsection{Module dynamique.}
On va définir une nouvelle fonction en C++ qui sera accessible depuis
{\tt xcas}. Ici cette fonction s'appellera {\tt pgcd} dans {\tt xcas}
(c'est le rôle de la ligne \\ \verb|const string _pgcd_s("pgcd");|).
La fonction
de calcul (de nom C++ \verb|pgcd|)
est identique à la précédente, la fonction de nom C++ \verb|_pgcd|
est la fonction appelée par {\tt xcas} avec comme argument les arguments
de la ligne de commande regroupés en un vecteur. Elle doit donc
vérifier que l'utilisateur appelle la fonction avec 2 arguments (donc
l'argument passé à \verb|_pgcd| doit être un vecteur ayant 2 arguments).

La compilation de ce fichier \verb|pgcd.cpp| (répertoire \verb|doc/en| du
source de {\tt giac}) se fait automatiquement
en l'ouvrant dans \verb|emacs| ou en recopiant la chaine qui suit
\verb|compile-command|.
Pour l'insérer dans une session {\tt xcas}, il faut taper la commande
{\tt insmod} suivi du chemin absolu complet de la librairie, par exemple
{\tt insmod("/home/user/giac-0.3.0/doc/en/libpgcd.so")} (en supposant
que le source de {\tt giac} a été désarchivé dans le répertoire 
{\tt /home/user}).
\begin{verbatim}
// -*- mode:C++ ; compile-command: "g++ -I.. -fPIC -DPIC -g -c pgcd.cpp \
 -o pgcd.lo && ln -sf pgcd.lo pgcd.o && gcc -shared pgcd.lo -lc \
 -Wl,-soname -Wl,libpgcd.so.0 -o libpgcd.so.0.0.0 && \
 ln -sf libpgcd.so.0.0.0 libpgcd.so.0 && \
 ln -sf libpgcd.so.0.0.0 libpgcd.so" -*-
using namespace std;
#include <stdexcept>
#include <cmath>
#include <cstdlib>
#include <giac/giac.h>
#include "pgcd.h"

#ifndef NO_NAMESPACE_GIAC
namespace giac {
#endif // ndef NO_NAMESPACE_GIAC

  gen pgcd(gen a,gen b){
    gen q,r;
    for (;b!=0;){
      r=irem(a,b,q);
      a=b;
      b=r;
    }
    return a;
  }
  gen _pgcd(const gen & args){
    if ( (args.type!=_VECT) || (args._VECTptr->size()!=2))
      setsizeerr();
    vecteur &v=*args._VECTptr;
    return pgcd(v[0],v[1]);
  }
  const string _pgcd_s("pgcd");
  unary_function_unary __pgcd(&_pgcd,_pgcd_s);
  unary_function_ptr at_pgcd (&__pgcd,0,true);
  

#ifndef NO_NAMESPACE_GIAC
} // namespace giac
#endif // ndef NO_NAMESPACE_GIAC
\end{verbatim}

\section{Compl\'ements.}
Pour les programmeurs C++, le code source de {\tt giac}
contient un peu de documentation dans le fichier 
{\tt doc/en/giac\_us.texinfo} qui s'installe dans\\
{\tt /usr/local/info/giac\_us.info} (à lire avec {\tt emacs}
commande Ctrl-U Ctrl-H I suivi du chemin d'accès précédent).
Pour le reste, il faut consulter directement le code source (les
fichiers en-tête et source contiennent quelques commentaires).

\end{document}

\item les commandes graphiques n'affichent pas leurs résultats dans 
l'historique mais dans la fen\^etre {\tt geo} pour les graphes
2-d et dans une autre fen\^etre pour les graphes 3-d. Il faut cliquer 
sur le bouton jaune {\tt geo} pour voir les graphes 2-d
et cliquer sur le bouton
jaune {\tt hist} pour revenir \`a l'historique). La fen\^etre
graphique est interactive (voir ci-dessous la g\'eom\'etrie
interactive). L'affichage d'un graphe de fonction n'efface
pas le pr\'ec\'edent, utilisez {\tt erase} pour effacer entre
deux graphes. Les graphes seront imprim\'es avec la session de l'historique
\`a chaque commande
dont le nom commence par {\tt plot}, ou si on valide la
commande {\tt graph2tex()} ou {\tt graph3d2tex()} pour les graphes en 3-d.
