Définition des Quaternions






Jean-François COLONNA
[Contact me]

www.lactamme.polytechnique.fr

CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641, École polytechnique, Institut Polytechnique de Paris, CNRS, 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]]
[Real Numbers don't exist in Computers and Floating Point Computations aren't safe. [Les Nombres Réels n'existent dans les Ordinateurs et les Calculs Flottants ne sont pas sûrs.]]
[N'oubliez pas de visiter Une Machine Virtuelle à Explorer l'Espace-Temps et au-delà où vous trouverez plusieurs milliers d'images et d'animations à la frontière de l'Art et de la Science]
(Site WWW CMAP28 : cette page a été créée le 01/23/2001 et mise à jour le 14/11/2023 17:51:07 -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                                                                                */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

Définition de l'exponentielle d'un Quaternion :

/*                                                                                           */
/*                   q    R(q)                                                               */
/*                  e  = e    .[cos(|I(q)|) + sinc(|I(q)|).I(q)]                             */
/*                                                                                           */
/* En effet :                                                                                */
/*                                                                                           */
/*                  q  = R(q) + I(q)                                                         */
/*                  q  = a    + b.i + c.j + d.k                                              */
/*                                                                                           */
/*                  I  =        b.i + c.j + d.k             [I = I(q)]                       */
/*                                                                                           */
/*                  q  = a + I                                                               */
/*                                                                                           */
/*                   2     2   2   2       2     2                                           */
/*                  I  = -b  -c  -d  = -|I|  = -m           [m = |I|]                        */
/*                                                                                           */
/*                   3     2                                                                 */
/*                  I  = -m .I                                                               */
/*                                                                                           */
/*                   4     4                                                                 */
/*                  I  = +m                                                                  */
/*                                                                                           */
/*                   5     4                                                                 */
/*                  I  = +m .I                                                               */
/*                                                                                           */
/*                  (...)                                                                    */
/*                                                                                           */
/*                   q    a  I                         a.i  c.j  d.k                         */
/*                  e  = e .e           (et non pas : e   .e   .e   )                        */
/*                                                                                           */
/*         I        1    1    1    2    1    3    1    4    1    5                           */
/*        e  = 1 + ----.I  + ----.I  + ----.I  + ----.I  + ----.I  + (...)                   */
/*                  1!        2!        3!        4!        5!                               */
/*                                                                                           */
/*         I        1    1    1      2     1      2        1      4     1      4             */
/*        e  = 1 + ----.I  + ----.(-m ) + ----.(-m ).I) + ----.(+m ) + ----.(+m .I) + (...)  */
/*                  1!        2!           3!              4!           5!                   */
/*                                                                                           */
/*         I        1    2    1    4               1      1    2                             */
/*        e  = 1 - ----.m  + ----.m  + (...) + I.[---- - ----.m  + (...)]                    */
/*                  2!        4!                   1!     3!                                 */
/*                                                                                           */
/*         I        1    2    1    4            I    1    1   1    3                         */
/*        e  = 1 - ----.m  + ----.m  + (...) + ---.[----.m - ----.m  + (...)]                */
/*                  2!        4!                m    1!       3!                             */
/*                                                                                           */
/*         I                                    I                                            */
/*        e  = cos(m)                        + ---.sin(m)                                    */
/*                                              m                                            */
/*                                                                                           */
/*         I                                                                                 */
/*        e  = cos(m) + sinc(m).I                                                            */
/*                                                                                           */
/*         q    a                                                                            */
/*        e  = e .[cos(m) + sinc(m).I]                      [sinc(...) = sinus cardinal]     */
/*                                                                                           */

Définition du logarithme d'un Quaternion :

/*                                                                                           */
/*                                        1          |R(q)|                                  */
/*                  log(q) = {log(|q|,--------.acos(--------).I(q)}                          */
/*                                     |I(q)|          |q|                                   */
/*                                                                                           */

Définition des lignes trigonométriques circulaires et hyperboliques d'un Quaternion :

/*                                                                                           */
/*                  cos(q) = [cos(R(q)).ch(|I(q)|)]  - [sin(R(q)).shc(|I(q)|).I(q)]          */
/*                  sin(q) = [sin(R(q)).ch(|I(q)|)]  + [cos(R(q)).shc(|I(q)|).I(q)]          */
/*                                                                                           */
/*                  ch(q)  = [ch(R(q)).cos(|I(q)|)]  + [sh(R(q)).sinc(|I(q)|).I(q)]          */
/*                  sh(q)  = [sh(R(q)).cos(|I(q)|)]  + [ch(R(q)).sinc(|I(q)|).I(q)]          */
/*                                                                                           */
/* en faisant les hypotheses audacieuses suivantes :                                         */
/*                                                                                           */
/*                  q  = R(q) + I(q)                                                         */
/*                  q  = a    + b.i + c.j + d.k                                              */
/*                                                                                           */
/*                  I  =        b.i + c.j + d.k                                 [I = I(q)]   */
/*                                                                              [m = |I|]    */
/*                                                                                           */
/*                  q  = a + I                                                               */
/*                                                                                           */
/*                                          f11    f12      f21    f22                       */
/*                                                                                           */
/*                  cos(q) = cos(a+I)   = [cos(a).cos(I) - sin(a).sin(I)]                    */
/*                  sin(q) = cos(a+I)   = [sin(a).cos(I) + cos(a).sin(I)]                    */
/*                                                                                           */
/*                  ch(q)  = ch(a+I)    = [ch(a).ch(I)   + sh(a).sh(I)]                      */
/*                  sh(q)  = sh(a+I)    = [sh(a).ch(I)   + ch(a).sh(I)]                      */
/*                                                                                           */
/* En effet, par des developpements en series tel celui de 'FgHCexponentielle(...)', on      */
/* montre facilement que :                                                                   */
/*                                                                                           */
/*                  cos(I) = ch(m)                                                           */
/*                                                                                           */
/*                            sh(m)                                                          */
/*                  sin(I) = -------.I  = shc(m).I                                           */
/*                              m                                                            */
/*                                                                                           */
/*                                                                                           */
/*                  ch(I)  = cos(m)                                                          */
/*                                                                                           */
/*                            sin(m)                                                         */
/*                  sh(I)  = --------.I = sinc(m).I                                          */
/*                              m                                                            */
/*                                                                                           */
/* d'ou :                                                                                    */
/*                                                                                           */
/*                                          f11    f12      f21    f22                       */
/*                                                                                           */
/*                  cos(q) = cos(a+I)   = [cos(a).ch(m)  - sin(a).shc(m).I]                  */
/*                  sin(q) = cos(a+I)   = [sin(a).ch(m)  + cos(a).shc(m).I]                  */
/*                                                                                           */
/*                  ch(q)  = ch(a+I)    = [ch(a).cos(m)  + sh(a).sinc(m).I]                  */
/*                  sh(q)  = sh(a+I)    = [sh(a).cos(m)  + ch(a).sinc(m).I]                  */
/*                                                                                           */
/*                                                                                           */
/* On verifie aisement que :                                                                 */
/*                                                                                           */
/*                     2         2        2         2     2                                  */
/*                  cos (q) + sin (q) = ch (m) + shc (m).I                                   */
/*                                                                                           */
/*                                                  2                                        */
/*                                        2       sh (m)   2            2      2             */
/*                                    = ch (m) + --------.I           [I  = -(m )]           */
/*                                                   2                                       */
/*                                                  m                                        */
/*                                                                                           */
/*                                        2        2                                         */
/*                                    = ch (m) - sh (m)                                      */
/*                                                                    ['m' etant un Reel...] */
/*                                    = 1                                                    */
/*                                                                                           */
/* de meme :                                                                                 */
/*                                                                                           */
/*                    2        2                                                             */
/*                  ch (q) - sh (q)   = 1                                                    */
/*                                                                                           */


(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 © Jean-François COLONNA, 2001-2023.
Copyright © France Telecom R&D and CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2001-2023.