/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E L A C H A R G E D E C O U L E U R : */
/* */
/* */
/* Author of '$xrq/nucleon.LD$I' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 1991??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E L A C H A R G E D E C O U L E U R S : */
/* */
/* */
/* Principe : */
/* */
/* Lorsque l'on genere 'N' particules, il */
/* est necessaire qu'elles forment un N-uplet */
/* de couleur donnee : */
/* */
/* - soit BLANC, c'est-a-dire dont la charge de */
/* couleur soit (ROUGE_max,VERTE_max,BLEUE_max), */
/* dans le cas d'une creation a partir du vide, */
/* */
/* - soit de charge donnee dans le cas d'une */
/* transformation, auquel cas il faut garantir */
/* la conservation de la charge de couleur. */
/* */
/* Pour ce faire, appelons 'C' l'une des trois */
/* composantes 'ROUGE', 'VERTE' ou 'BLEUE'. */
/* */
/* Procedons a 'N' tirages au sort tels */
/* que : */
/* */
/* C' E [min,max] ou 'max' designe 'BLANC' ou la charge a conserver. */
/* i */
/* */
/* Ensuite, chacun des nombres est renormalise, */
/* c'est-a-dire qu'on lui substitue la valeur : */
/* */
/* C' - min */
/* i */
/* C = ----------------.(max - min) + min */
/* i ____ */
/* \ */
/* \ (C' - min) */
/* / i */
/* /___ */
/* (N) */
/* */
/* Ainsi, on a bien : */
/* ____ */
/* \ */
/* \ (C - min) = max */
/* / i */
/* /___ */
/* (N) */
/* */
/* */
/*************************************************************************************************************************************/
#define BINARISER_LES_CHARGES_DE_COULEUR \
FAUX
DEFV(Local,DEFV(Logical,INIT(binariser_les_charges_de_couleur,BINARISER_LES_CHARGES_DE_COULEUR)));
/* Indicateur le 20031105122626 permettant si besoin est de generer des charges de couleur */
/* de nature "tout ou rien", c'est-a-dire ne valant que 'couleur`min' ou 'couleur`max'. La */
/* valeur par defaut assure la compatibilite anterieure... */
=define GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(composante,couleur) \
Bblock \
GENERATION_D_UNE_VALEUR(composante \
,couleur`min \
,couleur`max \
); \
\
Test(IL_FAUT(binariser_les_charges_de_couleur)) \
Bblock \
EGAL(composante \
,COND(IFLE(composante,MOYE(couleur`min,couleur`max)) \
,couleur`min \
,couleur`max \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/* Generation d'une composante de charge de couleur dans [min,max]. */
=define ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(composante,anti_translation) \
Bblock \
DECR(composante,anti_translation); \
Eblock
/* Anti-translation d'une composante de la charge de couleur ; ceci sera utilise lorsque */
/* l'on determine les composantes (C1,C2,C3) de trois charges de couleur, alors que 'C1' */
/* est donnee par ailleurs : */
/* */
/* 1 - C1 imposee, */
/* 2 - GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(C2,C3,couleur), qui provoquera */
/* ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(C2,C1/2) et */
/* ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(C3,C1/2). */
/* */
/* On aura ainsi : C1+C2+C3=max... */
=define RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(composante,couleur,somme_non_normalisee,somme_normalisee) \
Bblock \
EGAL(composante \
,HOMO(composante \
,couleur`min,somme_non_normalisee \
,couleur`min,somme_normalisee \
) \
); \
Eblock
/* Renormalisation d'une composante de charge de couleur, ce qui signifie qu'on la fait */
/* passer de [min,somme_non_normalisee] a [min,somme_normalisee], ce qui permet de garantir */
/* que la somme de 'N' telles composantes est egale a un maximum 'somme_normalisee', et */
/* assure donc la neutralite (blancheur) de ces 'N' composantes ou la conservation de la */
/* couleur dans le cas ou 'somme_normalisee' est la charge d'une particule... */
=define GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(comp1,comp2,couleur,anti_translation,somme_normalisee) \
Bblock \
DEFV(Float,INIT(somme_non_normalisee,FLOT__UNDEF)); \
/* Variable destinee a contenir a quelque chose pres la somme des deux composantes... */ \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,couleur); \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,couleur); \
/* Generation d'une composante de deux charges de couleur dans [min,max], que l'on */ \
/* qualifie donc de non renormalisee... */ \
EGAL(somme_non_normalisee \
,ADD2(ADD2(SOUS(comp1,couleur`min) \
,SOUS(comp2,couleur`min) \
) \
,couleur`min \
) \
); \
/* Calcul de la somme des deux composantes relativisees chacune par rapport au minimum, */ \
/* cette somme etant ensuite absolutisee par rapport a ce meme minimum... */ \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,couleur,somme_non_normalisee,somme_normalisee); \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,couleur,somme_non_normalisee,somme_normalisee); \
/* Generation d'une composante de deux charges de couleur dans [min,max] renormalisees */ \
/* ce qui signifie que leur somme vaut le maximum 'max'... */ \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,FRA2(anti_translation)); \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,FRA2(anti_translation)); \
/* Repartition equitable (1/2) de 'anti_translation' sur les deux charges de couleur... */ \
Eblock
/* Generation d'une composante de deux charges de couleur dans [min,max], mais */
/* renormalisees, ce qui signifie que leur somme est egale au maximum 'max'... */
=define GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(comp1,comp2,comp3,couleur,anti_translation,somme_normalisee) \
Bblock \
DEFV(Float,INIT(somme_non_normalisee,FLOT__UNDEF)); \
/* Variable destinee a contenir a quelque chose pres la somme des trois composantes... */ \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,couleur); \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,couleur); \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp3,couleur); \
/* Generation d'une composante de trois charges de couleur dans [min,max], que l'on */ \
/* qualifie donc de non renormalisee... */ \
EGAL(somme_non_normalisee \
,ADD2(ADD3(SOUS(comp1,couleur`min) \
,SOUS(comp2,couleur`min) \
,SOUS(comp3,couleur`min) \
) \
,couleur`min \
) \
); \
/* Calcul de la somme des trois composantes relativisees chacune par rapport au minimum, */ \
/* cette somme etant ensuite absolutisee par rapport a ce meme minimum... */ \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,couleur,somme_non_normalisee,somme_normalisee); \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,couleur,somme_non_normalisee,somme_normalisee); \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp3,couleur,somme_non_normalisee,somme_normalisee); \
/* Generation d'une composante de trois charges de couleur dans [min,max] renormalisees */ \
/* ce qui signifie que leur somme vaut le maximum 'max'... */ \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,FRA3(anti_translation)); \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,FRA3(anti_translation)); \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp3,FRA3(anti_translation)); \
/* Repartition equitable (1/3) de 'anti_translation' sur les trois charges de couleur... */ \
Eblock
/* Generation d'une composante de trois charges de couleur dans [min,max], mais */
/* renormalisees, ce qui signifie que leur somme est egale au maximum 'max'... */
=define GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(comp1,comp2,comp3,comp4,couleur,anti_translation,somme_normalisee) \
Bblock \
DEFV(Float,INIT(somme_non_normalisee,FLOT__UNDEF)); \
/* Variable destinee a contenir a quelque chose pres la somme des quatre composantes... */ \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,couleur); \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,couleur); \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp3,couleur); \
GENERATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp4,couleur); \
/* Generation d'une composante de quatre charges de couleur dans [min,max], que l'on */ \
/* qualifie donc de non renormalisee... */ \
EGAL(somme_non_normalisee \
,ADD2(ADD4(SOUS(comp1,couleur`min) \
,SOUS(comp2,couleur`min) \
,SOUS(comp3,couleur`min) \
,SOUS(comp4,couleur`min) \
) \
,couleur`min \
) \
); \
/* Calcul de la somme des quatre composantes relativisees chacune par rapport au minimum, */ \
/* cette somme etant ensuite absolutisee par rapport a ce meme minimum... */ \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,couleur,somme_non_normalisee,somme_normalisee); \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,couleur,somme_non_normalisee,somme_normalisee); \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp3,couleur,somme_non_normalisee,somme_normalisee); \
RENORMALISATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp4,couleur,somme_non_normalisee,somme_normalisee); \
/* Generation d'une composante de quatre charges de couleur dans [min,max] renormalisees */ \
/* ce qui signifie que leur somme vaut le maximum 'max'... */ \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp1,FRA4(anti_translation)); \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp2,FRA4(anti_translation)); \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp3,FRA4(anti_translation)); \
ANTI_TRANSLATION_D_UNE_COMPOSANTE_DE_LA_CHARGE_DE_COULEUR(comp4,FRA4(anti_translation)); \
/* Repartition equitable (1/4) de 'anti_translation' sur les quatre charges de couleur... */ \
Eblock
/* Generation d'une composante de quatre charges de couleur dans [min,max], mais */
/* renormalisees, ce qui signifie que leur somme est egale au maximum 'max'... */
=define GENERATION_DE_2_CHARGES_DE_COULEUR(particule1,particule2) \
Bblock \
GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule1,ROUGE) \
,cCOULEUR(particule2,ROUGE) \
,ROUGE,ROUGE_min \
,ROUGE_max \
); \
GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule1,VERTE) \
,cCOULEUR(particule2,VERTE) \
,VERTE,VERTE_min \
,VERTE_max \
); \
GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule1,BLEUE) \
,cCOULEUR(particule2,BLEUE) \
,BLEUE,BLEUE_min \
,BLEUE_max \
); \
Eblock
/* Generation des composantes de couleur de 2 particules. ATTENTION : on notera les */
/* ecritures suivantes : */
/* */
/* ,ROUGE,ROUGE_min */
/* ,VERTE,VERTE_min */
/* ,BLEUE,BLEUE_min */
/* */
/* qui sont mises sur une seule ligne, et non pas deux, afin que l'operateur de */
/* concatenation fonctionne correctement (en effet, sinon, on retrouve un espace en trop */
/* entre 'ROUGE' (ou 'VERTE' ou 'BLEUE') et la fin du nom)... */
=define GENERATION_DE_3_CHARGES_DE_COULEUR(particule1,particule2,particule3) \
Bblock \
GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule1,ROUGE) \
,cCOULEUR(particule2,ROUGE) \
,cCOULEUR(particule3,ROUGE) \
,ROUGE,ROUGE_min \
,ROUGE_max \
); \
GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule1,VERTE) \
,cCOULEUR(particule2,VERTE) \
,cCOULEUR(particule3,VERTE) \
,VERTE,VERTE_min \
,VERTE_max \
); \
GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule1,BLEUE) \
,cCOULEUR(particule2,BLEUE) \
,cCOULEUR(particule3,BLEUE) \
,BLEUE,BLEUE_min \
,BLEUE_max \
); \
Eblock
/* Generation des composantes de couleur de 2 particules. ATTENTION : on notera les */
/* ecritures suivantes : */
/* */
/* ,ROUGE,ROUGE_min */
/* ,VERTE,VERTE_min */
/* ,BLEUE,BLEUE_min */
/* */
/* qui sont mises sur une seule ligne, et non pas deux, afin que l'operateur de */
/* concatenation fonctionne correctement (en effet, sinon, on retrouve un espace en trop */
/* entre 'ROUGE' (ou 'VERTE' ou 'BLEUE') et la fin du nom)... */
=define GENERATION_DE_4_CHARGES_DE_COULEUR(particule1,particule2,particule3,particule4) \
Bblock \
GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule1,ROUGE) \
,cCOULEUR(particule2,ROUGE) \
,cCOULEUR(particule3,ROUGE) \
,cCOULEUR(particule4,ROUGE) \
,ROUGE,ROUGE_min \
,ROUGE_max \
); \
GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule1,VERTE) \
,cCOULEUR(particule2,VERTE) \
,cCOULEUR(particule3,VERTE) \
,cCOULEUR(particule4,VERTE) \
,VERTE,VERTE_min \
,VERTE_max \
); \
GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule1,BLEUE) \
,cCOULEUR(particule2,BLEUE) \
,cCOULEUR(particule3,BLEUE) \
,cCOULEUR(particule4,BLEUE) \
,BLEUE,BLEUE_min \
,BLEUE_max \
); \
Eblock
/* Generation des composantes de couleur de 2 particules. ATTENTION : on notera les */
/* ecritures suivantes : */
/* */
/* ,ROUGE,ROUGE_min */
/* ,VERTE,VERTE_min */
/* ,BLEUE,BLEUE_min */
/* */
/* qui sont mises sur une seule ligne, et non pas deux, afin que l'operateur de */
/* concatenation fonctionne correctement (en effet, sinon, on retrouve un espace en trop */
/* entre 'ROUGE' (ou 'VERTE' ou 'BLEUE') et la fin du nom)... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S E R V A T I O N D E L A C H A R G E D E C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
=define CONSERVATION_DE_2_CHARGES_DE_COULEUR(particule11,particule12,particule21) \
Bblock \
GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule11,ROUGE) \
,cCOULEUR(particule12,ROUGE) \
,ROUGE,ROUGE_min \
,cCOULEUR(particule21,ROUGE) \
); \
GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule11,VERTE) \
,cCOULEUR(particule12,VERTE) \
,VERTE,VERTE_min \
,cCOULEUR(particule21,VERTE) \
); \
GENERATION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule11,BLEUE) \
,cCOULEUR(particule12,BLEUE) \
,BLEUE,BLEUE_min \
,cCOULEUR(particule21,BLEUE) \
); \
Eblock
/* Conservation de 2 charges de couleur : */
/* */
/* particule21 --> particule11 + particule12. */
/* */
/* ATTENTION : on notera les ecritures suivantes : */
/* */
/* ,ROUGE,ROUGE_min */
/* ,VERTE,VERTE_min */
/* ,BLEUE,BLEUE_min */
/* */
/* qui sont mises sur une seule ligne, et non pas deux, afin que l'operateur de */
/* concatenation fonctionne correctement (en effet, sinon, on retrouve un espace en trop */
/* entre 'ROUGE' (ou 'VERTE' ou 'BLEUE') et la fin du nom)... */
=define CONSERVATION_DE_3_CHARGES_DE_COULEUR(particule11,particule12,particule13,particule21) \
Bblock \
GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule11,ROUGE) \
,cCOULEUR(particule12,ROUGE) \
,cCOULEUR(particule13,ROUGE) \
,ROUGE,ROUGE_min \
,cCOULEUR(particule21,ROUGE) \
); \
GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule11,VERTE) \
,cCOULEUR(particule12,VERTE) \
,cCOULEUR(particule13,VERTE) \
,VERTE,VERTE_min \
,cCOULEUR(particule21,VERTE) \
); \
GENERATION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule11,BLEUE) \
,cCOULEUR(particule12,BLEUE) \
,cCOULEUR(particule13,BLEUE) \
,BLEUE,BLEUE_min \
,cCOULEUR(particule21,BLEUE) \
); \
Eblock
/* Conservation de 3 charges de couleur : */
/* */
/* particule21 --> particule11 + particule12 + particule13. */
/* */
/* ATTENTION : on notera les ecritures suivantes : */
/* */
/* ,ROUGE,ROUGE_min */
/* ,VERTE,VERTE_min */
/* ,BLEUE,BLEUE_min */
/* */
/* qui sont mises sur une seule ligne, et non pas deux, afin que l'operateur de */
/* concatenation fonctionne correctement (en effet, sinon, on retrouve un espace en trop */
/* entre 'ROUGE' (ou 'VERTE' ou 'BLEUE') et la fin du nom)... */
=define CONSERVATION_DE_4_CHARGES_DE_COULEUR(particule11,particule12,particule13,particule14,particule21) \
Bblock \
GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule11,ROUGE) \
,cCOULEUR(particule12,ROUGE) \
,cCOULEUR(particule13,ROUGE) \
,cCOULEUR(particule14,ROUGE) \
,ROUGE,ROUGE_min \
,cCOULEUR(particule21,ROUGE) \
); \
GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule11,VERTE) \
,cCOULEUR(particule12,VERTE) \
,cCOULEUR(particule13,VERTE) \
,cCOULEUR(particule14,VERTE) \
,VERTE,VERTE_min \
,cCOULEUR(particule21,VERTE) \
); \
GENERATION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule11,BLEUE) \
,cCOULEUR(particule12,BLEUE) \
,cCOULEUR(particule13,BLEUE) \
,cCOULEUR(particule14,BLEUE) \
,BLEUE,BLEUE_min \
,cCOULEUR(particule21,BLEUE) \
); \
Eblock
/* Conservation de 4 charges de couleur : */
/* */
/* particule21 --> particule11 + particule12 + particule13 + particule14. */
/* */
/* ATTENTION : on notera les ecritures suivantes : */
/* */
/* ,ROUGE,ROUGE_min */
/* ,VERTE,VERTE_min */
/* ,BLEUE,BLEUE_min */
/* */
/* qui sont mises sur une seule ligne, et non pas deux, afin que l'operateur de */
/* concatenation fonctionne correctement (en effet, sinon, on retrouve un espace en trop */
/* entre 'ROUGE' (ou 'VERTE' ou 'BLEUE') et la fin du nom)... */
=define ADDITION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(compA,compD1,compD2) \
Bblock \
EGAL(compA,ADD2(compD1,compD2)); \
Eblock
/* La somme est faite betement, sans renormalisation... */
=define ADDITION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(compA,compD1,compD2,compD3) \
Bblock \
EGAL(compA,ADD3(compD1,compD2,compD3)); \
Eblock
/* La somme est faite betement, sans renormalisation... */
=define ADDITION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(compA,compD1,compD2,compD3,compD4) \
Bblock \
EGAL(compA,ADD4(compD1,compD2,compD3,compD4)); \
Eblock
/* La somme est faite betement, sans renormalisation... */
=define ADDITION_DE_2_CHARGES_DE_COULEUR(particule21,particule11,particule12) \
Bblock \
ADDITION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule21,ROUGE) \
,cCOULEUR(particule11,ROUGE) \
,cCOULEUR(particule12,ROUGE) \
); \
ADDITION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule21,VERTE) \
,cCOULEUR(particule11,VERTE) \
,cCOULEUR(particule12,VERTE) \
); \
ADDITION_D_UNE_COMPOSANTE_DE_2_CHARGES_DE_COULEUR(cCOULEUR(particule21,BLEUE) \
,cCOULEUR(particule11,BLEUE) \
,cCOULEUR(particule12,BLEUE) \
); \
Eblock
/* Addition de 2 charges de couleur : */
/* */
/* particule21 <-- particule11 + particule12. */
/* */
=define ADDITION_DE_3_CHARGES_DE_COULEUR(particule21,particule11,particule12,particule13) \
Bblock \
ADDITION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule21,ROUGE) \
,cCOULEUR(particule11,ROUGE) \
,cCOULEUR(particule12,ROUGE) \
,cCOULEUR(particule13,ROUGE) \
); \
ADDITION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule21,VERTE) \
,cCOULEUR(particule11,VERTE) \
,cCOULEUR(particule12,VERTE) \
,cCOULEUR(particule13,VERTE) \
); \
ADDITION_D_UNE_COMPOSANTE_DE_3_CHARGES_DE_COULEUR(cCOULEUR(particule21,BLEUE) \
,cCOULEUR(particule11,BLEUE) \
,cCOULEUR(particule12,BLEUE) \
,cCOULEUR(particule13,BLEUE) \
); \
Eblock
/* Addition de 3 charges de couleur : */
/* */
/* particule21 <-- particule11 + particule12 + particule13. */
/* */
=define ADDITION_DE_4_CHARGES_DE_COULEUR(particule21,particule11,particule12,particule13,particule14) \
Bblock \
ADDITION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule21,ROUGE) \
,cCOULEUR(particule11,ROUGE) \
,cCOULEUR(particule12,ROUGE) \
,cCOULEUR(particule13,ROUGE) \
,cCOULEUR(particule14,ROUGE) \
); \
ADDITION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule21,VERTE) \
,cCOULEUR(particule11,VERTE) \
,cCOULEUR(particule12,VERTE) \
,cCOULEUR(particule13,VERTE) \
,cCOULEUR(particule14,VERTE) \
); \
ADDITION_D_UNE_COMPOSANTE_DE_4_CHARGES_DE_COULEUR(cCOULEUR(particule21,BLEUE) \
,cCOULEUR(particule11,BLEUE) \
,cCOULEUR(particule12,BLEUE) \
,cCOULEUR(particule13,BLEUE) \
,cCOULEUR(particule14,BLEUE) \
); \
Eblock
/* Addition de 4 charges de couleur : */
/* */
/* particule21 <-- particule11 + particule12 + particule13 + particule14. */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E N O R M A L I S A T I O N D E L A C H A R G E D E C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
=define RENORMALISATION_DE_LA_CHARGE_DE_COULEUR(particule) \
Bblock \
DEFV(Float,INIT(composante_minimale \
,MIN3(cCOULEUR(particule,ROUGE),cCOULEUR(particule,VERTE),cCOULEUR(particule,BLEUE)) \
) \
); \
DEFV(Float,INIT(composante_maximale \
,MAX3(cCOULEUR(particule,ROUGE),cCOULEUR(particule,VERTE),cCOULEUR(particule,BLEUE)) \
) \
); \
/* Recherche de la plus petite et de la plus grande composante. */ \
Test(IFOU(IFLT(composante_minimale,COULEUR_min) \
,IFGT(composante_maximale,COULEUR_max) \
) \
) \
Bblock \
EGAL(cCOULEUR(particule,ROUGE) \
,HOMO(cCOULEUR(particule,ROUGE) \
,composante_minimale,composante_maximale \
,ROUGE_min,ROUGE_max \
) \
); \
EGAL(cCOULEUR(particule,VERTE) \
,HOMO(cCOULEUR(particule,VERTE) \
,composante_minimale,composante_maximale \
,VERTE_min,VERTE_max \
) \
); \
EGAL(cCOULEUR(particule,BLEUE) \
,HOMO(cCOULEUR(particule,BLEUE) \
,composante_minimale,composante_maximale \
,BLEUE_min,BLEUE_max \
) \
); \
/* Dans le cas ou les extrema des composantes de la charge de couleur sont en dehors du */ \
/* segment [COULEUR_min,COULEUR_max], on renormalise... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/* Renormalisation d'une charge de couleur... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P E R T U R B A T I O N D E L A C H A R G E D E C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
#define MODERATEUR_DE_LA_PERTURBATION_ALEATOIRE_ADDITIVE_DES_TROIS_COMPOSANTES \
FRA3(FU)
DEFV(Local,DEFV(Float,INIT(moderateur_de_la_perturbation_aleatoire_additive_des_trois_composantes
,MODERATEUR_DE_LA_PERTURBATION_ALEATOIRE_ADDITIVE_DES_TROIS_COMPOSANTES
)
)
);
/* Constante multiplicative destinee a limiter l'impact de la perturbation aleatoire */
/* additive appliquee a chacune des composantes des charges de couleur de certaines */
/* particules... */
=define PERTURBATION_ALEATOIRE_ADDITIVE_DE_LA_CHARGE_DE_COULEUR(particule) \
Bblock \
DEFV(Float,INIT(composante_maximale \
,MAX3(cCOULEUR(particule,ROUGE),cCOULEUR(particule,VERTE),cCOULEUR(particule,BLEUE)) \
) \
); \
/* Recherche de la plus grande composante. */ \
DEFV(Float,INIT(perturbation_aleatoire_additive_des_trois_composantes,FLOT__UNDEF)); \
/* Perturbation aleatoire a appliquer additivement aux trois composantes de la charge */ \
/* de couleur. */ \
GENERATION_D_UNE_VALEUR(perturbation_aleatoire_additive_des_trois_composantes \
,SOUS(COULEUR_max,composante_maximale) \
,composante_maximale \
); \
/* Calcul d'une perturbation aleatoire telle qu'aucune des trois composantes n'excedent */ \
/* le maximum 'COULEUR_max'. */ \
EGAL(perturbation_aleatoire_additive_des_trois_composantes \
,MUL2(moderateur_de_la_perturbation_aleatoire_additive_des_trois_composantes \
,perturbation_aleatoire_additive_des_trois_composantes \
) \
); \
/* Calcul de la perturbation aleatoire additive et moderee a appliquer a chacune des */ \
/* composantes des charges de couleur de certaines particules... */ \
INCR(cCOULEUR(particule,ROUGE),perturbation_aleatoire_additive_des_trois_composantes); \
INCR(cCOULEUR(particule,VERTE),perturbation_aleatoire_additive_des_trois_composantes); \
INCR(cCOULEUR(particule,BLEUE),perturbation_aleatoire_additive_des_trois_composantes); \
/* Une meme perturbation additive est applique aux trois composantes de la charge de */ \
/* couleur, et telle que chacune d'elle reste dans [COULEUR_min,COULEUR_max]. */ \
Eblock
/* Perturbation additive des trois composantes d'une charge de couleur. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A J O R A T I O N D E L A C H A R G E D E C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
#define MAJORER_LA_COMPOSANTE_PREPONDERANTE_DE_LA_CHARGE_DE_COULEURS \
FAUX
DEFV(Local,DEFV(Logical,INIT(majorer_la_composante_preponderante_de_la_charge_de_couleurs
,MAJORER_LA_COMPOSANTE_PREPONDERANTE_DE_LA_CHARGE_DE_COULEURS
)
)
);
/* Indicateur controlant la procedeure de majoration qui suit... */
=define MAJORATION_DE_LA_COMPOSANTE_PREPONDERANTE_DE_LA_CHARGE_DE_COULEURS(particule) \
Bblock \
Test(IL_FAUT(majorer_la_composante_preponderante_de_la_charge_de_couleurs)) \
Bblock \
DEFV(Float,INIT(composante_maximale \
,MAX3(cCOULEUR(particule,ROUGE),cCOULEUR(particule,VERTE),cCOULEUR(particule,BLEUE)) \
) \
); \
/* Recherche de la plus grande composante. */ \
Test(IFEQ(cCOULEUR(particule,ROUGE),composante_maximale)) \
Bblock \
EGAL(cCOULEUR(particule,ROUGE),ROUGE_max); \
/* Lorsque le ROUGE est preponderant, on le majore... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEQ(cCOULEUR(particule,VERTE),composante_maximale)) \
Bblock \
EGAL(cCOULEUR(particule,VERTE),VERTE_max); \
/* Lorsque le VERTE est preponderant, on le majore... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEQ(cCOULEUR(particule,BLEUE),composante_maximale)) \
Bblock \
EGAL(cCOULEUR(particule,BLEUE),BLEUE_max); \
/* Lorsque le BLEUE est preponderant, on le majore... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/* Majoration eventuelle de la composante preponderante de la charge de couleurs. */