Opérateurs et expressions logiques en OPL

Plan

 Opérateurs

 Priorités

 Expressions logiques

 Opérateurs logiques et booléains

Opérateurs

 Opérateurs arithmétiques

> En OPL on dispose des opérateurs arithmétiques suivants :

Opérateur Fonction
+ additionner
- soustraire
* multiplier
/ diviser
** élever à la puissance
- négativer (par exemple, -10)
% pourcentage
MOD modulo - reste de la division de deux nombres

 Opérateurs de comparaison

> En OPL on dispose des opérateurs de comparaison suivants :

Opérateur Fonction
> supérieur à
>= supérieur ou égal à
> inférieur à
<= inférieur ou égal à
= égal à
<> différent de

 Opérateurs logiques et booléains

> En OPL on dispose des opérateurs logiques et booléains suivants  :

Opérateur Fonction
AND ET     logique                       
OR OU     logique
NOT NON  logique
XOR OU     exclusif

 Opérateur %

> L'opérateur de pourcentage peut être utilisé dans des expressions telles que :

Expression Sign si ication Résultat
60+5% 60 plus 5% de 60 63
60-5% 60 moins 5% de 60 57
60*5% 5% de 60 3
60/5% 5% de quel nombre vaut 60 ?    1200

> On peut également l'utiliser de cette façon :

Expression Sign si ication Résultat
105>5% quel nombre vaut 105 quand on l'augmente de 5% ? 100
105<5% quelle est la valeur de l'augmentation de 5% qui donne 105 ? 5

Exemples :

  • Pour additionner 15% de taxes à 345 :
    345+15%                   Résultat = 396.75
  • Pour trouver la valeur du prix hors taxes :
    396.75>15%            Résultat = 345
  • Pour trouver le montant des taxes incluses dans le prix de vente :
    396.75<15%            Résultat = 51.75

Retour au Plan >

Priorités

 Ordre des priorités

Priorité Opérateur
Haute **
  - (négativation)
  NOT
  * /
  + - (soustraction)
  = > < <> >= <=
Basse AND OR

Exemple :

  • L'opération 7+3*4 retourne la valeur 19 (3 est multiplié par 4, puis 7 est additionné au résultat) et non 40 (4 fois 10).

 En cas de priorités équivalentes

> Si dans une expression tous les opératuers ont le même degré de priorité, ils sont évalués de gauche à droite (à l'exception des puissances).

Exemple :

  • Dans l'expression a+b-c, a est additionné à b puis c est soustrait du résultat.

> Les puissances sont pour leur part évaluées de droite ŕ gauche.

Exemple :

  • Dans l'expression a%**b%**c%, b% sera d'abord élevé à la puissance c% puis a% sera élevé à la puissance du résultat.

 Changer les priorités grâces aux parenthčses

> Le résultat d'une expression telle que a+b+c est identique quelque soit l'ordre d'addition de a avec b, ou de b avec c. Mais comment l'expression a+b*c/d est -elle évaluée ? Il vous est loisible de mettre des parenthèses :

  • soit pour rendre plus rendre plus évident l'ordre du calcul :
  • soit pour changer l'ordre du calcul.

> Par défaut, l'expression a+b*c/d est évaluée dans l'ordre suivant : b est multiplié par c, puis divisé par d, puis le résultat est additionné à a. Afin de réaliser l'addition et la division avant la multiplication, utilisez des parenthčses : (a+b)*(c/d). En cas de doute sur l'ordre d'effection des opérations, utilisez des parenthčses.

 Priorité entre valeurs entières et virgule-flottante

> Vous êtes libres de mélanger des valeurs entières et des nombres en virgule-flottante, mais il vous faut prendre en compte la façon dont OPL gère ce mélange :

  • À chaque étape de calcul, OPL se sert de l'arithmétique le plus simple. Pour deux nombres entiers il va utiliser l'arithmétique des entiers et cela peut donner des résultats surprenants : ainsi, la division 7/2 donne comme résultat le nombre entier 3.
  • Dans les autres cas, c'est l'arithmétique des nombres en virgule-flottante qui est utilisée : avec 7.0 qui est un nombre en virgule-flottante, la division 7.0/2 va donner pour résultat 3.5.
  • Enfin, le résultat de la partie droite d'une expression est automatiquement converti au type de la variable à laquelle il est assigné.

Exemple :

  • Il se peut que votre procédure inclut une expression telle que a%=b%+c. Elle est traitée de la manière suivante :
    • b% est converti en virgule-flottante et additionné à c.
    • le résultat - qui est rappelons le en virgule-flottante - est alors automatiquement converti en nombre entier pour être assigné à la variable a%.

> De telles conversions peuvent générer des résultats étranges.

Exemple :

  • L'expression a%=3.0*(7/2) donne pour résultat a%=9, alors que a%=3.0*(7.0/2) rend a%=10.

> L' OPL ne fait pas de rapport d'erreur pour ce genre de problème et c'est à vous de prendre en compte ce fait pour que cela ne survienne pas sauf si vous le souhaitez.

 Conversions de types et arrondi

> Il existe en OPL trois types pour représenter les nombres : les nombres en virgule-flottante, les entiers et les entiers longs. Vous avez la possibilité de convertir chacun de ces types en l'un quelconques des autres. La valeur de l'expression de droite sera automatiquement convertie au type de la variable de gauche.

  • Si vous assignez une valeur entière à une variable en virgule-flottante cela ne pose aucun problème.
  • Si vous assignez une valeur en virgule flottante à une variable de type entier, la valeur est convertie à un entier, toujours arrondie à zéro.

Exemple :

  • Si vous déclarez LOCAL c% , puis vous écrivez c%=3.75, la valeur 3.75 est automatiquement convertie à la valeur 3.

> L'arrondi à zéro peut parfois donner des résultats surprenants.

Exemple :

  • L'expression a%=2.9 va conférer à a% la valeur 2, et l'expression a%=-2.3 conférera à a% la valeur -2.
  • Lors de l'exécussion d'un module, vous pouvez avoir des erreurs si la partie gauche d'une assignation a un rang inférieur à la partie droite (si vous avez par exemple, x%=a& avec a& d'une valeur de 320000).
  • Pour contrôler la manière dont est arrondie un nombre en virgule-flottante, utilisez la fonction INT.

Retour au Plan >

Expressions logiques

> Les opérateurs de comparaison et les opérateurs logiques reposent sur l'idée qu'on peut évaluer certaines situations soit comme étant « Vraies » ou comme étant « Fausses »

Exemple :

  • Si les variables a%=6 et b%=8, le résultat de la compraison a%>b% sera Faux.

> Ces opérateurs utiles pour paramétrer les embranchements alternatifs de vos procédures.

Exemple :

    IF salaire<depenses
          FairePasBon:
    ELSE
          FaireBon:
    ENDIF

> Vous pouvez également tirer parti du fait que le résultat de ces expressions logiques est représenté par un nombre entier :

  • Vrai’ est représenté par l'entier -1 ;
  • Faux’ est représenté par l'entier 0 (zéro).
Opérateur Exemple Résultat retourné Valeur retournée
< a<b Vrai si a inférieur à b -1
    Faux si a supérieur ou égal à b 0
> a>b Vrai si a supérieur à b -1
    Faux si a inférieur ou égal à b 0
<= a<=b Vrai si a inférieur ou égal à b -1
    Faux si a supérieur à b 0
= a>=b Vrai si a supérieur ou égal à b -1
    Faux si a inférieur à b 0
<> a<>b Vrai si a différent de b -1
    Faux si a égal à b 0
= a=b Vrai si a égal à b -1
    Faux si a différent de b 0

Ces valeurs entières peuvent être assignées à une variable, affichées à l'écran pour vous signaler si une condition particulière est vraie ou fausse, ou utilisées dans des instructions IF.

Exemple :

  • Il peut arriver que dans une procédure vous ayez deux sou-totaux, a et b. Vous souhaitez connaître le plus grand des deux. En utilisant l'instruction PRINT a>b vous pourrez conclure :
    • Si c'est zéro qui s'affiche, a est inférieur ou égal à b are equal ou b est le plus grand ;
    • Si c'est -1 qui s'affiche, a>b est vrai et a est le plus grand des deux nombres.

Retour au Plan >

Opérateurs logiques et booléains

> Les opérateurs AND, OR et NOT ont des effets qui diffèrent selon qu'ils sont utilisés avec des nombres en virgule-flottante ou des entiers.

 Employés avec des nombres en virgule-flottante

Les commande AND, OR et NOT sont des opérateurs logiques. Ils agissent de la manière suivante :

Exemple Résultat Valeur
retournée
a AND b Vrai si a et b sont différents de zéro -1
  Faux si a ou b égale zéro 0
a OR b Vrai si a ou b est différent de zéro -1
  Faux si a et b égalent zéro 0
NOT a Vrai si a égale zéro -1
  Faux si a est différent de zéro 0

 Employés avec des nombres entiers ou entiers longs

Les commandes AND, OR et NOT sont des opérateurs booléains. En interne, OPL traite les nombres entiers de façons binaire avec un code sur 16 bits pour les nombres Entiers, et 32 bits pour les Entiers longs. Ces commandes opèrent sur chaque bit du code (bitwise operator en anglais). Un bit est activé (set) s'il vaut 1, ou inactivé (clear) s'il vaut 0. Les nombres entiers longs se comportent de la même mainères que les entiers avec AND, OR et NOT.

 AND

Cette commande laisse le bit actif si les deux entrées sont actives, sinon elle l'inactive.

Exemple :

  • L'instruction PRINT 12 AND 10 affiche le nombre 8.
    Afin de comprendre le mécanisme, nous allons écrire les nombres 12 et 10 en notation binaire :
    • 12      0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
    • 10      0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0
    La commande AND agits sur chaque pair de bits. Si on procède de droite à gauche en écartant les 12 premiers bits (dans la mesure où 0 AND 0 donne 0 comme résultat) :
    • 1 AND 1          1
    • 1 AND 0          0
    • 0 AND 1          0
    • 0 AND 0          0
    Le résultat correspond au nombre binaire 1000, soit 8 en notation décimale.

 OR

Cette commande active le bit du résultat si l'un au moins des bits d'entrée est activé, sinon elle l'inactive.

Exemple :

  • Que va afficher l'instruction PRINT 12 OR 10 ?
    Écrivons ces nombres en notation binaire et appliquons la règle à chaque chiffre afin de trouver le résultat.
    • 1 OR 1          1
    • 1 OR 0          1
    • 0 OR 1          1
    • 0 OR 0          0
    Ce résultat correspond au nombre binaire 1110, soit 14 en notation décimale.

 NOT

Cette commande active le bit si l'entrée est inactivée, et inversement.

La commande NOT ne s'applique qu'à un seul nombre. Elle retourne son complément, en remplaçant les 0 par des 1 et les 1 par des 0.

Exemple :

  • Si on considère le nombre 7 dont la représentation binaire est 0000000000000111, l'instruction NOT 7 donne pour résultat 1111111111111000 qui correspond au chiffre décimal -8.

Pour calculer rapidement le résultat de la commande NOT sur un entier, il suffit de lui ajouter 1 et de le négativer

Exemples : NOT 23 égale -24, NOT 0 égale -1 et NOT -1 égale 0.

Retour au Plan >