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.LGPL **
** 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 <ICLUtils/CompatMacros.h>
#include <ICLUtils/Time.h>
#include <ICLUtils/Range.h>
#include <ICLUtils/Exception.h>
#include <ICLUtils/ClippedCast.h>
#include <cmath>
#include <cstdlib>
#include <vector>

#ifdef WIN32
  #undef max
#endif

namespace icl{
  namespace utils{

    inline void randomSeed(long int seedval) {
  #ifdef WIN32
      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


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


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

    ICLUtils_API 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); }
    };


  /* }}} */

    inline std::vector<int> get_random_index_subset(int containerSize,
                                                    int subsetSize)
      {
      if(subsetSize > containerSize){
        throw ICLException("get_random_index_subset: subsetsize must be <= containerSize");
      }
      std::vector<int> s(containerSize);
      for(int i=0;i<containerSize;++i) s[i] = i;
      std::random_shuffle(s.begin(), s.end());
      return std::vector<int>(s.begin(), s.begin()+subsetSize);
    }

    template<class T>
    inline std::vector<T> get_random_subset(const std::vector<T> &s, int subsetSize)
      {
      std::vector<int> indices = get_random_index_subset(s.size(), subsetSize);
      std::vector<T> subset(subsetSize);
      for(int i=0;i<subsetSize;++i){
        subset[i] = s[indices[i]];
      }
      return subset;
    }

    template<class T>
    inline void get_random_subset(const std::vector<T> &s, int subsetSize,
                                  std::vector<T> &subset)
      {
      std::vector<int> indices = get_random_index_subset(s.size(), subsetSize);
      subset.resize(subsetSize);
      for(int i=0;i<subsetSize;++i){
        subset[i] = s[indices[i]];
      }
    }

    template<class T>
    inline void get_random_subset(const std::vector<T> &s, int subsetSize,
                                  std::vector<T> &subset, std::vector<int> &indices)
      {
      indices = get_random_index_subset(s.size(), subsetSize);
      subset.resize(subsetSize);
      for(int i=0;i<subsetSize;++i){
        subset[i] = s[indices[i]];
      }
    }



  } // namespace utils
}