/*************************************************************************************************************************************/
/* */
/* O U T I L S D E M E S U R E D E B A S N I V E A U P O U R */
/* L ' E T U D E D E L A C O M P L E X I T E S T R U C T U R E L L E : */
/* */
/* */
/* Author of '$xrC/OperateursComptage$vv$I' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 20151116114732). */
/* */
/*************************************************************************************************************************************/
#define COMPTAGE_NON_ENCORE_IMPLEMENTE(operation) \
operation \
/* Afin de reperer des operations non encore implementees au niveau comptage. On notera */
/* une forme tres simple (sans "{", "}" ou encore ";") destinee a pouvoir s'inserer */
/* n'importe ou... */
#define PointeurTypeImage \
TypeImage *
#ifndef Entier
# define Entier \
long int
# define LongInt \
Entier \
/* A cause de 'v $xrC/CompressionDeCompressionRunLengthEncoding.12$vv$I LongInt' qui fait */ \
/* que 'LongInt' peut etre defini par 'EntierCourt'... */
#else
#endif
#define PointeurEntier \
Entier *
/* Definition des types utiles au comptage... */
#define FONCTION_c(compteur,ponderation,PonderationInitiale) \
double ponderation=PonderationInitiale; \
double compteur=0;
/* Definition d'un compteur (reference ou pas par une fonction...) et de sa ponderation... */
#define FONCTION_g(operation,compteur,ponderation,PonderationInitiale) \
{ \
compteur++; \
return(operation); \
} \
/* Definition du corps d'une fonction. */
#define FONCTION_1Arg_(NomFonction,TypeArgf,TypeArg1,operation,compteur,ponderation,PonderationInitiale) \
FONCTION_c(compteur,ponderation,PonderationInitiale); \
TypeArgf NomFonction(TypeArg1 Arg1) \
FONCTION_g(operation,compteur ,ponderation,PonderationInitiale)
/* Definition des fonctions a un argument. */
#define FONCTION_2Args(NomFonction,TypeArgf,TypeArg1,TypeArg2,operation,compteur,ponderation,PonderationInitiale) \
FONCTION_c(compteur,ponderation,PonderationInitiale); \
TypeArgf NomFonction(TypeArg1 Arg1,TypeArg2 Arg2) \
FONCTION_g(operation,compteur,ponderation,PonderationInitiale)
/* Definition des fonctions a deux arguments. */
#define FONCTION_3Args(NomFonction,TypeArgf,TypeArg1,TypeArg2,TypeArg3,operation,compteur,ponderation,PonderationInitiale) \
FONCTION_c(compteur,ponderation,PonderationInitiale); \
TypeArgf NomFonction(TypeArg1 Arg1,TypeArg2 Arg2,TypeArg3 Arg3) \
FONCTION_g(operation,compteur,ponderation,PonderationInitiale)
/* Definition des fonctions a trois arguments. */
FONCTION_1Arg_(mNEUT,Entier,Entier,NEUT(Arg1),compteur_mNEUT,ponderation_mNEUT,1)
FONCTION_1Arg_(mNEGA,Entier,Entier,NEGA(Arg1),compteur_mNEGA,ponderation_mNEGA,1)
FONCTION_1Arg_(mABSO,Entier,Entier,ABSO(Arg1),compteur_mABSO,ponderation_mABSO,1)
FONCTION_1Arg_(mDECR,Entier,PointeurEntier,(*Arg1)--,compteur_mDECR,ponderation_mDECR,0)
FONCTION_1Arg_(mINCR,Entier,PointeurEntier,(*Arg1)++,compteur_mINCR,ponderation_mINCR,0)
/* Definition des operateurs a un argument. */
/* */
/* A priori, on a : */
/* */
/* mDECR = mDECRs */
/* mINCR = mINCRs */
/* */
/* D'ailleurs, les ponderations de {mDECRs,mINCRs} sont nulles a priori... */
FONCTION_c(compteur_mINCRs,ponderation_mINCRs,1);
#define mINCRs(Arg1) \
{ \
compteur_mINCRs++; \
mINCR(&Arg1); \
}
FONCTION_c(compteur_mDECRs,ponderation_mDECRs,1);
#define mDECRs(Arg1) \
{ \
compteur_mDECRs++; \
mDECR(&Arg1); \
}
#ifdef CHAR
/* En fait la definition de 'mEGALc(...)' ne sert que pour les fichiers '$I' du type */
/* 'v $xrC/CompressionDeCompression_BurrowsWheeler.01$vv$I CHAR'... */
FONCTION_2Args(mEGALc,CHAR,CHAR *,CHAR,(*(Arg1) = (Arg2)),compteur_mEGALc,ponderation_mEGALc,1)
#else
FONCTION_c(compteur_mEGALc,ponderation_mEGALc,0);
#endif
FONCTION_c(compteur_mEGALp,ponderation_mEGALp,1);
#define mEGALp(Arg1,Arg2) \
{ \
compteur_mEGALp++; \
Arg1 = Arg2; \
}
FONCTION_2Args(mEGALe,Entier,PointeurEntier,Entier,(*(Arg1) = (Arg2)),compteur_mEGALe,ponderation_mEGALe,1)
FONCTION_2Args(mEGALi,Entier,PointeurTypeImage,Entier,(*(Arg1) = (Arg2)),compteur_mEGALi,ponderation_mEGALi,1)
/* ATTENTION : a priori 'compteur_mEGALi' et 'compteur_mEGALv' donnent la meme valeur mais */
/* il n'en n'est pas de meme avec 'compteur_mEGALe' et 'compteur_mEGALs' a cause des */
/* definitions de 'DoIn(...)' et 'DoDe(...)' : */
/* */
/* mEGALe = mEGALs+DoIn+DoDe */
/* mEGALi = mEGALv */
/* */
/* D'ailleurs, les ponderations de {mEGALs,mEGALv} sont nulles a priori... */
FONCTION_c(compteur_mEGALs,ponderation_mEGALs,0);
#define mEGALs(Arg1,Arg2) \
{ \
compteur_mEGALs++; \
mEGALe(&Arg1,Arg2); \
}
FONCTION_c(compteur_mEGALv,ponderation_mEGALv,0);
#define mEGALv(Arg1,Arg2) \
{ \
compteur_mEGALv++; \
mEGALi(&Arg1,*Arg2); \
}
/* Affectations Scalaire et Vectorielle (introduites le 20151226085705)... */
FONCTION_2Args(mIFEQ,Entier,Entier,Entier,IFEQ(Arg1,Arg2),compteur_mIFEQ,ponderation_mIFEQ,1)
FONCTION_2Args(mIFNE,Entier,Entier,Entier,IFNE(Arg1,Arg2),compteur_mIFNE,ponderation_mIFNE,1)
FONCTION_2Args(mIFLE,Entier,Entier,Entier,IFLE(Arg1,Arg2),compteur_mIFLE,ponderation_mIFLE,1)
FONCTION_2Args(mIFLT,Entier,Entier,Entier,IFLT(Arg1,Arg2),compteur_mIFLT,ponderation_mIFLT,1)
FONCTION_2Args(mIFGE,Entier,Entier,Entier,IFGE(Arg1,Arg2),compteur_mIFGE,ponderation_mIFGE,1)
FONCTION_2Args(mIFGT,Entier,Entier,Entier,IFGT(Arg1,Arg2),compteur_mIFGT,ponderation_mIFGT,1)
FONCTION_2Args(mOUIN,Entier,Entier,Entier,gOUIN(Arg1,Arg2),compteur_mOUIN,ponderation_mOUIN,1)
FONCTION_2Args(mOUEX,Entier,Entier,Entier,gOUEX(Arg1,Arg2),compteur_mOUEX,ponderation_mOUEX,1)
FONCTION_2Args(mETLO,Entier,Entier,Entier,gETLO(Arg1,Arg2),compteur_mETLO,ponderation_mETLO,1)
FONCTION_2Args(mDECD,Entier,Entier,Entier,gDECD(Arg1,Arg2),compteur_mDECD,ponderation_mDECD,1)
FONCTION_2Args(mDECG,Entier,Entier,Entier,gDECG(Arg1,Arg2),compteur_mDECG,ponderation_mDECG,1)
FONCTION_2Args(mADD2,Entier,Entier,Entier,gADD2(Arg1,Arg2),compteur_mADD2,ponderation_mADD2,1)
FONCTION_2Args(mSOUS,Entier,Entier,Entier,gSOUS(Arg1,Arg2),compteur_mSOUS,ponderation_mSOUS,1)
FONCTION_2Args(mMUL2,Entier,Entier,Entier,gMUL2(Arg1,Arg2),compteur_mMUL2,ponderation_mMUL2,1)
FONCTION_2Args(mDIVI,Entier,Entier,Entier,gDIVI(Arg1,Arg2),compteur_mDIVI,ponderation_mDIVI,1)
FONCTION_2Args(mREST,Entier,Entier,Entier,gREST(Arg1,Arg2),compteur_mREST,ponderation_mREST,1)
FONCTION_2Args(mMIN2,Entier,Entier,Entier,MIN2(Arg1,Arg2),compteur_mMIN2,ponderation_mMIN2,1)
FONCTION_2Args(mMAX2,Entier,Entier,Entier,MAX2(Arg1,Arg2),compteur_mMAX2,ponderation_mMAX2,1)
#ifdef CHAR
FONCTION_2Args(mINDXc,CHAR *,CHAR *,Entier,(CHAR *)((Arg1)+(Arg2)),compteur_mINDXc,ponderation_mINDXc,1)
/* En fait la definition de 'mEGALc(...)' ne sert que pour les fichiers '$I' du type */
/* 'v $xrC/CompressionDeCompression_BurrowsWheeler.01$vv$I CHAR'... */
#else
FONCTION_c(compteur_mINDXc,ponderation_mINDXc,0);
#endif
FONCTION_2Args(mINDXe,PointeurEntier,PointeurEntier,Entier,(PointeurEntier)((Arg1)+(Arg2)),compteur_mINDXe,ponderation_mINDXe,1)
FONCTION_2Args(mINDXi
,PointeurTypeImage
,PointeurTypeImage
,Entier
,(PointeurTypeImage)((Arg1)+(Arg2))
,compteur_mINDXi
,ponderation_mINDXi,1
)
/* Definition des operateurs a deux arguments. */
FONCTION_3Args(mCOND,Entier,Entier,Entier,Entier,COND(Arg1,Arg2,Arg3),compteur_mCOND,ponderation_mCOND,1)
/* Definition des operateurs a trois arguments. */
FONCTION_c(compteur_Test,ponderation_Test,1);
FONCTION_c(compteur_Test_VRAI,ponderation_Test_VRAI,0);
FONCTION_c(compteur_Test_FAUX,ponderation_Test_FAUX,0);
#define Test(conditions) \
{ \
compteur_Test++; \
if (conditions) \
{ \
compteur_Test_VRAI++;
#define ATes \
} \
else \
{ \
{ \
{ \
compteur_Test_FAUX++;
#define ETes \
} \
} \
} \
}
/* Definition des tests : sont comptes d'une part les tests et d'autre part la nature */
/* 'VRAI' ou 'FAUX' de la branche suivie. */
FONCTION_c(compteur_Choi,ponderation_Choi,1);
FONCTION_c(compteur_Case,ponderation_Case,0);
FONCTION_c(compteur_Defo,ponderation_Defo,0);
#define Choi(expression) \
{ \
{ \
compteur_Choi++; \
switch(expression)
#define Case(constante) \
case constante: \
{ \
compteur_Case++;
#define ECas \
break; \
}
#define Defo \
default : \
{ \
compteur_Defo++;
#define EDef \
break; \
} \
}
#define ECho \
}
/* Definition des choix. */
#define Bouc(initialisation,test_de_continuation,action_iterative) \
for (initialisation ; test_de_continuation ; action_iterative)
FONCTION_c(compteur_DoIn,ponderation_DoIn,1);
FONCTION_c(compteur_DoIn_repetition,ponderation_DoIn_repetition,1);
#define DoIn(index,minimum_index,maximum_index) \
{ \
compteur_DoIn++; \
Bouc(mEGALe(&index,minimum_index),mIFLE(index,maximum_index),mINCR(&index)) \
{ \
compteur_DoIn_repetition++;
#define EDoI \
} \
}
FONCTION_c(compteur_DoDe,ponderation_DoDe,1);
FONCTION_c(compteur_DoDe_repetition,ponderation_DoDe_repetition,1);
#define DoDe(index,minimum_index,maximum_index) \
{ \
compteur_DoDe++; \
Bouc(mEGALe(&index,maximum_index),mIFGE(index,minimum_index),mDECR(&index)) \
{ \
compteur_DoDe_repetition++;
#define EDoD \
} \
}
/* Definition des boucles d'iterations sur comptage : sont comptes d'une part d'une facon */
/* globale les boucles et d'autre part le nombre d'iterations ("repetition"s) effectuees. */
/* */
/* ATTENTION, il est impossble d'ecrire : */
/* */
/* Bouc(mEGALs(index,minimum_index),mIFLE(index,maximum_index),mINCR(&index)) */
/* */
/* et : */
/* */
/* Bouc(mEGALs(index,maximum_index),mIFGE(index,minimum_index),mDECR(&index)) */
/* */
/* a cause de la progression du compteur 'compteur_mEGALs' dans 'mEGALs(...)'... */
FONCTION_c(compteur_Tant,ponderation_Tant,1);
FONCTION_c(compteur_Tant_repetition,ponderation_Tant_repetition,1);
#define Tant(conditions) \
{ \
compteur_Tant++; \
while (conditions) \
{ \
compteur_Tant_repetition++;
#define ETan \
} \
}
/* Definition des boucles d'iterations sur condition : sont comptes d'une part d'une facon */
/* globale les boucles et d'autre part le nombre d'iterations ("repetition"s) effectuees. */
FONCTION_c(compteur_CALL,ponderation_CALL,1);
#define CALL(fonction) \
{ \
compteur_CALL++; \
fonction; \
}
FONCTION_c(compteur_CALLs,ponderation_CALLs,1);
#define CALLs(fonction) \
{ \
compteur_CALLs++; \
fonction; \
}
/* Appel d'une fonction "locale" et d'une fonction "Systeme"... */
FONCTION_c(compteur_gSTORE_IMAGE_PLAN,ponderation_gSTORE_IMAGE_PLAN,1);
#define mgSTORE_IMAGE_PLAN(ImageDecompactee,x,y,valeur); \
{ \
compteur_gSTORE_IMAGE_PLAN++; \
gSTORE_IMAGE_PLAN(ImageDecompactee,x,y,valeur); \
} \
/* Definition de la mise en place d'un point de l'image decompressee. */
#define INITIALISATION_DES_COMPTEURS \
{ \
compteur_CALL=0; \
compteur_CALLs=0; \
compteur_Case=0; \
compteur_Choi=0; \
compteur_Defo=0; \
compteur_DoDe=0; \
compteur_DoDe_repetition=0; \
compteur_DoIn=0; \
compteur_DoIn_repetition=0; \
compteur_Tant=0; \
compteur_Tant_repetition=0; \
compteur_Test=0; \
compteur_Test_FAUX=0; \
compteur_Test_VRAI=0; \
compteur_gSTORE_IMAGE_PLAN=0; \
compteur_mABSO=0; \
compteur_mADD2=0; \
compteur_mCOND=0; \
compteur_mDECD=0; \
compteur_mDECG=0; \
compteur_mDECR=0; \
compteur_mDECRs=0; \
compteur_mDIVI=0; \
compteur_mEGALc=0; \
compteur_mEGALe=0; \
compteur_mEGALi=0; \
compteur_mEGALp=0; \
compteur_mEGALs=0; \
compteur_mEGALv=0; \
compteur_mETLO=0; \
compteur_mIFEQ=0; \
compteur_mIFGE=0; \
compteur_mIFGT=0; \
compteur_mIFLE=0; \
compteur_mIFLT=0; \
compteur_mIFNE=0; \
compteur_mINCR=0; \
compteur_mINCRs=0; \
compteur_mINDXc=0; \
compteur_mINDXe=0; \
compteur_mINDXi=0; \
compteur_mMAX2=0; \
compteur_mMIN2=0; \
compteur_mMUL2=0; \
compteur_mNEGA=0; \
compteur_mNEUT=0; \
compteur_mOUEX=0; \
compteur_mOUIN=0; \
compteur_mREST=0; \
compteur_mSOUS=0; \
} \
/* Initialisation des differents compteurs. */
#define CUMUL_DES_COMPTEURS(CumulDesCompteurs) \
{ \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_CALL*compteur_CALL); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_CALLs*compteur_CALLs); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Case*compteur_Case); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Choi*compteur_Choi); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Defo*compteur_Defo); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_DoDe*compteur_DoDe); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_DoDe_repetition*compteur_DoDe_repetition); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_DoIn*compteur_DoIn); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_DoIn_repetition*compteur_DoIn_repetition); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Tant*compteur_Tant); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Tant_repetition*compteur_Tant_repetition); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Test*compteur_Test); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Test_FAUX*compteur_Test_FAUX); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_Test_VRAI*compteur_Test_VRAI); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_gSTORE_IMAGE_PLAN*compteur_gSTORE_IMAGE_PLAN); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mABSO*compteur_mABSO); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mADD2*compteur_mADD2); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mCOND*compteur_mCOND); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mDECD*compteur_mDECD); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mDECG*compteur_mDECG); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mDECR*compteur_mDECR); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mDECRs*compteur_mDECRs); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mDIVI*compteur_mDIVI); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGALc*compteur_mEGALc); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGALe*compteur_mEGALe); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGALi*compteur_mEGALi); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGALp*compteur_mEGALp); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGALs*compteur_mEGALs); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGALv*compteur_mEGALv); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mETLO*compteur_mETLO); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mIFEQ*compteur_mIFEQ); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mIFGE*compteur_mIFGE); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mIFGT*compteur_mIFGT); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mIFLE*compteur_mIFLE); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mIFLT*compteur_mIFLT); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mIFNE*compteur_mIFNE); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mINCR*compteur_mINCR); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mINCRs*compteur_mINCRs); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mINDXc*compteur_mINDXc); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mINDXe*compteur_mINDXe); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mINDXi*compteur_mINDXi); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mMAX2*compteur_mMAX2); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mMIN2*compteur_mMIN2); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mMUL2*compteur_mMUL2); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mNEGA*compteur_mNEGA); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mNEUT*compteur_mNEUT); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mOUEX*compteur_mOUEX); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mOUIN*compteur_mOUIN); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mREST*compteur_mREST); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mSOUS*compteur_mSOUS); \
} \
/* Cumul pondere des differents compteurs... */
#define EDITION_DES_COMPTEURS \
{ \
fprintf(stderr,"\n"); \
fprintf(stderr,"ATTENTION : 'mEGALe' et 'mEGALs' ne sont pas independants.\n"); \
fprintf(stderr,"ATTENTION : 'mEGALi' et 'mEGALv' ne sont pas independants.\n"); \
fprintf(stderr,"\n"); \
\
fprintf(stderr,"CALL=%.0f\n",compteur_CALL); \
fprintf(stderr,"CALLs=%.0f\n",compteur_CALLs); \
fprintf(stderr,"Case=%.0f\n",compteur_Case); \
fprintf(stderr,"Choi=%.0f\n",compteur_Choi); \
fprintf(stderr,"Defo=%.0f\n",compteur_Defo); \
fprintf(stderr,"DoDe=%.0f\n",compteur_DoDe); \
fprintf(stderr,"DoDe_repetition=%.0f\n",compteur_DoDe_repetition); \
fprintf(stderr,"DoIn=%.0f\n",compteur_DoIn); \
fprintf(stderr,"DoIn_repetition=%.0f\n",compteur_DoIn_repetition); \
fprintf(stderr,"Tant=%.0f\n",compteur_Tant); \
fprintf(stderr,"Tant_repetition=%.0f\n",compteur_Tant_repetition); \
fprintf(stderr,"Test=%.0f\n",compteur_Test); \
fprintf(stderr,"Test_FAUX=%.0f\n",compteur_Test_FAUX); \
fprintf(stderr,"Test_VRAI=%.0f\n",compteur_Test_VRAI); \
fprintf(stderr,"gSTORE_IMAGE_PLAN=%.0f\n",compteur_gSTORE_IMAGE_PLAN); \
fprintf(stderr,"mABSO=%.0f\n",compteur_mABSO); \
fprintf(stderr,"mADD2=%.0f\n",compteur_mADD2); \
fprintf(stderr,"mCOND=%.0f\n",compteur_mCOND); \
fprintf(stderr,"mDECD=%.0f\n",compteur_mDECD); \
fprintf(stderr,"mDECG=%.0f\n",compteur_mDECG); \
fprintf(stderr,"mDECR=%.0f\n",compteur_mDECR); \
fprintf(stderr,"mDECRs=%.0f\n",compteur_mDECRs); \
fprintf(stderr,"mDIVI=%.0f\n",compteur_mDIVI); \
fprintf(stderr,"mEGALc=%.0f\n",compteur_mEGALc); \
fprintf(stderr,"mEGALe=%.0f\n",compteur_mEGALe); \
fprintf(stderr,"mEGALi=%.0f\n",compteur_mEGALi); \
fprintf(stderr,"mEGALp=%.0f\n",compteur_mEGALp); \
fprintf(stderr,"mEGALs=%.0f\n",compteur_mEGALs); \
fprintf(stderr,"mEGALv=%.0f\n",compteur_mEGALv); \
fprintf(stderr,"mETLO=%.0f\n",compteur_mETLO); \
fprintf(stderr,"mIFEQ=%.0f\n",compteur_mIFEQ); \
fprintf(stderr,"mIFGE=%.0f\n",compteur_mIFGE); \
fprintf(stderr,"mIFGT=%.0f\n",compteur_mIFGT); \
fprintf(stderr,"mIFLE=%.0f\n",compteur_mIFLE); \
fprintf(stderr,"mIFLT=%.0f\n",compteur_mIFLT); \
fprintf(stderr,"mIFNE=%.0f\n",compteur_mIFNE); \
fprintf(stderr,"mINCR=%.0f\n",compteur_mINCR); \
fprintf(stderr,"mINCRs=%.0f\n",compteur_mINCRs); \
fprintf(stderr,"mINDXc=%.0f\n",compteur_mINDXc); \
fprintf(stderr,"mINDXe=%.0f\n",compteur_mINDXe); \
fprintf(stderr,"mINDXi=%.0f\n",compteur_mINDXi); \
fprintf(stderr,"mMAX2=%.0f\n",compteur_mMAX2); \
fprintf(stderr,"mMIN2=%.0f\n",compteur_mMIN2); \
fprintf(stderr,"mMUL2=%.0f\n",compteur_mMUL2); \
fprintf(stderr,"mNEGA=%.0f\n",compteur_mNEGA); \
fprintf(stderr,"mNEUT=%.0f\n",compteur_mNEUT); \
fprintf(stderr,"mOUEX=%.0f\n",compteur_mOUEX); \
fprintf(stderr,"mOUIN=%.0f\n",compteur_mOUIN); \
fprintf(stderr,"mREST=%.0f\n",compteur_mREST); \
fprintf(stderr,"mSOUS=%.0f\n",compteur_mSOUS); \
} \
/* Edition des differents compteurs. */