From ae575882b0c25855564e1f482d98a681c8d8e445 Mon Sep 17 00:00:00 2001 From: Jean-Michel Sarlat Date: Thu, 22 Sep 2011 00:05:47 +0200 Subject: [PATCH] Introduction de la doc en ligne de TeXgraph... pour tester :) --- docs/index.xml | 3 + docs/texgraph/chap05.html | 673 ++++++++++++++++++ docs/texgraph/chap05.tex | 1391 +++++++++++++++++++++++++++++++++++++ docs/texgraph/chap07.html | 688 ++++++++++++++++++ docs/texgraph/chap07.tex | 1069 ++++++++++++++++++++++++++++ docs/texgraph/index.css | 14 + docs/texgraph/index.xml | 8 + docs/texgraph/tex2html | 87 +++ texgraph.php | 4 +- 9 files changed, 3935 insertions(+), 2 deletions(-) create mode 100644 docs/index.xml create mode 100644 docs/texgraph/chap05.html create mode 100644 docs/texgraph/chap05.tex create mode 100644 docs/texgraph/chap07.html create mode 100644 docs/texgraph/chap07.tex create mode 100644 docs/texgraph/index.css create mode 100644 docs/texgraph/index.xml create mode 100755 docs/texgraph/tex2html diff --git a/docs/index.xml b/docs/index.xml new file mode 100644 index 0000000..bc4cd55 --- /dev/null +++ b/docs/index.xml @@ -0,0 +1,3 @@ + + Documentation liée + diff --git a/docs/texgraph/chap05.html b/docs/texgraph/chap05.html new file mode 100644 index 0000000..8100d67 --- /dev/null +++ b/docs/texgraph/chap05.html @@ -0,0 +1,673 @@ +

Liste des commandes

+

Notations:

+

<argument>: signifie que l’argument est obligatoire.

+

[argument]: signifie que l’argument est facultatif.

+

Args

+ +

Assign

+ +

{for $k from 0 to 5 do Assign(%1,t,k), %1 od}

+

%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

+ +

Border

+ +

ChangeAttr

+ +

Clip2D

+ +

CloseFile

+ +

ComposeMatrix

+ +

Copy

+ +

NB: pour des raisons de compatibilité avec l’ancienne version, l’index 0 correspond aussi au dernier élément de la liste.

+

DefaultAttr

+ +

Del

+ +

NB: pour des raisons de compatibilité avec l’ancienne version, l’index 0 correspond aussi au dernier élément de la liste.

+

Delay

+ +

DelButton

+ +

DelGraph

+ +

DelItem

+ +

DelMac

+ +

DelText

+ +

DelVar

+ +

Der

+ +

Diff

+ +

Echange

+ +

EpsCoord

+ +

Eval

+ +
     if Input("x=", "Entrez une valeur pour x", x )
+     then x:= Eval( chaine() )
+     fi 
+
+

Exec

+ +
      [Export(pgf,[@TmpPath,"file.pgf"] ), 
+       Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+       Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+      ]
+
+

Export

+ +
      [Export(pgf,[@TmpPath,"file.pgf"] ), 
+       Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+       Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+      ]
+
+

ExportObject

+ +

Fenetre

+ +

Free

+ +

Get

+ +
+
+

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

+ +

GetMatrix

+ +

GetSpline

+ +

GrayScale

+ +

HexaColor

+ +

Hide

+ +

IdMatrix

+ +

Input

+ +

InputMac

+ +

Inc

+ +

Insert

+ +

Int

+ +

IsMac

+ +

IsVar

+ +

Liste

+ +

ListFiles

+ +

LoadImage

+ +

Loop

+ +

Map

+ +

Marges

+ +

Merge

+ +

Message

+ +

Move

+ +

Mtransform

+ +

MyExport

+ +

Nargs

+ +
    for $k from 1 to Nargs()/2 do
+         Label(Args(2*k-1), Args(2*k))
+    od
+
+

NewButton

+ +

NewGraph

+ +
 if Input("Label=")
+ then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ), 
+      ReDraw(), Inc(num,1)
+ fi
+
+

NewItem

+ +

NewMac

+ +

NewVar

+ +

Nops

+ +

NotXor

+ +

OpenFile

+ +

OriginalCoord

+ +

PermuteWith

+ +

ReadData

+ +

ReadFlatPs

+ +

ReCalc

+ +

Attention: l’utilisation de ReCalc() dans un élément graphique entraîne une récursion infinie et donc un plantage du programme!

+

ReDraw

+ +

RenCommand

+ +

RenMac

+ +

RestoreAttr

+ +

Reverse

+ +

Rgb

+ +

SaveAttr

+ +

Seq

+ +

Set

+ +

SetAttr

+ +

SetMatrix

+ +
+
+

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

+ +

Si

+ +

Solve

+ +

Sort

+ +

Special

+ +

Str

+ +

StrArgs

+ +

StrComp

+ +

String

+ +

Stroke

+ +
          [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

+ +

Timer

+ +

TimerMac

+ +

VisibleGraph

+ +

WriteFile

+ +
 if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi
+
+
+
+
    +

  1. 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. ↩

    2. +

  2. 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). ↩

    3. +

  3. 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, ...). ↩

    4. +
+
diff --git a/docs/texgraph/chap05.tex b/docs/texgraph/chap05.tex new file mode 100644 index 0000000..89b8355 --- /dev/null +++ b/docs/texgraph/chap05.tex @@ -0,0 +1,1391 @@ +\chapter{Liste des commandes} + +Notations: + +: signifie que l'argument est \Mytextbf{obligatoire}. + +[argument]: signifie que l'argument est \Mytextbf{facultatif}. + + +\section{Args}\label{cmdArgs} + +\begin{itemize} +\item \util \textbf[Args()]{Args( )}. + +\item \desc cette fonction n'a d'effet que dans une macro, elle évalue et renvoie l'argument numéro \argu{entier} avec +lequel la macro a été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la commande +\Helpref{StrArgs}{cmdStrArgs} + +\item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}. +\end{itemize} + +\section{Assign}\label{cmdAssign} + +\begin{itemize} +\item \util \textbf[Assign()]{Assign( , , )}. + +\item \desc cette fonction évalue \argu{valeur} et l'affecte à la variable nommée \argu{variable} dans +\argu{expression}\footnote{C'est la première occurrence de \argu{variable} dans \argu{expression} qui est assignée, car +toutes les occurrences pointent sur la même , sauf éventuellement pour les macros après l'affectation des +paramètres.}. La fonction \textit{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. + +\item \exem voici une macro \co{Bof} qui prend une fonction f(t) en paramètre et qui calcule la liste $[f(0), f(1), +..., f(5)]$: +\end{itemize} + +\centerline{\co{for \$k from 0 to 5 do Assign(\%1,t,k), \%1 od}} + +\%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 \co{Bof(t\^{}2)} donne: \res{[0,1,4,9,16,25]}. L'exécution de \co{Bof(x\^{}2)} donne \Nil. + +\section{Attributs}\label{cmdAttributs} + +\begin{itemize} +\item \util \textbf[Attributs()]{Attributs()}. + +\item \desc 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 \textit{OK}, elle renvoie la valeur 0 s'il a choisi \textit{Cancel}. Si +l'utilisateur a choisi \textit{OK}, alors les variables globales correspondant aux attributs sont modifiées en +conséquence. +\end{itemize} + +\section{Border}\label{cmdBorder} + +\begin{itemize} +\item \util \textbf[Border()]{Border( <0/1> )} + +\item \desc 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. +\end{itemize} + +\section{ChangeAttr}\label{cmdChangeAttr} + +\begin{itemize} +\item \util \textbf[ChangeAttr()]{ChangeAttr( , ..., )} +\item \desc cette fonction permet de modifier les attributs des éléments graphiques \argu{element1}, ..., +\argu{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. +\end{itemize} + +\section{Clip2D}\label{cmdClip2D} + +\begin{itemize} +\item \util \textbf[Clip2D()]{Clip2D( , [, close(0/1) ] )}. +\item \desc cette fonction clippe la \argu{ligne polygonale} qui doit être une variable contenant une liste de +complexes, avec le \argu{contour convexe}, qui est lui aussi une liste de complexes. La fonction calcule la ligne +polygonale qui en résulte modifie la variable \argu{ligne polygonale} en conséquence, le dernier +agument \argu{close} ($0$ par défaut) permet de préciser si la \argu{ligne polygonale} doit être refermée ou non. La +fonction renvoie \Nil. +\end{itemize} + +\section{CloseFile}\label{cmdCloseFile} + +\begin{itemize} +\item \util \textbf[CloseFile()]{CloseFile()}. +\item \desc cette fonction permet de fermer le fichier ouvert par la commande \Helpref{OpenFile}{cmdOpenFile}. +\end{itemize} + + +\section{ComposeMatrix}\label{cmdComposeMatrix} + +\begin{itemize} +\item \util \textbf[ComposeMatrix()]{ComposeMatrix( <[z1, z2, z3]> )} +\item \desc 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 \argu{[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 +\Helpref{GetMatrix}{cmdGetMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix}). +\end{itemize} + + +\section{Copy}\label{cmdCopy} + +\begin{itemize} +\item \util \textbf[Copy()]{Copy( , , )}. + +\item \desc cette fonction renvoie la liste constituée par les \argu{nombre} éléments de la \argu{liste} à partir de +l'élément numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie tous les éléments de la +liste à partir de l'élément numéro \argu{départ}. + +Si le numéro \argu{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$ $\cdots$ etc. La fonction renvoie les \argu{nombre} éléments de +la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche, mais la liste renvoyée est dans le même +sens que la \argu{liste}, et cette dernière n'est pas modifiée. + +\item \exem +\begin{itemize} + \item \co{Copy([1,2,3,4],2,2)} renvoie \res{[2,3]}. + \item \co{Copy([1,2,3,4],2,5)} renvoie \res{[2,3,4]}. + \item \co{Copy([1,2,3,4],2,0)} renvoie \res{[2,3,4]}. + \item \co{Copy([1,2,3,4],-1,2)} renvoie \res{[3,4]}. + \item \co{Copy([1,2,3,4],-2,2)} renvoie \res{[2,3]}. + \item \co{Copy([1,2,3,4],-2,0)} renvoie \res{[1,2,3]}. +\end{itemize} +\end{itemize} + +\Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier +élément de la liste. + +\section{DefaultAttr}\label{cmdDefaultAttr} + +\begin{itemize} +\item \util \textbf[DefaultAttr()]{DefaultAttr()} + +\item \desc cette fonction met toutes les variables correspondant aux attributs (\var{Color}, \var{Width}, ...) à leur +valeur par défaut. Cette fonction renvoie la valeur \Nil. +\end{itemize} + + +\section{Del}\label{cmdDel} + +\begin{itemize} +\item \util \textbf[Del()]{Del( , , )}. + +\item \desc supprime de la \argu{liste} \argu{nombre} éléments à partir du numéro \argu{départ} [inclus]. Si +\argu{nombre} est nul, alors la fonction supprime tous les éléments de la liste à partir de l'élément numéro +\argu{départ}. + + +Si le numéro \argu{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$ $\cdots$ etc. La fonction supprime les \argu{nombre} éléments de +la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche. + +Le paramètre \argu{liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la fonction renvoie \Nil. + +\item \exem la commande \co{[x:=[1,2,3,4], Del(x,2,2), x]} renvoie \res{[1,4]}. + +La commande \co{[x:=[1,2,3,4], Del(x,-2,2), x]} renvoie \res{[1,4]}. + +\end{itemize} + +\Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier +élément de la liste. + +\section{Delay}\label{cmdDelay} + +\begin{itemize} +\item \util \textbf[Delay()]{Delay( )} + +\item \desc permet de suspendre l'exécution du programme pendant le laps de temps indiqué (en milli-secondes). +\end{itemize} + +\section{DelButton}\label{cmdDelButton} + +\begin{itemize} +\item \util \textbf[DelButton()]{DelButton( , ..., )} + +\item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les boutons portant les +inscriptions \argu{texte1}, ..., \argu{texteN}. Si la liste est vide (\textsl{ 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. +\end{itemize} + +\section{DelGraph}\label{cmdDelGraph} + +\begin{itemize} +\item \util \textbf[DelGraph()]{DelGraph( , ..., )} + +\item \desc Cette fonction permet de supprimer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN}. Si +la liste est vide (\textsl{ 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. +\end{itemize} + +\section{DelItem}\label{cmdDelItem} + +\begin{itemize} +\item \util \textbf[DelItem()]{DelItem( , ..., )} + +\item \desc Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options +appelées +\argu{nom1}, ..., \argu{nomN}. Si la liste est vide (\textsl{ 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. +\end{itemize} + +\section{DelMac}\label{cmdDelMac} + +\begin{itemize} +\item \util \textbf[DelMac()]{DelMac( , ..., )} + +\item \desc Cette fonction permet de supprimer les macros (non prédéfinies) appelées \argu{mac1}, ..., \argu{macN}. Si +la liste est vide (\textsl{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. +\end{itemize} + +\section{DelText}\label{cmdDelText} + +\begin{itemize} +\item \util \textbf[DelText()]{DelText( , ..., )} + +\item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les labels \argu{texte1}, +..., \argu{texteN}. Si la liste est vide (\textsl{ 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. +\end{itemize} + +\section{DelVar}\label{cmdDelVar} + +\begin{itemize} +\item \util \textbf[DelVar()]{DelVar( , ..., )} + +\item \desc Cette fonction permet de supprimer les variables globales (non prédéfinies) appelés \argu{var1}, ..., +\argu{varN}. Si la liste est vide (\textsl{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. +\end{itemize} + + +\section{Der}\label{cmdDer} + +\begin{itemize} +\item \util \textbf[Der()]{Der( , , )}. + +\item \desc cette fonction calcule la dérivée de \argu{expression} par rapport à \argu{variable} et l'évalue en donnant +à \argu{variable} les valeurs successives de la \argu{liste}. La fonction \textsl{Der} renvoie la liste des résultats. +Mais si on a besoin de \textsl{l'expression de la dérivée}, alors on préférera la fonction \Helpref{Diff}{cmdDiff}. + +\item \exem +\begin{itemize} +\item la commande \co{Der(1/x,x,[-1,0,2] )} renvoie \res{[-1,-0.25]}. +\item Voici le texte d'une macro appelée \co{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: + +\centerline{\co{[Assign(\%1,x,\%2), \$A:=\%2+i*\%1, \$Df:=Der(\%1,x,\%2), Droite(A, A+1+i*Df)]}} + +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)$. +\end{itemize} +\end{itemize} + +\section{Diff}\label{cmdDiff} + +\begin{itemize} +\item \util \textbf[Diff()]{Diff( , , [, param1,..., paramN] )} + +\item \desc cette fonction permet de créer une macro appelée \argu{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 \argu{expression} par rapport à \argu{variable}. Les paramètres optionnels sont des noms de +variables, le nom de la variable \argu{param1} est remplacé dans l'expression de la dérivée par le paramètre \%1, le nom +\argu{param2} est remplacé par \%2 ... etc. Cette fonction renvoie \Nil. + +\item \exem après l'exécution de la commande (dans la ligne de commande en bas de la fenêtre): + \co{Diff(df, sin(3*t), t)}, une macro appelée \res{df} est créée et son contenu est: \res{3*cos(3*t)}, c'est une macro +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 $\backslash$)\footnote{Si par exemple on veut tracer la courbe représentative de cette fonction, +dans l'option \textit{Courbe/Paramétrée}, il faudra saisir la commande \textit{t+i*$\backslash$df} et non pas +\textit{t+i*df(t)}.}. Par contre après la commande \co{Diff(df,sin(3*t),t,t)}, le contenu de la macro \res{df} est: +\res{3*cos(3*\%1)} qui est une macro à un paramètre. +\end{itemize} + +\section{Echange}\label{cmdEchange} + +\begin{itemize} +\item \util \textbf[Echange()]{Echange( , )}. + +\item \desc 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: + +{\centering \co{[aux:=variable1, variable1:=variable2, variable2:=aux]}\par} + + La fonction \textsl{Echange} renvoie la valeur \Nil. +\end{itemize} + +\section{EpsCoord}\label{cmdEpsCoord} + +\begin{itemize} +\item \util \textbf[EpsCoord()]{EpsCoord( )} + +\item \desc renvoie l'affixe exportée en eps. Pour les autres, il y a les macros \Helpref{TeXCoord}{macTeXCoord} et +\Helpref{SvgCoord}{macSvgCoord}. +\end{itemize} + +\section{Eval}\label{cmdEval} + +\begin{itemize} +\item \util \textbf[Eval()]{Eval( )}. + +\item \desc cette fonction évalue l'\argu{expression} et renvoie le résultat. L'\argu{expression} est interprétée comme +une \Helpref{chaîne de caractères}{chaine}. + +\item La fonction \Helpref{{Input}}{cmdInput} renvoie la saisie sous forme d'une chaîne dans la macro appelée +\textit{chaine()}. La fonction \textsl{Eval} évalue cette chaîne (comme n'importe quelle commande TeXgraph) et renvoie +le résultat. + +\item \exem voici une commande demandant une valeur à l'utilisateur pour une variable \textit{x}: +\end{itemize} + +\begin{verbatim} + if Input("x=", "Entrez une valeur pour x", x ) + then x:= Eval( chaine() ) + fi +\end{verbatim} + + +\section{Exec}\label{cmdExec} + +\begin{itemize} +\item \util \textbf[Exec()]{Exec( [, argument(s), répertoire de travail, attendre] )}. + +\item \desc cette fonction permet d'exécuter un \argu{programme} (ou un script) en précisant éventuellement des +\argu{arguments} et un \argu{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. + +\item La macro-chaîne prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu} +exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute +\textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de +pdf. + +\item \exem la macro \textsl{Apercu} contenue dans interface.mac est: +\end{itemize} + +\begin{verbatim} + [Export(pgf,[@TmpPath,"file.pgf"] ), + Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1), + Exec(@PdfReader,"apercu.pdf",@TmpPath,0) + ] +\end{verbatim} + +\section{Export}\label{cmdExport} + +\begin{itemize} +\item \util \textbf[Export()]{Export( , )}. + +\item \desc cette fonction permet d'exporter le graphique en cours, \argu{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 \argu{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 \textit{Apercu} +exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute +\textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de +pdf. + +\item \exem la macro \textsl{Apercu} contenue dans interface.mac est: +\end{itemize} + +\begin{verbatim} + [Export(pgf,[@TmpPath,"file.pgf"] ), + Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1), + Exec(@PdfReader,"apercu.pdf",@TmpPath,0) + ] +\end{verbatim} + +\section{ExportObject}\label{cmdExportObject} + +\begin{itemize} + \item \textbf[ExportObject()]{ExportObject( )} + \item \desc cette commande n'a d'effet que pendant un export. Elle permet d'exporter l'\argu{argument} dans le fichier +de sortie, cet \argu{argumet} est soit le nom d'un élément graphique, soit une commande graphique (comme pour la +fonction \Helpref{Get}{cmdGet}). Elle peut-être utile pour écrire des exports personnalisés, ceci est décrit dans +\Helpref{cette section}{cmdMyExport}. +\end{itemize} + +\section{Fenetre}\label{cmdFenetre} + +\begin{itemize} +\item \util \textbf[Fenetre()]{Fenetre( , [, C] )}. +\item \desc cette fonction modifie la fenêtre graphique, c'est l'équivalent de l'option \textit{Paramètres/Fenêtre}, +\Mytextbf{sauf que les éléments graphiques ne sont pas automatiquement recalculés}. Le paramètre \argu{A} et le +paramètre \argu{B} sont les affixes de deux coins de la fenêtre diamétralement opposés, et le paramètre facultatif +\argu{C} représente les deux échelles, plus précisément, la partie réelle de \argu{C} est l'échelle [en cm] sur l'axe +des abscisses et la partie imaginaire de \argu{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. +\end{itemize} + +\section{Free}\label{cmdFree} + +\begin{itemize} +\item \util \textbf[Free()]{Free( , }. +\item \desc cette fonction renvoie $1$ si l'\argu{expression} contient la \argu{variable}, $0$ sinon. Lorsque le +deuxième argument n'est pas un nom de variable, la fonction renvoie \Nil. +\end{itemize} + +\section{Get}\label{cmdGet} + +\begin{itemize} +\item \util \textbf[Get()]{Get( [, clip(0/1)] )}. +\item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un +élément graphique dont le nom est \argu{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 \argu{argument} n'est pas un identificateur, celui-ci est considéré comme une \textit{fonction graphique}, la +fonction \textsl{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 \argu{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: \textsl{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. + +\item \exem \co{Get(Cercle(0,1))} renvoie la liste des points du cercle de centre 0 et de rayon 1 mais sans créer ce +cercle, la liste des points est clippée par la fenêtre graphique. + +\item \exem utilisation des points d'un objet graphique: +\end{itemize} + +\begin{demo}{Get}{Get} +\begin{texgraph}[name=Get,export=pgf,file] +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,"$C_1$","N"), + Color:=red, + LabelDot(3-i,"$C_2$","E"), + ]; +\end{texgraph} +\end{demo} + + +\section{GetAttr}\label{cmdGetAttr} + +\begin{itemize} +\item \util \textbf[GetAttr()]{GetAttr( )} + +\item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un +élément graphique dont le nom est \argu{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. +\end{itemize} + +\section{GetMatrix}\label{cmdGetMatrix} + +\begin{itemize} +\item \util \textbf[GetMatrix()]{GetMatrix()} + +\item \desc cette fonction renvoie la matrice courante. (Voir aussi les commandes +\Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix}) +\end{itemize} + +\section{GetSpline}\label{cmdGetSpline} + +\begin{itemize} +\item \util \textbf[GetSpline()]{GetSpline(, ,..., , )} +\item \desc renvoie la liste des points de contrôle correspondant à la spline cubique passant par les points +\argu{A0} jusqu'à \argu{An}. \argu{V0} et \argu{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 \Helpref{Bezier}{cmdBezier}. +\end{itemize} + + +\section{GrayScale}\label{cmdGrayScale} + +\begin{itemize} +\item \util \textbf[GrayScale()]{GrayScale(0/1)} ou \textbf[GrayScale()]{GrayScale()}. + +\item \desc cette fonction permet d'activer ou désactiver la conversion des couleurs en niveaux de gris. Elle équivaut à +l'option \textsl{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. +\end{itemize} + +\section{HexaColor}\label{cmdHexaColor} + +\begin{itemize} +\item \util \textbf[HexaColor()]{HexaColor( )} + +\item \desc cette fonction renvoie la couleur correspondant à la \argu{valeur héxadécimale}, cette valeur doit être +passée sous forme d'une chaîne de caractères. Voir aussi la commande \Helpref{Rgb}{cmdRgb}. + +\item \exem \verb Color:=HexaColor("F5F5DC") . +\end{itemize} + +\section{Hide}\label{cmdHide} + +\begin{itemize} +\item \util \textbf[Hide()]{Hide( , ..., )} + +\item \desc Cette fonction permet de cacher les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en +mettant leur attribut \textsl{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: \textsl{Hide()}. + +Pour tout cacher sauf un ou plusieurs éléments, on invoque la commande: \textsl{Hide(except, element1, ..., elementN)}. +Voir aussi la commande \Helpref{Show}{cmdShow}. +\end{itemize} + +\section{IdMatrix}\label{cmdIdMatrix} + +\begin{itemize} +\item \util \textbf[IdMatrix()]{IdMatrix()} +\item \desc change la matrice courante en la matrice identité. (Voir aussi les commandes +\Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{GetMatrix}{cmdGetMatrix}) +\end{itemize} + + + +\section{Input}\label{cmdInput} + +\begin{itemize} +\item \util \textbf[Input()]{Input( [, titre, chaîne] )}. +\item \desc cette fonction ouvre une boite de dialogue avec \argu{titre} dans la barre de titre (par défaut le titre +est vide), et dans laquelle le paramètre \argu{message} est affiché, le paramètre \argu{chaîne} est affiché dans la zone +de saisie. Ces paramètres sont donc interprétés comme des \Helpref{chaînes de caractères}{chaine}, l'utilisateur est +invité à faire une saisie. S'il valide alors la fonction \textsl{Input} renvoie la valeur $1$ et la chaîne saisie est +\Mytextbf{mémorisée dans la macro} \textsl{chaine()}. Si l'utilisateur ne valide pas ou si la chaîne saisie est vide, +alors la fonction \textsl{Input} renvoie la valeur $0$. +\item \exem voir la fonction \Helpref{Eval}{cmdEval}. +\end{itemize} + +\section{InputMac}\label{cmdInputMac} + +\begin{itemize} +\item \util \textbf[InputMac()]{InputMac( )} ou \textbf[Load()]{Load( )}. +\item \desc cette fonction permet de charger en mémoire un fichier de macros (\textit{*.mac}), ou un fichier modèle +(\textit{*.mod}), ou tout fichier source texgraph (\textit{*.teg}). + +Dans le premier cas (fichier \textit{*.mac}), les variables globales et les macros seront considérées comme +\Mytextbf{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 \argu{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 \textit{macros} de \textit{TeXgraph}, ou dans le dossier \textit{TeXgraphMac}, alors il +est inutile de préciser le chemin. +\item \exem \co{InputMac("MesMacros.mac")}. +\end{itemize} + +\section{Inc}\label{cmdInc} + +\begin{itemize} +\item \util \textbf[Inc()]{Inc( , )}. +\item \desc cette fonction évalue \argu{expression} et ajoute le résultat à \argu{variable}. Cette fonction est plus +avantageuse que la commande \co{variable := variable + expression}, car dans cette commande la \argu{variable} est +évaluée [c'est à dire dupliquée] pour calculer la somme. La fonction \textsl{Inc} renvoie la valeur \Nil. +\end{itemize} + + +\section{Insert}\label{cmdInsert} + +\begin{itemize} +\item \util \textbf[Insert()]{Insert( , [, position] )}. +\item \desc cette fonction insère la \argu{liste2} dans la \argu{liste1} à la position numéro \argu{position}. Lorsque +la position vaut 0 [valeur par défaut]. La \argu{liste2} est ajoutée à la fin. La \argu{liste1} doit être une variable +et celle-ci est modifiée. La fonction \textsl{Insert} renvoie la valeur \Nil. +\item \exem si une variable $L$ contient la liste \co{[1,4,5]}, alors après la commande \co{Insert(L,[2,3],2)}, la +variable $L$ contiendra la liste \res{[1,2,3,4,5]}. +\end{itemize} + +\section{Int}\label{cmdInt} + +\begin{itemize} +\item \util \textbf[Int()]{Int( , , , )}. +\item \desc cette fonction calcule l'intégrale de \argu{expression} par rapport à \argu{variable} sur l'intervalle +\Mytextbf{réel} défini par \argu{borne inf.} et \argu{borne sup}. Le calcul est fait à partir de la méthode de +\textsc{Simpson} accélérée deux fois avec la méthode de \textsc{Romberg}, \argu{expression} est supposée définie et +suffisamment régulière sur l'intervalle d'intégration. +\item \exem \co{Int(exp(sin(u)),u,0,1)} donne \res{1.63187} (Maple donne 1.631869608). +\end{itemize} + +\section{IsMac}\label{cmdIsMac} + +\begin{itemize} +\item \util \textbf[IsMac()]{IsMac( )}. +\item \desc cette fonction permet de savoir s'il y a une macro appellée \argu{nom}. Elle renvoie $1$ si c'est +le cas, $0$ sinon. +\end{itemize} + +\section{IsVar}\label{cmdIsVar} + +\begin{itemize} +\item \util \textbf[IsVar()]{IsVar( )}. +\item \desc cette fonction permet de savoir s'il y a une variable globale appellée \argu{nom}. Elle renvoie $1$ si c'est +le cas, $0$ sinon. +\end{itemize} + +\section{Liste}\label{cmdListe} + +\begin{itemize} +\item \util \textbf[Liste()]{Liste( , ..., )} ou bien \Mytextbf{[, ..., +]}. +\item \desc cette fonction évalue chaque argument et renvoie la liste des résultats \Mytextbf{différents de \Nil}. +\item \exem \co{Liste(1, Arg(1+2*i), sqrt(-1), Solve(cos(x)-x,x,0,1))} renvoie le résultat +\res{[1,1.107149,0.739085]}. +\end{itemize} + +\section{ListFiles}\label{cmdListFiles} + +\begin{itemize} +\item \util \textbf[ListFiles()]{ListFiles()}. +\item \desc 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 (\textit{*.mac}) chargés en mémoire. +\end{itemize} + +\section{LoadImage}\label{cmdLoadImage} + +\begin{itemize} +\item \util \textbf[LoadImage()]{LoadImage( )}. +\item \desc cette fonction charge le fichier \argu{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. +\end{itemize} + + +\section{Loop}\label{cmdLoop} + +\begin{itemize} +\item \util \textbf[Loop()]{Loop( , )}. +\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste en évaluant \argu{expression} et +\argu{condition} jusqu'à ce que le résultat de \argu{condition} soit égal à 1 (pour \textit{True}) ou \Nil, la fonction +\textsl{Loop} renvoie alors la liste des résultats de \argu{expression}. Cette commande est la représentation interne de +la boucle \Helpref{{repeat}}{cmdrepeat} dont l'utilisation est préférable pour des raisons de lisibilité. +\item \exem les commandes (équivalentes): + +\centerline{\co{[n:=1, m:=1, n, Loop([ aux:=n, n:=m, m:=aux+n, n], m>100)]}} + +ou encore + +\centerline{\co{[n:=1, m:=1, n, while m<=100 do aux:=n, n:=m, m:=aux+n, n od]}} + +ou encore + +\centerline{\co{[n:=1, m:=1, n, repeat aux:=n, n:=m, m:=aux+n, n until m>100 od]}} + +renvoient la liste: \res{[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]} (termes d'une suite de \textsc{Fibonacci} inférieurs à +100). +\end{itemize} + +\section{Map}\label{cmdMap} + +\begin{itemize} +\item \util \textbf[Map()]{Map( , , [, mode] )}. +\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable} +parcourt les éléments de \argu{liste} et pour chacun d'eux \argu{expression} est évaluée, la fonction \textsl{Map} +renvoie la liste des résultats. Cette commande est la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont +l'utilisation est préférable pour des raisons de lisibilité. + +Le paramètre optionnel \argu{mode} est un complexe qui vaut \Nil par défaut, lorsque \argu{mode}$=a+ib$, alors: + \begin{itemize} + \item si $a$ est un entier et $b=0$: les éléments de la \argu{liste} sont traités de $a$ en $a$, + \item si $a$ est un entier et $b=1$: la \argu{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é. + \item si $a$ est un entier et $b=-1$: la \argu{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é. + \item si $a=$Re(jump): la \argu{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$. + + \item \exem voir la boucle \Helpref{for}{cmdfor} pour des exemples. + \end{itemize} + + +\item \exem si $L$ est une variable contenant une liste de points, alors la commande: + \begin{itemize} + \item \co{[sum:=0, Map( Inc(sum,z), z, L), sum]} renvoie la somme des éléments de $L$. + \item la commande \co{Map(z*exp(i*$\pi$/3), z, L)} renvoie la liste des images des points de $L$ par la rotation +de centre O d'angle $\pi$/3. + \end{itemize} +\end{itemize} + +\section{Marges}\label{cmdMarges} + +\begin{itemize} +\item \util \textbf[Marges()]{Marges( , , , )} +\item \desc cette fonction permet de fixer les marges autour du dessin (en cm). Les nouvelles valeurs sont copiées dans +les constantes \var{margeG}, \var{margeD}, \var{margeH} et \var{margeB}. +\end{itemize} + + +\section{Merge}\label{cmdMerge} + +\begin{itemize} +\item \util \textbf[Merge()]{Merge( )}. +\item \desc cette fonction permet de recoller des morceaux de listes pour avoir des composantes de longeur maximale, +elle renvoie la liste qui en résulte. +\item \exem \co{Merge([1, 2, jump, 3, 5, jump, 3, 4, 2] )} renvoie \res{[1, 2, 3, 4, 5]}. Et \co{Merge( [1, 2, jump, 3, +5, jump, 3, 4] )} renvoie \res{[1, 2, jump, 4, 3, 5]}. + +Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine. +\end{itemize} + + +\section{Message}\label{cmdMessage} + +\begin{itemize} +\item \util \textbf[Message()]{Message( )}. +\item \desc cette fonction affiche le paramètre \argu{chaîne} [qui est donc interprété comme une \Helpref{chaîne de +caractères}{chaine}] dans une fenêtre. Quand l'utilisateur a cliqué sur \textit{OK}, la fenêtre se referme et la +fonction renvoie la valeur \Nil. +\end{itemize} + +\section{Move}\label{cmdMove} + +\begin{itemize} +\item \util \textbf[Move()]{Move( , ..., )}. +\item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode NotXor, ce qui correspond à la valeur +1 de la variable \Helpref{PenMode}{cmdPenMode}. Elle redessine les éléments graphiques \argu{element1}, ..., +\argu{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). +\item\exem voir la fonction \Helpref{Stroke}{cmdStroke}. +\end{itemize} + +\section{Mtransform}\label{cmdMtransform} + +\begin{itemize} +\item \util \textbf[Mtransform()]{Mtransform( , )}. +\item \desc cette fonction applique la \argu{matrice} à la \argu{liste} et renvoie le résultat. Si la \argu{liste} +contient la constante \jump, celle-ci est renvoyée dans le résultat sans être modifiée. La \argu{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). +\end{itemize} + +\section{MyExport} + +\begin{itemize} + \item \textbf[MyExport()]{MyExport( <"nom">, , ..., )} ou \textbf[draw()]{draw( +<"nom">, , ..., )} + \item \desc cette commande permet d'ajouter de nouveaux éléments graphiques avec un export personnalisé. Elle est +décrite dans \Helpref{cette section}{cmdMyExport}. +\end{itemize} + +\section{Nargs}\label{cmdNargs} + +\begin{itemize} +\item \util \textbf[Nargs()]{Nargs()}. +\item \desc 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 \Helpref{Args}{cmdArgs}. +\item\exem voici le corps d'une macro \textit{MyLabel(affixe1, texte1, affixe2, texte2, ...)} prenant un nombre +indéterminé d'arguments: +\end{itemize} + +\begin{verbatim} + for $k from 1 to Nargs()/2 do + Label(Args(2*k-1), Args(2*k)) + od +\end{verbatim} + +\section{NewButton}\label{cmdNewButton} + +\begin{itemize} +\item \util \textbf[NewButton()]{NewButton( , , , , [, aide] )}. +\item \desc cette fonction crée dans la zone grisée à gauche dans la fenêtre un bouton dont le numéro d'identification +est \Mytextbf{l'entier} \argu{Id}, le texte figurant sur le bouton est le paramètre \argu{nom} qui est donc interprété +comme une \Helpref{chaîne de caractères}{chaine}, la position du coin supérieur gauche est donnée par le paramètre +\argu{affixe} qui doit être de la forme X+i*Y avec X et Y \Mytextbf{entiers} car ce sont des coordonnées en +\Mytextbf{pixels}, la taille du bouton est donnée par le paramètre \argu{taille} qui doit être de la forme +\textit{long+i*haut} où \textit{long} désigne la longueur du bouton en pixels et \textit{haut} la hauteur (ce sont donc +des entiers), le paramètre \argu{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 \argu{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 \Mytextbf{sauf si +c'est un bouton prédéfini} (c'est à dire créé au démarrage). \`A chaque changement de fichier, les boutons non +prédéfinis sont détruits. La fonction \Mytextbf{NewButton} renvoie la valeur \Nil. +\end{itemize} + +\section{NewGraph}\label{cmdNewGraph} + +\begin{itemize} +\item \util \textbf[NewGraph()]{NewGraph( , [, code] )}. + +\item \desc cette fonction crée un élément graphique \textsl{Utilisateur} ayant pour nom: \argu{chaîne1} et défini par +la commande: \argu{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 \textsl{ReDraw()} qui permet de mettre l'affichage à +jour. + +Le troisième paramètre \argu{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 \textsl{ClicGraph( + )}, 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 \textit{Mouse.mod} (dessin à la souris). + +\item Supposons que l'utilisateur clique sur le point d'affixe 1+i, alors une fenêtre de dialogue s'ouvre avec le +message \textsl{Label=} et une ligne de saisie à remplir. Supposons que l'utilisateur entre la chaîne \textsl{Test} et +valide, alors la macro va créer un élément graphique \textsl{utilisateur} portant le nom \textsl{Label1} et défini par +la commande \co{Label(1+i,"Test")}. + +\item On peut aussi utiliser la macro prédéfinie \textsl{NewLabel} et définir la macro \textsl{ClicG()} +en écrivant simplement: \co{NewLabel(\%1) }. + +\item \exem voici une macro \textsl{ClicG()} permettant la création "à la volée" de labels, on a créé auparavant + une variable globale \textsl{num} initialisée à 1: +\end{itemize} + +\begin{verbatim} + if Input("Label=") + then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ), + ReDraw(), Inc(num,1) + fi +\end{verbatim} + +\section{NewItem}\label{cmdNewItem} + +\begin{itemize} +\item \util \textbf[NewItem()]{NewItem( , )}. +\item \desc cette fonction ajoute dans la liste déroulante de la zone grisée à gauche dans la fenêtre, un item appelé +\argu{nom}, le deuxième paramètre \argu{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 \Mytextbf{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 +\textsl{NewItem} renvoie la valeur \Nil. +\end{itemize} + +\section{NewMac}\label{cmdNewMac} + +\begin{itemize} +\item \util \textbf[NewMac()]{NewMac( , [, param1, $\ldots$, paramN])}. +\item \desc cette fonction crée une macro appelée \argu{nom} et dont le contenu est \argu{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 \argu{param1} est remplacé dans l'expression de la macro par le paramètre \%1, le nom \argu{param2} est +remplacé par \%2 $\ldots$ 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 \Mytextbf{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 \argu{corps} n'est pas correcte, alors la fonction est sans effet. +\end{itemize} + +\section{NewVar}\label{cmdNewVar} +\begin{itemize} +\item \util \textbf[NewVar()]{NewVar( , )}. +\item \desc cette fonction crée une variable globale appelée \argu{nom} et dont la valeur est \argu{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 \argu{expression} n'est pas correcte, alors la valeur +affectée à la variable sera \Nil. +\end{itemize} + + +\section{Nops}\label{cmdNops} +\begin{itemize} +\item \util \textbf[Nops()]{Nops( )}. +\item \desc cette fonction évalue \argu{liste} et renvoie le nombre de complexes qui la composent. +\item \exem \co{Nops([1,2,3] )} renvoie la valeur \res{3}. +\end{itemize} + +\section{NotXor}\label{cmdNotXor} + +\begin{itemize} +\item \util \textbf[NotXor()]{NotXor( , ..., )}. +\item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode normal, ce qui correspond à la valeur +0 de la variable \Helpref{PenMode}{cmdPenMode}. Elle change le mode des éléments graphiques \argu{element1}, ..., +\argu{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). +\item\exem voir la fonction \Helpref{Move}{cmdMove}. +\end{itemize} + +\section{OpenFile}\label{cmdOpenFile} + +\begin{itemize} +\item \util \textbf[OpenFile()]{OpenFile( )}. +\item \desc 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 \Helpref{WriteFile}{cmdWriteFile} et \Helpref{CloseFile}{cmdCloseFile}, cela permet à +l'utilisateur de créer ses propres fichiers textes. +\end{itemize} + + +\section{OriginalCoord}\label{cmdOriginalCoord} + +\begin{itemize} +\item \util \Mytextbf{OriginalCoord( <0/1> )} ou \textbf[OriginalCoord()]{OriginalCoord()} +\item \desc cette fonction détermine si le repère à l'exportation en \textit{pstricks} et \textit{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 (\textit{pstricks} et \textit{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 \TeX. + +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. +\end{itemize} + +\section{PermuteWith}\label{cmdPermuteWith} + +\begin{itemize} +\item \util \textbf[PermuteWith()]{PermuteWith( , , [, taille des paquets ou jump] )} +\item \desc la \argu{liste à permuter} doit être une variable, celle-ci sera permutée selon le \argu{liste d'index} qui +est une liste d'entiers strictement positifs. La \argu{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. +\item \exem: +\begin{itemize} +\item \co{[L:=[-1,0,3,5], PermuteWith([4,3,2,1], L), L]} renvoie \res{[5,3,0,-1]}. +\item \co{[L:=[-1,0,3,5], PermuteWith([4,3,4,1], L), L]} renvoie \res{[5,3,5,-1]}. +\item \co{[L:=[-1,0,3,5,6,7,8], PermuteWith([4,3,2,1], L, 2), L]} renvoie \res{[6,7,3,5,-1,0]}. +\item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8,jump], PermuteWith( [4,3,3,1,2], L, jump), L]} renvoie +\res{[8,jump,5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}. +\item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8], PermuteWith([4,3,3,1,2], L, jump), L]} renvoie +\res{[5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}. +\item \co{[L:=[-1,1,5,jump,0,3,jump,5,6,7,jump,8,9], PermuteWith( [2,1], L), L]} renvoie +\res{[1,-1,jump,3,0,jump,6,5,jump,9,8]}. +\end{itemize} +\end{itemize} + +\section{ReadData}\label{cmdReadData} + +\begin{itemize} +\item \util \textbf[ReadData()]{ReadData( [, type de lecture, séparateur] )}. +\item \desc cette fonction ouvre un \argu{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 \Helpref{chaîne de caractères}{chaine} qui +contient le nom du fichier (plus éventuellement son chemin). L'argument (optionnel) suivant \argu{type de lecture} est +une valeur numérique qui peut valoir: +\begin{itemize} +\item \argu{type de lecture}=1: la fonction lit le fichier réel par réel et renvoie la liste ou les listes lues: +\verb|[x1, x2, ...]|, +\item \argu{type de lecture}=2: La fonction lit le fichier complexe par complexe, c'est à dire \Mytextbf{par paquets de +deux réels} et renvoie la ou les listes lues sous forme d'affixes: \verb|[x1+i*x2, x3+i*x4, ...]|. C'est la valeur par +défaut, +\item \argu{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: \verb|[x1+i*x2, x3, x4+i*x5, x6, ...]|. +\end{itemize} + +Le troisième argument \argu{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 \co{"LF"} (\textit{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 \og complet\fg\ est ignoré. +\item \exem supposons qu'un fichier texte \textit{test.dat} contienne exactement ceci: + +\begin{verbatim} +1 2 3 4 5/ 6 +7 8 9 10 11/ 12 +13 14 15 16 17/ 18 +\end{verbatim} + +alors l'exécution de: + \begin{itemize} + \item \co{ReadData("test.dat")} donne: \res{[1+2*i,3+4*i,5+6*i,7+8*i,9+10*i,11+12*i,13+14*i,15+16*i,17+18*i]}, + \item \co{ReadData("test.dat",1,"/")} donne: +\res{[1,2,3,4,5,jump,6,7,8,9,10,11,jump,12,13,14,15,16,17,jump,18]}, + \item \co{ReadData("test.dat",2,"/")} donne: +\res{[1+2*i,3+4*i,jump,6+7*i,8+9*i,10+11*i,jump,12+13*i,14+15*i,16+17*i,jump]}, + \item \co{ReadData("test.dat",3,"/")} donne: +\res{[1+2*i,3,jump,6+7*i,8,9+10*i,11,jump,12+13*i,14,15+16*i,17,jump]}, + \item \co{ReadData("test.dat",3,"LF")} donne: +\res{[1+2*i,3,4+5*i,6,jump,7+8*i,9,10+11*i,12,jump,13+14*i,15,16+17*i,18,jump]}. + \end{itemize} +\end{itemize} + + +\section{ReadFlatPs}\label{cmdReadFlatPs} + +\begin{itemize} +\item \util \textbf[ReadFlatPs()]{ReadFlatPs( )}. +\item \desc cette fonction ouvre un \argu{fichier} en lecture, celui-ci est censé être un fichier écrit en +\textit{flattened postscript}. La fonction renvoie la liste des chemins contenus dans le fichier, le premier complexe de +la liste est \textit{largeur+i*hauteur} en cm, puis le premier complexe de chaque chemin est \textit{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 \textit{flattened postscript} grâce à +l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). La macro \Helpref{{conv2FlatPs}}{macconv2FlatPs} permet +cette conversion en supposant que l'utilitaire est installé sur votre système. + +La fonction \textsl{ReadFlatPs} est surtout utilisée en interne par la macro \Helpref{{loadFlatPs}}{macloadFlatPs} 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 \Helpref{{drawFlatPs}}{macdrawFlatPs}. + +Ce système est utilisé par la macro \Helpref{{NewTeXLabel}}{macNewTeXlabel} pour récupérer les formules TeX compilées. +\end{itemize} + + +\section{ReCalc}\label{cmdReCalc} + +\begin{itemize} +\item \util \Mytextbf{ReCalc( , ..., )} ou \textbf[ReCalc()]{ReCalc()}. +\item \desc 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 \textsl{Recalcul Automatique}. Si la liste est vide (\textsl{ReCalc()}) alors tout le graphique est +recalculé. Après le recalcul l'affichage est mis à jour et la fonction renvoie \Nil. +\end{itemize} + +\Mytextbf{Attention}: l'utilisation de \textsl{ReCalc()} dans un élément graphique entraîne une récursion infinie et +donc un plantage du programme! + +\section{ReDraw}\label{cmdReDraw} + +\begin{itemize} +\item \util \Mytextbf{ReDraw( , ..., )} ou \textbf[ReDraw()]{ReDraw()}. +\item \desc cette fonction (re)dessine les éléments graphiques dont les noms sont dans la liste. Si la liste est vide +(\textsl{ReDraw()}) alors tous les élments sont redessinés. Cette fonction renvoie la valeur \Nil. +\end{itemize} + +\section{RenCommand}\label{cmdRenCommand} + +\begin{itemize} +\item \util \textbf[RenCommand()]{RenCommand( , )}. +\item \desc cette fonction renomme la commande appelée \argu{nom}. Les deux arguments sont donc interprétés comme des +chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas +de commande portant ce \argu{nom}, ou s'il a déjà une commande portant le nom \argu{nouveau}, alors la fonction est sans +effet. +\end{itemize} + +\section{RenMac}\label{cmdRenMac} + +\begin{itemize} +\item \util \textbf[RenMac()]{RenMac( , )}. +\item \desc cette fonction renomme la macro appelée \argu{nom}. Les deux arguments sont donc interprétés comme des +chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas +de macro portant ce \argu{nom}, ou s'il a déjà une macro portant le nom \argu{nouveau}, alors la fonction est sans +effet. +\end{itemize} + + +\section{RestoreAttr}\label{cmdRestoreAttr} + +\begin{itemize} +\item \util \textbf[RestoreAttr()]{RestoreAttr()}. +\item \desc restaure l'ensemble des attributs sauvegardés dans une pile par la commande \Helpref{SaveAttr}{cmdSaveAttr}. +\end{itemize} + + +\section{Reverse}\label{cmdReverse} +\begin{itemize} +\item \util \textbf[Reverse()]{Reverse( )}. +\item \desc renvoie la \argu{liste} inversée. +\end{itemize} + +\section{Rgb}\label{cmdRgb} + +\begin{itemize} +\item \util \textbf[Rgb()]{Rgb( , , )}. +\item \desc cette fonction renvoie un entier représentant la couleur dont les trois composantes sont \argu{rouge}, +\argu{vert} et \argu{bleu}, ces trois valeurs doivent être des nombres \Mytextbf{compris entre 0 et 1}. Voir aussi la +commande \Helpref{HexaColor}{cmdHexaColor}. +\item \exem \co{Color:= Rgb(0.5,0.5,0.5))} sélectionne le gris. +\end{itemize} + +\section{SaveAttr}\label{cmdSaveAttr} + +\begin{itemize} +\item \util \textbf[SaveAttr()]{SaveAttr()}. +\item \desc sauvegarde sur une pile l'ensemble des attributs courants. Voir aussi \Helpref{RestoreAttr}{cmdRestoreAttr}. +\end{itemize} + + +\section{Seq}\label{cmdSeq} + +\begin{itemize} +\item \util \textbf[Seq()]{Seq( , , , [, pas] )}. +\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable} +est initialisée à \argu{départ} puis, tant que \argu{variable} est dans l'intervalle (fermé) défini par \argu{départ} +et \argu{fin}, on évalue \argu{expression} et on incrémente \argu{variable} de la valeur de \argu{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 \argu{variable} +sort de l'intervalle, la boucle s'arrête et la fonction \textsl{Seq} renvoie la liste des résultats. Cette commande est +la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont l'utilisation est préférable pour des raisons de +lisibilité. +\item \exem \co{Seq(exp(i*k*pi/5,k,1,5)} renvoie la liste des racines cinquièmes de l'unité. La commande: + +\centerline{\co{Ligne( Seq( exp(2*i*k*pi/5, k, 1, 5), 1)}} + +renverra la valeur \Nil mais dessinera un pentagone (voir \Helpref{Ligne}{cmdLigne}) si elle est utilisée dans un +élément graphique \textit{utilisateur}. +\end{itemize} + +\section{Set}\label{cmdSet} + +\begin{itemize} +\item \util \textbf[Set()]{Set( , )}. +\item \desc cette fonction permet d'affecter à \argu{variable}\footnote{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, $\pi$, e, ...).} la \argu{valeur} spécifiée. La fonction \textsl{Set} renvoie la valeur +\Nil. + +Cette commande est la représentation interne de l'affectation \textsl{:=}, dont l'utilisation est préférable pour des +raisons de lisibilité. +\end{itemize} + +\section{SetAttr}\label{cmdSetAttr} + +\begin{itemize} +\item \util \textbf[SetAttr()]{SetAttr()}. +\item \desc 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 \textsl{SetAttr} renvoie la valeur \Nil. +\end{itemize} + +\section{SetMatrix}\label{cmdSetMatrix} + +\begin{itemize} +\item \util \textbf[SetMatrix()]{SetMatrix( <[z1, z2, z3]> )}. +\item \desc 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 \Helpref{GetMatrix}{cmdGetMatrix}, +\Helpref{ComposeMatrix}{cmdComposeMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix}) + +\item \exem si $f:z \mapsto f(z)$ est une application affine, alors sa matrice est $[f(0), f(1)-f(0), f(i)-f(0)]$, ce +calcul peut-être fait par la macro \textit{matrix()} de TeXgraph.mac: \co{SetMatrix(matrix(i*bar(z)))} affecte la +matrice de la symétrie orthogonale par rapport à la première bissectrice. +\end{itemize} + + +\begin{demo}{Repère non orthogonal}{SetMatrix} +\begin{texgraph}[name=SetMatrix, export=pgf] +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() +\end{texgraph} +\end{demo} + + +\section{Show}\label{cmdShow} + +\begin{itemize} +\item \util \textbf[Show()]{Show( , ..., )}. +\item \desc Cette fonction permet de montrer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en +mettant leur attribut \textsl{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: \textsl{Show()}. Pour tout +montrer sauf un ou plusieurs éléments, on invoque la commande: \co{Show(except, element1, ..., elementN)}. Voir aussi la +commande \Helpref{Hide}{cmdHide}. +\end{itemize} + + +\section{Si}\label{cmdSi} + +\begin{itemize} +\item \util \textbf[Si()]{Si( , , ..., , [, sinon] )}. +\item \desc cette fonction évalue \argu{condition1}. Une condition est une expression dont le résultat de l'évaluation +doit être 0 [pour \textit{False}] ou 1 [pour \textit{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 \argu{expression1} et renvoie le résultat, si elle vaut +0, elle évalue \argu{condition2}, si celle-ci donne la valeur 1 alors la fonction évalue \argu{expression2}, sinon +etc... Lorsqu'aucune condition n'est remplie, la fonction évalue l'argument \argu{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 +\Helpref{{if}}{cmdif} dont la syntaxe est préférable pour des raisons de lisibilité. + +\item \exem définition d'une macro \co{f(x)} représentant une fonction f d'une variable x +définie en plusieurs morceaux: + +\centerline{\co{Si(\%1<-1,1-exp(pi*(\%1+1)),\%1<0,sin($\pi$*\%1),sh(pi*\%1))},} + +c'est à dire $f(x)=1-exp(\pi(x+1))$ si $x<-1$, $f(x)=sin(\pi x)$ si $-1\leqslant x<0$, $f(x)=$sh$(\pi x)$ sinon. + +\end{itemize} + + +\section{Solve}\label{cmdSolve} + +\begin{itemize} +\item \util \textbf[Solve()]{Solve( , , , [, n] )}. +\item \desc cette fonction "résout" l'équation \argu{expression}=0 par rapport à la variable \Mytextbf{réelle} +\argu{variable} dans l'intervalle défini par \argu{borne inf.} et \argu{borne sup.}. Cet intervalle est subdivisé en +\argu{n} parties [par défaut n=25] et on utilise la méthode de {\sc Newton} sur chaque partie. La fonction renvoie la +liste des résultats. +\item \exem +\begin{itemize} + \item \co{Solve(sin(x), x, -5, 5)} donne \res{[-3.141593, 0, 3.141593]}. + + \item Équation: $\displaystyle \int_0^x \exp(t^2)dt=1$: \co{Solve(Int( exp(u\^{}2),u,0,x)-1, x, 0, 1)} donne +\res{0.795172} et l'exécution de \co{Int(exp(u\^{}2), u, 0, 0.795172)} donne \res{1}. + + \item \co{Solve( $x^2+x+1$, x, -1, 1)} renvoie \Nil. + \end{itemize} +\end{itemize} + +\section{Sort}\label{cmdSort} + +\begin{itemize} +\item \util \textbf[Sort()]{Sort( [, option] )}. +\item \desc cette fonction trie la liste passée en argument dans l'ordre lexicographique, si l'argument \argu{option} +vaut 0 (valeur par défaut), ou dans l'ordre lexicographique inverse si l'argument \argu{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 \og composantes connexes\fg\ de la liste sont triées indépendamment les unes des autres. +La fonction renvoie la valeur \Nil. +\item \exem si la variable \textsl{L} contient la liste \res{[-2,-3+i,1,1-2*i, jump, 3,5,-6]} alors après l'exécution +de \co{Sort(L)}, la variable contiendra la liste \res{[-3+i,-2,1-2*i,1,jump,-6,3,5]}, et après l'exécution de +\co{Sort(L,1)}, la variable contiendra la liste \res{[1,1-2*i,-2,-3+i,jump,5,3,-6]}. La méthode utilisée est le Quick +Sort.. +\end{itemize} + +\section{Special}\label{cmdSpecial} + +\begin{itemize} +\item \util \textbf[Special()]{Special( )}. +\item \desc 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 \verb|\[|, +et \verb|\]|, 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). +\item \exem \co{Special("\bks psdot(\bks[1+\bks],\bks[2\^{}3\bks] )")}, écrira dans le fichier exporté: \res{\bks +psdot(2,8)}. +\end{itemize} + +\section{Str}\label{Str} + +\begin{itemize} +\item \util \textbf[Str()]{Str( )}. +\item \desc lors d'une évaluation alphanumérique, cette fonction renvoie la définition de la macro appelée \argu{nom de +macro} (sauf si c'est une macro prédéfinie). En dehors de ce contexte, la fonction \textsl{Str} renvoie \Nil. L'argument +\argu{nom de macro} est lui-même interprété comme une chaîne de caractères. +\item \exem supposons que la macro \co{f} soit définie par \co{\%1+i*sin(\%1)}, alors la commande +\co{Label(0,["f(\%1)=",Str("f")] )} affichera à l'écran à l'affixe 0, le texte: \res{f(\%1)=\%1+i*sin(\%1)}. +\end{itemize} + +\section{StrArgs}\label{cmdStrArgs} + +\begin{itemize} +\item \util \textbf[StrArgs()]{StrArgs( )}. +\item \desc cette fonction n'a d'effet que dans une macro, elle renvoie l'argument numéro \argu{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 \Helpref{Args}{cmdArgs} +\item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}. +\end{itemize} + +\section{StrComp}\label{cmdStrComp} + +\begin{itemize} +\item \util \textbf[StrComp()]{StrComp( , )}. +\item \desc les deux arguments sont interprétés comme une chaîne de caractères, et les deux chaînes sont comparées, si +elles sont égales alors la fonction renvoie la valeur 1, sinon la valeur 0. +\item \exem la combinaison de touches: Ctrl+Maj+ lance automatiquement l'exécution de la macro spéciale: +\textsl{ OnKey( )}. L'utilisateur peut définir cette macro avec par exemple la commande: + +\centerline{\co{if StrComp(\%1, "A") then Message("Lettre A") fi}} +\end{itemize} + +\section{String}\label{cmdString} + +\begin{itemize} +\item \util \textbf[String()]{String( )}. +\item \desc lors d'une évaluation alphanumérique, cette fonction renvoie \argu{expression mathématique} sous forme d'une +chaîne. En dehors de ce contexte, la fonction \textsl{String} renvoie \Nil. +\end{itemize} + +\section{Stroke}\label{cmdStroke} + +\begin{itemize} +\item \util \textbf[Stroke()]{Stroke( , ..., )}. + +\item \desc cette fonction recalcule les éléments graphiques \argu{element1}, ..., \argu{elementN}, puis les redéssine +en mode NORMAL, et renvoie la valeur \Nil. + +\item\exem on a créé deux variables globales: $a$ et \textit{drawing}. On va créer le cercle de centre a et de rayon 1, +appelé \textsl{objet1}, on souhaite pouvoir déplacer cet objet à la souris. Pour cela, on crée la macro \textsl{ClicG} +avec la commande: +\end{itemize} + +\begin{verbatim} + [PenMode:=1, {mode NotXor} + NewGraph("objet1", "Cercle(a,1)"), + PenMode:=0, {mode normal} + ReDraw(), {on montre} + drawing:=1] +\end{verbatim} + +on crée la macro \res{MouseMove} avec la commande: \co{if drawing then a:=\%1 \{on déplace le centre\}, Move(objet1) +fi}, + +puis la macro \res{LButtonUp} avec la commande: \co{if drawing then Stroke(objet1), drawing:=0 fi}. + +La macro \textsl{ClicG} crée l'objet1 en mode NotXor, rafraîchit l'affichage graphique et passe en mode "dessin". La +macro \textsl{ 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". + + +\section{TeX2FlatPs}\label{cmdTeX2FlatPs} + +\begin{itemize} +\item \util \textbf[TeX2FlatPs()]{TeX2FlatPs( <"formule"> [, dollar(0/1)] )}. + +\item \desc cette renvoie une \argu{formule} \TeX{} sous forme d'une liste de chemins, le résultat doit être dessiné +avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}. La \argu{formule} est écrite dans un fichier appelé +\textit{formula.tex}. Ce fichier est appelé par le fichier \textit{formule.tex} qui se trouve dans le dossier de +travail de TeXgraph, pour être compilé par \TeX{}. Si l'option \argu{dollar} vaut $1$ alors la formule sera délimitée +par \verb|\]| et \verb|\]|, 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 \Helpref{{ReadFlatPs}}{cmdReadFlatPs}. +\end{itemize} + + +\section{Timer}\label{cmdTimer} + +\begin{itemize} +\item \util \textbf[Timer()]{Timer( )}. + +\item \desc 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. +\end{itemize} + +\section{TimerMac}\label{cmdTimerMac} + +\begin{itemize} +\item \util \textbf[TimerMac()]{TimerMac( )}. + +\item \desc 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. + +\item \exem soit $A$ une variable globale (un point), soit \textit{dotA} un élément graphique qui dessine le point, +voilà une commande qui déplace $A$: + +\centerline{ +\co{[TimerMac("[Inc(A,0.1), if Re(A)>5 then Timer(0) else ReCalc(dotA) fi]"), A:=-5, Timer(10)]}} +\end{itemize} + +\section{VisibleGraph}\label{cmdVisibleGraph} + +\begin{itemize} +\item \util \Mytextbf{VisibleGraph( <0/1> )} ou \textbf[VisibleGraph()]{VisibleGraph()}. + +\item \desc 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. +\end{itemize} + + +\section{WriteFile}\label{cmdWriteFile} + +\begin{itemize} +\item \util \textbf[WriteFile()]{WriteFile( )}. + +\item \desc cette fonction permet d'écrire soit dans le fichier texte ouvert par la commande +\Helpref{OpenFile}{cmdOpenFile}, soit dans le fichier d'exportation si l'exécution de cette commande a lieu pendant une +exportation par l'intermédiare des macros \Helpref{Bsave}{macBsave} et/ou \Helpref{Esave}{macEsave}. + +\item \exem voici ce que pourrait être la macro \textsl{Bsave} pour modifier la taille des flêches en pstricks: +\end{itemize} + +\begin{verbatim} + if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi +\end{verbatim} diff --git a/docs/texgraph/chap07.html b/docs/texgraph/chap07.html new file mode 100644 index 0000000..9716ed8 --- /dev/null +++ b/docs/texgraph/chap07.html @@ -0,0 +1,688 @@ +

Les macros mathématiques de TeXgraph.mac

+

Opérations arithmétiques et logiques

+

Ceil

+
    +

  • Ceil( <x> ).

    • +

  • Description : renvoie le plus petit entier supérieur ou égal au réel <x>.

    • +
+

div

+
    +

  • div( <x>, <y> ).

    • +

  • Description : renvoie l’unique entier k tel que x - ky soit dans l’intervalle [0; ∣y∣[.

    • +
+

mod

+
    +

  • mod( <x>, <y> ).

    • +

  • Description : renvoie l’unique réel r de l’intervalle [0; ∣y∣[ tel que x = ky + r avec k entier.

    • +
+

not

+
    +

  • not( <expression booléenne> )

    • +

  • Description : renvoie la valeur booléenne de la négation.

    • +
+

pgcd

+
    +

  • 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

+
    +

  • ppcm( <a>, <b> )

    • +

  • Description : renvoie la valeur du ppcm de <a> et <b>.

    • +
+

Opérations sur les variables

+

Abs

+
    +

  • Abs( <affixe> ).

    • +

  • Description : cette macro donne la norme en cm.

    • +
+

free

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+ +

Opérations sur les listes

+

bary

+
    +

  • bary( <[affixe1, coef1, affixe2, coef2, ...]> ).

    • +

  • Description : renvoie le barycentre du système pondéré <[(affixe1, coef1), (affixe2, coef2),...]>.

    • +
+

del

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • isobar( <[affixe1, affixe2, ...]> ).

    • +

  • Description : renvoie l’isobarycentre du système <[affixe1, affixe2, ...]>.

    • +
+

KillDup

+
    +

  • 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

+
    +

  • length( <liste> ).

    • +

  • Description : calcule la longueur de la <liste> en cm.

    • +
+

permute

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • reverse( <liste> ).

    • +

  • Description : renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un jump).

    • +
+

SortWith

+
    +

  • 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.

    • +
+

Gestion des listes par composantes

+

La convention adoptée est que deux composantes sont séparées par la constante jump. Une composante peut être vide.

+

CpCopy

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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].

    • +
+

Gestion des listes de chaînes

+

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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • StrListDelVal( <nomListe>, <val1>, <val2>, ... ).

    • +

  • Description : cette macro supprime de <nomListe> les chaînes <val1>, <val2>..., sans avoir à connaître leurs index.

    • +
+

StrListGetKey

+
    +

  • 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

+
    +

  • 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

+
    +

  • StrListKill( <nomListe1>, <nomListe2>, ... ).

    • +

  • Description : cette macro détruit les listes de chaînes <nomListe1>, <nomListe2>, ...

    • +
+

StrListReplace

+
    +

  • StrListReplace( <nomListe>, <ancienne chaine>, <nouvelle> ).

    • +

  • Description : cette macro remplace dans la liste appelée <nomListe>, l’<ancienne chaine> par la <nouvelle>.

    • +
+

StrListReplaceKey

+
    +

  • 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

+
    +

  • 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).

    • +
+

Fonctions statistiques

+

Anp

+
    +

  • Anp( <n>, <p> ).

    • +

  • Description : renvoie le nombre d’arrangements de <p> parmi <n>.

    • +
+

binom

+
    +

  • binom( <n>, <p> ).

    • +

  • Description : renvoie le coefficient binomial (ou combinaison) <p> parmi <n>.

    • +
+

ecart

+
    +

  • ecart( <liste réels> ).

    • +

  • Description : renvoie l’écart type d’une liste de réels, la constante jump est ignorée.

    • +
+

fact

+
    +

  • fact( <n> ).

    • +

  • Description : renvoie la valeur de n! (fonction factorielle).

    • +
+

max

+
    +

  • max( <liste complexes> ).

    • +

  • Description : renvoie le plus grand élément d’une liste de complexes (ordre lexicographique), la constante jump est ignorée.

    • +
+

min

+
    +

  • min( <liste complexes> ).

    • +

  • Description : renvoie le plus petit élément d’une liste de complexes (ordre lexicographique), la constante jump est ignorée.

    • +
+

median

+
    +

  • median( <liste complexes> ).

    • +

  • Description : renvoie l’élément médian d’une liste de complexes (ordre lexicographique), la constante jump est ignorée.

    • +
+

moy

+
    +

  • moy( <liste complexes> ).

    • +

  • Description : renvoie la moyenne d’une liste de complexes, la constante jump est ignorée.

    • +
+

prod

+
    +

  • prod( <liste complexes> ).

    • +

  • Description : renvoie le produit des éléments d’une liste de complexes, la constante jump est ignorée.

    • +
+

sum

+
    +

  • sum( <liste complexes> ).

    • +

  • Description : renvoie la somme des éléments d’une liste de complexes, la constante jump est ignorée.

    • +
+

var

+
    +

  • var( <liste réels> ).

    • +

  • Description : renvoie la variance d’une liste de réels, la constante jump est ignorée.

    • +
+

Fonctions de conversion

+

RealArg

+
    +

  • RealArg( <affixe> )

    • +

  • Description : renvoie l’argument (en radians) de l’affixe réelle d’un vecteur en tenant compte de la matrice courante.

    • +
+

RealCoord

+
    +

  • RealCoord( <affixe écran> )

    • +

  • Description : renvoie l’affixe réelle d’un point compte tenu des échelles et de la matrice courante.

    • +
+

RealCoordV

+
    +

  • RealCoordV( <affixe écran> )

    • +

  • Description : renvoie l’affixe réelle d’un vecteur compte tenu des échelles de la matrice courante.

    • +
+

ScrCoord

+
    +

  • ScrCoord( <affixe réelle> )

    • +

  • Description : renvoie l’affixe écran d’un point en tenant compte des échelles et de la matrice courante.

    • +
+

ScrCoordV

+
    +

  • ScrCoordV( <affixe réelle> )

    • +

  • Description : renvoie l’affixe écran d’un vecteur en tenant compte des échelles et de la matrice courante.

    • +
+

SvgCoord

+
    +

  • SvgCoord( <screen affixe> )

    • +

  • Description : renvoie l’affixe exportée en svg en tenant compte des échelles et de la matrice courante.

    • +
+

TeXCoord

+
    +

  • 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.

    • +
+

Transformations géométriques planes

+

affin

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • shift( <liste>, <vecteur> )

    • +

  • Description : renvoie la liste des translatés des points de <liste> avec le <vecteur>.

    • +
+

simil

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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>.

    • +
+

Matrices de transformations 2D

+

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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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.

    • +
+

Constructions géométriques planes

+

Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets.

+

bissec

+
    +

  • bissec( <B>, <A>, <C>, <1 ou 2> )

    • +

  • Description : renvoie une liste de deux points de la bissectrice, 1=intérieure.

    • +
+

cap

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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:

    +

    [0.59851109463416+0.79925554731708*i, -0.99794539275033+0.00102730362483*i].

    • +
+

med

+
    +

  • med( <A>, <B> )

    • +

  • Description : renvoie une liste de deux points de la médiatrice de [A, B].

    • +
+

parallel

+
    +

  • parallel( <[A,B]>, <C> )

    • +

  • Description : renvoie une liste de deux points de la parallèle à (AB) passant par C.

    • +
+

parallelo

+
    +

  • parallelo( <A>, <B>, <C> )

    • +

  • Description : renvoie la liste des sommets du parallèlogramme de sommets consécutifs A, B, C.

    • +
+

perp

+
    +

  • perp( <[A, B]>, <C> )

    • +

  • Description : renvoie une liste de deux points de la perpendiculaire à (AB) passant par C.

    • +
+

polyreg

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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])

+
+
+

Gestion du flattened postscript

+

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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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

+
    +

  • 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:

    +

    NewTeXlabel( "label1", 0, "\frac{\pi}{\sqrt{2}}", [scale:=1.5, Color:=blue, LabelAngle:=45])

    • +
+

Autres

+

pdfprog

+
    +

  • 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é.

    • +
diff --git a/docs/texgraph/chap07.tex b/docs/texgraph/chap07.tex new file mode 100644 index 0000000..bb29089 --- /dev/null +++ b/docs/texgraph/chap07.tex @@ -0,0 +1,1069 @@ +\chapter{Les macros mathématiques de TeXgraph.mac} + +\section{Opérations arithmétiques et logiques} + +\subsection{Ceil} + +\begin{itemize} +\item \util \textbf[Ceil()]{Ceil( )}. +\item \desc renvoie le plus petit entier supérieur ou égal au réel \argu{x}. +\end{itemize} + +\subsection{div} + +\begin{itemize} +\item \util \textbf[div()]{div( , )}. +\item \desc renvoie l'unique entier $k$ tel que $x-ky$ soit dans l'intervalle $[0;|y|[$. +\end{itemize} + +\subsection{mod} + +\begin{itemize} +\item \util \textbf[mod()]{mod( , )}. +\item \desc renvoie l'unique réel $r$ de l'intervalle $[0;|y|[$ tel que +$x=ky+r$ avec $k$ entier. +\end{itemize} + +\subsection{not}\label{macnot} + +\begin{itemize} +\item \util \textbf[not()]{not( )} +\item \desc renvoie la valeur booléenne de la négation. +\end{itemize} + +\subsection{pgcd} + +\begin{itemize} +\item \util \textbf[pgcd()]{pgcd( , [, , ] )} +\item \desc renvoie la valeur d du pgcd de \argu{a} et \argu{b}, ainsi que deux coefficients de Bezout dans les +variables \argu{u} et \argu{v} (si celles-ci sont présentes), de telle sorte que $au+bv=d$. +\end{itemize} + +\subsection{ppcm} + +\begin{itemize} +\item \util \textbf[ppcm()]{ppcm( , )} +\item \desc renvoie la valeur du ppcm de \argu{a} et \argu{b}. +\end{itemize} + +\section{Opérations sur les variables} + +\subsection{Abs} + +\begin{itemize} +\item \util \textbf[Abs()]{Abs( )}. +\item \desc cette macro donne la norme en cm. +\end{itemize} + + +\subsection{free} + +\begin{itemize} +\item \util \textbf[free()]{free( )}. +\item \desc libère la variable \argu{x} en la mettant à \Nil. Depuis la version 1.93 on peut faire directement +l'affectation à la constante \Nil, par exemple: \co{x:=Nil}. +\end{itemize} + + +\subsection{IsIn} + +\begin{itemize} +\item \util \textbf[IsIn()]{IsIn( [, ] )}. +\item \desc renvoie 1 si l'\argu{affixe} est dans la fenêtre graphique, 0 sinon. Cette macro tient compte de la matrice +courante, le test se fait à \argu{epsilon} près et \argu{epsilon} vaut 0.0001 cm par défaut. +\end{itemize} + +\subsection{nil} + +\begin{itemize} +\item \util \textbf[nil()]{nil( )}. +\item \desc renvoie 1 si la variable \argu{x} est à \Nil, 0 sinon. Depuis la version 1.93 on peut faire directement le +test d'égalité avec la constante \Nil. +\end{itemize} + +\subsection{round} + +\begin{itemize} +\item \util \textbf[round()]{round( [, décimales] )} +\item \desc tronque les complexes de la \argu{liste} en arrondissant au plus proche les parties réelles et imaginaires +avec le nombre de \argu{décimales} demandé (0 par défaut). Si la \argu{liste} contient le constante \jump, alors +celle-ci est renvoyée dans la liste des résultats. Cette macro utilise la commande \Helpref{{Round}}{cmdRound} (qui ne +s'applique qu'à un complexe et non une liste). +\end{itemize} + +\section{Opérations sur les listes} + +\subsection{bary} +\begin{itemize} +\item \util \textbf[bary()]{bary( <[affixe1, coef1, affixe2, coef2, ...]> )}. +\item \desc renvoie le barycentre du système pondéré \argu{[(affixe1, coef1), (affixe2, coef2),...]}. +\end{itemize} + +\subsection{del} +\begin{itemize} +\item \util \textbf[del()]{del( , , )}. +\item \desc renvoie la liste après avoir supprimer les éléments dont l'index figure dans la \argu{liste des index à +supprimer}. La \argu{quantité à supprimer} (à chaque fois) est de $1$ par défaut, cet argument peut être une liste lui +aussi. +\item \exem + \begin{itemize} + \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8])} donne \res{[1,3,4,5,7]}. + \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8], 2)} donne \res{[1,4,5]}. + \item \co{del( [1,2,3,4,5,6,7,8], [2,6,8], [1,2])} donne \res{[1,3,4,5]}. + \item \co{del( [1,2,jump,3,4,5,jump,6,7,8],[3,7])} donne \res{[1,2,3,4,5,6,7,8]}. + \end{itemize} +\end{itemize} + +\subsection{getdot} +\begin{itemize} +\item \util \textbf[getdot()]{getdot( , )}. +\item \desc renvoie le point de la \argu{ligne polygonale} ayant \argu{s} comme abscisse curviligne. Le paramètre +\argu{s} doit être dans l'intervalle $[0;1]$, $0$ pour le premier point, et $1$ pour le dernier. +\end{itemize} + +\subsection{IsAlign} + +\begin{itemize} +\item \util \textbf[IsAlign()]{IsAlign( [, epsilon] )}. +\item \desc renvoie 1 si les points sont sur une même droite, 0 sinon. Par défaut la tolérance \argu{epsilon} vaut +1E-10. La \argu{liste} ne doit pas contenir la constante \jump. +\end{itemize} + + +\subsection{isobar} + +\begin{itemize} +\item \util \textbf[isobar()]{isobar( <[affixe1, affixe2, ...]> )}. +\item \desc renvoie l'isobarycentre du système \argu{[affixe1, affixe2, ...]}. +\end{itemize} + +\subsection{KillDup} +\begin{itemize} +\item \util \textbf[KillDup()]{KillDup( [, epsilon] )}. +\item \desc renvoie la liste sans doublons. Les comparaisons se font à \argu{epsilon} près (qui vaut $0$ par défaut). +\item \exem \co{KillDup( [1.255,1.258,jump,1.257,1.256,1.269,jump] ,1.5E-3)} renvoie \res{[1.255,1.258,1.269]}. +\end{itemize} + +\subsection{length} +\begin{itemize} +\item \util \textbf[length()]{length( )}. +\item \desc calcule la longueur de la \argu{liste} en cm. +\end{itemize} + +\subsection{permute} +\begin{itemize} +\item \util \textbf[permute()]{permute( )}. +\item \desc modifie la \argu{liste} en plaçant le premier élément à la fin, \argu{liste} doit être une variable. +\item la commande \co{[x:= [1,2,3,4], permute(x), x]} renvoie \res{[2,3,4,1]}. +\end{itemize} + +\subsection{Pos} +\begin{itemize} +\item \util \textbf[Pos()]{Pos( , , [, epsilon] )}. +\item \desc renvoie la liste des positions de l'\argu{affixe} dans la \argu{liste}, la comparaison se fait à +\argu{epsilon} près, par défaut \argu{epsilon} vaut 0. +\item la commande \co{Pos(2, [1,2,3,2,4])} renvoie \res{[2,4]}, mais \co{Pos(5, [1,2,3,2,4])} renvoie \Nil. +\end{itemize} + + +\subsection{rectangle} +\begin{itemize} +\item \util \textbf[rectangle()]{rectangle( )}. +\item \desc 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. +\end{itemize} + +\subsection{replace} +\begin{itemize} +\item \util \textbf[replace()]{replace( , , )}. +\item \desc modifie la variable \argu{liste} en remplaçant l'élément numéro \argu{position} par la \argu{valeur}, cette +macro renvoie \Nil. +\end{itemize} + +\subsection{reverse} +\begin{itemize} +\item \util \textbf[reverse()]{reverse( )}. +\item \desc renvoie la liste après avoir inverser chaque composante (deux composantes sont séparées par un \jump). +\end{itemize} + +\subsection{SortWith} +\begin{itemize} +\item \util \textbf[SortWith()]{SortWith( , , [, mode] )}. +\item \desc trie la \textbf{variable} \argu{liste} suivant les \argu{clés}. Les éléments de la \argu{liste} sont +traités par \argu{paquets}, leur taille est de 1 par défaut. La \argu{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: \argu{mode}=0 pour ordre croissant (valeur par défaut), \argu{mode}=1 pour décroissant. +\end{itemize} + +\section{Gestion des listes par composantes} + +La convention adoptée est que deux composantes sont séparées par la constante \jump. Une composante peut être vide. + +\subsection{CpCopy} +\begin{itemize} +\item \util \textbf[CpCopy()]{CpCopy( , , )}. +\item \desc cette fonction renvoie la liste constituée par les \argu{nombre} composantes de la \argu{liste} à partir de +la composante numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie toutes les composantes +de la liste à partir de la composante numéro \argu{départ}. + +Si le numéro \argu{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$ $\cdots$ etc. La fonction renvoie les \argu{nombre} +composantes de la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche, mais la liste renvoyée +est dans le même sens que la \argu{liste}, et cette dernière n'est pas modifiée. +\item \exem \begin{itemize} + \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], 2, 1)} renvoie \res{[3,7,8]}. + \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -1, 2)} renvoie \res{[4,jump,5,6]}. + \item \co{CpCopy([1,2,jump,3,7,8,jump,4,jump,5,6], -3, 0)} renvoie \res{[1,2,jump,3,7,8]}. + \end{itemize} +\end{itemize} + +\subsection{CpDel} +\begin{itemize} +\item \util \textbf[CpDel()]{CpDel( , , )}. +\item \desc cette fonction détruit dans la \argu{variable liste}, les \argu{nombre} composantes à partir +de la composante numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction détruit toutes les +composantes de la \argu{variable liste} à partir de la composante numéro \argu{départ}. + +Si le numéro \argu{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$ $\cdots$ etc. La fonction détruit les \argu{nombre} +composantes de la (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche. + +Le paramètre \argu{variable liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la macro renvoie +\Nil. +\end{itemize} + +\subsection{CpNops} +\begin{itemize} +\item \util \textbf[CpNops()]{CpNops( )}. +\item \desc cette fonction évalue \argu{liste} et renvoie le nombre de composantes qui la composent. +\item \exem + \begin{itemize} + \item \co{CpNops([1,2,jump,3] )} renvoie la valeur \res{2}. + \item \co{CpNops([1,2,jump,3,jump] )} renvoie la valeur \res{3}. + \item \co{CpNops([jump] )} renvoie la valeur \res{2}. + \end{itemize} +\end{itemize} + +\subsection{CpReplace} +\begin{itemize} +\item \util \textbf[CpReplace()]{CpReplace( , , )}. +\item \desc modifie la \argu{variable liste} en remplaçant la composante numéro \argu{position} par \argu{nouveau}, +cette macro renvoie \Nil. +\end{itemize} + +\subsection{CpReverse} +\begin{itemize} +\item \util \textbf[CpReverse()]{CpReverse( )}. +\item \desc renvoie la \argu{liste} avec les composantes dans l'ordre inverse. +\item \exem \co{CpReverse([1,2,jump,3,4,5,jump])} renvoie \res{[jump,3,4,5,jump,1,2]}. +\end{itemize} + +\section{Gestion des listes de chaînes} + +Une telle liste est en réalité une \textbf{macro}, les éléments sont indexés à partir de $1$, et la chaîne numéro $k$ +est donnée par \verb|@nomListe(k)|, alors que la longueur de la liste (nombre d'éléments) est donnée par +\verb|nomListe(0)|. + +\subsection{StrListInit}\label{macStrListInit} +\begin{itemize} +\item \util \textbf[StrListInit()]{StrListInit( , <"chaine1">, <"chaine2">, ... )}. +\item \desc crée une liste de chaines sous forme d'une macro appelée \argu{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. +\item \exem Après la commande \co{StrListInit(essai, "toto", ["toto",2/4], 24)}, une macro du nom de \Mytextbf{essai} +est créée et son contenu est: +\begin{verbatim} +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 +\end{verbatim} +\item \exem Afficher des labels avec une affixe et une orientation pour chacun, en utilisant une seule fois LabelDot. +\end{itemize} + +\begin{demo}{Utilisation de StrListInit}{StrListInit} +\begin{texgraph}[name=StrListInit,export=pgf] + 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) +\end{texgraph} +\end{demo} + +Une autre solution consiste à faire trois listes: nom, position, orientation: +\begin{verbatim} + 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) +\end{verbatim} + +\subsection{StrListAdd} +\begin{itemize} +\item \util \textbf[StrListAdd()]{StrListAdd( , <"chaine1">, <"chaine2">, ... )}. +\item \desc cette macro ajoute à la fin de la liste de chaînes appelée \argu{nomListe}, les arguments suivants (qui sont +interprétés comme des chaînes). Cela suppose que la liste \argu{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 \Helpref{StrListInit}{macStrListInit} quand c'est possible. +\end{itemize} + +\subsection{StrListCopy} +\begin{itemize} +\item \util \textbf[StrListCopy()]{StrListCopy( , [, index depart, nombre] )}. +\item \desc cette macro crée une nouvelle liste de chaînes appelée \argu{nouvelleListe} en copiant \argu{nombre} +éléments de la liste \argu{nomListe} en partant de \argu{index depart}. L'argument + 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 est positif, et dans le sens inverse quand est +négatif. Par défaut l'\argu{index depart} vaut $1$ et le \argu{nombre} vaut $0$ (ce qui signifie \og tous les +éléments\fg). +\end{itemize} + +\subsection{StrListDelKey} +\begin{itemize} +\item \util \textbf[StrListDelKey()]{StrListDelKey( , , )}. +\item \desc cette macro supprime de \argu{nomListe} \argu{nombre} éléments à partir de l'\argu{index depart}. Comme +dans la commande Del, l'argument \argu{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 est +positif, et dans le sens inverse quand est négatif. Cette macro renvoie \Nil. +\end{itemize} + +\subsection{StrListDelVal} +\begin{itemize} +\item \util \textbf[StrListDelVal()]{StrListDelVal( , , , ... )}. +\item \desc cette macro supprime de \argu{nomListe} les chaînes \argu{val1}, \argu{val2}..., sans avoir à connaître +leurs index. +\end{itemize} + +\subsection{StrListGetKey} +\begin{itemize} +\item \util \textbf[StrListGetKey()]{StrListGetKey( , )}. +\item \desc cette macro renvoie l'index de la \argu{chaîne} dans la liste \argu{nomListe}, si elle n'y figure pas, la +macro renvoie \Nil. +\end{itemize} + +\subsection{StrListInsert} +\begin{itemize} +\item \util \textbf[StrListInsert()]{StrListInsert( , [, ])}. +\item \desc cette macro modifie la liste de chaines \argu{nomListe}, en insérant une nouvelle \argu{chaîne} à la +position \argu{index}. Par défaut la valeur de \argu{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, ...). +\end{itemize} + +\subsection{StrListKill} +\begin{itemize} +\item \util \textbf[StrListKill()]{StrListKill( , , ... )}. +\item \desc cette macro détruit les listes de chaînes \argu{nomListe1}, \argu{nomListe2}, ... +\end{itemize} + +\subsection{StrListReplace} +\begin{itemize} +\item \util \textbf[StrListReplace()]{StrListReplace( , , )}. +\item \desc cette macro remplace dans la liste appelée \argu{nomListe}, l'\argu{ancienne chaine} par la \argu{nouvelle}. +\end{itemize} + +\subsection{StrListReplaceKey} +\begin{itemize} +\item \util \textbf[StrListReplaceKey()]{StrListReplaceKey( , , )}. +\item \desc cette macro remplace dans la liste appelée \argu{nomListe}, la chaîne dont le numéro est\argu{index}, par +la \argu{nouvelle chaîne}. +\end{itemize} + +\subsection{StrListShow} +\begin{itemize} +\item \util \textbf[StrListShow()]{StrListShow( [, , ])}. +\item \desc cette macro renvoie la chaîne obtenue en copiant \argu{nombre} éléments de la liste \argu{nomListe} en +partant de +\argu{index depart}, mais sans les concaténer. La chaîne renvoyée est de la forme: \verb|"chaine", "chaine", ...|. +L'argument 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 \argu{nombre} est positif, et dans le sens inverse quand + est négatif. Par défaut l' vaut $1$ et le \argu{nombre} vaut $0$ (ce qui signifie \og tous les +éléments\fg). +\end{itemize} + + +\section{Fonctions statistiques} + +\subsection{Anp} +\begin{itemize} +\item \util \textbf[Anp()]{Anp( ,

)}. +\item \desc renvoie le nombre d'arrangements de \argu{p} parmi \argu{n}. +\end{itemize} + +\subsection{binom} +\begin{itemize} +\item \util \textbf[binom()]{binom( ,

+ diff --git a/docs/texgraph/tex2html b/docs/texgraph/tex2html new file mode 100755 index 0000000..d9d45e1 --- /dev/null +++ b/docs/texgraph/tex2html @@ -0,0 +1,87 @@ +#!/usr/bin/perl + +use File::Basename; + +our ($nom, $dir, $ext) = fileparse($ARGV[0],qr{\..*}); +our $tex = qx{cat $ARGV[0]}; + +## === Filtres amont ----------------------------------------------------------- +$tex =~ s{\\util\s+}{}g; +$tex =~ s/\\label\{.+?\}//g; +$tex =~ s/\\opt\s*\{/\\modifopt\{/g; +$tex =~ s{\\desc\s+}{§§desc§:}g; +$tex =~ s/\\textbf\s*\[(.+?)\]\s*(\{(?:[^\{\}]++|(?2))*\})/§§textbf§$1§$2§:/g; +$tex =~ s/\\centerline\s*(\{(?:[^\{\}]++|(?1))*\})/§§centerline§$1§:/g; + +## === Fichier temporaire et transformation ------------------------------------ +open TMP, ">temp.tex"; +print TMP &pretex(); +print TMP $tex; +close TMP; +qx{pandoc --ascii temp.tex -o temp.html}; + +our $html = qx{cat temp.html}; +## === Filtres aval ------------------------------------------------------------ +$html =~ s/\&\#167\;/§/g; +$html =~ s/§§bks§:\s*/\&\#92\;/g; +$html =~ s{§§exem§:}{Exemple(s) : }g; +$html =~ s/§§textbf§(.*?)§\{(.*?)\}§:/$2<\/b>/g; +$html =~ s/§§desc§:/Description<\/u> : /g; +$html =~ s{§§opt§(.+?)§:}{$1}g; +$html =~ s{§§helpref§(.+?)§(.+?)§:}{&helpa($1,$2)}ge; +$html =~ s{§§span§co§(.+?)§:}{$1}g; +$html =~ s{§§span§var§(.+?)§:}{$1}g; +$html =~ s{§§span§res§(.+?)§:}{$1}g; +$html =~ s{§§textsl§(.+?)§:}{$1}g; +$html =~ s{§§centerline§\{(.+?)\}§:}{
$1
}g; +$html =~ s{

(.+?)

}{&modh3($1,$2)}ge; +$html =~ s{

(.+?)

}{&modh2($1,$2)}ge; + + +## === Fichier final ----------------------------------------------------------- +open HTM, ">$nom.html"; +print HTM $html; +close HTM; + + +sub pretex { + return << "eop"; +\\newcommand{\\argu}[1]{<\\textit{#1}>} +\\newcommand{\\exem}{§§exem§:} +\\newcommand{\\Nil}{\\textit{Nil}} +\\newcommand{\\jump}{\\textit{jump}} +\\newcommand{\\var}[1]{§§span§var§#1§:} +\\newcommand{\\co}[1]{§§span§co§#1§:} +\\newcommand{\\res}[1]{§§span§res§#1§:} +\\newcommand{\\Mytextbf}[1]{\\textbf{#1}} +\\newcommand{\\textsl}[1]{§§textsl§#1§:} +\\newcommand{\\modifopt}[2]{§§opt§#1 := < #2 >§:} +\\newcommand{\\Helpref}[2]{§§helpref§#1§#2§:} +\\newcommand{\\bks}{§§bks§:} +eop +} + +sub modh3 { + my ($i, $c) = @_; + if ("\U$i" eq "\U$c") { + return qq{

$c

}; + } else { + return qq{

$c

}; + } +} + +sub modh2 { + my ($i, $c) = @_; + if ("\U$i" eq "\U$c") { + return qq{

$c

}; + } else { + return qq{

$c

}; + } +} + +sub helpa { + my ($a, $b) =@_; + $a =~ s/^\{|\}$//g; + $b =~ s/^cmd|^mac//; + return qq{$a}; +} \ No newline at end of file diff --git a/texgraph.php b/texgraph.php index 9ee1627..7670d57 100644 --- a/texgraph.php +++ b/texgraph.php @@ -7,7 +7,7 @@ * Release Version: 1.0.0.0 * Date Started: 2011/09/18 * - * Metapost language file for GeSHi. + * TeXgraph language file for GeSHi. * * ************************************************************************************* @@ -266,7 +266,7 @@ $language_data = array ( 2 => '', 3 => '', 4 => '', - 5 => '', + 5 => 'http://melusine.eu.org/G/geshi/docs/texgraph/#{FNAME}', 6 => '', 7 => '', 8 => '', -- 2.20.1

)}. +\item \desc renvoie le coefficient binomial (ou combinaison) \argu{p} parmi \argu{n}. +\end{itemize} + + +\subsection{ecart} +\begin{itemize} +\item \util \textbf[ecart()]{ecart( )}. +\item \desc renvoie l'écart type d'une liste de réels, la constante \jump est ignorée. +\end{itemize} + +\subsection{fact} +\begin{itemize} +\item \util \textbf[fact()]{fact( )}. +\item \desc renvoie la valeur de $n!$ (fonction factorielle). +\end{itemize} + + +\subsection{max} +\begin{itemize} +\item \util \textbf[max()]{max( )}. +\item \desc renvoie le plus grand élément d'une liste de complexes (ordre lexicographique), la constante \jump est +ignorée. +\end{itemize} + +\subsection{min} +\begin{itemize} +\item \util \textbf[min()]{min( )}. +\item \desc renvoie le plus petit élément d'une liste de complexes (ordre lexicographique), la constante \jump est +ignorée. +\end{itemize} + +\subsection{median} +\begin{itemize} +\item \util \textbf[median()]{median( )}. +\item \desc renvoie l'élément médian d'une liste de complexes (ordre lexicographique), la constante \jump est ignorée. +\end{itemize} + +\subsection{moy} +\begin{itemize} +\item \util \textbf[moy()]{moy( )}. +\item \desc renvoie la moyenne d'une liste de complexes, la constante \jump est ignorée. +\end{itemize} + +\subsection{prod} +\begin{itemize} +\item \util \textbf[prod()]{prod( )}. +\item \desc renvoie le produit des éléments d'une liste de complexes, la constante \jump est ignorée. +\end{itemize} + +\subsection{sum} +\begin{itemize} +\item \util \textbf[sum()]{sum( )}. +\item \desc renvoie la somme des éléments d'une liste de complexes, la constante \jump est ignorée. +\end{itemize} + +\subsection{var} +\begin{itemize} +\item \util \textbf[var()]{var( )}. +\item \desc renvoie la variance d'une liste de réels, la constante \jump est ignorée. +\end{itemize} + +\section{Fonctions de conversion} + +\subsection{RealArg} + +\begin{itemize} +\item \util \textbf[RealArg()]{RealArg( )} +\item \desc renvoie l'argument (en radians) de l'affixe réelle d'un vecteur en tenant compte de la matrice courante. +\end{itemize} + + +\subsection{RealCoord} +\begin{itemize} +\item \util \textbf[RealCoord()]{RealCoord( )} + +\item \desc renvoie l'affixe réelle d'un point compte tenu des échelles et de la matrice courante. +\end{itemize} + +\subsection{RealCoordV} + +\begin{itemize} +\item \util \textbf[RealCoordV()]{RealCoordV( )} +\item \desc renvoie l'affixe réelle d'un vecteur compte tenu des échelles de la matrice courante. +\end{itemize} + +\subsection{ScrCoord} + +\begin{itemize} +\item \util \textbf[ScrCoord()]{ScrCoord( )} +\item \desc renvoie l'affixe écran d'un point en tenant compte des échelles et de la matrice courante. +\end{itemize} + +\subsection{ScrCoordV} + +\begin{itemize} +\item \util \textbf[ScrCoordV()]{ScrCoordV( )} +\item \desc renvoie l'affixe écran d'un vecteur en tenant compte des échelles et de la matrice courante. +\end{itemize} + +\subsection{SvgCoord}\label{macSvgCoord} + +\begin{itemize} +\item \util \textbf[SvgCoord()]{SvgCoord( )} +\item \desc renvoie l'affixe exportée en svg en tenant compte des échelles et de la matrice courante. +\end{itemize} + +\subsection{TeXCoord}\label{macTeXCoord} + +\begin{itemize} +\item \util \textbf[TeXCoord()]{TeXCoord( )} +\item \desc 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 \Helpref{EpsCoord}{cmdEpsCoord}. +\end{itemize} + + +\section{Transformations géométriques planes} + +\subsection{affin} + +\begin{itemize} +\item \util \textbf[affin()]{affin( , <[A, B]>, , )} +\item \desc renvoie la liste des images des points de \argu{liste} par l'affinité de base la droite \argu{(AB)}, de +rapport \argu{lambda} et de direction le vecteur \argu{V}. +\end{itemize} + +\subsection{defAff} + +\begin{itemize} +\item \util \textbf[defAff()]{defAff( , , , )} +\item \desc cette fonction permet de créer une macro appelée \argu{nom} qui représentera l'application affine qui +transforme \argu{A} en \argu{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. +\end{itemize} + + +\subsection{ftransform} + +\begin{itemize} +\item \util \textbf[ftransform()]{ftransform( , )} +\item \desc renvoie la liste des images des points de \argu{liste} par la fonction \argu{f(z)}, celle-ci peut-être une +expression fonction de z ou une macro d'argument z. +\end{itemize} + +\subsection{hom} + +\begin{itemize} +\item \util \textbf[hom()]{hom( , , )} +\item \desc renvoie la liste des images de la \argu{liste} par l'homothétie de centre \argu{A} et de rapport +\argu{lambda}. +\end{itemize} + +\subsection{inv} + +\begin{itemize} +\item \util \textbf[inv()]{inv( , , )} +\item \desc renvoie la liste des images des points de \argu{liste} par l'inversion de cercle de centre \argu{A} et de +rayon \argu{R}. +\end{itemize} + +\subsection{mtransform} +\begin{itemize} +\item \util \textbf[mtransform()]{mtransform( , )} +\item \desc renvoie la liste des images des points de \argu{liste} par l'application affine $f$ définie par la +\argu{matrice}. Cette \Helpref{matrice}{macmatrix} est de la forme [f(0), Lf(1), Lf(i)] où Lf désigne la partie +linéaire. +\end{itemize} + +\subsection{proj} + +\begin{itemize} +\item \util \textbf[proj()]{proj( , , )} ou \Mytextbf{proj( , <[A,B]> )} +\item \desc renvoie la liste des projetés orthogonaux des points de \argu{liste} sur la droite $(AB)$. +\end{itemize} + + +\subsection{projO} + +\begin{itemize} +\item \util \textbf[projO()]{projO( , <[A,B]>, )} +\item \desc renvoie la liste des projetés des points de \argu{liste} sur la droite \argu{(AB)} dans la direction du +\argu{vecteur}. +\end{itemize} + +\subsection{rot} + +\begin{itemize} +\item \util \textbf[rot()]{rot( , , )} +\item \desc renvoie la liste des images des points de \argu{liste} par la rotation de centre \argu{A} et d'angle +\argu{alpha}. +\end{itemize} + + +\subsection{shift} + +\begin{itemize} +\item \util \textbf[shift()]{shift( , )} +\item \desc renvoie la liste des translatés des points de \argu{liste} avec le \argu{vecteur}. +\end{itemize} + + +\subsection{simil} + +\begin{itemize} +\item \util \textbf[simil()]{simil( , , , )} +\item \desc renvoie la liste des images des points de \argu{liste}, par la similitude de centre \argu{A}, de rapport +\argu{lambda} et d'angle \argu{alpha}. +\end{itemize} + +\subsection{sym} + +\begin{itemize} +\item \util \textbf[sym()]{sym( , , )} ou \Mytextbf{sym( , <[A,B]> )} +\item \desc renvoie la liste des symétriques des points de \argu{liste}, par rapport à la droite $(AB)$. +\end{itemize} + +\subsection{symG} + +\begin{itemize} +\item \util \textbf[symG()]{symG( , , )} +\item \desc symétrie glissée: renvoie la liste des images des points de \argu{liste}, par la symétrie orthogonale d'axe +la droite passant par \argu{A} et dirigée par \argu{vecteur}, composée avec la translation de \argu{vecteur}. +\end{itemize} + +\subsection{symO} + +\begin{itemize} +\item \util \textbf[symO()]{symO( , <[A, B]>, )} +\item \desc renvoie la liste des symétriques des points de \argu{liste} par rapport à la droite \argu{(AB)} et dans la +direction du \argu{vecteur}. +\end{itemize} + + +\section{Matrices de transformations 2D}\label{macmatrix} + +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: + +{\Large +\[\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 \co{[t1+i*t2, a+i*c, b+i*d]} c'est à dire: \co{[ f(0), f(1)-f(0), f(i)-f(0)]}, cette liste sera appelée plus brièvement (et de manière abusive) \textit{matrice} de la transformation $f$. Les deux derniers éléments de cette liste: \co{[ a+i*c, b+i*d]}, représentent la matrice de la partie linéaire de $f$: Lf$=f-f(0)$. + +\subsection{ChangeWinTo} +\begin{itemize} +\item \util \textbf[ChangeWinTo()]{ChangeWinTo( <[xinf+i*yinf, xsup+i*ysup]> [, ortho] )} + +\item \desc modifie la matrice courante de manière à transformer la fenêtre courante en la fenêtre de grande diagonale \argu{[xinf+i*yinf, xsup+i*ysup]}, la fenêtre sera orthonormée ou non en fonction de la valeur du paramètre optionnel \argu{ortho} ($0$ par défaut). +\end{itemize} + + +\begin{demo}{Utilisation de ChangeWinTo}{ChangeWinTo} +\begin{texgraph}[name=ChangeWinTo,export=pgf] +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) +\end{texgraph} +\end{demo} + + +\subsection{invmatrix} +\begin{itemize} +\item \util \textbf[invmatrix()]{invmatrix( <[f(0), Lf(1), Lf(i)]> )} +\item \desc renvoie l'inverse de la matrice \argu{[f(0), Lf(1), Lf(i)]}, c'est à dire la matrice $[f^{-1}(0), +Lf^{-1}(1), Lf^{-1}(i)]$ si elle existe. +\end{itemize} + +\subsection{matrix} +\begin{itemize} +\item \util \textbf[matrix()]{matrix( , [variable] )} +\item \desc renvoie la matrice de la \argu{fonction affine}, par défaut la \argu{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). +\item \exem \co{matrix(i*bar(z))} renvoie \res{[0,i,1]}. +\end{itemize} + + +\subsection{mulmatrix} +\begin{itemize} +\item \util \textbf[mulmatrix()]{mulmatrix( <[f(0), Lf(1), Lf(i)]>, <[g(0), Lg(1), Lg(i)]> )} +\item \desc 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. +\end{itemize} + +\section{Constructions géométriques planes} + +Ces macros définissent des objets graphiques mais ne les dessinent pas, elles renvoient une liste de points représentant ces objets. + +\subsection{bissec} +\begin{itemize} +\item \util \textbf[bissec()]{bissec( , , , <1 ou 2> )} +\item \desc renvoie une liste de deux points de la bissectrice, 1=intérieure. +\end{itemize} + +\subsection{cap} +\begin{itemize} +\item \util \textbf[cap()]{cap( , )} +\item \desc renvoie le contour de l'intersection de \argu{ensemble1} avec \argu{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 \Helpref{set}{macset} permet de définir et dessiner des ensembles. +\item \exem intersection de deux ensembles: +\end{itemize} + + +\begin{demo}{macro cap}{cap} +\begin{texgraph}[name=cap, export=pgf] +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) +\end{texgraph} +\end{demo} + +\subsection{capB}\label{maccapB} +\begin{itemize} +\item \util \textbf[capB()]{capB( , )} +\item \desc renvoie le contour de l'intersection de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de +points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. 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 \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles. +\item \exem intersection de deux ensembles: +\end{itemize} + + +\begin{demo}{macro capB}{capB} +\begin{texgraph}[name=capB, export=pgf] +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]) +\end{texgraph} +\end{demo} + +\subsection{carre} +\begin{itemize} +\item \util \textbf[carre()]{carre( , , <1 ou -1> )} +\item \desc renvoie la liste des sommets du carré de sommets consécutifs A et B, 1=sens direct. +\end{itemize} + +\subsection{cup} +\begin{itemize} +\item \util \textbf[cup()]{cup( , )} +\item \desc renvoie le contour de la réunion de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles. +\item \exem réunion de deux ensembles: +\end{itemize} + +\begin{demo}{macro cup}{cup} +\begin{texgraph}[name=cup, export=pgf] +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) +\end{texgraph} +\end{demo} + +\subsection{cupB}\label{maccupB} +\begin{itemize} +\item \util \textbf[cupB()]{cupB( , )} +\item \desc renvoie le contour de la réunion de \argu{ensemble1} avec \argu{ensemble2} sous forme d'une liste de +points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. 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 \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles. +\item \exem intersection de deux ensembles: +\end{itemize} + +\begin{demo}{macro cupB}{cupB} +\begin{texgraph}[name=cupB, export=pgf] +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]) +\end{texgraph} +\end{demo} + +\subsection{cutBezier} +\begin{itemize} +\item \util \textbf[cutBezier()]{cutBezier( , , )} +\item \desc renvoie un arc de bézier correspondant à la \argu{courbe de bézier} coupée avant ou après le \argu{point}, +en fonction du paramètre \argu{avant}. Le résultat doit être dessiné par la commande \Helpref{Bezier}{cmdBezier}. +\end{itemize} + + +\subsection{Cvx2d} +\begin{itemize} +\item \util \textbf[Cvx2d()]{Cvx2d( )} +\item \desc renvoie l'enveloppe convexe de la \argu{liste} selon l'algorithme de \textsc{Ronald Graham}. La \argu{liste} ne doit pas contenir la constante \jump. +\item \exem on choisit aléatoirement $10$ points dans le pavé $[-4,4]\times[-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. +\end{itemize} + +\begin{demo}{macro Cvx2d}{Cvx2d} +\begin{texgraph}[name=Cvx2d, export=pgf] +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) +\end{texgraph} +\end{demo} + + +\subsection{Intersec} +\begin{itemize} +\item \util \textbf[Intersec()]{Intersec( , )} +\item \desc 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éé. +\item \exem la commande \co{Intersec( Cercle(0, 1), Droite(-1,i/2) )} renvoie: + +\centerline{\res{[0.59851109463416+0.79925554731708*i, -0.99794539275033+0.00102730362483*i]}.} +\end{itemize} + + +\subsection{med} +\begin{itemize} +\item \util \textbf[med()]{med( , )} +\item \desc renvoie une liste de deux points de la médiatrice de $[A,B]$. +\end{itemize} + +\subsection{parallel} +\begin{itemize} +\item \util \textbf[parallel()]{parallel( <[A,B]>, )} +\item \desc renvoie une liste de deux points de la parallèle à $(AB)$ passant par $C$. +\end{itemize} + + +\subsection{parallelo} +\begin{itemize} +\item \util \textbf[parallelo()]{parallelo( , , )} +\item \desc renvoie la liste des sommets du parallèlogramme de sommets consécutifs $A$, $B$, $C$. +\end{itemize} + +\subsection{perp} +\begin{itemize} +\item \util \textbf[perp()]{perp( <[A, B]>, )} +\item \desc renvoie une liste de deux points de la perpendiculaire à $(AB)$ passant par $C$. +\end{itemize} + + +\subsection{polyreg} +\begin{itemize} +\item \util \textbf[polyreg()]{polyreg( , , )} +\item \desc renvoie la liste des sommets du polygône régulier de centre $A$, passant par $B$ et avec le nombre de côtés indiqué. +\end{itemize} + +ou + +\begin{itemize} +\item \util \Mytextbf{polyreg( , , )} avec sens = +/-1 +\item \desc renvoie la liste des sommets du polygône régulier de sommets consécutifs $A$ et $B$, avec le nombre de côtés indiqué et dans le sens indiqué (1 pour le sens trigonométrique). +\end{itemize} + +\subsection{pqGoneReg} +\begin{itemize} +\item \util \textbf[pqGoneReg()]{pqGoneReg( , , <[p,q]> )} +\item \desc renvoie la liste des sommets du \argu{p/q}-gône régulier défini par le \argu{centre} et un \argu{sommet}. +\item \exem voir \Helpref{ici}{macDpqGoneReg}. +\end{itemize} + + +\subsection{rect} +\begin{itemize} +\item \util \textbf[rect()]{rect( , , )} +\item \desc renvoie la liste des sommets du rectangle de sommets consécutifs $A$, $B$, le côté opposé passant par $C$. +\end{itemize} + +\subsection{setminus} +\begin{itemize} +\item \util \textbf[setminus()]{setminus( , )} +\item \desc renvoie le contour de la différence \argu{ensemble1} - \argu{ensemble2} sous forme d'une liste de points. Ces deux ensembles doivent être des courbes fermées, orientées dans le meme sens, ayant une forme relativement simple. La macro \Helpref{set}{macset} permet de définir et dessiner des ensembles. +\item \exem différence de deux ensembles: +\end{itemize} + +\begin{demo}{macro setminus}{setminus} +\begin{texgraph}[name=setminus, export=pgf] +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) +\end{texgraph} +\end{demo} + +\subsection{setminusB}\label{macsetminusB} +\begin{itemize} +\item \util \textbf[setminusB()]{setminusB( , )} +\item \desc renvoie le contour de la différence \argu{ensemble1} - \argu{ensemble2} sous forme d'une liste de +points de contrôles qui doit être dessinée avec la macro \Helpref{drawSet}{macdrawSet}. 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 \Helpref{setB}{macsetB} permet de définir et dessiner des ensembles. +\item \exem différence de deux ensembles: +\end{itemize} + +\begin{demo}{macro setminusB}{setminusB} +\begin{texgraph}[name=setminusB, export=pgf] +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]) +\end{texgraph} +\end{demo} + +\section{Gestion du flattened postscript} + +Il est possible de transformer un fichier pdf ou un fichier postscript en \textit{flattened postscript} grâce à l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). Dans le fichier obtenu, tout est chemin, y compris le texte. TeXgraph peut récupérer tous les chemins d'un fichier écrit en \textit{flattened postscript}. C'est que proposent les macros de cette section. + +\subsection{conv2FlatPs}\label{macconv2FlatPs} + +\begin{itemize} +\item \util \textbf[conv2FlatPs()]{conv2FlatPs( , [, dossier de travail] )} +\item \desc cette macro invoque l'utilitaire \textit{pstoedit} pour transformer le \argu{fichier entrée} en \textit{flattened postscript} dans le \argu{fichier sortie}. Le fichier \argu{fichier entrée} doit être un fichier pdf ou ps. +\end{itemize} + +\subsection{drawFlatPs}\label{macdrawFlatPs} +\begin{itemize} +\item \util \textbf[drawFlatPs()]{drawFlatPs( , [, options] )} +\item \desc cette macro dessine à l'écran l'ensemble des chemins lus dans un fichier en \textit{flattened postscript} par la macro \Helpref{loadFlatPs}{macloadFlatPs}. L'affichage se fait à l'\argu{affixe} demandé. Le paramètre \argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les options sont: + \begin{itemize} + \item \opt{scale}{nombre positif}: échelle, 1 par défaut. + \item \opt{position}{center/left/right/...}: position de l'affixe par rapport à l'image, center par défaut (fonctionne comme la variable LabelStyle). + \item \opt{color}{couleur}: pour imposer une couleur, \Nil par défaut ce qui signifie qu'on prend la couleur d'origine. + \item \opt{rotation}{angle en degrés}: 0 par défaut. + \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués. + \item \opt{select}{liste des numéros de chemin à montrer}: \Nil par défaut, ce qui signifie tous les chemins. + \end{itemize} + +\end{itemize} + +\subsection{drawTeXlabel}\label{macdrawTeXlabel} +\begin{itemize} +\item \util \textbf[drawTeXlabel()]{drawTeXlabel( , , [, options] )} +\item \desc cette macro invoque la macro \Helpref{drawFlatPs}{macdrawFlatPs} pour dessiner une expression qui a été au +préalable compilée par \TeX. Le paramètre \argu{options} est une liste (facultative) de la forme \textsl{[ option1:= +valeur1, ..., optionN:=valeurN ]}, les options sont: + + \begin{itemize} + \item \opt{scale}{nombre>0}: échelle, 1 par défaut. + \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués. + \end{itemize} +Cette macro est utilisée en interne par la macro \Helpref{NewTeXlabel}{macNewTeXlabel}. +\end{itemize} + + +\subsection{loadFlatPs}\label{macloadFlatPs} +\begin{itemize} +\item \util \textbf[loadFlatPs()]{loadFlatPs( , [, options] )} +\item \desc cette macro charge un \argu{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 \Helpref{{drawFlatPs}}{macdrawFlatPs}). Le paramètre +\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les +options sont: + \begin{itemize} + \item \opt{width}{nombre>0}: largeur en cm, \Nil par défaut pour largeur naturelle. + \item \opt{height}{nombre>0}: hauteur en cm, \Nil par défaut pour hauteur naturelle. + \end{itemize} +\item supposons que vous ayez le fichier \textit{circuit.pdf} dans le dossier temporaire de TeXgraph, la commande +suivante dans un élément graphique Utilisateur: +\end{itemize} + +\begin{verbatim} + [conv2FlatPs( "circuit.pdf", "circuit.fps", @TmpPath), + stock:= loadFlatPs( [@TmpPath,"circuit.fps"] ), + drawFlatPs( 0, stock, [scale:=1, hollow:=1] ) + ] +\end{verbatim} + +va permettre de charger et dessiner le contenu de ce fichier dans TeXgraph, sans faire les remplissages. + + +\subsection{NewTeXlabel}\label{macNewTeXlabel} +\begin{itemize} +\item \util \textbf[NewTeXlabel()]{NewTeXlabel( , , , [, options] )} +\item \desc cette macro va demander à \TeX{} 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é \argu{nom} est créée pour dessiner la formule avec drawTeXLabel. Le paramètre +\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les +options sont: + \begin{itemize} + \item \opt{dollar}{0/1}: indique à TeXgraph s'il doit ajouter les délimiteurs \verb|\[| et \verb|\]| autour de la formule, 1 par défaut. + \item \opt{scale}{nombre>0}: échelle, 1 par défaut. + \item \opt{hollow}{0/1}: avec la valeur 0 (par défaut) les remplissages sont effectués. + \end{itemize} +Dans les options, les attributs suivants peuvent également être utilisés: \var{LabelStyle}, \var{LabelAngle} et +\var{Color}. + +Voici la définition de cette macro: + +\begin{small} +\begin{verbatim} +[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() +] +\end{verbatim} +\end{small} + +La formule est écrite dans le fichier \textit{formula.tex}, puis on compile le fichier \textit{tex2FlatPs.tex} suivant: + +\begin{verbatim} + \documentclass[12pt]{article} + \usepackage{amsmath,amssymb} + \usepackage{fourier} + \pagestyle{empty} + \begin{document} + \large + \input{formula.tex}% + \end{document} +\end{verbatim} + +et on convertit le résultat en \textit{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: + +\centerline{\co{NewTeXlabel( "label1", 0, "\bks frac\{\bks pi\}\{\bks sqrt\{2\}\}", [scale:=1.5, Color:=blue, LabelAngle:=45])}} +\end{itemize} + + +\section{Autres} + +\subsection{pdfprog} +\begin{itemize} +\item \util \textbf[pdfprog()]{pdfprog()}. +\item \desc 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: \textsl{"epstopdf"}. En éditant le fichier TeXgraph.mac, vous pouvez modifier le programme utilisé. +\end{itemize} + + + + diff --git a/docs/texgraph/index.css b/docs/texgraph/index.css new file mode 100644 index 0000000..a12fa17 --- /dev/null +++ b/docs/texgraph/index.css @@ -0,0 +1,14 @@ +#docu { + margin : 10px 15px 10px 50px; +} + +#docu h1 { + margin-left : -30px; + color : #666; +} + +#docu h2 { + margin-left : -15px; + color : #777; + border-bottom : 1px solid #964; +} \ No newline at end of file diff --git a/docs/texgraph/index.xml b/docs/texgraph/index.xml new file mode 100644 index 0000000..8effa91 --- /dev/null +++ b/docs/texgraph/index.xml @@ -0,0 +1,8 @@ + + + Documentation de TeXgraph +