home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 09 / statis / test.inc < prev    next >
Encoding:
Text File  |  1987-07-07  |  6.6 KB  |  184 lines
  1. {***************************************************************************}
  2. {*                              TEST.INC                                   *}
  3. {***************************************************************************}
  4. PROCEDURE signifikanz (VAR alpha : REAL);
  5.  
  6. BEGIN
  7.   REPEAT
  8.     Write('Vorgabe der alpha-Signifikanz in % : ');  ReadLn(alpha);
  9.   UNTIL (alpha > 0.0) AND (alpha < 100.0);
  10.   alpha := alpha/100.0;
  11. END;
  12. {---------------------------------------------------------------------------}
  13. PROCEDURE seitenanzahl (VAR seiten : INTEGER; VAR tcu, tco : BOOLEAN);
  14.  
  15. BEGIN
  16.   REPEAT
  17.     Write('Einseitig oder zweiseitig  (1 oder 2) ? ');  ReadLn(seiten);
  18.     IF seiten = 1 THEN
  19.        BEGIN
  20.          WriteLn(' <U> fuer Test auf Abweichungen nach unten ');
  21.          Write(' <O> fuer Test auf Abweichungen nach oben  ');
  22.          Read(Kbd, ch);  ch := UpCase(ch);  Writeln(ch);  Writeln;
  23.          IF ch = 'U' THEN tcu := TRUE;
  24.          IF ch = 'O' THEN tco := TRUE;
  25.        END;
  26.   UNTIL seiten IN [1..2];
  27. END;
  28. {---------------------------------------------------------------------------}
  29. PROCEDURE nullhypothese (VAR h0 : REAL );
  30.  
  31. BEGIN
  32.   Write('Wert der zu testenden Hypothese ?  ');  ReadLn(h0);
  33. END;
  34. {---------------------------------------------------------------------------}
  35. PROCEDURE zuruecklegen (VAR zurueck : BOOLEAN);
  36.  
  37. BEGIN
  38.   Write('Stichprobe mit Zuruecklegen (J/N) ?  ');
  39.   zurueck := Ja;
  40. END;
  41. {---------------------------------------------------------------------------}
  42. PROCEDURE Konfidenz (mw, cu, co : REAL);
  43.  
  44. BEGIN
  45.   GotoXY(20,18);  WriteLn('Stichprobenmittelwert          :  ',mw:11:4);
  46.   GotoXY(20,19);  WriteLn('Untere Konfidenzgrenze         :  ',cu:11:4);
  47.   GotoXY(20,20);  WriteLn('Obere Konfidenzgrenze          :  ',co:11:4);
  48. END;
  49. {---------------------------------------------------------------------------}
  50. PROCEDURE entscheidung ( test, alpha, h0, cu, co : REAL;
  51.                          seiten                  : INTEGER;
  52.                          tcu, tco                : BOOLEAN);
  53.  
  54. CONST msg = '     Die Hypothese wird abgelehnt ! ';
  55.  
  56. VAR   sig : REAL;
  57.  
  58. BEGIN
  59.   sig := (1.0-alpha*seiten)*100.0;
  60.   IF seiten = 2 THEN
  61.      IF ((test < cu) OR (test > co)) THEN WriteLn(msg)
  62.      ELSE WriteLn(h0:11:2,' wird zum Niveau ',sig:4:2,'% akzeptiert.')
  63.   ELSE IF seiten = 1 THEN
  64.     IF tcu THEN
  65.        IF test < cu THEN WriteLn(msg)
  66.        ELSE WriteLn(h0:11:2,' wird zum Niveau ',sig:4:2,'% akzeptiert.')
  67.     ELSE IF tco THEN
  68.        IF test > co THEN WriteLn(msg)
  69.        ELSE WriteLn(h0:11:2,' wird zum Niveau ',sig:4:2,'% akzeptiert.');
  70.   warten;
  71. END;
  72. {---------------------------------------------------------------------------}
  73. PROCEDURE mitint (zurueck : BOOLEAN; n : INTEGER; alpha, h0, sx : REAL;
  74.                   VAR cu, co : REAL);
  75.  
  76. VAR l, z : REAL;
  77.     p    : parametervector;
  78.  
  79. BEGIN
  80.   L := 0.0;
  81.   REPEAT
  82.     Write('Die Groesse des Loses ( > 0) ? '); ReadLn(L);
  83.   UNTIL (L > 0.0);
  84.   Write('Standardabweichung des Loses bekannt (J/N) ? ');
  85.   IF Ja THEN
  86.     BEGIN
  87.       REPEAT
  88.         Write('Wert der Standardabweichung des Loses ( > 0): ');
  89.         ReadLn(sx);
  90.       UNTIL sx >= 0.0;
  91.       IF zurueck THEN sx := sx/Sqrt(n)
  92.       ELSE IF (n / L < 0.05) THEN sx := sx/Sqrt(n)
  93.       ELSE sx := sx/Sqrt(n)*Sqrt((L-n)/(L-1.0));
  94.       z := quantil(nor, p, 1.0-alpha);
  95.     END
  96.   ELSE
  97.     BEGIN
  98.       IF zurueck THEN sx := sx/Sqrt(n-1.0)
  99.       ELSE IF (n/L < 0.05) THEN sx := sx/Sqrt(n-1)
  100.       ELSE sx := sx/Sqrt(n-1)*Sqrt((L-n)/L);
  101.       IF n > 29 THEN z := quantil(nor, p, 1.0-alpha)
  102.       ELSE BEGIN p[1] := n-1.0; z := quantil(stu, p, 1.0-alpha); END;
  103.     END;
  104.   cu := h0 - z * sx;
  105.   co := h0 + z * sx;
  106. END;
  107. {---------------------------------------------------------------------------}
  108. PROCEDURE mitkonfidenz;
  109.  
  110. VAR alpha, h0, mw, sx, cu, co, dummy : REAL;
  111.     seiten                           : INTEGER;
  112.     zur, tcu, tco                    : BOOLEAN;
  113.     vec                              : vector;
  114.  
  115. BEGIN
  116.   readvector(vec);  signifikanz(alpha);  alpha := alpha/2.0;
  117.   zuruecklegen(zur);  mittel(vec, mw, dummy, sx);  h0 := mw;
  118.   mitint(zur, vec.n, alpha, h0, sx, cu, co);
  119.   WriteLn('Stichprobenstandardabweichung  :  ',sx:11:4);
  120.   Konfidenz(mw, cu, co);
  121.   warten;
  122. END;
  123. {---------------------------------------------------------------------------}
  124. PROCEDURE mitteltest;
  125.  
  126. VAR test, h0, alpha, cu, co, mw, sx, dummy : REAL;
  127.     seiten                                 : INTEGER;
  128.     zur, tcu, tco                          : BOOLEAN;
  129.     vec                                    : vector;
  130.  
  131. BEGIN
  132.   readvector(vec);  signifikanz(alpha);  seitenanzahl(seiten, tco, tco);
  133.   zuruecklegen(zur);  alpha := alpha/seiten;  nullhypothese(h0);
  134.   mittel(vec, mw, dummy, sx);  test := mw;
  135.   mitint(zur, vec.n, alpha, h0, sx, cu, co);
  136.   WriteLn('Stichprobenstandardabweichung  :  ',sx:11:4);
  137.   Konfidenz(mw, cu, co);
  138.   entscheidung(test, alpha, h0, cu, co, seiten, tcu, tco);
  139. END;
  140. {---------------------------------------------------------------------------}
  141. PROCEDURE varianzint (VAR cu, co : REAL; n : INTEGER; alpha, vx : REAL);
  142.  
  143. VAR p : parametervector;
  144.  
  145. BEGIN
  146.   p[1] := n-1.0;
  147.   cu := p[1] * vx / quantil(chi, p, 1.0-alpha);
  148.   co := p[1] * vx / quantil(chi, p, alpha);
  149. END;
  150. {---------------------------------------------------------------------------}
  151. PROCEDURE varianzkonfidenz;
  152.  
  153. VAR alpha, mw, vx, cu, co, dummy : REAL;
  154.     seiten                       : INTEGER;
  155.     tcu, tco                     : BOOLEAN;
  156.     vec                          : vector;
  157.  
  158. BEGIN
  159.   readvector(vec);  signifikanz(alpha);  seitenanzahl(seiten, tcu, tco);
  160.   alpha := alpha/seiten;  mittel(vec, mw, vx, dummy);
  161.   varianzint(cu, co, vec.n, alpha, vx);
  162.   WriteLn('Stichprobenvarianz             :  ',vx:11:4);
  163.   Konfidenz(mw, cu, co);
  164.   warten;
  165. END;
  166. {---------------------------------------------------------------------------}
  167. PROCEDURE varianztest;
  168.  
  169. VAR test, h0, mw, vx, cu, co, alpha, dummy : REAL;
  170.     seiten                                 : INTEGER;
  171.     tcu, tco                               : BOOLEAN;
  172.     vec                                    : vector;
  173.  
  174. BEGIN
  175.   readvector(vec);  signifikanz(alpha);  seitenanzahl(seiten, tcu, tco);
  176.   alpha := alpha/seiten;  nullhypothese(h0);  mittel(vec, mw, vx, dummy);
  177.   test := vx;  varianzint(cu, co, vec.n, alpha, vx);
  178.   WriteLn('Stichprobenvarianz             :  ',vx:11:4);
  179.   Konfidenz(mw, cu, co);
  180.   entscheidung(test, alpha, h0, cu, co, seiten, tcu, tco);
  181. END;
  182. {---------------------------------------------------------------------------}
  183. {                            Ende TEST.INC                                  }
  184.