Commit | Line | Data |
---|---|---|
81e70d48 PH |
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. |