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, ...). ↩
Ceil( <x> ).
Description : renvoie le plus petit entier supérieur ou égal au réel <x>.
div( <x>, <y> ).
Description : renvoie l’unique entier k tel que x - ky soit dans l’intervalle [0; ∣y∣[.
mod( <x>, <y> ).
Description : renvoie l’unique réel r de l’intervalle [0; ∣y∣[ tel que x = ky + r avec k entier.
not( <expression booléenne> )
Description : renvoie la valeur booléenne de la négation.
pgcd( <a>, <b> [, <u>, <v>] )
Description : renvoie la valeur d du pgcd de <a> et <b>, ainsi que deux coefficients de Bezout dans les variables <u> et <v> (si celles-ci sont présentes), de telle sorte que au + bv = d.
ppcm( <a>, <b> )
Description : renvoie la valeur du ppcm de <a> et <b>.
Abs( <affixe> ).
Description : cette macro donne la norme en cm.
free( <x> ).
Description : libère la variable <x> en la mettant à Nil. Depuis la version 1.93 on peut faire directement l’affectation à la constante Nil, par exemple: x:=Nil.
IsIn( <affixe> [, <epsilon>] ).
Description : renvoie 1 si l’<affixe> est dans la fenêtre graphique, 0 sinon. Cette macro tient compte de la matrice courante, le test se fait à <epsilon> près et <epsilon> vaut 0.0001 cm par défaut.
nil( <x> ).
Description : renvoie 1 si la variable <x> est à Nil, 0 sinon. Depuis la version 1.93 on peut faire directement le test d’égalité avec la constante Nil.
round( <liste> [, décimales] )
Description : tronque les complexes de la <liste> en arrondissant au plus proche les parties réelles et imaginaires avec le nombre de <décimales> demandé (0 par défaut). Si la <liste> contient le constante jump, alors celle-ci est renvoyée dans la liste des résultats. Cette macro utilise la commande Round (qui ne s’applique qu’à un complexe et non une liste).
bary( <[affixe1, coef1, affixe2, coef2, ...]> ).
Description : renvoie le barycentre du système pondéré <[(affixe1, coef1), (affixe2, coef2),...]>.
del( <liste>, <liste des index à supprimer>, <quantité à supprimer> ).
Description : renvoie la liste après avoir supprimer les éléments dont l’index figure dans la <liste des index à supprimer>. La <quantité à supprimer> (à chaque fois) est de 1 par défaut, cet argument peut être une liste lui aussi.
Exemple(s) :
del( [1,2,3,4,5,6,7,8], [2,6,8]) donne [1,3,4,5,7].
del( [1,2,3,4,5,6,7,8], [2,6,8], 2) donne [1,4,5].
del( [1,2,3,4,5,6,7,8], [2,6,8], [1,2]) donne [1,3,4,5].
del( [1,2,jump,3,4,5,jump,6,7,8],[3,7]) donne [1,2,3,4,5,6,7,8].
getdot( <s> , <ligne polygonale> ).
Description : renvoie le point de la <ligne polygonale> ayant <s> comme abscisse curviligne. Le paramètre <s> doit être dans l’intervalle [0; 1], 0 pour le premier point, et 1 pour le dernier.
IsAlign( <liste points 2D> [, epsilon] ).
Description : renvoie 1 si les points sont sur une même droite, 0 sinon. Par défaut la tolérance <epsilon> vaut 1E-10. La <liste> ne doit pas contenir la constante jump.
isobar( <[affixe1, affixe2, ...]> ).
Description : renvoie l’isobarycentre du système <[affixe1, affixe2, ...]>.
KillDup( <liste> [, epsilon] ).
Description : renvoie la liste sans doublons. Les comparaisons se font à <epsilon> près (qui vaut 0 par défaut).
Exemple(s) : KillDup( [1.255,1.258,jump,1.257,1.256,1.269,jump] ,1.5E-3) renvoie [1.255,1.258,1.269].
length( <liste> ).
Description : calcule la longueur de la <liste> en cm.
permute( <liste> ).
Description : modifie la <liste> en plaçant le premier élément à la fin, <liste> doit être une variable.
la commande [x:= [1,2,3,4], permute(x), x] renvoie [2,3,4,1].
Pos( <affixe>, <liste>, [, epsilon] ).
Description : renvoie la liste des positions de l’<affixe> dans la <liste>, la comparaison se fait à <epsilon> près, par défaut <epsilon> vaut 0.
la commande Pos(2, [1,2,3,2,4]) renvoie [2,4], mais Pos(5, [1,2,3,2,4]) renvoie Nil.
rectangle( <liste> ).
Description : détermine le plus petit rectangle contenant la liste, cette macro renvoie une liste de deux complexes qui représentent l’affixe du coin inférieur gauche suivi de celle du coin supérieur droit.
replace( <liste>, <position>, <valeur> ).
Description : modifie la variable <liste> en remplaçant l’élément numéro <position> par la <valeur>, cette macro renvoie Nil.
reverse( <liste> ).
Description : renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un jump).
SortWith( <liste clés>, <liste>, <taille paquets> [, mode] ).
Description : trie la variable <liste> suivant les <clés>. Les éléments de la <liste> sont traités par <paquets>, leur taille est de 1 par défaut. La <taille paquets> peut être égale à jump pour un traitement par composante. Si un paquet n’est pas complet, il n’est pas traité. Si la liste contient la constante jump, alors toutes les composantes sont triées chacune leur tour. Le dernier paramètre détermine le type de tri: <mode>=0 pour ordre croissant (valeur par défaut), <mode>=1 pour décroissant.
La convention adoptée est que deux composantes sont séparées par la constante jump. Une composante peut être vide.
CpCopy( <liste>, <index depart>, <nombre> ).
Description : cette fonction renvoie la liste constituée par les <nombre> composantes de la <liste> à partir de la composante numéro <depart>[inclus]. Si <nombre> est nul, alors la fonction renvoie toutes les composantes de la liste à partir de la composante numéro <départ>.
Si le numéro <depart> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la dernière composante a l’index - 1, l’avant-dernière a l’index - 2 ⋯ etc. La fonction renvoie les <nombre> composantes 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) :
CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], 2, 1) renvoie [3,7,8].
CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -1, 2) renvoie [4,jump,5,6].
CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -3, 0) renvoie [1,2,jump,3,7,8].
CpDel( <variable liste>, <index depart>, <nombre> ).
Description : cette fonction détruit dans la <variable liste>, les <nombre> composantes à partir de la composante numéro <depart>[inclus]. Si <nombre> est nul, alors la fonction détruit toutes les composantes de la <variable liste> à partir de la composante numéro <départ>.
Si le numéro <depart> est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, la dernière composante a l’index - 1, l’avant-dernière a l’index - 2 ⋯ etc. La fonction détruit les <nombre> composantes de la <variable liste> (ou toute la liste si <nombre> est nul) en allant vers la gauche.
Le paramètre <variable liste> doit être un nom de variable, celle-ci est modifiée et la macro renvoie Nil.
CpNops( <liste> ).
Description : cette fonction évalue <liste> et renvoie le nombre de composantes qui la composent.
Exemple(s) :
CpNops([1,2,jump,3] ) renvoie la valeur 2.
CpNops([1,2,jump,3,jump] ) renvoie la valeur 3.
CpNops([jump] ) renvoie la valeur 2.
CpReplace( <variable liste>, <position>, <nouveau> ).
Description : modifie la <variable liste> en remplaçant la composante numéro <position> par <nouveau>, cette macro renvoie Nil.
CpReverse( <liste> ).
Description : renvoie la <liste> avec les composantes dans l’ordre inverse.
Exemple(s) : CpReverse([1,2,jump,3,4,5,jump]) renvoie [jump,3,4,5,jump,1,2].
Une telle liste est en réalité une macro, les éléments sont indexés à partir de 1, et la chaîne numéro k est donnée par @nomListe(k), alors que la longueur de la liste (nombre d’éléments) est donnée par nomListe(0).
StrListInit( <nomListe>, <"chaine1">, <"chaine2">, ... ).
Description : crée une liste de chaines sous forme d’une macro appelée <nomListe>, les arguments suivants sont interprétés comme des chaînes, ils constituent les éléments de la liste et sont indexés à partir de 1.
Exemple(s) : Après la commande StrListInit(essai, "toto", ["toto",2/4], 24), une macro du nom de essai est créée et son contenu est:
for $z in Args() do
if z<0 then Inc(z,4) fi,
if z=0 then 3
elif z=1 then "toto"
elif z=2 then "toto0.5"
elif z=3 then "24"
fi
od
Exemple(s) : Afficher des labels avec une affixe et une orientation pour chacun, en utilisant une seule fois LabelDot.
view(-2,2,-2,2), Marges(0,0,0,0), size(7.5), StrListInit( nom, -1,"A","O", i,"B","N", 1,"C","E", -i,"D","S"), for k from 1 to nom(0) step 3 do LabelDot( Eval(@nom(k)), @nom(k+1), @nom(k+2), 1) od, StrListKill(nom)
Une autre solution consiste à faire trois listes: nom, position, orientation:
view(-2,2,-2,2), Marges(0,0,0,0), size(7.5),
StrListInit( nom, "$A$", "$B$", "$C$", "$D$"),
StrListInit(orientation, "O", "N", "E", "S"),
position:=[-1, i, 1, -i],
for k from 1 to nom(0) do
LabelDot( position[k], @nom(k), @orientation(k), 1)
od,
StrListKill(nom, orientation)
StrListAdd( <nomListe>, <"chaine1">, <"chaine2">, ... ).
Description : cette macro ajoute à la fin de la liste de chaînes appelée <nomListe>, les arguments suivants (qui sont interprétés comme des chaînes). Cela suppose que la liste <nomListe> existe déjà, cette liste est en fait une macro qui va être entièrement réécrite pour lui ajouter les éléments supplémentaires. Il est plus rapide de définir la liste en une seule fois avec la macro StrListInit quand c’est possible.
StrListCopy( <nomListe>, <nouvelleListe> [, index depart, nombre] ).
Description : cette macro crée une nouvelle liste de chaînes appelée <nouvelleListe> en copiant <nombre> éléments de la liste <nomListe> en partant de <index depart>. L’argument <index depart> peut être négatif ( - 1 designe le dernier élément, - 2 l’avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est négatif. Par défaut l’<index depart> vaut 1 et le <nombre> vaut 0 (ce qui signifie øg tous les éléments).
StrListDelKey( <nomListe>, <index depart>, <nombre> ).
Description : cette macro supprime de <nomListe> <nombre> éléments à partir de l’<index depart>. Comme dans la commande Del, l’argument <index depart> peut être négatif ( - 1 designe le dernier élément, - 2 l’avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est négatif. Cette macro renvoie Nil.
StrListDelVal( <nomListe>, <val1>, <val2>, ... ).
Description : cette macro supprime de <nomListe> les chaînes <val1>, <val2>..., sans avoir à connaître leurs index.
StrListGetKey( <nomListe>, <chaine> ).
Description : cette macro renvoie l’index de la <chaîne> dans la liste <nomListe>, si elle n’y figure pas, la macro renvoie Nil.
StrListInsert( <nomListe1>, <chaîne> [, <index> ]).
Description : cette macro modifie la liste de chaines <nomListe>, en insérant une nouvelle <chaîne> à la position <index>. Par défaut la valeur de <index> est nulle ce qui représente la fin de la liste, cette valeur peut être négative ( - 1 est l’index du dernier élément, - 2 l’avant-dernier, ...).
StrListKill( <nomListe1>, <nomListe2>, ... ).
Description : cette macro détruit les listes de chaînes <nomListe1>, <nomListe2>, ...
StrListReplace( <nomListe>, <ancienne chaine>, <nouvelle> ).
Description : cette macro remplace dans la liste appelée <nomListe>, l’<ancienne chaine> par la <nouvelle>.
StrListReplaceKey( <nomListe>, <index>, <nouvelle chaîne> ).
Description : cette macro remplace dans la liste appelée <nomListe>, la chaîne dont le numéro est<index>, par la <nouvelle chaîne>.
StrListShow( <nomListe> [, <index depart>, <nombre> ]).
Description : cette macro renvoie la chaîne obtenue en copiant <nombre> éléments de la liste <nomListe> en partant de <index depart>, mais sans les concaténer. La chaîne renvoyée est de la forme: "chaine", "chaine", .... L’argument <index depart> peut être négatif ( - 1 designe le dernier élément, - 2 l’avant-dernier, ...), par contre les éléments sont toujours parcourus de gauche à droite quand <nombre> est positif, et dans le sens inverse quand <nombre> est négatif. Par défaut l’<index depart> vaut 1 et le <nombre> vaut 0 (ce qui signifie øg tous les éléments).
Anp( <n>, <p> ).
Description : renvoie le nombre d’arrangements de <p> parmi <n>.
binom( <n>, <p> ).
Description : renvoie le coefficient binomial (ou combinaison) <p> parmi <n>.
ecart( <liste réels> ).
Description : renvoie l’écart type d’une liste de réels, la constante jump est ignorée.
fact( <n> ).
Description : renvoie la valeur de n! (fonction factorielle).
max( <liste complexes> ).
Description : renvoie le plus grand élément d’une liste de complexes (ordre lexicographique), la constante jump est ignorée.
min( <liste complexes> ).
Description : renvoie le plus petit élément d’une liste de complexes (ordre lexicographique), la constante jump est ignorée.
median( <liste complexes> ).
Description : renvoie l’élément médian d’une liste de complexes (ordre lexicographique), la constante jump est ignorée.
moy( <liste complexes> ).
Description : renvoie la moyenne d’une liste de complexes, la constante jump est ignorée.
prod( <liste complexes> ).
Description : renvoie le produit des éléments d’une liste de complexes, la constante jump est ignorée.
sum( <liste complexes> ).
Description : renvoie la somme des éléments d’une liste de complexes, la constante jump est ignorée.
var( <liste réels> ).
Description : renvoie la variance d’une liste de réels, la constante jump est ignorée.
RealArg( <affixe> )
Description : renvoie l’argument (en radians) de l’affixe réelle d’un vecteur en tenant compte de la matrice courante.
RealCoord( <affixe écran> )
Description : renvoie l’affixe réelle d’un point compte tenu des échelles et de la matrice courante.
RealCoordV( <affixe écran> )
Description : renvoie l’affixe réelle d’un vecteur compte tenu des échelles de la matrice courante.
ScrCoord( <affixe réelle> )
Description : renvoie l’affixe écran d’un point en tenant compte des échelles et de la matrice courante.
ScrCoordV( <affixe réelle> )
Description : renvoie l’affixe écran d’un vecteur en tenant compte des échelles et de la matrice courante.
SvgCoord( <screen affixe> )
Description : renvoie l’affixe exportée en svg en tenant compte des échelles et de la matrice courante.
TeXCoord( <screen affixe> )
Description : renvoie l’affixe exportée en tex, pst et pgf en tenant compte des échelles et de la matrice courante. Pour l’eps il y a la commande EpsCoord.
affin( <liste> , <[A, B]>, <V>, <lambda> )
Description : renvoie la liste des images des points de <liste> par l’affinité de base la droite <(AB)>, de rapport <lambda> et de direction le vecteur <V>.
defAff( <nom>, <A>, <A’>, <partie linéaire> )
Description : cette fonction permet de créer une macro appelée <nom> qui représentera l’application affine qui transforme <A> en <A’>, et dont la partie linéaire est le dernier argument. Cette partie linéaire se présente sous la forme d’une liste de deux complexes: [Lf(1), Lf(i)] où Lf désigne la partie linéaire de la transformation.
ftransform( <liste>, <f(z)> )
Description : renvoie la liste des images des points de <liste> par la fonction <f(z)>, celle-ci peut-être une expression fonction de z ou une macro d’argument z.
hom( <liste>, <A>, <lambda> )
Description : renvoie la liste des images de la <liste> par l’homothétie de centre <A> et de rapport <lambda>.
inv( <liste>, <A>, <R> )
Description : renvoie la liste des images des points de <liste> par l’inversion de cercle de centre <A> et de rayon <R>.
mtransform( <liste>, <matrice> )
Description : renvoie la liste des images des points de <liste> par l’application affine f définie par la <matrice>. Cette matrice est de la forme [f(0), Lf(1), Lf(i)] où Lf désigne la partie linéaire.
proj( <liste>, <A>, <B> ) ou proj( <liste>, <[A,B]> )
Description : renvoie la liste des projetés orthogonaux des points de <liste> sur la droite (AB).
projO( <liste>, <[A,B]>, <vecteur> )
Description : renvoie la liste des projetés des points de <liste> sur la droite <(AB)> dans la direction du <vecteur>.
rot( <liste>, <A>, <alpha> )
Description : renvoie la liste des images des points de <liste> par la rotation de centre <A> et d’angle <alpha>.
shift( <liste>, <vecteur> )
Description : renvoie la liste des translatés des points de <liste> avec le <vecteur>.
simil( <liste> , <A>, <lambda>, <alpha> )
Description : renvoie la liste des images des points de <liste>, par la similitude de centre <A>, de rapport <lambda> et d’angle <alpha>.
sym( <liste>, <A>, <B> ) ou sym( <liste>, <[A,B]> )
Description : renvoie la liste des symétriques des points de <liste>, par rapport à la droite (AB).
symG( <liste>, <A>, <vecteur> )
Description : symétrie glissée: renvoie la liste des images des points de <liste>, par la symétrie orthogonale d’axe la droite passant par <A> et dirigée par <vecteur>, composée avec la translation de <vecteur>.
symO( <liste>, <[A, B]>, <vecteur> )
Description : renvoie la liste des symétriques des points de <liste> par rapport à la droite <(AB)> et dans la direction du <vecteur>.
Une transformation affine f du plan complexe peut être représentée par son expression analytique dans la base canonique (1, i), la forme générale de cette expression est:
{
$\left\{\begin{array}{rcl}
x'&=&t_1+ax+by\\
y'&=&t_2+cx+dy
\end{array}\right.$
}
cette expression analytique sera représentée par la liste [t1+i*t2, a+i*c, b+i*d] c’est à dire: [ f(0), f(1)-f(0), f(i)-f(0)], cette liste sera appelée plus brièvement (et de manière abusive) matrice de la transformation f. Les deux derniers éléments de cette liste: [ a+i*c, b+i*d], représentent la matrice de la partie linéaire de f: Lf = f - f(0).
ChangeWinTo( <[xinf+i*yinf, xsup+i*ysup]> [, ortho] )
Description : modifie la matrice courante de manière à transformer la fenêtre courante en la fenêtre de grande diagonale <[xinf+i*yinf, xsup+i*ysup]>, la fenêtre sera orthonormée ou non en fonction de la valeur du paramètre optionnel <ortho> (0 par défaut).
view(-10,10,-5,5),size(7.5),NbPoints:=100, LabelSize:=footnotesize, SaveWin(),view(-10,-1,-5,5), ChangeWinTo([-2-2*i,2+2*i]), Arrows:=1, axes(0,1+i),Arrows:=0, tMin:=-2, tMax:=2, Color:=red, Width:=8, Cartesienne(x*Ent(1/x)-1,5,1), Color:=blue,A:=(1+i)/4, Dparallelo(A,bar(A),-A), dep:=RealCoord(i*Im(A)), RestoreWin(), SaveWin(), //zoom view(1,10,-5,5), background(full,white), ChangeWinTo([-A,A]), Color:=black, arr:=RealCoord(-Re(A)+i*Im(A)*0.75), Arrows:=1, axes(0,A), Arrows:=0, tMin:=-0.25, tMax:=0.25, Color:=red, Width:=8, Cartesienne(x*Ent(1/x)-1,5,1), Color:=blue, Dparallelo(A,bar(A),-A), RestoreWin(), //trait Color:=blue, Arrows:=1, A:=ScrCoord(dep), B:=ScrCoord(arr), Bezier(A,A+3*exp(i*pi/2),B-3,B)
invmatrix( <[f(0), Lf(1), Lf(i)]> )
Description : renvoie l’inverse de la matrice <[f(0), Lf(1), Lf(i)]>, c’est à dire la matrice [f - 1(0), Lf - 1(1), Lf - 1(i)] si elle existe.
matrix( <fonction affine>, [variable] )
Description : renvoie la matrice de la <fonction affine>, par défaut la <variable> est z. Cette matrice se présente sous la forme [f(0), Lf(1), Lf(i)], où f désigne l’application affine et Lf sa partie linéaire, plus précisément: Lf(1)=f(1)-f(0) et Lf(i)=f(i)-f(0).
Exemple(s) : matrix(i*bar(z)) renvoie [0,i,1].
mulmatrix( <[f(0), Lf(1), Lf(i)]>, <[g(0), Lg(1), Lg(i)]> )
Description : renvoie la matrice de la composée: fog, où f et g sont les deux applications affines définies par les matrices passées en argument.
Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets.
bissec( <B>, <A>, <C>, <1 ou 2> )
Description : renvoie une liste de deux points de la bissectrice, 1=intérieure.
cap( <ensemble1>, <ensemble2> )
Description : renvoie le contour de l’intersection de <ensemble1> avec <ensemble2> sous forme d’une liste de points. Ces deux ensembles sont des lignes polygonales représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro set permet de définir et dessiner des ensembles.
Exemple(s) : intersection de deux ensembles:
Marges(0,0,0,0),size(7.5), A:=set("A", 0, [rotation:=30]), B:=set("B", 0, [rotation:=-30]), C:= cap(A,B),Color:=red,FillStyle:=full, FillOpacity:=0.5, FillColor:=pink, Ligne(C,0)
capB( <ensemble1>, <ensemble2> )
Description : renvoie le contour de l’intersection de <ensemble1> avec <ensemble2> sous forme d’une liste de points de contrôles qui doit être dessinée avec la macro drawSet. Ces deux ensembles sont doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro setB permet de définir et dessiner des ensembles.
Exemple(s) : intersection de deux ensembles:
Marges(0,0,0,0),size(7.5), A:=setB("A", 0, [rotation:=30]), B:=setB("B", 0, [rotation:=-30]), C:= capB(A,B),Color:=red,FillStyle:=full, drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
carre( <A>, <B>, <1 ou -1> )
Description : renvoie la liste des sommets du carré de sommets consécutifs A et B, 1=sens direct.
cup( <ensemble1>, <ensemble2> )
Description : renvoie le contour de la réunion de <ensemble1> avec <ensemble2> sous forme d’une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro set permet de définir et dessiner des ensembles.
Exemple(s) : réunion de deux ensembles:
Marges(0,0,0,0),size(7.5), A:=set("A", 0, [rotation:=30]), B:=set("B", 0, [rotation:=-30]), C:= cup(A,B),Color:=red,FillStyle:=full, FillOpacity:=0.5, FillColor:=pink, Ligne(C,0)
cupB( <ensemble1>, <ensemble2> )
Description : renvoie le contour de la réunion de <ensemble1> avec <ensemble2> sous forme d’une liste de points de contrôles qui doit être dessinée avec la macro drawSet. Ces deux ensembles sont doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro setB permet de définir et dessiner des ensembles.
Exemple(s) : intersection de deux ensembles:
Marges(0,0,0,0),size(7.5), A:=setB("A", 0, [rotation:=30]), B:=setB("B", 0, [rotation:=-30]), C:= cupB(A,B),Color:=red,FillStyle:=full, drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
cutBezier( <courbe de bézier>, <point>, <avant(0/1)> )
Description : renvoie un arc de bézier correspondant à la <courbe de bézier> coupée avant ou après le <point>, en fonction du paramètre <avant>. Le résultat doit être dessiné par la commande Bezier.
Cvx2d( <liste> )
Description : renvoie l’enveloppe convexe de la <liste> selon l’algorithme de {Ronald Graham}. La <liste> ne doit pas contenir la constante jump.
Exemple(s) : on choisit aléatoirement 10 points dans le pavé [ - 4, 4] × [ - 4, 4] que l’on place dans une variable P tout en dessinant chacun d’eux avec son numéro, puis on dessine l’enveloppe convexe.
Marges(0,0,0,0),size(7.5), P:= for k from 1 to 10 do z:=8*Rand()-4+i*(8*Rand()-4), LabelDot(z, k,"N",1), z od, Ligne(Cvx2d(P),1)
Intersec( <objet1>, <objet2> )
Description : renvoie la liste des points d’intersection des deux objets graphiques. Ces deux objets peuvent être soit des commandes graphiques (Cercle(), Droite(), ...) ou bien le nom d’un élément graphique déjà créé.
Exemple(s) : la commande Intersec( Cercle(0, 1), Droite(-1,i/2) ) renvoie:
med( <A>, <B> )
Description : renvoie une liste de deux points de la médiatrice de [A, B].
parallel( <[A,B]>, <C> )
Description : renvoie une liste de deux points de la parallèle à (AB) passant par C.
parallelo( <A>, <B>, <C> )
Description : renvoie la liste des sommets du parallèlogramme de sommets consécutifs A, B, C.
perp( <[A, B]>, <C> )
Description : renvoie une liste de deux points de la perpendiculaire à (AB) passant par C.
polyreg( <A>, <B>, <nombre de cotés> )
Description : renvoie la liste des sommets du polygône régulier de centre A, passant par B et avec le nombre de côtés indiqué.
ou
polyreg( <A>, <B>, <nombre de cotés + i*sens> ) avec sens = +/-1
Description : renvoie la liste des sommets du polygône régulier de sommets consécutifs A et B, avec le nombre de côtés indiqué et dans le sens indiqué (1 pour le sens trigonométrique).
pqGoneReg( <centre>, <sommet>, <[p,q]> )
Description : renvoie la liste des sommets du <p/q>-gône régulier défini par le <centre> et un <sommet>.
Exemple(s) : voir ici.
rect( <A>, <B>, <C> )
Description : renvoie la liste des sommets du rectangle de sommets consécutifs A, B, le côté opposé passant par C.
setminus( <ensemble1>, <ensemble2> )
Description : renvoie le contour de la différence <ensemble1> - <ensemble2> sous forme d’une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro set permet de définir et dessiner des ensembles.
Exemple(s) : différence de deux ensembles:
Marges(0,0,0,0),size(7.5), A:=set("A", 0, [rotation:=30]), B:=set("B", 0, [rotation:=-30]), C:= setminus(A,B),Color:=red,FillStyle:=full, FillOpacity:=0.5, FillColor:=pink, Ligne(C,0)
setminusB( <ensemble1>, <ensemble2> )
Description : renvoie le contour de la différence <ensemble1> - <ensemble2> sous forme d’une liste de points de contrôles qui doit être dessinée avec la macro drawSet. Ces deux ensembles sont doivent également être deux listes de points de contrôle représentant des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro setB permet de définir et dessiner des ensembles.
Exemple(s) : différence de deux ensembles:
Marges(0,0,0,0),size(7.5), A:=setB("A", 0, [rotation:=30]), B:=setB("B", 0, [rotation:=-30]), C:= setminusB(A,B),Color:=red,FillStyle:=full, drawSet(C, [FillOpacity:=0.5, FillColor:=pink])
Il est possible de transformer un fichier pdf ou un fichier postscript en flattened postscript grâce à l’utilitaire pstoedit (http://www.pstoedit.net/). Dans le fichier obtenu, tout est chemin, y compris le texte. TeXgraph peut récupérer tous les chemins d’un fichier écrit en flattened postscript. C’est que proposent les macros de cette section.
conv2FlatPs( <fichier entrée>, <fichier sortie> [, dossier de travail] )
Description : cette macro invoque l’utilitaire pstoedit pour transformer le <fichier entrée> en flattened postscript dans le <fichier sortie>. Le fichier <fichier entrée> doit être un fichier pdf ou ps.
drawFlatPs( <affixe>, <chemins lus par loadFlatPs> [, options] )
Description : cette macro dessine à l’écran l’ensemble des chemins lus dans un fichier en flattened postscript par la macro loadFlatPs. L’affichage se fait à l’<affixe> demandé. Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
scale := < nombre positif >: échelle, 1 par défaut.
position := < center/left/right/... >: position de l’affixe par rapport à l’image, center par défaut (fonctionne comme la variable LabelStyle).
color := < couleur >: pour imposer une couleur, Nil par défaut ce qui signifie qu’on prend la couleur d’origine.
rotation := < angle en degrés >: 0 par défaut.
hollow := < 0/1 >: avec la valeur 0 (par défaut) les remplissages sont effectués.
select := < liste des numéros de chemin à montrer >: Nil par défaut, ce qui signifie tous les chemins.
drawTeXlabel( <affixe>, <variable contenant la formule TeX lue par loadFlatPs>, [, options] )
Description : cette macro invoque la macro drawFlatPs pour dessiner une expression qui a été au préalable compilée par . Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
scale := < nombre>0 >: échelle, 1 par défaut.
hollow := < 0/1 >: avec la valeur 0 (par défaut) les remplissages sont effectués.
Cette macro est utilisée en interne par la macro NewTeXlabel.
loadFlatPs( <fichier en flattened postscript>, [, options] )
Description : cette macro charge un <fichier en flattened postscript>, adpate les coordonnées des points et renvoie la liste des chemins (que l’on peut alors dessiner avec la macro drawFlatPs). Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
width := < nombre>0 >: largeur en cm, Nil par défaut pour largeur naturelle.
height := < nombre>0 >: hauteur en cm, Nil par défaut pour hauteur naturelle.
supposons que vous ayez le fichier circuit.pdf dans le dossier temporaire de TeXgraph, la commande suivante dans un élément graphique Utilisateur:
[conv2FlatPs( "circuit.pdf", "circuit.fps", @TmpPath),
stock:= loadFlatPs( [@TmpPath,"circuit.fps"] ),
drawFlatPs( 0, stock, [scale:=1, hollow:=1] )
]
va permettre de charger et dessiner le contenu de ce fichier dans TeXgraph, sans faire les remplissages.
NewTeXlabel( <nom>, <affixe>, <formule TeX>, [, options] )
Description : cette macro va demander à {} de compiler la formule dans un fichier pdf, ce fichier sera ensuite converti en un fichier eps par pstoedit, puis celui-ci sera chargé par loadFlatPs et stocké dans une variable globale appelée TeX_+nom. Un élément graphique appelé <nom> est créée pour dessiner la formule avec drawTeXLabel. Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
dollar := < 0/1 >: indique à TeXgraph s’il doit ajouter les délimiteurs \[ et \] autour de la formule, 1 par défaut.
scale := < nombre>0 >: échelle, 1 par défaut.
hollow := < 0/1 >: avec la valeur 0 (par défaut) les remplissages sont effectués.
Dans les options, les attributs suivants peuvent également être utilisés: LabelStyle, LabelAngle et Color.
Voici la définition de cette macro:
[dollar:=1, scale:=1, hollow:=0, $options:=%4, $aux:=OpenFile([@TmpPath,"formula.tex"]), if dollar then WriteFile(["\[",%3,"\]"]) else WriteFile(%3) fi, CloseFile(), Exec("pdflatex","-interaction=nonstopmode tex2FlatPs.tex",@TmpPath,1), Exec("pstoedit -dt -pta -f ps -r2400x2400","tex2FlatPs.pdf tex2FlatPs.eps",@TmpPath,1), NewVar(["TeX_",%1],loadFlatPs([@TmpPath,"tex2FlatPs.eps"])), NewGraph(%1, ["drawTeXlabel(",%2,", TeX_",%1,", [scale:=",scale,", hollow:=",hollow,"])"]), ReDraw() ]
La formule est écrite dans le fichier formula.tex, puis on compile le fichier tex2FlatPs.tex suivant:
\documentclass[12pt]{article}
\usepackage{amsmath,amssymb}
\usepackage{fourier}
\pagestyle{empty}
\begin{document}
\large
\input{formula.tex}%
\end{document}
et on convertit le résultat en flattened postscript avant de le charger.
Cette macro s’utilise dans la ligne de commande ou bien dans des macros qui créent des éléments graphiques, mais pas directement dans un élément graphique Utilisateur, exemple:
pdfprog().
Description : cette macro est utilisée en interne pour mémoriser le programme utilisé pour faire la conversion du format eps vers le format pdf. Par défaut, cette macro contient la chaine: "epstopdf". En éditant le fichier TeXgraph.mac, vous pouvez modifier le programme utilisé.
Ces fonctions et macros créent un élément graphique au moment de leur évaluation et renvoient un résultat égal à Nil, elles ne sont utilisables que lors de la création d’un élément graphique "Utilisateur"1.
Elles peuvent être utilisées dans des macros, mais elles ne seront évaluées que si ces macros sont exécutées lors de la création d’un élément graphique "Utilisateur".
Notations:
<argument>: signifie que l’argument est obligatoire.
[, argument]: signifie que l’argument est facultatif.
Axes( <origine>, <graduationX + i*graduationY> [, position label origine] ).
Description : dessine les axes, <origine> est l’affixe du point d’intersection des axes, <graduationX> est le pas pour les graduations sur l’axe Ox, et <graduationY> celui de l’axe Oy, une graduation égale à zéro signifie l’absence de graduation. La longueur des graduations est dans la variable globale xyticks que l’on peut modifier, la distance des labels à l’extrêmité des graduations est dans la variable xylabelsep qui peut également être modifiée.
Le troisième paramètre est facultatif, il permet de préciser la position des labels de l’origine (à l’intersection des axes), c’est un complexe: a + ib, la partie réelle concerne l’abscisse de l’origine et l’autre concerne l’ordonnée. Ces deux nombres peuvent prendre trois valeurs:
0: le label n’apparaît pas,
1: le label est affiché comme celui des autres graduations,
2: le label est décalé pour ne pas chevaucher l’autre axe (valeur par défaut).
On peut modifier dans les Attributs: le style de ligne, l’épaisseur, la couleur et la taille des labels.
view(-5,4,-5,5),Marges(0.5,0,0,0.5), size(7.5), Width:=2, Color:=lightgray, Grille(-5-5*i,(1+i)/2), Width:=4, Color:=gray, Grille(-5-5*i,(1+i)), Color:=black, Arrows:=1, Axes(-5-5*i,1+i,1+i),Arrows:=0, LabelAxe(x,-pi-5*i," - π",2-i,1), LabelAxe(x,pi-5*i,"π",2+i,1), SaveAttr(), FillStyle:=full, FillColor:=lightblue, FillOpacity:=0.5, domaine2(3*sin(x)^3, -5,-pi,pi), RestoreAttr(), Color:=red, Arrows:=0, Width:=8, Cartesienne( 3*sin(x)^3 )
Bezier( <liste de points> ).
Description : dessine une succession de courbes de {Bezier} (avec éventuellement des segments de droite). Il y a plusieurs possibilités pour la liste de points:
une liste de trois points [A, C, B], il s’agit alors d’une courbe de Bezier d’origine <A> et d’extrémité <B> avec un point de contrôle <C>, c’est la courbe paramétrée par:
(1 - t)2A + 2t(1 - t)C + t2B
une liste de 4 points ou plus: [A1, C1, C2, A2, C3, C4, A3...]: il s’agit alors d’une succession de courbes de Bezier à 2 points de contrôles, la première va de A1 à A2, elle est contrôlée par C1, C2 (paramétrée par (1 - t)3tA1 + 3(1 - t)2tC1] + 3(1 - t)t2C2 + t3A2), la deuxième va de A2 à A3 et est contrôlée par C3,C4 ...etc. Une exception toutefois, on peut remplacer les deux points de contrôle par la constante jump, dans ce cas on saute directement de A1 à A2 en traçant un segment de droite.
Le nombre de points calculés (par courbe) est modifiable dans les Attributs (variable NbPoints).
view(-4,4,-4,5),Marges(0,0,0,0), size(7.5), Width:=8, A:=-3+4*i, B:=3+i, C:=3-3*i, D:=-3-3*i, C1:=4.5*i,C2:=-2*i, C3:=2-i, C4:=-2, FillStyle:=full, FillColor:=lightblue,Color:=red, Bezier(A,C1,C2,B,jump,C,C3,C4,D,jump,A), FillStyle:=none, DotStyle:=cross, DotScale:=2,Color:=black, LabelDot(A,"A","N",1), LabelDot(B,"B","E",1), LabelDot(C,"C","SE",1), LabelDot(D,"D","SO",1), LabelDot(C1,"C1","E",1), LabelDot(C2,"C2","SO",1), LabelDot(C3,"C3","N",1), LabelDot(C4,"C4","N",1), LineStyle:=userdash, DashPattern:=[5,2,0.5,2], Width:=6, LineCap:=round, Ligne([A,C1,C2,B,jump,C,C3,C4,D],0)
Cartesienne( <f(x)> [, n, 1] ).
Description : trace la courbe cartésienne d’équation y = f(x). Le paramètre optionnel <n> est un entier (égal à 5 par défaut) qui permet de faire varier le pas de la manière suivante: lorsque la distance entre deux points consécutifs est supérieur à un certain seuil alors on calcule un point intermédiaire [par dichotomie], ceci peut être répété n fois. Si au bout de n itérations la distance entre deux points consécutifs est toujours supérieure au seuil, et si la valeur optionnelle 1 est présente, alors une discontinuité (jump) est insérée dans la liste des points.
view(-2,2,-0.1,2),Marges(0.5,0.5,0.5,0.5), size(7.5), tMin:=-2, tMax:=2, Color:=darkgray, Width:=8, LineStyle:=dotted, Grille(0,0.5*(1+i)), Color:=black, LineStyle:=solid,Axes(0,1+i,1), NbPoints:=100, Width:=8, Color:=darkseagreen, Cartesienne(x*Ent(1/x),5,1)
Courbe( <f(t)> [, n, 1] ).
Description : trace la courbe paramétrée par <f(t)> où f est à valeurs complexes.
Le paramètre optionnel <n> est un entier (égal à 5 par défaut) qui permet de faire varier le pas de la manière suivante: lorsque la distance entre deux points consécutifs est supérieur à un certain seuil alors on calcule un point intermédiaire (par dichotomie), ceci peut être répété n fois. Si au bout de n itérations la distance entre deux points consécutifs est toujours supérieure au seuil, et si la valeur optionnelle 1 est présente, alors une discontinuité (jump) est insérée dans la liste des points.
Droite( <A>, <B> [, C] ).
Description : trace la droite (AB) lorsque le troisième argument <C> est omis, sinon c’est la droite d’équation cartésienne <A>x+<B>y=<C>.
view(-5,5,-5,5),Marges(0,0,0,0), size(7.5), F:=sqrt(7), F’:=-F, {foyers} Width:=1, Color:=darkgray, for t from -pi to pi step 0.1 do M:=4*cos(t)+3*i*sin(t), Vn:=(M-F)/abs(M-F)+(M-F’)/abs(M-F’), Droite(M,M+Vn),{normale à l’ellipse} od, Width:=8, Color:=red, Ellipse(0,4,3), LabelDot(F,"F","S",1), LabelDot(F’,"Fʹ","S",1)
Ellipse( <A>, <Rx>, <Ry> [, inclinaison] ).
Description : trace une ellipse de centre <A> de rayons <Rx> et <Ry> sur les axes respectifs Ox et Oy. Le dernier paramètre <inclinaison> est un angle en degrés (nul par défaut) qui indique l’inclinaison de l’ellipse par rapport à l’horizontale.
view(-5.25,5.25,-5.25,5.25), Marges(0,0,0,0), size(7.5), background(full,blue), Width:=4, Color:=white, inclin:=[0,35,-35], for z in inclin do Ellipse(0,5,2,z) od, Width:=2*mm, Ellipse(0,1.5,4.5), Label(-0.1, "{6cm} {3.5cm} {R T F}")
EllipticArc( <B>, <A>, <C>, <Rx>, <Ry> [, sens] ).
Description : trace un arc d’ellipse dont les axes sont Ox et Oy et le centre <A>, le rayon sur Ox est <Rx>, et celui sur Oy est <Ry>. L’arc est tracé partant de la droite (AB) jusqu’à la droite (AC), l’argument facultatif <sens> indique: le sens trigonométrique si sa valeur est 1 (valeur par défaut), le sens contraire si sa valeur est - 1.
view(-2.25,3.75,-2,5),Marges(0,0,0,0),size(7.5), A:=0, B:=3+i, C:=2+4*i, DotScale:=2, Width:=8, Ligne([B,A,C],0), Color:=red, LabelDot(A,"A","S",1), LabelDot(B,"B","N",1), LabelDot(C,"C","SE",1), Arrows:=1, Color:=blue, EllipticArc(B,A,C,2,1,-1), EllipticArc(B,A,C,2,3,1)
Remarque: pour un arc de cercle, il suffit de prendre <Rx> et <Ry> égaux. Mais le plus simple est d’utiliser la macro Arc qui remplace la commande Arc de l’ancienne version.
EquaDif( <f(t,x,y)>, <t0>, <x0 + i*y0> [, mode] ).
Description : trace une solution approchée de l’équation différentielle: xʹ(t) + iyʹ(t) = f(t, x, y) avec la condition initiale x(t0) = x0 et y(t0) = y0. Le dernier paramètre est facultatif et peut valoir 0, 1 ou 2:
<mode>=0: la courbe représente les points de coordonnées (x(t), y(t)), c’est la valeur par défaut.
<mode>=1: la courbe représente les points de coordonnées (t, x(t)).
<mode>=2: la courbe représente les points de coordonnées (t, y(t)).
C’est la méthode de {Runge-Kutta} d’ordre 4 qui est utilisée.
Exemple(s) : l’équation xʹʹ - xʹ - tx = sin(t) avec la condition initiale x(0) = - 1 et xʹ(0) = 1 / 2, se met sous la forme:
$\begin{pmatrix}
X'\\Y'\end{pmatrix}=\begin{pmatrix} 0&1\\t&1\end{pmatrix}\begin{pmatrix}X\\Y\end{pmatrix}+
\begin{pmatrix}0\\\sin(t)\end{pmatrix}$
en posant X = x et Y = xʹ:
view(-10.5,2.5,-1.5,4.5),Marges(0,0,0,0), size(7.5,0), Arrows:=1, Width:=4, Axes(0,1+i), Arrows:=0, LabelAxe(y,4.25*i,"x"), LabelAxe(x,2,"t",2), Width:=8, Color:=red, tMin:=-10, tMax:=2, EquaDif(y+i*(t*x+y+sin(t)),0,-1+i/2, 1), Color:=black, LabelStyle:=stacked, Label(-6+2*i, "xʹʹ - txʹ - x = sin(t)
avec x(0) = - 1 et $x'(0)=\frac12$")
Grille( <origine>, <graduationX + i*graduationY> ).
Description : dessine une grille, <origine> est l’affixe du point considéré comme origine, <graduationX> est le pas des graduations sur l’axe Ox, et <graduationY> celui de l’axe Oy, une graduation égale à zéro signifie l’absence de graduation.
On peut modifier dans les Attributs le style de ligne, l’épaisseur et la couleur. La grille de ne fait pas appraître de graduations, on peut dessiner des axes par dessus.
Implicit( <f(x,y)> [, n, m] ).
Description : trace la courbe implicite d’équation f(x, y) = 0. L’intervalle des abscisses est subdivisé en <n> parties et l’intervalle des ordonnées en <m> parties, par défaut n = m = 25. Sur chaque pavé ainsi obtenu on teste s’il y a un changement de signe, auquel cas on applique une dichotomie sur les bords du pavé.
view(-5,5,-5,5),Marges(0,0,0,0), size(7.5), Arrows:=1, Width:=4, Axes(0,1+i), Arrows:=0, Width:=8, Color:=red, Implicit( sin(x*y) )
Label( <affixe1>, <texte1>,..., <affixeN>, <texteN> ).
Description : place la chaîne de caractères <texte1> à la position <affixe1> ... etc. Les paramètres <texte1>,..., <texteN> sont donc interprétés comme des chaînes de caractères.
view(-5,5,-5,5),Marges(0,0,0,0), size(7.5,0), C:=Cube(Origin, M(3,3,0)), S:=Sommets(C), Point3D(S), DrawPoly(C,0), k:=0, for Z in S by 2 do Inc(k,1), Label(Proj3D(Z)+ if k>4 then 0.5*i else -0.5*i fi, ["$S_",k,"$"]) od
Ligne( <liste>, <fermée> [, rayon] ).
Description : trace la ligne polygonale définie par la liste, si le paramètre <fermée> vaut 1, la ligne polygonale sera fermée, si sa valeur est 0 la ligne est ouverte. Si l’argument <rayon> est précisé (0 par défaut), alors les "angles" de la ligne polygonale sont arrondis avec un arc de cercle dont le rayon correspond à l’argument <rayon>.
Marges(0,0,0,0), size(7.5), A:=-5-5*i, B:=5*i, C:=5-5*i,niv:=6, Tr:=[A,B,C,jump], {initial} for k from 1 to niv do Tr:=[hom(Tr,A,0.5),hom(Tr,B,0.5), hom(Tr,C,0.5)] od, FillStyle:=full,FillColor:=blue, Ligne(Tr,1)
Path( <liste> [, fermé (0/1)]
Description : trace le chemin représenté par <liste> et ferme la dernière composante de celui-ci si l’argument optionnel vaut 1 (sa valeur par défaut est 0). La liste est une succession de points (affixes) et d’instructions indiquant à quoi correspondent ces points, ces instructions sont:
line: relie les points par une ligne polygonale,
linearc: relie les points par une ligne polygonale mais les angles sont arrondis par un arc de cercle, la valeur précédent la commande linearc est interprétée comme le rayon de ces arcs.
arc: dessine un arc de cercle, ce qui nécessite quatre arguments: 3 points et le rayon, plus éventuellement un cinquième argument: le sens (+/- 1), le sens par défaut est 1 (sens trigonométrique).
ellipticArc: dessine un arc d’ellipse, ce qui nécessite cinq arguments: 3 points, le rayonX, le rayonY, plus éventuellement un sixième argument: le sens (+/- 1), le sens par défaut est 1 (sens trigonométrique), plus éventuellement un septième argument: l’inclinaison en degrés du grand axe par rapport à l’horizontale.
curve: relie les points par une spline cubique naturelle.
bezier: relie le premier et le quatrième point par une courbe de bézier (les deuxième et troisième points sont les points de contrôle).
circle: desine un cercle, ce qui necessite deux arguments: un point et le centre, ou bien trois arguments qui sont trois points du cercle.
ellipse: dessine une ellipse, les arguments sont: un point, le centre, rayon rX, rayon rY, inclinaison du grand axe en degrés par rapport à l’horizontale (facultatif).
move: indique un déplacement sans tracé.
closepath: ferme la composante en cours.
Par convention, le premier point du tronçon numéro n+1 est le dernier point du tronçon numéro n.
Exemple(s) :
view(-5,5,-4,6),Marges(0,0,0,0),size(7.5), Axes(2*i,1+i),Eofill:=1, FillStyle:=full,FillOpacity:=0.9, FillColor:= blue, Width:=8, Path([-4,i,circle, -3+2*i,move,-3,-2,line, 0,2,2,-1,arc, 3,3+3*i,0.5,linearc, 1,-1+5*i,-3+2*i,bezier, closepath, ])
Point( <A1>, ..., <An> ).
Description : représente le nuage de points <A1> ... <An>.
view(2.75,4,0,1), Marges(0.75,0.5,0.5,0.5),size(7.5), Axes(Xmin+i*Ymin,0.25+0.2*i,1+i), pas:=0.001, Color:=red, DotScale:=0.1, Point( for r from Xmin to Xmax step pas do u:=0.5, for k from 1 to 25 do u:=r*u*(1-u) od, for k from 1 to 25 do u:=r*u*(1-u), r+i*u od od)
Polaire( <r(t)> [, n, 0/1] ).
Description : trace la courbe polaire d’équation ρ = r(t), <expression>. Le paramètre optionnel <n> est un entier (égal à 5 par défaut) qui permet de faire varier le pas de la manière suivante: lorsque la distance entre deux points consécutifs est supérieur à un certain seuil alors on calcule un point intermédiaire (par dichotomie), ceci peut être répété n fois. Si au bout de n itérations la distance entre deux points consécutifs est toujours supérieure au seuil, et si la valeur optionnelle 1 est présente, alors une discontinuité (jump) est insérée dans la liste des points.
view(-3,2,-2,3),Marges(0.25,0.25,0.25,0.25), size(7.5),Width:=4, Axes(0,1+i),NbPoints:=250,tMin:=-25,tMax:=25, courbe:=Get(Polaire((t+1)/(t-1))), ptDoubles:= courbe InterL courbe, Width:=8, Color:= blue, Ligne(courbe,0), DotStyle:=dotcircle, DotScale:=2, Point(ptDoubles), Label(1+2*i,"$r(t)=\dfrac{t+1}{t-1}$")
Spline( <V0>, <A0>,..., <An>, <Vn> ).
Description : trace 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).
view(-5,5,-5,5),Marges(0.25,0.25,0.25,0.25), size(7.5),Width:=4,Axes(0,1+i), A:= -4-3*i, B:=-2+2*i, C:=1-3*i, D:=4+3*i, LabelDot(A,"A","S",1),LabelDot(B,"B","N",1), LabelDot(C,"C","S",1),LabelDot(D,"D","O",1), Width:=8,Color:=red, Spline(0,A,B,C,D,0), Ligne([-4.5+4.5*i,-4+4.5*i],0), LabelStyle:=left, Label(-3.5+4.5*i,"libre"), Color:=blue,Spline(5,A,B,C,D,5*i), Ligne([-4.5+3.5*i,-4+3.5*i],0), Label(-3.5+3.5*i,"contrainte"), Width:=4, Arrows:=1, Ligne([A,A+2,jump,D,D+2*i],0)
La version propose quelques commandes de base pour faire du dessin bitmap. Ce dessin bitmap peut être enregistré (au format bmp) mais il n’est pas pris en compte par les autres exports du logiciel. Ces commandes ne sont fonctionnelles qu’avec la version GUI de TeXgraph. Chaque pixel est repéré son affixe x + iy où x et y sont deux entiers, l’origine est en haut à gauche de la zone de dessin marges exclues, l’axe Ox est dirigé vers la droite et l’axe Oy vers le bas.
DelBitmap().
Description : détruit le bitmap en cours.
MaxPixels().
Description : renvoie la taille de la zone graphique en pixels sous la forme: maxX+i*maxY, ainsi pour les coordonnées des pixels (coordonnées entières), l’intervalle des abscisses est [0 .. maxX] et celui des ordonnées [0 .. maxY]. Chaque pixel est repéré par des coordonnées entières, donc chaque pixel a une affixe a + ib avec a dans [0 .. maxX] et b dans [0 .. maxY]. L’origine étant le coin supérieur gauche de la zone graphique marges exclues.
NewBitmap( [fond] ).
Description : permet de créer un nouveau bitmap (vide). Par défaut la couleur du fond est le blanc.
Pixel( <liste> ).
Description : permet de d’allumer une <liste> de pixels. Cette liste est de la forme: [affixe, couleur, affixe, couleur, ...]. Les affixes des pixels sont de la forme a + ib avec a et b des entiers positifs ou nuls, l’origine étant le coin supérieur gauche de la zone graphique marges exclues.
Pixel2Scr( <affixe> ).
Description : permet de convertir l’<affixe> d’un pixel (coordonnées entières) en affixe dans le repère de l’utilisateur à l’écran.
Scr2Pixel( <affixe> ).
Description : permet de convertir l’<affixe> d’un point dans le repère de l’utilisateur à l’écran en coordonnées entières (affixe du pixel correspondant au point).
Exemple(s) : un ensemble de Julia, la commande est à placer dans un élément graphique utilisateur. L’image png a été obtenue à partir du bouton snapshot de l’interface graphique en prenant l’export bmp puis une conversion en png:
view(-1.5,1.5,-1,1),Marges(0,0,0,0),size(7.5), NewBitmap(), T:=100, m:=MaxPixels(), c:=-0.181-0.667*i, for x from 0 to Re(m) do Pixel( for y from 0 to Im(m) do N:=0, z:=Pixel2Scr(x+i*y), repeat z:=z^2+c, Inc(N,1) until (N=T) Or (abs(z)>2) od, x+i*y, MixColor(darkred,1-N/T,yellow,N/T) od ) od
angleD( <B>, <A>, <C>, <r> ).
Description : dessine l’angle $\widehat{BAC}$ avec un parallèlogramme de coté r.
Arc( <B>, <A>, <C>, <R> [, sens] ).
Description : trace un arc de cercle de centre <A> et de rayon <R>. L’arc est tracé partant de la droite (AB) jusqu’à la droite (AC), l’argument facultatif <sens> indique: le sens trigonométrique si sa valeur est 1 (valeur par défaut), le sens contraire si valeur est - 1.
view(-2.25,3.75,-2,5),Marges(0,0,0,0),size(7.5), A:=0, B:=3+i, C:=2+4*i, DotScale:=2, Width:=8, Ligne([B,A,C],0), Color:=red, LabelDot(A,"A","S",1), LabelDot(B,"B","N",1), LabelDot(C,"C","SE",1), Arrows:=1, Color:=blue, Arc(B,A,C,1,-1), Arc(B,A,C,2,1)
arcBezier( <B>, <A>, <C>, <r> [,sens] ).
Description : a le même effet que la macro graphique Arc mais l’arc est dessiné avec des courbes de Bezier.
axes( <[origine, etendueX, etendueY]>, <gradX+i*gradY> [, subdivX+i*subdivY, posOriginX+i*posOriginY, num, "texte", den, firstnum] ).
Description : pour tracer et graduer les axes passant par <origine> (affixe), elle s’utilise comme la commande Axes et utilise donc les variables xylabelpos et xyticks. Par défaut les axes occupent toute la fenêtre si les paramètres optionnels <etendueX> et <etendueY> sont omis. Le paramètre <etendueX> représente sous forme complexe l’intervalle des abcisses: xmin+i*xmax, de même pour les ordonnées avec le paramètre <etendueY>, les axes sont alors limités à ces intervalles. Remarque: pour préciser une valeur de <etendueY> sans préciser de valeur pour <etendueX>, il suffit de mettre jump à la place de <etendueX> (et non pas Nil!).
Le paramètre optionnel <subdivX+i*subdivY> indique le nombre de subdivisions par unité sur chaque axe (0 par défaut).
Le paramètre optionnel <posOriginX+i*posOriginY> permet de positionner le label de l’origine:
<posOriginX>=0: pas de label à l’origine (idem pour <posOriginY>=0),
<posOriginX>=1: label normal à l’origine (idem pour <posOriginY>=1),,
<posOriginX>=2: label décalé à droite de l’origine et en haut pour <posOriginY>=2 (valeurs par défaut),
<posOriginX>=-2 label décalé à gauche de l’origine et en bas pour <posOriginY>=-2.
Sur les 2 axes, chaque label est multiplié par la fraction <num/den> (1 par défaut), ajouté à <firstnum/den> (l’origine par défaut) et accompagné du <"texte"> au numérateur. Pour que le séparateur décimal soit la virgule à la place du point, il suffit de mettre la variable usecomma à la valeur 1. Cette macro est également sensible aux variables dollar (pour ajouter ou non des $ autour des labels des graduations), et nbdeci qui fixe le nombre de décimales affichées.
Exemple(s) : pour avoir des axes gradués en π / 2 en π / 2: axes(0, pi*(1+i)/2, 1+i, 2+2*i, 1, "\pi", 2, 0). Contrairement à la commande Axes, cette macro est sensible aux modifications de la matrice courante.
axeX( <[origine, posOrigine, etendue]>, <Xpas> [, Subdiv, labelPos , num, ""texte"", den, firstnum] ).
Description : pour tracer et graduer un axe des abscisses passant par <origine> et avec un pas de <Xpas>. Le paramètre <etendue> représente sous forme complexe l’intervalle des abscisses xmin+i*xmax, si celui-ci est omis, alors le tracé occupe la fenêtre. Remarque: pour préciser une valeur de <etendue> sans préciser de valeur pour <posOrigine>, il suffit de mettre jump à la place de <posOrigine> (et non pas Nil!).
<Subdiv> est le nombre de subdivisions par unité, chaque abscisse est multipliée par la fraction <num/den> (1 par défaut), ajoutée à <firstnum/den> (l’origine par défaut) et accompagnée du <"texte"> au numérateur. Pour que le séparateur décimal soit la virgule à la place du point, il suffit de mettre la variable usecomma à la valeur 1. Cette macro est également sensible aux variables dollar (pour ajouter ou non des $ autour des labels des graduations), et nbdeci qui fixe le nombre de décimales affichées.
Les paramètres optionnels <posOrigine> et <labelpos> permettent de positionner les labels:
<posOrigine>=0: pas de label à l’origine,
<posOrigine>=1: label normal à l’origine,
<posOrigine>=2: label décalé à droite à l’origine (valeur par défaut),
<posOrigine>=-2 label décalé à gauche à l’origine,
<labelPos>=0 : pas de label du tout,
<Re(labelpos)>=top: labels au-dessus,
Re(<labelPos>)=bottom : labels en-dessous (valeur par défaut),
Im(<Im(labelPos>)=1: labels orthogonaux à l’axe.
axeY(<[origine, posOrigine, etendue]>, <Ypas> [, Subdiv, labelPos , num, ""texte"", den, firstnum] ).
Description : pour tracer et graduer un axe des abscisses passant par <origine> et avec un pas de <Ypas>. Le paramètre <etendue> représente sous forme complexe l’intervalle des ordonnées ymin+i*ymax, si celui-ci est omis, alors le tracé occupe la fenêtre. Remarque: pour préciser une valeur de <etendue> sans préciser de valeur pour <posOrigine>, il suffit de mettre jump à la place de <posOrigine> (et non pas Nil!).
<Subdiv> est le nombre de subdivisions par unité, chaque ordonnée est multipliée par la fraction <num/den> (1 par défaut), ajoutée à <firstnum/den> (l’origine par défaut) et accompagnée du <"texte"> au numérateur. Pour que le séparateur décimal soit la virgule à la place du point, il suffit de mettre la variable usecomma à la valeur 1. Cette macro est également sensible aux variables dollar (pour ajouter ou non des $ autour des labels des graduations), et nbdeci qui fixe le nombre de décimales affichées.
Les paramètres optionnels <posOrigine> et <labelpos> permettent de positionner les labels:
<posOrigine>=0: pas de label à l’origine,
<posOrigine>=1: label normal à l’origine,
<posOrigine>=2: label décalé vers le haut à l’origine (valeur par défaut),
<posOrigine>=-2 label décalé vers le bas à l’origine,
<labelPos>=0 : pas de label du tout,
<Re(labelpos)>=left: labels à gauche de l’axe (valeur par défaut),
Re(<labelPos>=right : labels à droite de l’axe,
Im(<labelPos>)=1: labels orthogonaux à l’axe.
view(-5,5,-5,5),size(7.5), LabelSize:=footnotesize, //graphique du haut SaveWin(), view(-5,5,0.25,5),Width:=6, Arrows:=1, SetMatrix([2.5*i,2/pi,2*i]), axeX(0,pi/2,Nil,Nil,1,"",2), axeY(0,1), Arrows:=0, Color:=red, Width:=8, tMin:=-2*pi, tMax:=2*pi, Cartesienne(sin(x)), Label(pi*1.65+i,"f(x) = sin(x)"),RestoreWin(), //graphique du bas SaveWin(), Color:=black, view(-5,5,-5,-0.25), SetMatrix([-5.5*i,2,i]), Width:=6, Arrows:=1, usecomma:=1, axeX([i,0],0.5), axeY([i,0],1,Nil,Nil,1,"a"), Arrows:=0, Color:=blue, Width:=8, Cartesienne(x^2+1), Label(1+4.75*i,"g(x) = x2 + a"), RestoreWin()
background( <fillstyle>, <fillcolor> ).
Description : permet de remplir le fond de la fenêtre graphique avec le style et la couleur demandée. Cette macro met à jour la variable backcolor.
bbox().
Description : permet d’ajuster la fenêtre à la "bounding box" autour du dessin courant. Cette macro est destinée à être utilisée dans la ligne de commande en bas de la fenêtre principale, et non pas dans un élément graphique.
centerView( <affixe> ).
Description : permet de centrer la fenêtre graphique sur le point représenté par <affixe>, sans changer les dimensions courantes du graphique. Cette macro est plutôt destinée à être utilisée dans la ligne de commande en bas de la fenêtre principale.
Cercle( <A>, <r> [, B] ).
Description : trace un cercle de centre <A> et de rayon <r> lorsque le troisième paramètre est omis, sinon c’est le cercle défini par les trois points <A>, <r> et <B>.
Pour les macros Arc et Cercle, on peut s’attendre à des surprises dans le résultat final si le repère n’est pas orthonormé! Le repère est orthonormé lorsque les variables Xscale et Yscale sont égales, voir option Paramètres/Fenêtre.
view(-5,5,-1,3),Marges(0,0,0,0), size(7.5), Seg(-5,5), for t in [-4,-1.85,0,1.85,3] do M:=t-sin(t)+i*(1-cos(t)), I:=t+i, DotStyle:=cross, Point(I), DotStyle:=bigdot, Point(M), Cercle(I,1), Seg(M,I), Arrows:=1, Arc(M,I,t,0.5,t), Arrows:=0, LineStyle:=dashed, Seg(I,t), LineStyle:=solid od, Width:=8,Color:=red, Courbe( t-sin(t)+i*(1-cos(t)))
Clip( <liste> ).
Description : permet de clipper les éléments graphiques déjà dessinés avec la <liste> qui doit être une courbe fermée et simple. La macro peint l’extérieur de la courbe représentée par la <liste>.
Dbissec( <B>, <A>, <C>, <1 ou 2> ).
Description : dessine la bissectrice de l’angle $\widehat{BAC}$, intérieure si le dernier paramètre vaut 1 et extérieure pour la valeur 2.
Dcarre( <A>, <B>, <+/-1> [, rayon] ).
Description : dessine de carré de sommets consécutifs <A> et <B> dans le sens direct si le troisième paramètre vaut 1 (indirect pour - 1). Si le paramètre <rayon> est présent, alors les øg coins de la figure seront arrondis par un arc de cercle ayant le rayon mentionné.
Ddroite( <A>, <B> ).
Description : dessine la demi-droite [A, B).
Dmed( <A>, <B> [, angle droit(0/1)] ).
Description : dessine la médiatrice du segment [A, B]. Si le troisième paramètre vaut 1 (0 par défaut) alors un angle droit est dessiné.
domaine1( <f(x)> [, a, b] ).
Description : dessine la partie du plan comprise entre la courbe Cf, l’axe Ox et les droites x = a, x = b si a et b sont précisés, sinon x = tMin et x = tMax.
domaine2( <f(x)>, <g(x)> [, a, b] ).
Description : dessine la partie du plan comprise entre les courbes Cf, Cg et les droites x = a, x = b si a et b sont précisés, sinon x = tMin et x = tMax.
domaine3( <f(x)>, <g(x)> ).
Description : délimite la partie du plan comprise entre les courbes Cf et Cg avec x dans l’intervalle [tMin,tMax], en recherchant les points d’intersection.
view(-5,5,-4,5),size(7.5),tMin:=-5, Axes(-5,1+i,2+2*i), tMax:=-1, Cartesienne(sin(x)), tMax:=5, Cartesienne(2*cos(x)),tMin:=-3,tMax:=3, Cartesienne(x^2), A:=-4.5+(Ymin+1.75)*i, FillStyle:=full, FillOpacity:=0.5,FillColor:=green, LabelStyle:=left, LabelSize:=footnotesize, Dcarre(A+0.25*(-1+i), A+0.25*(1+i), -1), Label(A+0.4,"domaine2 sur [ - 4 ; - 1. 5] "), Inc(A,-0.75*i), FillColor:=blue, Dcarre(A+0.25*(-1+i), A+0.25*(1+i),-1), Label(A+0.4,"domaine3 entre 2cos(x) et x2 "), Inc(A,-0.75*i), FillColor:=red, Dcarre(A+0.25*(-1+i), A+0.25*(1+i),-1), Label(A+0.4,"domaine1 sur [1. 1 ; 4]"), FillColor:=red, domaine1(2*cos(x), 1.1, 4), FillColor:=green, domaine2(2*cos(x), sin(x),-4,-1.5), FillColor:=blue, domaine3(2*cos(x),x^2), Arrows:=2, tangente(2*cos(x),0.5,1.5)
Dparallel( <[A, B]> , <C> ).
Description : dessine la parallèle à la droite <[A,B]> passant par <C>.
Dparallelo( <A>, <B> , <C> [, rayon] ).
Description : dessine le parallèlogramme de sommets consécutifs <A>, <B> et <C>. Si le paramètre <rayon> est présent, alors les øg coins de la figure seront arrondis par un arc de cercle ayant le rayon mentionné.
Dperp( <[A, B]> , <C> [, angle droit(0/1)] ).
Description : dessine la perpendiculaire à la droite <[A,B]> passant par <C>. Si le troisième paramètre vaut 1 (0 par défaut) alors un angle droit est dessiné.
Dpolyreg( <centre> , <sommet>, <nombre de côtés> [, rayon] ).
Description : dessine le polygône régulier défini par le <centre>, un <sommet> et le <nb de côtés>. Si le paramètre <rayon> est présent, alors les øg coins de la figure seront arrondis par un arc de cercle ayant le rayon mentionné.
Dpolyreg( <sommet1>, <sommet2>, <nombre de cotés +sens*i> [, rayon] ).
Description : dessine le polygône régulier défini par deux sommets consécutifs <sommet1> et <sommet2>, le <nb de côtés>, et le <sens> (1 pour direct et - 1 pour indirect). Si le paramètre <rayon> est présent, alors les øg coins de la figure seront arrondis par un arc de cercle ayant le rayon mentionné.
DpqGoneReg( <centre> , <sommet>, <[p,q]> ).
Description : dessine le <p/q>-gône régulier défini par le <centre> et un <sommet>.
view(-5,5,-6,6),Marges(0,0,0,0),size(7.5), FillStyle:=full, FillColor:=lightpink, Color:=blue, Width:=8, DpqGoneReg(-2.5+2.5*i,-2.5+0.25*i, [7,3]), Label(-2.5+5*i,"[7,3]"), DpqGoneReg(2.5+2.5*i,2.5+0.25*i, [7,2]), Label(2.5+5*i,"[7,2]"), DpqGoneReg(-2.5-2.5*i,-2.5-0.25*i, [7,1]), Label(-2.5-5*i,"[7,1]"), DpqGoneReg(2.5-2.5*i,2.5-0.25*i, [6,2]), Label(2.5-5*i,"[6,2]")
drawSet( <ensemble> ).
Description : dessine un ensemble produit par les macros capB, cupB ou setminusB.
Drectangle( <A>, <B> , <C> [, rayon] ).
Description : dessine le rectangle de sommets consécutifs <A>, <B>, le côté opposé passant par <C>. Si le paramètre <rayon> est présent, alors les øg coins de la figure seront arrondis par un arc de cercle ayant le rayon mentionné.
ellipticArc( <B>, <A>, <C>, <RX>, <RY>, <sens(+/-1)> [, inclinaison] ).
Description : dessine un arc d’ellipse de centre <A>, allant de <B> à <C> de rayons <RX> et <RY>, l’axe portant le rayon <RX> ayant une certaine <inclinaison> par rapport à l’horizontale, celle-ci est en degrés et vaut 0 par défaut, le paramètre <sens> indique le sens de rotation, 1 pour le sens trigonométrique.
flecher( <liste>, <pos1, ..., posN> ).
Description : dessine des flèches le long de la ligne polygonale <liste>, la position de chaque flèche (pos1, ...) est un nombre entre 0 et 1 (0 pour début de la ligne et 1 pour fin de ligne), les flèches sont dessinées dans le sens de parcourt de la ligne, pour inverser une flèche on ajoute +i à la position.
Exemple(s) : flecher(Get(Cercle(0,3)), [0,0.5] )
GradDroite( <[A, origine + i*posOrigine, etendue]>, <[u, unit]>, <hautDiv>, <subdiv> [, poslab, orientation, num, ""texte"", den, firstnum] )
Description : gradue la droite passant par <A> et dirigée par le vecteur <u> (celui-ci n’est pas forcément unitaire), <hautdiv> est la hauteur des graduations en cm, <subdiv> est le nombre de subdivisions par unité.
Paramètres optionnels:
<origin>: indique la graduation de l’origine <A> (0 par défaut),
<posOrigin>: indique la position du label à l’origine <A>, plusieurs cas:
<posOrigin>=0: pas de label à l’origine,
<posOrigin>=1: label normal à l’origine (comme les autres)
<posOrigin>=2: label à l’origine décalé dans le sens du vecteur <u> (valeur par défaut),
<posOrigin>=-2: label à l’origine décalé dans le sens opposé du vecteur <u>.
<etendue>: représente l’intervalle des graduations sous forme complexe: min+i*max, le tracé de l’axe sera limité à cet intervalle. Si ce paramètre est omis, le tracé occupera la fenêtre.
<unit>: indique le pas des graduations sur l’axe (1 par défaut), cette valeur doit être positive.
<poslab> indique la position des labels par rapport à l’axe, ce paramètre prend les valeurs top ou bottom,
<orientation>: orientation des labels, la valeur i signifie que les labels sont orthogonaux à l’axe, sinon l’orientation représente le LabelStyle (left, right, top, ...),
chaque graduation est multipliée par la fraction <num/den> (1 par défaut), ajoutée à <firstnum/den> (l’origine par défaut) et accompagnée du <"texte"> au numérateur. Pour avoir une virgule comme spérateur décimal au lieu du point, il faut mettre la variable usecomma à la valeur 1. Cette macro est également sensible aux variables dollar (pour ajouter ou non des $ autour des labels des graduations), et nbdeci qui fixe le nombre de décimales affichées. Le nombre maximal de graduations est fixé par la variable maxGrad qui vaut 100 par défaut.
Exemple(s) : GradDroite([0,1+2*i],[1,0.5], xyticks, 1, bottom, i): signifie que la graduation de l’origine sera 1 avec un label décalé à droite, les graduations iront de 0.5 en 0.5, les labels seront sous l’axe et orthogonaux à l’axe.
LabelArc( <B>, <A>, <C>, <R>, <sens>, <"texte">, [, options] ).
Description : cette macro dessine un arc de cercle de centre <A>, de rayon <R> partant de la droite (AB) jusqu’à la droite (AC), l’argument facultatif <sens> indique: le sens trigonométrique si sa valeur est 1 (valeur par défaut), le sens contraire si valeur est -1. La macro ajoute également le <"texte">. Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
labelpos := < inside/outside >: positionnement du label (outside par defaut)),
labelsep := < distance en cm >: distance du label à l’arc (0.25cm par défaut).
rotation := < nombre >: angle en degrés que fait le label par rapport à l’horizontale (0 par défaut).
Il est possible dans la liste des options, de modifier des attributs comme Color par exemple.
LabelAxe( <x ou y>, <affixe>, <label> [, [labelPos,décalage en cm], mark(0/1)] ).
Description : permet d’ajouter un label sur un des axes <x ou y>, <affixe> désigne l’affixe du point où se fait l’ajout, <label> contient le texte à ajouter. Paramètres optionnels, <[labelPos, décalage en cm]> et <mark>:
Re(<labelpos>)=1 signifie en dessous pour Ox et à droite pour Oy (par défaut pour Ox),
Re(<labelpos>)=2 signifie au dessus pour Ox et à gauche pour Oy (par défaut pour Oy),
Im(<labelpos>)=-1 signifie un décalage sur la gauche pour Ox, vers le bas pour Oy, si le décalage n’est pas précisé, il vaut 0.25 cm par défaut,
Im(<labelpos>)=1 signifie un décalage sur la droite pour Ox, vers le haut pour Oy, si le décalage n’est pas précisé, il vaut 0.25 cm par défaut,
Im(<labelpos>)=0 signifie pas de décalage (valeur par défaut),
<mark>: indique si le point doit être marqué (dans le dotsyle courant).
LabelDot( <affixe>, <"texte">, <orientation> [, DrawDot, distance] ).
Description : cette macro affiche un texte à coté du point <affixe>. L’orientation peut être "N" pour nord, "NE" pour nord-est ...etc, ou bien une liste de la forme [longueur, direction] où direction est un complexe, dans ce deuxième cas, le paramètre optionnel <distance> est ignoré. Le point est également affiché lorsque <DrawDot> vaut 1 (0 par défaut) et on peut redéfinir la <distance> en cm entre le point et le texte (0.25cm par défaut).
LabelSeg( <A>, <B>, <"texte">, [, options] ).
Description : cette macro dessine le segment défini par <A> et <B>, et ajoute le <"texte">. Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
labelpos := < center/top/bottom >: positionnement du label (center par défaut),
labelsep := < distance en cm >: distance du label au segment lorsque labelpos vaut top ou bottom (0.25cm par défaut).
rotation := < nombre >: angle en degrés que fait le label par rapport à l’horizontale (par défaut le label est parallèle au segment).
Il est possible dans la liste des options, de modifier des attributs comme Color par exemple.
markangle( <B>, <A>, <C>, <r>, <n>, <espacement>, <longueur> ).
Description : même chose que markseg mais pour marquer un arc de cercle.
markseg( <A>, <B>, <n>, <espacement>, <longueur> [, angle] ).
Description : marque le segment [A, B] avec <n> petits segments, l’<espacement> est en unité graphique, et la <longueur> en cm. Le paramètre optionnel <angle> permet de définir en degré l’angle que feront les marques par rapport à la droite (AB) (45 degrés par défaut).
periodic( <f(x)>, <a>, <b> [, divisions, discontinuités] ).
Description : trace la courbe de la fonction périodique définie par y = f(x) sur la période [a; b], puis translate le motif pour couvrir l’intervalle [tMin; tMax]. Les deux paramètres optionnels sont identiques à ceux des courbes paramétrées (nombre de divisions et discontinuités).
view(-5,5,-5,5), size(7.5), Axes(0,1+i), Width:=8, Color:=red, periodic(if t>0 then 4 else 2 fi,-1,1,5,1), Color:=blue, periodic(2*abs(t)-1,-1,1), Color:=magenta, periodic(sin(t)-3,-pi/2,pi/2)
Rarc( <B>, <A>, <C>, <R>, <sens> ).
Description : comme la macro Arc sauf que l’arc de cercle est rond même si le repère n’est pas orthonormé, le rayon <R> est en centimètres.
Rcercle( <A>, <R> ) ou Rcercle( <A>, <B>, <C> ).
Description : dessine un cercle rond même si le repère n’est pas orthonormé. Dans la première forme, le rayon <R> est en centimètres.
Rellipse( <O>, <RX>, <RY> [, inclinaison] ).
Description : comme la commande Ellipse sauf que celle-ci est insensible au repère écran, les rayons sont en centimètres.
RellipticArc( <B>, <A>, <C>, <RX>, <RY>, <sens(+/-1)> [, inclinaison] ).
Description : comme la macro ellipticArc sauf que celle-ci est insensible au repère écran, les rayons sont en centimètres.
RestoreWin().
Description : restaure la fenêtre graphique ainsi que la matrice 2D enregistrées lors du dernier appel à la macro SaveWin.
SaveWin().
Description : enregistre la fenêtre graphique ainsi que la matrice 2D courantes, sur une pile. Cette macro va de paire avec la macro RestoreWin.
Exemple(s) : plusieurs graphiques sur un seul: voir cet exemple.
Seg( <A>, <B> ).
Description : dessine le segment [A, B].
set( <nom>, <affixe centre> [, options] ).
Description : dessine un ensemble en forme de patatoïde, <affixe centre> désigne le centre de cet ensemble, et le paramètre <nom> est une chaîne contenant le nom de cet ensemble. Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
scale := < entier positif >: représente l’échelle (1 par défaut),
rotation := < angle en degrés >: permettant d’incliner le dessin (0 degré par défaut),
labels := < 0/1 >: pour afficher ou non le nom de l’ensemble.
labelsep := < distance en cm >: distance du label au bord de l’ensemble (0.45cm par défaut)
Il est possible dans la liste des options, de modifier des attributs comme LabelStyle par exemple.
La macro renvoie en résultat la liste des points de la courbe dessinant l’ensemble.
setB( <nom>, <affixe centre> [, options] ).
Description : dessine un ensemble en forme de patatoïde à l’aide de courbes de Bézier, <affixe centre> désigne le centre de cet ensemble, et le paramètre <nom> est une chaîne contenant le nom de cet ensemble. Le paramètre <options> est une liste (facultative) de la forme [ option1:= valeur1, ..., optionN:=valeurN ], les options sont:
scale := < entier positif >: représente l’échelle (1 par défaut),
rotation := < angle en degrés >: permettant d’incliner le dessin (0 degré par défaut),
labels := < 0/1 >: pour afficher ou non le nom de l’ensemble.
labelsep := < distance en cm >: distance du label au bord de l’ensemble (0.45cm par défaut)
Il est possible dans la liste des options, de modifier des attributs comme LabelStyle par exemple.
La macro renvoie en résultat la liste des points de contrôle de la courbe représentant l’ensemble. Cette liste peut-être utilisée ensuite pour déterminer une intersection (voir capB), une réunion (voir capB) ou une différence (voir setminusB).
size( <largeur + i*hauteur> [, ratio(Xscale/Yscale)] )
Description : permet de fixer les tailles du graphique: <largeur> et <hauteur> (marges incluses) en cm. Si le paramètre <hauteur> est nul, alors on considère que hauteur=largeur.
Si le paramètre <ratio> est omis, les échelles sur les deux axes sont calculées pour que la figure entre au plus juste dans le cadre fixé, tout en conservant le ratio courant.
Si <ratio> est égal à 0 alors les échelles sont calculées de manière à obtenir exactement la taille souhaitée (le ratio courant n’est donc vraisemblablement pas conservé).
Le repère est orthonormé lorsque le paramètre <ratio> vaut 1.
NB: un appel aux fonctions Fenetre Marges ou à la macro view, modifiera la taille du graphique. Il est donc préférable de déterminer les marges et la fenêtre graphique avant de fixer la taille.
La largeur d’un graphique est donnée par la formule:
et la hauteur est donnée par:
suite( <f(x)>, <u0>, <n> ).
Description : représentation graphique de la suite définie par un + 1 = f(un), de premier terme <u0> et jusqu’au rang <n>. Cette macro ne représente que les "escaliers".
view(-0.1,1.1,-0.1,1.1),size(7.5), Arrows:=1,Axes(0,1/2+i/4),Arrows:=0, u0:=0.3,nb:=20, Width:=6, Color:=darkseagreen, Droite(1,-1,0), Color:=red, tMin:=0, tMax:=1, Width:=8, Cartesienne(4*x*(1-x)), Width:=6, Color:=blue, Label(0.5+1.05*i,"un + 1 = 4un(1 - un)"), LabelDot(u0, "u0","S",1), suite(4*x*(1-x), u0,nb)
tangente( <f(x)>, <x0> [, longueur] ).
Description : trace la tangente à la courbe cartésienne y = f(x) au point d’abscisse <x0>, on trace un segment de la <longueur> indiquée (en cm) ou la droite entière si la longueur est omise.
tangenteP( <f(t)>, <t0> [,longueur] ).
Description : trace la tangente à la courbe paramétrée par <f(t)> au point de paramètre <t0>, on trace un segment de la <longueur> indiquée (en cm) ou la droite entière si la longueur est omise.
view( <xmin>, <xmax>, <ymin>, <ymax> ) ou view( <[xmin+i*ymin, xmax+i*ymax]> )
Description : change la fenêtre graphique courante et conserve l’échelle. Attention: ceci change la taille du graphique, celle-ci peut-être modifiée avec la macro size.
Exemple(s) : dans un élément graphique utilisateur, la commande [ view(-4, 4,-3, 3), size(12) ] va fixer la fenêtre graphique à [ - 4, 4] × [ - 3, 3], et la taille du graphique à 12cm en conservant le ratio courant. Il est important de respecter l’ordre (view avant size).
wedge( <B>, <A>, <C>, <r> )
Description : dessine le secteur angulaire défini par l’angle $\widehat{BAC}$ avec un rayon <r>.
zoom( <+/-1> )
Description : permet de faire un zoom arrière/avant.
Option Elément graphique/Créer/Utilisateur du menu. ↩