UpsKrn.Reel

Définition


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

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

/* Objet : Encapsulation du type Reel. */

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

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

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

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

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

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

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

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

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

/* Heritage des methodes de ICorpsCommutatif.        				*/

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

Public :


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

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

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

/* Heritage des methodes d'IEspaceMetre.            				*/

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

Public :


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

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

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

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

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

/* Methodes propres.                                           */

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

Public :


	
	Constructeur();
	

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

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

	Constructeur Optimiser(Invariant, NulAbsorbant) (D: Nul Ou Date);
	

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

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

	Operateur =(E : Nul Ou Entier);
	

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Prive :

	
   Destructeur(MettreEnAnteMemoire : Booleen) Retourner Booleen;

Fin Type

Le type Reel modélise un nombre réel dans l'intervalle [-1.7E-308, 1.7E+308]. La précision est de 15 chiffres significatifs.

Le type Reel possède quatre constructeurs :

Un constructeur implicite qui initialise la valeur entière à 0.0.
Conversion d'une chaîne de caractères représentant un réel.
Conversion d'un entier en un réel.
Conversion d'un date en un réel représentant le numéro du jour et l'heure dans le calendrier Julien.

Opérateurs

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

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

Exemple

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

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


	PrixArticle : Reel;


/* 'PrixArticle' est une variable de type réel. */



Debut

PrixArticle=PrixArticle+10.5;

/* Addition de deux réels. */

PrixArticle=PrixArticle+10;

/* Addition d'un réel et d'un entier. */

PrixArticle=PrixArticle-10.5;

/* Soustraction de deux réels. */

PrixArticle=PrixArticle-10;

/* Soustraction d'un réel et d'un entier. */

PrixArticle=PrixArticle*2.5;

/* Multiplication de deux réels. */

PrixArticle=PrixArticle*2;

/* Multiplication d'un réel et d'un entier. */

PrixArticle=PrixArticle/2.5;

/* Division de deux réels. */

PrixArticle=PrixArticle/10;

/* Division d'un réel et d'un entier. */

PrixArticle=PrixArticle^1.5;

/* Puissance de deux réels. */

PrixArticle=PrixArticle^2;

/* Puissance d'un réel par un entier. */

Si PrixArticle==10.5 Alors

/* Egalité entre deux réels. */

	...

Fin Si

Si PrixArticle==10 Alors

/* Egalité entre un réel et un entier. */

	...

Fin Si

Si PrixArticle!=10.5 Alors

/* Inégalité entre deux réels. */

	...

Fin Si

Si PrixArticle!=10 Alors

/* Inégalité entre un réel et un entier. */

	...

Fin Si

Si PrixArticle<=10.5 Alors

/* Infériorité large entre deux réels. */

	...

Fin Si

Si PrixArticle<=10 Alors

/* Infériorité large entre un réel et un entier. */


	...

Fin Si

Si PrixArticle<10.5 Alors

/* Infériorité stricte entre deux réels. */

	...

Fin Si

Si PrixArticle<10 Alors

/* Infériorité stricte entre un réel et un entier. */


	...

Fin Si

PrixArticle=Reel("10.5");

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

Fin Principal

Traduction


-	-	-	-	-	-	-	-	-