CodeS-SourceS
Rechercher un code, un tuto, une réponse

[bases] booléens, table de verités, syntaxe delphi

Novembre 2017

Sommaire

    Valeurs des booléens
    Tables de vérité des operateurs booléen
    Operateurs relationnel et d'ensemble
    Exemple d'opérations complexe et tables de vérité
    Exemple d'écriture de code grâce aux operateurs booléen
    Ecriture des booléens dans les conditions


 



Valeurs des booléens


Les booléens on par défaut des valeurs binaire pour définir leurs états (0 ou 1).
Dans de nombreux langages, ces valeurs sont remplacées par des mots  plus "parlant", c'est à dire faux (0) ou vrai (1) (false,true).


Un booléen ne peu avoir que deux états unique donc, vrai ou faux. Ils sont comparables a une lampe qui serait soit allumée, soit éteinte mais ne peut être dans les deux états a la fois. Il faut comprendre par la  que le booléen ne peut pas être "presque" vrai ou "presque" faux, il est soit l'un, soit l'autre...


Tables de vérité des operateurs booléens


NOT (non)


       R = 1 (true) si l'expression est fausse.


       Syntaxe Delphi : NOT A


       A      R
       0      1
       1      0
 


AND (et)                   


       R = 1 (true) si toutes les expressions sont vraies.


       syntax Delphi : (A AND B)


       A      B      R
       0      0      0
       1      0      0
       0      1      0
       1      1      1
 


NOT AND (non-et)


       R = 1 (true) si l'une ou toutes les expressions sont fausse.


       syntax Delphi : NOT (A AND B)


       A      B      R
       0      0      1
       1      0      1
       0      1      1
       1      1      0


OR (ou)


       R = 1 (true) si l'une ou toutes les expressions sont vraie.


       syntax Delphi : (A OR B)


       A      B      R
       0      0      0
       1      0      1
       0      1      1
       1      1      1
 


NOT OR (non-ou)


       R = 1 (true) si toutes les expressions sont fausses.


       syntax Delphi : NOT (A OR B)


       A      B      R
       0      0      1
       1      0      0
       0      1      0
       1      1      0


XOR (ou exclusif)


       R = 1 (true) exclusivement si une seule expression est vraie


       syntax Delphi : (A XOR B)


       A      B      R
       0      0      0
       1      0      1
       0      1      1
       1      1      0


NOT XOR (non-ou exclusif)


       R = 1 (true) exclusivement si une toutes les expressions sont vraie ou fausse


       syntax Delphi : NOT (A XOR B)


       A      B      R
       0      0      1
       1      0      0
       0      1      0
       1      1      1


Operateurs relationnel et d'ensemble


    >      supérieur a
    <      inferieur a
    >=     supérieur ou égale a   //   est un sous-ensemble de
    <=     inferieur ou égale a   //   est un sous-ensemble de
    <>     différent de              
    =      égale a                  
    IN     est dans l'ensemble


Exemple d'opérations complexe et tables de vérité


R := (A AND B) OR (C AND D);


       R = 1 (true) si l'expression AB ou l'expression CD est vraie.


       A      B      C      D      R
       0      0      0      0      0
       0      0      0      1      0
       0      0      1      0      0
       0      0      1      1      1 (par CD)
       0      1      0      0      0
       0      1      0      1      0
       0      1      1      0      0
       0      1      1      1      1 (par CD)
       1      0      0      0      0
       1      0      0      1      0
       1      0      1      0      0
       1      0      1      1      1 (par CD)
       1      1      0      0      1 (par AB)
       1      1      0      1      1 (par AB)
       1      1      1      0      1 (par AB)
       1      1      1      1      1 (par AB ou CD)
                          


R := (A AND B) OR (NOT(C AND D));


       R = 1 (true) si l'expression AB est vrai ou si l'expression CD est fausse


       A      B      C      D      R
       0      0      0      0      1 (par CD)
       0      0      0      1      1 (par CD)
       0      0      1      0      1 (par CD)
       0      0      1      1      0
       0      1      0      0      1 (par CD)
       0      1      0      1      1 (par CD)
       0      1      1      0      1 (par CD)
       0      1      1      1      0
       1      0      0      0      1 (par CD)
       1      0      0      1      1 (par CD)
       1      0      1      0      1 (par CD)
       1      0      1      1      0
       1      1      0      0      1 (par AB ou CD)
       1      1      0      1      1 (par AB ou CD)
       1      1      1      0      1 (par AB ou CD)
       1      1      1      1      1 (par AB)                          


Exemple d'écriture de code grâce aux operateurs booléen


Cette fonction renvois true si V est supérieur ou égale à VMin ET inferieur ou égale à VMax


       function InRange(const V, VMin, VMax :integer) : boolean;
       begin
        result := (V >= VMin) and (V <= VMax);
       end;
 
cette fonction renvois true si V est inferieur a VMin OU superieur a VMax


       function OutRange(const V, VMin, VMax : integer) : boolean;
       begin
         result := (V < VMin) or (V > VMax);
       end;


 
Grace  a cela on peut également remplacer beaucoup de condition IF, Case Of, et de gagner beaucoup de temps, exemple :

Exemple 1 :


       if X = 2 then R := true else R := false;


       on remplacera par :


       R :X 2;


Exemple 2 :


       Case X of
          0,1,4,5 : R := false;
          2,3,6   : R := true;
       End;


       on remplacera par :


       R :(X 2) OR (X = 3) OR (X = 6);


       our encore (pour les trés longues méthodes case ou if), on peu utiliser les ensembles :


       R := X IN [2,3,6 * ;


Attention toute fois, les ensemble [a,b,c,d * ne supportent que les types scalaires.


Ecriture des booléens dans les conditions


Beaucoup font l'erreur d'ecrire leur conditions If, While, Repeat de cette manière :


  if booleen = true then
  while booleen = true then
  repeat ... until booleen = true;


voici donc la bonne méthode :

  if booleen then ... (la condition s'execute seulement si le booléen est égale à true)
  if not booleen then ... (la condition s'execute seulement si le booléen est égale à false)


exemple d'application de cette façon d'écrire :


  if checkbox1.checked then label1.caption := 'l''option est cochée';
  if not checkbox1.checked then label1.caption := 'l''option n'est pas cochée';
  if (checkbox1.checked) and (checkbox2.checked) then label1.caption := 'l''option 1 et 2 sont cochées';


on peu également faire :


const


BTC : array[boolean * of string = ('L’’option est cochée’,’L’’option n’’est pas cochée’) ;


Begin


label1.caption := BTC[checkbox1.checked * ;


end;

Adresse d'origine
Publié par f0xi.
Ce document intitulé «  [bases] booléens, table de verités, syntaxe delphi  » issu de CodeS-SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Formatez vos chaines de caractères grâce à la fonction format
[delphi] conventions d'écriture des identifiants de variables et methodes