/*************************************************************************************************************************************/
/* */
/* P R O D U I T D E H O R N E R D U Q U A T R I E M E D E G R E */
/* D E D E U X I M A G E S F L O T T A N T E S : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande genere une image */
/* dont le nom est le premier argument */
/* d'appel ; elle est le resultat de */
/* du produit 'HORNER_2_04(...)' */
/* des deux images Arguments. */
/* */
/* */
/* Author of '$xci/ProduitHorner_2_04.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20181119103604). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
#include image_image_IMAGESF_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define CALCULER_LA_PUISSANCE_2_PUISSANCE_N_D_UNE_IMAGE_PLUTOT_QU_UN_PRODUIT_DE_DEUX \
FAUX \
/* Indique s'il faut ('VRAI') ou pas ('FAUX') calculer plutot le "carre" d'une image. */
#define CALCULER_LA_PUISSANCE_N_PLUTOT_QUE_LA_PUISSANCE_2_PUISSANCE_N \
FAUX \
/* Indique s'il faut en fait calculer une puissance ('VRAI') plutot qu'un "carre" ('FAUX'). */
#define NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE \
UN \
/* Soit N le nombre d'iterations de la puissance ; deux cas se presentent alors : */ \
/* */ \
/* IL_NE_FAUT_PAS(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */ \
/* L'image Argument est elevee a la puissance 2^N. */ \
/* */ \
/* IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */ \
/* L'image Argument est elevee a la puissance N. */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define PRODUIT_HORNER_2_04(imageR,imageA1,imageA2) \
Bblock \
CALS(IFproduit_de_Horner_2_04(imageR \
,imageA1 \
,imageA2 \
,image_a44 \
,image_a43 \
,image_a42 \
,image_a41 \
,image_a40 \
,image_a34 \
,image_a33 \
,image_a32 \
,image_a31 \
,image_a30 \
,image_a24 \
,image_a23 \
,image_a22 \
,image_a21 \
,image_a20 \
,image_a14 \
,image_a13 \
,image_a12 \
,image_a11 \
,image_a10 \
,image_a04 \
,image_a03 \
,image_a02 \
,image_a01 \
,image_a00 \
) \
); \
Eblock \
/* Combinaison universelle variable... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O D U I T D E H O R N E R D E D E U X I M A G E S F L O T T A N T E S : */
/* D E D E U X I M A G E S F L O T T A N T E S : */
/* */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageA1),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageA2),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a44),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a43),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a42),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a41),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a40),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a34),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a33),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a32),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a31),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a30),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a24),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a23),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a22),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a21),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a20),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a14),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a13),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a12),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a11),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a10),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a04),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a03),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a02),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a01),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_image_a00),NOM_PIPE));
DEFV(Logical,INIT(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
,CALCULER_LA_PUISSANCE_2_PUISSANCE_N_D_UNE_IMAGE_PLUTOT_QU_UN_PRODUIT_DE_DEUX
)
);
/* Indique s'il faut ('VRAI') ou pas ('FAUX') calculer plutot le "carre" d'une image. */
DEFV(Logical,INIT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N
,CALCULER_LA_PUISSANCE_N_PLUTOT_QUE_LA_PUISSANCE_2_PUISSANCE_N
)
);
/* Indique s'il faut en fait calculer une puissance ('VRAI') plutot qu'un "carre" ('FAUX'). */
DEFV(Positive,INIT(nombre_d_iterations_de_la_puissance,NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE));
/* Soit N le nombre d'iterations de la puissance ; deux cas se presentent alors : */
/* */
/* IL_NE_FAUT_PAS(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */
/* L'image Argument est elevee a la puissance 2^N. */
/* */
/* IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N) */
/* L'image Argument est elevee a la puissance N. */
/* */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_C("imageA1=""A1=""imageA=""A=",nom_imageA1);
GET_ARGUMENT_C("imageA2=""A2=",nom_imageA2);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_C("a44=",nom_image_a44);
GET_ARGUMENT_C("a43=",nom_image_a43);
GET_ARGUMENT_C("a42=",nom_image_a42);
GET_ARGUMENT_C("a41=",nom_image_a41);
GET_ARGUMENT_C("a40=",nom_image_a40);
GET_ARGUMENT_C("a34=",nom_image_a34);
GET_ARGUMENT_C("a33=",nom_image_a33);
GET_ARGUMENT_C("a32=",nom_image_a32);
GET_ARGUMENT_C("a31=",nom_image_a31);
GET_ARGUMENT_C("a30=",nom_image_a30);
GET_ARGUMENT_C("a24=",nom_image_a24);
GET_ARGUMENT_C("a23=",nom_image_a23);
GET_ARGUMENT_C("a22=",nom_image_a22);
GET_ARGUMENT_C("a21=",nom_image_a21);
GET_ARGUMENT_C("a20=",nom_image_a20);
GET_ARGUMENT_C("a14=",nom_image_a14);
GET_ARGUMENT_C("a13=",nom_image_a13);
GET_ARGUMENT_C("a12=",nom_image_a12);
GET_ARGUMENT_C("a11=",nom_image_a11);
GET_ARGUMENT_C("a10=",nom_image_a10);
GET_ARGUMENT_C("a04=",nom_image_a04);
GET_ARGUMENT_C("a03=",nom_image_a03);
GET_ARGUMENT_C("a02=",nom_image_a02);
GET_ARGUMENT_C("a01=",nom_image_a01);
GET_ARGUMENT_C("a00=",nom_image_a00);
GET_ARGUMENT_L("carre_image=""ci=""c=""exponentiation_image=""expi="
,calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
);
GET_ARGUMENT_N("produit_images=""pi=""p="
,calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
);
PROCESS_ARGUMENT_L("puissance_image=""puis="
,calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N
,BLOC(VIDE;)
,BLOC(
Bblock
EGAL(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux
,VRAI
);
/* Cette argument est force a priori... */
Eblock
)
);
GET_ARGUMENT_I("iterations=""nombre_carres=""nombre=""n=",nombre_d_iterations_de_la_puissance);
PROCESS_ARGUMENT_I("exposant=""exp="
,nombre_d_iterations_de_la_puissance
,BLOC(VIDE;)
,BLOC(
Bblock
Test(IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N))
Bblock
Eblock
ATes
Bblock
Test(IZGT(nombre_d_iterations_de_la_puissance))
Bblock
Eblock
ATes
Bblock
PRINT_ATTENTION("l'exposant est negatif ou nul");
EGAL(nombre_d_iterations_de_la_puissance
,NOMBRE_D_ITERATIONS_DE_LA_PUISSANCE
);
CAL1(Prer1("(la valeur par defaut (%d) est forcee)\n"
,nombre_d_iterations_de_la_puissance
)
);
Eblock
ETes
EGAL(nombre_d_iterations_de_la_puissance
,INTE(LO2X(nombre_d_iterations_de_la_puissance))
);
/* On notera qu'evidemment, la valeur de 'LO2X(...)' est rarement entiere... */
Eblock
ETes
Eblock
)
);
)
);
CALi(IFinitialisation(IFmageR,FZERO));
/* Initialisation de l'image Resultat. */
begin_nouveau_block
Bblock
BDEFV(imageF,image_a44);
BDEFV(imageF,image_a43);
BDEFV(imageF,image_a42);
BDEFV(imageF,image_a41);
BDEFV(imageF,image_a40);
BDEFV(imageF,image_a34);
BDEFV(imageF,image_a33);
BDEFV(imageF,image_a32);
BDEFV(imageF,image_a31);
BDEFV(imageF,image_a30);
BDEFV(imageF,image_a24);
BDEFV(imageF,image_a23);
BDEFV(imageF,image_a22);
BDEFV(imageF,image_a21);
BDEFV(imageF,image_a20);
BDEFV(imageF,image_a14);
BDEFV(imageF,image_a13);
BDEFV(imageF,image_a12);
BDEFV(imageF,image_a11);
BDEFV(imageF,image_a10);
BDEFV(imageF,image_a04);
BDEFV(imageF,image_a03);
BDEFV(imageF,image_a02);
BDEFV(imageF,image_a01);
BDEFV(imageF,image_a00);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a44,nom_image_a44,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a43,nom_image_a43,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a42,nom_image_a42,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a41,nom_image_a41,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a40,nom_image_a40,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a34,nom_image_a34,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a33,nom_image_a33,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a32,nom_image_a32,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a31,nom_image_a31,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a30,nom_image_a30,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a24,nom_image_a24,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a23,nom_image_a23,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a22,nom_image_a22,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a21,nom_image_a21,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a20,nom_image_a20,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a14,nom_image_a14,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a13,nom_image_a13,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a12,nom_image_a12,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a11,nom_image_a11,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a10,nom_image_a10,NOM_PIPE,FU);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a04,nom_image_a04,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a03,nom_image_a03,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a02,nom_image_a02,NOM_PIPE,FZERO);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a01,nom_image_a01,NOM_PIPE,FU);
CHARGEMENT_D_UNE_IMAGE_FLOTTANTE_OU_INITIALISATION_EN_CAS_D_ABSENCE(image_a00,nom_image_a00,NOM_PIPE,FZERO);
/* L'initialisation par defaut est faite avec "A1+A2"... */
Test(IL_NE_FAUT_PAS(calculer_la_puissance_2_puissance_N_d_une_image_plutot_qu_un_produit_de_deux))
Bblock
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA1,nom_imageA1))))
Bblock
/* Chargement de la premiere image Argument. */
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageA2,nom_imageA2))))
Bblock
/* Chargement de la deuxieme image Argument. */
CALS(PRODUIT_HORNER_2_04(IFmageR
,IFmageA1
,IFmageA2
)
);
/* Et produit des deux images arguments 'ImageA1' et 'ImageA2'. */
CALi(IupdateF_image(nom_imageR,IFmageR));
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ATes
Bblock
Test(IFNE_chaine(nom_imageA2,NOM_PIPE))
Bblock
PRINT_ATTENTION("lors du calcul du carre d'une image, un seul nom doit etre donne");
Eblock
ATes
Bblock
Eblock
ETes
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(IFmageR,nom_imageA1))))
Bblock
/* Chargement de l'image Argument unique. */
Test(IL_FAUT(calculer_la_puissance_N_plutot_que_la_puissance_2_puissance_N))
Bblock
CALS(IFmove(IFmageA1,IFmageR));
CALS(IFinitialisation(IFmageR,FU));
Repe(nombre_d_iterations_de_la_puissance)
Bblock
CALS(PRODUIT_HORNER_2_04(IFmageR
,IFmageR
,IFmageA1
)
);
/* Elevation a la puissance N de l'image Argument unique. */
Eblock
ERep
Eblock
ATes
Bblock
Repe(NEUT(nombre_d_iterations_de_la_puissance))
Bblock
CALS(IFmove(IFmageA1,IFmageR));
CALS(PRODUIT_HORNER_2_04(IFmageR
,IFmageA1
,IFmageA1
)
);
/* Elevation a la puissance 2^N de l'image Argument unique. */
Eblock
ERep
Eblock
ETes
CALi(IupdateF_image(nom_imageR,IFmageR));
Eblock
ATes
Bblock
Test__CODE_ERREUR__ERREUR07;
Eblock
ETes
Eblock
ETes
EDEFV(imageF,image_a00);
EDEFV(imageF,image_a01);
EDEFV(imageF,image_a02);
EDEFV(imageF,image_a03);
EDEFV(imageF,image_a04);
EDEFV(imageF,image_a10);
EDEFV(imageF,image_a11);
EDEFV(imageF,image_a12);
EDEFV(imageF,image_a13);
EDEFV(imageF,image_a14);
EDEFV(imageF,image_a20);
EDEFV(imageF,image_a21);
EDEFV(imageF,image_a22);
EDEFV(imageF,image_a23);
EDEFV(imageF,image_a24);
EDEFV(imageF,image_a30);
EDEFV(imageF,image_a31);
EDEFV(imageF,image_a32);
EDEFV(imageF,image_a33);
EDEFV(imageF,image_a34);
EDEFV(imageF,image_a40);
EDEFV(imageF,image_a41);
EDEFV(imageF,image_a42);
EDEFV(imageF,image_a43);
EDEFV(imageF,image_a44);
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande