/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Created on: 16 mars 2010
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "avm_numeric.h"

#include <time.h>

#include <boost/random.hpp>

namespace sep
{


avm_uinteger_t RANDOM::gen_uinteger(avm_uinteger_t min, avm_uinteger_t max)
{
	if( min < max )
	{
		// Initialize a random number generator.
		// Boost provides a bunch of these, note that some of them are not meant
		// for direct user usage and you should instead use a specialization
		// (for example, don't use linear_congruential and use minstd_rand or
		// minstd_rand0 instead)

		// This constructor seeds the generator with the current time.
		// As mentioned in Boost's sample program, time(0) is not a great seed,
		// but you can probably get away with it for most situations.
		// Consider using more precise timers such as gettimeofday on *nix or
		// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.
		boost::mt19937 randGen(static_cast< avm_uint64_t >(clock()));

		// Now we set up a distribution. Boost provides a bunch of these as well.
		// This is the preferred way to generate numbers in a certain range.
		boost::uniform_int<avm_uinteger_t> uIntDist(min, max);

		// Finally, declare a variate_generator which maps the random number
		// generator and the distribution together. This variate_generator
		// is usable like a function call.
		boost::variate_generator< boost::mt19937 & ,
				boost::uniform_int<avm_uinteger_t> > GetRand(randGen, uIntDist);

		// Generate a random number
		return( GetRand() );
	}
	else// if( min == max )
	{
		return( min );
	}
}


avm_integer_t RANDOM::gen_integer(avm_integer_t min, avm_integer_t max)
{
	if( min < max )
	{
		// Initialize a random number generator.
		// Boost provides a bunch of these, note that some of them are not meant
		// for direct user usage and you should instead use a specialization
		// (for example, don't use linear_congruential and use minstd_rand or
		// minstd_rand0 instead)

		// This constructor seeds the generator with the current time.
		// As mentioned in Boost's sample program, time(0) is not a great seed,
		// but you can probably get away with it for most situations.
		// Consider using more precise timers such as gettimeofday on *nix or
		// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.
		boost::mt19937 randGen(static_cast< avm_uint64_t >(clock()));

		// Now we set up a distribution. Boost provides a bunch of these as well.
		// This is the preferred way to generate numbers in a certain range.
		boost::uniform_int<avm_integer_t> uIntDist(min, max);

		// Finally, declare a variate_generator which maps the random number
		// generator and the distribution together. This variate_generator
		// is usable like a function call.
		boost::variate_generator< boost::mt19937 & ,
				boost::uniform_int<avm_integer_t> > GetRand(randGen, uIntDist);

		// Generate a random number
		return( GetRand() );
	}
	else// if( min == max )
	{
		return( min );
	}
}


avm_uint32_t RANDOM::gen_uint(avm_uint32_t min, avm_uint32_t max)
{
	if( min < max )
	{
		// Initialize a random number generator.
		// Boost provides a bunch of these, note that some of them are not meant
		// for direct user usage and you should instead use a specialization
		// (for example, don't use linear_congruential and use minstd_rand or
		// minstd_rand0 instead)

		// This constructor seeds the generator with the current time.
		// As mentioned in Boost's sample program, time(0) is not a great seed,
		// but you can probably get away with it for most situations.
		// Consider using more precise timers such as gettimeofday on *nix or
		// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.
		boost::mt19937 randGen(static_cast< avm_uint64_t >(clock()));

		// Now we set up a distribution. Boost provides a bunch of these as well.
		// This is the preferred way to generate numbers in a certain range.
		boost::uniform_int<avm_uint32_t> uIntDist(min, max);

		// Finally, declare a variate_generator which maps the random number
		// generator and the distribution together. This variate_generator
		// is usable like a function call.
		boost::variate_generator< boost::mt19937 & ,
				boost::uniform_int<avm_uint32_t> > GetRand(randGen, uIntDist);

		// Generate a random number
		return( GetRand() );
	}
	else// if( min == max )
	{
		return( min );
	}
}


avm_int32_t RANDOM::gen_int(avm_int32_t min, avm_int32_t max)
{
	if( min < max )
	{
		// Initialize a random number generator.
		// Boost provides a bunch of these, note that some of them are not meant
		// for direct user usage and you should instead use a specialization
		// (for example, don't use linear_congruential and use minstd_rand or
		// minstd_rand0 instead)

		// This constructor seeds the generator with the current time.
		// As mentioned in Boost's sample program, time(0) is not a great seed,
		// but you can probably get away with it for most situations.
		// Consider using more precise timers such as gettimeofday on *nix or
		// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.
		boost::mt19937 randGen(static_cast< avm_uint64_t >(clock()));

		// Now we set up a distribution. Boost provides a bunch of these as well.
		// This is the preferred way to generate numbers in a certain range.
		boost::uniform_int<avm_int32_t> uIntDist(min, max);

		// Finally, declare a variate_generator which maps the random number
		// generator and the distribution together. This variate_generator
		// is usable like a function call.
		boost::variate_generator< boost::mt19937 & ,
				boost::uniform_int<avm_int32_t> > GetRand(randGen, uIntDist);

		// Generate a random number
		return( GetRand() );
	}
	else// if( min == max )
	{
		return( min );
	}
}


double RANDOM::gen_double(double min, double max, avm_uint64_t previous)
{
	if( min < max )
	{
		// Initialize a random number generator.
		// Boost provides a bunch of these, note that some of them are not meant
		// for direct user usage and you should instead use a specialization
		// (for example, don't use linear_congruential and use minstd_rand or
		// minstd_rand0 instead)

		// This constructor seeds the generator with the current time.
		// As mentioned in Boost's sample program, time(0) is not a great seed,
		// but you can probably get away with it for most situations.
		// Consider using more precise timers such as gettimeofday on *nix or
		// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.

//		boost::mt19937 randGen(std::time(0));
//		AVM_FLOAT_TIME_TYPE tps0 = ExecutionTime::getClock();
//		AVM_OS_TRACE << OS_FLOAT_PRECISION << "Valeur tps0 = " << tps0
//				<< " clock = " << static_cast<long unsigned int>(clock())
//				<< std::endl;
//		unsigned int tps = (unsigned int)tps0;
//		AVM_OS_TRACE << "Valeur tps = " << tps << std::endl;
		boost::mt19937 randGen(static_cast< avm_uint64_t >(clock()) + previous);

		// Now we set up a distribution. Boost provides a bunch of these as well.
		// This is the preferred way to generate numbers in a certain range.
		boost::uniform_real<double> uRealDist(min, max);

		// Finally, declare a variate_generator which maps the random number
		// generator and the distribution together. This variate_generator
		// is usable like a function call.
		boost::variate_generator< boost::mt19937 & ,
				boost::uniform_real<double> > GetRand(randGen, uRealDist);

		// Generate a random number
		return( GetRand() );
	}
	else// if( min == max )
	{
		return( min );
	}
}


}