Définition des Quaternions






Jean-François COLONNA
www.lactamme.polytechnique.fr
jean-francois.colonna@polytechnique.edu
CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641, Ecole Polytechnique, CNRS, 91128 Palaiseau Cedex, France
france telecom, France Telecom R&D

[Site Map, Help and Search [Plan du Site, Aide et Recherche]]
[The Y2K bug [Le bug de l'an 2000]]
[Croyez-vous que les Nombres Réels existent dans un ordinateur et que les calculs flottants sont sûrs ?]
[N'oubliez pas de visiter Une Machine Virtuelle à Explorer l'Espace-Temps où vous trouverez plus de 5400 images à la frontière de l'Art et de la Science]
(Site WWW CMAP28 : cette page a été créée le 23/01/2001 et mise à jour le 28/01/2014 15:04:01 -CET-)



/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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                                                                                */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/


(Nota : les lignes d'explications qui précédent sont des commentaires extraits des programmes ayant été utilisés pour calculer les images correspondantes. Ce programme en est un exemple parmi des centaines.)





Copyright (c) Jean-François Colonna, 2001-2014.
Copyright (c) France Telecom R&D and CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2001-2014.