/* boost random/weibull_distribution.hpp header file
 *
 * Copyright Matthias Christian Schabel 2008
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * See http://www.boost.org for most recent version including documentation.
 *
 */

#ifndef BOOST_RANDOM_WEIBULL_DISTRIBUTION_HPP
#define BOOST_RANDOM_WEIBULL_DISTRIBUTION_HPP

#include <cmath>
#include <cassert>
#include <iostream>
#include <boost/limits.hpp>
#include <boost/static_assert.hpp>

#include <boost/random/uniform_real.hpp>

namespace boost {

template<class RealType = double>
class weibull_distribution
{
	public:
		typedef RealType input_type;
		typedef RealType result_type;

		#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) && !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300)
		BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
		#endif

		explicit weibull_distribution(const result_type& k_arg,
									  const result_type& lambda_arg)
			: _k(k_arg), _k_inv(result_type(1)/_k), _lambda(lambda_arg), _uniform_dist()
		{
			assert(_k > result_type(0));
			assert(_lambda > result_type(0));
		}

		// compiler-generated copy constructor is fine

		// compiler-generated copy ctor and assignment operator are fine

		RealType k() const		{ return _k; }
		RealType lamdba() const { return _lambda; }

		void reset() { _uniform_dist.reset(); }

		template<class Engine>
		result_type operator()(Engine& eng)
		{
			#ifndef BOOST_NO_STDC_NAMESPACE
			// allow for Koenig lookup
			using std::log; using std::pow;
			#endif
			result_type	U;
			
			do
			{
				U = _uniform_dist(eng);
			} while (U == result_type(0));
							
			return _lambda*std::pow(-std::log(U),_k_inv);
		}

		#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
		template<class CharT, class Traits>
		friend std::basic_ostream<CharT,Traits>&
		operator<<(std::basic_ostream<CharT,Traits>& os, const weibull_distribution& nd)
		{
			os << nd._k << " " << nd._lambda;

			return os;
		}

		template<class CharT, class Traits>
		friend std::basic_istream<CharT,Traits>&
		operator>>(std::basic_istream<CharT,Traits>& is, weibull_distribution& nd)
		{
			is >> std::ws >> nd._k >> std::ws >> nd._lambda;

			return is;
		}
		#endif
		
	private:
		result_type					_k, 
									_k_inv,
									_lambda;
		uniform_real<result_type>	_uniform_dist;
};

} // namespace boost

#endif // BOOST_RANDOM_WEIBULL_DISTRIBUTION_HPP