source: lemon-0.x/lemon/random.h @ 2231:06faf3f06d67

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#ifndef LEMON_RANDOM_H
#define LEMON_RANDOM_H

#include <algorithm>

#include <ctime>
#include <cmath>
#include <cmath>

///\ingroup misc
///\file
///\brief Mersenne Twister random number generator
///
///\author Balazs Dezso

namespace lemon {

#if WORD_BIT == 32

  /// \ingroup misc
  ///
  /// \brief Mersenne Twister random number generator
  ///
  /// The Mersenne Twister is a twisted generalized feedback
  /// shift-register generator of Matsumoto and Nishimura. The period of
  /// this generator is \f$ 2^{19937} - 1 \f$ and it is equi-distributed in
  /// 623 dimensions. The time performance of this generator is comparable
  /// to the commonly used generators.
  ///
  /// \author Balazs Dezso
  class Random {

    static const int length = 624;
    static const int shift = 397;

  public:

    static const unsigned long min = 0ul;
    static const unsigned long max = ~0ul;
  
    /// \brief Constructor
    ///
    /// Constructor with time dependent seeding.
    Random() { initState(std::time(0)); }

    /// \brief Constructor
    ///
    /// Constructor
    Random(unsigned long seed) { initState(seed); }

    /// \brief Copy constructor
    ///
    /// Copy constructor. The generated sequence will be identical to
    /// the other sequence.
    Random(const Random& other) { 
      std::copy(other.state, other.state + length, state);
      current = state + (other.current - other.state);
    }

    /// \brief Assign operator
    ///
    /// Assign operator. The generated sequence will be identical to
    /// the other sequence.
    Random& operator=(const Random& other) {
      if (&other != this) {
        std::copy(other.state, other.state + length, state);
        current = state + (other.current - other.state);
      }
      return *this;
    }

    /// \brief Returns an unsigned random number
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, 2^{32} - 1\} \f$.
    unsigned long getUnsigned() {
      if (current == state) fillState();
      --current;
      unsigned long rnd = *current;
      rnd ^= (rnd >> 11);
      rnd ^= (rnd << 7) & 0x9D2C5680ul;
      rnd ^= (rnd << 15) & 0xEFC60000ul;
      rnd ^= (rnd >> 18);
      return rnd;
    }

    /// \brief Returns a random number
    ///
    /// It returns an integer random number from the range 
    /// \f$ \{-2^{31}, \dots, 2^{31} - 1\} \f$.
    long getInt() {
      return (long)getUnsigned();
    }
    
    /// \brief Returns an unsigned integer random number
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, 2^{31} - 1\} \f$.
    long getNatural() {
      return (long)(getUnsigned() >> 1);
    }

    /// \brief Returns a random bool
    ///
    /// It returns a random bool.
    bool getBool() {
      return (bool)(getUnsigned() & 1);
    }

    /// \brief Returns a real random number
    ///
    /// It returns a real random number from the range 
    /// \f$ [0, 1) \f$. The double will have 32 significant bits.
    double getReal() {
      return std::ldexp((double)getUnsigned(), -32);
    }

    /// \brief Returns a real random number
    ///
    /// It returns a real random number from the range 
    /// \f$ [0, 1) \f$. The double will have 53 significant bits,
    /// but it is slower than the \c getReal().
    double getPrecReal() {
      return std::ldexp((double)(getUnsigned() >> 5), -27) + 
        std::ldexp((double)(getUnsigned() >> 6), -53);
    }

    /// \brief Returns an unsigned random number from a given range
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, n - 1\} \f$.
    unsigned long getUnsigned(unsigned long n) {
      unsigned long mask = n - 1, rnd;
      mask |= mask >> 1;
      mask |= mask >> 2;
      mask |= mask >> 4;
      mask |= mask >> 8;
      mask |= mask >> 16;
      do rnd = getUnsigned() & mask; while (rnd >= n);
      return rnd;
    }

    /// \brief Returns a random number from a given range
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, n - 1\} \f$.
    long getInt(long n) {
      long mask = n - 1, rnd;
      mask |= mask >> 1;
      mask |= mask >> 2;
      mask |= mask >> 4;
      mask |= mask >> 8;
      mask |= mask >> 16;
      do rnd = getUnsigned() & mask; while (rnd >= n);
      return rnd;
    }

  private:

    void initState(unsigned long seed) {
      static const unsigned long mul = 0x6c078965ul;

      current = state; 

      unsigned long *curr = state + length - 1;
      curr[0] = seed; --curr;
      for (int i = 1; i < length; ++i) {
        curr[0] = (mul * ( curr[1] ^ (curr[1] >> 30) ) + i);
        --curr;
      }
    }
  
    void fillState() {
      static const unsigned long mask[2] = { 0x0ul, 0x9908B0DFul };
      static const unsigned long loMask = (1ul << 31) - 1;
      static const unsigned long hiMask = ~loMask;

      current = state + length; 

      register unsigned long *curr = state + length - 1;
      register long num;
      
      num = length - shift;
      while (num--) {
        curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
          curr[- shift] ^ mask[curr[-1] & 1ul];
        --curr;
      }
      num = shift - 1;
      while (num--) {
        curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
          curr[length - shift] ^ mask[curr[-1] & 1ul];
        --curr;
      }
      curr[0] = (((curr[0] & hiMask) | (curr[length - 1] & loMask)) >> 1) ^
        curr[length - shift] ^ mask[curr[length - 1] & 1ul];

    }
  
    unsigned long *current;
    unsigned long state[length];
    
  };

#elif WORD_BIT == 64

  /// \ingroup misc
  ///
  /// \brief Mersenne Twister random number generator
  ///
  /// The Mersenne Twister is a twisted generalized feedback
  /// shift-register generator of Matsumoto and Nishimura. The period of
  /// this generator is \f$ 2^{19937} - 1 \f$ and it is equi-distributed in
  /// 311 dimensions. The time performance of this generator is comparable
  /// to the commonly used generators.
  class Random {

    static const int length = 312;
    static const int shift = 156;

  public:

    static const unsigned long min = 0ul;
    static const unsigned long max = ~0ul;
  
    /// \brief Constructor
    ///
    /// Constructor with time dependent seeding.
    Random() { initState(std::time(0)); }

    /// \brief Constructor
    ///
    /// Constructor
    Random(unsigned long seed) { initState(seed); }

    /// \brief Copy constructor
    ///
    /// Copy constructor. The generated sequence will be identical to
    /// the other sequence.
    Random(const Random& other) { 
      std::copy(other.state, other.state + length, state);
      current = state + (other.current - other.state);
    }

    /// \brief Assign operator
    ///
    /// Assign operator. The generated sequence will be identical to
    /// the other sequence.
    Random& operator=(const Random& other) {
      if (&other != this) {
        std::copy(other.state, other.state + length, state);
        current = state + (other.current - other.state);
      }
      return *this;
    }

    /// \brief Returns an unsigned random number
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, 2^{64} - 1\} \f$.
    unsigned long getUnsigned() {
      if (current == state) fillState();
      --current;
      unsigned long rnd = *current;
      rnd ^= (rnd >> 29) & 0x5555555555555555ul;
      rnd ^= (rnd << 17) & 0x71D67FFFEDA60000ul;
      rnd ^= (rnd << 37) & 0xFFF7EEE000000000ul;
      rnd ^= (rnd >> 43);
      return rnd;
    }

    /// \brief Returns a random number
    ///
    /// It returns an integer random number from the range 
    /// \f$ \{-2^{63}, \dots, 2^{63} - 1\} \f$.
    long getInt() {
      return (long)getUnsigned();
    }
    
    /// \brief Returns an unsigned integer random number
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, 2^{63} - 1\} \f$.
    long getNatural() {
      return (long)(getUnsigned() >> 1);
    }

    /// \brief Returns a random bool
    ///
    /// It returns a random bool.
    bool getBool() {
      return (bool)(getUnsigned() & 1);
    }

    /// \brief Returns a real random number
    ///
    /// It returns a real random number from the range 
    /// \f$ [0, 1) \f$.
    double getReal() {
      return std::ldexp((double)(getUnsigned() >> 11), -53);
    }

    /// \brief Returns a real random number
    ///
    /// It returns a real random number from the range 
    /// \f$ [0, 1) \f$. This function is identical to the \c getReal().
    double getPrecReal() {
      return getReal();
    }

    /// \brief Returns an unsigned random number from a given range
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, n - 1\} \f$.
    unsigned long getUnsigned(unsigned long n) {
      unsigned long mask = n - 1, rnd;
      mask |= mask >> 1;
      mask |= mask >> 2;
      mask |= mask >> 4;
      mask |= mask >> 8;
      mask |= mask >> 16;
      mask |= mask >> 32;
      do rnd = getUnsigned() & mask; while (rnd >= n);
      return rnd;
    }

    /// \brief Returns a random number from a given range
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, n - 1\} \f$.
    long getInt(long n) {
      long mask = n - 1, rnd;
      mask |= mask >> 1;
      mask |= mask >> 2;
      mask |= mask >> 4;
      mask |= mask >> 8;
      mask |= mask >> 16;
      mask |= mask >> 32;
      do rnd = getUnsigned() & mask; while (rnd >= n);
      return rnd;
    }

  private:

    void initState(unsigned long seed) {

      static const unsigned long mul = 0x5851F42D4C957F2Dul;

      current = state; 

      unsigned long *curr = state + length - 1;
      curr[0] = seed; --curr;
      for (int i = 1; i < length; ++i) {
        curr[0] = (mul * ( curr[1] ^ (curr[1] >> 62) ) + i);
        --curr;
      }
    }
  
    void fillState() {
      static const unsigned long mask[2] = { 0x0ul, 0xB5026F5AA96619E9ul };
      static const unsigned long loMask = (1ul << 31) - 1;
      static const unsigned long hiMask = ~loMask;

      current = state + length; 

      register unsigned long *curr = state + length - 1;
      register int num;
      
      num = length - shift;
      while (num--) {
        curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
          curr[- shift] ^ mask[curr[-1] & 1ul];
        --curr;
      }
      num = shift - 1;
      while (num--) {
        curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
          curr[length - shift] ^ mask[curr[-1] & 1ul];
        --curr;
      }
      curr[0] = (((curr[0] & hiMask) | (curr[length - 1] & loMask)) >> 1) ^
        curr[length - shift] ^ mask[curr[length - 1] & 1ul];

    }
  
    unsigned long *current;
    unsigned long state[length];
    
  };

#else

  /// \ingroup misc
  ///
  /// \brief Mersenne Twister random number generator
  ///
  /// The Mersenne Twister is a twisted generalized feedback
  /// shift-register generator of Matsumoto and Nishimura. There is
  /// two different implementation in the Lemon library, one for
  /// 32-bit processors and one for 64-bit processors. The period of
  /// the generated sequence is \f$ 2^{19937} - 1 \f$, the generated
  /// sequence of 32-bit random numbers is equi-distributed in 623
  /// dimensions. The time performance of this generator is comparable
  /// to the commonly used generators.
  class Random {
  public:

    static const unsigned long min = 0ul;
    static const unsigned long max = ~0ul;
  
    /// \brief Constructor
    ///
    /// Constructor with time dependent seeding.
    Random() {}

    /// \brief Constructor
    ///
    /// Constructor
    Random(unsigned long seed) {}

    /// \brief Copy constructor
    ///
    /// Copy constructor. The generated sequence will be identical to
    /// the other sequence.
    Random(const Random& other) {}

    /// \brief Assign operator
    ///
    /// Assign operator. The generated sequence will be identical to
    /// the other sequence.
    Random& operator=(const Random& other) { return *this; }

    /// \brief Returns an unsigned random number
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, 2^{64} - 1\} \f$ for 64-bit processors and from
    /// \f$ \{0, 1, \dots, 2^{32} - 1\} \f$ for 32-bit processors.
    unsigned long getUnsigned() { return 0ul; }

    /// \brief Returns a random number
    ///
    /// It returns an integer random number from the range 
    /// \f$ \{-2^{63}, \dots, 2^{63} - 1\} \f$ for 64-bit processors and from
    /// \f$ \{-2^{31}, \dots, 2^{31} - 1\} \f$ for 32-bit processors.
    long getInt() { return 0l; }
    
    /// \brief Returns an unsigned integer random number
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, 2^{63} - 1\} \f$ for 64-bit processors and
    /// from \f$ \{0, 1, \dots, 2^{31} - 1\} \f$ for 32-bit processors.
    long getNatural() { return 0l; }

    /// \brief Returns a random bool
    ///
    /// It returns a random bool.
    bool getBool() { return false; }

    /// \brief Returns a real random number
    ///
    /// It returns a real random number from the range 
    /// \f$ [0, 1) \f$. For 32-bit processors the generated random
    /// number will just have 32 significant bits.
    double getReal() { return 0.0; }

    /// \brief Returns a real random number
    ///
    /// It returns a real random number from the range 
    /// \f$ [0, 1) \f$. This function returns random numbers with 53
    /// significant bits for 32-bit processors. For 64-bit processors
    /// it is identical to the \c getReal().
    double getPrecReal() { return 0.0; }

    /// \brief Returns an unsigned random number from a given range
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, n - 1\} \f$.
    unsigned long getUnsigned(unsigned long n) { return 0; }

    /// \brief Returns a random number from a given range
    ///
    /// It returns an unsigned integer random number from the range 
    /// \f$ \{0, 1, \dots, n - 1\} \f$.
    long getInt(long n) { return 0; }

  };

#endif

  /// \brief Global random number generator instance
  ///
  /// A global mersenne twister random number generator instance
  extern Random rnd;

}

#endif