Introduction de la doc en ligne de TeXgraph... pour tester :)
[geshi.git] / docs / texgraph / chap05.tex
1 \chapter{Liste des commandes}
2
3 Notations:
4
5 <argument>: signifie que l'argument est \Mytextbf{obligatoire}.
6
7 [argument]: signifie que l'argument est \Mytextbf{facultatif}.
8
9
10 \section{Args}\label{cmdArgs}
11
12 \begin{itemize}
13 \item \util \textbf[Args()]{Args( <entier> )}.
14
15 \item \desc cette fonction n'a d'effet que dans une macro, elle évalue et renvoie l'argument numéro \argu{entier} avec
16 lequel la macro a été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la commande
17 \Helpref{StrArgs}{cmdStrArgs}
18
19 \item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}.
20 \end{itemize}
21
22 \section{Assign}\label{cmdAssign}
23
24 \begin{itemize}
25 \item \util \textbf[Assign()]{Assign( <expression>, <variable>, <valeur> )}.
26
27 \item \desc cette fonction évalue \argu{valeur} et l'affecte à la variable nommée \argu{variable} dans
28 \argu{expression}\footnote{C'est la première occurrence de \argu{variable} dans \argu{expression} qui est assignée, car
29 toutes les occurrences pointent sur la même <case mémoire>, sauf éventuellement pour les macros après l'affectation des
30 paramètres.}. La fonction \textit{Assign} renvoie la valeur \Nil. Cette fonction est utile dans l'écriture de macros
31 prenant une expression comme paramètre et qui doivent l'évaluer.
32
33 \item \exem voici une macro \co{Bof} qui prend une fonction f(t) en paramètre et qui calcule la liste $[f(0), f(1),
34 ..., f(5)]$:
35 \end{itemize}
36
37 \centerline{\co{for \$k from 0 to 5 do Assign(\%1,t,k), \%1 od}}
38
39 \%1 représente le premier paramètre de la macro (c'est à dire f(t)), la boucle: pour k allant de 0 à 5 elle exécute la
40 commande [Assign(\%1, t, k), \%1], celle-ci assigne la valeur de k à la variable $t$ dans l'expression \%1, puis
41 évalue
42 \%1. L'exécution de \co{Bof(t\^{}2)} donne: \res{[0,1,4,9,16,25]}. L'exécution de \co{Bof(x\^{}2)} donne \Nil.
43
44 \section{Attributs}\label{cmdAttributs}
45
46 \begin{itemize}
47 \item \util \textbf[Attributs()]{Attributs()}.
48
49 \item \desc cette fonction ouvre la fenêtre permettant de modifier les attributs d'un élément graphique. Cette fonction
50 renvoie la valeur 1 si l'utilisateur a choisi \textit{OK}, elle renvoie la valeur 0 s'il a choisi \textit{Cancel}. Si
51 l'utilisateur a choisi \textit{OK}, alors les variables globales correspondant aux attributs sont modifiées en
52 conséquence.
53 \end{itemize}
54
55 \section{Border}\label{cmdBorder}
56
57 \begin{itemize}
58 \item \util \textbf[Border()]{Border( <0/1> )}
59
60 \item \desc cette fonction détermine si un cadre doit être dessiné ou non autour des marges du graphique dans les
61 exportations. Lorsque la valeur de l'argument est nulle (valeur par défaut), le cadre n'est pas dessiné.
62
63 Lorsque l'argument est vide, cette fonction renvoie l'état de la bordure à l'exportation (0 ou 1). Sinon, elle renvoie
64 la valeur \Nil.
65 \end{itemize}
66
67 \section{ChangeAttr}\label{cmdChangeAttr}
68
69 \begin{itemize}
70 \item \util \textbf[ChangeAttr()]{ChangeAttr( <element1>, ..., <elementN> )}
71 \item \desc cette fonction permet de modifier les attributs des éléments graphiques \argu{element1}, ...,
72 \argu{elementN}, en leur affectant la valeur des attributs en cours. Les arguments sont interprétés comme des chaînes de
73 caractères. Cette fonction renvoie la valeur \Nil.
74 \end{itemize}
75
76 \section{Clip2D}\label{cmdClip2D}
77
78 \begin{itemize}
79 \item \util \textbf[Clip2D()]{Clip2D( <ligne polygonale>, <contour convexe> [, close(0/1) ] )}.
80 \item \desc cette fonction clippe la \argu{ligne polygonale} qui doit être une variable contenant une liste de
81 complexes, avec le \argu{contour convexe}, qui est lui aussi une liste de complexes. La fonction calcule la ligne
82 polygonale qui en résulte modifie la variable \argu{ligne polygonale} en conséquence, le dernier
83 agument \argu{close} ($0$ par défaut) permet de préciser si la \argu{ligne polygonale} doit être refermée ou non. La
84 fonction renvoie \Nil.
85 \end{itemize}
86
87 \section{CloseFile}\label{cmdCloseFile}
88
89 \begin{itemize}
90 \item \util \textbf[CloseFile()]{CloseFile()}.
91 \item \desc cette fonction permet de fermer le fichier ouvert par la commande \Helpref{OpenFile}{cmdOpenFile}.
92 \end{itemize}
93
94
95 \section{ComposeMatrix}\label{cmdComposeMatrix}
96
97 \begin{itemize}
98 \item \util \textbf[ComposeMatrix()]{ComposeMatrix( <[z1, z2, z3]> )}
99 \item \desc cette fonction permet de composer la matrice courante (celle-ci affecte tous les éléments graphiques sauf
100 les axes et les grilles dans la version actuelle) avec la matrice \argu{[z1, z2, z3]}. Cette matrice représente
101 l'expression analytique d'une application affine du plan, c'est une liste de trois complexes: $z1$ qui est l'affixe du
102 vecteur de translation, $z2$ qui est l'affixe du premier vecteur colonne de la matrice de la partie linéaire dans la
103 base (1,i), et $z3$ qui est l'affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la
104 matrice de l'identité s'écrit ainsi: [0,1,i] (c'est la matrice par défaut). (Voir aussi les commandes
105 \Helpref{GetMatrix}{cmdGetMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix}).
106 \end{itemize}
107
108
109 \section{Copy}\label{cmdCopy}
110
111 \begin{itemize}
112 \item \util \textbf[Copy()]{Copy( <liste>, <index depart>, <nombre> )}.
113
114 \item \desc cette fonction renvoie la liste constituée par les \argu{nombre} éléments de la \argu{liste} à partir de
115 l'élément numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie tous les éléments de la
116 liste à partir de l'élément numéro \argu{départ}.
117
118 Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, le dernier
119 élément a l'index $-1$, l'avant-dernier a l'index $-2$ $\cdots$ etc. La fonction renvoie les \argu{nombre} éléments de
120 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
121 sens que la \argu{liste}, et cette dernière n'est pas modifiée.
122
123 \item \exem
124 \begin{itemize}
125 \item \co{Copy([1,2,3,4],2,2)} renvoie \res{[2,3]}.
126 \item \co{Copy([1,2,3,4],2,5)} renvoie \res{[2,3,4]}.
127 \item \co{Copy([1,2,3,4],2,0)} renvoie \res{[2,3,4]}.
128 \item \co{Copy([1,2,3,4],-1,2)} renvoie \res{[3,4]}.
129 \item \co{Copy([1,2,3,4],-2,2)} renvoie \res{[2,3]}.
130 \item \co{Copy([1,2,3,4],-2,0)} renvoie \res{[1,2,3]}.
131 \end{itemize}
132 \end{itemize}
133
134 \Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier
135 élément de la liste.
136
137 \section{DefaultAttr}\label{cmdDefaultAttr}
138
139 \begin{itemize}
140 \item \util \textbf[DefaultAttr()]{DefaultAttr()}
141
142 \item \desc cette fonction met toutes les variables correspondant aux attributs (\var{Color}, \var{Width}, ...) à leur
143 valeur par défaut. Cette fonction renvoie la valeur \Nil.
144 \end{itemize}
145
146
147 \section{Del}\label{cmdDel}
148
149 \begin{itemize}
150 \item \util \textbf[Del()]{Del( <liste>, <depart>, <nombre> )}.
151
152 \item \desc supprime de la \argu{liste} \argu{nombre} éléments à partir du numéro \argu{départ} [inclus]. Si
153 \argu{nombre} est nul, alors la fonction supprime tous les éléments de la liste à partir de l'élément numéro
154 \argu{départ}.
155
156
157 Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier. Le dernier
158 élément a l'index $-1$, l'avant-dernier a l'index $-2$ $\cdots$ etc. La fonction supprime les \argu{nombre} éléments de
159 la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche.
160
161 Le paramètre \argu{liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la fonction renvoie \Nil.
162
163 \item \exem la commande \co{[x:=[1,2,3,4], Del(x,2,2), x]} renvoie \res{[1,4]}.
164
165 La commande \co{[x:=[1,2,3,4], Del(x,-2,2), x]} renvoie \res{[1,4]}.
166
167 \end{itemize}
168
169 \Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier
170 élément de la liste.
171
172 \section{Delay}\label{cmdDelay}
173
174 \begin{itemize}
175 \item \util \textbf[Delay()]{Delay( <nb millisecondes> )}
176
177 \item \desc permet de suspendre l'exécution du programme pendant le laps de temps indiqué (en milli-secondes).
178 \end{itemize}
179
180 \section{DelButton}\label{cmdDelButton}
181
182 \begin{itemize}
183 \item \util \textbf[DelButton()]{DelButton( <texte1>, ..., <texteN> )}
184
185 \item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les boutons portant les
186 inscriptions \argu{texte1}, ..., \argu{texteN}. Si la liste est vide (\textsl{ DelButton()}), alors tous les boutons
187 sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
188 \end{itemize}
189
190 \section{DelGraph}\label{cmdDelGraph}
191
192 \begin{itemize}
193 \item \util \textbf[DelGraph()]{DelGraph( <element1>, ..., <elementN> )}
194
195 \item \desc Cette fonction permet de supprimer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN}. Si
196 la liste est vide (\textsl{ DelGraph()}), alors tous les éléments sont supprimés. Les arguments sont interprétés comme
197 des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
198 \end{itemize}
199
200 \section{DelItem}\label{cmdDelItem}
201
202 \begin{itemize}
203 \item \util \textbf[DelItem()]{DelItem( <nom1>, ..., <nomN> )}
204
205 \item \desc Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options
206 appelées
207 \argu{nom1}, ..., \argu{nomN}. Si la liste est vide (\textsl{ DelItem()}), alors toute la liste est supprimée. Les
208 arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
209 \end{itemize}
210
211 \section{DelMac}\label{cmdDelMac}
212
213 \begin{itemize}
214 \item \util \textbf[DelMac()]{DelMac( <mac1>, ..., <macN> )}
215
216 \item \desc Cette fonction permet de supprimer les macros (non prédéfinies) appelées \argu{mac1}, ..., \argu{macN}. Si
217 la liste est vide (\textsl{DelMac()}), la commande est sans effet. Les arguments sont interprétés comme
218 des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
219 \end{itemize}
220
221 \section{DelText}\label{cmdDelText}
222
223 \begin{itemize}
224 \item \util \textbf[DelText()]{DelText( <texte1>, ..., <texteN> )}
225
226 \item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les labels \argu{texte1},
227 ..., \argu{texteN}. Si la liste est vide (\textsl{ DelText()}), alors tous les labels sont supprimés. Les arguments sont
228 interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
229 \end{itemize}
230
231 \section{DelVar}\label{cmdDelVar}
232
233 \begin{itemize}
234 \item \util \textbf[DelVar()]{DelVar( <var1>, ..., <varN> )}
235
236 \item \desc Cette fonction permet de supprimer les variables globales (non prédéfinies) appelés \argu{var1}, ...,
237 \argu{varN}. Si la liste est vide (\textsl{DelVar()}), la commande est sans effet. Les arguments sont interprétés comme
238 des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
239 \end{itemize}
240
241
242 \section{Der}\label{cmdDer}
243
244 \begin{itemize}
245 \item \util \textbf[Der()]{Der( <expression>, <variable>, <liste> )}.
246
247 \item \desc cette fonction calcule la dérivée de \argu{expression} par rapport à \argu{variable} et l'évalue en donnant
248 à \argu{variable} les valeurs successives de la \argu{liste}. La fonction \textsl{Der} renvoie la liste des résultats.
249 Mais si on a besoin de \textsl{l'expression de la dérivée}, alors on préférera la fonction \Helpref{Diff}{cmdDiff}.
250
251 \item \exem
252 \begin{itemize}
253 \item la commande \co{Der(1/x,x,[-1,0,2] )} renvoie \res{[-1,-0.25]}.
254 \item Voici le texte d'une macro appelée \co{tangente} qui prend une expression $f(x)$ en premier paramètre, une valeur
255 réelle $x0$ en second paramètre et qui trace la tangente à la courbe au point d'abscisse x0:
256
257 \centerline{\co{[Assign(\%1,x,\%2), \$A:=\%2+i*\%1, \$Df:=Der(\%1,x,\%2), Droite(A, A+1+i*Df)]}}
258
259 On assigne la valeur $x0$ à la variable $x$ dans l'expression $f(x)$, on stocke dans une variable $A$ le point de
260 coordonnées $(x0,f(x0))$ (sous forme d'affixe), on stocke dans une variable $Df$ la dérivée en $x0$ ($f'(x0)$), puis on
261 trace la droite passant par $A$ et dirigée par le vecteur d'affixe $1+if'(x0)$.
262 \end{itemize}
263 \end{itemize}
264
265 \section{Diff}\label{cmdDiff}
266
267 \begin{itemize}
268 \item \util \textbf[Diff()]{Diff( <nom>, <expression>, <variable> [, param1,..., paramN] )}
269
270 \item \desc cette fonction permet de créer une macro appelée \argu{nom}, s'il existait déjà une macro portant ce nom,
271 elle sera écrasée, sauf si c'est une macro prédéfinie auquel cas la commande est sans effet. Le corps de la macro créée
272 correspond à la dérivée de \argu{expression} par rapport à \argu{variable}. Les paramètres optionnels sont des noms de
273 variables, le nom de la variable \argu{param1} est remplacé dans l'expression de la dérivée par le paramètre \%1, le nom
274 \argu{param2} est remplacé par \%2 ... etc. Cette fonction renvoie \Nil.
275
276 \item \exem après l'exécution de la commande (dans la ligne de commande en bas de la fenêtre):
277 \co{Diff(df, sin(3*t), t)}, une macro appelée \res{df} est créée et son contenu est: \res{3*cos(3*t)}, c'est une macro
278 sans paramètre qui contient une variable locale $t$, elle devra donc être utilisée en développement immédiat (c'est à
279 dire
280 précédée du symbole $\backslash$)\footnote{Si par exemple on veut tracer la courbe représentative de cette fonction,
281 dans l'option \textit{Courbe/Paramétrée}, il faudra saisir la commande \textit{t+i*$\backslash$df} et non pas
282 \textit{t+i*df(t)}.}. Par contre après la commande \co{Diff(df,sin(3*t),t,t)}, le contenu de la macro \res{df} est:
283 \res{3*cos(3*\%1)} qui est une macro à un paramètre.
284 \end{itemize}
285
286 \section{Echange}\label{cmdEchange}
287
288 \begin{itemize}
289 \item \util \textbf[Echange()]{Echange( <variable1>, <variable2> )}.
290
291 \item \desc cette fonction échange les deux variables, ce sont en fait les adresses qui sont échangées. Les contenus ne
292 sont pas dupliqués alors qu'ils le seraient si on utilisait la commande:
293
294 {\centering \co{[aux:=variable1, variable1:=variable2, variable2:=aux]}\par}
295
296 La fonction \textsl{Echange} renvoie la valeur \Nil.
297 \end{itemize}
298
299 \section{EpsCoord}\label{cmdEpsCoord}
300
301 \begin{itemize}
302 \item \util \textbf[EpsCoord()]{EpsCoord( <affixe> )}
303
304 \item \desc renvoie l'affixe exportée en eps. Pour les autres, il y a les macros \Helpref{TeXCoord}{macTeXCoord} et
305 \Helpref{SvgCoord}{macSvgCoord}.
306 \end{itemize}
307
308 \section{Eval}\label{cmdEval}
309
310 \begin{itemize}
311 \item \util \textbf[Eval()]{Eval( <expression> )}.
312
313 \item \desc cette fonction évalue l'\argu{expression} et renvoie le résultat. L'\argu{expression} est interprétée comme
314 une \Helpref{chaîne de caractères}{chaine}.
315
316 \item La fonction \Helpref{{Input}}{cmdInput} renvoie la saisie sous forme d'une chaîne dans la macro appelée
317 \textit{chaine()}. La fonction \textsl{Eval} évalue cette chaîne (comme n'importe quelle commande TeXgraph) et renvoie
318 le résultat.
319
320 \item \exem voici une commande demandant une valeur à l'utilisateur pour une variable \textit{x}:
321 \end{itemize}
322
323 \begin{verbatim}
324 if Input("x=", "Entrez une valeur pour x", x )
325 then x:= Eval( chaine() )
326 fi
327 \end{verbatim}
328
329
330 \section{Exec}\label{cmdExec}
331
332 \begin{itemize}
333 \item \util \textbf[Exec()]{Exec( <programme> [, argument(s), répertoire de travail, attendre] )}.
334
335 \item \desc cette fonction permet d'exécuter un \argu{programme} (ou un script) en précisant éventuellement des
336 \argu{arguments} et un \argu{répertoire de travail}, ces trois arguments sont interprétés comme des chaînes de
337 caractères. Le dernier argument doit valoir 0 (par défaut) ou 1, il indique si le programme attend ou non la fin du
338 processus fils. La fonction renvoie la valeur \Nil. Un message d'erreur s'affiche lorsque: les ressources sont
339 insuffisantes, ou bien le programme est invalide, ou bien le chemin est invalide.
340
341 \item La macro-chaîne prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu}
342 exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute
343 \textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de
344 pdf.
345
346 \item \exem la macro \textsl{Apercu} contenue dans interface.mac est:
347 \end{itemize}
348
349 \begin{verbatim}
350 [Export(pgf,[@TmpPath,"file.pgf"] ),
351 Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
352 Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
353 ]
354 \end{verbatim}
355
356 \section{Export}\label{cmdExport}
357
358 \begin{itemize}
359 \item \util \textbf[Export()]{Export( <mode>, <fichier> )}.
360
361 \item \desc cette fonction permet d'exporter le graphique en cours, \argu{mode} est une valeur numérique qui peut être
362 l'une
363 des constantes suivantes: tex, pst, pgf, tkz, eps, psf, pdf, epsc, pdfc, svg, bmp, obj, geom, jvx ou teg. L'exportation
364 se fait dans \argu{fichier} qui contient donc le nom du fichier, avec éventuellement le chemin.
365
366 La macro prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu}
367 exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute
368 \textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de
369 pdf.
370
371 \item \exem la macro \textsl{Apercu} contenue dans interface.mac est:
372 \end{itemize}
373
374 \begin{verbatim}
375 [Export(pgf,[@TmpPath,"file.pgf"] ),
376 Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
377 Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
378 ]
379 \end{verbatim}
380
381 \section{ExportObject}\label{cmdExportObject}
382
383 \begin{itemize}
384 \item \textbf[ExportObject()]{ExportObject( <argument> )}
385 \item \desc cette commande n'a d'effet que pendant un export. Elle permet d'exporter l'\argu{argument} dans le fichier
386 de sortie, cet \argu{argumet} est soit le nom d'un élément graphique, soit une commande graphique (comme pour la
387 fonction \Helpref{Get}{cmdGet}). Elle peut-être utile pour écrire des exports personnalisés, ceci est décrit dans
388 \Helpref{cette section}{cmdMyExport}.
389 \end{itemize}
390
391 \section{Fenetre}\label{cmdFenetre}
392
393 \begin{itemize}
394 \item \util \textbf[Fenetre()]{Fenetre( <A>, <B> [, C] )}.
395 \item \desc cette fonction modifie la fenêtre graphique, c'est l'équivalent de l'option \textit{Paramètres/Fenêtre},
396 \Mytextbf{sauf que les éléments graphiques ne sont pas automatiquement recalculés}. Le paramètre \argu{A} et le
397 paramètre \argu{B} sont les affixes de deux coins de la fenêtre diamétralement opposés, et le paramètre facultatif
398 \argu{C} représente les deux échelles, plus précisément, la partie réelle de \argu{C} est l'échelle [en cm] sur l'axe
399 des abscisses et la partie imaginaire de \argu{C} est l'échelle [en cm] sur l'axe des ordonnées, ces deux valeurs
400 doivent être strictement positives. Cette fonction renvoie la valeur \Nil.
401 \end{itemize}
402
403 \section{Free}\label{cmdFree}
404
405 \begin{itemize}
406 \item \util \textbf[Free()]{Free( <expression>, <variable>}.
407 \item \desc cette fonction renvoie $1$ si l'\argu{expression} contient la \argu{variable}, $0$ sinon. Lorsque le
408 deuxième argument n'est pas un nom de variable, la fonction renvoie \Nil.
409 \end{itemize}
410
411 \section{Get}\label{cmdGet}
412
413 \begin{itemize}
414 \item \util \textbf[Get()]{Get( <argument> [, clip(0/1)] )}.
415 \item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un
416 élément graphique dont le nom est \argu{argument}, si c'est le cas, alors la fonction renvoie la liste des points de cet
417 élément graphique, sinon elle renvoie la valeur \Nil. Dans ce cas l'argument optionnel est ignoré.
418
419 Lorsque \argu{argument} n'est pas un identificateur, celui-ci est considéré comme une \textit{fonction graphique}, la
420 fonction \textsl{Get} renvoie la liste des points de l'élément graphique construit par cette fonction graphique mais
421 sans créer l'élément en question. L'argument optionnel \argu{clip} (qui vaut $1$ par défaut) indique si l'élément doit
422 être clippé par la fenêtre courante (valeur 1) ou non (valeur 0).
423
424 Lorsque l'argument est vide: \textsl{Get()}, la fonction renvoie la liste des points de tous les éléments graphiques
425 déjà construits, ceux qui sont cachés sont ignorés.
426
427 \item \exem \co{Get(Cercle(0,1))} renvoie la liste des points du cercle de centre 0 et de rayon 1 mais sans créer ce
428 cercle, la liste des points est clippée par la fenêtre graphique.
429
430 \item \exem utilisation des points d'un objet graphique:
431 \end{itemize}
432
433 \begin{demo}{Get}{Get}
434 \begin{texgraph}[name=Get,export=pgf,file]
435 Cmd view(0,6.25,-1.5,2);
436 size(7.5);
437 [tMin:=0, tMax:=6.25];
438 Graph axe = Axes(0,1+i);
439 C1 = [Color:=blue,Width:=8,
440 Cartesienne(1/x) ];
441 C2 = [Color:=red,Width:=8,
442 Cartesienne(sin(2*x)*1.5)];
443 inter = [DotScale:=2,DotStyle:=dotcircle,
444 Color:=forestgreen,
445 Point(Get(C1) InterL Get(C2)),
446 Color:=blue,
447 LabelDot(5.5+0.1*i,"$C_1$","N"),
448 Color:=red,
449 LabelDot(3-i,"$C_2$","E"),
450 ];
451 \end{texgraph}
452 \end{demo}
453
454
455 \section{GetAttr}\label{cmdGetAttr}
456
457 \begin{itemize}
458 \item \util \textbf[GetAttr()]{GetAttr( <argument> )}
459
460 \item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un
461 élément graphique dont le nom est \argu{argument}, si c'est le cas, alors les attributs de cet élément graphique
462 deviennent les attributs courants, et la fonction renvoie la valeur \Nil. Sinon, l'argument est interprété comme une
463 chaîne de caractères puis la fonction
464 effectue la même recherche.
465 \end{itemize}
466
467 \section{GetMatrix}\label{cmdGetMatrix}
468
469 \begin{itemize}
470 \item \util \textbf[GetMatrix()]{GetMatrix()}
471
472 \item \desc cette fonction renvoie la matrice courante. (Voir aussi les commandes
473 \Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix})
474 \end{itemize}
475
476 \section{GetSpline}\label{cmdGetSpline}
477
478 \begin{itemize}
479 \item \util \textbf[GetSpline()]{GetSpline(<V0>, <A0>,..., <An>, <Vn> )}
480 \item \desc renvoie la liste des points de contrôle correspondant à la spline cubique passant par les points
481 \argu{A0} jusqu'à \argu{An}. \argu{V0} et \argu{Vn} désignent les vecteurs vitesses aux extrémités [contraintes], si
482 l'un d'eux est nul alors l'extrémité correspondante est considérée comme libre (sans contrainte). Le résultat doit être
483 dessiné avec la commande graphique \Helpref{Bezier}{cmdBezier}.
484 \end{itemize}
485
486
487 \section{GrayScale}\label{cmdGrayScale}
488
489 \begin{itemize}
490 \item \util \textbf[GrayScale()]{GrayScale(0/1)} ou \textbf[GrayScale()]{GrayScale()}.
491
492 \item \desc cette fonction permet d'activer ou désactiver la conversion des couleurs en niveaux de gris. Elle équivaut à
493 l'option \textsl{Paramètres/Gérer les couleurs} du menu de l'interface graphique.
494
495 Lorsque l'argument est vide, la fonction renvoie l'état actuel de la conversion en niveaux de gris (0 ou 1). Sinon, elle
496 renvoie \Nil.
497 \end{itemize}
498
499 \section{HexaColor}\label{cmdHexaColor}
500
501 \begin{itemize}
502 \item \util \textbf[HexaColor()]{HexaColor( <valeur héxadécimale> )}
503
504 \item \desc cette fonction renvoie la couleur correspondant à la \argu{valeur héxadécimale}, cette valeur doit être
505 passée sous forme d'une chaîne de caractères. Voir aussi la commande \Helpref{Rgb}{cmdRgb}.
506
507 \item \exem \verb Color:=HexaColor("F5F5DC") .
508 \end{itemize}
509
510 \section{Hide}\label{cmdHide}
511
512 \begin{itemize}
513 \item \util \textbf[Hide()]{Hide( <element1>, ..., <elementN> )}
514
515 \item \desc Cette fonction permet de cacher les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en
516 mettant leur attribut \textsl{IsVisible} à false. Les arguments sont interprétés comme des chaînes de caractères. Cette
517 fonction renvoie la valeur \Nil.
518
519 Pour tout cacher on invoque la commande sans arguments: \textsl{Hide()}.
520
521 Pour tout cacher sauf un ou plusieurs éléments, on invoque la commande: \textsl{Hide(except, element1, ..., elementN)}.
522 Voir aussi la commande \Helpref{Show}{cmdShow}.
523 \end{itemize}
524
525 \section{IdMatrix}\label{cmdIdMatrix}
526
527 \begin{itemize}
528 \item \util \textbf[IdMatrix()]{IdMatrix()}
529 \item \desc change la matrice courante en la matrice identité. (Voir aussi les commandes
530 \Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{GetMatrix}{cmdGetMatrix})
531 \end{itemize}
532
533
534
535 \section{Input}\label{cmdInput}
536
537 \begin{itemize}
538 \item \util \textbf[Input()]{Input( <message> [, titre, chaîne] )}.
539 \item \desc cette fonction ouvre une boite de dialogue avec \argu{titre} dans la barre de titre (par défaut le titre
540 est vide), et dans laquelle le paramètre \argu{message} est affiché, le paramètre \argu{chaîne} est affiché dans la zone
541 de saisie. Ces paramètres sont donc interprétés comme des \Helpref{chaînes de caractères}{chaine}, l'utilisateur est
542 invité à faire une saisie. S'il valide alors la fonction \textsl{Input} renvoie la valeur $1$ et la chaîne saisie est
543 \Mytextbf{mémorisée dans la macro} \textsl{chaine()}. Si l'utilisateur ne valide pas ou si la chaîne saisie est vide,
544 alors la fonction \textsl{Input} renvoie la valeur $0$.
545 \item \exem voir la fonction \Helpref{Eval}{cmdEval}.
546 \end{itemize}
547
548 \section{InputMac}\label{cmdInputMac}
549
550 \begin{itemize}
551 \item \util \textbf[InputMac()]{InputMac( <nom de fichier> )} ou \textbf[Load()]{Load( <nom de fichier> )}.
552 \item \desc cette fonction permet de charger en mémoire un fichier de macros (\textit{*.mac}), ou un fichier modèle
553 (\textit{*.mod}), ou tout fichier source texgraph (\textit{*.teg}).
554
555 Dans le premier cas (fichier \textit{*.mac}), les variables globales et les macros seront considérées comme
556 \Mytextbf{prédéfinies} (elles n'apparaissent pas à l'écran, elles ne seront pas
557 enregistrées avec le graphique, mais elles sont effacées de la mémoire dès qu'on commence un nouveau graphique). Le
558 paramètre \argu{nom de fichier} est une chaîne de caractères représentant le fichier à charger avec éventuellement son
559 chemin. Cette fonction renvoie \Nil, et si ce fichier était déjà chargé, alors elle est sans effet. Si le fichier à
560 charger est dans le répertoire \textit{macros} de \textit{TeXgraph}, ou dans le dossier \textit{TeXgraphMac}, alors il
561 est inutile de préciser le chemin.
562 \item \exem \co{InputMac("MesMacros.mac")}.
563 \end{itemize}
564
565 \section{Inc}\label{cmdInc}
566
567 \begin{itemize}
568 \item \util \textbf[Inc()]{Inc( <variable>, <expression> )}.
569 \item \desc cette fonction évalue \argu{expression} et ajoute le résultat à \argu{variable}. Cette fonction est plus
570 avantageuse que la commande \co{variable := variable + expression}, car dans cette commande la \argu{variable} est
571 évaluée [c'est à dire dupliquée] pour calculer la somme. La fonction \textsl{Inc} renvoie la valeur \Nil.
572 \end{itemize}
573
574
575 \section{Insert}\label{cmdInsert}
576
577 \begin{itemize}
578 \item \util \textbf[Insert()]{Insert( <liste1>, <liste2> [, position] )}.
579 \item \desc cette fonction insère la \argu{liste2} dans la \argu{liste1} à la position numéro \argu{position}. Lorsque
580 la position vaut 0 [valeur par défaut]. La \argu{liste2} est ajoutée à la fin. La \argu{liste1} doit être une variable
581 et celle-ci est modifiée. La fonction \textsl{Insert} renvoie la valeur \Nil.
582 \item \exem si une variable $L$ contient la liste \co{[1,4,5]}, alors après la commande \co{Insert(L,[2,3],2)}, la
583 variable $L$ contiendra la liste \res{[1,2,3,4,5]}.
584 \end{itemize}
585
586 \section{Int}\label{cmdInt}
587
588 \begin{itemize}
589 \item \util \textbf[Int()]{Int( <expression>, <variable>, <borne inf.>, <borne sup.> )}.
590 \item \desc cette fonction calcule l'intégrale de \argu{expression} par rapport à \argu{variable} sur l'intervalle
591 \Mytextbf{réel} défini par \argu{borne inf.} et \argu{borne sup}. Le calcul est fait à partir de la méthode de
592 \textsc{Simpson} accélérée deux fois avec la méthode de \textsc{Romberg}, \argu{expression} est supposée définie et
593 suffisamment régulière sur l'intervalle d'intégration.
594 \item \exem \co{Int(exp(sin(u)),u,0,1)} donne \res{1.63187} (Maple donne 1.631869608).
595 \end{itemize}
596
597 \section{IsMac}\label{cmdIsMac}
598
599 \begin{itemize}
600 \item \util \textbf[IsMac()]{IsMac( <nom> )}.
601 \item \desc cette fonction permet de savoir s'il y a une macro appellée \argu{nom}. Elle renvoie $1$ si c'est
602 le cas, $0$ sinon.
603 \end{itemize}
604
605 \section{IsVar}\label{cmdIsVar}
606
607 \begin{itemize}
608 \item \util \textbf[IsVar()]{IsVar( <nom> )}.
609 \item \desc cette fonction permet de savoir s'il y a une variable globale appellée \argu{nom}. Elle renvoie $1$ si c'est
610 le cas, $0$ sinon.
611 \end{itemize}
612
613 \section{Liste}\label{cmdListe}
614
615 \begin{itemize}
616 \item \util \textbf[Liste()]{Liste( <argument1>, ..., <argumentn> )} ou bien \Mytextbf{[<argument1>, ...,
617 <argumentn>]}.
618 \item \desc cette fonction évalue chaque argument et renvoie la liste des résultats \Mytextbf{différents de \Nil}.
619 \item \exem \co{Liste(1, Arg(1+2*i), sqrt(-1), Solve(cos(x)-x,x,0,1))} renvoie le résultat
620 \res{[1,1.107149,0.739085]}.
621 \end{itemize}
622
623 \section{ListFiles}\label{cmdListFiles}
624
625 \begin{itemize}
626 \item \util \textbf[ListFiles()]{ListFiles()}.
627 \item \desc cette fonction est disponible seulement dans la version GUI de TeXgraph, elle s'utilise dans la barre de
628 commande en bas de la fenêtre, elle affiche alors la liste des fichiers de macros (\textit{*.mac}) chargés en mémoire.
629 \end{itemize}
630
631 \section{LoadImage}\label{cmdLoadImage}
632
633 \begin{itemize}
634 \item \util \textbf[LoadImage()]{LoadImage( <image> )}.
635 \item \desc cette fonction charge le fichier \argu{image}, qui doit être une image png, jpeg ou bmp. Celle-ci est
636 affichée en image de fond et fait partie du graphique, en particulier elle est exportée dans les formats tex (visible
637 seulement dans la version postscript), pgf, pst et teg. Pour le format pgf c'est la version png ou jpg qui sera dans le
638 document, mais pour les versions pst et tex il faut une version eps de l'image. L'argument est interprêté comme une
639 chaîne de caractères, et la fonction renvoie la valeur \Nil.
640
641 Lors du chargement, la taille de l'image est adaptée à la fenêtre, mais celle-ci peut être modifiée de manière à
642 conserver les proportions de l'image. Dès lors la position de l'image et sa taille sont fixées. On peut ensuite élargir
643 la fenêtre si on ne veut pas que l'image occupe tout l'espace. Pour modifier la position ou la taille de l'image, il
644 faut recharger celle-ci.
645 \end{itemize}
646
647
648 \section{Loop}\label{cmdLoop}
649
650 \begin{itemize}
651 \item \util \textbf[Loop()]{Loop( <expression>, <condition> )}.
652 \item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste en évaluant \argu{expression} et
653 \argu{condition} jusqu'à ce que le résultat de \argu{condition} soit égal à 1 (pour \textit{True}) ou \Nil, la fonction
654 \textsl{Loop} renvoie alors la liste des résultats de \argu{expression}. Cette commande est la représentation interne de
655 la boucle \Helpref{{repeat}}{cmdrepeat} dont l'utilisation est préférable pour des raisons de lisibilité.
656 \item \exem les commandes (équivalentes):
657
658 \centerline{\co{[n:=1, m:=1, n, Loop([ aux:=n, n:=m, m:=aux+n, n], m>100)]}}
659
660 ou encore
661
662 \centerline{\co{[n:=1, m:=1, n, while m<=100 do aux:=n, n:=m, m:=aux+n, n od]}}
663
664 ou encore
665
666 \centerline{\co{[n:=1, m:=1, n, repeat aux:=n, n:=m, m:=aux+n, n until m>100 od]}}
667
668 renvoient la liste: \res{[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]} (termes d'une suite de \textsc{Fibonacci} inférieurs à
669 100).
670 \end{itemize}
671
672 \section{Map}\label{cmdMap}
673
674 \begin{itemize}
675 \item \util \textbf[Map()]{Map( <expression>, <variable>, <liste> [, mode] )}.
676 \item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable}
677 parcourt les éléments de \argu{liste} et pour chacun d'eux \argu{expression} est évaluée, la fonction \textsl{Map}
678 renvoie la liste des résultats. Cette commande est la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont
679 l'utilisation est préférable pour des raisons de lisibilité.
680
681 Le paramètre optionnel \argu{mode} est un complexe qui vaut \Nil par défaut, lorsque \argu{mode}$=a+ib$, alors:
682 \begin{itemize}
683 \item si $a$ est un entier et $b=0$: les éléments de la \argu{liste} sont traités de $a$ en $a$,
684 \item si $a$ est un entier et $b=1$: la \argu{liste} est traitée par composante (deux composantes sont séparées
685 par la constante \jump) et les éléments de chaque composante sont traités par paquets complets de $a$ éléments, lorsque
686 la constante \jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat. Un paquet non complet n'est pas
687 traité.
688 \item si $a$ est un entier et $b=-1$: la \argu{liste} est traitée par composante (deux composantes sont séparées
689 par la constante \jump) et les éléments de chaque composante sont traités par paquets complets de $a$ éléments, lorsque
690 la constante \jump est rencontrée dans la liste, celle-ci n'est pas renvoyée dans le résultat. Un paquet non complet
691 n'est pas traité.
692 \item si $a=$Re(jump): la \argu{liste} est traitée par composante (deux composantes sont séparées par la
693 constante \jump), lorsque la constante \jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat si
694 $b=1$ et n'est pas renvoyée si $b=-1$.
695
696 \item \exem voir la boucle \Helpref{for}{cmdfor} pour des exemples.
697 \end{itemize}
698
699
700 \item \exem si $L$ est une variable contenant une liste de points, alors la commande:
701 \begin{itemize}
702 \item \co{[sum:=0, Map( Inc(sum,z), z, L), sum]} renvoie la somme des éléments de $L$.
703 \item la commande \co{Map(z*exp(i*$\pi$/3), z, L)} renvoie la liste des images des points de $L$ par la rotation
704 de centre O d'angle $\pi$/3.
705 \end{itemize}
706 \end{itemize}
707
708 \section{Marges}\label{cmdMarges}
709
710 \begin{itemize}
711 \item \util \textbf[Marges()]{Marges( <gauche>, <droite>, <haut>, <bas> )}
712 \item \desc cette fonction permet de fixer les marges autour du dessin (en cm). Les nouvelles valeurs sont copiées dans
713 les constantes \var{margeG}, \var{margeD}, \var{margeH} et \var{margeB}.
714 \end{itemize}
715
716
717 \section{Merge}\label{cmdMerge}
718
719 \begin{itemize}
720 \item \util \textbf[Merge()]{Merge( <liste> )}.
721 \item \desc cette fonction permet de recoller des morceaux de listes pour avoir des composantes de longeur maximale,
722 elle renvoie la liste qui en résulte.
723 \item \exem \co{Merge([1, 2, jump, 3, 5, jump, 3, 4, 2] )} renvoie \res{[1, 2, 3, 4, 5]}. Et \co{Merge( [1, 2, jump, 3,
724 5, jump, 3, 4] )} renvoie \res{[1, 2, jump, 4, 3, 5]}.
725
726 Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine.
727 \end{itemize}
728
729
730 \section{Message}\label{cmdMessage}
731
732 \begin{itemize}
733 \item \util \textbf[Message()]{Message( <chaîne> )}.
734 \item \desc cette fonction affiche le paramètre \argu{chaîne} [qui est donc interprété comme une \Helpref{chaîne de
735 caractères}{chaine}] dans une fenêtre. Quand l'utilisateur a cliqué sur \textit{OK}, la fenêtre se referme et la
736 fonction renvoie la valeur \Nil.
737 \end{itemize}
738
739 \section{Move}\label{cmdMove}
740
741 \begin{itemize}
742 \item \util \textbf[Move()]{Move( <element1>, ..., <elementN> )}.
743 \item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode NotXor, ce qui correspond à la valeur
744 1 de la variable \Helpref{PenMode}{cmdPenMode}. Elle redessine les éléments graphiques \argu{element1}, ...,
745 \argu{elementN}, puis les recalcule, puis les redessine, et elle renvoie la valeur \Nil.
746
747 Lorsqu'on redessine un élément graphique créé en mode NotXor, il s'efface en restituant le fond, on peut alors modifier
748 sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres
749 (ce qui évite d'avoir une image qui saute).
750 \item\exem voir la fonction \Helpref{Stroke}{cmdStroke}.
751 \end{itemize}
752
753 \section{Mtransform}\label{cmdMtransform}
754
755 \begin{itemize}
756 \item \util \textbf[Mtransform()]{Mtransform( <liste>, <matrice> )}.
757 \item \desc cette fonction applique la \argu{matrice} à la \argu{liste} et renvoie le résultat. Si la \argu{liste}
758 contient la constante \jump, celle-ci est renvoyée dans le résultat sans être modifiée. La \argu{matrice} représente
759 l'expression analytique d'une application affine du plan, c'est une liste de trois complexes $[z1,z2,z3]$: $z1$ est
760 l'affixe du vecteur de translation, $z2$ est l'affixe du premier vecteur colonne de la matrice de la partie linéaire
761 dans la base (1,i), et $z3$ est l'affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par
762 exemple, la matrice de l'identité s'écrit ainsi: [0,1,i] (c'est la matrice par défaut).
763 \end{itemize}
764
765 \section{MyExport}
766
767 \begin{itemize}
768 \item \textbf[MyExport()]{MyExport( <"nom">, <paramètre 1>, ..., <paramètre n> )} ou \textbf[draw()]{draw(
769 <"nom">, <paramètre 1>, ..., <paramètre n> )}
770 \item \desc cette commande permet d'ajouter de nouveaux éléments graphiques avec un export personnalisé. Elle est
771 décrite dans \Helpref{cette section}{cmdMyExport}.
772 \end{itemize}
773
774 \section{Nargs}\label{cmdNargs}
775
776 \begin{itemize}
777 \item \util \textbf[Nargs()]{Nargs()}.
778 \item \desc cette fonction n'a d'effet que dans une macro, elle renvoie le nombre d'arguments avec lesquels la macro a
779 été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir aussi la fonction \Helpref{Args}{cmdArgs}.
780 \item\exem voici le corps d'une macro \textit{MyLabel(affixe1, texte1, affixe2, texte2, ...)} prenant un nombre
781 indéterminé d'arguments:
782 \end{itemize}
783
784 \begin{verbatim}
785 for $k from 1 to Nargs()/2 do
786 Label(Args(2*k-1), Args(2*k))
787 od
788 \end{verbatim}
789
790 \section{NewButton}\label{cmdNewButton}
791
792 \begin{itemize}
793 \item \util \textbf[NewButton()]{NewButton( <Id>, <nom>, <affixe>, <taille>, <commande> [, aide] )}.
794 \item \desc cette fonction crée dans la zone grisée à gauche dans la fenêtre un bouton dont le numéro d'identification
795 est \Mytextbf{l'entier} \argu{Id}, le texte figurant sur le bouton est le paramètre \argu{nom} qui est donc interprété
796 comme une \Helpref{chaîne de caractères}{chaine}, la position du coin supérieur gauche est donnée par le paramètre
797 \argu{affixe} qui doit être de la forme X+i*Y avec X et Y \Mytextbf{entiers} car ce sont des coordonnées en
798 \Mytextbf{pixels}, la taille du bouton est donnée par le paramètre \argu{taille} qui doit être de la forme
799 \textit{long+i*haut}\textit{long} désigne la longueur du bouton en pixels et \textit{haut} la hauteur (ce sont donc
800 des entiers), le paramètre \argu{commande} est interprété comme une chaîne de caractères, c'est la commande associée au
801 bouton, chaque clic provoquera l'exécution de cette commande. Le dernier paramètre \argu{aide} est facultatif, il
802 contient le message de la bulle d'aide s'affichant lorsque la souris passe au-dessus du bouton.
803
804 Si on crée un bouton dont le numéro d'identification est déjà pris, alors l'ancien bouton est détruit \Mytextbf{sauf si
805 c'est un bouton prédéfini} (c'est à dire créé au démarrage). \`A chaque changement de fichier, les boutons non
806 prédéfinis sont détruits. La fonction \Mytextbf{NewButton} renvoie la valeur \Nil.
807 \end{itemize}
808
809 \section{NewGraph}\label{cmdNewGraph}
810
811 \begin{itemize}
812 \item \util \textbf[NewGraph()]{NewGraph( <chaîne1>, <chaîne2> [, code] )}.
813
814 \item \desc cette fonction crée un élément graphique \textsl{Utilisateur} ayant pour nom: \argu{chaîne1} et défini par
815 la commande: \argu{chaîne2}. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction
816 renvoie la valeur \Nil. S'il existait déjà un élément graphique portant le même nom, alors celui-ci est écrasé.
817 L'élément graphique est créé mais non dessiné, c'est la fonction \textsl{ReDraw()} qui permet de mettre l'affichage à
818 jour.
819
820 Le troisième paramètre \argu{code} est un entier positif (optionnel), un clic gauche avec la souris sur l'élément
821 graphique créé dans la liste des éléments graphiques, provoquera l'exécution de la macro spéciale \textsl{ClicGraph(
822 <code> )}, cette macro n'existe pas par défaut et peut-être créée par l'utilisateur, elle est utilisée en particulier
823 dans le fichier modèle \textit{Mouse.mod} (dessin à la souris).
824
825 \item Supposons que l'utilisateur clique sur le point d'affixe 1+i, alors une fenêtre de dialogue s'ouvre avec le
826 message \textsl{Label=} et une ligne de saisie à remplir. Supposons que l'utilisateur entre la chaîne \textsl{Test} et
827 valide, alors la macro va créer un élément graphique \textsl{utilisateur} portant le nom \textsl{Label1} et défini par
828 la commande \co{Label(1+i,"Test")}.
829
830 \item On peut aussi utiliser la macro prédéfinie \textsl{NewLabel} et définir la macro \textsl{ClicG()}
831 en écrivant simplement: \co{NewLabel(\%1) }.
832
833 \item \exem voici une macro \textsl{ClicG()} permettant la création "à la volée" de labels, on a créé auparavant
834 une variable globale \textsl{num} initialisée à 1:
835 \end{itemize}
836
837 \begin{verbatim}
838 if Input("Label=")
839 then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ),
840 ReDraw(), Inc(num,1)
841 fi
842 \end{verbatim}
843
844 \section{NewItem}\label{cmdNewItem}
845
846 \begin{itemize}
847 \item \util \textbf[NewItem()]{NewItem( <nom>, <commande> )}.
848 \item \desc cette fonction ajoute dans la liste déroulante de la zone grisée à gauche dans la fenêtre, un item appelé
849 \argu{nom}, le deuxième paramètre \argu{commande} est la commande associée à l'item, chaque sélection de l'item
850 provoquera l'exécution de cette commande. Les deux arguments sont interprétés comme des chaînes de caractères. S'il
851 existe déjà un item portant le même nom, alors l'ancien est détruit \Mytextbf{sauf si c'est un item prédéfini} (c'est à
852 dire créé au démarrage). À chaque changement de fichier, les items non prédéfinis sont détruits. La fonction
853 \textsl{NewItem} renvoie la valeur \Nil.
854 \end{itemize}
855
856 \section{NewMac}\label{cmdNewMac}
857
858 \begin{itemize}
859 \item \util \textbf[NewMac()]{NewMac( <nom>, <corps> [, param1, $\ldots$, paramN])}.
860 \item \desc cette fonction crée une macro appelée \argu{nom} et dont le contenu est \argu{corps}. Les deux arguments
861 sont donc interprétés comme des chaînes de caractères. Les paramètres optionnels sont des noms de variables, le nom de
862 la variable \argu{param1} est remplacé dans l'expression de la macro par le paramètre \%1, le nom \argu{param2} est
863 remplacé par \%2 $\ldots$ etc. Cette fonction renvoie la valeur \Nil. S'il existait déjà une macro portant le même nom,
864 alors celui-ci est écrasée \Mytextbf{si elle n'est pas prédéfinie}. Si le nom n'est pas valide, ou s'il y a déjà une
865 macro prédéfinie portant ce nom, ou si l'expression \argu{corps} n'est pas correcte, alors la fonction est sans effet.
866 \end{itemize}
867
868 \section{NewVar}\label{cmdNewVar}
869 \begin{itemize}
870 \item \util \textbf[NewVar()]{NewVar( <nom>, <expression> )}.
871 \item \desc cette fonction crée une variable globale appelée \argu{nom} et dont la valeur est \argu{expression}. Les
872 deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil. S'il
873 existait déjà une variable portant le même nom, alors celle-ci est écrasée. Si le nom n'est pas valide, ou s'il y a déjà
874 une constante portant ce nom, alors la fonction est sans effet. Si \argu{expression} n'est pas correcte, alors la valeur
875 affectée à la variable sera \Nil.
876 \end{itemize}
877
878
879 \section{Nops}\label{cmdNops}
880 \begin{itemize}
881 \item \util \textbf[Nops()]{Nops( <liste> )}.
882 \item \desc cette fonction évalue \argu{liste} et renvoie le nombre de complexes qui la composent.
883 \item \exem \co{Nops([1,2,3] )} renvoie la valeur \res{3}.
884 \end{itemize}
885
886 \section{NotXor}\label{cmdNotXor}
887
888 \begin{itemize}
889 \item \util \textbf[NotXor()]{NotXor( <element1>, ..., <elementN> )}.
890 \item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode normal, ce qui correspond à la valeur
891 0 de la variable \Helpref{PenMode}{cmdPenMode}. Elle change le mode des éléments graphiques \argu{element1}, ...,
892 \argu{elementN} en mode NotXor puis les recalcule, et elle renvoie la valeur \Nil.
893
894 Lorsqu'on redessine un élément graphique qui est en mode NotXor, il s'efface en restituant le fond, on peut alors
895 modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous
896 les autres (ce qui évite d'avoir une image qui saute).
897 \item\exem voir la fonction \Helpref{Move}{cmdMove}.
898 \end{itemize}
899
900 \section{OpenFile}\label{cmdOpenFile}
901
902 \begin{itemize}
903 \item \util \textbf[OpenFile()]{OpenFile( <nom fichier> )}.
904 \item \desc cette fonction permet d'ouvrir un fichier texte en écriture. ATTENTION: s'il existe un fichier du même nom,
905 alors celui-ci sera écrasé.
906
907 En combinaison avec les commandes \Helpref{WriteFile}{cmdWriteFile} et \Helpref{CloseFile}{cmdCloseFile}, cela permet à
908 l'utilisateur de créer ses propres fichiers textes.
909 \end{itemize}
910
911
912 \section{OriginalCoord}\label{cmdOriginalCoord}
913
914 \begin{itemize}
915 \item \util \Mytextbf{OriginalCoord( <0/1> )} ou \textbf[OriginalCoord()]{OriginalCoord()}
916 \item \desc cette fonction détermine si le repère à l'exportation en \textit{pstricks} et \textit{tikz/pgf} est
917 identique à celui de l'écran (ce qui correspond à la valeur 1 de l'argument, valeur par défaut), ou non. Lorsque la
918 valeur de l'argument est nulle, le repère à l'exportation (\textit{pstricks} et \textit{tikz/pgf}) aura son origine en
919 bas à gauche et l'unité sera le cm sur les deux axes. Cela est utile lorsqu'on travaille dans des répères où certaines
920 valeurs numériques ne sont plus acceptées par \TeX.
921
922 Lorsque l'argument vaut 1, les coordonnées des points dans le fichier exporté sont les mêmes qu'à l'écran.
923
924 Lorsque l'argument vaut 0, les coordonnées dans le fichier exporté (tex, pst, tikz/pgf) du point d'affixe z à l'écran,
925 sont x=Re(TexCoord(z)) et y=Im(TeXCoord(z)) (et EpsCoord à la place de TeXCoord pour l'export eps).
926
927 Lorsque l'argument est vide, la fonction renvoie l'état actuel du repère à l'exportation (0 ou 1). Sinon, elle renvoie
928 la valeur \Nil.
929 \end{itemize}
930
931 \section{PermuteWith}\label{cmdPermuteWith}
932
933 \begin{itemize}
934 \item \util \textbf[PermuteWith()]{PermuteWith( <liste d'index>, <liste à permuter>, [, taille des paquets ou jump] )}
935 \item \desc la \argu{liste à permuter} doit être une variable, celle-ci sera permutée selon le \argu{liste d'index} qui
936 est une liste d'entiers strictement positifs. La \argu{liste à permuter} est traitée par composante si elle contient
937 la constante \jump, et les éléments de chaque composante sont traités par paquets (de $1$ par défaut) ou par
938 composante entière (une composante se termine par \jump), la liste est donc modifiée.
939 \item \exem:
940 \begin{itemize}
941 \item \co{[L:=[-1,0,3,5], PermuteWith([4,3,2,1], L), L]} renvoie \res{[5,3,0,-1]}.
942 \item \co{[L:=[-1,0,3,5], PermuteWith([4,3,4,1], L), L]} renvoie \res{[5,3,5,-1]}.
943 \item \co{[L:=[-1,0,3,5,6,7,8], PermuteWith([4,3,2,1], L, 2), L]} renvoie \res{[6,7,3,5,-1,0]}.
944 \item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8,jump], PermuteWith( [4,3,3,1,2], L, jump), L]} renvoie
945 \res{[8,jump,5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}.
946 \item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8], PermuteWith([4,3,3,1,2], L, jump), L]} renvoie
947 \res{[5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}.
948 \item \co{[L:=[-1,1,5,jump,0,3,jump,5,6,7,jump,8,9], PermuteWith( [2,1], L), L]} renvoie
949 \res{[1,-1,jump,3,0,jump,6,5,jump,9,8]}.
950 \end{itemize}
951 \end{itemize}
952
953 \section{ReadData}\label{cmdReadData}
954
955 \begin{itemize}
956 \item \util \textbf[ReadData()]{ReadData( <fichier> [, type de lecture, séparateur] )}.
957 \item \desc cette fonction ouvre un \argu{fichier} texte en lecture, celui-ci est supposé contenir une ou plusieurs
958 listes de valeurs numériques. Le premier argument est interprété comme une \Helpref{chaîne de caractères}{chaine} qui
959 contient le nom du fichier (plus éventuellement son chemin). L'argument (optionnel) suivant \argu{type de lecture} est
960 une valeur numérique qui peut valoir:
961 \begin{itemize}
962 \item \argu{type de lecture}=1: la fonction lit le fichier réel par réel et renvoie la liste ou les listes lues:
963 \verb|[x1, x2, ...]|,
964 \item \argu{type de lecture}=2: La fonction lit le fichier complexe par complexe, c'est à dire \Mytextbf{par paquets de
965 deux réels} et renvoie la ou les listes lues sous forme d'affixes: \verb|[x1+i*x2, x3+i*x4, ...]|. C'est la valeur par
966 défaut,
967 \item \argu{type de lecture}=3: La fonction lit le fichier par paquet de 3 réels (points de l'espace ou point3D) et
968 renvoie la ou les listes lues sous la forme: \verb|[x1+i*x2, x3, x4+i*x5, x6, ...]|.
969 \end{itemize}
970
971 Le troisième argument \argu{séparateur}, est interprété comme une chaîne, il est supposé contenir le caractère servant à
972 indiquer la fin de liste, entre deux listes la constante \jump sera insérée, cet argument est facultatif et par défaut
973 il n'y a pas de séparateur (ce qui fait donc une seule liste). Lorsque le séparateur est la fin de ligne dans le
974 fichier, on utilisera la chaîne \co{"LF"} (\textit{line feed}) en troisième paramètre. Lorsqu'il y a un séparateur et
975 lorsque la lecture se fait par paquet de 2 ou 3 réels, un paquet non \og complet\fg\ est ignoré.
976 \item \exem supposons qu'un fichier texte \textit{test.dat} contienne exactement ceci:
977
978 \begin{verbatim}
979 1 2 3 4 5/ 6
980 7 8 9 10 11/ 12
981 13 14 15 16 17/ 18
982 \end{verbatim}
983
984 alors l'exécution de:
985 \begin{itemize}
986 \item \co{ReadData("test.dat")} donne: \res{[1+2*i,3+4*i,5+6*i,7+8*i,9+10*i,11+12*i,13+14*i,15+16*i,17+18*i]},
987 \item \co{ReadData("test.dat",1,"/")} donne:
988 \res{[1,2,3,4,5,jump,6,7,8,9,10,11,jump,12,13,14,15,16,17,jump,18]},
989 \item \co{ReadData("test.dat",2,"/")} donne:
990 \res{[1+2*i,3+4*i,jump,6+7*i,8+9*i,10+11*i,jump,12+13*i,14+15*i,16+17*i,jump]},
991 \item \co{ReadData("test.dat",3,"/")} donne:
992 \res{[1+2*i,3,jump,6+7*i,8,9+10*i,11,jump,12+13*i,14,15+16*i,17,jump]},
993 \item \co{ReadData("test.dat",3,"LF")} donne:
994 \res{[1+2*i,3,4+5*i,6,jump,7+8*i,9,10+11*i,12,jump,13+14*i,15,16+17*i,18,jump]}.
995 \end{itemize}
996 \end{itemize}
997
998
999 \section{ReadFlatPs}\label{cmdReadFlatPs}
1000
1001 \begin{itemize}
1002 \item \util \textbf[ReadFlatPs()]{ReadFlatPs( <fichier> )}.
1003 \item \desc cette fonction ouvre un \argu{fichier} en lecture, celui-ci est censé être un fichier écrit en
1004 \textit{flattened postscript}. La fonction renvoie la liste des chemins contenus dans le fichier, le premier complexe de
1005 la liste est \textit{largeur+i*hauteur} en cm, puis le premier complexe de chaque chemin est \textit{Color+i*Width}.
1006 Chaque chemin se termine par un \jump dont la partie imaginaire est un enter négatif: $-1$ pour eofill, $-2$ pour fill,
1007 $-3$ pour stroke et $-4$ pour clip.
1008
1009 Il est possible de transformer un fichier pdf ou un fichier postscript en \textit{flattened postscript} grâce à
1010 l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). La macro \Helpref{{conv2FlatPs}}{macconv2FlatPs} permet
1011 cette conversion en supposant que l'utilitaire est installé sur votre système.
1012
1013 La fonction \textsl{ReadFlatPs} est surtout utilisée en interne par la macro \Helpref{{loadFlatPs}}{macloadFlatPs} qui
1014 en plus du chargement, adpate les coordonnées des points avant de renvoyer à son tour la liste des chemins que l'on peut
1015 alors dessiner avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}.
1016
1017 Ce système est utilisé par la macro \Helpref{{NewTeXLabel}}{macNewTeXlabel} pour récupérer les formules TeX compilées.
1018 \end{itemize}
1019
1020
1021 \section{ReCalc}\label{cmdReCalc}
1022
1023 \begin{itemize}
1024 \item \util \Mytextbf{ReCalc( <nom1>, ..., <nomN> )} ou \textbf[ReCalc()]{ReCalc()}.
1025 \item \desc cette fonction force le recalcul des éléments graphiques dont les noms sont dans la liste même si ceux-ci
1026 ne sont pas en mode \textsl{Recalcul Automatique}. Si la liste est vide (\textsl{ReCalc()}) alors tout le graphique est
1027 recalculé. Après le recalcul l'affichage est mis à jour et la fonction renvoie \Nil.
1028 \end{itemize}
1029
1030 \Mytextbf{Attention}: l'utilisation de \textsl{ReCalc()} dans un élément graphique entraîne une récursion infinie et
1031 donc un plantage du programme!
1032
1033 \section{ReDraw}\label{cmdReDraw}
1034
1035 \begin{itemize}
1036 \item \util \Mytextbf{ReDraw( <nom1>, ..., <nomN> )} ou \textbf[ReDraw()]{ReDraw()}.
1037 \item \desc cette fonction (re)dessine les éléments graphiques dont les noms sont dans la liste. Si la liste est vide
1038 (\textsl{ReDraw()}) alors tous les élments sont redessinés. Cette fonction renvoie la valeur \Nil.
1039 \end{itemize}
1040
1041 \section{RenCommand}\label{cmdRenCommand}
1042
1043 \begin{itemize}
1044 \item \util \textbf[RenCommand()]{RenCommand( <nom>, <nouveau> )}.
1045 \item \desc cette fonction renomme la commande appelée \argu{nom}. Les deux arguments sont donc interprétés comme des
1046 chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas
1047 de commande portant ce \argu{nom}, ou s'il a déjà une commande portant le nom \argu{nouveau}, alors la fonction est sans
1048 effet.
1049 \end{itemize}
1050
1051 \section{RenMac}\label{cmdRenMac}
1052
1053 \begin{itemize}
1054 \item \util \textbf[RenMac()]{RenMac( <nom>, <nouveau> )}.
1055 \item \desc cette fonction renomme la macro appelée \argu{nom}. Les deux arguments sont donc interprétés comme des
1056 chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas
1057 de macro portant ce \argu{nom}, ou s'il a déjà une macro portant le nom \argu{nouveau}, alors la fonction est sans
1058 effet.
1059 \end{itemize}
1060
1061
1062 \section{RestoreAttr}\label{cmdRestoreAttr}
1063
1064 \begin{itemize}
1065 \item \util \textbf[RestoreAttr()]{RestoreAttr()}.
1066 \item \desc restaure l'ensemble des attributs sauvegardés dans une pile par la commande \Helpref{SaveAttr}{cmdSaveAttr}.
1067 \end{itemize}
1068
1069
1070 \section{Reverse}\label{cmdReverse}
1071 \begin{itemize}
1072 \item \util \textbf[Reverse()]{Reverse( <liste> )}.
1073 \item \desc renvoie la \argu{liste} inversée.
1074 \end{itemize}
1075
1076 \section{Rgb}\label{cmdRgb}
1077
1078 \begin{itemize}
1079 \item \util \textbf[Rgb()]{Rgb( <rouge>, <vert>, <bleu> )}.
1080 \item \desc cette fonction renvoie un entier représentant la couleur dont les trois composantes sont \argu{rouge},
1081 \argu{vert} et \argu{bleu}, ces trois valeurs doivent être des nombres \Mytextbf{compris entre 0 et 1}. Voir aussi la
1082 commande \Helpref{HexaColor}{cmdHexaColor}.
1083 \item \exem \co{Color:= Rgb(0.5,0.5,0.5))} sélectionne le gris.
1084 \end{itemize}
1085
1086 \section{SaveAttr}\label{cmdSaveAttr}
1087
1088 \begin{itemize}
1089 \item \util \textbf[SaveAttr()]{SaveAttr()}.
1090 \item \desc sauvegarde sur une pile l'ensemble des attributs courants. Voir aussi \Helpref{RestoreAttr}{cmdRestoreAttr}.
1091 \end{itemize}
1092
1093
1094 \section{Seq}\label{cmdSeq}
1095
1096 \begin{itemize}
1097 \item \util \textbf[Seq()]{Seq( <expression>, <variable>, <départ>, <fin> [, pas] )}.
1098 \item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable}
1099 est initialisée à \argu{départ} puis, tant que \argu{variable} est dans l'intervalle (fermé) défini par \argu{départ}
1100 et \argu{fin}, on évalue \argu{expression} et on incrémente \argu{variable} de la valeur de \argu{pas}. Le pas peut être
1101 négatif mais il doit être non nul. Lorsqu'il n'est pas spécifié, sa valeur par défaut est 1. Lorsque \argu{variable}
1102 sort de l'intervalle, la boucle s'arrête et la fonction \textsl{Seq} renvoie la liste des résultats. Cette commande est
1103 la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont l'utilisation est préférable pour des raisons de
1104 lisibilité.
1105 \item \exem \co{Seq(exp(i*k*pi/5,k,1,5)} renvoie la liste des racines cinquièmes de l'unité. La commande:
1106
1107 \centerline{\co{Ligne( Seq( exp(2*i*k*pi/5, k, 1, 5), 1)}}
1108
1109 renverra la valeur \Nil mais dessinera un pentagone (voir \Helpref{Ligne}{cmdLigne}) si elle est utilisée dans un
1110 élément graphique \textit{utilisateur}.
1111 \end{itemize}
1112
1113 \section{Set}\label{cmdSet}
1114
1115 \begin{itemize}
1116 \item \util \textbf[Set()]{Set( <variable>, <valeur> )}.
1117 \item \desc cette fonction permet d'affecter à \argu{variable}\footnote{Il n'est pas nécessaire de déclarer les
1118 variables, elles sont implicitement locales et initialisées à \Nil sauf si c'est le nom d'une variable globale ou d'une
1119 constante prédéfinie (comme i, $\pi$, e, ...).} la \argu{valeur} spécifiée. La fonction \textsl{Set} renvoie la valeur
1120 \Nil.
1121
1122 Cette commande est la représentation interne de l'affectation \textsl{:=}, dont l'utilisation est préférable pour des
1123 raisons de lisibilité.
1124 \end{itemize}
1125
1126 \section{SetAttr}\label{cmdSetAttr}
1127
1128 \begin{itemize}
1129 \item \util \textbf[SetAttr()]{SetAttr()}.
1130 \item \desc cette fonction n'a d'effet que dans un élément graphique Utilisateur. Elle permet d'affecter aux attributs
1131 de l'élément la valeur des attributs actuellement en cours. La fonction \textsl{SetAttr} renvoie la valeur \Nil.
1132 \end{itemize}
1133
1134 \section{SetMatrix}\label{cmdSetMatrix}
1135
1136 \begin{itemize}
1137 \item \util \textbf[SetMatrix()]{SetMatrix( <[z1, z2, z3]> )}.
1138 \item \desc cette fonction permet de modifier la matrice courante (celle-ci affecte tous les éléments graphiques sauf
1139 les axes et les grilles dans la version actuelle). Cette matrice représente l'expression analytique d'une application
1140 affine du plan, c'est une liste de trois complexes: $z1$ qui est l'affixe du vecteur de translation, $z2$ qui est
1141 l'affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et $z3$ qui est l'affixe du
1142 deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l'identité s'écrit ainsi:
1143 [0,1,i] (c'est la matrice par défaut). (Voir aussi les commandes \Helpref{GetMatrix}{cmdGetMatrix},
1144 \Helpref{ComposeMatrix}{cmdComposeMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix})
1145
1146 \item \exem si $f:z \mapsto f(z)$ est une application affine, alors sa matrice est $[f(0), f(1)-f(0), f(i)-f(0)]$, ce
1147 calcul peut-être fait par la macro \textit{matrix()} de TeXgraph.mac: \co{SetMatrix(matrix(i*bar(z)))} affecte la
1148 matrice de la symétrie orthogonale par rapport à la première bissectrice.
1149 \end{itemize}
1150
1151
1152 \begin{demo}{Repère non orthogonal}{SetMatrix}
1153 \begin{texgraph}[name=SetMatrix, export=pgf]
1154 view(-5,5,-3,3), size(7.5),
1155 SetMatrix([0,1,1+i]), axes(0,1+i),
1156 tMin:=-5, tMax:=5,
1157 Color:=red, Width:=8, Cartesienne(2*sin(x)),
1158 Color:=black, Arrows:=2,
1159 tangente(2*sin(x), pi/2, 1.5),
1160 Arrows:=0, LineStyle:=dotted,
1161 Ligne( [2*i,pi/2+2*i, pi/2], 0),
1162 Point(pi/2+2*i),
1163 LabelDot( pi/2, "$\frac{\pi}2$","S",1),
1164 IdMatrix()
1165 \end{texgraph}
1166 \end{demo}
1167
1168
1169 \section{Show}\label{cmdShow}
1170
1171 \begin{itemize}
1172 \item \util \textbf[Show()]{Show( <element1>, ..., <elementN> )}.
1173 \item \desc Cette fonction permet de montrer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en
1174 mettant leur attribut \textsl{IsVisible} à true. Les arguments sont interprétés comme des chaînes de caractères. Cette
1175 fonction renvoie la valeur \Nil. Pour tout montrer on invoque la commande sans arguments: \textsl{Show()}. Pour tout
1176 montrer sauf un ou plusieurs éléments, on invoque la commande: \co{Show(except, element1, ..., elementN)}. Voir aussi la
1177 commande \Helpref{Hide}{cmdHide}.
1178 \end{itemize}
1179
1180
1181 \section{Si}\label{cmdSi}
1182
1183 \begin{itemize}
1184 \item \util \textbf[Si()]{Si( <condition1>, <expression1>, ..., <conditionN>, <expressionN> [, sinon] )}.
1185 \item \desc cette fonction évalue \argu{condition1}. Une condition est une expression dont le résultat de l'évaluation
1186 doit être 0 [pour \textit{False}] ou 1 [pour \textit{True}], sinon il y a un échec et la fonction renvoie la valeur
1187 \Nil. Si la condition donne la valeur 1 alors la fonction évalue \argu{expression1} et renvoie le résultat, si elle vaut
1188 0, elle évalue \argu{condition2}, si celle-ci donne la valeur 1 alors la fonction évalue \argu{expression2}, sinon
1189 etc... Lorsqu'aucune condition n'est remplie, la fonction évalue l'argument \argu{sinon}, s'il est présent, et renvoie
1190 le résultat, sinon la fonction renvoie \Nil. Cette commande est la représentation interne de l'alternative
1191 \Helpref{{if}}{cmdif} dont la syntaxe est préférable pour des raisons de lisibilité.
1192
1193 \item \exem définition d'une macro \co{f(x)} représentant une fonction f d'une variable x
1194 définie en plusieurs morceaux:
1195
1196 \centerline{\co{Si(\%1<-1,1-exp(pi*(\%1+1)),\%1<0,sin($\pi$*\%1),sh(pi*\%1))},}
1197
1198 c'est à dire $f(x)=1-exp(\pi(x+1))$ si $x<-1$, $f(x)=sin(\pi x)$ si $-1\leqslant x<0$, $f(x)=$sh$(\pi x)$ sinon.
1199
1200 \end{itemize}
1201
1202
1203 \section{Solve}\label{cmdSolve}
1204
1205 \begin{itemize}
1206 \item \util \textbf[Solve()]{Solve( <expression>, <variable>, <borne inf.>, <borne sup.> [, n] )}.
1207 \item \desc cette fonction "résout" l'équation \argu{expression}=0 par rapport à la variable \Mytextbf{réelle}
1208 \argu{variable} dans l'intervalle défini par \argu{borne inf.} et \argu{borne sup.}. Cet intervalle est subdivisé en
1209 \argu{n} parties [par défaut n=25] et on utilise la méthode de {\sc Newton} sur chaque partie. La fonction renvoie la
1210 liste des résultats.
1211 \item \exem
1212 \begin{itemize}
1213 \item \co{Solve(sin(x), x, -5, 5)} donne \res{[-3.141593, 0, 3.141593]}.
1214
1215 \item Équation: $\displaystyle \int_0^x \exp(t^2)dt=1$: \co{Solve(Int( exp(u\^{}2),u,0,x)-1, x, 0, 1)} donne
1216 \res{0.795172} et l'exécution de \co{Int(exp(u\^{}2), u, 0, 0.795172)} donne \res{1}.
1217
1218 \item \co{Solve( $x^2+x+1$, x, -1, 1)} renvoie \Nil.
1219 \end{itemize}
1220 \end{itemize}
1221
1222 \section{Sort}\label{cmdSort}
1223
1224 \begin{itemize}
1225 \item \util \textbf[Sort()]{Sort( <liste de complexes> [, option] )}.
1226 \item \desc cette fonction trie la liste passée en argument dans l'ordre lexicographique, si l'argument \argu{option}
1227 vaut 0 (valeur par défaut), ou dans l'ordre lexicographique inverse si l'argument \argu{option} vaut 1. Cette liste doit
1228 être une variable, et celle-ci sera modifiée. Si la liste contient la constante \jump alors celle-ci est recopiée telle
1229 quelle dans le résultat, et les \og composantes connexes\fg\ de la liste sont triées indépendamment les unes des autres.
1230 La fonction renvoie la valeur \Nil.
1231 \item \exem si la variable \textsl{L} contient la liste \res{[-2,-3+i,1,1-2*i, jump, 3,5,-6]} alors après l'exécution
1232 de \co{Sort(L)}, la variable contiendra la liste \res{[-3+i,-2,1-2*i,1,jump,-6,3,5]}, et après l'exécution de
1233 \co{Sort(L,1)}, la variable contiendra la liste \res{[1,1-2*i,-2,-3+i,jump,5,3,-6]}. La méthode utilisée est le Quick
1234 Sort..
1235 \end{itemize}
1236
1237 \section{Special}\label{cmdSpecial}
1238
1239 \begin{itemize}
1240 \item \util \textbf[Special()]{Special( <chaîne> )}.
1241 \item \desc cette fonction n'aura d'effet que dans un élément graphique Utilisateur (comme les fonctions graphiques).
1242 L'argument doit être une chaîne de caractères (délimitée par " et "), si cette chaîne contient les balises \verb|\[|,
1243 et \verb|\]|, alors tout le texte contenu entre ces deux balises est interprété par TeXgraph et le résultat est replacé
1244 dans la chaîne. Puis cette chaîne sera écrite telle quelle dans le fichier d'exportation (c'est en fait un Label créé
1245 avec LabelStyle= special).
1246 \item \exem \co{Special("\bks psdot(\bks[1+\bks],\bks[2\^{}3\bks] )")}, écrira dans le fichier exporté: \res{\bks
1247 psdot(2,8)}.
1248 \end{itemize}
1249
1250 \section{Str}\label{Str}
1251
1252 \begin{itemize}
1253 \item \util \textbf[Str()]{Str( <nom de macro> )}.
1254 \item \desc lors d'une évaluation alphanumérique, cette fonction renvoie la définition de la macro appelée \argu{nom de
1255 macro} (sauf si c'est une macro prédéfinie). En dehors de ce contexte, la fonction \textsl{Str} renvoie \Nil. L'argument
1256 \argu{nom de macro} est lui-même interprété comme une chaîne de caractères.
1257 \item \exem supposons que la macro \co{f} soit définie par \co{\%1+i*sin(\%1)}, alors la commande
1258 \co{Label(0,["f(\%1)=",Str("f")] )} affichera à l'écran à l'affixe 0, le texte: \res{f(\%1)=\%1+i*sin(\%1)}.
1259 \end{itemize}
1260
1261 \section{StrArgs}\label{cmdStrArgs}
1262
1263 \begin{itemize}
1264 \item \util \textbf[StrArgs()]{StrArgs( <entier> )}.
1265 \item \desc cette fonction n'a d'effet que dans une macro, elle renvoie l'argument numéro \argu{entier} avec lequel la
1266 macro a été appelée, sous forme d'une chaîne. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la
1267 commande \Helpref{Args}{cmdArgs}
1268 \item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}.
1269 \end{itemize}
1270
1271 \section{StrComp}\label{cmdStrComp}
1272
1273 \begin{itemize}
1274 \item \util \textbf[StrComp()]{StrComp( <chaîne1>, <chaîne2> )}.
1275 \item \desc les deux arguments sont interprétés comme une chaîne de caractères, et les deux chaînes sont comparées, si
1276 elles sont égales alors la fonction renvoie la valeur 1, sinon la valeur 0.
1277 \item \exem la combinaison de touches: Ctrl+Maj+<lettre> lance automatiquement l'exécution de la macro spéciale:
1278 \textsl{ OnKey( <lettre> )}. L'utilisateur peut définir cette macro avec par exemple la commande:
1279
1280 \centerline{\co{if StrComp(\%1, "A") then Message("Lettre A") fi}}
1281 \end{itemize}
1282
1283 \section{String}\label{cmdString}
1284
1285 \begin{itemize}
1286 \item \util \textbf[String()]{String( <expression mathématique> )}.
1287 \item \desc lors d'une évaluation alphanumérique, cette fonction renvoie \argu{expression mathématique} sous forme d'une
1288 chaîne. En dehors de ce contexte, la fonction \textsl{String} renvoie \Nil.
1289 \end{itemize}
1290
1291 \section{Stroke}\label{cmdStroke}
1292
1293 \begin{itemize}
1294 \item \util \textbf[Stroke()]{Stroke( <element1>, ..., <elementN> )}.
1295
1296 \item \desc cette fonction recalcule les éléments graphiques \argu{element1}, ..., \argu{elementN}, puis les redéssine
1297 en mode NORMAL, et renvoie la valeur \Nil.
1298
1299 \item\exem on a créé deux variables globales: $a$ et \textit{drawing}. On va créer le cercle de centre a et de rayon 1,
1300 appelé \textsl{objet1}, on souhaite pouvoir déplacer cet objet à la souris. Pour cela, on crée la macro \textsl{ClicG}
1301 avec la commande:
1302 \end{itemize}
1303
1304 \begin{verbatim}
1305 [PenMode:=1, {mode NotXor}
1306 NewGraph("objet1", "Cercle(a,1)"),
1307 PenMode:=0, {mode normal}
1308 ReDraw(), {on montre}
1309 drawing:=1]
1310 \end{verbatim}
1311
1312 on crée la macro \res{MouseMove} avec la commande: \co{if drawing then a:=\%1 \{on déplace le centre\}, Move(objet1)
1313 fi},
1314
1315 puis la macro \res{LButtonUp} avec la commande: \co{if drawing then Stroke(objet1), drawing:=0 fi}.
1316
1317 La macro \textsl{ClicG} crée l'objet1 en mode NotXor, rafraîchit l'affichage graphique et passe en mode "dessin". La
1318 macro \textsl{ MouseMove} permet de placer le centre à la position de la souris, puis de déplacer l'objet1. Lorsque le
1319 bouton gauche est relâché, on dessine l'objet1 en mode normal, puis on quitte le mode "dessin".
1320
1321
1322 \section{TeX2FlatPs}\label{cmdTeX2FlatPs}
1323
1324 \begin{itemize}
1325 \item \util \textbf[TeX2FlatPs()]{TeX2FlatPs( <"formule"> [, dollar(0/1)] )}.
1326
1327 \item \desc cette renvoie une \argu{formule} \TeX{} sous forme d'une liste de chemins, le résultat doit être dessiné
1328 avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}. La \argu{formule} est écrite dans un fichier appelé
1329 \textit{formula.tex}. Ce fichier est appelé par le fichier \textit{formule.tex} qui se trouve dans le dossier de
1330 travail de TeXgraph, pour être compilé par \TeX{}. Si l'option \argu{dollar} vaut $1$ alors la formule sera délimitée
1331 par \verb|\]| et \verb|\]|, sinon elle est écrite telle quelle. Pour plus de renseignements sur la façon dont sont
1332 récupérés ces chemins, voir la commande \Helpref{{ReadFlatPs}}{cmdReadFlatPs}.
1333 \end{itemize}
1334
1335
1336 \section{Timer}\label{cmdTimer}
1337
1338 \begin{itemize}
1339 \item \util \textbf[Timer()]{Timer( <milli-secondes> )}.
1340
1341 \item \desc règle l'intervalle de temps pour le timer, celui exécute régulièrement une certaine macro (que l'on peut
1342 définir avec la commande TimerMac). Pour stopper le timer il suffit de régler l'intervalle de temps à 0.
1343 \end{itemize}
1344
1345 \section{TimerMac}\label{cmdTimerMac}
1346
1347 \begin{itemize}
1348 \item \util \textbf[TimerMac()]{TimerMac( <corps de la macro à exécuter> )}.
1349
1350 \item \desc cette commande permet de créer une macro qui sera attachée au timer. L'argument est interprété comme une
1351 chaîne de caractères et doit correspondre au corps de la macro (celle-ci sera appélée TimerMac). Pour des raisons de
1352 performances, il est préférable d'éviter trop d'appels à d'autres macros dans celle-ci. Cette fonction renvoie la valeur
1353 1 si la macro est correctement définie, 0 en cas d'erreur. Attention, l'exécution de TimerMac ne déclenche pas le timer!
1354 Il faut utiliser la commande Timer pour cela.
1355
1356 \item \exem soit $A$ une variable globale (un point), soit \textit{dotA} un élément graphique qui dessine le point,
1357 voilà une commande qui déplace $A$:
1358
1359 \centerline{
1360 \co{[TimerMac("[Inc(A,0.1), if Re(A)>5 then Timer(0) else ReCalc(dotA) fi]"), A:=-5, Timer(10)]}}
1361 \end{itemize}
1362
1363 \section{VisibleGraph}\label{cmdVisibleGraph}
1364
1365 \begin{itemize}
1366 \item \util \Mytextbf{VisibleGraph( <0/1> )} ou \textbf[VisibleGraph()]{VisibleGraph()}.
1367
1368 \item \desc cette fonction permet d'activer ou désactiver la zone de dessin dans l'interface graphique. Lorsque
1369 celle-ci est désactivée, son contenu ne change plus car il n'y a plus de mise à jour de la zone. Désactiver l'affichage
1370 graphique peut permettre dans certains cas un gain de temps pour enregistrer une animation par exemple.
1371
1372 Lorsque l'argument est vide, la fonction renvoie simplement l'état actuel de l'affichage graphique (0 ou 1). Sinon, elle
1373 renvoie \Nil.
1374 \end{itemize}
1375
1376
1377 \section{WriteFile}\label{cmdWriteFile}
1378
1379 \begin{itemize}
1380 \item \util \textbf[WriteFile()]{WriteFile( <argument> )}.
1381
1382 \item \desc cette fonction permet d'écrire soit dans le fichier texte ouvert par la commande
1383 \Helpref{OpenFile}{cmdOpenFile}, soit dans le fichier d'exportation si l'exécution de cette commande a lieu pendant une
1384 exportation par l'intermédiare des macros \Helpref{Bsave}{macBsave} et/ou \Helpref{Esave}{macEsave}.
1385
1386 \item \exem voici ce que pourrait être la macro \textsl{Bsave} pour modifier la taille des flêches en pstricks:
1387 \end{itemize}
1388
1389 \begin{verbatim}
1390 if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi
1391 \end{verbatim}

Licence Creative Commons Les fichiers de Syracuse sont mis à disposition (sauf mention contraire) selon les termes de la
Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.