Définition des Opérateurs des Corps construits à partir de R






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

[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 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 16/03/2019 et mise à jour le 13/04/2019 12:20:30 -CEST-)



/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   G E N E R A L E   D E S   O P E R A T E U R S   D A N S   L E S                                      */
/*        C O R P S   C O N S T R U I T S   A   P A R T I R   D E S   N O M B R E S   R E E L S  :                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Nota :                                                                                                                     */
/*                                                                                                                                   */
/*                    Tous les operateurs arithmetiques dans                                                                         */
/*                  un corps vont etre definis recursivement                                                                         */
/*                  a partir de ceux du sous-corps grace auquel                                                                      */
/*                  le corps est defini. Soient ainsi 'a', 'a1'                                                                      */
/*                  et 'a2' des nombres Arguments dans le corps,                                                                     */
/*                  et 'r' le Resultat d'une certaine operation                                                                      */
/*                  concernant ces Arguments ; soit d'autre part                                                                     */
/*                  'R(...)' et 'I(...)' les fonctions d'acces                                                                       */
/*                  aux parties Reelle et Imaginaire generalisees                                                                    */
/*                  definissant un nombre quelconque du corps en                                                                     */
/*                  tant que vecteur compose de deux nombres du                                                                      */
/*                  sous corps.                                                                                                      */
/*                                                                                                                                   */
/*                    On a donc, par definition, pour tout nombre 'a' :                                                              */
/*                                                                                                                                   */
/*                                      a = {R(a),I(a)}                                                                              */
/*                                                                                                                                   */
/*                  'a' appartenant a un certain corps K et                                                                          */
/*                  'R(a)' et 'I(a)' appartenant au "sous-corps"                                                                     */
/*                  sK a partir duquel K est defini.                                                                                 */
/*                                                                                                                                   */
/*                    De plus, tout nombre Reel 'x' est egal a                                                                       */
/*                  son conjugue :                                                                                                   */
/*                                                                                                                                   */
/*                                      _                                                                                            */
/*                                      x = x                                                                                        */
/*                                                                                                                                   */
/*                  A partir de R (les nombres Reels) sera                                                                           */
/*                  donc construit C (les nombres Complexes),                                                                        */
/*                  qui lui-meme servira de base a Q (les                                                                            */
/*                  Quaternions, appeles aussi HC [Hyper-Complexes]),                                                                */
/*                  qui lui-meme servira de base a O (les                                                                            */
/*                  Octonions, appeles aussi HHC [Hyper-Hyper-Complexes]).                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition recursive des operateurs arithmetiques :                                                                        */
/*                                                                                                                                   */
/*                  r = a               <==>      {R(r),I(r)} = {R(a),I(a)}                                                          */
/*                                                                                                                                   */
/*                  r = -a              <==>      {R(r),I(r)} = {-R(a),-I(a)}                                                        */
/*                                                                                                                                   */
/*                      _                                        ____                                                                */
/*                  r = a               <==>      {R(r),I(r)} = {R(a),-I(a)}                                                         */
/*                                                                                                                                   */
/*                  r = a1 + a2         <==>      {R(r),I(r)} = {R(a1)+R(a2),I(a1)+I(a2)}                                            */
/*                                                                                                                                   */
/*                  r = a1 - a2         <==>      {R(r),I(r)} = {R(a1)-R(a2),I(a1)-I(a2)}                                            */
/*                                                                                                                                   */
/*                  r = (A.a1) + (B.a2) <==>      {R(r),I(r)} = {[A.R(a1)]+[B.R(a2)],[A.I(a1)]+[B.I(a2)]}                            */
/*                                                                                                                                   */
/*                                                                                      _____                         _____          */
/*                  r = a1.a2           <==>      {R(r),I(r)} = {[R(a1).R(a2)] - [I(a1).I(a2)],[R(a1).I(a2)] + [I(a1).R(a2)]}        */
/*                                                                                                                                   */
/*                     2                             2                2         2                                                    */
/*                  |a|                 <==>      |a|         = |R(a)|  + |I(a)|                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Exceptions au schema recursif :                                                                                            */
/*                                                                                                                                   */
/*                    Malheureusement, echappent a ce schema, deux                                                                   */
/*                  operateurs car, en effet, ils considerent chaque                                                                 */
/*                  nombre du groupe, non pas comme un vecteur                                                                       */
/*                  bidimensionnel dans le sous-groupe sous-jacent,                                                                  */
/*                  mais comme un vecteur N-dimensionnel defini dans                                                                 */
/*                  les nombres Reels. Ces operateurs d'exception                                                                    */
/*                  sont :                                                                                                           */
/*                                                                                                                                   */
/*                                      FH...Cinitialisation(...)                                                                    */
/*                                      FH...Cforme_lineaire(...)                                                                    */
/*                                                                                                                                   */
/*                  qui initialise et calcule une forme lineaire                                                                     */
/*                  respectivement. D'une part le nombre d'arguments                                                                 */
/*                  varient quand la dimension du groupe change, et                                                                  */
/*                  d'autre part, en ce qui concerne le second, l'operation                                                          */
/*                  qu'il realise dissymetrise les differentes composantes,                                                          */
/*                  la premiere etant "scalee" et "translatee", alors que                                                            */
/*                  les suivantes ne sont que "scalees"...                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/


(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, 2019.
Copyright (c) CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2019.