• coordsys: permet d'utiliser n'importe quel repère cartésien.
• point : équivalent au type pair dans le repère par défaut.
• vector : aussi équivalent au type pair dans le repère par défaut.
• mass : pour les barycentres.
• line : quelques objets de type line :
• line line(point A, bool extendA=true, point B, bool extendB=true)
  Pour les droites, demi-droites (extendA=false ou extendB=false) et segments de droites (extendA=false et extendB=false).
  line line(coordsys R=currentcoordsys, real a, real b, real c)
  Renvoie la droite d'équation kitxmlcodeinlinelatexdvpax+by +c = 0finkitxmlcodeinlinelatexdvp dans le repère R.
  line line(coordsys R=currentcoordsys, real slope, real origin)
  Renvoie la droite de pente slope et d'ordonnée à l'origine origin donnés relativement au repère R.
  line parallel(point M, line l)
  Renvoie la droite parallèle à l passant par M.
  line parallel(point M, explicit vector dir)
  Renvoie la droite de vecteur directeur dir et passant par M.
  line parallel(point M, explicit pair dir)
  Renvoie la droite de vecteur directeur dir donné dans le repère courant currentcoordsys et passant par M.
  line line(real a, point A=point(currentcoordsys,(0,0)))
  Renvoie la droite passant par A et faisant un angle de a degrés avec l'axe des abscisses du repère dans lequel est défini A.
  line bisector(line l1, line l2, real angle=0, bool sharp=true)
  Renvoie l'image de la bissectrice de l'angle formé par les droites orientées l1 et l2 par la rotation de centre « l'intersection de l1 et l2 » et d'angle angle. Si le paramètre sharp vaut true, renvoie la bissectrice de l'angle aigu.
  line sector(int n=2, int p=1, line l1, line l2, real angle=0, bool sharp=true)
  Renvoie l'image de la p-ième droite qui partage l'angle formé par les droites orientées l₁ et l₂ en n parties égales par la rotation de centre « l'intersection de l₁ et l₂ » et d'angle angle. Si le paramètre sharp vaut true, considère l'angle aigu.
  line perpendicular(point M, line l)
  Renvoie la droite perpendiculaire à l passant par M.
  line perpendicular(point M, explicit vector normal)
  Renvoie la droite passant par M et de vecteur normal normal.
  line perpendicular(point M, explicit pair normal)
  Renvoie la droite passant par M et de vecteur normal normal donné dans le repère courant currentcoordsys.
  line reverse(line l)
  Renvoie la droite représentée par l avec une orientation contraire à celle de l.
  line extend(line l)
  Renvoie la droite portée par l qui peut être une demi-droite ou un segment de droite.
  line complementary(explicit line l)
  Renvoie la demi-droite complémentaire de l. Ne fonctionne que si l représente effectivement une demi-droite.
• Segment :
  segment segment(point A, point B)
  On notera notamment la routine :
  line bisector(segment s, real angle=0)
  qui renvoie l'image de la médiatrice de s par la rotation de centre « le milieu de s » et d'angle angle.
  Ainsi que :
  line[] complementary(explicit segment s)
  qui renvoie sous forme de tableau les deux demi-droites de support s et d'extrémités respectives s.A et s.B.
• conic : pour une conique quelconque non dégénérée. Les types dérivés sont : circle, ellipse, parabola et hyperbola.
  De nombreuses routines permettent de définir un cercle. Entre autres :
  circle circle(explicit point C, real r)
  Renvoie le cercle de centre C et de rayon r.
  circle circle(point A, point B)
  Renvoie le cercle de diamètre AB.
  circle circle(point A, point B, point C)
  Renvoie le cercle passant par les points distincts A, B et C.
  Etc. (Voir la documentation)
• arc : pour les arcs orientés d'ellipses.
  arc arc(ellipse el, real angle1, real angle2,polarconicroutine polarconicroutine=polarconicroutine(el), bool direction=CCW)
• abscissa : pour instancier une abscisse sur un objet de type line, segment, conic et arc.

• triangle : structure assez complexe bénéficiant de nombreuses routines. Encore une fois, le minimum sera vu. Ici, la lecture de la documentation est essentielle.

   

  Sélectionnez

  struct triangle {
      restricted point A, B, C; // points marquant les sommets du triangle
  struct vertex { // sommet de triangle
      int n;
      triangle t; }
  restricted vertex VA, VB, VC; // les sommets du triangle
  struct side { // côté de triangle
      int n;
      triangle t; }
  side AB, BC, CA, BA, AC, CB; } // les côtés du triangle

   

  Sélectionnez

  void label(picture pic=currentpicture, Label LA="$A$",
             Label LB="$B$", Label LC="$C$",
             triangle t,
             real alignAngle=0,
             real alignFactor=1,
             pen p=nullpen, filltype filltype=NoFill)

• 
  Place les labels LA, LB et LC aux sommets du triangle t, alignés suivant la première bissectrice du sommet correspondant.
  Les paramètres alignAngle et alignFactor permettent de modifier la direction et la longueur de l'alignement.

   

  Sélectionnez

  void show(picture pic=currentpicture,
            Label LA="$A$", Label LB="$B$", Label LC="$C$",
            Label La="$a$", Label Lb="$b$", Label Lc="$c$",
            triangle t, pen p=currentpen, filltype filltype=NoFill)

• 
  Trace le triangle t et affiche les labels aux sommets du triangle ainsi que les longueurs de ses côtés. Cette routine est surtout utile pour localiser les sommets t.A, t.B et t.C en cours de codage.

   

  Sélectionnez

  void draw(picture pic=currentpicture, triangle t,
            pen p=currentpen, marker marker=nomarker)

• Trace le triangle t ; les côtés sont tracés comme des segments.
  void drawline(picture pic=currentpicture, triangle t, pen p=currentpen)
  Trace le triangle t ; les côtés sont tracés comme des droites.
  triangle triangle(point A, point B, point C)
  Renvoie le triangle dont les sommets sont A, B et C.
  triangle triangleabc(real a, real b, real c, real angle=0, point A=(0,0))
  Retourne le triangle ABC tel que BC=a, AC=b, AB=c et
  triangle triangleAbc(real alpha, real b, real c, real angle=0, point A=(0,0))
  Retourne le triangle ABC tel que

  kitxmlcodelatexdvp\left(\vec{AB};\vec{AC}\right)= \mathrm{alpha}finkitxmlcodelatexdvp

  , AC=b, AB=c et

  kitxmlcodelatexdvp\left(\vec{\imath};\vec{AB}\right)= \mathrm{angle}.finkitxmlcodelatexdvp

  
  triangle triangle(line l1, line l2, line l3)
  Renvoie le triangle dont les côtés sont l1, l2 et l3.
  Et de nombreuses autres routines permettant de tracer l'orthocentre, les hauteurs, le centre de gravité, les médianes, etc.

• trilinear : instancie des coordonnées trilinéaires relatives à un triangle (sic).

• inversion : permet d'instancier l'inversion de pôle C et de puissance k.

struct inversion
{
point C;
real k;
}

transform scale(real k, point M)

Homothétie de centre M et de rapport k.

transform scale(real k, line l1, line l2, bool safe=false)

Renvoie l'affinité de rapport k, d'axe l1 et de direction l2.

Si safe vaut true et l1 parallèle à l2, la routine renvoie l'identité.

transform projection(point A, point B)

Projection orthogonale sur la droite (AB).

transform projection(line l)

Renvoie la projection orthogonale sur l.

transform projection(point A, point B, point C, point D, bool safe=false)

Projection sur la droite (AB) parallèlement à (CD).

Si safe vaut true et (AB) est parallèle à (CD), l'identité est renvoyée.

Si safe vaut false et (AB) est parallèle à (CD), l'homothétie de centre O et de rapport infini est renvoyée.

transform projection(line l1, line l2, bool safe=false)

Renvoie la projection sur l1 parallèlement à l2.

Si safe vaut true et l1 parallèle à l2, la routine renvoie l'identité.

transform vprojection(line l, bool safe=false)

Renvoie la projection sur l parallèlement à la verticale.

Si safe vaut true et l est une droite verticale, la routine renvoie l'identité.

transform hprojection(line l, bool safe=false)

Renvoie la projection sur l parallèlement à l'horizontale.

Si safe vaut true et l est une droite horizontale, la routine renvoie l'identité.

transform scale(real k, point A, point B, point C, point D, bool safe=false)

Affinité de rapport k, d'axe (AB) et de direction (CD). Si safe vaut true et (AB) est parallèle à (CD), l'identité est renvoyée.

Si safe vaut false et (AB) est parallèle à (CD), l'homothétie de centre O et de rapport infini est renvoyée.

transform xscale(real k, point M)

Affinité de rapport k, d'axe « l'axe passant par M et parallèle à (Oy) » et de direction (Ox).

transform yscale(real k, point M)

Affinité de rapport k, d'axe « l'axe passant par M et parallèle à (Ox) » et de direction (Oy).

transform scaleO(real x)

Homothétie de rapport x et de centre « l'origine du repère courant ». Cette transformation est identique à scale(x, origin()).

transform xscaleO(real x)

Identique à xscale(x, origin()).

transform yscaleO(real x)

Identique à yscale(x, origin()).

transform rotateO(real angle)

Identique à rotate(angle, origin()).

transform reflect(line l)

Renvoie la réflexion par rapport à l.

void distance(picture pic=currentpicture, Label L="", point A, point B,
              bool rotated=true, real offset=3mm,
              pen p=currentpen, pen joinpen=invisible,
              arrowbar arrow=Arrows(NoFill))
              
void markrightangle(picture pic=currentpicture, point A, point O,
                    point B, real size=0, pen p=currentpen,
                    margin margin=NoMargin,
                    filltype filltype=NoFill)
                    
void perpendicularmark(picture pic=currentpicture, point z,
                       explicit pair align,
                       explicit pair dir=E, real size=0,
                       pen p=currentpen,
                       margin margin=NoMargin,
                       filltype filltype=NoFill)
                       
void perpendicularmark(picture pic=currentpicture, point z,
                       vector align,
                       vector dir=E, real size=0,
                       pen p=currentpen,
                       margin margin=NoMargin,
                       filltype filltype=NoFill)
                       
void perpendicularmark(picture pic=currentpicture, point z, explicit pair align, path g,
                       real size=0, pen p=currentpen,
                       margin margin=NoMargin,
                       filltype filltype=NoFill)
                       
void perpendicularmark(picture pic=currentpicture, point z, vector align, path g,
                       real size=0, pen p=currentpen,
                       margin margin=NoMargin,
                       filltype filltype=NoFill)
                       
path compassmark(pair O, pair A, real position, real angle=10)

À noter aussi la routine :

void addMargins(picture pic=currentpicture,
                real lmargin=0, real bmargin=0,
                real rmargin=lmargin, real tmargin=bmargin,
                bool rigid=true, bool allObject=true)

Pour le tracé des droites, ajoute des marges à l'image (remplace avantageusement interp).

Si rigid vaut false, les marges sont ajoutées si et seulement si une courbe infinie se prolonge jusqu'à la marge.

Si allObject vaut false, les objets de taille fixe (comme les labels et pointes de flèches) seront ignorés.

Quelques exemples :

Code 47 Sélectionnez import geometry; size(7cm); real ac=3, am=2, coef=am/ac; triangle t=triangleAbc(40,ac,4); drawline(t); label("$A$",t.A,NW); label("$B$",t.B,NE); label("$C$",t.C,2N); point M=relpoint(line(t.AC),-coef); line par=parallel(M,t.BC); draw(par); point pN=intersectionpoint(par,t.AB); label("$M$",M,2*S); label("$N$",pN,N+.5*E); addMargins(1cm,.5cm);	Code 48 Sélectionnez import geometry; size(6cm); triangle t=triangleabc(4,5,6); label(t); draw(t,linewidth(bp)); point pE=midpoint(t.AB), pF=t.A+(1/3)*(t.C-t.A), pG=t.B+(1/3)*(t.C-t.B); dot("$E$",pE,-dir(t.VC)); dot("$F$",pF,-dir(t.VB)); dot("$G$",pG,-dir(t.VA)); draw(segment(t.AB), StickIntervalMarker(2,2,angle=-35)); draw(t.C--pE^^t.B--pF^^t.A--pG); line CE=line(t.C,pE); line AG=line(t.A,pG); dot(intersectionpoint(CE,AG));
Code 49 Sélectionnez import geometry; size(6cm); triangle t=triangleabc(4,5,6); label(t); draw(t,linewidth(bp)); point pE=midpoint(t.AB), pF=t.A+(1/3)*(t.C-t.A), pG=t.B+(1/3)*(t.C-t.B); dot("$E$",pE,-dir(t.VC)); dot("$F$",pF,-dir(t.VB)); dot("$G$",pG,-dir(t.VA)); draw(segment(t.AB), StickIntervalMarker(2,2,angle=-35)); draw(t.C--pE^^t.B--pF^^t.A--pG); line CE=line(t.C,pE); line AG=line(t.A,pG); dot(intersectionpoint(CE,AG));	Code 50 Sélectionnez import geometry; size(6cm); triangle t=triangleabc(4,5,6); label(t); draw(t,linewidth(bp)); point pE=midpoint(t.AB), pF=t.A+(1/3)*(t.C-t.A), pG=t.B+(1/3)*(t.C-t.B); dot("$E$",pE,-dir(t.VC)); dot("$F$",pF,-dir(t.VB)); dot("$G$",pG,-dir(t.VA)); draw(segment(t.AB), StickIntervalMarker(2,2,angle=-35)); draw(t.C--pE^^t.B--pF^^t.A--pG); line CE=line(t.C,pE); line AG=line(t.A,pG); dot(intersectionpoint(CE,AG));
Code 51 Sélectionnez size(8cm); import geometry; usepackage("fourier"); void filldrawtri(triangle t, pen fpen=currentpen, pen dpen=currentpen) { filldraw(t.A--t.B--t.C--cycle,fpen,dpen); } point A=(0,0),B=(3,0),C=(1,2.5),pI=(A.x,C.y); point D=(4,0),pE=(7,0),G=(8.5,2.5),F=(G.x,0); point H=projection(A,B)*C; triangle t1=triangle(A,B,C); triangle t2=triangle(D,pE,G); filldrawtri(t1,lightgreen,linewidth(bp)); filldrawtri(t2,lightred,linewidth(bp)); draw(C--H^^pE--F^^G--F,dashed); markrightangle(C,H,A,3mm); markrightangle(G,F,D,3mm); distance("$\frac{1}{3}$",A,H,4mm, Arrows(1mm,NoFill)); distance("$\frac{1}{2}$",H,B,4mm); distance("$\frac{3}{5}$",A,pI, rotated=false,-2mm); distance("$\frac{3}{4}$",D,pE,4mm); distance("$\frac{2}{3}$",F,G,rotated=false);	Code 52 Sélectionnez import geometry; usepackage("fourier","upright"); usepackage("mathrsfs"); size(6cm); triangle t=triangleAbc(75,7,8.5,225); point H=foot(t.VA); circle c=circle(t.A,H); point[] ct=intersectionpoints(t,c); draw(t,heavyblue); draw(t.A--H); draw(c,red); draw(ct[0]--ct[3],deepgreen); label(t,heavyblue);dot("$O$",c.C,W); label("$\mathscr{C}$",angpoint(c,50),NE,red); label("$H$",H,NW); label("$D$",ct[0],NW,deepgreen); label("$E$",ct[3],E,deepgreen); markrightangle(t.A,H,t.C); markangle(scale(.8)*"$45^\circ$",5mm, t.B,t.A,H); markangle(scale(.8)*"$30^\circ$",n=2,6mm, H,t.A,t.C);

Sélectionnez import geometry; usepackage("fourier","upright"); usepackage("mathrsfs"); size(10cm); pen mediane=brown, bissec=heavymagenta, mediat=deepcyan, ortho=deepgreen; // ---------------------------------------------------------------------- triangle t=triangleabc(5,4,6); drawline(t); label(t); // ---------------------------------------------------------------------- line med=median(t.VA); point A1=midpoint(t.BC); point G=centroid(t); draw(med,mediane); dot("$A'$",A1,N+.5*E,mediane); dot("$G$",G,S,mediane); // ---------------------------------------------------------------------- line biss=bisector(t.VC); point Bi=bisectorpoint(t.AB); point Ci=incenter(t); circle ci=incircle(t); draw(biss,bissec); draw(ci,bissec); dot("$C_1$",Bi,SE,bissec); dot("$I$",Ci,N+.5*E,bissec); // ---------------------------------------------------------------------- line mediatrice=bisector(t.AC); point B1=midpoint(t.AC); point Cc=circumcenter(t); circle cc=circle(t); draw(mediatrice,mediat); draw(cc,mediat); dot("$B'$",B1,N,mediat); dot("$O$",Cc,E+.5*N,mediat); // ---------------------------------------------------------------------- line haut=altitude(t.VC); point C2=foot(t.VC); point orth=orthocentercenter(t); draw(haut,ortho); dot("$C_2$",C2,SW,ortho); dot("$H$",orth,SW,ortho); // ---------------------------------------------------------------------- draw(line(orth,Cc),dashdotted); label(Label("droite d'Euler",Rotate(dir(orth--Cc)),align=RightSide), relpoint(line(orth,Cc),1.7)); // ---------------------------------------------------------------------- addMargins(.5cm,.5cm);

graph fournit les routines suivantes :

void xaxis(picture pic=currentpicture, Label L="", axis axis=YZero,
           real xmin=-infinity, real xmax=infinity, pen p=currentpen,
           ticks ticks=NoTicks, arrowbar arrow=None, bool above=false);

Dessine l'axe des abscisses. Certains paramètres méritent de s'y attarder :

• axis : détermine la position de l'axe. Les différents types sont :

  • YZero(bool extend=true) : l'axe a pour équation y = 0 (ou y =.1 pour une échelle logarithmique).
    extend=true (valeur par défaut) pour que l'axe soit aux dimensions complètes de la figure.
  • YEquals(real Y, bool extend=true) : l'axe a pour équation y = Y. (Voir plutôt yequals.)
  • Bottom(bool extend=false) : l'axe est au bas de la figure.
  • Top(bool extend=false) : l'axe est en haut.
  • BottomTop(bool extend=false) : axes en bas et en haut.
• xmin et xmax : automatiquement déterminés par les dimensions de la figure si non spécifiés.

• ticks : les traits de graduation. Les valeurs sont NoTicks (par défaut, aucune graduation), LeftTicks (graduations uniquement à gauche de l'axe), RightTicks (graduations uniquement à droite de l'axe) et Ticks (graduations des deux cotés de l'axe). Ces trois dernières routines prennent elles-mêmes de nombreux arguments en option :

   

  Sélectionnez

  ticks Ticks(Label format="", ticklabel ticklabel=null,
              bool beginlabel=true, bool endlabel=true,
              int N=0, int n=0, real Step=0, real step=0,
              bool begin=true, bool end=true, tickmodifier modify=None,
              real Size=0, real size=0, bool extend=false,
              pen pTick=nullpen, pen ptick=nullpen);

• format : format des nombres sur les axes (par défaut "$%.4g$"). Pour n'avoir que les traits, sans les labels, la valeur est "%".

• ticklabel : fonction string(real x) qui retourne le label (par défaut format(format.s,x)) de chaque graduation principale d'abscisse x. Voir par exemple labelfrac page 41 et le code 73.
  Le ticklabel OmitFormat(string s=defaultformat ... real[] x) permet d'enlever certains labels, mais pas la graduation correspondante.
  NoZeroFormat est une abréviation pour OmitFormat(0).

• beginlabel et endlabel : inclut le premier et le dernier label.

• N : Quand la mise à l'échelle est activée (par défaut), l'axe est divisé en N intervalles séparés par les graduations principales.

• n : Chaque intervalle principal est divisé en n intervalles secondaires séparés par les graduations secondaires.

• Step : la valeur entre chaque trait de graduation principale (si N=0).

• step : la valeur entre chaque trait de graduation secondaire (si n=0).

• begin et end : inclut le premier et le dernier trait de graduation principale.

• tickmodifier modify : fonction permettant de modifier des graduations « manuellement ».
  Certains tickmodifier sont prédéfinis :
  OmitTick(... real[] x), OmitTickInterval(real a, real b) et OmitTickIntervals(real[] a, real[] b) peuvent servir à enlever des graduations, ainsi que leurs labels.
  NoZero est une abréviation pour OmitTick(0).

• Size et size : taille des graduations principales et secondaires.

• extend : étend les graduations. Permet de tracer des grilles.

• pen pTick et ptick : stylos pour le tracé des traits de graduation.

Code 58 Sélectionnez import graph; unitsize(1cm); xaxis(L="$x$", axis=YZero, xmin=-3, xmax=3, p=bp+blue, ticks=LeftTicks(ticklabel=OmitFormat(1), endlabel=false,Step=1,step=.5, end=false,modify=OmitTick(-2), pTick=bp+red,ptick=bp+.8green), arrow=Arrow);	Code 59 Sélectionnez import graph; unitsize(1cm); real[] tabT={-2,0,1}, tabt={-1.5,-.5,.5}; xaxis(L="$x$", axis=YZero(extend=true), xmin=-3, xmax=3, p=bp+blue, ticks=Ticks(Ticks=tabT, ticks=tabt, pTick=bp+red,ptick=bp+.8green), arrow=Arrow, above=false);

Il est aussi possible de spécifier l'emplacement des graduations à l'aide d'un tableau de réels à l'aide de la routine (voir le code 59, valable aussi pour LeftTicks et RightTicks) :

ticks Ticks(Label format="", ticklabel ticklabel=null,
            bool beginlabel=true, bool endlabel=true,
            real[] Ticks, real[] ticks=new real[],
            real Size=0, real size=0, bool extend=false,
            pen pTick=nullpen, pen ptick=nullpen)

De la même façon que xaxis est défini :

void yaxis(picture pic=currentpicture, Label L="", axis axis=XZero,
           real ymin=-infinity, real ymax=infinity, pen p=currentpen,
           ticks ticks=NoTicks, arrowbar arrow=None, bool above=false,
           bool autorotate=true);

Les paramètres sont similaires à ceux de xaxis. On notera pour le type axis les valeurs Left, Right et LeftRight.

Il est possible de fixer les valeurs xmin, xmax, ymin et ymax par la routine :

xlimits(picture pic=currentpicture, real min=-infinity,
        real max=infinity, bool crop=NoCrop);

et la routine ylimits.

Le booléen crop=Crop sert à couper les parties de la figure qui dépassent les limites.

Code 60 Sélectionnez import graph; unitsize(1cm); xaxis(L="$x$", axis=YZero, xmin=-3, xmax=3, p=bp+blue, ticks=Ticks(endlabel=false, beginlabel=false, Step=1,step=.5, end=false,pTick=bp+red, ptick=bp+.8green), arrow=Arrow); yaxis(L="$y$", axis=LeftRight, ymin=-1, ymax=3, p=bp+purple, ticks=Ticks(beginlabel=false, Step=1,step=.25, pTick=bp+red, ptick=bp+.8green), arrow=Arrow);	Code 61 Sélectionnez import graph; unitsize(1cm); xlimits(-3, 3); ylimits(-1, 3); xaxis(L="$x$",axis=BottomTop,p=bp+blue, ticks=Ticks(Step=1,step=.5,extend=true, pTick=bp+red, ptick=bp+dotted+.8green), arrow=Arrow); yaxis(L="$y$",axis=LeftRight,p=bp+purple, ticks=Ticks(Step=1,step=.5,extend=true, pTick=bp+red, ptick=bp+dotted+.8green), arrow=Arrow);

Pour des axes déportés, on peut utiliser les routines suivantes :

void xequals(picture pic=currentpicture, Label L="", real x,
             bool extend=false, real ymin=-infinity, real ymax=infinity,
             pen p=currentpen, ticks ticks=NoTicks, bool above=true,
             arrowbar arrow=None);

void yequals(picture pic=currentpicture, Label L="", real y,
             bool extend=false, real xmin=-infinity, real xmax=infinity,
             pen p=currentpen, ticks ticks=NoTicks, bool above=true,
             arrowbar arrow=None);


void axes(picture pic=currentpicture, Label xlabel="", Label ylabel="",
          pair min=(-infinity,-infinity), pair max=(infinity,infinity),
          pen p=currentpen, arrowbar arrow=None, bool above=false);

Voir le code 65. Dans cet exemple, les axes sont tracés dans une image séparée, qui est ajoutée à currentpicture à la fin.

Code 62 Sélectionnez import graph; unitsize(1cm); xlimits(17,23); ylimits(52,55); xequals(pic=currentpicture,L="$y$",x=17, ticks=Ticks(Step=1,step=.5,end=false), arrow=Arrow(HookHead)); yequals(pic=currentpicture,L="$x$",y=52, ticks=Ticks(Step=1,step=.5,end=false), arrow=Arrow(HookHead));	Code 63 Sélectionnez import graph; unitsize(x=1cm, y=.5cm); xlimits(-1, 5); ylimits(-2, 2); xaxis(BottomTop, Ticks("%",extend=true, pTick=linewidth(.5pt),ptick=dotted)); yaxis(LeftRight, Ticks("%",extend=true, pTick=linewidth(.5pt), ptick=dotted)); xequals(Label("$y$",align=2NW), 0, p=linewidth(bp), Arrow(2mm)); yequals(Label("$x$",align=2SE), 0, p=linewidth(bp), Arrow(2mm)); labelx(Label("$1$",UnFill), 1); labely(Label("$1$",UnFill), 1); dot("$O$",(0,0),2SW);
Code 64 Sélectionnez import graph; unitsize(1cm); xlimits(-1,6); ylimits(-1,3); xaxis(L="$x$", p=bp+blue, ticks=Ticks(NoZero,endlabel=false, beginlabel=false,Step=1,step=.5, begin=false,end=false), arrow=Arrow(TeXHead)); yaxis(L="$y$", p=bp+blue, ticks=Ticks(NoZero,beginlabel=false, Step=1,step=.5, begin=false,end=false), arrow=Arrow(TeXHead)); labelx("$O$",0,2*SW,blue); xequals(pic=currentpicture,L="$Y$",x=3, p=brown+dashed,ticks=NoTicks, arrow=Arrow(HookHead)); yequals(pic=currentpicture,L="$X$",y=1, p=brown+dashed,ticks=NoTicks, arrow=Arrow(HookHead)); labelx("$A$",(3,1),2*SW,brown); xtick("$1$",(4,1),size=1mm,brown); xtick(dir=S,(4,1),size=1mm,brown); ytick("$1$",(3,2),size=1mm,brown); ytick(dir=W,(3,2),size=1mm,brown);	Code 65 Sélectionnez import graph; unitsize(1cm); xlimits(-1,6); ylimits(-1,3); xaxis(L="$x$", p=bp+purple, ticks=Ticks(NoZero,endlabel=false, beginlabel=false,Step=1,step=.5, begin=false,end=false), arrow=Arrow(TeXHead)); yaxis(L="$y$", p=bp+purple, ticks=Ticks(NoZero,beginlabel=false, Step=1,step=.5, begin=false,end=false), arrow=Arrow(TeXHead)); labelx("$O$",0,2*SW,purple); picture pic; unitsize(pic,1cm); axes(pic, xlabel="$X$", ylabel="$Y$", min=(-4,-2), max=(3,2),p=dashed+red, arrow=Arrow(HookHead)); labelx(pic,"$A$",(0,0),2*SW,red); xtick(pic,"$1$",1,size=1mm,red); xtick(pic,dir=S,1,size=1mm,red); ytick(pic,"$1$",1,size=1mm,red); ytick(pic,dir=W,1,size=1mm,red); add(pic.fit(),(3,1));

Les routines suivantes permettent de placer manuellement des graduations :

void xtick(picture pic=currentpicture, Label L="", explicit pair z,
           pair dir=N, string format="",
           real size=Ticksize, pen p=currentpen);
           void xtick(picture pic=currentpicture, Label L="", real x,
           pair dir=N, string format="",
           real size=Ticksize, pen p=currentpen);

De la même façon que xtick est défini ytick.

void tick(picture pic=currentpicture, pair z,
          pair dir, real size=Ticksize, pen p=currentpen);
          void labelx(picture pic=currentpicture, Label L="", explicit pair z,
          align align=S, string format="", pen p=nullpen);
          void labelx(picture pic=currentpicture, Label L="", real x,
          align align=S, string format="", pen p=nullpen);
          void labelx(picture pic=currentpicture, Label L,
          string format="", explicit pen p=currentpen);

De la même façon que labelx est défini labely.

Plusieurs routines permettent de définir un graphe. Seules les plus utiles pour débuter seront vues (voir la documentation officielle pour les autres).

guide graph(picture pic=currentpicture, real f(real), real a, real b,
            int n=ngraph, real T(real)=identity,
            interpolate join=operator --);

Retourne le graphe de la fonction f sur l'intervalle kitxmlcodeinlinelatexdvp\left[T(a) ;T(b)\right]finkitxmlcodeinlinelatexdvp , basé sur n points (100 par défaut) régulièrement espacés dans kitxmlcodeinlinelatexdvp\left[a ;b\right]finkitxmlcodeinlinelatexdvp .

Code 66 Sélectionnez import graph; unitsize(1cm); xaxis("$x$", Ticks(scale(.7)*Label(), NoZero),Arrow(2mm)); yaxis("$y$", Ticks(scale(.7)*Label(), NoZero, beginlabel=false, endlabel=false, begin=false, end=false), Arrow(2mm)); labelx(scale(.7)*"$O$",0,SW); real f(real x) {return 4*x/(x^2+1);} draw(graph(f,-5.5,5.5),bp+purple); label("$y=\frac{4x}{x^2+1}$",(4,f(4)),1.5N,purple); label("anguin\'ea",(-3.5,1.5),purple); label(scale(.8)*"(ou cubique serpentine)",(-3.5,1),purple);

guide graph(picture pic=currentpicture, real x(real), real y(real),
            real a, real b, int n=ngraph, real T(real)=identity,
            interpolate join=operator --);

Retourne la courbe paramétrée kitxmlcodeinlinelatexdvp\left(x(t);y(t)\right)\quad\forall t \in \left[T(a);T(b)\right]finkitxmlcodeinlinelatexdvp .

Code 67 Sélectionnez import graph; unitsize(1cm); usepackage("inputenc","utf8"); usepackage("icomma"); xaxis("$x$", Ticks(scale(.7)*Label(), NoZero),Arrow(2mm)); yaxis("$y$", Ticks(scale(.7)*Label(), NoZero, beginlabel=false, endlabel=false, begin=false, end=false), Arrow(2mm)); labelx(scale(.7)*"$O$",0,SW); real x(real t) {return 2*cos(t)+1.5*cos(2*t);} real y(real t) {return 2*sin(t)-1.5*sin(2*t);} pen pg=royalblue; draw(graph(x,y,0,2*pi),bp+pg); label(scale(.6)*"$x(t)=2\cos(t)+1,5\cos(2t)$",(1.8,-2),1.5N,pg); label(scale(.6)*"$y(t)=2\sin(t)-1,5\sin(2t)$",(1.8,-2),pg);

guide polargraph(picture pic=currentpicture, real f(real), real a,
                 real b, int n=ngraph, interpolate join=operator --);

Retourne le graphe de la fonction kitxmlcodeinlinelatexdvpffinkitxmlcodeinlinelatexdvp en coordonnées polaires sur l'intervalle kitxmlcodeinlinelatexdvp[a;b].finkitxmlcodeinlinelatexdvp

Code 68 Sélectionnez import graph; size(6cm); usepackage("inputenc","utf8"); xaxis(Ticks("%", NoZero, Step=1, step=.5), Arrow(2mm)); yaxis(Ticks("%", NoZero, Step=1, step=.5), Arrow(2mm)); labelx(scale(.7)*"$O$",0,SW); real r(real t) {return 1+2*sin(t/2);} pen pg=deepmagenta; draw(polargraph(r,0,4*pi,n=400),bp+pg); label(scale(.8)*"$r=1+2\sin\left(\theta/2\right)$",(-1.5,-1),pg); label("néphroïde de Freeth",(-.5,1.3),pg);

Remarque : Fonctions non définies en certaines valeurs

Deux possibilités ici :

1. « enlever » les valeurs interdites : pour l'exemple, considérons la fonction

   kitxmlcodelatexdvpf : x \longmapsto \dfrac{-1}{x^2-4x+3}.finkitxmlcodelatexdvp

   
   Cette fonction est définie sur

   kitxmlcodelatexdvp\mathbb{R}\setminus\{1;3\}.finkitxmlcodelatexdvp

   La courbe sera découpée en trois graphes,

   kitxmlcodelatexdvp\mathcal{C_1},\ \mathcal{C_2}\ \mathrm{et}\ \mathcal{C_3}finkitxmlcodelatexdvp

   qui éviteront soigneusement les valeurs 1 et 3.

   

    

   Sélectionnez

   import graph;
   import contour;
   usepackage("mathrsfs");
   unitsize(x=1cm,y=1cm);
   
   transform ec=scale(.8);
   xaxis(ec*"$x$", Ticks(ec*Label(), NoZero), Arrow(2mm));
   yaxis(ec*"$y$", Ticks(ec*Label(), NoZero), Arrow(2mm));
   labelx(ec*"$O$",0,SW);
   
   real f(real x) {return -1/(x^2-4*x+3);}
   path c1=graph(f,-2.8,.9); // on évite les valeurs
   path c2=graph(f,1.1,2.9); // interdites
   path c3=graph(f,3.1,6.8); //
   draw(c1^^c2^^c3,bp+heavyred);
   ylimits(-2.9,2.9,Crop); // on coupe ce qui dépasse
   label("$\mathscr{C}_f$",(3,1.5),heavyred);

2. utiliser le module contour et tracer la courbe comme une ligne de niveau.
   On utilise la routine suivante :

    

   Sélectionnez

   guide[][] contour(real f(real, real), pair a, pair b,
                     real[] c, int nx=ngraph, int ny=nx,
                     interpolate join=operator--, int subsample=1)

3. Pour notre exemple, la courbe kitxmlcodeinlinelatexdvp\mathcal{C_f}finkitxmlcodeinlinelatexdvp a pour équation kitxmlcodeinlinelatexdvpy=\dfrac{-1}{x^2-4x+3}.finkitxmlcodeinlinelatexdvp
   D'où l'on tire : kitxmlcodeinlinelatexdvpy\times (x^2-4x+3)=-1.finkitxmlcodeinlinelatexdvp
   On considérera donc la fonction kitxmlcodeinlinelatexdvpF(x , y)= y(x^2-4x+3)finkitxmlcodeinlinelatexdvp et on tracera la ligne de niveau -1.

• f : fonction de deux variables réelles.
• a et b : les sommets de la diagonale du domaine rectangulaire.
• c : tableau contenant les valeurs des lignes de niveau.
• nx et ny : nombre de subdivisions dans les directions x et y (détermine la précision).
• join : l'opérateur d'interpolation (-- ou ..).
• subsample : nombre de points intérieurs à inclure dans chaque carré de la grille (en plus des points sur le bord).

Code 70 Sélectionnez import graph; import contour; usepackage("mathrsfs"); unitsize(x=1cm,y=1cm); transform ec=scale(.8); xaxis(ec*"$x$", Ticks(ec*Label(), NoZero), Arrow(2mm)); yaxis(ec*"$y$", Ticks(ec*Label(), NoZero), Arrow(2mm)); labelx(ec*"$O$",0,SW); real F(real x, real y) {return y*(x^2-4*x+3);} draw(contour(F,(-2.8,-2.9),(6.8,2.9),new real[] {-1}),bp+deepcyan); label("$\mathscr{C}_f$",(3,1.5),deepcyan);

Voir aussi le code 71

Cette extension de Philippe Ivaldi apporte bon nombre d'outils intéressants.

Elle peut être téléchargée à cette adresse : git.piprime.fr/?p=asymptote/pi-packages.git;a=tree, lien snapshot, et placée dans le dossier $HOME/.asy.

Pour une utilisation avec git, voir : forum.mathematex.net/asymptote-f34/version-2-10-et-graph-pi-t13226.html#p127606.

Les modules graph, markers et base_pi (voir à l'adresse ci-dessus) sont chargés par graph_pi, ainsi que le package kitxmlcodeinlinelatexdvp\LaTeXfinkitxmlcodeinlinelatexdvp mathrsfs.

Axes et repères :

void graphicrules(picture pic=currentpicture, real unit=1cm,
                  real xunit=unit != 0 ? unit : 0,
                  real yunit=unit != 0 ? unit : 0,
                  real xmin=-infinity, real xmax=infinity,
                  real ymin=-infinity, real ymax=infinity,
                  bool crop=NoCrop, bool xcrop=crop, bool ycrop=crop)

Passe les dimensions du graphique à cartesianaxis, grid, et millimeterpaper (voir ci-après).

void cartesianaxis(picture pic=currentpicture,
                   Label Lx=Label("$x$",align=2S),
                   Label Ly=Label("$y$",align=2W),
                   real xmin=-infinity, real xmax=infinity,
                   real ymin=-infinity, real ymax=infinity,
                   real extrawidth=1, real extraheight=extrawidth,
                   pen p=currentpen,
                   ticks xticks=Ticks("%",pTick=nullpen, ptick=grey),
                   ticks yticks=Ticks("%",pTick=nullpen, ptick=grey),
                   bool viewxaxis=true,
                   bool viewyaxis=true,
                   bool above=true,
                   arrowbar arrow=Arrow)

Trace l'axe des abscisses, des ordonnées ou les deux (viewxaxis et viewyaxis qui prennent les valeurs true ou false). extrawidth est la longueur rajoutée à l'axe des abscisses par rapport à xmin et xmax. On a la même chose avec extraheight pour l'axe des ordonnées.

Code 71 Sélectionnez import graph_pi; import contour; graphicrules(xunit=.5cm, yunit=2cm, xmin=-14.8, xmax=14.8, ymin=-1.9, ymax=1.9); cartesianaxis(extrawidth=0,xticks=Ticks(NoZero), yticks=Ticks(NoZero), Arrow(2mm)); labelx("$O$",0,SW); real F(real x, real y) {return x*y-cos(x);} draw(contour(F,(-14.8,-1.9),(14.8,1.9),new real[] {0}),bp+darkgreen); label("$y=\displaystyle\frac{\cos x}{x}$",(3,1),darkgreen);

void labeloij(picture pic=currentpicture,
              Label Lo=Label("$O$",NoFill),
              Label Li=Label("$\overrightarrow{\imath}$",NoFill),
              Label Lj=Label("$\overrightarrow{\jmath}$",NoFill),
              pen p=scale(2)*currentpen,
              pair diro=SW, pair diri=labelijmargin*S, pair dirj=labelijmargin*1.5*W,
              filltype filltype=NoFill, arrowbar arrow=Arrow(2mm),
              marker marker=dot)

Trace le repère kitxmlcodeinlinelatexdvp(O; \vec{\imath}; \vec{\jmath}).finkitxmlcodeinlinelatexdvp

void labeloIJ(picture pic=currentpicture,
              Label Lo=Label("$O$",NoFill),
              Label LI=Label("$I$",NoFill),
              Label LJ=Label("$J$",NoFill),
              pair diro=SW, pair dirI=labelIJmargin*S, pair dirJ=labelIJmargin*W,
              pen p=currentpen,
              filltype filltype=NoFill,
              marker marker=dot)

Trace le repère kitxmlcodeinlinelatexdvp(O;I;J).finkitxmlcodeinlinelatexdvp

void grid(picture pic=currentpicture,
          real xmin=pic.userMin.x, real xmax=pic.userMax.x,
          real ymin=pic.userMin.y, real ymax=pic.userMax.y,
          real xStep=1, real xstep=.5,
          real yStep=1, real ystep=.5,
          pen pTick=currentpen, pen ptick=grey, bool above=false)

Trace une grille.

Code 72 Sélectionnez import graph_pi; graphicrules(xunit=1cm, yunit=2cm, xmin=-5, xmax=5, ymin=0, ymax=1.5); grid(pTick=currentpen,ptick=dotted); cartesianaxis(xticks=Ticks("%"), yticks=Ticks(NoZero,Step=1,step=.5), Arrow(2mm)); labeloij(); real f(real x) {return 1/(1+x^2);} draw(graph(f), bp+fuchsia); label("$y=\displaystyle\frac{1}{1+x^2}$",(1,f(1)),NE,fuchsia); label("Cubique d'Agnesi",(-3,1.2),fuchsia);

picture millimeterpaper(picture pic=currentpicture, pair O=(0,0),
                        real xmin=infinity, real xmax=infinity,
                        real ymin=infinity, real ymax=infinity,
                        pen p=.5bp+orange)

Grille sous forme de papier millimétré.

ticklabel labelfrac(real ep=1/10^5, real factor=1,
                    string symbol="",
                    bool signin=false, bool symbolin=true,
                    bool displaystyle=false,
                    bool zero=true)

Ce ticklabel permet d'écrire les graduations sous forme de fractions. Attention, base_pi doit être dans le dossier $HOME/.asy.

Sélectionnez import graph_pi; marker croix=marker(scale(4)*rotate(45)*cross(4),linewidth(bp)); pen bpd=bp+brown+linetype("4 4"); graphicrules(xunit=1cm, yunit=3cm, xmin=-6.5, xmax=6.5, ymin=-1.17, ymax=1.17); add(millimeterpaper(p=1bp+orange),(0,0)); labeloij(Lj=Label("")); cartesianaxis(Lx=Label("$x$",align=2N),extrawidth=0, xticks=Ticks(Label(Fill(white)), labelfrac(factor=pi,symbol="\pi",symbolin=true, zero=false),Step=pi/2, step=pi/4), yticks=Ticks(Label(Fill(white)), labelfrac(zero=false),Step=.5)); // Définition des fonctions real f(real x) {return cos(x);} real g(real x) {return sin(x);} // Tracé de courbe draw(graph(f),bp+blue); draw(graph(g),bpd); // Points sur les courbes real l=-2pi; for(int i=0; i<17; ++i) { draw((l,f(l)),croix); draw((l,g(l)),croix); l=l+pi/4; } label("$\mathscr{C}_f : y=\cos(x)$",(2.5,f(2.5)),W,blue); label("$\mathscr{C}_g : y=\sin(x)$",(2.5,g(2.5)),NE,brown);

Représentations graphiques de suites :

recursiveroutime recursiveoption(Label L="u",
                                 bool labelbegin=true,
                                 bool labelend=true,
                                 bool labelinner=true,
                                 bool labelalternate=false,
                                 string format="",
                                 int labelplace=onX,
                                 pen px=nullpen,
                                 pen py=nullpen,
                                 bool startonyaxis=false,
                                 arrowbar circuitarrow=None,
                                 marker automarker=marker(cross(4)),
                                 marker xaxismarker=nomarker,
                                 marker yaxismarker=nomarker,
                                 marker xmarker=nomarker,
                                 marker fmarker=nomarker)

Les options du graphique :

• L : le nom de la suite (à taper sans $).
• labelbegin : si la valeur est true, le premier terme est placé.
• labelend : même chose pour le dernier terme.
• abelinner : si la valeur est true, les termes compris entre le premier et le dernier sont placés.
• labelalternate : si la valeur est true, les termes sont alternés par rapport à l'axe.
• format : le format d'affichage de la valeur. Par exemple "%.2f" (2 chiffres après la virgule).
• labelplace : emplacement des termes : onX, onY, ou onXY.
• px et py : stylos pour les tracés des traits de lecture.
• startonyaxis : comme son nom l'indique...
• circuitarrow : flèches sur le « circuit ».
• Pour tous les marker, voir le code 75.

recursivegraph recursivegraph(real F(real), real u0, int n0=0, int n)

« Graphe » de la suite : kitxmlcodeinlinelatexdvpu0finkitxmlcodeinlinelatexdvp est le premier terme, kitxmlcodeinlinelatexdvpn0finkitxmlcodeinlinelatexdvp est l'indice du premier terme et kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp pour spécifier le nombre de termes placés sur le graphique (le dernier terme placé est celui d'indice kitxmlcodeinlinelatexdvpn-1finkitxmlcodeinlinelatexdvp ).

void draw(picture pic=currentpicture, Label L="", recursivegraph g,
          recursiveroutime lr=DefaultRecursiveOption, align align=NoAlign,
          pen p=currentpen, arrowbar arrow=None, arrowbar bar=None,
          margin margin=NoMargin, Label legend="", marker marker=nomarker)

Code 74 Sélectionnez import graph_pi; usepackage("amsmath"); graphicrules(xunit=1cm, yunit=1cm, xmin=-.4, xmax=8.9, ymin=-.4, ymax=7.9); cartesianaxis(extrawidth=0,xticks=Ticks("%"),yticks=Ticks("%")); label("$0$",(0,0),2*SW);labely("$1$",1,1.5W); real f(real x){return 2*sqrt(x)+1;} draw(graph(f,0,8.9,n=400),bp+purple); draw(graph(new real(real x){return x;},0,7.9),bp+red); draw(recursivegraph(f,u0=1,n0=1,n=6), recursiveoption(L="v", labelplace=onXY), bp+heavymagenta); label("$y=2\sqrt{x}+1$",(7.5,f(7.5)),3S,purple); label("$y=x$",(7,7),2W,red); label("$\left\{\begin{aligned}&v_1=1\\&v_{n+1}=2\sqrt{v_n}+1 \end{aligned}\right.$",(2.5,7));

Code 75 Sélectionnez import graph_pi; usepackage("amsmath");usepackage("icomma"); graphicrules(xunit=2cm, yunit=2cm, xmin=-.4, xmax=4.4, ymin=-.4, ymax=3.4); cartesianaxis(extrawidth=0,xticks=Ticks(NoZero),yticks=Ticks(NoZero)); label("$0$",(0,0),2*SW); real f(real x){return x/2+1/x;} draw(graph(f,.1,4.4),bp+deepblue); draw(graph(new real(real x){return x;}),bp+red); ylimits(-.4,3.4,Crop); draw(recursivegraph(f,3.5,n=4), recursiveoption(L=scale(.7)*"u", labelbegin=true, labelend=true, labelinner=true, labelalternate=true, format="\approx %.1f", labelplace=onX, px=dashed, py=nullpen, startonyaxis=false, circuitarrow=MidArrow(3mm), automarker=marker(scale(5)*cross(4),blue), xaxismarker=dot(orange), yaxismarker=nomarker, xmarker=dot(green), fmarker=dot(magenta)),bp+heavycyan); label("$y=\frac{x}{2}+\frac{1}{x}$",(.5,f(.5)),E,deepblue); label("$y=x$",(3,3),SE,red); label(scale(.9)*"$\left\{\begin{aligned}&u_0=3,5\\ &u_{n+1}=\frac{u_n}{2}+\frac{1}{u_n} \end{aligned}\right.$",(.75,3),E);

void graphpoint(picture pic=currentpicture,
                Label L="",
                real f(real), real xCoordinate,
                real xmin=0, real ymin=0,
                int draw=onXY,
                pen px=nullpen, pen py=px,
                arrowbar arrow=None, arrowbar bar=None,
                margin marginy=NoMargin, margin marginx=NoMargin,
                bool extend=false, bool extendx=extend, bool extendy=extend,
                Label legendx="", Label legendy="",
                marker markerx=nomarker, marker markery=nomarker)

path tangent(path g, real x, pathb=box(userMin(currentpicture),userMax(currentpicture)))

void addtangent(picture pic=currentpicture,
                path g,//Point on the path g
                pair pt,// real x (x-Coordinate) est aussi défini
                real size=infinity,//ABSOLUTE size of the tangent line
                bool drawright=true,//Draw the tangent at the right
                bool drawleft=true,//... left
                pair v=(infinity,infinity),//A finite value forces the value of the derivative
                pair vr=v,//A finite value forces the value of the derivative at right
                pair vl=v,//A finite value forces the value of the derivative at left
                arrowbar arrow=null,//null=automatic determination
                margin margin=NoMargin,//Useful with size=infinity
                Label legend="",
                pen p=currentpen,
                real dt=2,
                bool differentiable=true)

Code 76 Sélectionnez import graph_pi; graphicrules(xunit=1cm, yunit=1cm, xmin=-4, xmax=3, ymin=-.5, ymax=5); cartesianaxis(xticks=RightTicks(NoZero), yticks=LeftTicks(NoZero,Step=1)); grid(pTick=paleblue,ptick=paleblue); labeloij(); real f(real x){return exp(x);} path Cf=graph(f,n=200); draw(Cf, bp+darkbrown); addtangent(Cf,x=0,size=1cm,heavymagenta); addtangent(Cf,x=1,size=1cm,heavymagenta); graphpoint(f,1,px=dashed+blue); dot((1,f(1))); dot((0,f(0))); labely("e",f(1),blue); ylimits(-1,5.5,Crop); label("$\mathscr{C}_\mathrm{exp}$",(1.5,f(1.5)),E,darkbrown);

Les principales routines utilisées ici sont :

void erase(picture pic=currentpicture);

qui efface l'image,

void save()

qui sauvegarde l'image à l'endroit où elle est utilisée,

void restore()

qui restaure (c'est facile l'anglais !) l'image au point où elle a été sauvegardée par save(), et enfin

void add(picture pic=currentpicture, enclosure enclosure=NoBox)

qui ajoute l'image à l'animation.

Un exemple : construction de la médiatrice d'un segment. (Pour voir l'animation, il faut utiliser Acrobat Reader.)

Code 77 Sélectionnez import geometry; import animate; settings.tex="pdflatex"; settings.outformat="pdf"; size(15cm,0); point A=(0,0), B=(3,-2), lab=(6,1); circle cA=circle(A,2.5), cB=circle(B,2.5); point[] int=intersectionpoints(cA,cB); segment seg=segment(A,B); line med=line(int[0],int[1]); animation Anim; // -------------------------------------------- // Étape 0 draw(seg,bp+heavygreen); dot("$A$",A,unit(A-B)); dot("$B$",B,unit(B-A)); Anim.add(); // Étape 1 draw(cA,bp+blue); draw(cB,bp+blue); Anim.add(); // Étape 2 save(); // tout ce qu'il y a avant sera conservé dans la suite label("\begin{minipage}{4cm} On trace deux cercles\\ de m\^eme rayon.\end{minipage}",lab,E); draw(lab..controls (4,2) and (3,2)..angpoint(cA,45),Arrow()); draw(lab..controls (5.5,1) and (4.5,1)..angpoint(cB,60),Arrow()); Anim.add(); restore(); // Etape 3 save(); label("\begin{minipage}{4cm} Deux points\\ \'equidistants\\ de $A$ et $B$.\end{minipage}",lab,E); draw(lab..controls (3,.5) and (2,-.5)..int[0],Arrow()); draw(lab..controls (5,1) and (4.5,1)..int[1],Arrow()); dot(int[0],heavyred); dot(int[1],heavyred); Anim.add(); restore(); // Étape 4 save(); draw(med,bp+heavyred); label("\begin{minipage}{4cm} M\'ediatrice de $\left[AB\right]$\end{minipage}",lab,E,heavyred); draw(lab..controls (5,1.5) and (4,1.6)..relpoint(med,1.4),Arrow()); dot(int[0],heavyred); dot(int[1],heavyred); Anim.add(); restore(); // -------------------------------------------- erase(); // permet d'éviter les effets de "décalage" label(Anim.pdf("controls,step"));