rng.h

Go to the documentation of this file.

 
#ifndef ARGOS_RANDOM
#define ARGOS_RANDOM
 
namespace argos {
   class CRandom;
}
 
#include <argos3/core/utility/math/angles.h>
#include <argos3/core/utility/math/range.h>
#include <map>
 
namespace argos {
 
   class CRandom {
 
   public:
 
      class CRNG {
 
      public:
 
         CRNG(UInt32 un_seed);
 
         CRNG(const CRNG& c_rng);
 
         virtual ~CRNG();
 
         inline UInt32 GetSeed() const throw() {
            return m_unSeed;
         }
 
         inline void SetSeed(UInt32 un_seed) throw() {
            m_unSeed = un_seed;
         }
 
         void Reset();
 
         bool Bernoulli(Real f_true = 0.5);
         
         CRadians Uniform(const CRange<CRadians>& c_range);
         
         Real Uniform(const CRange<Real>& c_range);
         
         SInt32 Uniform(const CRange<SInt32>& c_range);
         
         UInt32 Uniform(const CRange<UInt32>& c_range);
         
         Real Exponential(Real f_mean);
 
         UInt32 Poisson(Real f_mean);
         
         Real Gaussian(Real f_std_dev, Real f_mean = 0.0f);
         
         Real Rayleigh(Real f_sigma);
         
         Real Lognormal(Real f_sigma, Real f_mu);
 
         template <typename T>
         void Shuffle(std::vector<T>& vec_data) {
            UInt32 j;
            for(UInt32 i = 0; i < vec_data.size()-1; ++i) {
               j = i + Uniform(CRange<UInt32>(0, vec_data.size() - i));
               T tTmp = vec_data[i];
               vec_data[i] = vec_data[j];
               vec_data[j] = tTmp;
            }
         }
 
      private:
 
         /*
          * Generates a random 32bit unsigned integer.
          * Used internally by all other functions.
          */
         UInt32 Uniform32bit();
 
      private:
 
         UInt32 m_unSeed;
         UInt32* m_punState;
         SInt32 m_nIndex;
 
      };
 
      class CCategory {
 
      public:
 
         CCategory(const std::string& str_id,
                   UInt32 un_seed);
 
         virtual ~CCategory();
 
         inline const std::string& GetId() const throw() {
            return m_strId;
         }
         void SetId(const std::string& str_id) {
            m_strId = str_id;
         }
 
         inline UInt32 GetSeed() const {
            return m_unSeed;
         }
         void SetSeed(UInt32 un_seed);
 
         CRNG* CreateRNG();
 
         void ResetRNGs();
 
         void ReseedRNGs();
 
      private:
 
         std::string m_strId;
         std::vector<CRNG*> m_vecRNGList;
         UInt32 m_unSeed;
         CRNG m_cSeeder;
         CRange<UInt32> m_cSeedRange;
      };
 
   public:
 
      static bool CreateCategory(const std::string& str_category,
                                 UInt32 un_seed);
      static CCategory& GetCategory(const std::string& str_category);
 
      static bool ExistsCategory(const std::string& str_category);
 
      static void RemoveCategory(const std::string& str_category);
 
      static CRNG* CreateRNG(const std::string& str_category);
 
      static UInt32 GetSeedOf(const std::string& str_category);
 
      static void SetSeedOf(const std::string& str_category,
                            UInt32 un_seed);
 
      static void Reset();
 
   private:
 
      static std::map<std::string, CCategory*> m_mapCategories;
   };
 
}
 
#endif