Random.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLUtils/src/ICLUtils/Random.h                         **
** Module : ICLUtils                                               **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <cmath>
#include <cstdlib>
#include <ICLUtils/Time.h>
#include <ICLUtils/Range.h>
#include <ICLUtils/ClippedCast.h>

namespace icl{
  namespace utils{

    inline void randomSeed(long int seedval) {
  #ifdef ICL_SYSTEM_WINDOWS
      srand(seedval);
  #else
      srand48(seedval);
  #endif
    }
  
    inline void randomSeed() {randomSeed(Time::now().toMicroSeconds());}
  

    struct RandomSeeder{
      inline RandomSeeder(){randomSeed();}
    };
  
    inline double random(double max=1) {
  #ifdef WIN32
      // this generates quite poor random numbers, because RAND_MAX = 32767
      return max*(static_cast<double>(rand()) / (1.0 + static_cast<double>(RAND_MAX)));
  #else
      return max*drand48();
  #endif
    }
    

    inline double random(double min, double max) {
      return ((max - min) * random() + min); 
    }
    
    template<class T>
    inline double random(const Range<T> &r){
      return random((double)r.minVal,(double)r.maxVal);
    }
   

    inline unsigned int random(unsigned int max) {
      unsigned int val = static_cast<unsigned int>(floor(random (static_cast<double>(max)+1.0)));
      return iclMin(val, max);
    }
    
  #if 0
    // removed due to lack of usebility: use std::fill(i.begin(c),i.end(c),URand(range)) instead
    

    void random(ImgBase *poImage, const Range<double> &range=Range<double>(0,255), bool roiOnly=true);
  

    void gaussRandom(ImgBase *poImage, double mean, double var, const Range<double> &minAndMax, bool roiOnly=true);
  #endif


    double gaussRandom(double mean, double var);
  

    inline double gaussRandom(double mean, double var, const Range<double> &range){
      return clip<double>( gaussRandom(mean,var), range.minVal, range.maxVal);
    }
  

    class URand{
      Range64f range;
      public:
      inline URand():range(0,1){};
      
      inline URand(icl64f min, icl64f max):range(min,max){}
  
      inline URand(const Range64f &range):range(range){};
  
      inline operator icl64f() const { return random(range.minVal,range.maxVal); }
    };
  

    class URandI{
      unsigned int max;
      public:
      inline URandI(unsigned int max):max(max){}
      
      inline operator unsigned int() const{ return random(max); }
    };
  

    class GRand{
      icl64f mean,var;
      public:
      inline GRand(icl64f mean=0, icl64f var=1.0):mean(mean),var(var){}
      
      inline operator icl64f() const { return gaussRandom(mean,var); }
    };
  

    class GRandClip{
      icl64f mean,var;
      Range64f range;
      public:
      inline GRandClip(icl64f mean, icl64f var,const Range64f &range):mean(mean),var(var),range(range){}
      
      inline operator icl64f() const { return gaussRandom(mean,var,range); }
    };
  
  
  /* }}} */
  
  
    
  } // namespace utils
}