/*************************************************************************************************************************************/
/* */
/* M I S E E N E V I D E N C E D E C L A S S E S D ' E Q U I V A L E N C E */
/* D A N S U N F I C H I E R N U M E R I Q U E */
/* D E P R E F E R E N C E M O N O T O N E E T M E M E C R O I S S A N T : */
/* */
/* */
/* Definition : */
/* */
/* Le principe est, en supposant le fichier */
/* Argument monotone croissant, de regrouper */
/* les valeurs successives en classes d'equivalence */
/* de valeurs proches (voir a ce propos */
/* 'v $xrCC/EImAgEs.04$vv$Y ClassesEquivalence.01.X' */
/* pour un exemple d'utilisation). */
/* */
/* Ainsi, par exemple, avec un epsilon egal a 0.2, */
/* voici (a gauche) les deux classes d'equivalence d'un */
/* fichier (a droite) : */
/* */
/* +1.0 -> +1 */
/* +1.2 +1 */
/* +1.4 +1 */
/* +1.6 +1 */
/* */
/* +2.0 -> +2 */
/* +2.2 +2 */
/* +2.4 +2 */
/* +2.6 +2 */
/* */
/* (voir l'usage qui en est fait dans 'v $xrCC/EImAgEs.04$vv$Y .xrv.ClassesEquivalence.01.X'). */
/* */
/* */
/* Author of '$xrv/ClassesEquivalence.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20160705092441). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L E U R S I M P L I C I T E S D E S P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define COMPATIBILITE_20160706 \
FAUX \
/* Permet de faire des calculs compatibles a ceux faits anterieurement au 20160706124204... */
#define EPSILON_DE_DEFINITION_DES_CLASSES_D_EQUIVALENCE \
FRA10(FRA10(FU)) \
/* Epsilon de definition des classes d'equivalence. */
#define AIDER_AU_CHOIX_DE_L_EPSILON_DE_DEFINITION_DES_CLASSES_D_EQUIVALENCE \
FAUX \
/* Afin d'aider le choix de l'epsilon de definition des classes d'equivalence. */
#define VERIFIER_QUE_LE_FICHIER_EST_MONOTONE_CROISSANT \
FAUX \
/* Afin de verifier que le fichier est monotone croissant (introduit le 20160706101911). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#include xrv/ARITHMET.1d.I"
#define FORMATER_LE_RESULTAT_DE_L_OPERATION_SUR_LES_VALEURS_COURANTES \
VRAI
#include xrv/ARITHMET.21.I"
#include xrv/champs_5.41.I"
#define VALEUR_IMPLICITE \
FZERO
gGENERATION_D_UN_FICHIER(fichier_des_valeurs,liste_des_valeurs);
/* Definition en memoire du fichier. */
#define ELEMENT_DU_FICHIER(index) \
gELEMENT_DU_FICHIER(liste_des_valeurs,index) \
/* Acces a un element courant du fichier. */
gGENERATION_D_UN_FICHIER(fichier_intermediaire_des_valeurs,liste_intermediaire_des_valeurs);
/* Definition en memoire du fichier intermediaire. */
#define ELEMENT_DU_FICHIER_INTERMEDIAIRE(index) \
gELEMENT_DU_FICHIER(liste_intermediaire_des_valeurs,index) \
/* Acces a un element courant du fichier intermediaire. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M I S E E N E V I D E N C E D E C L A S S E S D ' E Q U I V A L E N C E */
/* D A N S U N F I C H I E R N U M E R I Q U E */
/* D E P R E F E R E N C E M O N O T O N E E T M E M E C R O I S S A N T : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
#include xrv/ARITHMET.22.I"
#include xci/valeurs.03.I"
DEFV(Logical,INIT(compatibilite_20160706,COMPATIBILITE_20160706));
/* Permet de faire des calculs compatibles a ceux faits anterieurement au 20160706124204... */
DEFV(Float,INIT(epsilon_de_definition_des_classes_d_equivalence,EPSILON_DE_DEFINITION_DES_CLASSES_D_EQUIVALENCE));
/* Epsilon de definition des classes d'equivalence. */
DEFV(Logical,INIT(aider_au_choix_de_l_epsilon_de_definition_des_classes_d_equivalence
,AIDER_AU_CHOIX_DE_L_EPSILON_DE_DEFINITION_DES_CLASSES_D_EQUIVALENCE
)
);
/* Afin d'aider le choix de l'epsilon de definition des classes d'equivalence. */
DEFV(Logical,INIT(verifier_que_le_fichier_est_monotone_croissant,VERIFIER_QUE_LE_FICHIER_EST_MONOTONE_CROISSANT));
/* Afin de verifier que le fichier est monotone croissant (introduit le 20160706101911). */
/*..............................................................................................................................*/
#include xrv/champs_5.1A.I"
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20160706=",compatibilite_20160706);
PROCESS_ARGUMENT_I("nombre_elements=""ne=",nombre_d_elements
,BLOC(VIDE;)
,BLOC(Bblock
PRINT_AVERTISSEMENT("'ne=' doit etre defini avant toute entree de fichiers");
Eblock
)
);
PROCESS_ARGUMENTS_DE_DEFINITION_DES_FICHIERS_01;
PROKESF_ARGUMENT_FICHIER("fichier="
,fichier_des_valeurs
,liste_des_valeurs
,VALEUR_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
GET_ARGUMENT_F("epsilon_classes_equivalence=""ece=""eps=",epsilon_de_definition_des_classes_d_equivalence);
GET_ARGUMENT_L("aider=",aider_au_choix_de_l_epsilon_de_definition_des_classes_d_equivalence);
GET_ARGUMENT_L("verifier_monotone_croissant=""verifier=""vmc="
,verifier_que_le_fichier_est_monotone_croissant
);
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_3;
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
)
);
iGENERATION_D_UN_FICHIER(liste_intermediaire_des_valeurs,VALEUR_IMPLICITE);
begin_nouveau_block
Bblock
DEFV(Float,INIT(valeur_n_0_,FLOT__UNDEF));
/* Valeur courante dans le fichier. */
DEFV(Float,INIT(valeur_n_m1,FLOT__UNDEF));
/* Valeur precedente dans le fichier. */
DEFV(Float,INIT(classe_d_equivalence_courante,FLOT__UNDEF));
/* Classe d'equivalence courante... */
DoIn(index
,PREMIER_ELEMENT_D_UN_FICHIER
,DERNIER_ELEMENT_D_UN_FICHIER
,I
)
Bblock
DEFV(Float,INIT(valeur_a_editer,FLOT__UNDEF));
/* Valeur courante a editer... */
EGAL(valeur_n_0_,ELEMENT_DU_FICHIER(index));
/* Recuperation de la valeur courante dans le fichier. */
Test(IFEQ(index,PREMIER_ELEMENT_D_UN_FICHIER))
Bblock
EGAL(classe_d_equivalence_courante,valeur_n_0_);
/* Cas de la premiere classe d'equivalence... */
EGAL(valeur_a_editer,valeur_n_0_);
Eblock
ATes
Bblock
DEFV(Float,INIT(discriminateur,FLOT__UNDEF));
/* Discriminateur d'appartenance a la classe d'equivalence courante. Au passage, on notera */
/* qu'il est evidemment preferable que le fichier soit trie (de facon croissante est le */
/* mieux). */
Test(IL_FAUT(verifier_que_le_fichier_est_monotone_croissant))
/* Validation introduite le 20160706101911... */
Bblock
Test(IFLT(valeur_n_0_,valeur_n_m1))
Bblock
PRINT_ATTENTION("le fichier n'est pas monotone croissant");
CAL1(Prer2("(%+.^^^ < %+.^^^)\n",valeur_n_0_,valeur_n_m1));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
EGAL(discriminateur,DIVI(SOUA(valeur_n_0_,valeur_n_m1),valeur_n_m1));
/* Le 20160706095627 : */
/* */
/* valeur_n_m1 */
/* */
/* a ete remplace par : */
/* */
/* MIN2(valeur_n_0_,valeur_n_m1) */
/* */
/* mais, malheureusement, cela ne suiffit pas a obtenir les memes resultats pour un fichier */
/* monotone croissant et sa version monotone de croissant... */
/* */
/* Le 20160706111722, je reviens finalement en arriere car, en effet, c'est plus logique... */
Test(IFLE(discriminateur,epsilon_de_definition_des_classes_d_equivalence))
Bblock
/* Cas ou la valeur courante appartient a la classe d'equivalence courante : */
Test(IL_FAUT(compatibilite_20160706))
Bblock
EGAL(valeur_n_0_,valeur_n_m1);
/* Dans le cas de la compatibilite, la mesure de voisinnage se fait par rapport au */
/* debut de la classe d'equivalence courante. L'inconvenient est que plus on s'eloigne */
/* de son debut, plus le discriminateur augmente ce qui fait donc changer artificiellement */
/* et frequemment de classe d'equivalence... */
Eblock
ATes
Bblock
/* Dans le cas "standard", la mesure de voisinnage se fait par rapport a la valeur */
/* precedente (qui se deplace donc du debut vers la fin du fichier lors du processus), */
/* ce qui fait que l'on peut avoir des suites de longueur quelconque de valeurs voisines... */
Eblock
ETes
Eblock
ATes
Bblock
EGAL(classe_d_equivalence_courante,valeur_n_0_);
/* Cas d'une nouvelle classe d'equivalence... */
Eblock
ETes
EGAL(valeur_a_editer,classe_d_equivalence_courante);
Test(IL_FAUT(aider_au_choix_de_l_epsilon_de_definition_des_classes_d_equivalence))
Bblock
EGAL(valeur_a_editer,discriminateur);
/* On notera que dans ce cas la valeur donnee a 'valeur_a_editer' est ignoree. On ne peut */
/* faire autrement a cause de l'option 'compatibilite_20160706' ci-dessus qui modifie alors */
/* la valeur de 'valeur_n_0_' et donc le prochain 'discriminateur'... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
EGAL(ELEMENT_DU_FICHIER_INTERMEDIAIRE(index),valeur_a_editer);
EGAL(valeur_n_m1,valeur_n_0_);
Eblock
EDoI
Eblock
end_nouveau_block
DoIn(index
,PREMIER_ELEMENT_D_UN_FICHIER
,DERNIER_ELEMENT_D_UN_FICHIER
,I
)
Bblock
Test(IFOU(IFGT(index,PREMIER_ELEMENT_D_UN_FICHIER)
,IFET(IFEQ(index,PREMIER_ELEMENT_D_UN_FICHIER)
,IL_NE_FAUT_PAS(aider_au_choix_de_l_epsilon_de_definition_des_classes_d_equivalence)
)
)
)
Bblock
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(ELEMENT_DU_FICHIER_INTERMEDIAIRE(index));
/* Introduit sous cette forme le 20160804093309... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
lGENERATION_D_UN_FICHIER(liste_intermediaire_des_valeurs,VALEUR_IMPLICITE);
lGENERATION_D_UN_FICHIER(liste_des_valeurs,VALEUR_IMPLICITE);
RETU_Commande;
Eblock
ECommande