sw/src/pascal/PIXAKT.PS

   1 PROGRAM PIIIIIIIIIIII(INPUT,OUTPUT);
   2
   3
   4 (*)
   5 (   BERECHNUNG DER ZAHL  PI  AUF BIS ZU 1000 KOMMASTELLEN GENAU
   6 (   AUS
   7 (
   8 (           PI = 20 * ARCTAN(1/7)  +  8 * ARCTAN(3/79)
   9 (
  10 (
  11 (   UEBER DIE REIHENENTWICKLUNG
  12 (
  13 (
  14 (                 T             2     T^2       2   4     T^2
  15 (   ARCTAN(T) = ----- * ( 1  +  - * (-----)  +  - * - * (-----)^2  +
  16 (               1+T^2           3    1+T^2      3   5    1+T^2
  17 (
  18 (
  19 (                2   4   6     T^2
  20 (             +  - * - * - * (-----)^3  +  .......  )
  21 (                3   5   7    1+T^2
  22 (
  23 (*)
  24
  25
  26   CONST BASE (* OF ARITHMETIC *) = 100000  (* DON'T CHANGE *);
  27
  28
  29   TYPE  LONGNUMBER = ARRAY[0..205] OF INTEGER;
  30
  31
  32   VAR   NUMBEROFDIGITS, N, I, AFIRST, BFIRST, LAST,
  33         CARRY, DIGIT, POWER, AMUL, BMUL, ADIV, BDIV: INTEGER;
  34
  35         A, B, PI: LONGNUMBER;
  36
  37
  38 BEGIN
  39     READ(NUMBEROFDIGITS);
  40     AFIRST := 0;  BFIRST := 1;  LAST := NUMBEROFDIGITS DIV 5 + 4;
  41
  42     (*)
  43     (   AUFSTELLEN DER ANFANGSGLIEDER BEIDER REIHEN
  44     (   UND DES ANFANGSWERTES DER SUMME:
  45     (*)
  46
  47     N := 0;
  48      A[0] := 2;  A[1] := 80000 (* OF 2.80000 *);
  49      B[0] := 0;  B[1] := 30336 (* OF 0.30336 *);
  50     PI[0] := 3; PI[1] := 10336 (* OF 3.10336 *);
  51     FOR I := 2 TO LAST DO
  52         BEGIN A[I] := 0;  B[I] := 0;  PI[I] := 0 END;
  53     A[LAST+1] := BASE  (* GUARD *);
  54     B[LAST+1] := BASE  (* GUARD *);
  55
  56
  57     REPEAT N := N + 1;
  58
  59         (*)
  60         (   BERECHNUNG DES N-TEN GLIEDES DER ERSTEN REIHE:
  61         (
  62         (           A <=== A * AMUL / ADIV
  63         (
  64         (*)
  65
  66         AMUL := N;
  67         I := LAST+1;  CARRY := 0;
  68         WHILE (AFIRST<I) OR (CARRY<>0) DO
  69           BEGIN
  70             I := I - 1;
  71             DIGIT := AMUL*A[I] + CARRY;
  72             A[I]  := DIGIT MOD BASE;
  73             CARRY := DIGIT DIV BASE
  74           END;
  75         AFIRST := I;
  76
  77         ADIV := (N+N + 1)*25;
  78         CARRY := 0;
  79         FOR I := AFIRST TO LAST DO
  80           BEGIN
  81             DIGIT := CARRY*BASE + A[I];
  82             A[I]  := DIGIT DIV ADIV;
  83             CARRY := DIGIT MOD ADIV
  84           END;
  85         WHILE A[AFIRST]=0 DO AFIRST := AFIRST + 1;
  86
  87
  88         (*)
  89         (   BERECHNUNG DES N-TEN GLIEDES DER ZWEITEN REIHE:
  90         (
  91         (           B <=== B * BMUL / BDIV
  92         (
  93         (*)
  94
  95         BMUL := 288*N  (* INCLUDES DIVISION BY 100000 *);
  96         I := LAST;  CARRY := (BMUL*B[LAST]) DIV BASE;
  97         WHILE (BFIRST<I) OR (CARRY<>0) DO
  98           BEGIN
  99             I := I - 1;
 100             DIGIT := BMUL*B[I] + CARRY;
 101             B[I+1]:= DIGIT MOD BASE;
 102             CARRY := DIGIT DIV BASE
 103           END;
 104         B[I] := 0;  BFIRST := I+1;
 105
 106         BDIV := N+N + 1;
 107         CARRY := 0;
 108         FOR I := BFIRST TO LAST DO
 109           BEGIN
 110             DIGIT := CARRY*BASE + B[I];
 111             B[I]  := DIGIT DIV BDIV;
 112             CARRY := DIGIT MOD BDIV
 113           END;
 114         IF B[BFIRST]=0 THEN BFIRST := BFIRST + 1;
 115
 116         (*)
 117         (   AUFSUMMIERUNG ZUR ZAHL PI:
 118         (
 119         (          PI <=== PI + A + B
 120         (
 121         (*)
 122
 123         I := LAST;  CARRY := 0;
 124         WHILE (AFIRST<=I) OR (CARRY<>0) DO
 125           BEGIN
 126             DIGIT := PI[I] + A[I] + B[I] + CARRY;  CARRY := 0;
 127             WHILE DIGIT>=BASE DO BEGIN
 128                                    DIGIT := DIGIT - BASE;
 129                                    CARRY := CARRY + 1
 130                                 END;
 131             PI[I] := DIGIT;
 132             I := I - 1
 133           END
 134
 135     UNTIL AFIRST>LAST;
 136
 137
 138     (*)
 139     (   AUSGABE:
 140     (*)
 141
 142     WRITELN; WRITE("PI = 3.":10);
 143     FOR I := 1 TO LAST-4 DO
 144       BEGIN
 145         DIGIT := PI[I];  POWER := BASE;
 146         REPEAT POWER := POWER DIV 10;
 147             WRITE(DIGIT DIV POWER :1);
 148             DIGIT := DIGIT MOD POWER
 149         UNTIL POWER=1;
 150         IF I MOD 10 = 0 THEN BEGIN WRITELN; WRITE(" ":10) END
 151       END;
 152     WRITELN
 153 END.