/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A P P L I C A T I O N   D E   L A   T R A N S F O R M A T I O N   C O N F O R M E   H O M O G R A P H I Q U E              */
/*        D A N S   L E   P L A N   H Y P E R - C O M P L E X E  :                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrv/q_homographique.41$K' :                                                                                    */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20220613090925).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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
#define   PRAGMA_CPP_____SI_LE_GooF_EST_ACTIVABLE_ALORS_FAIRE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_BASE

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V A L E U R S   I M P L I C I T E S   D E S   P A R A M E T R E S  :                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_D_ITERATIONS                                                                                                           \
                    UN                                                                                                                  \
                                        /* Nombre d'iterations de la transformation (introduit le 20220604083802).                   */


#define   MODE_UNITE__                                                                                                                  \
                    FAUX
#define   MODE_INVERSE                                                                                                                  \
                    FAUX
#define   MODE_CARRE__                                                                                                                  \
                    FAUX
                                        /* Quelques modes simples a priori...                                                        */

#define   EXPOSANT_NUMERATEUR__                                                                                                         \
                    FU
#define   EXPOSANT_DENOMINATEUR                                                                                                         \
                    FU
                                        /* Exposants des Numerateur et Denominateur.                                                 */

#define   PARTIE_REELLE_____DE_A                                                                                                        \
                    FU
#define   PARTIE_IMAGINAIRE_DE_A                                                                                                        \
                    FZERO
#define   PARTIE_JMAGINAIRE_DE_A                                                                                                        \
                    FZERO
#define   PARTIE_KMAGINAIRE_DE_A                                                                                                        \
                    FZERO
                                        /* Nombre hyper-complexe 'A'.                                                                */

#define   PARTIE_REELLE_____DE_B                                                                                                        \
                    FZERO
#define   PARTIE_IMAGINAIRE_DE_B                                                                                                        \
                    FZERO
#define   PARTIE_JMAGINAIRE_DE_B                                                                                                        \
                    FZERO
#define   PARTIE_KMAGINAIRE_DE_B                                                                                                        \
                    FZERO
                                        /* Nombre hyper-complexe 'B'.                                                                */

#define   PARTIE_REELLE_____DE_C                                                                                                        \
                    FZERO
#define   PARTIE_IMAGINAIRE_DE_C                                                                                                        \
                    FZERO
#define   PARTIE_JMAGINAIRE_DE_C                                                                                                        \
                    FZERO
#define   PARTIE_KMAGINAIRE_DE_C                                                                                                        \
                    FZERO
                                        /* Nombre hyper-complexe 'C'.                                                                */
#define   PARTIE_REELLE_____DE_D                                                                                                        \
                    FU
#define   PARTIE_IMAGINAIRE_DE_D                                                                                                        \
                    FZERO
#define   PARTIE_JMAGINAIRE_DE_D                                                                                                        \
                    FZERO
#define   PARTIE_KMAGINAIRE_DE_D                                                                                                        \
                    FZERO
                                        /* Nombre hyper-complexe 'D'.                                                                */

#define   PONDERATION_R                                                                                                                 \
                    FZERO
#define   PONDERATION_I                                                                                                                 \
                    FZERO
#define   PONDERATION_J                                                                                                                 \
                    FZERO
#define   PONDERATION_K                                                                                                                 \
                    FZERO
                                        /* Ponderation de selection des coordonnees apres transformation.                            */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   T R O I S   F I C H I E R S  :                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/ARITHMET.1d.I"
#include  xrv/ARITHMET.21.I"
#include  xrv/champs_5.41.I"

#define   R_IMPLICITE                                                                                                                   \
                    FZERO
#define   I_IMPLICITE                                                                                                                   \
                    FZERO
#define   J_IMPLICITE                                                                                                                   \
                    FZERO
#define   K_IMPLICITE                                                                                                                   \
                    FZERO

gGENERATION_D_UN_FICHIER(fichier_LISTE_R,liste_initiale_des_R);
gGENERATION_D_UN_FICHIER(fichier_LISTE_I,liste_initiale_des_I);
gGENERATION_D_UN_FICHIER(fichier_LISTE_J,liste_initiale_des_J);
gGENERATION_D_UN_FICHIER(fichier_LISTE_K,liste_initiale_des_K);
                                        /* Definition en memoire des fichiers de coordonnees.                                        */

#define   ELEMENT_DU_FICHIER_LISTE_R(index)                                                                                             \
                    gELEMENT_DU_FICHIER(liste_initiale_des_R,index)
#define   ELEMENT_DU_FICHIER_LISTE_I(index)                                                                                             \
                    gELEMENT_DU_FICHIER(liste_initiale_des_I,index)
#define   ELEMENT_DU_FICHIER_LISTE_J(index)                                                                                             \
                    gELEMENT_DU_FICHIER(liste_initiale_des_J,index)
#define   ELEMENT_DU_FICHIER_LISTE_K(index)                                                                                             \
                    gELEMENT_DU_FICHIER(liste_initiale_des_K,index)

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N I T I A L I S A T I O N S   D I V E R S E S  :                                                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#define   INITIALISATION_SPECIFIQUE(eN,eD,nombre_A0,nombre_B0,nombre_C0,nombre_D0)                                                      \
                    Bblock                                                                                                              \
                    EGAL(exposant_numerateur__,eN);                                                                                     \
                    EGAL(exposant_denominateur,eD);                                                                                     \
                                                                                                                                        \
                    HCegal(nombre_A,nombre_A0);                                                                                         \
                    HCegal(nombre_B,nombre_B0);                                                                                         \
                    HCegal(nombre_C,nombre_C0);                                                                                         \
                    HCegal(nombre_D,nombre_D0);                                                                                         \
                    Eblock

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A P P L I C A T I O N   D E   L A   T R A N S F O R M A T I O N   C O N F O R M E   H O M O G R A P H I Q U E              */
/*        D A N S   L E   P L A N   H Y P E R - C O M P L E X E  :                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
#include  xrv/ARITHMET.22.I"
#include  xci/valeurs.03.I"

     DEFV(Positive,INIT(nombre_d_iterations,NOMBRE_D_ITERATIONS));
                                        /* Nombre d'iterations de la transformation (introduit le 20220604083802).                   */

     DEFV(Logical,INIT(mode_unite__,MODE_UNITE__));
     DEFV(Logical,INIT(mode_inverse,MODE_INVERSE));
     DEFV(Logical,INIT(mode_carre__,MODE_CARRE__));
                                        /* Quelques modes simples a priori...                                                        */
                                        /*                                                                                           */
                                        /* On notera que ces trois indicateurs ne servent que pour les 'PROCESS_ARGUMENT_L(...)'s.   */

     DEFV(Float,INIT(exposant_numerateur__,EXPOSANT_NUMERATEUR__));
     DEFV(Float,INIT(exposant_denominateur,EXPOSANT_DENOMINATEUR));
                                        /* Exposants des Numerateur et Denominateur.                                                 */

     DEFV(hyper_complexe,nombre_A);
     DEFV(hyper_complexe,nombre_B);
     DEFV(hyper_complexe,nombre_C);
     DEFV(hyper_complexe,nombre_D);
                                        /* Definition des quatre coefficients de la transformation homographique...                  */

     DEFV(Float,INIT(ponderation_R,PONDERATION_R));
     DEFV(Float,INIT(ponderation_I,PONDERATION_I));
     DEFV(Float,INIT(ponderation_J,PONDERATION_J));
     DEFV(Float,INIT(ponderation_K,PONDERATION_K));
                                        /* Ponderation de selection des coordonnees apres transformation.                            */
     /*..............................................................................................................................*/
#include  xrv/champs_5.1A.I"

     HCinitialisation(nombre_A
                     ,PARTIE_REELLE_____DE_A
                     ,PARTIE_IMAGINAIRE_DE_A
                     ,PARTIE_JMAGINAIRE_DE_A
                     ,PARTIE_KMAGINAIRE_DE_A
                      );
     HCinitialisation(nombre_B
                     ,PARTIE_REELLE_____DE_B
                     ,PARTIE_IMAGINAIRE_DE_B
                     ,PARTIE_JMAGINAIRE_DE_B
                     ,PARTIE_KMAGINAIRE_DE_B
                      );
     HCinitialisation(nombre_C
                     ,PARTIE_REELLE_____DE_C
                     ,PARTIE_IMAGINAIRE_DE_C
                     ,PARTIE_JMAGINAIRE_DE_C
                     ,PARTIE_KMAGINAIRE_DE_C
                      );
     HCinitialisation(nombre_D
                     ,PARTIE_REELLE_____DE_D
                     ,PARTIE_IMAGINAIRE_DE_D
                     ,PARTIE_JMAGINAIRE_DE_D
                     ,PARTIE_KMAGINAIRE_DE_D
                      );
                                        /* Initialisation des quatre coefficients de la transformation homographique...              */

     GET_ARGUMENTS_(nombre_d_arguments
                   ,BLOC(PROCESS_ARGUMENT_I("nombre_elements=""ne=",nombre_d_elements
                                           ,BLOC(VIDE;)
                                           ,BLOC(Bblock
                                                 PRINT_AVERTISSEMENT("'ne=' doit etre defini avant toute entree de fichiers");
                                                 Eblock
                                                 )
                                            );

                         PROCESS_ARGUMENTS_DE_DEFINITION_DES_FICHIERS_01;

                         PROKESF_ARGUMENT_FICHIER("LISTE_R=""LISTE_X="
                                                 ,fichier_LISTE_R
                                                 ,liste_initiale_des_R
                                                 ,R_IMPLICITE
                                                 ,lTRANSFORMAT_0d
                                                 ,iGENERATION_D_UN_FICHIER
                                                  );
                         PROKESF_ARGUMENT_FICHIER("LISTE_I=""LISTE_Y="
                                                 ,fichier_LISTE_I
                                                 ,liste_initiale_des_I
                                                 ,I_IMPLICITE
                                                 ,lTRANSFORMAT_0d
                                                 ,iGENERATION_D_UN_FICHIER
                                                  );
                         PROKESF_ARGUMENT_FICHIER("LISTE_J=""LISTE_Z="
                                                 ,fichier_LISTE_J
                                                 ,liste_initiale_des_J
                                                 ,J_IMPLICITE
                                                 ,lTRANSFORMAT_0d
                                                 ,iGENERATION_D_UN_FICHIER
                                                  );
                         PROKESF_ARGUMENT_FICHIER("LISTE_K="
                                                 ,fichier_LISTE_K
                                                 ,liste_initiale_des_K
                                                 ,K_IMPLICITE
                                                 ,lTRANSFORMAT_0d
                                                 ,iGENERATION_D_UN_FICHIER
                                                  );

                         GET_ARGUMENT_I("nombre=""iterations=",nombre_d_iterations);

                         PROCESS_ARGUMENT_L("mode_unite=""mu=",mode_unite__
                                           ,BLOC(VIDE;)
                                           ,BLOC(Bblock
                                                 INITIALISATION_SPECIFIQUE(UN,UN
                                                                          ,HC_____quaternion_p1__0__0__0
                                                                          ,HC_____quaternion__0__0__0__0
                                                                          ,HC_____quaternion__0__0__0__0
                                                                          ,HC_____quaternion_p1__0__0__0
                                                                           );
                                        /* Definition :                                                                              */
                                        /*                                                                                           */
                                        /*                  transformation(q) = q                                                    */
                                        /*                                                                                           */
                                        /* L'interet de faire cela avec 'PROCESS_ARGUMENT_L(...)' est de pouvoir ensuite redefinir   */
                                        /* les exposants et/ou les definitions des 'nombre_?'...                                     */
                                        /*                                                                                           */
                                        /* On notera que le mode "unite" est aussi le mode par defaut, mais on ne sait jamais...     */
                                                 Eblock
                                                 )
                                            );
                         PROCESS_ARGUMENT_L("mode_inverse=""mi=",mode_inverse
                                           ,BLOC(VIDE;)
                                           ,BLOC(Bblock
                                                 INITIALISATION_SPECIFIQUE(UN,UN
                                                                          ,HC_____quaternion__0__0__0__0
                                                                          ,HC_____quaternion_p1__0__0__0
                                                                          ,HC_____quaternion_p1__0__0__0
                                                                          ,HC_____quaternion__0__0__0__0
                                                                           );
                                        /* Definition :                                                                              */
                                        /*                                                                                           */
                                        /*                                       1                                                   */
                                        /*                  transformation(q) = ---                                                  */
                                        /*                                       q                                                   */
                                        /*                                                                                           */
                                        /* L'interet de faire cela avec 'PROCESS_ARGUMENT_L(...)' est de pouvoir ensuite redefinir   */
                                        /* les exposants et/ou les definitions des 'nombre_?'...                                     */
                                                 Eblock
                                                 )
                                            );
                         PROCESS_ARGUMENT_L("mode_carre=""mc=",mode_carre__
                                           ,BLOC(VIDE;)
                                           ,BLOC(Bblock
                                                 INITIALISATION_SPECIFIQUE(DEUX,UN
                                                                          ,HC_____quaternion_p1__0__0__0
                                                                          ,HC_____quaternion__0__0__0__0
                                                                          ,HC_____quaternion__0__0__0__0
                                                                          ,HC_____quaternion_p1__0__0__0
                                                                           );
                                        /* Definition :                                                                              */
                                        /*                                                                                           */
                                        /*                                       2                                                   */
                                        /*                  transformation(q) = q                                                    */
                                        /*                                                                                           */
                                        /* L'interet de faire cela avec 'PROCESS_ARGUMENT_L(...)' est de pouvoir ensuite redefinir   */
                                        /* les exposants et/ou les definitions des 'nombre_?'...                                     */
                                                 Eblock
                                                 )
                                            );

                         GET_ARGUMENT_F("exposant_numerateur=""eN=",exposant_numerateur__);
                         GET_ARGUMENT_F("exposant_denominateur=""eD=",exposant_denominateur);

                         GET_ARGUMENT_F("RA=",HReelle(nombre_A));
                         GET_ARGUMENT_F("IA=",HImaginaire(nombre_A));
                         GET_ARGUMENT_F("JA=",HJmaginaire(nombre_A));
                         GET_ARGUMENT_F("KA=",HKmaginaire(nombre_A));

                         GET_ARGUMENT_F("RB=",HReelle(nombre_B));
                         GET_ARGUMENT_F("IB=",HImaginaire(nombre_B));
                         GET_ARGUMENT_F("JB=",HJmaginaire(nombre_B));
                         GET_ARGUMENT_F("KB=",HKmaginaire(nombre_B));

                         GET_ARGUMENT_F("RC=",HReelle(nombre_C));
                         GET_ARGUMENT_F("IC=",HImaginaire(nombre_C));
                         GET_ARGUMENT_F("JC=",HJmaginaire(nombre_C));
                         GET_ARGUMENT_F("KC=",HKmaginaire(nombre_C));

                         GET_ARGUMENT_F("RD=",HReelle(nombre_D));
                         GET_ARGUMENT_F("ID=",HImaginaire(nombre_D));
                         GET_ARGUMENT_F("JD=",HJmaginaire(nombre_D));
                         GET_ARGUMENT_F("KD=",HKmaginaire(nombre_D));

                         GET_ARGUMENT_F("Pond1=""pR=""px=""pX=",ponderation_R);
                         GET_ARGUMENT_F("Pond2=""pI=""py=""pY=",ponderation_I);
                         GET_ARGUMENT_F("Pond3=""pJ=""pz=""pZ=",ponderation_J);
                         GET_ARGUMENT_F("Pond4=""pK=",ponderation_K);

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_3;

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_5;

                         CONTROLE_DE_L_ARITHMETIQUE_FOLKLORIQUE_DES_NOMBRES_COMPLEXES;
                                        /* Ces extensions de controle "floklorique"s ont ete introduites le 20220605091431...        */
                         )
                    );

     gOPERATION_SUR_LES_FICHIERS(BLOC(
                                      DEFV(hyper_complexe,p1);
                                      DEFV(hyper_complexe,p2);

                                      HCinitialisation(p1
                                                      ,ELEMENT_DU_FICHIER_LISTE_R(index)
                                                      ,ELEMENT_DU_FICHIER_LISTE_I(index)
                                                      ,ELEMENT_DU_FICHIER_LISTE_J(index)
                                                      ,ELEMENT_DU_FICHIER_LISTE_K(index)
                                                       );

                                      Repe(nombre_d_iterations)
                                           Bblock
                                           DEFV(hyper_complexe,p1N);
                                           DEFV(hyper_complexe,p1D);
                                           DEFV(hyper_complexe,pmA);
                                           DEFV(hyper_complexe,pmB);
                                           DEFV(hyper_complexe,pmC);
                                           DEFV(hyper_complexe,pmD);

                                           HCpuissance(p1N,p1,exposant_numerateur__);
                                        /* Calcul de :                                                                               */
                                        /*                                                                                           */
                                        /*                          expN                                                             */
                                        /*                  p1N = p1                                                                 */
                                        /*                                                                                           */

                                           HCpuissance(p1D,p1,exposant_denominateur);
                                        /* Calcul de :                                                                               */
                                        /*                                                                                           */
                                        /*                          expD                                                             */
                                        /*                  p1D = p1                                                                 */
                                        /*                                                                                           */

                                           HCproduit(pmA,nombre_A,p1N);
                                           HCsomme(pmB,pmA,nombre_B);
                                        /* Calcul de :                                                                               */
                                        /*                                                                                           */
                                        /*                  A.p1N + B                                                                */
                                        /*                                                                                           */

                                           HCproduit(pmC,nombre_C,p1D);
                                           HCsomme(pmD,pmC,nombre_D);
                                        /* Calcul de :                                                                               */
                                        /*                                                                                           */
                                        /*                  C.p1D + D                                                                */
                                        /*                                                                                           */

                                           HCquotient(p2,pmB,pmD);
                                        /* Calcul de :                                                                               */
                                        /*                                                                                           */
                                        /*                   A.p1N + B                                                               */
                                        /*                  -----------                                                              */
                                        /*                   C.p1D + D                                                               */
                                        /*                                                                                           */

                                           Test(IFLT(compteur_des_repetitions_du_Repe,nombre_de_repetitions_du_Repe))
                                                Bblock
                                                HCegal(p1,p2);
                                        /* Afin de preparer l'iteration suivante...                                                  */
                                                Eblock
                                           ATes
                                                Bblock
                                                Eblock
                                           ETes
                                           Eblock
                                      ERep
                                      )
                                ,USe_GooF(LIZ4(ponderation_R,HReelle(p2)
                                              ,ponderation_I,HImaginaire(p2)
                                              ,ponderation_J,HJmaginaire(p2)
                                              ,ponderation_K,HKmaginaire(p2)
                                               )
                                          )
                                ,EDITER_LA_VALEUR_RESULTANTE_DANS_gOPERATION_SUR_LES_FICHIERS
                                ,nombre_d_exemplaires_du_resultat_de_l_operation_sur_les_valeurs_courantes
                                 );
                                        /* Transformation homographique...                                                           */

     lGENERATION_D_UN_FICHIER(liste_initiale_des_K,K_IMPLICITE);
     lGENERATION_D_UN_FICHIER(liste_initiale_des_J,J_IMPLICITE);
     lGENERATION_D_UN_FICHIER(liste_initiale_des_I,I_IMPLICITE);
     lGENERATION_D_UN_FICHIER(liste_initiale_des_R,R_IMPLICITE);

     RETU_Commande;
     Eblock
ECommande



Copyright © Jean-François COLONNA, 2022-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2022-2024.