home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / modula2 / library / fst / modula1 / reihe.mod < prev   
Text File  |  1993-07-28  |  5KB  |  153 lines
  1. MODULE  Reihe;
  2. (* Harmonische Reihe
  3.    Das folgende Programm berechnet die harmonische
  4.    Reihe der Form:
  5.                        m
  6.                   Sm = Σ 1/i
  7.                       i=1
  8.    einmal von links:  1/1 + 1/2 + ... + 1/m,
  9.    einmal von rechts: 1/m + 1/(m-1) + ... + 1/2 + 1/1
  10.    und errechnet anschließend die Differenz die sich bei der Berechnung
  11.    von links und von rechts ergibt.
  12.  
  13.  *)
  14. FROM RealInOut IMPORT WriteReal;
  15. FROM InOut     IMPORT ReadCard,
  16.                       WriteString,
  17.                       WriteLn;
  18.  
  19.  
  20. CONST
  21.   Maxm = 40000; (* Maximaler Wert fuer m *)
  22.  
  23. VAR
  24.   m : CARDINAL;  (* die einzugebende Zahl m *)
  25.   sumleft,   (*linke Summe *)
  26.   sumright,  (* rechte Summe *)
  27.   difference (* Differenz der beiden Summen *)  : REAL;
  28.  
  29.  
  30. (*******************************************************************)
  31. (* PROCEDURE Init                                                  *)
  32. (*******************************************************************)
  33. (* Installiert das Programm REIHE.                                 *)
  34. (* (Nachricht ausgeben)                                            *)
  35. (*******************************************************************)
  36. PROCEDURE init();
  37. BEGIN
  38.   WriteLn; WriteLn;
  39.   WriteString('Das folgende Programm berechnet eine harmonische ');
  40.   WriteString('Reihe der Form:'); WriteLn; WriteLn;
  41.   WriteString('      m'); WriteLn;
  42.   WriteString(' Sm = Σ 1/i'); WriteLn;
  43.   WriteString('     i=1'); WriteLn; WriteLn;
  44. END init;
  45.  
  46.  
  47. (*******************************************************************)
  48. (* PROCEDURE CalcLeft                                              *)
  49. (*******************************************************************)
  50. (* Berechnet die Harmonische Reihe von links nach rechts,          *)
  51. (* also von 1 bis m, und gibt sie an das aufrufende Prg. zurueck.  *)
  52. (*******************************************************************)
  53. PROCEDURE calcleft(m : CARDINAL) : REAL;
  54. VAR
  55.   i : CARDINAL;
  56.   ireal, sum : REAL;
  57.  
  58. BEGIN
  59.   FOR i:=1 TO m DO
  60.     ireal:=FLOAT(i);
  61.     sum:=sum + (1.0/ireal);
  62.   END;
  63.   RETURN sum;
  64. END calcleft;
  65.  
  66.  
  67. (*******************************************************************)
  68. (* PROCEDURE CalcRight                                             *)
  69. (*******************************************************************)
  70. (* Berechnet die Harmonische Reiche von rechts nach links,         *)
  71. (* also von m bis 1 (Schrittweite -1) und gibt sie ans aufrufende  *)
  72. (* Prg. zurueck                                                    *)
  73. (*******************************************************************)
  74. PROCEDURE calcright(m : CARDINAL) : REAL;
  75. VAR
  76.   i : CARDINAL;
  77.   ireal, sum : REAL;
  78.  
  79. BEGIN
  80.   FOR i:=m TO 1 BY -1 DO
  81.     ireal:=FLOAT(i);
  82.     sum:=sum + (1.0/ireal);
  83.   END;
  84.   RETURN sum;
  85. END calcright;
  86.  
  87.  
  88. (*******************************************************************)
  89. (* PROCEDURE Readm                                                 *)
  90. (*******************************************************************)
  91. (* Liest eine Zahl (hier m) ein und gibt sie ans aufrufende Prg    *)
  92. (* zurueck                                                         *)
  93. (*******************************************************************)
  94. PROCEDURE readm() : CARDINAL;
  95. VAR
  96.   z : CARDINAL;
  97.  
  98. BEGIN
  99.   REPEAT
  100.     WriteLn;
  101.     WriteString('Bitte m eingeben: ');
  102.     ReadCard(z);
  103.   UNTIL (z>0) AND (z<Maxm);
  104.   WriteLn;
  105.   RETURN z;
  106. END readm;
  107.  
  108.  
  109. (*******************************************************************)
  110. (* PROCEDURE Calculation                                           *)
  111. (*******************************************************************)
  112. (* -Ruft CalcRight und Calcleft mit dem Parameter m auf            *)
  113. (* -Berechnet die Differenz der beiden Berechnungen                *)
  114. (* -Gibt die berechneten Ergebnisse aus                            *)
  115. (*******************************************************************)
  116. PROCEDURE calculation(m : CARDINAL);
  117. BEGIN
  118.   WriteLn;
  119.   sumleft:=calcleft(m);
  120.   WriteString('Das Ergebnis der Berechnung von links nach rechts ');
  121.   WriteString('lautet: ');
  122.   WriteReal(sumleft, 13);
  123.   WriteLn;
  124.   sumright:=calcright(m);
  125.   WriteString('Das Ergebnis der Berechnung von rechts nach links ');
  126.   WriteString('lautet: ');
  127.   WriteReal(sumright, 13);
  128.   WriteLn;
  129.   difference:=sumright-sumleft;
  130.   WriteString('Differenz zwischen den beiden Berechnungsverfahren');
  131.   WriteString('......: ');
  132.   WriteReal(difference, 13);
  133.   WriteLn; WriteLn;
  134.   WriteString('Ende der Berechnung. ');
  135.   WriteLn; WriteLn;
  136. END calculation;
  137.  
  138.  
  139.  
  140. (*******************************************************************)
  141. (*  Hauptprogramm                                                  *)
  142. (*******************************************************************)
  143. BEGIN
  144.   init;
  145.   m:=readm();
  146.   calculation(m);
  147. END Reihe.
  148.  
  149.  
  150.  
  151.  
  152.  
  153.