Unità Logici

Analisi

  • Elementi: VERO, FALSO
  • Struttura: semplice
  • Dominio: VERO, FALSO
  • Operazioni: Leggi(), Scrivi(), MyAnd(), MyOr(), MyNot(), MyXor()

Specifica delle operazioni

LEGGI()
  • Interfaccia: Procedure LEGGI(A: LOGICO);
  • Effetti: inserimento del valore logico VERO(1) o FALSO (0) in A
  • Prerequisiti: input controllato di una stringa di tipo ‘Vero’/’Falso’
  • Esempio: Leggi(A);
SCRIVI()
  • Interfaccia: Procedure SCRIVI(A: LOGICO);
  • Effetti: stampa il valore logico associato alla variabile A
  • Prerequisiti: – – –
  • Esempio: Scrivi(A);
MYAND()
  • Interfaccia: Function MYAND(A, B: LOGICO): LOGICO;
  • Effetti: Simula la funzione AND
  • Prerequisiti: – – –
  • Esempio: C:=MYAND(A,B);
MYOR()
  • Interfaccia: Function MYOR(A, B: LOGICO): LOGICO;
  • Effetti: Simula la funzione OR
  • Prerequisiti: – – –
  • Esempio: C:=MYOR(A,B);
MYNOT()
  • Interfaccia: Function MYNOT(A: LOGICO): LOGICO;
  • Effetti: Simula la funzione NOT
  • Prerequisiti: – – –
  • Esempio: A:=MYNOT(A);
MYXOR()
  • Interfaccia: Function MYXOR(A, B: LOGICO): LOGICO;
  • Effetti: Simula la funzione XOR
  • Prerequisiti: – – –
  • Esempio: C:=MYXOR(A,B);

Unità

Unit LOGICI;

Interface

Const VERO   = 1;
      FALSO  = 0;
Type  LOGICO = byte;

Procedure LEGGI (Var A: LOGICO);
Procedure SCRIVI( A: LOGICO);
Function  MYAND (A,B: LOGICO): LOGICO;
Function  MYOR  (A,B: LOGICO): LOGICO;
Function  MYNOT (A  : LOGICO): LOGICO;
Function  MYXOR (A,B: LOGICO): LOGICO;

Implementation

Const StrVERO  = 'VERO';
      StrFALSO = 'FALSO';

Procedure LEGGI(Var A: LOGICO);
Var
   S: String;
   I: Integer;
Begin
   Repeat
      write('Inserisci VERO o FALSO ---> ');
      readln(S);
      For I:=1 To Length(S) do
         S[I]:=upcase(S[I]);
   Until(S = StrVERO) or (S = StrFALSO);
   If(S = StrVERO) Then
      A:=VERO
   Else
      A:=FALSO;
End;

Procedure SCRIVI(A: LOGICO);
Begin
   If(A = VERO) Then
      write(StrVERO)
   Else
      write(StrFALSO);
End;

Function MYAND(A, B: LOGICO): LOGICO;
Begin
   If(A = VERO) and (B = VERO) Then
      MYAND:=VERO
   Else
      MYAND:=FALSO;
End;

Function MYOR(A, B: LOGICO): LOGICO;
Begin
   If(A = FALSO) and (B = FALSO) then
      MYOR:=FALSO
   Else
      MYOR:=VERO;
End;

Function MYNOT(A: LOGICO): LOGICO;
Begin
   If(A = FALSO) Then
      MYNOT:=VERO
   Else
      MYNOT:=FALSO;
End;

Function MYXOR(A, B: LOGICO): LOGICO;
Begin
   If(A = B) Then
      MYXOR:=FALSO
   Else
      MYXOR:=VERO;
End;

Begin
    Writeln("Unit Logici.");
End.

Test

Program TESTLOGICI;

Uses Crt,
     LOGICI;

Function MYNAND(A, B: LOGICO): LOGICO;
Begin
   MYNAND:=MYNOT(MYAND(A, B));
End;

Function MYNOR(A, B: LOGICO): LOGICO;
Begin
   MYNOR:=MYNOT(MYOR(A, B));
End;

Var A, B, C, R: LOGICO;
    SCELTA:     Byte;
Begin
   A:=VERO;
   B:=VERO;
   C:=VERO;
   R:=FALSO;
   Repeat
      ClrScr;
      Write('A = '); SCRIVI(A); Writeln;
      Write('B = '); SCRIVI(B); Writeln;
      Write('C = '); SCRIVI(C); Writeln;
      Write('R = '); SCRIVI(R); Writeln;

      Writeln('       0. USCITA');
      Writeln('11.12.13. Inserimento');
      Writeln('21.22.23. MyAnd');
      Writeln('31.32.33. MyOr');
      Writeln('41.42.43. MyXor');
      Writeln('51.52.53. MyNot');
      Writeln('61.62.63. MyNand');
      Writeln('71.72.73. MyNor');
      Writeln;
      Write  ('SCEGLI: ');
      Readln(SCELTA);
      Case SCELTA Of
          11: LEGGI(A);       12: LEGGI(B);       13: LEGGI(C);
          21: R:=MYAND(A,B);  22: R:=MYAND(B,C);  23: R:=MYAND(A,C);
          31: R:=MYOR(A,B);   32: R:=MYOR(B,C);   33: R:=MYOR(B,C);
          41: R:=MYXOR(B,C);  42: R:=MYXOR(B,C);  43: R:=MYXOR(B,C);
          51: R:=MYNOT(A);    52: R:=MYNOT(B);    53: R:=MYNOT(C);
          61: R:=MYNAND(A,B); 62: R:=MYNAND(B,C); 63: R:=MYNAND(A,C);
          71: R:=MYNOR(A,B);  72: R:=MYNOR(B,C);  73: R:=MYNOR(A,C);
      End;
   Until(SCELTA = 0);
End.