157 lines
6.8 KiB
Plaintext
157 lines
6.8 KiB
Plaintext
//DCstat-1
|
|
//02/03/2009
|
|
|
|
|
|
pen[] couleur={mediumred,mediumcyan,mediumgreen,mediummagenta,mediumblue,yellow,
|
|
orange,fuchsia,brown,heavycyan,heavygreen,heavymagenta,deepblue,white,black};
|
|
|
|
struct axes{pair min; pair max;real graduationx;real numerotationx;real taillex;real graduationy;real numerotationy;real tailley;}
|
|
|
|
axes calculaxes(real[] xi,real[] ni,pair ptO=(0,0)){
|
|
axes ax;
|
|
ax.min=ptO;
|
|
ax.max=(max(xi)*1.05,max(ni)*1.05);
|
|
|
|
//axe des x
|
|
if (ax.max.x-ax.min.x<1){ax.graduationx=0.025;ax.numerotationx=0.1;}
|
|
else if (ax.max.x-ax.min.x<10){ax.graduationx=0.25;ax.numerotationx=1;}
|
|
else if (ax.max.x-ax.min.x<100){ax.graduationx=2.5;ax.numerotationx=10;}
|
|
else if (ax.max.x-ax.min.x<1000){ax.graduationx=25;ax.numerotationx=100;}
|
|
else if (ax.max.x-ax.min.x<10000){ax.graduationx=250;ax.numerotationx=1000;}
|
|
else {ax.graduationx=2500;ax.numerotationx=10000;}
|
|
|
|
//données axe y
|
|
ax.tailley=0.0125*(ax.max.x-ax.min.x);
|
|
if (ax.max.y-ax.min.y<1){ax.graduationy=0.025;ax.numerotationy=0.1;}
|
|
else if (ax.max.y-ax.min.y<10){ax.graduationy=0.25;ax.numerotationy=1;}
|
|
else if (ax.max.y-ax.min.y<100){ax.graduationy=2.5;ax.numerotationy=10;}
|
|
else if (ax.max.y-ax.min.y<1000){ax.graduationy=25;ax.numerotationy=100;}
|
|
else if (ax.max.y-ax.min.y<10000){ax.graduationy=250;ax.numerotationy=1000;}
|
|
else {ax.graduationy=2500;ax.numerotationy=10000;}
|
|
|
|
//retour axe des x
|
|
ax.taillex=0.0125*(ax.max.y-ax.min.y);
|
|
return ax;}
|
|
|
|
void traceaxe(axes lesaxes,bool axedesy=true,bool origine=true,pair pointO=(0,0), string libellex,string libelley=""){
|
|
//axe des abscisses
|
|
draw((lesaxes.min.x,pointO.y)--(lesaxes.max.x,pointO.y),Arrow(1.5mm));
|
|
|
|
//tracé des graduations
|
|
for (int n = round(lesaxes.min.x/lesaxes.graduationx) ; n <= (0.98*lesaxes.max.x)/lesaxes.graduationx; ++ n) {
|
|
draw((n*lesaxes.graduationx,pointO.y-0.5*lesaxes.taillex)--(n*lesaxes.graduationx,pointO.y+0.5*lesaxes.taillex));}
|
|
|
|
//tracé des numérotations
|
|
for (int n = round(lesaxes.min.x/lesaxes.numerotationx) ; n <= (0.98*lesaxes.max.x)/lesaxes.numerotationx; ++ n) {
|
|
draw((n*lesaxes.numerotationx,pointO.y-lesaxes.taillex)--(n*lesaxes.numerotationx,pointO.y+lesaxes.taillex));
|
|
if(origine){label(scale(0.6)*format(n*lesaxes.numerotationx),(n*lesaxes.numerotationx,pointO.y-lesaxes.taillex),S);}
|
|
else {if(n!=0){label(scale(0.6)*format(n*lesaxes.numerotationx),(n*lesaxes.numerotationx,pointO.y-lesaxes.taillex),S);}}}
|
|
|
|
//Nom de l'axe
|
|
label(scale(0.9)*libellex,(lesaxes.max.x,pointO.y-5*lesaxes.taillex),SW);
|
|
|
|
//axe des ordonnées
|
|
if (axedesy) {draw((pointO.x,lesaxes.min.y)--(pointO.x,lesaxes.max.y),Arrow(1.5mm));
|
|
|
|
//tracé des graduations
|
|
for (int n = round(lesaxes.min.y/lesaxes.graduationy) ; n <= (0.98*lesaxes.max.y)/lesaxes.graduationy; ++ n) {
|
|
draw((pointO.x-0.5*lesaxes.tailley,n*lesaxes.graduationy)--(pointO.x+0.5*lesaxes.tailley,n*lesaxes.graduationy));}
|
|
|
|
//tracé des numérotations
|
|
for (int n = round(lesaxes.min.y/lesaxes.numerotationy) ; n <= (0.98*lesaxes.max.y)/lesaxes.numerotationy; ++ n) {
|
|
draw((pointO.x-lesaxes.tailley,n*lesaxes.numerotationy)--(pointO.x+lesaxes.tailley,n*lesaxes.numerotationy));
|
|
label(scale(0.6)*format(n*lesaxes.numerotationy),(pointO.x-lesaxes.tailley,n*lesaxes.numerotationy),W);}
|
|
|
|
//Nom de l'axe
|
|
label(scale(0.9)*rotate(90)*libelley,(pointO.x-(log10(lesaxes.max.y)+3)*1.5*lesaxes.tailley,lesaxes.max.y),SW);}
|
|
}
|
|
|
|
void diagramme_baton(real[] xi,real[] ni,pen p1=0.5bp+blue,pair origine=(0,0),bool affichey=true,string nomdesx,string nomdesy="Effectif"){
|
|
|
|
real largeur=0.1;
|
|
real hauteur=0;
|
|
for(int i=0; i < ni.length;++i){hauteur=hauteur+xi[i];
|
|
filldraw(((xi[i]-largeur),origine.y)--((xi[i]-largeur),ni[i])--((xi[i]+largeur),ni[i])--((xi[i]+largeur),origine.y)--cycle,p1);}
|
|
|
|
traceaxe(calculaxes(xi,ni,origine),origine,nomdesx,nomdesy);
|
|
}
|
|
|
|
|
|
void diagramme_barre(string[] modalite,real[] ni,pen p1=0.5bp+blue,pair origine=(0,0),bool affichey=true,string nomdesy="Effectif"){
|
|
|
|
//tracé des axes
|
|
real[] tbxi;
|
|
for (int i=0;i<modalite.length;++i){tbxi[i]=i+1;}
|
|
axes ax=calculaxes(tbxi,ni,origine);
|
|
ax.graduationx=(abs(ax.max.x)+abs(ax.min.x))*2;
|
|
ax.numerotationx=(abs(ax.max.x)+abs(ax.min.x))*2;
|
|
ax.max=(ax.max.x+0.5,ax.max.y);
|
|
traceaxe(ax,true,false,origine,"",nomdesy);
|
|
|
|
//les rectangles
|
|
real largeur=0.2;
|
|
for(int i=0; i < ni.length;++i)
|
|
{filldraw(((i+1-largeur),origine.y)--((i+1-largeur),ni[i])--
|
|
((i+1+largeur),ni[i])--((i+1+largeur),origine.y)--cycle,p1);
|
|
label(scale(0.8)*rotate(90)*modalite[i],(i+1,origine.y),S);}
|
|
}
|
|
|
|
void histogramme(real[] tabxi,real[] tabni,bool axedesy=false,bool unitedaire =true,real uniteaire,pair origine=(0,0),string libellecaractere,string libelleunite="effectif \'egal \`a "+format(uniteaire),pen p1=.8lightgreen,pen p2=1bp+blue){
|
|
//calculs
|
|
// Une variable utile pour déterminer la plus petite amplitude :
|
|
real largeurunite=abs(tabxi[1]-tabxi[0]);
|
|
// ... et une autre pour le numéro de classe correspondant :
|
|
int iclasse=0;
|
|
|
|
// Calcul des hauteurs (et de la plus petite amplitude de classe) :
|
|
real[] tabhi;
|
|
for(int i=0; i < tabni.length; ++i){
|
|
tabhi[i]=tabni[i]/(tabxi[i+1]-tabxi[i]);
|
|
if (largeurunite>abs(tabxi[i+1]-tabxi[i])) {largeurunite=abs(tabxi[i+1]-tabxi[i]);iclasse=i;}}
|
|
|
|
// Hauteur du rectangle le plus haut pour placer l'unité au dessus.
|
|
real hauteurmaxi=max(tabhi);
|
|
|
|
// Calcul de la hauteur à donner au rectangle unité d'aire
|
|
real hauteurunite=(uniteaire/tabni[iclasse])*tabhi[iclasse];
|
|
|
|
//tracé des axes
|
|
axes ax=calculaxes(tabxi,tabhi,origine);
|
|
traceaxe(ax,axedesy,true,origine,libellecaractere,"hauteurs");
|
|
|
|
// Hauteur du rectangle le plus haut pour placer l'unité au dessus.
|
|
real hauteurmaxi=max(tabhi);
|
|
|
|
// Calcul de la hauteur à donner au rectangle unité d'aire
|
|
real hauteurunite=(uniteaire/tabni[iclasse])*tabhi[iclasse];
|
|
|
|
// Tracé de l'histogramme
|
|
for (int i=0; i < tabhi.length;++i){
|
|
//tracé d'un rectangle
|
|
filldraw(box((tabxi[i],origine.y),(tabxi[i+1],tabhi[i])),p1);
|
|
draw((tabxi[i],origine.y)--(tabxi[i],tabhi[i])--(tabxi[i+1],tabhi[i])--(tabxi[i+1],origine.y),p2);}
|
|
|
|
// Tracé de l'unité d'aire et son étiquette
|
|
if (unitedaire) {filldraw(box((0.05*ax.max.x,1.1*hauteurmaxi),(0.05*ax.max.x+largeurunite,1.1*hauteurmaxi+hauteurunite)),p1,p2);
|
|
label(scale(0.8)*libelleunite,(0.05*ax.max.x+1.2*largeurunite,1.1*hauteurmaxi+0.5*hauteurunite),E);}
|
|
|
|
|
|
}
|
|
|
|
void diagrammecirculaire(string[] tabmod,real[] tabeff,string nomdugraph=""){
|
|
|
|
real[] tabangle,tabanglecumule,tabanglelabel;
|
|
tabanglecumule[0]=0;
|
|
int n=tabeff.length;
|
|
for(int i=0; i<n; ++i) {
|
|
tabangle[i]=tabeff[i]*360/sum(tabeff);
|
|
tabanglecumule[i+1]=tabanglecumule[i]+tabangle[i];
|
|
tabanglelabel[i]=tabanglecumule[i]+tabangle[i]/2;
|
|
path secteur=(0,0)--arc((0,0),1,tabanglecumule[i],tabanglecumule[i+1])--cycle;
|
|
filldraw(secteur,couleur[i]);
|
|
label(scale(0.9)*tabmod[i],(1.6,(i+1)/n),E);
|
|
filldraw((1.4,(i+0.9)/n)--(1.4,(i+1.2)/n)--(1.6,(i+1.2)/n)--(1.6,(i+0.9)/n)--cycle,couleur[i]);}
|
|
label(nomdugraph,(0.5,-1.2),S);}
|
|
|
|
|