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);
         
         Real Gaussian(Real f_std_dev, Real f_mean = 0.0f);
         
         Real Rayleigh(Real f_sigma);
         
         Real Lognormal(Real f_sigma, Real f_mu);

      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