/*************************************************************************************************************************************/
/* */
/* E T U D E D E L A D Y N A M I Q U E D E V E R H U L S T */
/* E N M O D I F I A N T B I T A B I T L A P R E C I S I O N */
/* D E S C A L C U L S E F F E C T U E S A V E C E D I T I O N D E X [ n ] : */
/* */
/* */
/* Author of '$xrk/verhulst.03$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1988??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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_CPP_____AUTORISER_LE_GooF
/* Ceci est essentiel puisque l'on souhaite etudier l'influence de la syntaxe sur les */
/* resultats obtenus. Ceci manquait et a ete introduit le 20040420233036. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
#define NOMBRE_D_ITERATIONS \
PARE(100000) \
/* Nombre d'iterations a effectuer. */
#define PAS_D_EDITION \
PARE(10000) \
/* On editera la valeur de X[n] toutes les 'PAS_D_EDITION' valeurs. */
#define VALEUR_INITIALE_X0 \
PARE(0.5) \
/* Valeur de X[0]. */
#define TAUX_DE_CROISSANCE \
PARE(3.0) \
/* Valeur de 'r'. */
#define MASQUE_DE_PRECISION_32 \
PAR1(MMOT) \
/* Masque avec toute la precision, */
#define MASQUE_DE_PRECISION_31 \
PAR0(MMOT) \
/* Masque avec toute la precision moins 1 bit. */
#define MASQUE_DE_PRECISION \
MASQUE_DE_PRECISION_32 \
/* Masque a appliquer pour simuler une precision de 32 a 1 bits. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define PRECISION(X) \
Bblock \
EGAL(flint_InT(X),ETLO(flint_InT(X),precision_des_calculs)); \
Eblock \
/* Pour eliminer des bits dans la representation flottante... */
#define ITERATION_PRECISE(Xn) \
Bblock \
EGAL(flint_FloaT(Xn) \
,SOUS(MUL2(ADD2(flint_FloaT(taux_de_croissance),I) \
,flint_FloaT(Xn) \
) \
,MUL2(flint_FloaT(taux_de_croissance) \
,EXP2(flint_FloaT(Xn)) \
) \
) \
); \
/* Nota important : le code genere correspond a : */ \
/* */ \
/* 2 */ \
/* ((1+r).X[n]) - (r.(X[n] )) */ \
/* */ \
/* qui ne donne pas du tout les memes resultats numeriques que : */ \
/* */ \
/* 2 */ \
/* ((1+r).X[n]) - (r.X[n] ) */ \
/* */ \
/* ce qui est dans la logique du chaos deterministe... */ \
Eblock \
/* Iteration avec toute la precision possible. */
#define ITERATION_IMPRECISE(Xn) \
Bblock \
EGAL(flint_FloaT(manoeuvre_1),ADD2(flint_FloaT(taux_de_croissance),I)); \
PRECISION(manoeuvre_1); \
/* Calcul de : (1 + r). */ \
EGAL(flint_FloaT(manoeuvre_2),MUL2(flint_FloaT(manoeuvre_1),flint_FloaT(Xn))); \
PRECISION(manoeuvre_2); \
/* Calcul de : (1 + r).X[n]. */ \
EGAL(flint_FloaT(manoeuvre_3),EXP2(flint_FloaT(Xn))); \
PRECISION(manoeuvre_3); \
/* 2 */ \
/* calcul de : X[n] . */ \
EGAL(flint_FloaT(manoeuvre_4),MUL2(flint_FloaT(taux_de_croissance),flint_FloaT(manoeuvre_3))); \
PRECISION(manoeuvre_4); \
/* 2 */ \
/* calcul de : r.X[n] . */ \
EGAL(flint_FloaT(manoeuvre_5),SOUS(flint_FloaT(manoeuvre_2),flint_FloaT(manoeuvre_4))); \
PRECISION(manoeuvre_5); \
/* 2 */ \
/* calcul de : (1+r).X[n] - r.X[n] . */ \
EGAL(flint_FloaT(Xn),flint_FloaT(manoeuvre_5)); \
Eblock \
/* Iteration avec la precision definie par 'precision_des_calculs'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E T U D E D E L A D Y N A M I Q U E D E V E R H U L S T : */
/* */
/* */
/* Definition : */
/* */
/* Considerons la relation de recurrence */
/* suivante : */
/* */
/* 2 */
/* X[n+1] = (1+r).X[n] - r.X[n] */
/* */
/* Cette relation correspond par exemple */
/* a la population annuelle d'une colonie */
/* animale, dont le taux de croissance est R ; */
/* par definition, on a : */
/* */
/* X[n+1] - X[n] */
/* R = ------------- */
/* X[n] */
/* */
/* d'ou : */
/* */
/* X[n+1] = (1+R).X[n] */
/* */
/* le taux de croissance n'est en fait pas */
/* constant, et vaut : */
/* */
/* R = r.(1-X[n]) */
/* */
/* d'ou la premiere formule. */
/* */
/* Celle-ci, bien que strictement deterministe */
/* pour des valeurs de 'r' superieures a 2.57, */
/* donnent pour des grandes valeurs 'N' de 'n' */
/* des series de valeurs completement chaotiques */
/* et qui sont completement sensibles a la valeur */
/* initiale X[0]. */
/* */
/* */
/* Objectif : */
/* */
/* montrer que les resultats changent du */
/* tout au tout soit en changeant d'ordinateur, */
/* soit plus simplement en changeant la precision */
/* des calculs (ce qui est previsible, puisque */
/* cette iteration chaotique depend de tous les */
/* bits, et donc de la representation interne */
/* des nombres flottants)... */
/* */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(flint,taux_de_croissance);
DEFV(flint,Xn);
/* Definition de la recurrence X[n]. */
DEFV(Positive,INIT(precision_des_calculs,MASQUE_DE_PRECISION));
/* Definition de la precision des calculs sous la forme d'une masque. */
DEFV(flint,manoeuvre_1);
DEFV(flint,manoeuvre_2);
DEFV(flint,manoeuvre_3);
DEFV(flint,manoeuvre_4);
DEFV(flint,manoeuvre_5);
/* Variables de manoeuvre... */
DEFV(Int,INIT(n,UNDEF));
/* Definition de l'index de la recurrence 'n'. */
/*..............................................................................................................................*/
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(VIDE;)
);
EGAL(flint_FloaT(taux_de_croissance),TAUX_DE_CROISSANCE);
EGAL(flint_FloaT(Xn),VALEUR_INITIALE_X0);
/* Definition de la recurrence X[n]. */
CAL2(Prin1("precision des calculs =%08x\n",precision_des_calculs));
CAL2(Prin1("taux de croissance : r=%g\n\n",flint_FloaT(taux_de_croissance)));
DoIn(n,PRED(UN),PRED(NOMBRE_D_ITERATIONS),I)
Bblock
Test(IZEQ(REST(n,PAS_D_EDITION)))
Bblock
CAL2(Prin2("X[%d] = %g\n",n,flint_FloaT(Xn)));
Eblock
ATes
Bblock
Eblock
ETes
USs_GooF(BLOC(
Bblock
ITERATION_IMPRECISE(Xn);
Eblock
)
);
/* Procedure introduite le 20080106095439... */
Eblock
EDoI
RETU_Commande;
Eblock
ECommande