path: root/info/apprendre-a-programmer-en-tex/source/progtexmacro.tex

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                                                          %%
%%                      Macros définies dans le livre                       %%
%%                    « Apprendre à programmer en TeX »                     %%
%%                     et nécessaires à sa compilation                      %%
%%                                                                          %%
%%                           Encodage ISO 8859-1                            %%
%%                                   _____                                  %%
%%                                                                          %%
%%                        © 2014 Christian Tellechea                        %%
%%                                                                          %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                                                          %%
%%  Ce fichier contient celles des macros définies dans le livre qui sont   %%
%%  nécessaires à sa compilation.                                           %%
%%                                                                          %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Les codes et les macros donnés dans ce fichier sont diffusés sous licence
% libre « Creative Commons "BY-SA" ».
%
% https://creativecommons.org/licenses/by-sa/4.0/
% https://creativecommons.org/licenses/by-sa/4.0/legalcode
%
% Vous êtes autorisé à
%
%   * partager : copier, distribuer et communiquer le matériel par tous moyens
%     et sous tous formats ;
%   * adapter : remixer, transformer et créer à partir du matériel pour toute
%     utilisation, y compris commerciale
%
% selon les conditions suivantes
%
%   * paternité : vous devez citer le nom de l'auteur de façon appropriée,
%     fournir un lien vers la licence, et indiquer si des modifications ont
%     été apportées. Vous pouvez le faire de manière raisonnable, mais pas
%     d'une façon qui suggère le donneur de licence vous approuve ou approuve
%     l'utilisation que vous en faites ;
%   * partage dans les mêmes conditions : dans le cas où vous effectuez un
%     remix, que vous transformez, ou créez à partir du matériel composant
%     l'Oeuvre originale, vous devez diffuser l'Oeuvre modifiée dans les mêmes
%     conditions, c'est-à-dire avec la même licence avec laquelle l'Oeuvre
%     originale a été diffusée.
%
%
% Les commentaires dont sont assorties les macros dans le livre ne sont pas
% sous licence libre et ne sont pas reproduits dans ce fichier.

\edef\restoreatcoatcode{\catcode`\noexpand\@=\the\catcode`\@}
\catcode`\@11
{\def\:{\let\sptoken= }\expandafter}\: %

\long\def\gobone#1{}

\long\def\identity#1{#1}

\long\def\firstoftwo#1#2{#1}

\long\def\secondoftwo#1#2{#2}

\def\gobtwo#1#2{}%

\def\defactive#1{%
    \catcode`#1=13
    \begingroup
    \lccode`~=`#1
    \lowercase{\endgroup\def~}}

\def\letactive#1{%
    \catcode`#1=13
    \begingroup
    \lccode`~=`#1
    \lowercase{\endgroup\let~}}

\def\litterate#1{% #1=lit le token frontière choisi
	\begingroup% ouvre un groupe pour y faire les modifications
		\def\do##1{\catcode`##1=12 }%
		\dospecials% rend inoffensifs tous les tokens spéciaux
		\defactive\^^M{\leavevmode\par}%
		\defactive\ {\space}%
		\defactive<{\string<{}}\defactive>{\string>{}}%
		\defactive-{\string-{}}\defactive`{\string`{}}%
		\defactive,{\string,{}}\defactive'{\string'{}}%
		\defactive#1{\endgroup}% #1 sera un \endgroup
		\tt% passe en police à chasse fixe
}

\long\def\firstto@nil#1#2\@nil{#1}

\long\def\remainto@nil#1#2\@nil{#2}

\def\rightofsc#1#2{%
	\exparg\ifin{#1}{#2}%
		{% si #1 contient le #2
		\def\right@of##1#2##2\@nil{\def#1{##2}}% définit la macro auxiliaire
		\expandafter\right@of#1\@nil% appelle la macro auxiliaire
		}%
		{\let#1=\empty}% sinon, ne rien faire
}

\def\defname#1{\expandafter\def\csname#1\endcsname}

\def\letname#1{\expandafter\let\csname#1\endcsname}

\long\def\addtomacro#1#2{\expandafter\def\expandafter#1\expandafter{#1#2}}

\long\def\eaddtomacro#1#2{\expandafter\addtomacro\expandafter#1\expandafter{#2}}

\long\def\addtotoks#1#2{#1\expandafter{\the#1#2}}

\long\def\eaddtotoks#1#2{\expandafter\addtotoks\expandafter#1\expandafter{#2}}

\long\def\swaparg#1#2{#2{#1}}

\long\def\expsecond#1#2{\expandafter\swaparg\expandafter{#2}{#1}}
\let\exparg\expsecond

\def\exptwoargs#1#2{\expsecond{\expsecond{#1}{#2}}}

\def\sgn#1{\ifnum#1<0 -\fi}

\def\abs#1{\sgn{#1}#1 }

\def\truncdiv#1#2{%
	\exptwoargs\truncdiv@i{\number\numexpr#1\relax}{\number\numexpr#2\relax}%
}
\def\truncdiv@i#1#2{%
	\numexpr(2*\sgn{#1}#1-\sgn{#2}#2+1)/(\sgn{#1}2*#2)\relax
}

\def\ifinside#1[#2,#3]{%
	\ifnum\sgn{\dimexpr#1pt-#2pt\relax}\sgn{\dimexpr#1pt-#3pt}1=1
		\expandafter\secondoftwo
	\else
		\expandafter\firstoftwo
	\fi
}

\def\absval#1{\expandafter\absval@i\expandafter{\number\numexpr#1\relax}}
\def\absval@i#1{\number\ifnum#1<\z@-\fi#1 }

\edef\saved@catcode{\number\catcode`\:}% sauvegarde du catcode de ":"
\catcode`\:12 % ":" est désormais un caractère non actif normal
\def\hdif{%
	\begingroup% ouvrir un groupe semi-simple
		\catcode`\:12 % modifier le catcode de ":"
		\hdif@i% aller lire les deux arguments
}

\def\hdif@i#1#2{% lit les 2 arguments
		\hdif@ii#1-#2\@nil% et les transmet à la macro à argument délimités
}

\def\hdif@ii#1:#2:#3-#4:#5:#6\@nil{%
		%%%%%% calcul des nombres à afficher %%%%%%
		\edef\nb@hrs{\number\numexpr#1-#4\relax}% différence des heures
		\edef\nb@min{\number\numexpr#2-#5\relax}% différence des minutes
		\edef\nb@sec{\number\numexpr#3-#6\relax}% différence des secondes
		\ifnum\nb@sec<\z@ % si la différence des secondes est <0
			\edef\nb@sec{\number\numexpr\nb@sec+60\relax}% ajouter 60 sec
			\edef\nb@min{\number\numexpr\nb@min-1\relax}% enlever 1 aux minutes
		\fi
		\ifnum\nb@min<\z@ % si les minutes sont <0
			\edef\nb@min{\number\numexpr\nb@min+60\relax}% ajouter 60 min
			\edef\nb@hrs{\number\numexpr\nb@hrs-1\relax}% enlever 1 aux heures
		\fi
		%%%%%% affichage du résultat %%%%%%
		\let\inter@space\empty% pas d'espace avant un nombre pour l'instant
		\ifnum\nb@hrs>\z@ % si les heures sont >0
			\nb@hrs h% afficher les heures et "h"
			\let\inter@space\space% espace pour plus tard
		\fi
		\ifnum\nb@min>\z@ % si les minutes sont >0
			\inter@space% afficher une espace éventuelle
			\nb@min min% afficher les minutes et "min"
			\let\inter@space\space
		\fi
		\ifnum\nb@sec>\z@ % si les secondes sont >0
			\inter@space% afficher une espace éventuelle
			\nb@sec s% afficher les secondes et "s"
		\fi
	\endgroup% fermer le groupe ouvert au début
}
\catcode`\:=\saved@catcode\relax% restaure le code de catégorie de ":"

\long\def\afterfi#1#2\fi{#2\fi#1}

\long\def\antefi#1\fi{\fi#1}

\def\for#1=#2to#3\do#4#{%
	\edef\temp@increment{\number\numexpr0#4}% lit et normalise l'argument optionnel
	\ifnum\temp@increment=\z@% s'il est nul,
		\edef\temp@increment{% le redéfinir à -1 (si #3<#2) et 1 sinon
			\ifnum\numexpr#3-#2\relax<\z@ -1\else 1\fi
		}% \temp@increment vaut donc 1 ou -1
	\fi
	\ifnum\numexpr\temp@increment*(#3-#2)\relax<\z@
		\expandafter\gobone% si argument optionnel incompatible, manger le {<code>}
	\else
		\edef#1{\number\numexpr#2}% initialise la variable
		\edef\macro@args{% définit et développe les arguments de la macro
			%#1=nom de la macro à définir :
			\expandafter\noexpand\csname for@ii@\string#1\endcsname
			\ifnum\temp@increment<\z@ <\else >\fi% #2=signe de comparaison
			{\temp@increment}% #3=incrément
			\noexpand#1% #4=variable
			{\number\numexpr#3\relax}% #5=entier max
		}%
		\antefi
		\expandafter\for@i\macro@args
	\fi
}

% #1=nom de la macro récursive de type "\for@ii@<variable>"
% #2=signe de comparaison  % #3=incrément
% #4=variable  % #5=entier max  % #6=code à exécuter
\long\def\for@i#1#2#3#4#5#6{%
	\def#1{% dfinit la sous macro récursive
		\unless\ifnum#4#2#5\relax% tant que la variable n'a pas dépassé l'entier max
			\afterfi{% rendre la récursivité terminale
				#6% exécute le code
				\edef#4{\number\numexpr#4+#3\relax}% incrémente la variable #1
				#1% recommence
			}%
		\fi
	}%
	#1% appelle la sous-macro récursive
}

\def\exitfor#1{% #1=variable correspondant à la boucle de laquelle on veut sortir
	\expandafter\let\csname for@ii@\string#1\endcsname\empty
}

\def\quark{\quark}

\long\def\ifempty#1{%
	\expandafter\ifx\expandafter\relax\detokenize{#1}\relax
		\expandafter\firstoftwo
	\else
		\expandafter\secondoftwo
	\fi}

\def\reverse#1{%
	\ifempty{#1}
		{}% s'il n'y a rien à inverse, ne rien faire
		{\reverse@i#1\@nil\@nil}% initialisation des réservoirs et appeler \reverse@i
}
\def\reverse@i#1#2\@nil#3\@nil{% #1 est le 1er caractère du réservoir A
	\ifempty{#2}% si ce qui reste après ce 1er caractère est vide
		{#1#3}% renvoyer #1#3 qui est le résultat final
		{\reverse@i#2\@nil#1#3\@nil}% sinon, recommencer en déplaçant #1
		                            % en 1re position du réservoir B
}
\long\def\ifin#1#2{%
	\long\def\ifin@i##1#2##2\@nil{% définit la macro auxiliaire
		\ifempty{##2}% si ce qu'il y a derrière le motif est vide
			\secondoftwo% aller à "faux"
			\firstoftwo% sinon à "vrai"
	}%
	\ifin@i#1#2\@nil% appel de la macro auxiliaire
}

\def\ifstart#1#2{%
	\def\if@start##1#2##2\@nil{\ifempty{##1}}%
	\ifempty{#2}\firstoftwo{\if@start#1\relax#2\@nil}}

\def\substin#1#2#3{%
	\def\substin@i##1{%
		\ifempty{##1}% si le code est vide
			\relax% ne rien faire -> fin du processus
			{\ifin{##1}{#2}% sinon, si le code contient motif1
				{\substin@ii##1\@nil}% appeler la macro à argument délimités
				{##1}% sinon, afficher le code
			}%
	}%
	\def\substin@ii##1#2##2\@nil{%
		##1#3% afficher ##1 et #3 (qui est <motif2>)
		\substin@i{##2}% et recommencer avec ce qui reste
	}%
	\substin@i{#1}%
}

\def\substtocs#1#2#3#4{%
	\def\substtocs@i##1{%
		\ifempty{##1}% si le code est vide
			\relax% ne rien faire -> fin du processus
			{\ifin{##1}{#3}% sinon, si le code contient motif1
				{\substtocs@ii##1\@nil}% appeler la macro à argument délimités
				{\addtomacro#1{##1}}% sinon, ajouter le code
			}%
	}%
	\def\substtocs@ii##1#3##2\@nil{%
		\addtomacro#1{##1#4}% ajouter ##1#4
		\substtocs@i{##2}% et recommencer avec ce qui reste
	}%
	\let#1=\empty% initialise la macro à vide
	\substtocs@i{#2}%
}

\long\def\cnttimestocs#1#2#3{% #3=macro recevant le résultat
	\long\def\cnttimestocs@i##1\@nil##2#2##3\@nil{%
		% ##1=nb d'occurrences rencontrées jusqu'alors
		% ##2 et ##3=ce qui est avant/après le <motif>
		\ifin{##3}{#2}% si le <motif> est dans ce qui reste
			{\expandafter\cnttimestocs@i% appeler la macro récursive
				\number\numexpr##1+1\relax\@nil% avec une occurrence de plus
				##3\@nil% et ce qui reste
			}%
			{\edef#3{\number\numexpr##1+1\relax}}% sinon, stocker 1 occurrence de plus dans #3
	}%
	\ifin{#1}{#2}% si le <motif> est dans le <code>
		{\cnttimestocs@i 0\@nil#1\@nil}% appeler la macro récursive avec 0 occurrence
		{\def#3{0}}% sinon, mettre 0 dans #3
}

\def\ifcs#1{%
	\begingroup
		\escapechar=`\@ % prend "@" comme caractère d'échappement
		\if% les premiers caractères de
			\expandafter\firstto@nil\string#1a\@nil% "#1a"
			\expandafter\firstto@nil\string\relax\@nil% et "\relax" sont-ils égaux ?
			\endgroup\expandafter\firstoftwo% si oui, fermer le groupe et renvoyer "vrai"
		\else% sinon, fermer le groupe et renvoyer "faux"
			\endgroup\expandafter\secondoftwo
		\fi
}

\def\endif{\endif}\def\elseif{\elseif}
\def\idto@endif#1\endif{#1}
\def\firstto@endif#1#2\endif{#1}
\def\ifxcase#1#2{% #1=<token>   #2=prochain argument
	\ifx\elseif#2% si #2 est \elseif
	\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
		\idto@endif% aller à \idto@endif, sinon :
		{\ifx\endif#2% si #2 est \endif
		\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
			{}% ne rien faire, sinon :
			{\ifx#1#2% s'il y a égalité
			\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
				\firstto@endif% aller à \firstto@endif
				{\ifxcase@i{#1}}% sinon aller à \ifxcase@i
			}%
		}%
}
\def\ifxcase@i#1#2{% #1=<nombre>  #2=<code>
	\ifxcase{#1}% manger le <code> et aller à \ifxcase en transmettant #1
}

\newcount\cnt@nest \cnt@nest=0 % définit et initialise le compteur d'imbrication
\def\end@foreach{\end@foreach}
\long\def\save@macro#1#2{\expandafter\let\csname saved@var@\number\cnt@nest#1\endcsname#2}
\long\def\save@macro@i#1/#2{\save@macro{a}#1\save@macro{b}#2}
\long\def\restore@macro#1#2{%
	\expandafter\let\expandafter#2\csname saved@var@\number\cnt@nest#1\endcsname
}
\long\def\restore@macro@i#1/#2{\restore@macro{a}#1\restore@macro{b}#2}
\def\defseplist#1{%
	\long\def\doforeach##1\in##2##3{%
		\global\advance\cnt@nest1 % entrée de boucle : incrémenter le compteur d'imbrication
		\ifin{##1}{/}% si ##1 contient "/"
			{\save@macro@i##1% sauvegarde les macros
			\doforeach@ii% appeler la macro récursive après avoir
				{##3}%\csname loop@code@\number\cnt@nest\endcsname% formé la macro contenant le code
				##1% mettre les variables ##1 en 2e position
				##2#1\end@foreach/\end@foreach#1% puis la liste ##2 suivie de ",\end@foreach,"
			\restore@macro@i##1% une fois sorti de toutes les boucles, restaurer les macros
			}% si ##1 ne contient pas "/"
			{\save@macro{}##1% sauvegarde la macro
			\doforeach@i% appeler la macro récursive
				{##3}% mettre en premier le <code>
				##1% puis la variable ##1 en 2e position
				##2#1\end@foreach#1% enfin la liste ##2 suivie de ",\end@foreach,"
			\restore@macro{}##1% une fois sorti de toutes les boucles, restaurer la macro
			}%
		\global\advance\cnt@nest-1 % décrémente le compteur d'imbrications
	}%
	% ##1 = code à exécuter, ##2= variable, ##3=valeur courante
	\long\def\doforeach@i##1##2##3#1{%
		\def##2{##3}% fait l'assignation à la variable
		\global\let\allow@recurse\identity% permet l'appel récursif plus bas
		\ifx\end@foreach##2% si la fin est atteinte
		\expandafter\gobone\else\expandafter\identity\fi% manger sinon exécuter:
			{##1% le code puis
			\allow@recurse{\doforeach@i{##1}##2}% recommencer
			}%
	}%
	% ##1 = code à exécuter, ##2/##3= variables, ##4/##5=valeurs courantes
	\long\def\doforeach@ii##1##2/##3##4/##5#1{%
		\def##2{##4}\def##3{##5}% fait l'assignation des deux variables
		\global\let\allow@recurse\identity% permet l'appel récursif plus bas
		\ifx\end@foreach##2% si la fin est atteinte
		\expandafter\gobone\else\expandafter\identity\fi% manger sinon exécuter:
			{##1% le code puis
			\allow@recurse{\doforeach@ii{##1}##2/##3}% recommencer
			}%
	}%
	% macro qui, si elle remplace \allow@recurse, annule l'appel récursif
	\long\def\forbid@recurse##1\end@foreach#1{}% tout manger jusqu'à "\end@foreach,"
}
% macro pour annuler le prochain appel récursif
\def\doforeachexit{\global\let\allow@recurse\forbid@recurse}
\defseplist{,}

\begingroup% ouvrir un groupe
	\edef\temp{\endgroup\def\noexpand\removept##1.##2\string p\string t}%
\temp{#1\ifnum#2>0 .#2\fi}% et le fermer avant de définir \removept

\def\dimtodec{\expandafter\removept\the}

\def\FOR#1=#2to#3\do#4#{%
	\ifempty{#4}
		{\let\FOR@increment\z@}
		{\edef\FOR@increment{\the\dimexpr#4pt\relax}}% lit et normalise l'argument optionnel
	\ifdim\FOR@increment=\z@% s'il est nul,
		\edef\FOR@increment{% le redéfinir à -1pt (si #3<#2) et 1pt sinon
			\ifdim\dimexpr#3pt-#2pt\relax<\z@ -1\else 1\fi pt
		}% \FOR@increment vaut donc 1 ou -1
	\fi
	\ifdim\dimtodec\dimexpr#3pt-#2pt\relax\dimexpr\FOR@increment\relax<\z@
		\expandafter\gobone% si argument optionnel incompatible, manger le {<code>}
	\else
		\edef#1{\dimtodec\dimexpr#2pt\relax}% initialise la \<macro>
		\edef\macro@args{% définit et développe les arguments à passer à \FOR@i
			%#1=nom de la macro récursive :
			\expandafter\noexpand\csname FOR@ii@\string#1\endcsname
			\ifdim\FOR@increment<\z@ <\else >\fi% #2=signe de comparaison
			{\FOR@increment}% #3=incrément
			\noexpand#1% #4=\<macro>
			{\the\dimexpr#3pt\relax}% #5=dimension n2
		}%
		\antefi% externalise la ligne ci-dessous de la portée du test
		\expandafter\FOR@i\macro@args% appelle \FOR@i avec les arguments définis ci-dessus
	\fi
}

% #1=nom de la macro récursive de type "\FOR@ii@\<macro>"
% #2=signe de comparaison  % #3=incrément
% #4=\<macro>  % #5=dimension n2  % #6=<code> à exécuter
\long\def\FOR@i#1#2#3#4#5#6{%
	\def#1{% dfinit la sous macro récursive
		\unless\ifdim#4pt#2#5\relax% tant que la \<macro> variable n'a pas dépassé n2
			\afterfi{% rendre la récursivité terminale
				#6% exécute le code
				\edef#4{\dimtodec\dimexpr#4pt+#3\relax}% incrémente la \<macro>
				#1% recommence
			}%
		\fi
	}%
	#1% appelle la sous-macro récursive
}%
\def\exitFOR#1{% #1=\<macro> correspondant à la boucle de laquelle on veut sortir
	\defname{FOR@ii@\string#1}{}%
}

\def\ifexitFOR#1{% envoie vrai si on est prématurément sorti de la boucle de \<macro> #1
	% si la macro récursive est \empty
	\expandafter\ifx\csname FOR@ii@\string#1\endcsname\empty
		\expandafter\firstoftwo% c'est qu'on est sortir prématurément, renvoyer "vrai"
	\else
		\expandafter\secondoftwo% sinon, renvoyer "faux"
	\fi
}

\def\decmul#1#2{\dimtodec\dimexpr#1\dimexpr#2pt\relax\relax}

\def\decdiv#1#2{% divise le décimal #1 par le décimal #2
	\dimtodec\dimexpr 1pt*\dimexpr#1pt\relax/\dimexpr#2pt\relax\relax
}

\def\convertunit#1#2{%
	\dimtodec
	\dimexpr
		\numexpr
			\dimexpr #1 \relax * 65536 / \dimexpr 1#2 \relax
		\relax
		sp
	\relax
}

\def\vdim#1{\dimexpr\ht#1+\dp#1\relax}% hauteur totale de la boite #1

\def\cbox#1{\setbox0\vbox{#1}\lower\dimexpr(\ht0-\dp0)/2\relax\box0 }

\def\clap#1{\hbox to\z@{\hss#1\hss}}

\def\ifzerodimbox#1{% #1=registre de boite
% revoie vrai si le registre est vide ou contient une boite vide
	\csname% former le nom "\firstoftwo" ou "secondoftwo"
	\ifvoid#1first%% si le registre est vide "first"
	\else% sinon
		\ifnum\wd#1=\z@% si la largeur
			\ifnum\ht#1=\z@% la hauteur
				\ifnum\dp#1=\z@ first% et la profondeur=0pt, "first"
				\else second% dans les autres cas "second"
				\fi
			\else second%
			\fi
		\else second%
		\fi
	\fi
	oftwo% compléter avec "oftwo"
	\endcsname
}

\def\ifvoidorempty#1{% teste si le registre de boite #1 est vide ou contient une boite vide
	\ifvoid#1\relax
		\expandafter\firstoftwo
	\else
		\begingroup% dans un groupe
			\setbox0=% affecter à la boite 0
				\ifhbox#1\hbox\bgroup\unhcopy% un boite horizontale
				\else    \vbox\bgroup\unvcopy% ou verticale
				\fi% dans laquelle on compose
				#1\relax% composer #1 en dimensions naturelles
				\expandafter\egroup% sauter la fin de la boite
				\expandafter% et le \endgroup
		\endgroup
		\ifnum\lastnodetype<0 % pour tester si le dernier noeud est vide
			\expandafter\expandafter\expandafter\firstoftwo
		\else
			\expandafter\expandafter\expandafter\secondoftwo
		\fi
	\fi
}

\def\showdim#1{%
	\vrule width0.2pt height 1ex depth 0pt
	\vrule width#1 height0.4pt depth 0pt
	\vrule width0.2pt height 1ex depth 0pt \relax}
	

\newdimen\frboxrule \frboxrule0.4pt
\newdimen\frboxsep \frboxsep5pt
\def\FRbox#1{% ne pas changer le mode H ou V en cours
	\hbox{% mettre à la suite horizontalement
		\vrule width\frboxrule% 1) réglure gauche
		\vbox{%                 2) un empilement vertical comprenant
			\hrule height\frboxrule% a) réglure supérieure
			\kern\frboxsep%          b) espace verticale haute
			\hbox{%                  c) contenu + espaces en mode H
				\kern\frboxsep#1\kern\frboxsep
			}%
			\kern\frboxsep%          d) espace verticale basse
			\hrule height\frboxrule% e)réglure inférieure
			}%
		\vrule width\frboxrule% 3) réglure droite
	}%
}
\def\frbox#1{% ne pas changer le mode H ou V en cours
	\hbox{% enferme dans une \hbox
		\vrule width\frboxrule% réglure gauche
		\vtop{%
			\vbox{% 1er élément de la \vtop
				\hrule height\frboxrule% réglure supérieure
				\kern\frboxsep% espace haut
				\hbox{%
					\kern\frboxsep% espace gauche
					#1% contenu
					\kern\frboxsep% espace droite
					}%
			}% puis autres éléments de la \vtop, sous la ligne de base
			\kern\frboxsep% espace bas
			\hrule height\frboxrule% réglure inférieure
		}%
		\vrule width\frboxrule% réglure droite
	}%
}
\def\souligne#1{%
	\setbox0=\hbox{#1}% stocke le contenu dans le registre no 0
	\setbox0=\hbox{% puis, dans une \hbox, construit une réglure
		\vrule width\wd0 % de la longueur du contenu
			depth\dimexpr\dp0 + 1.4pt\relax % dp = profondeur texte + 1.4pt
			height\dimexpr-\dp0 - 1pt\relax % ht = -profondeux texte - 1pt
	}%
	\wd0=0pt \dp0=0pt \ht0=0pt % annule toutes les dimensions
	\leavevmode \box0 % affiche la réglure
	#1% puis le contenu
}

\def\Souligne#1{%
	\setbox0=\hbox{#1}%
	\setbox0=\hbox{\vrule width\wd0 depth1.4pt height-1pt }%
	\wd0=0pt \dp0=0pt \ht0=0pt
	\leavevmode \box0 #1%
}

\newdimen\stackwd \stackwd=3em 
\catcode`\@11
\def\stackbox#1{%
	\par% termine le paragraphe en cours
	\begingroup% dans un groupe semi-simple
		\parindent=0pt% pas d'indentation
		\parskip=0pt% annuler le \parskip
		\setbox0\hbox{Àgjp}% boite pour le strut
		\edef\stack@strut{\vrule width\z@ height\the\ht0 depth\the\dp0 }% définit le strut
		\stackbox@i#1\\\quark\\% ajoute "\\\quark\\" à la fin et appelle \stackbox@i
		\unkern% annule la dernière compensation verticale
		\par
	\endgroup
}
\def\stackbox@i#1\\{% #1=ligne courante
	\def\temp@{#1}% stocke la ligne courante
	\unless\ifx\quark\temp@% si ce n'est pas la fin
		\hfill % ressort infini de centrage (passe en mode horizontal)
		\doforeach\current@item\in{#1}% pour chaque élément dans la ligne courante...
			{\frbox{% ...encadrer
				\hbox to\stackwd{% une \hbox de largeur \stackwd contenant
					\hss%         1) ressort de centrage
					\stack@strut% 2) strut de dimension verticale
					\current@item%3) l'élement courant
					\hss}%        4)ressort de centrage
				}% fin de la \fbox
			\kern-\frboxrule% revenir en arrière pour superposer les réglures verticales
			}% fin de \doforeach
		\unkern% annuler la dernière compensation horizontale
		\hfill% ressort infini de centrage
		\null% fait prendre en compte le dernier ressort
		\par% termine le paragraphe
		\nobreak% interdit une coupure de page
		\nointerlineskip% sinon, ne pas ajouter le ressort interligne
		\kern-\frboxrule% superposer les réglures horizontales
		\expandafter\stackbox@i% et recommencer
	\fi
}

\def\vlap#1{\vbox to\z@{\vss#1\vss}}
\newdimen\xunit \newdimen\yunit
\newdimen\mainrule \newdimen\subrule
\xunit=1cm \yunit=1cm \mainrule=0.8pt \subrule=0.2pt
\def\grid#1#2#3#4{% #1=nb xunit #2=nb xsubunit #3=nb yunit #4=nb ysubunit
	\vbox{%
		\offinterlineskip
		\edef\total@wd{\the\dimexpr\xunit*#1\relax}%
		\edef\sub@unit{\the\dimexpr\yunit/#4\relax}%
		\for\iii=1to#3\do
			{\ifnum#4>1
				\vbox to\z@{%
					\for\jjj=2to#4\do
						{\kern\sub@unit
						\vlap{\hrule width\total@wd height\subrule}%
						}%
					\vss
				}%
			\fi
			\vlap{\hrule width\total@wd height\mainrule}%
			\kern\yunit
			}%
		\vlap{\hrule width\total@wd height\mainrule}%
		\vbox to\z@{%
			\vss
			\hbox to\total@wd{%
				\edef\total@ht{\the\dimexpr\yunit*#3\relax}%
				\edef\sub@unit{\the\dimexpr\xunit/#2\relax}%
				\for\iii=1to#1\do
					{\ifnum#2>1
						\rlap{%
							\for\jjj=2to#2\do
								{\kern\sub@unit
								\clap{\vrule width\subrule height\total@ht}%
								}%
						}%
					\fi
					\clap{\vrule width\dimexpr\mainrule height\total@ht}%
					\kern\xunit
					}%
				\clap{\vrule width\mainrule height\total@ht}%
			}%
		}%
	}%
}

\def\iffileexists#1#2{% #1=canal de lecture  #2=nom du fichier
	\openin#1=#2 %
	\ifeof#1% le fichier n'existe pas
		\closein#1%
		\expandafter\secondoftwo% renvoyer faux
	\else
		\closein#1
		\expandafter\firstoftwo% sinon renvoyer vrai
	\fi
}

\def\xread{% doit être suivie de "<nombre> to \<macro>"
	\edef\restoreendlinechar{\endlinechar=\the\endlinechar}%
	\endlinechar=-1 % neutralise \endlinechar
	\afterassignment\restoreendlinechar% après l'assignation restaurer \endlinechar
	\read% attend <nombre> to \<macro>
}

\def\showfilecontent#1#2{% #1=canal de lecture #2=nom de fichier
	\begingroup
		\tt% sélectionner la fonte à chasse fixe
		\openin#1=#2\relax
		\ifeof#1% si la fin du fichier est déjà atteinte, il n'existe pas et
			Le fichier n'existe pas% afficher le message
		\else% le fichier existe
			\def\do##1{\catcode`##1=12 }%
			\dospecials% neutraliser tous les tokens spéciaux
			\obeyspaces% rendre l'espace actif
			\def\magicpar{\let\magicpar=\par}%
			\loop
				\xread#1 to \currline% lire une ligne
				\unless\ifeof#1% si la fin du fichier n'est pas atteinte
				\leavevmode\magicpar% former le paragraphe (sauf à la 1er itération)
				\currline% afficher la ligne
			\repeat% recommencer
		\fi
		\closein#1\relax%
	\endgroup
}

\def\exactwrite#1#2{% #1=numéro de canal #2=caractère délimiteur
	\begingroup
		\def\canal@write{#1}% sauvegarde le numéro de canal
		\for\xx=0 to 255\do{\catcode\xx=12 }% donne à tous les octets le catcode 12
		\expandafter\exactwrite@i\expandafter{\string#2}% rend #2 de catcode 12
}

\def\exactwrite@i#1{% #1=caractère frontière (de catcode 12)
		% la macro \exactwrite@ii lit tout jusqu'au caractère #2 et passe
		% ce qu'elle a lu à la macro \exactwrite@iii en mettant un \@nil à la fin
		\def\exactwrite@ii##1#1{\exactwrite@iii##1\@nil}%
		\exactwrite@ii% va lire tout ce qui se trouve jusqu'au prochain #2
}

{\catcode`\^^M 12 \gdef\EOL@char{^^M}}% définit le caractère <EOL> de catcode 12

\def\exactwrite@iii#1\@nil{% #1 = contenu à écrire
	\expsecond{\ifin{#1}}\EOL@char% si #1 contient "retour chariot"
		{\write@line#1\@nil}% écrire la première ligne de #1
		{\immediate\write\canal@write{#1}% sinon : dernière ligne atteinte, l'écrire
		\endgroup% puis sortir du groupe
		}%
}

% les \expandafter provoquent le 1-développement de \EOL@char :
\expandafter\def\expandafter\write@line\expandafter#\expandafter1\EOL@char#2\@nil{%
	\immediate\write\canal@write{#1}% écrit la ligne (ce qui se trouve avant ^^M)
	\exactwrite@iii#2\@nil% continue avec ce qui se trouve après ^^M
}

\def\quark@list{\quark@list}% quark de fin de liste

\def\finditemtocs#1#2#3{% #1 = \<macro>  #2=position  #3=macro à définir
	\def\finditemtocs@iii##1##2\quark@list,{% renvoyer #1 et manger le reste de la liste
		\expandafter\def\expandafter#3\expandafter{\gobone##1}%
	}%
	\let#3=\empty%
	\exparg\finditemtocs@i{#1}{#2}% 1-développe la \<macro>
}
\def\finditemtocs@i#1#2{% #1 = liste   #2=position cherchée
	\ifnum#2>\z@% ne faire quelque chose que si la position est >0
		\antefi\finditemtocs@ii{1}{#2}\relax#1,\quark@list,% appelle la macro récursive
	\fi
}
\def\finditemtocs@ii#1#2#3,{%
% #1=position courante  #2=position cherché  #3=\relax + élément courant
	\expandafter\ifx\expandafter\quark@list\gobone#3%
	\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
		{}% si fin de liste ne rien faire. Sinon, si position bonne
		{\ifnum#1=#2 \expandafter\firstoftwo\else\expandafter\secondoftwo\fi
			{\finditemtocs@iii{#3}% renvoyer #3 et manger les éléments restants
			}% si la position n'est pas la bonne, recommencer en incrémentant #1
			{\exparg\finditemtocs@ii{\number\numexpr#1+1}{#2}\relax%
			}%
		}%
}

\def\insitem#1#2#3{% #1 = macro   #2=position cherchée   #3=élément à insérer
	\let\item@list=\empty
	\ifnum#2<1 \expandafter\firstoftwo\else\expandafter\secondoftwo\fi
		% si position < 1
		{\addtomacro\item@list{#3,}% ajouter l'élement à insérer en premier
		\eaddtomacro\item@list#1% puis la liste entière
		}
		% si la position  > 1
		{% définir la macro récursive
		\def\insitem@i##1##2,{% ##1 = position courante  ##2=\relax + élément courant
			\expandafter\ifx\expandafter\quark@list\gobone##2%
			\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
				{\addtomacro\item@list{#3}}% si fin de liste, ajouter l'élément en dernier
				{% sinon, si la position cherchée est atteinte
				\ifnum##1=#2 \expandafter\firstoftwo\else\expandafter\secondoftwo\fi
					{\addtomacro\item@list{#3,}% ajouter l'élement
					\add@remainlist##2,% et ##2 (en supprimant le \relax) et le reste
					}% si la position n'est pas atteinte
					{\eaddtomacro\item@list{\gobone##2,}% ajouter l'élément
					\exparg\insitem@i{\number\numexpr##1+1}\relax% et recommencer
					}%
				}%
			}%
		% appel de la macro récursive
		\expandafter\insitem@i\expandafter1\expandafter\relax#1,\quark@list,%
		}%
	\let#1=\item@list% rendre #1 égal au résultat
}

\def\add@remainlist#1,\quark@list,{%
	\eaddtomacro\item@list{\gobone#1}% ajouter #1 ainsi que les autres
}
\def\delitem#1#2{% #1 = macro   #2=position cherchée
	\ifnum#2>0 % ne faire quelque chose que si la position est >0
		\def\delitem@i##1##2,{% ##1 = position courante  ##2=\relax + élément courant
			\expandafter\ifx\expandafter\quark@list\gobone##2%
			\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
				{}% si fin de liste, ne rien faire
				{% sinon, si la position cherchée est atteinte
				\ifnum##1=#2 \expandafter\firstoftwo\else\expandafter\secondoftwo\fi
					{\add@reaminingitems% et ##2 (en supprimant le \relax) et le reste
					}% si la position n'est pas la bonne
					{\eaddtomacro\item@list{\gobone##2,}% ajouter l'élément
					\exparg\delitem@i{\number\numexpr##1+1}\relax% et recommencer
					}%
				}%
			}%
		\let\item@list=\empty% initialiser la macro tempporaire
		% appel de la macro récursive
		\expandafter\delitem@i\expandafter1\expandafter\relax#1,\quark@list,%
		\expandafter\remove@lastcomma\item@list\@nil
		\let#1=\item@list% rendre #1 égal au résultat
	\fi
}

\def\add@reaminingitems#1\quark@list,{%
	\eaddtomacro\item@list{#1}% ajouter tout jusqu'au quark
}
\def\remove@lastcomma#1,\@nil{\def\item@list{#1}}

\def\runlist#1\with#2{% #1=liste #2=macro
	\def\runlist@i##1,##2\@nil{%
		\addtomacro\collect@run{#2{##1}}% ajouter "\<macro>{<élément>}""
		\ifempty{##2}% plus d'élément ?
			\relax% ne rien faire (donc terminer le processus)
			{\runlist@i##2\@nil}% sinon, recommencer avec les éléments restants
	}%
	\begingroup% fait la collecte dans un groupe
		\let\collect@run=\empty% initialiser la macro
		\ifcs{#1}% si #1 est une séquence de contrôle
			{\expandafter\runlist@i#1,\@nil%% aller à \runlist@i
			}% sinon, former la sc
			{\expandafter\expandafter\expandafter\runlist@i\csname#1\endcsname,\@nil
			}%
	\expandafter\endgroup% ferme le groupe et détruit \collect@run
	\collect@run% après l'avoir développé !
}

\def\ifspacefirst#1{%
	\expandafter\ifspacefirst@i\detokenize{#1W} \@nil% "W" se prémunit d'un argument vide
}
\def\ifspacefirst@i#1 #2\@nil{\ifempty{#1}}

\expandafter\def\expandafter\gobspace\space{}

\def\removefirstspaces{%
	\romannumeral% lance le développement maximal
	\removefirstspaces@i% et passe la main à la macro récursive
}

\def\removefirstspaces@i#1{%
	\ifspacefirst{#1}% si #1 commence par un espace
		{\expandafter\removefirstspaces@i\expandafter% recommencer
			{\gobspace#1}% après avoir supprimé cet espace
		}
		{\z@#1}% sinon, renvoyer l'argument où \z@ stoppe l'action de \romannumeral
}

\edef\catcodezero@saved{\number\catcode0 }% stocke le catcode de ^^00
\catcode0=12 % le modifie à 12
\def\removelastspaces#1{%
	\romannumeral% lance le développement maximal
	\removelastspaces@i#1^^00 ^^00\@nil% et passe la main à \removelastspaces@i
}
\def\removelastspaces@i#1 ^^00{%
	\removelastspaces@ii#1^^00%
}
\def\removelastspaces@ii#1^^00#2\@nil{%
	\ifspacefirst{#2}% si le reliquat commence par un espace
		{\removelastspaces@i#1^^00 ^^00\@nil}% recommencer sans passer par \removelastspaces
		{\z@#1}% sinon "\z@" stoppe l'action de \romannumeral
}
\catcode0=\catcodezero@saved\relax% restaure le catcode de ^^00

\def\removetrailspaces#1{%
	\romannumeral% lance le développement maximal
		\expandafter\expandafter\expandafter% le pont d'\expandafter
	\removelastspaces
		\expandafter\expandafter\expandafter% fait agir \removefirstspaces en premier
	{%
		\expandafter\expandafter\expandafter
	\z@% stoppe le développement initié par \romannumeral
	\removefirstspaces{#1}%
	}%
}

\newcount\test@cnt
\def\ifinteger#1{%
	\ifstart{#1}{-}% si "-" est au début de #1
		{\expandafter\ifinteger\expandafter{\gobone#1}% l'enlever et recommencer
		}
		{\ifempty{#1}% sinon, si #1 est vide, lire l'argument <faux>
			\secondoftwo% lire l'argument <faux>
			{\afterassignment\after@number% sinon, après l'assignation, aller à \after@number
			\test@cnt=0#1\relax% faire l'assignation (\relax termine le nombre et n'est pas mangé)
			}%
		}%
}
\def\after@number#1\relax{% #1 est ce qui reste après l'assignation
	\ifempty{#1}% teste si #1 est vide et lit l'argument <vrai> ou <faux> qui suit
}

\newif\iftestspace \testspacefalse

\def\deftok#1#2{\let#1= #2\empty}

\def\ifnexttok#1#2#3{% #1=token #2=code vrai #3=code faux
	\let\test@tok= #1% stocke le token à tester
	\def\true@code{#2}\def\false@code{#3}% et les codes à exécuter
	\iftestspace \def\ifnexttok@i{\futurelet\nxttok\ifnexttok@ii}%
	\else        \def\ifnexttok@i{\futurelet\nxttok\ifnexttok@iii}%
	\fi% après avoir défini la macro récursive selon le booléen
	\ifnexttok@i% l'exécuter
}

\def\ifnexttok@ii{% macro qui teste aussi les espaces
	\ifx\nxttok\test@tok \expandafter\true@code% exécuter le code vrai
	\else                \expandafter\false@code% sinon code faux
	\fi
}

\def\ifnexttok@iii{%
	\ifx\nxttok\sptoken% si le prochain token est un espace
		\def\donext{%
			\afterassignment\ifnexttok@i% aller "sentir" le token d'après
			\let\nxttok= }% après avoir absorbé l'espace
	\else   \let\donext\ifnexttok@ii% sinon, faire le test
	\fi
	\donext% faire l'action décidée ci-dessus
}

\def\ifstarred#1{\ifnexttok*{\firstoftwo{#1}}}

\def\parsestop{\parsestop}% définit le quark se trouvant en fin de code
\newtoks\code@toks% alloue le registre contenant le code lu
\def\parseadd#1{\code@toks\expandafter{\the\code@toks#1}}
\newif\ifparse@group
\def\parse{%
	\code@toks{}% initialise le collecteur de tokens
	\ifstarred
		{\parse@grouptrue
		\ifnexttok{ }% si un espace suit l'étoile
			{\afterassignment\parse@i \let\nxttok= }% le manger et aller à \parse@i
			{\parse@i}% sinon, aller à \parse@i
		}
		{\parse@groupfalse
		\parse@i
		}%
}
\def\parse@i{\futurelet\nxttok\parse@ii}% lit le prochain token et va à \parse@ii
\def\parse@ii{%
	\ifx\nxttok\parsestop% si la fin va être atteinte, aller à \parsestop@i
		\let\next@action\parsestop@i
	\else
		\ifx\nxttok\@sptoken% si un espace va être lu, aller à \read@space
			\let\next@action\read@space
		\else
			\ifx\nxttok\bgroup% si une accolade ouvrante va être lue
				\let\next@action\read@bracearg% aller à \read@bracearg
			\else
				\let\next@action\testtoken% dans les autres cas, aller à \testtoken
			\fi
		\fi
	\fi
	\next@action% faire l'action décidée ci-dessus
}
\def\parsestop@i{% la fin est atteinte
	\expandafter\the\expandafter\code@toks% afficher le registre de tokens
	\gobone% après avoir mangé \parsestop
}
\expandafter\def\expandafter\read@space\space{% \read@space mange un espace dans le code
	\testtoken{ }% et va à \testtoken
}
\def\read@bracearg{%
	\read@bracearg@i\relax% ajoute un \relax avant de passer la main à \read@bracearg@i
}
\def\read@bracearg@i#1\parsestop{% l'argument tout jusqu'à \parsestop
	\expsecond\ifbracefirst{\gobone#1}% retire le \relax et teste si #1 commence par "{"
		{\expandafter\read@bracearg@ii\gobone#1\parsestop}% lire l'argument entre accolades
		{\expandafter\testtoken\gobone#1\parsestop}% sinon, tester le token
}
\def\read@bracearg@ii#1{% l'argument entre accolades est lu
	\ifparse@group\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
		{\begingroup% ouvre un groupe pour parser l'intérieur de l'accolade
			\def\parsestop@i{% redéfinir localement \parsestop@i pour
					\expandafter% retarde \endgroup
				\endgroup%   pour ajouter le contenu local de \code@toks entre accolades
					\expandafter% au contenu de ce même registre avant le groupe
				\parseadd
					\expandafter
				{\expandafter{\the\code@toks}}%
				\expandafter\parse@i% puis va lire le token suivant
				\gobone% après avoir mangé le \parsestop
			}%
			\parse*#1\parsestop% <- le \parsestop@i fermera le groupe semi simple
		}
		{\parseadd{{#1}}% macro non étoilée, on ajoute #1 tel quel entre accolades
		\parse@i% puis va lire le token suivant
		}%
}
\def\testtoken#1{% macro qui teste le token
	\parseadd{#1}% ici, ne rien faire à part ajouter le token
	\parse@i% aller lire le token suivant
}
\def\ifbracefirst#1{% teste si #1 commence par un token de catcode 1
	\ifspacefirst{#1}% si #1 commence par un espace
		{\secondoftwo}% renvoyer faux
		{\ifnum
			\catcode
				\expandafter\expandafter\expandafter
			`%
				\expandafter
			\firstto@nil\detokenize{#1W}\@nil=1
			\expandafter\firstoftwo
		\else
			\expandafter\secondoftwo
		\fi
		}%
}

\def\grab@first#1#2{%
	\ifx#1\empty\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
		{\let#2\empty% si #1 est vide, ne rien faire et assigner <vide> à #2
		}% si #1 n'est pas vide
		{\def\arg@b{#2}% stocke la macro #2 dans \arg@b
		\exparg\ifbracefirst#1% si le 1er token de #1 est "{"
			{\expandafter\grab@arg#1\@nil#1% aller lire l'argument avec \grab@arg
			}
			{% sinon, développer #1 avant de le regarder avec \futurelet :
			\expandafter\futurelet\expandafter\nxttok\expandafter\test@nxttok#1\@nil#1%
			% puis aller à \test@nxttok
			}%
		}%
}
\def\test@nxttok{% si le premier token de l'arg #1 de \grab@first est
	\ifx\nxttok\sptoken% un espace
		\expandafter\grab@spc% aller le lire avec \grab@spc
	\else
		\expandafter\grab@tok% sinon, lire le token avec \grab@tok
	\fi
}
\def\grab@arg#1{% assigne l'argument de \grab@first (mis entre accolades)
	\expandafter\def\arg@b{{#1}}% à #2
	\assign@tonil\relax% puis, assigne le reste à #1 de \grab@first
}
\expandafter\def\expandafter\grab@spc\space{%
	\expandafter\def\arg@b{ }% assigne un espace à #2 de \grab@first
	\assign@tonil\relax% puis, assigne le reste à #1 de \grab@first
}
\def\grab@tok#1{%% assigne le premier token de l'arg #1 de \grab@first
	\expandafter\def\arg@b{#1}% à la macro #2 de \grab@first
	\assign@tonil\relax% puis, assigne le reste à #1 de \grab@first
}
% assigne tout ce qui reste à lire (moins le "\relax") à la macro
% #1 de \grab@first
\def\assign@tonil#1\@nil#2{\expsecond{\def#2}{\gobone#1}}

\def\ifstartwith#1#2{%
	\def\startwith@code{#1}\def\startwith@pattern{#2}%
	\ifempty{#2}
		\firstoftwo% renvoyer vrai si #2 est vide
		{\ifempty{#1}
			\secondoftwo% renvoyer faux si #1 est vide et pas #2
			\ifstartwith@i% dans les autres cas, aller à \ifstartwith@i
		}%
}

\def\ifstartwith@i{%
	\grab@first\startwith@code\first@code% extrait le premier "argument" de <code>
	\grab@first\startwith@pattern\first@pattern% et celui de <motif>
	\ifx\first@code\first@pattern% s'il sont égaux
		\expandafter\ifempty\expandafter{\startwith@pattern}
			{\expandafter\firstoftwo}% et que <motif> ne contient plus rien => vrai
			{\expandafter\ifempty\expandafter{\startwith@code}
				{\expandafter\secondoftwo}% si <code> ne contient plus rien => faux
				{\expandafter\ifstartwith@i}% sinon poursuivre les tests
			}%
	\else% s'ils ne sont pas égaux
		\expandafter\secondoftwo% renvoyer faux
	\fi
}

\newif\ifin@group
\def\ifcontain{%
	\ifstarred
		{\in@groupfalse\ifcontain@i\ifcontain@star}%
		{\ifcontain@i\ifcontain@nostar}%
}

\def\ifcontain@i#1#2#3{% #1 = macro à appeler selon étoile ou pas. #2 = code. #3 = motif
	\def\main@arg{#2}\def\pattern@arg{#3}%
	\ifempty{#3}%
		\firstoftwo
		{\ifempty{#2}
			\secondoftwo
			#1% aller à \ifcontain@star ou \ifcontain@nostar
		}%
}

\def\ifcontain@nostar{%
	\exptwoargs\ifstartwith\main@arg\pattern@arg
		\firstoftwo% si motif est au début de code => vrai
		{\expandafter\ifempty\expandafter{\main@arg}
			\secondoftwo% sinon, si code est vide => faux
			{\grab@first\main@arg\aux@arg% autrement, manger le 1er "argument" de code
			\ifcontain@nostar% et recommencer
			}%
		}%
}

\def\ifcontain@star{%
	\expandafter\ifbracefirst\expandafter{\main@arg}% si code commence par "{"
		{\grab@first\main@arg\aux@arg% enlever {<sous code>} de main@arg
		\begingroup% ouvrir un groupe
			\in@grouptrue% mettre le booléen à vrai
			\expandafter\assign@main@arg\aux@arg\@nil% assigner "sous code" à \main@arg
			\ifcontain@star% et recommencer avec ce nouveau \main@arg
		}% si code ne commence pas par "{"
		{\exptwoargs\ifstartwith\main@arg\pattern@arg% si motif est au début de code
			\return@true% renvoyer vrai
			{\expandafter\ifempty\expandafter{\main@arg}% si code est vide
				{\ifin@group% et que l'on est dans un groupe
					\endgroup \expandafter\ifcontain@star% en sortir et recommencer
				\else% si on n'est pas dans un groupe, le code a été parcouru
					\expandafter\secondoftwo% sans trouver <motif> => renvoyer faux
				\fi
				}% si code n'est pas vide
				{\grab@first\main@arg\arg@code% manger le 1er "argument" de code
				\ifcontain@star% et recommencer
				}%
			}%
		}%
}

\def\return@true{%
	\ifin@group% tant qu'on est dans un groupe
		\endgroup \expandafter\return@true% en sortir et recommencer
	\else
		\expandafter\firstoftwo% sinon, renvoyer vrai
	\fi
}

\def\forcemath#1{% compose #1 en mode math, quel que soit le mode en cours
	\ifmmode\expandafter\firstoftwo\else\expandafter\secondoftwo\fi
		{#1}{$#1$}%
}

\newcount\macro@cnt% numéro à mettre dans le nom des sous macros
\newcount\arg@cnt% compte le nombre d'arguments
\newtoks\param@text% texte de paramètre des macros sous forme #x et/ou [#x]
\newtoks\arg@text% arguments sous forme {#x} et/ou [#x]

\def\newmacro#1{%
	% stocke le nom de la macro et éventuellement "@[<chiffre romain>]"
	\def\macro@name##1{\expandafter\gobone\string#1\ifnum##1>0 @[\romannumeral##1]\fi}%
	\macro@cnt=0 \arg@cnt=0 % initialise les compteurs
	\param@text{}\arg@text{}% vide les registres de texte de paramètre et d'argument
	\newmacro@i% va voir le prochain token
}

\def\newmacro@i{\futurelet\nxttok\newmacro@ii}% met le prochain token dans \nxttok...
% ...puis va à la macro :
\def\newmacro@ii{%
	\ifx\nxttok[% si le prochain token est un crochet
		\let\donext\newmacro@optarg% aller à \newmacro@optarg
	\else
		\ifx\nxttok\bgroup% si c'est un accolade ouvrante
			% le texte de paramètre est fini et il faut définir la macro
			\def\donext{%
				\expandafter\def
					\csname\macro@name\macro@cnt\expandafter\endcsname
				\the\param@text}% <- code juste après non encore lu
		\else% sinon, c'est donc un chiffre
			\let\donext\newmacro@arg% aller à \newmacro@arg
		\fi
	\fi
	\donext% faire l'action décidée ci-dessus
}

\def\newmacro@optarg[#1]{% lit la valeur par défaut de l'argument optionnel
	% définit la macro \<nom>@<nbre> qui lit tous les arguments (optionnels ou pas) jusqu'alors définis
	% à l'aide de \param@text. Puis, elle testera si le prochain token est un crochet
	\expandafter\edef\csname\macro@name\macro@cnt\expandafter\endcsname\the\param@text{%
		\noexpand\ifnexttok[%
			% si oui : la macro \<nom>@<nbr+1> le lira
			{\expandafter\noexpand\csname\macro@name{\numexpr\macro@cnt+1}\expandafter\endcsname
			\the\arg@text}%
			% si non : transmettre à \<nom>@<nbr+1> l'argument optionnel par défaut lu
			{\expandafter\noexpand\csname\macro@name{\numexpr\macro@cnt+1}\expandafter\endcsname
			\the\arg@text[\unexpanded{#1}]}%
	}%
	\advance\arg@cnt 1 % incrémenter le numéro d'argument
	% pour ajouter "[#<x>]" à \param@text et à \arg@text
	\eaddtotoks\param@text{\expandafter[\expandafter##\number\arg@cnt]}%
	\eaddtotoks\arg@text{\expandafter[\expandafter##\number\arg@cnt]}%
	\advance\macro@cnt 1 % incrémenter le numéro de nom de macro
	\newmacro@i% va voir le token suivant
}

\def\newmacro@arg#1{% #1=nb arguments obligatoires à ajouter
	% boucle qui ajoute "#<x>#<x+1>etc" dans \param@text
	% et "{#<x>}{#<x+1>}etc" dans \arg@text
	\ifnum#1>0 % tant qu'on n'a pas ajouté le nombre de #x nécessaire
		\advance\arg@cnt 1 % incrémenter le numéro d'argument
		% pour ajouter #x à \param@text et {#x} à \arg@text
		\eaddtotoks\param@text{\expandafter##\number\arg@cnt}%
		\eaddtotoks\arg@text{\expandafter{\expandafter##\number\arg@cnt}}%
		\expandafter\newmacro@arg\expandafter{\number\numexpr#1-1\expandafter}% reboucler
	\else% après avoir rajouté e qu'il fallait à \param@text et à \arg@text
		\expandafter\newmacro@i% lire le token suivant
	\fi
}

% encadrement avec les réglures où l'on veut
\newmacro\framebox[ULRD]1{% #1 = ULRD (Up, Down, Right, Left)
% ne pas changer le mode H ou V en cours
	\hbox{% enferme dans une \hbox
		\uppercase{\ifin{#1}L}{\vrule width\frboxrule}{}% réglure gauche
		\vtop{%
			\vbox{% 1er élément de la \vtop
				\uppercase{\ifin{#1}U}{% si la réglure sup doit être tracée
					\hrule height\frboxrule% réglure supérieure
					\kern\frboxsep% espace haut
					}
					{}%
				\hbox{%
					\uppercase{\ifin{#1}L}{\kern\frboxsep}{}% espace gauche
					#2% contenu
					\uppercase{\ifin{#1}R}{\kern\frboxsep}{}% espace droite
					}%
			}% puis autres éléments de la \vtop, sous la ligne de base
			\uppercase{\ifin{#1}D}{%
				\kern\frboxsep% espace bas
				\hrule height\frboxrule% réglure inférieure
				}%
				{}%
		}%
		\uppercase{\ifin{#1}R}{\vrule width\frboxrule}{}% réglure droite
	}%
}

\def\retokenize#1{%
	\immediate\openout\wtest=retokenize.tex % ouvre le fichier
	\immediate\write\wtest{\unexpanded{#1}}%  y écrit l'argument
	\immediate\closeout\wtest% ferme le fichier
	\input retokenize.tex % lit le fichier selon les catcodes en vigueur
	\unskip% mange l'espace précédemment ajouté qui provient de la fin du fichier
}

\newtoks\alter@toks% collecteur de tokens

\def\alter#1#2{% #1= délimiteur  #2 = macro altérée
	\let\alter@macro#2% sauvegarde la macro
	\edef\alter@restorecatcode{% restaurera le catcode de #1
		\catcode`\noexpand#1=\the\catcode`#1 }%
	\edef\alter@tmp{\let\noexpand\alter@markertoks= \string#1}%
	\alter@tmp% et sauvegarder le délimiteur après avoir mis son catcode à 12
	\edef\alter@tmp{\def\noexpand\alter@readlitterate@i\string#1####1\string#1}%
	% développe les \string#1 pour que les arguments délimités aient
	% des délimiteurs de catcode 12
	\alter@tmp{% <- comme si on écrivait "\def\alter@readlitterate@i#1##1#1"
		\endgroup% après avoir lu ##1 (tokens rendus inoffensifs), fermer le groupe
		\addtotoks\alter@toks{{\tt##1}}% ajouter ces tokens
		\alter@i% et aller lire le prochain token
	}%
	\alter@toks{}% initialise le collecteur de tokens
	\afterassignment\alter@i% aller lire le premier token après avoir
	\let\alter@tmptok= % mangé l'accolade ouvrante de l'argument qui suit
}

\def\alter@i{% lit le prochain token et va à \alter@ii
	\futurelet\alter@nxttok\alter@ii}

\def\alter@ii{%
	% teste le token qui doit être lu (car \futurelet ne l'a pas mangé)
	\ifx\alter@nxttok\egroup% si la fin va être atteinte
		\let\alter@next\alter@stop% aller à \alterstop@i
	\else
		\ifx\alter@nxttok\@sptoken% si un espace va être lu
			\let\alter@next\alter@readspc% aller à \alter@readspc
		\else
			\ifx\alter@nxttok\bgroup% si une accolade ouvrante av être lue
				\let\alter@next\alter@readarg% aller à \alter@readarg
			\else
				\ifx\alter@nxttok\alter@markertoks% si le délimiteur va être lu
					\let\alter@next\alter@readlitterate% aller à \alter@readlitterate
				\else
					\let\alter@next\alter@readtok% dans les autres cas, aller à \alter@readtok
				\fi
			\fi
		\fi
	\fi
	\alter@next% faire l'action décidée ci-dessus
}

\def\alter@readlitterate{%
	% le prochain token est le délimiteur
	\begingroup% ouvrir un groupe
	\for\alter@tmp=0to255\do{\catcode\alter@tmp=12 }%
	% mettre tous les catcodes à 12
	\defactive{ }{\ }% sauf l'espace
	\doforeach\alter@tmp\in{<,>,-,`,{,},'}% pour chaque motif de ligature
			{\unless\if\alter@tmp\alter@markertoks% s'il est différent du délimiteur
			% le définir pour éviter la ligature
				\expandafter\alter@defligchar\alter@tmp
			\fi
			}%
	\alter@readlitterate@i% puis aller à \alter@readlitterate@i...
	% ...qui a été définie dans \alter
}

\def\alter@defligchar#1{% définit le caractère pour ne pas provoquer de ligature
	\defactive#1{\string#1{}}%
}

\expandafter\def\expandafter\alter@readspc\space{% \alter@readspc mange un espace dans le code
	\addtotoks\alter@toks{ }% ajoute l'espace
	\alter@i% puis lire le token suivant
}

\def\alter@readarg{%
	% le token qui suit est "{"
	\begingroup% ouvrir un groupe
	\def\alterstop@ii{% et modifier localement la macro appelée à la toute fin,
	% après que l'accolade fermante ait été mangée (par \alterstop@i)
		\expandafter\endgroup% retarder la fermeture de groupe ouvert ci-dessus
		\expandafter\addtotoks\expandafter\alter@toks\expandafter
			{\expandafter{\the\alter@toks}}%
		% pour ajouter hors du groupe ce qui a été collecté à l'intérieur,
		% le tout mis entre accolades
		\alter@i% puis, lire le token suivant
	}%
	\alter@toks{}% au début du groupe, initialiser le collecteur
	\afterassignment\alter@i% aller lire le prochain token après
	\let\alter@tmptok= % avoir mangé l'accolade ouvrante
}

\def\alter@readtok#1{%
	% le prochain token n'est pas un token demandant une action spéciale
	\addtotoks\alter@toks{#1}% l'ajouter au collecteur
	\alter@i% et aller lire le token suivant
}

\def\alter@stop{%
	% le token à lire est "}"
	\afterassignment\alterstop@ii% aller à \alterstop@ii après
	\let\alter@tmptok= % avoir mangé l'accolade fermante
}

\def\alterstop@ii{%
	% donner à la macro #2 de \alter tout ce qui a été récolté
	\expandafter\alter@macro\expandafter{\the\alter@toks}%
	\alter@restorecatcode% puis restaure le catcode du délimiteur
}

\newdimen\pixelsize
\newdimen\pixelsep
\pixelsize=.9pt \pixelsep=0pt
\def\pixel{\vrule height\pixelsize width\pixelsize}
\def\blankpixel{\vrule height\pixelsize width0pt \vrule height0pt width\pixelsize}
\def\vblankpixel{\vrule height\pixelsize width0pt}
\def\gap{\kern\pixelsep}

\newskip\letter@skip

\begingroup% dans ce groupe :
\expandafter\gdef\csname impact@" "\endcsname{\hskip4\pixelsize plus0.5\pixelsize minus0.5\pixelsize\relax}%
\catcode`\^^M=13\relax% le retour à la ligne est actif
\edef^^M{\string,}% et se développe en une virgule (de catcode 12)
\catcode`\ =12\relax% l'espace devient un "caractère autre"
\global\deftok\otherspc{ }% définit un espace de catcode 12
\gdef\impact@alphabet{
a/
***
   *
 ***
*  *
****,
a`/
*
 *

***
   *
 ***
*  *
****,
b/
*
*
***
*  *
*  *
*  *
***,
c/
 ***
*
*
*
 ***,
d/
   *
   *
 ***
*  *
*  *
*  *
 ***,
e/
 **
*  *
***
*
 ***,
e'/
  *
 *

 **
*  *
***
*
 ***,
e^/
  *
 * *

 **
*  *
***
*
 ***,
e`/
 *
  *

 **
*  *
***
*
 ***,
f/
 **
*
***
*
*
*
*,
g/
 ***
*  *
*  *
*  *
 ***_
   *
 **,
h/
*
*
*
***
*  *
*  *
*  *
*  *,
i/
*

*
*
*
*
*,
j/
  *

  *
  *
  *
  *
  *_
  *
**,
k/
*
*
*  *
* *
**
* *
*  *,
l/
*
*
*
*
*
*
 *,
m/
** *
* * *
* * *
* * *
* * *,
n/
***
*  *
*  *
*  *
*  *,
o/
 **
*  *
*  *
*  *
 **,
o^/
  *
 * *

 **
*  *
*  *
*  *
 **,
p/
***
*  *
*  *
*  *
***_
*
*,
q/
 ***
*  *
*  *
*  *
 ***_
   *
   *,
r/
* **
**
*
*
*,
s/
 ***
*
 **
   *
***,
t/
*
*
**
*
*
*
 **,
u/
*   *
*   *
*   *
*   *
 ***,
u`/
 *
  *

*   *
*   *
*   *
*   *
 ***,
v/
*   *
*   *
*   *
 * *
  *,
w/
*   *
*   *
* * *
* * *
 * *,
x/
*   *
 * *
  *
 * *
*   *,
y/
*  *
*  *
 * *
  **
   *_
   *
 **,
z/
****
  *
 *
*
****,
TEX/
*****   *     *
  *      *   *
  *       * *
  * *****  * 
  * *     * *
  * *    *   *
  * *** *     *_
    *
    *
    *****,
A/
 ***
*   *
*   *
*   *
*****
*   *
*   *,
B/
***
*  *
*  *
****
*   *
*   *
****,
C/
 ****
*
*
*
*
*
 ****,
D/
****
*   *
*   *
*   *
*   *
*   *
****,
E/
*****
*
*
***
*
*
*****,
F/
*****
*
*
***
*
*
*,
G/
 ***
*   *
*
*  **
*   *
*   *
 ***,
H/
*   *
*   *
*   *
*****
*   *
*   *
*   *,
I/
*
*
*
*
*
*
*,
J/
   *
   *
   *
   *
   *
*  *
 **,
K/
*   *
*  *
* *
**
* *
*  *
*   *,
L/
*
*
*
*
*
*
****,
M/
*   *
** **
* * *
* * *
*   *
*   *
*   *,
N/
*   *
**  *
**  *
* * *
*  **
*  **
*   *,
O/
 ***
*   *
*   *
*   *
*   *
*   *
 ***,
P/
****
*   *
*   *
****
*
*
*,
Q/
 ***
*   *
*   *
*   *
* * *
*  **
 ***,
R/
****
*   *
*   *
****
* *
*  *
*   *,
S/
 ***
*   *
 *
  *
   *
*   *
 ***,
T/
*****
  *
  *
  *
  *
  *
  *,
U/
*   *
*   *
*   *
*   *
*   *
*   *
 ***,
V/
*   *
*   *
*   *
*   *
*   *
 * *
  *,
W/
*   *
*   *
*   *
*   *
* * *
** **
*   *,
X/
*   *
*   *
 * *
  *
 * *
*   *
*   *,
Y/
*   *
*   *
 * *
  *
  *
  *
  *,
Z/
*****
    *
   *
  *
 *
*
*****,
?/
 ***
*   *
   *
  *
  *

  *,
!/
*
*
*
*
*

*,
'/
 *
*



,
./
*,
{,}/
 *_
*,
1/
  *
 **
* *
  *
  *
  *
  *,
2/
 ***
*   *
    *
   *
  *
 *
*****,
3/
 ***
*   *
    *
  **
    *
*   *
 ***,
4/
   *
  **
 * *
*  *
*****
   *
   *,
5/
*****
*
****
    *
    *
    *
****,
6/
 ***
*
*
****
*   *
*   *
 ***,
7/
*****
    *
   *
  *
  *
  *
  *,
8/
 ***
*   *
*   *
 ***
*   *
*   *
 ***,
9/
 ***
*   *
*   *
 ****
    *
    *
 ***,
0/
 ***
*   *
*   *
* * *
*   *
*   *
 ***,
@/
  **
 *  *
*  **
* * *
*  *
 *   *
  ***,
error/
* * *
 * *
* * *
 * *
* * *
 * *
* * *}%
\endgroup%

\def\makecar#1#2{% #1=nom recevant le code final  #2=macro contenant le dessin
	\let\pixabove\empty \let\pixbelow\empty \let\pix@line\empty% initialise à vide
	\exparg\ifin{#2}_% si le code contient _
		{\expandafter\makecar@iii#2\@nil}% aller à \makecar@iii
		{\exparg\makecar@i{#2}}% sinon, à \makecar@i
	\edef#1{% définit la macro #1 comme
		\vtop{% une \vtop contenant :
			\unexpanded{\offinterlineskip\lineskip\pixelsep}% réglage d'espace inter ligne
			\vbox{\unexpanded\expandafter{\pixabove}}% \vbox des pixels au-dessus
			                                         % de la ligne de base
			\unless\ifx\pixbelow\empty% s'il y a des pixels au-dessous de la baseline
				\unexpanded\expandafter{\pixbelow}% les ajouter dans la \vtop
			\fi
			}%
		}%
}

\def\makecar@i#1{% #1 = dessin de la lettre avec les caractères "," "*" et " "
	\doforeach\current@line\in{#1}% pour chaque ligne dans #1 :
		{\ifx\empty\current@line% si la ligne est vide
			\addtomacro\pixabove{\hbox{\vblankpixel}}% ajouter une fausse ligne
		\else% sinon
			\let\pix@line\empty% initialiser le code de la ligne à vide
			\expandafter\makecar@ii\current@line\quark% et la construire
		\fi
		}%
}

\def\makecar@ii#1{% #1=caractère de dessin de la ligne en cours
	\ifxcase#1% si le caractère est
		*        {\addtomacro\pix@line\pixel}%
		\otherspc{\addtomacro\pix@line\blankpixel}%
	\endif
	\ifx#1\quark% si la fin est atteinte 
		\addtomacro\pix@line\unkern% annuler le dernier espace interpixel
		\eaddtomacro\pixabove{% et encapsuler \pix@line dans une \hbox
		\expandafter\hbox\expandafter{\pix@line}}%
	\else% si la fin n'est pas atteinte, ajouter l'espace interpixel
		\addtomacro\pix@line\gap%
		\expandafter\makecar@ii% recommencer avec le caractère suivant
	\fi
}

\def\makecar@iii#1_,#2\@nil{%
	\makecar@i{#2}% construit la partie au-dessous de la baseline
	\let\pixbelow\pixabove% et affecte le code à \pixbelow
	\let\pixabove\empty \let\pix@line\empty% ré-initialise
	\makecar@i{#1}% construit la partie au-dessus de la baseline
}

% On parcourt le texte de remplacement de \impact@alphabet
\edef\saved@crcatcode{\catcode13=\the\catcode13\relax}%
\catcode`\^^M=13\relax% le retour à la ligne est actif
\edef^^M{\string,}% et se développe en une virgule (de catcode 12)
\expsecond{\doforeach\letter@name/\letter@code\in}\impact@alphabet%
	{\edef\letter@name{\letter@name}% développe la lettre (^^M devient ",")
	\edef\letter@code{\letter@code}% développe le code (^^M devient ",")
	\exparg\ifstart\letter@name,% si la lettre commence par ","
		{\edef\letter@name{\expandafter\gobone\letter@name}}% la retirer
		{}%
	\exparg\ifstart\letter@code,% si le code commence par ","
		{\edef\letter@code{\expandafter\gobone\letter@code}}% la retirer
		{}%
	\expandafter\makecar\csname impact@"\letter@name"\endcsname\letter@code%
}%
\saved@crcatcode% redonne le catcode de ^^M
\def\end@process{\end@process}%

\def\impactend{\endgroup}

\newmacro\impact[0.2ex][0pt]{%
	\begingroup
	\pixelsize#1 \pixelsep#2
	\letter@skip=#1 plus.1pt minus.1pt
	\catcode`\!12 \catcode`\?12
	\impact@i
}

\def\impact@i{\futurelet\nxtletter\impact@ii}

\def\impact@ii{%
	\ifx\nxtletter\impactend
		\let\next\unskip
	\else
		\leavevmode
		\ifx\nxtletter\sptoken
			\let\next\impact@spc
		\else
			\let\next\impact@arg
		\fi
	\fi
	\next
}

\expandafter\def\expandafter\impact@spc\space{%
	\csname impact@" "\endcsname
	\impact@i
}

\def\impact@arg#1{%
	\ifcsname impact@"#1"\endcsname
		\csname impact@"#1"\endcsname
	\else
		\csname impact@"error"\endcsname
	\fi
	\hskip\letter@skip
	\impact@i
}

\newdimen\maingraddim \maingraddim=4pt
\newdimen\maingradwd \maingradwd=0.5pt
\newdimen\subgraddim \subgraddim=2.5pt
\newdimen\subgradwd \subgradwd=0.2pt
\newdimen\axiswd \axiswd=0.5pt
\newdimen\plotincrement \plotincrement=0.1pt
\newdimen\tmpdim

\def\maingradx#1{%
	\lower1.5ex\clap{$\scriptscriptstyle#1$}% afficher l'argument au dessous
	\clap{\vrule height\maingraddim width\maingradwd depth0pt }% et la réglure
}

\def\subgradx{\clap{\vrule height\subgraddim width\subgradwd depth0pt }}

% #1= dim entre 2 grad principales #2=nb départ #3=incrément #4=nb arrivée #4=nb intervalles secondaires
\newmacro\xaxis[1cm]1[1]1[4]{%
	\hbox{% tout mettre dans une \hbox
		\setbox0=\hbox{% stocke dans une \hbox les grad secondaires entre 2 unités
			\edef\dimsubgrad{\the\dimexpr#1/#5\relax}% dimension entre 2 subdivisions
			\for\xx=1 to #5-1 \do{% insérer #5-1 fois
				\kern\dimsubgrad% une espace secondaire
				\subgradx% une graduation secondaire
				}%
		}%
		\rlap{% en débordement à droite :
			\FOR\xx = #2 to #4 \do #3{% pour chaque graduation principale
				\maingradx{\xx}% imprimer l'abscisse
				\ifdim\xx pt<#4pt % et en débordement à droite,
					\rlap{\copy0 }% les réglures secondaires, sauf pour la dernière
				\fi
				\kern#1\relax% se déplacer vers la droite
			}%
		}%
		\vrule% tracer l'axe des abscisses
			height\axiswd% d'epaisseur \axiswd, de longueur #1*(#4-#2)/#3
			width\dimexpr#1*\decdiv{\dimtodec\dimexpr#4pt-#2pt\relax}{#3}\relax
			depth 0pt\relax % et de profondeur nulle
	}%
}

\def\maingrady#1{% affiche...
	\vlap{\llap{$\scriptscriptstyle#1$\kern2pt }}% l'ordonnée...
	\vbox to0pt{\vss\hrule height\maingradwd width\maingraddim depth0pt }% et la réglure
}

% affiche une subdiv
\def\subgrady{\vlap{\hrule height\subgradwd width\subgraddim depth0pt }}
% #1= dim entre 2 grad principales #2=abscisse départ #3=incrément
% #4=abscisse arrivée #5=nb intervalles secondaires
\newmacro\yaxis[1cm]1[1]1[4]{%
	\vbox{%
		\offinterlineskip% désactiver le ressort interligne
		\setbox0=\vbox{% stocke dans une \hbox les grad secondaires entre 2 unités
			\edef\dimsubgrad{\the\dimexpr#1/#5\relax}% dimension entre 2 subdivisions
			\for\xx=1 to #5-1 \do{% insérer #5-1 fois
				\kern\dimsubgrad% une espace secondaire
				\subgrady% une graduation secondaire
				}%
		}%
		\edef\dimsubgrad{\the\dimexpr#1/#5\relax}% distance entre 2 subdivisions
		\vbox to 0pt{% en débordement vers le bas
			\FOR\xx = #4to#2\do-#3{%
				\maingrady{\xx}% imprimer l'abscisse
				\ifdim\xx pt>#2pt % et en débordement à droite,
					\vbox to 0pt{\copy0 \vss}% les réglures secondaires, sauf pour la dernière
				\fi
				\kern#1\relax% se déplacer vers la droite
			}%
			\vss% assure le débordement vers le bas
		}%
		\clap{\vrule% tracer l'axe des abscisses
			width\axiswd% d'épaisseur \axiwd, et de hauteur (#4-#2)/#3*#1
			height\decdiv{\dimtodec\dimexpr(#4pt-#2pt)\relax}{#3}\dimexpr#1\relax
			depth 0pt\relax % profondeur nulle
		}
	}%
}

\newdimen\xunit \xunit=1cm
\newdimen\yunit \yunit=1cm
\newmacro\graphzone1[1]1[4]1[1]1[4]{%
	\quitvmode
	\begingroup
		\def\graphxmin{#1}\def\graphxmax{#3}%
		\def\graphymin{#5}\def\graphymax{#7}%
		\def\xincrement{#2}\def\yincrement{#6}%
		\setbox0\hbox{\yaxis[\yunit]{#5}[#6]{#7}[#8]}%
		\setbox1\hbox{\xaxis[\xunit]{#1}[#2]{#3}[#4]}%
		\edef\graphboxht{\the\ht0 }%
		\edef\graphboxwd{\the\wd1 }%
		\rlap{\box1 \clap{\vrule height\dimexpr\graphboxht+\axiswd\relax width\axiswd depth0pt }}%
		\rlap{\box0 }%
		\raise\graphboxht\rlap{\kern-.5\axiswd\vrule height\axiswd width\dimexpr\graphboxwd+\axiswd}%
		\begingroup
			\catcode`\^^M=9\relax
			\graphzone@i
}

\def\graphzone@i#1{%
		\endgroup
		\xunit=\decdiv1\xincrement\xunit
		\yunit=\decdiv1\yincrement\yunit
		\setbox0\hbox{#1}%
		\wd0=\dimexpr\graphboxwd+\axiswd\relax
		\ht0=\dimexpr\graphboxht+\axiswd\relax
		\box0
	\endgroup
	\ignorespaces
}

\def\plot(#1,#2){%
	\edef\x@plot{#1}\edef\y@plot{#2}%
	\ifinside\x@plot[\graphxmin,\graphxmax]%
		{\ifinside\y@plot[\graphymin,\graphymax]%
			{\putat{\dimexpr\x@plot\xunit-\graphxmin\xunit\relax}{\dimexpr\y@plot\yunit-\graphymin\yunit\relax}\plotstuff}%
			\relax
		}
		\relax
}

\def\showyaxis{%
	\ifinside0[\graphymin,\graphymax]%
		{\putat\z@{-\graphymin\yunit}{\vrule width\graphboxwd height\axiswd}}%
		\relax
}

\def\showxaxis{%
	\ifinside0[\graphxmin,\graphxmax]%
		{\putat{-\graphxmin\xunit}\z@{\clap{\vrule width\axiswd height\graphboxht}}}%
		\relax
}

\def\showaxis{\showxaxis\showyaxis}

\def\putat#1#2#3{%
	\leavevmode\rlap{\kern#1\vbox to0pt{\vss\hbox{#3}\kern#2}}%
}

\newmacro\cross[2pt][0.2pt]{%
	\quitvmode
	\vlap{%
		\clap{%
			\vrule height#2 depth0pt width#1
			\vrule height#1 depth#1 width#2
			\vrule height#2 depth0pt width#1
		}%
	}%
}

\protected\def\numsep{\kern0.2em }% \numsep est le séparateur mis tous les 3 chiffres

\def\formatdecpart#1{% #1=série de chiffres
	\ifempty{#1}% si la partie décimale est vide
		{}% ne rien afficher
		{{,}\formatdecpart@i1.#1..}% sinon, afficher la virgule et mettre en forme
}

% #1=compteur de caractères #2= chiffre à déplacer
% #3= chiffres restants     #4 = chiffres déjà traités
\def\formatdecpart@i#1.#2#3.#4.{% #1=compteur de caractères #2= chiffres traité #3= chiffres traités
	\ifempty{#3}% si #2 est le dernier chiffre à traiter
		{#4#2}% le mettre en dernière position et tout afficher, sinon
		{\ifnum#1=3 \expandafter\firstoftwo
		\else\expandafter\secondoftwo
		\fi% si 3 chiffres sont atteint, rendre #1 égal à 1 et
			{\formatdecpart@i 1.#3.#4#2\numsep.}% mettre #2\numsep en dernier puis recommencer
			% sinon, mettre #2 en dernière position et recommencer
			% tout en incrémentant #1 de 1
			{\expandafter\formatdecpart@i\number\numexpr#1+1.#3.#4#2.}%
		}%
}

\def\formatintpart#1{% #1=série de chiffres
	\expandafter\formatintpart@i\expandafter1\expandafter.%
	\romannumeral\reverse{#1\z@}..% appelle la macro récursive
}

% #1=compteur de caractères #2= chiffre à déplacer
% #3= chiffres restants     #4 = chiffres déjà traités
\def\formatintpart@i#1.#2#3.#4.{% #1=compteur de caractères #2= chiffres traité #3= chiffres traités
	\ifempty{#3}% si #2 est le dernier chiffre à traiter
		{#2#4}% le mettre en première position et tout afficher, sinon
		{\ifnum#1=3 \expandafter\firstoftwo
		\else\expandafter\secondoftwo
		\fi% si 3 chiffres sont atteint, rendre #1 égal à 1 et
			{\formatintpart@i 1.#3.\numsep#2#4.}% mettre \numsep#2 en premier puis recommencer
			% sinon, mettre #2 en dernière position et recommencer
			% tout en incrémentant #1 de 1
			{\expandafter\formatintpart@i\number\numexpr#1+1.#3.#2#4.}%
		}%
}

\def\removefirstzeros#1{%
	\removefirstzeros@i#1\removefirstzeros@i
}
\def\removefirstzeros@i#1{%
	\ifx\removefirstzeros@i#1% \removefirstzeros@i est lu donc tout le nombre a été parcouru
		\expandafter0% laisser un zéro
	\else
		\ifx0#1% si le chiffre lu est un 0
			\expandafter\expandafter\expandafter\removefirstzeros@i% recommencer
		\else% sinon remettre le chiffre et tout afficher jusqu'à \removefirstzeros@i
			\expandafter\expandafter\expandafter\removefirstzeros@ii\expandafter\expandafter\expandafter#1%
		\fi
	\fi
}
\def\removefirstzeros@ii#1\removefirstzeros@i{#1}

\def\ifnodecpart#1{\ifnodecpart@i#1.\@nil}
\def\ifnodecpart@i#1.#2\@nil{\ifempty{#2}}

\newbox\remainbox% boite contenant le texte total
\newbox\currentline% boite contenant le ligne en cours
\newcount\linecnt% compteur pour numéroter les lignes

\newmacro\leftline[0pt]{% définit ce qui se trouve à gauche de chaque ligne
	\def\wd@left{#1}%
	\def\stuff@left
}

\newmacro\rightline[0pt]{% définit ce qui se trouve à droite de chaque ligne
	\def\wd@right{#1}%
	\def\stuff@right
}

\let\formatline=\identity

\leftline[15pt]{$\scriptscriptstyle\number\linecnt$\kern5pt }% numérotation à gauche
\rightline{}% rien à droite

\def\numlines{%
	\par\smallskip
	\begingroup% dans un groupe semi simple
		\splittopskip=0pt % ne rajouter aucun espace au sommet de la boite restante
		\savingvdiscards=1 % autorise la sauvagarde des éléments supprimés
		\linecnt=0 % initialiser le compteur de lignes
		\setbox\remainbox=\vbox\bgroup% compose la boite...
			\advance\hsize by% diminuer la \hsize
			-\dimexpr\wd@left+\wd@right\relax% de la largeur des contenus
}

\def\endnumlines{%
	\egroup
	\offinterlineskip
	\split@line
}

\def\split@line{%
	\ifvoid\remainbox% si la boite est vide
		\par% fin du processus
		\endgroup% fermer le groupe ouvert au début
	\else% sinon
		\advance\linecnt 1 % incrémente le compteur de lignes
		\edef\htbefore{\the\vdim\remainbox}%
		\edef\restorevfuzz{\vfuzz=\the\vfuzz\relax}% sauvegarde le \vfuzz
		\vfuzz=\maxdimen% annule les avertissements pour débordement
		\setbox\currentline=\vsplit\remainbox to 0pt % couper la boite à 0pt de hauteur
		\restorevfuzz
		\setbox\currentline=\vbox{\unvbox\currentline}% redonner à la boite sa hauteur
		\let\savedsplitdiscards\splitdiscards
		\edef\intersplitspace{% calcul de l'espace vertical perdu à la coupure
			\the\dimexpr\htbefore-(\vdim\remainbox+\vdim\currentline)\relax
		}%
		\hbox{% en mode vertical et dans une hbox, afficher :
			\hbox to\wd@left{\hss\stuff@left}%   1) ce qui est à gauche
			\formatline{\box\currentline}%       2) la ligne courante
			\hbox to\wd@right{\stuff@right\hss}% 3) ce qui est à droite
		}%
		\splitdiscards% affiche ce qui a été ignoré à la coupure
		\expandafter\split@line% recommencer
	\fi
}

\newskip\interletterskip
\newskip\interwordskip
\catcode`\@11
\newtoks\spacetxt@toks%  le registre qui contient le texte final

\def\spacetxt{%
	\let\spacetxt@endprocess\spacetxt@endnormal
	% définit la macro appelée en fin de processus -> à priori : fin normale
	\ifstarred% si la macro est étoilée
		{\let\spacetxt@recurse\spacetxt@star% définir la macro récursive
		\spacetxt@i% et aller à \spacetxt@i
		}% sinon
		{\let\spacetxt@recurse\spacetxt@nostar% définir la macro récursive
		\spacetxt@i% et aller à \spacetxt@i
		}%
}

\newmacro\spacetxt@i[0.3em][3\interletterskip]1{%
% arg optionnel #1 et #2 = ressorts inter-lettre et inter--mot
% #3 = texte à espacer
	\interletterskip=#1\relax
	\interwordskip=#2\relax
	\def\spacetxt@code{#3}% met le texte à espacer dans \spacetxt@code
	\spacetxt@toks{}% initialiser le registre contenant le texte final
	\spacetxt@recurse% aller à la macro récursive précédemment définie
}

\newif\if@indivifound% booléen qui sera vrai si un motif spécial est rencontré

\def\spacetxt@nostar{%
	\expandafter\ifempty\expandafter{\spacetxt@code}% si texte restant est vide
		\spacetxt@endprocess% aller à la fin du processus
		{\@indivifoundfalse% sinon, à priori, les motifs non réguliers ne sont pas trouvés
		\expandafter\doforeach\expandafter\indivi@tmp\expandafter\in\expandafter{\indivilist}
		% pour chaque \indivi@tmp dans \indivilist
			{\exptwoargs\ifstartwith\spacetxt@code\indivi@tmp
			% si le code commence par le motif courant
				{\eaddtotoks\spacetxt@toks{\indivi@tmp\hskip\interletterskip}%
				% l'ajouter dans le registre ainsi que l'espace inter-lettre
				\expandafter\rightofsc\expandafter\spacetxt@code\expandafter{\indivi@tmp}%
				% et enlever le motif du texte restant à lire
				\@indivifoundtrue
				% marquer qu'un motif a été trouvé
				\doforeachexit
				% et sortir prématurément de la boucle
				}%
				\relax
				% si le code ne commence pas le motif courant -> ne rien faire
			}%
		\if@indivifound
		\else% si aucun motif n'a été trouvé
			\grab@first\spacetxt@code\spacetxt@temp
			% retirer le 1er caractère du texte
% 			\ifcat\noexpand\spacetxt@temp\sptoken
			\ifx\spacetxt@temp\space
			% si le 1er caractère est un espace
				\addtotoks\spacetxt@toks{\hskip\interwordskip}%
				% ajouter l'espace inter-mot au registre de token
			\else
			% si le 1er caractère n'est pas un espace
				\eaddtotoks\spacetxt@toks{\spacetxt@temp\hskip\interletterskip}%
				% ajouter ce caractère et l'espace inter-lettre au registre de token
			\fi
		\fi
		\spacetxt@recurse% enfin, continuer le processus
		}%
}

\def\spacetxt@star{%
	\expandafter\ifempty\expandafter{\spacetxt@code}% si texte restant est vide
		\spacetxt@endprocess% aller à la fin du processus
		{\expandafter\ifbracefirst\expandafter{\spacetxt@code}%
		% sinon, si texte commence par "{"
			{\grab@first\spacetxt@code\spacetxt@temp
			% mettre {<argument} dans \spacetxt@temp
			\begingroup% ouvrir un groupe
			\expandafter\def\expandafter\spacetxt@code\spacetxt@temp
			% mettre le contenu de l'argument dans \spacetxt@code
			\let\spacetxt@endprocess\spacetxt@endingroup% changer le processus de fin
			\spacetxt@toks{}% initialiser
			\spacetxt@recurse% exécuter le processus avec ce nouveau texte
			}% si le code ne commence pas par "{", aller à \spacetxt@nostar mais comme
			\spacetxt@nostar% \spacetxt@recurse vaut \spacetxt@star, n'y faire qu'1 boucle
		}%
}

\def\spacetxt@endnormal{% fin de processus normal
	\the\spacetxt@toks% afficher le registre à token
	\unskip% et supprimer le dernier ressort
}

\def\spacetxt@endingroup{% fin du processus dans un groupe :
	\expandafter\endgroup\expandafter% avant de fermer le groupe
	\addtotoks\expandafter\spacetxt@toks\expandafter% ajouter au registre hors du groupe
		{\expandafter{\the\spacetxt@toks}}% ce qui est collecté localement mis entre {}
	\spacetxt@recurse% puis aller à la macro récursive
}

\def\indivilist{<<,>>}% liste des motifs spéciaux

\def\insert@blankchar{%
	\ifstarred\insert@blankchar@ii\insert@blankchar@i
}

\def\insert@blankchar@i#1{% insère une espace de largeur #1 caractères complets
	\ifnum\numexpr#1\relax>0
		\kern\numexpr#1\relax\dimexpr\ttchar@width+\brktt@interletter\relax
	\fi
}

\def\insert@blankchar@ii#1{% insère #1-1 caractères complets + 1 largeur de caractère
	\ifnum\numexpr#1\relax>0
		\insert@blankchar@i{#1-1}\kern\ttchar@width
	\fi
}

\def\restart@hbox#1{%
	\egroup
	\hbox\bgroup
	\expsecond{\def\tt@remaintext}
		{\romannumeral\removefirstspaces@i{#1}}% initialiser le code à composer
	\let\previous@char\space% initialise le caractère précédent
	\line@starttrue% aucun caractère n'a encore été imprimé
	\brktt@cnt=0\relax% remettre le compteur à 0
}

\def\print@nchar#1{% affiche #1 caractères pris dans \tt@remaintext
	\for\xxx= 1 to #1 \do 1{%
		\ifx\tt@remaintext\empty% si le code restant à composer est vide
			\exitfor\xxx%sortir de la boucle prématurément
		\else
			\@indivifoundfalse% sinon, à priori, les motifs de ligature ne sont pas trouvés
			% pour chaque \indivi@tmp dans la liste de ligatures
			\expsecond{\doforeach\indivi@tmp\in}{\liglist}%
				{% si le code commence par la \idx{ligature} courante
				\exptwoargs\ifstartwith\tt@remaintext\indivi@tmp%
					{\let\previous@char\indivi@tmp% prendre le motif pour caractère courant
					\expsecond{\rightofsc\tt@remaintext}{\indivi@tmp}% et l'enlever du texte restant à lire%
					\@indivifoundtrue% marquer qu'un motif a été trouvé
					\doforeachexit% et sortir prématurément de la boucle
					}%
					{}% si le code ne commence pas le motif courant -> ne rien faire
				}%
			\unless\if@indivifound% si aucun motif trouvé,
				\grab@first\tt@remaintext\previous@char%  lire le premier caractère
			\fi
			\advance\brktt@cnt by 1 % incrémenter le compteur de caractères
			\hbox to\ttchar@width{\hss\previous@char\hss}% afficher le caractère lu
			\line@startfalse% nous ne sommes plus au début d'une ligne
			\ifnum\brktt@cnt<\maxchar@num\relax% si la ligne n'est pas encore remplie
				\kern\brktt@interletter% insérer le ressort inter-lettre
			\else
				\exitfor\xxx% sinon, sortir de la boucle prématurément
			\fi
		\fi
	}%
}

\newmacro\breakttA[0.3em][\hsize]1{%
% arg optionnel #1 et #2 = ressorts inter-lettre et dimension horizontale texte
% #3 = texte à espacer
	\begingroup% ouvrir un groupe et le fermer à la toute fin
	\par% commencer un nouveau paragraphe -> passage en mode vertical
	\parindent=0pt% empêche l'indentation
	\tt% passer en police à chasse fixe
	\setbox0 = \hbox{M}% la boite 0 contient un caractère
	\edef\ttchar@width{\the\wd0 }% largeur de chaque caractère en police \tt
	\edef\text@width{\the\dimexpr#2\relax}% largeur de composition
	% les 2 lignes suivantes rendent le compteur égal à E((L-l)/(l+Delta))
	\brktt@cnt=\numexpr\dimexpr#2-\wd0 \relax\relax% largeur diminuée du 1er caractère
	\divide\brktt@cnt by \numexpr\dimexpr\wd0 + #1 \relax\relax
	% le nombre de caractères par ligne est égal à 1 de plus :
	\edef\maxchar@num{\number\numexpr\brktt@cnt+1\relax}%
	% calcul de la dimension inter-lettre
	\brktt@interletter=\dimexpr(\text@width-\ttchar@width*\maxchar@num)/\brktt@cnt\relax
	\expsecond{\expsecond{\def\tt@remaintext}}{\removetrailspaces{#3}}% met le texte à espacer dans \tt@remaintext
	\addtomacro\tt@remaintext{ \relax}% ajouter " \relax" à la fin : le code finit donc par " \relax"
	\def\tt@emptytext{ \relax}% sera le code lorsque tout est composé
	\unless\ifx\tt@remaintext\tt@emptytext% si le texte à composer n'est pas vide
		\hbox\bgroup% démarrer la boite horizontale contenant la première ligne
		\insert@blankchar\ttindent% insérer une espace d'indentation de longueur (l+Delta')*\ttindent
		\brktt@cnt=\ttindent\relax% tenir compte du nombre de caractères indentés
		\line@starttrue% il s'agit du début d'une ligne
		\expandafter\breakttA@i% aller à la macro récursive
	\fi
}

\def\leftofsc#1#2{% dans la sc #1, garde ce qui est à gauche de #2
	\def\leftofsc@i##1#2##2\@nil{\def#1{##1}}%
	\expandafter\leftofsc@i#1\@nil
}

\def\len@tonextword{% stocke dans \next@len le nombre de caractères avant
                    % le prochain point de coupure dans \tt@remaintext
	\let\next@word\tt@remaintext% copie \tt@remaintext dans la macro temporaire \next@word
	\leftofsc\next@word{ }% ne prend que ce qui est avant le prochain espace
	\exparg\ifin{\next@word}{-}% si le mot contient un tiret
		{\leftofsc\next@word{-}% prendre ce qui est à gauche de ce tiret
		\def\extra@char{1}% il y a un caractère de plus à loger après le mot
		}
		{% sinon, le caractère après le mot est un espace
		\def\extra@char{0}% qu'il ne faut pas compter
		}%
	\setbox0=\hbox{\next@word}% enfermer le mot dans une boite
	% et en calculer le nombre de caractères
	\edef\next@len{\number\numexpr\dimexpr\wd0 \relax/\dimexpr\ttchar@width\relax\relax}%
}

\newmacro\zerocompose[]2{%
% #1=code à exécuter avant la composition
% #2=registre de boite recevant le résultat
% #3= texte à composer en largeur 0pt
	\setbox#2=\vbox{%
		#1% code a exécuter (changement de fonte par exemple)
		\hfuzz=\maxdimen% annule les avertissements pour débordement horizontaux
		\hbadness=10000 % annule les avertissements pour mauvaise boite horizontale
		\pretolerance=-1 % désactive la première passe (celle sans coupures)
		\tolerance=10000 % passe avec coupures acceptée
		\hyphenpenalty=-10000 % favorise fortement les copures de mots
		\lefthyphenmin=2 \righthyphenmin=3 % longueur mini des fragments de début et fin
		\clubpenalty=0 % pas de \idx{pénalité} supplémentaire après la première ligne
		\interlinepenalty=0 % pas de \idx{pénalité} inter-ligne
		\widowpenalty=0 % pas de \idx{pénalité} supplémentaire avant la dernière ligne
		\exhyphenpenalty=0 % ne pas pénaliser une coupure explicite
		\leftskip=0pt \rightskip=0pt % désactive les éventuels ressorts latéraux
		\everypar={}% désactive l'éventuel \everypar
		\parfillskip=0pt plus1fil % règle le \parfillskip par défaut
		\hsize=0pt % largeur de composition = 0pt
		\edef\restorehyphenchar{\hyphenchar\font=\number\hyphenchar\font}%
		\hyphenchar\font=`\- % impose "-" comme caractère de coupure
		\noindent % pas d'indentation + passage en mode horizontal
		\hskip0pt \relax% premier noeud horizontal pour permettre la coupure de la suite
		#3\par% compose #3
		\restorehyphenchar% restaure le caractère de coupure
		}%
}

\def\hyphlengths#1#2{%#2 = macro contenant les longueurs de coupures du mot #1
	\begingroup
		\zerocompose
			[\tt% passer en police à chasse fixe
			\setbox\z@\hbox{M}\xdef\ttwidth{\the\wd\z@}% mesurer la largeur des caractères
			\hyphenchar\font=`\- % choisit "-" comme caractère de coupure
			]\z@{#1}% compose en 0pt dans la boite 0
		\let#2 = \empty% initialise la macro #2
		\def\cumul@length{0}%
		\vfuzz=\maxdimen% annule les avertissements pour débordement
		\splittopskip=\z@ % ne rajouter aucun espace au sommet de la boite restante
		\loop
			\setbox1=\vsplit\z@ to \z@% couper la boite à 0pt de hauteur
			{\setbox\z@=\vbox{\unvbox1 \unskip\unpenalty\global\setbox1=\lastbox}}%
			\setbox1=\hbox{\unhbox1 }%
			\unless\ifvoid\z@% si la boite 0 n'est pas encore vide
				\edef\cumul@length{% mettre à jour \cumul@length
					\number\numexpr
						\cumul@length
						+% ajouter le quotient "largeur syllabe/largeur d'1 caractère"
						\wd1/\dimexpr\ttwidth\relax
						-1% et soustraire 1 (le caractère "-")
						\relax
				}%
				% ajouter à #2 la virgule et le cumul actuel +1
				\edef#2{% définir la macro #2 :
					#2% reprendre le contenu de #2
					\ifx#2\empty\else,\fi% ajouter "," si #2 non vide
					\number\numexpr\cumul@length+1\relax% et le cumul
					}%
		\repeat% et recommencer
		\expsecond{% avant de fermer le groupe
	\endgroup
	\def#2}{#2}% définit #2 hors du groupe
}

\newif\ifnumalgo
\newcount\algocnt
\numalgotrue

\def\algoindent{2em}
\def\algorule{.4pt}% épaisseur des réglures de début et de fin

\def\algohrulefill{% remplit avec une ligne horizontale
	\leavevmode
	\leaders\hrule height\algorule\hfill
	\kern0pt % rajoute un noeud au cas où la commande est en fin de ligne
}

\def\algoleftskip{10pt}
\def\algorightskip{10pt}

\newmacro\algorithm[\\,\#,\{,\}]2{%
	\medbreak
	\begingroup% ouvre un groupe (sera fermé à la fin de l'algorithme)
		\footnotesize
		\algocnt=1 % initialise le compteur de lignes
		\leftskip=\algoleftskip \rightskip=\algorightskip% initialise les ressorts latéraux
		\parindent=0pt % pas d'indentation
		%%%%%%%%%%%% affichage du titre %%%%%%%
		\algohrulefill% remplir avec une ligne horizontale
		\ifempty{#2}% si #2 est vide
			{}% ne rien insérer
			{% sinon
			\lower.5ex\hbox{ #2 }% insérer le titre abaissé de 0.5ex
			\algohrulefill% insérer une ligne horizontale
			}%
		\par% aller à la ligne
		\nointerlineskip% ne pas insérer le ressort interligne
		\kern7pt % et sauter 7pt verticalement
		\nobreak% empêcher une coupure de page
		%%%%%%%%%%%%%% fin du titre %%%%%%%%%%
		%
		%%%%%%%%%%%%%% rend les caractères actifs %%%%%%%%%%%%%%
		\def~##1~{\begingroup\bf##1\endgroup}%
		\defactive:{% rend ":" actif
			\futurelet\nxttok\algoassign% \nxttok = token suivant
		}%
		\def\algoassign{% suite du code de ":"
			\ifx=\nxttok% si ":" est suivi de "="
				\ifmmode% si mode math
					\leftarrow% afficher "\leftarrow"
				\else% si mode texte
					${}\leftarrow{}$% passer en mode math pour "\leftarrow"
				\fi
				\expandafter\gobone% manger le signe "="
			\else% si ":" n'est pas suivi de "="'
				\string:% afficher ":"
			\fi
		}%
		\expandafter\def\expandafter\oldeverypar\expandafter% sauvegarder...
			{\the\everypar}% ... l'action effectuée à chaque paragraphe
		\ifnumalgo% si la numérotation est demandée,
			\everypar\expandafter{% à chaque paragraphe
				\the\everypar% reprendre le contenu précédent
				\llap{% et à droite du début de la ligne,
					$\scriptstyle\number\algocnt$% afficher le numéro
					\kern\dimexpr4pt+\leftskip-\algoleftskip\relax% en tenant compte de l'indentation
					}%
			}%
		\fi
		\def\algopar{% actions effectués par ^^M
			\advance\algocnt by 1 % incrémente le compteur de lignes
			\color{black}% repasse en couleur noire
			\rm% fonte droite
			\par% termine le paragraphe
			\leftskip=\algoleftskip % initialise le ressort gauche
		}%
		\doforeach\currentchar\in{#1}{\expandafter\catcode\expandafter`\currentchar=12 }%
		\defactive\^^I{\advance\leftskip by \algoindent\relax}%
		\defactive\ {\hskip1.25\fontdimen2\font\relax}% espace = 25% de + que la largeur naturelle
		\letactive\^^M\algopar
		\defactive\%{\it\color{gray}\char`\%}% passe en italique et gris puis affiche "%"
		\defactive_{\ifmmode_\else\string_\fi}%
		\defactive#3{% rend le token #3 actif (il sera rencontré à la fin de l'algorithme)
			\everypar\expandafter{\oldeverypar}% restaurer l'ancien \everypar
			\par% aller à la ligne
			\nointerlineskip% ne pas insérer le ressort interligne
			\kern7pt % et sauter 7pt verticalement
			\nobreak% empêcher une coupure de page
			\algohrulefill% tracer la ligne de fin
			\smallbreak% saute un petit espace vertical
	\endgroup% ferme le groupe ouvert au début de l'algorithme
		}%
	%%%%%%%%%%%%%%%%% fin des caractères actifs %%%%%%%%%%%%%%%%
	%
	\sanitizealgo% va manger les espaces et les ^^M au début de l'algo
}

\def\sanitizealgo{\futurelet\nxttok\checkfirsttok}% récupère le prochain token

\def\checkfirsttok{% teste le prochaun token
	\def\nextaction{% à priori, on considère que la suite est " " ou "^^M" donc
		\afterassignment\sanitizealgo% aller à \sanitizealgo
		\let\nexttok= % après avoir mangé ce "^^M" ou cet espace
	}%
	\unless\ifx\nxttok\algopar% si le prochain token n'est pas un ^^M
		\unless\ifx\space\nxttok% et si le prochain token n'est pas un espace
			\let\nextaction\relax% ne rien faire ensuite
		\fi
	\fi
	\nextaction% faire l'action décidée ci-dessus
}

\def\true@sgn#1{\ifnum#11<\z@-\fi}

\restoreatcoatcode\relax
\endinput