// performance.cpp : Defines the entry point for the console application.
//

#include <stdio.h>
#include <tchar.h>
#include <safe_integer.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/integer.hpp>
#include <iostream>
#include <boost/chrono.hpp>

typedef boost::numeric::safe<unsigned> safe_type;

namespace boost {
	namespace multiprecision {

		namespace detail {

			template <class T> struct double_integer;

			template <>
			struct double_integer<safe_type>
			{
				typedef boost::numeric::safe<unsigned __int64> type;
			};
		}

		template <class Integer, class I2>
		typename enable_if_c<boost::numeric::is_safe<Integer>::value, Integer&>::type
			multiply(Integer& result, const I2& a, const I2& b)
		{
			return result = static_cast<Integer>(a) * static_cast<Integer>(b);
		}

		template <class Integer>
		typename enable_if_c<boost::numeric::is_safe<Integer>::value, bool>::type bit_test(const Integer& val, unsigned index)
		{
			Integer mask = 1;
			if (index >= sizeof(Integer) * CHAR_BIT)
				return 0;
			if (index)
				mask <<= index;
			return val & mask ? true : false;
		}

		template <class I1, class I2>
		typename enable_if_c<boost::numeric::is_safe<I1>::value, I2>::type integer_modulus(const I1& x, I2 val)
		{
			return static_cast<I2>(x % val);
		}

		template <class I1, class I2, class I3>
		typename enable_if_c<boost::numeric::is_safe<I1>::value, I1>::type
			powm(const I1& a, I2 b, I3 c)
		{
			typedef typename detail::double_integer<I1>::type double_type;

			I1 x(1), y(a);
			double_type result;

			while (b > 0)
			{
				if (b & 1)
				{
					multiply(result, x, y);
					x = integer_modulus(result, c);
				}
				multiply(result, y, y);
				y = integer_modulus(result, c);
				b >>= 1;
			}
			return x % c;
		}

		template <class T, class PP, class EP>
		inline unsigned lsb(const boost::numeric::safe<T, PP, EP>& x)
		{
			return lsb(static_cast<T>(x));
		}

} }

#include <boost/multiprecision/miller_rabin.hpp>

template <class Clock>
struct stopwatch
{
	typedef typename Clock::duration duration;
	stopwatch()
	{
		m_start = Clock::now();
	}
	duration elapsed()
	{
		return Clock::now() - m_start;
	}
	void reset()
	{
		m_start = Clock::now();
	}

private:
	typename Clock::time_point m_start;
};


int main()
{
	boost::chrono::duration<double> time;
	stopwatch<boost::chrono::high_resolution_clock> c;

	unsigned count = 0;
	for (unsigned i = 3; i < 30000000; ++i)
		if (boost::multiprecision::miller_rabin_test(i, 25)) ++count;
	time = c.elapsed();
	std::cout << "Testing type unsigned:\ntime = " << time;
	std::cout << "\ncount = " << count << std::endl;
	c.reset();
	count = 0;
	for (safe_type i = 3; i < 30000000; ++i)
		if (boost::multiprecision::miller_rabin_test(i, 25)) ++count;
	time = c.elapsed();
	std::cout << "Testing type safe<unsigned>:\ntime = " << time;
	std::cout << "\ncount = " << count << std::endl;
	c.reset();
	count = 0;
	typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > safe_mp_type;
	for (safe_mp_type i = 3; i < 30000000; ++i)
		if (boost::multiprecision::miller_rabin_test(i, 25)) ++count;
	time = c.elapsed();
	std::cout << "Testing type 32-bit cpp_int:\ntime = " << time;
	std::cout << "\ncount = " << count << std::endl;
	return 0;
}