Routine Accounting given Wait
  '' Ce sous-programme est appele a toutes les fois qu'un appel
  '' est complete
  '' Wait = temp d'attente d'un appel complete

  Define Wait as a double variable

  Define  Epoch, i, N.Epoch,
          Num, Rep, Trun
          as saved integer variable
  Define X          as a real saved 1-dim array
  Define j as an integer variable
  USE 09 for input
  if N.Epoch = 0   '' Au debut
     Read N.Epoch, Trun, i, Rep
       '' N.Epoch = nombre desire d'appel complete
       '' Trun    = nombre d'appel a eliminer au debut
       '' i       = nombre desire de la premiere repetition
       '' Rep     = nombre de repetitions

     RESERVE S(*) AS Rep
     RESERVE Seed.V(*) AS Rep

     For i = 1 to Rep
     Do
        Read S(i)
        Seed.V(i) = S(i)
     Loop
     epoch = 1
     Reserve X(*) as N.Epoch
     Num = 0
     Add i-1 to Rep
     return
  endif
  Add 1 to Num

  if Num <= Trun,              '' Doit-t-on tronquer les observation
     return
  endif


  X(Epoch) = .EnMinute * Wait '' convertir en minutes
  if Epoch = N.Epoch,
    Call Methode.Moyenne.Lots    giving N.Epoch, X(*)
    Call Methode.Autoregressive  giving N.Epoch, X(*)
    Call Methode.Spectrale       giving N.Epoch, X(*)

    if i = Rep     ''Est-on rendu au nombre de repetitions limites
        stop
     endif
     for j=1 to Dim.F(S(*)), S(j) = SEED.V(j)
     epoch = 1
     Num = 0
     Add 1 to i
  else
     Add 1 to Epoch
  endif
  return

end '' Accounting


Routine Methode.Moyenne.Lots given N, X
   '' Calcule un intervalle de confiance a 0.95
   '' par la methode des moyennes de lots

   Define i, k, N, No, Ntilde
          as integer variables
   Define C, Valeur.Critique, D, E, Demie.Largeur, Na, Xbar
          as real variables
   Define X, y as
          1-dim real arrays

   if N < 8,
      Print 1 line as follows
      Dimension de l'echantillon trop petite pour le test d'independance
      return
   endif

   Reserve Y(*) as N
   Ntilde = N
   K = 1

   for i = 1 to N, Y(i) = X(i)
   for i = 1 to N, Compute Xbar as the mean of X(i)
   skip 5 lines
   print 5 lines with TIME.V,Xbar as follows
                          Temps de simulation  *******.*******

                   Intervalle d'estimation 0.95  --- Methode des lots

                        Moyenne echantillonnee = *******.****

   skip 3 lines
   begin report
 ''     begin heading
         Print 3 lines thus
  Nb.     Nb. obs.  Variance echan.        Intervalle (0.95)              Valeur
  lots    par lot   de la moy. echan.     Inf.       Sup.          C      Critique
  ------ ---------  -----------------     -----------------       --      ---------

   ''   end  heading
      skip 1 line


      While 1 = 1
      do
         for i = 1 to Ntilde,
         Do
            Compute D as the variance of Y(i)
            if i < Ntilde,
               Compute E as the sum of (Y(i) - Y(i+1)) * (Y(i) - Y(i+1))
            endif
         Loop

         D  = D * Ntilde
         C  = 1.0 - E / (2.0 * D)
         Na = Ntilde * ( Ntilde - 1)
         Valeur.Critique = 1.645 * SQRT.F (( Ntilde - 2.0)
                                 / (Ntilde * Ntilde - 1.0))
         Demie.Largeur = Student.F ( Real.F(Ntilde-1))
                         * SQRT.F ( D / Na )
         Print 1 line with Ntilde, K, D / Na, Xbar-Demie.Largeur,
                           Xbar + Demie.Largeur, C, Valeur.Critique
                           thus
  *****   *******   *****.**********   ****.****  ***.****     *.****    *.***
         Skip 1 line
         if ABS.F (C) <= Valeur.Critique And No = 0,
            No = Ntilde
         endif
         if Ntilde < 16,   '' Le nombre d'observations par lots
                           '' doit >= 8
            skip 1 line
            if No > 0
               Print 1 line with No thus
     ********* lots suffisent pour passer le test d'independance a 0.05
            else
               Print 1 line thus
      Rejet du test d'independance
            endif
            Release Y
            return
         endif

         Ntilde = TRUNC.F (Ntilde / 2.0)
         K = 2 * K
         for i = 1 to Ntilde,
            Y(i) = (Y(2*i-1) + Y(2*i)) / 2.0
      loop
   end '' report

end ''Methode.Moyenne.Lots