Définition des Nombres Complexes






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:02 -CET-)



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

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

/*                                                                                           */
/*                  cos(z) = [cos(R(z)).ch(|I(z)|)]  - [sin(R(z)).shc(|I(z)|).I(z)]          */
/*                  sin(z) = [sin(R(z)).ch(|I(z)|)]  + [cos(R(z)).shc(|I(z)|).I(z)]          */
/*                                                                                           */
/*                  ch(z)  = [ch(R(z)).cos(|I(z)|)]  + [sh(R(z)).sinc(|I(z)|).I(z)]          */
/*                  sh(z)  = [sh(R(z)).cos(|I(z)|)]  + [ch(R(z)).sinc(|I(z)|).I(z)]          */
/*                                                                                           */
/* en faisant les hypotheses audacieuses suivantes :                                         */
/*                                                                                           */
/*                  z  = R(z) + I(z)                                                         */
/*                  z  = a    + b.i                                                          */
/*                                                                                           */
/*                  I  =        b.i                                             [I = I(z)]   */
/*                                                                              [m = |I|]    */
/*                                                                                           */
/*                  z  = a + I                                                               */
/*                                                                                           */
/*                                          f11    f12      f21    f22                       */
/*                                                                                           */
/*                  cos(z) = cos(a+I)   = [cos(a).cos(I) - sin(a).sin(I)]                    */
/*                  sin(z) = cos(a+I)   = [sin(a).cos(I) + cos(a).sin(I)]                    */
/*                                                                                           */
/*                  ch(z)  = ch(a+I)    = [ch(a).ch(I)   + sh(a).sh(I)]                      */
/*                  sh(z)  = 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(z) = cos(a+I)   = [cos(a).ch(m)  - sin(a).shc(m).I]                  */
/*                  sin(z) = cos(a+I)   = [sin(a).ch(m)  + cos(a).shc(m).I]                  */
/*                                                                                           */
/*                  ch(z)  = ch(a+I)    = [ch(a).cos(m)  + sh(a).sinc(m).I]                  */
/*                  sh(z)  = sh(a+I)    = [sh(a).cos(m)  + ch(a).sinc(m).I]                  */
/*                                                                                           */
/*                                                                                           */
/* On verifie aisement que :                                                                 */
/*                                                                                           */
/*                     2         2        2         2     2                                  */
/*                  cos (z) + sin (z) = 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                                                    */
/*                                                                                           */
/* et de meme :                                                                              */
/*                                                                                           */
/*                    2        2                                                             */
/*                  ch (z) - sh (z)   = 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.