www.pudn.com > eval-1.2.zip > stat.h

#ifndef JKL_STAT
#define JKL_STAT

#include "def.h"

void CalcTime(dump_t *, unsigned, char *);
void CalcLoss(dump_t *, unsigned, loss_t *, char *);
void CalcDist(dump_t *, unsigned, loss_t *);
void CalcJitter(dump_t *, unsigned);
void CalcDelay(dump_t *, unsigned);

void PoBLoss(data_t *, unsigned);

void OutJitter(dump_t *, unsigned, char *);
void CalcSRate(dump_t *, unsigned, double, char *);
void CalcRRate(dump_t *, unsigned, double, char *);
void CalcHist(dump_t *, unsigned, unsigned, unsigned, char *);

double min(avg_t *, DIR, double, double);
double max(avg_t *, DIR, double, double);
double avg(avg_t *, DIR, double, double);
double std(avg_t *, DIR, double, double, double);
double expsmooth(avg_t *, DIR, double, double, double);

void norm(avg_t *);
void norm1(avg_t *, double);

int pred(avg_t *, DIR, int, double);

double KorrKoeff(avg_t *, double, double);
double AutoKorr(avg_t *, double, double);

void Hist(double *, unsigned, double, double, unsigned);
double Avg_D(double *, unsigned);
double Std_D(double *, unsigned, double);

#define MINV(v, a, dir, start, end, field) {                                       \
  int i = 0;                                                                       \
  double min;                                                                      \
  while (i < a.nP && a.P[i].t[dir] < start) i++;                                   \
  min = a.P[i++].field[dir];                                                       \
  while (i < a.nP && (a.P[i].t[dir] < end || a.P[i].t[dir] == -1 || end == -1)) {  \
    if (a.P[i].field[dir] != 0 && a.P[i].t[dir] != -1) {                           \
      if (a.P[i].field[dir] < min)                                                 \
        min = a.P[i].field[dir];                                                   \
    }                                                                              \
    i++;                                                                           \
  }                                                                                \
  v = min;                                                                         \
}

#define MAXV(v, a, dir, start, end, field) {                                       \
  int i = 0;                                                                       \
  double max;                                                                      \
  while (i < a.nP && a.P[i].t[dir] < start) i++;                                   \
  max = a.P[i++].field[dir];                                                       \
  while (i < a.nP && (a.P[i].t[dir] < end || a.P[i].t[dir] == -1 || end == -1)) {  \
    if (a.P[i].field[dir] != 0 && a.P[i].t[dir] != -1) {                           \
      if (a.P[i].field[dir] > max)                                                 \
        max = a.P[i].field[dir];                                                   \
    }                                                                              \
    i++;                                                                           \
  }                                                                                \
  v = max;                                                                         \
}
/*
#define NORM(a, field) {                                                                       \
  unsigned i;                                                                                  \
  double min1, max1, min2, max2;                                                               \
  MINV(min1, a, TO_MOBILE, a.P[0].t[TO_MOBILE], a.P[a.nP - 1].t[TO_MOBILE], field);            \
  MINV(min2, a, FROM_MOBILE, a.P[0].t[FROM_MOBILE], a.P[a.nP - 1].t[FROM_MOBILE], field);      \
  MAXV(max1, a, TO_MOBILE, a.P[0].t[TO_MOBILE], a.P[a.nP - 1].t[TO_MOBILE], field);            \
  MAXV(max2, a, FROM_MOBILE, a.P[0].t[FROM_MOBILE], a.P[a.nP - 1].t[FROM_MOBILE], field);      \
  for (i=0; i