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

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

\chapter{Les macros mathématiques de TeXgraph.mac}

\section{Opérations arithmétiques et logiques}

\subsection{Ceil}

\begin{itemize}
\item \util \textbf[Ceil()]{Ceil( <x> )}.
\item \desc  renvoie le plus petit entier supérieur ou égal au réel \argu{x}.
\end{itemize}

\subsection{div}

\begin{itemize}
\item \util \textbf[div()]{div( <x>, <y> )}.
\item \desc  renvoie l'unique entier $k$ tel que $x-ky$ soit dans l'intervalle $[0;|y|[$.
\end{itemize}

\subsection{mod}

\begin{itemize}
\item \util \textbf[mod()]{mod( <x>, <y> )}.
\item \desc renvoie l'unique réel $r$ de l'intervalle $[0;|y|[$ tel que 
$x=ky+r$ avec $k$ entier.
\end{itemize}

\subsection{not}\label{macnot}

\begin{itemize}
\item \util \textbf[not()]{not( <expression booléenne> )}
\item \desc renvoie la valeur booléenne de la négation.
\end{itemize}

\subsection{pgcd}

\begin{itemize}
\item \util \textbf[pgcd()]{pgcd( <a>, <b> [, <u>, <v>] )}
\item \desc renvoie la valeur d du pgcd de \argu{a} et \argu{b}, ainsi que deux coefficients de Bezout dans les
variables \argu{u} et \argu{v} (si celles-ci sont présentes), de telle sorte que $au+bv=d$.
\end{itemize}

\subsection{ppcm}

\begin{itemize}
\item \util \textbf[ppcm()]{ppcm( <a>, <b> )}
\item \desc renvoie la valeur du ppcm de \argu{a} et \argu{b}.
\end{itemize}

\section{Opérations sur les variables}

\subsection{Abs}

\begin{itemize}
\item \util \textbf[Abs()]{Abs( <affixe> )}.
\item \desc cette macro donne la norme en cm.
\end{itemize}


\subsection{free}

\begin{itemize}
\item \util \textbf[free()]{free( <x> )}.
\item \desc libère la variable \argu{x} en la mettant à \Nil. Depuis la version 1.93 on peut faire directement
l'affectation à la constante \Nil, par exemple: \co{x:=Nil}.
\end{itemize}


\subsection{IsIn}

\begin{itemize}
\item \util \textbf[IsIn()]{IsIn( <affixe> [, <epsilon>] )}.
\item \desc renvoie 1 si l'\argu{affixe} est dans la fenêtre graphique, 0 sinon. Cette macro tient compte de la matrice
courante, le test se fait à \argu{epsilon} près et \argu{epsilon} vaut 0.0001 cm par défaut.
\end{itemize}

\subsection{nil}

\begin{itemize}
\item \util \textbf[nil()]{nil( <x> )}.
\item \desc renvoie 1 si la variable \argu{x} est à \Nil, 0 sinon. Depuis la version 1.93 on peut faire directement le
test d'égalité avec la constante \Nil.
\end{itemize}

\subsection{round}

\begin{itemize}
\item \util \textbf[round()]{round( <liste> [, décimales] )}
\item \desc tronque les complexes de la \argu{liste} en arrondissant au plus proche les parties réelles et imaginaires
avec le nombre de \argu{décimales} demandé (0 par défaut). Si la \argu{liste} contient le constante \jump, alors
celle-ci est renvoyée dans la liste des résultats. Cette macro utilise la commande \Helpref{{Round}}{cmdRound} (qui ne
s'applique qu'à un complexe et non une liste).
\end{itemize}

\section{Opérations sur les listes}

\subsection{bary}
\begin{itemize}
\item \util \textbf[bary()]{bary( <[affixe1, coef1, affixe2, coef2, ...]> )}.
\item \desc renvoie le barycentre du système pondéré \argu{[(affixe1, coef1), (affixe2, coef2),...]}.
\end{itemize}

\subsection{del}
\begin{itemize}
\item \util \textbf[del()]{del( <liste>, <liste des index à supprimer>, <quantité à supprimer> )}.
\item \desc renvoie la liste après avoir supprimer les éléments dont l'index figure dans la \argu{liste des index à
supprimer}. La \argu{quantité à supprimer} (à chaque fois) est de $1$ par défaut, cet argument peut être une liste lui
aussi.
\item \exem
  \begin{itemize}
  \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8])} donne \res{[1,3,4,5,7]}.
  \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8], 2)} donne \res{[1,4,5]}.  
  \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8], [1,2])} donne \res{[1,3,4,5]}.  
  \item \co{del( [1,2,jump,3,4,5,jump,6,7,8],[3,7])} donne \res{[1,2,3,4,5,6,7,8]}.  
  \end{itemize}
\end{itemize}

\subsection{getdot}
\begin{itemize}
\item \util \textbf[getdot()]{getdot( <s> , <ligne polygonale> )}.
\item \desc renvoie le point de la \argu{ligne polygonale} ayant \argu{s} comme abscisse curviligne. Le paramètre
\argu{s} doit être dans l'intervalle $[0;1]$, $0$ pour le premier point, et $1$ pour le dernier.
\end{itemize}

\subsection{IsAlign}

\begin{itemize}
\item \util \textbf[IsAlign()]{IsAlign( <liste points 2D> [, epsilon] )}.
\item \desc renvoie 1 si les points sont sur une même droite, 0 sinon. Par défaut la tolérance \argu{epsilon} vaut
1E-10. La \argu{liste} ne doit pas contenir la constante \jump.
\end{itemize}


\subsection{isobar}

\begin{itemize}
\item \util \textbf[isobar()]{isobar( <[affixe1, affixe2, ...]> )}.
\item \desc renvoie l'isobarycentre du système \argu{[affixe1, affixe2, ...]}.
\end{itemize}

\subsection{KillDup}
\begin{itemize}
\item \util \textbf[KillDup()]{KillDup( <liste> [, epsilon] )}.
\item \desc renvoie la liste sans doublons. Les comparaisons se font à \argu{epsilon} près (qui vaut $0$ par défaut).
\item \exem \co{KillDup( [1.255,1.258,jump,1.257,1.256,1.269,jump] ,1.5E-3)} renvoie \res{[1.255,1.258,1.269]}.
\end{itemize}

\subsection{length}
\begin{itemize}
\item \util \textbf[length()]{length( <liste> )}.
\item \desc  calcule la longueur de la \argu{liste} en cm.
\end{itemize}

\subsection{permute}
\begin{itemize}
\item \util \textbf[permute()]{permute( <liste> )}.
\item \desc modifie la \argu{liste} en plaçant le premier élément à la fin, \argu{liste} doit être une variable.
\item la commande \co{[x:= [1,2,3,4], permute(x), x]} renvoie \res{[2,3,4,1]}.
\end{itemize}

\subsection{Pos}
\begin{itemize}
\item \util \textbf[Pos()]{Pos( <affixe>, <liste>, [, epsilon] )}.
\item \desc renvoie la liste des positions de l'\argu{affixe} dans la \argu{liste}, la comparaison se fait à
\argu{epsilon} près, par défaut \argu{epsilon} vaut 0.
\item la commande \co{Pos(2, [1,2,3,2,4])} renvoie \res{[2,4]}, mais \co{Pos(5, [1,2,3,2,4])} renvoie \Nil.
\end{itemize}


\subsection{rectangle}
\begin{itemize}
\item \util \textbf[rectangle()]{rectangle( <liste> )}.
\item \desc détermine le plus petit rectangle contenant la liste, cette macro renvoie une liste de deux complexes qui
représentent l'affixe du coin inférieur gauche suivi de celle du coin supérieur droit.
\end{itemize}

\subsection{replace}
\begin{itemize}
\item \util \textbf[replace()]{replace( <liste>, <position>, <valeur> )}.
\item \desc modifie la variable \argu{liste} en remplaçant l'élément numéro \argu{position} par la \argu{valeur}, cette
macro renvoie \Nil.
\end{itemize}

\subsection{reverse}
\begin{itemize}
\item \util \textbf[reverse()]{reverse( <liste> )}.
\item \desc renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un \jump).
\end{itemize}

\subsection{SortWith}
\begin{itemize}
\item \util \textbf[SortWith()]{SortWith( <liste clés>, <liste>, <taille paquets> [, mode] )}.
\item \desc trie la \textbf{variable} \argu{liste} suivant les \argu{clés}. Les éléments de la \argu{liste} sont 
traités par \argu{paquets}, leur taille est de 1 par défaut. La \argu{taille paquets} peut être égale à \jump pour un
traitement par composante. Si un paquet n'est pas complet, il n'est pas traité. Si la liste contient la
constante \jump, alors toutes les composantes sont triées chacune leur tour. Le dernier paramètre détermine
le type de tri: \argu{mode}=0 pour ordre croissant (valeur par défaut), \argu{mode}=1 pour décroissant.
\end{itemize}

\section{Gestion des listes par composantes}

La convention adoptée est que deux composantes sont séparées par la constante \jump. Une composante peut être vide.

\subsection{CpCopy}
\begin{itemize}
\item \util \textbf[CpCopy()]{CpCopy( <liste>, <index depart>,  <nombre> )}.
\item \desc cette fonction renvoie la liste constituée par les \argu{nombre} composantes de la \argu{liste} à partir de
la composante numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie toutes les composantes
de la liste à partir de la composante numéro \argu{départ}. 

Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la
dernière composante a l'index $-1$, l'avant-dernière a l'index $-2$ $\cdots$ etc. La fonction renvoie les \argu{nombre}
composantes de la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche, mais la liste renvoyée
est dans le même sens que la \argu{liste}, et cette dernière n'est pas modifiée.
\item \exem \begin{itemize}
      \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], 2, 1)} renvoie \res{[3,7,8]}.
      \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -1, 2)} renvoie \res{[4,jump,5,6]}.
      \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -3, 0)} renvoie \res{[1,2,jump,3,7,8]}.
      \end{itemize}
\end{itemize}

\subsection{CpDel}
\begin{itemize}
\item \util \textbf[CpDel()]{CpDel( <variable liste>, <index depart>,  <nombre> )}.
\item \desc cette fonction détruit dans la \argu{variable liste}, les \argu{nombre} composantes à partir
de la composante numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction détruit toutes les
composantes de la \argu{variable liste} à partir de la composante numéro \argu{départ}. 

Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la
dernière composante a l'index $-1$, l'avant-dernière a l'index $-2$ $\cdots$ etc. La fonction détruit les \argu{nombre}
composantes de la <variable liste> (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche.

Le paramètre \argu{variable liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la macro renvoie
\Nil.
\end{itemize}

\subsection{CpNops}
\begin{itemize}
\item \util  \textbf[CpNops()]{CpNops( <liste> )}.
\item \desc  cette fonction évalue \argu{liste} et renvoie le nombre de composantes qui la composent.
\item \exem  
   \begin{itemize}
   \item \co{CpNops([1,2,jump,3] )} renvoie la valeur \res{2}.
   \item \co{CpNops([1,2,jump,3,jump] )} renvoie la valeur \res{3}.
   \item \co{CpNops([jump] )} renvoie la valeur \res{2}.
   \end{itemize}
\end{itemize}

\subsection{CpReplace}
\begin{itemize}
\item \util \textbf[CpReplace()]{CpReplace( <variable liste>, <position>, <nouveau> )}.
\item \desc modifie la \argu{variable liste} en remplaçant la composante numéro \argu{position} par \argu{nouveau},
cette macro renvoie \Nil.
\end{itemize}

\subsection{CpReverse}
\begin{itemize}
\item \util  \textbf[CpReverse()]{CpReverse( <liste> )}.
\item \desc renvoie la \argu{liste} avec les composantes dans l'ordre inverse.
\item \exem \co{CpReverse([1,2,jump,3,4,5,jump])} renvoie \res{[jump,3,4,5,jump,1,2]}. 
\end{itemize}

\section{Gestion des listes de chaînes}

Une telle liste est en réalité une \textbf{macro}, les éléments sont indexés à partir de $1$, et la chaîne numéro $k$
est donnée par \verb|@nomListe(k)|, alors que la longueur de la liste (nombre d'éléments) est donnée par
\verb|nomListe(0)|.

\subsection{StrListInit}\label{macStrListInit}
\begin{itemize}
\item \util  \textbf[StrListInit()]{StrListInit( <nomListe>, <"chaine1">, <"chaine2">, ... )}.
\item \desc crée une liste de chaines sous forme d'une macro appelée  \argu{nomListe}, les arguments suivants sont
interprétés comme des chaînes, ils constituent les éléments de la liste et sont indexés à partir de 1.
\item \exem Après la commande \co{StrListInit(essai, "toto", ["toto",2/4], 24)}, une macro du nom de \Mytextbf{essai}
est créée et son contenu est:
\begin{verbatim}
for $z in Args() do
  if z<0 then Inc(z,4) fi,
  if z=0 then 3
  elif z=1 then "toto"
  elif z=2 then "toto0.5"
  elif z=3 then "24"
  fi
od
\end{verbatim}
\item \exem Afficher des labels avec une affixe et une orientation pour chacun, en utilisant une seule fois LabelDot.
\end{itemize}

\begin{demo}{Utilisation de StrListInit}{StrListInit}
\begin{texgraph}[name=StrListInit,export=pgf]
 view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
 StrListInit( nom, -1,"$A$","O", i,"$B$","N",
              1,"$C$","E", -i,"$D$","S"),
 for k from 1 to nom(0) step 3 do 
     LabelDot( Eval(@nom(k)), @nom(k+1), @nom(k+2), 1)
 od,
 StrListKill(nom)
\end{texgraph}
\end{demo}

Une autre solution consiste à faire trois listes: nom, position, orientation:
\begin{verbatim}
 view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
 StrListInit( nom, "$A$", "$B$", "$C$", "$D$"),
 StrListInit(orientation, "O", "N", "E", "S"),
 position:=[-1, i, 1, -i],
 for k from 1 to nom(0) do
     LabelDot( position[k], @nom(k), @orientation(k), 1)
 od,
 StrListKill(nom, orientation) 
\end{verbatim}

\subsection{StrListAdd}
\begin{itemize}
\item \util  \textbf[StrListAdd()]{StrListAdd( <nomListe>, <"chaine1">, <"chaine2">, ... )}.
\item \desc cette macro ajoute à la fin de la liste de chaînes appelée \argu{nomListe}, les arguments suivants (qui sont
interprétés comme des chaînes). Cela suppose que la liste \argu{nomListe} existe déjà, cette liste est en fait une
macro qui va être entièrement réécrite pour lui ajouter les éléments supplémentaires. Il est plus rapide de définir la
liste en une seule fois avec la macro \Helpref{StrListInit}{macStrListInit} quand c'est possible.
\end{itemize}

\subsection{StrListCopy}
\begin{itemize}
\item \util  \textbf[StrListCopy()]{StrListCopy( <nomListe>, <nouvelleListe> [, index depart,  nombre] )}.
\item \desc cette macro crée une nouvelle liste de chaînes appelée \argu{nouvelleListe} en copiant \argu{nombre}
éléments de la liste \argu{nomListe} en partant de  \argu{index depart}. L'argument
<index depart> peut être négatif ($-1$ designe le dernier élément, $-2$ l'avant-dernier, ...),  par contre les éléments
sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est
négatif. Par défaut l'\argu{index depart} vaut $1$ et le \argu{nombre} vaut $0$ (ce qui signifie \og tous les
éléments\fg).
\end{itemize}

\subsection{StrListDelKey}
\begin{itemize}
\item \util  \textbf[StrListDelKey()]{StrListDelKey( <nomListe>, <index depart>, <nombre> )}.
\item \desc cette macro supprime de \argu{nomListe} \argu{nombre} éléments à partir de l'\argu{index depart}. Comme
dans la commande Del, l'argument \argu{index depart} peut être négatif ($-1$ designe le dernier élément,
$-2$ l'avant-dernier, ...),  par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est
positif, et dans le sens inverse quand <nombre> est négatif. Cette macro renvoie \Nil.
\end{itemize}

\subsection{StrListDelVal}
\begin{itemize}
\item \util  \textbf[StrListDelVal()]{StrListDelVal( <nomListe>, <val1>, <val2>, ... )}.
\item \desc cette macro supprime de \argu{nomListe} les chaînes \argu{val1}, \argu{val2}..., sans avoir à connaître
leurs index.
\end{itemize}

\subsection{StrListGetKey}
\begin{itemize}
\item \util  \textbf[StrListGetKey()]{StrListGetKey( <nomListe>, <chaine> )}.
\item \desc cette macro renvoie l'index de la \argu{chaîne} dans la liste \argu{nomListe}, si elle n'y figure pas, la
macro renvoie \Nil.
\end{itemize}

\subsection{StrListInsert}
\begin{itemize}
\item \util  \textbf[StrListInsert()]{StrListInsert( <nomListe1>, <chaîne> [, <index> ])}.
\item \desc cette macro modifie la liste de chaines \argu{nomListe}, en insérant une nouvelle \argu{chaîne} à la
position \argu{index}. Par défaut la valeur de \argu{index} est nulle ce qui représente la fin de la liste, cette valeur
peut être négative ($-1$ est l'index du dernier élément, $-2$ l'avant-dernier, ...).
\end{itemize}

\subsection{StrListKill}
\begin{itemize}
\item \util  \textbf[StrListKill()]{StrListKill( <nomListe1>, <nomListe2>, ... )}.
\item \desc cette macro détruit les listes de chaînes \argu{nomListe1}, \argu{nomListe2}, ...
\end{itemize}

\subsection{StrListReplace}
\begin{itemize}
\item \util  \textbf[StrListReplace()]{StrListReplace( <nomListe>, <ancienne chaine>, <nouvelle> )}.
\item \desc cette macro remplace dans la liste appelée \argu{nomListe}, l'\argu{ancienne chaine} par la \argu{nouvelle}.
\end{itemize}

\subsection{StrListReplaceKey}
\begin{itemize}
\item \util  \textbf[StrListReplaceKey()]{StrListReplaceKey( <nomListe>, <index>, <nouvelle chaîne> )}.
\item \desc cette macro remplace dans la liste appelée \argu{nomListe}, la chaîne dont le numéro est\argu{index}, par
la \argu{nouvelle chaîne}.
\end{itemize}

\subsection{StrListShow}
\begin{itemize}
\item \util  \textbf[StrListShow()]{StrListShow( <nomListe> [, <index depart>,  <nombre> ])}.
\item \desc cette macro renvoie la chaîne obtenue en copiant \argu{nombre} éléments de la liste \argu{nomListe} en
partant de 
\argu{index depart}, mais sans les concaténer. La chaîne renvoyée est de la forme: \verb|"chaine", "chaine", ...|.
L'argument <index depart> peut être négatif ($-1$ designe le dernier élément, $-2$ l'avant-dernier, ...),  par contre
les éléments sont toujours parcourus de gauche à droite quand \argu{nombre} est positif, et dans le sens inverse quand
<nombre> est négatif. Par défaut l'<index depart> vaut $1$ et le \argu{nombre} vaut $0$ (ce qui signifie \og tous les
éléments\fg).
\end{itemize}


\section{Fonctions statistiques}

\subsection{Anp}
\begin{itemize}
\item \util \textbf[Anp()]{Anp( <n>, <p> )}.
\item \desc renvoie le nombre d'arrangements de \argu{p} parmi \argu{n}.
\end{itemize}

\subsection{binom}
\begin{itemize}
\item \util \textbf[binom()]{binom( <n>, <p> )}.
\item \desc renvoie le coefficient binomial (ou combinaison)  \argu{p} parmi \argu{n}.
\end{itemize}


\subsection{ecart}
\begin{itemize}
\item \util \textbf[ecart()]{ecart( <liste réels> )}.
\item \desc renvoie l'écart type d'une liste de réels, la constante \jump est ignorée.
\end{itemize}

\subsection{fact}
\begin{itemize}
\item \util \textbf[fact()]{fact( <n> )}.
\item \desc renvoie la valeur de $n!$ (fonction factorielle).
\end{itemize}


\subsection{max}
\begin{itemize}
\item \util \textbf[max()]{max( <liste complexes> )}.
\item \desc renvoie le plus grand élément d'une liste de complexes (ordre lexicographique), la constante \jump est
ignorée.
\end{itemize}

\subsection{min}
\begin{itemize}
\item \util \textbf[min()]{min( <liste complexes> )}.
\item \desc renvoie le plus petit élément d'une liste de complexes (ordre lexicographique), la constante \jump est
ignorée.
\end{itemize}

\subsection{median}
\begin{itemize}
\item \util \textbf[median()]{median( <liste complexes> )}.
\item \desc renvoie l'élément médian d'une liste de complexes (ordre lexicographique), la constante \jump est ignorée.
\end{itemize}

\subsection{moy}
\begin{itemize}
\item \util \textbf[moy()]{moy( <liste complexes> )}.
\item \desc renvoie la moyenne d'une liste de complexes, la constante \jump est ignorée.
\end{itemize}

\subsection{prod}
\begin{itemize}
\item \util \textbf[prod()]{prod( <liste complexes> )}.
\item \desc renvoie le produit des éléments d'une liste de complexes, la constante \jump est ignorée.
\end{itemize}

\subsection{sum}
\begin{itemize}
\item \util \textbf[sum()]{sum( <liste complexes> )}.
\item \desc renvoie la somme des éléments d'une liste de complexes, la constante \jump est ignorée.
\end{itemize}

\subsection{var}
\begin{itemize}
\item \util \textbf[var()]{var( <liste réels> )}.
\item \desc renvoie la variance d'une liste de réels, la constante \jump est ignorée.
\end{itemize}

\section{Fonctions de conversion}

\subsection{RealArg}

\begin{itemize}
\item \util \textbf[RealArg()]{RealArg( <affixe> )}
\item \desc renvoie l'argument (en radians) de l'affixe réelle d'un vecteur en tenant compte de la matrice courante.
\end{itemize}


\subsection{RealCoord}
\begin{itemize}
\item \util \textbf[RealCoord()]{RealCoord( <affixe écran> )}

\item \desc renvoie l'affixe réelle d'un point compte tenu des échelles et de la matrice courante.
\end{itemize}

\subsection{RealCoordV}

\begin{itemize}
\item \util \textbf[RealCoordV()]{RealCoordV( <affixe écran> )}
\item \desc renvoie l'affixe réelle d'un vecteur compte tenu des échelles de la matrice courante.
\end{itemize}

\subsection{ScrCoord}

\begin{itemize}
\item \util \textbf[ScrCoord()]{ScrCoord( <affixe réelle> )}
\item \desc renvoie l'affixe écran d'un point en tenant compte des échelles et de la matrice courante.
\end{itemize}

\subsection{ScrCoordV}

\begin{itemize}
\item \util \textbf[ScrCoordV()]{ScrCoordV( <affixe réelle> )}
\item \desc renvoie l'affixe écran d'un vecteur en tenant compte des échelles et de la matrice courante.
\end{itemize}

\subsection{SvgCoord}\label{macSvgCoord}

\begin{itemize}
\item \util \textbf[SvgCoord()]{SvgCoord( <screen affixe> )}
\item \desc renvoie l'affixe exportée en svg en tenant compte des échelles et de la matrice courante.
\end{itemize}

\subsection{TeXCoord}\label{macTeXCoord}

\begin{itemize}
\item \util \textbf[TeXCoord()]{TeXCoord( <screen affixe> )}
\item \desc renvoie l'affixe exportée en tex, pst et pgf en tenant compte des échelles et de la matrice courante. Pour
l'eps il y a la commande \Helpref{EpsCoord}{cmdEpsCoord}.
\end{itemize}


\section{Transformations géométriques planes}

\subsection{affin}

\begin{itemize}
\item \util \textbf[affin()]{affin( <liste> , <[A, B]>, <V>, <lambda> )}
\item \desc renvoie la liste des images des points de \argu{liste} par l'affinité de base la droite \argu{(AB)}, de
rapport \argu{lambda} et de direction le vecteur \argu{V}.
\end{itemize}

\subsection{defAff}

\begin{itemize}
\item \util \textbf[defAff()]{defAff( <nom>, <A>, <A'>, <partie linéaire> )}
\item \desc cette fonction permet de créer une macro appelée \argu{nom} qui représentera l'application affine qui
transforme \argu{A}  en  \argu{A'}, et dont la partie linéaire est le dernier argument. Cette partie linéaire se
présente sous la forme d'une liste de deux complexes: [Lf(1), Lf(i)] où Lf désigne la partie linéaire de la
transformation.
\end{itemize}


\subsection{ftransform}

\begin{itemize}
\item \util \textbf[ftransform()]{ftransform( <liste>, <f(z)> )}
\item \desc renvoie la liste des images des points de \argu{liste} par la fonction \argu{f(z)}, celle-ci peut-être une
expression fonction de z ou une macro d'argument z.
\end{itemize}

\subsection{hom}

\begin{itemize}
\item \util \textbf[hom()]{hom( <liste>, <A>, <lambda> )}
\item \desc renvoie la liste des images de la \argu{liste} par l'homothétie de centre \argu{A} et de rapport
\argu{lambda}.
\end{itemize}

\subsection{inv}

\begin{itemize}
\item \util \textbf[inv()]{inv( <liste>, <A>, <R> )}
\item \desc renvoie la liste des images des points de \argu{liste} par l'inversion de cercle de centre \argu{A} et de
rayon \argu{R}.
\end{itemize}

\subsection{mtransform}
\begin{itemize}
\item \util \textbf[mtransform()]{mtransform( <liste>, <matrice> )}
\item \desc renvoie la liste des images des points de \argu{liste} par l'application affine $f$ définie par la
\argu{matrice}. Cette \Helpref{matrice}{macmatrix} est de la forme [f(0), Lf(1), Lf(i)] où Lf désigne la partie
linéaire.
\end{itemize}

\subsection{proj}

\begin{itemize}
\item \util \textbf[proj()]{proj( <liste>, <A>, <B> )} ou \Mytextbf{proj( <liste>, <[A,B]> )}
\item \desc renvoie la liste des projetés orthogonaux des points de \argu{liste} sur la droite $(AB)$.
\end{itemize}


\subsection{projO}

\begin{itemize}
\item \util \textbf[projO()]{projO( <liste>, <[A,B]>, <vecteur> )}
\item \desc renvoie la liste des projetés des points de \argu{liste} sur la droite \argu{(AB)}  dans la direction du
\argu{vecteur}.
\end{itemize}

\subsection{rot}

\begin{itemize}
\item \util \textbf[rot()]{rot( <liste>, <A>, <alpha> )}
\item \desc renvoie la liste des images des points de \argu{liste} par la rotation de centre \argu{A} et d'angle
\argu{alpha}.
\end{itemize}


\subsection{shift}

\begin{itemize}
\item \util \textbf[shift()]{shift( <liste>, <vecteur> )}
\item \desc renvoie la liste des translatés des points de \argu{liste} avec le \argu{vecteur}.
\end{itemize}


\subsection{simil}

\begin{itemize}
\item \util \textbf[simil()]{simil( <liste> , <A>, <lambda>, <alpha> )}
\item \desc renvoie la liste des images des points de \argu{liste}, par la similitude de centre \argu{A}, de rapport
\argu{lambda} et d'angle \argu{alpha}.
\end{itemize}

\subsection{sym}

\begin{itemize}
\item \util \textbf[sym()]{sym( <liste>, <A>, <B> )} ou \Mytextbf{sym( <liste>, <[A,B]> )}
\item \desc renvoie la liste des symétriques des points de \argu{liste}, par rapport à la droite $(AB)$.
\end{itemize}

\subsection{symG}

\begin{itemize}
\item \util \textbf[symG()]{symG( <liste>, <A>, <vecteur> )}
\item \desc symétrie glissée: renvoie la liste des images des points de \argu{liste}, par la symétrie orthogonale d'axe
la droite passant par \argu{A} et dirigée par \argu{vecteur}, composée avec la translation de \argu{vecteur}.
\end{itemize}

\subsection{symO}

\begin{itemize}
\item \util \textbf[symO()]{symO( <liste>, <[A, B]>, <vecteur> )}
\item \desc renvoie la liste des symétriques des points de \argu{liste} par rapport à la droite \argu{(AB)} et dans la
direction du \argu{vecteur}.
\end{itemize}


\section{Matrices de transformations 2D}\label{macmatrix}

Une transformation affine $f$ du plan complexe peut être représentée par son expression analytique dans la base canonique $(1,i)$, la forme générale de cette expression est:

{\Large
\[\left\{\begin{array}{rcl}
          x'&=&t_1+ax+by\\
y'&=&t_2+cx+dy
         \end{array}\right.\]
}

cette expression analytique sera représentée par la liste \co{[t1+i*t2, a+i*c, b+i*d]} c'est à dire: \co{[ f(0), f(1)-f(0), f(i)-f(0)]}, cette liste sera appelée plus brièvement (et de manière abusive) \textit{matrice} de la transformation $f$. Les deux derniers éléments de cette liste: \co{[ a+i*c, b+i*d]}, représentent la matrice de la partie linéaire de $f$: Lf$=f-f(0)$.

\subsection{ChangeWinTo}
\begin{itemize}
\item \util \textbf[ChangeWinTo()]{ChangeWinTo( <[xinf+i*yinf, xsup+i*ysup]> [, ortho] )}

\item \desc modifie la matrice courante de manière à transformer la fenêtre courante en la fenêtre de grande diagonale \argu{[xinf+i*yinf, xsup+i*ysup]}, la fenêtre sera orthonormée ou non en fonction de la valeur du paramètre optionnel \argu{ortho} ($0$ par défaut).
\end{itemize}


\begin{demo}{Utilisation de ChangeWinTo}{ChangeWinTo}
\begin{texgraph}[name=ChangeWinTo,export=pgf]
view(-10,10,-5,5),size(7.5),NbPoints:=100,
LabelSize:=footnotesize, SaveWin(),view(-10,-1,-5,5),
ChangeWinTo([-2-2*i,2+2*i]),
Arrows:=1, axes(0,1+i),Arrows:=0,
tMin:=-2, tMax:=2, Color:=red, Width:=8,
Cartesienne(x*Ent(1/x)-1,5,1),
Color:=blue,A:=(1+i)/4, Dparallelo(A,bar(A),-A),
dep:=RealCoord(i*Im(A)), RestoreWin(), SaveWin(),
//zoom
view(1,10,-5,5), background(full,white),
ChangeWinTo([-A,A]), Color:=black,
arr:=RealCoord(-Re(A)+i*Im(A)*0.75),
Arrows:=1, axes(0,A), Arrows:=0,
tMin:=-0.25, tMax:=0.25, Color:=red, Width:=8,
Cartesienne(x*Ent(1/x)-1,5,1),
Color:=blue, Dparallelo(A,bar(A),-A),
RestoreWin(),
//trait
Color:=blue, Arrows:=1,
A:=ScrCoord(dep), B:=ScrCoord(arr),
Bezier(A,A+3*exp(i*pi/2),B-3,B) 
\end{texgraph}
\end{demo}


\subsection{invmatrix}
\begin{itemize}
\item \util \textbf[invmatrix()]{invmatrix( <[f(0), Lf(1), Lf(i)]> )}
\item \desc renvoie l'inverse de la matrice \argu{[f(0), Lf(1), Lf(i)]}, c'est à dire la matrice $[f^{-1}(0),
Lf^{-1}(1), Lf^{-1}(i)]$ si elle existe.
\end{itemize}

\subsection{matrix}
\begin{itemize}
\item \util \textbf[matrix()]{matrix( <fonction affine>, [variable] )}
\item \desc renvoie la matrice de la \argu{fonction affine}, par défaut la \argu{variable} est $z$. Cette matrice se
présente sous la forme [f(0), Lf(1), Lf(i)], où f désigne l'application affine et Lf sa partie linéaire, plus
précisément: Lf(1)=f(1)-f(0) et Lf(i)=f(i)-f(0). 
\item \exem \co{matrix(i*bar(z))} renvoie \res{[0,i,1]}.
\end{itemize}


\subsection{mulmatrix}
\begin{itemize}
\item \util \textbf[mulmatrix()]{mulmatrix( <[f(0), Lf(1), Lf(i)]>, <[g(0), Lg(1), Lg(i)]> )}
\item \desc renvoie la matrice de la composée: $fog$, où $f$ et $g$ sont les deux applications affines définies par les
matrices passées en argument.
\end{itemize}

\section{Constructions géométriques planes}

Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets.

\subsection{bissec}
\begin{itemize}
\item \util \textbf[bissec()]{bissec( <B>, <A>, <C>, <1 ou 2> )}
\item \desc renvoie une liste de deux points de la bissectrice, 1=intérieure.
\end{itemize}

\subsection{cap}
\begin{itemize}
\item \util \textbf[cap()]{cap( <ensemble1>, <ensemble2> )}
\item \desc renvoie le contour de l'intersection de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de
points. Ces deux ensembles sont des lignes polygonales représentant des courbes fermées, orientées dans le meme
sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles.
\item \exem intersection de deux ensembles:
\end{itemize}


\begin{demo}{macro cap}{cap}
\begin{texgraph}[name=cap, export=pgf]
Marges(0,0,0,0),size(7.5),
A:=set("A", 0, [rotation:=30]), 
B:=set("B", 0, [rotation:=-30]),
C:= cap(A,B),Color:=red,FillStyle:=full, 
FillOpacity:=0.5, FillColor:=pink,
Ligne(C,0)
\end{texgraph}
\end{demo}

\subsection{capB}\label{maccapB}
\begin{itemize}
\item \util \textbf[capB()]{capB( <ensemble1>, <ensemble2> )}
\item \desc renvoie le contour de l'intersection de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de
points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. Ces deux ensembles sont
doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
ayant une forme relativement simple. La macro \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles.
\item \exem intersection de deux ensembles:
\end{itemize}


\begin{demo}{macro capB}{capB}
\begin{texgraph}[name=capB, export=pgf]
Marges(0,0,0,0),size(7.5),
A:=setB("A", 0, [rotation:=30]), 
B:=setB("B", 0, [rotation:=-30]),
C:= capB(A,B),Color:=red,FillStyle:=full, 
drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
\end{texgraph}
\end{demo}

\subsection{carre}
\begin{itemize}
\item \util \textbf[carre()]{carre( <A>, <B>, <1 ou -1> )}
\item \desc renvoie la liste des sommets du carré de sommets consécutifs A et B, 1=sens direct.
\end{itemize}

\subsection{cup}
\begin{itemize}
\item \util \textbf[cup()]{cup( <ensemble1>, <ensemble2> )}
\item \desc renvoie le contour de la réunion de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles.
\item \exem réunion de deux ensembles:
\end{itemize}

\begin{demo}{macro cup}{cup}
\begin{texgraph}[name=cup, export=pgf]
Marges(0,0,0,0),size(7.5),
A:=set("A", 0, [rotation:=30]), 
B:=set("B", 0, [rotation:=-30]),
C:= cup(A,B),Color:=red,FillStyle:=full, 
FillOpacity:=0.5, FillColor:=pink,
Ligne(C,0)
\end{texgraph}
\end{demo}

\subsection{cupB}\label{maccupB}
\begin{itemize}
\item \util \textbf[cupB()]{cupB( <ensemble1>, <ensemble2> )}
\item \desc renvoie le contour de la réunion de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de
points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. Ces deux ensembles sont
doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
ayant une forme relativement simple. La macro \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles.
\item \exem intersection de deux ensembles:
\end{itemize}

\begin{demo}{macro cupB}{cupB}
\begin{texgraph}[name=cupB, export=pgf]
Marges(0,0,0,0),size(7.5),
A:=setB("A", 0, [rotation:=30]), 
B:=setB("B", 0, [rotation:=-30]),
C:= cupB(A,B),Color:=red,FillStyle:=full, 
drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
\end{texgraph}
\end{demo}

\subsection{cutBezier}
\begin{itemize}
\item \util \textbf[cutBezier()]{cutBezier( <courbe de bézier>, <point>, <avant(0/1)> )}
\item \desc renvoie un arc de bézier correspondant à la \argu{courbe de bézier} coupée avant ou après le \argu{point},
en fonction du paramètre \argu{avant}. Le résultat doit être dessiné par la commande \Helpref{Bezier}{cmdBezier}.
\end{itemize}


\subsection{Cvx2d}
\begin{itemize}
\item \util \textbf[Cvx2d()]{Cvx2d( <liste> )}
\item \desc renvoie l'enveloppe convexe de la \argu{liste} selon l'algorithme de \textsc{Ronald Graham}. La \argu{liste} ne doit pas contenir la constante \jump.
\item \exem on choisit aléatoirement $10$ points dans le pavé $[-4,4]\times[-4,4]$ que l'on place dans une variable $P$
tout en dessinant chacun d'eux avec son numéro, puis on dessine l'enveloppe convexe.
\end{itemize}

\begin{demo}{macro Cvx2d}{Cvx2d}
\begin{texgraph}[name=Cvx2d, export=pgf]
Marges(0,0,0,0),size(7.5),
P:= for k from 1 to 10 do
    z:=8*Rand()-4+i*(8*Rand()-4),
    LabelDot(z, k,"N",1), z
    od,
Ligne(Cvx2d(P),1)
\end{texgraph}
\end{demo}


\subsection{Intersec}
\begin{itemize}
\item \util \textbf[Intersec()]{Intersec( <objet1>, <objet2> )}
\item \desc renvoie la liste des points d'intersection des deux objets graphiques. Ces deux objets peuvent être soit des
commandes graphiques (Cercle(), Droite(), ...) ou bien le nom d'un élément graphique déjà créé.
\item \exem la commande \co{Intersec( Cercle(0, 1), Droite(-1,i/2) )} renvoie:

\centerline{\res{[0.59851109463416+0.79925554731708*i, -0.99794539275033+0.00102730362483*i]}.}
\end{itemize}


\subsection{med}
\begin{itemize}
\item \util \textbf[med()]{med( <A>, <B> )}
\item \desc renvoie une liste de deux points de la médiatrice de $[A,B]$.
\end{itemize}

\subsection{parallel}
\begin{itemize}
\item \util \textbf[parallel()]{parallel( <[A,B]>, <C> )}
\item \desc renvoie une liste de deux points de la parallèle à $(AB)$ passant par $C$.
\end{itemize}


\subsection{parallelo}
\begin{itemize}
\item \util \textbf[parallelo()]{parallelo( <A>, <B>, <C> )}
\item \desc renvoie la liste des sommets du parallèlogramme de sommets consécutifs $A$, $B$, $C$.
\end{itemize}

\subsection{perp}
\begin{itemize}
\item \util \textbf[perp()]{perp( <[A, B]>, <C> )}
\item \desc renvoie une liste de deux points de la perpendiculaire à $(AB)$ passant par $C$.
\end{itemize}


\subsection{polyreg}
\begin{itemize}
\item \util \textbf[polyreg()]{polyreg( <A>, <B>, <nombre de cotés> )}
\item \desc renvoie la liste des sommets du polygône régulier de centre $A$, passant par $B$ et avec le nombre de côtés indiqué.
\end{itemize}

ou

\begin{itemize}
\item \util \Mytextbf{polyreg( <A>, <B>, <nombre de cotés + i*sens> )} avec sens = +/-1
\item \desc renvoie la liste des sommets du polygône régulier de sommets consécutifs $A$ et $B$, avec le nombre de côtés indiqué et dans le sens indiqué (1 pour le sens trigonométrique).
\end{itemize}

\subsection{pqGoneReg}
\begin{itemize}
\item \util \textbf[pqGoneReg()]{pqGoneReg( <centre>, <sommet>, <[p,q]> )}
\item \desc renvoie la liste des sommets du \argu{p/q}-gône régulier défini par le \argu{centre} et un \argu{sommet}.
\item \exem voir \Helpref{ici}{macDpqGoneReg}.
\end{itemize}


\subsection{rect} 
\begin{itemize}
\item \util \textbf[rect()]{rect( <A>, <B>, <C> )}
\item \desc renvoie la liste des sommets du rectangle de sommets consécutifs $A$, $B$, le côté opposé passant par $C$.
\end{itemize}

\subsection{setminus}
\begin{itemize}
\item \util \textbf[setminus()]{setminus( <ensemble1>, <ensemble2> )}
\item \desc renvoie le contour de la différence \argu{ensemble1} - \argu{ensemble2} sous forme d'une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles.
\item \exem différence de deux ensembles:
\end{itemize}

\begin{demo}{macro setminus}{setminus}
\begin{texgraph}[name=setminus, export=pgf]
Marges(0,0,0,0),size(7.5),
A:=set("A", 0, [rotation:=30]), 
B:=set("B", 0, [rotation:=-30]),
C:= setminus(A,B),Color:=red,FillStyle:=full, 
FillOpacity:=0.5, FillColor:=pink,
Ligne(C,0)
\end{texgraph}
\end{demo}

\subsection{setminusB}\label{macsetminusB}
\begin{itemize}
\item \util \textbf[setminusB()]{setminusB( <ensemble1>, <ensemble2> )}
\item \desc renvoie le contour de la différence \argu{ensemble1} - \argu{ensemble2} sous forme d'une liste de
points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. Ces deux ensembles sont
doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
ayant une forme relativement simple. La macro \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles.
\item \exem différence de deux ensembles:
\end{itemize}

\begin{demo}{macro setminusB}{setminusB}
\begin{texgraph}[name=setminusB, export=pgf]
Marges(0,0,0,0),size(7.5),
A:=setB("A", 0, [rotation:=30]), 
B:=setB("B", 0, [rotation:=-30]),
C:= setminusB(A,B),Color:=red,FillStyle:=full, 
drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
\end{texgraph}
\end{demo}

\section{Gestion du flattened postscript}

Il est possible de transformer un fichier pdf ou un fichier postscript en \textit{flattened postscript} grâce à l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). Dans le fichier obtenu, tout est chemin, y compris le texte. TeXgraph peut récupérer tous les chemins d'un fichier écrit en \textit{flattened postscript}. C'est que proposent les macros de cette section.

\subsection{conv2FlatPs}\label{macconv2FlatPs}

\begin{itemize}
\item \util \textbf[conv2FlatPs()]{conv2FlatPs( <fichier entrée>, <fichier sortie> [, dossier de travail] )}
\item \desc cette macro invoque l'utilitaire \textit{pstoedit} pour transformer le \argu{fichier entrée} en \textit{flattened postscript} dans le \argu{fichier sortie}. Le fichier \argu{fichier entrée} doit être un fichier pdf ou ps. 
\end{itemize}

\subsection{drawFlatPs}\label{macdrawFlatPs}
\begin{itemize}
\item \util \textbf[drawFlatPs()]{drawFlatPs( <affixe>, <chemins lus par loadFlatPs> [, options] )}
\item \desc cette macro dessine à l'écran l'ensemble des chemins lus dans un fichier en \textit{flattened postscript} par la macro \Helpref{loadFlatPs}{macloadFlatPs}. L'affichage se fait à l'\argu{affixe} demandé. Le paramètre \argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les options sont:
        \begin{itemize}
        \item \opt{scale}{nombre positif}: échelle, 1 par défaut.
        \item \opt{position}{center/left/right/...}: position de l'affixe par rapport à l'image, center par défaut (fonctionne comme la variable LabelStyle).
        \item \opt{color}{couleur}: pour imposer une couleur, \Nil par défaut ce qui signifie qu'on prend la couleur d'origine.
        \item \opt{rotation}{angle en degrés}: 0 par défaut.
        \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués.
        \item \opt{select}{liste des numéros de chemin à montrer}: \Nil par défaut, ce qui signifie tous les chemins.
        \end{itemize}

\end{itemize}

\subsection{drawTeXlabel}\label{macdrawTeXlabel}
\begin{itemize}
\item \util \textbf[drawTeXlabel()]{drawTeXlabel( <affixe>, <variable contenant la formule TeX lue par loadFlatPs>, [, options] )}
\item \desc cette macro invoque la macro \Helpref{drawFlatPs}{macdrawFlatPs} pour dessiner une expression qui a été au
préalable compilée par \TeX. Le paramètre \argu{options} est une liste (facultative) de la forme \textsl{[ option1:=
valeur1, ..., optionN:=valeurN ]}, les options sont:

        \begin{itemize}
        \item \opt{scale}{nombre>0}: échelle, 1 par défaut.
        \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués.
        \end{itemize}
Cette macro est utilisée en interne par la macro \Helpref{NewTeXlabel}{macNewTeXlabel}.
\end{itemize}


\subsection{loadFlatPs}\label{macloadFlatPs}
\begin{itemize}
\item \util \textbf[loadFlatPs()]{loadFlatPs( <fichier en flattened postscript>, [, options] )}
\item \desc cette macro charge un \argu{fichier en flattened postscript}, adpate les coordonnées des points et renvoie
la liste des chemins (que l'on peut alors dessiner avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}). Le paramètre
\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les
options sont:
        \begin{itemize}
        \item \opt{width}{nombre>0}: largeur en cm, \Nil par défaut pour largeur naturelle.
        \item \opt{height}{nombre>0}: hauteur en cm, \Nil par défaut pour hauteur naturelle.
        \end{itemize}
\item supposons que vous ayez le fichier \textit{circuit.pdf} dans le dossier temporaire de TeXgraph, la commande
suivante dans un élément graphique Utilisateur:
\end{itemize}

\begin{verbatim}
     [conv2FlatPs( "circuit.pdf", "circuit.fps", @TmpPath),
      stock:= loadFlatPs( [@TmpPath,"circuit.fps"] ),
      drawFlatPs( 0, stock, [scale:=1, hollow:=1] )
     ]
\end{verbatim}

va permettre de charger et dessiner le contenu de ce fichier dans TeXgraph, sans faire les remplissages.


\subsection{NewTeXlabel}\label{macNewTeXlabel}
\begin{itemize}
\item \util \textbf[NewTeXlabel()]{NewTeXlabel( <nom>, <affixe>, <formule TeX>, [, options] )}
\item \desc cette macro va demander à \TeX{} de compiler la formule dans un fichier pdf, ce fichier sera ensuite
converti
en un fichier eps par pstoedit, puis celui-ci sera chargé par loadFlatPs et stocké dans une variable globale appelée
TeX\_+nom. Un élément graphique appelé \argu{nom} est créée pour dessiner la formule avec drawTeXLabel. Le paramètre
\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les
options sont:
        \begin{itemize}
        \item \opt{dollar}{0/1}: indique à TeXgraph s'il doit ajouter les délimiteurs \verb|\[| et \verb|\]| autour de la formule, 1 par défaut.
        \item \opt{scale}{nombre>0}: échelle, 1 par défaut.
        \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués.
        \end{itemize}
Dans les options, les attributs suivants peuvent également être utilisés:  \var{LabelStyle}, \var{LabelAngle} et
\var{Color}.

Voici la définition de cette macro:

\begin{small}
\begin{verbatim}
[dollar:=1, scale:=1, hollow:=0, $options:=%4,
 $aux:=OpenFile([@TmpPath,"formula.tex"]),
 if dollar then WriteFile(["\[",%3,"\]"]) else WriteFile(%3) fi,
 CloseFile(),
 Exec("pdflatex","-interaction=nonstopmode tex2FlatPs.tex",@TmpPath,1),
 Exec("pstoedit -dt -pta -f ps -r2400x2400","tex2FlatPs.pdf tex2FlatPs.eps",@TmpPath,1),
 NewVar(["TeX_",%1],loadFlatPs([@TmpPath,"tex2FlatPs.eps"])),
 NewGraph(%1, ["drawTeXlabel(",%2,", TeX_",%1,", [scale:=",scale,", hollow:=",hollow,"])"]),
 ReDraw()
]
\end{verbatim}
\end{small}

La formule est écrite dans le fichier \textit{formula.tex}, puis on compile le fichier \textit{tex2FlatPs.tex} suivant:

\begin{verbatim}
        \documentclass[12pt]{article}
        \usepackage{amsmath,amssymb}
        \usepackage{fourier}
        \pagestyle{empty}
        \begin{document}
        \large
        \input{formula.tex}%
        \end{document}
\end{verbatim}

et on convertit le résultat en \textit{flattened postscript} avant de le charger.

Cette macro s'utilise dans la ligne de commande ou bien dans des macros qui créent des éléments graphiques, mais pas directement dans un élément graphique Utilisateur, exemple:

\centerline{\co{NewTeXlabel( "label1", 0, "\bks frac\{\bks pi\}\{\bks sqrt\{2\}\}", [scale:=1.5, Color:=blue, LabelAngle:=45])}}
\end{itemize}


\section{Autres}

\subsection{pdfprog}
\begin{itemize}
\item \util \textbf[pdfprog()]{pdfprog()}.
\item \desc  cette macro est utilisée en interne pour mémoriser le programme utilisé pour faire la conversion
 du format eps vers le format pdf. Par défaut, cette macro contient la chaine: \textsl{"epstopdf"}. En éditant le fichier TeXgraph.mac, vous pouvez modifier le programme utilisé.
\end{itemize}