/*
 * This file is a part of TTMath Bignum Library
 * and is distributed under the (new) BSD licence.
 * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

/* 
 * Copyright (c) 2006-2009, Tomasz Sowa
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *    
 *  * 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.
 *    
 *  * Neither the name Tomasz Sowa nor the names of contributors to this
 *    project may 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.
 */



#ifndef headerfilettmathint
#define headerfilettmathint

/*!
	\file ttmathint.h
    \brief template class Int<uint>
*/

#include "ttmathuint.h"

namespace ttmath
{


/*!
	\brief Int implements a big integer value with a sign

	value_size - how many bytes specify our value
		on 32bit platforms: value_size=1 -> 4 bytes -> 32 bits
		on 64bit platforms: value_size=1 -> 8 bytes -> 64 bits
	value_size = 1,2,3,4,5,6....
*/
template<uint value_size>
class Int : public UInt<value_size>
{
public:

	/*!
		this method sets the max value which this class can hold
		(all bits will be one besides the last one)
	*/
	void SetMax()
	{
		UInt<value_size>::SetMax();
		UInt<value_size>::table[value_size-1] = ~ TTMATH_UINT_HIGHEST_BIT;
	}


	/*!
		this method sets the min value which this class can hold
		(all bits will be zero besides the last one which is one)
	*/
	void SetMin()
	{
		UInt<value_size>::SetZero();
		UInt<value_size>::table[value_size-1] = TTMATH_UINT_HIGHEST_BIT;
	}


	/*!
		this method sets -1 as the value
		(-1 is equal the max value in an unsigned type)
	*/
	void SetSignOne()
	{
		UInt<value_size>::SetMax();
	}


	/*!
		we change the sign of the value

		if it isn't possible to change the sign this method returns 1
		else return 0 and changing the sign
	*/
	uint ChangeSign()
	{
	Int<value_size> temp;
	
		temp.SetMin();

		/*
			if the value is equal that one which has been returned from SetMin
			that means we can't change sign because the value is too big (bigger about one)

			e.g. when value_size = 1 and value is -2147483648 we can't change it to the
			2147483648 because the max value which can be held is 2147483647

			we don't change the value and we're using this fact somewhere in some methods
			(if we look on our value without the sign we get the correct value 
			eg. -2147483648 in Int<1> will be 2147483648 on the UInt<1> type)
		*/
		if( operator==(temp) )
			return 1;

		temp.SetZero();
		temp.UInt<value_size>::Sub(*this);

		operator=(temp);

	return 0;
	}



	/*!	
		this method sets the sign

		e.g. 1  -> -1
		     -2 -> -2
		
		from a positive value we make a negative value,
		if the value is negative we do nothing
	*/
	void SetSign()
	{
		if( IsSign() )
			return;

		ChangeSign();
	}



	/*!
		this method returns true if there's the sign

		(the highest bit will be converted to the bool)
	*/
	bool IsSign() const
	{
		return UInt<value_size>::IsTheHighestBitSet();
	}



	/*!
		it sets an absolute value

		it can return carry (1) (look on ChangeSign() for details)
	*/
	uint Abs()
	{
		if( !IsSign() )
			return 0;

	return ChangeSign();
	}




	/*!
	*
	*	basic mathematic functions
	*
	*/

private:

	uint CorrectCarryAfterAdding(bool p1_is_sign, bool p2_is_sign)
	{
		if( !p1_is_sign && !p2_is_sign )
		{
			if( UInt<value_size>::IsTheHighestBitSet() )
				return 1;
		}

		if( p1_is_sign && p2_is_sign )
		{	
			if( ! UInt<value_size>::IsTheHighestBitSet() )
				return 1;
		}

	return 0;
	}


public:

	/*!
		this method adds two value with a sign and returns a carry

		we're using methods from the base class because values are stored with U2
		we must only make the carry correction

		this = p1(=this) + p2

		when p1>=0 i p2>=0 carry is set when the highest bit of value is set
		when p1<0  i p2<0  carry is set when the highest bit of value is clear
		when p1>=0 i p2<0  carry will never be set
		when p1<0  i p2>=0 carry will never be set
	*/
	uint Add(const Int<value_size> & ss2)
	{
		bool p1_is_sign = IsSign();
		bool p2_is_sign = ss2.IsSign();

		UInt<value_size>::Add(ss2);		

	return CorrectCarryAfterAdding(p1_is_sign, p2_is_sign);
	}


	/*!
		this method adds one *unsigned* word (at a specific position)
		and returns a carry (if it was)

		look at a description in UInt<>::AddInt(...)
	*/
	uint AddInt(uint value, uint index = 0)
	{
		bool p1_is_sign = IsSign();

		UInt<value_size>::AddInt(value, index);		

	return CorrectCarryAfterAdding(p1_is_sign, false);
	}


	/*!
		this method adds two *unsigned* words to the existing value
		and these words begin on the 'index' position

		index should be equal or smaller than value_size-2 (index <= value_size-2)
		x1 - lower word, x2 - higher word

		look at a description in UInt<>::AddTwoInts(...)
	*/
	uint AddTwoInts(uint x2, uint x1, uint index)
	{
		bool p1_is_sign = IsSign();

		UInt<value_size>::AddTwoInts(x2, x1, index);		

	return CorrectCarryAfterAdding(p1_is_sign, false);
	}

private:

	uint CorrectCarryAfterSubtracting(bool p1_is_sign, bool p2_is_sign)
	{
		if( !p1_is_sign && p2_is_sign )
		{
			if( UInt<value_size>::IsTheHighestBitSet() )
				return 1;
		}

		if( p1_is_sign && !p2_is_sign )
		{	
			if( ! UInt<value_size>::IsTheHighestBitSet() )
				return 1;
		}

	return 0;
	}

public:

	/*!	
		this method subtracts two values with a sign

		we don't use the previous Add because the method ChangeSign can
		sometimes return carry 

		this = p1(=this) - p2

		when p1>=0 i p2>=0 carry will never be set
		when p1<0  i p2<0  carry will never be set
		when p1>=0 i p2<0  carry is set when the highest bit of value is set
		when p1<0  i p2>=0 carry is set when the highest bit of value is clear
	*/
	uint Sub(const Int<value_size> & ss2)
	{
		bool p1_is_sign = IsSign();
		bool p2_is_sign = ss2.IsSign();

		UInt<value_size>::Sub(ss2);		

	return CorrectCarryAfterSubtracting(p1_is_sign, p2_is_sign);
	}


	/*!
		this method subtracts one *unsigned* word (at a specific position)
		and returns a carry (if it was)
	*/
	uint SubInt(uint value, uint index = 0)
	{
		bool p1_is_sign = IsSign();

		UInt<value_size>::SubInt(value, index);		

	return CorrectCarryAfterSubtracting(p1_is_sign, false);
	}


	/*!
		this method adds one to the value and returns carry
	*/
	uint AddOne()
	{
		bool p1_is_sign = IsSign();

		UInt<value_size>::AddOne();		

	return CorrectCarryAfterAdding(p1_is_sign, false);
	}


	/*!
		this method subtracts one from the value and returns carry
	*/
	uint SubOne()
	{
		bool p1_is_sign = IsSign();

		UInt<value_size>::SubOne();		

	return CorrectCarryAfterSubtracting(p1_is_sign, false);
	}



	/*!
		multiplication this = this * ss2

		it returns carry if the result is too big
		(we're using the method from the base class but we have to make
		one correction in account of signs)
	*/
	uint Mul(Int<value_size> ss2)
	{
	bool ss1_is_sign, ss2_is_sign;

		ss1_is_sign = IsSign();
		ss2_is_sign = ss2.IsSign();

		/*
			we don't have to check the carry from Abs (values will be correct
			because next we're using the method Mul from the base class UInt
			which is without a sign)
		*/
		Abs();
		ss2.Abs();

		if( UInt<value_size>::Mul(ss2) )
			return 1;


		/*
			we have to examine the sign of the result now
			but if the result is with the sign then:
				1. if the signs were the same that means the result is too big
				(the result must be without a sign)
				2. if the signs were different that means if the result
				is different from that one which has been returned from SetMin()
				that is carry (result too big) but if the result is equal SetMin()
				there'll be ok (and the next SetSign will has no effect because
				the value is actually negative -- look at description of that case
				in ChangeSign())
		*/
		if( IsSign() )
		{
			/*
				there can be one case where signs are different and
				the result will be equal the value from SetMin()
				(this situation is ok)
			*/
			if( ss1_is_sign != ss2_is_sign )
			{
				Int<value_size> temp;
				temp.SetMin();
				
				if( operator!=(temp) )
					/*
						the result is too big
					*/
					return 1;
			}
			else
			{
				/*
					the result is too big
				*/
				return 1;
			}
		}

		if( ss1_is_sign != ss2_is_sign )
			SetSign();


	return 0;
	}


	/*!
		division this = this / ss2
		returned values:
			0 - ok
			1 - division by zero

		for example: (result means 'this')
			 20 /  3 --> result:  6   remainder:  2
			-20 /  3 --> result: -6   remainder: -2
			 20 / -3 --> result: -6   remainder:  2
			-20 / -3 --> result:  6   remainder: -2

		in other words: this(old) = ss2 * this(new)(result) + remainder
	*/
	uint Div(Int<value_size> ss2, Int<value_size> * remainder = 0)
	{
	bool ss1_is_sign, ss2_is_sign;

		ss1_is_sign = IsSign();
		ss2_is_sign = ss2.IsSign();

		/*
			we don't have to test the carry from Abs as well as in Mul
		*/
		Abs();
		ss2.Abs();

		uint c = UInt<value_size>::Div(ss2, remainder);

		if( ss1_is_sign != ss2_is_sign )
			SetSign();

		if( ss1_is_sign && remainder )
			remainder->SetSign();

	return c;
	}
	
	uint Div(const Int<value_size> & ss2, Int<value_size> & remainder)
	{
		return Div(ss2, &remainder);
	}



private:


	/*!
		power this = this ^ pow
		this can be negative
		pow is >= 0
	*/
	uint Pow2(const Int<value_size> & pow)
	{
		bool was_sign = IsSign();
		uint c = 0;

		if( was_sign )
			c += Abs();

		uint c_temp = UInt<value_size>::Pow(pow);
		if( c_temp > 0 )
			return c_temp; // c_temp can be: 0, 1 or 2
		
		if( was_sign && (pow.table[0] & 1) == 1 )
			// negative value to the power of odd number is negative
			c += ChangeSign();

	return (c==0)? 0 : 1;
	}


public:


	/*!
		power this = this ^ pow

		return values:
		0 - ok
		1 - carry
		2 - incorrect arguments 0^0 or 0^(-something)
	*/
	uint Pow(Int<value_size> pow)
	{
		if( !pow.IsSign() )
			return Pow2(pow);

		if( UInt<value_size>::IsZero() )
			// if 'p' is negative then
			// 'this' must be different from zero
			return 2;

		if( pow.ChangeSign() )
			return 1;

		Int<value_size> t(*this);
		uint c_temp = t.Pow2(pow);
		if( c_temp > 0 )
			return c_temp;

		UInt<value_size>::SetOne();
		if( Div(t) )
			return 1;

	return 0;
	}


	/*!
	*
	*	convertion methods
	*
	*/
private:


	/*!
		an auxiliary method for converting both from UInt and Int
	*/
	template<uint argument_size>
	uint FromUIntOrInt(const UInt<argument_size> & p, bool UInt_type)
	{
		uint min_size = (value_size < argument_size)? value_size : argument_size;
		uint i;

		for(i=0 ; i<min_size ; ++i)
			UInt<value_size>::table[i] = p.table[i];


		if( value_size > argument_size )
		{	
			uint fill;

			if( UInt_type )
				fill = 0;
			else
				fill = (p.table[argument_size-1] & TTMATH_UINT_HIGHEST_BIT)?
														TTMATH_UINT_MAX_VALUE : 0;

			// 'this' is longer than 'p'
			for( ; i<value_size ; ++i)
				UInt<value_size>::table[i] = fill;
		}
		else
		{
			uint test = (UInt<value_size>::table[value_size-1] & TTMATH_UINT_HIGHEST_BIT)?
																TTMATH_UINT_MAX_VALUE : 0;

			if( UInt_type && test!=0 )
				return 1;

			for( ; i<argument_size ; ++i)
				if( p.table[i] != test )
					return 1;
		}

	return 0;
	}

public:

	/*!
		this method converts an Int<another_size> type into this class

		this operation has mainly sense if the value from p
		can be held in this type

		it returns a carry if the value 'p' is too big
	*/
	template<uint argument_size>
	uint FromInt(const Int<argument_size> & p)
	{
		return FromUIntOrInt(p, false);
	}


	/*!
		this method converts the sint type into this class
	*/
	uint FromInt(sint value)
	{
	uint fill = ( value<0 ) ? TTMATH_UINT_MAX_VALUE : 0;

		for(uint i=1 ; i<value_size ; ++i)
			UInt<value_size>::table[i] = fill;

		UInt<value_size>::table[0] = uint(value);
	
		// there'll never be a carry here
	return 0;
	}


	/*!
		this method converts UInt<another_size> into this class
	*/
	template<uint argument_size>
	uint FromUInt(const UInt<argument_size> & p)
	{
		return FromUIntOrInt(p, true);
	}


	/*!
		this method converts the uint type into this class
	*/
	uint FromUInt(uint value)
	{
		for(uint i=1 ; i<value_size ; ++i)
			UInt<value_size>::table[i] = 0;

		UInt<value_size>::table[0] = value;

		// there can be a carry here when the size of this value is equal one word
		// and the 'value' has the highest bit set
		if( value_size==1 && (value & TTMATH_UINT_HIGHEST_BIT)!=0 )
			return 1;

	return 0;
	}

	// converting from Int

	/*!
		the default assignment operator
	*/
	Int<value_size> & operator=(const Int<value_size> & p)
	{
		FromInt(p);

	return *this;
	}


	/*!
		this operator converts an Int<another_size> type to this class

		it doesn't return a carry
	*/
	template<uint argument_size>
	Int<value_size> & operator=(const Int<argument_size> & p)
	{
		FromInt(p);

	return *this;
	}


	/*!
		this method converts the sint type to this class
	*/
	Int<value_size> & operator=(sint i)
	{
		FromInt(i);

	return *this;
	}


	/*!
		a constructor for converting the uint to this class
	*/
	Int(sint i)
	{
		FromInt(i);
	}


	/*!
		a copy constructor
	*/
	Int(const Int<value_size> & u)
	{
		FromInt(u);
	}


	/*!
		a constructor for copying from another types
	*/
	template<uint argument_size>
	Int(const Int<argument_size> & u)
	{
		// look that 'size' we still set as 'value_size' and not as u.value_size
		FromInt(u);
	}


	// converting from UInt

	/*!
		this operator converts an UInt<another_size> type to this class

		it doesn't return a carry
	*/
	template<uint argument_size>
	Int<value_size> & operator=(const UInt<argument_size> & p)
	{
		FromUInt(p);

	return *this;
	}


	/*!
		this method converts the Uint type to this class
	*/
	Int<value_size> & operator=(uint i)
	{
		FromUInt(i);

	return *this;
	}


	/*!
		a constructor for converting the uint to this class
	*/
	Int(uint i)
	{
		FromUInt(i);
	}


	/*!
		a constructor for copying from another types
	*/
	template<uint argument_size>
	Int(const UInt<argument_size> & u)
	{
		// look that 'size' we still set as 'value_size' and not as u.value_size
		FromUInt(u);
	}

	// 


#ifdef TTMATH_PLATFORM64

	/*!
		this method converts the signed int type to this class

		***this operator is created only on a 64bit platform***
		it takes one argument of 32bit
	*/
	Int<value_size> & operator=(signed int i)
	{
		FromInt(sint(i));

	return *this;
	}


	/*!
		a constructor for converting the signed int to this class

		***this constructor is created only on a 64bit platform***
		it takes one argument of 32bit
	*/
	Int(signed int i)
	{
		FromInt(sint(i));
	}


	/*!
		this method converts the unsigned int type to this class

		***this operator is created only on a 64bit platform***
		it takes one argument of 32bit
	*/
	Int<value_size> & operator=(unsigned int i)
	{
		FromUInt(uint(i));

	return *this;
	}


	/*!
		a constructor for converting the unsigned int to this class

		***this constructor is created only on a 64bit platform***
		it takes one argument of 32bit
	*/
	Int(unsigned int i)
	{
		FromUInt(uint(i));
	}

#endif


	/*!
		a constructor for converting string to this class (with the base=10)
	*/
	Int(const char * s)
	{
		FromString(s);
	}


	/*!
		a constructor for converting a string to this class (with the base=10)
	*/
	Int(const std::string & s)
	{
		FromString( s.c_str() );
	}


	/*!
		a default constructor

		we don't clear table etc.
	*/
	Int()
	{
	}


	/*!
		the destructor
	*/
	~Int()
	{
	}


	/*!
		this method returns the lowest value from table with a sign

		we must be sure when we using this method whether the value
		will hold in an sint type or not (the rest value from table must be zero or -1)
	*/
	sint ToInt() const
	{
		return sint( UInt<value_size>::table[0] );
	}


	/*!	
		this method converts the value to a string with a base equal 'b'
	*/
	void ToString(std::string & result, uint b = 10) const
	{
		if( IsSign() )
		{
			Int<value_size> temp(*this);
			temp.Abs();

			temp.UInt<value_size>::ToString(result, b);
			result.insert(result.begin(), '-');
		}
		else
		{
			UInt<value_size>::ToString(result, b);
		}
	}




	/*!
		this method converts a string into its value
		it returns carry=1 if the value will be too big or an incorrect base 'b' is given

		string is ended with a non-digit value, for example:
			"-12" will be translated to -12
			as well as:
			"- 12foo" will be translated to 12 too

		existing first white characters will be ommited
		(between '-' and a first digit can be white characters too)
	*/
	uint FromString(const char * s, uint b = 10)
	{
	bool is_sign = false;
	
		UInt<value_size>::SkipWhiteCharacters(s);

		if( *s == '-' )
		{
			is_sign = true;
			UInt<value_size>::SkipWhiteCharacters(++s);
		}
		else
		if( *s == '+' )
		{
			UInt<value_size>::SkipWhiteCharacters(++s);
		}

		if( UInt<value_size>::FromString(s,b) )
			return 1;

		if( is_sign )
		{
		Int<value_size> mmin;

			mmin.SetMin();

			/*
				the reference to mmin will be automatically converted to the reference
				to a UInt type
				(this value can be equal mmin -- look at a description in ChangeSign())
			*/
			if( UInt<value_size>::operator>( mmin ) )
				return 1;

			ChangeSign();
		}
		else
		{
		Int<value_size> mmax;

			mmax.SetMax();

			if( UInt<value_size>::operator>( mmax ) )
					return 1;
		}

	return 0;
	}


	/*!
		this method converts a string into its value
		it returns carry=1 if the value will be too big or an incorrect base 'b' is given
	*/
	uint FromString(const std::string & s, uint b = 10)
	{
		return FromString( s.c_str() );
	}


	/*!
		this operator converts a string into its value (with base = 10)
	*/
	Int<value_size> & operator=(const char * s)
	{
		FromString(s);

	return *this;
	}


	/*!
		this operator converts a string into its value (with base = 10)
	*/
	Int<value_size> & operator=(const std::string & s)
	{
		FromString( s.c_str() );

	return *this;
	}




	/*!
	*
	*	methods for comparing
	*
	*
	*/

	bool operator==(const Int<value_size> & l) const
	{
		return UInt<value_size>::operator==(l);
	}

	bool operator!=(const Int<value_size> & l) const
	{
		return UInt<value_size>::operator!=(l);
	}

	bool operator<(const Int<value_size> & l) const
	{
		sint i=value_size-1;

		sint a1 = sint(UInt<value_size>::table[i]);
		sint a2 = sint(l.table[i]);

		if( a1 != a2 )
			return a1 < a2;


		for(--i ; i>=0 ; --i)
		{
			if( UInt<value_size>::table[i] != l.table[i] )
				// comparison as unsigned int
				return UInt<value_size>::table[i] < l.table[i];
		}

	// they're equal
	return false;
	}


	bool operator>(const Int<value_size> & l) const
	{
		sint i=value_size-1;

		sint a1 = sint(UInt<value_size>::table[i]);
		sint a2 = sint(l.table[i]);

		if( a1 != a2 )
			return a1 > a2;


		for(--i ; i>=0 ; --i)
		{
			if( UInt<value_size>::table[i] != l.table[i] )
				// comparison as unsigned int
				return UInt<value_size>::table[i] > l.table[i];
		}

	// they're equal
	return false;
	}


	bool operator<=(const Int<value_size> & l) const
	{
		sint i=value_size-1;

		sint a1 = sint(UInt<value_size>::table[i]);
		sint a2 = sint(l.table[i]);

		if( a1 != a2 )
			return a1 < a2;


		for(--i ; i>=0 ; --i)
		{
			if( UInt<value_size>::table[i] != l.table[i] )
				// comparison as unsigned int
				return UInt<value_size>::table[i] < l.table[i];
		}

	// they're equal
	return true;
	}


	bool operator>=(const Int<value_size> & l) const
	{
		sint i=value_size-1;

		sint a1 = sint(UInt<value_size>::table[i]);
		sint a2 = sint(l.table[i]);

		if( a1 != a2 )
			return a1 > a2;


		for(--i ; i>=0 ; --i)
		{
			if( UInt<value_size>::table[i] != l.table[i] )
				// comparison as unsigned int
				return UInt<value_size>::table[i] > l.table[i];
		}

	// they're equal
	return true;
	}



	/*!
	*
	*	standard mathematical operators 
	*
	*/


	/*!
		an operator for changing the sign

		it's not changing 'this' but the changed value will be returned
	*/
	Int<value_size> operator-() const
	{
	Int<value_size> temp(*this);

		temp.ChangeSign();
		
	return temp;
	}


	Int<value_size> operator-(const Int<value_size> & p2) const
	{
	Int<value_size> temp(*this);

		temp.Sub(p2);

	return temp;
	}


	Int<value_size> & operator-=(const Int<value_size> & p2)
	{
		Sub(p2);

	return *this;
	}


	Int<value_size> operator+(const Int<value_size> & p2) const
	{
	Int<value_size> temp(*this);

		temp.Add(p2);

	return temp;
	}


	Int<value_size> & operator+=(const Int<value_size> & p2)
	{
		Add(p2);

	return *this;
	}


	Int<value_size> operator*(const Int<value_size> & p2) const
	{
	Int<value_size> temp(*this);

		temp.Mul(p2);

	return temp;
	}


	Int<value_size> & operator*=(const Int<value_size> & p2)
	{
		Mul(p2);

	return *this;
	}


	Int<value_size> operator/(const Int<value_size> & p2) const
	{
	Int<value_size> temp(*this);

		temp.Div(p2);

	return temp;
	}


	Int<value_size> & operator/=(const Int<value_size> & p2)
	{
		Div(p2);

	return *this;
	}


	Int<value_size> operator%(const Int<value_size> & p2) const
	{
	Int<value_size> temp(*this);
	Int<value_size> remainder;
	
		temp.Div(p2, remainder);

	return remainder;
	}


	Int<value_size> & operator%=(const Int<value_size> & p2)
	{
	Int<value_size> temp(*this);
	Int<value_size> remainder;
	
		temp.Div(p2, remainder);

		operator=(remainder);

	return *this;
	}


	/*!
		Prefix operator e.g. ++variable
	*/
	UInt<value_size> & operator++()
	{
		AddOne();

	return *this;
	}


	/*!
		Postfix operator e.g. variable++
	*/
	UInt<value_size> operator++(int)
	{
	UInt<value_size> temp( *this );

		AddOne();

	return temp;
	}


	UInt<value_size> & operator--()
	{
		SubOne();

	return *this;
	}


	UInt<value_size> operator--(int)
	{
	UInt<value_size> temp( *this );

		SubOne();

	return temp;
	}



	/*!
	*
	*	input/output operators for standard streams
	*
	*/

	friend std::ostream & operator<<(std::ostream & s, const Int<value_size> & l)
	{
	std::string ss;

		l.ToString(ss);
		s << ss;

	return s;
	}



	friend std::istream & operator>>(std::istream & s, Int<value_size> & l)
	{
	std::string ss;
	
	// char for operator>>
	unsigned char z;
	
		// operator>> omits white characters if they're set for ommiting
		s >> z;

		if( z=='-' || z=='+' )
		{
			ss += z;
			s >> z; // we're reading a next character (white characters can be ommited)
		}

		// we're reading only digits (base=10)
		while( s.good() && UInt<value_size>::CharToDigit(z, 10)>=0 )
		{
			ss += z;
			z = s.get();
		}

		// we're leaving the last readed character
		// (it's not belonging to the value)
		s.unget();

		l.FromString(ss);

	return s;
	}

};

} // namespace


#endif