/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O R M A T   D E S   N O M B R E S   C O M P L E X E S ,                                                                  */
/*        D E S   Q U A T E R N I O N S   E T   D E S   O C T O N I O N S  :                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$ximc/definit$DEF' :                                                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 19870000000000).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   V E R S I O N  :                                                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#nodefine DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01                                                              \
                                        /* Cette version definit les nombres complexes, hyper-complexes et hyper-hyper-complexes en  */ \
                                        /* tant que vecteurs de nombres Reels a 2, 4 et 8 dimensions.                                */
#define   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02                                                              \
                                        /* Cette version definit les nombres d'un corps (par exemple celui des Quaternions) en tant  */ \
                                        /* vecteurs a 2 dimensions composes de deux nombres appartenant au sous-corps grace auquel   */ \
                                        /* le corps est defini (par exemple celui des Complexes)...                                  */

/*===================================================================================================================================*/
/*        :Debut_listMN_DEFINITION_NOMBRES_COMPLEXES_11:                                                                             */
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   N O M B R E S   C O M P L E X E S  :                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Soit 'R' le corps des nombres Reels, le                                                                        */
/*                  corps 'C' des nombres Complexes peut alors                                                                       */
/*                  se definir par :                                                                                                 */
/*                                                                                                                                   */
/*                                      C = (R.1) + (R.i)                                                                            */
/*                                                                                                                                   */
/*                  la conjugaison '-' pouvant se definir par :                                                                      */
/*                                                                                                                                   */
/*                                      -    -                                                                                       */
/*                                      C = (R.1) - (R.i)                                                                            */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                       2                                                                                           */
/*                                      i  = -1                                                                                      */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Notation :                                                                                                                 */
/*                                                                                                                                   */
/*                    Un nombre complexe 'z' est compose                                                                             */
/*                  d'une partie reelle 'a' et d'une partie                                                                          */
/*                  imaginaire 'b' ; on le notera :                                                                                  */
/*                                                                                                                                   */
/*                                      z = (a,b)                                                                                    */
/*                                                                                                                                   */
/*                  ou :                                                                                                             */
/*                                                                                                                                   */
/*                                      z = (a.1) + (b.i)                                                                            */
/*                                                                                                                                   */
/*                  ou :                                                                                                             */
/*                                                                                                                                   */
/*                                      z = a + b.i                                                                                  */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                       2                                                                                           */
/*                                      i  = -1                                                                                      */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  on a donc la table de multiplication (v1.v2) :                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                      +            |    |    |                                                                     */
/*                                                   |    |    |                                                                     */
/*                                          +    v1  | +1 | +i |                                                                     */
/*                                                   |    |    |                                                                     */
/*                                              +    |    |    |                                                                     */
/*                                         v2        |    |    |                                                                     */
/*                                                  +|    |    |                                                                     */
/*                                      -------------+---------|                                                                     */
/*                                         +1        | +1 | +i |                                                                     */
/*                                      -------------|----+----|                                                                     */
/*                                         +i        | +i | -1 |                                                                     */
/*                                      -----------------------                                                                      */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  (ce resultat a ete obtenu grace au programme trivial 'v $xtKg/complexes$K')                                      */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Remarque :                                                                                                                 */
/*                                                                                                                                   */
/*                    Le corps des nombres Complexes 'z'                                                                             */
/*                  defini par :                                                                                                     */
/*                                                                                                                                   */
/*                                      z = a + b.i                                                                                  */
/*                                                                                                                                   */
/*                  est isomorphe a l'ensemble des matrices                                                                          */
/*                  du type :                                                                                                        */
/*                                                                                                                                   */
/*                                      | +a +b |                                                                                    */
/*                                      | -b +a |                                                                                    */
/*                                                                                                                                   */
/*                  ou 'a' et 'b' sont deux nombres Reels.                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
/*        :Fin_listMN_DEFINITION_NOMBRES_COMPLEXES_11:                                                                               */

TypedefS(PRECISION_DES_NOMBRES_COMPLEXES,Float PGPD)
                                        /* Precision ('Float' ou 'Double') des nombres complexes.                                    */
Dstruct02(nombre_complexe
         ,DEFV(PRECISION_DES_NOMBRES_COMPLEXES,reelle)
         ,DEFV(PRECISION_DES_NOMBRES_COMPLEXES,imaginaire)
         ,NOM_VIDE
          );
Dstruct04(nombre_complexe_etendu
         ,DEFV(PRECISION_DES_NOMBRES_COMPLEXES,reelle)
         ,DEFV(PRECISION_DES_NOMBRES_COMPLEXES,imaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_COMPLEXES,rho)
         ,DEFV(PRECISION_DES_NOMBRES_COMPLEXES,theta)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre complexe".                                                     */
                                        /*                                                                                           */
                                        /* Le 20061211113711 furent introduits {rho,theta} inutiles a cette date, mais               */
                                        /* on ne sait jamais : mieux vaut prevenir que guerir...                                     */
                                        /*                                                                                           */
                                        /* Aux environs du 20061223122047, cela a cree une sacree "crise" de :                       */
                                        /*                                                                                           */
                                        /*                  Segmentation fault                                                       */
                                        /*                                                                                           */
                                        /* et autres phenomenes bizarres sur '$LACT15'. La solution fut evidemment de tout           */
                                        /* recompiler...                                                                             */
                                        /*                                                                                           */
                                        /* En fait, le 20061223125559 je decide que cette extension etant d'une part inutile a       */
                                        /* cette date et d'autre part doublant la memoire necessaire, je la supprime, tout en        */
                                        /* conservant sa definition sous le nom 'nombre_complexe_etendu'...                          */

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02

#define   _nombre_complexe                                                                                                              \
                    STRU(nombre_complexe)                                                                                               \
                                        /* Definition d'un type intermediaire pour faciliter la parametrisation de la taille...      */
Typedef(complexe,_nombre_complexe)
TypedefS(A___complexe,complexe)
TypedefS(E___complexe,complexe)

#define   size_complexe                                                                                                                 \
                    SIZP(_nombre_complexe)                                                                                              \
                                        /* Taille des nombres complexes...                                                           */

#define   _nombre_complexe_etendu                                                                                                       \
                    STRU(nombre_complexe_etendu)                                                                                        \
                                        /* Definition d'un type intermediaire pour faciliter la parametrisation de la taille         */ \
                                        /* (introduit le 20091119085332).                                                            */
Typedef(complexe_etendu,_nombre_complexe_etendu)
TypedefS(A___complexe_etendu,complexe_etendu)
TypedefS(E___complexe_etendu,complexe_etendu)

#define   size_complexe_etendu                                                                                                          \
                    SIZP(_nombre_complexe_etendu)                                                                                       \
                                        /* Taille des nombres complexes etendus (introduit le 20091119085332).                       */

#define   Carre_de_i__Complexe                                                                                                          \
                    NEGA(FU)                                                                                                            \
                                        /* Carre de 'i' (introduit le 20200321152406).                                               */

#define   Rho1_Complexe                                                                                                                 \
                    FU                                                                                                                  \
                                        /* Module unite des nombres complexes (introduit le 20061209102141).                         */

#define   R0_Complexe                                                                                                                   \
                    FZERO
#define   R1_Complexe                                                                                                                   \
                    FU
                                        /* Definition d'une partie Reelle valant 0 ou 1.                                             */
#define   I0_Complexe                                                                                                                   \
                    FZERO
#define   I1_Complexe                                                                                                                   \
                    FU
                                        /* Definition d'une partie Imaginaire valant 0 ou 1.                                         */

#define   Reelle(z)                                                                                                                     \
                    ASD1(PARE(z),reelle)                                                                                                \
                                        /* Acces a la partie reelle du nombre complexe 'z',                                          */
#define   Imaginaire(z)                                                                                                                 \
                    ASD1(PARE(z),imaginaire)                                                                                            \
                                        /* Acces a la partie imaginaire du nombre complexe 'z'.                                      */

#define   CP_Rho(z_etendu)                                                                                                              \
                    ASD1(PARE(z_etendu),rho)                                                                                            \
                                        /* Acces a la partie 'rho' du nombre complexe 'z' (introduite le 20061211113711).            */ \
                                        /*                                                                                           */ \
                                        /* On notera le nom 'CP_Rho' (pour "Coordonnees Polaires") et non pas 'Rho' afin de ne       */ \
                                        /* pas perturber les autres utilisations possibles de 'Rho'...                               */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : cela ne concerne que les 'complexe_etendu's...                                */
#define   CP_Theta(z_etendu)                                                                                                            \
                    ASD1(PARE(z_etendu),theta)                                                                                          \
                                        /* Acces a la partie 'theta' du nombre complexe 'z' (introduite le 20061211113711).          */ \
                                        /*                                                                                           */ \
                                        /* On notera le nom 'CP_Theta' (pour "Coordonnees Polaires") et non pas 'Theta' afin de ne   */ \
                                        /* pas perturber les autres utilisations possibles de 'Theta'...                             */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : cela ne concerne que les 'complexe_etendu's...                                */

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#    define    dReelle(z)                                                                                                               \
                         Reelle(z)                                                                                                      \
                                        /* Acces a la partie reelle du nombre complexe 'z',                                          */
#    define    dImaginaire(z)                                                                                                           \
                         Imaginaire(z)                                                                                                  \
                                        /* Acces a la partie imaginaire du nombre complexe 'z'.                                      */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02

#define   ConjugaisonReelle(composante)                                                                                                 \
                    NEUT(composante)
#define   ConjugaisonImaginaire_s(composante)                                                                                           \
                    NEGA(composante)
                                        /* Operateurs de conjugaison des parties Reelle et Imaginaire(s) (le 's' de 'Imaginaire'     */
                                        /* etant lie aux nombres Hyper-Complexes et aux nombres Hyper-Hyper-Complexes). Ceci fut     */
                                        /* introduit le 20030430165703.                                                              */
#define   CReelle(z)                                                                                                                    \
                    ConjugaisonReelle(Reelle(z))                                                                                        \
                                        /* Acces a la partie reelle du conjugue du nombre complexe 'z',                              */
#define   CImaginaire(z)                                                                                                                \
                    ConjugaisonImaginaire_s(Imaginaire(z))                                                                              \
                                        /* Acces a la partie imaginaire du conjugue du nombre complexe 'z'.                          */

/*===================================================================================================================================*/
/*        :Debut_listMN_DEFINITION_NOMBRES_HYPER_COMPLEXES_11:                                                                       */
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   N O M B R E S   H Y P E R - C O M P L E X E S                                                */
/*        ( O U   " Q U A T E R N I O N S " )  :                                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Soit 'C' le corps des nombres Complexes, le corps                                                              */
/*                  'Q' des nombres Hyper-Complexes (ou "quaternions" de                                                             */
/*                  Hamilton) peut alors se definir par :                                                                            */
/*                                                                                                                                   */
/*                                      Q = (C.1) + (C.j)                                                                            */
/*                                                                                                                                   */
/*                  la conjugaison '-' pouvant se definir par :                                                                      */
/*                                                                                                                                   */
/*                                      -    -                                                                                       */
/*                                      Q = (C.1) - (C.j)                                                                            */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                       2                                                                                           */
/*                                      j  = -1                                                                                      */
/*                                                                                                                                   */
/*                                      i.j = -j.i ('i' definissant 'C', et 'j' definissant 'Q')                                     */
/*                                                                                                                                   */
/*                  d'ou l'on tire ('1' etant l'element neutre de la multiplication dans 'R' et 'C') :                               */
/*                                                                                                                                   */
/*                                      Q = (C.1) + (C.j)                                                                            */
/*                                      Q = (((R.1) + (R.i)).1) + (((R.1) + (R.i)).j)                                                */
/*                                      Q = ((R.1).1) + ((R.i).1) + ((R.1).j) + ((R.i).j)                                            */
/*                                                                                                                                   */
/*                                                |           |           |           |                                              */
/*                                                |           |           |           |                                              */
/*                                                 -------    |           |           |                                              */
/*                                                        |   |           |           |                                              */
/*                                                        |   |           |           |                                              */
/*                                      1 = (1).1      <--    |           |           |                                              */
/*                                      i = (i).1      <------            |           |                                              */
/*                                                                        |           |                                              */
/*                                      j = (1).j      <------------------            |                                              */
/*                                      k = (i).j      <------------------------------                                               */
/*                                                                                                                                   */
/*                  d'ou :                                                                                                           */
/*                                                                                                                                   */
/*                                      1 = 1.1                                                                                      */
/*                                      i = i.1                                                                                      */
/*                                                                                                                                   */
/*                                      j = 1.j                                                                                      */
/*                                      k = i.j                                                                                      */
/*                                                                                                                                   */
/*                                          | |                                                                                      */
/*                                          | |                                                                                      */
/*                                          |  -------->    (1,j) definit 'Q'                                                        */
/*                                           ---------->    (1,i) est la base de 'C'                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Notation :                                                                                                                 */
/*                                                                                                                                   */
/*                    Un nombre hyper-complexe 'q' (ou "quaternion")                                                                 */
/*                  est compose d'une partie reelle 'a' et de trois                                                                  */
/*                  parties imaginaires 'b', 'c' et 'd' ; on le notera :                                                             */
/*                                                                                                                                   */
/*                                      q = (a,b,c,d)                                                                                */
/*                                                                                                                                   */
/*                  ou :                                                                                                             */
/*                                                                                                                                   */
/*                                      q = (a.1) + (b.i) + (c.j) + (d.k)                                                            */
/*                                                                                                                                   */
/*                  ou :                                                                                                             */
/*                                                                                                                                   */
/*                                      q = a + b.i + c.j + d.k                                                                      */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                       2    2    2                                                                                 */
/*                                      i  = j  = k  = -1                                                                            */
/*                                                                                                                                   */
/*                                      i.j = k = -j.i                                                                               */
/*                                      j.k = i = -k.j                                                                               */
/*                                      k.i = j = -i.k                                                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  on a donc la table de multiplication (v1.v2) :                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                      +            |    |    |    |    |                                                           */
/*                                                   |    |    |    |    |                                                           */
/*                                          +    v1  | +1 | +i | +j | +k |                                                           */
/*                                                   |    |    |    |    |                                                           */
/*                                              +    |    |    |    |    |                                                           */
/*                                         v2        |    |    |    |    |                                                           */
/*                                                  +|    |    |    |    |                                                           */
/*                                      -------------+-------------------|                                                           */
/*                                         +1        | +1   +i | +j   +k |                                                           */
/*                                      -------------|    *    |    *    |                                                           */
/*                                         +i        | +i   -1 | -k   +j |                                                           */
/*                                      -------------|----+----+----+----|                                                           */
/*                                         +j        | +j   +k | -1   -i |                                                           */
/*                                      -------------|    *    |    *    |                                                           */
/*                                         +k        | +k   -j | +i   -1 |                                                           */
/*                                      ---------------------------------                                                            */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  (ce resultat a ete obtenu grace au programme 'v $xtKg/quaternions$K')                                            */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  Le produit de deux quaternions 'q1' et 'q2' se definit par :                                                     */
/*                                                                                                                                   */
/*                                      q1 = z11.1 + z12.j                                                                           */
/*                                      q2 = z21.1 + z22.j                                                                           */
/*                                                                                                                                   */
/*                                      (ou 'z11', 'z12', 'z21' et 'z22' sont quatre nombres complexes)                              */
/*                                                                                                                                   */
/*                                      q1.q2 = (z11.1 + z12.j).(z21.1 + z22.j)                                                      */
/*                                                                                                                                   */
/*                                                         ---                         ---                                           */
/*                                      q1.q2 = (z11.z21 - z22.z12).1 + (z22.z11 + z12.z21).j                                        */
/*                                                                                                                                   */
/*                  La multiplication n'est pas commutative...                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  Une autre definition peut etre donnee, en rappelant le                                                           */
/*                  produit de deux nombres complexes 'z1' et 'z2' :                                                                 */
/*                                                                                                                                   */
/*                                      z1 = (a,b)                                                                                   */
/*                                      z2 = (c,d)                                                                                   */
/*                                                                                                                                   */
/*                                      (ou 'a', 'b', 'c' et 'd' sont quatre nombres reels)                                          */
/*                                                                                                                                   */
/*                  on a :                                                                                                           */
/*                                                                                                                                   */
/*                                      z1.z2 = (a,b)(c,d) = (ac - bd , ad + bc)                                                     */
/*                                                                                                                                   */
/*                  ecrivons alors les deux quaternions 'q1' et 'q2' sous la forme :                                                 */
/*                                                                                                                                   */
/*                                              -->                                                                                  */
/*                                      q1 = (a, B )                                                                                 */
/*                                                                                                                                   */
/*                                              -->                                                                                  */
/*                                      q2 = (c, D )                                                                                 */
/*                                                                                                                                   */
/*                                                                                         -->      -->                              */
/*                                      (ou 'a' et 'c' sont deux nombres reels, alors que ' B ' et ' D ' sont deux 3-vecteurs)       */
/*                                                                                                                                   */
/*                  Le produit de 'q1' et 'q2' sera defini par :                                                                     */
/*                                                                                                                                   */
/*                                                 -->    -->          --> -->    -->   -->    -->  -->                              */
/*                                      q1.q2 = (a, B )(c, D ) = (ac -  B . D  , a D  +  B c +  B /\ D )                             */
/*                                                                                                                                   */
/*                                                           -->  -->                                                                */
/*                  ou est donc ajoute le produit vectoriel ' B /\ D '.                                                              */
/*                                                                                                                                   */
/*                                                       --->                                                                        */
/*                  Une application de cela ; soit donc ' \/ ' l'operateur                                                           */
/*                  'del' defini par :                                                                                               */
/*                                                                                                                                   */
/*                                      --->    d      d      d                                                                      */
/*                                       \/  = ---- + ---- + ----                                                                    */
/*                                              dx     dy     dz                                                                     */
/*                                                                                                                                   */
/*                  on a alors :                                                                                                     */
/*                                                                                                                                   */
/*                                                                                -->                                                */
/*                                        d   --->    -->      dc    ---> -->    d D     --->    --->  -->                           */
/*                                      (----, \/ )(c, D ) = (---- -  \/ . D  , ------ +  \/ c +  \/ /\ D )                          */
/*                                        dt                   dt                 dt                                                 */
/*                                                                                                                                   */
/*                      --->-->                        -->    --->                          --->  -->                     -->        */
/*                  ou ' \/  D ' est la divergence de ' D ', ' \/ c' le gradient de 'c' et ' \/ /\ D ' le rotationnel de ' D ').     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Remarque :                                                                                                                 */
/*                                                                                                                                   */
/*                    Le corps des quaternions 'q'                                                                                   */
/*                  defini par :                                                                                                     */
/*                                                                                                                                   */
/*                                      q = a.1 + b.i + c.j + d.k                                                                    */
/*                                                                                                                                   */
/*                  est isomorphe a l'ensemble des matrices                                                                          */
/*                  du type :                                                                                                        */
/*                                                                                                                                   */
/*                                      | +z  +z  |                                                                                  */
/*                                      |   1   2 |                                                                                  */
/*                                      |  _   _  |                                                                                  */
/*                                      | -z  +z  |                                                                                  */
/*                                      |   2   1 |                                                                                  */
/*                                                                                                                                   */
/*                  ou 'z1' et 'z2' sont les deux nombres Complexes :                                                                */
/*                                                                                                                                   */
/*                                      z  = a.1 + b.i                                                                               */
/*                                       1                                                                                           */
/*                                                                                                                                   */
/*                                      z  = c.1 + d.i                                                                               */
/*                                       2                                                                                           */
/*                                                                                                                                   */
/*                  en notant que :                                                                                                  */
/*                                                                                                                                   */
/*                                      q = z .1 + z .j                                                                              */
/*                                           1      2                                                                                */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
/*        :Fin_listMN_DEFINITION_NOMBRES_HYPER_COMPLEXES_11:                                                                         */

/*===================================================================================================================================*/
/*        :Debut_listMN_DEFINITION_NOMBRES_PSEUDO_HYPER_COMPLEXES_11:                                                                */
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   N O M B R E S   P S E U D O - H Y P E R - C O M P L E X E S                                  */
/*        ( O U   " P S E U D O - Q U A T E R N I O N S " )  :                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Les nombres complexes peuvent etre representes                                                                 */
/*                  de deux facons differentes comme couple de nombres                                                               */
/*                  reels : {x,y} en coordonnees cartesiennes et {rho,theta}                                                         */
/*                  en coordonnees polaires.                                                                                         */
/*                                                                                                                                   */
/*                    L'addition de deux nombres complexes 'z1' et 'Z2'                                                              */
/*                  est facile a exprimer en coordonnees cartesiennes :                                                              */
/*                                                                                                                                   */
/*                                      z = z  + z  = (x ,y ) + (x ,y )                                                              */
/*                                           1    2     1  1      2  2                                                               */
/*                                                                                                                                   */
/*                                                  = (x  + x ,y  + y )                                                              */
/*                                                      1    2  1    2                                                               */
/*                                                                                                                                   */
/*                  alors que la multiplication est plus facile a exprimer                                                           */
/*                  en coordonnees polaires :                                                                                        */
/*                                                                                                                                   */
/*                                      z = z  . z  = (rho ,theta ) . (rho ,theta )                                                  */
/*                                           1    2       1      1        2      2                                                   */
/*                                                                                                                                   */
/*                                                  = (rho  . rho ,theta  + theta )                                                  */
/*                                                        1      2      1        2                                                   */
/*                                                                                                                                   */
/*                    Les pseudo-nombres baptises "pseudo-hyper-complexes"                                                           */
/*                  (ou "pseudo-quaternions") seront representes de deux                                                             */
/*                  facons differentes comme quadruplets de nombres reels :                                                          */
/*                  {x,y,z,t} en coordonnees cartesiennes et {rho,theta,phi,alpha}                                                   */
/*                  en coordonnees hyper-spheriques.                                                                                 */
/*                                                                                                                                   */
/*                    L'addition de deux "pseudo-quaternions" 'q1' et 'q2'                                                           */
/*                  sera definie en coordonnees cartesiennes par :                                                                   */
/*                                                                                                                                   */
/*                                      q = q  + q  = (x ,y ,z ,t ) + (x ,y ,z ,t )                                                  */
/*                                           1    2     1  1  1  1      2  2  2  2                                                   */
/*                                                                                                                                   */
/*                                                  = (x  + x ,y  + y ,z  + z ,t  + t )                                              */
/*                                                      1    2  1    2  1    2  1    2                                               */
/*                                                                                                                                   */
/*                  alors que seront utilisees les coordonnees hyper-spheriques                                                      */
/*                  pour definir la multiplication :                                                                                 */
/*                                                                                                                                   */
/*                                      q = q  . q  = (rho ,theta ,phi ,alpha ) . (rho ,theta ,phi ,alpha )                          */
/*                                           1    2       1      1    1      1        2      2    2      2                           */
/*                                                                                                                                   */
/*                                                  = (rho  . rho ,theta  + theta ,phi  + phi ,alpha  + alpha )                      */
/*                                                        1      2      1        2    1      2      1        2                       */
/*                                                                                                                                   */
/*                    Par soucis de generalite, les combinaisons entre les quatre                                                    */
/*                  composantes {rho,theta,phi,alpha} des deux "pseudo-quaternions"                                                  */
/*                  seront en fait effectuees via des polynomes 'P' du quatrieme                                                     */
/*                  degre a deux variables initialises par defaut de facon a ce que :                                                */
/*                                                                                                                                   */
/*                                      P(rho ,rho ) = rho  . rho                                                                    */
/*                                           1    2       1      2                                                                   */
/*                                                                                                                                   */
/*                                      P(theta ,theta ) = theta  + theta                                                            */
/*                                             1      2         1        2                                                           */
/*                                                                                                                                   */
/*                                      P(phi ,phi ) = phi  + phi                                                                    */
/*                                           1    2       1      2                                                                   */
/*                                                                                                                                   */
/*                                      P(alpha ,alpha ) = alpha  + alpha                                                            */
/*                                             1      2         1        2                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
/*        :Fin_listMN_DEFINITION_NOMBRES_PSEUDO_HYPER_COMPLEXES_11:                                                                  */

TypedefS(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Float PGPD)
                                        /* Precision ('Float' ou 'Double') des nombres hyper-complexes.                              */

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
Dstruct04(nombre_hyper_complexe
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hreelle)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Himaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hjmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hkmaginaire)
         ,NOM_VIDE
          );
Dstruct08(nombre_hyper_complexe_etendu
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hreelle)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Himaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hjmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hkmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hrho)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Htheta)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hphi)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Halpha)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre hyper-complexe".                                               */
                                        /*                                                                                           */
                                        /* Le 20061211113711 furent introduits {rho,theta,phi,alpha} inutiles a cette date, mais     */
                                        /* on ne sait jamais : mieux vaut prevenir que guerir...                                     */
                                        /*                                                                                           */
                                        /* Aux environs du 20061223122047, cela a cree une sacree "crise" de :                       */
                                        /*                                                                                           */
                                        /*                  Segmentation fault                                                       */
                                        /*                                                                                           */
                                        /* et autres phenomenes bizarres sur '$LACT15'. La solution fut evidemment de tout           */
                                        /* recompiler...                                                                             */
                                        /*                                                                                           */
                                        /* En fait, le 20061223125559 je decide que cette extension etant d'une part inutile a       */
                                        /* cette date et d'autre part doublant la memoire necessaire, je la supprime, tout en        */
                                        /* conservant sa definition sous le nom 'nombre_hyper_complexe_etendu'...                    */
                                        /*                                                                                           */
                                        /* Le 20110811162718, le type de {Hrho,Htheta,Hphi,Halpha} est passe de                      */
                                        /* 'PRECISION_DES_NOMBRES_COMPLEXES' a 'PRECISION_DES_NOMBRES_HYPER_COMPLEXES'...            */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
Dstruct02(nombre_hyper_complexe
         ,DEFV(complexe,Hreelle)
         ,DEFV(complexe,Hjmaginaire)
         ,NOM_VIDE
          );
Dstruct06(nombre_hyper_complexe_etendu
         ,DEFV(complexe,Hreelle)
         ,DEFV(complexe,Hjmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hrho)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Htheta)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Hphi)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_COMPLEXES,Halpha)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre hyper-complexe".                                               */
                                        /*                                                                                           */
                                        /* Le 20061211113711 furent introduits {rho,theta,phi,alpha} inutiles a cette date, mais     */
                                        /* on ne sait jamais : mieux vaut prevenir que guerir...                                     */
                                        /*                                                                                           */
                                        /* Aux environs du 20061223122047, cela a cree une sacree "crise" de :                       */
                                        /*                                                                                           */
                                        /*                  Segmentation fault                                                       */
                                        /*                                                                                           */
                                        /* et autres phenomenes bizarres sur '$LACT15'. La solution fut evidemment de tout           */
                                        /* recompiler...                                                                             */
                                        /*                                                                                           */
                                        /* En fait, le 20061223125559 je decide que cette extension etant d'une part inutile a       */
                                        /* cette date et d'autre part doublant la memoire necessaire, je la supprime, tout en        */
                                        /* conservant sa definition sous le nom 'nombre_hyper_complexe_etendu'...                    */
                                        /*                                                                                           */
                                        /* Le 20110811162718, le type de {Hrho,Htheta,Hphi,Halpha} est passe de                      */
                                        /* 'PRECISION_DES_NOMBRES_COMPLEXES' a 'PRECISION_DES_NOMBRES_HYPER_COMPLEXES'...            */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02

#define   _nombre_hyper_complexe                                                                                                        \
                    STRU(nombre_hyper_complexe)                                                                                         \
                                        /* Definition d'un type intermediaire pour faciliter la parametrisation de la taille...      */
Typedef(hyper_complexe,_nombre_hyper_complexe)
TypedefS(A___hyper_complexe,hyper_complexe)
TypedefS(E___hyper_complexe,hyper_complexe)

#define   size_hyper_complexe                                                                                                           \
                    SIZP(_nombre_hyper_complexe)                                                                                        \
                                        /* Taille des nombres hyper-complexes...                                                     */

#define   _nombre_hyper_complexe_etendu                                                                                                 \
                    STRU(nombre_hyper_complexe_etendu)                                                                                  \
                                        /* Definition d'un type intermediaire pour faciliter la parametrisation de la taille         */ \
                                        /* (introduit le 20091119085332).                                                            */
Typedef(hyper_complexe_etendu,_nombre_hyper_complexe_etendu)
TypedefS(A___hyper_complexe_etendu,hyper_complexe_etendu)
TypedefS(E___hyper_complexe_etendu,hyper_complexe_etendu)

#define   size_hyper_complexe_etendu                                                                                                    \
                    SIZP(_nombre_hyper_complexe_etendu)                                                                                 \
                                        /* Taille des nombres hyper-complexes (introduit le 20091119085332).                         */

#define   Carre_de_i__Quaternion                                                                                                        \
                    Carre_de_i__Complexe
#define   Carre_de_j__Quaternion                                                                                                        \
                    Carre_de_i__Complexe
#define   Carre_de_k__Quaternion                                                                                                        \
                    Carre_de_i__Complexe
                                        /* Carre de {i,j,k} (introduit le 20200321152406).                                           */

#define   Rho1_Quaternion                                                                                                               \
                    Rho1_Complexe                                                                                                       \
                                        /* Module unite des nombres hyper-complexes (introduit le 20061209102141).                   */

#define   R0_Quaternion                                                                                                                 \
                    R0_Complexe
#define   I0_Quaternion                                                                                                                 \
                    I0_Complexe
#define   J0_Quaternion                                                                                                                 \
                    FZERO
#define   K0_Quaternion                                                                                                                 \
                    FZERO
                                        /* Definition du nombre {0,0,0,0}.                                                           */
#define   R1_Quaternion                                                                                                                 \
                    R1_Complexe
#define   I1_Quaternion                                                                                                                 \
                    I1_Complexe
#define   J1_Quaternion                                                                                                                 \
                    FU
#define   K1_Quaternion                                                                                                                 \
                    FU
                                        /* Definition du nombre {1,1,1,1} (introduit le 20060425154031).                             */

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#    define    HReelle(q)                                                                                                               \
                         ASD1(PARE(q),Hreelle)                                                                                          \
                                        /* Acces a la partie reelle du nombre hyper-complexe 'q',                                    */
#    define    HImaginaire(q)                                                                                                           \
                         ASD1(PARE(q),Himaginaire)                                                                                      \
                                        /* Acces a la partie imaginaire du nombre hyper-complexe 'q',                                */
#    define    HJmaginaire(q)                                                                                                           \
                         ASD1(PARE(q),Hjmaginaire)                                                                                      \
                                        /* Acces a la partie jmaginaire du nombre hyper-complexe 'q',                                */
#    define    HKmaginaire(q)                                                                                                           \
                         ASD1(PARE(q),Hkmaginaire)                                                                                      \
                                        /* Acces a la partie kmaginaire du nombre hyper-complexe 'q'.                                */

#    define    CHReelle(q)                                                                                                              \
                         ConjugaisonReelle(HReelle(q))                                                                                  \
                                        /* Acces a la partie reelle du conjugue du nombre hyper-complexe 'q',                        */
#    define    CHImaginaire(q)                                                                                                          \
                         ConjugaisonImaginaire_s(HImaginaire(q))                                                                        \
                                        /* Acces a la partie imaginaire du conjugue du nombre hyper-complexe 'q',                    */
#    define    CHJmaginaire(q)                                                                                                          \
                         ConjugaisonImaginaire_s(HJmaginaire(q))                                                                        \
                                        /* Acces a la partie jmaginaire du conjugue du nombre hyper-complexe 'q',                    */
#    define    CHKmaginaire(q)                                                                                                          \
                         ConjugaisonImaginaire_s(HKmaginaire(q))                                                                        \
                                        /* Acces a la partie kmaginaire du conjugue du nombre hyper-complexe 'q'.                    */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#    define    dHReelle(q)                                                                                                              \
                         ASD1(PARE(q),Hreelle)                                                                                          \
                                        /* Acces a la partie 'Hreelle' du nombre hyper-complexe 'q' ou "decomposistion",             */
#    define    dHImaginaire(q)                                                                                                          \
                         ASD1(PARE(q),Hjmaginaire)                                                                                      \
                                        /* Acces a la partie 'Hjmaginaire' du nombre hyper-complexe 'q' ou "decomposistion".         */

#    define    HReelle(q)                                                                                                               \
                         Reelle(dHReelle(q))                                                                                            \
                                        /* Acces a la partie reelle du nombre hyper-complexe 'q',                                    */
#    define    HImaginaire(q)                                                                                                           \
                         Imaginaire(dHReelle(q))                                                                                        \
                                        /* Acces a la partie imaginaire du nombre hyper-complexe 'q',                                */
#    define    HJmaginaire(q)                                                                                                           \
                         Reelle(dHImaginaire(q))                                                                                        \
                                        /* Acces a la partie jmaginaire du nombre hyper-complexe 'q',                                */
#    define    HKmaginaire(q)                                                                                                           \
                         Imaginaire(dHImaginaire(q))                                                                                    \
                                        /* Acces a la partie kmaginaire du nombre hyper-complexe 'q'.                                */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02

#define  HCHS_Rho(q_etendu)                                                                                                             \
                    ASD1(PARE(q_etendu),Hrho)                                                                                           \
                                        /* Acces a la partie 'Hrho' du nombre hyper-complexe 'q' (introduite le 20061211113711).     */ \
                                        /*                                                                                           */ \
                                        /* On notera le nom 'HCHS_Rho' (pour "Coordonnees Hyper-Spheriques") et non pas 'HRho'       */ \
                                        /* afin de ne pas perturber les autres utilisations possibles de 'HRho'...                   */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : cela ne concerne que les 'hyper_complexe_etendu's...                          */
#define  HCHS_Theta(q_etendu)                                                                                                           \
                    ASD1(PARE(q_etendu),Htheta)                                                                                         \
                                        /* Acces a la partie 'Htheta' du nombre hyper-complexe 'q' (introduite le 20061211113711).   */ \
                                        /*                                                                                           */ \
                                        /* On notera le nom 'HCHS_Theta' (pour "Coordonnees Hyper-Spheriques") et non pas 'HTheta'   */ \
                                        /* afin de ne pas perturber les autres utilisations possibles de 'HTheta'...                 */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : cela ne concerne que les 'hyper_complexe_etendu's...                          */
#define  HCHS_Phi(q_etendu)                                                                                                             \
                    ASD1(PARE(q_etendu),Hphi)                                                                                           \
                                        /* Acces a la partie 'Hphi' du nombre hyper-complexe 'q' (introduite le 20061211113711).     */ \
                                        /*                                                                                           */ \
                                        /* On notera le nom 'HCHS_Phi' (pour "Coordonnees Hyper-Spheriques") et non pas 'HPhi'       */ \
                                        /* afin de ne pas perturber les autres utilisations possibles de 'HPhi'...                   */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : cela ne concerne que les 'hyper_complexe_etendu's...                          */
#define  HCHS_Alpha(q_etendu)                                                                                                           \
                    ASD1(PARE(q_etendu),Halpha)                                                                                         \
                                        /* Acces a la partie 'Halpha' du nombre hyper-complexe 'q' (introduite le 20061211113711).   */ \
                                        /*                                                                                           */ \
                                        /* On notera le nom 'HCHS_Alpha' (pour "Coordonnees Hyper-Spheriques") et non pas 'HAlpha'   */ \
                                        /* afin de ne pas perturber les autres utilisations possibles de 'HAlpha'...                 */ \
                                        /*                                                                                           */ \
                                        /* ATTENTION : cela ne concerne que les 'hyper_complexe_etendu's...                          */

/*===================================================================================================================================*/
/*        :Debut_listMN_DEFINITION_NOMBRES_HYPER_HYPER_COMPLEXES_11:                                                                 */
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   N O M B R E S   H Y P E R - H Y P E R - C O M P L E X E S                                    */
/*        ( O U   " O C T O N I O N S " )  :                                                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Soit 'Q' le corps des nombres Hyper-Complexes (ou "quaternions"),                                              */
/*                  le corps 'O' des nombres Hyper-Hyper-Complexes (ou "octonions" ou                                                */
/*                  encore "octaves" de Cayley) peut alors se definir par :                                                          */
/*                                                                                                                                   */
/*                                      O = (Q.1) + (Q.s)                                                                            */
/*                                                                                                                                   */
/*                  la conjugaison '-' pouvant se definir par :                                                                      */
/*                                                                                                                                   */
/*                                      -    -                                                                                       */
/*                                      O = (Q.1) - (Q.s)                                                                            */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                       2                                                                                           */
/*                                      s  = -1                                                                                      */
/*                                                                                                                                   */
/*                                      j.s = -s.j ('j' definissant 'Q', et 's' definissant 'O')                                     */
/*                                                                                                                                   */
/*                  d'ou l'on tire ('1' etant l'element neutre de la multiplication dans 'R', 'C' et 'Q') :                          */
/*                                                                                                                                   */
/*                                      O = (Q.1) + (Q.s)                                                                            */
/*                                      O = (((C.1) + (C.j)).1) + (((C.1) + (C.j)).s)                                                */
/*                                      O = ((C.1).1) + ((C.j).1) + ((C.1).s) + ((C.j).s)                                            */
/*   = ((((R.1) + (R.i)).1).1) + ((((R.1) + (R.i)).j).1) + ((((R.1) + (R.i)).1).s) + ((((R.1) + (R.i)).j).s)                         */
/*   = (((R.1).1).1) + (((R.i).1).1) + (((R.1).j).1) + (((R.i).j).1) + (((R.1).1).s) + (((R.i).1).s) + (((R.1).j).s) + (((R.i).j).s) */
/*                                                                                                                                   */
/*             |               |               |               |               |               |               |               |     */
/*             |               |               |               |               |               |               |               |     */
/*             |               |                -------------  |               |               |               |               |     */
/*             |                ---------------------------  | |               |               |               |               |     */
/*              -----------------------------------------  | | |               |               |               |               |     */
/*                                                       | | | |               |               |               |               |     */
/*                                                       | | | |               |               |               |               |     */
/*                                      1 = ((1).1).1  <-  | | |               |               |               |               |     */
/*                                      i = ((i).1).1  <---  | |               |               |               |               |     */
/*                                      j = ((1).j).1  <-----  |               |               |               |               |     */
/*                                      k = ((i).j).1  <-------                |               |               |               |     */
/*                                                                             |               |               |               |     */
/*                                      s = ((1).1).s  <-----------------------                |               |               |     */
/*                                      t = ((i).1).s  <---------------------------------------                |               |     */
/*                                      u = ((1).j).s  <-------------------------------------------------------                |     */
/*                                      v = ((i).j).s  <-----------------------------------------------------------------------      */
/*                                                                                                                                   */
/*                  d'ou, avec k = (i).j :                                                                                           */
/*                                                                                                                                   */
/*                                      1 = 1.1                                                                                      */
/*                                      i = i.1                                                                                      */
/*                                      j = j.1                                                                                      */
/*                                      k = k.1                                                                                      */
/*                                                                                                                                   */
/*                                      s = 1.s                                                                                      */
/*                                      t = i.s                                                                                      */
/*                                      u = j.s                                                                                      */
/*                                      v = k.s                                                                                      */
/*                                                                                                                                   */
/*                                          | |                                                                                      */
/*                                          | |                                                                                      */
/*                                          |  -------->    (1,s) definit 'O'                                                        */
/*                                           ---------->    (1,i,j,k) est la base de 'Q'                                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Notation :                                                                                                                 */
/*                                                                                                                                   */
/*                    Un octonion 'o' est  compose d'une partie reelle 'a'                                                           */
/*                  et de sept parties parties imaginaires 'b', 'c', 'd',                                                            */
/*                  'e' 'f', 'g' et 'h' ; on le notera :                                                                             */
/*                                                                                                                                   */
/*                                      o = (a,b,c,d,e,f,g,h)                                                                        */
/*                                                                                                                                   */
/*                  ou :                                                                                                             */
/*                                                                                                                                   */
/*                                      o = a.1 + b.i + c.j + d.k + e.s + f.t + g.u + h.v                                            */
/*                                                                                                                                   */
/*                  ou :                                                                                                             */
/*                                                                                                                                   */
/*                                      o = a + b.i + c.j + d.k + e.s + f.t + g.u + h.v                                              */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                       2    2    2    2    2    2    2                                                             */
/*                                      i  = j  = k  = s  = t  = u  = v  = -1                                                        */
/*                                                                                                                                   */
/*                                      i.j = -j.i                                                                                   */
/*                                      j.k = -k.j                                                                                   */
/*                                      k.i = -i.k                                                                                   */
/*                                                                                                                                   */
/*                                      etc, tous les produits de deux vecteurs de base distincts anticommutant (sauf avec '1')...   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  on a donc la table de multiplication (v1.v2) :                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                                     |    |    |    |    |    |    |    |    |                                     */
/*                                      +        v1    | +1 | +i | +j | +k | +s | +t | +u | +v |                                     */
/*                                          +          |    |    |    |    |    |    |    |    |                                     */
/*                                              +      |    |    |    |    |    |    |    |    |                                     */
/*                                         v2       +  |    |    |    |    |    |    |    |    |                                     */
/*                                                     |    |    |    |    |    |    |    |    |                                     */
/*                                      ---------------|---------|---------|---------|---------|                                     */
/*                                         +1          | +1   +i | +j   +k | +s   +t | +u   +v |                                     */
/*                                      ---------------|    *    |    *    |    *    |    *    |                                     */
/*                                         +i          | +i   -1 | -k   +j | -t   +s | +v   -u |                                     */
/*                                      ---------------|---------|---------|---------|---------|                                     */
/*                                         +j          | +j   +k | -1   -i | -u   -v | +s   +t |                                     */
/*                                      ---------------|    *    |    *    |    *    |    *    |                                     */
/*                                         +k          | +k   -j | +i   -1 | -v   +u | -t   +s |                                     */
/*                                      ---------------|---------|---------|---------|---------|                                     */
/*                                         +s          | +s   +t | +u   +v | -1   -i | -j   -k |                                     */
/*                                      ---------------|    *    |    *    |    *    |    *    |                                     */
/*                                         +t          | +t   -s | +v   -u | +i   -1 | +k   -j |                                     */
/*                                      ---------------|---------|---------|---------|---------|                                     */
/*                                         +u          | +u   -v | -s   +t | +j   -k | -1   +i |                                     */
/*                                      ---------------|    *    |    *    |    *    |    *    |                                     */
/*                                         +v          | +v   +u | -t   -s | +k   +j | -i   -1 |                                     */
/*                                      -------------------------------------------------------                                      */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  (ce resultat a ete obtenu grace au programme 'v $xtKg/octonions$K')                                              */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  Le produit de deux octonions 'o1' et 'o2' se definit par :                                                       */
/*                                                                                                                                   */
/*                                      o1 = q11.1 + q12.s                                                                           */
/*                                      o2 = q21.1 + q22.s                                                                           */
/*                                                                                                                                   */
/*                                      (ou 'q11', 'q12', 'q21' et 'q22' sont quatre quaternions)                                    */
/*                                                                                                                                   */
/*                                      o1.o2 = (q11.1 + q12.s).(q21.1 + q22.s)                                                      */
/*                                                                                                                                   */
/*                                                         ---                         ---                                           */
/*                                      o1.o2 = (q11.q21 - q22.q12).1 + (q22.q11 + q12.q21).s                                        */
/*                                                                                                                                   */
/*                  La multiplication n'est ni commutative, ni associative...                                                        */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
/*        :Fin_listMN_DEFINITION_NOMBRES_HYPER_HYPER_COMPLEXES_11:                                                                   */

/*===================================================================================================================================*/
/*        :Debut_listMN_DEFINITION_NOMBRES_PSEUDO_HYPER_HYPER_COMPLEXES_11:                                                          */
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   N O M B R E S   P S E U D O - H Y P E R - H Y P E R - C O M P L E X E S                      */
/*        ( O U   " P S E U D O - O C T O N I O N S " )  :                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Les nombres complexes peuvent etre representes                                                                 */
/*                  de deux facons differentes comme couple de nombres                                                               */
/*                  reels : {x,y} en coordonnees cartesiennes et {rho,theta}                                                         */
/*                  en coordonnees polaires.                                                                                         */
/*                                                                                                                                   */
/*                    L'addition de deux nombres complexes 'z1' et 'Z2'                                                              */
/*                  est facile a exprimer en coordonnees cartesiennes :                                                              */
/*                                                                                                                                   */
/*                                      z = z  + z  = (x ,y ) + (x ,y )                                                              */
/*                                           1    2     1  1      2  2                                                               */
/*                                                                                                                                   */
/*                                                  = (x  + x ,y  + y )                                                              */
/*                                                      1    2  1    2                                                               */
/*                                                                                                                                   */
/*                  alors que la multiplication est plus facile a exprimer                                                           */
/*                  en coordonnees polaires :                                                                                        */
/*                                                                                                                                   */
/*                                      z = z  . z  = (rho ,theta ) . (rho ,theta )                                                  */
/*                                           1    2       1      1        2      2                                                   */
/*                                                                                                                                   */
/*                                                  = (rho  . rho ,theta  + theta )                                                  */
/*                                                        1      2      1        2                                                   */
/*                                                                                                                                   */
/*                    Les pseudo-nombres baptises "pseudo-hyper-hyper-complexes"                                                     */
/*                  (ou "pseudo-octonions") seront representes de deux                                                               */
/*                  facons differentes comme octuplets de nombres reels :                                                            */
/*                  {x1,x2,x3,x4,x5,x6,x7,x8} en coordonnees cartesiennes et {rho,A1,A2,A3,A4,A5,A6,A7}                              */
/*                  en coordonnees hyper-hyper-spheriques.                                                                           */
/*                                                                                                                                   */
/*                    L'addition de deux "pseudo-octonions" 'o1' et 'o2'                                                             */
/*                  sera definie en coordonnees cartesiennes par :                                                                   */
/*                                                                                                                                   */
/*                            o = o  + o  = (x1 ,x2 ,x3 ,x5 ,x5 ,x6 ,x7 ,x8 ) + (x1 ,x2 ,x3 ,x5 ,x5 ,x6 ,x7 ,x8 )                    */
/*                                 1    2      1   1   1   1   1   1   1   1       2   2   2   2   2   2   2   2                     */
/*                                                                                                                                   */
/*                                        = (x1  + x1 ,x2  + x2 ,x3  + x3 ,x4  + x4 ,x5  + x5 ,x6  + x6 ,x7  + x7 ,x8  + x8 )        */
/*                                             1     2   1     2   1     2   1     2   1     2   1     2   1     2   1     2         */
/*                                                                                                                                   */
/*                  alors que seront utilisees les coordonnees hyper-hyper-spheriques                                                */
/*                  pour definir la multiplication :                                                                                 */
/*                                                                                                                                   */
/*                            o = o  . o  = (rho ,A1 ,A2 ,A3 ,A4 ,A5 ,A6 ,A7 ) . (rho ,A1 ,A2 ,A3 ,A4 ,A5 ,A6 ,A7 )                  */
/*                                 1    2       1   1   1   1   1   1   1   1        2   2   2   2   2   2   2   2                   */
/*                                                                                                                                   */
/*                                        = (rho  . rho ,A1  + A1 ,A2  + A2 ,A3  + A3 ,A4  + A4 ,A5  + A5 ,A6  + A6 ,A7  + A7 )      */
/*                                              1      2   1     2   1     2   1     2   1     2   1     2   1     2   1     2       */
/*                                                                                                                                   */
/*                    Par soucis de generalite, les combinaisons entre les huit                                                      */
/*                  composantes {rho,A1,A2,A3,A4,A5,A6,A7} des deux "pseudo-octonions"                                               */
/*                  seront en fait effectuees via des polynomes 'P' du quatrieme                                                     */
/*                  degre a deux variables initialises par defaut de facon a ce que :                                                */
/*                                                                                                                                   */
/*                                      P(rho ,rho ) = rho  . rho                                                                    */
/*                                           1    2       1      2                                                                   */
/*                                                                                                                                   */
/*                                      P(A1 ,A1 ) = A1  + A1                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                      P(A2 ,A2 ) = A2  + A2                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                      P(A3 ,A3 ) = A3  + A3                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                      P(A4 ,A4 ) = A4  + A4                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                      P(A5 ,A5 ) = A5  + A5                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                      P(A6 ,A6 ) = A6  + A6                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                      P(A7 ,A7 ) = A7  + A7                                                                        */
/*                                          1   2      1     2                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
/*        :Fin_listMN_DEFINITION_NOMBRES_PSEUDO_HYPER_HYPER_COMPLEXES_11:                                                            */

TypedefS(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,Float PGPD)
                                        /* Precision ('Float' ou 'Double') des nombres hyper-hyper-complexes.                        */

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
Dstruct08(nombre_hyper_hyper_complexe
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHreelle)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHimaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHjmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHkmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHsmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHtmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHumaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHvmaginaire)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre hyper-hyper-complexes".                                        */
Dstruct16(nombre_hyper_hyper_complexe_etendu
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHreelle)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHimaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHjmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHkmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHsmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHtmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHumaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHvmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHrho)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle1)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle2)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle3)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle4)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle5)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle6)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle7)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre hyper-hyper-complexes" etendu.                                 */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
Dstruct02(nombre_hyper_hyper_complexe
         ,DEFV(hyper_complexe,HHreelle)
         ,DEFV(hyper_complexe,HHsmaginaire)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre hyper-hyper-complexes".                                        */
Dstruct10(nombre_hyper_hyper_complexe_etendu
         ,DEFV(hyper_complexe,HHreelle)
         ,DEFV(hyper_complexe,HHsmaginaire)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHrho)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle1)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle2)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle3)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle4)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle5)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle6)
         ,DEFV(PRECISION_DES_NOMBRES_HYPER_HYPER_COMPLEXES,HHangle7)
         ,NOM_VIDE
          );
                                        /* Definition du type "nombre hyper-hyper-complexes" etendu.                                 */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02

#define   _nombre_hyper_hyper_complexe                                                                                                  \
                    STRU(nombre_hyper_hyper_complexe)                                                                                   \
                                        /* Definition d'un type intermediaire pour faciliter la parametrisation de la taille...      */
Typedef(hyper_hyper_complexe,_nombre_hyper_hyper_complexe)
TypedefS(A___hyper_hyper_complexe,hyper_hyper_complexe)
TypedefS(E___hyper_hyper_complexe,hyper_hyper_complexe)

#define   size_hyper_hyper_complexe                                                                                                     \
                    SIZP(_nombre_hyper_hyper_complexe)                                                                                  \
                                        /* Taille des nombres hyper-hyper-complexes...                                               */

#define   _nombre_hyper_hyper_complexe_etendu                                                                                           \
                    STRU(nombre_hyper_hyper_complexe_etendu)                                                                            \
                                        /* Definition d'un type intermediaire pour faciliter la parametrisation de la taille         */ \
                                        /* (introduit le 20091119085332).                                                            */
Typedef(hyper_hyper_complexe_etendu,_nombre_hyper_hyper_complexe_etendu)
TypedefS(A___hyper_hyper_complexe_etendu,hyper_hyper_complexe_etendu)
TypedefS(E___hyper_hyper_complexe_etendu,hyper_hyper_complexe_etendu)

#define   size_hyper_hyper_complexe_etendu                                                                                              \
                    SIZP(_nombre_hyper_hyper_complexe_etendu)                                                                           \
                                        /* Taille des nombres hyper-hyper-complexes (introduit le 20110811162718).                   */

#define   Carre_de_i__Octonion                                                                                                          \
                    Carre_de_i__Complexe
#define   Carre_de_j__Octonion                                                                                                          \
                    Carre_de_i__Complexe
#define   Carre_de_k__Octonion                                                                                                          \
                    Carre_de_i__Complexe
#define   Carre_de_s__Octonion                                                                                                          \
                    Carre_de_i__Complexe
#define   Carre_de_t__Octonion                                                                                                          \
                    Carre_de_i__Complexe
#define   Carre_de_u__Octonion                                                                                                          \
                    Carre_de_i__Complexe
#define   Carre_de_v__Octonion                                                                                                          \
                    Carre_de_i__Complexe
                                        /* Carre de {i,j,k,s,t,u,v} (introduit le 20200321152406).                                   */

#define   Rho1_Octonion                                                                                                                 \
                    Rho1_Complexe                                                                                                       \
                                        /* Module unite des nombres hyper-hyper-complexes (introduit le 20110829151249).             */

#define   R0_Octonion                                                                                                                   \
                    R0_Quaternion
#define   I0_Octonion                                                                                                                   \
                    I0_Quaternion
#define   J0_Octonion                                                                                                                   \
                    J0_Quaternion
#define   K0_Octonion                                                                                                                   \
                    K0_Quaternion
#define   S0_Octonion                                                                                                                   \
                    FZERO
#define   T0_Octonion                                                                                                                   \
                    FZERO
#define   U0_Octonion                                                                                                                   \
                    FZERO
#define   V0_Octonion                                                                                                                   \
                    FZERO
                                        /* Definition du nombre {0,0,0,0,0,0,0,0} (introduit le 20060425155739).                     */
#define   R1_Octonion                                                                                                                   \
                    R1_Quaternion
#define   I1_Octonion                                                                                                                   \
                    I1_Quaternion
#define   J1_Octonion                                                                                                                   \
                    K1_Quaternion
#define   K1_Octonion                                                                                                                   \
                    K1_Quaternion
#define   S1_Octonion                                                                                                                   \
                    FU
#define   T1_Octonion                                                                                                                   \
                    FU
#define   U1_Octonion                                                                                                                   \
                    FU
#define   V1_Octonion                                                                                                                   \
                    FU
                                        /* Definition du nombre {1,1,1,1,1,1,1,1} (introduit le 20060425155739).                     */

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#    define    HHReelle(o)                                                                                                              \
                         ASD1(PARE(o),HHreelle)                                                                                         \
                                        /* Acces a la partie reelle du nombre hyper-hyper-complexe 'o',                              */
#    define    HHImaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHimaginaire)                                                                                     \
                                        /* Acces a la partie imaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHJmaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHjmaginaire)                                                                                     \
                                        /* Acces a la partie jmaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHKmaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHkmaginaire)                                                                                     \
                                        /* Acces a la partie kmaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHSmaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHsmaginaire)                                                                                     \
                                        /* Acces a la partie smaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHTmaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHtmaginaire)                                                                                     \
                                        /* Acces a la partie tmaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHUmaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHumaginaire)                                                                                     \
                                        /* Acces a la partie umaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHVmaginaire(o)                                                                                                          \
                         ASD1(PARE(o),HHvmaginaire)                                                                                     \
                                        /* Acces a la partie vmaginaire du nombre hyper-hyper-complexe 'o'.                          */

#    define    CHHReelle(o)                                                                                                             \
                         ConjugaisonReelle(HHReelle(o))                                                                                 \
                                        /* Acces a la partie reelle du conjugue du nombre hyper-hyper-complexe 'o',                  */
#    define    CHHImaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHImaginaire(o))                                                                       \
                                        /* Acces a la partie imaginaire du conjugue du nombre hyper-hyper-complexe 'o',              */
#    define    CHHJmaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHJmaginaire(o))                                                                       \
                                        /* Acces a la partie jmaginaire du conjugue du nombre hyper-hyper-complexe 'o',              */
#    define    CHHKmaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHKmaginaire(o))                                                                       \
                                        /* Acces a la partie kmaginaire du conjugue du nombre hyper-hyper-complexe 'o'.              */
#    define    CHHSmaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHSmaginaire(o))                                                                       \
                                        /* Acces a la partie smaginaire du conjugue du nombre hyper-hyper-complexe 'o',              */
#    define    CHHTmaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHTmaginaire(o))                                                                       \
                                        /* Acces a la partie tmaginaire du conjugue du nombre hyper-hyper-complexe 'o'.              */
#    define    CHHUmaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHUmaginaire(o))                                                                       \
                                        /* Acces a la partie umaginaire du conjugue du nombre hyper-hyper-complexe 'o',              */
#    define    CHHVmaginaire(o)                                                                                                         \
                         ConjugaisonImaginaire_s(HHVmaginaire(o))                                                                       \
                                        /* Acces a la partie vmaginaire du conjugue du nombre hyper-hyper-complexe 'o'.              */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_01

#ifdef    DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#    define    dHHReelle(o)                                                                                                             \
                         ASD1(PARE(o),HHreelle)                                                                                         \
                                        /* Acces a la partie 'HHreelle' du nombre hyper-hyper-complexe 'o' ou "decomposistion",      */
#    define    dHHImaginaire(o)                                                                                                         \
                         ASD1(PARE(o),HHsmaginaire)                                                                                     \
                                        /* Acces a la partie 'HHsmaginaire' du nombre hyper-hyper-complexe 'o' ou "decomposistion".  */

#    define    HHReelle(o)                                                                                                              \
                         HReelle(dHHReelle(o))                                                                                          \
                                        /* Acces a la partie reelle du nombre hyper-hyper-complexe 'o',                              */
#    define    HHImaginaire(o)                                                                                                          \
                         HImaginaire(dHHReelle(o))                                                                                      \
                                        /* Acces a la partie imaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHJmaginaire(o)                                                                                                          \
                         HJmaginaire(dHHReelle(o))                                                                                      \
                                        /* Acces a la partie jmaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHKmaginaire(o)                                                                                                          \
                         HKmaginaire(dHHReelle(o))                                                                                      \
                                        /* Acces a la partie kmaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHSmaginaire(o)                                                                                                          \
                         HReelle(dHHImaginaire(o))                                                                                      \
                                        /* Acces a la partie smaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHTmaginaire(o)                                                                                                          \
                         HImaginaire(dHHImaginaire(o))                                                                                  \
                                        /* Acces a la partie tmaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHUmaginaire(o)                                                                                                          \
                         HJmaginaire(dHHImaginaire(o))                                                                                  \
                                        /* Acces a la partie umaginaire du nombre hyper-hyper-complexe 'o',                          */
#    define    HHVmaginaire(o)                                                                                                          \
                         HKmaginaire(dHHImaginaire(o))                                                                                  \
                                        /* Acces a la partie vmaginaire du nombre hyper-hyper-complexe 'o'.                          */
#Aifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02
#Eifdef   DEFINITION_DES_CORPS_BATIS_A_PARTIR_DES_NOMBRES_REELS_VERSION_02

#define  HHCHHS_Rho(o_etendu)                                                                                                           \
                    ASD1(PARE(o_etendu),HHrho)
#define  HHCHHS_Angle1(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle1)
#define  HHCHHS_Angle2(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle2)
#define  HHCHHS_Angle3(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle3)
#define  HHCHHS_Angle4(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle4)
#define  HHCHHS_Angle5(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle5)
#define  HHCHHS_Angle6(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle6)
#define  HHCHHS_Angle7(o_etendu)                                                                                                        \
                    ASD1(PARE(o_etendu),HHangle7)
                                        /* Acces aux composantes "etendues" d'un nombre hyper-hyper-complexe, le symbole "CHHS"      */
                                        /* signifiant "Coordonnees Hyper-Hyper-Spheriques" (introduit le 20110811180011).    '       */



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