RhodeCode

  public:

    ///\name Initialization

    ///

    /// @{

    /// \brief Default constructor

    ///

    /// Constructor with constant seeding.

    Random() { core.initState(); }

    /// \brief Constructor with seed

    /// It returns a random real number from the range [a, b).

    template <typename Number>

    Number real(Number a, Number b) {

      return real<Number>() * (b - a) + a;

    }

    /// \brief Returns a random real number from the range [0, 1)

    ///

    /// It returns a random double from the range [0, 1).

    double operator()() {

      return real<double>();

    }

    /// type of this function is <tt>unsigned int</tt>.

    template <typename Number>

    Number uinteger() {

      return _random_bits::IntConversion<Number, Word>::convert(core);

    }

    unsigned int uinteger() {

      return uinteger<unsigned int>();

    }

    /// \brief Returns a random integer

    ///

    }

    /// @}

    ///\name Non-uniform distributions

    ///

    ///@{

    ///

    /// It returns a random bool with given probability of true result.

    bool boolean(double p) {

      return operator()() < p;

    }

    /// \note The Cartesian form of the Box-Muller

    /// transformation is used to generate a random normal distribution.

    double gauss()

    {

      double V1,V2,S;

      do {

        V1=2*real<double>()-1;

        V2=2*real<double>()-1;

        S=V1*V1+V2*V2;

      } while(S>=1);

      return std::sqrt(-2*std::log(S)/S)*V1;

    }

    /// \sa gauss()

    double gauss(double mean,double std_dev)

    {

      return gauss()*std_dev+mean;

    }

    /// Compute the lognormal parameters from mean and standard deviation

    /// This function computes the lognormal parameters from mean and

    /// standard deviation. The return value can direcly be passed to

    /// lognormal().

    std::pair<double,double> lognormalParamsFromMD(double mean,

    {

      double fr=std_dev/mean;

      fr*=fr;

      double lg=std::log(1+fr);

      return std::pair<double,double>(std::log(mean)-lg/2.0,std::sqrt(lg));

    }

    /// Lognormal distribution with given mean and standard deviation

    /// Lognormal distribution with given mean and standard deviation.

    ///

    double lognormalMD(double mean,double std_dev)

    {

      return lognormal(lognormalParamsFromMD(mean,std_dev));

    }

    /// Exponential distribution with given mean

    /// This function generates an exponential distribution random number

    /// with mean <tt>1/lambda</tt>.

    ///

    double exponential(double lambda=1.0)

    }

    ///@}

    ///\name Two dimensional distributions

    ///

    ///@{

    /// Uniform distribution on the full unit circle

    /// Uniform distribution on the full unit circle.

    ///

        V1=2*real<double>()-1;

        V2=2*real<double>()-1;

      } while(V1*V1+V2*V2>=1);

      return dim2::Point<double>(V1,V2);

    }

    /// This function provides a turning symmetric two-dimensional distribution.

    /// Both coordinates are of standard normal distribution, but they are not

    /// independent.

    ///

    /// \note The coordinates are the two random variables provided by