changed: version of the library: 0.9.0 now

git-svn-id: svn://ttmath.org/publicrep/ttmath/trunk@251 e52654a7-88a9-db11-a3e9-0013d4bc506e

CHANGELOG

@@ -1,15 +1,5 @@
-Version 0.9.0 prerelease (2009.07.16):
+Version 0.9.0 (2009.11.25):
-    * added:   support for wide characters (wchar_t)
+    * added:   support for wide characters (wchar_t, std::wstring)
-               wide characters are used when macro TTMATH_USE_WCHAR is defined
-               this macro is defined automatically when there is macro UNICODE or _UNICODE defined
-               some types have been changed
-                 char               -> tt_char
-                 std::string        -> tt_string
-                 std::ostringstream -> tt_ostringstream
-                 std::ostream       -> tt_ostream
-                 std::istream       -> tt_istream
-               normally tt_char is equal char but when you are using wide characters then tt_char will be wchar_t (and so on)
-               (all typedef's are in ttmathtypes.h)
     * added:   Big::IsInteger()
                returns true if the value is integer (without fraction)
                (NaN flag is not checked)
@@ -17,10 +7,117 @@ Version 0.9.0 prerelease (2009.07.16):
     * added:   gamma() function to the parser
     * added:   CGamma<ValueType> class
                is used with Gamma() and Factorial() in multithreaded environment
+    * added:   multithread support for Big<> class
+               you should compile with TTMATH_MULTITHREADS
+               and use TTMATH_MULTITHREADS_HELPER macro somewhere in your *.cpp file
+    * added:   x86_64 asm code for Microsoft Visual compiler
+               file: ttmathuint_x86_64_msvc.asm
+               (this file should be compiled first because MS VC doesn't support inline assembler in x86_64 mode) 
+    * added:   flag TTMATH_BIG_ZERO to Big<> class
+               if this flag is set then there is a value zero
+               Big::IsZero() is faster now
+    * added:   Big::ClearInfoBit(unsigned char)
+               Big::SetInfoBit(unsigned char)
+               Big::IsInfoBit(unsigned char)
+               some methods for manipulating the info flags
+    * added:   macro: TTMATH_BITS(min_bits)
+		       which returns the number of machine words 
+		       capable to hold min_bits bits
+    * added:   bool Parser::Calculated()
+               this method returns true is something was calculated
+               (at least one mathematical operator was used or a function or variable)
+    * added:   to the parser: operator percentage
+               e.g. 1000-50%=1000-(1000*0,5)=500
+    * added:   struct: Conv
+               consists of some parameters used
+               in ToString() and FromString()
+    * added:   Big::ToString() can group digits
+               e.g. 1234567 -> 1`234`567
+    * added:   Parser::SetGroup(int g)
+               Parser::SetComma(int c, int c2 = 0)
+               Parser::SetParamSep(int s)
+    * added:   std::string  UInt::ToString(uint b = 10)
+               std::wstring UInt::ToWString(uint b = 10)
+               std::string  Int::ToString(uint b = 10)
+               std::wstring Int::ToWString(uint b = 10)
+               uint         Big::ToString(std::string & result, const Conv & conv)
+               uint         Big::ToString(std::wstring & result, const Conv & conv)
+               std::string  Big::ToString(const Conv & conv)
+               std::string  Big::ToString()
+               std::wstring Big::ToWString(const Conv & conv)
+               std::wstring Big::ToWString()
+    * added:   uint FromString(const char * source, const Conv & conv, const char **, bool *)
+               uint FromString(const wchar_t * source, const Conv & conv, const wchar_t **, bool *)
+               uint FromString(const std::string & string, const Conv & conv, const wchar_t **, bool *)
+               uint FromString(const std::wstring & string, const Conv & conv, const wchar_t **, bool *)
+    * added:   UInt::Sqrt() - a new algorithm for calculating the square root
+    * added:   to the parser: function frac() - returns a value without the integer part
+               (only fraction remains)
+    * added:   Int::DivInt(sint divisor, sint * remainder)
+    * added:   const char * UInt::LibTypeStr()
+               const char * Big::LibTypeStr()
+               LibTypeCode UInt::LibType()
+               LibTypeCode Big::LibType()
+               returning a string/enum represents the currect type of the library
+               we have following types:
+                   asm_vc_32   - with asm code designed for Microsoft Visual C++ (32 bits)
+                   asm_gcc_32  - with asm code designed for GCC (32 bits)
+                   asm_vc_64   - with asm for VC (64 bit)
+                   asm_gcc_64  - with asm for GCC (64 bit)
+                   no_asm_32   - pure C++ version (32 bit) - without any asm code
+                   no_asm_64   - pure C++ version (64 bit) - without any asm code
+    * added:   UInt::operator>>(int)
+               UInt::operator>>=(int)
+               UInt::operator<<(int)
+               UInt::operator<<=(int)
     * changed: Factorial() is using the Gamma() function now
+    * changed: Big::Div(ss2)
+               Big::Mod(ss2)
+               they return 2 when ss2 is zero
+               previously returned 1
+    * changed: algorithms in Big::Sqrt() and ttmath::Root(x ; n)
+               they were not too much accurate for some integers
+               e.g. Root(16;4) returned a value very closed to 2 (not exactly 2)
+    * changed: added specializations to Big::ToString() when the base is equal 4, 8 or 16
+               the previous version was not accurate on some last digits (after the comma operator)
+               consider this binary value (32 bit mantissa):
+               base 2: 1.1111 1111 1111 1111 1111 1111 1110 101
+               previous ToString() gave:
+                  base 4:  1.33333333333332
+                  base 8:  1.777777777
+                  base 16: 1.FFFFFF
+               now we have:
+                  base 4:  1.3333333333333222
+                  base 8:  1.77777777724
+                  base 16: 1.FFFFFFEA
+    * changed: in Big::ToString() some additional rounding (base_round) is now made only 
+               when the value is not an integer
+    * changed: another compilers than MS VC or GCC by default use no asm version (TTMATH_NOASM)
     * removed: Parser<>::SetFactorialMax() method
                the factorial() is such a fast now that we don't need the method longer
     * removed: ErrorCode::err_too_big_factorial
+    * removed: macros: TTMATH_COMMA_CHARACTER_1 and TTMATH_COMMA_CHARACTER_2
+               the comma characters we have in Conv struct now
+               
+
+Version 0.8.6 (2009.10.25):
+    * fixed:   UInt::SetBitInWord(uint & value, uint bit) set 1 if the bit was
+               equal 1 (should be set 2)
+               this affected only no-asm parts - when macro TTMATH_NOASM was defined
+    * fixed:   UInt<value_size>::MulInt(uint ss2)
+               there was a buffer overflow when value_size was equal 1
+    * fixed:   UInt::AddVector() and UInt::SubVector() didn't want to compile
+               when macro TTMATH_NOASM was defined
+    * fixed:   Big::operator>> didn't correctly recognize values in scientific mode (with 'e' character)
+    * fixed:   Int::FromString(const tt_string & s, uint b = 10)
+               didn't use 'b' (always was '10')
+    * fixed:   buffer overflow in Big::ToInt(Int<int_size> & result)
+    * fixed:   powering algorithm in:
+               UInt::Pow(UInt<value_size> pow)
+               Big::Pow(UInt<pow_size> pow)
+               Big::PowUInt(Big<exp, man> pow)
+               when 'pow' was sufficient large the algorithm returned carry
+               but the result could have been calculated correctly
 
 
 Version 0.8.5 (2009.06.16):

README

@@ -1,26 +1,23 @@
-TTMath - a bignum library for C++
+A bignum library for C++
 
 TTMath is a small library which allows one to perform arithmetic operations
-with big unsigned integer, big signed integer and big floating point
+with big unsigned integer, big signed integer and big floating point numbers.
-numbers. It provides standard mathematical operations like adding,
+It provides standard mathematical operations like adding, subtracting,
-subtracting, multiplying, dividing etc. With the library also goes
+multiplying, dividing. With the library also goes a mathematical parser to
-a mathematical parser which helps you solving input formulas read directly
+help you solving mathematical expressions.
-from a user.
 
-TTMath is developed under the BSD licence which means that it is free
+TTMath is developed under the BSD licence which means that it is free for
-for both personal and commercial use.
+both personal and commercial use.
-
-The library has some technical limitations:
- * there are only two platforms that are supported: x86 and x86_64,
- * you can use this library only with the C++ programming language.
 
 The main goal of the library is to allow one to use big values in the same
-way as the standard types like int, float, etc. It does not need to be
+way as the standard types like int or float. It does not need to be compiled
-compiled first because the whole library is written as the C++ templates.
+first because the whole library is written as the C++ templates. This means
-This means only C++ developers can use this library and one thing they have
+only C++ developers can use this library and one thing they have to do is
-to do is to use 'include' directive of the preprocessor. How big the
+to use 'include' directive of the preprocessor. How big the values can be
-values can be is set directly in the source code by the programmer.
+is set at compile time.
 
 Author: Tomasz Sowa <t.sowa@ttmath.org>
-Project pages: http://www.ttmath.org
+WWW:    http://www.ttmath.org
-http://sourceforge.net/projects/ttmath
+
+Contributors:
+Christian Kaiser <chk@online.de>

ttmath/ttmathconfig.h

@@ -1,110 +0,0 @@
-/*
- * This file is a part of TTMath Bignum Library
- * and is distributed under the PNG licence.
- * Author: Christian Kaiser <chk@online.de>
- */
-
-/* 
-	Copyright (c) 2009 Christian Kaiser
-
-	This software is provided 'as-is', without any express or implied
-	warranty. In no event will the authors be held liable for any damages
-	arising from the use of this software.
-
-	Permission is granted to anyone to use this software for any purpose,
-	including commercial applications, and to alter it and redistribute it
-	freely, subject to the following restrictions:
-
-		1. The origin of this software must not be misrepresented; you must not
-		claim that you wrote the original software. If you use this software
-		in a product, an acknowledgment in the product documentation would be
-		appreciated but is not required.
-
-		2. Altered source versions must be plainly marked as such, and must not be
-		misrepresented as being the original software.
-
-		3. This notice may not be removed or altered from any source
-		distribution.
- */
-
-#ifndef headerfilettmathconfig
-#define headerfilettmathconfig
-#pragma once
-
-#include <sstream>
-
-namespace ttmath
-{
-#if defined(WIN32)
-	#include <windows.h>
-	
-	#if defined(_MT)
-		class 	clsCrit
-			{
-			private:
-				mutable CRITICAL_SECTION 		_Crit;
-
-												clsCrit(const clsCrit&) // inhibit copy (easy mistake to do; use clsCritObj instead!!!)
-													{
-													}
-				clsCrit&						operator=(const clsCrit& rhs); // inhibit assignment
-			public:
-												clsCrit(void)
-													{
-													InitializeCriticalSection(&_Crit);
-													}
-				virtual							~clsCrit(void)
-													{
-													DeleteCriticalSection(&_Crit);
-													}
-
-				void							Enter(void) const
-													{
-													EnterCriticalSection(&_Crit);
-													}
-				void							Leave(void) const
-													{
-													LeaveCriticalSection(&_Crit);
-													}
-			};
-
-		class 	clsCritObj
-			{
-			private:
-				const clsCrit&					_Crit;
-				
-				clsCritObj&						operator=(const clsCritObj& rhs); // not applicable
-			public:
-												clsCritObj(const clsCrit& Sync)
-													: _Crit(Sync)
-													{
-													_Crit.Enter();
-													}
-												~clsCritObj(void)
-													{
-													_Crit.Leave();
-													}
-			};
-		#define TTMATH_IMPLEMENT_THREADSAFE_OBJ					\
-			private:											\
-				clsCrit CritSect;								\
-			public:												\
-				operator clsCrit&()								\
-				{												\
-					return(CritSect);							\
-				}
-		#define TTMATH_USE_THREADSAFE_OBJ(c)	clsCritObj	lock(c)
-	#endif
-#else // defined(WIN32) 
-	// not Windows world: no threading synchronization for now
-#endif
-
-#if !defined(TTMATH_IMPLEMENT_THREADSAFE_OBJ)
-	// if we don't know about serialization, make it a no-op
-	#define TTMATH_IMPLEMENT_THREADSAFE_OBJ		/* */
-	#define TTMATH_USE_THREADSAFE_OBJ(c)		/* */
-#endif
-
-} // namespace
-
-#endif // headerfilettmathconfig

ttmath/ttmathint.h

@@ -47,10 +47,6 @@
 
 #include "ttmathuint.h"
 
-#if defined(_MSC_VER)
-	#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
 namespace ttmath
 {
 
@@ -472,6 +468,64 @@ public:
 	}
 
 
+	/*!
+		division this = this / ss2  (ss2 is int)
+		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 DivInt(sint ss2, sint * remainder = 0)
+	{
+	bool ss1_is_sign, ss2_is_sign;
+
+		ss1_is_sign = IsSign();
+
+		/*
+			we don't have to test the carry from Abs as well as in Mul
+		*/
+		Abs();
+
+		if( ss2 < 0 )
+		{
+			ss2 = -ss2;
+			ss2_is_sign = true;
+		}
+		else
+		{
+			ss2_is_sign = false;
+		}
+
+		uint rem;
+		uint c = UInt<value_size>::DivInt((uint)ss2, &rem);
+
+		if( ss1_is_sign != ss2_is_sign )
+			SetSign();
+
+		if( remainder )
+		{
+			if( ss1_is_sign )
+				*remainder = -sint(rem);
+			else
+				*remainder = sint(rem);
+		}
+
+	return c;
+	}
+
+
+	uint DivInt(sint ss2, sint & remainder)
+	{
+		return DivInt(ss2, &remainder);
+	}
+
 
 private:
 
@@ -518,7 +572,7 @@ public:
 			return Pow2(pow);
 
 		if( UInt<value_size>::IsZero() )
-			// if 'p' is negative then
+			// if 'pow' is negative then
 			// 'this' must be different from zero
 			return 2;
 
@@ -538,6 +592,7 @@ public:
 	}
 
 
+
 	/*!
 	*
 	*	convertion methods
@@ -645,14 +700,8 @@ public:
 
 		// 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 defined(_MSC_VER)
-			#pragma warning(disable:4127) // conditional expression is constant
-		#endif
 		if( value_size==1 && (value & TTMATH_UINT_HIGHEST_BIT)!=0 )
 			return 1;
-		#if defined(_MSC_VER)
-			#pragma warning(default:4127) // conditional expression is constant
-		#endif
 
 	return 0;
 	}
@@ -831,7 +880,16 @@ public:
 	/*!
 		a constructor for converting string to this class (with the base=10)
 	*/
-	Int(const tt_char * s)
+	Int(const char * s)
+	{
+		FromString(s);
+	}
+
+
+	/*!
+		a constructor for converting string to this class (with the base=10)
+	*/
+	Int(const wchar_t * s)
 	{
 		FromString(s);
 	}
@@ -840,7 +898,16 @@ public:
 	/*!
 		a constructor for converting a string to this class (with the base=10)
 	*/
-	Int(const tt_string & s)
+	Int(const std::string & s)
+	{
+		FromString( s.c_str() );
+	}
+
+
+	/*!
+		a constructor for converting a string to this class (with the base=10)
+	*/
+	Int(const std::wstring & s)
 	{
 		FromString( s.c_str() );
 	}
@@ -876,10 +943,13 @@ public:
 	}
 
 
+private:
+
 	/*!	
-		this method converts the value to a string with a base equal 'b'
+		an auxiliary method for converting to a string
 	*/
-	void ToString(tt_string & result, uint b = 10) const
+	template<class string_type>
+	void ToStringBase(string_type & result, uint b = 10) const
 	{
 		if( IsSign() )
 		{
@@ -895,42 +965,71 @@ public:
 		}
 	}
 
+public:
+
+	/*!	
+		this method converts the value to a string with a base equal 'b'
+	*/
+	void ToString(std::string & result, uint b = 10) const
+	{
+		return ToStringBase(result, b);
+	}
 
 
+	/*!	
+		this method converts the value to a string with a base equal 'b'
+	*/
+	void ToString(std::wstring & result, uint b = 10) const
+	{
+		return ToStringBase(result, b);
+	}
+
+
+	/*!	
+		this method converts the value to a string with a base equal 'b'
+	*/
+	std::string ToString(uint b = 10) const
+	{
+		std::string result;
+		ToStringBase(result, b);
+
+	return result;
+	}
+
+
+	/*!	
+		this method converts the value to a string with a base equal 'b'
+	*/
+	std::wstring ToWString(uint b = 10) const
+	{
+		std::wstring result;
+		ToStringBase(result, b);
+
+	return result;
+	}
+
+
+private:
 
 	/*!
-		this method converts a string into its value
+		an auxiliary method for converting from a string
-		string is given either as 'const char *' or 'const wchar_t *'
-
-		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)
-
-		after_source (if exists) is pointing at the end of the parsed string
-
-		value_read (if exists) tells whether something has actually been read (at least one digit)
 	*/
-	uint FromString(const tt_char * s, uint b = 10, const tt_char ** after_source = 0, bool * value_read = 0)
+	template<class char_type>
+	uint FromStringBase(const char_type * s, uint b = 10, const char_type ** after_source = 0, bool * value_read = 0)
 	{
 	bool is_sign = false;
 	
-		UInt<value_size>::SkipWhiteCharacters(s);
+		Misc::SkipWhiteCharacters(s);
 
 		if( *s == '-' )
 		{
 			is_sign = true;
-			UInt<value_size>::SkipWhiteCharacters(++s);
+			Misc::SkipWhiteCharacters(++s);
 		}
 		else
 		if( *s == '+' )
 		{
-			UInt<value_size>::SkipWhiteCharacters(++s);
+			Misc::SkipWhiteCharacters(++s);
 		}
 
 		if( UInt<value_size>::FromString(s,b,after_source,value_read) )
@@ -969,11 +1068,54 @@ public:
 	}
 
 
+public:
+
+	/*!
+		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)
+
+		after_source (if exists) is pointing at the end of the parsed string
+
+		value_read (if exists) tells whether something has actually been read (at least one digit)
+	*/
+	uint FromString(const char * s, uint b = 10, const char ** after_source = 0, bool * value_read = 0)
+	{
+		return FromStringBase(s, b, after_source, value_read);
+	}
+
+
+	/*!
+		this method converts a string into its value
+	*/
+	uint FromString(const wchar_t * s, uint b = 10, const wchar_t ** after_source = 0, bool * value_read = 0)
+	{
+		return FromStringBase(s, b, after_source, value_read);
+	}
+
+
 	/*!
 		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 tt_string & s, uint b = 10)
+	uint FromString(const std::string & s, uint b = 10)
+	{
+		return FromString( s.c_str(), 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
+	*/
+	uint FromString(const std::wstring & s, uint b = 10)
 	{
 		return FromString( s.c_str(), b );
 	}
@@ -982,7 +1124,7 @@ public:
 	/*!
 		this operator converts a string into its value (with base = 10)
 	*/
-	Int<value_size> & operator=(const tt_char * s)
+	Int<value_size> & operator=(const char * s)
 	{
 		FromString(s);
 
@@ -993,7 +1135,18 @@ public:
 	/*!
 		this operator converts a string into its value (with base = 10)
 	*/
-	Int<value_size> & operator=(const tt_string & s)
+	Int<value_size> & operator=(const wchar_t * 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() );
 
@@ -1001,6 +1154,15 @@ public:
 	}
 
 
+	/*!
+		this operator converts a string into its value (with base = 10)
+	*/
+	Int<value_size> & operator=(const std::wstring & s)
+	{
+		FromString( s.c_str() );
+
+	return *this;
+	}
 
 
 	/*!
@@ -1280,14 +1442,15 @@ public:
 	*
 	*/
 
-	/*!
+private:
-		output for standard streams
 
-		tt_ostream is either std::ostream or std::wostream
+	/*!
+		an auxiliary method for outputing to standard streams
 	*/
-	friend tt_ostream & operator<<(tt_ostream & s, const Int<value_size> & l)
+	template<class ostream_type, class string_type>
+	static ostream_type & OutputToStream(ostream_type & s, const Int<value_size> & l)
 	{
-	tt_string ss;
+	string_type ss;
 
 		l.ToString(ss);
 		s << ss;
@@ -1296,17 +1459,41 @@ public:
 	}
 
 
-	/*!
-		input from standard streams
 
-		tt_istream is either std::istream or std::wistream
+public:
+
+
+	/*!
+		output to standard streams
 	*/
-	friend tt_istream & operator>>(tt_istream & s, Int<value_size> & l)
+	friend std::ostream & operator<<(std::ostream & s, const Int<value_size> & l)
 	{
-	tt_string ss;
+		return OutputToStream<std::ostream, std::string>(s, l);
+	}
+
+
+	/*!
+		output to standard streams
+	*/
+	friend std::wostream & operator<<(std::wostream & s, const Int<value_size> & l)
+	{
+		return OutputToStream<std::wostream, std::wstring>(s, l);
+	}
+
+
+
+private:
+
+	/*!
+		an auxiliary method for converting from a string
+	*/
+	template<class istream_type, class string_type, class char_type>
+	static istream_type & InputFromStream(istream_type & s, Int<value_size> & l)
+	{
+	string_type ss;
 	
-	// tt_char for operator>>
+	// char or wchar_t for operator>>
-	tt_char z;
+	char_type z;
 	
 		// operator>> omits white characters if they're set for ommiting
 		s >> z;
@@ -1318,10 +1505,10 @@ public:
 		}
 
 		// we're reading only digits (base=10)
-		while( s.good() && UInt<value_size>::CharToDigit(z, 10)>=0 )
+		while( s.good() && Misc::CharToDigit(z, 10)>=0 )
 		{
 			ss += z;
-			z = static_cast<tt_char>(s.get());
+			z = static_cast<char_type>(s.get());
 		}
 
 		// we're leaving the last readed character
@@ -1333,13 +1520,28 @@ public:
 	return s;
 	}
 
+
+public:
+
+	/*!
+		input from standard streams
+	*/
+	friend std::istream & operator>>(std::istream & s, Int<value_size> & l)
+	{
+		return InputFromStream<std::istream, std::string, char>(s, l);
+	}
+
+
+	/*!
+		input from standard streams
+	*/
+	friend std::wistream & operator>>(std::wistream & s, Int<value_size> & l)
+	{
+		return InputFromStream<std::wistream, std::wstring, wchar_t>(s, l);
+	}
+
 };
 
 } // namespace
 
-#if defined(_MSC_VER)
-	#pragma warning(default:4127) // conditional expression is constant
-#endif
-
-
 #endif

ttmath/ttmathmisc.h

@@ -0,0 +1,243 @@
+/*
+ * This file is a part of TTMath Bignum Library
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * 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 headerfilettmathmisc
+#define headerfilettmathmisc
+
+
+/*!
+	\file ttmathmisc.h
+    \brief some helpful functions
+*/
+
+
+#include <string>
+
+
+namespace ttmath
+{
+
+/*!
+	some helpful functions
+*/
+class Misc
+{
+public:
+
+
+/*
+ *
+ *	AssignString(result, str)
+ *	result = str
+ *
+ */
+
+/*!
+	result = str
+*/
+static void AssignString(std::string & result, const char * str)
+{
+	result = str;
+}
+
+
+/*!
+	result = str
+*/
+static void AssignString(std::wstring & result, const char * str)
+{
+	result.clear();
+
+	for( ; *str ; ++str )
+		result += *str;
+}
+
+
+/*!
+	result = str
+*/
+static void AssignString(std::wstring & result, const std::string & str)
+{
+	return AssignString(result, str.c_str());
+}
+
+
+/*!
+	result = str
+*/
+static void AssignString(std::string & result, const wchar_t * str)
+{
+	result.clear();
+
+	for( ; *str ; ++str )
+		result += static_cast<char>(*str);
+}
+
+
+/*!
+	result = str
+*/
+static void AssignString(std::string & result, const std::wstring & str)
+{
+	return AssignString(result, str.c_str());
+}
+
+
+/*
+ *
+ *	AddString(result, str)
+ *	result += str
+ *
+ */
+
+
+/*!
+	result += str
+*/
+static void AddString(std::string & result, const char * str)
+{
+	result += str;
+}
+
+
+/*!
+	result += str
+*/
+static void AddString(std::wstring & result, const char * str)
+{
+	for( ; *str ; ++str )
+		result += *str;
+}
+
+
+
+/*
+	this method omits any white characters from the string
+	char_type is char or wchar_t
+*/
+template<class char_type>
+static void SkipWhiteCharacters(const char_type * & c)
+{
+	// 13 is at the end in a DOS text file (\r\n)
+	while( (*c==' ' ) || (*c=='\t') || (*c==13 ) || (*c=='\n') )
+		++c;
+}
+
+
+
+
+/*!
+	this static method converts one character into its value
+
+	for example:
+		1 -> 1
+		8 -> 8
+		A -> 10
+		f -> 15
+
+	this method don't check whether c is correct or not
+*/
+static uint CharToDigit(uint c)
+{
+	if(c>='0' && c<='9')
+		return c-'0';
+
+	if(c>='a' && c<='z')
+		return c-'a'+10;
+
+return c-'A'+10;
+}
+
+
+/*!
+	this method changes a character 'c' into its value
+	(if there can't be a correct value it returns -1)
+
+	for example:
+	c=2, base=10 -> function returns 2
+	c=A, base=10 -> function returns -1
+	c=A, base=16 -> function returns 10
+*/
+static sint CharToDigit(uint c, uint base)
+{
+	if( c>='0' && c<='9' )
+		c=c-'0';
+	else
+	if( c>='a' && c<='z' )
+		c=c-'a'+10;
+	else
+	if( c>='A' && c<='Z' )
+		c=c-'A'+10;
+	else
+		return -1;
+
+
+	if( c >= base )
+		return -1;
+
+
+return sint(c);
+}
+
+
+
+/*!
+	this method converts a digit into a char
+	digit should be from <0,F>
+	(we don't have to get a base)
+	
+	for example:
+		1  -> 1
+		8  -> 8
+		10 -> A
+		15 -> F
+*/
+static uint DigitToChar(uint digit)
+{
+	if( digit < 10 )
+		return digit + '0';
+
+return digit - 10 + 'A';
+}
+
+
+}; // struct Misc
+
+}
+
+
+#endif

ttmath/ttmathobjects.h

@@ -44,13 +44,13 @@
     \brief Mathematic functions.
 */
 
-#include "ttmathtypes.h"
-
 #include <string>
 #include <vector>
 #include <list>
 #include <map>
 
+#include "ttmathtypes.h"
+#include "ttmathmisc.h"
 
 
 namespace ttmath
@@ -74,19 +74,19 @@ public:
 	struct Item
 	{
 		// name of a variable of a function
-		// (either std::string or std::wstring)
+		// internally we store variables and funcions as std::string (not std::wstring even when wide characters are used)
-		tt_string value;
+		std::string value;
 
 		// number of parameters required by the function
 		// (if there's a variable this 'param' is ignored)
 		int param;
 
 		Item() {}
-		Item(const tt_string & v, int p) : value(v), param(p) {}
+		Item(const std::string & v, int p) : value(v), param(p) {}
 	};
 
 	// 'Table' is the type of our table
-	typedef std::map<tt_string, Item> Table;
+	typedef std::map<std::string, Item> Table;
 	typedef	Table::iterator Iterator;
 	typedef	Table::const_iterator CIterator;
 
@@ -99,7 +99,7 @@ public:
 		if 'can_be_digit' is true that means when the 'c' is a digit this 
 		method returns true otherwise it returns false
 	*/
-	static bool CorrectCharacter(int c, bool can_be_digit)
+	static bool CorrectCharacter(wchar_t c, bool can_be_digit)
 	{
 		if( (c>='a' && c<='z') || (c>='A' && c<='Z') )
 			return true;
@@ -114,7 +114,8 @@ public:
 	/*!
 		this method returns true if the name can be as a name of an object
 	*/
-	static bool IsNameCorrect(const tt_string & name)
+	template<class string_type>
+	static bool IsNameCorrect(const string_type & name)
 	{
 		if( name.empty() )
 			return false;
@@ -122,7 +123,7 @@ public:
 		if( !CorrectCharacter(name[0], false) )
 			return false;
 
-		tt_string::const_iterator i=name.begin();
+		typename string_type::const_iterator i = name.begin();
 
 		for(++i ; i!=name.end() ; ++i)
 			if( !CorrectCharacter(*i, true) )
@@ -135,7 +136,7 @@ public:
 	/*!
 		this method returns true if such an object is defined (name exists)
 	*/
-	bool IsDefined(const tt_string & name)
+	bool IsDefined(const std::string & name)
 	{
 		Iterator i = table.find(name);
 
@@ -147,10 +148,26 @@ public:
 	}
 
 
+	/*!
+		this method returns true if such an object is defined (name exists)
+	*/
+	bool IsDefined(const std::wstring & name)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return false;
+
+		Misc::AssignString(str_tmp1, name);
+
+	return IsDefined(str_tmp1);
+	}
+
+
 	/*!
 		this method adds one object (variable of function) into the table
 	*/
-	ErrorCode Add(const tt_string & name, const tt_string & value, int param = 0)
+	ErrorCode Add(const std::string & name, const std::string & value, int param = 0)
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -167,6 +184,23 @@ public:
 	}
 
 
+	/*!
+		this method adds one object (variable of function) into the table
+	*/
+	ErrorCode Add(const std::wstring & name, const std::wstring & value, int param = 0)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+		Misc::AssignString(str_tmp2, value);
+		
+	return Add(str_tmp1, str_tmp2, param);
+	}
+
+
 	/*!
 		this method returns 'true' if the table is empty
 	*/
@@ -207,7 +241,7 @@ public:
 	/*!
 		this method changes the value and the number of parameters for a specific object
 	*/
-	ErrorCode EditValue(const tt_string & name, const tt_string & value, int param = 0)
+	ErrorCode EditValue(const std::string & name, const std::string & value, int param = 0)
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -224,10 +258,27 @@ public:
 	}
 
 
+	/*!
+		this method changes the value and the number of parameters for a specific object
+	*/
+	ErrorCode EditValue(const std::wstring & name, const std::wstring & value, int param = 0)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+		Misc::AssignString(str_tmp2, value);
+		
+	return EditValue(str_tmp1, str_tmp2, param);
+	}
+
+
 	/*!
 		this method changes the name of a specific object
 	*/
-	ErrorCode EditName(const tt_string & old_name, const tt_string & new_name)
+	ErrorCode EditName(const std::string & old_name, const std::string & new_name)
 	{
 		if( !IsNameCorrect(old_name) || !IsNameCorrect(new_name) )
 			return err_incorrect_name;
@@ -255,10 +306,27 @@ public:
 	}
 
 
+	/*!
+		this method changes the name of a specific object
+	*/
+	ErrorCode EditName(const std::wstring & old_name, const std::wstring & new_name)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(old_name) || !IsNameCorrect(new_name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, old_name);
+		Misc::AssignString(str_tmp2, new_name);
+
+	return EditName(str_tmp1, str_tmp2);
+	}
+
+
 	/*!
 		this method deletes an object
 	*/
-	ErrorCode Delete(const tt_string & name)
+	ErrorCode Delete(const std::string & name)
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -274,10 +342,26 @@ public:
 	}
 
 
+	/*!
+		this method deletes an object
+	*/
+	ErrorCode Delete(const std::wstring & name)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+
+	return Delete(str_tmp1);
+	}	
+		
+		
 	/*!
 		this method gets the value of a specific object
 	*/
-	ErrorCode GetValue(const tt_string & name, tt_string & value) const
+	ErrorCode GetValue(const std::string & name, std::string & value) const
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -296,11 +380,29 @@ public:
 	}
 
 
+	/*!
+		this method gets the value of a specific object
+	*/
+	ErrorCode GetValue(const std::wstring & name, std::wstring & value)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+		ErrorCode err = GetValue(str_tmp1, str_tmp2);
+		Misc::AssignString(value, str_tmp2);
+
+	return err;
+	}
+
+
 	/*!
 		this method gets the value of a specific object
 		(this version is used for not copying the whole string)
 	*/
-	ErrorCode GetValue(const tt_string & name, const tt_char ** value) const
+	ErrorCode GetValue(const std::string & name, const char ** value) const
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -319,11 +421,28 @@ public:
 	}
 
 
+	/*!
+		this method gets the value of a specific object
+		(this version is used for not copying the whole string)
+	*/
+	ErrorCode GetValue(const std::wstring & name, const char ** value)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+
+	return GetValue(str_tmp1, value);
+	}
+
+
 	/*!
 		this method gets the value and the number of parameters
 		of a specific object
 	*/
-	ErrorCode GetValueAndParam(const tt_string & name, tt_string & value, int * param) const
+	ErrorCode GetValueAndParam(const std::string & name, std::string & value, int * param) const
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -344,12 +463,31 @@ public:
 	}
 
 
+	/*!
+		this method gets the value and the number of parameters
+		of a specific object
+	*/
+	ErrorCode GetValueAndParam(const std::wstring & name, std::wstring & value, int * param)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+		ErrorCode err = GetValueAndParam(str_tmp1, str_tmp2, param);
+		Misc::AssignString(value, str_tmp2);
+
+	return err;
+	}
+
+
 	/*!
 		this method sets the value and the number of parameters
 		of a specific object
 		(this version is used for not copying the whole string)
 	*/
-	ErrorCode GetValueAndParam(const tt_string & name, const tt_char ** value, int * param) const
+	ErrorCode GetValueAndParam(const std::string & name, const char ** value, int * param) const
 	{
 		if( !IsNameCorrect(name) )
 			return err_incorrect_name;
@@ -370,6 +508,25 @@ public:
 	}
 
 
+	/*!
+		this method sets the value and the number of parameters
+		of a specific object
+		(this version is used for not copying the whole string
+		but in fact we make one copying during AssignString())
+	*/
+	ErrorCode GetValueAndParam(const std::wstring & name, const char ** value, int * param)
+	{
+		// we should check whether the name (in wide characters) are correct
+		// before calling AssignString() function
+		if( !IsNameCorrect(name) )
+			return err_incorrect_name;
+
+		Misc::AssignString(str_tmp1, name);
+
+	return GetValueAndParam(str_tmp1, value, param);
+	}
+
+
 	/*!
 		this method returns a pointer into the table
 	*/
@@ -382,6 +539,7 @@ public:
 private:
 
 	Table table;
+	std::string str_tmp1, str_tmp2;
 
 }; // end of class Objects
 
@@ -428,7 +586,7 @@ public:
 	
 	/*!
 		default constructor
-		default max size of the History's container is 10 items
+		default max size of the History's container is 15 items
 	*/
 	History()
 	{
@@ -591,8 +749,8 @@ struct CGamma
 		you don't have to call this method, these coefficients will be automatically calculated
 		when they are needed
 
-		you must note that calculating of the coefficients is a little time-consuming operation,
+		you must note that calculating these coefficients is a little time-consuming operation,
-		(especially when the mantissa is large) and first called to Gamma() or Factorial()
+		(especially when the mantissa is large) and first call to Gamma() or Factorial()
 		can take more time than next calls, and in the end this is the point when InitAll()
 		comes in handy: you can call this method somewhere at the beginning of your program
 	*/

ttmath/ttmaththreads.h

@@ -0,0 +1,250 @@
+/*
+ * This file is a part of TTMath Bignum Library
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * 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 headerfilettmaththreads
+#define headerfilettmaththreads
+
+#include "ttmathtypes.h"
+
+#ifdef TTMATH_WIN32_THREADS
+#include <windows.h>
+#include <cstdio>
+#endif
+
+#ifdef TTMATH_POSIX_THREADS
+#include <pthread.h>
+#endif
+
+
+
+/*!
+	\file ttmaththreads.h
+    \brief Some objects used in multithreads environment
+*/
+
+
+/*
+	this is a simple skeleton of a program in multithreads environment:
+
+	#define TTMATH_MULTITHREADS
+	#include<ttmath/ttmath.h>
+	
+	TTMATH_MULTITHREADS_HELPER
+
+	int main()
+	{
+	[...]
+	}
+
+	make sure that macro TTMATH_MULTITHREADS is defined and (somewhere in *.cpp file)
+	use TTMATH_MULTITHREADS_HELPER macro (outside of any classes/functions/namespaces scope)
+*/
+
+
+namespace ttmath
+{
+
+
+#ifdef TTMATH_WIN32_THREADS
+
+	/*
+		we use win32 threads
+	*/
+
+
+	/*!
+		in multithreads environment you should use TTMATH_MULTITHREADS_HELPER macro
+		somewhere in *.cpp file
+
+		(at the moment in win32 this macro does nothing)
+	*/
+	#define TTMATH_MULTITHREADS_HELPER
+
+
+	/*!
+		objects of this class are used to synchronize
+	*/
+	class ThreadLock
+	{
+		HANDLE mutex_handle;
+
+
+		void CreateName(char * buffer) const
+		{
+			#ifdef _MSC_VER
+			#pragma warning (disable : 4996)
+			// warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead.
+			#endif
+
+			sprintf(buffer, "TTMATH_LOCK_%ul", (unsigned long)GetCurrentProcessId());
+
+			#ifdef _MSC_VER
+			#pragma warning (default : 4996)
+			#endif
+		}
+
+
+	public:
+
+		bool Lock()
+		{
+		char buffer[50];
+
+			CreateName(buffer);
+			mutex_handle = CreateMutexA(0, false, buffer);
+
+			if( mutex_handle == 0 )
+				return false;
+
+			WaitForSingleObject(mutex_handle, INFINITE);
+
+		return true;
+		}
+
+
+		ThreadLock()
+		{
+			mutex_handle = 0;
+		}
+
+
+		~ThreadLock()
+		{
+			if( mutex_handle != 0 )
+			{
+				ReleaseMutex(mutex_handle);
+				CloseHandle(mutex_handle);
+			}
+		}
+	};
+
+#endif  // #ifdef TTMATH_WIN32_THREADS
+
+
+
+
+
+#ifdef TTMATH_POSIX_THREADS
+
+	/*
+		we use posix threads
+	*/
+
+
+	/*!
+		in multithreads environment you should use TTMATH_MULTITHREADS_HELPER macro
+		somewhere in *.cpp file
+		(this macro defines a pthread_mutex_t object used by TTMath library)
+	*/
+	#define TTMATH_MULTITHREADS_HELPER                          \
+	namespace ttmath                                            \
+	{                                                           \
+	pthread_mutex_t ttmath_mutex = PTHREAD_MUTEX_INITIALIZER;   \
+	}
+
+
+	/*!
+		ttmath_mutex will be defined by TTMATH_MULTITHREADS_HELPER macro 
+	*/
+	extern pthread_mutex_t ttmath_mutex;
+
+
+	/*!
+		objects of this class are used to synchronize
+	*/
+	class ThreadLock
+	{
+	public:
+
+		bool Lock()
+		{
+			if( pthread_mutex_lock(&ttmath_mutex) != 0 )
+				return false;
+
+		return true;
+		}
+
+
+		~ThreadLock()
+		{
+			pthread_mutex_unlock(&ttmath_mutex);
+		}
+	};
+
+#endif // #ifdef TTMATH_POSIX_THREADS
+
+
+
+
+#if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS)
+
+	/*!
+		we don't use win32 and pthreads
+	*/
+
+	/*!
+	*/
+	#define TTMATH_MULTITHREADS_HELPER
+
+
+	/*!
+		objects of this class are used to synchronize
+		actually we don't synchronize, the method Lock() returns always 'false'
+	*/
+	class ThreadLock
+	{
+	public:
+
+		bool Lock()
+		{
+			return false;
+		}
+	};
+
+
+#endif // #if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS)
+
+
+
+
+
+} // namespace
+
+#endif
+

ttmath/ttmathuint_noasm.h

@@ -41,8 +41,6 @@
 
 #ifdef TTMATH_NOASM
 
-#pragma message("TTMATH_NOASM")
-
 /*!
 	\file ttmathuint_noasm.h
     \brief template class UInt<uint> with methods without any assembler code
@@ -53,6 +51,56 @@
 
 namespace ttmath
 {
+
+	/*!
+		returning the string represents the currect type of the library
+		we have following types:
+		  asm_vc_32   - with asm code designed for Microsoft Visual C++ (32 bits)
+		  asm_gcc_32  - with asm code designed for GCC (32 bits)
+		  asm_vc_64   - with asm for VC (64 bit)
+		  asm_gcc_64  - with asm for GCC (64 bit)
+		  no_asm_32   - pure C++ version (32 bit) - without any asm code
+		  no_asm_64   - pure C++ version (64 bit) - without any asm code
+	*/
+	template<uint value_size>
+	const char * UInt<value_size>::LibTypeStr()
+	{
+		#ifdef TTMATH_PLATFORM32
+			static const char info[] = "no_asm_32";
+		#endif		
+
+		#ifdef TTMATH_PLATFORM64
+			static const char info[] = "no_asm_64";
+		#endif
+
+	return info;
+	}
+
+	
+	/*!
+		returning the currect type of the library
+	*/
+	template<uint value_size>
+	LibTypeCode UInt<value_size>::LibType()
+	{
+		#ifdef TTMATH_PLATFORM32
+			LibTypeCode info = no_asm_32;
+		#endif		
+
+		#ifdef TTMATH_PLATFORM64
+			LibTypeCode info = no_asm_64;
+		#endif
+
+	return info;
+	}
+
+
+	/*!
+		this method adds two words together
+		returns carry
+
+		this method is created only when TTMATH_NOASM macro is defined
+	*/
 	template<uint value_size>
 	uint UInt<value_size>::AddTwoWords(uint a, uint b, uint carry, uint * result)
 	{
@@ -97,7 +145,7 @@ namespace ttmath
 		for(i=0 ; i<value_size ; ++i)
 			c = AddTwoWords(table[i], ss2.table[i], c, &table[i]);
 
-		TTMATH_LOG("UInt::Add")
+		TTMATH_LOGC("UInt::Add", c)
 	
 	return c;
 	}
@@ -133,7 +181,7 @@ namespace ttmath
 		for(i=index+1 ; i<value_size && c ; ++i)
 			c = AddTwoWords(table[i], 0, c, &table[i]);
 
-		TTMATH_LOG("UInt::AddInt")
+		TTMATH_LOGC("UInt::AddInt", c)
 	
 	return c;
 	}
@@ -186,7 +234,7 @@ namespace ttmath
 		for(i=index+2 ; i<value_size && c ; ++i)
 			c = AddTwoWords(table[i], 0, c, &table[i]);
 
-		TTMATH_LOG("UInt::AddTwoInts")
+		TTMATH_LOGC("UInt::AddTwoInts", c)
 	
 	return c;
 	}
@@ -226,7 +274,7 @@ namespace ttmath
 		for( ; i<ss1_size ; ++i)
 			c = AddTwoWords(ss1[i], 0, c, &result[i]);
 
-		TTMATH_LOG("UInt::AddVector")
+		TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size)
 
 	return c;
 	}
@@ -234,6 +282,12 @@ namespace ttmath
 
 
 
+	/*!
+		this method subtractes one word from the other
+		returns carry
+
+		this method is created only when TTMATH_NOASM macro is defined
+	*/
 	template<uint value_size>
 	uint UInt<value_size>::SubTwoWords(uint a, uint b, uint carry, uint * result)
 	{
@@ -275,7 +329,7 @@ namespace ttmath
 		for(i=0 ; i<value_size ; ++i)
 			c = SubTwoWords(table[i], ss2.table[i], c, &table[i]);
 
-		TTMATH_LOG("UInt::Sub")
+		TTMATH_LOGC("UInt::Sub", c)
 
 	return c;
 	}
@@ -313,7 +367,7 @@ namespace ttmath
 		for(i=index+1 ; i<value_size && c ; ++i)
 			c = SubTwoWords(table[i], 0, c, &table[i]);
 
-		TTMATH_LOG("UInt::SubInt")
+		TTMATH_LOGC("UInt::SubInt", c)
 	
 	return c;
 	}
@@ -353,7 +407,7 @@ namespace ttmath
 		for( ; i<ss1_size ; ++i)
 			c = SubTwoWords(ss1[i], 0, c, &result[i]);
 
-		TTMATH_LOG("UInt::SubVector")
+		TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size)
 
 	return c;
 	}
@@ -387,7 +441,7 @@ namespace ttmath
 			c        = new_c;
 		}
 
-		TTMATH_LOG("UInt::Rcl2_one")
+		TTMATH_LOGC("UInt::Rcl2_one", c)
 
 	return c;
 	}
@@ -426,7 +480,7 @@ namespace ttmath
 			c        = new_c;
 		}
 
-		TTMATH_LOG("UInt::Rcr2_one")
+		TTMATH_LOGC("UInt::Rcr2_one", c)
 
 	return c;
 	}
@@ -464,7 +518,7 @@ namespace ttmath
 			c        = new_c;
 		}
 
-		TTMATH_LOG("UInt::Rcl2")
+		TTMATH_LOGC("UInt::Rcl2", c)
 
 	return (c & 1);
 	}
@@ -503,7 +557,7 @@ namespace ttmath
 			c        = new_c;
 		}
 
-		TTMATH_LOG("UInt::Rcr2")
+		TTMATH_LOGC("UInt::Rcr2", c)
 
 	return (c & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
 	}
@@ -511,10 +565,9 @@ namespace ttmath
 
 
 
-	/*
+	/*!
 		this method returns the number of the highest set bit in x
 		if the 'x' is zero this method returns '-1'
-
 	*/
 	template<uint value_size>
 	sint UInt<value_size>::FindLeadingBitInWord(uint x)
@@ -541,7 +594,7 @@ namespace ttmath
 		this method sets a special bit in the 'value'
 		and returns the last state of the bit (zero or one)
 
-		bit is from <0,63>
+		bit is from <0,TTMATH_BITS_PER_UINT-1>
 
 		e.g.
 		 uint x = 100;
@@ -555,7 +608,7 @@ namespace ttmath
 
 		uint mask = 1;
 
-		if( bit > 1 )
+		if( bit > 0 )
 			mask = mask << bit;
 
 		uint last = value & mask;
@@ -743,11 +796,11 @@ namespace ttmath
 			temp1.u_.high = a_.u_.low;
 			temp1.u_.low  = b_.u_.high;
 
-			res_.u_.high  = temp1.u / c;
+			res_.u_.high  = (unsigned int)(temp1.u / c);
-			temp2.u_.high = temp1.u % c;
+			temp2.u_.high = (unsigned int)(temp1.u % c);
 			temp2.u_.low  = b_.u_.low;
 			
-			res_.u_.low  = temp2.u / c;
+			res_.u_.low  = (unsigned int)(temp2.u / c);
 			*rest        = temp2.u % c;
 
 			*r = res_.u;

ttmath/ttmathuint_x86_64_msvc.asm

@@ -1,386 +1,548 @@
-PUBLIC	adc_x64
+;
-PUBLIC	addindexed_x64
+; This file is a part of TTMath Bignum Library
-PUBLIC	addindexed2_x64
+; and is distributed under the (new) BSD licence.
-
+; Author: Christian Kaiser <chk@online.de>
-PUBLIC	sbb_x64
+;
-PUBLIC	subindexed_x64
+
-
+; 
-PUBLIC	rcl_x64
+; Copyright (c) 2009, Christian Kaiser
-PUBLIC	rcr_x64
+; All rights reserved.
-
+; 
-PUBLIC	rcl2_x64
+; Redistribution and use in source and binary forms, with or without
-PUBLIC	rcr2_x64
+; modification, are permitted provided that the following conditions are met:
-
+; 
-PUBLIC	div_x64
+;  * Redistributions of source code must retain the above copyright notice,
-
+;    this list of conditions and the following disclaimer.
-;
+;    
-;	"rax, rcx, rdx, r8-r11 are volatile."
+;  * Redistributions in binary form must reproduce the above copyright
-;	"rbx, rbp, rdi, rsi, r12-r15 are nonvolatile."
+;    notice, this list of conditions and the following disclaimer in the
-;
+;    documentation and/or other materials provided with the distribution.
-
+;    
-.CODE
+;  * Neither the name Christian Kaiser nor the names of contributors to this
-
+;    project may be used to endorse or promote products derived
-        ALIGN       8
+;    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
-adc_x64				PROC
+; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-        ; rcx = p1
+; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-        ; rdx = p2
+; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-        ; r8 = nSize
+; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-        ; r9 = nCarry
+; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-
+; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-        xor		rax, rax
+; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-        xor		r11, r11
+; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-        sub		rax, r9		; sets CARRY if r9 != 0
+; THE POSSIBILITY OF SUCH DAMAGE.
-
+;
-		ALIGN 16
+
- loop1:
+;
-		mov		rax,qword ptr [rdx + r11 * 8]
+; compile with debug info:    ml64.exe /Zd /Zi ttmathuint_x86_64_msvc.asm
-		adc		qword ptr [rcx + r11 * 8], rax
+; compile without debug info: ml64.exe ttmathuint_x86_64_msvc.asm
-		lea		r11, [r11+1]
+; this create ttmathuint_x86_64_msvc.obj file which can be linked with your program
-		dec		r8
+;
-		jnz		loop1
+
-
+PUBLIC	ttmath_adc_x64
-		setc	al
+PUBLIC	ttmath_addindexed_x64
-		movzx	rax, al
+PUBLIC	ttmath_addindexed2_x64
-
+PUBLIC	ttmath_addvector_x64
-		ret
+
-
+PUBLIC	ttmath_sbb_x64
-adc_x64				ENDP
+PUBLIC	ttmath_subindexed_x64
-
+PUBLIC	ttmath_subvector_x64
-;----------------------------------------
+
-
+PUBLIC	ttmath_rcl_x64
-        ALIGN       8
+PUBLIC	ttmath_rcr_x64
-
+
-;----------------------------------------
+PUBLIC	ttmath_rcl2_x64
-
+PUBLIC	ttmath_rcr2_x64
-addindexed_x64	PROC
+
-
+PUBLIC	ttmath_div_x64
-        ; rcx = p1
+
-        ; rdx = nSize
+;
-        ; r8 = nPos
+; Microsoft x86_64 convention: http://msdn.microsoft.com/en-us/library/9b372w95.aspx
-        ; r9 = nValue
+;
-
+;	"rax, rcx, rdx, r8-r11 are volatile."
-		xor		rax, rax			; rax = result
+;	"rbx, rbp, rdi, rsi, r12-r15 are nonvolatile."
-		sub		rdx, r8				; rdx = remaining count of uints
+;
-
+
-		add		qword ptr [rcx + r8 * 8], r9
+
-		jc		next1
+.CODE
-
+
-		ret
+
-
+        ALIGN       8
-next1:
+
-		mov		r9, 1
+;----------------------------------------
-
+
-		ALIGN 16
+ttmath_adc_x64				PROC
-loop1:
+        ; rcx = p1
-		dec		rdx
+        ; rdx = p2
-		jz		done_with_cy
+        ; r8 = nSize
-		lea		r8, [r8+1]
+        ; r9 = nCarry
-		add		qword ptr [rcx + r8 * 8], r9
+
-		jc		loop1
+        xor		rax, rax
-
+        xor		r11, r11
-		ret
+        sub		rax, r9		; sets CARRY if r9 != 0
-
+
-done_with_cy:
+		ALIGN 16
-		lea		rax, [rax+1]		; rax = 1
+ loop1:
-
+		mov		rax,qword ptr [rdx + r11 * 8]
-		ret
+		adc		qword ptr [rcx + r11 * 8], rax
-
+		lea		r11, [r11+1]
-addindexed_x64	ENDP
+		dec		r8
-
+		jnz		loop1
-;----------------------------------------
+
-
+		setc	al
-        ALIGN       8
+		movzx	rax, al
-
+
-;----------------------------------------
+		ret
-
+
-addindexed2_x64	PROC
+ttmath_adc_x64				ENDP
-
+
-        ; rcx = p1 (pointer)
+;----------------------------------------
-        ; rdx = b  (value size)
+
-        ; r8 = nPos
+        ALIGN       8
-        ; r9 = nValue1
+
-        ; [esp+0x28] = nValue2
+;----------------------------------------
-
+
-		xor		rax, rax			; return value
+ttmath_addindexed_x64	PROC
-		mov		r11, rcx			; table
+
-		sub		rdx, r8				; rdx = remaining count of uints
+        ; rcx = p1
-		mov		r10, [esp+028h]		; r10 = nValue2
+        ; rdx = nSize
-
+        ; r8 = nPos
-		add		qword ptr [r11 + r8 * 8], r9
+        ; r9 = nValue
-		lea		r8, [r8+1]
+
-		lea		rdx, [rdx-1]
+		xor		rax, rax			; rax = result
-		adc		qword ptr [r11 + r8 * 8], r10
+		sub		rdx, r8				; rdx = remaining count of uints
-		jc		next
+
-		ret
+		add		qword ptr [rcx + r8 * 8], r9
-
+		jc		next1
-		ALIGN 16
+
-loop1:
+		ret
-		lea		r8, [r8+1]
+
-		add		qword ptr [r11 + r8 * 8], 1
+next1:
-		jc		next
+		mov		r9, 1
-		ret
+
-
+		ALIGN 16
-next:
+loop1:
-		dec		rdx					; does not modify CY too...
+		dec		rdx
-		jnz		loop1
+		jz		done_with_cy
-		lea		rax, [rax+1]
+		lea		r8, [r8+1]
-		ret
+		add		qword ptr [rcx + r8 * 8], r9
-
+		jc		loop1
-addindexed2_x64	ENDP
+
-
+		ret
-;----------------------------------------
+
-
+done_with_cy:
-        ALIGN       8
+		lea		rax, [rax+1]		; rax = 1
-
+
-;----------------------------------------
+		ret
-
+
-sbb_x64				PROC
+ttmath_addindexed_x64	ENDP
-
+
-        ; rcx = p1
+;----------------------------------------
-        ; rdx = p2
+
-        ; r8 = nCount
+        ALIGN       8
-        ; r9 = nCarry
+
-
+;----------------------------------------
-        xor		rax, rax
+
-        xor		r11, r11
+ttmath_addindexed2_x64	PROC
-        sub		rax, r9				; sets CARRY if r9 != 0
+
-
+        ; rcx = p1 (pointer)
-		ALIGN 16
+        ; rdx = b  (value size)
- loop1:
+        ; r8 = nPos
-		mov		rax,qword ptr [rdx + r11 * 8]
+        ; r9 = nValue1
-		sbb		qword ptr [rcx + r11 * 8], rax
+        ; [esp+0x28] = nValue2
-		lea		r11, [r11+1]
+
-		dec		r8
+		xor		rax, rax			; return value
-		jnz		loop1
+		mov		r11, rcx			; table
-
+		sub		rdx, r8				; rdx = remaining count of uints
-		setc	al
+		mov		r10, [esp+028h]		; r10 = nValue2
-		movzx	rax, al
+
-
+		add		qword ptr [r11 + r8 * 8], r9
-		ret
+		lea		r8, [r8+1]
-
+		lea		rdx, [rdx-1]
-sbb_x64				ENDP
+		adc		qword ptr [r11 + r8 * 8], r10
-
+		jc		next
-;----------------------------------------
+		ret
-
+
-        ALIGN       8
+		ALIGN 16
-
+loop1:
-;----------------------------------------
+		lea		r8, [r8+1]
-
+		add		qword ptr [r11 + r8 * 8], 1
-subindexed_x64	PROC
+		jc		next
-        ; rcx = p1
+		ret
-        ; rdx = nSize
+
-        ; r8 = nPos
+next:
-        ; r9 = nValue
+		dec		rdx					; does not modify CY too...
-
+		jnz		loop1
-		sub		rdx, r8				; rdx = remaining count of uints
+		lea		rax, [rax+1]
-
+		ret
-		ALIGN 16
+
-loop1:
+ttmath_addindexed2_x64	ENDP
-		sub		qword ptr [rcx + r8 * 8], r9
+
-		jnc		done
+
-
+
-		lea		r8, [r8+1]
+;----------------------------------------
-		mov		r9, 1
+
-		dec		rdx
+        ALIGN       8
-		jnz		loop1
+
-		jc		return_1	; most of the times, there will be NO carry (I hope)
+;----------------------------------------
-
+
-done:
+
-		xor		rax, rax
+ttmath_addvector_x64				PROC
-		ret
+        ; rcx = ss1
-
+        ; rdx = ss2
-  return_1:
+        ; r8 = ss1_size
-		mov		rax, 1
+        ; r9 = ss2_size
-		ret
+        ; [esp+0x28] = result
-
+
-subindexed_x64	ENDP
+		mov		r10, [esp+028h]
-
+		sub		r8, r9
-;----------------------------------------
+        xor		r11, r11				; r11=0, cf=0
-
+
-        ALIGN       8
+		ALIGN 16
-
+ loop1:
-;----------------------------------------
+		mov		rax, qword ptr [rcx + r11 * 8]
-
+		adc		rax, qword ptr [rdx + r11 * 8]
-rcl_x64	PROC
+		mov		qword ptr [r10 + r11 * 8], rax
-        ; rcx = p1
+		inc		r11
-        ; rdx = b
+		dec		r9
-        ; r8 = nLowestBit
+		jnz		loop1
-
+
-		mov		r11, rcx			; table
+		adc		r9, r9					; r9 has the cf state
-		xor		r10, r10
+
-		neg		r8					; CY set if r8 <> 0
+		or		r8, r8
-
+		jz		done
-		ALIGN 16
+
-loop1:
+		neg		r9						; setting cf from r9
-		rcl		qword ptr [r11 + r10 * 8], 1
+		mov		r9, 0					; don't use xor here (cf is used)
-		lea		r10, [r10+1]
+ loop2:
-		dec		rdx
+		mov		rax, qword ptr [rcx + r11 * 8]
-		jnz		loop1
+		adc		rax, r9
-
+		mov		qword ptr [r10 + r11 * 8], rax
-		setc	al
+		inc		r11
-		movzx	rax, al
+		dec		r8
-
+		jnz		loop2
-        ret
+
-
+		adc		r8, r8
-rcl_x64	ENDP
+		mov		rax, r8
-
+		
-;----------------------------------------
+		ret
-
+
-        ALIGN       8
+done:
-
+		mov		rax, r9
-;----------------------------------------
+		ret
-
+
-rcr_x64	PROC
+ttmath_addvector_x64				ENDP
-        ; rcx = p1
+
-        ; rdx = nSize
+
-        ; r8 = nLowestBit
+;----------------------------------------
-
+
-		xor		r10, r10
+        ALIGN       8
-		neg		r8					; CY set if r8 <> 0
+
-
+;----------------------------------------
-		ALIGN 16
+
-loop1:
+ttmath_sbb_x64				PROC
-		rcr		qword ptr -8[rcx + rdx * 8], 1
+
-		dec		rdx
+        ; rcx = p1
-		jnz		loop1
+        ; rdx = p2
-
+        ; r8 = nCount
-		setc	al
+        ; r9 = nCarry
-		movzx	rax, al
+
-
+        xor		rax, rax
-        ret
+        xor		r11, r11
-
+        sub		rax, r9				; sets CARRY if r9 != 0
-rcr_x64	ENDP
+
-
+		ALIGN 16
-;----------------------------------------
+ loop1:
-
+		mov		rax,qword ptr [rdx + r11 * 8]
-        ALIGN       8
+		sbb		qword ptr [rcx + r11 * 8], rax
-
+		lea		r11, [r11+1]
-;----------------------------------------
+		dec		r8
-
+		jnz		loop1
-div_x64	PROC
+
-
+		setc	al
-        ; rcx = &Hi
+		movzx	rax, al
-        ; rdx = &Lo
+
-        ; r8 = nDiv
+		ret
-
+
-        mov		r11, rcx
+ttmath_sbb_x64				ENDP
-        mov		r10, rdx
+
-
+;----------------------------------------
-        mov		rdx, qword ptr [r11]
+
-        mov		rax, qword ptr [r10]
+        ALIGN       8
-        div		r8
+
-        mov		qword ptr [r10], rdx ; remainder
+;----------------------------------------
-        mov		qword ptr [r11], rax ; value
+
-
+ttmath_subindexed_x64	PROC
-        ret
+        ; rcx = p1
-
+        ; rdx = nSize
-div_x64	ENDP
+        ; r8 = nPos
-
+        ; r9 = nValue
-;----------------------------------------
+
-
+		sub		rdx, r8				; rdx = remaining count of uints
-        ALIGN       8
+
-
+		ALIGN 16
-;----------------------------------------
+loop1:
-
+		sub		qword ptr [rcx + r8 * 8], r9
-rcl2_x64	PROC
+		jnc		done
-        ; rcx = p1
+
-        ; rdx = nSize
+		lea		r8, [r8+1]
-        ; r8 = bits
+		mov		r9, 1
-        ; r9 = c
+		dec		rdx
-
+		jnz		loop1
-        push	rbx
+
-
+		mov		rax, 1
-        mov		r10, rcx	; r10 = p1
+		ret
-        xor		rax, rax
+
-
+done:
-        mov		rcx, 64
+		xor		rax, rax
-        sub		rcx, r8
+		ret
-
+
-        mov		r11, -1
+ttmath_subindexed_x64	ENDP
-        shr		r11, cl		; r11 = mask
+
-
+
-		mov		rcx, r8		; rcx = count of bits
+
-
+;----------------------------------------
-		mov		rbx, rax	; rbx = old value = 0
+
-		or		r9, r9
+        ALIGN       8
-		cmovnz	rbx, r11	; if (c) then old value = mask
+
-
+;----------------------------------------
-        mov		r9, rax		; r9 = index (0..nSize-1)
+
-
+;	the same asm code as in addvector_x64 only two instructions 'adc' changed to 'sbb'
-		ALIGN 16
+
-loop1:
+ttmath_subvector_x64				PROC
-		rol		qword ptr [r10+r9*8], cl
+        ; rcx = ss1
-		mov		rax, qword ptr [r10+r9*8]
+        ; rdx = ss2
-		and		rax, r11
+        ; r8 = ss1_size
-		xor		qword ptr [r10+r9*8], rax
+        ; r9 = ss2_size
-		or		qword ptr [r10+r9*8], rbx
+        ; [esp+0x28] = result
-		mov		rbx, rax
+
-
+		mov		r10, [esp+028h]
-		lea		r9, [r9+1]
+		sub		r8, r9
-		dec		rdx
+        xor		r11, r11				; r11=0, cf=0
-
+
-		jnz		loop1
+		ALIGN 16
-
+ loop1:
-		and		rax, 1
+		mov		rax, qword ptr [rcx + r11 * 8]
-		pop		rbx
+		sbb		rax, qword ptr [rdx + r11 * 8]
-        ret
+		mov		qword ptr [r10 + r11 * 8], rax
-
+		inc		r11
-rcl2_x64	ENDP
+		dec		r9
-
+		jnz		loop1
-;----------------------------------------
+
-
+		adc		r9, r9					; r9 has the cf state
-        ALIGN       8
+
-
+		or		r8, r8
-;----------------------------------------
+		jz		done
-
+
-rcr2_x64	PROC
+		neg		r9						; setting cf from r9
-        ; rcx = p1
+		mov		r9, 0					; don't use xor here (cf is used)
-        ; rdx = nSize
+ loop2:
-        ; r8 = bits
+		mov		rax, qword ptr [rcx + r11 * 8]
-        ; r9 = c
+		sbb		rax, r9
-
+		mov		qword ptr [r10 + r11 * 8], rax
-        push	rbx
+		inc		r11
-        mov		r10, rcx	; r10 = p1
+		dec		r8
-        xor		rax, rax
+		jnz		loop2
-
+
-        mov		rcx, 64
+		adc		r8, r8
-        sub		rcx, r8
+		mov		rax, r8
-
+		
-        mov		r11, -1
+		ret
-        shl		r11, cl		; r11 = mask
+
-
+done:
-		mov		rcx, r8		; rcx = count of bits
+		mov		rax, r9
-
+		ret
-		mov		rbx, rax	; rbx = old value = 0
+
-		or		r9, r9
+ttmath_subvector_x64				ENDP
-		cmovnz	rbx, r11	; if (c) then old value = mask
+
-
+
-        mov		r9, rdx		; r9 = index (0..nSize-1)
+
-		lea		r9, [r9-1]
+
-
+;----------------------------------------
-		ALIGN 16
+
-loop1:
+        ALIGN       8
-		ror		qword ptr [r10+r9*8], cl
+
-		mov		rax, qword ptr [r10+r9*8]
+;----------------------------------------
-		and		rax, r11
+
-		xor		qword ptr [r10+r9*8], rax
+ttmath_rcl_x64	PROC
-		or		qword ptr [r10+r9*8], rbx
+        ; rcx = p1
-		mov		rbx, rax
+        ; rdx = b
-
+        ; r8 = nLowestBit
-		lea		r9, [r9-1]
+
-		dec		rdx
+		mov		r11, rcx			; table
-
+		xor		r10, r10
-		jnz		loop1
+		neg		r8					; CY set if r8 <> 0
-
+
-		rol		rax, 1
+		ALIGN 16
-		and		rax, 1
+loop1:
-		pop		rbx
+		rcl		qword ptr [r11 + r10 * 8], 1
-
+		lea		r10, [r10+1]
-        ret
+		dec		rdx
-
+		jnz		loop1
-rcr2_x64	ENDP
+
-
+		setc	al
-END
+		movzx	rax, al
+
+        ret
+
+ttmath_rcl_x64	ENDP
+
+;----------------------------------------
+
+        ALIGN       8
+
+;----------------------------------------
+
+ttmath_rcr_x64	PROC
+        ; rcx = p1
+        ; rdx = nSize
+        ; r8 = nLowestBit
+
+		xor		r10, r10
+		neg		r8					; CY set if r8 <> 0
+
+		ALIGN 16
+loop1:
+		rcr		qword ptr -8[rcx + rdx * 8], 1
+		dec		rdx
+		jnz		loop1
+
+		setc	al
+		movzx	rax, al
+
+        ret
+
+ttmath_rcr_x64	ENDP
+
+;----------------------------------------
+
+        ALIGN       8
+
+;----------------------------------------
+
+ttmath_div_x64	PROC
+
+        ; rcx = &Hi
+        ; rdx = &Lo
+        ; r8 = nDiv
+
+        mov		r11, rcx
+        mov		r10, rdx
+
+        mov		rdx, qword ptr [r11]
+        mov		rax, qword ptr [r10]
+        div		r8
+        mov		qword ptr [r10], rdx ; remainder
+        mov		qword ptr [r11], rax ; value
+
+        ret
+
+ttmath_div_x64	ENDP
+
+;----------------------------------------
+
+        ALIGN       8
+
+;----------------------------------------
+
+ttmath_rcl2_x64	PROC
+        ; rcx = p1
+        ; rdx = nSize
+        ; r8 = bits
+        ; r9 = c
+
+        push	rbx
+
+        mov		r10, rcx	; r10 = p1
+        xor		rax, rax
+
+        mov		rcx, 64
+        sub		rcx, r8
+
+        mov		r11, -1
+        shr		r11, cl		; r11 = mask
+
+		mov		rcx, r8		; rcx = count of bits
+
+		mov		rbx, rax	; rbx = old value = 0
+		or		r9, r9
+		cmovnz	rbx, r11	; if (c) then old value = mask
+
+        mov		r9, rax		; r9 = index (0..nSize-1)
+
+		ALIGN 16
+loop1:
+		rol		qword ptr [r10+r9*8], cl
+		mov		rax, qword ptr [r10+r9*8]
+		and		rax, r11
+		xor		qword ptr [r10+r9*8], rax
+		or		qword ptr [r10+r9*8], rbx
+		mov		rbx, rax
+
+		lea		r9, [r9+1]
+		dec		rdx
+
+		jnz		loop1
+
+		and		rax, 1
+		pop		rbx
+        ret
+
+ttmath_rcl2_x64	ENDP
+
+;----------------------------------------
+
+        ALIGN       8
+
+;----------------------------------------
+
+ttmath_rcr2_x64	PROC
+        ; rcx = p1
+        ; rdx = nSize
+        ; r8 = bits
+        ; r9 = c
+
+        push	rbx
+        mov		r10, rcx	; r10 = p1
+        xor		rax, rax
+
+        mov		rcx, 64
+        sub		rcx, r8
+
+        mov		r11, -1
+        shl		r11, cl		; r11 = mask
+
+		mov		rcx, r8		; rcx = count of bits
+
+		mov		rbx, rax	; rbx = old value = 0
+		or		r9, r9
+		cmovnz	rbx, r11	; if (c) then old value = mask
+
+        mov		r9, rdx		; r9 = index (0..nSize-1)
+		lea		r9, [r9-1]
+
+		ALIGN 16
+loop1:
+		ror		qword ptr [r10+r9*8], cl
+		mov		rax, qword ptr [r10+r9*8]
+		and		rax, r11
+		xor		qword ptr [r10+r9*8], rax
+		or		qword ptr [r10+r9*8], rbx
+		mov		rbx, rax
+
+		lea		r9, [r9-1]
+		dec		rdx
+
+		jnz		loop1
+
+		rol		rax, 1
+		and		rax, 1
+		pop		rbx
+
+        ret
+
+ttmath_rcr2_x64	ENDP
+
+END