Introduction de la doc en ligne de TeXgraph... pour tester :)

[geshi.git] / docs / texgraph / chap07.html

<h1 id="les-macros-math&#233;matiques-de-texgraph.mac">Les macros math&#233;matiques de TeXgraph.mac</h1>
<h2 id="op&#233;rations-arithm&#233;tiques-et-logiques">Op&#233;rations arithm&#233;tiques et logiques</h2>
<h3 id="Ceil">Ceil</h3>
<ul>
<li><p><b>Ceil( &lt;x&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le plus petit entier sup&#233;rieur ou &#233;gal au r&#233;el &lt;<em>x</em>&gt;.</p></li>
</ul>
<h3 id="div">div</h3>
<ul>
<li><p><b>div( &lt;x&gt;, &lt;y&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie l&#8217;unique entier <span class="math"><em>k</em></span> tel que <span class="math"><em>x</em>&#8197;-&#8197;<em>k</em><em>y</em></span> soit dans l&#8217;intervalle <span class="math">[0;&#8198;&#8739;<em>y</em>&#8739;[</span>.</p></li>
</ul>
<h3 id="mod">mod</h3>
<ul>
<li><p><b>mod( &lt;x&gt;, &lt;y&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie l&#8217;unique r&#233;el <span class="math"><em>r</em></span> de l&#8217;intervalle <span class="math">[0;&#8198;&#8739;<em>y</em>&#8739;[</span> tel que <span class="math"><em>x</em>&#8196;=&#8196;<em>k</em><em>y</em>&#8197;+&#8197;<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( &lt;expression bool&#233;enne&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la valeur bool&#233;enne de la n&#233;gation.</p></li>
</ul>
<h3 id="pgcd">pgcd</h3>
<ul>
<li><p><b>pgcd( &lt;a&gt;, &lt;b&gt; [, &lt;u&gt;, &lt;v&gt;] )</b></p></li>
<li><p><u>Description</u> : renvoie la valeur d du pgcd de &lt;<em>a</em>&gt; et &lt;<em>b</em>&gt;, ainsi que deux coefficients de Bezout dans les variables &lt;<em>u</em>&gt; et &lt;<em>v</em>&gt; (si celles-ci sont pr&#233;sentes), de telle sorte que <span class="math"><em>a</em><em>u</em>&#8197;+&#8197;<em>b</em><em>v</em>&#8196;=&#8196;<em>d</em></span>.</p></li>
</ul>
<h3 id="ppcm">ppcm</h3>
<ul>
<li><p><b>ppcm( &lt;a&gt;, &lt;b&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la valeur du ppcm de &lt;<em>a</em>&gt; et &lt;<em>b</em>&gt;.</p></li>
</ul>
<h2 id="op&#233;rations-sur-les-variables">Op&#233;rations sur les variables</h2>
<h3 id="Abs">Abs</h3>
<ul>
<li><p><b>Abs( &lt;affixe&gt; )</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( &lt;x&gt; )</b>.</p></li>
<li><p><u>Description</u> : lib&#232;re la variable &lt;<em>x</em>&gt; en la mettant &#224; <em>Nil</em>. Depuis la version 1.93 on peut faire directement l&#8217;affectation &#224; 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( &lt;affixe&gt; [, &lt;epsilon&gt;] )</b>.</p></li>
<li><p><u>Description</u> : renvoie 1 si l&#8217;&lt;<em>affixe</em>&gt; est dans la fen&#234;tre graphique, 0 sinon. Cette macro tient compte de la matrice courante, le test se fait &#224; &lt;<em>epsilon</em>&gt; pr&#232;s et &lt;<em>epsilon</em>&gt; vaut 0.0001 cm par d&#233;faut.</p></li>
</ul>
<h3 id="nil">nil</h3>
<ul>
<li><p><b>nil( &lt;x&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie 1 si la variable &lt;<em>x</em>&gt; est &#224; <em>Nil</em>, 0 sinon. Depuis la version 1.93 on peut faire directement le test d&#8217;&#233;galit&#233; avec la constante <em>Nil</em>.</p></li>
</ul>
<h3 id="round">round</h3>
<ul>
<li><p><b>round( &lt;liste&gt; [, d&#233;cimales] )</b></p></li>
<li><p><u>Description</u> : tronque les complexes de la &lt;<em>liste</em>&gt; en arrondissant au plus proche les parties r&#233;elles et imaginaires avec le nombre de &lt;<em>d&#233;cimales</em>&gt; demand&#233; (0 par d&#233;faut). Si la &lt;<em>liste</em>&gt; contient le constante <em>jump</em>, alors celle-ci est renvoy&#233;e dans la liste des r&#233;sultats. Cette macro utilise la commande <a href="#Round">Round</a> (qui ne s&#8217;applique qu&#8217;&#224; un complexe et non une liste).</p></li>
</ul>
<h2 id="op&#233;rations-sur-les-listes">Op&#233;rations sur les listes</h2>
<h3 id="bary">bary</h3>
<ul>
<li><p><b>bary( &lt;[affixe1, coef1, affixe2, coef2, ...]&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le barycentre du syst&#232;me pond&#233;r&#233; &lt;<em>[(affixe1, coef1), (affixe2, coef2),...]</em>&gt;.</p></li>
</ul>
<h3 id="del">del</h3>
<ul>
<li><p><b>del( &lt;liste&gt;, &lt;liste des index &#224; supprimer&gt;, &lt;quantit&#233; &#224; supprimer&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie la liste apr&#232;s avoir supprimer les &#233;l&#233;ments dont l&#8217;index figure dans la &lt;<em>liste des index &#224; supprimer</em>&gt;. La &lt;<em>quantit&#233; &#224; supprimer</em>&gt; (&#224; chaque fois) est de <span class="math">1</span> par d&#233;faut, cet argument peut &#234;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( &lt;s&gt; , &lt;ligne polygonale&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le point de la &lt;<em>ligne polygonale</em>&gt; ayant &lt;<em>s</em>&gt; comme abscisse curviligne. Le param&#232;tre &lt;<em>s</em>&gt; doit &#234;tre dans l&#8217;intervalle <span class="math">[0;&#8198;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( &lt;liste points 2D&gt; [, epsilon] )</b>.</p></li>
<li><p><u>Description</u> : renvoie 1 si les points sont sur une m&#234;me droite, 0 sinon. Par d&#233;faut la tol&#233;rance &lt;<em>epsilon</em>&gt; vaut 1E-10. La &lt;<em>liste</em>&gt; ne doit pas contenir la constante <em>jump</em>.</p></li>
</ul>
<h3 id="isobar">isobar</h3>
<ul>
<li><p><b>isobar( &lt;[affixe1, affixe2, ...]&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie l&#8217;isobarycentre du syst&#232;me &lt;<em>[affixe1, affixe2, ...]</em>&gt;.</p></li>
</ul>
<h3 id="KillDup">KillDup</h3>
<ul>
<li><p><b>KillDup( &lt;liste&gt; [, epsilon] )</b>.</p></li>
<li><p><u>Description</u> : renvoie la liste sans doublons. Les comparaisons se font &#224; &lt;<em>epsilon</em>&gt; pr&#232;s (qui vaut <span class="math">0</span> par d&#233;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( &lt;liste&gt; )</b>.</p></li>
<li><p><u>Description</u> : calcule la longueur de la &lt;<em>liste</em>&gt; en cm.</p></li>
</ul>
<h3 id="permute">permute</h3>
<ul>
<li><p><b>permute( &lt;liste&gt; )</b>.</p></li>
<li><p><u>Description</u> : modifie la &lt;<em>liste</em>&gt; en pla&#231;ant le premier &#233;l&#233;ment &#224; la fin, &lt;<em>liste</em>&gt; doit &#234;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( &lt;affixe&gt;, &lt;liste&gt;, [, epsilon] )</b>.</p></li>
<li><p><u>Description</u> : renvoie la liste des positions de l&#8217;&lt;<em>affixe</em>&gt; dans la &lt;<em>liste</em>&gt;, la comparaison se fait &#224; &lt;<em>epsilon</em>&gt; pr&#232;s, par d&#233;faut &lt;<em>epsilon</em>&gt; 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( &lt;liste&gt; )</b>.</p></li>
<li><p><u>Description</u> : d&#233;termine le plus petit rectangle contenant la liste, cette macro renvoie une liste de deux complexes qui repr&#233;sentent l&#8217;affixe du coin inf&#233;rieur gauche suivi de celle du coin sup&#233;rieur droit.</p></li>
</ul>
<h3 id="replace">replace</h3>
<ul>
<li><p><b>replace( &lt;liste&gt;, &lt;position&gt;, &lt;valeur&gt; )</b>.</p></li>
<li><p><u>Description</u> : modifie la variable &lt;<em>liste</em>&gt; en rempla&#231;ant l&#8217;&#233;l&#233;ment num&#233;ro &lt;<em>position</em>&gt; par la &lt;<em>valeur</em>&gt;, cette macro renvoie <em>Nil</em>.</p></li>
</ul>
<h3 id="reverse">reverse</h3>
<ul>
<li><p><b>reverse( &lt;liste&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie la liste apr&#232;s avoir inverser chaque composante (deux composantes sont s&#233;par&#233;es par un <em>jump</em>).</p></li>
</ul>
<h3 id="SortWith">SortWith</h3>
<ul>
<li><p><b>SortWith( &lt;liste cl&#233;s&gt;, &lt;liste&gt;, &lt;taille paquets&gt; [, mode] )</b>.</p></li>
<li><p><u>Description</u> : trie la <strong>variable</strong> &lt;<em>liste</em>&gt; suivant les &lt;<em>cl&#233;s</em>&gt;. Les &#233;l&#233;ments de la &lt;<em>liste</em>&gt; sont trait&#233;s par &lt;<em>paquets</em>&gt;, leur taille est de 1 par d&#233;faut. La &lt;<em>taille paquets</em>&gt; peut &#234;tre &#233;gale &#224; <em>jump</em> pour un traitement par composante. Si un paquet n&#8217;est pas complet, il n&#8217;est pas trait&#233;. Si la liste contient la constante <em>jump</em>, alors toutes les composantes sont tri&#233;es chacune leur tour. Le dernier param&#232;tre d&#233;termine le type de tri: &lt;<em>mode</em>&gt;=0 pour ordre croissant (valeur par d&#233;faut), &lt;<em>mode</em>&gt;=1 pour d&#233;croissant.</p></li>
</ul>
<h2 id="gestion-des-listes-par-composantes">Gestion des listes par composantes</h2>
<p>La convention adopt&#233;e est que deux composantes sont s&#233;par&#233;es par la constante <em>jump</em>. Une composante peut &#234;tre vide.</p>
<h3 id="CpCopy">CpCopy</h3>
<ul>
<li><p><b>CpCopy( &lt;liste&gt;, &lt;index depart&gt;, &lt;nombre&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette fonction renvoie la liste constitu&#233;e par les &lt;<em>nombre</em>&gt; composantes de la &lt;<em>liste</em>&gt; &#224; partir de la composante num&#233;ro &lt;<em>depart</em>&gt;[inclus]. Si &lt;<em>nombre</em>&gt; est nul, alors la fonction renvoie toutes les composantes de la liste &#224; partir de la composante num&#233;ro &lt;<em>d&#233;part</em>&gt;.</p>
<p>Si le num&#233;ro &lt;<em>depart</em>&gt; est n&#233;gatif, alors la liste et parcourue de droite &#224; gauche en partant du dernier, la derni&#232;re composante a l&#8217;index <span class="math">&#8197;-&#8197;1</span>, l&#8217;avant-derni&#232;re a l&#8217;index <span class="math">&#8197;-&#8197;2</span> <span class="math">&#8943;</span> etc. La fonction renvoie les &lt;<em>nombre</em>&gt; composantes de la liste (ou toute la liste si &lt;<em>nombre</em>&gt; est nul) en allant vers la gauche, mais la liste renvoy&#233;e est dans le m&#234;me sens que la &lt;<em>liste</em>&gt;, et cette derni&#232;re n&#8217;est pas modifi&#233;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( &lt;variable liste&gt;, &lt;index depart&gt;, &lt;nombre&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette fonction d&#233;truit dans la &lt;<em>variable liste</em>&gt;, les &lt;<em>nombre</em>&gt; composantes &#224; partir de la composante num&#233;ro &lt;<em>depart</em>&gt;[inclus]. Si &lt;<em>nombre</em>&gt; est nul, alors la fonction d&#233;truit toutes les composantes de la &lt;<em>variable liste</em>&gt; &#224; partir de la composante num&#233;ro &lt;<em>d&#233;part</em>&gt;.</p>
<p>Si le num&#233;ro &lt;<em>depart</em>&gt; est n&#233;gatif, alors la liste et parcourue de droite &#224; gauche en partant du dernier, la derni&#232;re composante a l&#8217;index <span class="math">&#8197;-&#8197;1</span>, l&#8217;avant-derni&#232;re a l&#8217;index <span class="math">&#8197;-&#8197;2</span> <span class="math">&#8943;</span> etc. La fonction d&#233;truit les &lt;<em>nombre</em>&gt; composantes de la &lt;variable liste&gt; (ou toute la liste si &lt;<em>nombre</em>&gt; est nul) en allant vers la gauche.</p>
<p>Le param&#232;tre &lt;<em>variable liste</em>&gt; doit &#234;tre <strong>un nom de variable</strong>, celle-ci est modifi&#233;e et la macro renvoie <em>Nil</em>.</p></li>
</ul>
<h3 id="CpNops">CpNops</h3>
<ul>
<li><p><b>CpNops( &lt;liste&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette fonction &#233;value &lt;<em>liste</em>&gt; 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( &lt;variable liste&gt;, &lt;position&gt;, &lt;nouveau&gt; )</b>.</p></li>
<li><p><u>Description</u> : modifie la &lt;<em>variable liste</em>&gt; en rempla&#231;ant la composante num&#233;ro &lt;<em>position</em>&gt; par &lt;<em>nouveau</em>&gt;, cette macro renvoie <em>Nil</em>.</p></li>
</ul>
<h3 id="CpReverse">CpReverse</h3>
<ul>
<li><p><b>CpReverse( &lt;liste&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie la &lt;<em>liste</em>&gt; avec les composantes dans l&#8217;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&#238;nes">Gestion des listes de cha&#238;nes</h2>
<p>Une telle liste est en r&#233;alit&#233; une <strong>macro</strong>, les &#233;l&#233;ments sont index&#233;s &#224; partir de <span class="math">1</span>, et la cha&#238;ne num&#233;ro <span class="math"><em>k</em></span> est donn&#233;e par <code>@nomListe(k)</code>, alors que la longueur de la liste (nombre d&#8217;&#233;l&#233;ments) est donn&#233;e par <code>nomListe(0)</code>.</p>
<h3 id="StrListInit">StrListInit</h3>
<ul>
<li><p><b>StrListInit( &lt;nomListe&gt;, &lt;&quot;chaine1&quot;&gt;, &lt;&quot;chaine2&quot;&gt;, ... )</b>.</p></li>
<li><p><u>Description</u> : cr&#233;e une liste de chaines sous forme d&#8217;une macro appel&#233;e &lt;<em>nomListe</em>&gt;, les arguments suivants sont interpr&#233;t&#233;s comme des cha&#238;nes, ils constituent les &#233;l&#233;ments de la liste et sont index&#233;s &#224; partir de 1.</p></li>
<li><p><u>Exemple(s)</u> :  Apr&#232;s la commande <span style="color:red">StrListInit(essai, &quot;toto&quot;, [&quot;toto&quot;,2/4], 24)</span>, une macro du nom de <strong>essai</strong> est cr&#233;&#233;e et son contenu est:</p>
<pre><code>for $z in Args() do
  if z&lt;0 then Inc(z,4) fi,
  if z=0 then 3
  elif z=1 then &quot;toto&quot;
  elif z=2 then &quot;toto0.5&quot;
  elif z=3 then &quot;24&quot;
  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,&quot;<span class="math"><em>A</em></span>&quot;,&quot;O&quot;, i,&quot;<span class="math"><em>B</em></span>&quot;,&quot;N&quot;, 1,&quot;<span class="math"><em>C</em></span>&quot;,&quot;E&quot;, -i,&quot;<span class="math"><em>D</em></span>&quot;,&quot;S&quot;), 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 &#224; faire trois listes: nom, position, orientation:</p>
<pre><code> view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
 StrListInit( nom, &quot;$A$&quot;, &quot;$B$&quot;, &quot;$C$&quot;, &quot;$D$&quot;),
 StrListInit(orientation, &quot;O&quot;, &quot;N&quot;, &quot;E&quot;, &quot;S&quot;),
 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( &lt;nomListe&gt;, &lt;&quot;chaine1&quot;&gt;, &lt;&quot;chaine2&quot;&gt;, ... )</b>.</p></li>
<li><p><u>Description</u> : cette macro ajoute &#224; la fin de la liste de cha&#238;nes appel&#233;e &lt;<em>nomListe</em>&gt;, les arguments suivants (qui sont interpr&#233;t&#233;s comme des cha&#238;nes). Cela suppose que la liste &lt;<em>nomListe</em>&gt; existe d&#233;j&#224;, cette liste est en fait une macro qui va &#234;tre enti&#232;rement r&#233;&#233;crite pour lui ajouter les &#233;l&#233;ments suppl&#233;mentaires. Il est plus rapide de d&#233;finir la liste en une seule fois avec la macro <a href="#StrListInit">StrListInit</a> quand c&#8217;est possible.</p></li>
</ul>
<h3 id="StrListCopy">StrListCopy</h3>
<ul>
<li><p><b>StrListCopy( &lt;nomListe&gt;, &lt;nouvelleListe&gt; [, index depart, nombre] )</b>.</p></li>
<li><p><u>Description</u> : cette macro cr&#233;e une nouvelle liste de cha&#238;nes appel&#233;e &lt;<em>nouvelleListe</em>&gt; en copiant &lt;<em>nombre</em>&gt; &#233;l&#233;ments de la liste &lt;<em>nomListe</em>&gt; en partant de &lt;<em>index depart</em>&gt;. L&#8217;argument &lt;index depart&gt; peut &#234;tre n&#233;gatif (<span class="math">&#8197;-&#8197;1</span> designe le dernier &#233;l&#233;ment, <span class="math">&#8197;-&#8197;2</span> l&#8217;avant-dernier, ...), par contre les &#233;l&#233;ments sont toujours parcourus de gauche &#224; droite quand &lt;nombre&gt; est positif, et dans le sens inverse quand &lt;nombre&gt; est n&#233;gatif. Par d&#233;faut l&#8217;&lt;<em>index depart</em>&gt; vaut <span class="math">1</span> et le &lt;<em>nombre</em>&gt; vaut <span class="math">0</span> (ce qui signifie &#248;g tous les &#233;l&#233;ments).</p></li>
</ul>
<h3 id="StrListDelKey">StrListDelKey</h3>
<ul>
<li><p><b>StrListDelKey( &lt;nomListe&gt;, &lt;index depart&gt;, &lt;nombre&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette macro supprime de &lt;<em>nomListe</em>&gt; &lt;<em>nombre</em>&gt; &#233;l&#233;ments &#224; partir de l&#8217;&lt;<em>index depart</em>&gt;. Comme dans la commande Del, l&#8217;argument &lt;<em>index depart</em>&gt; peut &#234;tre n&#233;gatif (<span class="math">&#8197;-&#8197;1</span> designe le dernier &#233;l&#233;ment, <span class="math">&#8197;-&#8197;2</span> l&#8217;avant-dernier, ...), par contre les &#233;l&#233;ments sont toujours parcourus de gauche &#224; droite quand &lt;nombre&gt; est positif, et dans le sens inverse quand &lt;nombre&gt; est n&#233;gatif. Cette macro renvoie <em>Nil</em>.</p></li>
</ul>
<h3 id="StrListDelVal">StrListDelVal</h3>
<ul>
<li><p><b>StrListDelVal( &lt;nomListe&gt;, &lt;val1&gt;, &lt;val2&gt;, ... )</b>.</p></li>
<li><p><u>Description</u> : cette macro supprime de &lt;<em>nomListe</em>&gt; les cha&#238;nes &lt;<em>val1</em>&gt;, &lt;<em>val2</em>&gt;..., sans avoir &#224; conna&#238;tre leurs index.</p></li>
</ul>
<h3 id="StrListGetKey">StrListGetKey</h3>
<ul>
<li><p><b>StrListGetKey( &lt;nomListe&gt;, &lt;chaine&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette macro renvoie l&#8217;index de la &lt;<em>cha&#238;ne</em>&gt; dans la liste &lt;<em>nomListe</em>&gt;, si elle n&#8217;y figure pas, la macro renvoie <em>Nil</em>.</p></li>
</ul>
<h3 id="StrListInsert">StrListInsert</h3>
<ul>
<li><p><b>StrListInsert( &lt;nomListe1&gt;, &lt;cha&#238;ne&gt; [, &lt;index&gt; ])</b>.</p></li>
<li><p><u>Description</u> : cette macro modifie la liste de chaines &lt;<em>nomListe</em>&gt;, en ins&#233;rant une nouvelle &lt;<em>cha&#238;ne</em>&gt; &#224; la position &lt;<em>index</em>&gt;. Par d&#233;faut la valeur de &lt;<em>index</em>&gt; est nulle ce qui repr&#233;sente la fin de la liste, cette valeur peut &#234;tre n&#233;gative (<span class="math">&#8197;-&#8197;1</span> est l&#8217;index du dernier &#233;l&#233;ment, <span class="math">&#8197;-&#8197;2</span> l&#8217;avant-dernier, ...).</p></li>
</ul>
<h3 id="StrListKill">StrListKill</h3>
<ul>
<li><p><b>StrListKill( &lt;nomListe1&gt;, &lt;nomListe2&gt;, ... )</b>.</p></li>
<li><p><u>Description</u> : cette macro d&#233;truit les listes de cha&#238;nes &lt;<em>nomListe1</em>&gt;, &lt;<em>nomListe2</em>&gt;, ...</p></li>
</ul>
<h3 id="StrListReplace">StrListReplace</h3>
<ul>
<li><p><b>StrListReplace( &lt;nomListe&gt;, &lt;ancienne chaine&gt;, &lt;nouvelle&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette macro remplace dans la liste appel&#233;e &lt;<em>nomListe</em>&gt;, l&#8217;&lt;<em>ancienne chaine</em>&gt; par la &lt;<em>nouvelle</em>&gt;.</p></li>
</ul>
<h3 id="StrListReplaceKey">StrListReplaceKey</h3>
<ul>
<li><p><b>StrListReplaceKey( &lt;nomListe&gt;, &lt;index&gt;, &lt;nouvelle cha&#238;ne&gt; )</b>.</p></li>
<li><p><u>Description</u> : cette macro remplace dans la liste appel&#233;e &lt;<em>nomListe</em>&gt;, la cha&#238;ne dont le num&#233;ro est&lt;<em>index</em>&gt;, par la &lt;<em>nouvelle cha&#238;ne</em>&gt;.</p></li>
</ul>
<h3 id="StrListShow">StrListShow</h3>
<ul>
<li><p><b>StrListShow( &lt;nomListe&gt; [, &lt;index depart&gt;, &lt;nombre&gt; ])</b>.</p></li>
<li><p><u>Description</u> : cette macro renvoie la cha&#238;ne obtenue en copiant &lt;<em>nombre</em>&gt; &#233;l&#233;ments de la liste &lt;<em>nomListe</em>&gt; en partant de &lt;<em>index depart</em>&gt;, mais sans les concat&#233;ner. La cha&#238;ne renvoy&#233;e est de la forme: <code>&quot;chaine&quot;, &quot;chaine&quot;, ...</code>. L&#8217;argument &lt;index depart&gt; peut &#234;tre n&#233;gatif (<span class="math">&#8197;-&#8197;1</span> designe le dernier &#233;l&#233;ment, <span class="math">&#8197;-&#8197;2</span> l&#8217;avant-dernier, ...), par contre les &#233;l&#233;ments sont toujours parcourus de gauche &#224; droite quand &lt;<em>nombre</em>&gt; est positif, et dans le sens inverse quand &lt;nombre&gt; est n&#233;gatif. Par d&#233;faut l&#8217;&lt;index depart&gt; vaut <span class="math">1</span> et le &lt;<em>nombre</em>&gt; vaut <span class="math">0</span> (ce qui signifie &#248;g tous les &#233;l&#233;ments).</p></li>
</ul>
<h2 id="fonctions-statistiques">Fonctions statistiques</h2>
<h3 id="Anp">Anp</h3>
<ul>
<li><p><b>Anp( &lt;n&gt;, &lt;p&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le nombre d&#8217;arrangements de &lt;<em>p</em>&gt; parmi &lt;<em>n</em>&gt;.</p></li>
</ul>
<h3 id="binom">binom</h3>
<ul>
<li><p><b>binom( &lt;n&gt;, &lt;p&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le coefficient binomial (ou combinaison) &lt;<em>p</em>&gt; parmi &lt;<em>n</em>&gt;.</p></li>
</ul>
<h3 id="ecart">ecart</h3>
<ul>
<li><p><b>ecart( &lt;liste r&#233;els&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie l&#8217;&#233;cart type d&#8217;une liste de r&#233;els, la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="fact">fact</h3>
<ul>
<li><p><b>fact( &lt;n&gt; )</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( &lt;liste complexes&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le plus grand &#233;l&#233;ment d&#8217;une liste de complexes (ordre lexicographique), la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="min">min</h3>
<ul>
<li><p><b>min( &lt;liste complexes&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le plus petit &#233;l&#233;ment d&#8217;une liste de complexes (ordre lexicographique), la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="median">median</h3>
<ul>
<li><p><b>median( &lt;liste complexes&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie l&#8217;&#233;l&#233;ment m&#233;dian d&#8217;une liste de complexes (ordre lexicographique), la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="moy">moy</h3>
<ul>
<li><p><b>moy( &lt;liste complexes&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie la moyenne d&#8217;une liste de complexes, la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="prod">prod</h3>
<ul>
<li><p><b>prod( &lt;liste complexes&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie le produit des &#233;l&#233;ments d&#8217;une liste de complexes, la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="sum">sum</h3>
<ul>
<li><p><b>sum( &lt;liste complexes&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie la somme des &#233;l&#233;ments d&#8217;une liste de complexes, la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h3 id="var">var</h3>
<ul>
<li><p><b>var( &lt;liste r&#233;els&gt; )</b>.</p></li>
<li><p><u>Description</u> : renvoie la variance d&#8217;une liste de r&#233;els, la constante <em>jump</em> est ignor&#233;e.</p></li>
</ul>
<h2 id="fonctions-de-conversion">Fonctions de conversion</h2>
<h3 id="RealArg">RealArg</h3>
<ul>
<li><p><b>RealArg( &lt;affixe&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;argument (en radians) de l&#8217;affixe r&#233;elle d&#8217;un vecteur en tenant compte de la matrice courante.</p></li>
</ul>
<h3 id="RealCoord">RealCoord</h3>
<ul>
<li><p><b>RealCoord( &lt;affixe &#233;cran&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;affixe r&#233;elle d&#8217;un point compte tenu des &#233;chelles et de la matrice courante.</p></li>
</ul>
<h3 id="RealCoordV">RealCoordV</h3>
<ul>
<li><p><b>RealCoordV( &lt;affixe &#233;cran&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;affixe r&#233;elle d&#8217;un vecteur compte tenu des &#233;chelles de la matrice courante.</p></li>
</ul>
<h3 id="ScrCoord">ScrCoord</h3>
<ul>
<li><p><b>ScrCoord( &lt;affixe r&#233;elle&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;affixe &#233;cran d&#8217;un point en tenant compte des &#233;chelles et de la matrice courante.</p></li>
</ul>
<h3 id="ScrCoordV">ScrCoordV</h3>
<ul>
<li><p><b>ScrCoordV( &lt;affixe r&#233;elle&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;affixe &#233;cran d&#8217;un vecteur en tenant compte des &#233;chelles et de la matrice courante.</p></li>
</ul>
<h3 id="SvgCoord">SvgCoord</h3>
<ul>
<li><p><b>SvgCoord( &lt;screen affixe&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;affixe export&#233;e en svg en tenant compte des &#233;chelles et de la matrice courante.</p></li>
</ul>
<h3 id="TeXCoord">TeXCoord</h3>
<ul>
<li><p><b>TeXCoord( &lt;screen affixe&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;affixe export&#233;e en tex, pst et pgf en tenant compte des &#233;chelles et de la matrice courante. Pour l&#8217;eps il y a la commande <a href="#EpsCoord">EpsCoord</a>.</p></li>
</ul>
<h2 id="transformations-g&#233;om&#233;triques-planes">Transformations g&#233;om&#233;triques planes</h2>
<h3 id="affin">affin</h3>
<ul>
<li><p><b>affin( &lt;liste&gt; , &lt;[A, B]&gt;, &lt;V&gt;, &lt;lambda&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images des points de &lt;<em>liste</em>&gt; par l&#8217;affinit&#233; de base la droite &lt;<em>(AB)</em>&gt;, de rapport &lt;<em>lambda</em>&gt; et de direction le vecteur &lt;<em>V</em>&gt;.</p></li>
</ul>
<h3 id="defAff">defAff</h3>
<ul>
<li><p><b>defAff( &lt;nom&gt;, &lt;A&gt;, &lt;A&#8217;&gt;, &lt;partie lin&#233;aire&gt; )</b></p></li>
<li><p><u>Description</u> : cette fonction permet de cr&#233;er une macro appel&#233;e &lt;<em>nom</em>&gt; qui repr&#233;sentera l&#8217;application affine qui transforme &lt;<em>A</em>&gt; en &lt;<em>A&#8217;</em>&gt;, et dont la partie lin&#233;aire est le dernier argument. Cette partie lin&#233;aire se pr&#233;sente sous la forme d&#8217;une liste de deux complexes: [Lf(1), Lf(i)] o&#249; Lf d&#233;signe la partie lin&#233;aire de la transformation.</p></li>
</ul>
<h3 id="ftransform">ftransform</h3>
<ul>
<li><p><b>ftransform( &lt;liste&gt;, &lt;f(z)&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images des points de &lt;<em>liste</em>&gt; par la fonction &lt;<em>f(z)</em>&gt;, celle-ci peut-&#234;tre une expression fonction de z ou une macro d&#8217;argument z.</p></li>
</ul>
<h3 id="hom">hom</h3>
<ul>
<li><p><b>hom( &lt;liste&gt;, &lt;A&gt;, &lt;lambda&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images de la &lt;<em>liste</em>&gt; par l&#8217;homoth&#233;tie de centre &lt;<em>A</em>&gt; et de rapport &lt;<em>lambda</em>&gt;.</p></li>
</ul>
<h3 id="inv">inv</h3>
<ul>
<li><p><b>inv( &lt;liste&gt;, &lt;A&gt;, &lt;R&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images des points de &lt;<em>liste</em>&gt; par l&#8217;inversion de cercle de centre &lt;<em>A</em>&gt; et de rayon &lt;<em>R</em>&gt;.</p></li>
</ul>
<h3 id="mtransform">mtransform</h3>
<ul>
<li><p><b>mtransform( &lt;liste&gt;, &lt;matrice&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images des points de &lt;<em>liste</em>&gt; par l&#8217;application affine <span class="math"><em>f</em></span> d&#233;finie par la &lt;<em>matrice</em>&gt;. Cette <a href="#matrix">matrice</a> est de la forme [f(0), Lf(1), Lf(i)] o&#249; Lf d&#233;signe la partie lin&#233;aire.</p></li>
</ul>
<h3 id="proj">proj</h3>
<ul>
<li><p><b>proj( &lt;liste&gt;, &lt;A&gt;, &lt;B&gt; )</b> ou <strong>proj( &lt;liste&gt;, &lt;[A,B]&gt; )</strong></p></li>
<li><p><u>Description</u> : renvoie la liste des projet&#233;s orthogonaux des points de &lt;<em>liste</em>&gt; 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( &lt;liste&gt;, &lt;[A,B]&gt;, &lt;vecteur&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des projet&#233;s des points de &lt;<em>liste</em>&gt; sur la droite &lt;<em>(AB)</em>&gt; dans la direction du &lt;<em>vecteur</em>&gt;.</p></li>
</ul>
<h3 id="rot">rot</h3>
<ul>
<li><p><b>rot( &lt;liste&gt;, &lt;A&gt;, &lt;alpha&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images des points de &lt;<em>liste</em>&gt; par la rotation de centre &lt;<em>A</em>&gt; et d&#8217;angle &lt;<em>alpha</em>&gt;.</p></li>
</ul>
<h3 id="shift">shift</h3>
<ul>
<li><p><b>shift( &lt;liste&gt;, &lt;vecteur&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des translat&#233;s des points de &lt;<em>liste</em>&gt; avec le &lt;<em>vecteur</em>&gt;.</p></li>
</ul>
<h3 id="simil">simil</h3>
<ul>
<li><p><b>simil( &lt;liste&gt; , &lt;A&gt;, &lt;lambda&gt;, &lt;alpha&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des images des points de &lt;<em>liste</em>&gt;, par la similitude de centre &lt;<em>A</em>&gt;, de rapport &lt;<em>lambda</em>&gt; et d&#8217;angle &lt;<em>alpha</em>&gt;.</p></li>
</ul>
<h3 id="sym">sym</h3>
<ul>
<li><p><b>sym( &lt;liste&gt;, &lt;A&gt;, &lt;B&gt; )</b> ou <strong>sym( &lt;liste&gt;, &lt;[A,B]&gt; )</strong></p></li>
<li><p><u>Description</u> : renvoie la liste des sym&#233;triques des points de &lt;<em>liste</em>&gt;, par rapport &#224; 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( &lt;liste&gt;, &lt;A&gt;, &lt;vecteur&gt; )</b></p></li>
<li><p><u>Description</u> : sym&#233;trie gliss&#233;e: renvoie la liste des images des points de &lt;<em>liste</em>&gt;, par la sym&#233;trie orthogonale d&#8217;axe la droite passant par &lt;<em>A</em>&gt; et dirig&#233;e par &lt;<em>vecteur</em>&gt;, compos&#233;e avec la translation de &lt;<em>vecteur</em>&gt;.</p></li>
</ul>
<h3 id="symO">symO</h3>
<ul>
<li><p><b>symO( &lt;liste&gt;, &lt;[A, B]&gt;, &lt;vecteur&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des sym&#233;triques des points de &lt;<em>liste</em>&gt; par rapport &#224; la droite &lt;<em>(AB)</em>&gt; et dans la direction du &lt;<em>vecteur</em>&gt;.</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 &#234;tre repr&#233;sent&#233;e par son expression analytique dans la base canonique <span class="math">(1,&#8198;<em>i</em>)</span>, la forme g&#233;n&#233;rale de cette expression est:</p>
<p>{ <br /><span class="math">$\left\{\begin{array}{rcl}
          x'&amp;=&amp;t_1+ax+by\\
y'&amp;=&amp;t_2+cx+dy
         \end{array}\right.$</span><br /> }</p>
<p>cette expression analytique sera repr&#233;sent&#233;e par la liste <span style="color:red">[t1+i*t2, a+i*c, b+i*d]</span> c&#8217;est &#224; dire: <span style="color:red">[ f(0), f(1)-f(0), f(i)-f(0)]</span>, cette liste sera appel&#233;e plus bri&#232;vement (et de mani&#232;re abusive) <em>matrice</em> de la transformation <span class="math"><em>f</em></span>. Les deux derniers &#233;l&#233;ments de cette liste: <span style="color:red">[ a+i*c, b+i*d]</span>, repr&#233;sentent la matrice de la partie lin&#233;aire de <span class="math"><em>f</em></span>: Lf<span class="math">&#8196;=&#8196;<em>f</em>&#8197;-&#8197;<em>f</em>(0)</span>.</p>
<h3 id="ChangeWinTo">ChangeWinTo</h3>
<ul>
<li><p><b>ChangeWinTo( &lt;[xinf+i*yinf, xsup+i*ysup]&gt; [, ortho] )</b></p></li>
<li><p><u>Description</u> : modifie la matrice courante de mani&#232;re &#224; transformer la fen&#234;tre courante en la fen&#234;tre de grande diagonale &lt;<em>[xinf+i*yinf, xsup+i*ysup]</em>&gt;, la fen&#234;tre sera orthonorm&#233;e ou non en fonction de la valeur du param&#232;tre optionnel &lt;<em>ortho</em>&gt; (<span class="math">0</span> par d&#233;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( &lt;[f(0), Lf(1), Lf(i)]&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;inverse de la matrice &lt;<em>[f(0), Lf(1), Lf(i)]</em>&gt;, c&#8217;est &#224; dire la matrice <span class="math">[<em>f</em><sup>&#8197;-&#8197;1</sup>(0),&#8198;<em>L</em><em>f</em><sup>&#8197;-&#8197;1</sup>(1),&#8198;<em>L</em><em>f</em><sup>&#8197;-&#8197;1</sup>(<em>i</em>)]</span> si elle existe.</p></li>
</ul>
<h3 id="matrix">matrix</h3>
<ul>
<li><p><b>matrix( &lt;fonction affine&gt;, [variable] )</b></p></li>
<li><p><u>Description</u> : renvoie la matrice de la &lt;<em>fonction affine</em>&gt;, par d&#233;faut la &lt;<em>variable</em>&gt; est <span class="math"><em>z</em></span>. Cette matrice se pr&#233;sente sous la forme [f(0), Lf(1), Lf(i)], o&#249; f d&#233;signe l&#8217;application affine et Lf sa partie lin&#233;aire, plus pr&#233;cis&#233;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( &lt;[f(0), Lf(1), Lf(i)]&gt;, &lt;[g(0), Lg(1), Lg(i)]&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la matrice de la compos&#233;e: <span class="math"><em>f</em><em>o</em><em>g</em></span>, o&#249; <span class="math"><em>f</em></span> et <span class="math"><em>g</em></span> sont les deux applications affines d&#233;finies par les matrices pass&#233;es en argument.</p></li>
</ul>
<h2 id="constructions-g&#233;om&#233;triques-planes">Constructions g&#233;om&#233;triques planes</h2>
<p>Ces macros d&#233;finissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points repr&#233;sentant ces objets.</p>
<h3 id="bissec">bissec</h3>
<ul>
<li><p><b>bissec( &lt;B&gt;, &lt;A&gt;, &lt;C&gt;, &lt;1 ou 2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie une liste de deux points de la bissectrice, 1=int&#233;rieure.</p></li>
</ul>
<h3 id="cap">cap</h3>
<ul>
<li><p><b>cap( &lt;ensemble1&gt;, &lt;ensemble2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie le contour de l&#8217;intersection de &lt;<em>ensemble1</em>&gt; avec &lt;<em>ensemble2</em>&gt; sous forme d&#8217;une liste de points. Ces deux ensembles sont des lignes polygonales repr&#233;sentant des courbes ferm&#233;es, orient&#233;es dans le meme sens, ayant une forme relativement simple. La macro <a href="#set">set</a> permet de d&#233;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(&quot;A&quot;, 0, [rotation:=30]), B:=set(&quot;B&quot;, 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( &lt;ensemble1&gt;, &lt;ensemble2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie le contour de l&#8217;intersection de &lt;<em>ensemble1</em>&gt; avec &lt;<em>ensemble2</em>&gt; sous forme d&#8217;une liste de points de contr&#244;les qui doit &#234;tre dessin&#233;e avec la macro <a href="#drawSet">drawSet</a>. Ces deux ensembles sont doivent &#233;galement &#234;tre deux listes de points de contr&#244;le repr&#233;sentant des courbes ferm&#233;es, orient&#233;es dans le meme sens, ayant une forme relativement simple. La macro <a href="#setB">setB</a> permet de d&#233;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(&quot;A&quot;, 0, [rotation:=30]), B:=setB(&quot;B&quot;, 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( &lt;A&gt;, &lt;B&gt;, &lt;1 ou -1&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des sommets du carr&#233; de sommets cons&#233;cutifs A et B, 1=sens direct.</p></li>
</ul>
<h3 id="cup">cup</h3>
<ul>
<li><p><b>cup( &lt;ensemble1&gt;, &lt;ensemble2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie le contour de la r&#233;union de &lt;<em>ensemble1</em>&gt; avec &lt;<em>ensemble2</em>&gt; sous forme d&#8217;une liste de points. Ces deux ensembles doivent &#234;tre des courbes ferm&#233;es, orient&#233;es dans le meme sens, ayant une forme relativement simple. La macro <a href="#set">set</a> permet de d&#233;finir et dessiner des ensembles.</p></li>
<li><p><u>Exemple(s)</u> :  r&#233;union de deux ensembles:</p></li>
</ul>
<blockquote>
<blockquote>
<p>Marges(0,0,0,0),size(7.5), A:=set(&quot;A&quot;, 0, [rotation:=30]), B:=set(&quot;B&quot;, 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( &lt;ensemble1&gt;, &lt;ensemble2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie le contour de la r&#233;union de &lt;<em>ensemble1</em>&gt; avec &lt;<em>ensemble2</em>&gt; sous forme d&#8217;une liste de points de contr&#244;les qui doit &#234;tre dessin&#233;e avec la macro <a href="#drawSet">drawSet</a>. Ces deux ensembles sont doivent &#233;galement &#234;tre deux listes de points de contr&#244;le repr&#233;sentant des courbes ferm&#233;es, orient&#233;es dans le meme sens, ayant une forme relativement simple. La macro <a href="#setB">setB</a> permet de d&#233;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(&quot;A&quot;, 0, [rotation:=30]), B:=setB(&quot;B&quot;, 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( &lt;courbe de b&#233;zier&gt;, &lt;point&gt;, &lt;avant(0/1)&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie un arc de b&#233;zier correspondant &#224; la &lt;<em>courbe de b&#233;zier</em>&gt; coup&#233;e avant ou apr&#232;s le &lt;<em>point</em>&gt;, en fonction du param&#232;tre &lt;<em>avant</em>&gt;. Le r&#233;sultat doit &#234;tre dessin&#233; par la commande <a href="#Bezier">Bezier</a>.</p></li>
</ul>
<h3 id="Cvx2d">Cvx2d</h3>
<ul>
<li><p><b>Cvx2d( &lt;liste&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie l&#8217;enveloppe convexe de la &lt;<em>liste</em>&gt; selon l&#8217;algorithme de {Ronald Graham}. La &lt;<em>liste</em>&gt; ne doit pas contenir la constante <em>jump</em>.</p></li>
<li><p><u>Exemple(s)</u> :  on choisit al&#233;atoirement <span class="math">10</span> points dans le pav&#233; <span class="math">[&#8197;-&#8197;4,&#8198;4]&#8197;&#215;&#8197;[&#8197;-&#8197;4,&#8198;4]</span> que l&#8217;on place dans une variable <span class="math"><em>P</em></span> tout en dessinant chacun d&#8217;eux avec son num&#233;ro, puis on dessine l&#8217;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,&quot;N&quot;,1), z od, Ligne(Cvx2d(P),1)</p>
</blockquote>
</blockquote>
<h3 id="Intersec">Intersec</h3>
<ul>
<li><p><b>Intersec( &lt;objet1&gt;, &lt;objet2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des points d&#8217;intersection des deux objets graphiques. Ces deux objets peuvent &#234;tre soit des commandes graphiques (Cercle(), Droite(), ...) ou bien le nom d&#8217;un &#233;l&#233;ment graphique d&#233;j&#224; cr&#233;&#233;.</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( &lt;A&gt;, &lt;B&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie une liste de deux points de la m&#233;diatrice de <span class="math">[<em>A</em>,&#8198;<em>B</em>]</span>.</p></li>
</ul>
<h3 id="parallel">parallel</h3>
<ul>
<li><p><b>parallel( &lt;[A,B]&gt;, &lt;C&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie une liste de deux points de la parall&#232;le &#224; <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( &lt;A&gt;, &lt;B&gt;, &lt;C&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des sommets du parall&#232;logramme de sommets cons&#233;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( &lt;[A, B]&gt;, &lt;C&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie une liste de deux points de la perpendiculaire &#224; <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( &lt;A&gt;, &lt;B&gt;, &lt;nombre de cot&#233;s&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des sommets du polyg&#244;ne r&#233;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&#244;t&#233;s indiqu&#233;.</p></li>
</ul>
<p>ou</p>
<ul>
<li><p><strong>polyreg( &lt;A&gt;, &lt;B&gt;, &lt;nombre de cot&#233;s + i*sens&gt; )</strong> avec sens = +/-1</p></li>
<li><p><u>Description</u> : renvoie la liste des sommets du polyg&#244;ne r&#233;gulier de sommets cons&#233;cutifs <span class="math"><em>A</em></span> et <span class="math"><em>B</em></span>, avec le nombre de c&#244;t&#233;s indiqu&#233; et dans le sens indiqu&#233; (1 pour le sens trigonom&#233;trique).</p></li>
</ul>
<h3 id="pqGoneReg">pqGoneReg</h3>
<ul>
<li><p><b>pqGoneReg( &lt;centre&gt;, &lt;sommet&gt;, &lt;[p,q]&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des sommets du &lt;<em>p/q</em>&gt;-g&#244;ne r&#233;gulier d&#233;fini par le &lt;<em>centre</em>&gt; et un &lt;<em>sommet</em>&gt;.</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( &lt;A&gt;, &lt;B&gt;, &lt;C&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie la liste des sommets du rectangle de sommets cons&#233;cutifs <span class="math"><em>A</em></span>, <span class="math"><em>B</em></span>, le c&#244;t&#233; oppos&#233; passant par <span class="math"><em>C</em></span>.</p></li>
</ul>
<h3 id="setminus">setminus</h3>
<ul>
<li><p><b>setminus( &lt;ensemble1&gt;, &lt;ensemble2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie le contour de la diff&#233;rence &lt;<em>ensemble1</em>&gt; - &lt;<em>ensemble2</em>&gt; sous forme d&#8217;une liste de points. Ces deux ensembles doivent &#234;tre des courbes ferm&#233;es, orient&#233;es dans le meme sens, ayant une forme relativement simple. La macro <a href="#set">set</a> permet de d&#233;finir et dessiner des ensembles.</p></li>
<li><p><u>Exemple(s)</u> :  diff&#233;rence de deux ensembles:</p></li>
</ul>
<blockquote>
<blockquote>
<p>Marges(0,0,0,0),size(7.5), A:=set(&quot;A&quot;, 0, [rotation:=30]), B:=set(&quot;B&quot;, 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( &lt;ensemble1&gt;, &lt;ensemble2&gt; )</b></p></li>
<li><p><u>Description</u> : renvoie le contour de la diff&#233;rence &lt;<em>ensemble1</em>&gt; - &lt;<em>ensemble2</em>&gt; sous forme d&#8217;une liste de points de contr&#244;les qui doit &#234;tre dessin&#233;e avec la macro <a href="#drawSet">drawSet</a>. Ces deux ensembles sont doivent &#233;galement &#234;tre deux listes de points de contr&#244;le repr&#233;sentant des courbes ferm&#233;es, orient&#233;es dans le meme sens, ayant une forme relativement simple. La macro <a href="#setB">setB</a> permet de d&#233;finir et dessiner des ensembles.</p></li>
<li><p><u>Exemple(s)</u> :  diff&#233;rence de deux ensembles:</p></li>
</ul>
<blockquote>
<blockquote>
<p>Marges(0,0,0,0),size(7.5), A:=setB(&quot;A&quot;, 0, [rotation:=30]), B:=setB(&quot;B&quot;, 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&#226;ce &#224; l&#8217;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&#233;cup&#233;rer tous les chemins d&#8217;un fichier &#233;crit en <em>flattened postscript</em>. C&#8217;est que proposent les macros de cette section.</p>
<h3 id="conv2FlatPs">conv2FlatPs</h3>
<ul>
<li><p><b>conv2FlatPs( &lt;fichier entr&#233;e&gt;, &lt;fichier sortie&gt; [, dossier de travail] )</b></p></li>
<li><p><u>Description</u> : cette macro invoque l&#8217;utilitaire <em>pstoedit</em> pour transformer le &lt;<em>fichier entr&#233;e</em>&gt; en <em>flattened postscript</em> dans le &lt;<em>fichier sortie</em>&gt;. Le fichier &lt;<em>fichier entr&#233;e</em>&gt; doit &#234;tre un fichier pdf ou ps.</p></li>
</ul>
<h3 id="drawFlatPs">drawFlatPs</h3>
<ul>
<li><p><b>drawFlatPs( &lt;affixe&gt;, &lt;chemins lus par loadFlatPs&gt; [, options] )</b></p></li>
<li><p><u>Description</u> : cette macro dessine &#224; l&#8217;&#233;cran l&#8217;ensemble des chemins lus dans un fichier en <em>flattened postscript</em> par la macro <a href="#loadFlatPs">loadFlatPs</a>. L&#8217;affichage se fait &#224; l&#8217;&lt;<em>affixe</em>&gt; demand&#233;. Le param&#232;tre &lt;<em>options</em>&gt; 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 := &lt; nombre positif &gt;</span>: &#233;chelle, 1 par d&#233;faut.</p></li>
<li><p><span style="color:blue">position := &lt; center/left/right/... &gt;</span>: position de l&#8217;affixe par rapport &#224; l&#8217;image, center par d&#233;faut (fonctionne comme la variable LabelStyle).</p></li>
<li><p><span style="color:blue">color := &lt; couleur &gt;</span>: pour imposer une couleur, <em>Nil</em> par d&#233;faut ce qui signifie qu&#8217;on prend la couleur d&#8217;origine.</p></li>
<li><p><span style="color:blue">rotation := &lt; angle en degr&#233;s &gt;</span>: 0 par d&#233;faut.</p></li>
<li><p><span style="color:blue">hollow := &lt; 0/1 &gt;</span>: avec la valeur 0 (par d&#233;faut) les remplissages sont effectu&#233;s.</p></li>
<li><p><span style="color:blue">select := &lt; liste des num&#233;ros de chemin &#224; montrer &gt;</span>: <em>Nil</em> par d&#233;faut, ce qui signifie tous les chemins.</p></li>
</ul></li>
</ul>
<h3 id="drawTeXlabel">drawTeXlabel</h3>
<ul>
<li><p><b>drawTeXlabel( &lt;affixe&gt;, &lt;variable contenant la formule TeX lue par loadFlatPs&gt;, [, 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 &#233;t&#233; au pr&#233;alable compil&#233;e par . Le param&#232;tre &lt;<em>options</em>&gt; 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 := &lt; nombre&gt;0 &gt;</span>: &#233;chelle, 1 par d&#233;faut.</p></li>
<li><p><span style="color:blue">hollow := &lt; 0/1 &gt;</span>: avec la valeur 0 (par d&#233;faut) les remplissages sont effectu&#233;s.</p></li>
</ul>
<p>Cette macro est utilis&#233;e en interne par la macro <a href="#NewTeXlabel">NewTeXlabel</a>.</p></li>
</ul>
<h3 id="loadFlatPs">loadFlatPs</h3>
<ul>
<li><p><b>loadFlatPs( &lt;fichier en flattened postscript&gt;, [, options] )</b></p></li>
<li><p><u>Description</u> : cette macro charge un &lt;<em>fichier en flattened postscript</em>&gt;, adpate les coordonn&#233;es des points et renvoie la liste des chemins (que l&#8217;on peut alors dessiner avec la macro <a href="#drawFlatPs">drawFlatPs</a>). Le param&#232;tre &lt;<em>options</em>&gt; 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 := &lt; nombre&gt;0 &gt;</span>: largeur en cm, <em>Nil</em> par d&#233;faut pour largeur naturelle.</p></li>
<li><p><span style="color:blue">height := &lt; nombre&gt;0 &gt;</span>: hauteur en cm, <em>Nil</em> par d&#233;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 &#233;l&#233;ment graphique Utilisateur:</p></li>
</ul>
<pre><code>     [conv2FlatPs( &quot;circuit.pdf&quot;, &quot;circuit.fps&quot;, @TmpPath),
      stock:= loadFlatPs( [@TmpPath,&quot;circuit.fps&quot;] ),
      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( &lt;nom&gt;, &lt;affixe&gt;, &lt;formule TeX&gt;, [, options] )</b></p></li>
<li><p><u>Description</u> : cette macro va demander &#224; {} de compiler la formule dans un fichier pdf, ce fichier sera ensuite converti en un fichier eps par pstoedit, puis celui-ci sera charg&#233; par loadFlatPs et stock&#233; dans une variable globale appel&#233;e TeX_+nom. Un &#233;l&#233;ment graphique appel&#233; &lt;<em>nom</em>&gt; est cr&#233;&#233;e pour dessiner la formule avec drawTeXLabel. Le param&#232;tre &lt;<em>options</em>&gt; 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 := &lt; 0/1 &gt;</span>: indique &#224; TeXgraph s&#8217;il doit ajouter les d&#233;limiteurs <code>\[</code> et <code>\]</code> autour de la formule, 1 par d&#233;faut.</p></li>
<li><p><span style="color:blue">scale := &lt; nombre&gt;0 &gt;</span>: &#233;chelle, 1 par d&#233;faut.</p></li>
<li><p><span style="color:blue">hollow := &lt; 0/1 &gt;</span>: avec la valeur 0 (par d&#233;faut) les remplissages sont effectu&#233;s.</p></li>
</ul>
<p>Dans les options, les attributs suivants peuvent &#233;galement &#234;tre utilis&#233;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&#233;finition de cette macro:</p>
<blockquote>
<pre><code>[dollar:=1, scale:=1, hollow:=0, $options:=%4,
 $aux:=OpenFile([@TmpPath,&quot;formula.tex&quot;]),
 if dollar then WriteFile([&quot;\[&quot;,%3,&quot;\]&quot;]) else WriteFile(%3) fi,
 CloseFile(),
 Exec(&quot;pdflatex&quot;,&quot;-interaction=nonstopmode tex2FlatPs.tex&quot;,@TmpPath,1),
 Exec(&quot;pstoedit -dt -pta -f ps -r2400x2400&quot;,&quot;tex2FlatPs.pdf tex2FlatPs.eps&quot;,@TmpPath,1),
 NewVar([&quot;TeX_&quot;,%1],loadFlatPs([@TmpPath,&quot;tex2FlatPs.eps&quot;])),
 NewGraph(%1, [&quot;drawTeXlabel(&quot;,%2,&quot;, TeX_&quot;,%1,&quot;, [scale:=&quot;,scale,&quot;, hollow:=&quot;,hollow,&quot;])&quot;]),
 ReDraw()
]
</code></pre>
</blockquote>
<p>La formule est &#233;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&#233;sultat en <em>flattened postscript</em> avant de le charger.</p>
<p>Cette macro s&#8217;utilise dans la ligne de commande ou bien dans des macros qui cr&#233;ent des &#233;l&#233;ments graphiques, mais pas directement dans un &#233;l&#233;ment graphique Utilisateur, exemple:</p>
<p><div style="text-align:center"><span style="color:red">NewTeXlabel( &quot;label1&quot;, 0, &quot;&#92;frac{&#92;pi}{&#92;sqrt{2}}&quot;, [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&#233;e en interne pour m&#233;moriser le programme utilis&#233; pour faire la conversion du format eps vers le format pdf. Par d&#233;faut, cette macro contient la chaine: <span style="font-style:italic">&quot;epstopdf&quot;</span>. En &#233;ditant le fichier TeXgraph.mac, vous pouvez modifier le programme utilis&#233;.</p></li>
</ul>