/*************************************************************************************************************************************/
/* */
/* 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/CompressionDeCompression_OperateursComptage.01$vv$I' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 20160129092715). */
/* */
/*************************************************************************************************************************************/
#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 COMPTAGE(expression,compteur) \
((expression)+((int)(0*(compteur++)))) \
/* Afin de compter une certaine expression... */
#define DEFINITION_COMPTEUR(compteur,ponderation,PonderationInitiale) \
double ponderation=PonderationInitiale; \
double compteur=0;
/* Definition d'un compteur (reference ou pas par une fonction...) et de sa ponderation... */
DEFINITION_COMPTEUR(compteur_mNEUT,ponderation_mNEUT,1)
#define mNEUT(Arg1) \
COMPTAGE(NEUT(Arg1),compteur_mNEUT)
DEFINITION_COMPTEUR(compteur_mNEGA,ponderation_mNEGA,1)
#define mNEGA(Arg1) \
COMPTAGE(NEGA(Arg1),compteur_mNEGA)
DEFINITION_COMPTEUR(compteur_mABSO,ponderation_mABSO,1)
#define mABSO(Arg1) \
COMPTAGE(ABSO(Arg1),compteur_mABSO)
DEFINITION_COMPTEUR(compteur_mDECR,ponderation_mDECR,1)
#define mDECR(Arg1) \
COMPTAGE(Arg1 = gSOUS(Arg1,1),compteur_mDECR) \
/* Pour 'mDECR(...)', il y a trois possibilites : */ \
/* */ \
/* ponderation_mDECR=1 Arg1 = gSOUS(Arg1,1) */ \
/* */ \
/* qui compte pour 1 instruction, ou : */ \
/* */ \
/* ponderation_mDECR=0 Arg1 = mSOUS(Arg1,1) */ \
/* */ \
/* qui compte pour 1 instruction, ou encore : */ \
/* */ \
/* ponderation_mDECR=0 mEGAL(Arg1,mSOUS(Arg1,1)) */ \
/* */ \
/* qui compte pour 2 instructions... */
DEFINITION_COMPTEUR(compteur_mINCR,ponderation_mINCR,1)
#define mINCR(Arg1) \
COMPTAGE(Arg1 = gADD2(Arg1,1),compteur_mINCR) \
/* Pour 'mINCR(...)', il y a trois possibilites : */ \
/* */ \
/* ponderation_mINCR=1 Arg1 = gADD2(Arg1,1) */ \
/* */ \
/* qui compte pour 1 instruction, ou : */ \
/* */ \
/* ponderation_mINCR=0 Arg1 = mADD2(Arg1,1) */ \
/* */ \
/* qui compte pour 1 instruction, ou encore : */ \
/* */ \
/* ponderation_mINCR=0 mEGAL(Arg1,mADD2(Arg1,1)) */ \
/* */ \
/* qui compte pour 2 instructions... */
DEFINITION_COMPTEUR(compteur_mEGAL,ponderation_mEGAL,1);
#define mEGAL(Arg1,Arg2) \
Arg1 = COMPTAGE(Arg2,compteur_mEGAL)
DEFINITION_COMPTEUR(compteur_mIFEQ,ponderation_mIFEQ,1)
#define mIFEQ(Arg1,Arg2) \
COMPTAGE(IFEQ(Arg1,Arg2),compteur_mIFEQ)
DEFINITION_COMPTEUR(compteur_mIFNE,ponderation_mIFNE,1)
#define mIFNE(Arg1,Arg2) \
COMPTAGE(IFNE(Arg1,Arg2),compteur_mIFNE)
DEFINITION_COMPTEUR(compteur_mIFLE,ponderation_mIFLE,1)
#define mIFLE(Arg1,Arg2) \
COMPTAGE(IFLE(Arg1,Arg2),compteur_mIFLE)
DEFINITION_COMPTEUR(compteur_mIFLT,ponderation_mIFLT,1)
#define mIFLT(Arg1,Arg2) \
COMPTAGE(IFLT(Arg1,Arg2),compteur_mIFLT)
DEFINITION_COMPTEUR(compteur_mIFGE,ponderation_mIFGE,1)
#define mIFGE(Arg1,Arg2) \
COMPTAGE(IFGE(Arg1,Arg2),compteur_mIFGE)
DEFINITION_COMPTEUR(compteur_mIFGT,ponderation_mIFGT,1)
#define mIFGT(Arg1,Arg2) \
COMPTAGE(IFGT(Arg1,Arg2),compteur_mIFGT)
DEFINITION_COMPTEUR(compteur_mOUIN,ponderation_mOUIN,1)
#define mOUIN(Arg1,Arg2) \
COMPTAGE(gOUIN(Arg1,Arg2),compteur_mOUIN)
DEFINITION_COMPTEUR(compteur_mOUEX,ponderation_mOUEX,1)
#define mOUEX(Arg1,Arg2) \
COMPTAGE(gOUEX(Arg1,Arg2),compteur_mOUEX)
DEFINITION_COMPTEUR(compteur_mETLO,ponderation_mETLO,1)
#define mETLO(Arg1,Arg2) \
COMPTAGE(gETLO(Arg1,Arg2),compteur_mETLO)
DEFINITION_COMPTEUR(compteur_mDECD,ponderation_mDECD,1)
#define mDECD(Arg1,Arg2) \
COMPTAGE(gDECD(Arg1,Arg2),compteur_mDECD)
DEFINITION_COMPTEUR(compteur_mDECG,ponderation_mDECG,1)
#define mDECG(Arg1,Arg2) \
COMPTAGE(gDECG(Arg1,Arg2),compteur_mDECG)
DEFINITION_COMPTEUR(compteur_mADD2,ponderation_mADD2,1)
#define mADD2(Arg1,Arg2) \
COMPTAGE(gADD2(Arg1,Arg2),compteur_mADD2)
DEFINITION_COMPTEUR(compteur_mSOUS,ponderation_mSOUS,1)
#define mSOUS(Arg1,Arg2) \
COMPTAGE(gSOUS(Arg1,Arg2),compteur_mSOUS)
DEFINITION_COMPTEUR(compteur_mMUL2,ponderation_mMUL2,1)
#define mMUL2(Arg1,Arg2) \
COMPTAGE(gMUL2(Arg1,Arg2),compteur_mMUL2)
DEFINITION_COMPTEUR(compteur_mDIVI,ponderation_mDIVI,1)
#define mDIVI(Arg1,Arg2) \
COMPTAGE(gDIVI(Arg1,Arg2),compteur_mDIVI)
DEFINITION_COMPTEUR(compteur_mREST,ponderation_mREST,1)
#define mREST(Arg1,Arg2) \
COMPTAGE(gREST(Arg1,Arg2),compteur_mREST)
DEFINITION_COMPTEUR(compteur_mMIN2,ponderation_mMIN2,1)
#define mMIN2(Arg1,Arg2) \
COMPTAGE(MIN2(Arg1,Arg2),compteur_mMIN2)
DEFINITION_COMPTEUR(compteur_mMAX2,ponderation_mMAX2,1)
#define mMAX2(Arg1,Arg2) \
COMPTAGE(MAX2(Arg1,Arg2),compteur_mMAX2)
DEFINITION_COMPTEUR(compteur_mINDX,ponderation_mINDX,1)
#define mINDX(Arg1,Arg2) \
COMPTAGE(gADD2(Arg1,Arg2),compteur_mINDX)
DEFINITION_COMPTEUR(compteur_mCOND,ponderation_mCOND,1)
#define mCOND(Arg1,Arg2,Arg3) \
COMPTAGE(COND(Arg1,Arg2,Arg3),compteur_mCOND)
DEFINITION_COMPTEUR(compteur_Test,ponderation_Test,1);
DEFINITION_COMPTEUR(compteur_Test_VRAI,ponderation_Test_VRAI,0);
DEFINITION_COMPTEUR(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. */
DEFINITION_COMPTEUR(compteur_Choi,ponderation_Choi,1);
DEFINITION_COMPTEUR(compteur_Case,ponderation_Case,0);
DEFINITION_COMPTEUR(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)
DEFINITION_COMPTEUR(compteur_DoIn,ponderation_DoIn,1);
DEFINITION_COMPTEUR(compteur_DoIn_repetition,ponderation_DoIn_repetition,1);
#define DoIn(index,minimum_index,maximum_index) \
{ \
compteur_DoIn++; \
Bouc(mEGAL(index,minimum_index),mIFLE(index,maximum_index),mINCR(index)) \
{ \
compteur_DoIn_repetition++;
#define EDoI \
} \
}
DEFINITION_COMPTEUR(compteur_DoDe,ponderation_DoDe,1);
DEFINITION_COMPTEUR(compteur_DoDe_repetition,ponderation_DoDe_repetition,1);
#define DoDe(index,minimum_index,maximum_index) \
{ \
compteur_DoDe++; \
Bouc(mEGAL(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. */
DEFINITION_COMPTEUR(compteur_Tant,ponderation_Tant,1);
DEFINITION_COMPTEUR(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. */
DEFINITION_COMPTEUR(compteur_CALL,ponderation_CALL,1);
#define CALL(fonction) \
{ \
compteur_CALL++; \
fonction; \
}
DEFINITION_COMPTEUR(compteur_CALLs,ponderation_CALLs,0);
#define CALLs(fonction) \
{ \
compteur_CALLs++; \
fonction; \
}
/* Appel d'une fonction "locale" et d'une fonction "Systeme"... */
#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_mABSO=0; \
compteur_mADD2=0; \
compteur_mCOND=0; \
compteur_mDECD=0; \
compteur_mDECG=0; \
compteur_mDECR=0; \
compteur_mDIVI=0; \
compteur_mEGAL=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_mINDX=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_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_mDIVI*compteur_mDIVI); \
CumulDesCompteurs = CumulDesCompteurs+(ponderation_mEGAL*compteur_mEGAL); \
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_mINDX*compteur_mINDX); \
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,"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,"mDIVI=%.0f\n",compteur_mDIVI); \
fprintf(stderr,"mEGAL=%.0f\n",compteur_mEGAL); \
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,"mINDX=%.0f\n",compteur_mINDX); \
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. */