UpsMat.Complexe

Définition


/***************************************************************/

Type Complexe Implemente Public : ICorpsCommutatif, IEspaceMetre Defaut Final TailleSegment 32 ConserverObjets

/* Objet : Encapsulation du type Complexe. */

/***************************************************************/

/*-------------------------------------------------------------*/

/* Heritage des proprietes d'Objet.  */

/*-------------------------------------------------------------*/

Prive :

	
	EstInstanceDe : Type Lecture Public;

/*-------------------------------------------------------------*/

/* Heritage des methodes d'Objet.    					      */

/*-------------------------------------------------------------*/

Public :

	
	Fonction Optimiser(Invariant) Identique(O : Nul Ou Objet) Retourner Nul Ou Booleen;
	

	Procedure Convertir(O : Nul Ou Objet);
	

	Fonction Optimiser(Invariant) CreeParLeServeur() Retourner Entier;
	

	Fonction Optimiser(Invariant) CreeParLeProcessus() Retourner Entier;
	

	Fonction Optimiser(Invariant) CreeDansLEntrepot() Retourner Entrepot;
	

	Fonction Cloner(EntrepotCible : Nul Ou Entrepot=Nul, Profondeur : ModeClonage = ClonageObjetSeul) Retourner Nul Ou Objet;
	

	Fonction LirePropriete(NomPropriete : Caractere) Retourner Nul Ou Objet;
	

	Procedure EcrirePropriete(NomPropriete : Caractere, Valeur : Nul Ou Objet);
	

	Fonction IncrementerDecrementerPropriete(NomPropriete : Nul Ou Caractere, Incrementer : Booleen, Prefixe : Booleen) Retourner Nul Ou Objet;
	

	Procedure SupprimerPropriete(NomPropriete : Caractere);
	

	Fonction Optimiser(Invariant) EnumererProprietes(NumeroPropriete : Entier, TypePropriete : Nul Ou Type=? Sortie, PeutEtreNul : Booleen=? Sortie, Aide : Nul Ou Caractere=? Sortie, NomEnumere : Nul Ou Caractere=? Sortie) Retourner Nul Ou Caractere;
	

	Fonction Optimiser(Invariant) Adresse() Retourner Nul Ou Caractere;

Prive :

	
	Fonction Exporter(E : Nul Ou IEchangeElementaire) Retourner Boolean;
	

	Fonction Importer(E : Nul Ou IEchangeElementaire, EntrepotCible : Nul Ou Entrepot=Nul, EstFiltre : Booleen=Faux, V : Entier=0, R : Entier=0, C : Entier=0) Retourner Nul Ou Objet;

/*-------------------------------------------------------------*/

/* Heritage des methodes de IAlgebreCommutative.      				*/

/*-------------------------------------------------------------*/

Public :


	
	Operateur Optimiser(Invariant, NulAbsorbant) +(C : Nul Ou Complexe) Retourner Complexe;
	

	Operateur Optimiser(Invariant) -() Retourner Nul Ou Complexe;
	

	Operateur Optimiser(Invariant, NulAbsorbant) -(E : Nul Ou Entier) Retourner Nul Ou Complexe;
	

	Operateur Optimiser(Invariant, NulAbsorbant) *(C : Nul Ou Complexe) Retourner Nul Ou Complexe;
	

	Operateur ++(P : Nul Ou Booleen) Retourner Nul Ou Complexe;
	

	Operateur --(P : Nul Ou Booleen) Retourner Nul Ou Complexe;

/*-------------------------------------------------------------*/

/* Heritage des methodes de ICorpsCommutatif.        				*/

/*-------------------------------------------------------------*/

Public :


	
	Operateur Optimiser(Invariant, NulAbsorbant) /(C : Nul Ou Complexe) Retourner Nul Ou Complexe;
	

	Operateur Optimiser(Invariant, NulAbsorbant) ^(C : Nul Ou Complexe) Retourner Nul Ou Complexe;

/*-------------------------------------------------------------*/

/* Heritage des methodes d'IEspaceMetre.            				*/

/*-------------------------------------------------------------*/

Public :


	
	Operateur Optimiser(Invariant, NulAbsorbant) <=(C : Nul Ou Complexe) Retourner Nul Ou Booleen;
	

	Operateur Optimiser(Invariant, NulAbsorbant) >=(C : Nul Ou Complexe) Retourner Nul Ou Booleen;
	

	Operateur Optimiser(Invariant, NulAbsorbant) <(C : Nul Ou Complexe) Retourner Nul Ou Booleen;
	

	Operateur Optimiser(Invariant, NulAbsorbant) >(C : Nul Ou Complexe) Retourner Nul Ou Booleen;

/*-------------------------------------------------------------*/

/* Methodes propres.                                           */

/*-------------------------------------------------------------*/

Public :


	
   Constructeur();
	

   Constructeur Optimiser(Invariant, NulAbsorbant) (E : Nul Ou Entier, EI : Nul Ou Entier=Nul, EstPolaire : Booleen=Faux);
	

   Constructeur Optimiser(Invariant, NulAbsorbant) (R : Nul Ou Reel, RI : Nul Ou Reel=Nul, EstPolaire : Booleen=Faux);
	

   Constructeur Optimiser(Invariant, NulAbsorbant) (C : Nul Ou Caractere, EstDecimal : Booleen=Faux);
	

   Constructeur Optimiser(Invariant, NulAbsorbant) (D : Nul Ou Decimal, DI : Nul Ou Decimal=Nul, EstPolaire : Booleen=Faux);
	

   Operateur Optimiser(Invariant, NulAbsorbant) ==(C : Nul Ou Complexe) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) !=(C : Nul Ou Complexe) Retourner Nul Ou Booleen;
	

   Operateur =(E : Nul Ou Entier);
	

   Operateur =(R : Nul Ou Reel);
	

   Operateur =(D : Nul Ou Decimal);
	

   Operateur Optimiser(Invariant, NulAbsorbant) +(E : Nul Ou Entier) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) +(R : Nul Ou Reel) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) +(D : Nul Ou Decimal) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) -(E : Nul Ou Entier) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) -(R : Nul Ou Reel) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) -(D : Nul Ou Decimal) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) *(E : Nul Ou Entier) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) *(R : Nul Ou Reel) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) *(D : Nul Ou Decimal) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) /(E : Nul Ou Entier) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) /(R : Nul Ou Reel) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) /(D : Nul Ou Decimal) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) ^(E : Nul Ou Entier) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) ^(R : Nul Ou Reel) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) ^(D : Nul Ou Decimal) Retourner Nul Ou Complexe;
	

   Operateur Optimiser(Invariant, NulAbsorbant) ==(E : Nul Ou Entier) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) ==(R : Nul Ou Reel) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) ==(D : Nul Ou Decimal) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) !=(E : Nul Ou Entier) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) !=(R : Nul Ou Reel) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) !=(D : Nul Ou Decimal) Retourner Nul Ou Booleen;
	

   Fonction Optimiser(Invariant, NulAbsorbant) Arrondir(N : Nul Ou Entier) Retourner Nul Ou Complexe;
	

   Fonction Optimiser(Invariant) AnglePolaireVersReel() Retourner Nul Ou Reel;
	

   Fonction Optimiser(Invariant) AnglePolaireVersDecimal() Retourner Nul Ou Decimal;
	

   Fonction Optimiser(Invariant) PartieReelleVersEntier() Retourner Nul Ou Entier;
	

   Fonction Optimiser(Invariant) PartieReelleVersReel() Retourner Nul Ou Reel;
	

   Fonction Optimiser(Invariant) PartieReelleVersDecimal() Retourner Nul Ou Decimal;
	

   Fonction Optimiser(Invariant) PartieImaginaireVersEntier() Retourner Nul Ou Entier;
	

   Fonction Optimiser(Invariant) PartieImaginaireVersReel() Retourner Nul Ou Reel;
	

   Fonction Optimiser(Invariant) PartieImaginaireVersDecimal() Retourner Nul Ou Decimal;
	

   Fonction Optimiser(Invariant) VersCaractere(Filtre : Nul Ou Caractere=Nul, PointVirgule : Nul Ou Caractere=Nul) Retourner Nul Ou Caractere;

Prive :

	
   Destructeur(MettreEnAnteMemoire : Booleen) Retourner Booleen;

Fin Type

Le type Complexe modélise un nombre complexe en virgule flottante ou en virgule fixe selon la précision requise. La bascule d'un mode à l'autre est réalisée automatiquement.

Le type Complexe possède cinq constructeurs :

Un constructeur implicite qui initialise la valeur complexe à 0.0.
Conversion d'un couple d'entiers en un complexe. La représentation peut être polaire.
Conversion d'un couple de réels en un complexe. La représentation peut être polaire.
Conversion d'un couple de décimaix en un complexe. La représentation peut être polaire.
Conversion d'une chaîne de caractères représentant un complexe.

Opérateurs

Le type Complexe possède les opérateurs standards suivants :

+ pour l'addition entre deux complexes. Le résultat est un complexe.
+ pour l'addition entre un complexe et un entier. Le résultat est un complexe.
+ pour l'addition entre un complexe et un réel. Le résultat est un complexe.
+ pour l'addition entre un complexe et un décimal. Le résultat est un complexe.
- pour le changement de signe d'un complexe. Le résultat est un complexe.
- pour la soustraction entre deux complexes. Le résultat est un complexe.
- pour la soustraction entre un complexe et un entier. Le résultat est un complexe.
- pour la soustraction entre un complexe et un réel. Le résultat est un complexe.
- pour la soustraction entre un complexe et un décimal. Le résultat est un complexe.
* pour la multiplication entre deux complexes. Le résultat est un complexe.
* pour la multiplication entre un complexe et un entier. Le résultat est un complexe.
* pour la multiplication entre un complexe et un réel. Le résultat est un complexe.
* pour la multiplication entre un complexe et un décimal. Le résultat est un complexe.
/ pour la division entre deux complexes. Le résultat est un complexe.
/ pour la division entre un complexe et un entier. Le résultat est un complexe.
/ pour la division entre un complexe et un réel. Le résultat est un complexe.
/ pour la division entre un complexe et un décimal. Le résultat est un complexe.
^ pour la puissance d'un complexe par un complexe. Le résultat est un complexe.
^ pour la puissance d'un complexe par un entier. Le résultat est un complexe.
^ pour la puissance d'un complexe par un réel. Le résultat est un complexe.
^ pour la puissance d'un complexe par un décimal. Le résultat est un complexe.
== pour l'égalité entre deux complexes. Le résultat est un booléen.
== pour l'égalité entre un complexe et un entier. Le résultat est un booléen.
== pour l'égalité entre un complexe et un réel. Le résultat est un booléen.
== pour l'égalité entre un complexe et un décimal. Le résultat est un booléen.
!= pour l'inégalité entre deux complexes. Le résultat est un booléen.
!= pour l'inégalité entre un complexe et un entier. Le résultat est un booléen.
!= pour l'inégalité entre un complexe et un réel. Le résultat est un booléen.
!= pour l'inégalité entre un complexe et un décimal. Le résultat est un booléen.
<= et >= pour l'inégalité large entre deux complexes. Le résultat est un booléen.
<= et >= pour l'inégalité large entre un complexe et un entier. Le résultat est un booléen.
<= et >= pour l'inégalité large entre un complexe et un réel. Le résultat est un booléen.
<= et >= pour l'inégalité large entre un complexe et un décimal. Le résultat est un booléen.
< et > pour l'égalité stricte entre deux complexes. Le résultat est un booléen.
< et > pour l'égalité stricte entre un complexe et un entier. Le résultat est un booléen.
< et > pour l'égalité stricte entre un complexe et un réel. Le résultat est un booléen.
< et > pour l'égalité stricte entre un complexe et un décimal. Le résultat est un booléen.
= pour l'affectation d'un complexe dans un autre.
= pour l'affectation d'un entier dans un complexe.
= pour l'affectation d'un réel dans un complexe.
= pour l'affectation d'un décimal dans un complexe.
+= pour l'addition d'un entier puis affectation du résultat.
+= pour l'addition d'un réel puis l'affectation du résultat.
+= pour l'addition d'un décimal puis l'affectation du résultat.
+= pour l'addition d'un complexe puis l'affectation du résultat.
-= pour soustraction d'un entier puis l'affectation du résultat.
-= pour soustraction d'un réel puis l'affectation du résultat.
-= pour soustraction d'un décimal puis l'affectation du résultat.
-= pour soustraction d'un complexe puis l'affectation du résultat.
*= pour la multiplication d'un entier puis l'affectation du résultat.
*= pour la multiplication d'un réel puis l'affectation du résultat.
*= pour la multiplication d'un décimal puis l'affectation du résultat.
*= pour la multiplication d'un complexe puis l'affectation du résultat.
/= pour la division d'un entier puis l'affectation du résultat.
/= pour la division d'un réel puis l'affectation du résultat.
/= pour la division d'un décimal puis l'affectation du résultat.
/= pour la division d'un complexe puis l'affectation du résultat.

Exemple

Pour un exemple complet, merci de se référer à Complexe.

Principal /*******/ Variable /******/


	C : Complexe;




/* 'C' est une variable de type complexe. */



Debut

C=C+Complexe(10.5);

/* Addition de deux complexes. */

C=C+10;

/* Addition d'un complexe et d'un entier. */

C=C-Complexe(10.5);

/* Soustraction de deux complexes. */

C=C-10;

/* Soustraction d'un complexe et d'un entier. */

C=C*Complexe(2.5);

/* Multiplication de deux complexes. */

C=C*2;

/* Multiplication d'un complexe et d'un entier. */

C=C/Complexe(2.5);

/* Division de deux complexes. */

C=C/10;

/* Division d'un complexe et d'un entier. */

C=C^Complexe(1.5);

/* Puissance de deux complexes. */

C=C^2;

/* Puissance d'un complexe par un entier. */

Si C==10.5 Alors

/* Egalité entre deux complexes. */

	...

Fin Si

Si C==10 Alors

/* Egalité entre un complexe et un entier. */

	...

Fin Si

Si C!=Complexe(10.5) Alors

/* Inégalité entre deux complexes. */

	...

Fin Si

Si C!=10 Alors

/* Inégalité entre un complexe et un entier. */

	...

Fin Si

Si C<=Complexe(10.5) Alors

/* Infériorité large entre deux complexes. */

	...

Fin Si

Si C<=10 Alors

/* Infériorité large entre un complexe et un entier. */


	...

Fin Si

Si C<Complexe(10.5) Alors

/* Infériorité stricte entre deux complexes. */

	...

Fin Si

Si C<10 Alors

/* Infériorité stricte entre un complexe et un entier. */


	...

Fin Si

C=Complexe("10.5-i*3.14");

/* Conversion d'une chaîne de caractères en un complexe. */

Fin Principal

Traduction


-	-	-	-	-	-	-	-	-