UpsMat.Decimal

Définition


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

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

/* Objet : Encapsulation du type Decimal. */

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

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

/* 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) +(D : Nul Ou Decimal) Retourner Decimal;
	

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

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

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

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

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

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

/* Heritage des methodes de ICorpsCommutatif.        				*/

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

Public :


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

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

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

/* Heritage des methodes d'IEspaceMetre.            				*/

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

Public :


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

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

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

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

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

/* Methodes propres.                                           */

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

Public :


	
	Constructeur();
	

	Constructeur Optimiser(Invariant, NulAbsorbant) (E: Nul Ou Entier);
	

	Constructeur Optimiser(Invariant, NulAbsorbant) (R: Nul Ou Reel);
	

	Constructeur Optimiser(Invariant, NulAbsorbant) (C: Nul Ou Caractere, Base : Nul Ou Entier=Nul);
	

   Constructeur Optimiser(Invariant, NulAbsorbant) (B : Nul Ou Binaire, BigEndian : Booleen=Vrai);
	

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

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

   Operateur =(E : Nul Ou Entier);
	

   Operateur =(R : Nul Ou Reel);
	

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

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

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

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

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

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

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

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

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

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

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

   Operateur Optimiser(Invariant, NulAbsorbant) \(E : Nul Ou Entier) Retourner Nul Ou Decimal;
	

   Operateur Optimiser(Invariant, NulAbsorbant) \(R : Nul Ou Reel) Retourner Nul Ou Decimal;
	

   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) !=(E : Nul Ou Entier) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) !=(R : Nul Ou Reel) 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) >=(E : Nul Ou Entier) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) >=(R : Nul Ou Reel) 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) >(E : Nul Ou Entier) Retourner Nul Ou Booleen;
	

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

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

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

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

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

   Fonction Optimiser(Invariant) VersCaractere(Base : Nul Ou Entier) Retourner Nul Ou Caractere;
	

   Fonction Optimiser(Invariant) VersBinaire(BigEndian : Booleen=Vrai) Retourner Nul Ou Binaire;

Prive :

	
   Destructeur(MettreEnAnteMemoire : Booleen) Retourner Booleen;

Fin Type

Le type Decimal modélise un nombre réel en virgule fixe de précision arbitraire définie par les paramètres UpsMat.TaillePartieEntiere et UpsMat.TaillePartieDecimale.

Le type Decimal possède quatre constructeurs :

Un constructeur implicite qui initialise la valeur décimale à 0.0.
Conversion d'un entier en un décimal.
Conversion d'un réel en un décimal.
Conversion d'une chaîne de caractères représentant un décimal dans la base demandée. Les bases supportées sont 2, 4, 8, 10 et 16. Par défaut, la base décimale est utilisée.
Conversion d'un binaire en un décimal entier. Si le paramètre BigEndian a pour valeur Vrai, alors l'ordre des octets est conforme à Motorola. Sinon, l'ordre est conforme à Intel.

Opérateurs

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

+ pour l'addition entre deux décimaux. Le résultat est un décimal.
+ pour l'addition entre un décimal et un entier. Le résultat est un décimal.
+ pour l'addition entre un décimal et un réel. Le résultat est un décimal.
- pour le changement de signe d'un décimal. Le résultat est un décimal.
- pour la soustraction entre deux décimaux. Le résultat est un décimal.
- pour la soustraction entre un décimal et un entier. Le résultat est un décimal.
- pour la soustraction entre un décimal et un réel. Le résultat est un décimal.
* pour la multiplication entre deux décimaux. Le résultat est un décimal.
* pour la multiplication entre un décimal et un entier. Le résultat est un décimal.
* pour la multiplication entre un décimal et un réel. Le résultat est un décimal.
/ pour la division entre deux décimaux. Le résultat est un décimal.
/ pour la division entre un décimal et un entier. Le résultat est un décimal.
/ pour la division entre un décimal et un réel. Le résultat est un décimal.
\ pour la division entre deux décimaux. Le résultat est un entier.
\ pour la division entre un décimal et un entier. Le résultat est un entier.
\ pour la division entre un décimal et un reel. Le résultat est un entier.
^ pour la puissance d'un décimal par un décimal. Le résultat est un décimal.
^ pour la puissance d'un décimal par un entier. Le résultat est un décimal.
^ pour la puissance d'un décimal par un réel. Le résultat est un décimal.
== pour l'égalité entre deux décimauxs. Le résultat est un booléen.
== pour l'égalité entre un décimal et un entier. Le résultat est un booléen.
== pour l'égalité entre un décimal et un réel. Le résultat est un booléen.
!= pour l'inégalité entre deux décimaux. Le résultat est un booléen.
!= pour l'inégalité entre un décimal et un entier. Le résultat est un booléen.
!= pour l'inégalité entre un décimal et un réel. Le résultat est un booléen.
<= et >= pour l'inégalité large entre deux décimaux. Le résultat est un booléen.
<= et >= pour l'inégalité large entre un décimal et un entier. Le résultat est un booléen.
<= et >= pour l'inégalité large entre un décimal et un réel. Le résultat est un booléen.
< et > pour l'égalité stricte entre deux décimaux. Le résultat est un booléen.
< et > pour l'égalité stricte entre un décimal et un entier. Le résultat est un booléen.
< et > pour l'égalité stricte entre un décimal et un réel. Le résultat est un booléen.
= pour l'affectation d'un décimal dans un autre.
= pour l'affectation d'un entier dans un décimal.
= pour l'affectation d'un réel dans un décimal.
+= 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 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 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 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.

Exemple

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

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


	D : Decimal;




/* 'D' est une variable de type décimal. */



Debut

D=D+Decimal(10.5);

/* Addition de deux décimaux. */

D=D+10;

/* Addition d'un décimal et d'un entier. */

D=D-Decimal(10.5);

/* Soustraction de deux décimaux. */

D=D-10;

/* Soustraction d'un décimal et d'un entier. */

D=D*Decimal(2.5);

/* Multiplication de deux décimaux. */

D=D*2;

/* Multiplication d'un décimal et d'un entier. */

D=D/Decimal(2.5);

/* Division de deux décimaux. */

D=D/10;

/* Division d'un décimal et d'un entier. */

D=D^Decimal(1.5);

/* Puissance de deux décimaux. */

D=D^2;

/* Puissance d'un décimal par un entier. */

Si D==Decimal(10.5) Alors

/* Egalité entre deux décimaux. */

	...

Fin Si

Si D==10 Alors

/* Egalité entre un décimal et un entier. */

	...

Fin Si

Si D!=Decimal(10.5) Alors

/* Inégalité entre deux décimaux. */

	...

Fin Si

Si D!=10 Alors

/* Inégalité entre un décimal et un entier. */

	...

Fin Si

Si D<=Decimal(10.5) Alors

/* Infériorité large entre deux décimaux. */

	...

Fin Si

Si D<=10 Alors

/* Infériorité large entre un décimal et un entier. */


	...

Fin Si

Si D<Decimal(10.5) Alors

/* Infériorité stricte entre deux décimaux. */

	...

Fin Si

Si D<10 Alors

/* Infériorité stricte entre un décimal et un entier. */


	...

Fin Si

D=Decimal("12345678901234567890123456789012345678901234567890.12345678901234567890123456789012345678901234567890");

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

Fin Principal

Traduction


-	-	-	-	-	-	-	-	-