PROGRAM ERROR (INPUT,OUTPUT);
(*IT FINDS THE QUOTIENT OF TWO NUMBERS AND CALCULATES ITS ERROR*)
CONST
     SPACE=' ';
     DOT='.';
TYPE
     DIGITS=PACKED ARRAY[1..30] OF CHAR;
     DF=ARRAY[1..16] OF INTEGER;
VAR 
     DIGITA,DIGIT:DIGITS;
     DMIN,DMAX:DF;
     X,Y,C1,C2, EC,EA,EB,A,B,C,RA,RB,RC:REAL;
     Q,P,K,N1,N2,M,N:INTEGER;
     CH1,CH2,CH3:CHAR;



PROCEDURE ROUNDOFNUMBER(VAR DIG:DIGITS;VAR R,E:REAL;VAR NOFDP:INTEGER);
    VAR
       Q,P,I,J,K,L:INTEGER;
    X,Y,Z:REAL;
PROCEDURE ABSOLUTE;

 BEGIN

(*IT CALCULATES THE ABSOLUTE BOUND ERROR*)
  IF DIG[K+5]<>SPACE THEN
      NOFDP:=5
  ELSE
      BEGIN
      IF DIG[K+4]<>SPACE THEN
        NOFDP:=4
      ELSE
       BEGIN
        IF DIG[K+3]<>SPACE THEN
          NOFDP:=3
        ELSE
         BEGIN
           IF DIG[K+2]<>SPACE THEN

          NOFDP:=2
         ELSE
           BEGIN
             IF DIG[K+1]<>SPACE THEN
              NOFDP:=1
             ELSE
              NOFDP:=0;
           END;
       END;
    END;
  END;

END;


PROCEDURE NUMBER;

 VAR
   M,S:INTEGER;

 BEGIN
    X:=0;
    FOR M:=1 TO K-1 DO
     BEGIN
       IF (DIG[M]<>'+') AND (DIG[M]<>'-') THEN

         Y:=ORD(DIG[M])-ORD('0')
       ELSE
         Y:=0;
         X:=X+EXP((K-1-M)*LN(10));
     END;
    FOR S:=K+1 TO K+5 DO
     BEGIN
       IF DIG[S]<>SPACE THEN
         Z:=ORD(DIG[S])-ORD('0')
       ELSE
         Z:=0;
      X:=X+Z*EXP((K-S)*LN(10));
    END;
IF (DIG[1]='+') OR (DIG[1] IN ['0'..'9']) THEN
  R:=X;
IF DIG[1]='-' THEN
  R:=0-X;
IF (R>100) OR (R<-100) THEN
  BEGIN
    WRITELN('J ASKED YOU THE NUMBER TO BE BETWEEN -100 TO 100.');
    WRITELN('PLEASE TYPE ANOTHER NUMBER');
  END;

END (*NUMBER*);

 BEGIN
(*IT FINDS THE ABSOLUTE BOUND ERROR OF A NUNBER AFTER ROUNDING IT*) 

     I:=0;
     REPEAT

    I:=I+1;
    READ(DIG[I]);
    IF NOT(DIG[I]IN ['+','-',' ','.','0','1','2','3','4','5','6','7','8','9']) THEN
Q:=1000;
    IF Q=1000 THEN
      WRITELN('YOU MADE A MISTAKE,YOU PRESSED WRONG KEY.TYPE ANOTHER NUMBER');
    IF Q<>1000 THEN
      BEGIN
        WRITELN('THE NUMBER YOU TYPED IS:');
        WRITE(DIG[I]);
      END;
  UNTIL EOLN;
  WRITELN;
  K:=0;
REPEAT
  K:=K+1;
UNTIL (DIG[K]=DOT) OR (DIG[K]=SPACE);
IF DIG[K]=SPACE THEN
  BEGIN
    X:=0;
    FOR J:=1 TO K-1 DO
     BEGIN
      IF (DIG[J]<>'+') AND (DIG[J]<>'-') THEN
       Y:=ORD(DIG[J])-ORD('0')
      ELSE
       Y:=0;
       X:=X+Y*EXP((K-1-J)*LN(10));
     END;
   NOFDP:=0;
   E:=0.5;
  END;
IF DIG[K]=DOT THEN

 BEGIN
    FOR L:=K+6 TO K+2 DO
       BEGIN
       IF DIG[L] IN ['5','6','7','8','9'] THEN
        BEGIN
          L:=L-1;
          IF DIG[L]<>SPACE THEN
      BEGIN

        Q:=ORD(DIG[L])+1;
        DIG[L]:=CHR(Q);
      END;

          END;
        END;
   IF DIG[K+1] IN ['5','6','7','8','9'] THEN

   BEGIN
      P:=ORD(DIG[K-1])+1;
      DIG[K-1]:=CHR(P);
   END;

 ABSOLUTE;

    E:=5*EXP((-(NOFDP+1))*LN(10));

NUMBER;

    END;
END(*ROUNDOFNUMBER*);
PROCEDURE FINDSTHEDECDIGITSOFZ(Z:REAL;VAR D:DF;VAR I:INTEGER);
 VAR
    T,U:REAL;
      Y:INTEGER;
BEGIN
 (*IT FINDS THE NUMBER OF DECIMAL PLACES OF A NUMBER AND PUT THEM IN AN ARRAY*)
    T:=10*(Z-TRUNC(Z));
    I:=0;
   REPEAT
        Y:=TRUNC(T);
        U:=T-Y;
        I:=I+1;
        D[I]:=Y;
        T:=10*U;
   UNTIL U=0;
END(*FINDSTHEDECDIGITSOFZ*);

BEGIN (*PROGRAM BODY*);
WRITELN('PLEASE TYPE AN ORDINARY NUMBER "A",BETWEEN -100 AND 100');
WRITELN('IF THE NUMBER HAS MORE THAN 5 DECIMAL PLACES,THEN');
WRITELN('THECOMPUTER WILL ROUND IT');
WRITELN('YOU CAN SEE THIS PROCEDURE IF YOU TYPE A NUMBER WITH MORE');

WRITELN('THAN 5 DECIMAL PLACES');
REPEAT
   REPEAT

    ROUNDOFNUMBER(DIGIT,A,EA,N1);
  UNTIL (A<100) AND (A>-100) AND (Q<>1000);
  WRITELN('THE NUMBER BECOMES A=',A:12);
  WRITELN;
  WRITELN('YOU CAN SEE THE SAME PROCEDURE IF YOU TYPE A');
  WRITELN('TYPE ANY KEY EXCEPT A IF YOU WANT TO CONTINUE TO THE NEXT STEP');
  READLN(CH1);

  IF CH1='+' THEN
  WRITELN('TYPE A NUMBER');

UNTIL CH1<>'A';

WRITELN('PLEASE TYPE ANOTHER NUMBER "B",BETWEEN -100 AND 100');
WRITELN('WE WANT TO CALCULATE THE QUOTIENT C=A/B');
WRITELN('YOU WILL SEE THE SAME PROCEDURE AS WITH A IF YOU HAVE');
WRITELN('SUPPLIED A NUMBER WITH MORE THAN FIVE DECIMAL PLACES');
REPEAT
    REPEAT
      ROUNDOFNUMBER(DIGITA,B,EB,N2);
      IF B=0 THEN
       WRITELN('THE DIVISION OF A NUMBER BY ZERO IS IMPOSSIBLE');
      WRITELN('TYPE ANOTHER NUMBER');
    UNTIL (B<100) AND (B>-100) AND (B<>0) AND (Q<>1000);
  WRITELN('THE NUMBER BECOMES B=',B:12);
  WRITELN('YOU CAN SEE THIS PROCEDURE AS TIMES AS YOU WANT IF YOU');
  WRITELN('TYPE KEY.IF YOU DON"T WANT,TYPE ANY KEY EXCEPT B TO CONTINUE');
  READLN(CH2);
  IF CH2='B' THEN 
    WRITELN('TYPE ANOTHER NUMBER');
UNTIL CH2<>'B';
WRITELN('THE COMPUTER DISPLAYS,AS YOU CAN SEE BELOW,THE VALUES OF A AND B,');
WRITELN('THE NUMBER OF THEIR DECIMAL PLACES AND THEIR ABSOLUTE ERROR BOUND');
WRITELN('  VALUE OF A   NUMBER OF DEC. PLACES   ABSOLUTE ERROR BOUND    ');   
WRITELN(A:10,N1:15,EA:20);
WRITELN;

WRITELN('  VALUE OF B   NUMBER OF DEC. PLACES   ABSOLUTE ERROR BOUND    ');
WRITELN(B:10,N2:15,EB:20);

C:=A/B;
RA:=EA/A;
RB:=EB/B;
RC:=RA+RB;
EC:=ABS(RC*C);
WRITELN('THE QUOTIENTC=A/B,WHERE A=',A:12,'AND B=',B:12,'HAS A VALUE ');
WRITELN('CALCULATED BY THE COMPUTER TO BE');
WRITELN('C=',C:16);
WRITELN('BUT A AND B ARE ROUNDED NUMBERS,SO THIS ANSWER MAY BE MISLEADING');
WRITELN('THE CORRECT ANSWER LIES BETWEEN C-EC AND C+EC,WHERE EC IS THE ');
WRITELN('ABSOLUTE ERROR BOUND OF C');
WRITELN('SO THE CORRECT ANSWER LIES BETWEEN');
WRITELN(C-EC:16,'AND',C+EC:16);
WRITELN('NOW WRITE DOWN THE CORRECTLY ROUNDED NUMBER,WHICH REPRESENTS A//B');
WRITELN('TO CHECK YOUR ANSWER TYPE C');
READLN(CH3);
REPEAT
    IF CH3='C' THEN
      BEGIN
       FINDSTHEDECDIGITSOFZ(C-EC,DMIN,M);
       FINDSTHEDECDIGITSOFZ(C+EC,DMAX,M);

     IF TRUNC(C-EC)<>TRUNC(C+EC) THEN
         C2:=TRUNC(C-EC)
     ELSE
       BEGIN
          FOR N:=M TO 1 DO
           BEGIN
             X:=0;
             Y:=0;
              FOR K:=1 TO N DO
               BEGIN
                X:=X+EXP((N-K)*LN(10))*DMIN[K];
                Y:=Y+EXP((N-K)*LN(10))*DMAX[K];

             END;
           IF X=Y THEN
             BEGIN
               C1:=X;
               P:=N;

             END

          ELSE
           BEGIN
              IF DMIN[N]>=5 THEN
                 DMIN[N-1]:=DMIN[N-1]+1;
              IF DMAX[N]>=5 THEN
                 DMAX[N-1]:=DMAX[N-1]+1;
           END;
        END;
       IF TRUNC(C-EC)>=0 THEN
         C2:=TRUNC(C-EC)+C1*EXP((-P)*LN(10))
       ELSE
         C2:=TRUNC(C-EC)-C1*EXP((-P)*LN(10));
       WRITELN('THE CORRECTLY ROUNDED NUMBER IS');
       WRITELN(C2:16);
    END;

  END
     ELSE
        WRITELN('YOU TYPED WRONG KEY,TRY AGAIN');
  UNTIL CH3='C';
END.