random.h

Go to the documentation of this file.

#ifndef RANDOM_H
#define RANDOM_H

#include <cassert>
#include <algorithm>
#include <climits>
#include <cmath>
using namespace std;

#include <point.h>
#include <typedefs.h>


/*
  About

  random00<> random10<> random01<> random11<> generate
  random numbers between 0 and 1. 

  The suffix on random indicates whether the end points 
  of the interval are included or not.  eg random11< > 
  includes the start and end points of the interval in 
  sampling.
*/

class randomgenerator
{
public:

  uintc operator()() const
    { return rand(); }

  void randomize_start()
    { srand( time(NULL) ); }

  void seed(uintc s=1);

  template< typename Q >
  static boolc domain(point3<Q> const & p, boolc zero=true, boolc one=true);
  template< typename Q >
  static boolc domain(point2<Q> const & p, boolc zero=true, boolc one=true);
  template< typename T >
  static boolc domain(T const & x, boolc zero=true, boolc one=true);

};



template<typename T = double , typename G = randomgenerator >
class random11
{
  uint nend;
  T delta;
public:

  G rg;

  typedef T Ttype;
  typedef G Gtype;

  random11( uintc nend_=LONG_MAX)
    : nend(nend_), delta(1) { delta /= (nend-1); }

  void seed(uint s=1)
    { rg.seed(s); }

  T const operator()() const  
    { return T(rg() % nend)*delta; }

  void operator()(T& x) const 
    { x = (rg() % nend)*delta; }

  uintc endpoint() const
    { return nend; }

};


template<typename T = double , typename G = randomgenerator >
class random00
{
  uint nend;
  G rg;
  T delta;
public:

  typedef T Ttype;
  typedef G Gtype;

  random00(uintc nend_=LONG_MAX)
    : nend(nend_), delta(1) { delta /= (nend+1);}

  void seed(uintc s=1)
    { rg.seed(s); }

  T const operator()() const
    { return T( 1+(rg() % nend))*delta; }

  void operator()(T& x) const
    { x = T( 1+(rg() % nend))*delta; }

  uintc endpoint() const
    { return nend; }
};

template<typename T = double , typename G = randomgenerator >
class random01
{
  uint nend;
  G rg;
  T delta;
public:

  typedef T Ttype;
  typedef G Gtype;

  random01(uintc nend_=LONG_MAX)
    : nend(nend_), delta(1) { delta /= nend; }

  void seed(uintc s=1)
    { rg.seed(s); }

  T const operator()() const
    { return ( T(1+(rg() % nend)) )*delta; }

  void operator()(T& x) const 
    { x = ( T(1+(rg() % nend)) )*delta; }

  uintc endpoint() const
    { return nend; }
};


template<typename T = double , typename G = randomgenerator >
class random10
{
    uint nend;
    G rg;
    T delta;
public:

  typedef T Ttype;
  typedef G Gtype;

  random10(uintc nend_=LONG_MAX)
    : nend(nend_), delta(1) { delta /= nend; }

  void seed(uintc s=1)
    { rg.seed(s); }

  T const operator()() const 
    { return T(rg() % nend)*delta; }

  void operator()(T& x) const 
    { x = (rg() % nend)*delta; }

  uintc endpoint() const
    { return nend; }
};

template< typename RG=random11<> >
class randompoint
{
public:

  RG random;

  randompoint() {}

  randompoint(RG random_)
    : random(random_) {}

  typedef point2< typename RG::Ttype > pt2;
  typedef point3< typename RG::Ttype > pt3;

  pt2 makepoint2()
    { return pt2(random(),random()); }
  pt3 makepoint3()
    { return pt3(random(),random(),random()); }

};

//----------------------------------------------------------
//  Implementation


template< typename T >
boolc randomgenerator::domain(T const & x, boolc zero, boolc one)
{
//cout << SHOW(x) << endl;
  if (zero==false)
    assertreturnfalseN( x == (T)0 );

  if (one==false)
    assertreturnfalseN( x == (T)1 );

  assertreturnfalseN( x < (T)0 );

  assertreturnfalse( x <= (T)1 ); 

  return true;
}


template< typename Q >
boolc randomgenerator::domain(point2<Q> const & p, boolc zero, boolc one)
{
  bool res=true;
  if ( domain(p.x,zero,one) == false )
    res=false;
  if ( domain(p.y,zero,one) == false )
    res=false;

  return res;
}

template< typename Q >
boolc randomgenerator::domain(point3<Q> const & p, boolc zero, boolc one)
{
  bool res=true;
  res &= domain(p.x,zero,one);
  res &= domain(p.y,zero,one);
  res &= domain(p.z,zero,one);

  return res;
}


#endif