RhodeCode

EXTRA_DIST += \

	lemon/Makefile \

	lemon/lemon.pc.in

pkgconfig_DATA += lemon/lemon.pc

lib_LTLIBRARIES += lemon/libemon.la

lemon_libemon_la_SOURCES = \

        lemon/base.cc \

        lemon/random.cc

lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)

lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)

lemon_HEADERS += \

        lemon/dim2.h \

	lemon/maps.h \

        lemon/random.h \

	lemon/list_graph.h \

        lemon/tolerance.h

bits_HEADERS += \

	lemon/bits/alteration_notifier.h \

	lemon/bits/array_map.h \

	lemon/bits/base_extender.h \

	lemon/bits/default_map.h \

	lemon/bits/graph_extender.h \

        lemon/bits/invalid.h \

	lemon/bits/map_extender.h \

	lemon/bits/traits.h \

        lemon/bits/utility.h \

	lemon/bits/vector_map.h

concept_HEADERS += \

	lemon/concept_check.h \

	lemon/concepts/digraph.h \

	lemon/concepts/graph.h \

	lemon/concepts/maps.h \

	lemon/concepts/graph_components.h

/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2008

 * 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.

 *

 */

/*

 * This file contains the reimplemented version of the Mersenne Twister

 * Generator of Matsumoto and Nishimura.

 *

 * See the appropriate copyright notice below.

 * 

 * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,

 * All rights reserved.                          

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * 3. The names of its contributors may not be used to endorse or promote 

 *    products derived from this software without specific prior written 

 *    permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE

 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

 * OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *

 * 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 <ctime>

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

    struct RandomTraits<_Word, 32> {

      typedef _Word Word;

      static const int bits = 32;

      static const int length = 624;

      static const int shift = 397;

      static const Word mul = 0x6c078965u;

      static const Word arrayInit = 0x012BD6AAu;

      static const Word arrayMul1 = 0x0019660Du;

      static const Word arrayMul2 = 0x5D588B65u;

      static const Word mask = 0x9908B0DFu;

      static const Word loMask = (1u << 31) - 1;

      static const Word hiMask = ~loMask;

      static Word tempering(Word rnd) {

        rnd ^= (rnd >> 11);

        rnd ^= (rnd << 7) & 0x9D2C5680u;

        rnd ^= (rnd << 15) & 0xEFC60000u;

        rnd ^= (rnd >> 18);

        return rnd;

      }

    };

    template <typename _Word>

    struct RandomTraits<_Word, 64> {

      typedef _Word Word;

      static const int bits = 64;

      static const int length = 312;

      static const int shift = 156;

      static const Word mul = Word(0x5851F42Du) << 32 | Word(0x4C957F2Du);

      static const Word arrayInit = Word(0x00000000u) << 32 |Word(0x012BD6AAu);

      static const Word arrayMul1 = Word(0x369DEA0Fu) << 32 |Word(0x31A53F85u);

      static const Word arrayMul2 = Word(0x27BB2EE6u) << 32 |Word(0x87B0B0FDu);

      static const Word mask = Word(0xB5026F5Au) << 32 | Word(0xA96619E9u);

      static const Word loMask = (Word(1u) << 31) - 1;

      static const Word hiMask = ~loMask;

      static Word tempering(Word rnd) {

        rnd ^= (rnd >> 29) & (Word(0x55555555u) << 32 | Word(0x55555555u));

        rnd ^= (rnd << 17) & (Word(0x71D67FFFu) << 32 | Word(0xEDA60000u));

        rnd ^= (rnd << 37) & (Word(0xFFF7EEE0u) << 32 | Word(0x00000000u));

        rnd ^= (rnd >> 43);

        return rnd;

      }

    };

    template <typename _Word>

    class RandomCore {

    public:

      typedef _Word Word;

    private:

      static const int bits = RandomTraits<Word>::bits;

      static const int length = RandomTraits<Word>::length;

      static const int shift = RandomTraits<Word>::shift;

    public:

      void initState() {

        static const Word seedArray[4] = {

          0x12345u, 0x23456u, 0x34567u, 0x45678u

        };

        initState(seedArray, seedArray + 4);

      }

      void initState(Word seed) {

        static const Word mul = RandomTraits<Word>::mul;

        current = state; 

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

        (std::numeric_limits<Number>::is_signed ? 1 : 0);

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

    }

    int integer() {

      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;

    }

    /// Standard Gauss distribution

    /// Standard Gauss distribution.

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

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

    /// \todo Consider using the "ziggurat" method instead.

    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;

    }

    /// Gauss distribution with given mean and standard deviation

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

    /// \sa gauss()

    double gauss(double mean,double std_dev)

    {

      return gauss()*std_dev+mean;

    }

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

    {

      return -std::log(1.0-real<double>())/lambda;

    }

    /// Gamma distribution with given integer shape

    /// This function generates a gamma distribution random number.

    /// 

    ///\param k shape parameter (<tt>k>0</tt> integer)

    double gamma(int k) 

    {

      double s = 0;

      for(int i=0;i<k;i++) s-=std::log(1.0-real<double>());

      return s;

    }

    /// Gamma distribution with given shape and scale parameter

    /// This function generates a gamma distribution random number.

    /// 

    ///\param k shape parameter (<tt>k>0</tt>)

    ///\param theta scale parameter

    ///

    double gamma(double k,double theta=1.0)

    {

      double xi,nu;

      const double delta = k-std::floor(k);

      do {

	double V0=1.0-real<double>();

	double V1=1.0-real<double>();

	double V2=1.0-real<double>();

	if(V2<=v0) 

	  {

	    xi=std::pow(V1,1.0/delta);

	    nu=V0*std::pow(xi,delta-1.0);

	  }

	else 

	  {

	    xi=1.0-std::log(V1);

	    nu=V0*std::exp(-xi);

	  }

      } while(nu>std::pow(xi,delta-1.0)*std::exp(-xi));

      return theta*(xi-gamma(int(std::floor(k))));

    }

    /// Weibull distribution

    /// This function generates a Weibull distribution random number.

    /// 

    ///\param k shape parameter (<tt>k>0</tt>)

    ///\param lambda scale parameter (<tt>lambda>0</tt>)

    ///

    double weibull(double k,double lambda)

    {

      return lambda*pow(-std::log(1.0-real<double>()),1.0/k);

    }  

    /// Pareto distribution

    /// This function generates a Pareto distribution random number.

    /// 

    ///\param k shape parameter (<tt>k>0</tt>)

    ///\param x_min location parameter (<tt>x_min>0</tt>)

    ///

    double pareto(double k,double x_min)

    {

      return exponential(gamma(k,1.0/x_min));

    }  

    ///@}

    ///\name Two dimensional distributions

    ///

    ///@{

    /// Uniform distribution on the full unit circle

    /// Uniform distribution on the full unit circle.

    ///

    dim2::Point<double> disc() 

    {

      double V1,V2;

      do {

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

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

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

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

    }

    /// A kind of two dimensional Gauss distribution

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

    /// the Box-Muller method.

    dim2::Point<double> gauss2()

    {

      double V1,V2,S;

      do {

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

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

	S=V1*V1+V2*V2;

      } while(S>=1);

      double W=std::sqrt(-2*std::log(S)/S);

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

    }

    /// A kind of two dimensional exponential distribution

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

    /// The x-coordinate is of conditionally exponential distribution

    /// with the condition that x is positive and y=0. If x is negative and 

    /// y=0 then, -x is of exponential distribution. The same is true for the

    /// y-coordinate.

    dim2::Point<double> exponential2() 

    {

      double V1,V2,S;

      do {

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

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

	S=V1*V1+V2*V2;