RhodeCode

dnl Process this file with autoconf to produce a configure script.

dnl Version information.

m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))])

AC_PREREQ([2.59])

AC_INIT([LEMON], [lemon_version()], [lemon-devel@lemon.cs.elte.hu], [lemon])

AC_CONFIG_AUX_DIR([build-aux])

AC_CONFIG_MACRO_DIR([m4])

AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc])

AC_CONFIG_SRCDIR([lemon/list_graph.h])

AC_CONFIG_HEADERS([config.h lemon/config.h])

lx_cmdline_cxxflags_set=${CXXFLAGS+set}

dnl Checks for programs.

 * Any feedback is very welcome.

 * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html

 * email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)

 */

#ifndef LEMON_RANDOM_H

#define LEMON_RANDOM_H

#include <algorithm>

#include <iterator>

#include <vector>

#include <limits>

#include <lemon/math.h>

#include <lemon/dim2.h>

///\ingroup misc

///\file

///\brief Mersenne Twister random number generator

namespace lemon {

  namespace _random_bits {

    template <typename _Word, int _bits = std::numeric_limits<_Word>::digits>

    struct RandomTraits {};

    template <typename _Word>

  class Random {

  private:

    // Architecture word

    typedef unsigned long Word;

    _random_bits::RandomCore<Word> core;

    _random_bits::BoolProducer<Word> bool_producer;

  public:

    /// \brief Default constructor

    ///

    /// Constructor with constant seeding.

    Random() { core.initState(); }

    /// \brief Constructor with seed

    ///

    /// Constructor with seed. The current number type will be converted

    /// to the architecture word type.

    template <typename Number>

    Random(Number seed) { 

      _random_bits::Initializer<Number, Word>::init(core, seed);

    /// \brief Seeding random sequence

    ///

    /// Seeding the random sequence. The given range should contain

    /// any number type and the numbers will be converted to the

    /// architecture word type.

    template <typename Iterator>

    void seed(Iterator begin, Iterator end) { 

      typedef typename std::iterator_traits<Iterator>::value_type Number;

      _random_bits::Initializer<Number, Word>::init(core, begin, end);

    }

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

    ///

    /// It returns a random real number from the range [0, 1). The

    /// default Number type is \c double.

    template <typename Number>

    Number real() {

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

    }

    double real() {

      return real<double>();

    }

    Number real(Number b) { 

      return real<Number>() * b; 

    }

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

    ///

    /// 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>();

    }

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

    ///

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

    template <typename Number>

    Number operator()(Number b) { 

    }

    /// \brief Returns a random non-negative integer

    ///

    /// It returns a random non-negative integer uniformly from the

    /// whole range of the current \c Number type. The default result

    /// 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

    ///

    /// It returns a random integer uniformly from the whole range of

    /// the current \c Number type. The default result type of this

    /// function is \c int.

    template <typename Number>

    Number integer() {

      static const int nb = std::numeric_limits<Number>::digits + 

      return integer<int>();

    }

    /// \brief Returns a random bool

    ///

    /// It returns a random bool. The generator holds a buffer for

    /// random bits. Every time when it become empty the generator makes

    /// a new random word and fill the buffer up.

    bool boolean() {

      return bool_producer.convert(core);

    }

    ///\name Non-uniform distributions

    ///

    ///@{

    /// \brief Returns a random bool

    ///

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

    bool boolean(double p) {

      return operator()() < p;

    }