size(7cm,0);

pair C1=(-3,0),C2=(3,0);
real r=4;
path EnsA=circle(C1,r);
path EnsB=circle(C2,r);
picture AinterB;

// Sur l'image courante, on colorie successivement les disques
// représentant les ensembles A et B.
fill(EnsA,lightblue);
fill(EnsB,lightgreen); // B vient au dessus de A.

// Sur une image nommée AinterB, on dessine l'ensemble A
// avec la "couleur somme" (mélange des couleurs de A et B)
fill(AinterB,EnsA,lightblue+lightgreen);
// puis on découpe cette image AinterB pour ne garder que la
// partie de l'ensemble A qui est incluse aussi dans l'ensemble B.
clip(AinterB,EnsB);
// On  vient ajouter (superposer) l'image AinterB à l'image courante.
add(AinterB);
// On trace les cercles délimitant les ensembles, on les étiquette
draw(EnsA); label("$A$",C1);
draw(EnsB); label("$B$",C2);
// et on ajoute la flèche indiquant l'intersection.
draw(Label("$A\cap B$",0),(0,-5)--(0,0),Arrow);

shipout(bbox(5mm,white));

size(7cm,0);

real r=4, R=r*1.5;
pair pC=(0,-r), pA=pC*dir(-120), pB=pC*dir(120);
path EnsA=circle(pA,R),
     EnsB=circle(pB,R),
     EnsC=circle(pC,R);
pen coulA=lightblue, coulB=lightgreen, coulC=lightred,
    coula=blue,      coulb=green,      coulc=red;

fill(EnsA,coulA+opacity(.8));
fill(EnsB,coulB+opacity(.6));
fill(EnsC,coulC+opacity(.4));
draw(EnsA^^EnsB^^EnsC,1bp+black);

draw("A",2.5pA,e=roundbox,xmargin=.4,p=coula,FillDraw(coulA+white));
draw("B",2.5pB,e=roundbox,xmargin=.4,p=coulb,FillDraw(coulB+white));
draw("C",2.5pC,e=roundbox,xmargin=.4,p=coulc,FillDraw(coulC+white));

shipout(bbox(5mm,white));

// Un exemple de Philippe Ivaldi
// à retrouver sur la page "Generalities" de son site.

size(7cm,0);

path a,b,c;
a = shift(1,0)*scale(2)*unitcircle;
b = rotate(120)*a;
c = rotate(120)*b;

fill(a, red);
fill(b, green);
fill(c, blue);
fill(buildcycle(a,b), red + green); // (comprendre buildcycle)
fill(buildcycle(b,c), green + blue);
fill(buildcycle(c,a), blue + red);
fill(buildcycle(a,b,c), white);

draw(a^^b^^c);

shipout(bbox(5mm,white));

// Comme la fonction buildcycle a un fonctionnement assez particulier (qui dépend 
// de la définition des paths utilisés), on peut préférer procéder par "clipping".
size(7cm,0);

real r=4, R=r*1.25;
pair pC=(0,-r), pA=pC*dir(-120), pB=pC*dir(120);
path EnsA=circle(pA,R), EnsB=circle(pB,R), EnsC=circle(pC,R);
pen coulA=red, coulB=green, coulC=blue;

fill(EnsA,coulA); // On dessine EnsA,
fill(EnsB,coulB); // recouvert en partie par EnsB,
fill(EnsC,coulC); // qui lui-même est recouvert en partie par EnsC.
// Dans une image AiB, on dessine EnsA 
// puis on enlève la partie qui n'est pas dans EnsB.
picture AiB; fill(AiB,EnsA,coulA+coulB); clip(AiB,EnsB);
// Dans une image AiC, on dessine EnsA 
// puis on enlève la partie qui n'est pas dans EnsC.
picture AiC; fill(AiC,EnsA,coulA+coulC); clip(AiC,EnsC);
// Dans une image AiB, on dessine EnsB 
// puis on enlève la partie qui n'est pas dans EnsC.
picture BiC; fill(BiC,EnsB,coulB+coulC); clip(BiC,EnsC);
// Dans une image AiBiC, on dessine EnsA 
// puis on enlève les parties qui ne sont pas dans EnsB et EnsC.
picture AiBiC; fill(AiBiC,EnsA,coulA+coulB+coulC);
clip(AiBiC,EnsB); clip(AiBiC,EnsC);
// Dans l'image courante qui va être affichée, on vient 
// superposer (dans un ordre réfléchi) les images précédentes.
add(AiB); add(AiC); add(BiC); add(AiBiC);
// On ajoute les contours et les étiquettes.
draw(EnsA^^EnsB^^EnsC);
transform t=scale((R+r)/r);
draw("$A$",e=ellipse,xmargin=.1cm,t*pA,p=1bp+coulA,FillDraw(coulA+white));
draw("$B$",e=ellipse,xmargin=.1cm,t*pB,p=1bp+coulB,FillDraw(coulB+white));
draw("$C$",e=ellipse,xmargin=.1cm,t*pC,p=1bp+coulC,FillDraw(coulC+white));
shipout(bbox(2mm,white));

size(7cm,0);

real r=4, R=r*1.5;
pair pC=(0,-r), pA=pC*dir(-120), pB=pC*dir(120);
path EnsA=circle(pA,R),
     EnsB=circle(pB,R),
     EnsC=circle(pC,R);
pen coulA=lightblue, coulB=lightgreen, coulC=lightred,
    coula=blue,      coulb=green,      coulc=red;

fill(EnsA,coulA+opacity(.8));
fill(EnsB,coulB+opacity(.6));
fill(EnsC,coulC+opacity(.4));
draw(EnsA^^EnsB^^EnsC,1bp+black);

// On définit le chemin définissant l'intersection de EnsB et EnsC
// ... et on trace l'ensemble.
path BiC=buildcycle(EnsB,EnsC); // (comprendre buildcycle)
filldraw(BiC,palegray+opacity(.7),2bp+red);
// On conclut en plaçant les étiquettes.
draw("A",2.5pA,e=roundbox,xmargin=.4,p=coula,FillDraw(coulA+white));
draw("B",2.5pB,e=roundbox,xmargin=.4,p=coulb,FillDraw(coulB+white));
draw("C",2.5pC,e=roundbox,xmargin=.4,p=coulc,FillDraw(coulC+white));

shipout(bbox(5mm,white));

size(7cm,0);

// Définition de deux points de EnsA (qui seront utiles ensuite 
// pour placer les étiquettes des ensembles).
pair pA1=(2,0), pA2=(3,2);
// Définition d'une rotation et d'une translation utilisées
// pour construire les ensembles EnsB, EnsC et EnsD à partir de EnsA
transform r=rotate(50),t=shift(-2,-2);
// Définition du chemin définissant l'ensemble EnsA, passant par le point pA
path EnsA=(0,0)..pA1..(3,1)..pA2..cycle;
// Définition des autres ensembles comme images de EnsA par r, ror et t.
path EnsB=r*EnsA;
path EnsC=r^2*EnsA;
path EnsD=t*EnsA;
// et des points où placer les étiquettes.
pair pA=pA1, pB=r*pA2, pC=r^2*pA2, pD=t*pA1;
// On trace les ensembles, dans la même couleur.
// On pourra dans un prochain exemple faire des couleurs distinctes.
filldraw(EnsA^^EnsB^^EnsC^^EnsD,paleblue+white,1bp+blue);
// On définit le chemin définissant la réunion de EnsA et EnsD.
// ... et on trace l'ensemble.
path AuD=buildcycle(EnsA,EnsD);                     // (comprendre buildcycle)
filldraw(AuD,palegreen+opacity(.7),1bp+green);
// On conclut en plaçant les étiquettes.
// Plusieurs enveloppes possibles : box, roundbox, ellipse.
draw("$A$",e=roundbox,xmargin=.1cm,pA,p=1bp+red,FillDraw(palered));
draw("$B$",e=ellipse,xmargin=.1cm,pB,p=1bp+blue,FillDraw(paleblue));
draw("$C$",e=ellipse,xmargin=.1cm,pC,p=1bp+blue,FillDraw(paleblue));
draw("$D$",e=roundbox,xmargin=.1cm,pD,p=1bp+red,FillDraw(palered));
draw("$A\cup D$",(2,-2),e=box,xmargin=.1cm,
                        p=1bp+green,
                        FillDraw(palegreen+opacity(.7)));
shipout(bbox(5mm,white));

unitsize(1cm);

real marge=1mm;
pair z1=(0,0), z2=(4,0), z3=(4,-3), z4=(0,-3);
transform r=scale(.8);

object etat_1=draw("1",ellipse,z1,marge),
       etat_2=draw("2",ellipse,z2,marge),
       etat_3=draw("3",ellipse,z3,marge),
       etat_4=draw("4",ellipse,z4,marge);

add(new void(picture pic, transform t) {
   draw(pic,r*Label("3/5"),point(etat_1,N,t){N}..{E}point(etat_1,W,t),Arrow);
   draw(pic,r*Label("2/5"),point(etat_2,E,t){E}..{S}point(etat_2,N,t),Arrow);
   draw(pic,r*Label("1/5"),point(etat_3,S,t){S}..{W}point(etat_3,E,t),Arrow);
   draw(pic,r*Label("1"),point(etat_4,W,t){W}..{N}point(etat_4,S,t),Arrow);
   
   draw(pic,r*Label("3/10"),point(etat_1,E,t){NE}..point(etat_2,W,t),Arrow);
   draw(pic,r*Label("1/10"),point(etat_2,W,t){SW}..point(etat_1,E,t),Arrow);
   draw(pic,r*Label("1/2"),point(etat_2,S,t){S}..point(etat_3,N,t),Arrow);
   draw(pic,r*Label("1/20"),point(etat_3,W,t){W}..point(etat_4,E,t),Arrow);
   draw(pic,r*Label("1/10"),point(etat_1,S,t){S}..point(etat_4,N,t),Arrow);
   draw(pic,r*Label("3/4"),point(etat_3,NW,t){NW}..point(etat_1,SE,t),Arrow);
});