home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / sonderh1 / intlogik.pas < prev    next >
Pascal/Delphi Source File  |  1987-05-18  |  6KB  |  141 lines
  1. (**************************************************************************)
  2. (*                          INTLOGIK.PAS                                  *)
  3. (* Das INCLUDE-Modul "INT.Logik" implementiert unter Ausnutzung des CASE- *)
  4. (* Tricks die logischen Funktionen AND,OR,XOR,EQV,IMP auch fuer INTEGER-  *)
  5. (* Operanden, wobei das Ergebnis natuerlich wieder vom typ INTEGER ist !  *)
  6. (*                                                                        *)
  7. (* Das Modul stellt folgende Funktionen zur Verfuegung :                  *)
  8. (*                                                                        *)
  9. (*  FUNCTION XOR  (b1, b2: BOOLEAN): BOOLEAN                              *)
  10. (*  FUNCTION EQV  (b1, b2: BOOLEAN): BOOLEAN                              *)
  11. (*  FUNCTION IMP  (b1, b2: BOOLEAN): BOOLEAN                              *)
  12. (*                                                                        *)
  13. (*  FUNCTION int_AND  (i1, i2: INTEGER): INTEGER                          *)
  14. (*  FUNCTION int_OR   (i1, i2: INTEGER): INTEGER                          *)
  15. (*  FUNCTION int_XOR  (i1, i2: INTEGER): INTEGER                          *)
  16. (*  FUNCTION int_EQV  (i1, i2: INTEGER): INTEGER                          *)
  17. (*  FUNCTION int_IMP  (i1, i2: INTEGER): INTEGER                          *)
  18. (*  FUNCTION int_NOT  (i     : INTEGER): INTEGER                          *)
  19. (*                                                                        *)
  20. (**************************************************************************)
  21.  
  22. (*------------------------ globale Typenvereinbarung ---------------------*)
  23.  
  24. TYPE  int_typ = RECORD
  25.                   CASE INTEGER OF              (* ein sog. freier Verbund *)
  26.                     1 : (int_zahl: INTEGER);
  27.                     2 : (int_feld: PACKED ARRAY [0..15] OF BOOLEAN)
  28.                  END;
  29.  
  30.  (*************************************************************************)
  31.  (*  Ab hier die Formulierung der im Pascal-Wortschatz nicht vorhandenen  *)
  32.  (*  logischen Funktionen XOR, EQV und IMP                                *)
  33.  (*                                                                       *)
  34.  (*  Wahrheitstafeln     XOR : 0 1      EQV : 0 1        IMP : 0 1        *)
  35.  (*                       --------        -------          -------        *)
  36.  (*                        0 : 0 1        0 : 1 0          0 : 1 1        *)
  37.  (*                        1 : 1 0        1 : 0 1          1 : 0 1        *)
  38.  (*                                                                       *)
  39.  (*************************************************************************)
  40.  
  41.  
  42. FUNCTION EQV (b1, b2: BOOLEAN): BOOLEAN;          (* logische Aequivalenz *)
  43.  
  44. BEGIN  EQV := (b1 = b2)  END;
  45.  
  46.  
  47. FUNCTION IMP (b1, b2: BOOLEAN): BOOLEAN;          (* logische Implikation *)
  48.  
  49. BEGIN  IMP := (NOT (b1 AND (NOT b2)))  END;
  50.  
  51.  
  52. FUNCTION XOR (b1, b2: BOOLEAN): BOOLEAN;     (* logisches exklusives ODER *)
  53.  
  54. BEGIN  XOR := (NOT EQV(b1,b2))  END;
  55.  
  56.  
  57. (**************************************************************************)
  58. (* Ab hier nun die Formulierung der einzelnen Routinen zur Anwendung      *)
  59. (* aller logischer Funktionen auch auf INTEGER-Zahlen.                    *)
  60. (**************************************************************************)
  61.  
  62. FUNCTION int_AND (i1, i2: INTEGER): INTEGER;         (* INT.logisches AND *)
  63.  
  64. VAR op1, op2, erg: int_typ;              (* zur Anwendung des CASE-Tricks *)
  65.      j           : INTEGER;
  66.  
  67. BEGIN
  68.   op1.int_zahl := i1;             (* Operanden als INTEGER-Zahl behandeln *)
  69.   op2.int_zahl := i2;
  70.   FOR j := 0 TO 15 DO                                   (* bitweise Logik *)
  71.     erg.int_feld[j] := (op1.int_feld[j] AND op2.int_feld[j]);
  72.   int_AND := erg.int_zahl
  73. END;
  74.  
  75.  
  76. FUNCTION int_OR (i1, i2: INTEGER): INTEGER;           (* INT.logisches OR *)
  77.  
  78. VAR op1, op2, erg: int_typ;              (* zur Anwendung des CASE-Tricks *)
  79.      j           : INTEGER;
  80.  
  81. BEGIN
  82.   op1.int_zahl := i1;  op2.int_zahl := i2;
  83.   FOR j := 0 TO 15 DO                                   (* bitweise Logik *)
  84.     erg.int_feld[j] := (op1.int_feld[j] OR op2.int_feld[j]);
  85.   int_OR := erg.int_zahl
  86. END;
  87.  
  88.  
  89. FUNCTION int_XOR (i1, i2: INTEGER): INTEGER;         (* INT.logisches XOR *)
  90.  
  91. VAR  op1, op2, erg: int_typ;             (* zur Anwendung des CASE-Tricks *)
  92.        j          : INTEGER;
  93.  
  94. BEGIN
  95.   op1.int_zahl := i1;  op2.int_zahl := i2;
  96.   FOR j := 0 TO 15 DO                                   (* bitweise Logik *)
  97.     erg.int_feld[j] := XOR(op1.int_feld[j], op2.int_feld[j]);
  98.   int_XOR := erg.int_zahl
  99. END;
  100.  
  101.  
  102. FUNCTION int_EQV (i1, i2: INTEGER): INTEGER;         (* INT.logisches EQV *)
  103.  
  104. VAR op1, op2, erg: int_typ;              (* zur Anwendung des CASE-Tricks *)
  105.      j           : INTEGER;
  106.  
  107. BEGIN
  108.   op1.int_zahl := i1;  op2.int_zahl := i2;
  109.   FOR j := 0 TO 15 DO                                   (* bitweise Logik *)
  110.     erg.int_feld[j] := EQV(op1.int_feld[j], op2.int_feld[j]);
  111.  int_EQV:=erg.int_zahl
  112. END;
  113.  
  114.  
  115. FUNCTION int_IMP (i1, i2: INTEGER): INTEGER;         (* INT.logisches IMP *)
  116.  
  117. VAR op1, op2, erg: int_typ;              (* zur Anwendung des CASE-Tricks *)
  118.      j           : INTEGER;
  119.  
  120. BEGIN
  121.   op1.int_zahl := i1;  op2.int_zahl:=i2;
  122.   FOR j := 0 TO 15 DO                                   (* bitweise Logik *)
  123.     erg.int_feld[j] := IMP(op1.int_feld[j], op2.int_feld[j]);
  124.   int_IMP := erg.int_zahl
  125. END;
  126.  
  127.  
  128. FUNCTION int_NOT (i: INTEGER): INTEGER;     (* INT.logisches NOT = Kompl. *)
  129.  
  130. VAR op, erg: int_typ;                    (* zur Anwendung des CASE-Tricks *)
  131.     j      : INTEGER;
  132.  
  133. BEGIN
  134.   op.int_zahl := i;
  135.   FOR j := 0 TO 15 DO erg.int_feld[j] := (NOT op.int_feld[j]);
  136.   int_NOT := erg.int_zahl
  137. END;
  138.  
  139. (*------------------------------------------------------------------------*)
  140. (*                         Ende von INTLOGIK.PAS                          *)
  141.