Search  

---

C:/temp/src/j2k/DataType/Sort/Random.cpp

Go to the documentation of this file.

// Random.cpp - Implementation of Randomize number
//              generations and verification algorithm.

#ifndef __J2K__Sort__Random_CPP__
#define __J2K__Sort__Random_CPP__

#include <j2k/DataType/Sort/Random.hpp>

Random::Random() 
: maximum( RAND_MAX )
{
  Randomize();
  Resize( 256 );
}

Random::Random( const ULONG Size )
: maximum( Size )
{
  Randomize();
  Resize( Size );
}

Random::Random( const ULONG Size, const ULONG Max )
: maximum( Max )
{
  Randomize();
  Resize( Size );
}

Random::Random( const ULONG Size, const ULONG Max, const UINT value )
: maximum( Max )
{
  Randomize( value );
  Resize( Size );
}

Random::Random( const Random& r )   // Copy Constructor
 : maximum( r.maximum ),
   size(    r.size )
{
  Randomize( r.seed );

  Resize( size );

  for( register size_t i = 0; i < size; i++ ) 
  {
    array[i]       = r.array[i];
    arrayBackup[i] = r.arrayBackup[i];
  }
}

Random::~Random() 
{
//  Clear();
}

void Random::Clear() 
{
  if ( filled == false )  return;

  if ( array != NULL )
  {    
    delete[]  array;
  }

  if ( arrayBackup != NULL )
  {  
    delete[]  arrayBackup;
  }

  filled = false;
}

void Random::Resize( const ULONG Size )
{
  if ( filled == true )
  {
    Clear();
  }

  size        = Size;
  array       = new Elem[ size ];
  arrayBackup = new Elem[ size ];
  filled      = true;
}

void Random::Backup() 
{
  for( register size_t i = 0; i < size; i++ ) 
  {
    arrayBackup[i] = array[i];
  }
}

void Random::Restore() 
{
  for( register size_t i = 0; i < size; i++ ) 
  {
    array[i] = arrayBackup[i];
  }
}

void Random::feed() 
{
  feed( false );
}

void Random::feedUp() 
{
  feedUp( false );
}

void Random::feedDown() 
{
  feedDown( false );
}

void Random::feedValue( Elem value )
{
  feedValue( false, value );
}

void Random::feed( BOOL keepBackup )
{
  init();

  for( register size_t i = 0; i < size; i++ ) 
  {
    array[i] = getRnd();

    if ( keepBackup == false )
    {
      arrayBackup[i] = array[i];
    }
  }
}

void Random::feedValue( BOOL keepBackup, Elem value )
{
  init();

  for( register size_t i = 0; i < size; i++ ) 
  {
    array[i] = value;

    if ( keepBackup == false )
    {
      arrayBackup[i] = array[i];
    }
  }
}

void Random::feedUp( BOOL keepBackup )
{
  init();

  for( register size_t i = 0; i < size; i++ ) 
  {
    array[i] = (Elem)( i );

    if ( keepBackup == false )
    {
      arrayBackup[i] = array[i];
    }
  }
}

void Random::feedDown( BOOL keepBackup )
{
  init();

  for( register size_t i = 0; i < size; i++ ) 
  {
    array[i] = (Elem)( size - i );

    if ( keepBackup == false )
    {
      arrayBackup[i] = array[i];
    }
  }
}

void Random::Randomize() 
{
  // Seed the random-number generator with current time so that
  // the numbers will be different every time we run.
  seed = (UINT)time( NULL );
  init();
}

void Random::Randomize( const UINT value )
{
  // Seed the random-number generator with the given value
  seed = value;
  init();
}

void Random::init() const 
{
  srand( seed );
}

Elem*  Random::getArray() 
{
  return array;
}

UINT Random::getSeed() const 
{
  return seed;
}

ULONG Random::getMaximum() const 
{
  return maximum;
}

ULONG Random::getSize() const 
{
  return size;
}

Elem Random::getRnd() 
{
  return getRnd( maximum );
}

Elem Random::getRnd( const ULONG Max )
{
  // Get a number of type Elem from a double calculation
  // to obtain a wide uniform spread random number
  // in the range from 0 to Max.

  double r1 = rand();
  double r2 = r1 / RAND_MAX * Max;
  
  return ( Elem ) floor( r2 + 0.5 );
}

void Random::Verify( const ULONG spread )
{
   Elem* nb = new Elem[ spread ];
   register size_t i = 0;

   for( i = 0; i < size; i++ )
   {
     array[i] = getRnd();

     nb[ array[i] % spread ]++;
 
     printf( " [%6d] ", array[i] );
   }

   printf("\n\n");

   for( i = 0; i < spread; i++ )
   {
     double s = (double)array[i] / size * 100;
     printf( " %6d %.2f \t", array[i], s );
   }
}

void Random::Display() 
{
  if ( array == NULL )
  {
    return;
  } 
  else 
  {
    for( register size_t i = 0; i < size; i++ )
    {
      printf(" %d", array[i] );
    }

    printf("\n");
  }
}

#endif // End of Random.cpp

---