--- /dev/null
+<simple>
+ <titre>Documentation liée</titre>
+</simple>
--- /dev/null
+<h1 id="liste-des-commandes">Liste des commandes</h1>
+<p>Notations:</p>
+<p><argument>: signifie que l’argument est <strong>obligatoire</strong>.</p>
+<p>[argument]: signifie que l’argument est <strong>facultatif</strong>.</p>
+<h2 id="Args">Args</h3>
+<ul>
+<li><p><b>Args( <entier> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction n’a d’effet que dans une macro, elle évalue et renvoie l’argument numéro <<em>entier</em>> avec lequel la macro a été appelée. Hors de ce contexte, elle renvoie la valeur <em>Nil</em>. Voir également la commande <a href="#StrArgs">StrArgs</a></p></li>
+<li><p><u>Exemple(s)</u> : Voir la fonction <a href="#Nargs">Nargs</a>.</p></li>
+</ul>
+<h2 id="Assign">Assign</h3>
+<ul>
+<li><p><b>Assign( <expression>, <variable>, <valeur> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue <<em>valeur</em>> et l’affecte à la variable nommée <<em>variable</em>> dans <<em>expression</em>><sup><a href="#fn1" class="footnoteRef" id="fnref1">1</a></sup>. La fonction <em>Assign</em> renvoie la valeur <em>Nil</em>. Cette fonction est utile dans l’écriture de macros prenant une expression comme paramètre et qui doivent l’évaluer.</p></li>
+<li><p><u>Exemple(s)</u> : voici une macro <span style="color:red">Bof</span> qui prend une fonction f(t) en paramètre et qui calcule la liste <span class="math">[<em>f</em>(0), <em>f</em>(1), . . . , <em>f</em>(5)]</span>:</p></li>
+</ul>
+<p><div style="text-align:center">{for $k from 0 to 5 do Assign(%1,t,k), %1 od}</div></p>
+<p>%1 représente le premier paramètre de la macro (c’est à dire f(t)), la boucle: pour k allant de 0 à 5 elle exécute la commande [Assign(%1, t, k), %1], celle-ci assigne la valeur de k à la variable <span class="math"><em>t</em></span> dans l’expression %1, puis évalue %1. L’exécution de <span style="color:red">Bof(t^2)</span> donne: <span style="color:magenta">[0,1,4,9,16,25]</span>. L’exécution de <span style="color:red">Bof(x^2)</span> donne <em>Nil</em>.</p>
+<h2 id="Attributs">Attributs</h3>
+<ul>
+<li><p><b>Attributs()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ouvre la fenêtre permettant de modifier les attributs d’un élément graphique. Cette fonction renvoie la valeur 1 si l’utilisateur a choisi <em>OK</em>, elle renvoie la valeur 0 s’il a choisi <em>Cancel</em>. Si l’utilisateur a choisi <em>OK</em>, alors les variables globales correspondant aux attributs sont modifiées en conséquence.</p></li>
+</ul>
+<h2 id="Border">Border</h3>
+<ul>
+<li><p><b>Border( <0/1> )</b></p></li>
+<li><p><u>Description</u> : cette fonction détermine si un cadre doit être dessiné ou non autour des marges du graphique dans les exportations. Lorsque la valeur de l’argument est nulle (valeur par défaut), le cadre n’est pas dessiné.</p>
+<p>Lorsque l’argument est vide, cette fonction renvoie l’état de la bordure à l’exportation (0 ou 1). Sinon, elle renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="ChangeAttr">ChangeAttr</h3>
+<ul>
+<li><p><b>ChangeAttr( <element1>, ..., <elementN> )</b></p></li>
+<li><p><u>Description</u> : cette fonction permet de modifier les attributs des éléments graphiques <<em>element1</em>>, ..., <<em>elementN</em>>, en leur affectant la valeur des attributs en cours. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Clip2D">Clip2D</h3>
+<ul>
+<li><p><b>Clip2D( <ligne polygonale>, <contour convexe> [, close(0/1) ] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction clippe la <<em>ligne polygonale</em>> qui doit être une variable contenant une liste de complexes, avec le <<em>contour convexe</em>>, qui est lui aussi une liste de complexes. La fonction calcule la ligne polygonale qui en résulte modifie la variable <<em>ligne polygonale</em>> en conséquence, le dernier agument <<em>close</em>> (<span class="math">0</span> par défaut) permet de préciser si la <<em>ligne polygonale</em>> doit être refermée ou non. La fonction renvoie <em>Nil</em>.</p></li>
+</ul>
+<h2 id="CloseFile">CloseFile</h3>
+<ul>
+<li><p><b>CloseFile()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet de fermer le fichier ouvert par la commande <a href="#OpenFile">OpenFile</a>.</p></li>
+</ul>
+<h2 id="ComposeMatrix">ComposeMatrix</h3>
+<ul>
+<li><p><b>ComposeMatrix( <[z1, z2, z3]> )</b></p></li>
+<li><p><u>Description</u> : cette fonction permet de composer la matrice courante (celle-ci affecte tous les éléments graphiques sauf les axes et les grilles dans la version actuelle) avec la matrice <<em>[z1, z2, z3]</em>>. Cette matrice représente l’expression analytique d’une application affine du plan, c’est une liste de trois complexes: <span class="math"><em>z</em>1</span> qui est l’affixe du vecteur de translation, <span class="math"><em>z</em>2</span> qui est l’affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et <span class="math"><em>z</em>3</span> qui est l’affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l’identité s’écrit ainsi: [0,1,i] (c’est la matrice par défaut). (Voir aussi les commandes <a href="#GetMatrix">GetMatrix</a>, <a href="#SetMatrix">SetMatrix</a>, et <a href="#IdMatrix">IdMatrix</a>).</p></li>
+</ul>
+<h2 id="Copy">Copy</h3>
+<ul>
+<li><p><b>Copy( <liste>, <index depart>, <nombre> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction renvoie la liste constituée par les <<em>nombre</em>> éléments de la <<em>liste</em>> à partir de l’élément numéro <<em>depart</em>>[inclus]. Si <<em>nombre</em>> est nul, alors la fonction renvoie tous les éléments de la liste à partir de l’élément numéro <<em>départ</em>>.</p>
+<p>Si le numéro <<em>depart</em>> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, le dernier élément a l’index <span class="math"> - 1</span>, l’avant-dernier a l’index <span class="math"> - 2</span> <span class="math">⋯</span> etc. La fonction renvoie les <<em>nombre</em>> éléments de la liste (ou toute la liste si <<em>nombre</em>> est nul) en allant vers la gauche, mais la liste renvoyée est dans le même sens que la <<em>liste</em>>, et cette dernière n’est pas modifiée.</p></li>
+<li><p><u>Exemple(s)</u> : </p>
+<ul>
+<li><p><span style="color:red">Copy([1,2,3,4],2,2)</span> renvoie <span style="color:magenta">[2,3]</span>.</p></li>
+<li><p><span style="color:red">Copy([1,2,3,4],2,5)</span> renvoie <span style="color:magenta">[2,3,4]</span>.</p></li>
+<li><p><span style="color:red">Copy([1,2,3,4],2,0)</span> renvoie <span style="color:magenta">[2,3,4]</span>.</p></li>
+<li><p><span style="color:red">Copy([1,2,3,4],-1,2)</span> renvoie <span style="color:magenta">[3,4]</span>.</p></li>
+<li><p><span style="color:red">Copy([1,2,3,4],-2,2)</span> renvoie <span style="color:magenta">[2,3]</span>.</p></li>
+<li><p><span style="color:red">Copy([1,2,3,4],-2,0)</span> renvoie <span style="color:magenta">[1,2,3]</span>.</p></li>
+</ul></li>
+</ul>
+<p><strong>NB</strong>: pour des raisons de compatibilité avec l’ancienne version, l’index <span class="math">0</span> correspond aussi au dernier élément de la liste.</p>
+<h2 id="DefaultAttr">DefaultAttr</h3>
+<ul>
+<li><p><b>DefaultAttr()</b></p></li>
+<li><p><u>Description</u> : cette fonction met toutes les variables correspondant aux attributs (<span style="font-style:italic;color:red">Color</span>, <span style="font-style:italic;color:red">Width</span>, ...) à leur valeur par défaut. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Del">Del</h3>
+<ul>
+<li><p><b>Del( <liste>, <depart>, <nombre> )</b>.</p></li>
+<li><p><u>Description</u> : supprime de la <<em>liste</em>> <<em>nombre</em>> éléments à partir du numéro <<em>départ</em>>[inclus]. Si <<em>nombre</em>> est nul, alors la fonction supprime tous les éléments de la liste à partir de l’élément numéro <<em>départ</em>>.</p>
+<p>Si le numéro <<em>depart</em>> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier. Le dernier élément a l’index <span class="math"> - 1</span>, l’avant-dernier a l’index <span class="math"> - 2</span> <span class="math">⋯</span> etc. La fonction supprime les <<em>nombre</em>> éléments de la liste (ou toute la liste si <<em>nombre</em>> est nul) en allant vers la gauche.</p>
+<p>Le paramètre <<em>liste</em>> doit être <strong>un nom de variable</strong>, celle-ci est modifiée et la fonction renvoie <em>Nil</em>.</p></li>
+<li><p><u>Exemple(s)</u> : la commande <span style="color:red">[x:=[1,2,3,4], Del(x,2,2), x]</span> renvoie <span style="color:magenta">[1,4]</span>.</p>
+<p>La commande <span style="color:red">[x:=[1,2,3,4], Del(x,-2,2), x]</span> renvoie <span style="color:magenta">[1,4]</span>.</p></li>
+</ul>
+<p><strong>NB</strong>: pour des raisons de compatibilité avec l’ancienne version, l’index <span class="math">0</span> correspond aussi au dernier élément de la liste.</p>
+<h2 id="Delay">Delay</h3>
+<ul>
+<li><p><b>Delay( <nb millisecondes> )</b></p></li>
+<li><p><u>Description</u> : permet de suspendre l’exécution du programme pendant le laps de temps indiqué (en milli-secondes).</p></li>
+</ul>
+<h2 id="DelButton">DelButton</h3>
+<ul>
+<li><p><b>DelButton( <texte1>, ..., <texteN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les boutons portant les inscriptions <<em>texte1</em>>, ..., <<em>texteN</em>>. Si la liste est vide (<span style="font-style:italic"> DelButton()</span>), alors tous les boutons sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="DelGraph">DelGraph</h3>
+<ul>
+<li><p><b>DelGraph( <element1>, ..., <elementN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de supprimer les éléments graphiques appelés <<em>element1</em>>, ..., <<em>elementN</em>>. Si la liste est vide (<span style="font-style:italic"> DelGraph()</span>), alors tous les éléments sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="DelItem">DelItem</h3>
+<ul>
+<li><p><b>DelItem( <nom1>, ..., <nomN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options appelées <<em>nom1</em>>, ..., <<em>nomN</em>>. Si la liste est vide (<span style="font-style:italic"> DelItem()</span>), alors toute la liste est supprimée. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="DelMac">DelMac</h3>
+<ul>
+<li><p><b>DelMac( <mac1>, ..., <macN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de supprimer les macros (non prédéfinies) appelées <<em>mac1</em>>, ..., <<em>macN</em>>. Si la liste est vide (<span style="font-style:italic">DelMac()</span>), la commande est sans effet. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="DelText">DelText</h3>
+<ul>
+<li><p><b>DelText( <texte1>, ..., <texteN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les labels <<em>texte1</em>>, ..., <<em>texteN</em>>. Si la liste est vide (<span style="font-style:italic"> DelText()</span>), alors tous les labels sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="DelVar">DelVar</h3>
+<ul>
+<li><p><b>DelVar( <var1>, ..., <varN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de supprimer les variables globales (non prédéfinies) appelés <<em>var1</em>>, ..., <<em>varN</em>>. Si la liste est vide (<span style="font-style:italic">DelVar()</span>), la commande est sans effet. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Der">Der</h3>
+<ul>
+<li><p><b>Der( <expression>, <variable>, <liste> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction calcule la dérivée de <<em>expression</em>> par rapport à <<em>variable</em>> et l’évalue en donnant à <<em>variable</em>> les valeurs successives de la <<em>liste</em>>. La fonction <span style="font-style:italic">Der</span> renvoie la liste des résultats. Mais si on a besoin de <span style="font-style:italic">l’expression de la dérivée</span>, alors on préférera la fonction <a href="#Diff">Diff</a>.</p></li>
+<li><p><u>Exemple(s)</u> : </p>
+<ul>
+<li><p>la commande <span style="color:red">Der(1/x,x,[-1,0,2] )</span> renvoie <span style="color:magenta">[-1,-0.25]</span>.</p></li>
+<li><p>Voici le texte d’une macro appelée <span style="color:red">tangente</span> qui prend une expression <span class="math"><em>f</em>(<em>x</em>)</span> en premier paramètre, une valeur réelle <span class="math"><em>x</em>0</span> en second paramètre et qui trace la tangente à la courbe au point d’abscisse x0:</p>
+<p><div style="text-align:center">{[Assign(%1,x,%2), $A:=%2+i*%1, $Df:=Der(%1,x,%2), Droite(A, A+1+i*Df)]}</div></p>
+<p>On assigne la valeur <span class="math"><em>x</em>0</span> à la variable <span class="math"><em>x</em></span> dans l’expression <span class="math"><em>f</em>(<em>x</em>)</span>, on stocke dans une variable <span class="math"><em>A</em></span> le point de coordonnées <span class="math">(<em>x</em>0, <em>f</em>(<em>x</em>0))</span> (sous forme d’affixe), on stocke dans une variable <span class="math"><em>D</em><em>f</em></span> la dérivée en <span class="math"><em>x</em>0</span> (<span class="math"><em>f</em>ʹ(<em>x</em>0)</span>), puis on trace la droite passant par <span class="math"><em>A</em></span> et dirigée par le vecteur d’affixe <span class="math">1 + <em>i</em><em>f</em>ʹ(<em>x</em>0)</span>.</p></li>
+</ul></li>
+</ul>
+<h2 id="Diff">Diff</h3>
+<ul>
+<li><p><b>Diff( <nom>, <expression>, <variable> [, param1,..., paramN] )</b></p></li>
+<li><p><u>Description</u> : cette fonction permet de créer une macro appelée <<em>nom</em>>, s’il existait déjà une macro portant ce nom, elle sera écrasée, sauf si c’est une macro prédéfinie auquel cas la commande est sans effet. Le corps de la macro créée correspond à la dérivée de <<em>expression</em>> par rapport à <<em>variable</em>>. Les paramètres optionnels sont des noms de variables, le nom de la variable <<em>param1</em>> est remplacé dans l’expression de la dérivée par le paramètre %1, le nom <<em>param2</em>> est remplacé par %2 ... etc. Cette fonction renvoie <em>Nil</em>.</p></li>
+<li><p><u>Exemple(s)</u> : après l’exécution de la commande (dans la ligne de commande en bas de la fenêtre): <span style="color:red">Diff(df, sin(3*t), t)</span>, une macro appelée <span style="color:magenta">df</span> est créée et son contenu est: <span style="color:magenta">3*cos(3*t)</span>, c’est une macro sans paramètre qui contient une variable locale <span class="math"><em>t</em></span>, elle devra donc être utilisée en développement immédiat (c’est à dire précédée du symbole <span class="math"> ∖ </span>)<sup><a href="#fn2" class="footnoteRef" id="fnref2">2</a></sup>. Par contre après la commande <span style="color:red">Diff(df,sin(3*t),t,t)</span>, le contenu de la macro <span style="color:magenta">df</span> est: {3*cos(3*%1)} qui est une macro à un paramètre.</p></li>
+</ul>
+<h2 id="Echange">Echange</h3>
+<ul>
+<li><p><b>Echange( <variable1>, <variable2> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction échange les deux variables, ce sont en fait les adresses qui sont échangées. Les contenus ne sont pas dupliqués alors qu’ils le seraient si on utilisait la commande:</p>
+<p>{ <span style="color:red">[aux:=variable1, variable1:=variable2, variable2:=aux]</span>}</p>
+<p>La fonction <span style="font-style:italic">Echange</span> renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="EpsCoord">EpsCoord</h3>
+<ul>
+<li><p><b>EpsCoord( <affixe> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe exportée en eps. Pour les autres, il y a les macros <a href="#TeXCoord">TeXCoord</a> et <a href="#SvgCoord">SvgCoord</a>.</p></li>
+</ul>
+<h2 id="Eval">Eval</h3>
+<ul>
+<li><p><b>Eval( <expression> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue l’<<em>expression</em>> et renvoie le résultat. L’<<em>expression</em>> est interprétée comme une <a href="#chaine">chaîne de caractères</a>.</p></li>
+<li><p>La fonction <a href="#Input">Input</a> renvoie la saisie sous forme d’une chaîne dans la macro appelée <em>chaine()</em>. La fonction <span style="font-style:italic">Eval</span> évalue cette chaîne (comme n’importe quelle commande TeXgraph) et renvoie le résultat.</p></li>
+<li><p><u>Exemple(s)</u> : voici une commande demandant une valeur à l’utilisateur pour une variable <em>x</em>:</p></li>
+</ul>
+<pre><code> if Input("x=", "Entrez une valeur pour x", x )
+ then x:= Eval( chaine() )
+ fi
+</code></pre>
+<h2 id="Exec">Exec</h3>
+<ul>
+<li><p><b>Exec( <programme> [, argument(s), répertoire de travail, attendre] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’exécuter un <<em>programme</em>> (ou un script) en précisant éventuellement des <<em>arguments</em>> et un <<em>répertoire de travail</em>>, ces trois arguments sont interprétés comme des chaînes de caractères. Le dernier argument doit valoir 0 (par défaut) ou 1, il indique si le programme attend ou non la fin du processus fils. La fonction renvoie la valeur <em>Nil</em>. Un message d’erreur s’affiche lorsque: les ressources sont insuffisantes, ou bien le programme est invalide, ou bien le chemin est invalide.</p></li>
+<li><p>La macro-chaîne prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro <em>Apercu</em> exporte le graphique courant dans ce dossier au format pgf dans le fichier <em>file.pgf</em>, puis elle exécute <em>pdflatex</em> sur le fichier <em>apercu.tex</em>, puis attend la fin de l’exécution avant de lancer le lecteur de pdf.</p></li>
+<li><p><u>Exemple(s)</u> : la macro <span style="font-style:italic">Apercu</span> contenue dans interface.mac est:</p></li>
+</ul>
+<pre><code> [Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+</code></pre>
+<h2 id="Export">Export</h3>
+<ul>
+<li><p><b>Export( <mode>, <fichier> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’exporter le graphique en cours, <<em>mode</em>> est une valeur numérique qui peut être l’une des constantes suivantes: tex, pst, pgf, tkz, eps, psf, pdf, epsc, pdfc, svg, bmp, obj, geom, jvx ou teg. L’exportation se fait dans <<em>fichier</em>> qui contient donc le nom du fichier, avec éventuellement le chemin.</p>
+<p>La macro prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro <em>Apercu</em> exporte le graphique courant dans ce dossier au format pgf dans le fichier <em>file.pgf</em>, puis elle exécute <em>pdflatex</em> sur le fichier <em>apercu.tex</em>, puis attend la fin de l’exécution avant de lancer le lecteur de pdf.</p></li>
+<li><p><u>Exemple(s)</u> : la macro <span style="font-style:italic">Apercu</span> contenue dans interface.mac est:</p></li>
+</ul>
+<pre><code> [Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+</code></pre>
+<h2 id="ExportObject">ExportObject</h3>
+<ul>
+<li><p><b>ExportObject( <argument> )</b></p></li>
+<li><p><u>Description</u> : cette commande n’a d’effet que pendant un export. Elle permet d’exporter l’<<em>argument</em>> dans le fichier de sortie, cet <<em>argumet</em>> est soit le nom d’un élément graphique, soit une commande graphique (comme pour la fonction <a href="#Get">Get</a>). Elle peut-être utile pour écrire des exports personnalisés, ceci est décrit dans <a href="#MyExport">cette section</a>.</p></li>
+</ul>
+<h2 id="Fenetre">Fenetre</h3>
+<ul>
+<li><p><b>Fenetre( <A>, <B> [, C] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction modifie la fenêtre graphique, c’est l’équivalent de l’option <em>Paramètres/Fenêtre</em>, <strong>sauf que les éléments graphiques ne sont pas automatiquement recalculés</strong>. Le paramètre <<em>A</em>> et le paramètre <<em>B</em>> sont les affixes de deux coins de la fenêtre diamétralement opposés, et le paramètre facultatif <<em>C</em>> représente les deux échelles, plus précisément, la partie réelle de <<em>C</em>> est l’échelle [en cm] sur l’axe des abscisses et la partie imaginaire de <<em>C</em>> est l’échelle [en cm] sur l’axe des ordonnées, ces deux valeurs doivent être strictement positives. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Free">Free</h3>
+<ul>
+<li><p><b>Free( <expression>, <variable></b>.</p></li>
+<li><p><u>Description</u> : cette fonction renvoie <span class="math">1</span> si l’<<em>expression</em>> contient la <<em>variable</em>>, <span class="math">0</span> sinon. Lorsque le deuxième argument n’est pas un nom de variable, la fonction renvoie <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Get">Get</h3>
+<ul>
+<li><p><b>Get( <argument> [, clip(0/1)] )</b>.</p></li>
+<li><p><u>Description</u> : lorsque le paramètre <<em>argument</em>> est un <em>identificateur</em>, la fonction cherche s’il y a un élément graphique dont le nom est <<em>argument</em>>, si c’est le cas, alors la fonction renvoie la liste des points de cet élément graphique, sinon elle renvoie la valeur <em>Nil</em>. Dans ce cas l’argument optionnel est ignoré.</p>
+<p>Lorsque <<em>argument</em>> n’est pas un identificateur, celui-ci est considéré comme une <em>fonction graphique</em>, la fonction <span style="font-style:italic">Get</span> renvoie la liste des points de l’élément graphique construit par cette fonction graphique mais sans créer l’élément en question. L’argument optionnel <<em>clip</em>> (qui vaut <span class="math">1</span> par défaut) indique si l’élément doit être clippé par la fenêtre courante (valeur 1) ou non (valeur 0).</p>
+<p>Lorsque l’argument est vide: <span style="font-style:italic">Get()</span>, la fonction renvoie la liste des points de tous les éléments graphiques déjà construits, ceux qui sont cachés sont ignorés.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Get(Cercle(0,1))</span> renvoie la liste des points du cercle de centre 0 et de rayon 1 mais sans créer ce cercle, la liste des points est clippée par la fenêtre graphique.</p></li>
+<li><p><u>Exemple(s)</u> : utilisation des points d’un objet graphique:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Cmd view(0,6.25,-1.5,2); size(7.5); [tMin:=0, tMax:=6.25]; Graph axe = Axes(0,1+i); C1 = [Color:=blue,Width:=8, Cartesienne(1/x) ]; C2 = [Color:=red,Width:=8, Cartesienne(sin(2*x)*1.5)]; inter = [DotScale:=2,DotStyle:=dotcircle, Color:=forestgreen, Point(Get(C1) InterL Get(C2)), Color:=blue, LabelDot(5.5+0.1*i,"<span class="math"><em>C</em><sub>1</sub></span>","N"), Color:=red, LabelDot(3-i,"<span class="math"><em>C</em><sub>2</sub></span>","E"), ];</p>
+</blockquote>
+</blockquote>
+<h2 id="GetAttr">GetAttr</h3>
+<ul>
+<li><p><b>GetAttr( <argument> )</b></p></li>
+<li><p><u>Description</u> : lorsque le paramètre <<em>argument</em>> est un <em>identificateur</em>, la fonction cherche s’il y a un élément graphique dont le nom est <<em>argument</em>>, si c’est le cas, alors les attributs de cet élément graphique deviennent les attributs courants, et la fonction renvoie la valeur <em>Nil</em>. Sinon, l’argument est interprété comme une chaîne de caractères puis la fonction effectue la même recherche.</p></li>
+</ul>
+<h2 id="GetMatrix">GetMatrix</h3>
+<ul>
+<li><p><b>GetMatrix()</b></p></li>
+<li><p><u>Description</u> : cette fonction renvoie la matrice courante. (Voir aussi les commandes <a href="#ComposeMatrix">ComposeMatrix</a>, <a href="#SetMatrix">SetMatrix</a>, et <a href="#IdMatrix">IdMatrix</a>)</p></li>
+</ul>
+<h2 id="GetSpline">GetSpline</h3>
+<ul>
+<li><p><b>GetSpline(<V0>, <A0>,..., <An>, <Vn> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des points de contrôle correspondant à la spline cubique passant par les points <<em>A0</em>> jusqu’à <<em>An</em>>. <<em>V0</em>> et <<em>Vn</em>> désignent les vecteurs vitesses aux extrémités [contraintes], si l’un d’eux est nul alors l’extrémité correspondante est considérée comme libre (sans contrainte). Le résultat doit être dessiné avec la commande graphique <a href="#Bezier">Bezier</a>.</p></li>
+</ul>
+<h2 id="GrayScale">GrayScale</h3>
+<ul>
+<li><p><b>GrayScale(0/1)</b> ou <b>GrayScale()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’activer ou désactiver la conversion des couleurs en niveaux de gris. Elle équivaut à l’option <span style="font-style:italic">Paramètres/Gérer les couleurs</span> du menu de l’interface graphique.</p>
+<p>Lorsque l’argument est vide, la fonction renvoie l’état actuel de la conversion en niveaux de gris (0 ou 1). Sinon, elle renvoie <em>Nil</em>.</p></li>
+</ul>
+<h2 id="HexaColor">HexaColor</h3>
+<ul>
+<li><p><b>HexaColor( <valeur héxadécimale> )</b></p></li>
+<li><p><u>Description</u> : cette fonction renvoie la couleur correspondant à la <<em>valeur héxadécimale</em>>, cette valeur doit être passée sous forme d’une chaîne de caractères. Voir aussi la commande <a href="#Rgb">Rgb</a>.</p></li>
+<li><p><u>Exemple(s)</u> : <code>Color:=HexaColor("F5F5DC")</code>.</p></li>
+</ul>
+<h2 id="Hide">Hide</h3>
+<ul>
+<li><p><b>Hide( <element1>, ..., <elementN> )</b></p></li>
+<li><p><u>Description</u> : Cette fonction permet de cacher les éléments graphiques appelés <<em>element1</em>>, ..., <<em>elementN</em>> en mettant leur attribut <span style="font-style:italic">IsVisible</span> à false. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>.</p>
+<p>Pour tout cacher on invoque la commande sans arguments: <span style="font-style:italic">Hide()</span>.</p>
+<p>Pour tout cacher sauf un ou plusieurs éléments, on invoque la commande: <span style="font-style:italic">Hide(except, element1, ..., elementN)</span>. Voir aussi la commande <a href="#Show">Show</a>.</p></li>
+</ul>
+<h2 id="IdMatrix">IdMatrix</h3>
+<ul>
+<li><p><b>IdMatrix()</b></p></li>
+<li><p><u>Description</u> : change la matrice courante en la matrice identité. (Voir aussi les commandes <a href="#ComposeMatrix">ComposeMatrix</a>, <a href="#SetMatrix">SetMatrix</a>, et <a href="#GetMatrix">GetMatrix</a>)</p></li>
+</ul>
+<h2 id="Input">Input</h3>
+<ul>
+<li><p><b>Input( <message> [, titre, chaîne] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ouvre une boite de dialogue avec <<em>titre</em>> dans la barre de titre (par défaut le titre est vide), et dans laquelle le paramètre <<em>message</em>> est affiché, le paramètre <<em>chaîne</em>> est affiché dans la zone de saisie. Ces paramètres sont donc interprétés comme des <a href="#chaine">chaînes de caractères</a>, l’utilisateur est invité à faire une saisie. S’il valide alors la fonction <span style="font-style:italic">Input</span> renvoie la valeur <span class="math">1</span> et la chaîne saisie est <strong>mémorisée dans la macro</strong> <span style="font-style:italic">chaine()</span>. Si l’utilisateur ne valide pas ou si la chaîne saisie est vide, alors la fonction <span style="font-style:italic">Input</span> renvoie la valeur <span class="math">0</span>.</p></li>
+<li><p><u>Exemple(s)</u> : voir la fonction <a href="#Eval">Eval</a>.</p></li>
+</ul>
+<h2 id="InputMac">InputMac</h3>
+<ul>
+<li><p><b>InputMac( <nom de fichier> )</b> ou <b>Load( <nom de fichier> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet de charger en mémoire un fichier de macros (<em>*.mac</em>), ou un fichier modèle (<em>*.mod</em>), ou tout fichier source texgraph (<em>*.teg</em>).</p>
+<p>Dans le premier cas (fichier <em>*.mac</em>), les variables globales et les macros seront considérées comme <strong>prédéfinies</strong> (elles n’apparaissent pas à l’écran, elles ne seront pas enregistrées avec le graphique, mais elles sont effacées de la mémoire dès qu’on commence un nouveau graphique). Le paramètre <<em>nom de fichier</em>> est une chaîne de caractères représentant le fichier à charger avec éventuellement son chemin. Cette fonction renvoie <em>Nil</em>, et si ce fichier était déjà chargé, alors elle est sans effet. Si le fichier à charger est dans le répertoire <em>macros</em> de <em>TeXgraph</em>, ou dans le dossier <em>TeXgraphMac</em>, alors il est inutile de préciser le chemin.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">InputMac("MesMacros.mac")</span>.</p></li>
+</ul>
+<h2 id="Inc">Inc</h3>
+<ul>
+<li><p><b>Inc( <variable>, <expression> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue <<em>expression</em>> et ajoute le résultat à <<em>variable</em>>. Cette fonction est plus avantageuse que la commande <span style="color:red">variable := variable + expression</span>, car dans cette commande la <<em>variable</em>> est évaluée [c’est à dire dupliquée] pour calculer la somme. La fonction <span style="font-style:italic">Inc</span> renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Insert">Insert</h3>
+<ul>
+<li><p><b>Insert( <liste1>, <liste2> [, position] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction insère la <<em>liste2</em>> dans la <<em>liste1</em>> à la position numéro <<em>position</em>>. Lorsque la position vaut 0 [valeur par défaut]. La <<em>liste2</em>> est ajoutée à la fin. La <<em>liste1</em>> doit être une variable et celle-ci est modifiée. La fonction <span style="font-style:italic">Insert</span> renvoie la valeur <em>Nil</em>.</p></li>
+<li><p><u>Exemple(s)</u> : si une variable <span class="math"><em>L</em></span> contient la liste <span style="color:red">[1,4,5]</span>, alors après la commande <span style="color:red">Insert(L,[2,3],2)</span>, la variable <span class="math"><em>L</em></span> contiendra la liste <span style="color:magenta">[1,2,3,4,5]</span>.</p></li>
+</ul>
+<h2 id="Int">Int</h3>
+<ul>
+<li><p><b>Int( <expression>, <variable>, <borne inf.>, <borne sup.> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction calcule l’intégrale de <<em>expression</em>> par rapport à <<em>variable</em>> sur l’intervalle <strong>réel</strong> défini par <<em>borne inf.</em>> et <<em>borne sup</em>>. Le calcul est fait à partir de la méthode de {Simpson} accélérée deux fois avec la méthode de {Romberg}, <<em>expression</em>> est supposée définie et suffisamment régulière sur l’intervalle d’intégration.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Int(exp(sin(u)),u,0,1)</span> donne <span style="color:magenta">1.63187</span> (Maple donne 1.631869608).</p></li>
+</ul>
+<h2 id="IsMac">IsMac</h3>
+<ul>
+<li><p><b>IsMac( <nom> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet de savoir s’il y a une macro appellée <<em>nom</em>>. Elle renvoie <span class="math">1</span> si c’est le cas, <span class="math">0</span> sinon.</p></li>
+</ul>
+<h2 id="IsVar">IsVar</h3>
+<ul>
+<li><p><b>IsVar( <nom> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet de savoir s’il y a une variable globale appellée <<em>nom</em>>. Elle renvoie <span class="math">1</span> si c’est le cas, <span class="math">0</span> sinon.</p></li>
+</ul>
+<h2 id="Liste">Liste</h3>
+<ul>
+<li><p><b>Liste( <argument1>, ..., <argumentn> )</b> ou bien <strong>[<argument1>, ..., <argumentn>]</strong>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue chaque argument et renvoie la liste des résultats <strong>différents de <em>Nil</em></strong>.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Liste(1, Arg(1+2*i), sqrt(-1), Solve(cos(x)-x,x,0,1))</span> renvoie le résultat <span style="color:magenta">[1,1.107149,0.739085]</span>.</p></li>
+</ul>
+<h2 id="ListFiles">ListFiles</h3>
+<ul>
+<li><p><b>ListFiles()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction est disponible seulement dans la version GUI de TeXgraph, elle s’utilise dans la barre de commande en bas de la fenêtre, elle affiche alors la liste des fichiers de macros (<em>*.mac</em>) chargés en mémoire.</p></li>
+</ul>
+<h2 id="LoadImage">LoadImage</h3>
+<ul>
+<li><p><b>LoadImage( <image> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction charge le fichier <<em>image</em>>, qui doit être une image png, jpeg ou bmp. Celle-ci est affichée en image de fond et fait partie du graphique, en particulier elle est exportée dans les formats tex (visible seulement dans la version postscript), pgf, pst et teg. Pour le format pgf c’est la version png ou jpg qui sera dans le document, mais pour les versions pst et tex il faut une version eps de l’image. L’argument est interprêté comme une chaîne de caractères, et la fonction renvoie la valeur <em>Nil</em>.</p>
+<p>Lors du chargement, la taille de l’image est adaptée à la fenêtre, mais celle-ci peut être modifiée de manière à conserver les proportions de l’image. Dès lors la position de l’image et sa taille sont fixées. On peut ensuite élargir la fenêtre si on ne veut pas que l’image occupe tout l’espace. Pour modifier la position ou la taille de l’image, il faut recharger celle-ci.</p></li>
+</ul>
+<h2 id="Loop">Loop</h3>
+<ul>
+<li><p><b>Loop( <expression>, <condition> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction est une <strong>boucle</strong> qui construit une liste en évaluant <<em>expression</em>> et <<em>condition</em>> jusqu’à ce que le résultat de <<em>condition</em>> soit égal à 1 (pour <em>True</em>) ou <em>Nil</em>, la fonction <span style="font-style:italic">Loop</span> renvoie alors la liste des résultats de <<em>expression</em>>. Cette commande est la représentation interne de la boucle <a href="#repeat">repeat</a> dont l’utilisation est préférable pour des raisons de lisibilité.</p></li>
+<li><p><u>Exemple(s)</u> : les commandes (équivalentes):</p>
+<p><div style="text-align:center"><span style="color:red">[n:=1, m:=1, n, Loop([ aux:=n, n:=m, m:=aux+n, n], m>100)]</span></div></p>
+<p>ou encore</p>
+<p><div style="text-align:center"><span style="color:red">[n:=1, m:=1, n, while m<=100 do aux:=n, n:=m, m:=aux+n, n od]</span></div></p>
+<p>ou encore</p>
+<p><div style="text-align:center"><span style="color:red">[n:=1, m:=1, n, repeat aux:=n, n:=m, m:=aux+n, n until m>100 od]</span></div></p>
+<p>renvoient la liste: <span style="color:magenta">[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]</span> (termes d’une suite de {Fibonacci} inférieurs à 100).</p></li>
+</ul>
+<h2 id="Map">Map</h3>
+<ul>
+<li><p><b>Map( <expression>, <variable>, <liste> [, mode] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction est une <strong>boucle</strong> qui construit une liste de la manière suivante: <<em>variable</em>> parcourt les éléments de <<em>liste</em>> et pour chacun d’eux <<em>expression</em>> est évaluée, la fonction <span style="font-style:italic">Map</span> renvoie la liste des résultats. Cette commande est la représentation interne de la boucle <a href="#for">for</a> dont l’utilisation est préférable pour des raisons de lisibilité.</p>
+<p>Le paramètre optionnel <<em>mode</em>> est un complexe qui vaut <em>Nil</em> par défaut, lorsque <<em>mode</em>><span class="math"> = <em>a</em> + <em>i</em><em>b</em></span>, alors:</p>
+<ul>
+<li><p>si <span class="math"><em>a</em></span> est un entier et <span class="math"><em>b</em> = 0</span>: les éléments de la <<em>liste</em>> sont traités de <span class="math"><em>a</em></span> en <span class="math"><em>a</em></span>,</p></li>
+<li><p>si <span class="math"><em>a</em></span> est un entier et <span class="math"><em>b</em> = 1</span>: la <<em>liste</em>> est traitée par composante (deux composantes sont séparées par la constante <em>jump</em>) et les éléments de chaque composante sont traités par paquets complets de <span class="math"><em>a</em></span> éléments, lorsque la constante <em>jump</em> est rencontrée dans la liste, celle-ci est renvoyée dans le résultat. Un paquet non complet n’est pas traité.</p></li>
+<li><p>si <span class="math"><em>a</em></span> est un entier et <span class="math"><em>b</em> =  - 1</span>: la <<em>liste</em>> est traitée par composante (deux composantes sont séparées par la constante <em>jump</em>) et les éléments de chaque composante sont traités par paquets complets de <span class="math"><em>a</em></span> éléments, lorsque la constante <em>jump</em> est rencontrée dans la liste, celle-ci n’est pas renvoyée dans le résultat. Un paquet non complet n’est pas traité.</p></li>
+<li><p>si <span class="math"><em>a</em> = </span>Re(jump): la <<em>liste</em>> est traitée par composante (deux composantes sont séparées par la constante <em>jump</em>), lorsque la constante <em>jump</em> est rencontrée dans la liste, celle-ci est renvoyée dans le résultat si <span class="math"><em>b</em> = 1</span> et n’est pas renvoyée si <span class="math"><em>b</em> =  - 1</span>.</p></li>
+<li><p><u>Exemple(s)</u> : voir la boucle <a href="#for">for</a> pour des exemples.</p></li>
+</ul></li>
+<li><p><u>Exemple(s)</u> : si <span class="math"><em>L</em></span> est une variable contenant une liste de points, alors la commande:</p>
+<ul>
+<li><p><span style="color:red">[sum:=0, Map( Inc(sum,z), z, L), sum]</span> renvoie la somme des éléments de <span class="math"><em>L</em></span>.</p></li>
+<li><p>la commande <span style="color:red">Map(z*exp(i*<span class="math">π</span>/3), z, L)</span> renvoie la liste des images des points de <span class="math"><em>L</em></span> par la rotation de centre O d’angle <span class="math">π</span>/3.</p></li>
+</ul></li>
+</ul>
+<h2 id="Marges">Marges</h3>
+<ul>
+<li><p><b>Marges( <gauche>, <droite>, <haut>, <bas> )</b></p></li>
+<li><p><u>Description</u> : cette fonction permet de fixer les marges autour du dessin (en cm). Les nouvelles valeurs sont copiées dans les constantes <span style="font-style:italic;color:red">margeG</span>, <span style="font-style:italic;color:red">margeD</span>, <span style="font-style:italic;color:red">margeH</span> et <span style="font-style:italic;color:red">margeB</span>.</p></li>
+</ul>
+<h2 id="Merge">Merge</h3>
+<ul>
+<li><p><b>Merge( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet de recoller des morceaux de listes pour avoir des composantes de longeur maximale, elle renvoie la liste qui en résulte.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Merge([1, 2, jump, 3, 5, jump, 3, 4, 2] )</span> renvoie <span style="color:magenta">[1, 2, 3, 4, 5]</span>. Et <span style="color:red">Merge( [1, 2, jump, 3, 5, jump, 3, 4] )</span> renvoie <span style="color:magenta">[1, 2, jump, 4, 3, 5]</span>.</p>
+<p>Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine.</p></li>
+</ul>
+<h2 id="Message">Message</h3>
+<ul>
+<li><p><b>Message( <chaîne> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction affiche le paramètre <<em>chaîne</em>>[qui est donc interprété comme une <a href="#chaine">chaîne de caractères</a>] dans une fenêtre. Quand l’utilisateur a cliqué sur <em>OK</em>, la fenêtre se referme et la fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Move">Move</h3>
+<ul>
+<li><p><b>Move( <element1>, ..., <elementN> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ne s’applique qu’aux éléments graphiques créés en mode NotXor, ce qui correspond à la valeur 1 de la variable <a href="#PenMode">PenMode</a>. Elle redessine les éléments graphiques <<em>element1</em>>, ..., <<em>elementN</em>>, puis les recalcule, puis les redessine, et elle renvoie la valeur <em>Nil</em>.</p>
+<p>Lorsqu’on redessine un élément graphique créé en mode NotXor, il s’efface en restituant le fond, on peut alors modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres (ce qui évite d’avoir une image qui saute).</p></li>
+<li><p><u>Exemple(s)</u> : voir la fonction <a href="#Stroke">Stroke</a>.</p></li>
+</ul>
+<h2 id="Mtransform">Mtransform</h3>
+<ul>
+<li><p><b>Mtransform( <liste>, <matrice> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction applique la <<em>matrice</em>> à la <<em>liste</em>> et renvoie le résultat. Si la <<em>liste</em>> contient la constante <em>jump</em>, celle-ci est renvoyée dans le résultat sans être modifiée. La <<em>matrice</em>> représente l’expression analytique d’une application affine du plan, c’est une liste de trois complexes <span class="math">[<em>z</em>1, <em>z</em>2, <em>z</em>3]</span>: <span class="math"><em>z</em>1</span> est l’affixe du vecteur de translation, <span class="math"><em>z</em>2</span> est l’affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et <span class="math"><em>z</em>3</span> est l’affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l’identité s’écrit ainsi: [0,1,i] (c’est la matrice par défaut).</p></li>
+</ul>
+<h2 id="MyExport">MyExport</h3>
+<ul>
+<li><p><b>MyExport( <"nom">, <paramètre 1>, ..., <paramètre n> )</b> ou <b>draw( <"nom">, <paramètre 1>, ..., <paramètre n> )</b></p></li>
+<li><p><u>Description</u> : cette commande permet d’ajouter de nouveaux éléments graphiques avec un export personnalisé. Elle est décrite dans <a href="#MyExport">cette section</a>.</p></li>
+</ul>
+<h2 id="Nargs">Nargs</h3>
+<ul>
+<li><p><b>Nargs()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction n’a d’effet que dans une macro, elle renvoie le nombre d’arguments avec lesquels la macro a été appelée. Hors de ce contexte, elle renvoie la valeur <em>Nil</em>. Voir aussi la fonction <a href="#Args">Args</a>.</p></li>
+<li><p><u>Exemple(s)</u> : voici le corps d’une macro <em>MyLabel(affixe1, texte1, affixe2, texte2, ...)</em> prenant un nombre indéterminé d’arguments:</p></li>
+</ul>
+<pre><code> for $k from 1 to Nargs()/2 do
+ Label(Args(2*k-1), Args(2*k))
+ od
+</code></pre>
+<h2 id="NewButton">NewButton</h3>
+<ul>
+<li><p><b>NewButton( <Id>, <nom>, <affixe>, <taille>, <commande> [, aide] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction crée dans la zone grisée à gauche dans la fenêtre un bouton dont le numéro d’identification est <strong>l’entier</strong> <<em>Id</em>>, le texte figurant sur le bouton est le paramètre <<em>nom</em>> qui est donc interprété comme une <a href="#chaine">chaîne de caractères</a>, la position du coin supérieur gauche est donnée par le paramètre <<em>affixe</em>> qui doit être de la forme X+i*Y avec X et Y <strong>entiers</strong> car ce sont des coordonnées en <strong>pixels</strong>, la taille du bouton est donnée par le paramètre <<em>taille</em>> qui doit être de la forme <em>long+i*haut</em> où <em>long</em> désigne la longueur du bouton en pixels et <em>haut</em> la hauteur (ce sont donc des entiers), le paramètre <<em>commande</em>> est interprété comme une chaîne de caractères, c’est la commande associée au bouton, chaque clic provoquera l’exécution de cette commande. Le dernier paramètre <<em>aide</em>> est facultatif, il contient le message de la bulle d’aide s’affichant lorsque la souris passe au-dessus du bouton.</p>
+<p>Si on crée un bouton dont le numéro d’identification est déjà pris, alors l’ancien bouton est détruit <strong>sauf si c’est un bouton prédéfini</strong> (c’est à dire créé au démarrage). À chaque changement de fichier, les boutons non prédéfinis sont détruits. La fonction <strong>NewButton</strong> renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="NewGraph">NewGraph</h3>
+<ul>
+<li><p><b>NewGraph( <chaîne1>, <chaîne2> [, code] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction crée un élément graphique <span style="font-style:italic">Utilisateur</span> ayant pour nom: <<em>chaîne1</em>> et défini par la commande: <<em>chaîne2</em>>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>. S’il existait déjà un élément graphique portant le même nom, alors celui-ci est écrasé. L’élément graphique est créé mais non dessiné, c’est la fonction <span style="font-style:italic">ReDraw()</span> qui permet de mettre l’affichage à jour.</p>
+<p>Le troisième paramètre <<em>code</em>> est un entier positif (optionnel), un clic gauche avec la souris sur l’élément graphique créé dans la liste des éléments graphiques, provoquera l’exécution de la macro spéciale <span style="font-style:italic">ClicGraph( <code> )</span>, cette macro n’existe pas par défaut et peut-être créée par l’utilisateur, elle est utilisée en particulier dans le fichier modèle <em>Mouse.mod</em> (dessin à la souris).</p></li>
+<li><p>Supposons que l’utilisateur clique sur le point d’affixe 1+i, alors une fenêtre de dialogue s’ouvre avec le message <span style="font-style:italic">Label=</span> et une ligne de saisie à remplir. Supposons que l’utilisateur entre la chaîne <span style="font-style:italic">Test</span> et valide, alors la macro va créer un élément graphique <span style="font-style:italic">utilisateur</span> portant le nom <span style="font-style:italic">Label1</span> et défini par la commande <span style="color:red">Label(1+i,"Test")</span>.</p></li>
+<li><p>On peut aussi utiliser la macro prédéfinie <span style="font-style:italic">NewLabel</span> et définir la macro <span style="font-style:italic">ClicG()</span> en écrivant simplement: {NewLabel(%1) }.</p></li>
+<li><p><u>Exemple(s)</u> : voici une macro <span style="font-style:italic">ClicG()</span> permettant la création "à la volée" de labels, on a créé auparavant une variable globale <span style="font-style:italic">num</span> initialisée à 1:</p></li>
+</ul>
+<pre><code> if Input("Label=")
+ then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ),
+ ReDraw(), Inc(num,1)
+ fi
+</code></pre>
+<h2 id="NewItem">NewItem</h3>
+<ul>
+<li><p><b>NewItem( <nom>, <commande> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ajoute dans la liste déroulante de la zone grisée à gauche dans la fenêtre, un item appelé <<em>nom</em>>, le deuxième paramètre <<em>commande</em>> est la commande associée à l’item, chaque sélection de l’item provoquera l’exécution de cette commande. Les deux arguments sont interprétés comme des chaînes de caractères. S’il existe déjà un item portant le même nom, alors l’ancien est détruit <strong>sauf si c’est un item prédéfini</strong> (c’est à dire créé au démarrage). À chaque changement de fichier, les items non prédéfinis sont détruits. La fonction <span style="font-style:italic">NewItem</span> renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="NewMac">NewMac</h3>
+<ul>
+<li><p><b>NewMac( <nom>, <corps> [, param1, <span class="math">…</span>, paramN])</b>.</p></li>
+<li><p><u>Description</u> : cette fonction crée une macro appelée <<em>nom</em>> et dont le contenu est <<em>corps</em>>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Les paramètres optionnels sont des noms de variables, le nom de la variable <<em>param1</em>> est remplacé dans l’expression de la macro par le paramètre %1, le nom <<em>param2</em>> est remplacé par %2 <span class="math">…</span> etc. Cette fonction renvoie la valeur <em>Nil</em>. S’il existait déjà une macro portant le même nom, alors celui-ci est écrasée <strong>si elle n’est pas prédéfinie</strong>. Si le nom n’est pas valide, ou s’il y a déjà une macro prédéfinie portant ce nom, ou si l’expression <<em>corps</em>> n’est pas correcte, alors la fonction est sans effet.</p></li>
+</ul>
+<h2 id="NewVar">NewVar</h3>
+<ul>
+<li><p><b>NewVar( <nom>, <expression> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction crée une variable globale appelée <<em>nom</em>> et dont la valeur est <<em>expression</em>>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>. S’il existait déjà une variable portant le même nom, alors celle-ci est écrasée. Si le nom n’est pas valide, ou s’il y a déjà une constante portant ce nom, alors la fonction est sans effet. Si <<em>expression</em>> n’est pas correcte, alors la valeur affectée à la variable sera <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Nops">Nops</h3>
+<ul>
+<li><p><b>Nops( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue <<em>liste</em>> et renvoie le nombre de complexes qui la composent.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Nops([1,2,3] )</span> renvoie la valeur <span style="color:magenta">3</span>.</p></li>
+</ul>
+<h2 id="NotXor">NotXor</h3>
+<ul>
+<li><p><b>NotXor( <element1>, ..., <elementN> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ne s’applique qu’aux éléments graphiques créés en mode normal, ce qui correspond à la valeur 0 de la variable <a href="#PenMode">PenMode</a>. Elle change le mode des éléments graphiques <<em>element1</em>>, ..., <<em>elementN</em>> en mode NotXor puis les recalcule, et elle renvoie la valeur <em>Nil</em>.</p>
+<p>Lorsqu’on redessine un élément graphique qui est en mode NotXor, il s’efface en restituant le fond, on peut alors modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres (ce qui évite d’avoir une image qui saute).</p></li>
+<li><p><u>Exemple(s)</u> : voir la fonction <a href="#Move">Move</a>.</p></li>
+</ul>
+<h2 id="OpenFile">OpenFile</h3>
+<ul>
+<li><p><b>OpenFile( <nom fichier> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’ouvrir un fichier texte en écriture. ATTENTION: s’il existe un fichier du même nom, alors celui-ci sera écrasé.</p>
+<p>En combinaison avec les commandes <a href="#WriteFile">WriteFile</a> et <a href="#CloseFile">CloseFile</a>, cela permet à l’utilisateur de créer ses propres fichiers textes.</p></li>
+</ul>
+<h2 id="OriginalCoord">OriginalCoord</h3>
+<ul>
+<li><p><strong>OriginalCoord( <0/1> )</strong> ou <b>OriginalCoord()</b></p></li>
+<li><p><u>Description</u> : cette fonction détermine si le repère à l’exportation en <em>pstricks</em> et <em>tikz/pgf</em> est identique à celui de l’écran (ce qui correspond à la valeur 1 de l’argument, valeur par défaut), ou non. Lorsque la valeur de l’argument est nulle, le repère à l’exportation (<em>pstricks</em> et <em>tikz/pgf</em>) aura son origine en bas à gauche et l’unité sera le cm sur les deux axes. Cela est utile lorsqu’on travaille dans des répères où certaines valeurs numériques ne sont plus acceptées par .</p>
+<p>Lorsque l’argument vaut 1, les coordonnées des points dans le fichier exporté sont les mêmes qu’à l’écran.</p>
+<p>Lorsque l’argument vaut 0, les coordonnées dans le fichier exporté (tex, pst, tikz/pgf) du point d’affixe z à l’écran, sont x=Re(TexCoord(z)) et y=Im(TeXCoord(z)) (et EpsCoord à la place de TeXCoord pour l’export eps).</p>
+<p>Lorsque l’argument est vide, la fonction renvoie l’état actuel du repère à l’exportation (0 ou 1). Sinon, elle renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="PermuteWith">PermuteWith</h3>
+<ul>
+<li><p><b>PermuteWith( <liste d’index>, <liste à permuter>, [, taille des paquets ou jump] )</b></p></li>
+<li><p><u>Description</u> : la <<em>liste à permuter</em>> doit être une variable, celle-ci sera permutée selon le <<em>liste d’index</em>> qui est une liste d’entiers strictement positifs. La <<em>liste à permuter</em>> est traitée par composante si elle contient la constante <em>jump</em>, et les éléments de chaque composante sont traités par paquets (de <span class="math">1</span> par défaut) ou par composante entière (une composante se termine par <em>jump</em>), la liste est donc modifiée.</p></li>
+<li><p><u>Exemple(s)</u> : :</p>
+<ul>
+<li><p><span style="color:red">[L:=[-1,0,3,5], PermuteWith([4,3,2,1], L), L]</span> renvoie <span style="color:magenta">[5,3,0,-1]</span>.</p></li>
+<li><p><span style="color:red">[L:=[-1,0,3,5], PermuteWith([4,3,4,1], L), L]</span> renvoie <span style="color:magenta">[5,3,5,-1]</span>.</p></li>
+<li><p><span style="color:red">[L:=[-1,0,3,5,6,7,8], PermuteWith([4,3,2,1], L, 2), L]</span> renvoie <span style="color:magenta">[6,7,3,5,-1,0]</span>.</p></li>
+<li><p><span style="color:red">[L:=[-1,jump,0,3,jump,5,6,7,jump,8,jump], PermuteWith( [4,3,3,1,2], L, jump), L]</span> renvoie <span style="color:magenta">[8,jump,5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]</span>.</p></li>
+<li><p><span style="color:red">[L:=[-1,jump,0,3,jump,5,6,7,jump,8], PermuteWith([4,3,3,1,2], L, jump), L]</span> renvoie <span style="color:magenta">[5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]</span>.</p></li>
+<li><p><span style="color:red">[L:=[-1,1,5,jump,0,3,jump,5,6,7,jump,8,9], PermuteWith( [2,1], L), L]</span> renvoie <span style="color:magenta">[1,-1,jump,3,0,jump,6,5,jump,9,8]</span>.</p></li>
+</ul></li>
+</ul>
+<h2 id="ReadData">ReadData</h3>
+<ul>
+<li><p><b>ReadData( <fichier> [, type de lecture, séparateur] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ouvre un <<em>fichier</em>> texte en lecture, celui-ci est supposé contenir une ou plusieurs listes de valeurs numériques. Le premier argument est interprété comme une <a href="#chaine">chaîne de caractères</a> qui contient le nom du fichier (plus éventuellement son chemin). L’argument (optionnel) suivant <<em>type de lecture</em>> est une valeur numérique qui peut valoir:</p>
+<ul>
+<li><p><<em>type de lecture</em>>=1: la fonction lit le fichier réel par réel et renvoie la liste ou les listes lues: <code>[x1, x2, ...]</code>,</p></li>
+<li><p><<em>type de lecture</em>>=2: La fonction lit le fichier complexe par complexe, c’est à dire <strong>par paquets de deux réels</strong> et renvoie la ou les listes lues sous forme d’affixes: <code>[x1+i*x2, x3+i*x4, ...]</code>. C’est la valeur par défaut,</p></li>
+<li><p><<em>type de lecture</em>>=3: La fonction lit le fichier par paquet de 3 réels (points de l’espace ou point3D) et renvoie la ou les listes lues sous la forme: <code>[x1+i*x2, x3, x4+i*x5, x6, ...]</code>.</p></li>
+</ul>
+<p>Le troisième argument <<em>séparateur</em>>, est interprété comme une chaîne, il est supposé contenir le caractère servant à indiquer la fin de liste, entre deux listes la constante <em>jump</em> sera insérée, cet argument est facultatif et par défaut il n’y a pas de séparateur (ce qui fait donc une seule liste). Lorsque le séparateur est la fin de ligne dans le fichier, on utilisera la chaîne <span style="color:red">"LF"</span> (<em>line feed</em>) en troisième paramètre. Lorsqu’il y a un séparateur et lorsque la lecture se fait par paquet de 2 ou 3 réels, un paquet non øg complet est ignoré.</p></li>
+<li><p><u>Exemple(s)</u> : supposons qu’un fichier texte <em>test.dat</em> contienne exactement ceci:</p>
+<pre><code>1 2 3 4 5/ 6
+7 8 9 10 11/ 12
+13 14 15 16 17/ 18
+</code></pre>
+<p>alors l’exécution de:</p>
+<ul>
+<li><p><span style="color:red">ReadData("test.dat")</span> donne: <span style="color:magenta">[1+2*i,3+4*i,5+6*i,7+8*i,9+10*i,11+12*i,13+14*i,15+16*i,17+18*i]</span>,</p></li>
+<li><p><span style="color:red">ReadData("test.dat",1,"/")</span> donne: <span style="color:magenta">[1,2,3,4,5,jump,6,7,8,9,10,11,jump,12,13,14,15,16,17,jump,18]</span>,</p></li>
+<li><p><span style="color:red">ReadData("test.dat",2,"/")</span> donne: <span style="color:magenta">[1+2*i,3+4*i,jump,6+7*i,8+9*i,10+11*i,jump,12+13*i,14+15*i,16+17*i,jump]</span>,</p></li>
+<li><p><span style="color:red">ReadData("test.dat",3,"/")</span> donne: <span style="color:magenta">[1+2*i,3,jump,6+7*i,8,9+10*i,11,jump,12+13*i,14,15+16*i,17,jump]</span>,</p></li>
+<li><p><span style="color:red">ReadData("test.dat",3,"LF")</span> donne: <span style="color:magenta">[1+2*i,3,4+5*i,6,jump,7+8*i,9,10+11*i,12,jump,13+14*i,15,16+17*i,18,jump]</span>.</p></li>
+</ul></li>
+</ul>
+<h2 id="ReadFlatPs">ReadFlatPs</h3>
+<ul>
+<li><p><b>ReadFlatPs( <fichier> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction ouvre un <<em>fichier</em>> en lecture, celui-ci est censé être un fichier écrit en <em>flattened postscript</em>. La fonction renvoie la liste des chemins contenus dans le fichier, le premier complexe de la liste est <em>largeur+i*hauteur</em> en cm, puis le premier complexe de chaque chemin est <em>Color+i*Width</em>. Chaque chemin se termine par un <em>jump</em> dont la partie imaginaire est un enter négatif: <span class="math"> - 1</span> pour eofill, <span class="math"> - 2</span> pour fill, <span class="math"> - 3</span> pour stroke et <span class="math"> - 4</span> pour clip.</p>
+<p>Il est possible de transformer un fichier pdf ou un fichier postscript en <em>flattened postscript</em> grâce à l’utilitaire <em>pstoedit</em> (<a href="http://www.pstoedit.net/"><code class="url">http://www.pstoedit.net/</code></a>). La macro <a href="#conv2FlatPs">conv2FlatPs</a> permet cette conversion en supposant que l’utilitaire est installé sur votre système.</p>
+<p>La fonction <span style="font-style:italic">ReadFlatPs</span> est surtout utilisée en interne par la macro <a href="#loadFlatPs">loadFlatPs</a> qui en plus du chargement, adpate les coordonnées des points avant de renvoyer à son tour la liste des chemins que l’on peut alors dessiner avec la macro <a href="#drawFlatPs">drawFlatPs</a>.</p>
+<p>Ce système est utilisé par la macro <a href="#NewTeXlabel">NewTeXLabel</a> pour récupérer les formules TeX compilées.</p></li>
+</ul>
+<h2 id="ReCalc">ReCalc</h3>
+<ul>
+<li><p><strong>ReCalc( <nom1>, ..., <nomN> )</strong> ou <b>ReCalc()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction force le recalcul des éléments graphiques dont les noms sont dans la liste même si ceux-ci ne sont pas en mode <span style="font-style:italic">Recalcul Automatique</span>. Si la liste est vide (<span style="font-style:italic">ReCalc()</span>) alors tout le graphique est recalculé. Après le recalcul l’affichage est mis à jour et la fonction renvoie <em>Nil</em>.</p></li>
+</ul>
+<p><strong>Attention</strong>: l’utilisation de <span style="font-style:italic">ReCalc()</span> dans un élément graphique entraîne une récursion infinie et donc un plantage du programme!</p>
+<h2 id="ReDraw">ReDraw</h3>
+<ul>
+<li><p><strong>ReDraw( <nom1>, ..., <nomN> )</strong> ou <b>ReDraw()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction (re)dessine les éléments graphiques dont les noms sont dans la liste. Si la liste est vide (<span style="font-style:italic">ReDraw()</span>) alors tous les élments sont redessinés. Cette fonction renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="RenCommand">RenCommand</h3>
+<ul>
+<li><p><b>RenCommand( <nom>, <nouveau> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction renomme la commande appelée <<em>nom</em>>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>. Si le <<em>nom</em>> n’est pas valide, ou s’il n’y a pas de commande portant ce <<em>nom</em>>, ou s’il a déjà une commande portant le nom <<em>nouveau</em>>, alors la fonction est sans effet.</p></li>
+</ul>
+<h2 id="RenMac">RenMac</h3>
+<ul>
+<li><p><b>RenMac( <nom>, <nouveau> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction renomme la macro appelée <<em>nom</em>>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>. Si le <<em>nom</em>> n’est pas valide, ou s’il n’y a pas de macro portant ce <<em>nom</em>>, ou s’il a déjà une macro portant le nom <<em>nouveau</em>>, alors la fonction est sans effet.</p></li>
+</ul>
+<h2 id="RestoreAttr">RestoreAttr</h3>
+<ul>
+<li><p><b>RestoreAttr()</b>.</p></li>
+<li><p><u>Description</u> : restaure l’ensemble des attributs sauvegardés dans une pile par la commande <a href="#SaveAttr">SaveAttr</a>.</p></li>
+</ul>
+<h2 id="Reverse">Reverse</h3>
+<ul>
+<li><p><b>Reverse( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la <<em>liste</em>> inversée.</p></li>
+</ul>
+<h2 id="Rgb">Rgb</h3>
+<ul>
+<li><p><b>Rgb( <rouge>, <vert>, <bleu> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction renvoie un entier représentant la couleur dont les trois composantes sont <<em>rouge</em>>, <<em>vert</em>> et <<em>bleu</em>>, ces trois valeurs doivent être des nombres <strong>compris entre 0 et 1</strong>. Voir aussi la commande <a href="#HexaColor">HexaColor</a>.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Color:= Rgb(0.5,0.5,0.5))</span> sélectionne le gris.</p></li>
+</ul>
+<h2 id="SaveAttr">SaveAttr</h3>
+<ul>
+<li><p><b>SaveAttr()</b>.</p></li>
+<li><p><u>Description</u> : sauvegarde sur une pile l’ensemble des attributs courants. Voir aussi <a href="#RestoreAttr">RestoreAttr</a>.</p></li>
+</ul>
+<h2 id="Seq">Seq</h3>
+<ul>
+<li><p><b>Seq( <expression>, <variable>, <départ>, <fin> [, pas] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction est une <strong>boucle</strong> qui construit une liste de la manière suivante: <<em>variable</em>> est initialisée à <<em>départ</em>> puis, tant que <<em>variable</em>> est dans l’intervalle (fermé) défini par <<em>départ</em>> et <<em>fin</em>>, on évalue <<em>expression</em>> et on incrémente <<em>variable</em>> de la valeur de <<em>pas</em>>. Le pas peut être négatif mais il doit être non nul. Lorsqu’il n’est pas spécifié, sa valeur par défaut est 1. Lorsque <<em>variable</em>> sort de l’intervalle, la boucle s’arrête et la fonction <span style="font-style:italic">Seq</span> renvoie la liste des résultats. Cette commande est la représentation interne de la boucle <a href="#for">for</a> dont l’utilisation est préférable pour des raisons de lisibilité.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Seq(exp(i*k*pi/5,k,1,5)</span> renvoie la liste des racines cinquièmes de l’unité. La commande:</p>
+<p><div style="text-align:center"><span style="color:red">Ligne( Seq( exp(2*i*k*pi/5, k, 1, 5), 1)</span></div></p>
+<p>renverra la valeur <em>Nil</em> mais dessinera un pentagone (voir <a href="#Ligne">Ligne</a>) si elle est utilisée dans un élément graphique <em>utilisateur</em>.</p></li>
+</ul>
+<h2 id="Set">Set</h3>
+<ul>
+<li><p><b>Set( <variable>, <valeur> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’affecter à <<em>variable</em>><sup><a href="#fn3" class="footnoteRef" id="fnref3">3</a></sup> la <<em>valeur</em>> spécifiée. La fonction <span style="font-style:italic">Set</span> renvoie la valeur <em>Nil</em>.</p>
+<p>Cette commande est la représentation interne de l’affectation <span style="font-style:italic">:=</span>, dont l’utilisation est préférable pour des raisons de lisibilité.</p></li>
+</ul>
+<h2 id="SetAttr">SetAttr</h3>
+<ul>
+<li><p><b>SetAttr()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction n’a d’effet que dans un élément graphique Utilisateur. Elle permet d’affecter aux attributs de l’élément la valeur des attributs actuellement en cours. La fonction <span style="font-style:italic">SetAttr</span> renvoie la valeur <em>Nil</em>.</p></li>
+</ul>
+<h2 id="SetMatrix">SetMatrix</h3>
+<ul>
+<li><p><b>SetMatrix( <[z1, z2, z3]> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet de modifier la matrice courante (celle-ci affecte tous les éléments graphiques sauf les axes et les grilles dans la version actuelle). Cette matrice représente l’expression analytique d’une application affine du plan, c’est une liste de trois complexes: <span class="math"><em>z</em>1</span> qui est l’affixe du vecteur de translation, <span class="math"><em>z</em>2</span> qui est l’affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et <span class="math"><em>z</em>3</span> qui est l’affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l’identité s’écrit ainsi: [0,1,i] (c’est la matrice par défaut). (Voir aussi les commandes <a href="#GetMatrix">GetMatrix</a>, <a href="#ComposeMatrix">ComposeMatrix</a>, et <a href="#IdMatrix">IdMatrix</a>)</p></li>
+<li><p><u>Exemple(s)</u> : si <span class="math"><em>f</em>: <em>z</em> ↦ <em>f</em>(<em>z</em>)</span> est une application affine, alors sa matrice est <span class="math">[<em>f</em>(0), <em>f</em>(1) - <em>f</em>(0), <em>f</em>(<em>i</em>) - <em>f</em>(0)]</span>, ce calcul peut-être fait par la macro <em>matrix()</em> de TeXgraph.mac: <span style="color:red">SetMatrix(matrix(i*bar(z)))</span> affecte la matrice de la symétrie orthogonale par rapport à la première bissectrice.</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>view(-5,5,-3,3), size(7.5), SetMatrix([0,1,1+i]), axes(0,1+i), tMin:=-5, tMax:=5, Color:=red, Width:=8, Cartesienne(2*sin(x)), Color:=black, Arrows:=2, tangente(2*sin(x), pi/2, 1.5), Arrows:=0, LineStyle:=dotted, Ligne( [2*i,pi/2+2*i, pi/2], 0), Point(pi/2+2*i), LabelDot( pi/2, "<span class="math">$\frac{\pi}2$</span>","S",1), IdMatrix()</p>
+</blockquote>
+</blockquote>
+<h2 id="Show">Show</h3>
+<ul>
+<li><p><b>Show( <element1>, ..., <elementN> )</b>.</p></li>
+<li><p><u>Description</u> : Cette fonction permet de montrer les éléments graphiques appelés <<em>element1</em>>, ..., <<em>elementN</em>> en mettant leur attribut <span style="font-style:italic">IsVisible</span> à true. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur <em>Nil</em>. Pour tout montrer on invoque la commande sans arguments: <span style="font-style:italic">Show()</span>. Pour tout montrer sauf un ou plusieurs éléments, on invoque la commande: <span style="color:red">Show(except, element1, ..., elementN)</span>. Voir aussi la commande <a href="#Hide">Hide</a>.</p></li>
+</ul>
+<h2 id="Si">Si</h3>
+<ul>
+<li><p><b>Si( <condition1>, <expression1>, ..., <conditionN>, <expressionN> [, sinon] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue <<em>condition1</em>>. Une condition est une expression dont le résultat de l’évaluation doit être 0 [pour <em>False</em>] ou 1 [pour <em>True</em>], sinon il y a un échec et la fonction renvoie la valeur <em>Nil</em>. Si la condition donne la valeur 1 alors la fonction évalue <<em>expression1</em>> et renvoie le résultat, si elle vaut 0, elle évalue <<em>condition2</em>>, si celle-ci donne la valeur 1 alors la fonction évalue <<em>expression2</em>>, sinon etc... Lorsqu’aucune condition n’est remplie, la fonction évalue l’argument <<em>sinon</em>>, s’il est présent, et renvoie le résultat, sinon la fonction renvoie <em>Nil</em>. Cette commande est la représentation interne de l’alternative <a href="#if">if</a> dont la syntaxe est préférable pour des raisons de lisibilité.</p></li>
+<li><p><u>Exemple(s)</u> : définition d’une macro <span style="color:red">f(x)</span> représentant une fonction f d’une variable x définie en plusieurs morceaux:</p>
+<p><div style="text-align:center">{Si(%1<-1,1-exp(pi*(%1+1)),%1<0,sin(<span class="math">π</span>*%1),sh(pi*%1))},</div></p>
+<p>c’est à dire <span class="math"><em>f</em>(<em>x</em>) = 1 - <em>e</em><em>x</em><em>p</em>(π(<em>x</em> + 1))</span> si <span class="math"><em>x</em> <  - 1</span>, <span class="math"><em>f</em>(<em>x</em>) = <em>s</em><em>i</em><em>n</em>(π<em>x</em>)</span> si <span class="math"> - 1 ≤ <em>x</em> < 0</span>, <span class="math"><em>f</em>(<em>x</em>) = </span>sh<span class="math">(π<em>x</em>)</span> sinon.</p></li>
+</ul>
+<h2 id="Solve">Solve</h3>
+<ul>
+<li><p><b>Solve( <expression>, <variable>, <borne inf.>, <borne sup.> [, n] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction "résout" l’équation <<em>expression</em>>=0 par rapport à la variable <strong>réelle</strong> <<em>variable</em>> dans l’intervalle défini par <<em>borne inf.</em>> et <<em>borne sup.</em>>. Cet intervalle est subdivisé en <<em>n</em>> parties [par défaut n=25] et on utilise la méthode de { Newton} sur chaque partie. La fonction renvoie la liste des résultats.</p></li>
+<li><p><u>Exemple(s)</u> : </p>
+<ul>
+<li><p><span style="color:red">Solve(sin(x), x, -5, 5)</span> donne <span style="color:magenta">[-3.141593, 0, 3.141593]</span>.</p></li>
+<li><p>Équation: <span class="math">$\displaystyle \int_0^x \exp(t^2)dt=1$</span>: <span style="color:red">Solve(Int( exp(u^2),u,0,x)-1, x, 0, 1)</span> donne <span style="color:magenta">0.795172</span> et l’exécution de <span style="color:red">Int(exp(u^2), u, 0, 0.795172)</span> donne <span style="color:magenta">1</span>.</p></li>
+<li><p><span style="color:red">Solve( <span class="math"><em>x</em><sup>2</sup> + <em>x</em> + 1</span>, x, -1, 1)</span> renvoie <em>Nil</em>.</p></li>
+</ul></li>
+</ul>
+<h2 id="Sort">Sort</h3>
+<ul>
+<li><p><b>Sort( <liste de complexes> [, option] )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction trie la liste passée en argument dans l’ordre lexicographique, si l’argument <<em>option</em>> vaut 0 (valeur par défaut), ou dans l’ordre lexicographique inverse si l’argument <<em>option</em>> vaut 1. Cette liste doit être une variable, et celle-ci sera modifiée. Si la liste contient la constante <em>jump</em> alors celle-ci est recopiée telle quelle dans le résultat, et les øg composantes connexes de la liste sont triées indépendamment les unes des autres. La fonction renvoie la valeur <em>Nil</em>.</p></li>
+<li><p><u>Exemple(s)</u> : si la variable <span style="font-style:italic">L</span> contient la liste <span style="color:magenta">[-2,-3+i,1,1-2*i, jump, 3,5,-6]</span> alors après l’exécution de <span style="color:red">Sort(L)</span>, la variable contiendra la liste <span style="color:magenta">[-3+i,-2,1-2*i,1,jump,-6,3,5]</span>, et après l’exécution de <span style="color:red">Sort(L,1)</span>, la variable contiendra la liste <span style="color:magenta">[1,1-2*i,-2,-3+i,jump,5,3,-6]</span>. La méthode utilisée est le Quick Sort..</p></li>
+</ul>
+<h2 id="Special">Special</h3>
+<ul>
+<li><p><b>Special( <chaîne> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction n’aura d’effet que dans un élément graphique Utilisateur (comme les fonctions graphiques). L’argument doit être une chaîne de caractères (délimitée par " et "), si cette chaîne contient les balises <code>\[</code>, et <code>\]</code>, alors tout le texte contenu entre ces deux balises est interprété par TeXgraph et le résultat est replacé dans la chaîne. Puis cette chaîne sera écrite telle quelle dans le fichier d’exportation (c’est en fait un Label créé avec LabelStyle= special).</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">Special("\psdot(\[1+\],\[2^3\] )")</span>, écrira dans le fichier exporté: <span style="color:magenta">\psdot(2,8)</span>.</p></li>
+</ul>
+<h2 id="Str">Str</h3>
+<ul>
+<li><p><b>Str( <nom de macro> )</b>.</p></li>
+<li><p><u>Description</u> : lors d’une évaluation alphanumérique, cette fonction renvoie la définition de la macro appelée <<em>nom de macro</em>> (sauf si c’est une macro prédéfinie). En dehors de ce contexte, la fonction <span style="font-style:italic">Str</span> renvoie <em>Nil</em>. L’argument <<em>nom de macro</em>> est lui-même interprété comme une chaîne de caractères.</p></li>
+<li><p><u>Exemple(s)</u> : supposons que la macro <span style="color:red">f</span> soit définie par {%1+i*sin(%1)}, alors la commande {Label(0,["f(%1)=",Str("f")] )} affichera à l’écran à l’affixe 0, le texte: {f(%1)=%1+i*sin(%1)}.</p></li>
+</ul>
+<h2 id="StrArgs">StrArgs</h3>
+<ul>
+<li><p><b>StrArgs( <entier> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction n’a d’effet que dans une macro, elle renvoie l’argument numéro <<em>entier</em>> avec lequel la macro a été appelée, sous forme d’une chaîne. Hors de ce contexte, elle renvoie la valeur <em>Nil</em>. Voir également la commande <a href="#Args">Args</a></p></li>
+<li><p><u>Exemple(s)</u> : Voir la fonction <a href="#Nargs">Nargs</a>.</p></li>
+</ul>
+<h2 id="StrComp">StrComp</h3>
+<ul>
+<li><p><b>StrComp( <chaîne1>, <chaîne2> )</b>.</p></li>
+<li><p><u>Description</u> : les deux arguments sont interprétés comme une chaîne de caractères, et les deux chaînes sont comparées, si elles sont égales alors la fonction renvoie la valeur 1, sinon la valeur 0.</p></li>
+<li><p><u>Exemple(s)</u> : la combinaison de touches: Ctrl+Maj+<lettre> lance automatiquement l’exécution de la macro spéciale: <span style="font-style:italic"> OnKey( <lettre> )</span>. L’utilisateur peut définir cette macro avec par exemple la commande:</p>
+<p><div style="text-align:center">{if StrComp(%1, "A") then Message("Lettre A") fi}</div></p></li>
+</ul>
+<h2 id="String">String</h3>
+<ul>
+<li><p><b>String( <expression mathématique> )</b>.</p></li>
+<li><p><u>Description</u> : lors d’une évaluation alphanumérique, cette fonction renvoie <<em>expression mathématique</em>> sous forme d’une chaîne. En dehors de ce contexte, la fonction <span style="font-style:italic">String</span> renvoie <em>Nil</em>.</p></li>
+</ul>
+<h2 id="Stroke">Stroke</h3>
+<ul>
+<li><p><b>Stroke( <element1>, ..., <elementN> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction recalcule les éléments graphiques <<em>element1</em>>, ..., <<em>elementN</em>>, puis les redéssine en mode NORMAL, et renvoie la valeur <em>Nil</em>.</p></li>
+<li><p><u>Exemple(s)</u> : on a créé deux variables globales: <span class="math"><em>a</em></span> et <em>drawing</em>. On va créer le cercle de centre a et de rayon 1, appelé <span style="font-style:italic">objet1</span>, on souhaite pouvoir déplacer cet objet à la souris. Pour cela, on crée la macro <span style="font-style:italic">ClicG</span> avec la commande:</p></li>
+</ul>
+<pre><code> [PenMode:=1, {mode NotXor}
+ NewGraph("objet1", "Cercle(a,1)"),
+ PenMode:=0, {mode normal}
+ ReDraw(), {on montre}
+ drawing:=1]
+</code></pre>
+<p>on crée la macro <span style="color:magenta">MouseMove</span> avec la commande: <span style="color:red">if drawing then a:=</span>,</p>
+<p>puis la macro <span style="color:magenta">LButtonUp</span> avec la commande: <span style="color:red">if drawing then Stroke(objet1), drawing:=0 fi</span>.</p>
+<p>La macro <span style="font-style:italic">ClicG</span> crée l’objet1 en mode NotXor, rafraîchit l’affichage graphique et passe en mode "dessin". La macro <span style="font-style:italic"> MouseMove</span> permet de placer le centre à la position de la souris, puis de déplacer l’objet1. Lorsque le bouton gauche est relâché, on dessine l’objet1 en mode normal, puis on quitte le mode "dessin".</p>
+<h2 id="TeX2FlatPs">TeX2FlatPs</h3>
+<ul>
+<li><p><b>TeX2FlatPs( <"formule"> [, dollar(0/1)] )</b>.</p></li>
+<li><p><u>Description</u> : cette renvoie une <<em>formule</em>> {} sous forme d’une liste de chemins, le résultat doit être dessiné avec la macro <a href="#drawFlatPs">drawFlatPs</a>. La <<em>formule</em>> est écrite dans un fichier appelé <em>formula.tex</em>. Ce fichier est appelé par le fichier <em>formule.tex</em> qui se trouve dans le dossier de travail de TeXgraph, pour être compilé par {}. Si l’option <<em>dollar</em>> vaut <span class="math">1</span> alors la formule sera délimitée par <code>\]</code> et <code>\]</code>, sinon elle est écrite telle quelle. Pour plus de renseignements sur la façon dont sont récupérés ces chemins, voir la commande <a href="#ReadFlatPs">ReadFlatPs</a>.</p></li>
+</ul>
+<h2 id="Timer">Timer</h3>
+<ul>
+<li><p><b>Timer( <milli-secondes> )</b>.</p></li>
+<li><p><u>Description</u> : règle l’intervalle de temps pour le timer, celui exécute régulièrement une certaine macro (que l’on peut définir avec la commande TimerMac). Pour stopper le timer il suffit de régler l’intervalle de temps à 0.</p></li>
+</ul>
+<h2 id="TimerMac">TimerMac</h3>
+<ul>
+<li><p><b>TimerMac( <corps de la macro à exécuter> )</b>.</p></li>
+<li><p><u>Description</u> : cette commande permet de créer une macro qui sera attachée au timer. L’argument est interprété comme une chaîne de caractères et doit correspondre au corps de la macro (celle-ci sera appélée TimerMac). Pour des raisons de performances, il est préférable d’éviter trop d’appels à d’autres macros dans celle-ci. Cette fonction renvoie la valeur 1 si la macro est correctement définie, 0 en cas d’erreur. Attention, l’exécution de TimerMac ne déclenche pas le timer! Il faut utiliser la commande Timer pour cela.</p></li>
+<li><p><u>Exemple(s)</u> : soit <span class="math"><em>A</em></span> une variable globale (un point), soit <em>dotA</em> un élément graphique qui dessine le point, voilà une commande qui déplace <span class="math"><em>A</em></span>:</p>
+<p><div style="text-align:center"> <span style="color:red">[TimerMac("[Inc(A,0.1), if Re(A)>5 then Timer(0) else ReCalc(dotA) fi]"), A:=-5, Timer(10)]</span></div></p></li>
+</ul>
+<h2 id="VisibleGraph">VisibleGraph</h3>
+<ul>
+<li><p><strong>VisibleGraph( <0/1> )</strong> ou <b>VisibleGraph()</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’activer ou désactiver la zone de dessin dans l’interface graphique. Lorsque celle-ci est désactivée, son contenu ne change plus car il n’y a plus de mise à jour de la zone. Désactiver l’affichage graphique peut permettre dans certains cas un gain de temps pour enregistrer une animation par exemple.</p>
+<p>Lorsque l’argument est vide, la fonction renvoie simplement l’état actuel de l’affichage graphique (0 ou 1). Sinon, elle renvoie <em>Nil</em>.</p></li>
+</ul>
+<h2 id="WriteFile">WriteFile</h3>
+<ul>
+<li><p><b>WriteFile( <argument> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction permet d’écrire soit dans le fichier texte ouvert par la commande <a href="#OpenFile">OpenFile</a>, soit dans le fichier d’exportation si l’exécution de cette commande a lieu pendant une exportation par l’intermédiare des macros <a href="#Bsave">Bsave</a> et/ou <a href="#Esave">Esave</a>.</p></li>
+<li><p><u>Exemple(s)</u> : voici ce que pourrait être la macro <span style="font-style:italic">Bsave</span> pour modifier la taille des flêches en pstricks:</p></li>
+</ul>
+<pre><code> if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi
+</code></pre>
+<div class="footnotes">
+<hr />
+<ol>
+<li id="fn1"><p>C’est la première occurrence de <<em>variable</em>> dans <<em>expression</em>> qui est assignée, car toutes les occurrences pointent sur la même <case mémoire>, sauf éventuellement pour les macros après l’affectation des paramètres. <a href="#fnref1" class="footnoteBackLink" title="Jump back to footnote 1">↩</a></p></li>
+<li id="fn2"><p>Si par exemple on veut tracer la courbe représentative de cette fonction, dans l’option <em>Courbe/Paramétrée</em>, il faudra saisir la commande <em>t+i*<span class="math"> ∖ </span>df</em> et non pas <em>t+i*df(t)</em>. <a href="#fnref2" class="footnoteBackLink" title="Jump back to footnote 2">↩</a></p></li>
+<li id="fn3"><p>Il n’est pas nécessaire de déclarer les variables, elles sont implicitement locales et initialisées à <em>Nil</em> sauf si c’est le nom d’une variable globale ou d’une constante prédéfinie (comme i, <span class="math">π</span>, e, ...). <a href="#fnref3" class="footnoteBackLink" title="Jump back to footnote 3">↩</a></p></li>
+</ol>
+</div>
--- /dev/null
+\chapter{Liste des commandes}
+
+Notations:
+
+<argument>: signifie que l'argument est \Mytextbf{obligatoire}.
+
+[argument]: signifie que l'argument est \Mytextbf{facultatif}.
+
+
+\section{Args}\label{cmdArgs}
+
+\begin{itemize}
+\item \util \textbf[Args()]{Args( <entier> )}.
+
+\item \desc cette fonction n'a d'effet que dans une macro, elle évalue et renvoie l'argument numéro \argu{entier} avec
+lequel la macro a été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la commande
+\Helpref{StrArgs}{cmdStrArgs}
+
+\item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}.
+\end{itemize}
+
+\section{Assign}\label{cmdAssign}
+
+\begin{itemize}
+\item \util \textbf[Assign()]{Assign( <expression>, <variable>, <valeur> )}.
+
+\item \desc cette fonction évalue \argu{valeur} et l'affecte à la variable nommée \argu{variable} dans
+\argu{expression}\footnote{C'est la première occurrence de \argu{variable} dans \argu{expression} qui est assignée, car
+toutes les occurrences pointent sur la même <case mémoire>, sauf éventuellement pour les macros après l'affectation des
+paramètres.}. La fonction \textit{Assign} renvoie la valeur \Nil. Cette fonction est utile dans l'écriture de macros
+prenant une expression comme paramètre et qui doivent l'évaluer.
+
+\item \exem voici une macro \co{Bof} qui prend une fonction f(t) en paramètre et qui calcule la liste $[f(0), f(1),
+..., f(5)]$:
+\end{itemize}
+
+\centerline{\co{for \$k from 0 to 5 do Assign(\%1,t,k), \%1 od}}
+
+\%1 représente le premier paramètre de la macro (c'est à dire f(t)), la boucle: pour k allant de 0 à 5 elle exécute la
+commande [Assign(\%1, t, k), \%1], celle-ci assigne la valeur de k à la variable $t$ dans l'expression \%1, puis
+évalue
+\%1. L'exécution de \co{Bof(t\^{}2)} donne: \res{[0,1,4,9,16,25]}. L'exécution de \co{Bof(x\^{}2)} donne \Nil.
+
+\section{Attributs}\label{cmdAttributs}
+
+\begin{itemize}
+\item \util \textbf[Attributs()]{Attributs()}.
+
+\item \desc cette fonction ouvre la fenêtre permettant de modifier les attributs d'un élément graphique. Cette fonction
+renvoie la valeur 1 si l'utilisateur a choisi \textit{OK}, elle renvoie la valeur 0 s'il a choisi \textit{Cancel}. Si
+l'utilisateur a choisi \textit{OK}, alors les variables globales correspondant aux attributs sont modifiées en
+conséquence.
+\end{itemize}
+
+\section{Border}\label{cmdBorder}
+
+\begin{itemize}
+\item \util \textbf[Border()]{Border( <0/1> )}
+
+\item \desc cette fonction détermine si un cadre doit être dessiné ou non autour des marges du graphique dans les
+exportations. Lorsque la valeur de l'argument est nulle (valeur par défaut), le cadre n'est pas dessiné.
+
+Lorsque l'argument est vide, cette fonction renvoie l'état de la bordure à l'exportation (0 ou 1). Sinon, elle renvoie
+la valeur \Nil.
+\end{itemize}
+
+\section{ChangeAttr}\label{cmdChangeAttr}
+
+\begin{itemize}
+\item \util \textbf[ChangeAttr()]{ChangeAttr( <element1>, ..., <elementN> )}
+\item \desc cette fonction permet de modifier les attributs des éléments graphiques \argu{element1}, ...,
+\argu{elementN}, en leur affectant la valeur des attributs en cours. Les arguments sont interprétés comme des chaînes de
+caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{Clip2D}\label{cmdClip2D}
+
+\begin{itemize}
+\item \util \textbf[Clip2D()]{Clip2D( <ligne polygonale>, <contour convexe> [, close(0/1) ] )}.
+\item \desc cette fonction clippe la \argu{ligne polygonale} qui doit être une variable contenant une liste de
+complexes, avec le \argu{contour convexe}, qui est lui aussi une liste de complexes. La fonction calcule la ligne
+polygonale qui en résulte modifie la variable \argu{ligne polygonale} en conséquence, le dernier
+agument \argu{close} ($0$ par défaut) permet de préciser si la \argu{ligne polygonale} doit être refermée ou non. La
+fonction renvoie \Nil.
+\end{itemize}
+
+\section{CloseFile}\label{cmdCloseFile}
+
+\begin{itemize}
+\item \util \textbf[CloseFile()]{CloseFile()}.
+\item \desc cette fonction permet de fermer le fichier ouvert par la commande \Helpref{OpenFile}{cmdOpenFile}.
+\end{itemize}
+
+
+\section{ComposeMatrix}\label{cmdComposeMatrix}
+
+\begin{itemize}
+\item \util \textbf[ComposeMatrix()]{ComposeMatrix( <[z1, z2, z3]> )}
+\item \desc cette fonction permet de composer la matrice courante (celle-ci affecte tous les éléments graphiques sauf
+les axes et les grilles dans la version actuelle) avec la matrice \argu{[z1, z2, z3]}. Cette matrice représente
+l'expression analytique d'une application affine du plan, c'est une liste de trois complexes: $z1$ qui est l'affixe du
+vecteur de translation, $z2$ qui est l'affixe du premier vecteur colonne de la matrice de la partie linéaire dans la
+base (1,i), et $z3$ qui est l'affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la
+matrice de l'identité s'écrit ainsi: [0,1,i] (c'est la matrice par défaut). (Voir aussi les commandes
+\Helpref{GetMatrix}{cmdGetMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix}).
+\end{itemize}
+
+
+\section{Copy}\label{cmdCopy}
+
+\begin{itemize}
+\item \util \textbf[Copy()]{Copy( <liste>, <index depart>, <nombre> )}.
+
+\item \desc cette fonction renvoie la liste constituée par les \argu{nombre} éléments de la \argu{liste} à partir de
+l'élément numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie tous les éléments de la
+liste à partir de l'élément numéro \argu{départ}.
+
+Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, le dernier
+élément a l'index $-1$, l'avant-dernier a l'index $-2$ $\cdots$ etc. La fonction renvoie les \argu{nombre} éléments de
+la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche, mais la liste renvoyée est dans le même
+sens que la \argu{liste}, et cette dernière n'est pas modifiée.
+
+\item \exem
+\begin{itemize}
+ \item \co{Copy([1,2,3,4],2,2)} renvoie \res{[2,3]}.
+ \item \co{Copy([1,2,3,4],2,5)} renvoie \res{[2,3,4]}.
+ \item \co{Copy([1,2,3,4],2,0)} renvoie \res{[2,3,4]}.
+ \item \co{Copy([1,2,3,4],-1,2)} renvoie \res{[3,4]}.
+ \item \co{Copy([1,2,3,4],-2,2)} renvoie \res{[2,3]}.
+ \item \co{Copy([1,2,3,4],-2,0)} renvoie \res{[1,2,3]}.
+\end{itemize}
+\end{itemize}
+
+\Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier
+élément de la liste.
+
+\section{DefaultAttr}\label{cmdDefaultAttr}
+
+\begin{itemize}
+\item \util \textbf[DefaultAttr()]{DefaultAttr()}
+
+\item \desc cette fonction met toutes les variables correspondant aux attributs (\var{Color}, \var{Width}, ...) à leur
+valeur par défaut. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+
+\section{Del}\label{cmdDel}
+
+\begin{itemize}
+\item \util \textbf[Del()]{Del( <liste>, <depart>, <nombre> )}.
+
+\item \desc supprime de la \argu{liste} \argu{nombre} éléments à partir du numéro \argu{départ} [inclus]. Si
+\argu{nombre} est nul, alors la fonction supprime tous les éléments de la liste à partir de l'élément numéro
+\argu{départ}.
+
+
+Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier. Le dernier
+élément a l'index $-1$, l'avant-dernier a l'index $-2$ $\cdots$ etc. La fonction supprime les \argu{nombre} éléments de
+la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche.
+
+Le paramètre \argu{liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la fonction renvoie \Nil.
+
+\item \exem la commande \co{[x:=[1,2,3,4], Del(x,2,2), x]} renvoie \res{[1,4]}.
+
+La commande \co{[x:=[1,2,3,4], Del(x,-2,2), x]} renvoie \res{[1,4]}.
+
+\end{itemize}
+
+\Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier
+élément de la liste.
+
+\section{Delay}\label{cmdDelay}
+
+\begin{itemize}
+\item \util \textbf[Delay()]{Delay( <nb millisecondes> )}
+
+\item \desc permet de suspendre l'exécution du programme pendant le laps de temps indiqué (en milli-secondes).
+\end{itemize}
+
+\section{DelButton}\label{cmdDelButton}
+
+\begin{itemize}
+\item \util \textbf[DelButton()]{DelButton( <texte1>, ..., <texteN> )}
+
+\item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les boutons portant les
+inscriptions \argu{texte1}, ..., \argu{texteN}. Si la liste est vide (\textsl{ DelButton()}), alors tous les boutons
+sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelGraph}\label{cmdDelGraph}
+
+\begin{itemize}
+\item \util \textbf[DelGraph()]{DelGraph( <element1>, ..., <elementN> )}
+
+\item \desc Cette fonction permet de supprimer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN}. Si
+la liste est vide (\textsl{ DelGraph()}), alors tous les éléments sont supprimés. Les arguments sont interprétés comme
+des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelItem}\label{cmdDelItem}
+
+\begin{itemize}
+\item \util \textbf[DelItem()]{DelItem( <nom1>, ..., <nomN> )}
+
+\item \desc Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options
+appelées
+\argu{nom1}, ..., \argu{nomN}. Si la liste est vide (\textsl{ DelItem()}), alors toute la liste est supprimée. Les
+arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelMac}\label{cmdDelMac}
+
+\begin{itemize}
+\item \util \textbf[DelMac()]{DelMac( <mac1>, ..., <macN> )}
+
+\item \desc Cette fonction permet de supprimer les macros (non prédéfinies) appelées \argu{mac1}, ..., \argu{macN}. Si
+la liste est vide (\textsl{DelMac()}), la commande est sans effet. Les arguments sont interprétés comme
+des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelText}\label{cmdDelText}
+
+\begin{itemize}
+\item \util \textbf[DelText()]{DelText( <texte1>, ..., <texteN> )}
+
+\item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les labels \argu{texte1},
+..., \argu{texteN}. Si la liste est vide (\textsl{ DelText()}), alors tous les labels sont supprimés. Les arguments sont
+interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelVar}\label{cmdDelVar}
+
+\begin{itemize}
+\item \util \textbf[DelVar()]{DelVar( <var1>, ..., <varN> )}
+
+\item \desc Cette fonction permet de supprimer les variables globales (non prédéfinies) appelés \argu{var1}, ...,
+\argu{varN}. Si la liste est vide (\textsl{DelVar()}), la commande est sans effet. Les arguments sont interprétés comme
+des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+
+\section{Der}\label{cmdDer}
+
+\begin{itemize}
+\item \util \textbf[Der()]{Der( <expression>, <variable>, <liste> )}.
+
+\item \desc cette fonction calcule la dérivée de \argu{expression} par rapport à \argu{variable} et l'évalue en donnant
+à \argu{variable} les valeurs successives de la \argu{liste}. La fonction \textsl{Der} renvoie la liste des résultats.
+Mais si on a besoin de \textsl{l'expression de la dérivée}, alors on préférera la fonction \Helpref{Diff}{cmdDiff}.
+
+\item \exem
+\begin{itemize}
+\item la commande \co{Der(1/x,x,[-1,0,2] )} renvoie \res{[-1,-0.25]}.
+\item Voici le texte d'une macro appelée \co{tangente} qui prend une expression $f(x)$ en premier paramètre, une valeur
+réelle $x0$ en second paramètre et qui trace la tangente à la courbe au point d'abscisse x0:
+
+\centerline{\co{[Assign(\%1,x,\%2), \$A:=\%2+i*\%1, \$Df:=Der(\%1,x,\%2), Droite(A, A+1+i*Df)]}}
+
+On assigne la valeur $x0$ à la variable $x$ dans l'expression $f(x)$, on stocke dans une variable $A$ le point de
+coordonnées $(x0,f(x0))$ (sous forme d'affixe), on stocke dans une variable $Df$ la dérivée en $x0$ ($f'(x0)$), puis on
+trace la droite passant par $A$ et dirigée par le vecteur d'affixe $1+if'(x0)$.
+\end{itemize}
+\end{itemize}
+
+\section{Diff}\label{cmdDiff}
+
+\begin{itemize}
+\item \util \textbf[Diff()]{Diff( <nom>, <expression>, <variable> [, param1,..., paramN] )}
+
+\item \desc cette fonction permet de créer une macro appelée \argu{nom}, s'il existait déjà une macro portant ce nom,
+elle sera écrasée, sauf si c'est une macro prédéfinie auquel cas la commande est sans effet. Le corps de la macro créée
+correspond à la dérivée de \argu{expression} par rapport à \argu{variable}. Les paramètres optionnels sont des noms de
+variables, le nom de la variable \argu{param1} est remplacé dans l'expression de la dérivée par le paramètre \%1, le nom
+\argu{param2} est remplacé par \%2 ... etc. Cette fonction renvoie \Nil.
+
+\item \exem après l'exécution de la commande (dans la ligne de commande en bas de la fenêtre):
+ \co{Diff(df, sin(3*t), t)}, une macro appelée \res{df} est créée et son contenu est: \res{3*cos(3*t)}, c'est une macro
+sans paramètre qui contient une variable locale $t$, elle devra donc être utilisée en développement immédiat (c'est à
+dire
+précédée du symbole $\backslash$)\footnote{Si par exemple on veut tracer la courbe représentative de cette fonction,
+dans l'option \textit{Courbe/Paramétrée}, il faudra saisir la commande \textit{t+i*$\backslash$df} et non pas
+\textit{t+i*df(t)}.}. Par contre après la commande \co{Diff(df,sin(3*t),t,t)}, le contenu de la macro \res{df} est:
+\res{3*cos(3*\%1)} qui est une macro à un paramètre.
+\end{itemize}
+
+\section{Echange}\label{cmdEchange}
+
+\begin{itemize}
+\item \util \textbf[Echange()]{Echange( <variable1>, <variable2> )}.
+
+\item \desc cette fonction échange les deux variables, ce sont en fait les adresses qui sont échangées. Les contenus ne
+sont pas dupliqués alors qu'ils le seraient si on utilisait la commande:
+
+{\centering \co{[aux:=variable1, variable1:=variable2, variable2:=aux]}\par}
+
+ La fonction \textsl{Echange} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{EpsCoord}\label{cmdEpsCoord}
+
+\begin{itemize}
+\item \util \textbf[EpsCoord()]{EpsCoord( <affixe> )}
+
+\item \desc renvoie l'affixe exportée en eps. Pour les autres, il y a les macros \Helpref{TeXCoord}{macTeXCoord} et
+\Helpref{SvgCoord}{macSvgCoord}.
+\end{itemize}
+
+\section{Eval}\label{cmdEval}
+
+\begin{itemize}
+\item \util \textbf[Eval()]{Eval( <expression> )}.
+
+\item \desc cette fonction évalue l'\argu{expression} et renvoie le résultat. L'\argu{expression} est interprétée comme
+une \Helpref{chaîne de caractères}{chaine}.
+
+\item La fonction \Helpref{{Input}}{cmdInput} renvoie la saisie sous forme d'une chaîne dans la macro appelée
+\textit{chaine()}. La fonction \textsl{Eval} évalue cette chaîne (comme n'importe quelle commande TeXgraph) et renvoie
+le résultat.
+
+\item \exem voici une commande demandant une valeur à l'utilisateur pour une variable \textit{x}:
+\end{itemize}
+
+\begin{verbatim}
+ if Input("x=", "Entrez une valeur pour x", x )
+ then x:= Eval( chaine() )
+ fi
+\end{verbatim}
+
+
+\section{Exec}\label{cmdExec}
+
+\begin{itemize}
+\item \util \textbf[Exec()]{Exec( <programme> [, argument(s), répertoire de travail, attendre] )}.
+
+\item \desc cette fonction permet d'exécuter un \argu{programme} (ou un script) en précisant éventuellement des
+\argu{arguments} et un \argu{répertoire de travail}, ces trois arguments sont interprétés comme des chaînes de
+caractères. Le dernier argument doit valoir 0 (par défaut) ou 1, il indique si le programme attend ou non la fin du
+processus fils. La fonction renvoie la valeur \Nil. Un message d'erreur s'affiche lorsque: les ressources sont
+insuffisantes, ou bien le programme est invalide, ou bien le chemin est invalide.
+
+\item La macro-chaîne prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu}
+exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute
+\textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de
+pdf.
+
+\item \exem la macro \textsl{Apercu} contenue dans interface.mac est:
+\end{itemize}
+
+\begin{verbatim}
+ [Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+\end{verbatim}
+
+\section{Export}\label{cmdExport}
+
+\begin{itemize}
+\item \util \textbf[Export()]{Export( <mode>, <fichier> )}.
+
+\item \desc cette fonction permet d'exporter le graphique en cours, \argu{mode} est une valeur numérique qui peut être
+l'une
+des constantes suivantes: tex, pst, pgf, tkz, eps, psf, pdf, epsc, pdfc, svg, bmp, obj, geom, jvx ou teg. L'exportation
+se fait dans \argu{fichier} qui contient donc le nom du fichier, avec éventuellement le chemin.
+
+La macro prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu}
+exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute
+\textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de
+pdf.
+
+\item \exem la macro \textsl{Apercu} contenue dans interface.mac est:
+\end{itemize}
+
+\begin{verbatim}
+ [Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+\end{verbatim}
+
+\section{ExportObject}\label{cmdExportObject}
+
+\begin{itemize}
+ \item \textbf[ExportObject()]{ExportObject( <argument> )}
+ \item \desc cette commande n'a d'effet que pendant un export. Elle permet d'exporter l'\argu{argument} dans le fichier
+de sortie, cet \argu{argumet} est soit le nom d'un élément graphique, soit une commande graphique (comme pour la
+fonction \Helpref{Get}{cmdGet}). Elle peut-être utile pour écrire des exports personnalisés, ceci est décrit dans
+\Helpref{cette section}{cmdMyExport}.
+\end{itemize}
+
+\section{Fenetre}\label{cmdFenetre}
+
+\begin{itemize}
+\item \util \textbf[Fenetre()]{Fenetre( <A>, <B> [, C] )}.
+\item \desc cette fonction modifie la fenêtre graphique, c'est l'équivalent de l'option \textit{Paramètres/Fenêtre},
+\Mytextbf{sauf que les éléments graphiques ne sont pas automatiquement recalculés}. Le paramètre \argu{A} et le
+paramètre \argu{B} sont les affixes de deux coins de la fenêtre diamétralement opposés, et le paramètre facultatif
+\argu{C} représente les deux échelles, plus précisément, la partie réelle de \argu{C} est l'échelle [en cm] sur l'axe
+des abscisses et la partie imaginaire de \argu{C} est l'échelle [en cm] sur l'axe des ordonnées, ces deux valeurs
+doivent être strictement positives. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{Free}\label{cmdFree}
+
+\begin{itemize}
+\item \util \textbf[Free()]{Free( <expression>, <variable>}.
+\item \desc cette fonction renvoie $1$ si l'\argu{expression} contient la \argu{variable}, $0$ sinon. Lorsque le
+deuxième argument n'est pas un nom de variable, la fonction renvoie \Nil.
+\end{itemize}
+
+\section{Get}\label{cmdGet}
+
+\begin{itemize}
+\item \util \textbf[Get()]{Get( <argument> [, clip(0/1)] )}.
+\item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un
+élément graphique dont le nom est \argu{argument}, si c'est le cas, alors la fonction renvoie la liste des points de cet
+élément graphique, sinon elle renvoie la valeur \Nil. Dans ce cas l'argument optionnel est ignoré.
+
+Lorsque \argu{argument} n'est pas un identificateur, celui-ci est considéré comme une \textit{fonction graphique}, la
+fonction \textsl{Get} renvoie la liste des points de l'élément graphique construit par cette fonction graphique mais
+sans créer l'élément en question. L'argument optionnel \argu{clip} (qui vaut $1$ par défaut) indique si l'élément doit
+être clippé par la fenêtre courante (valeur 1) ou non (valeur 0).
+
+Lorsque l'argument est vide: \textsl{Get()}, la fonction renvoie la liste des points de tous les éléments graphiques
+déjà construits, ceux qui sont cachés sont ignorés.
+
+\item \exem \co{Get(Cercle(0,1))} renvoie la liste des points du cercle de centre 0 et de rayon 1 mais sans créer ce
+cercle, la liste des points est clippée par la fenêtre graphique.
+
+\item \exem utilisation des points d'un objet graphique:
+\end{itemize}
+
+\begin{demo}{Get}{Get}
+\begin{texgraph}[name=Get,export=pgf,file]
+Cmd view(0,6.25,-1.5,2);
+ size(7.5);
+ [tMin:=0, tMax:=6.25];
+Graph axe = Axes(0,1+i);
+ C1 = [Color:=blue,Width:=8,
+ Cartesienne(1/x) ];
+ C2 = [Color:=red,Width:=8,
+ Cartesienne(sin(2*x)*1.5)];
+ inter = [DotScale:=2,DotStyle:=dotcircle,
+ Color:=forestgreen,
+ Point(Get(C1) InterL Get(C2)),
+ Color:=blue,
+ LabelDot(5.5+0.1*i,"$C_1$","N"),
+ Color:=red,
+ LabelDot(3-i,"$C_2$","E"),
+ ];
+\end{texgraph}
+\end{demo}
+
+
+\section{GetAttr}\label{cmdGetAttr}
+
+\begin{itemize}
+\item \util \textbf[GetAttr()]{GetAttr( <argument> )}
+
+\item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un
+élément graphique dont le nom est \argu{argument}, si c'est le cas, alors les attributs de cet élément graphique
+deviennent les attributs courants, et la fonction renvoie la valeur \Nil. Sinon, l'argument est interprété comme une
+chaîne de caractères puis la fonction
+effectue la même recherche.
+\end{itemize}
+
+\section{GetMatrix}\label{cmdGetMatrix}
+
+\begin{itemize}
+\item \util \textbf[GetMatrix()]{GetMatrix()}
+
+\item \desc cette fonction renvoie la matrice courante. (Voir aussi les commandes
+\Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix})
+\end{itemize}
+
+\section{GetSpline}\label{cmdGetSpline}
+
+\begin{itemize}
+\item \util \textbf[GetSpline()]{GetSpline(<V0>, <A0>,..., <An>, <Vn> )}
+\item \desc renvoie la liste des points de contrôle correspondant à la spline cubique passant par les points
+\argu{A0} jusqu'à \argu{An}. \argu{V0} et \argu{Vn} désignent les vecteurs vitesses aux extrémités [contraintes], si
+l'un d'eux est nul alors l'extrémité correspondante est considérée comme libre (sans contrainte). Le résultat doit être
+dessiné avec la commande graphique \Helpref{Bezier}{cmdBezier}.
+\end{itemize}
+
+
+\section{GrayScale}\label{cmdGrayScale}
+
+\begin{itemize}
+\item \util \textbf[GrayScale()]{GrayScale(0/1)} ou \textbf[GrayScale()]{GrayScale()}.
+
+\item \desc cette fonction permet d'activer ou désactiver la conversion des couleurs en niveaux de gris. Elle équivaut à
+l'option \textsl{Paramètres/Gérer les couleurs} du menu de l'interface graphique.
+
+Lorsque l'argument est vide, la fonction renvoie l'état actuel de la conversion en niveaux de gris (0 ou 1). Sinon, elle
+renvoie \Nil.
+\end{itemize}
+
+\section{HexaColor}\label{cmdHexaColor}
+
+\begin{itemize}
+\item \util \textbf[HexaColor()]{HexaColor( <valeur héxadécimale> )}
+
+\item \desc cette fonction renvoie la couleur correspondant à la \argu{valeur héxadécimale}, cette valeur doit être
+passée sous forme d'une chaîne de caractères. Voir aussi la commande \Helpref{Rgb}{cmdRgb}.
+
+\item \exem \verb Color:=HexaColor("F5F5DC") .
+\end{itemize}
+
+\section{Hide}\label{cmdHide}
+
+\begin{itemize}
+\item \util \textbf[Hide()]{Hide( <element1>, ..., <elementN> )}
+
+\item \desc Cette fonction permet de cacher les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en
+mettant leur attribut \textsl{IsVisible} à false. Les arguments sont interprétés comme des chaînes de caractères. Cette
+fonction renvoie la valeur \Nil.
+
+Pour tout cacher on invoque la commande sans arguments: \textsl{Hide()}.
+
+Pour tout cacher sauf un ou plusieurs éléments, on invoque la commande: \textsl{Hide(except, element1, ..., elementN)}.
+Voir aussi la commande \Helpref{Show}{cmdShow}.
+\end{itemize}
+
+\section{IdMatrix}\label{cmdIdMatrix}
+
+\begin{itemize}
+\item \util \textbf[IdMatrix()]{IdMatrix()}
+\item \desc change la matrice courante en la matrice identité. (Voir aussi les commandes
+\Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{GetMatrix}{cmdGetMatrix})
+\end{itemize}
+
+
+
+\section{Input}\label{cmdInput}
+
+\begin{itemize}
+\item \util \textbf[Input()]{Input( <message> [, titre, chaîne] )}.
+\item \desc cette fonction ouvre une boite de dialogue avec \argu{titre} dans la barre de titre (par défaut le titre
+est vide), et dans laquelle le paramètre \argu{message} est affiché, le paramètre \argu{chaîne} est affiché dans la zone
+de saisie. Ces paramètres sont donc interprétés comme des \Helpref{chaînes de caractères}{chaine}, l'utilisateur est
+invité à faire une saisie. S'il valide alors la fonction \textsl{Input} renvoie la valeur $1$ et la chaîne saisie est
+\Mytextbf{mémorisée dans la macro} \textsl{chaine()}. Si l'utilisateur ne valide pas ou si la chaîne saisie est vide,
+alors la fonction \textsl{Input} renvoie la valeur $0$.
+\item \exem voir la fonction \Helpref{Eval}{cmdEval}.
+\end{itemize}
+
+\section{InputMac}\label{cmdInputMac}
+
+\begin{itemize}
+\item \util \textbf[InputMac()]{InputMac( <nom de fichier> )} ou \textbf[Load()]{Load( <nom de fichier> )}.
+\item \desc cette fonction permet de charger en mémoire un fichier de macros (\textit{*.mac}), ou un fichier modèle
+(\textit{*.mod}), ou tout fichier source texgraph (\textit{*.teg}).
+
+Dans le premier cas (fichier \textit{*.mac}), les variables globales et les macros seront considérées comme
+\Mytextbf{prédéfinies} (elles n'apparaissent pas à l'écran, elles ne seront pas
+enregistrées avec le graphique, mais elles sont effacées de la mémoire dès qu'on commence un nouveau graphique). Le
+paramètre \argu{nom de fichier} est une chaîne de caractères représentant le fichier à charger avec éventuellement son
+chemin. Cette fonction renvoie \Nil, et si ce fichier était déjà chargé, alors elle est sans effet. Si le fichier à
+charger est dans le répertoire \textit{macros} de \textit{TeXgraph}, ou dans le dossier \textit{TeXgraphMac}, alors il
+est inutile de préciser le chemin.
+\item \exem \co{InputMac("MesMacros.mac")}.
+\end{itemize}
+
+\section{Inc}\label{cmdInc}
+
+\begin{itemize}
+\item \util \textbf[Inc()]{Inc( <variable>, <expression> )}.
+\item \desc cette fonction évalue \argu{expression} et ajoute le résultat à \argu{variable}. Cette fonction est plus
+avantageuse que la commande \co{variable := variable + expression}, car dans cette commande la \argu{variable} est
+évaluée [c'est à dire dupliquée] pour calculer la somme. La fonction \textsl{Inc} renvoie la valeur \Nil.
+\end{itemize}
+
+
+\section{Insert}\label{cmdInsert}
+
+\begin{itemize}
+\item \util \textbf[Insert()]{Insert( <liste1>, <liste2> [, position] )}.
+\item \desc cette fonction insère la \argu{liste2} dans la \argu{liste1} à la position numéro \argu{position}. Lorsque
+la position vaut 0 [valeur par défaut]. La \argu{liste2} est ajoutée à la fin. La \argu{liste1} doit être une variable
+et celle-ci est modifiée. La fonction \textsl{Insert} renvoie la valeur \Nil.
+\item \exem si une variable $L$ contient la liste \co{[1,4,5]}, alors après la commande \co{Insert(L,[2,3],2)}, la
+variable $L$ contiendra la liste \res{[1,2,3,4,5]}.
+\end{itemize}
+
+\section{Int}\label{cmdInt}
+
+\begin{itemize}
+\item \util \textbf[Int()]{Int( <expression>, <variable>, <borne inf.>, <borne sup.> )}.
+\item \desc cette fonction calcule l'intégrale de \argu{expression} par rapport à \argu{variable} sur l'intervalle
+\Mytextbf{réel} défini par \argu{borne inf.} et \argu{borne sup}. Le calcul est fait à partir de la méthode de
+\textsc{Simpson} accélérée deux fois avec la méthode de \textsc{Romberg}, \argu{expression} est supposée définie et
+suffisamment régulière sur l'intervalle d'intégration.
+\item \exem \co{Int(exp(sin(u)),u,0,1)} donne \res{1.63187} (Maple donne 1.631869608).
+\end{itemize}
+
+\section{IsMac}\label{cmdIsMac}
+
+\begin{itemize}
+\item \util \textbf[IsMac()]{IsMac( <nom> )}.
+\item \desc cette fonction permet de savoir s'il y a une macro appellée \argu{nom}. Elle renvoie $1$ si c'est
+le cas, $0$ sinon.
+\end{itemize}
+
+\section{IsVar}\label{cmdIsVar}
+
+\begin{itemize}
+\item \util \textbf[IsVar()]{IsVar( <nom> )}.
+\item \desc cette fonction permet de savoir s'il y a une variable globale appellée \argu{nom}. Elle renvoie $1$ si c'est
+le cas, $0$ sinon.
+\end{itemize}
+
+\section{Liste}\label{cmdListe}
+
+\begin{itemize}
+\item \util \textbf[Liste()]{Liste( <argument1>, ..., <argumentn> )} ou bien \Mytextbf{[<argument1>, ...,
+<argumentn>]}.
+\item \desc cette fonction évalue chaque argument et renvoie la liste des résultats \Mytextbf{différents de \Nil}.
+\item \exem \co{Liste(1, Arg(1+2*i), sqrt(-1), Solve(cos(x)-x,x,0,1))} renvoie le résultat
+\res{[1,1.107149,0.739085]}.
+\end{itemize}
+
+\section{ListFiles}\label{cmdListFiles}
+
+\begin{itemize}
+\item \util \textbf[ListFiles()]{ListFiles()}.
+\item \desc cette fonction est disponible seulement dans la version GUI de TeXgraph, elle s'utilise dans la barre de
+commande en bas de la fenêtre, elle affiche alors la liste des fichiers de macros (\textit{*.mac}) chargés en mémoire.
+\end{itemize}
+
+\section{LoadImage}\label{cmdLoadImage}
+
+\begin{itemize}
+\item \util \textbf[LoadImage()]{LoadImage( <image> )}.
+\item \desc cette fonction charge le fichier \argu{image}, qui doit être une image png, jpeg ou bmp. Celle-ci est
+affichée en image de fond et fait partie du graphique, en particulier elle est exportée dans les formats tex (visible
+seulement dans la version postscript), pgf, pst et teg. Pour le format pgf c'est la version png ou jpg qui sera dans le
+document, mais pour les versions pst et tex il faut une version eps de l'image. L'argument est interprêté comme une
+chaîne de caractères, et la fonction renvoie la valeur \Nil.
+
+Lors du chargement, la taille de l'image est adaptée à la fenêtre, mais celle-ci peut être modifiée de manière à
+conserver les proportions de l'image. Dès lors la position de l'image et sa taille sont fixées. On peut ensuite élargir
+la fenêtre si on ne veut pas que l'image occupe tout l'espace. Pour modifier la position ou la taille de l'image, il
+faut recharger celle-ci.
+\end{itemize}
+
+
+\section{Loop}\label{cmdLoop}
+
+\begin{itemize}
+\item \util \textbf[Loop()]{Loop( <expression>, <condition> )}.
+\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste en évaluant \argu{expression} et
+\argu{condition} jusqu'à ce que le résultat de \argu{condition} soit égal à 1 (pour \textit{True}) ou \Nil, la fonction
+\textsl{Loop} renvoie alors la liste des résultats de \argu{expression}. Cette commande est la représentation interne de
+la boucle \Helpref{{repeat}}{cmdrepeat} dont l'utilisation est préférable pour des raisons de lisibilité.
+\item \exem les commandes (équivalentes):
+
+\centerline{\co{[n:=1, m:=1, n, Loop([ aux:=n, n:=m, m:=aux+n, n], m>100)]}}
+
+ou encore
+
+\centerline{\co{[n:=1, m:=1, n, while m<=100 do aux:=n, n:=m, m:=aux+n, n od]}}
+
+ou encore
+
+\centerline{\co{[n:=1, m:=1, n, repeat aux:=n, n:=m, m:=aux+n, n until m>100 od]}}
+
+renvoient la liste: \res{[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]} (termes d'une suite de \textsc{Fibonacci} inférieurs à
+100).
+\end{itemize}
+
+\section{Map}\label{cmdMap}
+
+\begin{itemize}
+\item \util \textbf[Map()]{Map( <expression>, <variable>, <liste> [, mode] )}.
+\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable}
+parcourt les éléments de \argu{liste} et pour chacun d'eux \argu{expression} est évaluée, la fonction \textsl{Map}
+renvoie la liste des résultats. Cette commande est la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont
+l'utilisation est préférable pour des raisons de lisibilité.
+
+Le paramètre optionnel \argu{mode} est un complexe qui vaut \Nil par défaut, lorsque \argu{mode}$=a+ib$, alors:
+ \begin{itemize}
+ \item si $a$ est un entier et $b=0$: les éléments de la \argu{liste} sont traités de $a$ en $a$,
+ \item si $a$ est un entier et $b=1$: la \argu{liste} est traitée par composante (deux composantes sont séparées
+par la constante \jump) et les éléments de chaque composante sont traités par paquets complets de $a$ éléments, lorsque
+la constante \jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat. Un paquet non complet n'est pas
+traité.
+ \item si $a$ est un entier et $b=-1$: la \argu{liste} est traitée par composante (deux composantes sont séparées
+par la constante \jump) et les éléments de chaque composante sont traités par paquets complets de $a$ éléments, lorsque
+la constante \jump est rencontrée dans la liste, celle-ci n'est pas renvoyée dans le résultat. Un paquet non complet
+n'est pas traité.
+ \item si $a=$Re(jump): la \argu{liste} est traitée par composante (deux composantes sont séparées par la
+constante \jump), lorsque la constante \jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat si
+$b=1$ et n'est pas renvoyée si $b=-1$.
+
+ \item \exem voir la boucle \Helpref{for}{cmdfor} pour des exemples.
+ \end{itemize}
+
+
+\item \exem si $L$ est une variable contenant une liste de points, alors la commande:
+ \begin{itemize}
+ \item \co{[sum:=0, Map( Inc(sum,z), z, L), sum]} renvoie la somme des éléments de $L$.
+ \item la commande \co{Map(z*exp(i*$\pi$/3), z, L)} renvoie la liste des images des points de $L$ par la rotation
+de centre O d'angle $\pi$/3.
+ \end{itemize}
+\end{itemize}
+
+\section{Marges}\label{cmdMarges}
+
+\begin{itemize}
+\item \util \textbf[Marges()]{Marges( <gauche>, <droite>, <haut>, <bas> )}
+\item \desc cette fonction permet de fixer les marges autour du dessin (en cm). Les nouvelles valeurs sont copiées dans
+les constantes \var{margeG}, \var{margeD}, \var{margeH} et \var{margeB}.
+\end{itemize}
+
+
+\section{Merge}\label{cmdMerge}
+
+\begin{itemize}
+\item \util \textbf[Merge()]{Merge( <liste> )}.
+\item \desc cette fonction permet de recoller des morceaux de listes pour avoir des composantes de longeur maximale,
+elle renvoie la liste qui en résulte.
+\item \exem \co{Merge([1, 2, jump, 3, 5, jump, 3, 4, 2] )} renvoie \res{[1, 2, 3, 4, 5]}. Et \co{Merge( [1, 2, jump, 3,
+5, jump, 3, 4] )} renvoie \res{[1, 2, jump, 4, 3, 5]}.
+
+Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine.
+\end{itemize}
+
+
+\section{Message}\label{cmdMessage}
+
+\begin{itemize}
+\item \util \textbf[Message()]{Message( <chaîne> )}.
+\item \desc cette fonction affiche le paramètre \argu{chaîne} [qui est donc interprété comme une \Helpref{chaîne de
+caractères}{chaine}] dans une fenêtre. Quand l'utilisateur a cliqué sur \textit{OK}, la fenêtre se referme et la
+fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{Move}\label{cmdMove}
+
+\begin{itemize}
+\item \util \textbf[Move()]{Move( <element1>, ..., <elementN> )}.
+\item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode NotXor, ce qui correspond à la valeur
+1 de la variable \Helpref{PenMode}{cmdPenMode}. Elle redessine les éléments graphiques \argu{element1}, ...,
+\argu{elementN}, puis les recalcule, puis les redessine, et elle renvoie la valeur \Nil.
+
+Lorsqu'on redessine un élément graphique créé en mode NotXor, il s'efface en restituant le fond, on peut alors modifier
+sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres
+(ce qui évite d'avoir une image qui saute).
+\item\exem voir la fonction \Helpref{Stroke}{cmdStroke}.
+\end{itemize}
+
+\section{Mtransform}\label{cmdMtransform}
+
+\begin{itemize}
+\item \util \textbf[Mtransform()]{Mtransform( <liste>, <matrice> )}.
+\item \desc cette fonction applique la \argu{matrice} à la \argu{liste} et renvoie le résultat. Si la \argu{liste}
+contient la constante \jump, celle-ci est renvoyée dans le résultat sans être modifiée. La \argu{matrice} représente
+l'expression analytique d'une application affine du plan, c'est une liste de trois complexes $[z1,z2,z3]$: $z1$ est
+l'affixe du vecteur de translation, $z2$ est l'affixe du premier vecteur colonne de la matrice de la partie linéaire
+dans la base (1,i), et $z3$ est l'affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par
+exemple, la matrice de l'identité s'écrit ainsi: [0,1,i] (c'est la matrice par défaut).
+\end{itemize}
+
+\section{MyExport}
+
+\begin{itemize}
+ \item \textbf[MyExport()]{MyExport( <"nom">, <paramètre 1>, ..., <paramètre n> )} ou \textbf[draw()]{draw(
+<"nom">, <paramètre 1>, ..., <paramètre n> )}
+ \item \desc cette commande permet d'ajouter de nouveaux éléments graphiques avec un export personnalisé. Elle est
+décrite dans \Helpref{cette section}{cmdMyExport}.
+\end{itemize}
+
+\section{Nargs}\label{cmdNargs}
+
+\begin{itemize}
+\item \util \textbf[Nargs()]{Nargs()}.
+\item \desc cette fonction n'a d'effet que dans une macro, elle renvoie le nombre d'arguments avec lesquels la macro a
+été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir aussi la fonction \Helpref{Args}{cmdArgs}.
+\item\exem voici le corps d'une macro \textit{MyLabel(affixe1, texte1, affixe2, texte2, ...)} prenant un nombre
+indéterminé d'arguments:
+\end{itemize}
+
+\begin{verbatim}
+ for $k from 1 to Nargs()/2 do
+ Label(Args(2*k-1), Args(2*k))
+ od
+\end{verbatim}
+
+\section{NewButton}\label{cmdNewButton}
+
+\begin{itemize}
+\item \util \textbf[NewButton()]{NewButton( <Id>, <nom>, <affixe>, <taille>, <commande> [, aide] )}.
+\item \desc cette fonction crée dans la zone grisée à gauche dans la fenêtre un bouton dont le numéro d'identification
+est \Mytextbf{l'entier} \argu{Id}, le texte figurant sur le bouton est le paramètre \argu{nom} qui est donc interprété
+comme une \Helpref{chaîne de caractères}{chaine}, la position du coin supérieur gauche est donnée par le paramètre
+\argu{affixe} qui doit être de la forme X+i*Y avec X et Y \Mytextbf{entiers} car ce sont des coordonnées en
+\Mytextbf{pixels}, la taille du bouton est donnée par le paramètre \argu{taille} qui doit être de la forme
+\textit{long+i*haut} où \textit{long} désigne la longueur du bouton en pixels et \textit{haut} la hauteur (ce sont donc
+des entiers), le paramètre \argu{commande} est interprété comme une chaîne de caractères, c'est la commande associée au
+bouton, chaque clic provoquera l'exécution de cette commande. Le dernier paramètre \argu{aide} est facultatif, il
+contient le message de la bulle d'aide s'affichant lorsque la souris passe au-dessus du bouton.
+
+Si on crée un bouton dont le numéro d'identification est déjà pris, alors l'ancien bouton est détruit \Mytextbf{sauf si
+c'est un bouton prédéfini} (c'est à dire créé au démarrage). \`A chaque changement de fichier, les boutons non
+prédéfinis sont détruits. La fonction \Mytextbf{NewButton} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{NewGraph}\label{cmdNewGraph}
+
+\begin{itemize}
+\item \util \textbf[NewGraph()]{NewGraph( <chaîne1>, <chaîne2> [, code] )}.
+
+\item \desc cette fonction crée un élément graphique \textsl{Utilisateur} ayant pour nom: \argu{chaîne1} et défini par
+la commande: \argu{chaîne2}. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction
+renvoie la valeur \Nil. S'il existait déjà un élément graphique portant le même nom, alors celui-ci est écrasé.
+L'élément graphique est créé mais non dessiné, c'est la fonction \textsl{ReDraw()} qui permet de mettre l'affichage à
+jour.
+
+Le troisième paramètre \argu{code} est un entier positif (optionnel), un clic gauche avec la souris sur l'élément
+graphique créé dans la liste des éléments graphiques, provoquera l'exécution de la macro spéciale \textsl{ClicGraph(
+<code> )}, cette macro n'existe pas par défaut et peut-être créée par l'utilisateur, elle est utilisée en particulier
+dans le fichier modèle \textit{Mouse.mod} (dessin à la souris).
+
+\item Supposons que l'utilisateur clique sur le point d'affixe 1+i, alors une fenêtre de dialogue s'ouvre avec le
+message \textsl{Label=} et une ligne de saisie à remplir. Supposons que l'utilisateur entre la chaîne \textsl{Test} et
+valide, alors la macro va créer un élément graphique \textsl{utilisateur} portant le nom \textsl{Label1} et défini par
+la commande \co{Label(1+i,"Test")}.
+
+\item On peut aussi utiliser la macro prédéfinie \textsl{NewLabel} et définir la macro \textsl{ClicG()}
+en écrivant simplement: \co{NewLabel(\%1) }.
+
+\item \exem voici une macro \textsl{ClicG()} permettant la création "à la volée" de labels, on a créé auparavant
+ une variable globale \textsl{num} initialisée à 1:
+\end{itemize}
+
+\begin{verbatim}
+ if Input("Label=")
+ then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ),
+ ReDraw(), Inc(num,1)
+ fi
+\end{verbatim}
+
+\section{NewItem}\label{cmdNewItem}
+
+\begin{itemize}
+\item \util \textbf[NewItem()]{NewItem( <nom>, <commande> )}.
+\item \desc cette fonction ajoute dans la liste déroulante de la zone grisée à gauche dans la fenêtre, un item appelé
+\argu{nom}, le deuxième paramètre \argu{commande} est la commande associée à l'item, chaque sélection de l'item
+provoquera l'exécution de cette commande. Les deux arguments sont interprétés comme des chaînes de caractères. S'il
+existe déjà un item portant le même nom, alors l'ancien est détruit \Mytextbf{sauf si c'est un item prédéfini} (c'est à
+dire créé au démarrage). À chaque changement de fichier, les items non prédéfinis sont détruits. La fonction
+\textsl{NewItem} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{NewMac}\label{cmdNewMac}
+
+\begin{itemize}
+\item \util \textbf[NewMac()]{NewMac( <nom>, <corps> [, param1, $\ldots$, paramN])}.
+\item \desc cette fonction crée une macro appelée \argu{nom} et dont le contenu est \argu{corps}. Les deux arguments
+sont donc interprétés comme des chaînes de caractères. Les paramètres optionnels sont des noms de variables, le nom de
+la variable \argu{param1} est remplacé dans l'expression de la macro par le paramètre \%1, le nom \argu{param2} est
+remplacé par \%2 $\ldots$ etc. Cette fonction renvoie la valeur \Nil. S'il existait déjà une macro portant le même nom,
+alors celui-ci est écrasée \Mytextbf{si elle n'est pas prédéfinie}. Si le nom n'est pas valide, ou s'il y a déjà une
+macro prédéfinie portant ce nom, ou si l'expression \argu{corps} n'est pas correcte, alors la fonction est sans effet.
+\end{itemize}
+
+\section{NewVar}\label{cmdNewVar}
+\begin{itemize}
+\item \util \textbf[NewVar()]{NewVar( <nom>, <expression> )}.
+\item \desc cette fonction crée une variable globale appelée \argu{nom} et dont la valeur est \argu{expression}. Les
+deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil. S'il
+existait déjà une variable portant le même nom, alors celle-ci est écrasée. Si le nom n'est pas valide, ou s'il y a déjà
+une constante portant ce nom, alors la fonction est sans effet. Si \argu{expression} n'est pas correcte, alors la valeur
+affectée à la variable sera \Nil.
+\end{itemize}
+
+
+\section{Nops}\label{cmdNops}
+\begin{itemize}
+\item \util \textbf[Nops()]{Nops( <liste> )}.
+\item \desc cette fonction évalue \argu{liste} et renvoie le nombre de complexes qui la composent.
+\item \exem \co{Nops([1,2,3] )} renvoie la valeur \res{3}.
+\end{itemize}
+
+\section{NotXor}\label{cmdNotXor}
+
+\begin{itemize}
+\item \util \textbf[NotXor()]{NotXor( <element1>, ..., <elementN> )}.
+\item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode normal, ce qui correspond à la valeur
+0 de la variable \Helpref{PenMode}{cmdPenMode}. Elle change le mode des éléments graphiques \argu{element1}, ...,
+\argu{elementN} en mode NotXor puis les recalcule, et elle renvoie la valeur \Nil.
+
+Lorsqu'on redessine un élément graphique qui est en mode NotXor, il s'efface en restituant le fond, on peut alors
+modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous
+les autres (ce qui évite d'avoir une image qui saute).
+\item\exem voir la fonction \Helpref{Move}{cmdMove}.
+\end{itemize}
+
+\section{OpenFile}\label{cmdOpenFile}
+
+\begin{itemize}
+\item \util \textbf[OpenFile()]{OpenFile( <nom fichier> )}.
+\item \desc cette fonction permet d'ouvrir un fichier texte en écriture. ATTENTION: s'il existe un fichier du même nom,
+alors celui-ci sera écrasé.
+
+En combinaison avec les commandes \Helpref{WriteFile}{cmdWriteFile} et \Helpref{CloseFile}{cmdCloseFile}, cela permet à
+l'utilisateur de créer ses propres fichiers textes.
+\end{itemize}
+
+
+\section{OriginalCoord}\label{cmdOriginalCoord}
+
+\begin{itemize}
+\item \util \Mytextbf{OriginalCoord( <0/1> )} ou \textbf[OriginalCoord()]{OriginalCoord()}
+\item \desc cette fonction détermine si le repère à l'exportation en \textit{pstricks} et \textit{tikz/pgf} est
+identique à celui de l'écran (ce qui correspond à la valeur 1 de l'argument, valeur par défaut), ou non. Lorsque la
+valeur de l'argument est nulle, le repère à l'exportation (\textit{pstricks} et \textit{tikz/pgf}) aura son origine en
+bas à gauche et l'unité sera le cm sur les deux axes. Cela est utile lorsqu'on travaille dans des répères où certaines
+valeurs numériques ne sont plus acceptées par \TeX.
+
+Lorsque l'argument vaut 1, les coordonnées des points dans le fichier exporté sont les mêmes qu'à l'écran.
+
+Lorsque l'argument vaut 0, les coordonnées dans le fichier exporté (tex, pst, tikz/pgf) du point d'affixe z à l'écran,
+sont x=Re(TexCoord(z)) et y=Im(TeXCoord(z)) (et EpsCoord à la place de TeXCoord pour l'export eps).
+
+Lorsque l'argument est vide, la fonction renvoie l'état actuel du repère à l'exportation (0 ou 1). Sinon, elle renvoie
+la valeur \Nil.
+\end{itemize}
+
+\section{PermuteWith}\label{cmdPermuteWith}
+
+\begin{itemize}
+\item \util \textbf[PermuteWith()]{PermuteWith( <liste d'index>, <liste à permuter>, [, taille des paquets ou jump] )}
+\item \desc la \argu{liste à permuter} doit être une variable, celle-ci sera permutée selon le \argu{liste d'index} qui
+est une liste d'entiers strictement positifs. La \argu{liste à permuter} est traitée par composante si elle contient
+la constante \jump, et les éléments de chaque composante sont traités par paquets (de $1$ par défaut) ou par
+composante entière (une composante se termine par \jump), la liste est donc modifiée.
+\item \exem:
+\begin{itemize}
+\item \co{[L:=[-1,0,3,5], PermuteWith([4,3,2,1], L), L]} renvoie \res{[5,3,0,-1]}.
+\item \co{[L:=[-1,0,3,5], PermuteWith([4,3,4,1], L), L]} renvoie \res{[5,3,5,-1]}.
+\item \co{[L:=[-1,0,3,5,6,7,8], PermuteWith([4,3,2,1], L, 2), L]} renvoie \res{[6,7,3,5,-1,0]}.
+\item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8,jump], PermuteWith( [4,3,3,1,2], L, jump), L]} renvoie
+\res{[8,jump,5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}.
+\item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8], PermuteWith([4,3,3,1,2], L, jump), L]} renvoie
+\res{[5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}.
+\item \co{[L:=[-1,1,5,jump,0,3,jump,5,6,7,jump,8,9], PermuteWith( [2,1], L), L]} renvoie
+\res{[1,-1,jump,3,0,jump,6,5,jump,9,8]}.
+\end{itemize}
+\end{itemize}
+
+\section{ReadData}\label{cmdReadData}
+
+\begin{itemize}
+\item \util \textbf[ReadData()]{ReadData( <fichier> [, type de lecture, séparateur] )}.
+\item \desc cette fonction ouvre un \argu{fichier} texte en lecture, celui-ci est supposé contenir une ou plusieurs
+listes de valeurs numériques. Le premier argument est interprété comme une \Helpref{chaîne de caractères}{chaine} qui
+contient le nom du fichier (plus éventuellement son chemin). L'argument (optionnel) suivant \argu{type de lecture} est
+une valeur numérique qui peut valoir:
+\begin{itemize}
+\item \argu{type de lecture}=1: la fonction lit le fichier réel par réel et renvoie la liste ou les listes lues:
+\verb|[x1, x2, ...]|,
+\item \argu{type de lecture}=2: La fonction lit le fichier complexe par complexe, c'est à dire \Mytextbf{par paquets de
+deux réels} et renvoie la ou les listes lues sous forme d'affixes: \verb|[x1+i*x2, x3+i*x4, ...]|. C'est la valeur par
+défaut,
+\item \argu{type de lecture}=3: La fonction lit le fichier par paquet de 3 réels (points de l'espace ou point3D) et
+renvoie la ou les listes lues sous la forme: \verb|[x1+i*x2, x3, x4+i*x5, x6, ...]|.
+\end{itemize}
+
+Le troisième argument \argu{séparateur}, est interprété comme une chaîne, il est supposé contenir le caractère servant à
+indiquer la fin de liste, entre deux listes la constante \jump sera insérée, cet argument est facultatif et par défaut
+il n'y a pas de séparateur (ce qui fait donc une seule liste). Lorsque le séparateur est la fin de ligne dans le
+fichier, on utilisera la chaîne \co{"LF"} (\textit{line feed}) en troisième paramètre. Lorsqu'il y a un séparateur et
+lorsque la lecture se fait par paquet de 2 ou 3 réels, un paquet non \og complet\fg\ est ignoré.
+\item \exem supposons qu'un fichier texte \textit{test.dat} contienne exactement ceci:
+
+\begin{verbatim}
+1 2 3 4 5/ 6
+7 8 9 10 11/ 12
+13 14 15 16 17/ 18
+\end{verbatim}
+
+alors l'exécution de:
+ \begin{itemize}
+ \item \co{ReadData("test.dat")} donne: \res{[1+2*i,3+4*i,5+6*i,7+8*i,9+10*i,11+12*i,13+14*i,15+16*i,17+18*i]},
+ \item \co{ReadData("test.dat",1,"/")} donne:
+\res{[1,2,3,4,5,jump,6,7,8,9,10,11,jump,12,13,14,15,16,17,jump,18]},
+ \item \co{ReadData("test.dat",2,"/")} donne:
+\res{[1+2*i,3+4*i,jump,6+7*i,8+9*i,10+11*i,jump,12+13*i,14+15*i,16+17*i,jump]},
+ \item \co{ReadData("test.dat",3,"/")} donne:
+\res{[1+2*i,3,jump,6+7*i,8,9+10*i,11,jump,12+13*i,14,15+16*i,17,jump]},
+ \item \co{ReadData("test.dat",3,"LF")} donne:
+\res{[1+2*i,3,4+5*i,6,jump,7+8*i,9,10+11*i,12,jump,13+14*i,15,16+17*i,18,jump]}.
+ \end{itemize}
+\end{itemize}
+
+
+\section{ReadFlatPs}\label{cmdReadFlatPs}
+
+\begin{itemize}
+\item \util \textbf[ReadFlatPs()]{ReadFlatPs( <fichier> )}.
+\item \desc cette fonction ouvre un \argu{fichier} en lecture, celui-ci est censé être un fichier écrit en
+\textit{flattened postscript}. La fonction renvoie la liste des chemins contenus dans le fichier, le premier complexe de
+la liste est \textit{largeur+i*hauteur} en cm, puis le premier complexe de chaque chemin est \textit{Color+i*Width}.
+Chaque chemin se termine par un \jump dont la partie imaginaire est un enter négatif: $-1$ pour eofill, $-2$ pour fill,
+$-3$ pour stroke et $-4$ pour clip.
+
+Il est possible de transformer un fichier pdf ou un fichier postscript en \textit{flattened postscript} grâce à
+l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). La macro \Helpref{{conv2FlatPs}}{macconv2FlatPs} permet
+cette conversion en supposant que l'utilitaire est installé sur votre système.
+
+La fonction \textsl{ReadFlatPs} est surtout utilisée en interne par la macro \Helpref{{loadFlatPs}}{macloadFlatPs} qui
+en plus du chargement, adpate les coordonnées des points avant de renvoyer à son tour la liste des chemins que l'on peut
+alors dessiner avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}.
+
+Ce système est utilisé par la macro \Helpref{{NewTeXLabel}}{macNewTeXlabel} pour récupérer les formules TeX compilées.
+\end{itemize}
+
+
+\section{ReCalc}\label{cmdReCalc}
+
+\begin{itemize}
+\item \util \Mytextbf{ReCalc( <nom1>, ..., <nomN> )} ou \textbf[ReCalc()]{ReCalc()}.
+\item \desc cette fonction force le recalcul des éléments graphiques dont les noms sont dans la liste même si ceux-ci
+ne sont pas en mode \textsl{Recalcul Automatique}. Si la liste est vide (\textsl{ReCalc()}) alors tout le graphique est
+recalculé. Après le recalcul l'affichage est mis à jour et la fonction renvoie \Nil.
+\end{itemize}
+
+\Mytextbf{Attention}: l'utilisation de \textsl{ReCalc()} dans un élément graphique entraîne une récursion infinie et
+donc un plantage du programme!
+
+\section{ReDraw}\label{cmdReDraw}
+
+\begin{itemize}
+\item \util \Mytextbf{ReDraw( <nom1>, ..., <nomN> )} ou \textbf[ReDraw()]{ReDraw()}.
+\item \desc cette fonction (re)dessine les éléments graphiques dont les noms sont dans la liste. Si la liste est vide
+(\textsl{ReDraw()}) alors tous les élments sont redessinés. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{RenCommand}\label{cmdRenCommand}
+
+\begin{itemize}
+\item \util \textbf[RenCommand()]{RenCommand( <nom>, <nouveau> )}.
+\item \desc cette fonction renomme la commande appelée \argu{nom}. Les deux arguments sont donc interprétés comme des
+chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas
+de commande portant ce \argu{nom}, ou s'il a déjà une commande portant le nom \argu{nouveau}, alors la fonction est sans
+effet.
+\end{itemize}
+
+\section{RenMac}\label{cmdRenMac}
+
+\begin{itemize}
+\item \util \textbf[RenMac()]{RenMac( <nom>, <nouveau> )}.
+\item \desc cette fonction renomme la macro appelée \argu{nom}. Les deux arguments sont donc interprétés comme des
+chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas
+de macro portant ce \argu{nom}, ou s'il a déjà une macro portant le nom \argu{nouveau}, alors la fonction est sans
+effet.
+\end{itemize}
+
+
+\section{RestoreAttr}\label{cmdRestoreAttr}
+
+\begin{itemize}
+\item \util \textbf[RestoreAttr()]{RestoreAttr()}.
+\item \desc restaure l'ensemble des attributs sauvegardés dans une pile par la commande \Helpref{SaveAttr}{cmdSaveAttr}.
+\end{itemize}
+
+
+\section{Reverse}\label{cmdReverse}
+\begin{itemize}
+\item \util \textbf[Reverse()]{Reverse( <liste> )}.
+\item \desc renvoie la \argu{liste} inversée.
+\end{itemize}
+
+\section{Rgb}\label{cmdRgb}
+
+\begin{itemize}
+\item \util \textbf[Rgb()]{Rgb( <rouge>, <vert>, <bleu> )}.
+\item \desc cette fonction renvoie un entier représentant la couleur dont les trois composantes sont \argu{rouge},
+\argu{vert} et \argu{bleu}, ces trois valeurs doivent être des nombres \Mytextbf{compris entre 0 et 1}. Voir aussi la
+commande \Helpref{HexaColor}{cmdHexaColor}.
+\item \exem \co{Color:= Rgb(0.5,0.5,0.5))} sélectionne le gris.
+\end{itemize}
+
+\section{SaveAttr}\label{cmdSaveAttr}
+
+\begin{itemize}
+\item \util \textbf[SaveAttr()]{SaveAttr()}.
+\item \desc sauvegarde sur une pile l'ensemble des attributs courants. Voir aussi \Helpref{RestoreAttr}{cmdRestoreAttr}.
+\end{itemize}
+
+
+\section{Seq}\label{cmdSeq}
+
+\begin{itemize}
+\item \util \textbf[Seq()]{Seq( <expression>, <variable>, <départ>, <fin> [, pas] )}.
+\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable}
+est initialisée à \argu{départ} puis, tant que \argu{variable} est dans l'intervalle (fermé) défini par \argu{départ}
+et \argu{fin}, on évalue \argu{expression} et on incrémente \argu{variable} de la valeur de \argu{pas}. Le pas peut être
+ négatif mais il doit être non nul. Lorsqu'il n'est pas spécifié, sa valeur par défaut est 1. Lorsque \argu{variable}
+sort de l'intervalle, la boucle s'arrête et la fonction \textsl{Seq} renvoie la liste des résultats. Cette commande est
+la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont l'utilisation est préférable pour des raisons de
+lisibilité.
+\item \exem \co{Seq(exp(i*k*pi/5,k,1,5)} renvoie la liste des racines cinquièmes de l'unité. La commande:
+
+\centerline{\co{Ligne( Seq( exp(2*i*k*pi/5, k, 1, 5), 1)}}
+
+renverra la valeur \Nil mais dessinera un pentagone (voir \Helpref{Ligne}{cmdLigne}) si elle est utilisée dans un
+élément graphique \textit{utilisateur}.
+\end{itemize}
+
+\section{Set}\label{cmdSet}
+
+\begin{itemize}
+\item \util \textbf[Set()]{Set( <variable>, <valeur> )}.
+\item \desc cette fonction permet d'affecter à \argu{variable}\footnote{Il n'est pas nécessaire de déclarer les
+variables, elles sont implicitement locales et initialisées à \Nil sauf si c'est le nom d'une variable globale ou d'une
+constante prédéfinie (comme i, $\pi$, e, ...).} la \argu{valeur} spécifiée. La fonction \textsl{Set} renvoie la valeur
+\Nil.
+
+Cette commande est la représentation interne de l'affectation \textsl{:=}, dont l'utilisation est préférable pour des
+raisons de lisibilité.
+\end{itemize}
+
+\section{SetAttr}\label{cmdSetAttr}
+
+\begin{itemize}
+\item \util \textbf[SetAttr()]{SetAttr()}.
+\item \desc cette fonction n'a d'effet que dans un élément graphique Utilisateur. Elle permet d'affecter aux attributs
+de l'élément la valeur des attributs actuellement en cours. La fonction \textsl{SetAttr} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{SetMatrix}\label{cmdSetMatrix}
+
+\begin{itemize}
+\item \util \textbf[SetMatrix()]{SetMatrix( <[z1, z2, z3]> )}.
+\item \desc cette fonction permet de modifier la matrice courante (celle-ci affecte tous les éléments graphiques sauf
+les axes et les grilles dans la version actuelle). Cette matrice représente l'expression analytique d'une application
+affine du plan, c'est une liste de trois complexes: $z1$ qui est l'affixe du vecteur de translation, $z2$ qui est
+l'affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et $z3$ qui est l'affixe du
+deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l'identité s'écrit ainsi:
+[0,1,i] (c'est la matrice par défaut). (Voir aussi les commandes \Helpref{GetMatrix}{cmdGetMatrix},
+\Helpref{ComposeMatrix}{cmdComposeMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix})
+
+\item \exem si $f:z \mapsto f(z)$ est une application affine, alors sa matrice est $[f(0), f(1)-f(0), f(i)-f(0)]$, ce
+calcul peut-être fait par la macro \textit{matrix()} de TeXgraph.mac: \co{SetMatrix(matrix(i*bar(z)))} affecte la
+matrice de la symétrie orthogonale par rapport à la première bissectrice.
+\end{itemize}
+
+
+\begin{demo}{Repère non orthogonal}{SetMatrix}
+\begin{texgraph}[name=SetMatrix, export=pgf]
+view(-5,5,-3,3), size(7.5),
+SetMatrix([0,1,1+i]), axes(0,1+i),
+tMin:=-5, tMax:=5,
+Color:=red, Width:=8, Cartesienne(2*sin(x)),
+Color:=black, Arrows:=2,
+tangente(2*sin(x), pi/2, 1.5),
+Arrows:=0, LineStyle:=dotted,
+Ligne( [2*i,pi/2+2*i, pi/2], 0),
+Point(pi/2+2*i),
+LabelDot( pi/2, "$\frac{\pi}2$","S",1),
+IdMatrix()
+\end{texgraph}
+\end{demo}
+
+
+\section{Show}\label{cmdShow}
+
+\begin{itemize}
+\item \util \textbf[Show()]{Show( <element1>, ..., <elementN> )}.
+\item \desc Cette fonction permet de montrer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en
+mettant leur attribut \textsl{IsVisible} à true. Les arguments sont interprétés comme des chaînes de caractères. Cette
+fonction renvoie la valeur \Nil. Pour tout montrer on invoque la commande sans arguments: \textsl{Show()}. Pour tout
+montrer sauf un ou plusieurs éléments, on invoque la commande: \co{Show(except, element1, ..., elementN)}. Voir aussi la
+commande \Helpref{Hide}{cmdHide}.
+\end{itemize}
+
+
+\section{Si}\label{cmdSi}
+
+\begin{itemize}
+\item \util \textbf[Si()]{Si( <condition1>, <expression1>, ..., <conditionN>, <expressionN> [, sinon] )}.
+\item \desc cette fonction évalue \argu{condition1}. Une condition est une expression dont le résultat de l'évaluation
+doit être 0 [pour \textit{False}] ou 1 [pour \textit{True}], sinon il y a un échec et la fonction renvoie la valeur
+\Nil. Si la condition donne la valeur 1 alors la fonction évalue \argu{expression1} et renvoie le résultat, si elle vaut
+0, elle évalue \argu{condition2}, si celle-ci donne la valeur 1 alors la fonction évalue \argu{expression2}, sinon
+etc... Lorsqu'aucune condition n'est remplie, la fonction évalue l'argument \argu{sinon}, s'il est présent, et renvoie
+le résultat, sinon la fonction renvoie \Nil. Cette commande est la représentation interne de l'alternative
+\Helpref{{if}}{cmdif} dont la syntaxe est préférable pour des raisons de lisibilité.
+
+\item \exem définition d'une macro \co{f(x)} représentant une fonction f d'une variable x
+définie en plusieurs morceaux:
+
+\centerline{\co{Si(\%1<-1,1-exp(pi*(\%1+1)),\%1<0,sin($\pi$*\%1),sh(pi*\%1))},}
+
+c'est à dire $f(x)=1-exp(\pi(x+1))$ si $x<-1$, $f(x)=sin(\pi x)$ si $-1\leqslant x<0$, $f(x)=$sh$(\pi x)$ sinon.
+
+\end{itemize}
+
+
+\section{Solve}\label{cmdSolve}
+
+\begin{itemize}
+\item \util \textbf[Solve()]{Solve( <expression>, <variable>, <borne inf.>, <borne sup.> [, n] )}.
+\item \desc cette fonction "résout" l'équation \argu{expression}=0 par rapport à la variable \Mytextbf{réelle}
+\argu{variable} dans l'intervalle défini par \argu{borne inf.} et \argu{borne sup.}. Cet intervalle est subdivisé en
+\argu{n} parties [par défaut n=25] et on utilise la méthode de {\sc Newton} sur chaque partie. La fonction renvoie la
+liste des résultats.
+\item \exem
+\begin{itemize}
+ \item \co{Solve(sin(x), x, -5, 5)} donne \res{[-3.141593, 0, 3.141593]}.
+
+ \item Équation: $\displaystyle \int_0^x \exp(t^2)dt=1$: \co{Solve(Int( exp(u\^{}2),u,0,x)-1, x, 0, 1)} donne
+\res{0.795172} et l'exécution de \co{Int(exp(u\^{}2), u, 0, 0.795172)} donne \res{1}.
+
+ \item \co{Solve( $x^2+x+1$, x, -1, 1)} renvoie \Nil.
+ \end{itemize}
+\end{itemize}
+
+\section{Sort}\label{cmdSort}
+
+\begin{itemize}
+\item \util \textbf[Sort()]{Sort( <liste de complexes> [, option] )}.
+\item \desc cette fonction trie la liste passée en argument dans l'ordre lexicographique, si l'argument \argu{option}
+vaut 0 (valeur par défaut), ou dans l'ordre lexicographique inverse si l'argument \argu{option} vaut 1. Cette liste doit
+être une variable, et celle-ci sera modifiée. Si la liste contient la constante \jump alors celle-ci est recopiée telle
+quelle dans le résultat, et les \og composantes connexes\fg\ de la liste sont triées indépendamment les unes des autres.
+La fonction renvoie la valeur \Nil.
+\item \exem si la variable \textsl{L} contient la liste \res{[-2,-3+i,1,1-2*i, jump, 3,5,-6]} alors après l'exécution
+de \co{Sort(L)}, la variable contiendra la liste \res{[-3+i,-2,1-2*i,1,jump,-6,3,5]}, et après l'exécution de
+\co{Sort(L,1)}, la variable contiendra la liste \res{[1,1-2*i,-2,-3+i,jump,5,3,-6]}. La méthode utilisée est le Quick
+Sort..
+\end{itemize}
+
+\section{Special}\label{cmdSpecial}
+
+\begin{itemize}
+\item \util \textbf[Special()]{Special( <chaîne> )}.
+\item \desc cette fonction n'aura d'effet que dans un élément graphique Utilisateur (comme les fonctions graphiques).
+L'argument doit être une chaîne de caractères (délimitée par " et "), si cette chaîne contient les balises \verb|\[|,
+et \verb|\]|, alors tout le texte contenu entre ces deux balises est interprété par TeXgraph et le résultat est replacé
+dans la chaîne. Puis cette chaîne sera écrite telle quelle dans le fichier d'exportation (c'est en fait un Label créé
+avec LabelStyle= special).
+\item \exem \co{Special("\bks psdot(\bks[1+\bks],\bks[2\^{}3\bks] )")}, écrira dans le fichier exporté: \res{\bks
+psdot(2,8)}.
+\end{itemize}
+
+\section{Str}\label{Str}
+
+\begin{itemize}
+\item \util \textbf[Str()]{Str( <nom de macro> )}.
+\item \desc lors d'une évaluation alphanumérique, cette fonction renvoie la définition de la macro appelée \argu{nom de
+macro} (sauf si c'est une macro prédéfinie). En dehors de ce contexte, la fonction \textsl{Str} renvoie \Nil. L'argument
+\argu{nom de macro} est lui-même interprété comme une chaîne de caractères.
+\item \exem supposons que la macro \co{f} soit définie par \co{\%1+i*sin(\%1)}, alors la commande
+\co{Label(0,["f(\%1)=",Str("f")] )} affichera à l'écran à l'affixe 0, le texte: \res{f(\%1)=\%1+i*sin(\%1)}.
+\end{itemize}
+
+\section{StrArgs}\label{cmdStrArgs}
+
+\begin{itemize}
+\item \util \textbf[StrArgs()]{StrArgs( <entier> )}.
+\item \desc cette fonction n'a d'effet que dans une macro, elle renvoie l'argument numéro \argu{entier} avec lequel la
+macro a été appelée, sous forme d'une chaîne. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la
+commande \Helpref{Args}{cmdArgs}
+\item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}.
+\end{itemize}
+
+\section{StrComp}\label{cmdStrComp}
+
+\begin{itemize}
+\item \util \textbf[StrComp()]{StrComp( <chaîne1>, <chaîne2> )}.
+\item \desc les deux arguments sont interprétés comme une chaîne de caractères, et les deux chaînes sont comparées, si
+elles sont égales alors la fonction renvoie la valeur 1, sinon la valeur 0.
+\item \exem la combinaison de touches: Ctrl+Maj+<lettre> lance automatiquement l'exécution de la macro spéciale:
+\textsl{ OnKey( <lettre> )}. L'utilisateur peut définir cette macro avec par exemple la commande:
+
+\centerline{\co{if StrComp(\%1, "A") then Message("Lettre A") fi}}
+\end{itemize}
+
+\section{String}\label{cmdString}
+
+\begin{itemize}
+\item \util \textbf[String()]{String( <expression mathématique> )}.
+\item \desc lors d'une évaluation alphanumérique, cette fonction renvoie \argu{expression mathématique} sous forme d'une
+chaîne. En dehors de ce contexte, la fonction \textsl{String} renvoie \Nil.
+\end{itemize}
+
+\section{Stroke}\label{cmdStroke}
+
+\begin{itemize}
+\item \util \textbf[Stroke()]{Stroke( <element1>, ..., <elementN> )}.
+
+\item \desc cette fonction recalcule les éléments graphiques \argu{element1}, ..., \argu{elementN}, puis les redéssine
+en mode NORMAL, et renvoie la valeur \Nil.
+
+\item\exem on a créé deux variables globales: $a$ et \textit{drawing}. On va créer le cercle de centre a et de rayon 1,
+appelé \textsl{objet1}, on souhaite pouvoir déplacer cet objet à la souris. Pour cela, on crée la macro \textsl{ClicG}
+avec la commande:
+\end{itemize}
+
+\begin{verbatim}
+ [PenMode:=1, {mode NotXor}
+ NewGraph("objet1", "Cercle(a,1)"),
+ PenMode:=0, {mode normal}
+ ReDraw(), {on montre}
+ drawing:=1]
+\end{verbatim}
+
+on crée la macro \res{MouseMove} avec la commande: \co{if drawing then a:=\%1 \{on déplace le centre\}, Move(objet1)
+fi},
+
+puis la macro \res{LButtonUp} avec la commande: \co{if drawing then Stroke(objet1), drawing:=0 fi}.
+
+La macro \textsl{ClicG} crée l'objet1 en mode NotXor, rafraîchit l'affichage graphique et passe en mode "dessin". La
+macro \textsl{ MouseMove} permet de placer le centre à la position de la souris, puis de déplacer l'objet1. Lorsque le
+bouton gauche est relâché, on dessine l'objet1 en mode normal, puis on quitte le mode "dessin".
+
+
+\section{TeX2FlatPs}\label{cmdTeX2FlatPs}
+
+\begin{itemize}
+\item \util \textbf[TeX2FlatPs()]{TeX2FlatPs( <"formule"> [, dollar(0/1)] )}.
+
+\item \desc cette renvoie une \argu{formule} \TeX{} sous forme d'une liste de chemins, le résultat doit être dessiné
+avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}. La \argu{formule} est écrite dans un fichier appelé
+\textit{formula.tex}. Ce fichier est appelé par le fichier \textit{formule.tex} qui se trouve dans le dossier de
+travail de TeXgraph, pour être compilé par \TeX{}. Si l'option \argu{dollar} vaut $1$ alors la formule sera délimitée
+par \verb|\]| et \verb|\]|, sinon elle est écrite telle quelle. Pour plus de renseignements sur la façon dont sont
+récupérés ces chemins, voir la commande \Helpref{{ReadFlatPs}}{cmdReadFlatPs}.
+\end{itemize}
+
+
+\section{Timer}\label{cmdTimer}
+
+\begin{itemize}
+\item \util \textbf[Timer()]{Timer( <milli-secondes> )}.
+
+\item \desc règle l'intervalle de temps pour le timer, celui exécute régulièrement une certaine macro (que l'on peut
+définir avec la commande TimerMac). Pour stopper le timer il suffit de régler l'intervalle de temps à 0.
+\end{itemize}
+
+\section{TimerMac}\label{cmdTimerMac}
+
+\begin{itemize}
+\item \util \textbf[TimerMac()]{TimerMac( <corps de la macro à exécuter> )}.
+
+\item \desc cette commande permet de créer une macro qui sera attachée au timer. L'argument est interprété comme une
+chaîne de caractères et doit correspondre au corps de la macro (celle-ci sera appélée TimerMac). Pour des raisons de
+performances, il est préférable d'éviter trop d'appels à d'autres macros dans celle-ci. Cette fonction renvoie la valeur
+1 si la macro est correctement définie, 0 en cas d'erreur. Attention, l'exécution de TimerMac ne déclenche pas le timer!
+Il faut utiliser la commande Timer pour cela.
+
+\item \exem soit $A$ une variable globale (un point), soit \textit{dotA} un élément graphique qui dessine le point,
+voilà une commande qui déplace $A$:
+
+\centerline{
+\co{[TimerMac("[Inc(A,0.1), if Re(A)>5 then Timer(0) else ReCalc(dotA) fi]"), A:=-5, Timer(10)]}}
+\end{itemize}
+
+\section{VisibleGraph}\label{cmdVisibleGraph}
+
+\begin{itemize}
+\item \util \Mytextbf{VisibleGraph( <0/1> )} ou \textbf[VisibleGraph()]{VisibleGraph()}.
+
+\item \desc cette fonction permet d'activer ou désactiver la zone de dessin dans l'interface graphique. Lorsque
+celle-ci est désactivée, son contenu ne change plus car il n'y a plus de mise à jour de la zone. Désactiver l'affichage
+graphique peut permettre dans certains cas un gain de temps pour enregistrer une animation par exemple.
+
+Lorsque l'argument est vide, la fonction renvoie simplement l'état actuel de l'affichage graphique (0 ou 1). Sinon, elle
+renvoie \Nil.
+\end{itemize}
+
+
+\section{WriteFile}\label{cmdWriteFile}
+
+\begin{itemize}
+\item \util \textbf[WriteFile()]{WriteFile( <argument> )}.
+
+\item \desc cette fonction permet d'écrire soit dans le fichier texte ouvert par la commande
+\Helpref{OpenFile}{cmdOpenFile}, soit dans le fichier d'exportation si l'exécution de cette commande a lieu pendant une
+exportation par l'intermédiare des macros \Helpref{Bsave}{macBsave} et/ou \Helpref{Esave}{macEsave}.
+
+\item \exem voici ce que pourrait être la macro \textsl{Bsave} pour modifier la taille des flêches en pstricks:
+\end{itemize}
+
+\begin{verbatim}
+ if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi
+\end{verbatim}
--- /dev/null
+<h1 id="les-macros-mathématiques-de-texgraph.mac">Les macros mathématiques de TeXgraph.mac</h1>
+<h2 id="opérations-arithmétiques-et-logiques">Opérations arithmétiques et logiques</h2>
+<h3 id="Ceil">Ceil</h3>
+<ul>
+<li><p><b>Ceil( <x> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le plus petit entier supérieur ou égal au réel <<em>x</em>>.</p></li>
+</ul>
+<h3 id="div">div</h3>
+<ul>
+<li><p><b>div( <x>, <y> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie l’unique entier <span class="math"><em>k</em></span> tel que <span class="math"><em>x</em> - <em>k</em><em>y</em></span> soit dans l’intervalle <span class="math">[0; ∣<em>y</em>∣[</span>.</p></li>
+</ul>
+<h3 id="mod">mod</h3>
+<ul>
+<li><p><b>mod( <x>, <y> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie l’unique réel <span class="math"><em>r</em></span> de l’intervalle <span class="math">[0; ∣<em>y</em>∣[</span> tel que <span class="math"><em>x</em> = <em>k</em><em>y</em> + <em>r</em></span> avec <span class="math"><em>k</em></span> entier.</p></li>
+</ul>
+<h3 id="not">not</h3>
+<ul>
+<li><p><b>not( <expression booléenne> )</b></p></li>
+<li><p><u>Description</u> : renvoie la valeur booléenne de la négation.</p></li>
+</ul>
+<h3 id="pgcd">pgcd</h3>
+<ul>
+<li><p><b>pgcd( <a>, <b> [, <u>, <v>] )</b></p></li>
+<li><p><u>Description</u> : renvoie la valeur d du pgcd de <<em>a</em>> et <<em>b</em>>, ainsi que deux coefficients de Bezout dans les variables <<em>u</em>> et <<em>v</em>> (si celles-ci sont présentes), de telle sorte que <span class="math"><em>a</em><em>u</em> + <em>b</em><em>v</em> = <em>d</em></span>.</p></li>
+</ul>
+<h3 id="ppcm">ppcm</h3>
+<ul>
+<li><p><b>ppcm( <a>, <b> )</b></p></li>
+<li><p><u>Description</u> : renvoie la valeur du ppcm de <<em>a</em>> et <<em>b</em>>.</p></li>
+</ul>
+<h2 id="opérations-sur-les-variables">Opérations sur les variables</h2>
+<h3 id="Abs">Abs</h3>
+<ul>
+<li><p><b>Abs( <affixe> )</b>.</p></li>
+<li><p><u>Description</u> : cette macro donne la norme en cm.</p></li>
+</ul>
+<h3 id="free">free</h3>
+<ul>
+<li><p><b>free( <x> )</b>.</p></li>
+<li><p><u>Description</u> : libère la variable <<em>x</em>> en la mettant à <em>Nil</em>. Depuis la version 1.93 on peut faire directement l’affectation à la constante <em>Nil</em>, par exemple: <span style="color:red">x:=Nil</span>.</p></li>
+</ul>
+<h3 id="IsIn">IsIn</h3>
+<ul>
+<li><p><b>IsIn( <affixe> [, <epsilon>] )</b>.</p></li>
+<li><p><u>Description</u> : renvoie 1 si l’<<em>affixe</em>> est dans la fenêtre graphique, 0 sinon. Cette macro tient compte de la matrice courante, le test se fait à <<em>epsilon</em>> près et <<em>epsilon</em>> vaut 0.0001 cm par défaut.</p></li>
+</ul>
+<h3 id="nil">nil</h3>
+<ul>
+<li><p><b>nil( <x> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie 1 si la variable <<em>x</em>> est à <em>Nil</em>, 0 sinon. Depuis la version 1.93 on peut faire directement le test d’égalité avec la constante <em>Nil</em>.</p></li>
+</ul>
+<h3 id="round">round</h3>
+<ul>
+<li><p><b>round( <liste> [, décimales] )</b></p></li>
+<li><p><u>Description</u> : tronque les complexes de la <<em>liste</em>> en arrondissant au plus proche les parties réelles et imaginaires avec le nombre de <<em>décimales</em>> demandé (0 par défaut). Si la <<em>liste</em>> contient le constante <em>jump</em>, alors celle-ci est renvoyée dans la liste des résultats. Cette macro utilise la commande <a href="#Round">Round</a> (qui ne s’applique qu’à un complexe et non une liste).</p></li>
+</ul>
+<h2 id="opérations-sur-les-listes">Opérations sur les listes</h2>
+<h3 id="bary">bary</h3>
+<ul>
+<li><p><b>bary( <[affixe1, coef1, affixe2, coef2, ...]> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le barycentre du système pondéré <<em>[(affixe1, coef1), (affixe2, coef2),...]</em>>.</p></li>
+</ul>
+<h3 id="del">del</h3>
+<ul>
+<li><p><b>del( <liste>, <liste des index à supprimer>, <quantité à supprimer> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la liste après avoir supprimer les éléments dont l’index figure dans la <<em>liste des index à supprimer</em>>. La <<em>quantité à supprimer</em>> (à chaque fois) est de <span class="math">1</span> par défaut, cet argument peut être une liste lui aussi.</p></li>
+<li><p><u>Exemple(s)</u> : </p>
+<ul>
+<li><p><span style="color:red">del( [1,2,3,4,5,6,7,8], [2,6,8])</span> donne <span style="color:magenta">[1,3,4,5,7]</span>.</p></li>
+<li><p><span style="color:red">del( [1,2,3,4,5,6,7,8], [2,6,8], 2)</span> donne <span style="color:magenta">[1,4,5]</span>.</p></li>
+<li><p><span style="color:red">del( [1,2,3,4,5,6,7,8], [2,6,8], [1,2])</span> donne <span style="color:magenta">[1,3,4,5]</span>.</p></li>
+<li><p><span style="color:red">del( [1,2,jump,3,4,5,jump,6,7,8],[3,7])</span> donne <span style="color:magenta">[1,2,3,4,5,6,7,8]</span>.</p></li>
+</ul></li>
+</ul>
+<h3 id="getdot">getdot</h3>
+<ul>
+<li><p><b>getdot( <s> , <ligne polygonale> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le point de la <<em>ligne polygonale</em>> ayant <<em>s</em>> comme abscisse curviligne. Le paramètre <<em>s</em>> doit être dans l’intervalle <span class="math">[0; 1]</span>, <span class="math">0</span> pour le premier point, et <span class="math">1</span> pour le dernier.</p></li>
+</ul>
+<h3 id="IsAlign">IsAlign</h3>
+<ul>
+<li><p><b>IsAlign( <liste points 2D> [, epsilon] )</b>.</p></li>
+<li><p><u>Description</u> : renvoie 1 si les points sont sur une même droite, 0 sinon. Par défaut la tolérance <<em>epsilon</em>> vaut 1E-10. La <<em>liste</em>> ne doit pas contenir la constante <em>jump</em>.</p></li>
+</ul>
+<h3 id="isobar">isobar</h3>
+<ul>
+<li><p><b>isobar( <[affixe1, affixe2, ...]> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie l’isobarycentre du système <<em>[affixe1, affixe2, ...]</em>>.</p></li>
+</ul>
+<h3 id="KillDup">KillDup</h3>
+<ul>
+<li><p><b>KillDup( <liste> [, epsilon] )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la liste sans doublons. Les comparaisons se font à <<em>epsilon</em>> près (qui vaut <span class="math">0</span> par défaut).</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">KillDup( [1.255,1.258,jump,1.257,1.256,1.269,jump] ,1.5E-3)</span> renvoie <span style="color:magenta">[1.255,1.258,1.269]</span>.</p></li>
+</ul>
+<h3 id="length">length</h3>
+<ul>
+<li><p><b>length( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : calcule la longueur de la <<em>liste</em>> en cm.</p></li>
+</ul>
+<h3 id="permute">permute</h3>
+<ul>
+<li><p><b>permute( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : modifie la <<em>liste</em>> en plaçant le premier élément à la fin, <<em>liste</em>> doit être une variable.</p></li>
+<li><p>la commande <span style="color:red">[x:= [1,2,3,4], permute(x), x]</span> renvoie <span style="color:magenta">[2,3,4,1]</span>.</p></li>
+</ul>
+<h3 id="Pos">Pos</h3>
+<ul>
+<li><p><b>Pos( <affixe>, <liste>, [, epsilon] )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la liste des positions de l’<<em>affixe</em>> dans la <<em>liste</em>>, la comparaison se fait à <<em>epsilon</em>> près, par défaut <<em>epsilon</em>> vaut 0.</p></li>
+<li><p>la commande <span style="color:red">Pos(2, [1,2,3,2,4])</span> renvoie <span style="color:magenta">[2,4]</span>, mais <span style="color:red">Pos(5, [1,2,3,2,4])</span> renvoie <em>Nil</em>.</p></li>
+</ul>
+<h3 id="rectangle">rectangle</h3>
+<ul>
+<li><p><b>rectangle( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : détermine le plus petit rectangle contenant la liste, cette macro renvoie une liste de deux complexes qui représentent l’affixe du coin inférieur gauche suivi de celle du coin supérieur droit.</p></li>
+</ul>
+<h3 id="replace">replace</h3>
+<ul>
+<li><p><b>replace( <liste>, <position>, <valeur> )</b>.</p></li>
+<li><p><u>Description</u> : modifie la variable <<em>liste</em>> en remplaçant l’élément numéro <<em>position</em>> par la <<em>valeur</em>>, cette macro renvoie <em>Nil</em>.</p></li>
+</ul>
+<h3 id="reverse">reverse</h3>
+<ul>
+<li><p><b>reverse( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un <em>jump</em>).</p></li>
+</ul>
+<h3 id="SortWith">SortWith</h3>
+<ul>
+<li><p><b>SortWith( <liste clés>, <liste>, <taille paquets> [, mode] )</b>.</p></li>
+<li><p><u>Description</u> : trie la <strong>variable</strong> <<em>liste</em>> suivant les <<em>clés</em>>. Les éléments de la <<em>liste</em>> sont traités par <<em>paquets</em>>, leur taille est de 1 par défaut. La <<em>taille paquets</em>> peut être égale à <em>jump</em> pour un traitement par composante. Si un paquet n’est pas complet, il n’est pas traité. Si la liste contient la constante <em>jump</em>, alors toutes les composantes sont triées chacune leur tour. Le dernier paramètre détermine le type de tri: <<em>mode</em>>=0 pour ordre croissant (valeur par défaut), <<em>mode</em>>=1 pour décroissant.</p></li>
+</ul>
+<h2 id="gestion-des-listes-par-composantes">Gestion des listes par composantes</h2>
+<p>La convention adoptée est que deux composantes sont séparées par la constante <em>jump</em>. Une composante peut être vide.</p>
+<h3 id="CpCopy">CpCopy</h3>
+<ul>
+<li><p><b>CpCopy( <liste>, <index depart>, <nombre> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction renvoie la liste constituée par les <<em>nombre</em>> composantes de la <<em>liste</em>> à partir de la composante numéro <<em>depart</em>>[inclus]. Si <<em>nombre</em>> est nul, alors la fonction renvoie toutes les composantes de la liste à partir de la composante numéro <<em>départ</em>>.</p>
+<p>Si le numéro <<em>depart</em>> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la dernière composante a l’index <span class="math"> - 1</span>, l’avant-dernière a l’index <span class="math"> - 2</span> <span class="math">⋯</span> etc. La fonction renvoie les <<em>nombre</em>> composantes de la liste (ou toute la liste si <<em>nombre</em>> est nul) en allant vers la gauche, mais la liste renvoyée est dans le même sens que la <<em>liste</em>>, et cette dernière n’est pas modifiée.</p></li>
+<li><p><u>Exemple(s)</u> : </p>
+<ul>
+<li><p><span style="color:red">CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], 2, 1)</span> renvoie <span style="color:magenta">[3,7,8]</span>.</p></li>
+<li><p><span style="color:red">CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -1, 2)</span> renvoie <span style="color:magenta">[4,jump,5,6]</span>.</p></li>
+<li><p><span style="color:red">CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -3, 0)</span> renvoie <span style="color:magenta">[1,2,jump,3,7,8]</span>.</p></li>
+</ul></li>
+</ul>
+<h3 id="CpDel">CpDel</h3>
+<ul>
+<li><p><b>CpDel( <variable liste>, <index depart>, <nombre> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction détruit dans la <<em>variable liste</em>>, les <<em>nombre</em>> composantes à partir de la composante numéro <<em>depart</em>>[inclus]. Si <<em>nombre</em>> est nul, alors la fonction détruit toutes les composantes de la <<em>variable liste</em>> à partir de la composante numéro <<em>départ</em>>.</p>
+<p>Si le numéro <<em>depart</em>> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la dernière composante a l’index <span class="math"> - 1</span>, l’avant-dernière a l’index <span class="math"> - 2</span> <span class="math">⋯</span> etc. La fonction détruit les <<em>nombre</em>> composantes de la <variable liste> (ou toute la liste si <<em>nombre</em>> est nul) en allant vers la gauche.</p>
+<p>Le paramètre <<em>variable liste</em>> doit être <strong>un nom de variable</strong>, celle-ci est modifiée et la macro renvoie <em>Nil</em>.</p></li>
+</ul>
+<h3 id="CpNops">CpNops</h3>
+<ul>
+<li><p><b>CpNops( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : cette fonction évalue <<em>liste</em>> et renvoie le nombre de composantes qui la composent.</p></li>
+<li><p><u>Exemple(s)</u> : </p>
+<ul>
+<li><p><span style="color:red">CpNops([1,2,jump,3] )</span> renvoie la valeur <span style="color:magenta">2</span>.</p></li>
+<li><p><span style="color:red">CpNops([1,2,jump,3,jump] )</span> renvoie la valeur <span style="color:magenta">3</span>.</p></li>
+<li><p><span style="color:red">CpNops([jump] )</span> renvoie la valeur <span style="color:magenta">2</span>.</p></li>
+</ul></li>
+</ul>
+<h3 id="CpReplace">CpReplace</h3>
+<ul>
+<li><p><b>CpReplace( <variable liste>, <position>, <nouveau> )</b>.</p></li>
+<li><p><u>Description</u> : modifie la <<em>variable liste</em>> en remplaçant la composante numéro <<em>position</em>> par <<em>nouveau</em>>, cette macro renvoie <em>Nil</em>.</p></li>
+</ul>
+<h3 id="CpReverse">CpReverse</h3>
+<ul>
+<li><p><b>CpReverse( <liste> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la <<em>liste</em>> avec les composantes dans l’ordre inverse.</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">CpReverse([1,2,jump,3,4,5,jump])</span> renvoie <span style="color:magenta">[jump,3,4,5,jump,1,2]</span>.</p></li>
+</ul>
+<h2 id="gestion-des-listes-de-chaînes">Gestion des listes de chaînes</h2>
+<p>Une telle liste est en réalité une <strong>macro</strong>, les éléments sont indexés à partir de <span class="math">1</span>, et la chaîne numéro <span class="math"><em>k</em></span> est donnée par <code>@nomListe(k)</code>, alors que la longueur de la liste (nombre d’éléments) est donnée par <code>nomListe(0)</code>.</p>
+<h3 id="StrListInit">StrListInit</h3>
+<ul>
+<li><p><b>StrListInit( <nomListe>, <"chaine1">, <"chaine2">, ... )</b>.</p></li>
+<li><p><u>Description</u> : crée une liste de chaines sous forme d’une macro appelée <<em>nomListe</em>>, les arguments suivants sont interprétés comme des chaînes, ils constituent les éléments de la liste et sont indexés à partir de 1.</p></li>
+<li><p><u>Exemple(s)</u> : Après la commande <span style="color:red">StrListInit(essai, "toto", ["toto",2/4], 24)</span>, une macro du nom de <strong>essai</strong> est créée et son contenu est:</p>
+<pre><code>for $z in Args() do
+ if z<0 then Inc(z,4) fi,
+ if z=0 then 3
+ elif z=1 then "toto"
+ elif z=2 then "toto0.5"
+ elif z=3 then "24"
+ fi
+od
+</code></pre></li>
+<li><p><u>Exemple(s)</u> : Afficher des labels avec une affixe et une orientation pour chacun, en utilisant une seule fois LabelDot.</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>view(-2,2,-2,2), Marges(0,0,0,0), size(7.5), StrListInit( nom, -1,"<span class="math"><em>A</em></span>","O", i,"<span class="math"><em>B</em></span>","N", 1,"<span class="math"><em>C</em></span>","E", -i,"<span class="math"><em>D</em></span>","S"), for k from 1 to nom(0) step 3 do LabelDot( Eval(@nom(k)), @nom(k+1), @nom(k+2), 1) od, StrListKill(nom)</p>
+</blockquote>
+</blockquote>
+<p>Une autre solution consiste à faire trois listes: nom, position, orientation:</p>
+<pre><code> view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
+ StrListInit( nom, "$A$", "$B$", "$C$", "$D$"),
+ StrListInit(orientation, "O", "N", "E", "S"),
+ position:=[-1, i, 1, -i],
+ for k from 1 to nom(0) do
+ LabelDot( position[k], @nom(k), @orientation(k), 1)
+ od,
+ StrListKill(nom, orientation)
+</code></pre>
+<h3 id="StrListAdd">StrListAdd</h3>
+<ul>
+<li><p><b>StrListAdd( <nomListe>, <"chaine1">, <"chaine2">, ... )</b>.</p></li>
+<li><p><u>Description</u> : cette macro ajoute à la fin de la liste de chaînes appelée <<em>nomListe</em>>, les arguments suivants (qui sont interprétés comme des chaînes). Cela suppose que la liste <<em>nomListe</em>> existe déjà, cette liste est en fait une macro qui va être entièrement réécrite pour lui ajouter les éléments supplémentaires. Il est plus rapide de définir la liste en une seule fois avec la macro <a href="#StrListInit">StrListInit</a> quand c’est possible.</p></li>
+</ul>
+<h3 id="StrListCopy">StrListCopy</h3>
+<ul>
+<li><p><b>StrListCopy( <nomListe>, <nouvelleListe> [, index depart, nombre] )</b>.</p></li>
+<li><p><u>Description</u> : cette macro crée une nouvelle liste de chaînes appelée <<em>nouvelleListe</em>> en copiant <<em>nombre</em>> éléments de la liste <<em>nomListe</em>> en partant de <<em>index depart</em>>. L’argument <index depart> peut être négatif (<span class="math"> - 1</span> designe le dernier élément, <span class="math"> - 2</span> l’avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est négatif. Par défaut l’<<em>index depart</em>> vaut <span class="math">1</span> et le <<em>nombre</em>> vaut <span class="math">0</span> (ce qui signifie øg tous les éléments).</p></li>
+</ul>
+<h3 id="StrListDelKey">StrListDelKey</h3>
+<ul>
+<li><p><b>StrListDelKey( <nomListe>, <index depart>, <nombre> )</b>.</p></li>
+<li><p><u>Description</u> : cette macro supprime de <<em>nomListe</em>> <<em>nombre</em>> éléments à partir de l’<<em>index depart</em>>. Comme dans la commande Del, l’argument <<em>index depart</em>> peut être négatif (<span class="math"> - 1</span> designe le dernier élément, <span class="math"> - 2</span> l’avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est négatif. Cette macro renvoie <em>Nil</em>.</p></li>
+</ul>
+<h3 id="StrListDelVal">StrListDelVal</h3>
+<ul>
+<li><p><b>StrListDelVal( <nomListe>, <val1>, <val2>, ... )</b>.</p></li>
+<li><p><u>Description</u> : cette macro supprime de <<em>nomListe</em>> les chaînes <<em>val1</em>>, <<em>val2</em>>..., sans avoir à connaître leurs index.</p></li>
+</ul>
+<h3 id="StrListGetKey">StrListGetKey</h3>
+<ul>
+<li><p><b>StrListGetKey( <nomListe>, <chaine> )</b>.</p></li>
+<li><p><u>Description</u> : cette macro renvoie l’index de la <<em>chaîne</em>> dans la liste <<em>nomListe</em>>, si elle n’y figure pas, la macro renvoie <em>Nil</em>.</p></li>
+</ul>
+<h3 id="StrListInsert">StrListInsert</h3>
+<ul>
+<li><p><b>StrListInsert( <nomListe1>, <chaîne> [, <index> ])</b>.</p></li>
+<li><p><u>Description</u> : cette macro modifie la liste de chaines <<em>nomListe</em>>, en insérant une nouvelle <<em>chaîne</em>> à la position <<em>index</em>>. Par défaut la valeur de <<em>index</em>> est nulle ce qui représente la fin de la liste, cette valeur peut être négative (<span class="math"> - 1</span> est l’index du dernier élément, <span class="math"> - 2</span> l’avant-dernier, ...).</p></li>
+</ul>
+<h3 id="StrListKill">StrListKill</h3>
+<ul>
+<li><p><b>StrListKill( <nomListe1>, <nomListe2>, ... )</b>.</p></li>
+<li><p><u>Description</u> : cette macro détruit les listes de chaînes <<em>nomListe1</em>>, <<em>nomListe2</em>>, ...</p></li>
+</ul>
+<h3 id="StrListReplace">StrListReplace</h3>
+<ul>
+<li><p><b>StrListReplace( <nomListe>, <ancienne chaine>, <nouvelle> )</b>.</p></li>
+<li><p><u>Description</u> : cette macro remplace dans la liste appelée <<em>nomListe</em>>, l’<<em>ancienne chaine</em>> par la <<em>nouvelle</em>>.</p></li>
+</ul>
+<h3 id="StrListReplaceKey">StrListReplaceKey</h3>
+<ul>
+<li><p><b>StrListReplaceKey( <nomListe>, <index>, <nouvelle chaîne> )</b>.</p></li>
+<li><p><u>Description</u> : cette macro remplace dans la liste appelée <<em>nomListe</em>>, la chaîne dont le numéro est<<em>index</em>>, par la <<em>nouvelle chaîne</em>>.</p></li>
+</ul>
+<h3 id="StrListShow">StrListShow</h3>
+<ul>
+<li><p><b>StrListShow( <nomListe> [, <index depart>, <nombre> ])</b>.</p></li>
+<li><p><u>Description</u> : cette macro renvoie la chaîne obtenue en copiant <<em>nombre</em>> éléments de la liste <<em>nomListe</em>> en partant de <<em>index depart</em>>, mais sans les concaténer. La chaîne renvoyée est de la forme: <code>"chaine", "chaine", ...</code>. L’argument <index depart> peut être négatif (<span class="math"> - 1</span> designe le dernier élément, <span class="math"> - 2</span> l’avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <<em>nombre</em>> est positif, et dans le sens inverse quand <nombre> est négatif. Par défaut l’<index depart> vaut <span class="math">1</span> et le <<em>nombre</em>> vaut <span class="math">0</span> (ce qui signifie øg tous les éléments).</p></li>
+</ul>
+<h2 id="fonctions-statistiques">Fonctions statistiques</h2>
+<h3 id="Anp">Anp</h3>
+<ul>
+<li><p><b>Anp( <n>, <p> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le nombre d’arrangements de <<em>p</em>> parmi <<em>n</em>>.</p></li>
+</ul>
+<h3 id="binom">binom</h3>
+<ul>
+<li><p><b>binom( <n>, <p> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le coefficient binomial (ou combinaison) <<em>p</em>> parmi <<em>n</em>>.</p></li>
+</ul>
+<h3 id="ecart">ecart</h3>
+<ul>
+<li><p><b>ecart( <liste réels> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie l’écart type d’une liste de réels, la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="fact">fact</h3>
+<ul>
+<li><p><b>fact( <n> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la valeur de <span class="math"><em>n</em>!</span> (fonction factorielle).</p></li>
+</ul>
+<h3 id="max">max</h3>
+<ul>
+<li><p><b>max( <liste complexes> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le plus grand élément d’une liste de complexes (ordre lexicographique), la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="min">min</h3>
+<ul>
+<li><p><b>min( <liste complexes> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le plus petit élément d’une liste de complexes (ordre lexicographique), la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="median">median</h3>
+<ul>
+<li><p><b>median( <liste complexes> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie l’élément médian d’une liste de complexes (ordre lexicographique), la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="moy">moy</h3>
+<ul>
+<li><p><b>moy( <liste complexes> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la moyenne d’une liste de complexes, la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="prod">prod</h3>
+<ul>
+<li><p><b>prod( <liste complexes> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie le produit des éléments d’une liste de complexes, la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="sum">sum</h3>
+<ul>
+<li><p><b>sum( <liste complexes> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la somme des éléments d’une liste de complexes, la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h3 id="var">var</h3>
+<ul>
+<li><p><b>var( <liste réels> )</b>.</p></li>
+<li><p><u>Description</u> : renvoie la variance d’une liste de réels, la constante <em>jump</em> est ignorée.</p></li>
+</ul>
+<h2 id="fonctions-de-conversion">Fonctions de conversion</h2>
+<h3 id="RealArg">RealArg</h3>
+<ul>
+<li><p><b>RealArg( <affixe> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’argument (en radians) de l’affixe réelle d’un vecteur en tenant compte de la matrice courante.</p></li>
+</ul>
+<h3 id="RealCoord">RealCoord</h3>
+<ul>
+<li><p><b>RealCoord( <affixe écran> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe réelle d’un point compte tenu des échelles et de la matrice courante.</p></li>
+</ul>
+<h3 id="RealCoordV">RealCoordV</h3>
+<ul>
+<li><p><b>RealCoordV( <affixe écran> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe réelle d’un vecteur compte tenu des échelles de la matrice courante.</p></li>
+</ul>
+<h3 id="ScrCoord">ScrCoord</h3>
+<ul>
+<li><p><b>ScrCoord( <affixe réelle> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe écran d’un point en tenant compte des échelles et de la matrice courante.</p></li>
+</ul>
+<h3 id="ScrCoordV">ScrCoordV</h3>
+<ul>
+<li><p><b>ScrCoordV( <affixe réelle> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe écran d’un vecteur en tenant compte des échelles et de la matrice courante.</p></li>
+</ul>
+<h3 id="SvgCoord">SvgCoord</h3>
+<ul>
+<li><p><b>SvgCoord( <screen affixe> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe exportée en svg en tenant compte des échelles et de la matrice courante.</p></li>
+</ul>
+<h3 id="TeXCoord">TeXCoord</h3>
+<ul>
+<li><p><b>TeXCoord( <screen affixe> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’affixe exportée en tex, pst et pgf en tenant compte des échelles et de la matrice courante. Pour l’eps il y a la commande <a href="#EpsCoord">EpsCoord</a>.</p></li>
+</ul>
+<h2 id="transformations-géométriques-planes">Transformations géométriques planes</h2>
+<h3 id="affin">affin</h3>
+<ul>
+<li><p><b>affin( <liste> , <[A, B]>, <V>, <lambda> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images des points de <<em>liste</em>> par l’affinité de base la droite <<em>(AB)</em>>, de rapport <<em>lambda</em>> et de direction le vecteur <<em>V</em>>.</p></li>
+</ul>
+<h3 id="defAff">defAff</h3>
+<ul>
+<li><p><b>defAff( <nom>, <A>, <A’>, <partie linéaire> )</b></p></li>
+<li><p><u>Description</u> : cette fonction permet de créer une macro appelée <<em>nom</em>> qui représentera l’application affine qui transforme <<em>A</em>> en <<em>A’</em>>, et dont la partie linéaire est le dernier argument. Cette partie linéaire se présente sous la forme d’une liste de deux complexes: [Lf(1), Lf(i)] où Lf désigne la partie linéaire de la transformation.</p></li>
+</ul>
+<h3 id="ftransform">ftransform</h3>
+<ul>
+<li><p><b>ftransform( <liste>, <f(z)> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images des points de <<em>liste</em>> par la fonction <<em>f(z)</em>>, celle-ci peut-être une expression fonction de z ou une macro d’argument z.</p></li>
+</ul>
+<h3 id="hom">hom</h3>
+<ul>
+<li><p><b>hom( <liste>, <A>, <lambda> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images de la <<em>liste</em>> par l’homothétie de centre <<em>A</em>> et de rapport <<em>lambda</em>>.</p></li>
+</ul>
+<h3 id="inv">inv</h3>
+<ul>
+<li><p><b>inv( <liste>, <A>, <R> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images des points de <<em>liste</em>> par l’inversion de cercle de centre <<em>A</em>> et de rayon <<em>R</em>>.</p></li>
+</ul>
+<h3 id="mtransform">mtransform</h3>
+<ul>
+<li><p><b>mtransform( <liste>, <matrice> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images des points de <<em>liste</em>> par l’application affine <span class="math"><em>f</em></span> définie par la <<em>matrice</em>>. Cette <a href="#matrix">matrice</a> est de la forme [f(0), Lf(1), Lf(i)] où Lf désigne la partie linéaire.</p></li>
+</ul>
+<h3 id="proj">proj</h3>
+<ul>
+<li><p><b>proj( <liste>, <A>, <B> )</b> ou <strong>proj( <liste>, <[A,B]> )</strong></p></li>
+<li><p><u>Description</u> : renvoie la liste des projetés orthogonaux des points de <<em>liste</em>> sur la droite <span class="math">(<em>A</em><em>B</em>)</span>.</p></li>
+</ul>
+<h3 id="projO">projO</h3>
+<ul>
+<li><p><b>projO( <liste>, <[A,B]>, <vecteur> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des projetés des points de <<em>liste</em>> sur la droite <<em>(AB)</em>> dans la direction du <<em>vecteur</em>>.</p></li>
+</ul>
+<h3 id="rot">rot</h3>
+<ul>
+<li><p><b>rot( <liste>, <A>, <alpha> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images des points de <<em>liste</em>> par la rotation de centre <<em>A</em>> et d’angle <<em>alpha</em>>.</p></li>
+</ul>
+<h3 id="shift">shift</h3>
+<ul>
+<li><p><b>shift( <liste>, <vecteur> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des translatés des points de <<em>liste</em>> avec le <<em>vecteur</em>>.</p></li>
+</ul>
+<h3 id="simil">simil</h3>
+<ul>
+<li><p><b>simil( <liste> , <A>, <lambda>, <alpha> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des images des points de <<em>liste</em>>, par la similitude de centre <<em>A</em>>, de rapport <<em>lambda</em>> et d’angle <<em>alpha</em>>.</p></li>
+</ul>
+<h3 id="sym">sym</h3>
+<ul>
+<li><p><b>sym( <liste>, <A>, <B> )</b> ou <strong>sym( <liste>, <[A,B]> )</strong></p></li>
+<li><p><u>Description</u> : renvoie la liste des symétriques des points de <<em>liste</em>>, par rapport à la droite <span class="math">(<em>A</em><em>B</em>)</span>.</p></li>
+</ul>
+<h3 id="symG">symG</h3>
+<ul>
+<li><p><b>symG( <liste>, <A>, <vecteur> )</b></p></li>
+<li><p><u>Description</u> : symétrie glissée: renvoie la liste des images des points de <<em>liste</em>>, par la symétrie orthogonale d’axe la droite passant par <<em>A</em>> et dirigée par <<em>vecteur</em>>, composée avec la translation de <<em>vecteur</em>>.</p></li>
+</ul>
+<h3 id="symO">symO</h3>
+<ul>
+<li><p><b>symO( <liste>, <[A, B]>, <vecteur> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des symétriques des points de <<em>liste</em>> par rapport à la droite <<em>(AB)</em>> et dans la direction du <<em>vecteur</em>>.</p></li>
+</ul>
+<h2 id="matrices-de-transformations-2d">Matrices de transformations 2D</h2>
+<p>Une transformation affine <span class="math"><em>f</em></span> du plan complexe peut être représentée par son expression analytique dans la base canonique <span class="math">(1, <em>i</em>)</span>, la forme générale de cette expression est:</p>
+<p>{ <br /><span class="math">$\left\{\begin{array}{rcl}
+ x'&=&t_1+ax+by\\
+y'&=&t_2+cx+dy
+ \end{array}\right.$</span><br /> }</p>
+<p>cette expression analytique sera représentée par la liste <span style="color:red">[t1+i*t2, a+i*c, b+i*d]</span> c’est à dire: <span style="color:red">[ f(0), f(1)-f(0), f(i)-f(0)]</span>, cette liste sera appelée plus brièvement (et de manière abusive) <em>matrice</em> de la transformation <span class="math"><em>f</em></span>. Les deux derniers éléments de cette liste: <span style="color:red">[ a+i*c, b+i*d]</span>, représentent la matrice de la partie linéaire de <span class="math"><em>f</em></span>: Lf<span class="math"> = <em>f</em> - <em>f</em>(0)</span>.</p>
+<h3 id="ChangeWinTo">ChangeWinTo</h3>
+<ul>
+<li><p><b>ChangeWinTo( <[xinf+i*yinf, xsup+i*ysup]> [, ortho] )</b></p></li>
+<li><p><u>Description</u> : modifie la matrice courante de manière à transformer la fenêtre courante en la fenêtre de grande diagonale <<em>[xinf+i*yinf, xsup+i*ysup]</em>>, la fenêtre sera orthonormée ou non en fonction de la valeur du paramètre optionnel <<em>ortho</em>> (<span class="math">0</span> par défaut).</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>view(-10,10,-5,5),size(7.5),NbPoints:=100, LabelSize:=footnotesize, SaveWin(),view(-10,-1,-5,5), ChangeWinTo([-2-2*i,2+2*i]), Arrows:=1, axes(0,1+i),Arrows:=0, tMin:=-2, tMax:=2, Color:=red, Width:=8, Cartesienne(x*Ent(1/x)-1,5,1), Color:=blue,A:=(1+i)/4, Dparallelo(A,bar(A),-A), dep:=RealCoord(i*Im(A)), RestoreWin(), SaveWin(), //zoom view(1,10,-5,5), background(full,white), ChangeWinTo([-A,A]), Color:=black, arr:=RealCoord(-Re(A)+i*Im(A)*0.75), Arrows:=1, axes(0,A), Arrows:=0, tMin:=-0.25, tMax:=0.25, Color:=red, Width:=8, Cartesienne(x*Ent(1/x)-1,5,1), Color:=blue, Dparallelo(A,bar(A),-A), RestoreWin(), //trait Color:=blue, Arrows:=1, A:=ScrCoord(dep), B:=ScrCoord(arr), Bezier(A,A+3*exp(i*pi/2),B-3,B)</p>
+</blockquote>
+</blockquote>
+<h3 id="invmatrix">invmatrix</h3>
+<ul>
+<li><p><b>invmatrix( <[f(0), Lf(1), Lf(i)]> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’inverse de la matrice <<em>[f(0), Lf(1), Lf(i)]</em>>, c’est à dire la matrice <span class="math">[<em>f</em><sup> - 1</sup>(0), <em>L</em><em>f</em><sup> - 1</sup>(1), <em>L</em><em>f</em><sup> - 1</sup>(<em>i</em>)]</span> si elle existe.</p></li>
+</ul>
+<h3 id="matrix">matrix</h3>
+<ul>
+<li><p><b>matrix( <fonction affine>, [variable] )</b></p></li>
+<li><p><u>Description</u> : renvoie la matrice de la <<em>fonction affine</em>>, par défaut la <<em>variable</em>> est <span class="math"><em>z</em></span>. Cette matrice se présente sous la forme [f(0), Lf(1), Lf(i)], où f désigne l’application affine et Lf sa partie linéaire, plus précisément: Lf(1)=f(1)-f(0) et Lf(i)=f(i)-f(0).</p></li>
+<li><p><u>Exemple(s)</u> : <span style="color:red">matrix(i*bar(z))</span> renvoie <span style="color:magenta">[0,i,1]</span>.</p></li>
+</ul>
+<h3 id="mulmatrix">mulmatrix</h3>
+<ul>
+<li><p><b>mulmatrix( <[f(0), Lf(1), Lf(i)]>, <[g(0), Lg(1), Lg(i)]> )</b></p></li>
+<li><p><u>Description</u> : renvoie la matrice de la composée: <span class="math"><em>f</em><em>o</em><em>g</em></span>, où <span class="math"><em>f</em></span> et <span class="math"><em>g</em></span> sont les deux applications affines définies par les matrices passées en argument.</p></li>
+</ul>
+<h2 id="constructions-géométriques-planes">Constructions géométriques planes</h2>
+<p>Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets.</p>
+<h3 id="bissec">bissec</h3>
+<ul>
+<li><p><b>bissec( <B>, <A>, <C>, <1 ou 2> )</b></p></li>
+<li><p><u>Description</u> : renvoie une liste de deux points de la bissectrice, 1=intérieure.</p></li>
+</ul>
+<h3 id="cap">cap</h3>
+<ul>
+<li><p><b>cap( <ensemble1>, <ensemble2> )</b></p></li>
+<li><p><u>Description</u> : renvoie le contour de l’intersection de <<em>ensemble1</em>> avec <<em>ensemble2</em>> sous forme d’une liste de points. Ces deux ensembles sont des lignes polygonales représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro <a href="#set">set</a> permet de définir et dessiner des ensembles.</p></li>
+<li><p><u>Exemple(s)</u> : intersection de deux ensembles:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), A:=set("A", 0, [rotation:=30]), B:=set("B", 0, [rotation:=-30]), C:= cap(A,B),Color:=red,FillStyle:=full, FillOpacity:=0.5, FillColor:=pink, Ligne(C,0)</p>
+</blockquote>
+</blockquote>
+<h3 id="capB">capB</h3>
+<ul>
+<li><p><b>capB( <ensemble1>, <ensemble2> )</b></p></li>
+<li><p><u>Description</u> : renvoie le contour de l’intersection de <<em>ensemble1</em>> avec <<em>ensemble2</em>> sous forme d’une liste de points de contrôles qui doit être dessinée avec la macro <a href="#drawSet">drawSet</a>. Ces deux ensembles sont doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro <a href="#setB">setB</a> permet de définir et dessiner des ensembles.</p></li>
+<li><p><u>Exemple(s)</u> : intersection de deux ensembles:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), A:=setB("A", 0, [rotation:=30]), B:=setB("B", 0, [rotation:=-30]), C:= capB(A,B),Color:=red,FillStyle:=full, drawSet(C, [FillOpacity:=0.5, FillColor:=pink])</p>
+</blockquote>
+</blockquote>
+<h3 id="carre">carre</h3>
+<ul>
+<li><p><b>carre( <A>, <B>, <1 ou -1> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des sommets du carré de sommets consécutifs A et B, 1=sens direct.</p></li>
+</ul>
+<h3 id="cup">cup</h3>
+<ul>
+<li><p><b>cup( <ensemble1>, <ensemble2> )</b></p></li>
+<li><p><u>Description</u> : renvoie le contour de la réunion de <<em>ensemble1</em>> avec <<em>ensemble2</em>> sous forme d’une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro <a href="#set">set</a> permet de définir et dessiner des ensembles.</p></li>
+<li><p><u>Exemple(s)</u> : réunion de deux ensembles:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), A:=set("A", 0, [rotation:=30]), B:=set("B", 0, [rotation:=-30]), C:= cup(A,B),Color:=red,FillStyle:=full, FillOpacity:=0.5, FillColor:=pink, Ligne(C,0)</p>
+</blockquote>
+</blockquote>
+<h3 id="cupB">cupB</h3>
+<ul>
+<li><p><b>cupB( <ensemble1>, <ensemble2> )</b></p></li>
+<li><p><u>Description</u> : renvoie le contour de la réunion de <<em>ensemble1</em>> avec <<em>ensemble2</em>> sous forme d’une liste de points de contrôles qui doit être dessinée avec la macro <a href="#drawSet">drawSet</a>. Ces deux ensembles sont doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro <a href="#setB">setB</a> permet de définir et dessiner des ensembles.</p></li>
+<li><p><u>Exemple(s)</u> : intersection de deux ensembles:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), A:=setB("A", 0, [rotation:=30]), B:=setB("B", 0, [rotation:=-30]), C:= cupB(A,B),Color:=red,FillStyle:=full, drawSet(C, [FillOpacity:=0.5, FillColor:=pink])</p>
+</blockquote>
+</blockquote>
+<h3 id="cutBezier">cutBezier</h3>
+<ul>
+<li><p><b>cutBezier( <courbe de bézier>, <point>, <avant(0/1)> )</b></p></li>
+<li><p><u>Description</u> : renvoie un arc de bézier correspondant à la <<em>courbe de bézier</em>> coupée avant ou après le <<em>point</em>>, en fonction du paramètre <<em>avant</em>>. Le résultat doit être dessiné par la commande <a href="#Bezier">Bezier</a>.</p></li>
+</ul>
+<h3 id="Cvx2d">Cvx2d</h3>
+<ul>
+<li><p><b>Cvx2d( <liste> )</b></p></li>
+<li><p><u>Description</u> : renvoie l’enveloppe convexe de la <<em>liste</em>> selon l’algorithme de {Ronald Graham}. La <<em>liste</em>> ne doit pas contenir la constante <em>jump</em>.</p></li>
+<li><p><u>Exemple(s)</u> : on choisit aléatoirement <span class="math">10</span> points dans le pavé <span class="math">[ - 4, 4] × [ - 4, 4]</span> que l’on place dans une variable <span class="math"><em>P</em></span> tout en dessinant chacun d’eux avec son numéro, puis on dessine l’enveloppe convexe.</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), P:= for k from 1 to 10 do z:=8*Rand()-4+i*(8*Rand()-4), LabelDot(z, k,"N",1), z od, Ligne(Cvx2d(P),1)</p>
+</blockquote>
+</blockquote>
+<h3 id="Intersec">Intersec</h3>
+<ul>
+<li><p><b>Intersec( <objet1>, <objet2> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des points d’intersection des deux objets graphiques. Ces deux objets peuvent être soit des commandes graphiques (Cercle(), Droite(), ...) ou bien le nom d’un élément graphique déjà créé.</p></li>
+<li><p><u>Exemple(s)</u> : la commande <span style="color:red">Intersec( Cercle(0, 1), Droite(-1,i/2) )</span> renvoie:</p>
+<p><div style="text-align:center"><span style="color:magenta">[0.59851109463416+0.79925554731708*i, -0.99794539275033+0.00102730362483*i]</span>.</div></p></li>
+</ul>
+<h3 id="med">med</h3>
+<ul>
+<li><p><b>med( <A>, <B> )</b></p></li>
+<li><p><u>Description</u> : renvoie une liste de deux points de la médiatrice de <span class="math">[<em>A</em>, <em>B</em>]</span>.</p></li>
+</ul>
+<h3 id="parallel">parallel</h3>
+<ul>
+<li><p><b>parallel( <[A,B]>, <C> )</b></p></li>
+<li><p><u>Description</u> : renvoie une liste de deux points de la parallèle à <span class="math">(<em>A</em><em>B</em>)</span> passant par <span class="math"><em>C</em></span>.</p></li>
+</ul>
+<h3 id="parallelo">parallelo</h3>
+<ul>
+<li><p><b>parallelo( <A>, <B>, <C> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des sommets du parallèlogramme de sommets consécutifs <span class="math"><em>A</em></span>, <span class="math"><em>B</em></span>, <span class="math"><em>C</em></span>.</p></li>
+</ul>
+<h3 id="perp">perp</h3>
+<ul>
+<li><p><b>perp( <[A, B]>, <C> )</b></p></li>
+<li><p><u>Description</u> : renvoie une liste de deux points de la perpendiculaire à <span class="math">(<em>A</em><em>B</em>)</span> passant par <span class="math"><em>C</em></span>.</p></li>
+</ul>
+<h3 id="polyreg">polyreg</h3>
+<ul>
+<li><p><b>polyreg( <A>, <B>, <nombre de cotés> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des sommets du polygône régulier de centre <span class="math"><em>A</em></span>, passant par <span class="math"><em>B</em></span> et avec le nombre de côtés indiqué.</p></li>
+</ul>
+<p>ou</p>
+<ul>
+<li><p><strong>polyreg( <A>, <B>, <nombre de cotés + i*sens> )</strong> avec sens = +/-1</p></li>
+<li><p><u>Description</u> : renvoie la liste des sommets du polygône régulier de sommets consécutifs <span class="math"><em>A</em></span> et <span class="math"><em>B</em></span>, avec le nombre de côtés indiqué et dans le sens indiqué (1 pour le sens trigonométrique).</p></li>
+</ul>
+<h3 id="pqGoneReg">pqGoneReg</h3>
+<ul>
+<li><p><b>pqGoneReg( <centre>, <sommet>, <[p,q]> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des sommets du <<em>p/q</em>>-gône régulier défini par le <<em>centre</em>> et un <<em>sommet</em>>.</p></li>
+<li><p><u>Exemple(s)</u> : voir <a href="#DpqGoneReg">ici</a>.</p></li>
+</ul>
+<h3 id="rect">rect</h3>
+<ul>
+<li><p><b>rect( <A>, <B>, <C> )</b></p></li>
+<li><p><u>Description</u> : renvoie la liste des sommets du rectangle de sommets consécutifs <span class="math"><em>A</em></span>, <span class="math"><em>B</em></span>, le côté opposé passant par <span class="math"><em>C</em></span>.</p></li>
+</ul>
+<h3 id="setminus">setminus</h3>
+<ul>
+<li><p><b>setminus( <ensemble1>, <ensemble2> )</b></p></li>
+<li><p><u>Description</u> : renvoie le contour de la différence <<em>ensemble1</em>> - <<em>ensemble2</em>> sous forme d’une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro <a href="#set">set</a> permet de définir et dessiner des ensembles.</p></li>
+<li><p><u>Exemple(s)</u> : différence de deux ensembles:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), A:=set("A", 0, [rotation:=30]), B:=set("B", 0, [rotation:=-30]), C:= setminus(A,B),Color:=red,FillStyle:=full, FillOpacity:=0.5, FillColor:=pink, Ligne(C,0)</p>
+</blockquote>
+</blockquote>
+<h3 id="setminusB">setminusB</h3>
+<ul>
+<li><p><b>setminusB( <ensemble1>, <ensemble2> )</b></p></li>
+<li><p><u>Description</u> : renvoie le contour de la différence <<em>ensemble1</em>> - <<em>ensemble2</em>> sous forme d’une liste de points de contrôles qui doit être dessinée avec la macro <a href="#drawSet">drawSet</a>. Ces deux ensembles sont doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro <a href="#setB">setB</a> permet de définir et dessiner des ensembles.</p></li>
+<li><p><u>Exemple(s)</u> : différence de deux ensembles:</p></li>
+</ul>
+<blockquote>
+<blockquote>
+<p>Marges(0,0,0,0),size(7.5), A:=setB("A", 0, [rotation:=30]), B:=setB("B", 0, [rotation:=-30]), C:= setminusB(A,B),Color:=red,FillStyle:=full, drawSet(C, [FillOpacity:=0.5, FillColor:=pink])</p>
+</blockquote>
+</blockquote>
+<h2 id="gestion-du-flattened-postscript">Gestion du flattened postscript</h2>
+<p>Il est possible de transformer un fichier pdf ou un fichier postscript en <em>flattened postscript</em> grâce à l’utilitaire <em>pstoedit</em> (<a href="http://www.pstoedit.net/"><code class="url">http://www.pstoedit.net/</code></a>). Dans le fichier obtenu, tout est chemin, y compris le texte. TeXgraph peut récupérer tous les chemins d’un fichier écrit en <em>flattened postscript</em>. C’est que proposent les macros de cette section.</p>
+<h3 id="conv2FlatPs">conv2FlatPs</h3>
+<ul>
+<li><p><b>conv2FlatPs( <fichier entrée>, <fichier sortie> [, dossier de travail] )</b></p></li>
+<li><p><u>Description</u> : cette macro invoque l’utilitaire <em>pstoedit</em> pour transformer le <<em>fichier entrée</em>> en <em>flattened postscript</em> dans le <<em>fichier sortie</em>>. Le fichier <<em>fichier entrée</em>> doit être un fichier pdf ou ps.</p></li>
+</ul>
+<h3 id="drawFlatPs">drawFlatPs</h3>
+<ul>
+<li><p><b>drawFlatPs( <affixe>, <chemins lus par loadFlatPs> [, options] )</b></p></li>
+<li><p><u>Description</u> : cette macro dessine à l’écran l’ensemble des chemins lus dans un fichier en <em>flattened postscript</em> par la macro <a href="#loadFlatPs">loadFlatPs</a>. L’affichage se fait à l’<<em>affixe</em>> demandé. Le paramètre <<em>options</em>> est une liste (facultative) de la forme <span style="font-style:italic">[ option1:= valeur1, ..., optionN:=valeurN ]</span>, les options sont:</p>
+<ul>
+<li><p><span style="color:blue">scale := < nombre positif ></span>: échelle, 1 par défaut.</p></li>
+<li><p><span style="color:blue">position := < center/left/right/... ></span>: position de l’affixe par rapport à l’image, center par défaut (fonctionne comme la variable LabelStyle).</p></li>
+<li><p><span style="color:blue">color := < couleur ></span>: pour imposer une couleur, <em>Nil</em> par défaut ce qui signifie qu’on prend la couleur d’origine.</p></li>
+<li><p><span style="color:blue">rotation := < angle en degrés ></span>: 0 par défaut.</p></li>
+<li><p><span style="color:blue">hollow := < 0/1 ></span>: avec la valeur 0 (par défaut) les remplissages sont effectués.</p></li>
+<li><p><span style="color:blue">select := < liste des numéros de chemin à montrer ></span>: <em>Nil</em> par défaut, ce qui signifie tous les chemins.</p></li>
+</ul></li>
+</ul>
+<h3 id="drawTeXlabel">drawTeXlabel</h3>
+<ul>
+<li><p><b>drawTeXlabel( <affixe>, <variable contenant la formule TeX lue par loadFlatPs>, [, options] )</b></p></li>
+<li><p><u>Description</u> : cette macro invoque la macro <a href="#drawFlatPs">drawFlatPs</a> pour dessiner une expression qui a été au préalable compilée par . Le paramètre <<em>options</em>> est une liste (facultative) de la forme <span style="font-style:italic">[ option1:= valeur1, ..., optionN:=valeurN ]</span>, les options sont:</p>
+<ul>
+<li><p><span style="color:blue">scale := < nombre>0 ></span>: échelle, 1 par défaut.</p></li>
+<li><p><span style="color:blue">hollow := < 0/1 ></span>: avec la valeur 0 (par défaut) les remplissages sont effectués.</p></li>
+</ul>
+<p>Cette macro est utilisée en interne par la macro <a href="#NewTeXlabel">NewTeXlabel</a>.</p></li>
+</ul>
+<h3 id="loadFlatPs">loadFlatPs</h3>
+<ul>
+<li><p><b>loadFlatPs( <fichier en flattened postscript>, [, options] )</b></p></li>
+<li><p><u>Description</u> : cette macro charge un <<em>fichier en flattened postscript</em>>, adpate les coordonnées des points et renvoie la liste des chemins (que l’on peut alors dessiner avec la macro <a href="#drawFlatPs">drawFlatPs</a>). Le paramètre <<em>options</em>> est une liste (facultative) de la forme <span style="font-style:italic">[ option1:= valeur1, ..., optionN:=valeurN ]</span>, les options sont:</p>
+<ul>
+<li><p><span style="color:blue">width := < nombre>0 ></span>: largeur en cm, <em>Nil</em> par défaut pour largeur naturelle.</p></li>
+<li><p><span style="color:blue">height := < nombre>0 ></span>: hauteur en cm, <em>Nil</em> par défaut pour hauteur naturelle.</p></li>
+</ul></li>
+<li><p>supposons que vous ayez le fichier <em>circuit.pdf</em> dans le dossier temporaire de TeXgraph, la commande suivante dans un élément graphique Utilisateur:</p></li>
+</ul>
+<pre><code> [conv2FlatPs( "circuit.pdf", "circuit.fps", @TmpPath),
+ stock:= loadFlatPs( [@TmpPath,"circuit.fps"] ),
+ drawFlatPs( 0, stock, [scale:=1, hollow:=1] )
+ ]
+</code></pre>
+<p>va permettre de charger et dessiner le contenu de ce fichier dans TeXgraph, sans faire les remplissages.</p>
+<h3 id="NewTeXlabel">NewTeXlabel</h3>
+<ul>
+<li><p><b>NewTeXlabel( <nom>, <affixe>, <formule TeX>, [, options] )</b></p></li>
+<li><p><u>Description</u> : cette macro va demander à {} de compiler la formule dans un fichier pdf, ce fichier sera ensuite converti en un fichier eps par pstoedit, puis celui-ci sera chargé par loadFlatPs et stocké dans une variable globale appelée TeX_+nom. Un élément graphique appelé <<em>nom</em>> est créée pour dessiner la formule avec drawTeXLabel. Le paramètre <<em>options</em>> est une liste (facultative) de la forme <span style="font-style:italic">[ option1:= valeur1, ..., optionN:=valeurN ]</span>, les options sont:</p>
+<ul>
+<li><p><span style="color:blue">dollar := < 0/1 ></span>: indique à TeXgraph s’il doit ajouter les délimiteurs <code>\[</code> et <code>\]</code> autour de la formule, 1 par défaut.</p></li>
+<li><p><span style="color:blue">scale := < nombre>0 ></span>: échelle, 1 par défaut.</p></li>
+<li><p><span style="color:blue">hollow := < 0/1 ></span>: avec la valeur 0 (par défaut) les remplissages sont effectués.</p></li>
+</ul>
+<p>Dans les options, les attributs suivants peuvent également être utilisés: <span style="font-style:italic;color:red">LabelStyle</span>, <span style="font-style:italic;color:red">LabelAngle</span> et <span style="font-style:italic;color:red">Color</span>.</p>
+<p>Voici la définition de cette macro:</p>
+<blockquote>
+<pre><code>[dollar:=1, scale:=1, hollow:=0, $options:=%4,
+ $aux:=OpenFile([@TmpPath,"formula.tex"]),
+ if dollar then WriteFile(["\[",%3,"\]"]) else WriteFile(%3) fi,
+ CloseFile(),
+ Exec("pdflatex","-interaction=nonstopmode tex2FlatPs.tex",@TmpPath,1),
+ Exec("pstoedit -dt -pta -f ps -r2400x2400","tex2FlatPs.pdf tex2FlatPs.eps",@TmpPath,1),
+ NewVar(["TeX_",%1],loadFlatPs([@TmpPath,"tex2FlatPs.eps"])),
+ NewGraph(%1, ["drawTeXlabel(",%2,", TeX_",%1,", [scale:=",scale,", hollow:=",hollow,"])"]),
+ ReDraw()
+]
+</code></pre>
+</blockquote>
+<p>La formule est écrite dans le fichier <em>formula.tex</em>, puis on compile le fichier <em>tex2FlatPs.tex</em> suivant:</p>
+<pre><code> \documentclass[12pt]{article}
+ \usepackage{amsmath,amssymb}
+ \usepackage{fourier}
+ \pagestyle{empty}
+ \begin{document}
+ \large
+ \input{formula.tex}%
+ \end{document}
+</code></pre>
+<p>et on convertit le résultat en <em>flattened postscript</em> avant de le charger.</p>
+<p>Cette macro s’utilise dans la ligne de commande ou bien dans des macros qui créent des éléments graphiques, mais pas directement dans un élément graphique Utilisateur, exemple:</p>
+<p><div style="text-align:center"><span style="color:red">NewTeXlabel( "label1", 0, "\frac{\pi}{\sqrt{2}}", [scale:=1.5, Color:=blue, LabelAngle:=45])</span></div></p></li>
+</ul>
+<h2 id="autres">Autres</h2>
+<h3 id="pdfprog">pdfprog</h3>
+<ul>
+<li><p><b>pdfprog()</b>.</p></li>
+<li><p><u>Description</u> : cette macro est utilisée en interne pour mémoriser le programme utilisé pour faire la conversion du format eps vers le format pdf. Par défaut, cette macro contient la chaine: <span style="font-style:italic">"epstopdf"</span>. En éditant le fichier TeXgraph.mac, vous pouvez modifier le programme utilisé.</p></li>
+</ul>
--- /dev/null
+\chapter{Les macros mathématiques de TeXgraph.mac}
+
+\section{Opérations arithmétiques et logiques}
+
+\subsection{Ceil}
+
+\begin{itemize}
+\item \util \textbf[Ceil()]{Ceil( <x> )}.
+\item \desc renvoie le plus petit entier supérieur ou égal au réel \argu{x}.
+\end{itemize}
+
+\subsection{div}
+
+\begin{itemize}
+\item \util \textbf[div()]{div( <x>, <y> )}.
+\item \desc renvoie l'unique entier $k$ tel que $x-ky$ soit dans l'intervalle $[0;|y|[$.
+\end{itemize}
+
+\subsection{mod}
+
+\begin{itemize}
+\item \util \textbf[mod()]{mod( <x>, <y> )}.
+\item \desc renvoie l'unique réel $r$ de l'intervalle $[0;|y|[$ tel que
+$x=ky+r$ avec $k$ entier.
+\end{itemize}
+
+\subsection{not}\label{macnot}
+
+\begin{itemize}
+\item \util \textbf[not()]{not( <expression booléenne> )}
+\item \desc renvoie la valeur booléenne de la négation.
+\end{itemize}
+
+\subsection{pgcd}
+
+\begin{itemize}
+\item \util \textbf[pgcd()]{pgcd( <a>, <b> [, <u>, <v>] )}
+\item \desc renvoie la valeur d du pgcd de \argu{a} et \argu{b}, ainsi que deux coefficients de Bezout dans les
+variables \argu{u} et \argu{v} (si celles-ci sont présentes), de telle sorte que $au+bv=d$.
+\end{itemize}
+
+\subsection{ppcm}
+
+\begin{itemize}
+\item \util \textbf[ppcm()]{ppcm( <a>, <b> )}
+\item \desc renvoie la valeur du ppcm de \argu{a} et \argu{b}.
+\end{itemize}
+
+\section{Opérations sur les variables}
+
+\subsection{Abs}
+
+\begin{itemize}
+\item \util \textbf[Abs()]{Abs( <affixe> )}.
+\item \desc cette macro donne la norme en cm.
+\end{itemize}
+
+
+\subsection{free}
+
+\begin{itemize}
+\item \util \textbf[free()]{free( <x> )}.
+\item \desc libère la variable \argu{x} en la mettant à \Nil. Depuis la version 1.93 on peut faire directement
+l'affectation à la constante \Nil, par exemple: \co{x:=Nil}.
+\end{itemize}
+
+
+\subsection{IsIn}
+
+\begin{itemize}
+\item \util \textbf[IsIn()]{IsIn( <affixe> [, <epsilon>] )}.
+\item \desc renvoie 1 si l'\argu{affixe} est dans la fenêtre graphique, 0 sinon. Cette macro tient compte de la matrice
+courante, le test se fait à \argu{epsilon} près et \argu{epsilon} vaut 0.0001 cm par défaut.
+\end{itemize}
+
+\subsection{nil}
+
+\begin{itemize}
+\item \util \textbf[nil()]{nil( <x> )}.
+\item \desc renvoie 1 si la variable \argu{x} est à \Nil, 0 sinon. Depuis la version 1.93 on peut faire directement le
+test d'égalité avec la constante \Nil.
+\end{itemize}
+
+\subsection{round}
+
+\begin{itemize}
+\item \util \textbf[round()]{round( <liste> [, décimales] )}
+\item \desc tronque les complexes de la \argu{liste} en arrondissant au plus proche les parties réelles et imaginaires
+avec le nombre de \argu{décimales} demandé (0 par défaut). Si la \argu{liste} contient le constante \jump, alors
+celle-ci est renvoyée dans la liste des résultats. Cette macro utilise la commande \Helpref{{Round}}{cmdRound} (qui ne
+s'applique qu'à un complexe et non une liste).
+\end{itemize}
+
+\section{Opérations sur les listes}
+
+\subsection{bary}
+\begin{itemize}
+\item \util \textbf[bary()]{bary( <[affixe1, coef1, affixe2, coef2, ...]> )}.
+\item \desc renvoie le barycentre du système pondéré \argu{[(affixe1, coef1), (affixe2, coef2),...]}.
+\end{itemize}
+
+\subsection{del}
+\begin{itemize}
+\item \util \textbf[del()]{del( <liste>, <liste des index à supprimer>, <quantité à supprimer> )}.
+\item \desc renvoie la liste après avoir supprimer les éléments dont l'index figure dans la \argu{liste des index à
+supprimer}. La \argu{quantité à supprimer} (à chaque fois) est de $1$ par défaut, cet argument peut être une liste lui
+aussi.
+\item \exem
+ \begin{itemize}
+ \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8])} donne \res{[1,3,4,5,7]}.
+ \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8], 2)} donne \res{[1,4,5]}.
+ \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8], [1,2])} donne \res{[1,3,4,5]}.
+ \item \co{del( [1,2,jump,3,4,5,jump,6,7,8],[3,7])} donne \res{[1,2,3,4,5,6,7,8]}.
+ \end{itemize}
+\end{itemize}
+
+\subsection{getdot}
+\begin{itemize}
+\item \util \textbf[getdot()]{getdot( <s> , <ligne polygonale> )}.
+\item \desc renvoie le point de la \argu{ligne polygonale} ayant \argu{s} comme abscisse curviligne. Le paramètre
+\argu{s} doit être dans l'intervalle $[0;1]$, $0$ pour le premier point, et $1$ pour le dernier.
+\end{itemize}
+
+\subsection{IsAlign}
+
+\begin{itemize}
+\item \util \textbf[IsAlign()]{IsAlign( <liste points 2D> [, epsilon] )}.
+\item \desc renvoie 1 si les points sont sur une même droite, 0 sinon. Par défaut la tolérance \argu{epsilon} vaut
+1E-10. La \argu{liste} ne doit pas contenir la constante \jump.
+\end{itemize}
+
+
+\subsection{isobar}
+
+\begin{itemize}
+\item \util \textbf[isobar()]{isobar( <[affixe1, affixe2, ...]> )}.
+\item \desc renvoie l'isobarycentre du système \argu{[affixe1, affixe2, ...]}.
+\end{itemize}
+
+\subsection{KillDup}
+\begin{itemize}
+\item \util \textbf[KillDup()]{KillDup( <liste> [, epsilon] )}.
+\item \desc renvoie la liste sans doublons. Les comparaisons se font à \argu{epsilon} près (qui vaut $0$ par défaut).
+\item \exem \co{KillDup( [1.255,1.258,jump,1.257,1.256,1.269,jump] ,1.5E-3)} renvoie \res{[1.255,1.258,1.269]}.
+\end{itemize}
+
+\subsection{length}
+\begin{itemize}
+\item \util \textbf[length()]{length( <liste> )}.
+\item \desc calcule la longueur de la \argu{liste} en cm.
+\end{itemize}
+
+\subsection{permute}
+\begin{itemize}
+\item \util \textbf[permute()]{permute( <liste> )}.
+\item \desc modifie la \argu{liste} en plaçant le premier élément à la fin, \argu{liste} doit être une variable.
+\item la commande \co{[x:= [1,2,3,4], permute(x), x]} renvoie \res{[2,3,4,1]}.
+\end{itemize}
+
+\subsection{Pos}
+\begin{itemize}
+\item \util \textbf[Pos()]{Pos( <affixe>, <liste>, [, epsilon] )}.
+\item \desc renvoie la liste des positions de l'\argu{affixe} dans la \argu{liste}, la comparaison se fait à
+\argu{epsilon} près, par défaut \argu{epsilon} vaut 0.
+\item la commande \co{Pos(2, [1,2,3,2,4])} renvoie \res{[2,4]}, mais \co{Pos(5, [1,2,3,2,4])} renvoie \Nil.
+\end{itemize}
+
+
+\subsection{rectangle}
+\begin{itemize}
+\item \util \textbf[rectangle()]{rectangle( <liste> )}.
+\item \desc détermine le plus petit rectangle contenant la liste, cette macro renvoie une liste de deux complexes qui
+représentent l'affixe du coin inférieur gauche suivi de celle du coin supérieur droit.
+\end{itemize}
+
+\subsection{replace}
+\begin{itemize}
+\item \util \textbf[replace()]{replace( <liste>, <position>, <valeur> )}.
+\item \desc modifie la variable \argu{liste} en remplaçant l'élément numéro \argu{position} par la \argu{valeur}, cette
+macro renvoie \Nil.
+\end{itemize}
+
+\subsection{reverse}
+\begin{itemize}
+\item \util \textbf[reverse()]{reverse( <liste> )}.
+\item \desc renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un \jump).
+\end{itemize}
+
+\subsection{SortWith}
+\begin{itemize}
+\item \util \textbf[SortWith()]{SortWith( <liste clés>, <liste>, <taille paquets> [, mode] )}.
+\item \desc trie la \textbf{variable} \argu{liste} suivant les \argu{clés}. Les éléments de la \argu{liste} sont
+traités par \argu{paquets}, leur taille est de 1 par défaut. La \argu{taille paquets} peut être égale à \jump pour un
+traitement par composante. Si un paquet n'est pas complet, il n'est pas traité. Si la liste contient la
+constante \jump, alors toutes les composantes sont triées chacune leur tour. Le dernier paramètre détermine
+le type de tri: \argu{mode}=0 pour ordre croissant (valeur par défaut), \argu{mode}=1 pour décroissant.
+\end{itemize}
+
+\section{Gestion des listes par composantes}
+
+La convention adoptée est que deux composantes sont séparées par la constante \jump. Une composante peut être vide.
+
+\subsection{CpCopy}
+\begin{itemize}
+\item \util \textbf[CpCopy()]{CpCopy( <liste>, <index depart>, <nombre> )}.
+\item \desc cette fonction renvoie la liste constituée par les \argu{nombre} composantes de la \argu{liste} à partir de
+la composante numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie toutes les composantes
+de la liste à partir de la composante numéro \argu{départ}.
+
+Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la
+dernière composante a l'index $-1$, l'avant-dernière a l'index $-2$ $\cdots$ etc. La fonction renvoie les \argu{nombre}
+composantes de la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche, mais la liste renvoyée
+est dans le même sens que la \argu{liste}, et cette dernière n'est pas modifiée.
+\item \exem \begin{itemize}
+ \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], 2, 1)} renvoie \res{[3,7,8]}.
+ \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -1, 2)} renvoie \res{[4,jump,5,6]}.
+ \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -3, 0)} renvoie \res{[1,2,jump,3,7,8]}.
+ \end{itemize}
+\end{itemize}
+
+\subsection{CpDel}
+\begin{itemize}
+\item \util \textbf[CpDel()]{CpDel( <variable liste>, <index depart>, <nombre> )}.
+\item \desc cette fonction détruit dans la \argu{variable liste}, les \argu{nombre} composantes à partir
+de la composante numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction détruit toutes les
+composantes de la \argu{variable liste} à partir de la composante numéro \argu{départ}.
+
+Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la
+dernière composante a l'index $-1$, l'avant-dernière a l'index $-2$ $\cdots$ etc. La fonction détruit les \argu{nombre}
+composantes de la <variable liste> (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche.
+
+Le paramètre \argu{variable liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la macro renvoie
+\Nil.
+\end{itemize}
+
+\subsection{CpNops}
+\begin{itemize}
+\item \util \textbf[CpNops()]{CpNops( <liste> )}.
+\item \desc cette fonction évalue \argu{liste} et renvoie le nombre de composantes qui la composent.
+\item \exem
+ \begin{itemize}
+ \item \co{CpNops([1,2,jump,3] )} renvoie la valeur \res{2}.
+ \item \co{CpNops([1,2,jump,3,jump] )} renvoie la valeur \res{3}.
+ \item \co{CpNops([jump] )} renvoie la valeur \res{2}.
+ \end{itemize}
+\end{itemize}
+
+\subsection{CpReplace}
+\begin{itemize}
+\item \util \textbf[CpReplace()]{CpReplace( <variable liste>, <position>, <nouveau> )}.
+\item \desc modifie la \argu{variable liste} en remplaçant la composante numéro \argu{position} par \argu{nouveau},
+cette macro renvoie \Nil.
+\end{itemize}
+
+\subsection{CpReverse}
+\begin{itemize}
+\item \util \textbf[CpReverse()]{CpReverse( <liste> )}.
+\item \desc renvoie la \argu{liste} avec les composantes dans l'ordre inverse.
+\item \exem \co{CpReverse([1,2,jump,3,4,5,jump])} renvoie \res{[jump,3,4,5,jump,1,2]}.
+\end{itemize}
+
+\section{Gestion des listes de chaînes}
+
+Une telle liste est en réalité une \textbf{macro}, les éléments sont indexés à partir de $1$, et la chaîne numéro $k$
+est donnée par \verb|@nomListe(k)|, alors que la longueur de la liste (nombre d'éléments) est donnée par
+\verb|nomListe(0)|.
+
+\subsection{StrListInit}\label{macStrListInit}
+\begin{itemize}
+\item \util \textbf[StrListInit()]{StrListInit( <nomListe>, <"chaine1">, <"chaine2">, ... )}.
+\item \desc crée une liste de chaines sous forme d'une macro appelée \argu{nomListe}, les arguments suivants sont
+interprétés comme des chaînes, ils constituent les éléments de la liste et sont indexés à partir de 1.
+\item \exem Après la commande \co{StrListInit(essai, "toto", ["toto",2/4], 24)}, une macro du nom de \Mytextbf{essai}
+est créée et son contenu est:
+\begin{verbatim}
+for $z in Args() do
+ if z<0 then Inc(z,4) fi,
+ if z=0 then 3
+ elif z=1 then "toto"
+ elif z=2 then "toto0.5"
+ elif z=3 then "24"
+ fi
+od
+\end{verbatim}
+\item \exem Afficher des labels avec une affixe et une orientation pour chacun, en utilisant une seule fois LabelDot.
+\end{itemize}
+
+\begin{demo}{Utilisation de StrListInit}{StrListInit}
+\begin{texgraph}[name=StrListInit,export=pgf]
+ view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
+ StrListInit( nom, -1,"$A$","O", i,"$B$","N",
+ 1,"$C$","E", -i,"$D$","S"),
+ for k from 1 to nom(0) step 3 do
+ LabelDot( Eval(@nom(k)), @nom(k+1), @nom(k+2), 1)
+ od,
+ StrListKill(nom)
+\end{texgraph}
+\end{demo}
+
+Une autre solution consiste à faire trois listes: nom, position, orientation:
+\begin{verbatim}
+ view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
+ StrListInit( nom, "$A$", "$B$", "$C$", "$D$"),
+ StrListInit(orientation, "O", "N", "E", "S"),
+ position:=[-1, i, 1, -i],
+ for k from 1 to nom(0) do
+ LabelDot( position[k], @nom(k), @orientation(k), 1)
+ od,
+ StrListKill(nom, orientation)
+\end{verbatim}
+
+\subsection{StrListAdd}
+\begin{itemize}
+\item \util \textbf[StrListAdd()]{StrListAdd( <nomListe>, <"chaine1">, <"chaine2">, ... )}.
+\item \desc cette macro ajoute à la fin de la liste de chaînes appelée \argu{nomListe}, les arguments suivants (qui sont
+interprétés comme des chaînes). Cela suppose que la liste \argu{nomListe} existe déjà, cette liste est en fait une
+macro qui va être entièrement réécrite pour lui ajouter les éléments supplémentaires. Il est plus rapide de définir la
+liste en une seule fois avec la macro \Helpref{StrListInit}{macStrListInit} quand c'est possible.
+\end{itemize}
+
+\subsection{StrListCopy}
+\begin{itemize}
+\item \util \textbf[StrListCopy()]{StrListCopy( <nomListe>, <nouvelleListe> [, index depart, nombre] )}.
+\item \desc cette macro crée une nouvelle liste de chaînes appelée \argu{nouvelleListe} en copiant \argu{nombre}
+éléments de la liste \argu{nomListe} en partant de \argu{index depart}. L'argument
+<index depart> peut être négatif ($-1$ designe le dernier élément, $-2$ l'avant-dernier, ...), par contre les éléments
+sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est
+négatif. Par défaut l'\argu{index depart} vaut $1$ et le \argu{nombre} vaut $0$ (ce qui signifie \og tous les
+éléments\fg).
+\end{itemize}
+
+\subsection{StrListDelKey}
+\begin{itemize}
+\item \util \textbf[StrListDelKey()]{StrListDelKey( <nomListe>, <index depart>, <nombre> )}.
+\item \desc cette macro supprime de \argu{nomListe} \argu{nombre} éléments à partir de l'\argu{index depart}. Comme
+dans la commande Del, l'argument \argu{index depart} peut être négatif ($-1$ designe le dernier élément,
+$-2$ l'avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est
+positif, et dans le sens inverse quand <nombre> est négatif. Cette macro renvoie \Nil.
+\end{itemize}
+
+\subsection{StrListDelVal}
+\begin{itemize}
+\item \util \textbf[StrListDelVal()]{StrListDelVal( <nomListe>, <val1>, <val2>, ... )}.
+\item \desc cette macro supprime de \argu{nomListe} les chaînes \argu{val1}, \argu{val2}..., sans avoir à connaître
+leurs index.
+\end{itemize}
+
+\subsection{StrListGetKey}
+\begin{itemize}
+\item \util \textbf[StrListGetKey()]{StrListGetKey( <nomListe>, <chaine> )}.
+\item \desc cette macro renvoie l'index de la \argu{chaîne} dans la liste \argu{nomListe}, si elle n'y figure pas, la
+macro renvoie \Nil.
+\end{itemize}
+
+\subsection{StrListInsert}
+\begin{itemize}
+\item \util \textbf[StrListInsert()]{StrListInsert( <nomListe1>, <chaîne> [, <index> ])}.
+\item \desc cette macro modifie la liste de chaines \argu{nomListe}, en insérant une nouvelle \argu{chaîne} à la
+position \argu{index}. Par défaut la valeur de \argu{index} est nulle ce qui représente la fin de la liste, cette valeur
+peut être négative ($-1$ est l'index du dernier élément, $-2$ l'avant-dernier, ...).
+\end{itemize}
+
+\subsection{StrListKill}
+\begin{itemize}
+\item \util \textbf[StrListKill()]{StrListKill( <nomListe1>, <nomListe2>, ... )}.
+\item \desc cette macro détruit les listes de chaînes \argu{nomListe1}, \argu{nomListe2}, ...
+\end{itemize}
+
+\subsection{StrListReplace}
+\begin{itemize}
+\item \util \textbf[StrListReplace()]{StrListReplace( <nomListe>, <ancienne chaine>, <nouvelle> )}.
+\item \desc cette macro remplace dans la liste appelée \argu{nomListe}, l'\argu{ancienne chaine} par la \argu{nouvelle}.
+\end{itemize}
+
+\subsection{StrListReplaceKey}
+\begin{itemize}
+\item \util \textbf[StrListReplaceKey()]{StrListReplaceKey( <nomListe>, <index>, <nouvelle chaîne> )}.
+\item \desc cette macro remplace dans la liste appelée \argu{nomListe}, la chaîne dont le numéro est\argu{index}, par
+la \argu{nouvelle chaîne}.
+\end{itemize}
+
+\subsection{StrListShow}
+\begin{itemize}
+\item \util \textbf[StrListShow()]{StrListShow( <nomListe> [, <index depart>, <nombre> ])}.
+\item \desc cette macro renvoie la chaîne obtenue en copiant \argu{nombre} éléments de la liste \argu{nomListe} en
+partant de
+\argu{index depart}, mais sans les concaténer. La chaîne renvoyée est de la forme: \verb|"chaine", "chaine", ...|.
+L'argument <index depart> peut être négatif ($-1$ designe le dernier élément, $-2$ l'avant-dernier, ...), par contre
+les éléments sont toujours parcourus de gauche à droite quand \argu{nombre} est positif, et dans le sens inverse quand
+<nombre> est négatif. Par défaut l'<index depart> vaut $1$ et le \argu{nombre} vaut $0$ (ce qui signifie \og tous les
+éléments\fg).
+\end{itemize}
+
+
+\section{Fonctions statistiques}
+
+\subsection{Anp}
+\begin{itemize}
+\item \util \textbf[Anp()]{Anp( <n>, <p> )}.
+\item \desc renvoie le nombre d'arrangements de \argu{p} parmi \argu{n}.
+\end{itemize}
+
+\subsection{binom}
+\begin{itemize}
+\item \util \textbf[binom()]{binom( <n>, <p> )}.
+\item \desc renvoie le coefficient binomial (ou combinaison) \argu{p} parmi \argu{n}.
+\end{itemize}
+
+
+\subsection{ecart}
+\begin{itemize}
+\item \util \textbf[ecart()]{ecart( <liste réels> )}.
+\item \desc renvoie l'écart type d'une liste de réels, la constante \jump est ignorée.
+\end{itemize}
+
+\subsection{fact}
+\begin{itemize}
+\item \util \textbf[fact()]{fact( <n> )}.
+\item \desc renvoie la valeur de $n!$ (fonction factorielle).
+\end{itemize}
+
+
+\subsection{max}
+\begin{itemize}
+\item \util \textbf[max()]{max( <liste complexes> )}.
+\item \desc renvoie le plus grand élément d'une liste de complexes (ordre lexicographique), la constante \jump est
+ignorée.
+\end{itemize}
+
+\subsection{min}
+\begin{itemize}
+\item \util \textbf[min()]{min( <liste complexes> )}.
+\item \desc renvoie le plus petit élément d'une liste de complexes (ordre lexicographique), la constante \jump est
+ignorée.
+\end{itemize}
+
+\subsection{median}
+\begin{itemize}
+\item \util \textbf[median()]{median( <liste complexes> )}.
+\item \desc renvoie l'élément médian d'une liste de complexes (ordre lexicographique), la constante \jump est ignorée.
+\end{itemize}
+
+\subsection{moy}
+\begin{itemize}
+\item \util \textbf[moy()]{moy( <liste complexes> )}.
+\item \desc renvoie la moyenne d'une liste de complexes, la constante \jump est ignorée.
+\end{itemize}
+
+\subsection{prod}
+\begin{itemize}
+\item \util \textbf[prod()]{prod( <liste complexes> )}.
+\item \desc renvoie le produit des éléments d'une liste de complexes, la constante \jump est ignorée.
+\end{itemize}
+
+\subsection{sum}
+\begin{itemize}
+\item \util \textbf[sum()]{sum( <liste complexes> )}.
+\item \desc renvoie la somme des éléments d'une liste de complexes, la constante \jump est ignorée.
+\end{itemize}
+
+\subsection{var}
+\begin{itemize}
+\item \util \textbf[var()]{var( <liste réels> )}.
+\item \desc renvoie la variance d'une liste de réels, la constante \jump est ignorée.
+\end{itemize}
+
+\section{Fonctions de conversion}
+
+\subsection{RealArg}
+
+\begin{itemize}
+\item \util \textbf[RealArg()]{RealArg( <affixe> )}
+\item \desc renvoie l'argument (en radians) de l'affixe réelle d'un vecteur en tenant compte de la matrice courante.
+\end{itemize}
+
+
+\subsection{RealCoord}
+\begin{itemize}
+\item \util \textbf[RealCoord()]{RealCoord( <affixe écran> )}
+
+\item \desc renvoie l'affixe réelle d'un point compte tenu des échelles et de la matrice courante.
+\end{itemize}
+
+\subsection{RealCoordV}
+
+\begin{itemize}
+\item \util \textbf[RealCoordV()]{RealCoordV( <affixe écran> )}
+\item \desc renvoie l'affixe réelle d'un vecteur compte tenu des échelles de la matrice courante.
+\end{itemize}
+
+\subsection{ScrCoord}
+
+\begin{itemize}
+\item \util \textbf[ScrCoord()]{ScrCoord( <affixe réelle> )}
+\item \desc renvoie l'affixe écran d'un point en tenant compte des échelles et de la matrice courante.
+\end{itemize}
+
+\subsection{ScrCoordV}
+
+\begin{itemize}
+\item \util \textbf[ScrCoordV()]{ScrCoordV( <affixe réelle> )}
+\item \desc renvoie l'affixe écran d'un vecteur en tenant compte des échelles et de la matrice courante.
+\end{itemize}
+
+\subsection{SvgCoord}\label{macSvgCoord}
+
+\begin{itemize}
+\item \util \textbf[SvgCoord()]{SvgCoord( <screen affixe> )}
+\item \desc renvoie l'affixe exportée en svg en tenant compte des échelles et de la matrice courante.
+\end{itemize}
+
+\subsection{TeXCoord}\label{macTeXCoord}
+
+\begin{itemize}
+\item \util \textbf[TeXCoord()]{TeXCoord( <screen affixe> )}
+\item \desc renvoie l'affixe exportée en tex, pst et pgf en tenant compte des échelles et de la matrice courante. Pour
+l'eps il y a la commande \Helpref{EpsCoord}{cmdEpsCoord}.
+\end{itemize}
+
+
+\section{Transformations géométriques planes}
+
+\subsection{affin}
+
+\begin{itemize}
+\item \util \textbf[affin()]{affin( <liste> , <[A, B]>, <V>, <lambda> )}
+\item \desc renvoie la liste des images des points de \argu{liste} par l'affinité de base la droite \argu{(AB)}, de
+rapport \argu{lambda} et de direction le vecteur \argu{V}.
+\end{itemize}
+
+\subsection{defAff}
+
+\begin{itemize}
+\item \util \textbf[defAff()]{defAff( <nom>, <A>, <A'>, <partie linéaire> )}
+\item \desc cette fonction permet de créer une macro appelée \argu{nom} qui représentera l'application affine qui
+transforme \argu{A} en \argu{A'}, et dont la partie linéaire est le dernier argument. Cette partie linéaire se
+présente sous la forme d'une liste de deux complexes: [Lf(1), Lf(i)] où Lf désigne la partie linéaire de la
+transformation.
+\end{itemize}
+
+
+\subsection{ftransform}
+
+\begin{itemize}
+\item \util \textbf[ftransform()]{ftransform( <liste>, <f(z)> )}
+\item \desc renvoie la liste des images des points de \argu{liste} par la fonction \argu{f(z)}, celle-ci peut-être une
+expression fonction de z ou une macro d'argument z.
+\end{itemize}
+
+\subsection{hom}
+
+\begin{itemize}
+\item \util \textbf[hom()]{hom( <liste>, <A>, <lambda> )}
+\item \desc renvoie la liste des images de la \argu{liste} par l'homothétie de centre \argu{A} et de rapport
+\argu{lambda}.
+\end{itemize}
+
+\subsection{inv}
+
+\begin{itemize}
+\item \util \textbf[inv()]{inv( <liste>, <A>, <R> )}
+\item \desc renvoie la liste des images des points de \argu{liste} par l'inversion de cercle de centre \argu{A} et de
+rayon \argu{R}.
+\end{itemize}
+
+\subsection{mtransform}
+\begin{itemize}
+\item \util \textbf[mtransform()]{mtransform( <liste>, <matrice> )}
+\item \desc renvoie la liste des images des points de \argu{liste} par l'application affine $f$ définie par la
+\argu{matrice}. Cette \Helpref{matrice}{macmatrix} est de la forme [f(0), Lf(1), Lf(i)] où Lf désigne la partie
+linéaire.
+\end{itemize}
+
+\subsection{proj}
+
+\begin{itemize}
+\item \util \textbf[proj()]{proj( <liste>, <A>, <B> )} ou \Mytextbf{proj( <liste>, <[A,B]> )}
+\item \desc renvoie la liste des projetés orthogonaux des points de \argu{liste} sur la droite $(AB)$.
+\end{itemize}
+
+
+\subsection{projO}
+
+\begin{itemize}
+\item \util \textbf[projO()]{projO( <liste>, <[A,B]>, <vecteur> )}
+\item \desc renvoie la liste des projetés des points de \argu{liste} sur la droite \argu{(AB)} dans la direction du
+\argu{vecteur}.
+\end{itemize}
+
+\subsection{rot}
+
+\begin{itemize}
+\item \util \textbf[rot()]{rot( <liste>, <A>, <alpha> )}
+\item \desc renvoie la liste des images des points de \argu{liste} par la rotation de centre \argu{A} et d'angle
+\argu{alpha}.
+\end{itemize}
+
+
+\subsection{shift}
+
+\begin{itemize}
+\item \util \textbf[shift()]{shift( <liste>, <vecteur> )}
+\item \desc renvoie la liste des translatés des points de \argu{liste} avec le \argu{vecteur}.
+\end{itemize}
+
+
+\subsection{simil}
+
+\begin{itemize}
+\item \util \textbf[simil()]{simil( <liste> , <A>, <lambda>, <alpha> )}
+\item \desc renvoie la liste des images des points de \argu{liste}, par la similitude de centre \argu{A}, de rapport
+\argu{lambda} et d'angle \argu{alpha}.
+\end{itemize}
+
+\subsection{sym}
+
+\begin{itemize}
+\item \util \textbf[sym()]{sym( <liste>, <A>, <B> )} ou \Mytextbf{sym( <liste>, <[A,B]> )}
+\item \desc renvoie la liste des symétriques des points de \argu{liste}, par rapport à la droite $(AB)$.
+\end{itemize}
+
+\subsection{symG}
+
+\begin{itemize}
+\item \util \textbf[symG()]{symG( <liste>, <A>, <vecteur> )}
+\item \desc symétrie glissée: renvoie la liste des images des points de \argu{liste}, par la symétrie orthogonale d'axe
+la droite passant par \argu{A} et dirigée par \argu{vecteur}, composée avec la translation de \argu{vecteur}.
+\end{itemize}
+
+\subsection{symO}
+
+\begin{itemize}
+\item \util \textbf[symO()]{symO( <liste>, <[A, B]>, <vecteur> )}
+\item \desc renvoie la liste des symétriques des points de \argu{liste} par rapport à la droite \argu{(AB)} et dans la
+direction du \argu{vecteur}.
+\end{itemize}
+
+
+\section{Matrices de transformations 2D}\label{macmatrix}
+
+Une transformation affine $f$ du plan complexe peut être représentée par son expression analytique dans la base canonique $(1,i)$, la forme générale de cette expression est:
+
+{\Large
+\[\left\{\begin{array}{rcl}
+ x'&=&t_1+ax+by\\
+y'&=&t_2+cx+dy
+ \end{array}\right.\]
+}
+
+cette expression analytique sera représentée par la liste \co{[t1+i*t2, a+i*c, b+i*d]} c'est à dire: \co{[ f(0), f(1)-f(0), f(i)-f(0)]}, cette liste sera appelée plus brièvement (et de manière abusive) \textit{matrice} de la transformation $f$. Les deux derniers éléments de cette liste: \co{[ a+i*c, b+i*d]}, représentent la matrice de la partie linéaire de $f$: Lf$=f-f(0)$.
+
+\subsection{ChangeWinTo}
+\begin{itemize}
+\item \util \textbf[ChangeWinTo()]{ChangeWinTo( <[xinf+i*yinf, xsup+i*ysup]> [, ortho] )}
+
+\item \desc modifie la matrice courante de manière à transformer la fenêtre courante en la fenêtre de grande diagonale \argu{[xinf+i*yinf, xsup+i*ysup]}, la fenêtre sera orthonormée ou non en fonction de la valeur du paramètre optionnel \argu{ortho} ($0$ par défaut).
+\end{itemize}
+
+
+\begin{demo}{Utilisation de ChangeWinTo}{ChangeWinTo}
+\begin{texgraph}[name=ChangeWinTo,export=pgf]
+view(-10,10,-5,5),size(7.5),NbPoints:=100,
+LabelSize:=footnotesize, SaveWin(),view(-10,-1,-5,5),
+ChangeWinTo([-2-2*i,2+2*i]),
+Arrows:=1, axes(0,1+i),Arrows:=0,
+tMin:=-2, tMax:=2, Color:=red, Width:=8,
+Cartesienne(x*Ent(1/x)-1,5,1),
+Color:=blue,A:=(1+i)/4, Dparallelo(A,bar(A),-A),
+dep:=RealCoord(i*Im(A)), RestoreWin(), SaveWin(),
+//zoom
+view(1,10,-5,5), background(full,white),
+ChangeWinTo([-A,A]), Color:=black,
+arr:=RealCoord(-Re(A)+i*Im(A)*0.75),
+Arrows:=1, axes(0,A), Arrows:=0,
+tMin:=-0.25, tMax:=0.25, Color:=red, Width:=8,
+Cartesienne(x*Ent(1/x)-1,5,1),
+Color:=blue, Dparallelo(A,bar(A),-A),
+RestoreWin(),
+//trait
+Color:=blue, Arrows:=1,
+A:=ScrCoord(dep), B:=ScrCoord(arr),
+Bezier(A,A+3*exp(i*pi/2),B-3,B)
+\end{texgraph}
+\end{demo}
+
+
+\subsection{invmatrix}
+\begin{itemize}
+\item \util \textbf[invmatrix()]{invmatrix( <[f(0), Lf(1), Lf(i)]> )}
+\item \desc renvoie l'inverse de la matrice \argu{[f(0), Lf(1), Lf(i)]}, c'est à dire la matrice $[f^{-1}(0),
+Lf^{-1}(1), Lf^{-1}(i)]$ si elle existe.
+\end{itemize}
+
+\subsection{matrix}
+\begin{itemize}
+\item \util \textbf[matrix()]{matrix( <fonction affine>, [variable] )}
+\item \desc renvoie la matrice de la \argu{fonction affine}, par défaut la \argu{variable} est $z$. Cette matrice se
+présente sous la forme [f(0), Lf(1), Lf(i)], où f désigne l'application affine et Lf sa partie linéaire, plus
+précisément: Lf(1)=f(1)-f(0) et Lf(i)=f(i)-f(0).
+\item \exem \co{matrix(i*bar(z))} renvoie \res{[0,i,1]}.
+\end{itemize}
+
+
+\subsection{mulmatrix}
+\begin{itemize}
+\item \util \textbf[mulmatrix()]{mulmatrix( <[f(0), Lf(1), Lf(i)]>, <[g(0), Lg(1), Lg(i)]> )}
+\item \desc renvoie la matrice de la composée: $fog$, où $f$ et $g$ sont les deux applications affines définies par les
+matrices passées en argument.
+\end{itemize}
+
+\section{Constructions géométriques planes}
+
+Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets.
+
+\subsection{bissec}
+\begin{itemize}
+\item \util \textbf[bissec()]{bissec( <B>, <A>, <C>, <1 ou 2> )}
+\item \desc renvoie une liste de deux points de la bissectrice, 1=intérieure.
+\end{itemize}
+
+\subsection{cap}
+\begin{itemize}
+\item \util \textbf[cap()]{cap( <ensemble1>, <ensemble2> )}
+\item \desc renvoie le contour de l'intersection de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de
+points. Ces deux ensembles sont des lignes polygonales représentant des courbes fermées, orientées dans le meme
+sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles.
+\item \exem intersection de deux ensembles:
+\end{itemize}
+
+
+\begin{demo}{macro cap}{cap}
+\begin{texgraph}[name=cap, export=pgf]
+Marges(0,0,0,0),size(7.5),
+A:=set("A", 0, [rotation:=30]),
+B:=set("B", 0, [rotation:=-30]),
+C:= cap(A,B),Color:=red,FillStyle:=full,
+FillOpacity:=0.5, FillColor:=pink,
+Ligne(C,0)
+\end{texgraph}
+\end{demo}
+
+\subsection{capB}\label{maccapB}
+\begin{itemize}
+\item \util \textbf[capB()]{capB( <ensemble1>, <ensemble2> )}
+\item \desc renvoie le contour de l'intersection de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de
+points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. Ces deux ensembles sont
+doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
+ayant une forme relativement simple. La macro \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles.
+\item \exem intersection de deux ensembles:
+\end{itemize}
+
+
+\begin{demo}{macro capB}{capB}
+\begin{texgraph}[name=capB, export=pgf]
+Marges(0,0,0,0),size(7.5),
+A:=setB("A", 0, [rotation:=30]),
+B:=setB("B", 0, [rotation:=-30]),
+C:= capB(A,B),Color:=red,FillStyle:=full,
+drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
+\end{texgraph}
+\end{demo}
+
+\subsection{carre}
+\begin{itemize}
+\item \util \textbf[carre()]{carre( <A>, <B>, <1 ou -1> )}
+\item \desc renvoie la liste des sommets du carré de sommets consécutifs A et B, 1=sens direct.
+\end{itemize}
+
+\subsection{cup}
+\begin{itemize}
+\item \util \textbf[cup()]{cup( <ensemble1>, <ensemble2> )}
+\item \desc renvoie le contour de la réunion de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles.
+\item \exem réunion de deux ensembles:
+\end{itemize}
+
+\begin{demo}{macro cup}{cup}
+\begin{texgraph}[name=cup, export=pgf]
+Marges(0,0,0,0),size(7.5),
+A:=set("A", 0, [rotation:=30]),
+B:=set("B", 0, [rotation:=-30]),
+C:= cup(A,B),Color:=red,FillStyle:=full,
+FillOpacity:=0.5, FillColor:=pink,
+Ligne(C,0)
+\end{texgraph}
+\end{demo}
+
+\subsection{cupB}\label{maccupB}
+\begin{itemize}
+\item \util \textbf[cupB()]{cupB( <ensemble1>, <ensemble2> )}
+\item \desc renvoie le contour de la réunion de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de
+points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. Ces deux ensembles sont
+doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
+ayant une forme relativement simple. La macro \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles.
+\item \exem intersection de deux ensembles:
+\end{itemize}
+
+\begin{demo}{macro cupB}{cupB}
+\begin{texgraph}[name=cupB, export=pgf]
+Marges(0,0,0,0),size(7.5),
+A:=setB("A", 0, [rotation:=30]),
+B:=setB("B", 0, [rotation:=-30]),
+C:= cupB(A,B),Color:=red,FillStyle:=full,
+drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
+\end{texgraph}
+\end{demo}
+
+\subsection{cutBezier}
+\begin{itemize}
+\item \util \textbf[cutBezier()]{cutBezier( <courbe de bézier>, <point>, <avant(0/1)> )}
+\item \desc renvoie un arc de bézier correspondant à la \argu{courbe de bézier} coupée avant ou après le \argu{point},
+en fonction du paramètre \argu{avant}. Le résultat doit être dessiné par la commande \Helpref{Bezier}{cmdBezier}.
+\end{itemize}
+
+
+\subsection{Cvx2d}
+\begin{itemize}
+\item \util \textbf[Cvx2d()]{Cvx2d( <liste> )}
+\item \desc renvoie l'enveloppe convexe de la \argu{liste} selon l'algorithme de \textsc{Ronald Graham}. La \argu{liste} ne doit pas contenir la constante \jump.
+\item \exem on choisit aléatoirement $10$ points dans le pavé $[-4,4]\times[-4,4]$ que l'on place dans une variable $P$
+tout en dessinant chacun d'eux avec son numéro, puis on dessine l'enveloppe convexe.
+\end{itemize}
+
+\begin{demo}{macro Cvx2d}{Cvx2d}
+\begin{texgraph}[name=Cvx2d, export=pgf]
+Marges(0,0,0,0),size(7.5),
+P:= for k from 1 to 10 do
+ z:=8*Rand()-4+i*(8*Rand()-4),
+ LabelDot(z, k,"N",1), z
+ od,
+Ligne(Cvx2d(P),1)
+\end{texgraph}
+\end{demo}
+
+
+\subsection{Intersec}
+\begin{itemize}
+\item \util \textbf[Intersec()]{Intersec( <objet1>, <objet2> )}
+\item \desc renvoie la liste des points d'intersection des deux objets graphiques. Ces deux objets peuvent être soit des
+commandes graphiques (Cercle(), Droite(), ...) ou bien le nom d'un élément graphique déjà créé.
+\item \exem la commande \co{Intersec( Cercle(0, 1), Droite(-1,i/2) )} renvoie:
+
+\centerline{\res{[0.59851109463416+0.79925554731708*i, -0.99794539275033+0.00102730362483*i]}.}
+\end{itemize}
+
+
+\subsection{med}
+\begin{itemize}
+\item \util \textbf[med()]{med( <A>, <B> )}
+\item \desc renvoie une liste de deux points de la médiatrice de $[A,B]$.
+\end{itemize}
+
+\subsection{parallel}
+\begin{itemize}
+\item \util \textbf[parallel()]{parallel( <[A,B]>, <C> )}
+\item \desc renvoie une liste de deux points de la parallèle à $(AB)$ passant par $C$.
+\end{itemize}
+
+
+\subsection{parallelo}
+\begin{itemize}
+\item \util \textbf[parallelo()]{parallelo( <A>, <B>, <C> )}
+\item \desc renvoie la liste des sommets du parallèlogramme de sommets consécutifs $A$, $B$, $C$.
+\end{itemize}
+
+\subsection{perp}
+\begin{itemize}
+\item \util \textbf[perp()]{perp( <[A, B]>, <C> )}
+\item \desc renvoie une liste de deux points de la perpendiculaire à $(AB)$ passant par $C$.
+\end{itemize}
+
+
+\subsection{polyreg}
+\begin{itemize}
+\item \util \textbf[polyreg()]{polyreg( <A>, <B>, <nombre de cotés> )}
+\item \desc renvoie la liste des sommets du polygône régulier de centre $A$, passant par $B$ et avec le nombre de côtés indiqué.
+\end{itemize}
+
+ou
+
+\begin{itemize}
+\item \util \Mytextbf{polyreg( <A>, <B>, <nombre de cotés + i*sens> )} avec sens = +/-1
+\item \desc renvoie la liste des sommets du polygône régulier de sommets consécutifs $A$ et $B$, avec le nombre de côtés indiqué et dans le sens indiqué (1 pour le sens trigonométrique).
+\end{itemize}
+
+\subsection{pqGoneReg}
+\begin{itemize}
+\item \util \textbf[pqGoneReg()]{pqGoneReg( <centre>, <sommet>, <[p,q]> )}
+\item \desc renvoie la liste des sommets du \argu{p/q}-gône régulier défini par le \argu{centre} et un \argu{sommet}.
+\item \exem voir \Helpref{ici}{macDpqGoneReg}.
+\end{itemize}
+
+
+\subsection{rect}
+\begin{itemize}
+\item \util \textbf[rect()]{rect( <A>, <B>, <C> )}
+\item \desc renvoie la liste des sommets du rectangle de sommets consécutifs $A$, $B$, le côté opposé passant par $C$.
+\end{itemize}
+
+\subsection{setminus}
+\begin{itemize}
+\item \util \textbf[setminus()]{setminus( <ensemble1>, <ensemble2> )}
+\item \desc renvoie le contour de la différence \argu{ensemble1} - \argu{ensemble2} sous forme d'une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles.
+\item \exem différence de deux ensembles:
+\end{itemize}
+
+\begin{demo}{macro setminus}{setminus}
+\begin{texgraph}[name=setminus, export=pgf]
+Marges(0,0,0,0),size(7.5),
+A:=set("A", 0, [rotation:=30]),
+B:=set("B", 0, [rotation:=-30]),
+C:= setminus(A,B),Color:=red,FillStyle:=full,
+FillOpacity:=0.5, FillColor:=pink,
+Ligne(C,0)
+\end{texgraph}
+\end{demo}
+
+\subsection{setminusB}\label{macsetminusB}
+\begin{itemize}
+\item \util \textbf[setminusB()]{setminusB( <ensemble1>, <ensemble2> )}
+\item \desc renvoie le contour de la différence \argu{ensemble1} - \argu{ensemble2} sous forme d'une liste de
+points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. Ces deux ensembles sont
+doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
+ayant une forme relativement simple. La macro \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles.
+\item \exem différence de deux ensembles:
+\end{itemize}
+
+\begin{demo}{macro setminusB}{setminusB}
+\begin{texgraph}[name=setminusB, export=pgf]
+Marges(0,0,0,0),size(7.5),
+A:=setB("A", 0, [rotation:=30]),
+B:=setB("B", 0, [rotation:=-30]),
+C:= setminusB(A,B),Color:=red,FillStyle:=full,
+drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
+\end{texgraph}
+\end{demo}
+
+\section{Gestion du flattened postscript}
+
+Il est possible de transformer un fichier pdf ou un fichier postscript en \textit{flattened postscript} grâce à l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). Dans le fichier obtenu, tout est chemin, y compris le texte. TeXgraph peut récupérer tous les chemins d'un fichier écrit en \textit{flattened postscript}. C'est que proposent les macros de cette section.
+
+\subsection{conv2FlatPs}\label{macconv2FlatPs}
+
+\begin{itemize}
+\item \util \textbf[conv2FlatPs()]{conv2FlatPs( <fichier entrée>, <fichier sortie> [, dossier de travail] )}
+\item \desc cette macro invoque l'utilitaire \textit{pstoedit} pour transformer le \argu{fichier entrée} en \textit{flattened postscript} dans le \argu{fichier sortie}. Le fichier \argu{fichier entrée} doit être un fichier pdf ou ps.
+\end{itemize}
+
+\subsection{drawFlatPs}\label{macdrawFlatPs}
+\begin{itemize}
+\item \util \textbf[drawFlatPs()]{drawFlatPs( <affixe>, <chemins lus par loadFlatPs> [, options] )}
+\item \desc cette macro dessine à l'écran l'ensemble des chemins lus dans un fichier en \textit{flattened postscript} par la macro \Helpref{loadFlatPs}{macloadFlatPs}. L'affichage se fait à l'\argu{affixe} demandé. Le paramètre \argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les options sont:
+ \begin{itemize}
+ \item \opt{scale}{nombre positif}: échelle, 1 par défaut.
+ \item \opt{position}{center/left/right/...}: position de l'affixe par rapport à l'image, center par défaut (fonctionne comme la variable LabelStyle).
+ \item \opt{color}{couleur}: pour imposer une couleur, \Nil par défaut ce qui signifie qu'on prend la couleur d'origine.
+ \item \opt{rotation}{angle en degrés}: 0 par défaut.
+ \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués.
+ \item \opt{select}{liste des numéros de chemin à montrer}: \Nil par défaut, ce qui signifie tous les chemins.
+ \end{itemize}
+
+\end{itemize}
+
+\subsection{drawTeXlabel}\label{macdrawTeXlabel}
+\begin{itemize}
+\item \util \textbf[drawTeXlabel()]{drawTeXlabel( <affixe>, <variable contenant la formule TeX lue par loadFlatPs>, [, options] )}
+\item \desc cette macro invoque la macro \Helpref{drawFlatPs}{macdrawFlatPs} pour dessiner une expression qui a été au
+préalable compilée par \TeX. Le paramètre \argu{options} est une liste (facultative) de la forme \textsl{[ option1:=
+valeur1, ..., optionN:=valeurN ]}, les options sont:
+
+ \begin{itemize}
+ \item \opt{scale}{nombre>0}: échelle, 1 par défaut.
+ \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués.
+ \end{itemize}
+Cette macro est utilisée en interne par la macro \Helpref{NewTeXlabel}{macNewTeXlabel}.
+\end{itemize}
+
+
+\subsection{loadFlatPs}\label{macloadFlatPs}
+\begin{itemize}
+\item \util \textbf[loadFlatPs()]{loadFlatPs( <fichier en flattened postscript>, [, options] )}
+\item \desc cette macro charge un \argu{fichier en flattened postscript}, adpate les coordonnées des points et renvoie
+la liste des chemins (que l'on peut alors dessiner avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}). Le paramètre
+\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les
+options sont:
+ \begin{itemize}
+ \item \opt{width}{nombre>0}: largeur en cm, \Nil par défaut pour largeur naturelle.
+ \item \opt{height}{nombre>0}: hauteur en cm, \Nil par défaut pour hauteur naturelle.
+ \end{itemize}
+\item supposons que vous ayez le fichier \textit{circuit.pdf} dans le dossier temporaire de TeXgraph, la commande
+suivante dans un élément graphique Utilisateur:
+\end{itemize}
+
+\begin{verbatim}
+ [conv2FlatPs( "circuit.pdf", "circuit.fps", @TmpPath),
+ stock:= loadFlatPs( [@TmpPath,"circuit.fps"] ),
+ drawFlatPs( 0, stock, [scale:=1, hollow:=1] )
+ ]
+\end{verbatim}
+
+va permettre de charger et dessiner le contenu de ce fichier dans TeXgraph, sans faire les remplissages.
+
+
+\subsection{NewTeXlabel}\label{macNewTeXlabel}
+\begin{itemize}
+\item \util \textbf[NewTeXlabel()]{NewTeXlabel( <nom>, <affixe>, <formule TeX>, [, options] )}
+\item \desc cette macro va demander à \TeX{} de compiler la formule dans un fichier pdf, ce fichier sera ensuite
+converti
+en un fichier eps par pstoedit, puis celui-ci sera chargé par loadFlatPs et stocké dans une variable globale appelée
+TeX\_+nom. Un élément graphique appelé \argu{nom} est créée pour dessiner la formule avec drawTeXLabel. Le paramètre
+\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les
+options sont:
+ \begin{itemize}
+ \item \opt{dollar}{0/1}: indique à TeXgraph s'il doit ajouter les délimiteurs \verb|\[| et \verb|\]| autour de la formule, 1 par défaut.
+ \item \opt{scale}{nombre>0}: échelle, 1 par défaut.
+ \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués.
+ \end{itemize}
+Dans les options, les attributs suivants peuvent également être utilisés: \var{LabelStyle}, \var{LabelAngle} et
+\var{Color}.
+
+Voici la définition de cette macro:
+
+\begin{small}
+\begin{verbatim}
+[dollar:=1, scale:=1, hollow:=0, $options:=%4,
+ $aux:=OpenFile([@TmpPath,"formula.tex"]),
+ if dollar then WriteFile(["\[",%3,"\]"]) else WriteFile(%3) fi,
+ CloseFile(),
+ Exec("pdflatex","-interaction=nonstopmode tex2FlatPs.tex",@TmpPath,1),
+ Exec("pstoedit -dt -pta -f ps -r2400x2400","tex2FlatPs.pdf tex2FlatPs.eps",@TmpPath,1),
+ NewVar(["TeX_",%1],loadFlatPs([@TmpPath,"tex2FlatPs.eps"])),
+ NewGraph(%1, ["drawTeXlabel(",%2,", TeX_",%1,", [scale:=",scale,", hollow:=",hollow,"])"]),
+ ReDraw()
+]
+\end{verbatim}
+\end{small}
+
+La formule est écrite dans le fichier \textit{formula.tex}, puis on compile le fichier \textit{tex2FlatPs.tex} suivant:
+
+\begin{verbatim}
+ \documentclass[12pt]{article}
+ \usepackage{amsmath,amssymb}
+ \usepackage{fourier}
+ \pagestyle{empty}
+ \begin{document}
+ \large
+ \input{formula.tex}%
+ \end{document}
+\end{verbatim}
+
+et on convertit le résultat en \textit{flattened postscript} avant de le charger.
+
+Cette macro s'utilise dans la ligne de commande ou bien dans des macros qui créent des éléments graphiques, mais pas directement dans un élément graphique Utilisateur, exemple:
+
+\centerline{\co{NewTeXlabel( "label1", 0, "\bks frac\{\bks pi\}\{\bks sqrt\{2\}\}", [scale:=1.5, Color:=blue, LabelAngle:=45])}}
+\end{itemize}
+
+
+\section{Autres}
+
+\subsection{pdfprog}
+\begin{itemize}
+\item \util \textbf[pdfprog()]{pdfprog()}.
+\item \desc cette macro est utilisée en interne pour mémoriser le programme utilisé pour faire la conversion
+ du format eps vers le format pdf. Par défaut, cette macro contient la chaine: \textsl{"epstopdf"}. En éditant le fichier TeXgraph.mac, vous pouvez modifier le programme utilisé.
+\end{itemize}
+
+
+
+
--- /dev/null
+#docu {
+ margin : 10px 15px 10px 50px;
+}
+
+#docu h1 {
+ margin-left : -30px;
+ color : #666;
+}
+
+#docu h2 {
+ margin-left : -15px;
+ color : #777;
+ border-bottom : 1px solid #964;
+}
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<page>
+ <titre>Documentation de TeXgraph</titre>
+ <div id="docu">
+ <segment f="chap05.html"/>
+ <segment f="chap07.html"/>
+ </div>
+</page>
--- /dev/null
+#!/usr/bin/perl
+
+use File::Basename;
+
+our ($nom, $dir, $ext) = fileparse($ARGV[0],qr{\..*});
+our $tex = qx{cat $ARGV[0]};
+
+## === Filtres amont -----------------------------------------------------------
+$tex =~ s{\\util\s+}{}g;
+$tex =~ s/\\label\{.+?\}//g;
+$tex =~ s/\\opt\s*\{/\\modifopt\{/g;
+$tex =~ s{\\desc\s+}{§§desc§:}g;
+$tex =~ s/\\textbf\s*\[(.+?)\]\s*(\{(?:[^\{\}]++|(?2))*\})/§§textbf§$1§$2§:/g;
+$tex =~ s/\\centerline\s*(\{(?:[^\{\}]++|(?1))*\})/§§centerline§$1§:/g;
+
+## === Fichier temporaire et transformation ------------------------------------
+open TMP, ">temp.tex";
+print TMP &pretex();
+print TMP $tex;
+close TMP;
+qx{pandoc --ascii temp.tex -o temp.html};
+
+our $html = qx{cat temp.html};
+## === Filtres aval ------------------------------------------------------------
+$html =~ s/\&\#167\;/§/g;
+$html =~ s/§§bks§:\s*/\&\#92\;/g;
+$html =~ s{§§exem§:}{<u>Exemple(s)</u> : }g;
+$html =~ s/§§textbf§(.*?)§\{(.*?)\}§:/<b>$2<\/b>/g;
+$html =~ s/§§desc§:/<u>Description<\/u> : /g;
+$html =~ s{§§opt§(.+?)§:}{<span style="color:blue">$1</span>}g;
+$html =~ s{§§helpref§(.+?)§(.+?)§:}{&helpa($1,$2)}ge;
+$html =~ s{§§span§co§(.+?)§:}{<span style="color:red">$1</span>}g;
+$html =~ s{§§span§var§(.+?)§:}{<span style="font-style:italic;color:red">$1</span>}g;
+$html =~ s{§§span§res§(.+?)§:}{<span style="color:magenta">$1</span>}g;
+$html =~ s{§§textsl§(.+?)§:}{<span style="font-style:italic">$1</span>}g;
+$html =~ s{§§centerline§\{(.+?)\}§:}{<div style="text-align:center">$1</div>}g;
+$html =~ s{<h3 id="(.+?)">(.+?)</h3>}{&modh3($1,$2)}ge;
+$html =~ s{<h2 id="(.+?)">(.+?)</h2>}{&modh2($1,$2)}ge;
+
+
+## === Fichier final -----------------------------------------------------------
+open HTM, ">$nom.html";
+print HTM $html;
+close HTM;
+
+
+sub pretex {
+ return << "eop";
+\\newcommand{\\argu}[1]{<\\textit{#1}>}
+\\newcommand{\\exem}{§§exem§:}
+\\newcommand{\\Nil}{\\textit{Nil}}
+\\newcommand{\\jump}{\\textit{jump}}
+\\newcommand{\\var}[1]{§§span§var§#1§:}
+\\newcommand{\\co}[1]{§§span§co§#1§:}
+\\newcommand{\\res}[1]{§§span§res§#1§:}
+\\newcommand{\\Mytextbf}[1]{\\textbf{#1}}
+\\newcommand{\\textsl}[1]{§§textsl§#1§:}
+\\newcommand{\\modifopt}[2]{§§opt§#1 := < #2 >§:}
+\\newcommand{\\Helpref}[2]{§§helpref§#1§#2§:}
+\\newcommand{\\bks}{§§bks§:}
+eop
+}
+
+sub modh3 {
+ my ($i, $c) = @_;
+ if ("\U$i" eq "\U$c") {
+ return qq{<h3 id="$c">$c</h3>};
+ } else {
+ return qq{<h3 id="$i">$c</h3>};
+ }
+}
+
+sub modh2 {
+ my ($i, $c) = @_;
+ if ("\U$i" eq "\U$c") {
+ return qq{<h2 id="$c">$c</h3>};
+ } else {
+ return qq{<h2 id="$i">$c</h3>};
+ }
+}
+
+sub helpa {
+ my ($a, $b) =@_;
+ $a =~ s/^\{|\}$//g;
+ $b =~ s/^cmd|^mac//;
+ return qq{<a href="#$b">$a</a>};
+}
\ No newline at end of file
* Release Version: 1.0.0.0
* Date Started: 2011/09/18
*
- * Metapost language file for GeSHi.
+ * TeXgraph language file for GeSHi.
*
*
*************************************************************************************
2 => '',
3 => '',
4 => '',
- 5 => '',
+ 5 => 'http://melusine.eu.org/G/geshi/docs/texgraph/#{FNAME}',
6 => '',
7 => '',
8 => '',
Projets / geshi.git / commitdiff
Les fichiers de Syracuse sont mis à
disposition (sauf mention contraire) selon les termes de la