/*************************************************************************************************************************************/
/* */
/* E T U D E D E L A P E R S I S T A N C E M U L T I P L I C A T I V E */
/* E T A D D I T I V E D E S N O M B R E S : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande (inspiree de la fonction */
/* 'v $ximf/nombres$FON Ipersistance_multiplicative_des_nombres_entiers' */
/* permet d'etudier les persistances multiplicative */
/* et additive des nombres entiers... */
/* */
/* */
/* Author of '$xci/valeurs_Persistance$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20150310133049). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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_MINI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
#define PERSISTANCE_ADDITIVE \
FAUX \
/* Faut-il plutot etudier la persistance additive (au lieu de la multiplicative) ? */
#define BASE_DE_NUMERATION \
BASE10 \
/* Base de numeration. */
#define MAXIMUM_DE_LA_PERSISTANCE \
INFINI \
/* Afin de permettre, par exemple, de reperer les nombres qui initialement contiennent */ \
/* contiennent au moins un zero. Il suffit pour ce faire de prendre un maximum de la */ \
/* 'Persistance' egal a 0 et de ne pas renvoyer la 'Persistance' (et donc renvoyer le */ \
/* 'CumulMultiplicatif_ou_Additif')... */
#define EDITER_UNIQUEMENT_LE_NOMBRE_ET_SA_PERSISTANCE \
FAUX \
/* Faut-il editer uniquement le nombre et sa persistance ('VRAI') ou pas ('FAUX') ? La */ \
/* valeur par defaut garantit la compatibilite anterieure (introduit le 20220329174700)... */
#define EDITER_DES_EN_TETES \
VRAI \
/* Faut-il editer des en-tetes ? */
#define EDITER_LES_NOMBRES \
VRAI \
/* Faut-il editer les nombres eux-memes ? */
#define EDITER_LA_PERSISTANCE_COURANTE \
VRAI \
/* Faut-il editer la persistance ? */
#define EDITER_LA_PERSISTANCE_MAXIMALE \
VRAI \
/* Faut-il editer la persistance maximale ? */
#include xci/valeurs.01.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/valeurs.02.I"
#include xci/valeurs_Persistance.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E T U D E D E L A P E R S I S T A N C E M U L T I P L I C A T I V E */
/* E T A D D I T I V E D E S N O M B 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(persistance_additive,PERSISTANCE_ADDITIVE));
/* Faut-il plutot etudier la persistance additive (au lieu de la multiplicative) ? */
DEFV(Positive,INIT(base_de_numeration,BASE_DE_NUMERATION));
/* Base de numeration. */
DEFV(Positive,INIT(maximum_de_la_Persistance,MAXIMUM_DE_LA_PERSISTANCE));
/* Afin de permettre, par exemple, de reperer les nombres qui initialement contiennent */
/* contiennent au moins un zero. Il suffit pour ce faire de prendre un maximum de la */
/* 'Persistance' egal a 0 et de ne pas renvoyer la 'Persistance' (et donc renvoyer le */
/* 'CumulMultiplicatif_ou_Additif')... */
DEFV(Logical,INIT(editer_uniquement_le_nombre_et_sa_persistance,EDITER_UNIQUEMENT_LE_NOMBRE_ET_SA_PERSISTANCE));
/* Faut-il editer uniquement le nombre et sa persistance ('VRAI') ou pas ('FAUX') ? La */
/* valeur par defaut garantit la compatibilite anterieure (introduit le 20220329174700)... */
DEFV(Logical,INIT(editer_des_en_tetes,EDITER_DES_EN_TETES));
/* Faut-il editer des en-tetes (introduit le 20121109171704) ? */
DEFV(Logical,INIT(editer_les_nombres,EDITER_LES_NOMBRES));
/* Faut-il editer les nombres eux-memes (introduit le 20100102101009) ? */
DEFV(Logical,INIT(editer_la_Persistance_courante,EDITER_LA_PERSISTANCE_COURANTE));
/* Faut-il editer la persistance ? */
DEFV(Logical,INIT(editer_la_Persistance_maximale,EDITER_LA_PERSISTANCE_MAXIMALE));
/* Faut-il editer la persistance maximale ? */
DEFV(Int,INIT(PersistanceMaximale,MOINS_L_INFINI));
/* Calcul de la persistance maximale inutilisee pour le moment... */
#include xci/valeurs.03.I"
/*..............................................................................................................................*/
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(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("additive=""add=",persistance_additive);
GET_ARGUMENT_N("multiplicative=""mul=",persistance_additive);
GET_ARGUMENT_I("base=""b=",base_de_numeration);
GET_ARGUMENT_I("maximum_persistance=""mp=",maximum_de_la_Persistance);
GET_ARGUMENT_L("editer_nombre_persistance=""enp=",editer_uniquement_le_nombre_et_sa_persistance);
/* Argument introduit le 20220329174700... */
GET_ARGUMENT_L("editer_en_tetes=""en_tetes=""et=",editer_des_en_tetes);
GET_ARGUMENT_L("editer_nombres=""nombres=""en=",editer_les_nombres);
GET_ARGUMENT_L("Persistance=""lister=""pc=",editer_la_Persistance_courante);
GET_ARGUMENT_L("PersistanceMaximale=""pm=",editer_la_Persistance_maximale);
GET_ARGUMENT_C("signe=",valeurs_signees);
)
);
Test(IFLE(premiere_image,derniere_image))
Bblock
Test(IL_FAUT(editer_uniquement_le_nombre_et_sa_persistance))
Bblock
EGAL(editer_des_en_tetes,FAUX);
EGAL(editer_les_nombres,FAUX);
EGAL(editer_la_Persistance_courante,FAUX);
Eblock
ATes
Bblock
Eblock
ETes
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
DEFV(Int,INIT(nombre_courant,numero_d_image));
/* Nombre entier courant a tester. */
DEFV(Int,INIT(CumulMultiplicatif_ou_Additif
,COND(IL_NE_FAUT_PAS(persistance_additive)
,UN
,ZERO
)
)
);
DEFV(Int,INIT(Reduction,UNDEF));
DEFV(Int,INIT(Persistance,ZERO));
Test(IZLT(nombre_courant))
Bblock
PRINT_ERREUR("la persistance additive/multiplicative n'a de sens que pour les nombres positifs ou nuls");
CAL1(Prer1("(le nombre %d est negatif)\n",nombre_courant));
EGAL(nombre_courant,ABSO(nombre_courant));
/* On prend donc la valeur absolue des nombres negatifs... */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(Reduction,nombre_courant);
Test(IL_FAUT(editer_les_nombres))
Bblock
CAL2(Prin1(Cara(chain_Aconcaten5(COND(IL_FAUT(editer_des_en_tetes),"Nombre=",C_VIDE)
,INTRODUCTION_FORMAT
,valeurs_signees
,"d"
," : "
)
)
,nombre_courant
)
);
/* Edition des nombres eux-memes. */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(editer_la_Persistance_courante))
Bblock
CAL2(Prin1("%d",Reduction));
Test(IFLT(Reduction,base_de_numeration))
Bblock
CAL2(Prin2(" --%d--> %d",Persistance,Reduction));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Tant(IFET(IFGE(Reduction,base_de_numeration)
,IFLE(Persistance,maximum_de_la_Persistance)
)
)
Bblock
DEFV(Int,INIT(Quotient,Reduction));
DEFV(Int,INIT(Reste,UNDEF));
EGAL(CumulMultiplicatif_ou_Additif
,COND(IL_NE_FAUT_PAS(persistance_additive)
,UN
,ZERO
)
);
/* La reinitialisation de 'CumulMultiplicatif_ou_Additif' doit avoir lieu evidemment a */
/* chaque nouvelle iteration du 'Tant(...)'... */
Tant(IFNE(Quotient,ZERO))
Bblock
EGAL(Reste,REST(Quotient,base_de_numeration));
EGAL(Quotient,DIVI(Quotient,base_de_numeration));
CUMUL_MULTIPLICATIF_OU_ADDITIF;
/* Cette procedure est rendue obligatoire a cause du 'OPC2(...)' qu'elle contient... */
Eblock
ETan
EGAL(Reduction,CumulMultiplicatif_ou_Additif);
INCR(Persistance,I);
Test(IL_FAUT(editer_la_Persistance_courante))
Bblock
CAL2(Prin2(" --%d--> %d",Persistance,Reduction));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETan
EGAL(PersistanceMaximale,MAX2(PersistanceMaximale,Persistance));
Test(IL_FAUT(editer_la_Persistance_courante))
Bblock
CAL2(Prin1(" Persistance=%d",Persistance));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IL_FAUT(editer_les_nombres),IL_FAUT(editer_la_Persistance_courante)))
Bblock
CAL2(Prin0("\n"));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(editer_uniquement_le_nombre_et_sa_persistance))
Bblock
CAL2(Prin2("p(%d)=%d\n",nombre_courant,Persistance));
/* Possibilite introduite le 20220329174700... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
Test(IL_FAUT(editer_la_Persistance_maximale))
Bblock
CAL2(Prin1("\nPersistanceMaximale=%d\n",PersistanceMaximale));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la relation d'ordre stricte ('premier < dernier') n'est pas respectee");
Eblock
ETes
RETU_Commande;
Eblock
ECommande