Notations:
+<argument>: signifie que l’argument est obligatoire.
+[argument]: signifie que l’argument est facultatif.
+Args( <entier> ).
Description : cette fonction n’a d’effet que dans une macro, elle évalue et renvoie l’argument numéro <entier> avec lequel la macro a été appelée. Hors de ce contexte, elle renvoie la valeur Nil. Voir également la commande StrArgs
Exemple(s) : Voir la fonction Nargs.
Assign( <expression>, <variable>, <valeur> ).
Description : cette fonction évalue <valeur> et l’affecte à la variable nommée <variable> dans <expression>1. La fonction Assign renvoie la valeur Nil. Cette fonction est utile dans l’écriture de macros prenant une expression comme paramètre et qui doivent l’évaluer.
Exemple(s) : voici une macro Bof qui prend une fonction f(t) en paramètre et qui calcule la liste [f(0), f(1), . . . , f(5)]:
%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 commande [Assign(%1, t, k), %1], celle-ci assigne la valeur de k à la variable t dans l’expression %1, puis évalue %1. L’exécution de Bof(t^2) donne: [0,1,4,9,16,25]. L’exécution de Bof(x^2) donne Nil.
+Attributs().
Description : cette fonction ouvre la fenêtre permettant de modifier les attributs d’un élément graphique. Cette fonction renvoie la valeur 1 si l’utilisateur a choisi OK, elle renvoie la valeur 0 s’il a choisi Cancel. Si l’utilisateur a choisi OK, alors les variables globales correspondant aux attributs sont modifiées en conséquence.
Border( <0/1> )
Description : cette fonction détermine si un cadre doit être dessiné ou non autour des marges du graphique dans les exportations. Lorsque la valeur de l’argument est nulle (valeur par défaut), le cadre n’est pas dessiné.
+Lorsque l’argument est vide, cette fonction renvoie l’état de la bordure à l’exportation (0 ou 1). Sinon, elle renvoie la valeur Nil.
ChangeAttr( <element1>, ..., <elementN> )
Description : cette fonction permet de modifier les attributs des éléments graphiques <element1>, ..., <elementN>, en leur affectant la valeur des attributs en cours. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
Clip2D( <ligne polygonale>, <contour convexe> [, close(0/1) ] ).
Description : cette fonction clippe la <ligne polygonale> qui doit être une variable contenant une liste de complexes, avec le <contour convexe>, qui est lui aussi une liste de complexes. La fonction calcule la ligne polygonale qui en résulte modifie la variable <ligne polygonale> en conséquence, le dernier agument <close> (0 par défaut) permet de préciser si la <ligne polygonale> doit être refermée ou non. La fonction renvoie Nil.
CloseFile().
Description : cette fonction permet de fermer le fichier ouvert par la commande OpenFile.
ComposeMatrix( <[z1, z2, z3]> )
Description : cette fonction permet de composer la matrice courante (celle-ci affecte tous les éléments graphiques sauf les axes et les grilles dans la version actuelle) avec la matrice <[z1, z2, z3]>. Cette matrice représente l’expression analytique d’une application affine du plan, c’est une liste de trois complexes: z1 qui est l’affixe du vecteur de translation, z2 qui est 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 deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l’identité s’écrit ainsi: [0,1,i] (c’est la matrice par défaut). (Voir aussi les commandes GetMatrix, SetMatrix, et IdMatrix).
Copy( <liste>, <index depart>, <nombre> ).
Description : cette fonction renvoie la liste constituée par les <nombre> éléments de la <liste> à partir de l’élément numéro <depart>[inclus]. Si <nombre> est nul, alors la fonction renvoie tous les éléments de la liste à partir de l’élément numéro <départ>.
+Si le numéro <depart> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, le dernier élément a l’index - 1, l’avant-dernier a l’index - 2 ⋯ etc. La fonction renvoie les <nombre> éléments de la liste (ou toute la liste si <nombre> est nul) en allant vers la gauche, mais la liste renvoyée est dans le même sens que la <liste>, et cette dernière n’est pas modifiée.
Exemple(s) :
+Copy([1,2,3,4],2,2) renvoie [2,3].
Copy([1,2,3,4],2,5) renvoie [2,3,4].
Copy([1,2,3,4],2,0) renvoie [2,3,4].
Copy([1,2,3,4],-1,2) renvoie [3,4].
Copy([1,2,3,4],-2,2) renvoie [2,3].
Copy([1,2,3,4],-2,0) renvoie [1,2,3].
NB: pour des raisons de compatibilité avec l’ancienne version, l’index 0 correspond aussi au dernier élément de la liste.
+DefaultAttr()
Description : cette fonction met toutes les variables correspondant aux attributs (Color, Width, ...) à leur valeur par défaut. Cette fonction renvoie la valeur Nil.
Del( <liste>, <depart>, <nombre> ).
Description : supprime de la <liste> <nombre> éléments à partir du numéro <départ>[inclus]. Si <nombre> est nul, alors la fonction supprime tous les éléments de la liste à partir de l’élément numéro <départ>.
+Si le numéro <depart> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier. Le dernier élément a l’index - 1, l’avant-dernier a l’index - 2 ⋯ etc. La fonction supprime les <nombre> éléments de la liste (ou toute la liste si <nombre> est nul) en allant vers la gauche.
+Le paramètre <liste> doit être un nom de variable, celle-ci est modifiée et la fonction renvoie Nil.
Exemple(s) : la commande [x:=[1,2,3,4], Del(x,2,2), x] renvoie [1,4].
+La commande [x:=[1,2,3,4], Del(x,-2,2), x] renvoie [1,4].
NB: pour des raisons de compatibilité avec l’ancienne version, l’index 0 correspond aussi au dernier élément de la liste.
+Delay( <nb millisecondes> )
Description : permet de suspendre l’exécution du programme pendant le laps de temps indiqué (en milli-secondes).
DelButton( <texte1>, ..., <texteN> )
Description : Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les boutons portant les inscriptions <texte1>, ..., <texteN>. Si la liste est vide ( DelButton()), alors tous les boutons sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
DelGraph( <element1>, ..., <elementN> )
Description : Cette fonction permet de supprimer les éléments graphiques appelés <element1>, ..., <elementN>. Si la liste est vide ( DelGraph()), alors tous les éléments sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
DelItem( <nom1>, ..., <nomN> )
Description : Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options appelées <nom1>, ..., <nomN>. Si la liste est vide ( DelItem()), alors toute la liste est supprimée. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
DelMac( <mac1>, ..., <macN> )
Description : Cette fonction permet de supprimer les macros (non prédéfinies) appelées <mac1>, ..., <macN>. Si la liste est vide (DelMac()), la commande est sans effet. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
DelText( <texte1>, ..., <texteN> )
Description : Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les labels <texte1>, ..., <texteN>. Si la liste est vide ( DelText()), alors tous les labels sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
DelVar( <var1>, ..., <varN> )
Description : Cette fonction permet de supprimer les variables globales (non prédéfinies) appelés <var1>, ..., <varN>. Si la liste est vide (DelVar()), la commande est sans effet. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
Der( <expression>, <variable>, <liste> ).
Description : cette fonction calcule la dérivée de <expression> par rapport à <variable> et l’évalue en donnant à <variable> les valeurs successives de la <liste>. La fonction Der renvoie la liste des résultats. Mais si on a besoin de l’expression de la dérivée, alors on préférera la fonction Diff.
Exemple(s) :
+la commande Der(1/x,x,[-1,0,2] ) renvoie [-1,-0.25].
Voici le texte d’une macro appelée tangente qui prend une expression f(x) en premier paramètre, une valeur réelle x0 en second paramètre et qui trace la tangente à la courbe au point d’abscisse x0:
+On assigne la valeur x0 à la variable x dans l’expression f(x), on stocke dans une variable A le point de 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 trace la droite passant par A et dirigée par le vecteur d’affixe 1 + ifʹ(x0).
Diff( <nom>, <expression>, <variable> [, param1,..., paramN] )
Description : cette fonction permet de créer une macro appelée <nom>, s’il existait déjà une macro portant ce nom, 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 correspond à la dérivée de <expression> par rapport à <variable>. Les paramètres optionnels sont des noms de variables, le nom de la variable <param1> est remplacé dans l’expression de la dérivée par le paramètre %1, le nom <param2> est remplacé par %2 ... etc. Cette fonction renvoie Nil.
Exemple(s) : après l’exécution de la commande (dans la ligne de commande en bas de la fenêtre): Diff(df, sin(3*t), t), une macro appelée df est créée et son contenu est: 3*cos(3*t), c’est une macro sans paramètre qui contient une variable locale t, elle devra donc être utilisée en développement immédiat (c’est à dire précédée du symbole ∖ )2. Par contre après la commande Diff(df,sin(3*t),t,t), le contenu de la macro df est: {3*cos(3*%1)} qui est une macro à un paramètre.
Echange( <variable1>, <variable2> ).
Description : cette fonction échange les deux variables, ce sont en fait les adresses qui sont échangées. Les contenus ne sont pas dupliqués alors qu’ils le seraient si on utilisait la commande:
+{ [aux:=variable1, variable1:=variable2, variable2:=aux]}
+La fonction Echange renvoie la valeur Nil.
EpsCoord( <affixe> )
Description : renvoie l’affixe exportée en eps. Pour les autres, il y a les macros TeXCoord et SvgCoord.
Eval( <expression> ).
Description : cette fonction évalue l’<expression> et renvoie le résultat. L’<expression> est interprétée comme une chaîne de caractères.
La fonction Input renvoie la saisie sous forme d’une chaîne dans la macro appelée chaine(). La fonction Eval évalue cette chaîne (comme n’importe quelle commande TeXgraph) et renvoie le résultat.
Exemple(s) : voici une commande demandant une valeur à l’utilisateur pour une variable x:
if Input("x=", "Entrez une valeur pour x", x )
+ then x:= Eval( chaine() )
+ fi
+Exec( <programme> [, argument(s), répertoire de travail, attendre] ).
Description : cette fonction permet d’exécuter un <programme> (ou un script) en précisant éventuellement des <arguments> et un <répertoire de travail>, ces trois arguments sont interprétés comme des chaînes de caractères. Le dernier argument doit valoir 0 (par défaut) ou 1, il indique si le programme attend ou non la fin du processus fils. La fonction renvoie la valeur Nil. Un message d’erreur s’affiche lorsque: les ressources sont insuffisantes, ou bien le programme est invalide, ou bien le chemin est invalide.
La macro-chaîne prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro Apercu exporte le graphique courant dans ce dossier au format pgf dans le fichier file.pgf, puis elle exécute pdflatex sur le fichier apercu.tex, puis attend la fin de l’exécution avant de lancer le lecteur de pdf.
Exemple(s) : la macro Apercu contenue dans interface.mac est:
[Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+Export( <mode>, <fichier> ).
Description : cette fonction permet d’exporter le graphique en cours, <mode> est une valeur numérique qui peut être l’une des constantes suivantes: tex, pst, pgf, tkz, eps, psf, pdf, epsc, pdfc, svg, bmp, obj, geom, jvx ou teg. L’exportation se fait dans <fichier> qui contient donc le nom du fichier, avec éventuellement le chemin.
+La macro prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro Apercu exporte le graphique courant dans ce dossier au format pgf dans le fichier file.pgf, puis elle exécute pdflatex sur le fichier apercu.tex, puis attend la fin de l’exécution avant de lancer le lecteur de pdf.
Exemple(s) : la macro Apercu contenue dans interface.mac est:
[Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+ExportObject( <argument> )
Description : cette commande n’a d’effet que pendant un export. Elle permet d’exporter l’<argument> dans le fichier de sortie, cet <argumet> est soit le nom d’un élément graphique, soit une commande graphique (comme pour la fonction Get). Elle peut-être utile pour écrire des exports personnalisés, ceci est décrit dans cette section.
Fenetre( <A>, <B> [, C] ).
Description : cette fonction modifie la fenêtre graphique, c’est l’équivalent de l’option Paramètres/Fenêtre, sauf que les éléments graphiques ne sont pas automatiquement recalculés. Le paramètre <A> et le paramètre <B> sont les affixes de deux coins de la fenêtre diamétralement opposés, et le paramètre facultatif <C> représente les deux échelles, plus précisément, la partie réelle de <C> est l’échelle [en cm] sur l’axe des abscisses et la partie imaginaire de <C> est l’échelle [en cm] sur l’axe des ordonnées, ces deux valeurs doivent être strictement positives. Cette fonction renvoie la valeur Nil.
Free( <expression>, <variable>.
Description : cette fonction renvoie 1 si l’<expression> contient la <variable>, 0 sinon. Lorsque le deuxième argument n’est pas un nom de variable, la fonction renvoie Nil.
Get( <argument> [, clip(0/1)] ).
Description : lorsque le paramètre <argument> est un identificateur, la fonction cherche s’il y a un élément graphique dont le nom est <argument>, si c’est le cas, alors la fonction renvoie la liste des points de cet élément graphique, sinon elle renvoie la valeur Nil. Dans ce cas l’argument optionnel est ignoré.
+Lorsque <argument> n’est pas un identificateur, celui-ci est considéré comme une fonction graphique, la fonction Get renvoie la liste des points de l’élément graphique construit par cette fonction graphique mais sans créer l’élément en question. L’argument optionnel <clip> (qui vaut 1 par défaut) indique si l’élément doit être clippé par la fenêtre courante (valeur 1) ou non (valeur 0).
+Lorsque l’argument est vide: Get(), la fonction renvoie la liste des points de tous les éléments graphiques déjà construits, ceux qui sont cachés sont ignorés.
Exemple(s) : Get(Cercle(0,1)) renvoie la liste des points du cercle de centre 0 et de rayon 1 mais sans créer ce cercle, la liste des points est clippée par la fenêtre graphique.
Exemple(s) : utilisation des points d’un objet graphique:
++++Cmd view(0,6.25,-1.5,2); size(7.5); [tMin:=0, tMax:=6.25]; Graph axe = Axes(0,1+i); C1 = [Color:=blue,Width:=8, Cartesienne(1/x) ]; C2 = [Color:=red,Width:=8, Cartesienne(sin(2*x)*1.5)]; inter = [DotScale:=2,DotStyle:=dotcircle, Color:=forestgreen, Point(Get(C1) InterL Get(C2)), Color:=blue, LabelDot(5.5+0.1*i,"C1","N"), Color:=red, LabelDot(3-i,"C2","E"), ];
+
GetAttr( <argument> )
Description : lorsque le paramètre <argument> est un identificateur, la fonction cherche s’il y a un élément graphique dont le nom est <argument>, si c’est le cas, alors les attributs de cet élément graphique deviennent les attributs courants, et la fonction renvoie la valeur Nil. Sinon, l’argument est interprété comme une chaîne de caractères puis la fonction effectue la même recherche.
GetMatrix()
Description : cette fonction renvoie la matrice courante. (Voir aussi les commandes ComposeMatrix, SetMatrix, et IdMatrix)
GetSpline(<V0>, <A0>,..., <An>, <Vn> )
Description : renvoie la liste des points de contrôle correspondant à la spline cubique passant par les points <A0> jusqu’à <An>. <V0> et <Vn> désignent les vecteurs vitesses aux extrémités [contraintes], si l’un d’eux est nul alors l’extrémité correspondante est considérée comme libre (sans contrainte). Le résultat doit être dessiné avec la commande graphique Bezier.
GrayScale(0/1) ou GrayScale().
Description : cette fonction permet d’activer ou désactiver la conversion des couleurs en niveaux de gris. Elle équivaut à l’option Paramètres/Gérer les couleurs du menu de l’interface graphique.
+Lorsque l’argument est vide, la fonction renvoie l’état actuel de la conversion en niveaux de gris (0 ou 1). Sinon, elle renvoie Nil.
HexaColor( <valeur héxadécimale> )
Description : cette fonction renvoie la couleur correspondant à la <valeur héxadécimale>, cette valeur doit être passée sous forme d’une chaîne de caractères. Voir aussi la commande Rgb.
Exemple(s) : Color:=HexaColor("F5F5DC").
Hide( <element1>, ..., <elementN> )
Description : Cette fonction permet de cacher les éléments graphiques appelés <element1>, ..., <elementN> en mettant leur attribut IsVisible à false. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil.
+Pour tout cacher on invoque la commande sans arguments: Hide().
+Pour tout cacher sauf un ou plusieurs éléments, on invoque la commande: Hide(except, element1, ..., elementN). Voir aussi la commande Show.
IdMatrix()
Description : change la matrice courante en la matrice identité. (Voir aussi les commandes ComposeMatrix, SetMatrix, et GetMatrix)
Input( <message> [, titre, chaîne] ).
Description : cette fonction ouvre une boite de dialogue avec <titre> dans la barre de titre (par défaut le titre est vide), et dans laquelle le paramètre <message> est affiché, le paramètre <chaîne> est affiché dans la zone de saisie. Ces paramètres sont donc interprétés comme des chaînes de caractères, l’utilisateur est invité à faire une saisie. S’il valide alors la fonction Input renvoie la valeur 1 et la chaîne saisie est mémorisée dans la macro chaine(). Si l’utilisateur ne valide pas ou si la chaîne saisie est vide, alors la fonction Input renvoie la valeur 0.
Exemple(s) : voir la fonction Eval.
InputMac( <nom de fichier> ) ou Load( <nom de fichier> ).
Description : cette fonction permet de charger en mémoire un fichier de macros (*.mac), ou un fichier modèle (*.mod), ou tout fichier source texgraph (*.teg).
+Dans le premier cas (fichier *.mac), les variables globales et les macros seront considérées comme prédéfinies (elles n’apparaissent pas à l’écran, elles ne seront pas enregistrées avec le graphique, mais elles sont effacées de la mémoire dès qu’on commence un nouveau graphique). Le paramètre <nom de fichier> est une chaîne de caractères représentant le fichier à charger avec éventuellement son chemin. Cette fonction renvoie Nil, et si ce fichier était déjà chargé, alors elle est sans effet. Si le fichier à charger est dans le répertoire macros de TeXgraph, ou dans le dossier TeXgraphMac, alors il est inutile de préciser le chemin.
Exemple(s) : InputMac("MesMacros.mac").
Inc( <variable>, <expression> ).
Description : cette fonction évalue <expression> et ajoute le résultat à <variable>. Cette fonction est plus avantageuse que la commande variable := variable + expression, car dans cette commande la <variable> est évaluée [c’est à dire dupliquée] pour calculer la somme. La fonction Inc renvoie la valeur Nil.
Insert( <liste1>, <liste2> [, position] ).
Description : cette fonction insère la <liste2> dans la <liste1> à la position numéro <position>. Lorsque la position vaut 0 [valeur par défaut]. La <liste2> est ajoutée à la fin. La <liste1> doit être une variable et celle-ci est modifiée. La fonction Insert renvoie la valeur Nil.
Exemple(s) : si une variable L contient la liste [1,4,5], alors après la commande Insert(L,[2,3],2), la variable L contiendra la liste [1,2,3,4,5].
Int( <expression>, <variable>, <borne inf.>, <borne sup.> ).
Description : cette fonction calcule l’intégrale de <expression> par rapport à <variable> sur l’intervalle réel défini par <borne inf.> et <borne sup>. Le calcul est fait à partir de la méthode de {Simpson} accélérée deux fois avec la méthode de {Romberg}, <expression> est supposée définie et suffisamment régulière sur l’intervalle d’intégration.
Exemple(s) : Int(exp(sin(u)),u,0,1) donne 1.63187 (Maple donne 1.631869608).
IsMac( <nom> ).
Description : cette fonction permet de savoir s’il y a une macro appellée <nom>. Elle renvoie 1 si c’est le cas, 0 sinon.
IsVar( <nom> ).
Description : cette fonction permet de savoir s’il y a une variable globale appellée <nom>. Elle renvoie 1 si c’est le cas, 0 sinon.
Liste( <argument1>, ..., <argumentn> ) ou bien [<argument1>, ..., <argumentn>].
Description : cette fonction évalue chaque argument et renvoie la liste des résultats différents de Nil.
Exemple(s) : Liste(1, Arg(1+2*i), sqrt(-1), Solve(cos(x)-x,x,0,1)) renvoie le résultat [1,1.107149,0.739085].
ListFiles().
Description : cette fonction est disponible seulement dans la version GUI de TeXgraph, elle s’utilise dans la barre de commande en bas de la fenêtre, elle affiche alors la liste des fichiers de macros (*.mac) chargés en mémoire.
LoadImage( <image> ).
Description : cette fonction charge le fichier <image>, qui doit être une image png, jpeg ou bmp. Celle-ci est affichée en image de fond et fait partie du graphique, en particulier elle est exportée dans les formats tex (visible seulement dans la version postscript), pgf, pst et teg. Pour le format pgf c’est la version png ou jpg qui sera dans le document, mais pour les versions pst et tex il faut une version eps de l’image. L’argument est interprêté comme une chaîne de caractères, et la fonction renvoie la valeur Nil.
+Lors du chargement, la taille de l’image est adaptée à la fenêtre, mais celle-ci peut être modifiée de manière à conserver les proportions de l’image. Dès lors la position de l’image et sa taille sont fixées. On peut ensuite élargir 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 faut recharger celle-ci.
Loop( <expression>, <condition> ).
Description : cette fonction est une boucle qui construit une liste en évaluant <expression> et <condition> jusqu’à ce que le résultat de <condition> soit égal à 1 (pour True) ou Nil, la fonction Loop renvoie alors la liste des résultats de <expression>. Cette commande est la représentation interne de la boucle repeat dont l’utilisation est préférable pour des raisons de lisibilité.
Exemple(s) : les commandes (équivalentes):
+ou encore
+ou encore
+renvoient la liste: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] (termes d’une suite de {Fibonacci} inférieurs à 100).
Map( <expression>, <variable>, <liste> [, mode] ).
Description : cette fonction est une boucle qui construit une liste de la manière suivante: <variable> parcourt les éléments de <liste> et pour chacun d’eux <expression> est évaluée, la fonction Map renvoie la liste des résultats. Cette commande est la représentation interne de la boucle for dont l’utilisation est préférable pour des raisons de lisibilité.
+Le paramètre optionnel <mode> est un complexe qui vaut Nil par défaut, lorsque <mode> = a + ib, alors:
+si a est un entier et b = 0: les éléments de la <liste> sont traités de a en a,
si a est un entier et b = 1: la <liste> est traitée par composante (deux composantes sont séparées par la constante jump) et les éléments de chaque composante sont traités par paquets complets de a éléments, lorsque 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 traité.
si a est un entier et b = - 1: la <liste> est traitée par composante (deux composantes sont séparées par la constante jump) et les éléments de chaque composante sont traités par paquets complets de a éléments, lorsque la constante jump est rencontrée dans la liste, celle-ci n’est pas renvoyée dans le résultat. Un paquet non complet n’est pas traité.
si a = Re(jump): la <liste> est traitée par composante (deux composantes sont séparées par la constante jump), lorsque la constante jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat si b = 1 et n’est pas renvoyée si b = - 1.
Exemple(s) : voir la boucle for pour des exemples.
Exemple(s) : si L est une variable contenant une liste de points, alors la commande:
+[sum:=0, Map( Inc(sum,z), z, L), sum] renvoie la somme des éléments de L.
la commande Map(z*exp(i*π/3), z, L) renvoie la liste des images des points de L par la rotation de centre O d’angle π/3.
Marges( <gauche>, <droite>, <haut>, <bas> )
Description : cette fonction permet de fixer les marges autour du dessin (en cm). Les nouvelles valeurs sont copiées dans les constantes margeG, margeD, margeH et margeB.
Merge( <liste> ).
Description : cette fonction permet de recoller des morceaux de listes pour avoir des composantes de longeur maximale, elle renvoie la liste qui en résulte.
Exemple(s) : Merge([1, 2, jump, 3, 5, jump, 3, 4, 2] ) renvoie [1, 2, 3, 4, 5]. Et Merge( [1, 2, jump, 3, 5, jump, 3, 4] ) renvoie [1, 2, jump, 4, 3, 5].
+Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine.
Message( <chaîne> ).
Description : cette fonction affiche le paramètre <chaîne>[qui est donc interprété comme une chaîne de caractères] dans une fenêtre. Quand l’utilisateur a cliqué sur OK, la fenêtre se referme et la fonction renvoie la valeur Nil.
Move( <element1>, ..., <elementN> ).
Description : cette fonction ne s’applique qu’aux éléments graphiques créés en mode NotXor, ce qui correspond à la valeur 1 de la variable PenMode. Elle redessine les éléments graphiques <element1>, ..., <elementN>, puis les recalcule, puis les redessine, et elle renvoie la valeur Nil.
+Lorsqu’on redessine un élément graphique créé en mode NotXor, il s’efface en restituant le fond, on peut alors modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres (ce qui évite d’avoir une image qui saute).
Exemple(s) : voir la fonction Stroke.
Mtransform( <liste>, <matrice> ).
Description : cette fonction applique la <matrice> à la <liste> et renvoie le résultat. Si la <liste> contient la constante jump, celle-ci est renvoyée dans le résultat sans être modifiée. La <matrice> représente l’expression analytique d’une application affine du plan, c’est une liste de trois complexes [z1, z2, z3]: z1 est l’affixe du vecteur de translation, z2 est l’affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et z3 est l’affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l’identité s’écrit ainsi: [0,1,i] (c’est la matrice par défaut).
MyExport( <"nom">, <paramètre 1>, ..., <paramètre n> ) ou draw( <"nom">, <paramètre 1>, ..., <paramètre n> )
Description : cette commande permet d’ajouter de nouveaux éléments graphiques avec un export personnalisé. Elle est décrite dans cette section.
Nargs().
Description : cette fonction n’a d’effet que dans une macro, elle renvoie le nombre d’arguments avec lesquels la macro a été appelée. Hors de ce contexte, elle renvoie la valeur Nil. Voir aussi la fonction Args.
Exemple(s) : voici le corps d’une macro MyLabel(affixe1, texte1, affixe2, texte2, ...) prenant un nombre indéterminé d’arguments:
for $k from 1 to Nargs()/2 do
+ Label(Args(2*k-1), Args(2*k))
+ od
+NewButton( <Id>, <nom>, <affixe>, <taille>, <commande> [, aide] ).
Description : cette fonction crée dans la zone grisée à gauche dans la fenêtre un bouton dont le numéro d’identification est l’entier <Id>, le texte figurant sur le bouton est le paramètre <nom> qui est donc interprété comme une chaîne de caractères, la position du coin supérieur gauche est donnée par le paramètre <affixe> qui doit être de la forme X+i*Y avec X et Y entiers car ce sont des coordonnées en pixels, la taille du bouton est donnée par le paramètre <taille> qui doit être de la forme long+i*haut où long désigne la longueur du bouton en pixels et haut la hauteur (ce sont donc des entiers), le paramètre <commande> est interprété comme une chaîne de caractères, c’est la commande associée au bouton, chaque clic provoquera l’exécution de cette commande. Le dernier paramètre <aide> est facultatif, il contient le message de la bulle d’aide s’affichant lorsque la souris passe au-dessus du bouton.
+Si on crée un bouton dont le numéro d’identification est déjà pris, alors l’ancien bouton est détruit sauf si c’est un bouton prédéfini (c’est à dire créé au démarrage). À chaque changement de fichier, les boutons non prédéfinis sont détruits. La fonction NewButton renvoie la valeur Nil.
NewGraph( <chaîne1>, <chaîne2> [, code] ).
Description : cette fonction crée un élément graphique Utilisateur ayant pour nom: <chaîne1> et défini par la commande: <chaîne2>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil. S’il existait déjà un élément graphique portant le même nom, alors celui-ci est écrasé. L’élément graphique est créé mais non dessiné, c’est la fonction ReDraw() qui permet de mettre l’affichage à jour.
+Le troisième paramètre <code> est un entier positif (optionnel), un clic gauche avec la souris sur l’élément graphique créé dans la liste des éléments graphiques, provoquera l’exécution de la macro spéciale ClicGraph( <code> ), cette macro n’existe pas par défaut et peut-être créée par l’utilisateur, elle est utilisée en particulier dans le fichier modèle Mouse.mod (dessin à la souris).
Supposons que l’utilisateur clique sur le point d’affixe 1+i, alors une fenêtre de dialogue s’ouvre avec le message Label= et une ligne de saisie à remplir. Supposons que l’utilisateur entre la chaîne Test et valide, alors la macro va créer un élément graphique utilisateur portant le nom Label1 et défini par la commande Label(1+i,"Test").
On peut aussi utiliser la macro prédéfinie NewLabel et définir la macro ClicG() en écrivant simplement: {NewLabel(%1) }.
Exemple(s) : voici une macro ClicG() permettant la création "à la volée" de labels, on a créé auparavant une variable globale num initialisée à 1:
if Input("Label=")
+ then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ),
+ ReDraw(), Inc(num,1)
+ fi
+NewItem( <nom>, <commande> ).
Description : cette fonction ajoute dans la liste déroulante de la zone grisée à gauche dans la fenêtre, un item appelé <nom>, le deuxième paramètre <commande> est la commande associée à l’item, chaque sélection de l’item provoquera l’exécution de cette commande. Les deux arguments sont interprétés comme des chaînes de caractères. S’il existe déjà un item portant le même nom, alors l’ancien est détruit sauf si c’est un item prédéfini (c’est à dire créé au démarrage). À chaque changement de fichier, les items non prédéfinis sont détruits. La fonction NewItem renvoie la valeur Nil.
NewMac( <nom>, <corps> [, param1, …, paramN]).
Description : cette fonction crée une macro appelée <nom> et dont le contenu est <corps>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Les paramètres optionnels sont des noms de variables, le nom de la variable <param1> est remplacé dans l’expression de la macro par le paramètre %1, le nom <param2> est remplacé par %2 … etc. Cette fonction renvoie la valeur Nil. S’il existait déjà une macro portant le même nom, alors celui-ci est écrasée si elle n’est pas prédéfinie. Si le nom n’est pas valide, ou s’il y a déjà une macro prédéfinie portant ce nom, ou si l’expression <corps> n’est pas correcte, alors la fonction est sans effet.
NewVar( <nom>, <expression> ).
Description : cette fonction crée une variable globale appelée <nom> et dont la valeur est <expression>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil. S’il 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à une constante portant ce nom, alors la fonction est sans effet. Si <expression> n’est pas correcte, alors la valeur affectée à la variable sera Nil.
Nops( <liste> ).
Description : cette fonction évalue <liste> et renvoie le nombre de complexes qui la composent.
Exemple(s) : Nops([1,2,3] ) renvoie la valeur 3.
NotXor( <element1>, ..., <elementN> ).
Description : cette fonction ne s’applique qu’aux éléments graphiques créés en mode normal, ce qui correspond à la valeur 0 de la variable PenMode. Elle change le mode des éléments graphiques <element1>, ..., <elementN> en mode NotXor puis les recalcule, et elle renvoie la valeur Nil.
+Lorsqu’on redessine un élément graphique qui est en mode NotXor, il s’efface en restituant le fond, on peut alors modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres (ce qui évite d’avoir une image qui saute).
Exemple(s) : voir la fonction Move.
OpenFile( <nom fichier> ).
Description : cette fonction permet d’ouvrir un fichier texte en écriture. ATTENTION: s’il existe un fichier du même nom, alors celui-ci sera écrasé.
+En combinaison avec les commandes WriteFile et CloseFile, cela permet à l’utilisateur de créer ses propres fichiers textes.
OriginalCoord( <0/1> ) ou OriginalCoord()
Description : cette fonction détermine si le repère à l’exportation en pstricks et tikz/pgf est identique à celui de l’écran (ce qui correspond à la valeur 1 de l’argument, valeur par défaut), ou non. Lorsque la valeur de l’argument est nulle, le repère à l’exportation (pstricks et tikz/pgf) aura son origine en 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 valeurs numériques ne sont plus acceptées par .
+Lorsque l’argument vaut 1, les coordonnées des points dans le fichier exporté sont les mêmes qu’à l’écran.
+Lorsque l’argument vaut 0, les coordonnées dans le fichier exporté (tex, pst, tikz/pgf) du point d’affixe z à l’écran, sont x=Re(TexCoord(z)) et y=Im(TeXCoord(z)) (et EpsCoord à la place de TeXCoord pour l’export eps).
+Lorsque l’argument est vide, la fonction renvoie l’état actuel du repère à l’exportation (0 ou 1). Sinon, elle renvoie la valeur Nil.
PermuteWith( <liste d’index>, <liste à permuter>, [, taille des paquets ou jump] )
Description : la <liste à permuter> doit être une variable, celle-ci sera permutée selon le <liste d’index> qui est une liste d’entiers strictement positifs. La <liste à permuter> est traitée par composante si elle contient la constante jump, et les éléments de chaque composante sont traités par paquets (de 1 par défaut) ou par composante entière (une composante se termine par jump), la liste est donc modifiée.
Exemple(s) : :
+[L:=[-1,0,3,5], PermuteWith([4,3,2,1], L), L] renvoie [5,3,0,-1].
[L:=[-1,0,3,5], PermuteWith([4,3,4,1], L), L] renvoie [5,3,5,-1].
[L:=[-1,0,3,5,6,7,8], PermuteWith([4,3,2,1], L, 2), L] renvoie [6,7,3,5,-1,0].
[L:=[-1,jump,0,3,jump,5,6,7,jump,8,jump], PermuteWith( [4,3,3,1,2], L, jump), L] renvoie [8,jump,5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump].
[L:=[-1,jump,0,3,jump,5,6,7,jump,8], PermuteWith([4,3,3,1,2], L, jump), L] renvoie [5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump].
[L:=[-1,1,5,jump,0,3,jump,5,6,7,jump,8,9], PermuteWith( [2,1], L), L] renvoie [1,-1,jump,3,0,jump,6,5,jump,9,8].
ReadData( <fichier> [, type de lecture, séparateur] ).
Description : cette fonction ouvre un <fichier> texte en lecture, celui-ci est supposé contenir une ou plusieurs listes de valeurs numériques. Le premier argument est interprété comme une chaîne de caractères qui contient le nom du fichier (plus éventuellement son chemin). L’argument (optionnel) suivant <type de lecture> est une valeur numérique qui peut valoir:
+<type de lecture>=1: la fonction lit le fichier réel par réel et renvoie la liste ou les listes lues: [x1, x2, ...],
<type de lecture>=2: La fonction lit le fichier complexe par complexe, c’est à dire par paquets de deux réels et renvoie la ou les listes lues sous forme d’affixes: [x1+i*x2, x3+i*x4, ...]. C’est la valeur par défaut,
<type de lecture>=3: La fonction lit le fichier par paquet de 3 réels (points de l’espace ou point3D) et renvoie la ou les listes lues sous la forme: [x1+i*x2, x3, x4+i*x5, x6, ...].
Le troisième argument <séparateur>, est interprété comme une chaîne, il est supposé contenir le caractère servant à indiquer la fin de liste, entre deux listes la constante jump sera insérée, cet argument est facultatif et par défaut 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 fichier, on utilisera la chaîne "LF" (line feed) en troisième paramètre. Lorsqu’il y a un séparateur et lorsque la lecture se fait par paquet de 2 ou 3 réels, un paquet non øg complet est ignoré.
Exemple(s) : supposons qu’un fichier texte test.dat contienne exactement ceci:
+1 2 3 4 5/ 6
+7 8 9 10 11/ 12
+13 14 15 16 17/ 18
+alors l’exécution de:
+ReadData("test.dat") donne: [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],
ReadData("test.dat",1,"/") donne: [1,2,3,4,5,jump,6,7,8,9,10,11,jump,12,13,14,15,16,17,jump,18],
ReadData("test.dat",2,"/") donne: [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],
ReadData("test.dat",3,"/") donne: [1+2*i,3,jump,6+7*i,8,9+10*i,11,jump,12+13*i,14,15+16*i,17,jump],
ReadData("test.dat",3,"LF") donne: [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].
ReadFlatPs( <fichier> ).
Description : cette fonction ouvre un <fichier> en lecture, celui-ci est censé être un fichier écrit en flattened postscript. La fonction renvoie la liste des chemins contenus dans le fichier, le premier complexe de la liste est largeur+i*hauteur en cm, puis le premier complexe de chaque chemin est Color+i*Width. Chaque chemin se termine par un jump dont la partie imaginaire est un enter négatif: - 1 pour eofill, - 2 pour fill, - 3 pour stroke et - 4 pour clip.
+Il est possible de transformer un fichier pdf ou un fichier postscript en flattened postscript grâce à l’utilitaire pstoedit (http://www.pstoedit.net/). La macro conv2FlatPs permet cette conversion en supposant que l’utilitaire est installé sur votre système.
La fonction ReadFlatPs est surtout utilisée en interne par la macro loadFlatPs qui en plus du chargement, adpate les coordonnées des points avant de renvoyer à son tour la liste des chemins que l’on peut alors dessiner avec la macro drawFlatPs.
+Ce système est utilisé par la macro NewTeXLabel pour récupérer les formules TeX compilées.
ReCalc( <nom1>, ..., <nomN> ) ou ReCalc().
Description : cette fonction force le recalcul des éléments graphiques dont les noms sont dans la liste même si ceux-ci ne sont pas en mode Recalcul Automatique. Si la liste est vide (ReCalc()) alors tout le graphique est recalculé. Après le recalcul l’affichage est mis à jour et la fonction renvoie Nil.
Attention: l’utilisation de ReCalc() dans un élément graphique entraîne une récursion infinie et donc un plantage du programme!
+ReDraw( <nom1>, ..., <nomN> ) ou ReDraw().
Description : cette fonction (re)dessine les éléments graphiques dont les noms sont dans la liste. Si la liste est vide (ReDraw()) alors tous les élments sont redessinés. Cette fonction renvoie la valeur Nil.
RenCommand( <nom>, <nouveau> ).
Description : cette fonction renomme la commande appelée <nom>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil. Si le <nom> n’est pas valide, ou s’il n’y a pas de commande portant ce <nom>, ou s’il a déjà une commande portant le nom <nouveau>, alors la fonction est sans effet.
RenMac( <nom>, <nouveau> ).
Description : cette fonction renomme la macro appelée <nom>. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil. Si le <nom> n’est pas valide, ou s’il n’y a pas de macro portant ce <nom>, ou s’il a déjà une macro portant le nom <nouveau>, alors la fonction est sans effet.
RestoreAttr().
Description : restaure l’ensemble des attributs sauvegardés dans une pile par la commande SaveAttr.
Reverse( <liste> ).
Description : renvoie la <liste> inversée.
Rgb( <rouge>, <vert>, <bleu> ).
Description : cette fonction renvoie un entier représentant la couleur dont les trois composantes sont <rouge>, <vert> et <bleu>, ces trois valeurs doivent être des nombres compris entre 0 et 1. Voir aussi la commande HexaColor.
Exemple(s) : Color:= Rgb(0.5,0.5,0.5)) sélectionne le gris.
SaveAttr().
Description : sauvegarde sur une pile l’ensemble des attributs courants. Voir aussi RestoreAttr.
Seq( <expression>, <variable>, <départ>, <fin> [, pas] ).
Description : cette fonction est une boucle qui construit une liste de la manière suivante: <variable> est initialisée à <départ> puis, tant que <variable> est dans l’intervalle (fermé) défini par <départ> et <fin>, on évalue <expression> et on incrémente <variable> de la valeur de <pas>. Le pas peut être négatif mais il doit être non nul. Lorsqu’il n’est pas spécifié, sa valeur par défaut est 1. Lorsque <variable> sort de l’intervalle, la boucle s’arrête et la fonction Seq renvoie la liste des résultats. Cette commande est la représentation interne de la boucle for dont l’utilisation est préférable pour des raisons de lisibilité.
Exemple(s) : Seq(exp(i*k*pi/5,k,1,5) renvoie la liste des racines cinquièmes de l’unité. La commande:
+renverra la valeur Nil mais dessinera un pentagone (voir Ligne) si elle est utilisée dans un élément graphique utilisateur.
Set( <variable>, <valeur> ).
Description : cette fonction permet d’affecter à <variable>3 la <valeur> spécifiée. La fonction Set renvoie la valeur Nil.
+Cette commande est la représentation interne de l’affectation :=, dont l’utilisation est préférable pour des raisons de lisibilité.
SetAttr().
Description : cette fonction n’a d’effet que dans un élément graphique Utilisateur. Elle permet d’affecter aux attributs de l’élément la valeur des attributs actuellement en cours. La fonction SetAttr renvoie la valeur Nil.
SetMatrix( <[z1, z2, z3]> ).
Description : cette fonction permet de modifier la matrice courante (celle-ci affecte tous les éléments graphiques sauf les axes et les grilles dans la version actuelle). Cette matrice représente l’expression analytique d’une application affine du plan, c’est une liste de trois complexes: z1 qui est l’affixe du vecteur de translation, z2 qui est 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 deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l’identité s’écrit ainsi: [0,1,i] (c’est la matrice par défaut). (Voir aussi les commandes GetMatrix, ComposeMatrix, et IdMatrix)
Exemple(s) : si f: z ↦ f(z) est une application affine, alors sa matrice est [f(0), f(1) - f(0), f(i) - f(0)], ce calcul peut-être fait par la macro matrix() de TeXgraph.mac: SetMatrix(matrix(i*bar(z))) affecte la matrice de la symétrie orthogonale par rapport à la première bissectrice.
++++view(-5,5,-3,3), size(7.5), SetMatrix([0,1,1+i]), axes(0,1+i), tMin:=-5, tMax:=5, Color:=red, Width:=8, Cartesienne(2*sin(x)), Color:=black, Arrows:=2, tangente(2*sin(x), pi/2, 1.5), Arrows:=0, LineStyle:=dotted, Ligne( [2*i,pi/2+2*i, pi/2], 0), Point(pi/2+2*i), LabelDot( pi/2, "$\frac{\pi}2$","S",1), IdMatrix()
+
Show( <element1>, ..., <elementN> ).
Description : Cette fonction permet de montrer les éléments graphiques appelés <element1>, ..., <elementN> en mettant leur attribut IsVisible à true. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur Nil. Pour tout montrer on invoque la commande sans arguments: Show(). Pour tout montrer sauf un ou plusieurs éléments, on invoque la commande: Show(except, element1, ..., elementN). Voir aussi la commande Hide.
Si( <condition1>, <expression1>, ..., <conditionN>, <expressionN> [, sinon] ).
Description : cette fonction évalue <condition1>. Une condition est une expression dont le résultat de l’évaluation doit être 0 [pour False] ou 1 [pour True], sinon il y a un échec et la fonction renvoie la valeur Nil. Si la condition donne la valeur 1 alors la fonction évalue <expression1> et renvoie le résultat, si elle vaut 0, elle évalue <condition2>, si celle-ci donne la valeur 1 alors la fonction évalue <expression2>, sinon etc... Lorsqu’aucune condition n’est remplie, la fonction évalue l’argument <sinon>, s’il est présent, et renvoie le résultat, sinon la fonction renvoie Nil. Cette commande est la représentation interne de l’alternative if dont la syntaxe est préférable pour des raisons de lisibilité.
Exemple(s) : définition d’une macro f(x) représentant une fonction f d’une variable x définie en plusieurs morceaux:
+c’est à dire f(x) = 1 - exp(π(x + 1)) si x < - 1, f(x) = sin(πx) si - 1 ≤ x < 0, f(x) = sh(πx) sinon.
Solve( <expression>, <variable>, <borne inf.>, <borne sup.> [, n] ).
Description : cette fonction "résout" l’équation <expression>=0 par rapport à la variable réelle <variable> dans l’intervalle défini par <borne inf.> et <borne sup.>. Cet intervalle est subdivisé en <n> parties [par défaut n=25] et on utilise la méthode de { Newton} sur chaque partie. La fonction renvoie la liste des résultats.
Exemple(s) :
+Solve(sin(x), x, -5, 5) donne [-3.141593, 0, 3.141593].
Équation: $\displaystyle \int_0^x \exp(t^2)dt=1$: Solve(Int( exp(u^2),u,0,x)-1, x, 0, 1) donne 0.795172 et l’exécution de Int(exp(u^2), u, 0, 0.795172) donne 1.
Solve( x2 + x + 1, x, -1, 1) renvoie Nil.
Sort( <liste de complexes> [, option] ).
Description : cette fonction trie la liste passée en argument dans l’ordre lexicographique, si l’argument <option> vaut 0 (valeur par défaut), ou dans l’ordre lexicographique inverse si l’argument <option> vaut 1. Cette liste doit être une variable, et celle-ci sera modifiée. Si la liste contient la constante jump alors celle-ci est recopiée telle quelle dans le résultat, et les øg composantes connexes de la liste sont triées indépendamment les unes des autres. La fonction renvoie la valeur Nil.
Exemple(s) : si la variable L contient la liste [-2,-3+i,1,1-2*i, jump, 3,5,-6] alors après l’exécution de Sort(L), la variable contiendra la liste [-3+i,-2,1-2*i,1,jump,-6,3,5], et après l’exécution de Sort(L,1), la variable contiendra la liste [1,1-2*i,-2,-3+i,jump,5,3,-6]. La méthode utilisée est le Quick Sort..
Special( <chaîne> ).
Description : cette fonction n’aura d’effet que dans un élément graphique Utilisateur (comme les fonctions graphiques). L’argument doit être une chaîne de caractères (délimitée par " et "), si cette chaîne contient les balises \[, et \], alors tout le texte contenu entre ces deux balises est interprété par TeXgraph et le résultat est replacé dans la chaîne. Puis cette chaîne sera écrite telle quelle dans le fichier d’exportation (c’est en fait un Label créé avec LabelStyle= special).
Exemple(s) : Special("\psdot(\[1+\],\[2^3\] )"), écrira dans le fichier exporté: \psdot(2,8).
Str( <nom de macro> ).
Description : lors d’une évaluation alphanumérique, cette fonction renvoie la définition de la macro appelée <nom de macro> (sauf si c’est une macro prédéfinie). En dehors de ce contexte, la fonction Str renvoie Nil. L’argument <nom de macro> est lui-même interprété comme une chaîne de caractères.
Exemple(s) : supposons que la macro f soit définie par {%1+i*sin(%1)}, alors la commande {Label(0,["f(%1)=",Str("f")] )} affichera à l’écran à l’affixe 0, le texte: {f(%1)=%1+i*sin(%1)}.
StrArgs( <entier> ).
Description : cette fonction n’a d’effet que dans une macro, elle renvoie l’argument numéro <entier> avec lequel la macro a été appelée, sous forme d’une chaîne. Hors de ce contexte, elle renvoie la valeur Nil. Voir également la commande Args
Exemple(s) : Voir la fonction Nargs.
StrComp( <chaîne1>, <chaîne2> ).
Description : les deux arguments sont interprétés comme une chaîne de caractères, et les deux chaînes sont comparées, si elles sont égales alors la fonction renvoie la valeur 1, sinon la valeur 0.
Exemple(s) : la combinaison de touches: Ctrl+Maj+<lettre> lance automatiquement l’exécution de la macro spéciale: OnKey( <lettre> ). L’utilisateur peut définir cette macro avec par exemple la commande:
+String( <expression mathématique> ).
Description : lors d’une évaluation alphanumérique, cette fonction renvoie <expression mathématique> sous forme d’une chaîne. En dehors de ce contexte, la fonction String renvoie Nil.
Stroke( <element1>, ..., <elementN> ).
Description : cette fonction recalcule les éléments graphiques <element1>, ..., <elementN>, puis les redéssine en mode NORMAL, et renvoie la valeur Nil.
Exemple(s) : on a créé deux variables globales: a et drawing. On va créer le cercle de centre a et de rayon 1, appelé objet1, on souhaite pouvoir déplacer cet objet à la souris. Pour cela, on crée la macro ClicG avec la commande:
[PenMode:=1, {mode NotXor}
+ NewGraph("objet1", "Cercle(a,1)"),
+ PenMode:=0, {mode normal}
+ ReDraw(), {on montre}
+ drawing:=1]
+on crée la macro MouseMove avec la commande: if drawing then a:=,
+puis la macro LButtonUp avec la commande: if drawing then Stroke(objet1), drawing:=0 fi.
+La macro ClicG crée l’objet1 en mode NotXor, rafraîchit l’affichage graphique et passe en mode "dessin". La macro MouseMove permet de placer le centre à la position de la souris, puis de déplacer l’objet1. Lorsque le bouton gauche est relâché, on dessine l’objet1 en mode normal, puis on quitte le mode "dessin".
+TeX2FlatPs( <"formule"> [, dollar(0/1)] ).
Description : cette renvoie une <formule> {} sous forme d’une liste de chemins, le résultat doit être dessiné avec la macro drawFlatPs. La <formule> est écrite dans un fichier appelé formula.tex. Ce fichier est appelé par le fichier formule.tex qui se trouve dans le dossier de travail de TeXgraph, pour être compilé par {}. Si l’option <dollar> vaut 1 alors la formule sera délimitée par \] et \], sinon elle est écrite telle quelle. Pour plus de renseignements sur la façon dont sont récupérés ces chemins, voir la commande ReadFlatPs.
Timer( <milli-secondes> ).
Description : règle l’intervalle de temps pour le timer, celui exécute régulièrement une certaine macro (que l’on peut définir avec la commande TimerMac). Pour stopper le timer il suffit de régler l’intervalle de temps à 0.
TimerMac( <corps de la macro à exécuter> ).
Description : cette commande permet de créer une macro qui sera attachée au timer. L’argument est interprété comme une chaîne de caractères et doit correspondre au corps de la macro (celle-ci sera appélée TimerMac). Pour des raisons de performances, il est préférable d’éviter trop d’appels à d’autres macros dans celle-ci. Cette fonction renvoie la valeur 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! Il faut utiliser la commande Timer pour cela.
Exemple(s) : soit A une variable globale (un point), soit dotA un élément graphique qui dessine le point, voilà une commande qui déplace A:
+VisibleGraph( <0/1> ) ou VisibleGraph().
Description : cette fonction permet d’activer ou désactiver la zone de dessin dans l’interface graphique. Lorsque 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 graphique peut permettre dans certains cas un gain de temps pour enregistrer une animation par exemple.
+Lorsque l’argument est vide, la fonction renvoie simplement l’état actuel de l’affichage graphique (0 ou 1). Sinon, elle renvoie Nil.
WriteFile( <argument> ).
Description : cette fonction permet d’écrire soit dans le fichier texte ouvert par la commande OpenFile, soit dans le fichier d’exportation si l’exécution de cette commande a lieu pendant une exportation par l’intermédiare des macros Bsave et/ou Esave.
Exemple(s) : voici ce que pourrait être la macro Bsave pour modifier la taille des flêches en pstricks:
if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi
+C’est la première occurrence de <variable> dans <expression> qui est assignée, car toutes les occurrences pointent sur la même <case mémoire>, sauf éventuellement pour les macros après l’affectation des paramètres. ↩
Si par exemple on veut tracer la courbe représentative de cette fonction, dans l’option Courbe/Paramétrée, il faudra saisir la commande t+i* ∖ df et non pas t+i*df(t). ↩
Il n’est pas nécessaire de déclarer les variables, elles sont implicitement locales et initialisées à Nil sauf si c’est le nom d’une variable globale ou d’une constante prédéfinie (comme i, π, e, ...). ↩