1 \chapter{Les macros mathématiques de TeXgraph.mac
}
3 \section{Opérations arithmétiques et logiques
}
8 \item \util \textbf[Ceil()
]{Ceil( <x> )
}.
9 \item \desc renvoie le plus petit entier supérieur ou égal au réel
\argu{x
}.
15 \item \util \textbf[div()
]{div( <x>, <y> )
}.
16 \item \desc renvoie l'unique entier $k$ tel que $x-ky$ soit dans l'intervalle $
[0;|y|
[$.
22 \item \util \textbf[mod()
]{mod( <x>, <y> )
}.
23 \item \desc renvoie l'unique réel $r$ de l'intervalle $
[0;|y|
[$ tel que
24 $x=ky+r$ avec $k$ entier.
27 \subsection{not
}\label{macnot
}
30 \item \util \textbf[not()
]{not( <expression booléenne> )
}
31 \item \desc renvoie la valeur booléenne de la négation.
37 \item \util \textbf[pgcd()
]{pgcd( <a>, <b>
[, <u>, <v>
] )
}
38 \item \desc renvoie la valeur d du pgcd de
\argu{a
} et
\argu{b
}, ainsi que deux coefficients de Bezout dans les
39 variables
\argu{u
} et
\argu{v
} (si celles-ci sont présentes), de telle sorte que $au+bv=d$.
45 \item \util \textbf[ppcm()
]{ppcm( <a>, <b> )
}
46 \item \desc renvoie la valeur du ppcm de
\argu{a
} et
\argu{b
}.
49 \section{Opérations sur les variables
}
54 \item \util \textbf[Abs()
]{Abs( <affixe> )
}.
55 \item \desc cette macro donne la norme en cm.
62 \item \util \textbf[free()
]{free( <x> )
}.
63 \item \desc libère la variable
\argu{x
} en la mettant à
\Nil. Depuis la version
1.93 on peut faire directement
64 l'affectation à la constante
\Nil, par exemple:
\co{x:=Nil
}.
71 \item \util \textbf[IsIn()
]{IsIn( <affixe>
[, <epsilon>
] )
}.
72 \item \desc renvoie
1 si l'
\argu{affixe
} est dans la fenêtre graphique,
0 sinon. Cette macro tient compte de la matrice
73 courante, le test se fait à
\argu{epsilon
} près et
\argu{epsilon
} vaut
0.0001 cm par défaut.
79 \item \util \textbf[nil()
]{nil( <x> )
}.
80 \item \desc renvoie
1 si la variable
\argu{x
} est à
\Nil,
0 sinon. Depuis la version
1.93 on peut faire directement le
81 test d'égalité avec la constante
\Nil.
87 \item \util \textbf[round()
]{round( <liste>
[, décimales
] )
}
88 \item \desc tronque les complexes de la
\argu{liste
} en arrondissant au plus proche les parties réelles et imaginaires
89 avec le nombre de
\argu{décimales
} demandé (
0 par défaut). Si la
\argu{liste
} contient le constante
\jump, alors
90 celle-ci est renvoyée dans la liste des résultats. Cette macro utilise la commande
\Helpref{{Round
}}{cmdRound
} (qui ne
91 s'applique qu'à un complexe et non une liste).
94 \section{Opérations sur les listes
}
98 \item \util \textbf[bary()
]{bary( <
[affixe1, coef1, affixe2, coef2, ...
]> )
}.
99 \item \desc renvoie le barycentre du système pondéré
\argu{[(affixe1, coef1), (affixe2, coef2),...
]}.
104 \item \util \textbf[del()
]{del( <liste>, <liste des index à supprimer>, <quantité à supprimer> )
}.
105 \item \desc renvoie la liste après avoir supprimer les éléments dont l'index figure dans la
\argu{liste des index à
106 supprimer
}. La
\argu{quantité à supprimer
} (à chaque fois) est de $
1$ par défaut, cet argument peut être une liste lui
110 \item \co{del(
[1,
2,
3,
4,
5,
6,
7,
8],
[2,
6,
8])
} donne
\res{[1,
3,
4,
5,
7]}.
111 \item \co{del(
[1,
2,
3,
4,
5,
6,
7,
8],
[2,
6,
8],
2)
} donne
\res{[1,
4,
5]}.
112 \item \co{del(
[1,
2,
3,
4,
5,
6,
7,
8],
[2,
6,
8],
[1,
2])
} donne
\res{[1,
3,
4,
5]}.
113 \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]}.
119 \item \util \textbf[getdot()
]{getdot( <s> , <ligne polygonale> )
}.
120 \item \desc renvoie le point de la
\argu{ligne polygonale
} ayant
\argu{s
} comme abscisse curviligne. Le paramètre
121 \argu{s
} doit être dans l'intervalle $
[0;
1]$, $
0$ pour le premier point, et $
1$ pour le dernier.
127 \item \util \textbf[IsAlign()
]{IsAlign( <liste points
2D>
[, epsilon
] )
}.
128 \item \desc renvoie
1 si les points sont sur une même droite,
0 sinon. Par défaut la tolérance
\argu{epsilon
} vaut
129 1E-10. La
\argu{liste
} ne doit pas contenir la constante
\jump.
136 \item \util \textbf[isobar()
]{isobar( <
[affixe1, affixe2, ...
]> )
}.
137 \item \desc renvoie l'isobarycentre du système
\argu{[affixe1, affixe2, ...
]}.
142 \item \util \textbf[KillDup()
]{KillDup( <liste>
[, epsilon
] )
}.
143 \item \desc renvoie la liste sans doublons. Les comparaisons se font à
\argu{epsilon
} près (qui vaut $
0$ par défaut).
144 \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]}.
149 \item \util \textbf[length()
]{length( <liste> )
}.
150 \item \desc calcule la longueur de la
\argu{liste
} en cm.
155 \item \util \textbf[permute()
]{permute( <liste> )
}.
156 \item \desc modifie la
\argu{liste
} en plaçant le premier élément à la fin,
\argu{liste
} doit être une variable.
157 \item la commande
\co{[x:=
[1,
2,
3,
4], permute(x), x
]} renvoie
\res{[2,
3,
4,
1]}.
162 \item \util \textbf[Pos()
]{Pos( <affixe>, <liste>,
[, epsilon
] )
}.
163 \item \desc renvoie la liste des positions de l'
\argu{affixe
} dans la
\argu{liste
}, la comparaison se fait à
164 \argu{epsilon
} près, par défaut
\argu{epsilon
} vaut
0.
165 \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.
169 \subsection{rectangle
}
171 \item \util \textbf[rectangle()
]{rectangle( <liste> )
}.
172 \item \desc détermine le plus petit rectangle contenant la liste, cette macro renvoie une liste de deux complexes qui
173 représentent l'affixe du coin inférieur gauche suivi de celle du coin supérieur droit.
178 \item \util \textbf[replace()
]{replace( <liste>, <position>, <valeur> )
}.
179 \item \desc modifie la variable
\argu{liste
} en remplaçant l'élément numéro
\argu{position
} par la
\argu{valeur
}, cette
185 \item \util \textbf[reverse()
]{reverse( <liste> )
}.
186 \item \desc renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un
\jump).
189 \subsection{SortWith
}
191 \item \util \textbf[SortWith()
]{SortWith( <liste clés>, <liste>, <taille paquets>
[, mode
] )
}.
192 \item \desc trie la
\textbf{variable
} \argu{liste
} suivant les
\argu{clés
}. Les éléments de la
\argu{liste
} sont
193 traités par
\argu{paquets
}, leur taille est de
1 par défaut. La
\argu{taille paquets
} peut être égale à
\jump pour un
194 traitement par composante. Si un paquet n'est pas complet, il n'est pas traité. Si la liste contient la
195 constante
\jump, alors toutes les composantes sont triées chacune leur tour. Le dernier paramètre détermine
196 le type de tri:
\argu{mode
}=
0 pour ordre croissant (valeur par défaut),
\argu{mode
}=
1 pour décroissant.
199 \section{Gestion des listes par composantes
}
201 La convention adoptée est que deux composantes sont séparées par la constante
\jump. Une composante peut être vide.
205 \item \util \textbf[CpCopy()
]{CpCopy( <liste>, <index depart>, <nombre> )
}.
206 \item \desc cette fonction renvoie la liste constituée par les
\argu{nombre
} composantes de la
\argu{liste
} à partir de
207 la composante numéro
\argu{depart
} [inclus
]. Si
\argu{nombre
} est nul, alors la fonction renvoie toutes les composantes
208 de la liste à partir de la composante numéro
\argu{départ
}.
210 Si le numéro
\argu{depart
} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la
211 dernière composante a l'index $-
1$, l'avant-dernière a l'index $-
2$ $
\cdots$ etc. La fonction renvoie les
\argu{nombre
}
212 composantes de la liste (ou toute la liste si
\argu{nombre
} est nul) en allant vers la gauche, mais la liste renvoyée
213 est dans le même sens que la
\argu{liste
}, et cette dernière n'est pas modifiée.
214 \item \exem \begin{itemize
}
215 \item \co{CpCopy(
[1,
2,jump,
3,
7,
8,jump,
4,jump,
5,
6],
2,
1)
} renvoie
\res{[3,
7,
8]}.
216 \item \co{CpCopy(
[1,
2,jump,
3,
7,
8,jump,
4,jump,
5,
6], -
1,
2)
} renvoie
\res{[4,jump,
5,
6]}.
217 \item \co{CpCopy(
[1,
2,jump,
3,
7,
8,jump,
4,jump,
5,
6], -
3,
0)
} renvoie
\res{[1,
2,jump,
3,
7,
8]}.
223 \item \util \textbf[CpDel()
]{CpDel( <variable liste>, <index depart>, <nombre> )
}.
224 \item \desc cette fonction détruit dans la
\argu{variable liste
}, les
\argu{nombre
} composantes à partir
225 de la composante numéro
\argu{depart
} [inclus
]. Si
\argu{nombre
} est nul, alors la fonction détruit toutes les
226 composantes de la
\argu{variable liste
} à partir de la composante numéro
\argu{départ
}.
228 Si le numéro
\argu{depart
} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la
229 dernière composante a l'index $-
1$, l'avant-dernière a l'index $-
2$ $
\cdots$ etc. La fonction détruit les
\argu{nombre
}
230 composantes de la <variable liste> (ou toute la liste si
\argu{nombre
} est nul) en allant vers la gauche.
232 Le paramètre
\argu{variable liste
} doit être
\Mytextbf{un nom de variable
}, celle-ci est modifiée et la macro renvoie
238 \item \util \textbf[CpNops()
]{CpNops( <liste> )
}.
239 \item \desc cette fonction évalue
\argu{liste
} et renvoie le nombre de composantes qui la composent.
242 \item \co{CpNops(
[1,
2,jump,
3] )
} renvoie la valeur
\res{2}.
243 \item \co{CpNops(
[1,
2,jump,
3,jump
] )
} renvoie la valeur
\res{3}.
244 \item \co{CpNops(
[jump
] )
} renvoie la valeur
\res{2}.
248 \subsection{CpReplace
}
250 \item \util \textbf[CpReplace()
]{CpReplace( <variable liste>, <position>, <nouveau> )
}.
251 \item \desc modifie la
\argu{variable liste
} en remplaçant la composante numéro
\argu{position
} par
\argu{nouveau
},
252 cette macro renvoie
\Nil.
255 \subsection{CpReverse
}
257 \item \util \textbf[CpReverse()
]{CpReverse( <liste> )
}.
258 \item \desc renvoie la
\argu{liste
} avec les composantes dans l'ordre inverse.
259 \item \exem \co{CpReverse(
[1,
2,jump,
3,
4,
5,jump
])
} renvoie
\res{[jump,
3,
4,
5,jump,
1,
2]}.
262 \section{Gestion des listes de chaînes
}
264 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$
265 est donnée par
\verb|@nomListe(k)|, alors que la longueur de la liste (nombre d'éléments) est donnée par
268 \subsection{StrListInit
}\label{macStrListInit
}
270 \item \util \textbf[StrListInit()
]{StrListInit( <nomListe>, <"chaine1">, <"chaine2">, ... )
}.
271 \item \desc crée une liste de chaines sous forme d'une macro appelée
\argu{nomListe
}, les arguments suivants sont
272 interprétés comme des chaînes, ils constituent les éléments de la liste et sont indexés à partir de
1.
273 \item \exem Après la commande
\co{StrListInit(essai, "toto",
["toto",
2/
4],
24)
}, une macro du nom de
\Mytextbf{essai
}
274 est créée et son contenu est:
277 if z<
0 then Inc(z,
4) fi,
280 elif z=
2 then "toto0.5"
285 \item \exem Afficher des labels avec une affixe et une orientation pour chacun, en utilisant une seule fois LabelDot.
288 \begin{demo
}{Utilisation de StrListInit
}{StrListInit
}
289 \begin{texgraph
}[name=StrListInit,export=pgf
]
290 view(-
2,
2,-
2,
2), Marges(
0,
0,
0,
0), size(
7.5),
291 StrListInit( nom, -
1,"$A$","O", i,"$B$","N",
292 1,"$C$","E", -i,"$D$","S"),
293 for k from
1 to nom(
0) step
3 do
294 LabelDot( Eval(@nom(k)), @nom(k+
1), @nom(k+
2),
1)
300 Une autre solution consiste à faire trois listes: nom, position, orientation:
302 view(-
2,
2,-
2,
2), Marges(
0,
0,
0,
0), size(
7.5),
303 StrListInit( nom, "$A$", "$B$", "$C$", "$D$"),
304 StrListInit(orientation, "O", "N", "E", "S"),
305 position:=
[-
1, i,
1, -i
],
306 for k from
1 to nom(
0) do
307 LabelDot( position
[k
], @nom(k), @orientation(k),
1)
309 StrListKill(nom, orientation)
312 \subsection{StrListAdd
}
314 \item \util \textbf[StrListAdd()
]{StrListAdd( <nomListe>, <"chaine1">, <"chaine2">, ... )
}.
315 \item \desc cette macro ajoute à la fin de la liste de chaînes appelée
\argu{nomListe
}, les arguments suivants (qui sont
316 interprétés comme des chaînes). Cela suppose que la liste
\argu{nomListe
} existe déjà, cette liste est en fait une
317 macro qui va être entièrement réécrite pour lui ajouter les éléments supplémentaires. Il est plus rapide de définir la
318 liste en une seule fois avec la macro
\Helpref{StrListInit
}{macStrListInit
} quand c'est possible.
321 \subsection{StrListCopy
}
323 \item \util \textbf[StrListCopy()
]{StrListCopy( <nomListe>, <nouvelleListe>
[, index depart, nombre
] )
}.
324 \item \desc cette macro crée une nouvelle liste de chaînes appelée
\argu{nouvelleListe
} en copiant
\argu{nombre
}
325 éléments de la liste
\argu{nomListe
} en partant de
\argu{index depart
}. L'argument
326 <index depart> peut être négatif ($-
1$ designe le dernier élément, $-
2$ l'avant-dernier, ...), par contre les éléments
327 sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est
328 négatif. Par défaut l'
\argu{index depart
} vaut $
1$ et le
\argu{nombre
} vaut $
0$ (ce qui signifie
\og tous les
332 \subsection{StrListDelKey
}
334 \item \util \textbf[StrListDelKey()
]{StrListDelKey( <nomListe>, <index depart>, <nombre> )
}.
335 \item \desc cette macro supprime de
\argu{nomListe
} \argu{nombre
} éléments à partir de l'
\argu{index depart
}. Comme
336 dans la commande Del, l'argument
\argu{index depart
} peut être négatif ($-
1$ designe le dernier élément,
337 $-
2$ l'avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est
338 positif, et dans le sens inverse quand <nombre> est négatif. Cette macro renvoie
\Nil.
341 \subsection{StrListDelVal
}
343 \item \util \textbf[StrListDelVal()
]{StrListDelVal( <nomListe>, <val1>, <val2>, ... )
}.
344 \item \desc cette macro supprime de
\argu{nomListe
} les chaînes
\argu{val1
},
\argu{val2
}..., sans avoir à connaître
348 \subsection{StrListGetKey
}
350 \item \util \textbf[StrListGetKey()
]{StrListGetKey( <nomListe>, <chaine> )
}.
351 \item \desc cette macro renvoie l'index de la
\argu{chaîne
} dans la liste
\argu{nomListe
}, si elle n'y figure pas, la
355 \subsection{StrListInsert
}
357 \item \util \textbf[StrListInsert()
]{StrListInsert( <nomListe1>, <chaîne>
[, <index>
])
}.
358 \item \desc cette macro modifie la liste de chaines
\argu{nomListe
}, en insérant une nouvelle
\argu{chaîne
} à la
359 position
\argu{index
}. Par défaut la valeur de
\argu{index
} est nulle ce qui représente la fin de la liste, cette valeur
360 peut être négative ($-
1$ est l'index du dernier élément, $-
2$ l'avant-dernier, ...).
363 \subsection{StrListKill
}
365 \item \util \textbf[StrListKill()
]{StrListKill( <nomListe1>, <nomListe2>, ... )
}.
366 \item \desc cette macro détruit les listes de chaînes
\argu{nomListe1
},
\argu{nomListe2
}, ...
369 \subsection{StrListReplace
}
371 \item \util \textbf[StrListReplace()
]{StrListReplace( <nomListe>, <ancienne chaine>, <nouvelle> )
}.
372 \item \desc cette macro remplace dans la liste appelée
\argu{nomListe
}, l'
\argu{ancienne chaine
} par la
\argu{nouvelle
}.
375 \subsection{StrListReplaceKey
}
377 \item \util \textbf[StrListReplaceKey()
]{StrListReplaceKey( <nomListe>, <index>, <nouvelle chaîne> )
}.
378 \item \desc cette macro remplace dans la liste appelée
\argu{nomListe
}, la chaîne dont le numéro est
\argu{index
}, par
379 la
\argu{nouvelle chaîne
}.
382 \subsection{StrListShow
}
384 \item \util \textbf[StrListShow()
]{StrListShow( <nomListe>
[, <index depart>, <nombre>
])
}.
385 \item \desc cette macro renvoie la chaîne obtenue en copiant
\argu{nombre
} éléments de la liste
\argu{nomListe
} en
387 \argu{index depart
}, mais sans les concaténer. La chaîne renvoyée est de la forme:
\verb|"chaine", "chaine", ...|.
388 L'argument <index depart> peut être négatif ($-
1$ designe le dernier élément, $-
2$ l'avant-dernier, ...), par contre
389 les éléments sont toujours parcourus de gauche à droite quand
\argu{nombre
} est positif, et dans le sens inverse quand
390 <nombre> est négatif. Par défaut l'<index depart> vaut $
1$ et le
\argu{nombre
} vaut $
0$ (ce qui signifie
\og tous les
395 \section{Fonctions statistiques
}
399 \item \util \textbf[Anp()
]{Anp( <n>, <p> )
}.
400 \item \desc renvoie le nombre d'arrangements de
\argu{p
} parmi
\argu{n
}.
405 \item \util \textbf[binom()
]{binom( <n>, <p> )
}.
406 \item \desc renvoie le coefficient binomial (ou combinaison)
\argu{p
} parmi
\argu{n
}.
412 \item \util \textbf[ecart()
]{ecart( <liste réels> )
}.
413 \item \desc renvoie l'écart type d'une liste de réels, la constante
\jump est ignorée.
418 \item \util \textbf[fact()
]{fact( <n> )
}.
419 \item \desc renvoie la valeur de $n!$ (fonction factorielle).
425 \item \util \textbf[max()
]{max( <liste complexes> )
}.
426 \item \desc renvoie le plus grand élément d'une liste de complexes (ordre lexicographique), la constante
\jump est
432 \item \util \textbf[min()
]{min( <liste complexes> )
}.
433 \item \desc renvoie le plus petit élément d'une liste de complexes (ordre lexicographique), la constante
\jump est
439 \item \util \textbf[median()
]{median( <liste complexes> )
}.
440 \item \desc renvoie l'élément médian d'une liste de complexes (ordre lexicographique), la constante
\jump est ignorée.
445 \item \util \textbf[moy()
]{moy( <liste complexes> )
}.
446 \item \desc renvoie la moyenne d'une liste de complexes, la constante
\jump est ignorée.
451 \item \util \textbf[prod()
]{prod( <liste complexes> )
}.
452 \item \desc renvoie le produit des éléments d'une liste de complexes, la constante
\jump est ignorée.
457 \item \util \textbf[sum()
]{sum( <liste complexes> )
}.
458 \item \desc renvoie la somme des éléments d'une liste de complexes, la constante
\jump est ignorée.
463 \item \util \textbf[var()
]{var( <liste réels> )
}.
464 \item \desc renvoie la variance d'une liste de réels, la constante
\jump est ignorée.
467 \section{Fonctions de conversion
}
472 \item \util \textbf[RealArg()
]{RealArg( <affixe> )
}
473 \item \desc renvoie l'argument (en radians) de l'affixe réelle d'un vecteur en tenant compte de la matrice courante.
477 \subsection{RealCoord
}
479 \item \util \textbf[RealCoord()
]{RealCoord( <affixe écran> )
}
481 \item \desc renvoie l'affixe réelle d'un point compte tenu des échelles et de la matrice courante.
484 \subsection{RealCoordV
}
487 \item \util \textbf[RealCoordV()
]{RealCoordV( <affixe écran> )
}
488 \item \desc renvoie l'affixe réelle d'un vecteur compte tenu des échelles de la matrice courante.
491 \subsection{ScrCoord
}
494 \item \util \textbf[ScrCoord()
]{ScrCoord( <affixe réelle> )
}
495 \item \desc renvoie l'affixe écran d'un point en tenant compte des échelles et de la matrice courante.
498 \subsection{ScrCoordV
}
501 \item \util \textbf[ScrCoordV()
]{ScrCoordV( <affixe réelle> )
}
502 \item \desc renvoie l'affixe écran d'un vecteur en tenant compte des échelles et de la matrice courante.
505 \subsection{SvgCoord
}\label{macSvgCoord
}
508 \item \util \textbf[SvgCoord()
]{SvgCoord( <screen affixe> )
}
509 \item \desc renvoie l'affixe exportée en svg en tenant compte des échelles et de la matrice courante.
512 \subsection{TeXCoord
}\label{macTeXCoord
}
515 \item \util \textbf[TeXCoord()
]{TeXCoord( <screen affixe> )
}
516 \item \desc renvoie l'affixe exportée en tex, pst et pgf en tenant compte des échelles et de la matrice courante. Pour
517 l'eps il y a la commande
\Helpref{EpsCoord
}{cmdEpsCoord
}.
521 \section{Transformations géométriques planes
}
526 \item \util \textbf[affin()
]{affin( <liste> , <
[A, B
]>, <V>, <lambda> )
}
527 \item \desc renvoie la liste des images des points de
\argu{liste
} par l'affinité de base la droite
\argu{(AB)
}, de
528 rapport
\argu{lambda
} et de direction le vecteur
\argu{V
}.
534 \item \util \textbf[defAff()
]{defAff( <nom>, <A>, <A'>, <partie linéaire> )
}
535 \item \desc cette fonction permet de créer une macro appelée
\argu{nom
} qui représentera l'application affine qui
536 transforme
\argu{A
} en
\argu{A'
}, et dont la partie linéaire est le dernier argument. Cette partie linéaire se
537 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
542 \subsection{ftransform
}
545 \item \util \textbf[ftransform()
]{ftransform( <liste>, <f(z)> )
}
546 \item \desc renvoie la liste des images des points de
\argu{liste
} par la fonction
\argu{f(z)
}, celle-ci peut-être une
547 expression fonction de z ou une macro d'argument z.
553 \item \util \textbf[hom()
]{hom( <liste>, <A>, <lambda> )
}
554 \item \desc renvoie la liste des images de la
\argu{liste
} par l'homothétie de centre
\argu{A
} et de rapport
561 \item \util \textbf[inv()
]{inv( <liste>, <A>, <R> )
}
562 \item \desc renvoie la liste des images des points de
\argu{liste
} par l'inversion de cercle de centre
\argu{A
} et de
566 \subsection{mtransform
}
568 \item \util \textbf[mtransform()
]{mtransform( <liste>, <matrice> )
}
569 \item \desc renvoie la liste des images des points de
\argu{liste
} par l'application affine $f$ définie par la
570 \argu{matrice
}. Cette
\Helpref{matrice
}{macmatrix
} est de la forme
[f(
0), Lf(
1), Lf(i)
] où Lf désigne la partie
577 \item \util \textbf[proj()
]{proj( <liste>, <A>, <B> )
} ou
\Mytextbf{proj( <liste>, <
[A,B
]> )
}
578 \item \desc renvoie la liste des projetés orthogonaux des points de
\argu{liste
} sur la droite $(AB)$.
585 \item \util \textbf[projO()
]{projO( <liste>, <
[A,B
]>, <vecteur> )
}
586 \item \desc renvoie la liste des projetés des points de
\argu{liste
} sur la droite
\argu{(AB)
} dans la direction du
593 \item \util \textbf[rot()
]{rot( <liste>, <A>, <alpha> )
}
594 \item \desc renvoie la liste des images des points de
\argu{liste
} par la rotation de centre
\argu{A
} et d'angle
602 \item \util \textbf[shift()
]{shift( <liste>, <vecteur> )
}
603 \item \desc renvoie la liste des translatés des points de
\argu{liste
} avec le
\argu{vecteur
}.
610 \item \util \textbf[simil()
]{simil( <liste> , <A>, <lambda>, <alpha> )
}
611 \item \desc renvoie la liste des images des points de
\argu{liste
}, par la similitude de centre
\argu{A
}, de rapport
612 \argu{lambda
} et d'angle
\argu{alpha
}.
618 \item \util \textbf[sym()
]{sym( <liste>, <A>, <B> )
} ou
\Mytextbf{sym( <liste>, <
[A,B
]> )
}
619 \item \desc renvoie la liste des symétriques des points de
\argu{liste
}, par rapport à la droite $(AB)$.
625 \item \util \textbf[symG()
]{symG( <liste>, <A>, <vecteur> )
}
626 \item \desc symétrie glissée: renvoie la liste des images des points de
\argu{liste
}, par la symétrie orthogonale d'axe
627 la droite passant par
\argu{A
} et dirigée par
\argu{vecteur
}, composée avec la translation de
\argu{vecteur
}.
633 \item \util \textbf[symO()
]{symO( <liste>, <
[A, B
]>, <vecteur> )
}
634 \item \desc renvoie la liste des symétriques des points de
\argu{liste
} par rapport à la droite
\argu{(AB)
} et dans la
635 direction du
\argu{vecteur
}.
639 \section{Matrices de transformations
2D
}\label{macmatrix
}
641 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:
644 \
[\left\
{\begin{array
}{rcl
}
650 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)$.
652 \subsection{ChangeWinTo
}
654 \item \util \textbf[ChangeWinTo()
]{ChangeWinTo( <
[xinf+i*yinf, xsup+i*ysup
]>
[, ortho
] )
}
656 \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).
660 \begin{demo
}{Utilisation de ChangeWinTo
}{ChangeWinTo
}
661 \begin{texgraph
}[name=ChangeWinTo,export=pgf
]
662 view(-
10,
10,-
5,
5),size(
7.5),NbPoints:=
100,
663 LabelSize:=footnotesize, SaveWin(),view(-
10,-
1,-
5,
5),
664 ChangeWinTo(
[-
2-
2*i,
2+
2*i
]),
665 Arrows:=
1, axes(
0,
1+i),Arrows:=
0,
666 tMin:=-
2, tMax:=
2, Color:=red, Width:=
8,
667 Cartesienne(x*Ent(
1/x)-
1,
5,
1),
668 Color:=blue,A:=(
1+i)/
4, Dparallelo(A,bar(A),-A),
669 dep:=RealCoord(i*Im(A)), RestoreWin(), SaveWin(),
671 view(
1,
10,-
5,
5), background(full,white),
672 ChangeWinTo(
[-A,A
]), Color:=black,
673 arr:=RealCoord(-Re(A)+i*Im(A)*
0.75),
674 Arrows:=
1, axes(
0,A), Arrows:=
0,
675 tMin:=-
0.25, tMax:=
0.25, Color:=red, Width:=
8,
676 Cartesienne(x*Ent(
1/x)-
1,
5,
1),
677 Color:=blue, Dparallelo(A,bar(A),-A),
680 Color:=blue, Arrows:=
1,
681 A:=ScrCoord(dep), B:=ScrCoord(arr),
682 Bezier(A,A+
3*exp(i*pi/
2),B-
3,B)
687 \subsection{invmatrix
}
689 \item \util \textbf[invmatrix()
]{invmatrix( <
[f(
0), Lf(
1), Lf(i)
]> )
}
690 \item \desc renvoie l'inverse de la matrice
\argu{[f(
0), Lf(
1), Lf(i)
]}, c'est à dire la matrice $
[f^
{-
1}(
0),
691 Lf^
{-
1}(
1), Lf^
{-
1}(i)
]$ si elle existe.
696 \item \util \textbf[matrix()
]{matrix( <fonction affine>,
[variable
] )
}
697 \item \desc renvoie la matrice de la
\argu{fonction affine
}, par défaut la
\argu{variable
} est $z$. Cette matrice se
698 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
699 précisément: Lf(
1)=f(
1)-f(
0) et Lf(i)=f(i)-f(
0).
700 \item \exem \co{matrix(i*bar(z))
} renvoie
\res{[0,i,
1]}.
704 \subsection{mulmatrix
}
706 \item \util \textbf[mulmatrix()
]{mulmatrix( <
[f(
0), Lf(
1), Lf(i)
]>, <
[g(
0), Lg(
1), Lg(i)
]> )
}
707 \item \desc renvoie la matrice de la composée: $fog$, où $f$ et $g$ sont les deux applications affines définies par les
708 matrices passées en argument.
711 \section{Constructions géométriques planes
}
713 Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets.
717 \item \util \textbf[bissec()
]{bissec( <B>, <A>, <C>, <
1 ou
2> )
}
718 \item \desc renvoie une liste de deux points de la bissectrice,
1=intérieure.
723 \item \util \textbf[cap()
]{cap( <ensemble1>, <ensemble2> )
}
724 \item \desc renvoie le contour de l'intersection de
\argu{ensemble1
} avec
\argu{ensemble2
} sous forme d'une liste de
725 points. Ces deux ensembles sont des lignes polygonales représentant des courbes fermées, orientées dans le meme
726 sens, ayant une forme relativement simple. La macro
\Helpref{set
}{macset
} permet de définir et dessiner des ensembles.
727 \item \exem intersection de deux ensembles:
731 \begin{demo
}{macro cap
}{cap
}
732 \begin{texgraph
}[name=cap, export=pgf
]
733 Marges(
0,
0,
0,
0),size(
7.5),
734 A:=set("A",
0,
[rotation:=
30]),
735 B:=set("B",
0,
[rotation:=-
30]),
736 C:= cap(A,B),Color:=red,FillStyle:=full,
737 FillOpacity:=
0.5, FillColor:=pink,
742 \subsection{capB
}\label{maccapB
}
744 \item \util \textbf[capB()
]{capB( <ensemble1>, <ensemble2> )
}
745 \item \desc renvoie le contour de l'intersection de
\argu{ensemble1
} avec
\argu{ensemble2
} sous forme d'une liste de
746 points de contrôles qui doit être dessinée avec la macro
\Helpref{drawSet
}{macdrawSet
}. Ces deux ensembles sont
747 doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
748 ayant une forme relativement simple. La macro
\Helpref{setB
}{macsetB
} permet de définir et dessiner des ensembles.
749 \item \exem intersection de deux ensembles:
753 \begin{demo
}{macro capB
}{capB
}
754 \begin{texgraph
}[name=capB, export=pgf
]
755 Marges(
0,
0,
0,
0),size(
7.5),
756 A:=setB("A",
0,
[rotation:=
30]),
757 B:=setB("B",
0,
[rotation:=-
30]),
758 C:= capB(A,B),Color:=red,FillStyle:=full,
759 drawSet(C,
[FillOpacity:=
0.5, FillColor:=pink
])
765 \item \util \textbf[carre()
]{carre( <A>, <B>, <
1 ou -
1> )
}
766 \item \desc renvoie la liste des sommets du carré de sommets consécutifs A et B,
1=sens direct.
771 \item \util \textbf[cup()
]{cup( <ensemble1>, <ensemble2> )
}
772 \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.
773 \item \exem réunion de deux ensembles:
776 \begin{demo
}{macro cup
}{cup
}
777 \begin{texgraph
}[name=cup, export=pgf
]
778 Marges(
0,
0,
0,
0),size(
7.5),
779 A:=set("A",
0,
[rotation:=
30]),
780 B:=set("B",
0,
[rotation:=-
30]),
781 C:= cup(A,B),Color:=red,FillStyle:=full,
782 FillOpacity:=
0.5, FillColor:=pink,
787 \subsection{cupB
}\label{maccupB
}
789 \item \util \textbf[cupB()
]{cupB( <ensemble1>, <ensemble2> )
}
790 \item \desc renvoie le contour de la réunion de
\argu{ensemble1
} avec
\argu{ensemble2
} sous forme d'une liste de
791 points de contrôles qui doit être dessinée avec la macro
\Helpref{drawSet
}{macdrawSet
}. Ces deux ensembles sont
792 doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
793 ayant une forme relativement simple. La macro
\Helpref{setB
}{macsetB
} permet de définir et dessiner des ensembles.
794 \item \exem intersection de deux ensembles:
797 \begin{demo
}{macro cupB
}{cupB
}
798 \begin{texgraph
}[name=cupB, export=pgf
]
799 Marges(
0,
0,
0,
0),size(
7.5),
800 A:=setB("A",
0,
[rotation:=
30]),
801 B:=setB("B",
0,
[rotation:=-
30]),
802 C:= cupB(A,B),Color:=red,FillStyle:=full,
803 drawSet(C,
[FillOpacity:=
0.5, FillColor:=pink
])
807 \subsection{cutBezier
}
809 \item \util \textbf[cutBezier()
]{cutBezier( <courbe de bézier>, <point>, <avant(
0/
1)> )
}
810 \item \desc renvoie un arc de bézier correspondant à la
\argu{courbe de bézier
} coupée avant ou après le
\argu{point
},
811 en fonction du paramètre
\argu{avant
}. Le résultat doit être dessiné par la commande
\Helpref{Bezier
}{cmdBezier
}.
817 \item \util \textbf[Cvx2d()
]{Cvx2d( <liste> )
}
818 \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.
819 \item \exem on choisit aléatoirement $
10$ points dans le pavé $
[-
4,
4]\times[-
4,
4]$ que l'on place dans une variable $P$
820 tout en dessinant chacun d'eux avec son numéro, puis on dessine l'enveloppe convexe.
823 \begin{demo
}{macro Cvx2d
}{Cvx2d
}
824 \begin{texgraph
}[name=Cvx2d, export=pgf
]
825 Marges(
0,
0,
0,
0),size(
7.5),
826 P:= for k from
1 to
10 do
827 z:=
8*Rand()-
4+i*(
8*Rand()-
4),
828 LabelDot(z, k,"N",
1), z
835 \subsection{Intersec
}
837 \item \util \textbf[Intersec()
]{Intersec( <objet1>, <objet2> )
}
838 \item \desc renvoie la liste des points d'intersection des deux objets graphiques. Ces deux objets peuvent être soit des
839 commandes graphiques (Cercle(), Droite(), ...) ou bien le nom d'un élément graphique déjà créé.
840 \item \exem la commande
\co{Intersec( Cercle(
0,
1), Droite(-
1,i/
2) )
} renvoie:
842 \centerline{\res{[0.59851109463416+
0.79925554731708*i, -
0.99794539275033+
0.00102730362483*i
]}.
}
848 \item \util \textbf[med()
]{med( <A>, <B> )
}
849 \item \desc renvoie une liste de deux points de la médiatrice de $
[A,B
]$.
852 \subsection{parallel
}
854 \item \util \textbf[parallel()
]{parallel( <
[A,B
]>, <C> )
}
855 \item \desc renvoie une liste de deux points de la parallèle à $(AB)$ passant par $C$.
859 \subsection{parallelo
}
861 \item \util \textbf[parallelo()
]{parallelo( <A>, <B>, <C> )
}
862 \item \desc renvoie la liste des sommets du parallèlogramme de sommets consécutifs $A$, $B$, $C$.
867 \item \util \textbf[perp()
]{perp( <
[A, B
]>, <C> )
}
868 \item \desc renvoie une liste de deux points de la perpendiculaire à $(AB)$ passant par $C$.
874 \item \util \textbf[polyreg()
]{polyreg( <A>, <B>, <nombre de cotés> )
}
875 \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é.
881 \item \util \Mytextbf{polyreg( <A>, <B>, <nombre de cotés + i*sens> )
} avec sens = +/-
1
882 \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).
885 \subsection{pqGoneReg
}
887 \item \util \textbf[pqGoneReg()
]{pqGoneReg( <centre>, <sommet>, <
[p,q
]> )
}
888 \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
}.
889 \item \exem voir
\Helpref{ici
}{macDpqGoneReg
}.
895 \item \util \textbf[rect()
]{rect( <A>, <B>, <C> )
}
896 \item \desc renvoie la liste des sommets du rectangle de sommets consécutifs $A$, $B$, le côté opposé passant par $C$.
899 \subsection{setminus
}
901 \item \util \textbf[setminus()
]{setminus( <ensemble1>, <ensemble2> )
}
902 \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.
903 \item \exem différence de deux ensembles:
906 \begin{demo
}{macro setminus
}{setminus
}
907 \begin{texgraph
}[name=setminus, export=pgf
]
908 Marges(
0,
0,
0,
0),size(
7.5),
909 A:=set("A",
0,
[rotation:=
30]),
910 B:=set("B",
0,
[rotation:=-
30]),
911 C:= setminus(A,B),Color:=red,FillStyle:=full,
912 FillOpacity:=
0.5, FillColor:=pink,
917 \subsection{setminusB
}\label{macsetminusB
}
919 \item \util \textbf[setminusB()
]{setminusB( <ensemble1>, <ensemble2> )
}
920 \item \desc renvoie le contour de la différence
\argu{ensemble1
} -
\argu{ensemble2
} sous forme d'une liste de
921 points de contrôles qui doit être dessinée avec la macro
\Helpref{drawSet
}{macdrawSet
}. Ces deux ensembles sont
922 doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens,
923 ayant une forme relativement simple. La macro
\Helpref{setB
}{macsetB
} permet de définir et dessiner des ensembles.
924 \item \exem différence de deux ensembles:
927 \begin{demo
}{macro setminusB
}{setminusB
}
928 \begin{texgraph
}[name=setminusB, export=pgf
]
929 Marges(
0,
0,
0,
0),size(
7.5),
930 A:=setB("A",
0,
[rotation:=
30]),
931 B:=setB("B",
0,
[rotation:=-
30]),
932 C:= setminusB(A,B),Color:=red,FillStyle:=full,
933 drawSet(C,
[FillOpacity:=
0.5, FillColor:=pink
])
937 \section{Gestion du flattened postscript
}
939 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.
941 \subsection{conv2FlatPs
}\label{macconv2FlatPs
}
944 \item \util \textbf[conv2FlatPs()
]{conv2FlatPs( <fichier entrée>, <fichier sortie>
[, dossier de travail
] )
}
945 \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.
948 \subsection{drawFlatPs
}\label{macdrawFlatPs
}
950 \item \util \textbf[drawFlatPs()
]{drawFlatPs( <affixe>, <chemins lus par loadFlatPs>
[, options
] )
}
951 \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:
953 \item \opt{scale
}{nombre positif
}: échelle,
1 par défaut.
954 \item \opt{position
}{center/left/right/...
}: position de l'affixe par rapport à l'image, center par défaut (fonctionne comme la variable LabelStyle).
955 \item \opt{color}{couleur
}: pour imposer une couleur,
\Nil par défaut ce qui signifie qu'on prend la couleur d'origine.
956 \item \opt{rotation
}{angle en degrés
}:
0 par défaut.
957 \item \opt{hollow
}{0/
1}: avec la valeur
0 (par défaut) les remplissages sont effectués.
958 \item \opt{select
}{liste des numéros de chemin à montrer
}:
\Nil par défaut, ce qui signifie tous les chemins.
963 \subsection{drawTeXlabel
}\label{macdrawTeXlabel
}
965 \item \util \textbf[drawTeXlabel()
]{drawTeXlabel( <affixe>, <variable contenant la formule TeX lue par loadFlatPs>,
[, options
] )
}
966 \item \desc cette macro invoque la macro
\Helpref{drawFlatPs
}{macdrawFlatPs
} pour dessiner une expression qui a été au
967 préalable compilée par
\TeX. Le paramètre
\argu{options
} est une liste (facultative) de la forme
\textsl{[ option1:=
968 valeur1, ..., optionN:=valeurN
]}, les options sont:
971 \item \opt{scale
}{nombre>
0}: échelle,
1 par défaut.
972 \item \opt{hollow
}{0/
1}: avec la valeur
0 (par défaut) les remplissages sont effectués.
974 Cette macro est utilisée en interne par la macro
\Helpref{NewTeXlabel
}{macNewTeXlabel
}.
978 \subsection{loadFlatPs
}\label{macloadFlatPs
}
980 \item \util \textbf[loadFlatPs()
]{loadFlatPs( <fichier en flattened postscript>,
[, options
] )
}
981 \item \desc cette macro charge un
\argu{fichier en flattened postscript
}, adpate les coordonnées des points et renvoie
982 la liste des chemins (que l'on peut alors dessiner avec la macro
\Helpref{{drawFlatPs
}}{macdrawFlatPs
}). Le paramètre
983 \argu{options
} est une liste (facultative) de la forme
\textsl{[ option1:= valeur1, ..., optionN:=valeurN
]}, les
986 \item \opt{width
}{nombre>
0}: largeur en cm,
\Nil par défaut pour largeur naturelle.
987 \item \opt{height
}{nombre>
0}: hauteur en cm,
\Nil par défaut pour hauteur naturelle.
989 \item supposons que vous ayez le fichier
\textit{circuit.pdf
} dans le dossier temporaire de TeXgraph, la commande
990 suivante dans un élément graphique Utilisateur:
994 [conv2FlatPs( "circuit.pdf", "circuit.fps", @TmpPath),
995 stock:= loadFlatPs(
[@TmpPath,"circuit.fps"
] ),
996 drawFlatPs(
0, stock,
[scale:=
1, hollow:=
1] )
1000 va permettre de charger et dessiner le contenu de ce fichier dans TeXgraph, sans faire les remplissages.
1003 \subsection{NewTeXlabel
}\label{macNewTeXlabel
}
1005 \item \util \textbf[NewTeXlabel()
]{NewTeXlabel( <nom>, <affixe>, <formule TeX>,
[, options
] )
}
1006 \item \desc cette macro va demander à
\TeX{} de compiler la formule dans un fichier pdf, ce fichier sera ensuite
1008 en un fichier eps par pstoedit, puis celui-ci sera chargé par loadFlatPs et stocké dans une variable globale appelée
1009 TeX
\_+nom. Un élément graphique appelé
\argu{nom
} est créée pour dessiner la formule avec drawTeXLabel. Le paramètre
1010 \argu{options
} est une liste (facultative) de la forme
\textsl{[ option1:= valeur1, ..., optionN:=valeurN
]}, les
1013 \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.
1014 \item \opt{scale
}{nombre>
0}: échelle,
1 par défaut.
1015 \item \opt{hollow
}{0/
1}: avec la valeur
0 (par défaut) les remplissages sont effectués.
1017 Dans les options, les attributs suivants peuvent également être utilisés:
\var{LabelStyle
},
\var{LabelAngle
} et
1020 Voici la définition de cette macro:
1024 [dollar:=
1, scale:=
1, hollow:=
0, $options:=
%4,
1025 $aux:=OpenFile(
[@TmpPath,"formula.tex"
]),
1026 if dollar then WriteFile(
["\
[",
%3,"\]"]) else WriteFile(%3) fi,
1028 Exec("pdflatex","-interaction=nonstopmode tex2FlatPs.tex",@TmpPath,
1),
1029 Exec("pstoedit -dt -pta -f ps -r2400x2400","tex2FlatPs.pdf tex2FlatPs.eps",@TmpPath,
1),
1030 NewVar(
["TeX_",
%1],loadFlatPs([@TmpPath,"tex2FlatPs.eps"])),
1031 NewGraph(
%1, ["drawTeXlabel(",%2,", TeX_",%1,", [scale:=",scale,", hollow:=",hollow,"])"]),
1037 La formule est écrite dans le fichier
\textit{formula.tex
}, puis on compile le fichier
\textit{tex2FlatPs.tex
} suivant:
1040 \documentclass[12pt
]{article
}
1041 \usepackage{amsmath,amssymb
}
1042 \usepackage{fourier
}
1046 \input{formula.tex
}%
1050 et on convertit le résultat en
\textit{flattened postscript
} avant de le charger.
1052 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:
1054 \centerline{\co{NewTeXlabel( "label1",
0, "
\bks frac\
{\bks pi\
}\
{\bks sqrt\
{2\
}\
}",
[scale:=
1.5, Color:=blue, LabelAngle:=
45])
}}
1060 \subsection{pdfprog
}
1062 \item \util \textbf[pdfprog()
]{pdfprog()
}.
1063 \item \desc cette macro est utilisée en interne pour mémoriser le programme utilisé pour faire la conversion
1064 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é.