X-Git-Url: https://melusine.eu.org/syracuse/G/git/?p=geshi.git;a=blobdiff_plain;f=docs%2Ftexgraph%2Fchap08.tex;fp=docs%2Ftexgraph%2Fchap08.tex;h=7bf27d00812ce577a5ed69113ff4c7641f6f2917;hp=0000000000000000000000000000000000000000;hb=2a5997e79c39695343669a0f6c815a73a23e2ee9;hpb=ae575882b0c25855564e1f482d98a681c8d8e445

diff --git a/docs/texgraph/chap08.tex b/docs/texgraph/chap08.tex
new file mode 100644
index 0000000..7bf27d0
--- /dev/null
+++ b/docs/texgraph/chap08.tex
@@ -0,0 +1,1344 @@
+\chapter{Fonctions et macros graphiques}\label{cmdFoncGraph}
+
+
+Ces fonctions et macros créent un élément graphique au moment de leur évaluation et renvoient un résultat égal à \Nil,
+elles ne sont utilisables \Mytextbf{que lors de la création d'un élément graphique "Utilisateur"}\footnote{Option
+\textsl{Elément graphique/Créer/Utilisateur} du menu.}.
+
+Elles peuvent être utilisées dans des macros, mais elles ne seront évaluées que si ces macros sont exécutées lors de la
+création d'un élément graphique "Utilisateur".
+
+
+\section{Fonctions graphiques prédéfinies}
+
+Notations:
+
+<argument>: signifie que l'argument est \Mytextbf{obligatoire}.
+
+[, argument]: signifie que l'argument est \Mytextbf{facultatif}.
+
+
+\subsection{Axes}\label{cmdAxes}
+
+\begin{itemize}
+\item \util  \textbf[Axes()]{Axes( <origine>, <graduationX + i*graduationY> [, position label origine] )}.
+
+\item \desc  dessine les axes, \argu{origine} est l'affixe du point d'intersection des axes, \argu{graduationX} est le
+pas  pour les graduations sur l'axe Ox, et \argu{graduationY} celui de l'axe Oy, une graduation égale à zéro signifie
+l'absence de graduation. La longueur des graduations est dans la variable globale \co{xyticks} que l'on peut modifier,
+la distance des labels à l'extrêmité des graduations est dans la variable \co{xylabelsep} qui peut également être
+modifiée. 
+
+Le troisième paramètre est facultatif, il permet de préciser la position des labels de l'origine (à l'intersection des
+axes), c'est un complexe: $a+ib$, la partie réelle concerne l'abscisse de l'origine et l'autre concerne l'ordonnée. Ces
+deux nombres peuvent prendre trois valeurs:
+
+\begin{itemize}
+ \item $0$: le label n'apparaît pas,
+ \item $1$: le label est affiché comme celui des autres graduations,
+ \item $2$: le label est décalé pour ne pas chevaucher l'autre axe (valeur par défaut).
+\end{itemize}
+
+\item On peut modifier dans les \textit{Attributs}: le style de ligne, l'épaisseur, la couleur et la taille des labels.
+\end{itemize}
+
+\begin{demo}{Commande Axes}{Axes}
+\begin{texgraph}[name=Axes,export=pgf]
+view(-5,4,-5,5),Marges(0.5,0,0,0.5),
+size(7.5), Width:=2,
+Color:=lightgray, Grille(-5-5*i,(1+i)/2),
+Width:=4,
+Color:=gray, Grille(-5-5*i,(1+i)),
+Color:=black, Arrows:=1,
+Axes(-5-5*i,1+i,1+i),Arrows:=0,
+LabelAxe(x,-pi-5*i,"$-\pi$",2-i,1),
+LabelAxe(x,pi-5*i,"$\pi$",2+i,1),
+SaveAttr(),
+FillStyle:=full, FillColor:=lightblue,
+FillOpacity:=0.5,
+domaine2(3*sin(x)^3, -5,-pi,pi),
+RestoreAttr(),
+Color:=red, Arrows:=0, Width:=8,
+Cartesienne( 3*sin(x)^3 )
+\end{texgraph}
+\end{demo}
+
+
+\subsection{(Poly-)Bezier}\label{cmdBezier}
+
+\begin{itemize}
+\item \util  \textbf[Bezier()]{Bezier( <liste de points> )}.
+
+\item \desc  dessine une succession de courbes de \textsc{Bezier} (avec éventuellement des segments de droite).
+Il y a plusieurs possibilités pour la liste de points:
+	\begin{enumerate}
+ 	\item une liste de trois points $[A,C,B]$, il s'agit alors d'une courbe de Bezier d'origine \argu{A} et
+d'extrémité \argu{B} avec un point de contrôle \argu{C}, c'est la courbe paramétrée par:
+
+\[(1-t)^2A+2t(1-t)C+t^2B\]
+
+	\item une liste de 4 points ou plus: [A1, C1, C2, A2, C3, C4, A3...]: il s'agit alors d'une succession de
+courbes de Bezier à 2 points de contrôles, la première va de A1 à A2, elle est contrôlée par C1, C2 (paramétrée par
+$(1-t)^3tA1+3(1-t)^2tC1]+3(1-t)t^2C2+t^3A2$), la deuxième va de A2 à A3 et est contrôlée par C3,C4 ...etc. Une exception
+toutefois, on peut remplacer les deux points de contrôle par la constante \jump, dans ce cas on saute directement de A1
+à A2 en traçant un segment de droite.
+	\end{enumerate}
+\item Le nombre de points calculés (par courbe) est modifiable dans les \textit{Attributs} (variable \co{NbPoints}).
+\end{itemize}
+
+\begin{demo}{Commande Bezier}{Bezier}
+\begin{texgraph}[name=Bezier,export=pgf]
+view(-4,4,-4,5),Marges(0,0,0,0),
+size(7.5), Width:=8,
+A:=-3+4*i, B:=3+i, C:=3-3*i, D:=-3-3*i,
+C1:=4.5*i,C2:=-2*i, C3:=2-i, C4:=-2,
+FillStyle:=full, FillColor:=lightblue,Color:=red,
+Bezier(A,C1,C2,B,jump,C,C3,C4,D,jump,A),
+FillStyle:=none, DotStyle:=cross,
+DotScale:=2,Color:=black,
+LabelDot(A,"$A$","N",1),
+LabelDot(B,"$B$","E",1),
+LabelDot(C,"$C$","SE",1),
+LabelDot(D,"$D$","SO",1),
+LabelDot(C1,"$C_1$","E",1),
+LabelDot(C2,"$C_2$","SO",1),
+LabelDot(C3,"$C_3$","N",1),
+LabelDot(C4,"$C_4$","N",1),
+LineStyle:=userdash,
+DashPattern:=[5,2,0.5,2], Width:=6,
+LineCap:=round,
+Ligne([A,C1,C2,B,jump,C,C3,C4,D],0) 
+\end{texgraph}
+\end{demo}
+
+\subsection{Cartesienne}\label{cmdCartesienne}
+
+\begin{itemize}
+\item \util  \textbf[Cartesienne()]{Cartesienne( <f(x)> [, n, 1] )}.
+
+\item \desc trace la courbe cartésienne d'équation $y=f(x)$. Le paramètre optionnel \argu{n} est un entier (égal à 5 par
+défaut) qui permet de faire varier le pas de la manière suivante: lorsque la distance entre deux points consécutifs est
+supérieur à un certain seuil alors on calcule un point intermédiaire [par dichotomie], ceci peut être répété n fois. Si
+au bout de n itérations la distance entre deux points consécutifs est toujours supérieure au seuil, et si la valeur
+optionnelle $1$ est présente, alors une discontinuité (\jump) est insérée dans la liste des points.
+\end{itemize}
+
+
+\begin{demo}{Courbe avec discontinuités}{Cartesienne}
+\begin{texgraph}[name=Cartesienne,export=pgf]
+view(-2,2,-0.1,2),Marges(0.5,0.5,0.5,0.5),
+size(7.5), tMin:=-2, tMax:=2,
+Color:=darkgray, Width:=8,
+LineStyle:=dotted, Grille(0,0.5*(1+i)),
+Color:=black, LineStyle:=solid,Axes(0,1+i,1),
+NbPoints:=100, Width:=8, Color:=darkseagreen,
+Cartesienne(x*Ent(1/x),5,1)
+\end{texgraph}
+\end{demo}
+
+\subsection{Courbe}\label{cmdCourbe}
+
+\begin{itemize}
+\item \util  \textbf[Courbe()]{Courbe( <f(t)> [, n, 1] )}.
+
+\item \desc trace la courbe paramétrée par \argu{f(t)} où $f$ est à valeurs complexes.
+
+Le paramètre optionnel \argu{n} est un entier (égal à 5 par défaut) qui permet de faire varier le pas de la manière
+suivante:
+lorsque la distance entre deux points consécutifs est supérieur à un certain seuil  alors on calcule un point
+intermédiaire (par dichotomie), ceci peut être répété $n$ fois. Si au bout de $n$ itérations la distance entre deux
+points consécutifs est toujours supérieure au seuil, et si la valeur optionnelle $1$ est présente, alors une
+discontinuité (\jump) est insérée dans la liste des points.
+\end{itemize}
+
+\subsection{Droite}\label{cmdDroite}
+
+\begin{itemize}
+\item \util  \textbf[Droite()]{Droite( <A>, <B> [, C] )}.
+
+\item \desc  trace la droite $(AB)$ lorsque le troisième argument \argu{C} est omis, sinon c'est la droite d'équation
+cartésienne \argu{A}x+\argu{B}y=\argu{C}.
+\end{itemize}
+
+
+\begin{demo}{Développée d'une ellipse}{Droite}
+\begin{texgraph}[name=Droite,export=pgf]
+view(-5,5,-5,5),Marges(0,0,0,0),
+size(7.5),
+F:=sqrt(7), F':=-F, {foyers}
+Width:=1, Color:=darkgray,
+for t from -pi to pi step 0.1 do
+ M:=4*cos(t)+3*i*sin(t),
+ Vn:=(M-F)/abs(M-F)+(M-F')/abs(M-F'),
+ Droite(M,M+Vn),{normale à l'ellipse}
+od,
+Width:=8, Color:=red,
+Ellipse(0,4,3),
+LabelDot(F,"$F$","S",1),
+LabelDot(F',"$F'$","S",1)
+\end{texgraph}
+\end{demo}
+
+\subsection{Ellipse}\label{cmdEllipse}
+
+\begin{itemize}
+\item \util  \textbf[Ellipse()]{Ellipse( <A>, <Rx>, <Ry> [, inclinaison] )}.
+
+\item \desc trace une ellipse de centre \argu{A} de rayons \argu{Rx} et \argu{Ry} sur les axes respectifs $Ox$ et $Oy$.
+Le dernier paramètre \argu{inclinaison} est un angle en degrés (nul par défaut) qui indique l'inclinaison de l'ellipse
+par rapport à l'horizontale.
+\end{itemize}
+
+\begin{demo}{Ellipses}{Ellipse}
+\begin{texgraph}[name=ellipse,export=pgf]
+view(-5.25,5.25,-5.25,5.25),
+Marges(0,0,0,0), size(7.5),
+background(full,blue), 
+Width:=4, Color:=white,
+inclin:=[0,35,-35],
+for z in inclin do
+ Ellipse(0,5,2,z)
+od,
+Width:=2*mm, Ellipse(0,1.5,4.5),
+Label(-0.1,
+  "\resizebox{6cm}{3.5cm}{R\ T\ F}")
+\end{texgraph}
+\end{demo}
+
+\subsection{EllipticArc}\label{cmdEllipticArc}
+
+\begin{itemize}
+\item \util  \textbf[EllipticArc()]{EllipticArc( <B>, <A>, <C>, <Rx>, <Ry> [, sens] )}.
+
+\item \desc  trace un arc d'ellipse dont les axes sont $Ox$ et $Oy$ et le centre \argu{A}, 
+le rayon sur $Ox$ est \argu{Rx}, et celui sur $Oy$ est \argu{Ry}. L'arc est tracé partant de la droite $(AB)$ jusqu'à la
+droite $(AC)$, l'argument facultatif \argu{sens} indique: le sens trigonométrique si sa valeur est $1$ (valeur par
+défaut), le sens contraire si sa valeur est $-1$. 
+\end{itemize}
+
+\begin{demo}{Commande EllipticArc}{EllipticArc}
+\begin{texgraph}[name=Arc,export=pgf]
+view(-2.25,3.75,-2,5),Marges(0,0,0,0),size(7.5),
+A:=0, B:=3+i, C:=2+4*i,
+DotScale:=2, Width:=8,
+Ligne([B,A,C],0), Color:=red,
+LabelDot(A,"$A$","S",1),
+LabelDot(B,"$B$","N",1),
+LabelDot(C,"$C$","SE",1),
+Arrows:=1, Color:=blue,
+EllipticArc(B,A,C,2,1,-1),
+EllipticArc(B,A,C,2,3,1)
+\end{texgraph}
+\end{demo}
+
+Remarque: pour un arc de cercle, il suffit de prendre \argu{Rx} et \argu{Ry} égaux. Mais le plus simple est d'utiliser
+la macro \Helpref{Arc}{macArc} qui remplace la commande \Mytextbf{Arc} de l'ancienne version.
+
+
+\subsection{EquaDif}\label{cmdEquadif}
+
+\begin{itemize}
+\item \util  \textbf[EquaDif()]{EquaDif( <f(t,x,y)>, <t0>, <x0 + i*y0> [, mode] )}.
+
+\item \desc  trace une solution approchée de l'équation différentielle: $x'(t)+iy'(t)=f(t,x,y)$ avec la condition
+initiale $x(t0)=x0$ et $y(t0)=y0$. Le dernier paramètre est facultatif et peut valoir 0, 1 ou 2:
+	\begin{itemize}
+	\item \argu{mode}=0: la courbe représente les points de coordonnées $(x(t),y(t))$, c'est la valeur par défaut.
+	\item \argu{mode}=1: la courbe représente les points de coordonnées $(t,x(t))$.
+	\item \argu{mode}=2: la courbe représente les points de coordonnées $(t,y(t))$.
+	\end{itemize}
+C'est la méthode de \textsc{Runge-Kutta} d'ordre 4 qui est utilisée.
+\item \exem l'équation $x''-x'-tx=\sin(t)$ avec la condition initiale $x(0)=-1$ et $x'(0)=1/2$, se met sous la
+forme:
+\[\begin{pmatrix}
+X'\\Y'\end{pmatrix}=\begin{pmatrix} 0&1\\t&1\end{pmatrix}\begin{pmatrix}X\\Y\end{pmatrix}+
+\begin{pmatrix}0\\\sin(t)\end{pmatrix}\] en posant $X=x$ et $Y=x'$:
+\end{itemize}
+
+
+\begin{demo}{\'Equation différentielle}{EquaDif}
+\begin{texgraph}[name=EquaDif,export=pgf]
+view(-10.5,2.5,-1.5,4.5),Marges(0,0,0,0),
+size(7.5,0), Arrows:=1, Width:=4,
+Axes(0,1+i), Arrows:=0,
+LabelAxe(y,4.25*i,"$x$"),
+LabelAxe(x,2,"$t$",2),
+Width:=8, Color:=red, tMin:=-10, tMax:=2,
+EquaDif(y+i*(t*x+y+sin(t)),0,-1+i/2, 1),
+Color:=black, LabelStyle:=stacked,
+Label(-6+2*i,
+ "$x''-tx'-x=\sin(t)$\\
+avec $x(0)=-1$ et $x'(0)=\frac12$")
+\end{texgraph}
+\end{demo}
+
+
+\subsection{Grille}\label{cmdGrille}
+
+\begin{itemize}
+\item \util  \textbf[Grille()]{Grille( <origine>, <graduationX + i*graduationY> )}.
+
+\item \desc  dessine une grille, \argu{origine} est l'affixe du point considéré comme origine, \argu{graduationX} est le
+pas des graduations sur l'axe Ox, et \argu{graduationY} celui de l'axe Oy, une graduation égale à zéro signifie
+l'absence de graduation.
+\item On peut modifier dans les \textit{Attributs} le style de ligne, l'épaisseur et la couleur. La grille de ne fait
+pas appraître de graduations, on peut dessiner des axes par dessus.
+\end{itemize}
+
+\subsection{Implicit}\label{cmdImplicit}
+
+\begin{itemize}
+\item \util  \textbf[Implicit()]{Implicit( <f(x,y)> [, n, m] )}.
+\item \desc  trace la courbe implicite d'équation $f(x,y)=0$. L'intervalle des abscisses est subdivisé en \argu{n}
+parties et l'intervalle des ordonnées en \argu{m} parties, par défaut $n=m=25$. Sur chaque pavé ainsi obtenu on teste
+s'il y a un changement de signe, auquel cas on applique une dichotomie sur les bords du pavé.
+\end{itemize}
+
+
+\begin{demo}{\'Equation $\sin(xy)=0$}{Implicit}
+\begin{texgraph}[name=Implicit,export=pgf]
+view(-5,5,-5,5),Marges(0,0,0,0),
+size(7.5), Arrows:=1, Width:=4,
+Axes(0,1+i), Arrows:=0,
+Width:=8, Color:=red,
+Implicit( sin(x*y) )
+\end{texgraph}
+\end{demo}
+
+\subsection{Label}\label{cmdLabel}
+
+\begin{itemize}
+\item \util  \textbf[Label()]{Label( <affixe1>, <texte1>,..., <affixeN>, <texteN> )}.
+
+\item \desc  place la chaîne de caractères \argu{texte1} à la position \argu{affixe1} ... etc. Les paramètres
+\argu{texte1},..., \argu{texteN} sont donc interprétés comme des \Helpref{chaînes de caractères}{chaine}.
+\end{itemize}
+
+
+\begin{demo}{Nommer des points}{Label}
+\begin{texgraph}[name=Label,export=pgf,
+              preload="PolyedresII.mac"]
+view(-5,5,-5,5),Marges(0,0,0,0),
+size(7.5,0),
+C:=Cube(Origin, M(3,3,0)),
+S:=Sommets(C), Point3D(S),
+DrawPoly(C,0), k:=0,
+for Z in S by 2 do
+ Inc(k,1),
+ Label(Proj3D(Z)+
+  if k>4 then 0.5*i else -0.5*i fi,
+     ["$S_",k,"$"])
+od 
+\end{texgraph}
+\end{demo}
+
+\subsection{Ligne}\label{cmdLigne}
+
+\begin{itemize}
+\item \util   \textbf[Ligne()]{Ligne( <liste>, <fermée> [, rayon] )}.
+
+\item \desc  trace la ligne polygonale définie par la liste, si le paramètre \argu{fermée} vaut 1, la ligne polygonale
+sera fermée, si sa valeur est 0 la ligne est ouverte. Si l'argument \argu{rayon} est précisé (0 par défaut), alors les
+"angles" de la ligne polygonale sont arrondis avec un arc de cercle dont le rayon correspond à l'argument \argu{rayon}.
+\end{itemize}
+
+\begin{demo}{Triangle de \textsc{Sierpinski}}{Ligne}
+\begin{texgraph}[name=Ligne,export=pgf]
+Marges(0,0,0,0), size(7.5),
+A:=-5-5*i, B:=5*i, C:=5-5*i,niv:=6,
+Tr:=[A,B,C,jump], {initial}
+for k from 1 to niv do
+ Tr:=[hom(Tr,A,0.5),hom(Tr,B,0.5),
+      hom(Tr,C,0.5)]
+od,
+FillStyle:=full,FillColor:=blue,
+Ligne(Tr,1) 
+\end{texgraph}
+\end{demo}
+
+\subsection{Path}\label{cmdPath}
+
+\begin{itemize}
+\item \util   \textbf[Path()]{Path( <liste> [, fermé (0/1)]}
+
+\item \desc trace le chemin représenté par \argu{liste} et ferme la dernière composante de celui-ci si l'argument
+optionnel vaut $1$ (sa valeur par défaut est $0$). La liste est une succession de points (affixes) et d'instructions
+indiquant à quoi correspondent ces points, ces instructions sont: 
+
+\begin{itemize}
+ \item \textbf{line}: relie les points par une ligne polygonale,
+
+ \item  \textbf{linearc}: relie les points par une ligne polygonale mais les angles sont arrondis par un arc de cercle,
+la valeur précédent la commande linearc est interprétée comme le rayon de ces arcs.
+
+ \item \textbf{arc}: dessine un arc de cercle, ce qui nécessite quatre arguments: 3 points et le rayon, plus
+éventuellement un cinquième argument: le sens (+/- 1), le sens par défaut est 1 (sens trigonométrique).
+
+ \item \textbf{ellipticArc}: dessine un arc d'ellipse, ce qui nécessite cinq arguments: 3 points, le rayonX, le rayonY,
+plus éventuellement un sixième argument: le sens (+/- 1), le sens par défaut est 1 (sens trigonométrique), plus
+éventuellement un septième argument: l'inclinaison en degrés du grand axe par rapport à l'horizontale.
+
+ \item \textbf{curve}: relie les points par une spline cubique naturelle.
+
+ \item \textbf{bezier}: relie le premier et le quatrième point par une courbe de bézier (les deuxième et troisième
+points sont les points de contrôle).
+
+ \item \textbf{circle}: desine un cercle, ce qui necessite deux arguments: un point et le centre, ou bien trois
+arguments qui sont trois points du cercle.
+
+ \item \textbf{ellipse}: dessine une ellipse, les arguments sont: un point, le centre, rayon rX, rayon rY, inclinaison
+du grand axe en degrés  par rapport à l'horizontale (facultatif).
+
+ \item \textbf{move}: indique un déplacement sans tracé.
+
+ \item \textbf{closepath}: ferme la composante en cours.
+\end{itemize}
+
+Par convention, le premier point du tronçon numéro n+1 est le dernier point du tronçon numéro n.
+
+\item \exem
+\end{itemize}
+
+\begin{demo}{Commande Path et Eofill}{Path}
+\begin{texgraph}[name=Path,export=pgf]
+view(-5,5,-4,6),Marges(0,0,0,0),size(7.5),
+Axes(2*i,1+i),Eofill:=1,
+FillStyle:=full,FillOpacity:=0.9,
+FillColor:= blue, Width:=8,
+Path([-4,i,circle,
+      -3+2*i,move,-3,-2,line,
+      0,2,2,-1,arc,
+      3,3+3*i,0.5,linearc,
+      1,-1+5*i,-3+2*i,bezier,
+      closepath,
+      ]) 
+\end{texgraph}
+\end{demo}
+
+
+\subsection{Point}\label{cmdPoint}
+
+\begin{itemize}
+\item \util  \textbf[Point()]{Point( <A1>, ..., <An> )}.
+
+\item \desc  représente le nuage de points \argu{A1} ... \argu{An}.
+\end{itemize}
+
+\pngtrue
+\begin{demo}{Diagramme de bifurcation de la suite $u_{n+1}=ru_n(1-u_n)$}{Point}
+\begin{texgraph}[name=Point,export=eps]
+view(2.75,4,0,1),
+Marges(0.75,0.5,0.5,0.5),size(7.5),
+Axes(Xmin+i*Ymin,0.25+0.2*i,1+i),
+pas:=0.001, Color:=red,
+DotScale:=0.1,
+Point(
+ for r from Xmin to Xmax step pas do
+  u:=0.5,
+  for k from 1 to 25 do u:=r*u*(1-u) od,
+  for k from 1 to 25 do u:=r*u*(1-u), r+i*u od
+ od)
+\end{texgraph}
+\end{demo}
+\pngfalse
+
+\subsection{Polaire}\label{cmdPolaire}
+
+\begin{itemize}
+\item \util  \textbf[Polaire()]{Polaire( <r(t)> [, n, 0/1] )}.
+
+\item \desc trace la courbe polaire d'équation $\rho=r(t)$, \argu{expression}. Le paramètre optionnel \argu{n} est
+un entier (égal à 5 par défaut) qui permet de faire varier le pas de la manière suivante: lorsque la distance entre deux
+points consécutifs est supérieur à un certain seuil alors on calcule un point intermédiaire (par dichotomie), ceci peut
+être répété $n$ fois. Si au bout de $n$ itérations la distance entre deux points consécutifs est toujours supérieure au
+seuil, et si la valeur optionnelle $1$ est présente, alors une discontinuité (\jump) est insérée dans la liste des
+points.
+\end{itemize}
+
+
+\begin{demo}{Courbe polaire et points doubles}{Polaire}
+\begin{texgraph}[name=Polaire,export=pgf]
+view(-3,2,-2,3),Marges(0.25,0.25,0.25,0.25),
+size(7.5),Width:=4,
+Axes(0,1+i),NbPoints:=250,tMin:=-25,tMax:=25,
+courbe:=Get(Polaire((t+1)/(t-1))),
+ptDoubles:= courbe InterL courbe,
+Width:=8, Color:= blue, Ligne(courbe,0),
+DotStyle:=dotcircle, DotScale:=2,
+Point(ptDoubles),
+Label(1+2*i,"$r(t)=\dfrac{t+1}{t-1}$")
+\end{texgraph}
+\end{demo}
+
+
+\subsection{Spline}\label{cmdSpline}
+
+\begin{itemize}
+\item \util  \textbf[Spline()]{Spline( <V0>, <A0>,..., <An>, <Vn> )}.
+\item \desc trace 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).
+\end{itemize}
+
+
+\begin{demo}{Commande Spline}{Spline}
+\begin{texgraph}[name=Spline,export=pgf]
+view(-5,5,-5,5),Marges(0.25,0.25,0.25,0.25),
+size(7.5),Width:=4,Axes(0,1+i),
+A:= -4-3*i, B:=-2+2*i, C:=1-3*i, D:=4+3*i,
+LabelDot(A,"$A$","S",1),LabelDot(B,"$B$","N",1),
+LabelDot(C,"$C$","S",1),LabelDot(D,"$D$","O",1),
+Width:=8,Color:=red, Spline(0,A,B,C,D,0),
+Ligne([-4.5+4.5*i,-4+4.5*i],0), LabelStyle:=left,
+Label(-3.5+4.5*i,"libre"),
+Color:=blue,Spline(5,A,B,C,D,5*i),
+Ligne([-4.5+3.5*i,-4+3.5*i],0),
+Label(-3.5+3.5*i,"contrainte"),
+Width:=4,
+Arrows:=1, Ligne([A,A+2,jump,D,D+2*i],0)
+\end{texgraph}
+\end{demo}
+
+
+\section{Commandes de dessin bitmap}
+
+La version \version propose quelques commandes de base pour faire du dessin bitmap. Ce dessin bitmap peut être
+enregistré (au format \textit{bmp}) mais il n'est pas pris en compte par les autres exports du logiciel. Ces commandes
+ne sont fonctionnelles qu'avec la version GUI de TeXgraph. Chaque pixel est repéré son affixe $x+iy$ où $x$ et $y$ sont
+deux entiers, l'origine est en haut à gauche de la zone de dessin \Mytextbf{marges exclues}, l'axe $Ox$ est dirigé vers
+la droite et l'axe $Oy$ vers le bas.
+
+\subsection{DelBitmap}\label{cmdDelBitmap}
+
+\begin{itemize}
+\item \util  \textbf[DelBitmap()]{DelBitmap()}.
+\item \desc détruit le bitmap en cours.
+\end{itemize}
+
+\subsection{MaxPixels}\label{cmdMaxPixels}
+
+\begin{itemize}
+\item \util  \textbf[MaxPixels()]{MaxPixels()}.
+\item \desc renvoie la taille de la zone graphique en pixels sous la forme: \textsl{maxX+i*maxY}, ainsi pour les
+coordonnées des pixels (coordonnées entières), l'intervalle des abscisses est \textsl{[0 .. maxX]} et celui des
+ordonnées \textsl{[0 .. maxY]}. Chaque pixel est repéré par des coordonnées entières, donc chaque pixel a une affixe
+$a+ib$ avec $a$ dans \textsl{[0 .. maxX]} et $b$ dans \textsl{[0 .. maxY]}. L'origine étant le coin supérieur gauche de
+la zone graphique \Mytextbf{marges exclues}.
+\end{itemize}
+
+\subsection{NewBitmap}\label{cmdNewBitmap}
+
+\begin{itemize}
+\item \util  \textbf[NewBitmap()]{NewBitmap( [fond] )}.
+\item \desc  permet de créer un nouveau bitmap (vide). Par défaut la couleur du fond est le blanc.
+\end{itemize}
+
+\subsection{Pixel}\label{cmdPixel}
+
+\begin{itemize}
+\item \util  \textbf[Pixel()]{Pixel( <liste> )}.
+\item \desc  permet de d'allumer une \argu{liste} de pixels. Cette liste est de la forme: \textsl{[affixe, couleur,
+affixe, couleur, ...]}. Les affixes des pixels sont de la forme $a+ib$ avec $a$ et $b$ des entiers positifs ou nuls,
+l'origine étant le coin supérieur gauche de la zone graphique \Mytextbf{marges exclues}.
+\end{itemize}
+
+\subsection{Pixel2Scr}\label{cmdPixel2Scr}
+
+\begin{itemize}
+\item \util  \textbf[Pixel2Scr()]{Pixel2Scr( <affixe> )}.
+\item \desc  permet de convertir l'\argu{affixe} d'un pixel (coordonnées entières) en affixe dans le repère de
+l'utilisateur à l'écran.
+\end{itemize}
+
+\subsection{Scr2Pixel}\label{cmdScr2Pixel}
+
+\begin{itemize}
+\item \util  \textbf[Scr2Pixel()]{Scr2Pixel( <affixe> )}.
+\item \desc  permet de convertir l'\argu{affixe} d'un point dans le repère de l'utilisateur à l'écran en coordonnées
+entières (affixe du pixel correspondant au point).
+\item \exem un ensemble de Julia, la commande est à placer dans un élément graphique utilisateur. L'image \textit{png} a
+été obtenue à partir du bouton \textit{snapshot} de l'interface graphique en prenant l'export \textit{bmp} puis une
+conversion en \textit{png}:
+\end{itemize}
+
+\pngtrue
+\begin{demo}{Un ensemble de Julia}{julia}
+\begin{texgraph}[name=julia,export=none]
+view(-1.5,1.5,-1,1),Marges(0,0,0,0),size(7.5),
+ NewBitmap(),
+  T:=100, m:=MaxPixels(), c:=-0.181-0.667*i,
+   for x from 0 to Re(m) do
+    Pixel(
+     for y from 0 to Im(m) do
+         N:=0, z:=Pixel2Scr(x+i*y),
+         repeat
+              z:=z^2+c, Inc(N,1)
+         until (N=T) Or (abs(z)>2) od,
+         x+i*y, MixColor(darkred,1-N/T,yellow,N/T)
+    od )
+  od
+\end{texgraph}
+\end{demo}
+\pngfalse
+
+
+\section{Macros graphiques de TeXgraph.mac}
+
+\subsection{angleD}
+
+\begin{itemize}
+\item \util \textbf[angleD()]{angleD( <B>, <A>, <C>, <r> )}.
+\item \desc  dessine l'angle $\widehat{BAC}$ avec un parallèlogramme de coté r.
+\end{itemize}
+
+\subsection{Arc}\label{macArc}
+
+\begin{itemize}
+\item \util  \textbf[Arc()]{Arc( <B>, <A>, <C>, <R> [, sens] )}.
+
+\item \desc  trace un arc de cercle de centre \argu{A} et de rayon \argu{R}. L'arc est tracé partant de la droite $(AB)$
+jusqu'à la droite $(AC)$, l'argument facultatif \argu{sens} indique: le sens trigonométrique si sa valeur est $1$
+(valeur par défaut), le sens contraire si valeur est $-1$. 
+\end{itemize}
+
+\begin{demo}{Commande Arc}{Arc}
+\begin{texgraph}[name=Arc,export=pgf]
+view(-2.25,3.75,-2,5),Marges(0,0,0,0),size(7.5),
+A:=0, B:=3+i, C:=2+4*i,
+DotScale:=2, Width:=8,
+Ligne([B,A,C],0), Color:=red,
+LabelDot(A,"$A$","S",1),
+LabelDot(B,"$B$","N",1),
+LabelDot(C,"$C$","SE",1),
+Arrows:=1, Color:=blue,
+Arc(B,A,C,1,-1),
+Arc(B,A,C,2,1)
+\end{texgraph}
+\end{demo}
+
+\subsection{arcBezier}
+
+\begin{itemize}
+\item \util \textbf[arcBezier()]{arcBezier( <B>, <A>, <C>, <r> [,sens] )}.
+\item \desc a le même effet que la macro graphique \textsl{Arc} mais l'arc est dessiné avec des courbes de Bezier.
+\end{itemize}
+
+
+\subsection{axes}
+
+\begin{itemize}
+\item \util \textbf[axes()]{axes( <[origine, etendueX, etendueY]>, <gradX+i*gradY> [, subdivX+i*subdivY,
+posOriginX+i*posOriginY, num, "texte", den, firstnum] )}.
+\item \desc pour tracer et graduer les axes passant par \argu{origine} (affixe), elle s'utilise comme la commande
+\Helpref{Axes}{cmdAxes} et utilise donc les variables \textit{xylabelpos} et \textit{xyticks}. Par défaut les axes
+occupent toute la fenêtre si les paramètres optionnels \argu{etendueX} et \argu{etendueY} sont omis. Le paramètre
+\argu{etendueX} représente sous forme complexe l'intervalle des abcisses: \verb|xmin+i*xmax|, de même pour les ordonnées
+avec le paramètre \argu{etendueY}, les axes sont alors limités à ces intervalles. Remarque: pour préciser une valeur de
+\argu{etendueY} sans préciser de valeur pour \argu{etendueX}, il suffit de mettre \jump à la place de \argu{etendueX}
+(et non pas \Nil!).
+
+\item Le paramètre optionnel \argu{subdivX+i*subdivY} indique le nombre de subdivisions par unité sur chaque axe (0 par
+défaut).
+
+\item Le paramètre optionnel \argu{posOriginX+i*posOriginY} permet de positionner le label de l'origine:
+
+	\begin{itemize}
+	\item \argu{posOriginX}=0: pas de label à l'origine (idem pour \argu{posOriginY}=0),
+	\item \argu{posOriginX}=1: label normal à l'origine (idem pour \argu{posOriginY}=1),,
+	\item \argu{posOriginX}=2: label décalé à droite de l'origine   et en haut pour \argu{posOriginY}=2 (valeurs par
+défaut),
+	\item \argu{posOriginX}=-2 label décalé à gauche de l'origine et en bas pour \argu{posOriginY}=-2.
+	\end{itemize}
+
+\item Sur les 2 axes, chaque label est multiplié par la fraction \argu{num/den} (1 par défaut), ajouté à
+\argu{firstnum/den} (l'origine par défaut) et accompagné du \argu{"texte"} au numérateur. Pour que le séparateur décimal
+soit la virgule à la place du point, il suffit de mettre la variable \var{usecomma} à la valeur $1$. Cette macro est
+également sensible aux variables \var{dollar} (pour ajouter ou non des \$ autour des labels des graduations), et 
+\var{nbdeci} qui fixe le nombre de décimales affichées.
+
+\item \exem pour avoir des axes gradués en $\pi/2$ en $\pi/2$: \co{axes(0, pi*(1+i)/2, 1+i, 2+2*i, 1, "\bks pi", 2, 0)}.
+Contrairement à la commande Axes, cette macro est sensible aux modifications de la matrice courante.
+\end{itemize}
+
+\subsection{axeX}
+
+\begin{itemize}
+\item \util \textbf[axeX()]{axeX( <[origine, posOrigine, etendue]>, <Xpas>  [, Subdiv, labelPos , num, ""texte"", den,
+firstnum] )}.
+
+\item \desc pour tracer et graduer un axe des abscisses passant par \argu{origine} et avec un pas de \argu{Xpas}. Le
+paramètre \argu{etendue} représente sous forme complexe l'intervalle des abscisses \textsl{xmin+i*xmax}, si celui-ci est
+omis, alors le tracé occupe la fenêtre. Remarque: pour préciser une valeur de \argu{etendue} sans préciser de valeur
+pour \argu{posOrigine}, il suffit de mettre \jump à la place de \argu{posOrigine} (et non pas \Nil!).
+
+\item \argu{Subdiv} est le nombre de subdivisions par unité, chaque abscisse est multipliée par la fraction
+\argu{num/den} (1 par défaut), ajoutée à \argu{firstnum/den} (l'origine par défaut) et accompagnée du \argu{"texte"} au
+numérateur. Pour que le séparateur décimal soit la virgule à la place du point, il suffit de mettre la variable
+\var{usecomma} à la valeur $1$.  Cette macro est
+également sensible aux variables \var{dollar} (pour ajouter ou non des \$ autour des labels des graduations), et 
+\var{nbdeci} qui fixe le nombre de décimales affichées.
+
+\item Les paramètres optionnels \argu{posOrigine} et \argu{labelpos} permettent de positionner les labels:
+
+	\begin{itemize}
+	\item \argu{posOrigine}=0: pas de label à l'origine,
+	\item \argu{posOrigine}=1: label normal à l'origine,
+	\item \argu{posOrigine}=2: label décalé à droite à l'origine (valeur par défaut),
+	\item \argu{posOrigine}=-2 label décalé à gauche à l'origine,
+	\item \argu{labelPos}=0 : pas de label du tout,
+	\item \argu{Re(labelpos)}=top: labels au-dessus,
+	\item Re(\argu{labelPos})=bottom : labels en-dessous (valeur par défaut),
+	\item Im(\argu{Im(labelPos})=1: labels orthogonaux à l'axe.
+	\end{itemize}
+\end{itemize}
+
+\subsection{axeY}
+
+\begin{itemize}
+\item \util \textbf[axeY()]{axeY(<[origine, posOrigine, etendue]>, <Ypas>  [, Subdiv, labelPos , num, ""texte"", den,
+firstnum] )}.
+
+\item \desc pour tracer et graduer un axe des abscisses passant par \argu{origine} et avec un pas de \argu{Ypas}. Le
+paramètre \argu{etendue} représente sous forme complexe l'intervalle des ordonnées \textsl{ymin+i*ymax}, si celui-ci est
+omis, alors le tracé occupe la fenêtre. Remarque: pour préciser une valeur de \argu{etendue} sans préciser de valeur
+pour \argu{posOrigine}, il suffit de mettre \jump à la place de \argu{posOrigine} (et non pas \Nil!).
+
+\item \argu{Subdiv} est le nombre de subdivisions par unité, chaque ordonnée est multipliée par la fraction
+\argu{num/den} (1 par défaut), ajoutée à \argu{firstnum/den} (l'origine par défaut) et accompagnée du \argu{"texte"} au
+numérateur. Pour que le séparateur décimal soit la virgule à la place du point, il suffit de mettre la variable
+\var{usecomma} à la valeur $1$. Cette macro est
+également sensible aux variables \var{dollar} (pour ajouter ou non des \$ autour des labels des graduations), et 
+\var{nbdeci} qui fixe le nombre de décimales affichées.
+
+\item Les paramètres optionnels \argu{posOrigine} et \argu{labelpos} permettent de positionner les labels:
+
+	\begin{itemize}
+	\item \argu{posOrigine}=0: pas de label à l'origine,
+	\item \argu{posOrigine}=1: label normal à l'origine,
+	\item \argu{posOrigine}=2: label décalé vers le haut à l'origine (valeur par défaut),
+	\item \argu{posOrigine}=-2 label décalé vers le bas à l'origine,
+	\item \argu{labelPos}=0 : pas de label du tout,
+	\item \argu{Re(labelpos)}=left: labels à gauche de l'axe (valeur par défaut),
+	\item Re(\argu{labelPos}=right : labels à droite de l'axe,
+	\item Im(\argu{labelPos})=1: labels orthogonaux à l'axe.
+	\end{itemize}
+\end{itemize}
+
+
+\begin{demo}{Utilisation de axeX, axeY}{axeXY}
+\begin{texgraph}[name=axeXY,export=pgf]
+view(-5,5,-5,5),size(7.5),
+LabelSize:=footnotesize,
+//graphique du haut
+SaveWin(),
+view(-5,5,0.25,5),Width:=6, Arrows:=1,
+SetMatrix([2.5*i,2/pi,2*i]),
+axeX(0,pi/2,Nil,Nil,1,"\pi",2), axeY(0,1),
+Arrows:=0, Color:=red, Width:=8,
+tMin:=-2*pi, tMax:=2*pi, Cartesienne(sin(x)),
+Label(pi*1.65+i,"$f(x)=\sin(x)$"),RestoreWin(),
+//graphique du bas
+SaveWin(), Color:=black,
+view(-5,5,-5,-0.25), SetMatrix([-5.5*i,2,i]),
+Width:=6, Arrows:=1, usecomma:=1,
+axeX([i,0],0.5), axeY([i,0],1,Nil,Nil,1,"a"),
+Arrows:=0, Color:=blue, Width:=8,
+Cartesienne(x^2+1),
+Label(1+4.75*i,"$g(x)=x^2+a$"),
+RestoreWin()
+\end{texgraph}
+\end{demo}
+
+
+\subsection{background}\label{macbackground}
+
+\begin{itemize}
+\item \util \textbf[background()]{background( <fillstyle>, <fillcolor> )}.
+\item \desc permet de remplir le fond de la fenêtre graphique avec le style et la couleur demandée. Cette macro met à
+jour la variable \var{backcolor}.
+\end{itemize}
+
+\subsection{bbox}
+
+\begin{itemize}
+\item \util \textbf[bbox()]{bbox()}.
+\item \desc permet d'ajuster la fenêtre à la "bounding box" autour du dessin courant. Cette macro est destinée à être
+utilisée dans la ligne de commande en bas de la fenêtre principale, et non pas dans un élément graphique.
+\end{itemize}
+
+
+\subsection{centerView}
+
+\begin{itemize}
+\item \util \textbf[centerView()]{centerView( <affixe> )}.
+\item \desc permet de centrer la fenêtre graphique sur le point représenté par \argu{affixe}, sans changer les
+dimensions courantes du graphique. Cette macro est plutôt destinée à être utilisée dans la ligne de commande en bas de
+la fenêtre principale.
+\end{itemize}
+
+\subsection{Cercle}\label{cmdCercle}
+
+\begin{itemize}
+\item \util  \textbf[Cercle()]{Cercle( <A>, <r> [, B] )}.
+
+\item \desc trace un cercle de centre \argu{A} et de rayon \argu{r} lorsque le troisième paramètre est omis, sinon c'est
+le cercle défini par les trois points \argu{A}, \argu{r} et \argu{B}.
+
+Pour les macros \textsl{Arc} et \textsl{Cercle}, on peut s'attendre à des surprises dans le résultat final si le
+repère n'est pas orthonormé! Le repère est orthonormé lorsque les variables \var{Xscale} et \var{Yscale} sont égales,
+voir option \Helpref{Paramètres/Fenêtre}{param}.
+\end{itemize}
+
+\begin{demo}{La cycloïde}{cycloide}
+\begin{texgraph}[name=cycloide,export=pgf]
+view(-5,5,-1,3),Marges(0,0,0,0),
+size(7.5), Seg(-5,5),
+for t in [-4,-1.85,0,1.85,3] do
+  M:=t-sin(t)+i*(1-cos(t)),
+  I:=t+i, DotStyle:=cross,
+  Point(I), DotStyle:=bigdot,
+  Point(M), Cercle(I,1), Seg(M,I),
+  Arrows:=1, Arc(M,I,t,0.5,t),
+  Arrows:=0, LineStyle:=dashed,
+  Seg(I,t), LineStyle:=solid
+od,
+Width:=8,Color:=red,
+Courbe( t-sin(t)+i*(1-cos(t)))
+\end{texgraph}
+\end{demo}
+
+\subsection{Clip}
+
+\begin{itemize}
+\item \util \textbf[Clip()]{Clip( <liste> )}.
+\item \desc permet de clipper les éléments graphiques déjà dessinés avec la \argu{liste} qui doit être une courbe fermée
+et simple. La macro peint l'extérieur de la courbe représentée par la \argu{liste}.
+\end{itemize}
+
+\subsection{Dbissec}
+
+\begin{itemize}
+\item \util \textbf[Dbissec()]{Dbissec( <B>, <A>, <C>, <1 ou 2> )}.
+\item \desc dessine la bissectrice de l'angle $\widehat{BAC}$, intérieure si le dernier paramètre vaut $1$ et extérieure
+pour la valeur $2$.
+\end{itemize} 
+
+\subsection{Dcarre}
+
+\begin{itemize}
+\item \util \textbf[Dcarre()]{Dcarre( <A>, <B>, <+/-1> [, rayon]  )}.
+\item \desc dessine de carré de sommets consécutifs \argu{A} et \argu{B} dans le sens direct si le troisième paramètre
+vaut $1$ (indirect pour $-1$). Si le paramètre \argu{rayon} est présent, alors les \og coins\fg\ de la figure seront
+arrondis par un arc de cercle ayant le rayon mentionné.
+\end{itemize} 
+
+
+\subsection{Ddroite}
+
+\begin{itemize}
+\item \util \textbf[Ddroite()]{Ddroite( <A>, <B> )}.
+\item \desc dessine la demi-droite $[A,B)$.
+\end{itemize} 
+
+\subsection{Dmed}
+
+\begin{itemize}
+\item \util \textbf[Dmed()]{Dmed( <A>, <B> [, angle droit(0/1)] )}.
+\item \desc dessine la médiatrice du segment $[A,B]$. Si le troisième paramètre vaut $1$ ($0$ par défaut) alors un angle
+droit est dessiné.
+\end{itemize} 
+
+
+\subsection{domaine1}
+
+\begin{itemize}
+\item \util \textbf[domaine1()]{domaine1( <f(x)> [, a, b] )}.
+\item \desc dessine la partie du plan comprise entre la courbe Cf, l'axe $Ox$ et les droites $x=a$, $x=b$ si a et b sont
+précisés, sinon $x=$\textsl{tMin} et $x=$\textsl{tMax}.
+\end{itemize}
+
+
+\subsection{domaine2}
+
+\begin{itemize}
+\item \util \textbf[domaine2()]{domaine2( <f(x)>, <g(x)> [, a, b] )}.
+\item \desc dessine la partie du plan comprise entre les courbes Cf, Cg et les droites $x=a$, $x=b$ si a et b sont
+précisés, sinon $x=$\textsl{tMin} et $x=$\textsl{tMax}.
+\end{itemize}
+
+
+\subsection{domaine3}
+
+\begin{itemize}
+\item \util \textbf[domaine3()]{domaine3( <f(x)>, <g(x)> )}.
+\item \desc délimite la partie du plan comprise entre les courbes Cf et Cg avec $x$ dans l'intervalle
+\textsl{[tMin,tMax]}, en recherchant les points d'intersection.
+\end{itemize}
+
+\begin{demo}{Exemple avec domaine1, 2 et 3}{domaines}
+\begin{texgraph}[name=domaines,export=pgf]
+view(-5,5,-4,5),size(7.5),tMin:=-5,
+Axes(-5,1+i,2+2*i), tMax:=-1,
+Cartesienne(sin(x)), tMax:=5,
+Cartesienne(2*cos(x)),tMin:=-3,tMax:=3,
+Cartesienne(x^2), A:=-4.5+(Ymin+1.75)*i,
+FillStyle:=full, FillOpacity:=0.5,FillColor:=green,
+LabelStyle:=left, LabelSize:=footnotesize,
+Dcarre(A+0.25*(-1+i), A+0.25*(1+i), -1),
+Label(A+0.4,"domaine2 sur $[-4\,;\, -1.5]$ "),
+Inc(A,-0.75*i), FillColor:=blue,
+Dcarre(A+0.25*(-1+i), A+0.25*(1+i),-1),
+Label(A+0.4,"domaine3 entre $2\cos(x)$ et $x^2$ "),
+Inc(A,-0.75*i), FillColor:=red,
+Dcarre(A+0.25*(-1+i), A+0.25*(1+i),-1),
+Label(A+0.4,"domaine1 sur $[1.1\,;\, 4]$"),
+FillColor:=red, domaine1(2*cos(x), 1.1, 4),
+ FillColor:=green, domaine2(2*cos(x), sin(x),-4,-1.5),
+FillColor:=blue, domaine3(2*cos(x),x^2),
+Arrows:=2, tangente(2*cos(x),0.5,1.5)
+\end{texgraph}
+\end{demo}
+
+\subsection{Dparallel}
+
+\begin{itemize}
+\item \util \textbf[Dparallel()]{Dparallel( <[A, B]> , <C> )}.
+\item \desc dessine la parallèle à la droite \argu{[A,B]} passant par \argu{C}.
+\end{itemize} 
+
+\subsection{Dparallelo}
+
+\begin{itemize}
+\item \util \textbf[Dparallelo()]{Dparallelo( <A>, <B> , <C> [, rayon] )}.
+\item \desc dessine le parallèlogramme de sommets consécutifs \argu{A}, \argu{B} et \argu{C}. Si le paramètre
+\argu{rayon} est présent, alors les \og coins\fg\ de la figure seront arrondis par un arc de cercle ayant le rayon
+mentionné.
+\end{itemize} 
+
+
+\subsection{Dperp}
+
+\begin{itemize}
+\item \util \textbf[Dperp()]{Dperp( <[A, B]> , <C> [, angle droit(0/1)] )}.
+\item \desc dessine la perpendiculaire à la droite \argu{[A,B]} passant par \argu{C}. Si le troisième paramètre vaut $1$
+($0$ par défaut) alors un angle droit est dessiné.
+\end{itemize}
+
+\subsection{Dpolyreg}
+
+\begin{itemize}
+\item \util \textbf[Dpolyreg()]{Dpolyreg( <centre> , <sommet>, <nombre de côtés> [, rayon] )}.
+\item \desc dessine le polygône régulier défini par le \argu{centre}, un \argu{sommet} et le \argu{nb de côtés}. Si le
+paramètre \argu{rayon} est présent, alors les \og coins\fg\ de la figure seront arrondis par un arc de cercle ayant le
+rayon mentionné.
+\end{itemize}  
+
+\centerline{ou}
+
+\begin{itemize}
+\item \util \textbf[Dpolyreg()]{Dpolyreg( <sommet1>, <sommet2>, <nombre de cotés +sens*i> [, rayon] )}.
+\item \desc dessine le polygône régulier défini par deux sommets consécutifs \argu{sommet1} et \argu{sommet2}, le 
+\argu{nb de côtés}, et le \argu{sens} ($1$ pour direct et $-1$ pour indirect). Si le paramètre \argu{rayon} est présent,
+alors les \og coins\fg\ de la figure seront arrondis par un arc de cercle ayant le rayon mentionné.
+\end{itemize}
+
+\subsection{DpqGoneReg}\label{macDpqGoneReg}
+
+\begin{itemize}
+\item \util \textbf[DpqGoneReg()]{DpqGoneReg( <centre> , <sommet>, <[p,q]> )}.
+\item \desc dessine le \argu{p/q}-gône régulier défini par le \argu{centre} et un \argu{sommet}.
+\end{itemize} 
+
+\begin{demo}{\textit{DpqGoneReg}: exemple}{pqGoneReg}
+\begin{texgraph}[name=pqGoneReg,export=pgf]
+view(-5,5,-6,6),Marges(0,0,0,0),size(7.5),
+FillStyle:=full, FillColor:=lightpink,
+Color:=blue, Width:=8,
+DpqGoneReg(-2.5+2.5*i,-2.5+0.25*i, [7,3]),
+Label(-2.5+5*i,"[7,3]"),
+DpqGoneReg(2.5+2.5*i,2.5+0.25*i, [7,2]),
+Label(2.5+5*i,"[7,2]"),
+DpqGoneReg(-2.5-2.5*i,-2.5-0.25*i, [7,1]),
+Label(-2.5-5*i,"[7,1]"),
+DpqGoneReg(2.5-2.5*i,2.5-0.25*i, [6,2]),
+Label(2.5-5*i,"[6,2]") 
+\end{texgraph}
+\end{demo}
+
+
+\subsection{drawSet}\label{macdrawSet}
+
+\begin{itemize}
+\item \util \textbf[drawSet()]{drawSet( <ensemble> )}.
+\item \desc dessine un ensemble produit par les macros \Helpref{capB}{maccapB}, \Helpref{cupB}{maccupB} ou
+\Helpref{setminusB}{macsetminusB}.
+\end{itemize} 
+
+\subsection{Drectangle}
+
+\begin{itemize}
+\item \util \textbf[Drectangle()]{Drectangle( <A>, <B> , <C> [, rayon] )}.
+\item \desc dessine le rectangle de sommets consécutifs \argu{A}, \argu{B}, le côté opposé passant par \argu{C}. Si le
+paramètre \argu{rayon} est présent, alors les \og coins\fg\ de la figure seront arrondis par un arc de cercle ayant le
+rayon mentionné.
+\end{itemize} 
+
+
+\subsection{ellipticArc}\label{macellipticArc}
+\begin{itemize}
+\item \util \textbf[ellipticArc()]{ellipticArc( <B>, <A>, <C>, <RX>, <RY>, <sens(+/-1)> [, inclinaison] )}.
+\item \desc dessine un arc d'ellipse de centre \argu{A}, allant de \argu{B} à \argu{C} de rayons \argu{RX} et \argu{RY},
+l'axe portant le rayon \argu{RX} ayant une certaine \argu{inclinaison} par rapport à l'horizontale, celle-ci est en
+degrés et vaut 0 par défaut, le paramètre \argu{sens} indique le sens de rotation, 1 pour le sens trigonométrique.
+\end{itemize}
+
+
+\subsection{flecher}
+
+\begin{itemize}
+\item \util \textbf[flecher()]{flecher( <liste>, <pos1, ..., posN> )}.
+\item \desc dessine des flèches le long de la ligne polygonale \argu{liste}, la position de chaque flèche (pos1, ...)
+est un nombre entre $0$ et $1$ ($0$ pour début de la ligne et $1$ pour fin de ligne), les flèches sont dessinées dans le
+sens de parcourt de la ligne, pour inverser une flèche on ajoute +i à la position.
+\item \exem \co{flecher(Get(Cercle(0,3)), [0,0.5] )}
+\end{itemize}
+
+\subsection{GradDroite}\label{macGradDroite}
+
+\begin{itemize}
+\item \util \textbf[GradDroite()]{GradDroite( <[A, origine + i*posOrigine, etendue]>, <[u, unit]>, <hautDiv>, <subdiv>
+[, poslab, orientation, num, ""texte"", den, firstnum] )}
+\item \desc gradue la droite passant par \argu{A} et dirigée par le vecteur \argu{u} (celui-ci n'est pas forcément
+unitaire), \argu{hautdiv} est la hauteur des graduations en cm, \argu{subdiv} est le nombre de subdivisions par unité.
+
+Paramètres optionnels:
+	\begin{itemize}
+	\item \argu{origin}: indique la graduation de l'origine \argu{A} (0 par défaut), 
+	\item \argu{posOrigin}: indique la position du label à l'origine \argu{A}, plusieurs cas: 
+		\begin{itemize}
+		\item \argu{posOrigin}=0: pas de label à l'origine,
+		\item \argu{posOrigin}=1: label normal à l'origine (comme les autres)
+		\item \argu{posOrigin}=2: label à l'origine décalé dans le sens du vecteur \argu{u} (valeur par défaut),
+		\item \argu{posOrigin}=-2: label à l'origine décalé dans le sens opposé du vecteur \argu{u}.
+		\end{itemize}
+
+	\item \argu{etendue}: représente l'intervalle des graduations sous forme complexe: \textsl{min+i*max}, le tracé
+de l'axe sera limité à cet intervalle. Si ce paramètre est omis, le tracé occupera la fenêtre.
+	\item \argu{unit}: indique le pas des graduations sur l'axe (1 par défaut), cette valeur doit être positive.
+	\item \argu{poslab} indique la position des labels par rapport à l'axe, ce paramètre prend les valeurs \co{top}
+ou \co{bottom}, 
+	\item \argu{orientation}: orientation des labels, la valeur $i$ signifie que les labels sont orthogonaux à
+l'axe, sinon l'orientation représente le \var{LabelStyle} (left, right, top, ...),
+	\item  chaque graduation est multipliée par la fraction \argu{num/den} (1 par défaut), ajoutée à
+\argu{firstnum/den} (l'origine par défaut) et accompagnée du \argu{"texte"} au numérateur. Pour avoir une virgule comme
+spérateur décimal au lieu du point, il faut mettre la variable \var{usecomma} à la valeur $1$.  Cette macro est
+également sensible aux variables \var{dollar} (pour ajouter ou non des \$ autour des labels des graduations), et 
+\var{nbdeci} qui fixe le nombre de décimales affichées. Le nombre maximal de
+graduations est fixé par la variable \var{maxGrad} qui vaut $100$ par défaut.
+	\end{itemize}
+
+\item \exem \co{GradDroite([0,1+2*i],[1,0.5], xyticks, 1, bottom, i)}: signifie que la graduation de l'origine sera 1
+avec un label décalé à droite, les graduations iront de 0.5 en 0.5, les labels seront sous l'axe et orthogonaux à l'axe.
+
+\end{itemize}
+
+\subsection{LabelArc}
+
+\begin{itemize}
+\item \util \textbf[LabelArc()]{LabelArc( <B>, <A>, <C>, <R>, <sens>, <"texte">,  [, options] )}.
+\item \desc cette macro dessine un arc de cercle de centre \argu{A}, de rayon \argu{R} partant de la droite $(AB)$
+jusqu'à la droite $(AC)$, l'argument facultatif \argu{sens} indique: le sens trigonométrique si sa valeur est 1 (valeur
+par défaut), le sens contraire si valeur est -1. La macro ajoute également le \argu{"texte"}. Le paramètre
+\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les
+options sont:
+
+	\begin{itemize}
+	\item \opt{labelpos}{inside/outside}: positionnement du label (outside par defaut)),
+	\item \opt{labelsep}{distance en cm}: distance du label à l'arc (0.25cm par défaut).
+	\item \opt{rotation}{nombre}: angle en degrés que fait le label par rapport à l'horizontale ($0$ par défaut).
+	\end{itemize}
+Il est possible dans la liste des options, de modifier des attributs comme \var{Color} par exemple.
+\end{itemize}
+
+
+
+\subsection{LabelAxe}
+
+\begin{itemize}
+\item \util \textbf[LabelAxe()]{LabelAxe( <x ou y>, <affixe>, <label> [, [labelPos,décalage en cm], mark(0/1)] )}.
+\item \desc permet d'ajouter un label sur un des axes \argu{x ou y}, \argu{affixe} désigne l'affixe du point où se fait
+l'ajout, \argu{label} contient le texte à ajouter. Paramètres optionnels, \argu{[labelPos, décalage en cm]} et
+\argu{mark}:
+	\begin{itemize}
+	\item Re(\argu{labelpos})=1 signifie en dessous pour Ox et à droite pour Oy (par défaut pour Ox),
+	\item Re(\argu{labelpos})=2 signifie au dessus pour Ox et à gauche pour Oy (par défaut pour Oy),
+	\item Im(\argu{labelpos})=-1 signifie un décalage sur la gauche pour Ox, vers le bas pour Oy, si le décalage
+n'est pas précisé, il vaut 0.25 cm par défaut,
+	\item Im(\argu{labelpos})=1 signifie un décalage sur la droite pour Ox, vers le haut pour Oy, si le décalage
+n'est pas précisé, il vaut 0.25 cm par défaut,
+	\item Im(\argu{labelpos})=0 signifie pas de décalage (valeur  par défaut),
+	\item \argu{mark}: indique si le point doit être marqué (dans le dotsyle courant).
+	\end{itemize}
+\end{itemize}
+
+\subsection{LabelDot}\label{macLabelDot}
+
+\begin{itemize}
+\item \util \textbf[LabelDot()]{LabelDot( <affixe>, <"texte">, <orientation> [, DrawDot, distance] )}.
+\item \desc cette macro affiche un texte à coté du point \argu{affixe}. L'orientation peut être "N" pour nord, "NE" pour
+nord-est ...etc, ou bien une liste de la forme [longueur, direction] où direction est un complexe, dans ce deuxième cas,
+le paramètre optionnel \argu{distance} est ignoré. Le point est également affiché lorsque \argu{DrawDot} vaut $1$ (0 par
+défaut) et on peut redéfinir la \argu{distance} en cm entre le point et le texte (0.25cm par défaut).
+\end{itemize}
+
+\subsection{LabelSeg}
+
+\begin{itemize}
+\item \util \textbf[LabelSeg()]{LabelSeg( <A>, <B>, <"texte">,  [, options] )}.
+\item \desc cette macro dessine le segment défini par \argu{A} et \argu{B}, et ajoute le \argu{"texte"}. Le paramètre
+\argu{options} est une liste (facultative) de la forme \textsl{[ option1:= valeur1, ..., optionN:=valeurN ]}, les
+options sont:
+	\begin{itemize}
+	\item \opt{labelpos}{center/top/bottom}: positionnement du label (center par défaut),
+	\item \opt{labelsep}{distance en cm}: distance du label au segment lorsque labelpos vaut top ou bottom (0.25cm
+par défaut).
+	\item \opt{rotation}{nombre}: angle en degrés que fait le label par rapport à l'horizontale (par défaut le label
+est parallèle au segment).
+	\end{itemize}
+Il est possible dans la liste des options, de modifier des attributs comme \var{Color} par exemple.
+\end{itemize}
+
+
+\subsection{markangle}
+
+\begin{itemize}
+\item \util \textbf[markangle()]{markangle( <B>, <A>, <C>, <r>, <n>, <espacement>, <longueur> )}.
+\item \desc même chose que \Helpref{markseg}{cmdmarkseg} mais pour marquer un arc de cercle.
+\end{itemize}
+
+
+\subsection{markseg}\label{cmdmarkseg}
+
+\begin{itemize}
+\item \util \textbf[markseg()]{markseg( <A>, <B>, <n>, <espacement>, <longueur> [, angle] )}.
+\item \desc marque le segment $[A,B]$ avec \argu{n} petits segments, l'\argu{espacement} est en unité graphique, et la
+\argu{longueur} en cm. Le paramètre optionnel \argu{angle} permet de définir en degré l'angle que feront les marques par
+rapport à la droite $(AB)$ (45 degrés par défaut).
+\end{itemize}
+
+
+\subsection{periodic}
+
+\begin{itemize}
+\item \util \textbf[periodic()]{periodic( <f(x)>, <a>, <b> [, divisions, discontinuités] )}.
+\item \desc trace la courbe de la fonction périodique définie par $y=f(x)$ sur la période $[a;b]$, puis translate le
+motif pour couvrir l'intervalle [tMin; tMax]. Les deux paramètres optionnels sont identiques à ceux des courbes
+paramétrées (nombre de divisions et discontinuités).
+\end{itemize}
+
+\begin{demo}{Fonctions périodiques}{periodic}
+\begin{texgraph}[name=periodic,export=pgf]
+view(-5,5,-5,5), size(7.5),
+Axes(0,1+i), Width:=8,
+Color:=red,
+periodic(if t>0 then 4 else 2 fi,-1,1,5,1),
+Color:=blue,
+periodic(2*abs(t)-1,-1,1),
+Color:=magenta,
+periodic(sin(t)-3,-pi/2,pi/2) 
+\end{texgraph}
+\end{demo}
+
+\subsection{Rarc}
+
+\begin{itemize}
+\item \util \textbf[Rarc()]{Rarc( <B>, <A>, <C>, <R>, <sens> )}.
+\item \desc comme la macro \Helpref{Arc}{macArc} sauf que l'arc de cercle est rond même si le repère n'est pas
+orthonormé, le rayon \argu{R} est en centimètres.
+\end{itemize}
+
+\subsection{Rcercle}
+
+\begin{itemize}
+\item \util \textbf[Rcercle()]{Rcercle( <A>, <R> )} ou \Mytextbf{Rcercle( <A>, <B>, <C> )}.
+\item \desc dessine un cercle rond même si le repère n'est pas orthonormé. Dans la première forme, le rayon \argu{R} est
+en centimètres.
+\end{itemize}
+
+\subsection{Rellipse}
+
+\begin{itemize}
+\item \util \textbf[Rellipse()]{Rellipse( <O>, <RX>, <RY> [, inclinaison] )}.
+\item \desc comme la commande \Helpref{Ellipse}{cmdEllipse} sauf que celle-ci est insensible au repère écran, les rayons
+sont en centimètres.
+\end{itemize}
+
+\subsection{RellipticArc}
+
+\begin{itemize}
+\item \util \textbf[RellipticArc()]{RellipticArc( <B>, <A>, <C>, <RX>, <RY>, <sens(+/-1)> [, inclinaison] )}.
+\item \desc comme la macro \Helpref{ellipticArc}{macellipticArc} sauf que celle-ci est insensible au repère écran, les
+rayons sont en centimètres.
+\end{itemize}
+
+\subsection{RestoreWin}\label{macRestoreWin}
+
+\begin{itemize}
+\item \util \textbf[RestoreWin()]{RestoreWin()}.
+\item \desc restaure la fenêtre graphique ainsi que la matrice 2D enregistrées lors du dernier appel à la macro
+\Helpref{SaveWin}{macSaveWin}.
+\end{itemize}
+
+\subsection{SaveWin}\label{macSaveWin}
+
+\begin{itemize}
+\item \util \textbf[SaveWin()]{SaveWin()}.
+\item \desc enregistre la fenêtre graphique ainsi que la matrice 2D courantes, sur une pile. Cette macro va de paire
+avec la macro \Helpref{RestoreWin}{macRestoreWin}.
+\item \exem plusieurs graphiques sur un seul: voir \Helpref{cet exemple}{axeXY}.
+\end{itemize}
+
+\subsection{Seg}
+
+\begin{itemize}
+\item \util \textbf[Seg()]{Seg( <A>, <B> )}.
+\item \desc dessine le segment $[A,B]$.
+\end{itemize}
+
+\subsection{set}\label{macset}
+
+\begin{itemize}
+\item \util \textbf[set()]{set( <nom>, <affixe centre> [, options] )}.
+\item \desc dessine un ensemble en forme de patatoïde, \argu{affixe centre} désigne le centre de cet ensemble, et le
+paramètre \argu{nom} est une chaîne contenant le nom de cet ensemble. 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}{entier positif}: représente l'échelle (1 par défaut),
+	\item \opt{rotation}{angle en degrés}: permettant d'incliner le dessin (0 degré par défaut),
+	\item \opt{labels}{0/1}: pour afficher ou non le nom de l'ensemble.
+	\item \opt{labelsep}{distance en cm}: distance du label au bord de l'ensemble (0.45cm par défaut)
+	\end{itemize}
+Il est possible dans la liste des options, de modifier des attributs comme \co{LabelStyle} par exemple.
+\item La macro renvoie en résultat la liste des points de la courbe dessinant l'ensemble.
+\end{itemize}
+
+\subsection{setB}\label{macsetB}
+
+\begin{itemize}
+\item \util \textbf[setB()]{setB( <nom>, <affixe centre> [, options] )}.
+\item \desc dessine un ensemble en forme de patatoïde à l'aide de courbes de Bézier, \argu{affixe centre} désigne le
+centre de cet ensemble, et le paramètre \argu{nom} est une chaîne contenant le nom de cet ensemble. 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}{entier positif}: représente l'échelle (1 par défaut),
+	\item \opt{rotation}{angle en degrés}: permettant d'incliner le dessin (0 degré par défaut),
+	\item \opt{labels}{0/1}: pour afficher ou non le nom de l'ensemble.
+	\item \opt{labelsep}{distance en cm}: distance du label au bord de l'ensemble (0.45cm par défaut)
+	\end{itemize}
+Il est possible dans la liste des options, de modifier des attributs comme \co{LabelStyle} par exemple.
+\item La macro renvoie en résultat la liste des points de contrôle de la courbe représentant l'ensemble. Cette liste
+peut-être utilisée ensuite pour déterminer une intersection (voir \Helpref{capB}{maccapB}), une réunion (voir
+\Helpref{capB}{maccapB}) ou une différence (voir \Helpref{setminusB}{macsetminusB}).
+\end{itemize}
+
+
+\subsection{size}\label{macsize}
+
+\begin{itemize}
+\item \util \textbf[size()]{size( <largeur + i*hauteur> [, ratio(Xscale/Yscale)] )}
+\item \desc permet de fixer les tailles du graphique: \argu{largeur} et \argu{hauteur} (marges incluses) en cm. Si le
+paramètre \argu{hauteur} est nul, alors on considère que hauteur=largeur.
+
+Si le paramètre \argu{ratio} est omis, les échelles sur les deux axes sont calculées pour que la figure entre au plus
+juste dans le cadre fixé, tout en conservant le ratio courant.
+
+Si \argu{ratio} est égal à $0$ alors les échelles sont calculées de manière à obtenir exactement la taille souhaitée (le
+ratio courant n'est donc vraisemblablement pas conservé).
+
+Le repère est orthonormé lorsque le paramètre \argu{ratio} vaut 1. 
+
+\Mytextbf{NB}: un appel aux fonctions \textsl{Fenetre} \textsl{Marges} ou à la macro \textsl{view}, modifiera la taille
+du graphique. Il est donc préférable de déterminer les marges et la fenêtre graphique \Mytextbf{avant} de fixer la
+taille.
+
+La largeur d'un graphique est donnée par la formule: 
+
+\centerline{\textsl{(Xmax-Xmin)*Xscale+margeG+margeD}}
+
+et la hauteur est donnée par:
+
+\centerline{\textsl{(Ymax-Ymin)*Yscale+margeH+margeB}}
+\end{itemize}
+
+\subsection{suite}
+
+\begin{itemize}
+\item \util \textbf[suite()]{suite( <f(x)>, <u0>, <n> )}.
+\item \desc représentation graphique de la suite définie par $u_{n+1}=f(u_n)$, de premier terme \argu{u0} et jusqu'au
+rang \argu{n}. Cette macro ne représente que les "escaliers".
+\end{itemize}
+
+
+\begin{demo}{Utilisation de la macro suite}{suite}
+\begin{texgraph}[name=suite,export=pgf]
+view(-0.1,1.1,-0.1,1.1),size(7.5),
+Arrows:=1,Axes(0,1/2+i/4),Arrows:=0,
+u0:=0.3,nb:=20, Width:=6,
+Color:=darkseagreen,
+Droite(1,-1,0), Color:=red,
+tMin:=0, tMax:=1,
+Width:=8, Cartesienne(4*x*(1-x)),
+Width:=6, Color:=blue,
+Label(0.5+1.05*i,"$u_{n+1}=4u_n(1-u_n)$"),
+LabelDot(u0, "$u_0$","S",1),
+suite(4*x*(1-x), u0,nb)
+\end{texgraph}
+\end{demo}
+
+
+
+\subsection{tangente}
+
+\begin{itemize}
+\item \util \textbf[tangente()]{tangente( <f(x)>, <x0> [, longueur] )}.
+\item \desc trace la tangente à la courbe cartésienne $y=f(x)$ au point d'abscisse 
+\argu{x0}, on trace un segment de la \argu{longueur} indiquée (en cm) ou la droite entière si la longueur est omise.
+\end{itemize}
+
+
+\subsection{tangenteP}
+
+\begin{itemize}
+\item \util \textbf[tangenteP()]{tangenteP( <f(t)>, <t0> [,longueur] )}.
+\item \desc trace la tangente à la courbe paramétrée par \argu{f(t)} au point de paramètre \argu{t0}, on trace un
+segment de la \argu{longueur} indiquée (en cm) ou la droite entière si la longueur est omise.
+\end{itemize}
+
+\subsection{view}
+
+\begin{itemize}
+\item \util \textbf[view()]{view( <xmin>, <xmax>, <ymin>, <ymax> )} ou \Mytextbf{view( <[xmin+i*ymin, xmax+i*ymax]> )}
+\item \desc change la fenêtre graphique courante et conserve l'échelle. Attention: ceci change la taille du graphique,
+celle-ci peut-être modifiée avec la macro \Helpref{size}{macsize}.
+\item \exem dans un élément graphique utilisateur, la commande \co{[ view(-4, 4,-3, 3), size(12) ]} va fixer la fenêtre
+graphique à $[-4,4]\times[-3,3]$, et la taille du graphique à 12cm en conservant le ratio courant. Il est important de
+respecter l'ordre (view avant size).
+\end{itemize}
+
+
+\subsection{wedge}
+
+\begin{itemize}
+\item \util \textbf[wedge()]{wedge( <B>, <A>, <C>, <r> )}
+\item \desc dessine le secteur angulaire défini par l'angle $\widehat{BAC}$ avec un rayon \argu{r}.
+\end{itemize}
+
+\subsection{zoom}
+
+\begin{itemize}
+\item \util \textbf[zoom()]{zoom( <+/-1> )}
+\item \desc permet de faire un zoom arrière/avant.
+\end{itemize}