/*****************************************************************************
***                      Author: Hussein F. Salama                         ***
***                       Date: September 9, 1994                          ***
***                            File: stats.c                               ***
***          A library of C++ classes used to collect statistics from the  ***
***          discrete event simulator                                      *** 
*****************************************************************************/

#include "stats.h"

NodeStats::NodeStats(Node *current, Node *source, int address, 
                     const int batches) {
   c = current; 
   s = source; 
   addr = address; 
   numB = batches;
   pReceived = pLost = pMissed = 0; 
   minD = DBL_MAX; 
   maxD = jit = 0;
   aveD = confD = 0;
   prevSeqN = 0;
   n = NULL;
   totalD = new double[batches];
   int i;
   for (i = 0; i < batches; i++) (*(totalD +i)) = 0; 
   batchP = new unsigned long[batches];
   for (i = 0; i < batches; i++) (*(batchP +i)) = 0; 
   batchPL = new unsigned long[batches];
   for (i = 0; i < batches; i++) (*(batchPL +i)) = 0; 
};

double NodeStats::meanAndConf(int numBatches) {
   //calculate the mean and the cof. intervals for the end-to-end delay

   double mean, var;
   double meanL, varL;
   int i;
   int active = 0;

   if (numBatches > SKIPPEDBATCHES) {
        mean = var = 0.0 ;
        meanL = varL = 0.0;
        for (i = SKIPPEDBATCHES; i < numBatches; i++) {
           if ((*(batchP + i)) > 0) {
              mean += *(totalD + i);
              meanL += (double)(*(batchPL + i)) / 
                       ((*(batchPL + i)) + (*(batchP + i)));
              active++;
           };
        };
        mean /= active;
        meanL /= active;
        aveD = mean;
        aveL = meanL;

        for (i = SKIPPEDBATCHES; i < numBatches; i++) {
           if ((*(batchP + i)) > 0) {
              var += (*(totalD + i) - mean) * (*(totalD + i) - mean);
              varL += 
   (((double)(*(batchPL + i)) / ((*(batchPL + i)) + (*(batchP + i)))) - meanL) *
   (((double)(*(batchPL + i)) / ((*(batchPL + i)) + (*(batchP + i)))) - meanL);
           };
        };
        var /= active * (active - 1);
        varL /= active * (active - 1);
        confD = 1.96 * sqrt(var);
        confL = 1.96 * sqrt(varL);
        if (minD < DBL_MAX) {
          if ((aveD > 0) && (aveL > 0)) {
             if ((confD / aveD) > (confL / aveL)) return(confD / aveD);
             else return(confL / aveL);
          }
          else if (aveD > 0) return(confD / aveD);
          else return(0);
        }
        else return(DBL_MAX);
   };
};