<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">%%
%% xlop-doc-fr.tex: 
%% eXtra Large OPeration macros for Generic TeX.
%% See `xlop-doc.pdf' for documentation;
%%     `xlop-doc-fr.pdf' for french documentation.
%%
%% Copyright 2005-2020, by Jean-C\^ome Charpentier
%%   Jean-Come.Charpentier@wanadoo.fr
%%
%% This program may be distributed and/or modified under the
%% conditions of the LaTeX Project Public License, either version 1.3
%% of this license or (at your option) any later version.
%% The latest version of this license is in
%%   http://www.latex-project.org/lppl.txt
%% and version 1.3 or later is part of all distributions of LaTeX 
%% version 2003/12/01 or later.

\documentclass[12pt]{report}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{fourier}
\usepackage[scaled]{helvet}
\usepackage[scaled]{luximono}
\usepackage{makeidx}
\usepackage{longtable}
\usepackage{multicol}
\usepackage{pst-node}
\usepackage{fancyvrb-ex}
\usepackage{geometry}
\usepackage{xlop}
\usepackage[frenchb]{babel}
\usepackage[autolanguage]{numprint}
\usepackage{dcolumn}
\usepackage{hyperref}
\usepackage{microtype}

\fvset{label=source}% franÃ§ais

\fvset{xrightmargin=5cm, frame=single, fontsize=\small, gobble=2}
\geometry{a4paper,left=4cm,right=4cm,top=3cm,bottom=3cm,nohead}

\let\SBSori\SideBySideExample
\def\SideBySideExample{%
  \par\bigbreak\SBSori
}
\let\endSBSori\endSideBySideExample
\def\endSideBySideExample{%
  \endSBSori
  \par\bigskip\noindent}

\newenvironment{syntaxBNF}{%
  \catcode`\_=12
  \def\*##1*{$\langle$##1$\rangle$}%
  \def\alt{\unskip~$|$~\ignorespaces}%
  \def\sameline{\multicolumn{1}{c}{} &amp; \null\quad}%
  \ttfamily
  \begin{center}\begin{tabular}{r@{\quad:=\quad}l}}
{\end{tabular}\end{center}}

\setlongtables
\newcommand\package[1]{\textsf{#1}}
\newcommand\file[1]{\texttt{#1}}

\newcommand\macro[1]{\texttt{$\backslash$#1}\index{#1@\texttt{\boi {#1}}}}
\newcommand\parameter[1]{\texttt{#1}\index{#1@\texttt{#1}}%
  \index{parametre@paramÃ¨tre!\texttt{#1}}}
\newcommand\keyword[1]{\texttt{#1}}

\newcommand\bull{\vrule width3pt height4pt depth-1pt}

\newcounter{stuff}
\makeindex

\begin{document}
\begin{titlepage}
  \null\par\vfill
  \begin{center}
    \begin{minipage}{0.75\linewidth}
      \hrule width\linewidth height2pt depth0pt
      \hrule width0pt height3pt depth0pt
      \hrule width\linewidth height1pt depth0pt
      \hrule width0pt height18pt depth0pt
      \begin{center}
        \Huge\bfseries XLOP v \fileversion\par\vskip18pt
        Manuel de l'utilisateur
      \end{center}
      \hrule width0pt height6pt depth0pt
      \hrule width\linewidth height1pt depth0pt
      \hrule width0pt height3pt depth0pt
      \hrule width\linewidth height2pt depth0pt
    \end{minipage}
  \end{center}
  \vfill
  \begin{center}
    Jean-CÃ´me Charpentier\\
    \today
  \end{center}
  \vfill\null\par
\end{titlepage}
\newpage
\pagenumbering{roman}
\tableofcontents
\newpage
\pagenumbering{arabic}

\chapter{PrÃ©sentation}
\label{chap:PrÃ©sentation}
L'extension \package{xlop} a Ã©tÃ© dÃ©veloppÃ©e pour permettre de rÃ©aliser
automatiquement des calculs arithmÃ©tiques sur des nombres de taille
quelconque et d'afficher les rÃ©sultats sous forme posÃ©e ou en
ligne. Voici un premier exemple permettant de donner un aperÃ§u de la
syntaxe de base :
\begin{SideBySideExample}
  \opadd{45,05}{78,4}
\end{SideBySideExample}
Ce premier exemple appelle quelques commentaires qui permettront de
donner une idÃ©e sur la faÃ§on de manipuler l'extension.

L'addition est posÃ©e \og comme Ã&nbsp; l'Ã©cole \fg{} : il s'agit de la
prÃ©sentation par dÃ©faut. On a un alignement sur la virgule des
opÃ©randes et du rÃ©sultat, le symbole opÃ©ratoire placÃ© Ã&nbsp; gauche est
centrÃ©e verticalement entre les deux opÃ©randes et le sÃ©parateur
dÃ©cimal est un point malgrÃ© le fait d'avoir indiquer les opÃ©randes
avec une virgule dans l'appel de la macro. Enfin, on notera la
prÃ©sence d'une retenue au dessus de la premiÃ¨re opÃ©rande.

Mis Ã&nbsp; part l'alignement sur la virgule qui est obligatoire pour
l'addition posÃ©e, toutes les autres caractÃ©ristiques dÃ©crites
ci-dessus sont paramÃ©trables. Certaines macros de l'extension et, en
tout cas, toutes les macros affichant les opÃ©rations arithmÃ©tiques
admettent un argument optionnel qui permettra de contrÃ´ler la
prÃ©sentation. Pour cela, on utilisera une syntaxe \og Ã&nbsp; la keyval
\fg{} : on spÃ©cifie une suite de modifications de paramÃ¨tres par une
liste d'affectations sÃ©parÃ©es par des virgules. Une affectation a
une des deux syntaxes possibles ci-dessous :
\begin{verbatim}
  &lt;paramÃ¨tres&gt;=&lt;valeur&gt;
  &lt;paramÃ¨tre&gt;
\end{verbatim}
la seconde possibilitÃ© Ã©tant en fait un raccourci pour :
\begin{verbatim}
  &lt;paramÃ¨tre&gt;=true
\end{verbatim}
Dans cette liste d'affectation, on peut faire suivre les virgules par
un ou plusieurs espaces mais il ne faut pas mettre d'espace de part et
d'autre du signe Ã©gal ou avant la virgule : un paramÃ¨tre ou une valeur
pouvant potentiellement comporter le caractÃ¨re espace.

Ainsi, si l'on veut un sÃ©parateur dÃ©cimal qui soit une virgule, un
symbole opÃ©ratoire placÃ© en face de la seconde opÃ©rande et en
supprimant la prÃ©sence des retenues, il suffit d'indiquer :
\begin{SideBySideExample}
  \opadd[decimalsepsymbol={,},
         voperator=bottom,
         carryadd=false]{45.05}{78.4}
\end{SideBySideExample}
On notera la petite astuce consistant Ã&nbsp; mettre la virgule entre
accolades dans la dÃ©finition du symbole du sÃ©parateur dÃ©cimal. En
effet, la syntaxe :
\begin{Verbatim}[xrightmargin=0pt]
  \opadd[decimalsepsymbol=,,voperator=bottom,
         carryadd=false]{45.05}{78.4}
\end{Verbatim}
est fautive : \package{xlop} ne comprenant plus trop bien ce qu'est
cette \og liste \fg{} !

Un autre point important quoique moins visible, est que les chiffres
sont disposÃ©s Ã&nbsp; des emplacements trÃ¨s prÃ©cis. Chaque chiffre est placÃ©
dans une boÃ®te de largeur et de hauteur fixes (paramÃ©trables), le
sÃ©parateur dÃ©cimal est, par dÃ©faut, placÃ© dans une boÃ®te de largeur
nulle et toutes les lignes sont rÃ©guliÃ¨rement espacÃ©es qu'il y ait ou
non un trait horizontal. Cela permet d'obtenir des alignements
rigoureux et permet Ã©galement de placer ce que l'on veut Ã&nbsp;
l'emplacement que l'on veut.
\begin{SideBySideExample}
  \psset{xunit=\opcolumnwidth,
         yunit=\oplineheight}
  \opadd{45.05}{78.4}
  \oplput(1.5,3){retenue}
  \psline{-&gt;}(1,3.15)(-3.25,3.15)
\end{SideBySideExample}
Cet exemple a Ã©tÃ© rÃ©alisÃ© en utilisant l'extension
\package{pstricks}\index{pstricks@\package{pstricks}}

Nous avons dit prÃ©cÃ©demment que \package{xlop} Ã©tait capable de
manipuler des nombres de taille quelconque. Nous reviendrons plus en
dÃ©tail sur cette possibilitÃ© et nous nous contenterons ici de ne donner
qu'un exemple de ce que cela peut offrir. Ne regardez pas trop le
code, les explications seront donnÃ©es plus loin dans ce manuel, pour
l'instant, admirez seulement le rÃ©sultat !
\begin{CenterExample}[xrightmargin=0pt]
  \opdiv[style=text,period]{1}{49}
\end{CenterExample}

L'extension \package{xlop} offre quelques autres fonctionnalitÃ©s. Il
est ainsi possible de manipuler les nombres par l'intermÃ©diaire de
variables, ces variables pouvant Ãªtre crÃ©Ã©es par une assignation
simple ou bien comme rÃ©sultat d'un calcul. On peut Ã©galement manipuler
les chiffres de faÃ§on individuelle :
\begin{SideBySideExample}
  \opadd*{45.05}{78.4}{r}%
  Le premier chiffre apr\`es la
  virgule de $45.05+78.4$ est un
  \opgetdecimaldigit{r}{1}{d}%
  $\opprint{d}$.
\end{SideBySideExample}
effectuer des tests :
\begin{SideBySideExample}
  \opadd*{45.05}{78.4}{r}%
  La somme $45.05+78.4$ est
  \opcmp{r}{100}%
  \ifopgt strictement sup\'erieure
  \else\ifoplt strictement inf\'erieure
  \else \'egale
  \fi\fi
  \`a $100$.
\end{SideBySideExample}
avoir accÃ¨s Ã&nbsp; quelques opÃ©rations ou fonctions :
\begin{SideBySideExample}
  Le pgcd de $182$ et $442$ est
  \opgcd{182}{442}{d}$\opprint{d}$
\end{SideBySideExample}
pouvoir rÃ©aliser des calculs complexes sous forme infixe :
\begin{SideBySideExample}
  \opexpr{(2+3^2)/(gcd(22,33))}{r}%
  $$\frac{2+3^2}{\gcd(22,33)} =
    \opprint{r}$$
\end{SideBySideExample}

\chapter{Instruction \package{xlop}}
\`A quelques exceptions prÃ¨s qui seront Ã©tudiÃ©es en temps voulu, les
macros de \package{xlop} peuvent Ã©ventuellement avoir un argument
optionnel entre crochets pour modifier localement la valeur des
paramÃ¨tres de fonctionnement, les autres arguments (qui sont
obligatoires) Ã©tant presque toujours des nombres. Les deux sections de
ce chapitre dÃ©crivent en dÃ©tail ce qu'est un nombre pour
\package{xlop} et comment se servir des paramÃ¨tres.

\section{Au dÃ©but Ã©tait le nombre}
\label{sec:Au dÃ©but etait le nombre}
\subsection{Taille}
\label{subsec:Taille}
Avant de voir la syntaxe gÃ©nÃ©rale d'un nombre, nous allons nous
pencher sur la particularitÃ© de \package{xlop} qui est de pouvoir
manipuler des nombres de taille quelconque.

\index{nombre!taille}Pour Ãªtre tout Ã&nbsp; fait prÃ©cis, la taille thÃ©orique
maximum d'un nombre est de $2^{31}-1$ chiffres\index{nombre!limite}.
En pratique, cette limite ne pourra pas Ãªtre atteinte pour deux
raisons essentielles. La premiÃ¨re est qu'une multiplication avec deux
opÃ©randes ayant $2^{25}$ chiffres demanderait plus de $7\,000$ annÃ©es
de calcul sur l'ordinateur de l'auteur ! La seconde est beaucoup plus
restrictive car elle est liÃ©e aux limites de taille des piles de
\TeX{}. Voici un tableau indiquant une compilation sous \TeX{} avec
une multiplication de deux opÃ©randes de mÃªme taille sur une machine
Linux, pentium~II~600 et 256~Mo de RAM :
\begin{center}
  \begin{tabular}{|l|*{6}{c|}}
    \hline
    nombre de chiffres &amp; 100 &amp; 200 &amp; 300 &amp; 400 &amp; 425 &amp; 450 \\\hline
    temps de compilation (s) &amp; 2 &amp; 8 &amp; 18 &amp; 32 &amp; 36 &amp; crash \\\hline
  \end{tabular}
\end{center}
Le \og crash \fg{} indiquÃ© dans le tableau est dÃ» au dÃ©bordement de la
table de hachage (hash table).  \index{hash table}%
\index{depassement de capacite@dÃ©passement de capacitÃ©}%
Sous \LaTeX{}, la limite avant crash sera plus rÃ©duite. D'autre part,
ces tests ont Ã©tÃ© effectuÃ©s sur un fichier minimum : avec un document
source classique, cette limite sera un peu plus basse. Une autre
limite qui risque d'Ãªtre atteinte relativement rapidement est la
taille du spouleur (spool size).  \index{spool size}%
Pour composer ce document qui contient un grand nombre d'appel aux
macros de \package{xlop}, l'auteur a augmentÃ© la taille du spouleur
de~$125\,000$ Ã&nbsp;~$250\,000$ en Ã©ditant la ligne \verb+pool_size+ du
fichier \file{texmf.cnf}. De mÃªme, la table de hachage a dÃ» Ãªtre
augmentÃ©e en stipulant la valeur \texttt{1000} au niveau de la ligne
\verb+hash_extra+ du fichier \file{texmf.cnf}.

\subsection{Syntaxe}
\label{subsec:Syntaxe}
Nous allons prÃ©senter cette syntaxe avec la grammaire BNF mais des
explications plus humaines suivront :
\begin{syntaxBNF}
  \*nombre* &amp; \{\*signe*\}\*nombre_positif* \alt \*nom* \\
  \*signe* &amp; + \alt - \\
  \*nombre_positif* &amp; \*entier* \alt \*sep*\*entier* \alt \\
  \sameline \*entier*\*sep* \alt \*entier*\*sep*\*entier* \\
  \*sep* &amp; . \alt , \\
  \*entier* &amp; \*chiffre*\{\*chiffre*\} \\
  \*nom* &amp; \*dÃ©but*\{caractÃ¨re\} \\
  \*dÃ©but* &amp; caractÃ¨re \textnormal{autre que } \*signe*\textnormal{,}
  \*sep* \\
  \sameline \textnormal{et} \*chiffre*
\end{syntaxBNF}
\index{syntaxe BNF}\index{BNF}\index{grammaire BNF}

Le symbole \texttt{caractÃ¨re} dÃ©signe presque n'importe quel caractÃ¨re
acceptÃ© par \TeX{}. Les seules exceptions sont les caractÃ¨res \verb+%+,
et \verb+#+ qui sont totalement interdits. En fait, les caractÃ¨res
actifs risquent de poser des problÃ¨mes. Par exemple, la dÃ©finition de
\verb+~+ sous \LaTeX{} empÃªche ce caractÃ¨re de pouvoir faire partie
d'un nom. D'autre part, le caractÃ¨re \verb+\ +conserve sont rÃ´le de
caractÃ¨re d'Ã©chappement, c'est-Ã&nbsp;-dire que le nom sera celui obtenu
aprÃ¨s dÃ©veloppement de la macro introduite. Il n'y a aucune autre
contrainte comme le montre le code suivant :
\begin{SideBySideExample}
  \newcommand\prefix{a/b}
  \opadd*{2}{2}{a/b_{^c}!&amp;$}
  \opprint{\prefix_{^c}!&amp;$}
\end{SideBySideExample}
\index{nom de nombre}%
On notera que \verb+a/b_{^c}!&amp;$+ et \verb+\prefix_{^c}!&amp;$+
reprÃ©sentent trÃ¨s exactement le mÃªme nom, si \verb+\prefix+ a la
dÃ©finition adÃ©quate Ã©videmment. Cette possibilitÃ© d'obtenir un nom en
utilisant des macros peut sembler inutile mais il n'en est rien. On
peut ainsi rÃ©aliser des boucles\index{boucle} avec des noms tels que
\verb+r1+, \verb+r2+, \ldots, \verb+r&lt;n&gt;+ en utilisant le code
\verb+r\the\cpt+ comme nom oÃ¹ \verb+cpt+ est un compteur au sens
\TeX{}. Le mÃ©canisme des compteurs avec \LaTeX{} donne un code un peu
plus long avec \verb+r\number\value{cpt}+ oÃ¹ \verb+cpt+ est maintenant
un compteur au sens \LaTeX. Nous verrons un exemple d'utilisation de
cette forme Ã&nbsp; la section~\ref{sec:Creation d'operations complexes}
page~\pageref{sec:Creation d'operations complexes}.

\index{nombre!valide}En pratique, que signifient toutes ces rÃ¨gles ?
Elles indiquent d'abord qu'un nombre Ã©crit sous forme dÃ©cimale peut
Ãªtre prÃ©cÃ©dÃ© par n'importe quelle sÃ©quence de signes plus et moins.
Ã‰videmment, le nombre sera nÃ©gatif lorsqu'il y aura un nombre impair
de signes moins.  Ensuite, un nombre ne peut comporter qu'un seul
sÃ©parateur dÃ©cimal qui peut Ãªtre le point ou la virgule, celui-ci
pouvant Ãªtre placÃ© n'importe oÃ¹ dans le nombre. Enfin, l'Ã©criture d'un
nombre s'effectue obligatoirement en base~10.  Attention : ces rÃ¨gles
signifient Ã©galement que \verb+-a+ n'est pas valide.

L'extension utilise quelques noms de faÃ§on interne et il est plus
prudent de ne pas commencer un nom de variable par le caractÃ¨re
\texttt{@}.

\section{ParamÃ¨tres de \package{xlop}}
\label{sec:Parametres de xlop}
\index{parametre@paramÃ¨tre!syntaxe|(}
Les affectations de paramÃ¨tres restent locales Ã&nbsp; la macro lorsqu'elles
sont indiquÃ©es au niveau de leurs arguments optionnels. Pour rendre de
telles affectations globales, il faut utiliser la macro
\macro{opset}. Par exemple
\begin{Verbatim}[xrightmargin=0pt]
  \opset{decimalsepsymbol={,}}
\end{Verbatim}
fera que le symbole du sÃ©parateur dÃ©cimal sera la virgule pour tout le
reste du document, ou, du moins, jusqu'Ã&nbsp; une prochaine redÃ©finition
par la macro \verb+\opset+. Dans ce manuel, ce sera le cas Ã&nbsp; partir de
maintenant.\opset{decimalsepsymbol={,}}

\subsection{Symboles}
\label{subsecSymboles}
Le paramÃ¨tre \parameter{afterperiodsymbol} indique le symbole qui suit
l'Ã©criture d'un quotient en ligne lors d'une division avec recherche
de pÃ©riode\index{division!pÃ©riode}. Sa valeur par dÃ©faut est
\verb+$\ldots$+

Le paramÃ¨tre \parameter{equalsymbol} indique le symbole utilisÃ© pour
l'Ã©galitÃ©.  Sa valeur par dÃ©faut est \verb+$=$+. En rÃ©alitÃ©, le
paramÃ¨tre est dÃ©fini avec :
\begin{Verbatim}[xrightmargin=0pt]
  \opset{equalsymbol={$=$}}
\end{Verbatim}
c'est-Ã&nbsp;-dire avec des accolades pour protÃ©ger le signe Ã©gal. Sans les
accolades, il y aurait une erreur Ã&nbsp; la compilation. On doit procÃ©der
de cette faÃ§on lorsque la valeur comporte le signe Ã©gal ou une
virgule\index{parametre@paramÃ¨tre!avec \og = \fg{} ou \og ,\fg}

Le paramÃ¨tre \parameter{approxsymbol} indique le symbole utilisÃ© pour
les approximations. Sa valeur par dÃ©faut est \verb+$\approx$+.

Le paramÃ¨tre \parameter{decimalsepsymbol} indique le symbole utilisÃ©
pour le sÃ©parateur dÃ©cimal. Sa valeur par dÃ©faut est le point.

Les paramÃ¨tres \parameter{addsymbol}, \parameter{subsymbol},
\parameter{mulsymbol} et \parameter{divsymbol} indiquent les symboles
utilisÃ©s pour les quatre opÃ©rations arithmÃ©tiques. Les valeurs par
dÃ©faut sont respectivement \verb!$+$!, \verb!$-$!, \verb!$\times$! et
\verb!$\div$!.

\subsection{PrÃ©sentation gÃ©nÃ©rale}
\label{subsec:Presentation generale}
Le paramÃ¨tre \parameter{voperation} indique la faÃ§on dont une
opÃ©ration posÃ©e sera placÃ©e par rapport Ã&nbsp; la ligne de base. Les
valeurs possibles sont \keyword{top}, \keyword{center} et
\keyword{bottom} (valeur par dÃ©faut).
\begin{SideBySideExample}
  top\quad
  \opadd[voperation=top]{45}{172}\par
  center\quad
  \opadd[voperation=center]{45}{172}\par
  bottom\quad
  \opadd[voperation=bottom]{45}{172}
\end{SideBySideExample}

Le paramÃ¨tre \parameter{voperator} indique comment sera placÃ© le
symbole opÃ©ratoire par rapport aux opÃ©randes. Les valeurs possibles
sont \keyword{top}, \keyword{center} (valeur par dÃ©faut) et
\keyword{bottom}.
\begin{SideBySideExample}
  top\quad
  \opadd[voperator=top]{45}{172}\par
  center\quad
  \opadd[voperator=center]{45}{172}\par
  bottom\quad
  \opadd[voperator=bottom]{45}{172}
\end{SideBySideExample}

Le paramÃ¨tre \parameter{deletezero} indique si certains nombres d'une
opÃ©ration doivent Ãªtre affichÃ©s avec ou sans les zÃ©ros non
significatifs. Le rÃ´le exact de ce paramÃ¨tre varie en fonction de
l'opÃ©ration et nous y reviendrons lors de la prÃ©sentation des
diffÃ©rentes opÃ©rations.

Le paramÃ¨tre \parameter{style} indique si l'opÃ©ration doit Ãªtre posÃ©e
(avec la valeur \keyword{display} qui est la valeur par dÃ©faut) ou
bien Ãªtre affichÃ©e en ligne (valeur \keyword{text}). On reviendra sur
ce paramÃ¨tre lors de la prÃ©sentation de la division car les
possibilitÃ©s sont alors un peu plus nombreuses.
\begin{SideBySideExample}
  \opadd[style=text]{45}{172}
\end{SideBySideExample}
Dans les opÃ©rations en ligne, \package{xlop} fait attention Ã&nbsp; ne pas
composer la formule en mode mathÃ©matique de faÃ§on directe. Cela permet
de spÃ©cifier ce que l'on veut comme dans l'exemple qui suit et c'est
Ã©galement pour cela qu'il faut indiquer les valeurs classiques des
symboles entre dÃ©limiteurs mathÃ©matiques.
\begin{SideBySideExample}
  \opadd[addsymbol=plus,
         equalsymbol=\'egal,
         style=text]{42}{172}
\end{SideBySideExample}
Cependant, \package{xlop} introduit exactement les mÃªmes pÃ©nalitÃ©s de
coupures et exactement les mÃªmes espacements que pour une formule
mathÃ©matique.

Le paramÃ¨tre \parameter{parenthesisnegative} indique comment composer
les nombres nÃ©gatifs dans les opÃ©rations en ligne. Les valeurs
possibles sont :
\begin{itemize}
\item \texttt{none} qui compose les nombres nÃ©gatifs sans parenthÃ¨se ;
\item \texttt{all} qui compose les nombres nÃ©gatifs en les plaÃ§ant
  entre parenthÃ¨ses ;
\item \texttt{last} qui compose les nombres nÃ©gatifs en les plaÃ§ant
  entre parenthÃ¨ses s'il ne s'agit pas de la premiÃ¨re opÃ©rande.
\end{itemize}
\begin{SideBySideExample}
  \opadd[style=text,
         parenthesisnegative=none]
         {-12}{-23}\par
  \opadd[style=text,
         parenthesisnegative=all]
         {-12}{-23}\par
  \opadd[style=text,
         parenthesisnegative=last]
         {-12}{-23}
\end{SideBySideExample}

\subsection{Dimensions}
\label{subsec:Dimensions}
Dans les opÃ©rations posÃ©es, les chiffres sont placÃ©s dans des boÃ®tes
de dimensions fixÃ©es. La largeur est donnÃ©e par le paramÃ¨tre
\parameter{columnwidth} et la hauteur par le paramÃ¨tre
\parameter{lineheight}. La valeur par dÃ©faut du paramÃ¨tre
\texttt{lineheight} est \keyword{\string\baselineskip} ce qui fait que
les lignes des opÃ©rations seront espacÃ©es, par dÃ©faut, comme les
lignes d'un paragraphe. La valeur par dÃ©faut de \texttt{columnwidth}
est de \texttt{2ex} car la largeur \og normale \fg{} des chiffres
aurait donnÃ© des rÃ©sultats peu lisibles.
\begin{SideBySideExample}
  \opadd[columnwidth=0.5em]
        {45.89}{127.5}
\end{SideBySideExample}
Ce piÃ¨tre rÃ©sultat est dÃ» en partie au fait que la virgule est placÃ©
dans une boÃ®te dont la largeur est contrÃ´lÃ©e par le paramÃ¨tre
\parameter{decimalsepwidth} dont la valeur par dÃ©faut est nulle. Un
essai d'amÃ©lioration peut Ãªtre effectuÃ© en donnant Ã&nbsp; ce paramÃ¨tre la
largeur \og{} normale \fg{} d'une virgule.
\begin{SideBySideExample}
  \opadd[columnwidth=0.5em,
         decimalsepwidth=0.27778em]
        {45.89}{127.5}
\end{SideBySideExample}
C'est meilleur mais le fait de donner une largeur non nulle Ã&nbsp; la boÃ®te
contenant le sÃ©parateur dÃ©cimal risque de poser des difficultÃ©s si
l'on veut placer des Ã©lÃ©ments externes : cela va Ã&nbsp; l'encontre de
l'idÃ©e de placer les chiffres dans une grille fixe. Ceci est donc Ã&nbsp;
Ã©viter en temps normal.

Les deux paramÃ¨tres \parameter{columnwidth} et \parameter{lineheight}
correspondent aux deux seules dimensions que l'extension rend
publiques, Ã&nbsp; savoir respectivement
\verb+\opcolumnwidth+\index{opcolumnwidth@\texttt{$\backslash$opcolumnwidth}}
et
\verb+\oplineheight+\index{oplineheight@\texttt{$\backslash$oplineheight}}.
Il est cependant dangereux de vouloir modifier ces dimensions de faÃ§on
directe puisque une modification par voie normale n'a pas pour seule
consÃ©quence d'obtenir une nouvelle valeur pour ces
dimensions. L'extension \package{xlop} a rendu ces dimensions
publiques uniquement pour pouvoir les lire, pas pour les modifier.

Les deux paramÃ¨tres suivants permettent de spÃ©cifier les largeurs des
traits horizontaux et verticaux tracÃ©s par \package{xlop}. Il s'agit
des deux paramÃ¨tres \parameter{hrulewidth} et \parameter{vrulewidth}
dont la valeur par dÃ©faut est \texttt{0.4pt}.

Ces traits sont composÃ©s sans perturber la grille, c'est-Ã&nbsp;-dire sans
ajouter d'espace vertical. Ainsi, avec des valeurs importantes pour
l'Ã©paisseur, les traits risquent de dÃ©border au niveau des opÃ©randes.
\begin{SideBySideExample}
  \opadd[hrulewidth=8pt]{42}{172}
\end{SideBySideExample}

Il existe Ã©galement un paramÃ¨tre permettant de contrÃ´ler le dÃ©calage
horizontal du sÃ©parateur dÃ©cimal. Il s'agit de
\parameter{decimalsepoffset} dont la valeur par dÃ©faut est Ã©gale
Ã&nbsp;~\texttt{-0.35}. Cette valeur par dÃ©faut indique une longueur en
prenant \verb+\opcolumnwidth+ comme unitÃ©. Un exemple d'utilisation de
ce paramÃ¨tre sera donnÃ© Ã&nbsp; la section~\ref{sec:Division}
page~\pageref{sec:Division}.

\subsection{Styles des chiffres}
\label{subsec:Styles des chiffres}
L'extension \package{xlop} distingue cinq types de nombres et y
associe cinq paramÃ¨tres de style :
\begin{itemize}
\item les opÃ©randes avec \parameter{operandstyle} ;
\item le rÃ©sultat avec \parameter{resultstyle} ;
\item les restes avec \parameter{remainderstyle} ;
\item les rÃ©sultats intermÃ©diaires avec \parameter{intermediarystyle}
  ;
\item les retenues avec \parameter{carrystyle}.
\end{itemize}
\begin{SideBySideExample}
  \opadd[operandstyle=\blue,
         resultstyle=\red,
         carrystyle=\scriptsize\green]
         {45.89}{127.5}
\end{SideBySideExample}
Rappelons que dans ce manuel, nous utilisons l'extension
\package{pstricks}\index{pstricks}.

\index{parametre@paramÃ¨tre!indexÃ©|(}%
En rÃ©alitÃ©, la gestion de ces styles est encore plus puissante car on
peut distinguer les diffÃ©rents nombres d'une mÃªme classe. Dans une
mÃªme opÃ©ration, on a plusieurs opÃ©randes et, Ã©ventuellement plusieurs
restes et plusieurs nombres intermÃ©diaires. On accÃ¨de alors au style
de ces nombres individuels en indexant le paramÃ¨tre de style
correspondant.
\begin{SideBySideExample}
  \opadd[operandstyle=\blue,
         operandstyle.1=\lightgray,
         resultstyle=\red,
         carrystyle=\scriptsize\green]
         {45.89}{127.5}  
\end{SideBySideExample}
Sur cet exemple, on a indiquÃ© que la premiÃ¨re opÃ©rande devait Ãªtre
composÃ©e avec le style \verb+\lightgray+ et comme rien n'Ã©tait indiquÃ©
pour la seconde opÃ©rande, celle-ci a repris le style de base de sa
classe (donc a Ã©tÃ© composÃ©e avec le style \verb+\blue+).

Ce mÃ©canisme va encore plus loin car on peut indicer Ã&nbsp; deux niveaux
les styles des classes opÃ©rande, reste et nombre intermÃ©diaire et Ã&nbsp; un
niveau les styles des classes rÃ©sultat et retenue pour accÃ©der au
style de chacun des chiffres de ces nombres. Afin de rendre les
indexations plus facile Ã&nbsp; gÃ©rer, un index positif indiquera le rang
d'un chiffre de la partie entiÃ¨re (numÃ©rotÃ©e de droite Ã&nbsp; gauche,
l'index~1 correspondant au chiffre des unitÃ©s) et un index nÃ©gatif
indiquera le rang d'un chiffre de la partie dÃ©cimale (numÃ©rotÃ©e de
gauche Ã&nbsp; droite, l'index $-1$ correspondant au chiffre des dixiÃ¨mes).
\begin{SideBySideExample}
  \opadd[operandstyle.1.1=\white,
         operandstyle.1.-2=\white,
         operandstyle.2.3=\white,
         resultstyle.2=\white,
         deletezero=false]
         {045.89}{127.50}
\end{SideBySideExample}
On peut Ã©galement utiliser une macro Ã&nbsp; un paramÃ¨tre comme style.
\begin{SideBySideExample}
  \newcommand\hole[1]{$\bullet$}
  \opadd[operandstyle.1.1=\hole,
         operandstyle.1.-2=\hole,
         operandstyle.2.3=\hole,
         resultstyle.2=\hole]
         {45.89}{127.5}
\end{SideBySideExample}
\index{operation@opÃ©ration!Ã&nbsp; trou}%
Lorsque le style est une macro, le chiffre constitue le dernier
argument de cette macro. Voici un exemple plus compliquÃ© et utilisant
l'extension \package{pst-node} de la suite \package{pstricks} :
\begin{SideBySideExample}
  \newcommand\OPoval[3]{%
    \dimen1=#2\opcolumnwidth
    \ovalnode{#1}
      {\kern\dimen1 #3\kern\dimen1}}
  \opadd[voperation=top,
    operandstyle.1.1=\OPoval{A}{0},
    operandstyle.2.2=\OPoval{C}{0.8}]
    {45}{172}\qquad
  \begin{minipage}[t]{2cm}
    \pnode(0,0.2em){B}\ chiffre
    \ncarc{-&gt;}{A}{B}\par
    \pnode(0,0.2em){D}\ nombre
    \ncarc{&lt;-}{D}{C}
  \end{minipage}
\end{SideBySideExample}

Comme les chiffres, le sÃ©parateur dÃ©cimal tient compte du style d'un
nombre. Pour accÃ©der au style du sÃ©parateur dÃ©cimal de faÃ§on
individuelle, il faut employer l'indice \texttt{d} au lieu des indices
numÃ©riques des chiffres.
\begin{SideBySideExample}
  \newcommand\hole[1]{\texttt{\_}}
  \opmul[intermediarystyle=\hole,
    resultstyle=\hole,
    resultstyle.d=\white]{2.46}{35.7}
\end{SideBySideExample}
\index{parametre@paramÃ¨tre!indexÃ©|)}%
\index{parametre@paramÃ¨tre!syntaxe|)}

\chapter{OpÃ©rations arithmÃ©tiques}
\label{chap:OpÃ©rations arithmÃ©tiques}
\section{Addition}
\label{sec:Addition}
L'addition est gÃ©rÃ©e par la macro \macro{opadd}. L'addition,
lorsqu'elle est posÃ©e, n'affiche que des nombres positifs. Cela va
avoir comme consÃ©quence d'afficher une soustraction lorsqu'une des
opÃ©randes est nÃ©gative.%
\index{nombre!nÃ©gatifs dans une opÃ©ration posÃ©e}
\begin{SideBySideExample}
  \opadd{-245}{72}
\end{SideBySideExample}
De faÃ§on gÃ©nÃ©rale, le principe est de poser l'opÃ©ration qui permet de
retrouver le rÃ©sultat comme on le ferait Ã&nbsp; la main. En revanche,
l'affichage en ligne donnera toujours une addition puisqu'on peut
maintenant Ã©crire des nombres nÃ©gatifs.
\begin{SideBySideExample}
  \opadd[style=text]{-245}{72}
\end{SideBySideExample}
 Outre les paramÃ¨tres gÃ©nÃ©raux dÃ©crits Ã&nbsp; la
 section~\ref{sec:Parametres de xlop}, la macro \macro{opadd} est
 sensible aux paramÃ¨tres \texttt{carryadd}, \texttt{lastcarry} et
 \texttt{deletezero}.

Le paramÃ¨tre \parameter{carryadd} est un paramÃ¨tre
boolÃ©en\index{parametre@paramÃ¨tre!boolÃ©en} c'est-Ã&nbsp;-dire n'acceptant
que les valeurs \texttt{true} et \texttt{false}. Comme il d'usage,
l'omission du signe Ã©gal et de la partie droite de l'affectation
Ã©quivaut Ã&nbsp; \texttt{=true}. Ce paramÃ¨tre indique si les retenues
doivent Ãªtre ou non affichÃ©es. Sa valeur par dÃ©faut est
\texttt{true}.

Le paramÃ¨tre \parameter{lastcarry} est Ã©galement un paramÃ¨tre
boolÃ©en. Il indique si une retenue sans chiffre correspondant au
niveau des deux opÃ©randes doit Ãªtre ou non affichÃ©e. Sa valeur par
dÃ©faut est \texttt{false}. On fera attention au rÃ´le exact de ce
paramÃ¨tre. Ainsi, si la seconde opÃ©rande dans l'exemple qui suit avait
Ã©tÃ©~15307, la derniÃ¨re retenue aurait Ã©tÃ© affichÃ©e quelle que soit la
valeur du paramÃ¨tre \texttt{lastcarry} puisqu'il y aurait eu un
chiffre correspondant au niveau de la seconde opÃ©rande.
\begin{SideBySideExample}
  \opadd{4825}{5307}
\end{SideBySideExample}
\begin{SideBySideExample}
  \opadd[carryadd=false]{4825}{5307}
\end{SideBySideExample}
\begin{SideBySideExample}
  \opadd[lastcarry]{4825}{5307}
\end{SideBySideExample}

Le paramÃ¨tre \parameter{deletezero} est Ã©galement un paramÃ¨tre boolÃ©en
et son rÃ´le et d'indiquer si les zÃ©ros non significatifs doivent Ãªtre
supprimÃ©s ou non. Sa valeur par dÃ©faut est \texttt{true}. Si ce
paramÃ¨tre vaut \texttt{false}, les opÃ©randes et le rÃ©sultats auront le
mÃªme nombre de chiffres, \package{xlop} ajoutant des zÃ©ros non
significatifs pour y parvenir. Les zÃ©ros non significatifs des
opÃ©randes ne sont pas supprimÃ©s Ã©galement.
\begin{SideBySideExample}
  \opadd{012.3427}{5.2773}\par
  \opadd[deletezero=false]
    {012.3427}{5.2773}
\end{SideBySideExample}

Ce paramÃ¨tre a exactement le mÃªme rÃ´le dans l'affichage en ligne que
dans l'affichage posÃ©.
\begin{SideBySideExample}
  \opadd[style=text]{02.8}{1.2}\par
  \opadd[style=text,
         deletezero=false]{02.8}{1.2}
\end{SideBySideExample}

La version 0.27 de xlop a introduit la macro \macro{opmanyyadd} qui
permet de poser des additions avec plus de deux opÃ©randes. Cette macro
a quelques limitations:
\begin{itemize}
\item toutes les opÃ©randes doivent Ãªtre positives ;
\item certains paramÃ¨tres ne sont plus utilisÃ©s, par
  exemple \parameter{style} ;
\item les retenues ne sont pas affichÃ©es.
\end{itemize}
En revanche, le paramÃ¨tre \parameter{vmanyoperator} permet de
contrÃ´ler finement le placement des signes d'opÃ©ration.

Voici un premier exemple pour montrer la syntaxe de base. Les
opÃ©randes doivent Ãªtre placÃ©es entre accolades et leur nombre n'est
pas limitÃ©.
\begin{SideBySideExample}
  \opmanyadd{123.4}{3.1416}
            {2.71828}{0.001}
\end{SideBySideExample}
La macro \macro{opmanyadd} accepte les paramÃ¨tres de style pour les
opÃ©randes et le rÃ©sultat. En ce qui concerne le style pour les
opÃ©randes, le premier index indique la place de l'opÃ©rande (du haut
vers le bas) et la deuxiÃ¨me le chiffre de l'opÃ©rande. Par exemple :
\begin{SideBySideExample}
  \newcommand\R{\color{red}}
  \opmanyadd[operandstyle.2.3=\R,
             operandstyle.3.3=\R,
             resultstyle.3=\R,
             resultstyle.4=\R]
             {12.6}{853.3}{158.1}
\end{SideBySideExample}
Cet exemple montre que les zÃ©ros non significatifs ne sont pas
affichÃ©s. Ils peuvent l'Ãªtre en utilisant le
paramÃ¨tre \parameter{deletezero} avec la valeur false :
\begin{SideBySideExample}
  \opmanyadd[deletezero=false]
            {12.6}{853.3}{158.1}
\end{SideBySideExample}

La macro \macro{opmanyadd} utilise Ã©galement le
paramÃ¨tre \parameter{voperation} comme le fait \macro{opadd}.

Il existe un paramÃ¨tre spÃ©cifique Ã&nbsp; la macro \macro{opmanyadd} : le
paramÃ¨tre \parameter{vmanyoperator}. Ce paramÃ¨tre permet d'afficher
l'opÃ©rateur plus de six faÃ§ons diffÃ©rentes.
\begin{CenterExample}
  \opmanyadd{1}{12}{123}{1234}\quad
  \opmanyadd[vmanyoperator=center]
            {1}{12}{123}{1234}\quad
  \opmanyadd[vmanyoperator=top]
            {1}{12}{123}{1234}\quad
  \opmanyadd[vmanyoperator=bottom]
            {1}{12}{123}{1234}
\end{CenterExample}
On peut voir que la valeur par dÃ©faut est center. Les valeurs avec une
premiÃ¨re lettre minuscule affichent autant d'opÃ©rateurs qu'il y a
d'opÃ©randes moins une. Les mÃªmes valeurs avec la premiÃ¨re lettre en
capitale affichent un unique signe opÃ©ratoire:
\begin{CenterExample}
  \opmanyadd[vmanyoperator=Center]
            {1}{12}{123}{1234}\quad
  \opmanyadd[vmanyoperator=Top]
            {1}{12}{123}{1234}\quad
  \opmanyadd[vmanyoperator=Bottom]
            {1}{12}{123}{1234}
\end{CenterExample}

\section{Soustraction}
\label{sec:soustraction}
La soustraction est gÃ©rÃ©e par la macro \macro{opsub}. La soustraction,
lorsqu'elle est posÃ©e, n'affiche que des nombres positifs.  Par
consÃ©quence cette macro va afficher une addition lorsqu'une des
opÃ©randes est nÃ©gative.
\begin{SideBySideExample}
  \opsub{-245}{72}
\end{SideBySideExample}
De faÃ§on gÃ©nÃ©rale, le principe est de poser l'opÃ©ration qui permet de
retrouver le rÃ©sultat comme on le ferait Ã&nbsp; la main. En revanche,
l'affichage en ligne donnera toujours une soustraction puisqu'on peut
maintenant Ã©crire des nombres nÃ©gatifs.
\begin{SideBySideExample}
  \opsub[style=text]{-245}{72}
\end{SideBySideExample}
Ce principe s'applique Ã©galement lorsque la premiÃ¨re opÃ©rande est
infÃ©rieure Ã&nbsp; la seconde (cas positif) oÃ¹ on aura une inversion des
opÃ©randes.
\begin{SideBySideExample}
  \opsub{1.2}{2.45}
\end{SideBySideExample}
Bien entendu, l'opÃ©ration en ligne donnera le rÃ©sultat exact.
\begin{SideBySideExample}
  \opsub[style=text]{1.2}{2.45}
\end{SideBySideExample}


Outre les paramÃ¨tres gÃ©nÃ©raux vus Ã&nbsp; la section~\ref{sec:Parametres de
  xlop}, \macro{opsub} est sensible Ã&nbsp; \texttt{carrysub},
\texttt{lastcarry}, \texttt{offsetcarry}, \texttt{deletezero} et
\texttt{behaviorsub}.

Le paramÃ¨tre \parameter{carrysub} est un paramÃ¨tre boolÃ©en
qui indique si les retenues doivent Ãªtre ou non prÃ©sentes. Sa valeur
par dÃ©faut est \texttt{false} (rappelons que le paramÃ¨tre
\texttt{carryadd} avait une valeur par dÃ©faut Ã©gale Ã&nbsp; \texttt{true}).
\begin{SideBySideExample}
  \opsub[carrysub]{1234}{567}
\end{SideBySideExample}

Dans l'exemple prÃ©cÃ©dent, nous pouvons voir qu'il manque en fait une
retenue au niveau du dernier chiffre de 1234, cette faÃ§on de faire
Ã©tant assez courante. NÃ©anmoins, on peut contrÃ´ler l'affichage de
cette derniÃ¨re retenue avec le paramÃ¨tre \parameter{lastcarry}. Ce
paramÃ¨tre n'a pas tout Ã&nbsp; fait le mÃªme rÃ´le que pour l'addition puisque
la derniÃ¨re retenue ne sera pas affichÃ©e dans le cas oÃ¹ la seconde
opÃ©rande n'a pas de chiffre correspondant (alors que pour l'addition,
il fallait que les deux opÃ©randes n'aient pas de chiffres
correspondant).
\begin{SideBySideExample}
  \opsub[carrysub,lastcarry]{1234}{567}
\end{SideBySideExample}
On peut noter dans ce dernier cas qu'il est sans doute prÃ©fÃ©rable de
mettre le paramÃ¨tre \parameter{deletezero} Ã&nbsp; \texttt{false} pour
obtenir une prÃ©sentation plus correcte.
\begin{SideBySideExample}
  \opsub[carrysub,
         lastcarry,
         deletezero=false]{1234}{567}
\end{SideBySideExample}

L'affichage des retenues au niveau des soustractions peut sembler un
peu trop compact. On peut Ã©largir la boÃ®te des chiffres avec le
paramÃ¨tre \parameter{opcolumnwidth} mais Ã©galement indiquer le
dÃ©calage des retenues avec le paramÃ¨tre \parameter{offsetcarry}. La
valeur par dÃ©faut de ce paramÃ¨tre est \texttt{-0.35}.
\begin{SideBySideExample}
  \opsub[carrysub,
         lastcarry,
         deletezero=false]{12.34}{5.67}  

  \bigskip
  \opsub[carrysub,
         lastcarry,
         columnwidth=2.5ex,
         offsetcarry=-0.4,
         decimalsepoffset=-3pt,
         deletezero=false]{12.34}{5.67}  
\end{SideBySideExample}

Il peut arriver qu'une soustraction de deux nombres positifs, le
premier Ã©tant infÃ©rieur au second, soit le signe d'une erreur de
l'utilisateur. Dans ce cas, et uniquement dans ce cas, le paramÃ¨tre
\parameter{behaviorsub} permet d'obtenir un rappel Ã&nbsp; l'ordre. Les
trois valeurs possibles de ce paramÃ¨tre sont \texttt{silent} qui est
la valeur par dÃ©faut et qui donne le rÃ©sultat, \texttt{warning} qui
donne Ã©galement le rÃ©sultat mais affiche le message d'avertissement :
\begin{Verbatim}[xrightmargin=0pt,frame=none]
  xlop warning.  Substraction with first operand less than second one
      See documentation for further information.
\end{Verbatim}
et enfin \texttt{error} qui affichera le message d'erreur :
\begin{Verbatim}[xrightmargin=0pt,frame=none]
  xlop error.  See documentation for further information.
                   Type  H &lt;return&gt;  for immediate help.
  ! Substraction with first operand less than second one.
\end{Verbatim}
et l'opÃ©ration ne sera pas effectuÃ©e.

\section{Multiplication}
\label{sec:Multiplication}
La multiplication est gÃ©rÃ©e par la macro \macro{opmul}.
Nous prÃ©senterons les paramÃ¨tres \texttt{hfactor},
\texttt{displayintermediary}, \texttt{shiftintermediarysymbol},
\texttt{displayshiftintermediary} et finalement \texttt{deletezero},
les autres paramÃ¨tres ayant Ã©tÃ© vus Ã&nbsp; la section~\ref{sec:Parametres
  de xlop}.

Le paramÃ¨tre \parameter{shiftintermediarysymbol} indique quel symbole
sera utilisÃ© (sa valeur par dÃ©faut est \verb+$\cdot$+) pour visualiser
les dÃ©calages des nombres intermÃ©diaires. Le paramÃ¨tre
\parameter{displayshiftintermediary} peut prendre les valeurs
\texttt{shift} (valeur par dÃ©faut) qui ne montre ce symbole que
lorsque le dÃ©calage est supÃ©rieur Ã&nbsp; un rang, \texttt{all} qui indique
que ce symbole de dÃ©calage sera systÃ©matiquement affichÃ© et
\texttt{none} qui indique que ce symbole ne sera jamais affichÃ©.
\begin{CenterExample}[xrightmargin=0pt]
  \opmul[displayshiftintermediary=shift]{453}{1001205}\qquad
  \opmul[displayshiftintermediary=all]{453}{1001205}\qquad
  \opmul[displayshiftintermediary=none]{453}{1001205}
\end{CenterExample}

En rÃ©alitÃ©, le non affichage des nombres intermÃ©diaires nuls est dÃ» Ã&nbsp;
la valeur par dÃ©faut \texttt{none} du paramÃ¨tre
\parameter{displayintermediary}. La valeur \texttt{all} va afficher
tous les nombres intermÃ©diaires.
\begin{SideBySideExample}
  \opmul[displayintermediary=all]
        {453}{1001205}
\end{SideBySideExample}
On notera que les nombres intermÃ©diaires nuls sont affichÃ©s avec
autant de chiffres que le premier facteur.

Le paramÃ¨tre \parameter{displayintermediary} admet la valeur
\texttt{nonzero} qui a le mÃªme rÃ´le que la valeur \texttt{none} sauf
dans le cas oÃ¹ le second facteur ne comporte qu'un seul chiffre.
\begin{CenterExample}[xrightmargin=0pt]
  \opmul{3.14159}{4}\qquad
  \opmul[displayintermediary=nonzero]{3.14159}{4}
\end{CenterExample}

Enfin, le paramÃ¨tre \parameter{displayintermediary} admet la valeur
\texttt{None} qui n'affichera aucun rÃ©sultat intermÃ©diaire dans tous
les cas.
\begin{CenterExample}[xrightmargin=0pt]
  \opmul[displayintermediary=None]{453}{1001205}
\end{CenterExample}

Le paramÃ¨tre \parameter{hfactor} permet d'indiquer comment doit se
faire l'alignement des opÃ©randes. La valeur par dÃ©faut \texttt{right}
donne une composition au fer Ã&nbsp; droite tandis que la valeur
\texttt{decimal} donne un alignement au niveau de la virgule.
\begin{CenterExample}[xrightmargin=0pt]
  \opmul{3.1416}{12.8}\qquad\opmul[hfactor=decimal]{3.1416}{12.8}
\end{CenterExample}

Pour la multiplication posÃ©e, le paramÃ¨tre \parameter{deletezero} ne
concerne que les opÃ©randes, le rÃ©sultat gardant ses Ã©ventuels zÃ©ros
non significatifs puisque ceux-ci sont nÃ©cessaires pour effectuer
correctement le dÃ©calage de la virgule lorsqu'on travaille \og Ã&nbsp; la
main \fg{}.
\begin{CenterExample}[xrightmargin=0pt]
  \opmul[deletezero=false]{01.44}{25}\qquad
  \opmul{01.44}{25}
\end{CenterExample}
En revanche, dans la multiplication en ligne, ce paramÃ¨tre retrouve
son comportement normal.
\begin{CenterExample}[xrightmargin=0pt]
  \opmul[deletezero=false,style=text]{01.44}{25}\qquad
  \opmul[style=text]{01.44}{25}
\end{CenterExample}

\section{Division}
\label{sec:Division}
L'extension gÃ¨re la division \og classique \fg{} avec la macro
\macro{opdiv} et la division euclidienne avec la macro
\macro{opidiv}. En raison de sa complexitÃ©, la division est l'opÃ©ration
qui prend en compte le plus de paramÃ¨tres.

\subsection{ContrÃ´le de l'arrÃªt}
\label{subsec:Controle de l'arret}
Dans ce qui suivra, le terme d'\emph{Ã©tape} indique l'ensemble des
calculs permettant d'obtenir un chiffre au niveau du quotient. Ce
nombre d'Ã©tapes est contrÃ´lÃ© en partie par les paramÃ¨tres
\parameter{maxdivstep}, \parameter{safedivstep} et \parameter{period}.
En partie seulement car une division classique s'arrÃªtera
automatiquement lors de l'obtention d'un reste nul, quelles que que
soient les valeurs de ces trois paramÃ¨tres et une division euclidienne
s'arrÃªtera sur un quotient entier, sans tenir compte de ces trois
paramÃ¨tres.
\begin{SideBySideExample}
  \opdiv{25}{7}
\end{SideBySideExample}
\begin{SideBySideExample}
  \opidiv{25}{7}
\end{SideBySideExample}
Le premier exemple s'arrÃªte en raison de la valeur de
\parameter{maxdivstep} qui est Ã©gale, par dÃ©faut, Ã&nbsp;~10. On prendra
garde Ã&nbsp; ce que le nombre maximum d'Ã©tapes peut entraÃ®ner des rÃ©sultats
aberrants lorsqu'il est trop faible.
\begin{SideBySideExample}
  \opdiv[maxdivstep=2]{1248}{3}
\end{SideBySideExample}
Le rÃ©sultat prÃ©cÃ©dent est clairement faux mais \package{xlop} a fait
ce qu'on lui a demandÃ©, en l'occurrence avoir deux chiffres (maximum)
au quotient.

L'affichage en ligne va Ã©galement diffÃ©rer selon que la division s'est
arrÃªtÃ©e avec un reste final nul ou non ou selon qu'il s'agit d'une
division classique ou euclidienne.
\begin{SideBySideExample}
  \opdiv[style=text]{3.14}{2}\par
  \opdiv[style=text]{3.14}{3}\par
  \opidiv[style=text]{314}{2}\par
  \opidiv[style=text]{314}{3}
\end{SideBySideExample}
On notera l'emploi de \parameter{equalsymbol} ou
\parameter{approxsymbol} selon le cas ainsi que l'affichage avec une
troncature et non un arrondi. Nous verrons comment obtenir un arrondi
Ã&nbsp; la section~\ref{sec:Operations evoluees}

L'affichage en ligne de \macro{opdiv} tient compte de
\parameter{maxdivstep}. Cela signifie que l'on peut obtenir des
rÃ©sultats vraiment faux avec des valeurs trop faible de ce paramÃ¨tre
et, contrairement Ã&nbsp; l'affichage posÃ©, l'affichage en ligne ne
permettra pas de comprendre ce qu'il s'est passÃ©.
\begin{SideBySideExample}
  \opdiv[maxdivstep=2,style=text]
        {1248}{3}
\end{SideBySideExample}
Si en plus, le dernier reste calculÃ© est nul, on atteint un summum :
\begin{SideBySideExample}
  \opdiv[maxdivstep=1,style=text]
        {1208}{3}
\end{SideBySideExample}
puisqu'il n'y a mÃªme plus d'approximation !

Une division non euclidienne peut Ã©galement s'arrÃªter sur la dÃ©tection
de la survenue d'une pÃ©riode. Pour cela, il suffit de donner la valeur
\texttt{true} au paramÃ¨tre \parameter{period}\index{division!pÃ©riode}.
\begin{SideBySideExample}
  \opdiv[period]{100}{3}
\end{SideBySideExample}

Pour ne pas avoir Ã&nbsp; effectuer des comparaisons de chaque reste avec
l'ensemble de tous les restes prÃ©cÃ©dents, \package{xlop} calcule dÃ¨s
le dÃ©part la longueur de la pÃ©riode ce qui permet de n'effectuer
qu'une seule comparaison Ã&nbsp; chaque Ã©tape et donc d'accÃ©lÃ©rer
notablement les calculs\footnote{Je remercie Ã&nbsp; cette occasion Olivier
  Viennet pour ses prÃ©cisions mathÃ©matiques qui ont permis d'implanter
  correctement ces calculs.}. Malheureusement, ces calculs se font
avec des nombres directement accessibles Ã&nbsp; \TeX{} ce qui a pour
consÃ©quence de ne pas pouvoir utiliser d'opÃ©randes dont la valeur
absolue excÃ¨de
$\left\lfloor\frac{2^{31}-1}{10}\right\rfloor = 214748364$.

Pour ne pas entraÃ®ner des calculs trop longs, \package{xlop} ne
dÃ©passera pas la valeur du paramÃ¨tre \parameter{safedivstep} dans les
divisions avec dÃ©tection de pÃ©riode. Sa valeur par dÃ©faut est Ã©gale
Ã&nbsp;~50. Cependant, \package{xlop} signalera le problÃ¨me. Par exemple si
on demande un tel calcul avec le code :
\begin{Verbatim}[xrightmargin=0pt,frame=none]
  \opdiv[period]{1}{289}
\end{Verbatim}
on obtiendra le message d'avertissement :
\begin{Verbatim}[xrightmargin=0pt,frame=none]
  xlop warning.  Period of division is too big (272 &gt; safedivstep).
      Division will stop before reach it.
      See documentation for further information.
\end{Verbatim}
qui indique que la pÃ©riode de cette division est de~272 et qu'elle ne
sera donc pas atteinte Ã&nbsp; cause de la valeur de \texttt{safedivstep}.

L'affichage en ligne d'une telle division  prÃ©sente quelque
particularitÃ©s.
\begin{SideBySideExample}
  \opdiv[period,style=text]{150}{7}
\end{SideBySideExample}
On obtient donc une Ã©galitÃ© au lieu d'une approximation, la prÃ©sence
d'un trait sous la pÃ©riode et des points de suspension Ã&nbsp; la suite de
la pÃ©riode. Tous ces Ã©lÃ©ments peuvent Ãªtre configurÃ©s. Le symbole
d'Ã©galitÃ© est donnÃ© par le paramÃ¨tre \parameter{equalsymbol} (valeur
par dÃ©faut \verb+{$=$}+), la largeur du trait par le paramÃ¨tre
\parameter{hrulewidth} (valeur par dÃ©faut \texttt{0.4pt}), sa position
verticale par le paramÃ¨tre \parameter{vruleperiod} (valeur par dÃ©faut
\texttt{-0.2}) qui indique un dÃ©calage vertical en prenant
\verb+\oplineheight+ comme unitÃ© et les points de suspension sont
donnÃ©s par le paramÃ¨tre \parameter{afterperiodsymbol} (valeur par
dÃ©faut \verb+$\ldots$+).
\begin{SideBySideExample}
  \opdiv[period,style=text,
         equalsymbol=$\approx$,
         hrulewidth=0.2pt,
         vruleperiod=0.7,
         afterperiodsymbol=]
        {150}{7}
\end{SideBySideExample}

\subsection{Ã‰lÃ©ments supplÃ©mentaires}
\label{subsec:Elements supplementaires}
Les divisions posÃ©es peuvent comporter les soustractions successives
permettant le calcul des restes. Pour \package{xlop}, les nombres qui
sont soustraits sont des nombres intermÃ©diaires donc les diffÃ©rentes
faÃ§ons de reprÃ©senter les soustractions utiliserons le paramÃ¨tre
\parameter{displayintermediary} dÃ©jÃ&nbsp; vu pour la multiplication. La
valeur \texttt{none} (dÃ©faut) n'affichera aucune soustraction ainsi
que la valeur \texttt{None}, la valeur \texttt{all} affichera toutes
les soustractions et la valeur \texttt{nonzero} affichera les
soustractions avec un nombre non nul.
\begin{CenterExample}[xrightmargin=0pt]
  \opdiv[displayintermediary=none,voperation=top]
        {251}{25}\quad
  \opdiv[displayintermediary=nonzero,voperation=top]
        {251}{25}\quad
  \opdiv[displayintermediary=all,voperation=top]
        {251}{25}
\end{CenterExample}

Lorsqu'on pose une division, on peut dessiner un \og pont \fg{}
au-dessus de la partie du dividende qui sera prise en compte pour la
premiÃ¨re Ã©tape du calcul. L'extension \package{xlop} permet d'afficher
ce symbole grÃ¢ce au paramÃ¨tre boolÃ©en \parameter{dividendbridge}
(valeur par dÃ©faut \texttt{false}).
\begin{SideBySideExample}
  \opdiv[dividendbridge]{1254}{30}
\end{SideBySideExample}

\subsection{Nombres non entiers et nÃ©gatifs}
\label{subsec:Nombres non entiers et negatifs}
La prÃ©sentation d'opÃ©randes non entiÃ¨res est gÃ©rÃ©e par le paramÃ¨tre
\parameter{shiftdecimalsep}. Sa valeur par dÃ©faut est \texttt{both} et
indique que le sÃ©parateur dÃ©cimal sera dÃ©calÃ© pour obtenir un diviseur
et un dividende entiers. La valeur \texttt{divisor} indique qu'il y
aura le dÃ©calage nÃ©cessaire pour obtenir un diviseur entier et la
valeur \texttt{none} indique qu'il n'y aura aucun dÃ©calage.
\begin{CenterExample}[xrightmargin=0pt]
  \opdiv[shiftdecimalsep=both]{3.456}{25.6}\quad
  \opdiv[shiftdecimalsep=divisor]{3.456}{25.6}\quad
  \opdiv[shiftdecimalsep=none]{3.456}{25.6}
\end{CenterExample}

Un symbole indiquÃ© par le paramÃ¨tre \parameter{strikedecimalsepsymbol}
est rÃ©servÃ© pour montrer l'ancien emplacement de la virgule lorsqu'on
effectue un dÃ©calage. La valeur par dÃ©faut de ce paramÃ¨tre est vide ce
qui fait que l'on ne voyait rien sur les exemples prÃ©cÃ©dents.
\begin{CenterExample}[xrightmargin=0pt]
  \opset{strikedecimalsepsymbol={\rlap{,}\rule[-1pt]{3pt}{0.4pt}}}
  \opdiv[shiftdecimalsep=both]{3.456}{25.6}\quad
  \opdiv[shiftdecimalsep=divisor]{3.456}{25.6}\quad
  \opdiv[shiftdecimalsep=none]{3.456}{25.6}
\end{CenterExample}

La prÃ©sence d'un symbole non vide pour le sÃ©parateur dÃ©cimal barrÃ©
peut laisser les zÃ©ros non significatifs au niveau des opÃ©randes.
\begin{SideBySideExample}
  \opdiv[shiftdecimalsep=divisor,
         strikedecimalsepsymbol=%
           \hspace{-3pt}\tiny$\times$]
        {0.03456}{2.56}
\end{SideBySideExample}

Comme nous l'avons dÃ©jÃ&nbsp; vu, la macro \macro{opidiv} donne un quotient
entier, cela mÃªme si les opÃ©randes sont non entiÃ¨res. Il est un peu
bizarre de vouloir rÃ©aliser une division euclidienne sur des nombres
non entiers et la macro \macro{opidiv} sera assez stricte sur sa
prÃ©sentation. Les paramÃ¨tres \parameter{maxdivstep},
\parameter{safedivstep} et \parameter{period} seront sans effet ainsi
que le paramÃ¨tre \parameter{shiftdecimalsep}, les deux opÃ©randes Ã©tant
rendues entiÃ¨res.
\begin{SideBySideExample}
  \opidiv[strikedecimalsepsymbol=%
          \hspace{-3pt}\tiny$\times$]
          {34.57}{7}
\end{SideBySideExample}

Lorsque les opÃ©randes sont nÃ©gatives, l'affichage en ligne de
\macro{opidiv} diffÃ©rera des donnÃ©es obtenues avec l'affichage
posÃ©e. Le reste sera nÃ©cessairement un nombre compris entre zÃ©ro
(inclus) et la valeur absolue du diviseur (exclu).
\begin{SideBySideExample}
  \opdiv[style=text]{124}{7}\par
  \opidiv[style=text]{124}{7}\par
  \opidiv[style=text]{124}{-7}\par
  \opidiv[style=text]{-124}{7}\par
  \opidiv[style=text]{-124}{-7}
\end{SideBySideExample}

Cette condition sur le reste reste valable mÃªme avec un diviseur non
entier.
\begin{SideBySideExample}
  \opidiv[style=text]{1.24}{0.7}\par
  \opidiv[style=text]{1.24}{-0.7}\par
  \opidiv[style=text]{-1.24}{0.7}\par
  \opidiv[style=text]{-1.24}{-0.7}
\end{SideBySideExample}

\chapter{Autres commandes}
\label{chap:Autres commandes}
\section{Macros Ã©toilÃ©es}
\label{sec:Macros etoilees}
Les cinq macros vues au chapitre prÃ©cÃ©dent ont une version
Ã©toilÃ©e. Ces macros Ã©toilÃ©es rÃ©alisent le calcul mais ne procÃ¨dent Ã&nbsp;
aucun affichage, le rÃ©sultat Ã©tant stockÃ© dans une variable donnÃ©e en
dernier argument.

Comme ces commandes n'affichent rien, les paramÃ¨tres ne seront pas
acceptÃ©s pour les macros \macro{opadd*}, \macro{opsub*},
\macro{opmul*} et \macro{opidiv*}. En revanche, les paramÃ¨tres
\parameter{maxdivestep}, \parameter{safedivstep} et \parameter{period}
influencent les calculs et la macro \macro{opdiv*} acceptera donc un
argument optionnel pour pouvoir en tenir compte.
\begin{SideBySideExample}
  \opmul*{2}{2}{a}%
  \opmul*{a}{a}{a}\opmul*{a}{a}{a}%
  \opadd[style=text]{a}{1}
\end{SideBySideExample}
Pour les macros \macro{opdiv} et \macro{opidiv}, il y aura deux
arguments supplÃ©mentaires pour pouvoir recevoir le quotient et le
reste final.
\begin{SideBySideExample}
  \opdiv*[maxdivstep=1]{-88}{16}{q}{r}%
  \opmul*{q}{16}{bq}%
  \opmul[style=text]{16}{q}\par
  \opadd[style=text]{bq}{r}
\end{SideBySideExample}

\section{EntrÃ©es-sorties}
\label{sec:Entree-sorties}
La macro \macro{opcopy} recopie son premier argument dans son deuxiÃ¨me
argument. Le premier argument est donc un nombre Ã©crit sous forme
dÃ©cimale ou via une variable alors que le second sera considÃ©rÃ©e comme
un nom de variable.

La macro \macro{opprint} affiche son argument. L'exemple qui suit
utilise le compteur \macro{time} qui indique le nombre de minutes
Ã©coulÃ©s depuis  minuit.
\begin{SideBySideExample}
  \opidiv*{\the\time}{60}{h}{m}%
  Il est \opprint{h}~heures et
  \opprint{m}~minutes
\end{SideBySideExample}
On verra Ã&nbsp; la section~\ref{sec:Comparaisons} comment amÃ©liorer cet
affichage avec des tests.

La macro \macro{opdisplay} affiche Ã©galement un nombre mais en
Ã©crivant chaque chiffre dans une boÃ®te de largeur donnÃ©e par
\parameter{columnwidth} et de hauteur donnÃ©e par
\parameter{lineheight}. Le style est spÃ©cifiÃ© par le premier argument
et cette macro accepte un argument optionnel pour permettre de donner
un style particulier aux chiffres individuels.
\begin{SideBySideExample}
  \opdisplay[resultstyle.1=\bfseries,
             resultstyle.-2=\bfseries]
            {resultstyle}{129.192}
\end{SideBySideExample}

Les macros \macro{oplput} et \macro{oprput} permettent de placer un
objet Ã&nbsp; un emplacement dÃ©terminÃ©. La syntaxe de ces commandes ne
suit pas celle des autres macros de \package{xlop} puisque
l'emplacement est indiquÃ© sous forme de coordonnÃ©es entre
parenthÃ¨ses. Les coordonnÃ©es utilisent \macro{opcolumnwidth} et
\macro{oplineheight} comme unitÃ©s ce qui permet Ã&nbsp; l'utilisateur de
construire lui-mÃªme ses propres \og opÃ©rations \fg.
\begin{SideBySideExample}
  \psset{xunit=\opcolumnwidth,
    yunit=\oplineheight}%
  \psgrid[subgriddiv=1,gridlabels=7pt,
          griddots=5](0,1)(10,-2)
  \oplput(2,0){Bonjour}
  \oprput(8,-1){le monde}
  $\bullet$
\end{SideBySideExample}
Sur l'exemple ci-dessus, on peut voir que ces deux macros ne modifient
pas le point de rÃ©fÃ©rence. Elles prennent mÃªme la prÃ©caution d'inhiber
l'espace automatique qui les suit pour qu'il ne soit pas nÃ©cessaire de
mettre un \verb+%+ en fin de ligne.

Les macros \macro{ophline} et \macro{opvline} complÃ¨te les deux
prÃ©cÃ©dentes pour donner Ã&nbsp; l'utilisateur les outils lui permettant de
construire ses propres opÃ©rations. La macro \macro{ophline} permet de
placer un trait horizontal dont la longueur est donnÃ© par le paramÃ¨tre
qui suit les coordonnÃ©es. La macro \macro{opvline} fait de mÃªme avec
les traits verticaux. On rappelle que les paramÃ¨tres
\parameter{hrulewidth} et \parameter{vrulewidth} indiquent les
Ã©paisseurs respectives de ces types de traits.
\begin{CenterExample}[xrightmargin=0pt]
  \par\vspace{2\oplineheight}
  \oplput(1,2){O}\oplput(2,2){N}\oplput(3,2){E}
  \oplput(0,1.5){$+$}
  \oplput(1,1){O}\oplput(2,1){N}\oplput(3,1){E}
  \ophline(0,0.8){4}
  \oplput(1,0){T}\oplput(2,0){W}\oplput(3,0){O}
\end{CenterExample}

La macro \macro{opexport}\refstepcounter{stuff}\label{macro-opexport}
permet d'exporter un nombre dans une macro. Il s'agit d'un ajout de la
version 0.23 qui est trÃ¨s utile pour faire dialoguer \package{xlop}
avec le monde extÃ©rieur. Le premier argument est un nombre au sens
\package{xlop}, c'est-Ã&nbsp;-dire soit un nombre Ã©crit directement avec des
chiffres, soit un nom de variable. Le nombre sera Ã©crit sous une forme
directement comprÃ©hensible par \TeX{} dans le deuxiÃ¨me argument qui
doit donc Ãªtre un nom de macro. On notera cependant que le sÃ©parateur
dÃ©cimal sera celui dÃ©signÃ© par \parameter{decimalsepsymbol} dÃ©barrassÃ©
de ses Ã©ventuelles accolades.
\begin{SideBySideExample}
  \opmul*{5}{3.141592654}{C}
  \opexport{C}{\fivepi}
  \texttt{\meaning\fivepi}
\end{SideBySideExample}

On peut se servir de cette macro, par exemple, pour afficher des
nombres calculÃ©s par \package{xlop} dans un tableau avec un alignement
dÃ©cimal ou encore pour initialiser un compteur ou une longueur (ne pas
oublier l'unitÃ© dans ce dernier cas).

\section{Chiffres d'un nombre}
\label{sec:Chiffres d'un nombre}
Les macros \macro{opwidth}, \macro{opintegerwidth} et
\macro{opdecimalwidth} indiquent respectivement le nombre de chiffres
du nombre dans sa totalitÃ©, de sa partie entiÃ¨re et de sa partie
dÃ©cimale. Le premier argument est le nombre sur lequel s'effectue le
comptage et le second argument indique la variable oÃ¹ sera stockÃ© le
rÃ©sultat.
\begin{SideBySideExample}
  \opcopy{123456.1234}{a}%
  \opwidth{a}{na}%
  \opintegerwidth{a}{ia}%
  \opdecimalwidth{a}{da}%
  \opprint{a} s'\'ecrit avec \opprint{na}
  chiffres (\opprint{ia} en partie
  enti\`ere et \opprint{da} en partie
  d\'ecimale).
\end{SideBySideExample}

La macro \macro{opunzero} permet de supprimer les zÃ©ros non
significatifs\index{zeros non significatifs@zÃ©ros non significatifs}
du nombre passÃ© en argument.
\begin{SideBySideExample}
  \opcopy{00150.00250}{a}%
  Avant : \opprint{a}\par
  \opunzero{a}%
  Apr\`es : \opprint{a}
\end{SideBySideExample}

Les macros \macro{integer} et \macro{opdecimal} donnent respectivement
la partie entiÃ¨re et la partie dÃ©cimale d'un nombre.
\index{nombre!partie entiÃ¨re}\index{partie entiÃ¨re}%
\index{nombre!partie dÃ©cimale}\index{partie dÃ©cimale}%
Le premier argument est le nombre Ã&nbsp; traiter et le second est la
variable qui contiendra le rÃ©sultat.
\begin{SideBySideExample}
  \opcopy{-37.69911}{a}%
  \opinteger{a}{ia}%
  \opdecimal{a}{da}%
  Partie enti\`ere : \opprint{ia}\par
  Partie d\'ecimale : \opprint{da}
\end{SideBySideExample}

Six macros servent Ã&nbsp; Ã©crire ou lire un chiffre d'un nombre. On peut
lire ou Ã©crire un chiffre selon son rang dans le nombre, dans sa
partie entiÃ¨re ou dans sa partie dÃ©cimale. Les chiffres pour le nombre
dans sa totalitÃ© ou pour sa partie entiÃ¨re sont numÃ©rotÃ©s de droite Ã&nbsp;
gauche et, pour sa partie dÃ©cimale de gauche Ã&nbsp; droite. Ainsi, avec le
nombre 1234,56789, le deuxiÃ¨me chiffre est 8, le deuxiÃ¨me chiffre de
sa partie entiÃ¨re est 3 et le deuxiÃ¨me chiffre de sa partie dÃ©cimale
est 6. Il est alors facile de deviner le rÃ´le respectif des six macros
:
\begin{itemize}
\item \parameter{opgetdigit} ;
\item \parameter{opsetdigit} ;
\item \parameter{opgetintegerdigit} ;
\item \parameter{opsetintegerdigit} ;
\item \parameter{opgetdecimaldigit} ;
\item \parameter{opsetdecimaldigit} ;
\end{itemize}
La syntaxe est la mÃªme pour ces six macros. Le premier argument est le
nombre sur lequel doit porter la lecture ou l'Ã©criture, le deuxiÃ¨me
argument est l'index donnant la position du chiffre et le troisiÃ¨me
argument est le nom de la variable qui contiendra le chiffre lu ou
bien le chiffre qui devra Ãªtre Ã©crit. Si l'index est en dehors du
nombre, les macros de lecture donneront \texttt{0} comme rÃ©sultat et
les macros d'Ã©criture Ã©tendront le nombre pour pouvoir atteindre cet
index en crÃ©ant des zÃ©ros dans les nouvelles positions.

\section{Comparaisons}
\label{sec:Comparaisons}
Lorsqu'on dÃ©sire concevoir des macros Ã©voluÃ©es, il est trÃ¨s souvent
utile de pouvoir rÃ©aliser des tests. Pour cela, \package{xlop} met Ã&nbsp;
disposition la macro \macro{opcmp} dont les deux arguments sont des
nombres et qui mettra Ã&nbsp; jour les tests \macro{ifopgt}, \macro{ifopge},
\macro{ifople}, \macro{ifoplt}, \macro{ifopeq} et \macro{ifopneq} pour
respectivement indiquer que la premiÃ¨re opÃ©rande est strictement
supÃ©rieure, supÃ©rieure, infÃ©rieure, strictement infÃ©rieure, Ã©gale ou
diffÃ©rente de la seconde opÃ©rande.

Pour des raisons techniques, \package{xlop} donne des dÃ©finitions
globales aux six tests prÃ©cÃ©dents. Ceux-ci ne seront donc pas protÃ©gÃ©s
par les groupes. Comme ces tests sont utilisÃ©s par un grand nombre de
macros de \package{xlop}, une consÃ©quence pratique est qu'il faut
\emph{toujours} rÃ©aliser les tests \verb+\ifop...+ immÃ©diatement
aprÃ¨s le \macro{opcmp}, ou, du moins, avant toute autre utilisation de
macros de \package{xlop} sous peine de bogues Ã©ventuels difficiles Ã&nbsp;
comprendre !

On va reprendre la macro d'affichage de l'heure donnÃ©e Ã&nbsp; la
section~\ref{sec:Entree-sorties} mais en vÃ©rifiant si l'argument est
compris entre~0 (inclus) et~1440 (exclu) puis en rÃ©alisant les tests
nÃ©cessaires pour voir si \og heure \fg{} doit Ãªtre ou non au pluriel
ainsi que \og minute \fg{}.

\begin{CenterExample}[xrightmargin=0pt]
  \newcommand\heure[1]{%
    \opcmp{#1}{0}\ifopge
    \opcmp{#1}{1440}\ifoplt
      \opidiv*{#1}{60}{h}{m}%
      \opprint{h} heure%
      \opcmp{h}{1}\ifopgt
        s%
      \fi
      \opcmp{m}{0}\ifopneq
        \space\opprint{m} minute%
        \opcmp{m}{1}\ifopgt
          s%
        \fi
      \fi
    \fi\fi
  }
  \heure{60} -- \heure{1080} -- \heure{1081} -- \heure{1082}
\end{CenterExample}

\section{OpÃ©rations Ã©voluÃ©es}
\label{sec:Operations evoluees}
Les macros qui nous restent Ã&nbsp; voir proviennent soit de commandes
utilisÃ©es de faÃ§on interne et qu'il aurait Ã©tÃ© dommage de ne pas
rendre publiques, soit de demandes d'utilisateurs.

Les macros utilisÃ©es de faÃ§on interne sont \macro{opgcd}\index{pgcd}
qui donne le pgcd de deux nombres et
\macro{opdivperiod}\index{division!pÃ©riode} qui donne la longueur de
la pÃ©riode d'un quotient de deux nombres. Pour des raisons
d'efficacitÃ©, ces macros n'utilisent pas les nombres de \package{xlop}
mais des nombres directement accessibles Ã&nbsp; \TeX{}. Cela a pour
consÃ©quence que les nombres passÃ©s en paramÃ¨tres dans les deux
premiers arguments ne devront pas dÃ©passer la valeur
\texttt{2147483647} pour \macro{opgcd} et \texttt{214748364} pour
\macro{opdivperiod}. Un message d'avertissement rappellera Ã&nbsp; l'ordre
en cas de dÃ©passement. Le rÃ©sultat sera stockÃ© dans la variable
indiquÃ© en troisiÃ¨me paramÃ¨tre.

Il y aura Ã©galement quelques vÃ©rifications sur les deux premiers
paramÃ¨tres. Un pgcd ne peut pas avoir d'argument nul et le calcul de
la longueur d'une pÃ©riode ne pourra pas se faire avec un quotient
nul. D'autre part, si un nombre non entier est passÃ© en paramÃ¨tre,
seule la partie entiÃ¨re sera prise en compte.
\begin{SideBySideExample}
  \opcopy{5376}{a}%
  \opcopy{2304}{b}%
  \opgcd{a}{b}{gcd(ab)}%
  \newcommand\pgcd{%
    \mathop{\mathrm{pgcd}}}%
  $\pgcd(\opprint{a},\opprint{b}) =
    \opprint{gcd(ab)}$
\end{SideBySideExample}
Si vous voulez vous amuser Ã&nbsp; trouver de grandes pÃ©riodes de divisions,
sans entrer dans les dÃ©tails mathÃ©matiques, les carrÃ©s de nombres
premiers sont de bons candidats. Par exemple, avec $257^2=66049$ on
trouve :
\begin{SideBySideExample}
  \opdivperiod{1}{66049}{p}%
  $\frac{1}{66049}$ a une p\'eriode
  de longueur $\opprint{p}$.
\end{SideBySideExample}

Les macros \macro{opcastingoutnines}\index{preuve!par neuf} et
\macro{opcastingoutelevens}\index{preuve!par onze} vont permettre de
composer des preuves par neuf et par onze.  L'extension \package{xlop}
ne propose pas directement ces compositions puisqu'elles nÃ©cessitent
des traits en diagonal et donc le recours Ã&nbsp; d'autres extensions. En
rÃ©alitÃ©, la macro \macro{opcastingoutnines} va faire la somme modulo~9
des chiffres du premier argument et stockera le rÃ©sultat dans le
second argument tandis que la macro \macro{opcastingoutelevens} fera
la somme des chiffres de rangs impairs, la somme des chiffres de rangs
pairs puis la diffÃ©rence modulo~11 de ces deux sommes.
\begin{SideBySideExample}
  \newcommand\castingoutnines[3]{%
    \opcastingoutnines{#1}{cna}%
    \opcastingoutnines{#2}{cnb}%
    \opmul*{cna}{cnb}{cna*cnb}
    \opcastingoutnines{cna*cnb}{cna*cnb}%
    \opcastingoutnines{#3}{cn(a*b)}%
    \begin{pspicture}(-3.5ex,-3.5ex)%
                     (3.5ex,3.5ex)
      \psline(-3.5ex,-3.5ex)(3.5ex,3.5ex)
      \psline(-3.5ex,3.5ex)(3.5ex,-3.5ex)
      \rput(-2.75ex,0){\opprint{cna}}
      \rput(2.75ex,0){\opprint{cnb}}
      \rput(0,2.75ex){\opprint{cna*cnb}}
      \rput(0,-2.75ex){\opprint{cn(a*b)}}
    \end{pspicture}
  }
  \castingoutnines{157}{317}{49669}
\end{SideBySideExample}
Incidemment, cet exemple montre que $157\times317\neq49669$ ! La
rÃ©ponse correcte est \opmul[style=text]{157}{317}.

Les deux macros suivantes sont trÃ¨s simples. Il s'agit de
\macro{opneg} qui calcul l'opposÃ© de son premier argument et le
sauvegarde dans la variable indiquÃ©e par le second argument et de
\macro{opabs} qui rÃ©alise la mÃªme chose mais avec la valeur absolue.

La macro \macro{oppower} calcule des puissances entiÃ¨res. Cette macro
demande trois paramÃ¨tres, le troisiÃ¨me paramÃ¨tre Ã©tant la variable
recevant le rÃ©sultat du premier paramÃ¨tre Ã&nbsp; la puissance le deuxiÃ¨me
paramÃ¨tre. Le deuxiÃ¨me paramÃ¨tre doit Ãªtre un nombre entier. Lorsque
le premier argument est nul, si le deuxiÃ¨me paramÃ¨tre est nul, le
rÃ©sultat sera~1, s'il est strictement positif, le rÃ©sultat sera nul et
s'il est strictement nÃ©gatif il y aura une erreur et aucun rÃ©sultat ne
sera fourni. Il n'y a aucune limitation sur le premier paramÃ¨tre ce
qui peut entraÃ®ner quelques problÃ¨mes. Par exemple :
\begin{CenterExample}[xrightmargin=0pt]
  \opcopy{0.8}{a}\opcopy{-17}{n}%
  \oppower{a}{n}{r}%
  $\opprint{a}^{\opprint{n}} = \opprint{r}$
\end{CenterExample}
Avec $0{,}7$ au lieu de $0{,}8$, le problÃ¨me aurait Ã©tÃ© encore pire :
\begin{CenterExample}[xrightmargin=0pt]
  \opcopy{0.7}{a}\opcopy{-8}{n}%
  \oppower{a}{n}{r}%
  \opdecimalwidth{r}{dr}
  $\opprint{a}^{\opprint{n}}$ a \opprint{dr} chiffres apr\`es la
  virgule.
\end{CenterExample}
Cela est dÃ» au fait que lorsque l'exposant est nÃ©gatif,
\package{xlop} calcule \emph{d'abord} l'inverse du nombre pour
\emph{ensuite} calculer la puissance avec l'opposÃ© de l'exposant. Si
on avait laissÃ© $-17$ au lieu de $-8$ dans l'exemple prÃ©cÃ©dent, les
capacitÃ©s de \TeX{} auraient Ã©tÃ© dÃ©passÃ©es.

Les trois macros qui suivent permettent de contrÃ´ler la prÃ©cision des
nombres manipulÃ©s. Elles permettent de construire un nombre en donnant
une valeur approchÃ©e par dÃ©faut, par excÃ¨s ou un arrondi d'un nombre
donnÃ© en prÃ©cisant le rang oÃ¹ devra se faire l'arrondi. Ces macros
sont respectivement \macro{opfloor}, \macro{opceil} et
\macro{opround}. Elles demandent trois paramÃ¨tres qui seront dans
l'ordre le nombre de dÃ©part, le rang de l'arrondi et le nom de la
variable qui contiendra le rÃ©sultat.

Le rang est indiquÃ© par une valeur entiÃ¨re donnant le nombre de
chiffres aprÃ¨s la virgule qui doivent Ãªtre prÃ©sents. Si le rang est
nÃ©gatif, l'arrondi se fera avant la virgule. Si le rang positif
indique plus de chiffres que la partie dÃ©cimale n'en a, des zÃ©ros
seront ajoutÃ©s. Si le rang nÃ©gatif indique plus de chiffres que la
partie entiÃ¨re n'en a, l'arrondi restera bloquÃ© pour donner au moins
le premier chiffre du nombre.

Voici un tableau rÃ©capitulatif pour mieux comprendre le fonctionnement
de ces trois macros.
\begin{center}
  \opcopy{3838.3838}{a}
  \begin{tabular}{|r|l|l|l|}
    \hline
    \multicolumn{4}{|c|}{\textbf{\texttt{\textbackslash
          op\ldots{}\{3838.3838\}\{n\}\{r\}}}}\\\hline
    \multicolumn{1}{|c|}{\textbf{\texttt{n}}} &amp;
    \multicolumn{1}{c|}{\textbf{\texttt{floor}}} &amp;
    \multicolumn{1}{c|}{\textbf{\texttt{ceil}}} &amp;
    \multicolumn{1}{c|}{\textbf{\texttt{round}}} \\\hline
    \opcopy{6}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{4}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{3}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{0}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{-1}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{-2}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{-6}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\\hline
  \end{tabular}
  \opcopy{-3838.3838}{a}
  \begin{tabular}{|r|l|l|l|}
    \hline
    \multicolumn{4}{|c|}{\textbf{\texttt{\textbackslash
          op\ldots{}\{-3838.3838\}\{n\}\{r\}}}}\\\hline
    \multicolumn{1}{|c|}{\textbf{\texttt{n}}} &amp;
    \multicolumn{1}{c|}{\textbf{\texttt{floor}}} &amp;
    \multicolumn{1}{c|}{\textbf{\texttt{ceil}}} &amp;
    \multicolumn{1}{c|}{\textbf{\texttt{round}}} \\\hline
    \opcopy{6}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{4}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{3}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{0}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{-1}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{-2}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\
    \opcopy{-6}{n}$\opprint{n}$ &amp;
    \opfloor{a}{n}{r}$\opprint{r}$ &amp;
    \opceil{a}{n}{r}$\opprint{r}$ &amp;
    \opround{a}{n}{r}$\opprint{r}$ \\\hline
  \end{tabular}
\end{center}

\index{racine carrÃ©e}
Avec la version~0.26, \package{xlop} propose l'opÃ©ration de racine
carrÃ©e \macro{opsqrt}. Cette macro n'a pas la mÃªme syntaxe que les
autres macros arithmÃ©tiques puisqu'il n'y a pas de forme Ã©toilÃ©e. En
rÃ©alitÃ©, il y a bien une faÃ§on d'afficher l'opÃ©ration d'extraction de
racine carrÃ©e mais elle n'est pas franchement courante. Je suis
relativement Ã¢gÃ© et mon grand-pÃ¨re me racontait qu'il l'avait vue
lorsqu'il Ã©tait Ã&nbsp; l'Ã©cole. Ainsi, il y a une macro \macro{opgfsqrt} oÃ¹
le \og gf \fg{} est pour \og grandfather \fg{} (grand-pÃ¨re).

Voyons la premiÃ¨re macro : celle qui calcule la racine carrÃ©e et qui
stocke le rÃ©sultat dans une variable \package{xlop}:
\begin{SideBySideExample}
  \opsqrt{2}{sqrt2}
  $\sqrt{2}\approx\opprint{sqrt2}$
\end{SideBySideExample}
Cette macro partage le paramÃ¨tre \parameter{maxdivstep} avec les
macros de division. Par exemple:
\begin{SideBySideExample}
  \opsqrt[maxdivstep=15]{2}{sqrt2}
  $\sqrt{2}\approx\opprint{sqrt2}$
\end{SideBySideExample}

Pour la prÃ©sentation Ã&nbsp; la \og grand-pÃ¨re \fg{}, je n'ai vraiment pas
le courage d'expliquer tout le processus. Il se base sur l'identitÃ©
remarquable $(a+b)^2=a^2+2ab+b^2$. Merci Ã&nbsp; Jean-Michel Sarlat d'avoir
pris le temps de m'expliquer cette mÃ©thode afin que je puisse la coder
dans \package{xlop}.

Voici un exemple avec le calcul de la racine carrÃ©e de 15 :
\begin{CenterExample}
  \opgfsqrt[maxdivstep=5]{15}
\end{CenterExample}
Cette mÃ©thode est horrible, autant pour un humain que pour
l'ordinateur. Par exemple, l'opÃ©ration rÃ©ellement effectuÃ©e par
\package{xlop} se fonde sur la mÃ©thode de HÃ©ron.

\index{expression complexe|(}
La derniÃ¨re macro qui nous reste Ã&nbsp; voir est \macro{opexpr} qui permet
de rÃ©aliser le calcul d'une expression complexe. Cette macro demande
deux paramÃ¨tres : le premier est l'expression Ã&nbsp; calculer donnÃ©e sous
forme infixe (la forme habituelle pour un humain) et le second est le
nom de la variable qui contiendra le rÃ©sultat.

Dans un premier temps, la formule devait Ãªtre donnÃ©e sous forme
polonaise inverse (la notation des calculatrices HP ou du langage
PostScript par exemple) mais un travail commun avec Christophe Jorssen
a finalement abouti Ã&nbsp; la possibilitÃ© de donner l'expression sous une
forme plus agrÃ©able pour l'utilisateur.

Les formules acceptent les opÃ©rateurs arithmÃ©tiques habituels
\texttt{+}, \texttt{-}, \texttt{*} et \texttt{/} ainsi que l'opÃ©rateur
\texttt{:} pour la division euclidienne et \verb+^+ pour
l'exponentiation. L'opÃ©rateur \texttt{-} a les deux rÃ´les d'opÃ©rateur
binaire de la soustraction et d'opÃ©rateur unaire pour l'opposÃ©.
L'opÃ©rateur \texttt{+} a Ã©galement les deux rÃ´les d'opÃ©rateur binaire
de l'addition et d'opÃ©rateur unaire ne faisant \ldots{} rien ! Les
opÃ©randes sont Ã©crites sous forme dÃ©cimale ou par l'intermÃ©diaire de
nom de variable cependant, la macro \macro{opexpr} va introduire une
petite restriction sur les noms de variables puisque ceux-ci devront
Ãªtre diffÃ©rents des noms de fonctions reconnus par cette macro. Les
fonctions accessibles sont :
\begin{itemize}
\item \texttt{abs(a)} ;
\item \texttt{ceil(a,i)} ;
\item \texttt{decimal(a)} ;
\item \texttt{floor(a,i)} ;
\item \texttt{gcd(a,b)} ;
\item \texttt{integer(a)} ;
\item \texttt{mod(a,b)} qui donne le rÃ©sultat de \texttt{a} modulo
  \texttt{b} ;
\item \texttt{rest(a,b)} qui donne le reste de la division de
  \texttt{a} par \texttt{b} (la diffÃ©rence entre reste et modulo est
  la diffÃ©rence qui existe entre division non euclidienne et division
  euclidienne) ;
\item \texttt{round(a,i)}.
\end{itemize}
oÃ¹ les fonctions non dÃ©crites ci-dessus font appel aux macros
correspondantes (la fonction \texttt{xxx} faisant appel Ã&nbsp; la macro
\verb+\opxxx+). Pour les fonctions \texttt{ceil}, \texttt{floor} et
\texttt{round}, le nombre \texttt{i} indique le rang sur lequel doit
se faire l'arrondi.

La macro \macro{opexpr} accepte un argument optionnel car elle peut
rÃ©aliser des divisions et que ces divisions doivent pouvoir Ãªtre
contrÃ´lÃ©es \emph{via} les paramÃ¨tres \parameter{maxdivstep},
\parameter{safedivstep} et \parameter{period}.
Notre premier exemple est assez basique :
\begin{CenterExample}[xrightmargin=0pt]
  \opexpr{3--gcd(15*17,25*27)*2}{r}%
  $3--\gcd(15\times17,25\times27)\times2 = \opprint{r}$
\end{CenterExample}

Voici un autre exemple montrant que des donnÃ©es peuvent provenir d'une
macro :
\begin{CenterExample}[xrightmargin=0pt]
  \newcommand\try{2}%
  \opexpr{\try+1/
    (\try+1/
      (\try+1/
        (\try+1/
          (\try+1/
            (\try)))))}{r}
  La fraction continue de base $u_n=2$ vaut \opprint{r} au rang~5.
\end{CenterExample}
\index{expression complexe|)}

\appendix
\chapter{Aide-mÃ©moire}
\label{chap:Aide-mÃ©moire}
\section{Temps de compilation}
\label{sec:Temps de compilation}
Les temps de compilation ont Ã©tÃ© mesurÃ©s sur une machine Ã&nbsp; processeur
Pentium~II~600\,MHz ayant 256\,Mo de RAM et tournant sous Linux
(Debian woody)\footnote{En rÃ©alitÃ©, ces mesures ont Ã©tÃ© effectuÃ©es en
  2004 lors de la sortie de la version 0.2. L'auteur Ã©tant fainÃ©ant,
  il n'a pas repris ces tests avec son matÃ©riel actuel (bien plus
  performant) !}. Le principe a Ã©tÃ© de faire un fichier TeX{} minimum
dont le schÃ©ma gÃ©nÃ©ral est donnÃ© par :
\begin{verbatim}
  \input xlop
  \count255=0
  \loop
  \ifnum\count255&lt;1000
    &lt;opÃ©ration Ã&nbsp; tester&gt;
   \advance\count255 by1
  \repeat
  \bye
\end{verbatim}
Le temps de compilation avec \verb+&lt;opÃ©ration Ã&nbsp; tester&gt;+ vide a Ã©tÃ©
soustrait des autres tests et seul le temps utilisateur a Ã©tÃ© pris en
compte. Les rÃ©sultats sont donnÃ©s en millisecondes et sont Ã©videmment
Ã&nbsp; prendre avec beaucoup de prÃ©cautions.

\index{compilation (temps de)|(}\index{temps de calcul|(}%
Le tableau suivant donne le temps de compilation des opÃ©rations en
millisecondes. Les opÃ©randes utilisÃ©es l'ont Ã©tÃ© avec une Ã©criture
sous forme de chiffres mais des essais avec des opÃ©randes sous forme
de noms de variables ont montrÃ© que les diffÃ©rences Ã©taient vraiment
minimes.

La premiÃ¨re ligne indique le nombre de chiffres des deux
opÃ©randes. Ces nombres ont Ã©tÃ© construits de la faÃ§on suivante :
\begin{itemize}
\item $\mathrm{A} = 1$ et $\mathrm{B} = 9$ pour un chiffre ;
\item $\mathrm{A} = 12$ et $\mathrm{B} = 98$ pour deux chiffres ;
\item $\mathrm{A} = 123$ et $\mathrm{B} = 987$ pour trois chiffres ;
\item $\mathrm{A} = 12345$ et $\mathrm{B} = 98765$ pour cinq chiffres ;
\item $\mathrm{A} = 1234567890$ et $\mathrm{B} = 9876543210$ pour dix
  chiffres ;
\item $\mathrm{A} = 12345678901234567890$ et $\mathrm{B} =
  98765432109876543210$ pour vingt chiffres ;
\end{itemize}
Voici les rÃ©sultats, quelques commentaires suivront :

\bigskip\noindent\hbox to\linewidth{\hss
  \begin{tabular}{|r|*{6}{l|}}
    \cline{2-7}
    \multicolumn{1}{l|}{} &amp;
    \multicolumn{1}{c|}{1} &amp;
    \multicolumn{1}{c|}{2} &amp;
    \multicolumn{1}{c|}{3} &amp;
    \multicolumn{1}{c|}{5} &amp;
    \multicolumn{1}{c|}{10} &amp;
    \multicolumn{1}{c|}{20} \\\hline
    \verb+\opadd*{A}{B}{r}+ &amp;
    1.1 &amp; 1.4 &amp; 1.6 &amp; 2.1 &amp; 3.3 &amp; 5.8 \\\cline{2-7}
    \verb+\opadd*{B}{A}{r}+ &amp;
    1.1 &amp; 1.4 &amp; 1.6 &amp; 2.1 &amp; 3.3 &amp; 5.8 \\\hline
    \verb+\opsub*{A}{B}{r}+ &amp;
    1.7 &amp; 2.1 &amp; 2.4 &amp; 3.0 &amp; 4.8 &amp; 8.3 \\\cline{2-7}
    \verb+\opsub*{B}{A}{r}+ &amp;
    1.5 &amp; 1.7 &amp; 2.0 &amp; 2.6 &amp; 4.0 &amp; 7.0 \\\hline
    \verb+\opmul*{A}{B}{r}+ &amp;
    4.6 &amp; 6.3 &amp; 8.2 &amp; 12.8 &amp; 29.9 &amp; 87.0 \\\cline{2-7}
    \verb+\opmul*{B}{A}{r}+ &amp;
    5.0 &amp; 6.6 &amp; 8.5 &amp; 13.2 &amp; 30.3 &amp; 87.8 \\\hline
    \verb+\opdiv*{A}{B}{q}{r}+ &amp;
    46.4 &amp; 53.8 &amp; 53.8 &amp; 64.3 &amp; 85.8 &amp; 124.7 \\\cline{2-7}
    \verb+\opdiv*{B}{A}{q}{r}+ &amp;
    12.4 &amp; 48.9 &amp; 55.7 &amp; 58.6 &amp; 72.8 &amp; 111.0 \\\hline
    \verb+\opdiv*[maxdivstep=5]{A}{B}{q}{r}+ &amp;
    26.8 &amp; 30.0 &amp; 32.6 &amp; 37.6 &amp; 49.5 &amp; 73.5 \\\cline{2-7}
    \verb+\opdiv*[maxdivstep=5]{B}{A}{q}{r}+ &amp;
    12.4 &amp; 29.1 &amp; 32.6 &amp; 35.2 &amp; 43.3 &amp; 67.9 \\\hline
    \verb+\opidiv*{A}{B}{q}{r}+ &amp;
    10.8 &amp; 12.2 &amp; 13.5 &amp; 16.0 &amp; 22.3 &amp; 35.5 \\\cline{2-7}
    \verb+\opidiv*{B}{A}{q}{r}+ &amp;
    11.6 &amp; 13.0 &amp; 14.2 &amp; 16.6 &amp; 23.0 &amp; 36.7 \\\hline
    \verb+\opidiv*{A}{2}{q}{r}+ &amp;
    10.7 &amp; 12.0 &amp; 15.3 &amp; 22.3 &amp; 42.9 &amp; 83.0 \\\hline
  \end{tabular}
  \hss
}
\par\bigskip
Il est normal que l'inversion des opÃ©randes n'ait aucune influence
pour l'addition. Il peut alors sembler anormal qu'elle en ait une pour
la soustraction mais en fait, avoir une seconde opÃ©rande supÃ©rieure Ã&nbsp;
la premiÃ¨re va entraÃ®ner quelques instructions supplÃ©mentaires (double
inversion, gestion plus longue du signe du rÃ©sultat).

Il est normal que le temps de la division soit supÃ©rieur Ã&nbsp; celui de la
multiplication. Il peut alors sembler anormal que la division ait
l'air de \og rattraper \fg{} son retard. En fait, une multiplication
voit sa complexitÃ© fortement augmenter avec la taille des opÃ©randes
mais la division normale est bloquÃ©e par le paramÃ¨tre
\parameter{maxdivstep}. On le voit bien sur l'exemple oÃ¹ on limite ce
maximum Ã&nbsp; 5~Ã©tapes.

Quelques rÃ©sultats semblent bizarres. Ainsi,
\verb+\opdiv*{9}{1}{q}{r}+ est anormalement rapide : cela est dÃ»
au fait d'avoir un quotient Ã&nbsp; un seul chiffre. Plus bizarre encore,
\verb+\opdiv*{123}{987}{q}{r}+ est plutÃ´t rapide. Ici,
l'explication est plus subtile : cela est dÃ» Ã&nbsp; la prÃ©sence de nombreux
zÃ©ros au quotient.

Avec des opÃ©randes de tailles comparables, la division euclidienne est
trÃ¨s rapide par rapport Ã&nbsp; la division non euclidienne. Cela est dÃ» au
fait que le quotient n'aura que peu de chiffres (un seul avec tous les
nombres \texttt{A} et \texttt{B}). La derniÃ¨re ligne du tableau est
plus reprÃ©sentative des temps de compilation que l'on peut obtenir
avec cette opÃ©ration.

Toutes ces remarques sont faites pour bien insister sur la difficultÃ©
Ã&nbsp; Ã©valuer un temps de compilation a priori : il dÃ©pend de trop de
paramÃ¨tres. Cela dit, le tableau permet d'avoir quand mÃªme une idÃ©e de
ce Ã&nbsp; quoi il faut s'attendre.
\index{compilation (temps de)|)}\index{temps de calcul|)}

\clearpage
\section{Liste des macros}
\label{sec:Liste des macros}
\noindent\index{macros!table des|(}%
\begin{longtable}{|l|p{6.3cm}|}
  \hline
  \multicolumn{1}{|c|}{\textbf{Macro}} &amp;
  \multicolumn{1}{c|}{\textbf{Description}} \\\hline\hline
  \endfirsthead
  \hline
  \multicolumn{1}{|c|}{\textbf{Macro}} &amp;
  \multicolumn{1}{c|}{\textbf{Description}} \\\hline\hline
  \endhead
  \hline
  \multicolumn{2}{|c|}{$\ldots$ Ã&nbsp; suivre $\ldots$}\\
  \hline
  \endfoot
  \hline
  \endlastfoot
  \verb+\opabs{n}{N}+ &amp;
  \verb+N+ reÃ§oit la valeur absolue de \verb+n+. \\\hline
  \verb+\opadd[P]{n1}{n2}+ &amp;
  Affiche le rÃ©sultat de l'opÃ©ration \verb-n1+n2-. \\\hline
  \verb+\opadd*{n1}{n2}{N}+ &amp;
  Calcule \verb-n1+n2- et place le rÃ©sultat dans
  \verb+N+. \\\hline
  \verb+\opcastingoutelevens{n}{N}+ &amp;
  Calcule la diffÃ©rence (modulo 11) de la somme des chiffres de rang
  impair et de la somme des chiffres de rang pair de \verb+n+ et
  place le rÃ©sultat dans \verb+N+. \\\hline
  \verb+\opcastingoutnines{n}{N}+. &amp;
  Calcule la somme modulo 9 des chiffres de \verb+n+ et place le
  rÃ©sultat dans \verb+N+. \\\hline
  \verb+\opceil{n}{T}{N}+ &amp;
  Place dans \verb+N+ la valeur approchÃ©e par excÃ¨s de
  \verb+n+ au rang \verb+T+. \\\hline
  \verb+\opcmp{n1}{n2}+ &amp;
  Compare les nombres \verb+n1+ et \verb+n2+ et rÃ©alise la
  mise Ã&nbsp; jour correspondante des tests \verb+\ifopeq+,
  \verb+\ifopneq+, \verb+\ifopgt+, \verb+\ifopge+,
  \verb+\ifople+ et \verb+\ifoplt+. \\\hline
  \verb+\opcopy{n}{N}+ &amp;
  Copie le nombre \verb+n+ dans \verb+N+. \\\hline
  \verb+\opdecimal{n}{N}+ &amp;
  Copie la partie dÃ©cimale (nombre entier positif) de \verb+n+
  dans \verb+N+. \\\hline
  \verb+\opdecimalwidth{n}{N}+ &amp;
  Le nombre \verb+N+ reÃ§oit la largeur de la partie dÃ©cimale du
  nombre \verb+n+. \\\hline
  \verb+\opdisplay[P]{S}{n}+ &amp;
  Affiche le nombre \verb+n+ avec le style \verb+S+ en
  plaÃ§ant chaque chiffre dans une boÃ®te de largeur
  \verb+\opcolumnwidth+ et de hauteur
  \verb+\oplineheight+. \\\hline
  \verb+\opdiv[P]{n1}{n2}+ &amp;
  Affiche le rÃ©sultat de l'opÃ©ration n1/n2. \\\hline
  \verb+\opdiv*[P]{n1}{n2}{N1}{N2}+ &amp;
  Calcule \verb+n1/n2+, place le quotient dans \verb+N1+ et
  le reste dans \verb+N2+. \\\hline
  \verb+\opdivperiod{T1}{T2}{N}+ &amp;
  Calcule la longueur de la pÃ©riode de la division de \verb+T1+
  par \verb+T2+ et place le rÃ©sultat dans \verb+N+. \\\hline
  \verb+\opexport[P]{n}\cmd+ &amp;
  Copie le nombre \verb+n+ dans la macro \verb+\cmd+. \\\hline
  \verb+\opexpr[P]{F}{N}+ &amp;
  Ã‰value la formule \texttt{F} est place le rÃ©sultat final dans le
  nombre \texttt{N}. \\\hline
  \verb+\opfloor{n}{T}{N}+ &amp;
  Place dans \verb+N+ la valeur approchÃ©e par dÃ©faut de
  \verb+n+ au rang \verb+T+. \\\hline
  \verb+\opgcd{T1}{T2}{N}+ &amp;
  Calcule le pgcd de \verb+T1+ et \verb+T2+ et place le
  rÃ©sultat dans \verb+N+. \\\hline
  \verb+\opgetdecimaldigit{n}{T}{N}+ &amp;
  Construit le nombre \verb+N+ avec le seul chiffre situÃ© en
  \verb+T+iÃ¨me position de la partie dÃ©cimale du nombre
  \verb+n+. \\\hline
  \verb+\opgetdigit{n}{T}{N}+ &amp;
  Construit le nombre \verb+N+ avec le seul chiffre situÃ© en
  \verb+T+iÃ¨me position du nombre \verb+n+. \\\hline
  \verb+\opgetintegerdigit{n}{T}{N}+ &amp;
  Construit le nombre \verb+N+ avec le seul chiffre situÃ© en
  \verb+T+iÃ¨me position de la partie entiÃ¨re du nombre
  \verb+n+. \\\hline
  \verb+\opgfsqrt{n}+ &amp;
  Affiche la faÃ§on ancienne d'afficher le calcul de la racine
  carrÃ©e de \verb+n+. \\\hline
  \verb+\ophline(T1,T2){T3}+ &amp;
  Trace un trait horizontal de longueur \verb+T3+, d'Ã©paisseur
  \verb+hrulewidth+ et dÃ©butant en \verb+(T1,T2)+ par
  rapport au point de rÃ©fÃ©rence. \\\hline
  \verb+\opidiv[P]{n1}{n2}+ &amp;
  Affiche le rÃ©sultat de l'opÃ©ration \verb+n1/n2+ (division
  euclidienne,   c'est-Ã&nbsp;-dire avec un quotient entier). \\\hline
  \verb+\opidiv*{n1}{n2}{N1}{N2}+ &amp;
  Calcule \verb+n1/n2+ (division euclidienne), place le quotient
  (entier) dans \verb+N1+ et le reste (compris entre 0 inclus et
  \verb+|n2|+ exclu) dans \verb+N2+. \\\hline
  \verb+\opinteger{n}{N}+ &amp;
  Copie la partie entiÃ¨re (nombre entier positif) de \verb+n+
  dans \verb+N+. \\\hline
  \verb+\opintegerwidth{n}{N}+ &amp;
  Le nombre \verb+N+ reÃ§oit la longueur de la partie entiÃ¨re du
  nombre \verb+n+. \\\hline
  \verb+\oplput(T1,T2){&lt;objet&gt;}+ &amp;
  Place \verb+&lt;objet&gt;+ Ã&nbsp; droite du point situÃ© en
  \verb+(T1,T2)+ par rapport au point de rÃ©fÃ©rence. \\\hline
  \verb+\opmanyadd[P]{n1}...{np}+ &amp;
  Affiche le rÃ©sultat de l'opÃ©ration
  $\mathrm{n1}+\cdots+\mathrm{np}$. \\\hline
  \verb+\opmul[P]{n1}{n2}+ &amp;
  Affiche le rÃ©sultat de l'opÃ©ration \verb+n1*n2+. \\\hline
  \verb+\opmul*{n1}{n2}{N}+ &amp;
  Calcule \verb+n1*n2+ et place le rÃ©sultat dans
  \verb+N+. \\\hline
  \verb+\opneg{n}{N}+ &amp;
  Le nombre \verb+N+ reÃ§oit l'opposÃ© de \verb+n+. \\\hline
  \verb+\oppower{n}{T}{N}+ &amp;
  Calcule \verb+n+ Ã&nbsp; la puissance \verb+T+ et place le
  rÃ©sultat dans \verb+N+. \\\hline
  \verb+\opprint{n}+ &amp;
  Affiche le nombre \verb+n+ de faÃ§on directe. \\\hline
  \verb+\opround{n}{T}{N}+ &amp;
  Place dans \verb+N+ la valeur arrondie de \verb+n+ au rang
  \verb+T+. \\\hline
  \verb+\oprput(T1,T2){&lt;objet&gt;}+ &amp;
  Place \verb+&lt;objet&gt;+ Ã&nbsp; gauche du point situÃ© en
  \verb+(T1,T2)+ par rapport au point de rÃ©fÃ©rence. \\\hline
  \verb+\opset{L}+ &amp;
  Effectue une affectation globale des paramÃ¨tres de \package{xlop}
  dÃ©signÃ©s dans la liste \verb+L+. \\\hline
  \verb+\opsetdecimaldigit{n}{T}{N}+ &amp;
  Modifie le \verb+T+iÃ¨me chiffre de la partie dÃ©cimale de
  \verb+N+ pour qu'il soit Ã©gal Ã&nbsp; \verb+n+. \\\hline
  \verb+\opsetdigit{n}{T}{N}+ &amp;
  Modifie le \verb+T+iÃ¨me chiffre de \verb+N+ pour qu'il
  soit Ã©gal Ã&nbsp; \verb+n+. \\\hline
  \verb+\opsetintegerdigit{n}{T}{N}+ &amp;
  Modifie le \verb+T+iÃ¨me chiffre de la partie entiÃ¨re de
  \verb+N+ pour qu'il soit Ã©gal Ã&nbsp; \verb+n+. \\\hline
  \verb+\opsqrt{n}{N}+ &amp;
  MÃ©morise la racine carrÃ©e de \verb+n+ dans \verb+N+. \\\hline
  \verb+\opsub[P]{n1}{n2}+ &amp;
  Affiche le rÃ©sultat de l'opÃ©ration n1-n2. \\\hline
  \verb+\opsub*{n1}{n2}{N}+ &amp;
  Calcule n1-n2 et place le rÃ©sultat dans N. \\\hline
  \verb+\opunzero{N}+ &amp;
  Supprime les zÃ©ros non significatifs du nombre \verb+N+. \\\hline
  \verb+\opvline(T1,T2){T3}+ &amp;
  Trace un trait vertical de longueur \verb+T3+, d'Ã©paisseur
  \verb+hrulewidth+ et dÃ©butant en \verb+(T1,T2)+ par
  rapport au point de rÃ©fÃ©rence. \\\hline
  \verb+\opwidth{n}{N}+ &amp;
  Le nombre \verb+N+ reÃ§oit le nombre de chiffres du nombre
  \verb+n+. \\\hline
\end{longtable}\index{macros!table des|)}

Dans ce tableau, les paramÃ¨tres :
\begin{itemize}
\item \texttt{n} et \texttt{ni} (oÃ¹ \texttt{i} reprÃ©sente un indice)
  indiquent que le paramÃ¨tre doit Ãªtre un nombre donnÃ© sous forme
  dÃ©cimale ou sous forme d'un nom de variable ;
\item \texttt{N} et \texttt{Ni} (oÃ¹ \texttt{i} reprÃ©sente un indice)
  indiquent que le paramÃ¨tre doit Ãªtre un nombre donnÃ© sous forme d'un
  nom de variable ;
\item \texttt{[P]} indique que la macro accepte un paramÃ¨tre optionnel
  permettant de modifier les paramÃ¨tres de \package{xlop} ;
\item \texttt{T} et \texttt{Ti} (oÃ¹ \texttt{i} reprÃ©sente un indice)
  indiquent que le paramÃ¨tre doit Ãªtre un nombre donnÃ© sous forme
  dÃ©cimale ou sous forme d'un nom de variable mais ne devant pas
  excÃ©der la taille des nombres directement acceptables par \TeX{}
  ($-2147483648 \le \mathtt{T} \le 2147483647$ en l'occurrence).
\end{itemize}

\newpage
\section{Liste des paramÃ¨tres}
\label{sec:Liste des parametres}
\index{parametres@paramÃ¨tres!table des|(}%
\begingroup
\advance\hoffset by-1.75cm \advance\linewidth by1.75cm
\begin{longtable}{|l|l|p{7cm}|}
  \hline
  \multicolumn{1}{|c|}{\textbf{ParamÃ¨tre}} &amp;
  \multicolumn{1}{c|}{\textbf{DÃ©faut}} &amp;
  \multicolumn{1}{c|}{\textbf{Signification}} \\\hline\hline
  \endfirsthead
  \hline
  \multicolumn{1}{|c|}{\textbf{ParamÃ¨tre}} &amp;
  \multicolumn{1}{c|}{\textbf{DÃ©faut}} &amp;
  \multicolumn{1}{c|}{\textbf{Signification}} \\\hline\hline
  \endhead
  \hline
  \multicolumn{3}{|c|}{$\ldots$ Ã&nbsp; suivre $\ldots$}\\
  \hline
  \endfoot
  \hline
  \endlastfoot
  \verb+afterperiodsymbol+ &amp;
  \verb+$\ldots$+ &amp;
  Symbole utilisÃ© Ã&nbsp; la suite de la pÃ©riode d'une division. \\\hline
  \verb+approxsymbol+ &amp;
  \verb+$\approx$+ &amp;
  Symbole utilisÃ© comme relation d'Ã©galitÃ© approximative dans les
  opÃ©rations en ligne. \\\hline
  \verb+equalsymbol+ &amp;
  \verb+{$=$}+ &amp;
  Symbole utilisÃ© comme relation d'Ã©galitÃ© dans les opÃ©rations en
  ligne. \\\hline
  \verb+addsymbol+ &amp;
  \verb-$+$- &amp;
  Symbole utilisÃ© comme opÃ©rateur d'addition. \\\hline
  \verb+subsymbol+ &amp;
  \verb+$-$+ &amp;
  Symbole utilisÃ© comme opÃ©rateur de soustraction. \\\hline
  \verb+mulsymbol+ &amp;
  \verb+$\times$+ &amp;
  Symbole utilisÃ© comme opÃ©rateur de  multiplication. \\\hline
  \verb+divsymbol+ &amp;
  \verb+$\div$+ &amp;
  Symbole utilisÃ© comme opÃ©rateur de division pour les opÃ©rations en
  ligne. \\\hline
  \verb+decimalsepsymbol+ &amp;
  \verb+.+ &amp;
  Symbole utilisÃ© comme sÃ©parateur dÃ©cimal. \\\hline
  \verb+strikedecimalsepsymbol+ &amp;
  &amp;
  Symbole utilisÃ© pour un sÃ©parateur dÃ©cimal dÃ©placÃ© au niveau du
  dividende et du diviseur dans les divisions posÃ©es. \\\hline
  \verb+shiftintermediarysymbol+ &amp;
  \verb+$\cdot$+ &amp;
  Symbole utilisÃ© pour montrer les dÃ©calages des nombres
  intermÃ©diaires dans les multiplications posÃ©es. \\\hline
  \verb+displayshiftintermediary+ &amp;
  \verb+shift+ &amp;
  Indique que le caractÃ¨re de dÃ©calage dans les multiplications sera
  affichÃ© uniquement pour le dÃ©calage supplÃ©mentaire (valeur
  \verb+shift+), pour tous les dÃ©calages (valeur \verb+all+)
  ou jamais (valeur \verb+none+). \\\hline
  \verb+vmanyoperator+ &amp;
  \verb+center+ &amp;
  Positionnement vertical des opÃ©rateurs. La valeur \verb+top+ place
  les opÃ©rateurs en face des opÃ©randes, de la premiÃ¨re opÃ©rande
  jusqu'Ã&nbsp; l'avant-derniÃ¨re. La valeur \verb+center+ place les
  opÃ©rateurs entre les opÃ©randes. La valeur \verb+bottom+ place les
  opÃ©rateurs en face des opÃ©randes, de la deuxiÃ¨me opÃ©rande jusqu'Ã&nbsp; la
  derniÃ¨re. La valeur \verb+Top+ place un unique opÃ©rateur au niveau
  de la premiÃ¨re opÃ©rande. La valeur \verb+\center+ place un unique
  opÃ©rateur au milieu vertical des opÃ©randes. La valeur
  \verb+Bottom+ place un unique opÃ©rateur au niveau de la derniÃ¨re
  opÃ©rande. \\\hline
  \verb+voperation+ &amp;
  \verb+bottom+ &amp;
  Type d'alignement vertical d'une opÃ©ration posÃ©e. La
  valeur \verb+bottom+ indique que le bas de l'opÃ©ration sera
  au niveau de la ligne de base. La valeur \verb+top+ indique
  que la premiÃ¨re ligne de l'opÃ©ration sera sur la ligne de base. La
  valeur \verb+center+ indique que l'opÃ©ration sera centrÃ©e
  verticalement sur la ligne de base. \\\hline
  \verb+voperator+ &amp;
  \verb+center+ &amp;
  Positionnement vertical de l'opÃ©rateur dans les
  opÃ©rations posÃ©es. La valeur \verb+top+ place l'opÃ©rateur au
  niveau de la premiÃ¨re opÃ©rande. La valeur \verb+bottom+ place
  l'opÃ©rateur au niveau de la seconde opÃ©rande. La valeur
  \verb+center+ place l'opÃ©rateur entre les deux
  opÃ©randes. \\\hline
  \verb+hfactor+ &amp;
  \verb+decimal+ &amp;
  Type d'alignement des opÃ©randes dans les
  multiplications posÃ©es. La valeur \verb+decimal+ indique un
  alignement sur la virgule. La valeur \verb+right+ indique une
  composition au fer Ã&nbsp; droite. \\\hline
  \verb+vruleperiod+ &amp;
  \verb+-0.2+ &amp;
  Position verticale du trait indiquant la pÃ©riode du quotient
  dans les divisions en ligne. \\\hline
  \verb+dividendbridge+ &amp;
  \verb+false+ &amp;
  Indique si le \og pont \fg{} au-dessus du dividende est prÃ©sent ou
  non. \\\hline
  \verb+shiftdecimalsep+ &amp;
  \verb+both+ &amp;
  Indique la faÃ§on dont se fait le dÃ©calage de virgule au niveau des
  opÃ©randes d'une division posÃ©e. La valeur \verb+both+ indique
  que le dÃ©calage doit rendre le diviseur et le dividende
  entiers. La valeur \verb+divisor+ indique que le dÃ©calage
  doit rendre le diviseur entier. La valeur \verb+none+ indique
  qu'il n'y aura aucun dÃ©calage. \\\hline
  \verb+maxdivstep+ &amp;
  \verb+10+ &amp;
  Nombre d'Ã©tapes maximum d'une division. \\\hline
  \verb+safedivstep+ &amp;
  \verb+50+ &amp;
  Nombre d'Ã©tapes maximum d'une division lors d'un arrÃªt sur
  pÃ©riode. \\\hline
  \verb+period+ &amp;
  \verb+false+ &amp;
  Indique si la division doit s'arrÃªter sur une dÃ©tection de pÃ©riode
  ou non. \\\hline
  \verb+deletezero+ &amp;
  \verb+true+ &amp;
  Indique si on affiche (\verb+false+) ou on supprime
  (\verb+true+) les zÃ©ros non significatifs. \\\hline
  \verb+carryadd+ &amp;
  \verb+true+ &amp;
  Indique si les retenues doivent Ãªtre affichÃ©es pour les additions
  posÃ©es. \\\hline
  \verb+carrysub+ &amp;
  \verb+false+ &amp;
  Indique si les retenues doivent Ãªtre affichÃ©es pour les
  soustractions posÃ©es. \\\hline
  \verb+offsetcarry+ &amp;
  \verb+-0.35+ &amp;
  DÃ©calage horizontal pour les retenues dans les
  soustractions posÃ©es. \\\hline
  \verb+style+ &amp;
  \verb+display+ &amp;
  Indique si l'opÃ©ration doit Ãªtre en ligne (\verb+text+) ou
  posÃ©e (\verb+display+). \\\hline
  \verb+displayintermediary+ &amp;
  \verb+nonzero+ &amp;
  Indique si les rÃ©sultats intermÃ©diaires doivent Ãªtre affichÃ©s
  (\verb+all+) ou seulement les non nuls (\verb+nonzero+) ou
  aucun (valeur \verb+none+) dans les multiplications et les
  divisions. \\\hline
  \verb+lastcarry+ &amp;
  \verb+false+ &amp;
  Indique si la retenue au niveau d'une absence de chiffre devra
  Ãªtre affichÃ©e ou non. \\\hline
  \verb+parenthesisnegative+ &amp;
  \verb+none+ &amp;
  Comportement Ã&nbsp; adopter pour l'affichage des nombres
  nÃ©gatifs dans les opÃ©rations en lignes. La valeur \verb+none+
  les affiche sans parenthÃ¨se, \verb+all+ les mettra
  systÃ©matiquement les nombres nÃ©gatifs entre parenthÃ¨ses et
  \verb+last+ les mettra entre parenthÃ¨ses
  sauf pour la premiÃ¨re valeur d'une expression. \\\hline
  \verb+columnwidth+ &amp;
  \verb+2ex+ &amp;
  Largeur des boÃ®tes contenant un chiffre. \\\hline
  \verb+lineheight+ &amp;
  \verb+\baselineskip+ &amp;
  Hauteur des boÃ®tes contenant un chiffre. \\\hline
  \verb+decimalsepwidth+ &amp;
  \verb+0pt+ &amp;
  Largeur de la boÃ®te contenant le sÃ©parateur dÃ©cimal. \\\hline
  \verb+decimalsepoffset+ &amp;
  \verb+0pt+ &amp;
  DÃ©calage horizontal du sÃ©parateur dÃ©cimal. \\\hline
  \verb+hrulewidth+ &amp;
  \verb+0.4pt+ &amp;
  Ã‰paisseur des lignes horizontales. \\\hline
  \verb+vrulewidth+ &amp;
  \verb+0.4pt+ &amp;
  Ã‰paisseur des lignes verticales. \\\hline
  \verb+behaviorsub+ &amp;
  \verb+silent+ &amp;
  Comportement de \package{xlop} face Ã&nbsp; une
  soustraction \og impossible \fg{}, c'est-Ã&nbsp;-dire une soustraction
  ayant ses deux opÃ©randes positives avec une seconde opÃ©rande
  strictement supÃ©rieure Ã&nbsp; la premiÃ¨re. La valeur \verb+silent+
  effectuera l'opÃ©ration en permutant les opÃ©randes de faÃ§on
  silencieuse. La valeur \verb+warning+ fera de mÃªme mais en
  Ã©mettant un message d'avertissement. Enfin, la valeur
  \verb+error+ affichera un message d'erreur et l'opÃ©ration ne
  sera pas effectuÃ©e. \\\hline
  \verb+country+ &amp;
  \verb+french+ &amp;
  Indique le comportement des opÃ©rations posÃ©es en fonction du
  pays. L'extension prÃ©voit pour l'instant \verb+french+,
  \verb+american+ et \verb+russian+ mais les diffÃ©rentes
  faÃ§ons de prÃ©senter les opÃ©rations ne sont pas implantÃ©es dans la
  version 0.2. \\\hline
  \verb+operandstyle+ &amp;
  &amp;
  Style utilisÃ© pour les opÃ©randes. \\\hline
  \verb+resultstyle+ &amp;
  &amp;
  Style utilisÃ© pour les rÃ©sultats. \\\hline
  \verb+remainderstyle+ &amp;
  &amp;
  Style utilisÃ© pour les restes. \\\hline
  \verb+intermediarystyle+ &amp;
  &amp;
  Style utilisÃ© pour les rÃ©sultats intermÃ©diaires (nombres
  intermÃ©diaires dans une multiplication et nombres Ã&nbsp; soustraire
  dans une division oÃ¹ apparaissent les soustractions
  successives). \\\hline
  \verb+carrystyle+ &amp;
  \verb+\scriptsize+ &amp;
  Style utilisÃ© pour les retenues. La valeur par dÃ©faut lorsqu'on ne
  compile pas sous \LaTeX{} est \verb+\sevenrm+. \\\hline
\end{longtable}\index{parametres@paramÃ¨tres!table des|)}
\newpage\endgroup

\chapter{Trucs et astuces}
\label{chap:Trucs et astuces}
\section{Comparaison avec \package{calc} et \package{xfp}}
On pourrait croire que \package{xlop} puisse remplacer avantageusement
des extensions telles que
\package{calc}\index{extension!calc}\index{calc} et
\package{xfp}\index{extension!xfp}\index{xfp}. En rÃ©alitÃ©, c'est un
peu plus compliquÃ© que cela. Bien sÃ»r, \package{xlop} permet des
calculs complexes et sur des nombres comportant un nombre arbitraire
de chiffres mais, contrairement Ã&nbsp; \package{calc}, il ne permet pas de
gÃ©rer directement les unitÃ©s. La comparaison avec \package{xfp} est un
peu plus rÃ©aliste mais il ne faut pas perdre de vue que \package{xlop}
peut devenir gourmand en mÃ©moire et en temps de calcul. En rÃ©alitÃ©,
\package{xfp} est bien plus efficace que \package{xlop} en ce qui
concerne les calculs purs.

Si vous voulez vraiment rÃ©aliser des calculs sur des
longueurs\index{longueur}, vous pouvez toujours utiliser le fait
qu'une affectation d'un registre de longueur Ã&nbsp; un compteur donnera un
nombre correspondant Ã&nbsp; cette longueur avec l'unitÃ© \texttt{sp}.
\begin{CenterExample}[xrightmargin=0pt]
  \newcommand\getsize[2]{%
    \dimen0=#1\relax
    \count255=\dimen0
    \opcopy{\the\count255}{#2}}
  \getsize{1pt}{r}$1\,\mathrm{pt}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1pc}{r}$1\,\mathrm{pc}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1in}{r}$1\,\mathrm{in}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1bp}{r}$1\,\mathrm{bp}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1cm}{r}$1\,\mathrm{cm}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1mm}{r}$1\,\mathrm{mm}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1dd}{r}$1\,\mathrm{dd}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1cc}{r}$1\,\mathrm{cc}=\opprint{r}\,\mathrm{sp}$\quad
  \getsize{1sp}{r}$1\,\mathrm{sp}=\opprint{r}\,\mathrm{sp}$\quad
\end{CenterExample}
N'oubliez cependant pas que le but principal de \package{xlop} est
d'\emph{afficher} automatiquement les opÃ©rations.

Muni de la macro \macro{getsize}, il est possible de rÃ©aliser des
calculs sur des longueurs.
\newcommand\getsize[2]{%
  \dimen0=#1\relax
  \count255=\dimen0
  \opcopy{\the\count255}{#2}
}\par\vspace{-\baselineskip}\noindent
\vbox to0cm{\parindent=0pt\vbox to2.5cm{\vss
  \getsize{1cm}{u}%
  \getsize{\textwidth}{w}%
  \getsize{\textheight}{h}%
  \opexpr{w*h/u^2}{S}%
  \opround{S}{2}{S}%
  \begin{minipage}{4.3cm}
    La surface d'empagement est de
  \opprint{S}\,$\mathrm{cm}^2$
  \end{minipage}}}
\begin{Verbatim}[xleftmargin=5cm,xrightmargin=0pt]
  \getsize{1cm}{u}%
  \getsize{\textwidth}{w}%
  \getsize{\textheight}{h}%
  \opexpr{w*h/u^2}{S}%
  \opround{S}{2}{S}%
  La surface d'empagement est de
  \opprint{S}\,$\mathrm{cm}^2$
\end{Verbatim}

\section{CrÃ©ation d'opÃ©rations complexes}
\label{sec:Creation d'operations complexes}
L'utilisation des macros de \package{xlop} associÃ©es au mÃ©canisme de
boucle de \TeX{} permet de crÃ©er des opÃ©rations Ã&nbsp; volontÃ©. Nous ne
donnerons que deux exemples. Le premier est la dÃ©composition d'un
nombre en facteurs premiers, le second est un calcul gÃ©nÃ©ral de
fraction continue.\index{nombre!premier}\index{boucle|(}%
\index{decomposition@dÃ©composition en nombres premiers}
\begin{Verbatim}[xrightmargin=0pt]
  \newcount\primeindex
  \newcount\tryindex
  \newif\ifprime
  \newif\ifagain
  \newcommand\getprime[1]{%
    \opcopy{2}{P0}%
    \opcopy{3}{P1}%
    \opcopy{5}{try}
    \primeindex=2
    \loop
      \ifnum\primeindex&lt;#1\relax
      \testprimality
      \ifprime
        \opcopy{try}{P\the\primeindex}%
        \advance\primeindex by1
      \fi
      \opadd*{try}{2}{try}%
      \ifnum\primeindex&lt;#1\relax
        \testprimality
        \ifprime
          \opcopy{try}{P\the\primeindex}%
          \advance\primeindex by1
        \fi
        \opadd*{try}{4}{try}%
      \fi
    \repeat
  }
  \newcommand\testprimality{%
    \begingroup
      \againtrue
      \global\primetrue
      \tryindex=0
      \loop
        \opidiv*{try}{P\the\tryindex}{q}{r}%
        \opcmp{r}{0}%
        \ifopeq \global\primefalse \againfalse \fi
        \opcmp{q}{P\the\tryindex}%
        \ifoplt \againfalse \fi
        \advance\tryindex by1
      \ifagain
      \repeat
    \endgroup
  }
\end{Verbatim}
\newcount\primeindex
\newcount\tryindex
\newif\ifprime
\newif\ifagain
\newcommand\getprime[1]{%
  \opcopy{2}{P0}%
  \opcopy{3}{P1}%
  \opcopy{5}{try}
  \primeindex=2
  \loop
  \ifnum\primeindex&lt;#1\relax
    \testprimality
    \ifprime
      \opcopy{try}{P\the\primeindex}%
      \advance\primeindex by1
    \fi
    \opadd*{try}{2}{try}%
    \ifnum\primeindex&lt;#1\relax
      \testprimality
      \ifprime
        \opcopy{try}{P\the\primeindex}%
        \advance\primeindex by1
      \fi
      \opadd*{try}{4}{try}%
    \fi
  \repeat
}
\newcommand\testprimality{%
  \begingroup
    \againtrue
    \global\primetrue
    \tryindex=0
    \loop
      \opidiv*{try}{P\the\tryindex}{q}{r}%
      \opcmp{r}{0}%
      \ifopeq \global\primefalse \againfalse \fi
      \opcmp{q}{P\the\tryindex}%
      \ifoplt \againfalse \fi
      \advance\tryindex by1
    \ifagain
    \repeat
  \endgroup
}

Avec ce code, on dispose d'un moyen de crÃ©er une liste de nombres
premiers (en l'occurrence les 20~premiers).
\begin{SideBySideExample}
  \getprime{20}%
  \opprint{P0}, \opprint{P1}, \ldots,
  \opprint{P9}, \ldots \opprint{P19}.
\end{SideBySideExample}

On notera toutefois que ce code est trÃ¨s mauvais, il est excessivement
lent et n'apporte rien par rapport Ã&nbsp; une approche directe avec des
nombres manipulÃ©s par les opÃ©rations natives de \TeX{}. Ce n'est
qu'un exemple pÃ©dagogique. On notera Ã©galement l'astuce permettant
d'emboÃ®ter deux boucles avec la macro \verb+\testprimality+
entiÃ¨rement mise dans un groupe : s'il est nÃ©cessaire de rendre les
affectations \verb+\primetrue+ et \verb+\primefalse+ globales, les
opÃ©rations de \package{xlop} rendent leurs rÃ©sultats globaux
directement.\index{affectation globale}%

Une fois que vous avez votre \og table \fg{} de nombres premiers, vous
pouvez vous en servir pour dÃ©composer un nombre en facteurs
premiers.
\begin{CenterExample}[xrightmargin=0pt]
  \newcommand\primedecomp[2][nil]{%
    \begingroup
      \opset{#1}%
      \opcopy{#2}{NbtoDecompose}%
      \opabs{NbtoDecompose}{NbtoDecompose}%
      \opinteger{NbtoDecompose}{NbtoDecompose}%
      \opcmp{NbtoDecompose}{0}%
      \ifopeq
        Je refuse de d\'ecomposer z\'ero.
      \else
        \setbox1=\hbox{\opdisplay{operandstyle.1}%
            {NbtoDecompose}}%
        {\setbox2=\box2{}}%
        \count255=1
        \primeindex=0
        \loop
        \opcmp{NbtoDecompose}{1}\ifopneq
          \opidiv*{NbtoDecompose}{P\the\primeindex}{q}{r}%
          \opcmp{0}{r}\ifopeq
            \ifvoid2
              \setbox2=\hbox{%
                \opdisplay{intermediarystyle.\the\count255}%
                  {P\the\primeindex}}%
            \else
              \setbox2=\vtop{%
                \hbox{\box2}
                \hbox{%
                  \opdisplay{intermediarystyle.\the\count255}%
                    {P\the\primeindex}}}
            \fi
            \opcopy{q}{NbtoDecompose}%
            \advance\count255 by1
            \setbox1=\vtop{%
              \hbox{\box1}
              \hbox{%
                \opdisplay{operandstyle.\the\count255}%
                  {NbtoDecompose}}
            }%
          \else
            \advance\primeindex by1
          \fi
        \repeat
        \hbox{\box1
          \kern0.5\opcolumnwidth
          \opvline(0,0.75){\the\count255.25}
          \kern0.5\opcolumnwidth
          \box2}%
      \fi
    \endgroup
  }

  \getprime{20}%
  \primedecomp[operandstyle.2=\red,
               intermediarystyle.2=\red]{252}
\end{CenterExample}
Dans ce code, on notera l'emploi d'un groupe entourant l'ensemble de
la macro pour protÃ©ger les modifications de paramÃ¨tres de
\package{xlop}.\index{parametre@paramÃ¨tre!modifications locales}
\`A ce propos, on notera Ã©galement qu'un paramÃ¨tre vide n'est pas
acceptÃ©. C'est tout Ã&nbsp; fait volontaire, l'auteur de l'extension pensant
qu'un utilisateur tapant des crochets sans rien mettre Ã&nbsp; l'intÃ©rieur
est sans doute en train de commettre une erreur. Pour pallier Ã&nbsp; cette
impossibilitÃ© de transmettre un paramÃ¨tre vide
\index{parametre@paramÃ¨tre!vide}%
il existe le paramÃ¨tre particulier \parameter{nil} qui a exactement ce
rÃ´le.
\index{boucle|)}

On notera enfin l'astuce \verb+{\setbox2=\box2}+ qui permet
d'obtenir un registre de boÃ®te vide et les manipulations finales
permettant de reprÃ©senter la barre verticale de faÃ§on lisible.

Le second exemple permet de calculer une fraction continue du type :
\def\dfrac#1#2{\frac{\displaystyle #1}{\displaystyle #2}}
\[a_0+\dfrac{1}{a_1+\dfrac{1}{a_2+\dfrac{1}{a_3+\cdots}}}\]
en donnant la suite $a_0,a_1,a_2,a_3,\ldots$ Ã&nbsp; la macro. L'exemple
donne les fractions correspondant au nombre d'or et aux racines
carrÃ©es de~2 et~3.
\makeatletter
\begin{CenterExample}[xrightmargin=0pt]
  \begingroup
  \catcode`\:=12
  \long\gdef\continuedfraction#1#2{%
    \let\@mirror\relax
    \@for\op@Nb:=#1\do
    {%
      \ifx\@mirror\relax
        \edef\@mirror{\op@Nb}%
      \else
        \edef\@mirror{\op@Nb,\@mirror}%
      \fi
    }%
    \let\Op@result\relax
    \@for\op@Nb:=\@mirror\do
    {%
      \ifx\Op@result\relax
        \opcopy{\op@Nb}{result}%
      \else
        \opexpr{\op@Nb+1/result}{result}%
      \fi
    }%
    \opcopy{result}{#2}%
  }
  \endgroup
  \continuedfraction{1,1,1,1,1,1,1,1,1,1,1,1}{r}\opprint{r}\quad
  \continuedfraction{1,2,2,2,2,2,2,2,2,2,2,2}{r}\opprint{r}\quad
  \continuedfraction{1,1,2,1,2,1,2,1,2,1,2,1}{r}\opprint{r}
\end{CenterExample}
\makeatother
Une fois n'est pas coutume, nous avons fait appel Ã&nbsp; des commandes
\LaTeX{} pour effectuer une boucle. Ce manuel Ã©tant composÃ© en
franÃ§ais, le caractÃ¨re \og \texttt{\string:} \fg{} est actif ce qui
empÃªche la macro \verb+\@for+ de fonctionner correctement d'oÃ¹ le
groupe oÃ¹ ce caractÃ¨re reÃ§oit un code de catÃ©gorie adÃ©quat.

\section{AccÃ¨s direct aux nombres}
\label{sec:Acces direct aux nombres}
Lorsqu'on rÃ©cupÃ¨re un nombre dans une variable, on peut le traiter de
multiples faÃ§ons Ã&nbsp; l'aide des macros de \package{xlop}. Toutefois,
dans certaines situations, on peut souhaiter construire ses propres
macros ou utiliser des macros externes en passant un tel nombre en
paramÃ¨tre.

Passer directement \verb+\opprint{var}+ est inopÃ©rant car cette macro
est suffisamment complexe pour induire des effets de bord dans ce
genre de situations. Il devient alors nÃ©cessaire d'accÃ©der directement
Ã&nbsp; ce nombre. Lorsqu'un nombre est mÃ©morisÃ© dans une variable
\verb+var+, \package{xlop} crÃ©e une macro
\texttt{$\backslash$Op@var}\index{Opvar@\texttt{\boi {Op\at var}}}
qui contient
ce nombre. On notera le \og O \fg{} majuscule et le \og p \fg{}
minuscule. L'arrobas est lÃ&nbsp; pour rendre cette dÃ©finition privÃ©e
c'est-Ã&nbsp;-dire qu'il faut faire un effort pour y accÃ©der avec
l'utilisation des macros \macro{makeatletter} et \macro{makeatother}
de \LaTeX{} ou bien en indiquant un code de catÃ©gorie Ã©gal Ã&nbsp;~11
(lettre) pour ce caractÃ¨re lorsqu'on travaille sous \TeX{}.
\begin{SideBySideExample}
  \opcopy{1234}{a}\opcopy{56}{b}%
  \opmul*{a}{b}{r}%
  \makeatletter
  $\nombre{\Op@a} \times 
   \nombre{\Op@b} = \nombre{\Op@r}$
  \makeatother
\end{SideBySideExample}

On notera que cette faÃ§on de faire ne fonctionne plus forcÃ©ment
lorsque le sÃ©parateur dÃ©cimal est entre accolade car la macro
\verb+\opprint{var}+ contiendra ces accolades. Dans ce cas, le plus
simple est de passer par la macro \macro{opexport} dÃ©crite Ã&nbsp; la
page~\pageref{macro-opexport}.

\chapter{Versions futures}
\label{chap:Versions futures}
L'extension \package{xlop} en est Ã&nbsp; sa version~\fileversion{} qui
n'est qu'une version dÃ©boguÃ©e de la version~0.2 qui est elle mÃªme
essentiellement une version corrigÃ©e de la version~0.1 (premiÃ¨re
version publique). La prochaine version sera la~0.3 dont la version
\og stable \fg{} sera alors la version~0.4.

L'ensemble des spÃ©cificitÃ©s de la version 0.3 n'est pas totalement
arrÃªtÃ© mais il y a dÃ©jÃ&nbsp; plusieurs points prÃ©vus :
\begin{itemize}
\item gestion internationale des opÃ©rations posÃ©es ;
\item opÃ©rations en base 2 Ã&nbsp; 36 ;
\item ajout de fonctions de haut niveau avec les racines
  (\macro{oproot} pour les racines quelconques et \macro{opsqrt} pour
  la racine carrÃ©e), exponentielle, logarithme, fonctions
  trigonomÃ©triques (directes, inverses, hyperboliques) en passant par
  l'extension \package{xfp} qui est une version dÃ©boguÃ©e (par
  l'auteur) de l'extension \package{fp} ;
\item ajout d'une macro permettant de rÃ©aliser une Ã©criture formatÃ©e,
  c'est-Ã&nbsp;-dire une Ã©criture d'un nombre oÃ¹ les longueurs des parties
  entiÃ¨re et dÃ©cimale seront indiquÃ©es (si ces longueurs ne sont pas
  celles du nombre, il y aura un dÃ©bordement ou un remplissage) ;
  cette macro existait dans la version~0.1 et permettait
  essentiellement d'afficher des nombres avec un alignement sur la
  virgule, au fer Ã&nbsp; droite ou au fer Ã&nbsp; gauche ;
\item ajout d'un paramÃ¨tre permettant l'Ã©criture scientifique ou
  ingÃ©nieur ;
\item possibilitÃ© d'Ã©crire un nombre sur plusieurs lignes et/ou en
  utilisant un sÃ©parateur des milliers ;
\item retenues dans les multiplications ;
\item rendre publics les restes successives d'une division ;
\item les valeurs nÃ©gatives de \parameter{maxdivstep} et
  \parameter{safedivstep} rÃ©aliseront un comptage sur les chiffres
  dÃ©cimaux du quotient ;
\item manuel en anglais.
\end{itemize}

Pour toute demande ou rapport de bogue, l'auteur vous sera
Ã©ternellement reconnaissant de le contacter Ã&nbsp; l'adresse :
\begin{verbatim}
    Jean-Come.Charpentier@wanadoo.fr
\end{verbatim}
en plaÃ§ant le mot \og \texttt{xlop} \fg{} dans le sujet du message.

Il serait souhaitable d'avoir un manuel du hacker qui expliquerait en
dÃ©tail le code source. Cet outil pourrait Ãªtre tout Ã&nbsp; fait bÃ©nÃ©fique
pour que chacun puisse apporter plus facilement des amÃ©liorations au
code. Malheureusement, le code actuel fait plus de~\nombre{4000}
lignes et le travail nÃ©cessaire risque d'Ãªtre trop important.
Ã‰ventuellement, il pourra y avoir un manuel du hacker expliquant les
spÃ©cifications gÃ©nÃ©rales du code sans entrer dans trop de dÃ©tails
techniques.

%\printindex
\chapter{Index}
\label{chap:index}
\begin{multicols}{2}
\makeatletter
\parindent \z@\relax
\parskip \z@ \@plus.3\p@\relax
\let\item\@idxitem
\makeatother
\renewenvironment{theindex}{}{}%
\input\jobname.ind
\end{multicols}
\end{document}
</pre></body></html>