verbatimtex
%&latex
\documentclass{article}
\usepackage[upright]{fourier}
\usepackage{preambule}
\begin{document}
etex


%input latexmp;

%======================Fonctionsusuelles======================================
numeric Pi,E;
Pi:= 3.14159265359;
E:= 2.7182;

vardef sin(expr x) =
        sind(x/Pi*180)
enddef;

vardef cos(expr x) =
        cosd(x/Pi*180)
enddef;

vardef tan(expr x) =
        sin(x)/cos(x)
enddef;

vardef exp(expr x) =
        mexp(x*256)
enddef;

vardef ln(expr x) =
        mlog(x)/256
enddef;

% D�inition du rep�e ===================================================
def repere(expr Ox,Oy,Xmin,Xmax,Ymin,Ymax,Ux,Uy) = 
    % affectations des variables
    _ux := Ux ; _uy := Uy;_ox := Ox*_ux ; _oy := Oy*_uy  ; % _e := e;
    _xmin := Xmin ; _xmax := Xmax ; _ymin := Ymin ; _ymax := Ymax;
    _r_xmin := _xmin*_ux;%+_ox; %l'abscisse minimale 
    _r_xmax := _xmax*_ux;%+_ox; %l'abscisse maximale
    _r_ymin := _ymin*_uy;%+_oy; %l'ordonn� minimale
    _r_ymax := _ymax*_uy;%+_oy  %l'ordonn� maximale
enddef;

% Placer les axes du rep�e ==============================================

def r_axes =
     pickup pencircle scaled  1.1bp;
    drawarrow (_r_xmin,_oy)..(_r_xmax,_oy);
    drawarrow (_ox,_r_ymin)..(_ox,_r_ymax);
   % pickup pencircle scaled 0.5pt;
   % label.bot(btex $x$ etex, (_r_xmax-1mm,_oy));
   % label.lft(btex $y$ etex, (_ox,_r_ymax-1mm))
enddef;


% Placer les axes du rep�e avec noms diff�ents==============================================

def r_axenom(expr a,b) =
     pickup pencircle scaled  1.5bp;
    drawarrow (_r_xmin,_oy)..(_r_xmax,_oy);
    drawarrow (_ox,_r_ymin)..(_ox,_r_ymax);
    pickup pencircle scaled 0.5pt;
    label.bot(a, (_r_xmax-1.5mm,_oy));
    label.lft(b, (_ox,_r_ymax-1.5mm));
enddef;

% Placer l'origine =======================================================

def r_origine =
    label.lft(btex $O$ etex,(_ox,_oy-2mm));
    pickup pencircle scaled 3pt;
    draw (_ox,_oy);
    pickup pencircle scaled 0.5pt;
enddef;

%Graduation des unit� ===================================================
def r_unites =
    pickup pencircle scaled 1.4bp;
    draw (_ox+_ux,_oy-1mm)--(_ox+_ux,_oy+1mm);
    draw(_ox-1mm,_oy+_uy)--(_ox+1mm,_oy+_uy);
     label.bot(btex $\Mathbold{1}$ etex,(_ox+_ux,_oy-1mm));
    label.lft(btex $\Mathbold{1}$ etex, (_ox-1mm,_oy+_uy));
enddef;


%Graduation des axes =====================================================
def grad_x(expr n,m,couleur) =
   
    for i=1 upto (floor(-_xmin+1))/n: 
	draw (-i*n*_ux,_oy-.1cm)--(-i*n*_ux,_oy+.1cm) withcolor couleur;
    endfor

picture v[];
for i=1 upto (floor(-_xmin+1))/m:
  write "v["&decimal (i)&"]:=btex $" & decimal(-i*m) & "$ etex;"   to  "mptextmp.mp";
endfor
write EOF to "mptextmp.mp";
 scantokens "input mptextmp";
for i=1 upto (floor(-_xmin+1))/m:
   label.bot(v[i], (-i*m*_ux,_oy-1mm)) withcolor couleur;
endfor





%for i=1 upto (floor(-_xmin+1))/m:
%   label.bot(textext("$" & (decimal(-i*m)) & "$"), (-i*m*_ux,_oy-1mm)) withcolor couleur;
%endfor



    for i=1 upto (floor(_xmax-0.5))/n: 
	draw (i*n*_ux,_oy-.1cm)--(i*n*_ux,_oy+.1cm) withcolor  couleur;
    endfor
for i=1 upto (floor(_xmax-1))/m: 
	label.bot (str[i*m], (i*m*_ux,_oy-1mm)) withcolor couleur;
    endfor
enddef;

def grad_y(expr n,m,couleur) =
    numeric _m;
    _m:=m;
    for i=1 upto (floor(-_ymin+1))/n: 
	draw (_ox-.1cm,-i*n*_uy)--(_ox+.1cm,-i*n*_uy) withcolor couleur;
    endfor

for i=1 upto (floor(-_ymin+1))/m: 
	label.lft (str[i*m],(_ox-.1cm,i*n*_uy) ) withcolor couleur;
    endfor


    for i=1 upto (floor(_ymax-0.5))/n: 
	draw (_ox-.1cm,i*n*_uy)--(_ox+.1cm,i*n*_uy) withcolor couleur;
    endfor

for i=1 upto (floor(_ymax-1))/m: 
	label.lft (str[i*m], (_ox-.1cm,i*m*_uy)) withcolor couleur;
    endfor

picture u[];
for i=1 upto (floor(-_ymin+1))/m:
  write "u["&decimal (i)&"]:=btex $" & decimal(-i*m) & "$ etex;"   to  "mptextmp.mp";
endfor
write EOF to "mptextmp.mp";
 scantokens "input mptextmp";
for i=1 upto (floor(-_ymin+1))/m:
   label.lft(u[i],(_ox-.1cm,-i*n*_uy) ) withcolor couleur;
endfor


%for i=1 upto (floor(-_ymin+1))/m:
%   label.lft(textext("$" & (decimal(-i*m)) & "$"),(_ox-1mm,-i*n*_uy) ) withcolor couleur;
%endfor
enddef;

% Quadrillage==================%suppose que xmin est n�atif  et xmax positif=========
def quad_x(expr n,couleur) =
    numeric _a,_b,_c,_d,_m;
    _m:=m;
    _a = floor(_xmin)*_ux+_ox; _b = floor(_ymin)*_uy+_oy;
    _c = (floor(_xmax)+1)*_ux+_ox; _d = (floor(_ymax)+1)*_uy+_oy;
     pickup pencircle scaled  0.1pt;
    for i=1 upto (floor(-_xmin+1))/n: 
	draw (-i*n*_ux,_b)--(-i*n*_ux,_d) withcolor couleur;
    endfor
    for i=1 upto (floor(_xmax+1))/n: 
	draw (i*n*_ux,_b)--(i*n*_ux,_d) withcolor couleur;
    endfor
enddef;

def quadunite_x(expr couleur) =
    numeric _a,_b,_c,_d;
    _a = floor(_xmin)*_ux+_ox; _b = floor(_ymin)*_uy+_oy;
    _c = (floor(_xmax)+1)*_ux+_ox; _d = (floor(_ymax)+1)*_uy+_oy;
                 pickup pencircle scaled 0.4pt;
    for i=0 upto (floor(_xmax)+1-floor(_xmin)) -1:
	draw (_a+i*_ux,_b)--(_a+i*_ux,_d) withcolor couleur;
    endfor
enddef;

def quad_y(expr n,couleur) =
    numeric _a,_b,_c,_d;
    _a = floor(_xmin)*_ux+_ox; _b = floor(_ymin)*_uy+_oy;
    _c = (floor(_xmax)+1)*_ux+_ox; _d = (floor(_ymax)+1)*_uy+_oy;
     pickup pencircle scaled 0.1pt;
    for i=1 upto (floor(-_ymin+1))/n: 
	draw (_a,-i*n*_uy)--(_c,-i*n*_uy) withcolor couleur;
    endfor
    for i=1 upto (floor(_ymax+1))/n: 
    draw (_a,i*n*_uy)--(_c,i*n*_uy) withcolor couleur;
endfor

enddef;

def quadunite_y(expr couleur) =
    numeric _a,_b,_c,_d;
    _a = floor(_xmin)*_ux+_ox; _b = floor(_ymin)*_uy+_oy;
    _c = (floor(_xmax)+1)*_ux+_ox; _d = (floor(_ymax)+1)*_uy+_oy;
    pickup pencircle scaled 0.4pt;
    for i=0 upto (floor(_ymax)+1-floor(_ymin)) -1:
    draw (_a,_b+i*_uy)--(_c,_b+i*_uy) withcolor couleur;
           endfor
enddef;

def quad_xy(expr n,couleur) =
     quad_x(n,couleur);  quad_y(n,couleur);
enddef;

def quadu_xy(expr couleur) =
     quadunite_x(couleur);  quadunite_y(couleur);
   enddef;




def quad_logx(expr n,couleur) =
    numeric _a,_b,_c,_d,_m;
    _m:=m;
    _a = floor(_xmin)*_ux+_ox; _b = floor(_ymin)*_uy+_oy;
    _c = (floor(_xmax)+1)*_ux+_ox; _d = (floor(_ymax)+1)*_uy+_oy;
     pickup pencircle scaled  0.1pt;

     path p;
     p:=(0,_b)--(0,_d);
      for k:=0 step 1 until 10 :
    for j:=1 step 1 until 10 :
      draw p shifted ((k*ln(10)+ln(j))*cm,0);
    endfor;
    endfor;
     pickup pencircle scaled 0.7;
    
    for j:= step 1 until x.ne :
      draw p shifted (j*ln(10)*cm,0);
    endfor;    
enddef;


   

%D�inir un point dans ce plan ===========================================
def r_point(expr x,y) =
       (x*_ux,y*_uy)
enddef;
def r_p(expr x,y) =
 r_point(x,y)
enddef;

%Placer un point plein dans ce rep�e ====================================
def r_ppoint(expr x,y) =
        pickup pencircle scaled 3pt;
        draw (x*_ux,y*_uy);
pickup pencircle scaled 0.5pt 
enddef;

def r_pp(expr x,y) =
 r_ppoint(x,y)
enddef;



%Placer un point creux dans ce rep�e ====================================
def r_cpoint(expr x,y) =
        path _e;
_e = fullcircle scaled 3pt shifted(x*_ux,y*_uy);
draw _e;
fill _e withcolor white
enddef;

def r_cp(expr x,y) =
 r_cpoint(x,y)
enddef;
%Label des unit� ========================================================
def r_labelxy =

   pickup pencircle scaled 0.5pt;
    label.bot(btex $x$ etex, (_r_xmax-1mm,_oy));
    label.lft(btex $y$ etex, (_ox,_r_ymax-1mm));
             
enddef;

%Definir un segment ================================================
def r_segment(expr a,b,c,d) =
       (_ox+a*_ux,_oy+b*_uy)--(_ox+c*_ux,_oy+d*_uy)
enddef;

%ou

def r_seg(expr a,b,c,d) =
       r_p(a,b)--r_p(c,d)
enddef;

% Definir une droite // �l'axe des ordonn�s =============================
def rx_droite(expr k) =
   (k*_ux,_r_ymin)--(k*_ux,_r_ymax)
enddef;

% Definir une droite d�inie par un point et son coeff dir ================
def r_droitedir(expr a,b,m) =
    (_r_xmin,(m*_xmin+b-m*a)*_uy)--(_r_xmax,(m*_xmax+b-m*a)*_uy)
enddef;


def r_droite(expr a,b,m) =
      (_r_xmin,(m*_xmin+b-m*a)*_uy)--(_r_xmax,(m*_xmax+b-m*a)*_uy)
enddef;

% Projection d'un point sur les axes ======================================
def r_point_proj(expr x,y) =
    draw(x*_ux,_oy)--(x*_ux,y*_uy)--(_ox,_oy+y*_uy) dashed evenly;
    r_ppoint(x,y)
enddef;


def r_proj(expr x,y,couleur) =
  draw(x*_ux,_oy)--(x*_ux,y*_uy)--(_ox,y*_uy) dashed evenly withcolor couleur;
 r_ppoint(x,y)
enddef;
% On enl�e ce qui sort du rep�e =========================================
def r_fin =
    clip currentpicture to (_r_xmin-0.1*_ux,_r_ymin-0.1*_uy)--(_r_xmin-0.1*_ux,_r_ymax+0.1*_uy)--
    (_r_xmax+0.1*_ux,_r_ymax+0.1*_uy)--(_r_xmax+0.1*_ux,_r_ymin-0.1*_uy)--cycle
enddef;

% Tracer des courbes en dimension 2 =======================================
% Sont pr��inies avant beginfig les expressions fx(t) et fy(t)===========
vardef f_point(suffix fx,fy)(expr t) =
        r_point(fx(t),fy(t))
enddef;
vardef fy_val(suffix fx,fy)(expr t) =
        fy(t)
enddef;

vardef f_courbe(suffix fx,fy)(expr ti,tf,n) =
    f_point(fx,fy,ti)
    for i=1 upto n:
	...f_point(fx,fy,ti+(i/n)*(tf-ti))
    endfor
enddef;



%Aire sous une courbe : Aire(fx,fy,A,B,couleur)

vardef Aire(suffix fx,fy)(expr A,B,couleur)=
     save a,b,c,d,p; path a,b,c,d,p;

a:= f_courbe(fx,fy,A,B,50);
b:=r_p(B,fy(B))--r_p(B,0);
c:=r_p(B,0)--r_p(A,0);
d:=r_p(A,0)--r_p(A,fy(A));

p:=buildcycle(a,b,c,d);
fill p withcolor couleur;
%draw f_courbe(fx,fy,-1,7,50)withpen pencircle scaled 1.5bp withcolor red;
draw b withpen pencircle scaled 1.5bp;
draw d withpen pencircle scaled 1.5bp;

enddef;





% D�iv� de f sous r�erve d'existence =====================================
vardef fx_derive(suffix fx)(expr a,h) =
    ((fx(a+h))-(fx(a)))/h
enddef;
vardef fy_derive(suffix fy)(expr a,h) = 
    ((fy(a+h))-(fy(a)))/h
enddef;

% Tangente �la courbe en un point r�ulier tel que x'(t) diff�ent de 0=====
vardef f_tangente(suffix fx,fy)(expr a,h) =
            r_droitedir(fx(a),fy(a),(fy_derive(fy,a,h))/(fx_derive(fx,a,h)))
enddef;

% Trac�de la tangente en un point r�ulier tel que x'(t) diff�ent de 0=====
vardef tracef_tangente(suffix fx,fy)(expr a,b,h,couleur,larg) =
    pair _f[];
    _f1=f_point(fx,fy,a)+b*(1*_ux,(fy_derive(fy,a,h))/(fx_derive(fx,a,h))*_uy);
    _f2=f_point(fx,fy,a)-b*(1*_ux,(fy_derive(fy,a,h))/(fx_derive(fx,a,h))*_uy);
    drawdblarrow _f1.._f2 withcolor couleur withpen pencircle scaled larg;
    pickup pencircle scaled 0.5pt;
    r_ppoint(fx(a),fy(a))
enddef;

%==========================Suites numeriques=================================
%suites u(n)=f(n)
vardef u_courbe(suffix ux,uy)(expr ni,nf,t) =
    drawoptions( dashed evenly);
    draw f_point(ux,uy,ni)
    for i=ni upto nf:
	...f_point(ux,uy,i) 
    endfor ;
    drawoptions( );
    pickup pencircle scaled 3pt;
    for i=ni upto nf:   
	draw f_point(ux,uy,i);
        % dotlabel.bot(""&decimal i, r_point(i,0)); 
        % dotlabel.lft("u"&decimal i, r_point(0,uy(i));
    endfor ;
    if t=1:
    
     numeric u[];
	for j=ni upto nf:
	    u[j] = uy(j);
            write   "dotlabel.lft"
        	&
                "(btex $u_{"&decimal j&"}$ etex,r_point(0,u["&decimal j&"]));" 
                to 
                "TOTO.tmp";
        endfor;
            if ni=0:
              dotlabel.lrt(btex 0 etex,r_point(0,0));
               for j=1 upto nf:
            dotlabel.bot(""&decimal j, r_point(j,0));
        endfor;
           else:
             for j=ni upto nf:
            dotlabel.bot(""&decimal j, r_point(j,0));
            endfor;
            fi;
        write EOF to "TOTO.tmp";      
        scantokens "input TOTO.tmp";        
    fi; 
    pickup pencircle scaled 0.5pt 
enddef;


% calcul d'un terme quelconque de la suite u(n+1)=f(u(n)) �partir 
% d'un autre pr��ent dans la liste
% suites u(n+1)=f(u(n))
vardef u_rec(suffix fx,fy)(expr d,i,n) =
    numeric u[];
    u[i] = d;
    for j=i upto n:
    u[j+1] = fy(u[j]);
    endfor;
    u[n]
enddef;

% courbes suites u(n+1)=f(u(n))
vardef u_reccourbe (suffix fx,fy) (expr d,i,n,ni,nf,t)  =
    draw f_courbe(fx,fy,ni,nf,100) withcolor bleu withpen pencircle scaled 1.8bp;
    draw r_droitedir(0,0,1);
    numeric u[];
    u[i] = d;
    for j=i upto n-1:
    u[j+1] = fy(u[j]);   
    draw r_point(u[j+1],0)--r_point(u[j+1],u[j+1]) dashed evenly withpen pencircle scaled 1.4bp withcolor bleu_f;
    if j > i:
    draw r_point(u[j],u[j])--f_point(fx,fy,u[j])--r_point(u[j+1],u[j+1]) withpen pencircle scaled 1.4bp withcolor bleu_f;
     drawarrow  r_point(u[j],u[j])--0.5( r_point(u[j],u[j])+f_point(fx,fy,u[j]))withpen pencircle scaled 1.4bp withcolor bleu_f; 
     drawarrow f_point(fx,fy,u[j])--0.5(f_point(fx,fy,u[j])+r_point(u[j+1],u[j+1])) withpen pencircle scaled 1.4bp withcolor bleu_f;
    fi;
    endfor;
    draw r_point(u[i],0)--f_point(fx,fy,u[i])--r_point(u[i+1],u[i+1])withpen pencircle scaled 1.4bp withcolor bleu_f;
    drawarrow  r_point(u[i],0)--0.5(r_point(u[i],0)+f_point(fx,fy,u[i])) withpen pencircle scaled 1.4bp withcolor bleu_f;
    drawarrow f_point(fx,fy,u[i])--0.5(f_point(fx,fy,u[i])+r_point(u[i+1],u[i+1])) withpen pencircle scaled 1.4bp withcolor bleu_f;
    if t=1:
       for j=0 upto n:
          write   "dotlabel.bot"
                    &
                    "(btex $u_{"&decimal j&"}$ etex, r_point(u["&decimal j&"],0));" 
          to 
                   "TOTO.tmp";
      endfor;
     write EOF to "TOTO.tmp";      
     scantokens "input TOTO.tmp";        
    fi; 
    

 if t=2:
       for j=3 upto n:
          write   "dotlabel.top"
                    &
                    "(btex $u_{"&decimal j&"}$ etex, r_point(u["&decimal j&"],0));" 
          to 
                   "TOTO.tmp";
      endfor;
     write EOF to "TOTO.tmp";      
     scantokens "input TOTO.tmp";        
    fi; 

enddef;

%===================Hachurage (Christophe Poulain .....merci a lui)============
vardef hach(expr chemin, angle, ecart, trace,couleur)= % retourne une picture
  save $;
  picture $;
  path support;
  support=((cm*(-37,0))--(cm*(37,0))) rotated angle;
  if trace=1:
    drawoptions(dashed evenly);
  elseif trace=2:
    drawoptions(dashed dashpattern(on12bp off6bp on3bp off6bp));
  fi;
  $=image(
    for j=-200 upto 200:
      if ((support shifted (ecart*j*(cm,0))) intersectiontimes chemin)<>(-1,-1):
        draw support shifted (ecart*j*(cm,0))
        withcolor couleur;
      fi
    endfor;
    );
  clip $ to chemin;
  drawoptions();
  $

enddef;









%%$==========%==================integration===================================
%Pomp�en partie sur le net chez Vincent Zoonekynd.....merci a lui


% rectangles �gauche, on commence avec une hauteur qui est l'image 
% du premier point de la subdivision, la somme des aires ne minore 
% donc pas en general integrale de f sur [a,b]
vardef trace_rectangles_left (suffix fx,fy)(expr a,b,inc) = 
    % sur l'intervalle [a,b] avec un pas de inc
    save i; numeric i;
    for i=a step inc until b-inc:
      path p;
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,fy(i))--r_point(i,fy(i))--cycle;
      %p := p scaled 1cm;
      %fill p withcolor .8*white;
      draw p;
    endfor;
enddef;
  
% rectangles �droite, on commence avec une hauteur qui est l'image 
% du premier point +inc de la subdivision, la somme des aires ne 
% minore donc pas en general integrale de f sur [a,b]
vardef trace_rectangles_right (suffix fx,fy)(expr a,b,inc) = 
    % sur l'intervalle [a,b] avec un pas de inc
    save i; numeric i;
    for i=a step inc until b-inc:
      path p;
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,fy(i+inc))--
        r_point(i,fy(i+inc))--cycle;
      %p := p scaled 1cm;
      %fill p withcolor .8*white;
      draw p;
    endfor;
enddef;
  
%methode des trapezes
vardef trace_trapezes (suffix fx,fy)(expr a,b,inc) =
    save i; numeric i;
    for i=a step inc until b-inc:
      path p;
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,fy(i+inc)) -- 
        r_point(i,fy(i))--cycle;
      % p := p scaled 1cm;
      % fill p withcolor .8*white;
      draw p;
    endfor;
enddef;
  
  
% une macro non parfaite pour obtenir le min de f sur un intervalle, 
% cela suppose qu'elle soit bien reguliere......
vardef minf(suffix fx,fy)(expr a,b) =
    save m,i; numeric m,i;
    m:=fy(a);
    for i=a step (b-a)/100 until b:
      if m>fy(i): m:=fy(i); fi;
    endfor;
    m
enddef;


%rectangle en dessous de la courbe colori�en bleu, utilise la macro precedente
  vardef trace_rectangles_min (suffix fx,fy)(expr a,b,inc) =
    save i; numeric i;
    for i=a step inc until b-inc:
      path p; numeric m;
      m:=minf(fx,fy,i,i+inc);
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,m)--r_point(i,m)--cycle;
      %p := p scaled 1cm;
      
      fill p withcolor bleu_ciel;
      draw p;
    endfor;

enddef;


%rectangle en dessous de la courbe colori�en bleu, utilise la macro precedente
  vardef trace_rectangles_min_c (suffix fx,fy)(expr a,b,inc,couleur) =
    save i; numeric i;
    for i=a step inc until b-inc:
      path p; numeric m;
      m:=minf(fx,fy,i,i+inc);
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,m)--r_point(i,m)--cycle;
      %p := p scaled 1cm;
      
      fill p withcolor couleur;
      draw p;
    endfor;

enddef;

%rectangle en dessous de la courbe hachur�  
vardef trace_rectangles_min_h (suffix fx,fy)(expr a,b,inc) =
    save i; numeric i;
    for i=a step inc until b-inc:
       numeric m;path p;
      m:=minf(fx,fy,i,i+inc);
     
 p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,m)--r_point(i,m)--cycle;
     hach(p,45,0.2,1,bleu_m);
      draw p;
    endfor;

enddef;



%rectangle en dessous de la courbe transparents, utilise la macro precedente
  vardef trace_rectangles_min_t (suffix fx,fy)(expr a,b,inc) =
    save i; numeric i;
    for i=a step inc until b-inc:
      path p; numeric m;
      m:=minf(fx,fy,i,i+inc);
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,m)--r_point(i,m)--cycle;
      %p := p scaled 1cm;
      
     % fill p withcolor bleu_ciel;
      draw p;
    endfor;

enddef;


% une macro non parfaite pour obtenir le max de f sur un intervalle, 
% cela suppose qu'elle soit bien reguliere......
vardef maxf(suffix fx,fy)(expr a,b) =
    save m,i; numeric m,i;
    m:=fy(a);
    for i=a step (b-a)/100 until b:
      if m<fy(i): m:=fy(i); fi;
    endfor;
    m
enddef;

% rectangle au dessus de la courbe, utilise la macro precedente
vardef trace_rectangles_max (suffix fx,fy)(expr a,b,inc) =
    save i; numeric i;
    for i=a step inc until b-inc:
      path p; numeric m;
      m:=maxf(fx,fy,i,i+inc);
      p = r_point(i,0)--r_point(i+inc,0)--r_point(i+inc,m)--r_point(i,m)--cycle;
      %p := p scaled 1cm;
      %fill p withcolor .8*white;
      draw p;
    endfor;
enddef;


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%                 G E O
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%cube


vardef cube (expr depart,dimarete) =
                save fig,cube,chemin;
                pair sommetCube[];
                path chemin;
                picture fig,cube;
                fig=currentpicture;
                currentpicture:=nullpicture;
                sommetCube0=depart;
                sommetCube1=sommetCube0 shifted (dimarete,0);
                (sommetCube3-sommetCube0)=(sommetCube1-sommetCube0) scaled .5 rotated 35;
                (sommetCube2-sommetCube1)=(sommetCube0-sommetCube1) scaled .5 rotated (-145);               
                for i:=0 upto 3 :
                        sommetCube[i+4]=sommetCube[i] shifted (0,dimarete);
                endfor
                draw sommetCube0--sommetCube1--sommetCube2--sommetCube6--
                sommetCube5--sommetCube4--cycle;
                draw sommetCube1--sommetCube5;
                draw sommetCube0--sommetCube3--sommetCube7 dashed evenly;
                draw sommetCube2--sommetCube3 dashed evenly;
                draw sommetCube4--sommetCube7--sommetCube6;
                cube=currentpicture;
                currentpicture:=fig;
                cube
enddef;

vardef nommecube =
                label.llft("A", sommetCube0);
                label.lrt("B", sommetCube1);
                label.rt("C", sommetCube2);
                label.lft("D", sommetCube3);
                label.ulft("E", sommetCube4);
                label.ulft("F", sommetCube5);
                label.urt("G", sommetCube6);
                label.ulft("H", sommetCube7);
enddef;






vardef centredegravite (expr a,b,c) =
        ((a+b+c) scaled 1/3)
enddef;

vardef orthocentre (expr a,b,c) =
                save $;
                pair $;
                ($-a) rotated 90=whatever*(b-c);
                ($-b) rotated 90=whatever*(a-c);
                $
enddef;

vardef centrecerclecirconscrit (expr a,b,c) =
                save $;
                pair $;
                ($-1/2[a,b]) rotated 90=whatever*(a-b);
                ($-1/2[a,c]) rotated 90=whatever*(a-c);
                $
enddef;

vardef cerclecirconscrit (expr a,b,c) =
                save $,p;
                pair $;
                path p;
                $=centrecerclecirconscrit(a,b,c);
                p=fullcircle scaled (2*abs($-a)) shifted $;
                p
enddef;

vardef centrecercleinscrit (expr a,b,c) =
                save $;
                pair $;
                ($-a)=whatever*(b-a) rotated (1/2*(angle(c-a)-angle(b-a)));
                ($-b)=whatever*(c-b) rotated (1/2*(angle(a-b)-angle(c-b)));
                $
enddef;

vardef cercleinscrit (expr a,b,c) =
                save I,M,p;
                pair I,M;
                path p;
                I=centrecercleinscrit(a,b,c);
                ((M-I) rotated 90)=whatever*(b-a);
                M=whatever[a,b];
                p=fullcircle scaled (2*(abs(M-I))) shifted I;
                p
enddef;


def ps(expr a,b) =
        (xpart a)*(xpart b) + (ypart a)*(ypart b)
    enddef;

def distance(expr a,b) =
        sqrt(ps(b-a,b-a))
    enddef;

vardef milieu(expr a,b) =
        0.5[a,b]
       enddef;

vardef symbole_ortho(expr a,b,c,x) =
        (b+x*unitvector(a-b))
        --(b+x*unitvector(a-b)+x*unitvector(c-b))
        --(b+x*unitvector(c-b))
enddef;

vardef projection(expr m,a,b,h) =
        h - m = whatever * (b-a) rotated 90;
        h = whatever [a,b];
enddef;

vardef symetrique(expr m,a,b,s) =
        s - m = whatever * (b-a) rotated 90;
        .5[s,m] = whatever [a,b];
enddef;

vardef mediatrice (expr a, b, x) =
        (0.5[a,b]+(x*(b-a) rotated 90))--(0.5[a,b]+(x*(b-a) rotated -90))
       enddef;


% == Cercle [centre,point]
vardef cercle (expr o,a) =
        fullcircle scaled (2*distance(a,o)) shifted o
        enddef;

%% == Droite 
% Donn�s de deux points et d'un facteur d'�oignement de ces points
vardef droite (expr a,b,x) =
        x[a,b]--x[b,a]
        enddef;




%%%%%%%%%%%%%%%%%%%%%%%%%%
%pour les segments et angles non orient�
%%%%%%%%%%%%%%%%%%%%%%%%%

%macro pr�iminaire
marksize=4pt;
def draw_mark(expr p,a) =
begingroup
save t, dm; pair dm;
t=arctime a of p;
dm=marksize*unitvector direction t of p rotated 90;
drawarrow (-.5dm.. .5dm) shifted point t of p;
endgroup
enddef;

%macro pr�iminaire

def draw_marko(expr p,a,c) =
begingroup
save t, dm; pair dm;
t=arctime a of p;
dm=marksize*unitvector direction t of p rotated 90;
drawarrow (-.5dm.. .5dm) shifted point t of p withcolor c;
endgroup
enddef;


%la macro qui place n petits traits sur un segment ou une 
% marque d'angle
def draw_marks(expr p,n)=
begingroup
save amid;
amid= .5*arclength p;
for i=-(n-1)/2 upto (n-1)/2 : draw_mark(p, amid+.6marksize*i);
endfor
%draw p;
endgroup
enddef;

%la macro qui place n petits traits sur un segment ou une 
% marque d'angle et qui dessine le segment ou l'angle
def draw_markeds(expr p,n)=
begingroup
save amid;
amid= .5*arclength p;
for i=-(n-1)/2 upto (n-1)/2 : draw_mark(p, amid+.6marksize*i);
endfor
draw p;
endgroup
enddef;

def draw_markedso(expr p,n,c,d)=
begingroup
save amid;
amid= .5*arclength p;
for i=-(n-1)/2 upto (n-1)/2 : draw_marko(p, amid+.6marksize*i,c);
endfor
draw p withcolor c dashed d;
endgroup
enddef;

%%%%%%%%%%%%%%%%%%%%%
%pour les angles orient�
%%%%%%%%%%%%%%%%%%%%%%%

def draw_marked(expr p,n)=
begingroup
save amid;
amid= .5*arclength p;
for i=-(n-1)/2 upto (n-1)/2 : draw_mark(p, amid+.6marksize*i);
endfor
drawarrow p;
endgroup
enddef;



%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% angles g�m�riques :trace une marque d'angle g� de rayon % x et avec n petites marques
%%%%%%%%%%%%%%%%%%%%%%%%%%%

def mark_angleg(expr a, b, c, n,x)=
begingroup 
save  p; path p;
p= x*unitvector(a-b){(a-b)rotated 90}..x*unitvector(c-b);
%s=1.6marksize/length(point 1 of p-point 0 of p);
 draw_markeds(p  shifted b,n);
endgroup
enddef;


def mark_anglego(expr a, b, c, n,x,cc,d)=
begingroup 
save  p; path p;
p= x*unitvector(a-b){(a-b)rotated 90}..x*unitvector(c-b);
%s=1.6marksize/length(point 1 of p-point 0 of p);
 draw_markedso(p  shifted b,n,cc,d);
endgroup
enddef;



%%%%%%%%%%%%%%%%%%%%%%%%%
%angle +
%%%%%%%%%%%%%%%%%%%%%%


def mark_angle(expr a, b, c, n,x)=
begingroup 
save s, p; path p;
p= x*unitvector(a-b){(a-b)rotated 90}..x*unitvector(c-b);
s=1.6marksize/length(point 1 of p-point 0 of p);
 draw_marked(p scaled s shifted b,n);
endgroup
enddef;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%angle n�atif
%%%%%%%%%%%%%%%%%%%%%%%%%%

def mark_anglem(expr a, b, c, n,x)=
begingroup 
save s, p; path p;
p= x*unitvector(a-b){(a-b)rotated -90}..x*unitvector(c-b);
s=.9marksize/length(point 1 of p-point 0 of p);
 draw_marked(p scaled s shifted b,n);
endgroup
enddef;






% trace la droite (AB) l��ement prolong� en A et en B de u

def tracedroite(expr a, b, u) =
    begingroup
    save c,d ;
    pair c,d ;
    c := a+(unitvector(a-b)*u);
    d := b+(unitvector(b-a)*u);
    draw c--d;% withpen pencircle scaled Epaisseur;
    endgroup
enddef ;

% Epaisseur des traits de cote, d'angle ...
Epaisseur = .5pt ;

% Distance des �iquettes
labeloffset := 5bp ;

% liaison entre les lignes sont pointues
%linejoin := beveled ;

% Terminaison des lignes sur le point
% et rectangle
%linecap := butt ;




% fait la marque perpendiculaire en a
% en commen�nt par le cot�ab

def perpendiculaire(expr a, b) =
    begingroup
    save T,u,x,y,z ;
    transform T ;
    pair x,y,z ;
    numeric u ;
    u = 2mm ;
    T = identity rotated angle (b-a) shifted a ;
    x = (u,0) transformed T ;
    y = (u,u) transformed T ;
    z = (0,u) transformed T ;
    draw x--y--z withpen pencircle scaled Epaisseur;
    endgroup
enddef ;


% Faire des marques pour des segments meme longueur
% Exemple : milieur de AB avec 2 marques :
% memelong(a--b,2) ;

taillemarque = 4 pt ;

def marque(expr p, a ) =
    begingroup
    save t, dm ; pair dm ;
    t = arctime a of p ;
    dm = taillemarque*unitvector direction t of p rotated 90 ;
    draw (-0.5dm .. 0.5dm) shifted point t of p withpen pencircle scaled Epaisseur;
    endgroup
enddef ;

def memelong(expr p, n) =
    begingroup
    save m, i ;
    m = 0.5*arclength p ;
    for i=-(n-1)/2 upto (n-1)/2:
        marque(p, m + 0.6taillemarque*i);
    endfor ;
    endgroup
enddef ;


% Faire des marques pour des angle de meme mesure
% Exemple : milieux de AB avec 2 marques :
% memelong(a--b,2) ;

angle_radius = 8pt ;

def meme_angle(expr a, b, c, n) =
    begingroup
    save s, p; path p;
    p = unitvector(a-b){(a-b)rotated 90}..unitvector(c-b);
    s = 0.9taillemarque/length(point 1 of p - point 0 of p);
    if s<angle_radius: s:=angle_radius; fi
    draw p scaled s shifted b withpen pencircle scaled Epaisseur;
    memelong(p scaled s shifted b, n);
    endgroup
enddef;

% Dessine un angel droit de l'espace sur le sommet a en direction
% de b et c de dimension u et v suivant les directions

def perp(expr a, b, c, u, v)=
    begingroup
    save x,y,z ;
    pair x,y,z ;
    x = unitvector(b-a)*u ;
    y = unitvector(c-a)*v ;
    z = x+y ;
    draw (x+a)--(z+a)--(y+a) withpen pencircle scaled Epaisseur;
    endgroup
enddef;




% cote un angle abc 
% ditance est la distance de cotation
% etiquette est le texet �placer
% facteur est le d�lacement de l'�iquette par rapport �l'arc

def Angle(expr a, b, c, distance, etiquette, facteur) =
    begingroup
    save p, x; path p; pair x;
    p = (unitvector(a-b){(a-b)rotated 90}..unitvector(c-b))
                                        scaled distance shifted b ;
    drawdblarrow p withpen pencircle scaled Epaisseur;
    x = (point (.5(length p)) of p) ;
    label( etiquette , x shifted ( facteur*unitvector(x-b) ) );
    endgroup
enddef;

% cote un segment ab 
% ditance est la distance de cotation
% etiquette est le texet �placer
% facteur est le d�lacement de l'�iquette par rapport �l'arc

def Cote(expr a, b, distance, etiquette, facteur) =
    begingroup
    save T, p, q, x; path p, q; pair x; transform T;
    T = identity  shifted (((unitvector(b-a)) rotated 90)*distance);
    p = (a--b) transformed T ;
    q = (0,.5*distance)--(0,-.75*distance) ;
    drawdblarrow p withpen pencircle scaled Epaisseur;
    x = (point (.5(length p)) of p) ;
    label( etiquette , (0,0)) rotated angle(b-a) shifted x
                                    shifted (facteur*unitvector(x)) ;
    draw q rotated angle(b-a) transformed T shifted a
                                        withpen pencircle scaled Epaisseur;
    draw q rotated angle(b-a) transformed T shifted b
                                        withpen pencircle scaled Epaisseur;

    endgroup
enddef;

def CoteVD(expr a, b, distance, etiquette) =
    begingroup
    save x; numeric x;
    
    x := xpart(a) + distance ;
    
    draw a--(x + 7pt, ypart(a)) withpen pencircle scaled Epaisseur ;
    draw b--(x + 7pt, ypart(b)) withpen pencircle scaled Epaisseur ;
    
    drawdblarrow (x, ypart(a))--(x, ypart(b))
                    withpen pencircle scaled Epaisseur ;
    
    label.rt(etiquette , .5[(x, ypart(a)),(x, ypart(b))]) ;
    
    endgroup
enddef;

def CoteVG(expr a, b, distance, etiquette) =
    begingroup
    save x; numeric x;
    
    x := xpart(a) - distance ;
    
    draw a--(x - 7pt, ypart(a)) withpen pencircle scaled Epaisseur ;
    draw b--(x - 7pt, ypart(b)) withpen pencircle scaled Epaisseur ;
    
    drawdblarrow (x, ypart(a))--(x, ypart(b))
                    withpen pencircle scaled Epaisseur ;
    
    label.lft(etiquette , .5[(x, ypart(a)),(x, ypart(b))]) ;
    
    endgroup
enddef;

def CoteHS(expr a, b, distance, etiquette) =
    begingroup
    save y; numeric y;
    
    y := ypart(a) + distance ;
    
    draw a--(xpart(a), y + 7pt) withpen pencircle scaled Epaisseur ;
    draw b--(xpart(b), y + 7pt) withpen pencircle scaled Epaisseur ;
    
    drawdblarrow (xpart(a), y)--(xpart(b), y)
                    withpen pencircle scaled Epaisseur ;
    
    label.top(etiquette , .5[(xpart(a), y),(xpart(b), y)]) ;
    
    endgroup
enddef;

def CoteHI(expr a, b, distance, etiquette) =
    begingroup
    save y; numeric y;
    
    y := ypart(a) - distance ;
    
    draw a--(xpart(a), y - 7pt) withpen pencircle scaled Epaisseur ;
    draw b--(xpart(b), y - 7pt) withpen pencircle scaled Epaisseur ;
    
    drawdblarrow (xpart(a), y)--(xpart(b), y)
                    withpen pencircle scaled Epaisseur ;
    
    label.bot(etiquette , .5[(xpart(a), y),(xpart(b), y)]) ;
    
    endgroup
enddef;





























%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%%            A R B R E    2 x 2
%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



vardef branched(expr D,F, s,n) =
  draw D..F; label.top(TEX(s),.5(D+F)); dotlabel.top(TEX(n),F); enddef;

vardef branchef(expr D,F, s,n) =
  draw D..F; label.top(TEX(s),.5(D+F)); label.rt(TEX(n),F); enddef;


u=1cm;
vardef arbre(expr a,b,c,d,pa,pb,pac,pad,pbc,pbd)=
branched( (0,0),(2u,1.5u),pa,a);
branched((0,0),(2u,-1.5u),pb,b);
branchef((2u,1.5u),(4u,2.5u),pac,c);
branchef((2u,1.5u),(4u,0.5u),pad,d);
branchef((2u,-1.5u),(4u,-0.5u),pbc,c);
branchef((2u,-1.5u),(4u,-2.5u),pbd,d);
enddef;

% exemple d'appel 
% input TEX    si on a besoin de tex
%beginfig(1)
%arbre("$A$","$\overline{A}$","$C$","$D$","1/3","2/3","3/5","2/5","5/7","2/7");
%endfig;






def r_ppointc(expr x,y,couleur) =
        pickup pencircle scaled 6pt;
        draw (x*_ux,y*_uy) withcolor couleur;
pickup pencircle scaled 0.5pt 
enddef;




def r_ppc(expr x,y,couleur) =
 r_ppointc(x,y,couleur)
enddef;








%
%  M O U S T A C H E
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%






def moustache(expr min,qu,me,qt,max,UX,OX,Q)=

numeric XMIN,XMAX;
XMIN:=min-1;
XMAX:=max+1;
repere(OX,0,XMIN,XMAX,-1,4,UX,1cm);
path t;
t:=r_point(0,.1)--r_point(0,-.1);



draw r_droitedir(0,0,0) withpen pencircle scaled 1.5bp;
draw t shifted r_p(min,0) withcolor green withpen pencircle scaled 2bp;
draw t shifted r_p(qu,0) withcolor blue withpen pencircle scaled 2bp;
draw t shifted r_p(me,0) withcolor red withpen pencircle scaled 2bp;
draw t shifted r_p(qt,0) withcolor bleu withpen pencircle scaled 2bp;
draw t shifted r_p(max,0) withcolor .6white withpen pencircle scaled 2bp;

draw r_point(min,2)--r_point(qu,2); % min q1
draw r_point(qt,2)--r_point(max,2);  %q3 max

draw r_point(qu,1.5)--r_point(qu,2.5) withcolor blue;
draw r_point(me,1.5)--r_point(me,2.5) withcolor red;
draw r_point(qt,1.5)--r_point(qt,2.5)withcolor bleu;

draw r_point(qu,1.5)--r_point(qt,1.5);
draw r_point(qu,2.5)--r_point(qt,2.5);

r_ppc(min,2,or);
r_ppc(max,2,0.6white);

draw r_point(min,0)--r_point(min,2) dashed evenly withcolor green;
draw r_point(qu,0)--r_point(qu,1.5) dashed evenly withcolor blue;
draw r_point(me,0)--r_point(me,1.5) dashed evenly withcolor red;
draw r_point(qt,0)--r_point(qt,1.5) dashed evenly withcolor bleu;
draw r_point(max,0)--r_point(max,2) dashed evenly withcolor 0.6 white;


if Q=2:

label.bot(TEX(" $x_{min}=" & decimal(min) & "$ "), r_point(min,0))    withcolor green ;
label.bot(TEX(" $Q_{1}=" & decimal(qu) & "$ "), r_point(qu,0))    withcolor blue ;
label.bot(TEX(" $M_{e}=" & decimal(me) & "$ "), r_point(me,0))    withcolor red ;
label.bot(TEX(" $Q_{3}=" & decimal(qt) & "$ "), r_point(qt,0))    withcolor bleu ;
label.bot(TEX(" $x_{max}=" & decimal(max) & "$ "), r_point(max,0))    withcolor .6white ;

elseif Q=1:


label.bot(TEX(" $x_{min} $ "), r_point(min,0))    withcolor green ;
label.bot(TEX(" $Q_{1}$ "), r_point(qu,0))    withcolor blue ;
label.bot(TEX(" $M_{e}$ "), r_point(me,0))    withcolor red ;
label.bot(TEX(" $Q_{3}$ "), r_point(qt,0))    withcolor bleu ;
label.bot(TEX(" $x_{max}$ "), r_point(max,0))    withcolor .6white ;

else :

label.bot(TEX(  decimal(min)  ), r_point(min,0))    withcolor green ;
label.bot(TEX(  decimal(qu)  ), r_point(qu,0))    withcolor blue ;
label.bot(TEX(  decimal(me)  ), r_point(me,0))    withcolor red ;
label.bot(TEX(  decimal(qt)  ), r_point(qt,0))    withcolor bleu ;
label.bot(TEX(  decimal(max)  ), r_point(max,0))    withcolor .6white ;





fi;




r_fin;

enddef;





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%   L O I            N O R M A L E
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


vardef loinormale(expr m,s,p,P,X) =

 
  
%%%%%%%%%%%%%%%%%%%%%%%
vardef fx(expr t)=
t
enddef;


numeric h,H;
  h:=0.398942280401/s;
  H:=1.5*h;
vardef U(expr t) =
    (-(t-m)*(t-m))/(2*s*s)
enddef;

  
vardef fy(expr t)=
  h*exp(U(t))
enddef;

numeric ab,mi,ma,mm,Am;
ab:=2/s;
mi:=m-3*s;
ma:=m+3*s;
mm:=(mi+p)/2;
Am:=m-10*s;

%%%%%%%%%%%%%%%%%%%%%
repere(m,0,mi,ma,-0.1,H,1.5cm,20cm);
Aire(fx,fy,Am,p,bleu_ciel);
r_axes;
r_labelxy;
grad_x(1,1,0.2white);

draw f_courbe(fx,fy,mi,ma,100)withpen pencircle scaled 1.25bp withcolor red;

   dotlabel.urt(TEX(decimal h), r_p(m,fy(m)));
   dotlabel.lrt(TEX("$\mu= " & decimal(m) &  "$"), r_p(m,0));
   label.bot(TEX("$p(Y< " & decimal(p) & ")=" & decimal(P) & "$") , r_p(m-s,0.05));
   label.rt(TEX("La variable al\'eatoire " & X & "  suit la loi normale de param\`etres $\mu=$ "& decimal m & " et $\sigma=$" & decimal s ),r_p(m-3*s,1.2*h));
  label.urt(TEX( " $y={1\over{" & decimal s & "\sqrt{2\pi}}} e^{-{1\over{2}} \left({{x-" & decimal m  & "}\over{" & decimal s  & "}}\right)^2}$"),r_p(m+s,fy(m+s)))withcolor red;

r_fin;

enddef;