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