--- /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>
Projets / geshi.git / blobdiff
Les fichiers de Syracuse sont mis à
disposition (sauf mention contraire) selon les termes de la