---

CTBveri.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include    <stdlib.h>
#include    <string.h>
#include    <math.h>

#include    "CTB.hxx"
#include    "CTBveri.hxx"

#include    "CTBsystem.hxx"
#include    "CTBprintf.hxx"

//------------------------------------------+-----------------------------------

CTBveri::CTBveri()
  : mi_nalloc(0),
    mp_vp(0),
    mc_text(0),
    mb_active(0),
    mi_verbosity(0)
{
  RandomSeed(0);
}

//------------------------------------------+-----------------------------------

CTBveri::~CTBveri()
{
  delete mp_vp;
  delete mc_text;
  delete mb_active;
}

//------------------------------------------+-----------------------------------

void CTBveri::Register(CTBint i_ind, pveriproc_t p_vp, const char* c_text)
{
  if (i_ind <= 0) return;

  if (i_ind >= mi_nalloc-1) {

    if (mi_nalloc == 0) {
      mi_nalloc = 4;
      if (mi_nalloc <= i_ind) mi_nalloc = i_ind + 1;
      mp_vp     = new pveriproc_t [mi_nalloc];
      mc_text   = new const char* [mi_nalloc];
      for (CTBint i = 0; i < mi_nalloc; i++) {
        mp_vp[i]     = 0;
        mc_text[i]   = 0;
      }

    } else {
      pveriproc_t*  p_vp_old     = mp_vp;
      const char**  c_text_old   = mc_text;
      CTBint        i_nalloc_old = mi_nalloc;

      mi_nalloc *= 2;
      if (mi_nalloc <= i_ind) mi_nalloc = i_ind + 1;
      mp_vp     = new pveriproc_t [mi_nalloc];
      mc_text   = new const char* [mi_nalloc];

      for (CTBint i = 0; i < i_nalloc_old; i++) {
        mp_vp[i]     = p_vp_old[i];
        mc_text[i]   = c_text_old[i];
      }

      for (CTBint i = i_nalloc_old; i < mi_nalloc; i++) {
        mp_vp[i]     = 0;
        mc_text[i]   = 0;
      }

      delete p_vp_old;
      delete c_text_old;
    }
  }

  mp_vp[i_ind]   = p_vp;
  mc_text[i_ind] = c_text;
  
  return;
}

//------------------------------------------+-----------------------------------

int CTBveri::Exec(int argc, char *argv[])
{
  int  i_rc    = 0;
  bool b_help  = false;
  bool b_all   = true;

  if (mi_nalloc > 0) {
    mb_active = new bool [mi_nalloc];
    for (CTBint i = 0; i < mi_nalloc; i++) mb_active[i] = true;
  }

  for (CTBint i = 1; i < argc; i++) {
    
    if (argv[i][0] == '-') {
      if (strcmp(argv[i],"-?")  == 0) b_help = true;
      if (strcmp(argv[i],"-v")  == 0 && mi_verbosity < 1) mi_verbosity = 1;
      if (strcmp(argv[i],"-v1") == 0 && mi_verbosity < 1) mi_verbosity = 1;
      if (strcmp(argv[i],"-v2") == 0 && mi_verbosity < 2) mi_verbosity = 2;
      if (strcmp(argv[i],"-v3") == 0 && mi_verbosity < 3) mi_verbosity = 3;
      if (strcmp(argv[i],"-v4") == 0 && mi_verbosity < 4) mi_verbosity = 4;

    } else {
      char*  c_end;
      CTBint i_ind_b = strtol(argv[i],&c_end,10);
      CTBint i_ind_e = i_ind_b;
      if (c_end && c_end[0]) {
        if (c_end[0] == ':') {
          i_ind_e = strtol(c_end+1,&c_end,10);
          if (c_end && c_end[0]) {
            cerr << "conversion error in \"" << argv[i] << "\"" << endl;
            return 1;
          }
        } else {
          cerr << "conversion error in \"" << argv[i] << "\"" << endl;
          return 1;
        }
      }

      if (i_ind_b < 1)          i_ind_b = 1;
      if (i_ind_e < 1)          i_ind_e = 1;
      if (i_ind_b >= mi_nalloc) i_ind_b = mi_nalloc-1;
      if (i_ind_e >= mi_nalloc) i_ind_e = mi_nalloc-1;
      
      if (b_all) {
        b_all = false;
        for (CTBint j = 1; j < mi_nalloc; j++) mb_active[j] = false;
      }
      
      for (CTBint j = i_ind_b; j <= i_ind_e; j++) mb_active[j] = true;
    }
  }

  if (!b_all) {
    bool b_select = false;
    for (CTBint i = 1; i < mi_nalloc; i++) {
      b_select |= (mb_active[i] && mp_vp[i]);
    }
    if (!b_select) {
      cerr << "No tests selected" << endl;
    }
  }

  if (b_help) {
    for (CTBint i = 1; i < mi_nalloc; i++) {
      if (mp_vp[i]) {
        cout << "Test ";
        cout << setw(2) << i;
        if (mc_text[i]) cout << " : " << mc_text[i];
        cout << endl;
      }
    }
    return 0;
  }

  for (CTBint i = 1; i < mi_nalloc; i++) {
    if (mb_active[i] && mp_vp[i]) {
      bool b_ok;

      cout << "Test " << i;
      if (mc_text[i]) cout << " : " << mc_text[i];
      cout << endl;

      RandomSeed(47110815);
      
      b_ok = (*mp_vp[i])(*this);

      if (!b_ok) {
        cout << " === FAILED ===" << endl;
        i_rc = 1;
      }
    }
  }
  
  return i_rc;
}

//------------------------------------------+-----------------------------------

bool CTBveri::Verbosity(int i_level) const
{
  return mi_verbosity >= i_level;
}

//------------------------------------------+-----------------------------------

CTBuint32 CTBveri::RandomInt()
{
  CTBuint32 i_ran = mi_sz + mi_sn;          // new random #: sum of swb and con
  CTBuint32 i_s   = mi_sx + mi_sc;

  if (mi_sy > i_s) {
    i_s   = mi_sy - i_s;
    mi_sc = 0;
  } else {
    i_s   = mi_sy - i_s - 18;
    mi_sc = 1;
  }
  mi_sx = mi_sy;
  mi_sy = mi_sz;
  mi_sz = i_s;
  mi_sn = 69069 * mi_sn + 1013904243;
  
  return i_ran;
}

//------------------------------------------+-----------------------------------

double CTBveri::Random()
{
  return ((double)RandomInt())/(4294967296.);
}

//------------------------------------------+-----------------------------------

CTBint CTBveri::RandomInt(CTBint i_high)
{
  double d_r = (double) i_high * Random();
  CTBint i_r = (CTBint) d_r;
  
  if (i_r >= i_high) i_r = i_high-1;
  return i_r;
}

//------------------------------------------+-----------------------------------

CTBint CTBveri::RandomInt(CTBint i_low, CTBint i_high)
{
  double d_r = (double (i_high-i_low)) * Random();
  CTBint i_r = i_low + (CTBint) d_r;

  if (i_r >= i_high) i_r = i_high-1;
  return i_r;
}

//------------------------------------------+-----------------------------------

CTBint CTBveri::RandomInt1X(CTBint i_low, CTBint i_high)
{
  double d_log_l;
  double d_log_h;
  CTBint i_r;
  
  if (i_low <= 0 || i_high <= 0) return 0;

  d_log_l = log((double) i_low);
  d_log_h = log((double) i_high);
  
  i_r = (CTBint) exp(d_log_l + (d_log_h-d_log_l) * Random());

  if (i_r >= i_high) i_r = i_high-1;
  return i_r;
}

//------------------------------------------+-----------------------------------

double CTBveri::Random(double d_low, double d_high)
{
  return d_low + (d_high-d_low) * Random();
}

//------------------------------------------+-----------------------------------

bool CTBveri::RandomBool(double d_prob)
{
  return Random() <= d_prob;
}

//------------------------------------------+-----------------------------------

void CTBveri::RandomVector(CTBint i_ran[], CTBint i_size, CTBint i_high)
{
  for (CTBint i = 0; i < i_size; i++) i_ran[i] = RandomInt(i_high);
  return;
}

//------------------------------------------+-----------------------------------

void CTBveri::RandomVector(CTBint i_ran[], CTBint i_size, 
                           CTBint i_low, CTBint i_high)
{
  for (CTBint i = 0; i < i_size; i++) i_ran[i] = RandomInt(i_low,i_high);
  return;
}

//------------------------------------------+-----------------------------------

void CTBveri::RandomVector(bool b_ran[], CTBint i_size, double d_prob)
{
  for (CTBint i = 0; i < i_size; i++) b_ran[i] = RandomBool(d_prob);
  return;
}

//------------------------------------------+-----------------------------------

void CTBveri::RandomPermutation(CTBint i_perm[], CTBint i_size)
{
  for (CTBint i = 0; i < i_size; i++) i_perm[i] = i;
  
  for (CTBint i = 0; i < i_size-1; i++) {
    CTBint i_ind  = i + RandomInt(i_size-1-i);
    CTBint i_temp = i_perm[i];
    i_perm[i]     = i_perm[i_ind];
    i_perm[i_ind] = i_temp;
  }

  return;
}

//------------------------------------------+-----------------------------------
// Use a simple mod(2^32) congruential sequence to generate 32 numbers, take
// their most significant bit, and assemble them as a new 32 bit integer.
// The sequence created by cong32b has a shorter period (2**27) but all bits
// are equally random.

CTBuint32 cong32b(CTBuint32& i_seed)
{
  CTBuint32 i_ran = 0;
  CTBuint32 i_s   = i_seed;
  
  for (int i_b = 32; i_b > 0; i_b--) {
    i_ran = (i_ran >> 1) | (i_s & 0x80000000);
    i_s   = 69069 * i_s + 1013904243;
  }

  i_seed = i_s;
  return i_ran;
}

//------------------------------------------+-----------------------------------
void CTBveri::RandomSeed(CTBuint32 i_seed)
{
  mi_seed = i_seed;
  
  mi_sn = mi_seed;
  mi_sx = cong32b(mi_sn);
  mi_sy = cong32b(mi_sn);
  mi_sz = cong32b(mi_sn);
  if (mi_sx > 4294967277u) mi_sx = 4294967277u; // swb seeds in 0,...,2**32-18
  if (mi_sy > 4294967277u) mi_sy = 4294967277u;
  if (mi_sz > 4294967277u) mi_sz = 4294967277u;
  mi_sc = mi_sy > mi_sz;


  return;
}

//------------------------------------------+-----------------------------------
#if (defined(CTB__OutLine) || defined(CTBveri__OutLine))
#define inline
//#include "CTBveri.icc"
#undef  inline
#endif

---