1 \chapter{Liste des commandes
}
5 <argument>: signifie que l'argument est
\Mytextbf{obligatoire
}.
7 [argument
]: signifie que l'argument est
\Mytextbf{facultatif
}.
10 \section{Args
}\label{cmdArgs
}
13 \item \util \textbf[Args()
]{Args( <entier> )
}.
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
}
19 \item\exem Voir la fonction
\Helpref{Nargs
}{cmdNargs
}.
22 \section{Assign
}\label{cmdAssign
}
25 \item \util \textbf[Assign()
]{Assign( <expression>, <variable>, <valeur> )
}.
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.
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),
37 \centerline{\co{for \$k from
0 to
5 do Assign(\%
1,t,k), \%
1 od
}}
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
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.
44 \section{Attributs
}\label{cmdAttributs
}
47 \item \util \textbf[Attributs()
]{Attributs()
}.
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
55 \section{Border
}\label{cmdBorder
}
58 \item \util \textbf[Border()
]{Border( <
0/
1> )
}
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é.
63 Lorsque l'argument est vide, cette fonction renvoie l'état de la bordure à l'exportation (
0 ou
1). Sinon, elle renvoie
67 \section{ChangeAttr
}\label{cmdChangeAttr
}
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.
76 \section{Clip2D
}\label{cmdClip2D
}
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.
87 \section{CloseFile
}\label{cmdCloseFile
}
90 \item \util \textbf[CloseFile()
]{CloseFile()
}.
91 \item \desc cette fonction permet de fermer le fichier ouvert par la commande
\Helpref{OpenFile
}{cmdOpenFile
}.
95 \section{ComposeMatrix
}\label{cmdComposeMatrix
}
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
}).
109 \section{Copy
}\label{cmdCopy
}
112 \item \util \textbf[Copy()
]{Copy( <liste>, <index depart>, <nombre> )
}.
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
}.
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.
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]}.
134 \Mytextbf{NB
}: pour des raisons de compatibilité avec l'ancienne version, l'index $
0$ correspond aussi au dernier
137 \section{DefaultAttr
}\label{cmdDefaultAttr
}
140 \item \util \textbf[DefaultAttr()
]{DefaultAttr()
}
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.
147 \section{Del
}\label{cmdDel
}
150 \item \util \textbf[Del()
]{Del( <liste>, <depart>, <nombre> )
}.
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
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.
161 Le paramètre
\argu{liste
} doit être
\Mytextbf{un nom de variable
}, celle-ci est modifiée et la fonction renvoie
\Nil.
163 \item \exem la commande
\co{[x:=
[1,
2,
3,
4], Del(x,
2,
2), x
]} renvoie
\res{[1,
4]}.
165 La commande
\co{[x:=
[1,
2,
3,
4], Del(x,-
2,
2), x
]} renvoie
\res{[1,
4]}.
169 \Mytextbf{NB
}: pour des raisons de compatibilité avec l'ancienne version, l'index $
0$ correspond aussi au dernier
172 \section{Delay
}\label{cmdDelay
}
175 \item \util \textbf[Delay()
]{Delay( <nb millisecondes> )
}
177 \item \desc permet de suspendre l'exécution du programme pendant le laps de temps indiqué (en milli-secondes).
180 \section{DelButton
}\label{cmdDelButton
}
183 \item \util \textbf[DelButton()
]{DelButton( <texte1>, ..., <texteN> )
}
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.
190 \section{DelGraph
}\label{cmdDelGraph
}
193 \item \util \textbf[DelGraph()
]{DelGraph( <element1>, ..., <elementN> )
}
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.
200 \section{DelItem
}\label{cmdDelItem
}
203 \item \util \textbf[DelItem()
]{DelItem( <nom1>, ..., <nomN> )
}
205 \item \desc Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options
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.
211 \section{DelMac
}\label{cmdDelMac
}
214 \item \util \textbf[DelMac()
]{DelMac( <mac1>, ..., <macN> )
}
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.
221 \section{DelText
}\label{cmdDelText
}
224 \item \util \textbf[DelText()
]{DelText( <texte1>, ..., <texteN> )
}
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.
231 \section{DelVar
}\label{cmdDelVar
}
234 \item \util \textbf[DelVar()
]{DelVar( <var1>, ..., <varN> )
}
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.
242 \section{Der
}\label{cmdDer
}
245 \item \util \textbf[Der()
]{Der( <expression>, <variable>, <liste> )
}.
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
}.
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:
257 \centerline{\co{[Assign(\%
1,x,\%
2), \$A:=\%
2+i*\%
1, \$Df:=Der(\%
1,x,\%
2), Droite(A, A+
1+i*Df)
]}}
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)$.
265 \section{Diff
}\label{cmdDiff
}
268 \item \util \textbf[Diff()
]{Diff( <nom>, <expression>, <variable>
[, param1,..., paramN
] )
}
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.
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 à
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.
286 \section{Echange
}\label{cmdEchange
}
289 \item \util \textbf[Echange()
]{Echange( <variable1>, <variable2> )
}.
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:
294 {\centering \co{[aux:=variable1, variable1:=variable2, variable2:=aux
]}\par}
296 La fonction
\textsl{Echange
} renvoie la valeur
\Nil.
299 \section{EpsCoord
}\label{cmdEpsCoord
}
302 \item \util \textbf[EpsCoord()
]{EpsCoord( <affixe> )
}
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
}.
308 \section{Eval
}\label{cmdEval
}
311 \item \util \textbf[Eval()
]{Eval( <expression> )
}.
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
}.
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
320 \item \exem voici une commande demandant une valeur à l'utilisateur pour une variable
\textit{x
}:
324 if Input("x=", "Entrez une valeur pour x", x )
325 then x:= Eval( chaine() )
330 \section{Exec
}\label{cmdExec
}
333 \item \util \textbf[Exec()
]{Exec( <programme>
[, argument(s), répertoire de travail, attendre
] )
}.
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.
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
346 \item \exem la macro
\textsl{Apercu
} contenue dans interface.mac est:
350 [Export(pgf,
[@TmpPath,"file.pgf"
] ),
351 Exec("pdflatex",
["-interaction=nonstopmode apercu.tex"
],@TmpPath,
1),
352 Exec(@PdfReader,"apercu.pdf",@TmpPath,
0)
356 \section{Export
}\label{cmdExport
}
359 \item \util \textbf[Export()
]{Export( <mode>, <fichier> )
}.
361 \item \desc cette fonction permet d'exporter le graphique en cours,
\argu{mode
} est une valeur numérique qui peut être
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.
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
371 \item \exem la macro
\textsl{Apercu
} contenue dans interface.mac est:
375 [Export(pgf,
[@TmpPath,"file.pgf"
] ),
376 Exec("pdflatex",
["-interaction=nonstopmode apercu.tex"
],@TmpPath,
1),
377 Exec(@PdfReader,"apercu.pdf",@TmpPath,
0)
381 \section{ExportObject
}\label{cmdExportObject
}
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
}.
391 \section{Fenetre
}\label{cmdFenetre
}
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.
403 \section{Free
}\label{cmdFree
}
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.
411 \section{Get
}\label{cmdGet
}
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é.
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).
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.
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.
430 \item \exem utilisation des points d'un objet graphique:
433 \begin{demo
}{Get
}{Get
}
434 \begin{texgraph
}[name=Get,export=pgf,file
]
435 Cmd view(
0,
6.25,-
1.5,
2);
437 [tMin:=
0, tMax:=
6.25];
438 Graph axe = Axes(
0,
1+i);
439 C1 =
[Color:=blue,Width:=
8,
441 C2 =
[Color:=red,Width:=
8,
442 Cartesienne(sin(
2*x)*
1.5)
];
443 inter =
[DotScale:=
2,DotStyle:=dotcircle,
445 Point(Get(C1) InterL Get(C2)),
447 LabelDot(
5.5+
0.1*i,"$C_1$","N"),
449 LabelDot(
3-i,"$C_2$","E"),
455 \section{GetAttr
}\label{cmdGetAttr
}
458 \item \util \textbf[GetAttr()
]{GetAttr( <argument> )
}
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.
467 \section{GetMatrix
}\label{cmdGetMatrix
}
470 \item \util \textbf[GetMatrix()
]{GetMatrix()
}
472 \item \desc cette fonction renvoie la matrice courante. (Voir aussi les commandes
473 \Helpref{ComposeMatrix
}{cmdComposeMatrix
},
\Helpref{SetMatrix
}{cmdSetMatrix
}, et
\Helpref{IdMatrix
}{cmdIdMatrix
})
476 \section{GetSpline
}\label{cmdGetSpline
}
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
}.
487 \section{GrayScale
}\label{cmdGrayScale
}
490 \item \util \textbf[GrayScale()
]{GrayScale(
0/
1)
} ou
\textbf[GrayScale()
]{GrayScale()
}.
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.
495 Lorsque l'argument est vide, la fonction renvoie l'état actuel de la conversion en niveaux de gris (
0 ou
1). Sinon, elle
499 \section{HexaColor
}\label{cmdHexaColor
}
502 \item \util \textbf[HexaColor()
]{HexaColor( <valeur héxadécimale> )
}
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
}.
507 \item \exem \verb Color:=HexaColor("F5F5DC") .
510 \section{Hide
}\label{cmdHide
}
513 \item \util \textbf[Hide()
]{Hide( <element1>, ..., <elementN> )
}
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.
519 Pour tout cacher on invoque la commande sans arguments:
\textsl{Hide()
}.
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
}.
525 \section{IdMatrix
}\label{cmdIdMatrix
}
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
})
535 \section{Input
}\label{cmdInput
}
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
}.
548 \section{InputMac
}\label{cmdInputMac
}
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
}).
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")
}.
565 \section{Inc
}\label{cmdInc
}
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.
575 \section{Insert
}\label{cmdInsert
}
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]}.
586 \section{Int
}\label{cmdInt
}
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).
597 \section{IsMac
}\label{cmdIsMac
}
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
605 \section{IsVar
}\label{cmdIsVar
}
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
613 \section{Liste
}\label{cmdListe
}
616 \item \util \textbf[Liste()
]{Liste( <argument1>, ..., <argumentn> )
} ou bien
\Mytextbf{[<argument1>, ...,
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]}.
623 \section{ListFiles
}\label{cmdListFiles
}
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.
631 \section{LoadImage
}\label{cmdLoadImage
}
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.
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.
648 \section{Loop
}\label{cmdLoop
}
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):
658 \centerline{\co{[n:=
1, m:=
1, n, Loop(
[ aux:=n, n:=m, m:=aux+n, n
], m>
100)
]}}
662 \centerline{\co{[n:=
1, m:=
1, n, while m<=
100 do aux:=n, n:=m, m:=aux+n, n od
]}}
666 \centerline{\co{[n:=
1, m:=
1, n, repeat aux:=n, n:=m, m:=aux+n, n until m>
100 od
]}}
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 à
672 \section{Map
}\label{cmdMap
}
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é.
681 Le paramètre optionnel
\argu{mode
} est un complexe qui vaut
\Nil par défaut, lorsque
\argu{mode
}$=a+ib$, alors:
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
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
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$.
696 \item \exem voir la boucle
\Helpref{for
}{cmdfor
} pour des exemples.
700 \item \exem si $L$ est une variable contenant une liste de points, alors la commande:
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.
708 \section{Marges
}\label{cmdMarges
}
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
}.
717 \section{Merge
}\label{cmdMerge
}
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]}.
726 Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine.
730 \section{Message
}\label{cmdMessage
}
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.
739 \section{Move
}\label{cmdMove
}
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.
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
}.
753 \section{Mtransform
}\label{cmdMtransform
}
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).
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
}.
774 \section{Nargs
}\label{cmdNargs
}
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:
785 for $k from
1 to Nargs()/
2 do
786 Label(Args(
2*k-
1), Args(
2*k))
790 \section{NewButton
}\label{cmdNewButton
}
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
} où
\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.
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.
809 \section{NewGraph
}\label{cmdNewGraph
}
812 \item \util \textbf[NewGraph()
]{NewGraph( <chaîne1>, <chaîne2>
[, code
] )
}.
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 à
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).
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")
}.
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)
}.
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:
839 then NewGraph(
["Label",num
],
["Label(",
%1,",", """",chaine(),""")"] ),
844 \section{NewItem
}\label{cmdNewItem
}
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.
856 \section{NewMac
}\label{cmdNewMac
}
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.
868 \section{NewVar
}\label{cmdNewVar
}
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.
879 \section{Nops
}\label{cmdNops
}
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}.
886 \section{NotXor
}\label{cmdNotXor
}
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.
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
}.
900 \section{OpenFile
}\label{cmdOpenFile
}
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é.
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.
912 \section{OriginalCoord
}\label{cmdOriginalCoord
}
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.
922 Lorsque l'argument vaut
1, les coordonnées des points dans le fichier exporté sont les mêmes qu'à l'écran.
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).
927 Lorsque l'argument est vide, la fonction renvoie l'état actuel du repère à l'exportation (
0 ou
1). Sinon, elle renvoie
931 \section{PermuteWith
}\label{cmdPermuteWith
}
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.
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]}.
953 \section{ReadData
}\label{cmdReadData
}
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:
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
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, ...
]|.
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:
984 alors l'exécution de:
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
]}.
999 \section{ReadFlatPs
}\label{cmdReadFlatPs
}
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.
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.
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
}.
1017 Ce système est utilisé par la macro
\Helpref{{NewTeXLabel
}}{macNewTeXlabel
} pour récupérer les formules TeX compilées.
1021 \section{ReCalc
}\label{cmdReCalc
}
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.
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!
1033 \section{ReDraw
}\label{cmdReDraw
}
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.
1041 \section{RenCommand
}\label{cmdRenCommand
}
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
1051 \section{RenMac
}\label{cmdRenMac
}
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
1062 \section{RestoreAttr
}\label{cmdRestoreAttr
}
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
}.
1070 \section{Reverse
}\label{cmdReverse
}
1072 \item \util \textbf[Reverse()
]{Reverse( <liste> )
}.
1073 \item \desc renvoie la
\argu{liste
} inversée.
1076 \section{Rgb
}\label{cmdRgb
}
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.
1086 \section{SaveAttr
}\label{cmdSaveAttr
}
1089 \item \util \textbf[SaveAttr()
]{SaveAttr()
}.
1090 \item \desc sauvegarde sur une pile l'ensemble des attributs courants. Voir aussi
\Helpref{RestoreAttr
}{cmdRestoreAttr
}.
1094 \section{Seq
}\label{cmdSeq
}
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
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:
1107 \centerline{\co{Ligne( Seq( exp(
2*i*k*pi/
5, k,
1,
5),
1)
}}
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
}.
1113 \section{Set
}\label{cmdSet
}
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
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é.
1126 \section{SetAttr
}\label{cmdSetAttr
}
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.
1134 \section{SetMatrix
}\label{cmdSetMatrix
}
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
})
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.
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),
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),
1163 LabelDot( pi/
2, "$
\frac{\pi}2$","S",
1),
1169 \section{Show
}\label{cmdShow
}
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
}.
1181 \section{Si
}\label{cmdSi
}
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é.
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:
1196 \centerline{\co{Si(\%
1<-
1,
1-exp(pi*(\%
1+
1)),\%
1<
0,sin($
\pi$*\%
1),sh(pi*\%
1))
},
}
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.
1203 \section{Solve
}\label{cmdSolve
}
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.
1213 \item \co{Solve(sin(x), x, -
5,
5)
} donne
\res{[-
3.141593,
0,
3.141593]}.
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}.
1218 \item \co{Solve( $x^
2+x+
1$, x, -
1,
1)
} renvoie
\Nil.
1222 \section{Sort
}\label{cmdSort
}
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
1237 \section{Special
}\label{cmdSpecial
}
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
1250 \section{Str
}\label{Str
}
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)
}.
1261 \section{StrArgs
}\label{cmdStrArgs
}
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
}.
1271 \section{StrComp
}\label{cmdStrComp
}
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:
1280 \centerline{\co{if StrComp(\%
1, "A") then Message("Lettre A") fi
}}
1283 \section{String
}\label{cmdString
}
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.
1291 \section{Stroke
}\label{cmdStroke
}
1294 \item \util \textbf[Stroke()
]{Stroke( <element1>, ..., <elementN> )
}.
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.
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
}
1305 [PenMode:=
1,
{mode NotXor
}
1306 NewGraph("objet1", "Cercle(a,
1)"),
1307 PenMode:=
0,
{mode normal
}
1308 ReDraw(),
{on montre
}
1312 on crée la macro
\res{MouseMove
} avec la commande:
\co{if drawing then a:=\%
1 \
{on déplace le centre\
}, Move(objet1)
1315 puis la macro
\res{LButtonUp
} avec la commande:
\co{if drawing then Stroke(objet1), drawing:=
0 fi
}.
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".
1322 \section{TeX2FlatPs
}\label{cmdTeX2FlatPs
}
1325 \item \util \textbf[TeX2FlatPs()
]{TeX2FlatPs( <"formule">
[, dollar(
0/
1)
] )
}.
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
}.
1336 \section{Timer
}\label{cmdTimer
}
1339 \item \util \textbf[Timer()
]{Timer( <milli-secondes> )
}.
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.
1345 \section{TimerMac
}\label{cmdTimerMac
}
1348 \item \util \textbf[TimerMac()
]{TimerMac( <corps de la macro à exécuter> )
}.
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.
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$:
1360 \co{[TimerMac("
[Inc(A,
0.1), if Re(A)>
5 then Timer(
0) else ReCalc(dotA) fi
]"), A:=-
5, Timer(
10)
]}}
1363 \section{VisibleGraph
}\label{cmdVisibleGraph
}
1366 \item \util \Mytextbf{VisibleGraph( <
0/
1> )
} ou
\textbf[VisibleGraph()
]{VisibleGraph()
}.
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.
1372 Lorsque l'argument est vide, la fonction renvoie simplement l'état actuel de l'affichage graphique (
0 ou
1). Sinon, elle
1377 \section{WriteFile
}\label{cmdWriteFile
}
1380 \item \util \textbf[WriteFile()
]{WriteFile( <argument> )
}.
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
}.
1386 \item \exem voici ce que pourrait être la macro
\textsl{Bsave
} pour modifier la taille des flêches en pstricks:
1390 if ExportMode=pst then WriteFile("
\psset{arrowscale=
3}") fi