UpsKrn.Entier

Définition


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

Type Entier Implemente Public : IAlgebreCommutative, IEspaceMetre Defaut Final TailleSegment 32 ConserverObjets

/* Objet : Encapsulation du type Entier. */

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

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

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

	

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

	

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

	

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

	

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

	

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


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

/* Heritage des methodes d'IEspaceMetre.              				*/

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

Public :


	
	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;

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

/* Methodes propres.                                           */

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

Public :


	
	Constructeur();
	

	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) (D : Nul Ou Date);
	

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

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

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

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

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

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

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

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

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

	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;
	

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

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

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

   Operateur Optimiser(Invariant, NulAbsorbant) ~() Retourner Nul Ou Entier;

Prive :

	
   Destructeur(MettreEnAnteMemoire : Booleen) Retourner Booleen;

Fin Type

Le type Entier modélise un nombre entier dans l'intervalle [-2147483647, 2147483648].

Le type Entier possède quatre constructeurs :

Un constructeur implicite qui initialise la valeur entière à 0.
Conversion d'une chaîne de caractères représentant un entier exprimé dans une base donné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 réel en un entier. Seule la partie entière inférieure est retenue.
Conversion d'un date en un entier représentant le numéro du jour dans le calendrier Julien.
Conversion d'un binaire en un 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 Entier possède les opérateurs standards suivants :

+ pour l'addition entre deux entiers. Le résultat est un entier.
+ pour l'addition entre un entier et un réel. Le résultat est un réel.
- pour le changement de signe d'un entier. Le résultat est un entier.
- pour la soustraction entre deux entiers. Le résultat est un entier.
- pour la soustraction entre un entier et un réel. Le résultat est un réel.
* pour la multiplication entre deux entiers. Le résultat est un entier.
* pour la multiplication entre un entier et un réel. Le résultat est un réel.
/ pour la division entre deux entiers. Le résultat est un réel.
/ pour la division entre un entier et un réel. Le résultat est un réel.
\ pour la division entre deux entiers. Le résultat est un entier.
\ pour la division entre un entier et un réel. Le résultat est un entier.
% pour le reste de la division d'un entier par un entier. Le résultat est un entier.
^ pour la puissance d'un entier par un entier. Le résultat est un entier.
^ pour la puissance d'un entier par un réel. Le résultat est un réel.
& pour le et bit à bit entre deux entiers. Le résultat est un entier.
| pour le ou bit à bit entre deux entiers. Le résultat est un entier.
~ pour le complément à deux d'un entier. Le résultat est un entier.
<< pour le décalage vers la gauche entre deux entiers. Le résultat est un entier. Chaque décalage équivaut à une multiplication par deux.
>> pour le décalage vers la droite entre deux entiers. Le résultat est un entier. Chaque décalage équivaut à une division par deux.
++ pour l'incrémentation préfixée ou postfixée.
-- pour la décrémentation préfixée ou postfixée.
== pour l'égalité entre deux entiers. Le résultat est un booléen.
== pour l'égalité entre un entier et un réel. Le résultat est un booléen.
!= pour l'inégalité entre deux entiers. Le résultat est un booléen.
!= pour l'inégalité entre un entier et un réel. Le résultat est un booléen.
<= et >= pour respectivement l'infériorité large et la supériorité large entre deux entiers. Le résultat est un booléen.
<= et >= pour respectivement l'infériorité large et la supériorité large entre un entier et un réel. Le résultat est un booléen.
< et > pour respectivement l'infériorité stricte et la supériorité stricte entre deux entiers. Le résultat est un booléen.
< et > pour respectivement l'infériorité stricte et la supériorité stricte entre un entier et un réel. Le résultat est un booléen.
= pour l'affectation d'un entier dans un autre.
+= pour l'addition d'un entier puis l'affectation du résultat.
-= pour soustraction d'un entier puis l'affectation du résultat.
*= pour la multiplication d'un entier puis l'affectation d'un entier du résultat.
\= pour la division entière par un entier puis l'affectation du résultat.
%= pour le reste de la division par un entier puis l'affectation du résultat.
&= pour le et bit à bit avec un entier puis l'affectation du résultat.
|= pour le ou bit à bit avec un entier puis l'affectation du résultat.
<<= pour le décalage à gauche par un entier puis l'affectation du résultat.
>>= pour le décalage à droite par un entier puis l'affectation du résultat.

Exemple

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

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


	PrixArticle : Entier;

	/* 'PrixArticle' est une variable de type entier. */




Debut

PrixArticle=PrixArticle+10;

/* Addition de deux entiers. */

PrixArticle=PrixArticle+10.5;

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

PrixArticle=PrixArticle-10;

/* Soustraction de deux entiers. */

PrixArticle=PrixArticle-10.5;

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

PrixArticle=PrixArticle*2;

/* Multiplication de deux entiers. */

PrixArticle=PrixArticle*1.5;

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

PrixArticle=PrixArticle/2;

/* Division de deux entiers. */

PrixArticle=PrixArticle/1.5;

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

PrixArticle=PrixArticle%2;

/* Modulo de deux entiers. */

PrixArticle=PrixArticle^2;

/* Puissance de deux entiers. */

PrixArticle=PrixArticle^1.5;

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

PrixArticle=PrixArticle&2;

/* Et bit à bit entre deux entiers. */

PrixArticle=PrixArticle|2;

/* Ou bit à bit entre deux entiers. */

PrixArticle=PrixArticle<<3;

/* Décalage à gauche d'un entier. Dans cet exemple, cela revient a multiplier par 8. */

PrixArticle=PrixArticle>>3;

/* Décalage à droite d'un entier. Dans cet exemple, cela revient a diviser par 8. */

Si PrixArticle==10 Alors

/* Egalité entre deux entiers. */

	...

Fin Si

Si PrixArticle==10.5 Alors

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

	...

Fin Si

Si PrixArticle!=10 Alors

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

	...

Fin Si

Si PrixArticle!=10.5 Alors

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

	...

Fin Si

Si PrixArticle<=10 Alors

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

	...

Fin Si

Si PrixArticle<=10.5 Alors

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

	...

Fin Si

Si PrixArticle<10 Alors

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

	...

Fin Si

Si PrixArticle<10.5 Alors

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

	...

Fin Si

PrixArticle=Entier("10");

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

PrixArticle=Entier(10.5);

/* Conversion d'un réel en un entier. Seule la partie entière inférieure est retenue. */

Fin Principal

Traduction


-	-	-	-	-	-	-	-	-