/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E V A L E U R S A L E A T O I R E S : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande genere une sequence */
/* de valeurs numeriques flottantes obtenues */
/* par tirage au sort... */
/* */
/* */
/* On notera le 20200913114303 qu'il est */
/* possible de generer des listes aleatoires */
/* croissantes en cumulant les nombres generes */
/* de la facon suivante : */
/* */
/* $xci/valeurs_alea$X (...) | \ */
/* $xrv/accumule.01$X ne=0 fichier== */
/* */
/* et le tour est joue... */
/* */
/* */
/* Author of '$xci/valeurs_alea$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1994??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
@define PRAGMA_CL_____MODULE_NON_OPTIMISABLE
#define CONTROLE_DE_L_ADAPTATION_A_UNE_LOI_DE_DISTRIBUTION_QUELCONQUE__ARGUMENT_palette__PAS_p
/* Introduit le 20110403090032 a cause des arguments '"premiere=""p=""D="' ci-apres... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/substitue.01.I"
/* Introduit le 20110401192032... */
#include xci/sequence.01.I"
#define UTILISER_UN_ESPACE_DE_PARAMETRAGE_TRIDIMENSIONNEL \
VRAI \
/* Doit-on utiliser un espace de parametrage tridimensionnel ('VRAI') ou bidimensionnel */ \
/* ('FAUX') ? Ceci a ete introduit le 20001211162430. */
#define UTILISER_LE_GENERATEUR_A_PERIODICITE_PARAMETRABLE \
FAUX \
/* Doit-on utiliser le generateur a periodicite parametrable ('VRAI') ou l'autre ('FAUX') ? */
#define EDITER_LES_VALEURS_COURANTES_A_LA_FIN \
FAUX \
/* Si 'IL_FAUT(utiliser_le_generateur_a_periodicite_parametrable)' doit-on editer ('VRAI') */ \
/* ou pas ('FAUX') les valeurs courantes en fin de processus ? */ \
/* Ces editions sont destinees a permettre de repartir la ou l'on en est lors d'une future */ \
/* generation de nombres aleatoires. */
#define BORNE_INFERIEURE \
COORDONNEE_BARYCENTRIQUE_MINIMALE
#define BORNE_SUPERIEURE \
COORDONNEE_BARYCENTRIQUE_MAXIMALE
#define GRAINE \
PARE(1789)
#define LE_GENERATEUR_EST_DETERMINISTE \
VRAI
#define EDITER_LA_GRAINE_NON_DETERMINISTE \
FAUX
/* Definition du generateur aleatoire... */
/* */
/* La possibilite de generer des valeurs aleatoires non deterministes a ete introduite */
/* le 20220723120908... */
/* */
/* La possibilite d'editer la gaine lorsque la generation n'est pas deterministe a ete */
/* introduite le 20220724121541... */
#define PERTURBER_LE_GENERATEUR_ALEATOIRE \
FAUX
#define PBORNE_INFERIEURE \
NEGA(FRA10(FRA10(COORDONNEE_BARYCENTRIQUE_MAXIMALE)))
#define PBORNE_SUPERIEURE \
NEUT(FRA10(FRA10(COORDONNEE_BARYCENTRIQUE_MAXIMALE)))
#define PGRAINE \
PARE(1947)
/* Definition du Perturbateur du generateur aleatoire (introduit le 20161125142734)... */
#define FORCER_UNE_VALEUR_PARTICULIERE \
FAUX \
/* Doit-on forcer une valeur particuliere ('VRAI') ou pas ('FAUX') lors de la generation */ \
/* des nombre aleatoires ? */
#define NUMERO_DE_LA_VALEUR_PARTICULIERE_A_FORCER \
MOYE(PREMIERE_IMAGE,DERNIERE_IMAGE) \
/* Numero de la valeur particuliere lorsque l'on doit en forcer une... */
#define VALEUR_PARTICULIERE_A_FORCER \
FZERO \
/* Definition de la valeur particuliere lorsque l'on doit en forcer une... */
#define DEPHASAGE_INITIAL \
ZERO \
/* Nombre de valeurs aleatoires a generer initialement en aveugle de facon a se dephaser */ \
/* dans la liste des valeurs aleatoires generees (introduit le 20021028090331). */
#define NOMBRE_DE_REPETITIONS_POUR_LA_GENERATION_DE_LA_VALEUR_ALEATOIRE \
UN \
/* Nombre de fois que l'on bouclera sur 'GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(...)' */ \
/* pour produire chaque valeur aleatoire (introduit le 20080310141621). */
#define NOMBRE_MAXIMAL_D_ITERATIONS_DE_LA_GENERATION_DE_LA_VALEUR_ALEATOIRE \
INFINI \
/* Nombre maximal d'iterations de generation d'une valeur aleatoire lorsque des contraintes */ \
/* sont a appliquer ('IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions)' ou */ \
/* 'IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)'). */
#define GENERER_UNE_LISTE_DE_VALEURS_LOGIQUES \
FAUX \
/* Faut-il en fait generer des valeurs logiques {FAUX,VRAI} ? Ceci a ete introduit le */ \
/* 20041003103932 pour simplifier cette operation qui pouvait deja se faire "en sept coups". */
#define GENERER_UNE_LISTE_DE_NOMBRES_ENTIERS_SANS_COLLISIONS \
FAUX \
/* Lorque 'IL_FAUT(des_nombres_entiers)', ceux-ci peuvent-ils etre de temps en temps */ \
/* identiques ('FAUX') ou bien ne doit-il pas y avoir de collisions ('VRAI'). */
#define VERIFIER_LA_DISTANCE_ENTRE_DEUX_NOMBRES_CONSECUTIFS \
FAUX \
/* Doit-on verifier que deux nombres aleatoires consecutifs ne sont pas trop proches */ \
/* ('VRAI') ou pas ('FAUX'). */
#define DISTANCE_MINIMALE_ENTRE_DEUX_NOMBRES_CONSECUTIFS \
FZERO \
/* Lorsque 'IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)' donne la distance */ \
/* minimale entre deux nombres aleatoires consecutifs. */
#define DISTANCE_MAXIMALE_ENTRE_DEUX_NOMBRES_CONSECUTIFS \
F_INFINI \
/* Lorsque 'IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)' donne la distance */ \
/* maximale entre deux nombres aleatoires consecutifs (introduit le 20230114134735). */
#define N_EDITER_QUE_LA_VALEUR_MOYENNE_DES_VALEURS_ALEATOIRES_GENEREES \
FAUX \
/* Permet de n'editer que la valeur de la moyenne des nombres aleatoires calcules. Cela */ \
/* permet d'en valider la qualite (introduit le 20030926162513). */
#define EDITER_LE_MESSAGE_DE_LA_BORNE_SUPERIEURE_ENTIERE \
VRAI \
/* Permet de supprimer le message d'erreur concernant la borne superieure lorsqu'elle est */ \
/* entiere et que des nombres entiers sont demandes (introduit le 20020327172426). */
#define EPSILON_DE_CONVERSION_ENTIER_ANTERIEUR_AU_20030926 \
FDU
#define EPSILON_DE_CONVERSION_ENTIER \
FZERO
/* Ceci a ete introduit le 20020307120700 afin de forcer la valeur qui semble */
/* universellement utilisee et ce a la place de la valeur par defaut ('FZERO' dans */
/* 'v $xci/valeurs.01$I EPSILON_DE_CONVERSION_ENTIER'). Le passage de 'FDU' a 'FZERO' */
/* a eu lieu le 20020327172426. */
#define MAJORATION_DE_LA_BORNE_SUPERIEURE \
FU \
/* Lors de la generation de nombres entiers ('IL_FAUT(des_nombres_entiers)'), la borne */ \
/* superieure doit etre majoree (ce parametre "autonome" a ete introduit le 20030927095826). */
#include xci/valeurs.01.I"
#define COMPATIBILITE_20020306 \
FAUX \
/* Permet de generer des sequences de nombres entiers identiques a celles qui auraient pu */ \
/* etre generees anterieurement au 20020306171034... */
#define COMPATIBILITE_20030926 \
FAUX \
/* Permet de generer des sequences de nombres entiers identiques a celles qui auraient pu */ \
/* etre generees anterieurement au 20030926171705... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/substitue.02.I"
/* Introduit le 20110401192032... */
#include xci/valeurs.02.I"
#define PLUS_PETIT_NOMBRE_ENTIER_GENERABLE \
INTE(NEGA(MILLION))
#define PLUS_GRAND_NOMBRE_ENTIER_GENERABLE \
INTE(NEUT(MILLION))
/* Definition des nombres entiers extremaux que l'on peut generer. */
#define PLUS_PETIT_NOMBRE_ENTIER(nombre) \
INTE(MAX2(FLOT(MULTIPLE_DE(ENTIER_FLOTTANT(nombre))),FLOT(PLUS_PETIT_NOMBRE_ENTIER_GENERABLE)))
#define PLUS_GRAND_NOMBRE_ENTIER(nombre) \
INTE(MIN2(FLOT(MULTIPLE_DE(ENTIER_FLOTTANT(nombre))),FLOT(PLUS_GRAND_NOMBRE_ENTIER_GENERABLE)))
/* Procedures de limitation des nombres entiers generables. ATTENTION : le 20020829094851, */
/* j'ai applique 'MULTIPLE_DE(ENTIER_FLOTTANT(...))' a 'nombre' car, en effet, cela */
/* manquait et dans le cas 'IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions)' */
/* ne donnait pas du tout le resultat attendu, puisqu'il y avait malgre tout des collisions. */
#define PLUS_PETIT_NOMBRE_ENTIER_DEMANDE \
PLUS_PETIT_NOMBRE_ENTIER(borne_inferieure)
#define PLUS_GRAND_NOMBRE_ENTIER_DEMANDE \
PLUS_GRAND_NOMBRE_ENTIER(borne_superieure)
/* Definition des nombres entiers extremaux que l'on va generer. */
#define NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS \
COND(IFET(IL_FAUT(des_nombres_entiers) \
,IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions) \
) \
,NBRE(PLUS_PETIT_NOMBRE_ENTIER_DEMANDE,PLUS_GRAND_NOMBRE_ENTIER_DEMANDE) \
,gnnUNDEF \
) \
/* Nombre de nombres entiers differents que l'on peut generer. Le 20030528154724, je suis */ \
/* passe de 'UNDEF' a 'gnnUNDEF' de facon a garantir une allocation memoire minimale */ \
/* (on notera au passage que cette definition a contraint temporairement a la modification */ \
/* 'v $xil/defi_c1$vv$DEF 20030528141449' afin de permettre un 'lMalo(...)' dont le nombre */ \
/* d'octets demandes et un multiple de 'NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS' et donc de */ \
/* 'UNDEF' ; malgre le remplacement de 'UNDEF' par 'gnnUNDEF' ci-dessus, la modification */ \
/* de la definition de 'UNDEF' le 20030528141449 a ete conservee car, il est vrai qu'une */ \
/* aussi grande valeur que 444444719 pour 'UNDEF' pourrait avoir des consequences */ \
/* facheuses ailleurs... */
#define GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire) \
Bblock \
EGAL(valeur_aleatoire \
,COND(IL_NE_FAUT_PAS(utiliser_un_espace_de_parametrage_tridimensionnel) \
,rdnI2D(ADRESSE(point_courant_de_l_espace_de_parametrage_2D) \
,graine \
,RDN_INIT_AND_GENERE \
,borne_inferieure,borne_superieure \
) \
,rdnI3D(ADRESSE(point_courant_de_l_espace_de_parametrage_3D) \
,graine \
,RDN_INIT_AND_GENERE \
,borne_inferieure,borne_superieure \
) \
) \
); \
/* Generation d'une valeur aleatoire dans [borne_inferieure,borne_superieure] et parametree */ \
/* par le point courant de l'espace de parametrage. On notera que jusqu'au 19990916114633, */ \
/* il y avait ici : */ \
/* */ \
/* ,FLOT(borne_inferieure),FLOT(borne_superieure) */ \
/* */ \
/* mais, 'borne_inferieure' et 'borne_superieure' ayant le type 'Float', les 'FLOT(...)' */ \
/* sont donc inutiles... */ \
\
Test(IL_FAUT(perturber_le_generateur_aleatoire)) \
Bblock \
DEFV(Float,INIT(perturbation \
,COND(IL_NE_FAUT_PAS(utiliser_un_espace_de_parametrage_tridimensionnel) \
,rdnI2D(ADRESSE(point_courant_de_l_espace_de_parametrage_2D) \
,Pgraine \
,RDN_INIT_AND_GENERE \
,Pborne_inferieure,Pborne_superieure \
) \
,rdnI3D(ADRESSE(point_courant_de_l_espace_de_parametrage_3D) \
,Pgraine \
,RDN_INIT_AND_GENERE \
,Pborne_inferieure,Pborne_superieure \
) \
) \
) \
); \
INCR(valeur_aleatoire,perturbation); \
/* Perturbation de la valeur aleatoire (introduite le 20161125142734)... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
SPIRALE_INITIALISATION; \
/* Initialisation dynamique de 'spirale_nombre_de_points_a_traiter'. */ \
SPIRALE_DEPLACEMENT(ASD1(point_courant_de_l_espace_de_parametrage_2D,x) \
,ASD1(point_courant_de_l_espace_de_parametrage_2D,y) \
); \
SPIRALE_DEPLACEMENT(ASD1(point_courant_de_l_espace_de_parametrage_3D,x) \
,ASD1(point_courant_de_l_espace_de_parametrage_3D,y) \
); \
/* Deplacement du point courant de la spirale de l'espace de parametrage, et ce en restant */ \
/* dans un plan Z=constante (Zmin)... */ \
SPIRALE_PARCOURS; \
/* Parcours de la spirale avec rotation eventuelle de PI/2 du bras courant... */ \
Eblock
#define DETECTEUR_DE_COLLISIONS(nombre) \
IdTb1(nombre_entier_deja_rencontre \
,INDX(PLUS_GRAND_NOMBRE_ENTIER(PLUS_PETIT_NOMBRE_ENTIER(nombre)),PLUS_PETIT_NOMBRE_ENTIER_DEMANDE) \
,NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS \
) \
/* Acces au detecteur de collisions... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E V A L E U R S A L E A T O I R E S : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
/* Numero de la premiere image, */
DEFV(Int,INIT(derniere_image,DERNIERE_IMAGE));
/* Numero de la derniere image. */
DEFV(Int,INIT(numero_d_image,UNDEF));
/* Numero de l'image courante. */
DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(Logical,INIT(utiliser_un_espace_de_parametrage_tridimensionnel,UTILISER_UN_ESPACE_DE_PARAMETRAGE_TRIDIMENSIONNEL));
/* Doit-on utiliser un espace de parametrage tridimensionnel ('VRAI') ou bidimensionnel */
/* ('FAUX') ? Ceci a ete introduit le 20001211162430. */
DEFV(Logical,INIT(utiliser_le_generateur_a_periodicite_parametrable,UTILISER_LE_GENERATEUR_A_PERIODICITE_PARAMETRABLE));
/* Doit-on utiliser le generateur a periodicite parametrable ('VRAI') ou l'autre ('FAUX') ? */
DEFV(Logical,INIT(editer_les_valeurs_courantes_a_la_fin,EDITER_LES_VALEURS_COURANTES_A_LA_FIN));
/* Si 'IL_FAUT(utiliser_le_generateur_a_periodicite_parametrable)' doit-on editer ('VRAI') */
/* ou pas ('FAUX') les valeurs courantes en fin de processus ? */
/* Ces editions sont destinees a permettre de repartir la ou l'on en est lors d'une future */
/* generation de nombres aleatoires. */
DEFV(Logical,INIT(forcer_une_valeur_particuliere,FORCER_UNE_VALEUR_PARTICULIERE));
/* Doit-on forcer une valeur particuliere ('VRAI') ou pas ('FAUX') lors de la generation */
/* des nombre aleatoires ? */
DEFV(Int,INIT(numero_de_la_valeur_particuliere_a_forcer,NUMERO_DE_LA_VALEUR_PARTICULIERE_A_FORCER));
/* Numero de la valeur particuliere lorsque l'on doit en forcer une... */
DEFV(Float,INIT(valeur_particuliere_a_forcer,VALEUR_PARTICULIERE_A_FORCER));
/* Definition de la valeur particuliere lorsque l'on doit en forcer une... */
DEFV(Positive,INIT(dephasage_initial,DEPHASAGE_INITIAL));
/* Nombre de valeurs aleatoires a generer initialement en aveugle de facon a se dephaser */
/* dans la liste des valeurs aleatoires generees (introduit le 20021028090331). */
DEFV(Positive,INIT(nombre_de_repetitions_pour_la_generation_de_la_valeur_aleatoire
,NOMBRE_DE_REPETITIONS_POUR_LA_GENERATION_DE_LA_VALEUR_ALEATOIRE
)
);
/* Nombre de fois que l'on bouclera sur 'GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(...)' */
/* pour produire chaque valeur aleatoire (introduit le 20080310141621). */
DEFV(Positive,INIT(nombre_maximal_d_iterations_de_la_generation_de_la_valeur_aleatoire
,NOMBRE_MAXIMAL_D_ITERATIONS_DE_LA_GENERATION_DE_LA_VALEUR_ALEATOIRE
)
);
/* Nombre maximal d'iterations de generation d'une valeur aleatoire lorsque des contraintes */
/* sont a appliquer ('IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions)' ou */
/* 'IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)'). */
DEFV(Logical,INIT(generer_une_liste_de_valeurs_logiques,GENERER_UNE_LISTE_DE_VALEURS_LOGIQUES));
/* Faut-il en fait generer des valeurs logiques {FAUX,VRAI} ? Ceci a ete introduit le */
/* 20041003103932 pour simplifier cette operation qui pouvait deja se faire "en sept coups". */
DEFV(Logical,INIT(generer_une_liste_de_nombres_entiers_sans_collisions,GENERER_UNE_LISTE_DE_NOMBRES_ENTIERS_SANS_COLLISIONS));
/* Lorque 'IL_FAUT(des_nombres_entiers)', ceux-ci peuvent-ils etre de temps en temps */
/* identiques ('FAUX') ou bien ne doit-il pas y avoir de collisions ('VRAI'). */
DEFV(Logical,INIT(verifier_la_distance_entre_deux_nombres_consecutifs,VERIFIER_LA_DISTANCE_ENTRE_DEUX_NOMBRES_CONSECUTIFS));
/* Doit-on verifier que deux nombres aleatoires consecutifs ne sont pas trop proches */
/* ('VRAI') ou pas ('FAUX'). */
DEFV(Float,INIT(distance_minimale_entre_deux_nombres_consecutifs,DISTANCE_MINIMALE_ENTRE_DEUX_NOMBRES_CONSECUTIFS));
/* Lorsque 'IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)' donne la distance */
/* minimale entre deux nombres aleatoires consecutifs. */
DEFV(Float,INIT(distance_maximale_entre_deux_nombres_consecutifs,DISTANCE_MAXIMALE_ENTRE_DEUX_NOMBRES_CONSECUTIFS));
/* Lorsque 'IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)' donne la distance */
/* maximale entre deux nombres aleatoires consecutifs (introduit le 20230114134735). */
DEFV(Float,INIT(borne_inferieure,BORNE_INFERIEURE));
DEFV(Float,INIT(borne_superieure,BORNE_SUPERIEURE));
DEFV(Int,INIT(graine,GRAINE));
DEFV(Logical,INIT(le_generateur_est_deterministe,LE_GENERATEUR_EST_DETERMINISTE));
DEFV(Logical,INIT(editer_la_graine_non_deterministe,EDITER_LA_GRAINE_NON_DETERMINISTE));
/* Definition du generateur aleatoire... */
/* */
/* La possibilite de generer des valeurs aleatoires non deterministes a ete introduite */
/* le 20220723120908... */
/* */
/* La possibilite d'editer la gaine lorsque la generation n'est pas deterministe a ete */
/* introduite le 20220724121541... */
DEFV(Logical,INIT(perturber_le_generateur_aleatoire,PERTURBER_LE_GENERATEUR_ALEATOIRE));
DEFV(Float,INIT(Pborne_inferieure,PBORNE_INFERIEURE));
DEFV(Float,INIT(Pborne_superieure,PBORNE_SUPERIEURE));
DEFV(Int,INIT(Pgraine,PGRAINE));
/* Definition du Perturbateur du generateur aleatoire (introduit le 20161125142734)... */
#include xci/valeurs.03.I"
DEFV(Logical,INIT(n_editer_que_la_valeur_moyenne_des_valeurs_aleatoires_generees
,N_EDITER_QUE_LA_VALEUR_MOYENNE_DES_VALEURS_ALEATOIRES_GENEREES
)
);
DEFV(Float,INIT(cumul_des_des_valeurs_aleatoires_editees,FZERO));
/* Permet de n'editer que la valeur de la moyenne des nombres aleatoires calcules. Cela */
/* permet d'en valider la qualite (introduit le 20030926162513). */
DEFV(Logical,INIT(editer_le_message_de_la_borne_superieure_entiere,EDITER_LE_MESSAGE_DE_LA_BORNE_SUPERIEURE_ENTIERE));
/* Permet de supprimer le message d'erreur concernant la borne superieure lorsqu'elle est */
/* entiere et que des nombres entiers sont demandes (introduit le 20020327172426). */
DEFV(Float,INIT(majoration_de_la_borne_superieure,MAJORATION_DE_LA_BORNE_SUPERIEURE));
/* Lors de la generation de nombres entiers ('IL_FAUT(des_nombres_entiers)'), la borne */
/* superieure doit etre majoree (ce parametre "autonome" a ete introduit le 20030927095826). */
DEFV(Logical,INIT(compatibilite_20020306,COMPATIBILITE_20020306));
/* Permet de generer des sequences de nombres entiers identiques a celles qui auraient pu */
/* etre generees anterieurement au 20020306171034... */
DEFV(Logical,INIT(compatibilite_20030926,COMPATIBILITE_20030926));
/* Permet de generer des sequences de nombres entiers identiques a celles qui auraient pu */
/* etre generees anterieurement au 20030926171705... */
#include xci/substitue.03.I"
/* Introduit le 20110401192032... */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20020306=",compatibilite_20020306);
GET_ARGUMENT_L("compatibilite_20030926=",compatibilite_20030926);
GET_ARGUMENT_I("premiere=""p=""D=",premiere_image);
GET_ARGUMENT_I("derniere=""d=""A=",derniere_image);
GET_ARGUMENT_I("pas=",pas_des_images);
GET_ARGUMENT_L("tridimensionnel=""3D=",utiliser_un_espace_de_parametrage_tridimensionnel);
GET_ARGUMENT_N("bidimensionnel=""2D=",utiliser_un_espace_de_parametrage_tridimensionnel);
/* Les parametres bidimensionnels ont ete introduits le 20080924085857... */
GET_ARGUMENT_L("periodique=",utiliser_le_generateur_a_periodicite_parametrable);
GET_ARGUMENT_L("editer=",editer_les_valeurs_courantes_a_la_fin);
GET_ARGUMENT_L("forcer=",forcer_une_valeur_particuliere);
GET_ARGUMENT_I("Fnumero=",numero_de_la_valeur_particuliere_a_forcer);
GET_ARGUMENT_F("Fvaleur=",valeur_particuliere_a_forcer);
GET_ARGUMENT_I("methode=",gen_ft_____methode_standard);
/* Parametre introduit le 20080924091921... */
GET_ARGUMENT_F("inferieur=""inf=""bi=",borne_inferieure);
GET_ARGUMENT_F("superieur=""sup=""bs=",borne_superieure);
/* Les parametres {"inferieur=","superieur="} furent introduits le 20090221161945... */
/* Les parametres {"inferieur=","superieur="} furent introduits le 20090221161945... */
GET_ARGUMENT_I("graine=""g=",graine);
GET_ARGUMENT_L("deterministe=""gd=",le_generateur_est_deterministe);
GET_ARGUMENT_N("non_deterministe=""gnd=",le_generateur_est_deterministe);
GET_ARGUMENT_L("editer_graine_non_deterministe=""egnd=",editer_la_graine_non_deterministe);
/* Parametres introduits le 20220723120908 et completes le 20220724121541... */
GET_ARGUMENT_L("Perturber=""perturber=",perturber_le_generateur_aleatoire);
GET_ARGUMENT_F("Pinferieur=""Pinf=""Pbi=",Pborne_inferieure);
GET_ARGUMENT_F("Psuperieur=""Psup=""Pbs=",Pborne_superieure);
GET_ARGUMENT_I("Pgraine=""Pg=",Pgraine);
/* Les parametres de Perturbation ont ete introduits le 20161125142734... */
/* */
/* On notera que si : */
/* */
/* Pborne_inferieure = Pborne_superieure */
/* */
/* alors cela permet de translater globalement (de cette valeur commune) la suite des */
/* nombres aleatoires generes... */
GET_ARGUMENT_L("affiner_rdn=",rdnIFnD_____affiner_la_generation);
GET_ARGUMENT_L("iterer_rdn=",rdnIFnD_____iterer_la_generation);
GET_ARGUMENT_F("PrdnI2D_NEUT=",rdnI2D_____ponderation_NEUT);
GET_ARGUMENT_F("PrdnI2D_GAUS=",rdnI2D_____ponderation_GAUS);
GET_ARGUMENT_F("PrdnI2D_GAUS_esperance=",rdnI2D_____ponderation_GAUS_esperance_);
GET_ARGUMENT_F("PrdnI2D_GAUS_ecart_type=",rdnI2D_____ponderation_GAUS_ecart_type);
/* Parametres introduits le 20110325114445... */
GET_ARGUMENT_F("PrdnI3D_NEUT=",rdnI3D_____ponderation_NEUT);
GET_ARGUMENT_F("PrdnI3D_GAUS=",rdnI3D_____ponderation_GAUS);
GET_ARGUMENT_F("PrdnI3D_GAUS_esperance=",rdnI3D_____ponderation_GAUS_esperance_);
GET_ARGUMENT_F("PrdnI3D_GAUS_ecart_type=",rdnI3D_____ponderation_GAUS_ecart_type);
/* Parametres introduits le 20110325114445... */
CONTROLE_DE_L_ADAPTATION_A_UNE_LOI_DE_DISTRIBUTION_QUELCONQUE;
/* Introduit le 20110401182314 sous cette forme... */
GET_ARGUMENT_F("x=""X=",ASD1(rdn_iteratif_cercle_____point_courant_sur_la_droite,x));
GET_ARGUMENT_F("y=""Y=",ASD1(rdn_iteratif_cercle_____point_courant_sur_la_droite,y));
GET_ARGUMENT_F("pente=""Ad=",rdn_iteratif_cercle_____pente_A_de_la_droite);
/* Le 20050623152334, "A=" a ete remplace par "Ad=" (double definition...). */
GET_ARGUMENT_F("ordonnee=""Bd=",rdn_iteratif_cercle_____ordonnee_a_l_origine_B_de_la_droite);
/* Le 20050623152334, "B=" a ete remplace par "Bd=" (double definition...). */
GET_ARGUMENT_F("pd=""pas_droite=",rdn_iteratif_cercle_____pas_de_parcours_de_la_droite);
/* Le 20050623152334, "pas=" a ete remplace par "pas_droite=" et "pd=" (double def...). */
GET_ARGUMENT_F("rayon=",rdn_iteratif_cercle_____rayon_minimal_des_cercles);
GET_ARGUMENT_F("facteur=""extension=",rdn_iteratif_cercle_____facteur_d_extension_du_rayon_des_cercles);
GET_ARGUMENT_I("saut=",rdn_iteratif_cercle_____nombre_de_nombres_aleatoires_a_sauter);
GET_ARGUMENT_F("nombre=",rdn_iteratif_cercle_____nombre_aleatoire_courant);
GET_ARGUMENT_L("premiere_racine=",rdn_iteratif_cercle_____prendre_la_premiere_racine);
GET_ARGUMENT_I("dephasage=",dephasage_initial);
GET_ARGUMENT_I("nombre_repetitions=""nr=",nombre_de_repetitions_pour_la_generation_de_la_valeur_aleatoire);
GET_ARGUMENT_I("iterations=""bouclage="
,nombre_maximal_d_iterations_de_la_generation_de_la_valeur_aleatoire
);
GET_ARGUMENT_L("sans_collisions=""sc=",generer_une_liste_de_nombres_entiers_sans_collisions);
/* Le parametre "sc=" fut introduit le 20090221161945... */
GET_ARGUMENT_N("collisions=""c=",generer_une_liste_de_nombres_entiers_sans_collisions);
GET_ARGUMENT_L("verifier_distance=""vd=",verifier_la_distance_entre_deux_nombres_consecutifs);
GET_ARGUMENT_F("dm=""distance_minimale=",distance_minimale_entre_deux_nombres_consecutifs);
GET_ARGUMENT_F("dM=""distance_maximale=",distance_maximale_entre_deux_nombres_consecutifs);
/* Les parametres "dM=""distance_maximale=" furent introduits le 20230114134735... */
GET_ARGUMENT_L("moyenne=",n_editer_que_la_valeur_moyenne_des_valeurs_aleatoires_generees);
GET_ARGUMENT_L("logiques=""booleens=",generer_une_liste_de_valeurs_logiques);
GET_ARGUMENT_L("message_borne_superieure_entiere=""mbse="
,editer_le_message_de_la_borne_superieure_entiere
);
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
/* Cette procedure fut introduite le 20061226185610... */
GET_ARGUMENT_F("majoration=",majoration_de_la_borne_superieure);
)
);
#include xci/substitue.05.I"
/* Introduit le 20110401192032... */
Test(EST_FAUX(le_generateur_est_deterministe))
/* Test introduit le 20220723120908... */
Bblock
DEFV(Positive,INIT(Secondes,UNDEF));
DEFV(Positive,INIT(MicroSecondes,UNDEF));
DUREE_ECOULEE_DEPUIS_LE_01_01_1970_A_00_00_00(Secondes,MicroSecondes);
INCR(graine,ADD2(Secondes,MicroSecondes));
/* La graine est donc fonction de la duree ecoulee depuis le 01/01/1970 00:00:00 et le */
/* generateur n'est donc plus deterministe... */
/* */
/* Le 20220724100541, meme si cela est completement inutile, je suis passe de */
/* 'EGAL(graine,...)' a 'INCR(graine,...)'... */
Test(IL_FAUT(editer_la_graine_non_deterministe))
/* Test introduit le 20220724121541... */
Bblock
CAL2(Prin1("graine=%d\n",graine));
/* Il peut etre utile de connaitre la graine aleatoire utilisee au cas ou l'on voudrait */
/* reproduire cette generation... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(generer_une_liste_de_valeurs_logiques))
Bblock
EGAL(des_nombres_entiers,VRAI);
EGAL(editer_le_message_de_la_borne_superieure_entiere,FAUX);
EGAL(borne_inferieure,FLOT(FAUX));
EGAL(borne_superieure,FLOT(VRAI));
EGAL(compatibilite_20020306,FAUX);
EGAL(compatibilite_20030926,FAUX);
EGAL(valeurs_signees,chain_Acopie(C_VIDE));
/* Ainsi, les options utiles sont forcees afin de generer des 'Logical's. Ceci fut introduit */
/* le 20041003103932, en notant bien qu'anterieurement a cette date, cela pouvait deja se */
/* faire en forcant ces six parametres individuellement. Le 20041004111732 a ete introduit */
/* le septieme parametre 'valeurs_signees' car, en effet, il est plus correct de ne pas */
/* signer les valeurs logiques {0,1}... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IFLE(borne_inferieure,borne_superieure)
,IFLE(premiere_image,derniere_image)
)
)
Bblock
DEFV(Float,INIT(valeur_aleatoire_precedente,FLOT__UNDEF));
/* Valeur aleatoire precedente... */
DEFV(Logical,DdTb1(POINTERl
,nombre_entier_deja_rencontre
,NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS
,lMalo(MUL2(NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS,size_Logical))
)
);
/* Allocation du vecteur destine a reperer, si besoin est, les "collisions" dans les */
/* nombres entiers generes... */
DEFV(pointI_2D,point_courant_de_l_espace_de_parametrage_2D);
DEFV(pointI_3D,point_courant_de_l_espace_de_parametrage_3D);
/* Point courant d'un espace abstrait servant a parametrer le generateur d'evenements. */
SPIRALE_DEFINITION_GENERALE(SPIRALE_DELTA_HORIZONTAL_GLOBAL,SPIRALE_DELTA_VERTICAL_GLOBAL)
/* Donnees de generation d'une spirale de parcours d'un espace abstrait bidimensionnel */
/* de parametrage de la generation des evenements. */
/* ATTENTION : jusqu'au 20010926155950, il y avait ici : */
/* */
/* SPIRALE_REINITIALISATION_BRAS_ET_DELTAS; */
/* */
/* qui provenait d'un "copier-coller" un peu large. Il ne sert a rien et a ete supprime... */
SPIRALE_VALIDATION;
/* Validation des pas de parcours (pasX,pasY) de l'espace abstrait de parametrage du */
/* generateur d'evenements. */
INITIALISATION_POINT_2D(point_courant_de_l_espace_de_parametrage_2D,Xmin,Ymin);
INITIALISATION_POINT_3D(point_courant_de_l_espace_de_parametrage_3D,Xmin,Ymin,Zmin);
/* Initialisation de l'espace de parametrage independante du format de l'image, puisque le */
/* point 'min' n'en depend pas... */
Test(IFET(IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions)
,IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)
)
)
Bblock
PRINT_ATTENTION("il est pratiquement impossible de satisfaire simultanement les deux contraintes demandees");
PRINT_ATTENTION("(generer des nombres sans collisions et respecter la distance entre deux nombres consecutifs)");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)
,IFOU(IFLE(SOUA(borne_superieure,borne_inferieure)
,distance_minimale_entre_deux_nombres_consecutifs
)
,IFLE(distance_maximale_entre_deux_nombres_consecutifs
,distance_minimale_entre_deux_nombres_consecutifs
)
)
)
)
Bblock
PRINT_ERREUR("il est impossible de respecter les distances minimale et maximale entre deux nombres aleatoires");
CAL1(Prer2("les bornes du generateur sont (%+.^^^,%+.^^^)\n"
,borne_inferieure
,borne_superieure
)
);
/* Le 20060105155422, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123311, le format "^^g" est passe a "^^^" pour plus de souplesse... */
EGAL(distance_minimale_entre_deux_nombres_consecutifs,DISTANCE_MINIMALE_ENTRE_DEUX_NOMBRES_CONSECUTIFS);
/* On change arbitrairement cette distance minimale... */
EGAL(distance_maximale_entre_deux_nombres_consecutifs,DISTANCE_MAXIMALE_ENTRE_DEUX_NOMBRES_CONSECUTIFS);
/* On supprime arbitrairement cette distance maximale... */
CAL1(Prer1("la distance minimale est donc supprimee en prennant la valeur %+.^^^ "
,distance_minimale_entre_deux_nombres_consecutifs
)
);
/* Le 20060105155422, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123311, le format "^^g" est passe a "^^^" pour plus de souplesse... */
CAL1(Prer1("et la distance maximale est supprimee en prennant la valeur %+.^^^\n"
,distance_maximale_entre_deux_nombres_consecutifs
)
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(des_nombres_entiers))
Bblock
Test(fEST_ENTIER(borne_superieure))
/* Avant le 20011216160849, ce test n'etait effectue que si */
/* 'IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions)', mais en fait, grace */
/* a 'v $xcg/chiffrage.21$Z valeurs_alea.X', il est apparu qu'il etait necessaire des que */
/* des nombres entiers etaient demandes. Simultanement, l'increment de 'borne_superieure' */
/* est passe de 'FDU' a 'SOUS(FU,gEPSILON)' ce qui est plus "equitable"... */
Bblock
Test(IL_FAUT(compatibilite_20030926))
Bblock
EGAL(epsilon_de_conversion_entier,EPSILON_DE_CONVERSION_ENTIER_ANTERIEUR_AU_20030926);
/* Malheureusement, cela ne peut se faire lors de l'initialisation de la variable */
/* 'epsilon_de_conversion_entier' ci-dessus car, en effet, a ce moment-la, l'indicateur */
/* 'compatibilite_20030926' n'a pas encore la valeur eventuellement entree via le */
/* 'GET_ARGUMENT_L(...)' correspondant... */
Eblock
ATes
Bblock
Eblock
ETes
INCR(borne_superieure
,SOUS(COND(IL_NE_FAUT_PAS(compatibilite_20020306)
,COND(IL_NE_FAUT_PAS(compatibilite_20030926)
,majoration_de_la_borne_superieure
,epsilon_de_conversion_entier
)
,FU
)
,mgEPSILON
)
);
/* Les bornes du generateur aleatoire sont tres rarement atteintes. Ceci n'est pas genant */
/* pour la borne inferieure lors de sa conversion en entier puisqu'on utilise 'INTE(...)', */
/* (cela implique qu'elle est donc atteinte en entier puisqu'on arrondi par defaut) ; */
/* mais par contre, pour la borne superieure cela est tres ennuyeux car cela signifie */
/* qu'elle ne sera jamais atteinte en entier (l'arrondi par defaut donnera l'entier qui */
/* precede la borne superieure...). Le 20011218133414, je suis passe de 'gEPSILON' (qui */
/* etait donc utilise depuis le 20011216160849) a 'mgEPSILON' afin que le CAL1(Prer1(...))' */
/* qui suit edite correctement un nombre decimal (n'ayant pas l'apparence d'un nombre */
/* entier...). Le 20020306171034 je me suis rendu compte qu'il fallait non pas utiliser */
/* 'FU' mais bien plutot 'epsilon_de_conversion_entier' car, en effet, dans le cas de 'FU' */
/* la translation apportee aux nombres flottants generes avant leur conversion en entiers */
/* est en quelque sorte egale a 'FU-mgEPSILON+epsilon_de_conversion_entier' ce qui pouvait */
/* produire des nombres entiers egaux a la borne superieure plus 1 ; cela s'est vu dans la */
/* generation de fichiers tels '$xTG/COLLISIONNABLE' dans */
/* 'v _____xivPdf_09_2/.REFL.m.53.1.$U entiers'. A partir du 20020306171034, la translation */
/* devient egale a 'epsilon_de_conversion_entier-mgEPSILON+epsilon_de_conversion_entier' */
/* fictivement (puisqu'en effet elle porte d'une part sur la borne superieure pour ce qui */
/* est de 'epsilon_de_conversion_entier-mgEPSILON' et d'autre part sur la partie conversion */
/* pour ce qui est de nouveau de 'epsilon_de_conversion_entier'...). Le 20020311142707, */
/* j'ai introduit "compatibilite_20020306" afin de permettre d'assurer la compatibilite */
/* avec des choses faites anterieurement au 20020306171034... */
/* */
/* Le 20030926170657 (apres l'introduction le 20030926162513 de l'option "moyenne=" */
/* permettant de n'editer que la moyenne des valeurs calculees), il est apparu qu'une */
/* bonne valeur de 'epsilon_de_conversion_entier' permettant d'obtenir une repartition */
/* equitable de {0,1} ("inf=0 sup=1 entiers=vrai") est approximativement egale a 1/3. */
/* Cela reste vrai si les entiers demandes sont dans un ensemble plus vaste que {0,1}... */
/* Mais le 20020327172426, il m'est apparu evident qu'il fallait decoupler le parametre */
/* 'epsilon_de_conversion_entier' de l'incrementation de la borne superieure. Etant donne */
/* que le passage de flottant en entier se fait par 'vs :AINT:' via 'vs :AINT_a_peu_pres:' */
/* dans 'vs :ENTIER_FLOTTANT:', il est devenu evident qu'il faut en general utiliser : */
/* */
/* epsilon_de_conversion_entier = 0 */
/* */
/* afin de ramener sans "distorsion" tout nombre flottant au nombre entier inferieur le */
/* plus proche, ce qui permet de generer la bonne frequence de nombres entiers egaux a la */
/* borne inferieure ('borne_inferieure'). Cela conduit donc a introduire un nouveau */
/* parametre 'majoration_de_la_borne_superieure' utilise uniquement pour incrementer */
/* la borne superieure : */
/* */
/* majoration_de_la_borne_superieure = 1 */
/* */
/* en notant que la valeur effective est 'majoration_de_la_borne_superieure-mgEPSILON', */
/* soit en general : */
/* */
/* majoration_de_la_borne_superieure = 0.999999999 */
/* */
/* ce qui permet de generer la bonne frequence de nombres entiers egaux a la borne */
/* superieure ('borne_superieure'). Ainsi, on garantit la bonne frequence de tous les */
/* nombres entiers dans [borne_inferieure,borne_superieure]. */
/* */
/* */
/* Le 20030927190651 je note qu'il est possible de generer une liste de N nombres aleatoires */
/* entiers parfaitement equirepartis. Supposons pour simplifier que N est pair et que les */
/* nombres entiers aleatoires doivent etre dans [0,1]. Il suffit de generer deux fichiers */
/* 'F(0)' et 'F(1)' de longueur commune N/2 : */
/* */
/* F(0) = {0,0,...,0} */
/* F(1) = {1,1,...,1} */
/* */
/* puis un fichier 'FP' de N nombres aleatoires dans [0,N-1] sans collisions (il s'agit */
/* donc d'une permutation de {0,1,2,...,N-1}) : */
/* */
/* FP = PermutationAleatoire{0,1,2,...,N-1} */
/* */
/* Enfin, la concatenation de 'F(0)' et de 'F(1)' est permutee grace a '$xrv/permute.11$X' */
/* avec les arguments : */
/* */
/* fichier=Concatenation(F(0),F(1)) */
/* permutation=FP */
/* */
/* Cela se generalise pour des segments [a,b] plus vastes que [0,1] ; il suffit alors que */
/* 'N' soit un multiple de b-a+1 et de generer b-a+1 fichiers 'F(i)' : */
/* */
/* F(a) = {a,a,...,a} */
/* (...) */
/* F(i) = {i,i,...,i} */
/* (...) */
/* F(b) = {b,b,...,b} */
/* */
/* ces b-a+1 fichiers etant de longueur commune N/(b-a+1) et le fichier 'FP' etant defini */
/* comme ci-dessus dans le cas [0,1]... */
/* */
/* Evidemment, cela laisse supposer que 'N' est connu a l'avance. Si tel n'est pas le cas, */
/* ou s'il simplement il faut une suite indeterminee (infinie...) de nombres aleatoires */
/* entiers parfaitement equirepartis, il suffit de choisir un 'N' grand (et multiple de */
/* b-a+1) et d'iterer ensuite la procedure precedente en changeant la graine a chaque */
/* nouvelle iteration... */
Test(IL_FAUT(editer_le_message_de_la_borne_superieure_entiere))
Bblock
PRINT_ERREUR("la borne superieure est entiere et risque d'etre inaccessible");
CAL1(Prer1("elle est donc augmentee et prend la valeur %+.^^^\n",borne_superieure));
/* Le 20060105155422, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123311, le format "^^g" est passe a "^^^" pour plus de souplesse... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions))
Bblock
DEFV(Int,INIT(nombre_entier,UNDEF));
/* Nombre entier courant lors de l'initialisation. */
Test(IFOU(IFLT(borne_inferieure,PLUS_PETIT_NOMBRE_ENTIER_GENERABLE)
,IFGT(borne_superieure,PLUS_GRAND_NOMBRE_ENTIER_GENERABLE)
)
)
Bblock
PRINT_ERREUR("les capacites de gestion sont insuffisantes");
CAL1(Prer2("les bornes du generateur sont (%+.^^^,%+.^^^)\n"
,borne_inferieure
,borne_superieure
)
);
/* Le 20060105155422, le format "16g" est passe a "^^g" pour plus de souplesse... */
/* */
/* Le 20091123123311, le format "^^g" est passe a "^^^" pour plus de souplesse... */
CAL1(Prer2("alors que l'on ne peut gerer que (%d,%d)\n"
,PLUS_PETIT_NOMBRE_ENTIER_GENERABLE
,PLUS_GRAND_NOMBRE_ENTIER_GENERABLE
)
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFGT(NBRE(premiere_image,derniere_image),NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS))
Bblock
PRINT_ERREUR("trop de nombres entiers differents sont demandes");
CAL1(Prer1("%d nombres entiers differents sont demandes\n",NBRE(premiere_image,derniere_image)));
CAL1(Prer1("alors que seulement %d peuvent etre generes\n",NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS));
PRINT_ERREUR("il y aura donc des collisions");
EGAL(generer_une_liste_de_nombres_entiers_sans_collisions,FAUX);
/* Et les collisions sont autorisees... */
Eblock
ATes
Bblock
Eblock
ETes
DoIn(nombre_entier,PLUS_PETIT_NOMBRE_ENTIER_DEMANDE,PLUS_GRAND_NOMBRE_ENTIER_DEMANDE,pas_des_images)
Bblock
EGAL(DETECTEUR_DE_COLLISIONS(nombre_entier),FAUX);
/* Initialisation ("il n'y a pas encore de collisions"...). */
Eblock
EDoI
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_NE_FAUT_PAS(utiliser_le_generateur_a_periodicite_parametrable))
Bblock
Repe(dephasage_initial)
Bblock
DEFV(Float,INIT(valeur_aleatoire_sautee,FLOT__UNDEF));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire_sautee);
/* Et on saute eventuellement les 'dephasage_initial' premieres valeurs aleatoires... */
Eblock
ERep
Eblock
ATes
Bblock
Test(IZNE(dephasage_initial))
Bblock
PRINT_ERREUR("le dephasage est incompatible avec l'utilisation du generateur aleatoire periodique");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
DEFV(Logical,INIT(iterer_la_generation_de_la_valeur_aleatoire,VRAI));
/* Il faut calculer au moins une valeur aleatoire... */
DEFV(Positive,INIT(nombre_d_iterations_de_la_generation_de_la_valeur_aleatoire
,nombre_maximal_d_iterations_de_la_generation_de_la_valeur_aleatoire
)
);
/* Detecteur de "bouclage"... */
DEFV(Float,INIT(valeur_aleatoire,FLOT__UNDEF));
DEFV(Float,INIT(valeur_aleatoire_a_editer,FLOT__UNDEF));
/* Valeur aleatoire courante et sa version "a editer"... */
Tant(IL_FAUT(iterer_la_generation_de_la_valeur_aleatoire))
Bblock
Test(IL_NE_FAUT_PAS(utiliser_le_generateur_a_periodicite_parametrable))
Bblock
Repe(nombre_de_repetitions_pour_la_generation_de_la_valeur_aleatoire)
/* Cette possibilite de boucler plusieurs fois a ete introduite le 20080310141621... */
Bblock
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire);
/* Generation d'une valeur aleatoire dans [borne_inferieure,borne_superieure] et parametree */
/* par le point courant de l'espace de parametrage. */
Eblock
ERep
Eblock
ATes
Bblock
EGAL(valeur_aleatoire
,rdn_iteratif_cercle()
);
EGAL(valeur_aleatoire
,DENO(valeur_aleatoire,borne_inferieure,borne_superieure)
);
/* Generation d'une valeur aleatoire dans [borne_inferieure,borne_superieure] non parametree */
/* par le point courant de l'espace de parametrage. */
Eblock
ETes
DECR(nombre_d_iterations_de_la_generation_de_la_valeur_aleatoire,I);
/* Afin de ne pas boucler eternellement... */
Test(IFET(IZGT(nombre_d_iterations_de_la_generation_de_la_valeur_aleatoire)
,I3OU(I3ET(IL_FAUT(des_nombres_entiers)
,IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions)
,EST_VRAI(DETECTEUR_DE_COLLISIONS(valeur_aleatoire))
)
,I3ET(IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)
,IFGT(numero_d_image,premiere_image)
,IFLE(SOUA(valeur_aleatoire,valeur_aleatoire_precedente)
,distance_minimale_entre_deux_nombres_consecutifs
)
)
,I3ET(IL_FAUT(verifier_la_distance_entre_deux_nombres_consecutifs)
,IFGT(numero_d_image,premiere_image)
,IFGE(SOUA(valeur_aleatoire,valeur_aleatoire_precedente)
,distance_maximale_entre_deux_nombres_consecutifs
)
)
)
)
)
/* Le test relatif a la distance maximale a ete introduit le 20230114134735... */
Bblock
/* Lorsqu'il faut generer des nombres entiers sans collisions et qu'il y a collisions, */
/* ou lorsque la distance minimale entre deux nombres consecutifs n'est pas respectee, */
/* il faut iterer... */
Eblock
ATes
Bblock
EGAL(iterer_la_generation_de_la_valeur_aleatoire,FAUX);
/* Dans le cas general, on arrete apres la premiere iteration... */
Eblock
ETes
Test(IL_FAUT(des_nombres_entiers))
Bblock
Test(IL_FAUT(generer_une_liste_de_nombres_entiers_sans_collisions))
Bblock
EGAL(DETECTEUR_DE_COLLISIONS(valeur_aleatoire),VRAI);
/* A compter du 20001129160743, le detecteur de collisions n'est mis a jour que si cela */
/* est necessaire, alors qu'avant cette date, il l'etait systematiquement... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
/* La sequence {SPIRALE_INITIALISATION,SPIRALE_DEPLACEMENT,SPIRALE_PARCOURS} se trouvait ici */
/* avant le 20021028090331 et non dans 'GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(...)'. */
Eblock
ETan
Test(IFET(IL_FAUT(forcer_une_valeur_particuliere),IFEQ(numero_d_image,numero_de_la_valeur_particuliere_a_forcer)))
Bblock
EGAL(valeur_aleatoire,valeur_particuliere_a_forcer);
/* Cas ou un forcage est demande... */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(valeur_aleatoire_a_editer,MULTIPLE_DE(ENTIER_FLOTTANT(valeur_aleatoire)));
INCR(cumul_des_des_valeurs_aleatoires_editees,valeur_aleatoire_a_editer);
/* Mise a jour du cumul destine au calcul de la moyenne des valeurs calculees. */
Test(IL_FAUT(n_editer_que_la_valeur_moyenne_des_valeurs_aleatoires_generees))
Bblock
Eblock
ATes
Bblock
CAL2(Prin2(Cara(chain_Aconcaten5(INTRODUCTION_FORMAT,valeurs_signees,".*",format_d_edition,"\n"))
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,valeur_aleatoire_a_editer
)
);
/* Edition de la valeur aleatoire courante... */
/* */
/* On notera le 20080924164416 que la commande : */
/* */
/* $xci/valeurs_alea$X p=1 d=1 graine=1234610 */
/* */
/* donne : */
/* */
/* +0.19624373093072 sur {$CMAP28,$LACT16,$LACT15} */
/* */
/* et : */
/* */
/* +0.19624373093073 sur {$LACT17,$LACT18} */
/* */
/* Mais en fait, la valeur calculee est la meme sur toutes ces MACHINEs (0.1962437309307250) */
/* la difference semblant venir de l'impression tout simplement. Au passage, on trouve : */
/* */
/* fx=-517668276 */
/* fy=+1550138109 */
/* fz=+1527002520 */
/* */
/* pour les valeurs intermediaires {fx,fy,fz} sur toutes ces MACHINEs... */
Eblock
ETes
EGAL(valeur_aleatoire_precedente,valeur_aleatoire);
/* Memorisation de la valeur aleatoire "precedente"... */
Eblock
EDoI
Test(IL_FAUT(n_editer_que_la_valeur_moyenne_des_valeurs_aleatoires_generees))
Bblock
CAL2(Prin2(Cara(chain_Aconcaten5(INTRODUCTION_FORMAT,valeurs_signees,".*",format_d_edition,"\n"))
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,DIVI(cumul_des_des_valeurs_aleatoires_editees,FLOT(NBRE(premiere_image,derniere_image)))
)
);
/* Edition de la moyenne des valeurs aleatoires (introduit le 20030926162513). */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_NE_FAUT_PAS(utiliser_le_generateur_a_periodicite_parametrable))
Bblock
Eblock
ATes
Bblock
Test(IL_FAUT(editer_les_valeurs_courantes_a_la_fin))
Bblock
CAL3(Prme4(Cara(chain_Aconcaten8("\n point courant sur la droite : X=%",valeurs_signees,".*",format_d_edition
," Y=%",valeurs_signees,".*",format_d_edition
)
)
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,ASD1(rdn_iteratif_cercle_____point_courant_sur_la_droite,x)
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,ASD1(rdn_iteratif_cercle_____point_courant_sur_la_droite,y)
)
);
CAL3(Prme2(Cara(chain_Aconcaten4("\n nombre aleatoire courant... : nombre=%"
,valeurs_signees
,".*"
,format_d_edition
)
)
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,rdn_iteratif_cercle_____nombre_aleatoire_courant
)
);
CAL3(Prme1("prendre la premiere racine. : premiere_racine=%s\n"
,ETAT_LOGIQUE(rdn_iteratif_cercle_____prendre_la_premiere_racine)
)
);
/* Ces editions sont destinees a permettre de repartir la ou l'on en est lors d'une future */
/* generation de nombres aleatoires. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
FdTb1(nombre_entier_deja_rencontre,NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS,Logical,ADRESSE_PLUS_DEFINIE);
/* Liberation du vecteur destine a reperer, si besoin est, les "collisions" dans les */
/* nombres entiers generes (introduit le 20031111105925 car oublie anterieurement... */
/* */
/* Le 'ADRESSE_PLUS_DEFINIE' a ete introduit le 20050221170900... */
Eblock
ATes
Bblock
PRINT_ERREUR("une relation d'ordre ('premier <= dernier' ou 'inferieure <= superieure') n'est pas respectee");
Eblock
ETes
RETU_Commande;
Eblock
ECommande