changed version: 0.8.6 now

git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@222 e52654a7-88a9-db11-a3e9-0013d4bc506e

CHANGELOG

@@ -1,122 +1,369 @@
+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):
+    * fixed:   Big::Mod(x) didn't correctly return a carry
+               and the result was sometimes very big (even greater than x)
+    * fixed:   global function Mod(x) didn't set an ErrorCode object
+    * fixed:   global function Round() didn't test a carry
+               now it sets ErrorCode object
+    * changed: function Sin(x) to Sin(x, ErrorCode * err=0)
+               when x was very big the function returns zero
+               now it sets ErrorCode object to err_overflow
+               and the result has a NaN flag set
+               the same is to Cos() function
+    * changed: PrepareSin(x) is using Big::Mod() now when reducing 2PI period
+               should be a little accurate especially on a very big 'x'
+    * changed: uint Mul(const UInt<value_size> & ss2, uint algorithm = 100)
+               void MulBig(const UInt<value_size> & ss2, UInt<value_size*2> & result, uint algorithm = 100)
+               those methods by default use MulFastest() and MulFastestBig()
+    * changed: changed a little Mul2Big() to cooperate with Mul3Big()
+    * added:   uint UInt::Mul3(const UInt<value_size> & ss2)
+               void UInt::Mul3Big(const UInt<value_size> & ss2, UInt<value_size*2> & result)
+               a new multiplication algorithm: Karatsuba multiplication,
+               on a vector UInt<100> with all items different from zero this algorithm is faster
+               about 3 times than Mul2Big(), and on a vector UInt<1000> with all items different from
+               zero this algorithm is faster more than 5 times than Mul2Big()
+               (measured on 32bit platform with GCC 4.3.3 with -O3 and -DTTMATH_RELEASE)
+    * added:   uint MulFastest(const UInt<value_size> & ss2)
+               void MulFastestBig(const UInt<value_size> & ss2, UInt<value_size*2> & result)
+               those methods are trying to select the fastest multiplication algorithm
+    * added:   uint AddVector(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result)
+               uint SubVector(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result)
+               three forms: asm x86, asm x86_64, no-asm
+               those methods are used by the Karatsuba multiplication algorithm
+    * added:   to Big<> class: support for NaN flag (Not a Number)
+               bool Big::IsNan() - returns true if the NaN flag is set
+               void Big::SetNan() - sets the NaN flag
+               The NaN flag is set by default after creating an object:
+                 Big<1, 2> a;    // NaN is set (it means the object has not a valid number)
+                 std::cout << a; // cout gives "NaN"
+                 a = 123;        // now NaN is not set
+                 std::cout << a; // cout gives "123"
+               The NaN is set if there was a carry during calculations
+                 a.Mul(very_big_value); // a will have a NaN set
+               The NaN is set if an argument is NaN too
+                 b.SetNan();
+                 a.Add(b);  // a will have NaN because b has NaN too
+               If you try to do something on a NaN object, the result is a NaN too
+                 a.SetNan();
+                 a.Add(2);  // a is still a NaN 
+               The NaN is set if you use incorrect arguments
+                 a.Ln(-10); // a will have the NaN flag
+               The only way to clear the NaN flag is to assign a correct value or other correct object,
+               supposing 'a' has NaN flag, to remove the flag you can either:
+                 a = 10;
+                 a.FromInt(30);
+                 a.SetOne(); 
+                 a.FromBig(other_object_without_nan);
+                 etc.
+               
+               
+Version 0.8.4 (2009.05.08):
+    * fixed:   UInt::DivInt() didn't check whether the divisor is zero
+               there was a hardware interruption when the divisor was zero
+               (now the method returns one)
+    * fixed:   the problem with GCC optimization on x86_64
+               sometimes when using -O2 or -O3 GCC doesn't set correctly
+               the stack pointer (actually the stack is used for other things)
+               and you can't use instructions like push/pop in assembler code.
+               All the asm code in x86_64 have been rewritten, now instructions
+               push/pop are not used, other thing which have access to stack 
+               (like "m" (mask) constraints in Rcl2 and Rcr2) have also gone away,
+               now the library works well with -O2 and -O3 and the asm code
+               is a little faster
+    * added:   UInt::PrintLog(const char * msg, std::ostream & output)
+               used (for debugging purposes) by macro TTMATH_LOG(msg)
+               (it is used in nearly all methods in UInt class)
+    * added:   macro TTMATH_DEBUG_LOG: when defined then TTMATH_LOG() 
+               put some debug information (to std::cout)
+    * added:   ttmathuint_x86.h, ttmathuint_x86_64.h, ttmathuint_noasm.h, 
+               all the methods which are using assembler code have been 
+               rewritten to no-asm forms, now we have:
+               1. asm for x86      file: ttmathuint_x86.h
+               2. asm for x86_64   file: ttmathuint_x86_64.h
+               3. no asm           file: ttmathuint_noasm.h
+                  (it's used when macro TTMATH_NOASM is defined)
+               The third form can be used on x86 and x86_64 as well and
+               on other platforms with a little effort.
+                              
+
+Version 0.8.3 (2009.04.06):
+    * fixed:   RclMoveAllWords() and RcrMoveAllWords() sometimes didn't return
+               the proper carry, (when 'bits' was greater than or equal to 'value_size')
+               this had impact on Rcl() and Rcr(), they also returned the wrong carry	
+    * fixed:   UInt::Div() didn't return a correct result when the divisor was equal 1
+               there was an error in UInt::DivInt() - when the divisor was 1 it returned
+               zero and the carry was set
+    * fixed:   there was a TTMATH_REREFENCE_ASSERT error in Big::PowUInt() caused by: start.Mul(start)
+    * fixed:   Big::Add incorrectly rounded 'this' when both exponents were equal
+               it caused that sometimes when adding a zero the result has changed
+               this had impact among other things on FromString() method
+               "0,8" had different binary representation from "0,80"
+    * fixed:   template Big::FromBig(const Big<another_exp, another_man> & another)
+               didn't correctly set the exponent (when the mantisses had different size -
+               when 'man' was different from 'another_man')
+               this had impact on operator= too
+               sample:
+               Big<2,3> a = 100;
+               Big<3,5> b;
+               b = a; // b had a wrong value
+    * fixed:   Big::Pow(const Big<exp, man> & pow)
+               it's using PowInt() only when pow.exponent is in range (-man*TTMATH_BITS_PER_UINT; 0]
+               previously the powering 'hung' on an input like this: "(1+ 1e-10000) ^ 10e100000000"
+               (there was 10e100000000 iterations in PowInt())
+    * fixed:   in function DegToRad(const ValueType & x, ErrorCode * err = 0) it is better
+               to make division first and then mutliplication -- the result is more
+               accurate especially when x is: 90,180,270 or 360
+    * fixed:   the parser didn't correctly treat operators for changing the base
+               (radix) -- operators '#' and '&', e.g.:
+               '#sin(1)' was equal '0' -- there was a zero from '#' and then
+               it was multipied by 'sin(1)'
+               the parser didn't check whether Big::FromString() has actually
+               read a proper value -- the method Big::FromString() didn't have
+               something to report such a situation
+    * fixed:   Big::FromString() when the base is 10, the method reads the scientific
+               part only if such a part it correctly supplied, e.g:
+               '1234e10', '1234e+10', '1234e-5'
+               previous '1234e' was treated as: '1234e0' (now parsing stops on 'e' and
+               the 'e' can be parsed by other parsers, e.g. the mathematical
+               parser -- now in the parser would be: '1234e' = '1234 * e' = '3354,3597...' )
+    * changed: renamed: Big::PowUInt(UInt<pow_size> pow) -> Big::Pow(UInt<pow_size> pow)
+               it returns 2 when there is: 0^0
+    * changed: renamed: Big::PowInt(Int<pow_size> pow) -> Big::Pow(Int<pow_size> pow)
+               it returns 2 when there is: 0^0 or 0^(-something)
+    * changed: renamed: Big::PowBUInt() -> PowUInt(), Big::PowBInt() -> Big::PowInt()
+               they return 2 when the arguments are incorrect (like above)
+    * changed: UInt::SetBitInWord(uint & value, uint bit) is taking the first argument by a reference now,
+               the specific bit is set in the 'value' and the method returns the last state of the bit (zero or one)
+    * changed: UInt::SetBit(uint bit_index) - it's using TTMATH_ASSERT now
+    * changed: the size of built-in variables (constants) in ttmathbig.h
+               now they consist of 256 32bit words
+               macro TTMATH_BUILTIN_VARIABLES_SIZE is equal: 256u on a 32bit platform and 128ul on a 64bit platform
+    * changed: the asm code in ttmathuint.h and ttmathuint64.h has been completely rewritten
+               now UInt<> is faster about 15-30% than UInt<> from 0.8.2
+               this has impact on Big<> too - it's faster about 10% now
+    * changed: in the parser: the form with operators '#' and '&' is as follows:
+               [-|+][#|&]numeric_value
+               previous was: [-|+][#|&][-|+]numeric_value
+    * changed: in the parser: the short form of multiplication has the same
+               priority as the normal multiplication, e.g.:
+               '2x^3' = 2 * (x^3)
+               previous the priority was greater than powering priority
+               previous: '2x^3' = (2*x) ^ 3
+    * added:   UInt::GetBit(uint bit_index) - returning the state of the specific bit
+    * added:   Big::operator=(double) and Big::Big(double)
+    * added:   UInt::Pow(UInt<value_size> pow) and Int::Pow(Int<value_size> pow)
+    * added:   global template functions in ttmath.h:
+               ValueType GradToRad(const ValueType & x, ErrorCode * err = 0)
+               ValueType RadToGrad(const ValueType & x, ErrorCode * err = 0)
+               ValueType DegToGrad(const ValueType & x, ErrorCode * err = 0)
+               ValueType DegToGrad(const ValueType & d, const ValueType & m,
+                                   const ValueType & s, ErrorCode * err = 0)
+               ValueType GradToDeg(const ValueType & x, ErrorCode * err = 0)
+    * added:   Parser::SetDegRadGrad(int angle) - 0 deg, 1 rad (default), 2 grad
+               this affects following functions (in the parser only): sin, cos, tan, cot,
+               asin, acos, atan, acot
+    * added:   functions to the parser: gradtorad(grad), radtograd(rad), degtograd(deg),
+               degtograd(d,m,s), gradtodeg(grad)
+    * added:   UInt::FromString, added a parametr 'after_source'
+               which is pointing at the end of the parsed string
+    * added:   Int::FromString(): parameter 'const char ** after_source = 0'
+               if exists it's pointing at the end of the parsed string
+    * added:   to UInt::FromString(), Int::FromString(), Big::FromString():
+               parameter 'bool * value_read = 0' - (if exists) tells
+               whether something has actually been read (at least one digit)
+    * added:   Objects::IsDefined(const std::string & name)
+               returning true if such an object is defined
+    * removed: Big::FromString() this method doesn't longer recognize operators
+               for changing the base ('#' and '&')
+
+
+Version 0.8.2 (2008.06.18):
+    * added:   UInt::BitNot2() this method has been proposed by
+               Arek <kmicicc AnTispam users.sourceforge.net>
+    * changed: Int::FromInt(const Int<argument_size> & p), 
+               Int::FromInt(sint value) (it returns zero now)
+               Int::operator=(uint i)
+               Int::Int(uint i)
+    * added:   Int::FromUInt(const UInt<argument_size> & p),
+               Int::FromUInt(uint value)
+               and appropriate constructors and assignment 
+               operators as well
+    * changed: Big::FromInt(Int<int_size> value),
+    * added:   Big::FromUInt(UInt<int_size> value),
+               Big::operator=(const UInt<int_size> & value)
+               Big::Big(const UInt<int_size> & value)
+    * changed: the parser is allowed to recognize values which
+               begin with a dot, e.g '.5' is treated as '0.5'
+    * added:   a method Big::FromDouble(double) which converts from
+               standard double into a Big
+    * added:   uint Big::ToDouble(double&) - converting into double
+    * added:   Big::FromBig() and an operator= and a contructor
+               for converting from another kind of a Big class
+    * added:   to the parser: avg(), sum()
+    * added:   'decimal_point' parameter into Big::ToString(...)
+    * fixed:   Big::operator>> didn't use TTMATH_COMMA_CHARACTER_2 macro
+    * added:   a short form of multiplication (without the '*' character)
+               e.g. '5y', (it's used only if the second parameter
+               is a variable or function)
+    * changed: variables and functions are case-sensitive now
+    * added:   variables and functions can have underline characters
+               in their names
+    * changed: 'max_digit_after_comma' in Big::ToString()
+               remove the -2 state
+    * added:   'remove_trailing_zeroes' in Big::ToString()
+               it's either true or false
+    * fixed/changed: the way of using Big::SetSign()
+               the method do not check whether there is a zero or not now
+               (even if there's a zero the method can set a sign bit)
+               I changed this due to some prior errors
+               (errors corrected in revision 17, 49 and 58)
+
+
 Version 0.8.1 (2007.04.17):
-	* fixed: Big::PowFrac(..) didn't return a correct error code
-	  (when 'this' was negative)
-	* added: Root(x; index) (and to the parser as well)
-	* added: macro: TTMATH_PRERELEASE_VER (can be either zero or one)
-	* added: UInt::MulInt(int, UInt<int another_size>::&)
-	* added: Big::MulUInt(uint)
-	* changed: Big::MulInt(sint)
-	* added: Big::ToUInt(uint &)
-	* changed: Big::ToInt(sint&)
-	* changed: Factorial() it uses Big::MulUInt() at the beginning
-	  (faster now especially more on a 32bit platform)
-	* added: doxygen.cfg for generating a documentation from the doxygen
-	* changed: UInt::Rcl(uint c=0) and UInt::Rcr(uint c=0) into
-	  UInt::Rcl2(uint bits, uint c) and UInt::Rcr2(uint bits, uint c)
-	  now they can move more than one bit and they are only private
-	* fixed: UInt::Rcl(uint bits, uint c) and UInt::Rcr(uint bits, uint c)
-	  didn't correctly return a carry if the 'bits' were equal
-	  to 'value_size*TTMATH_BITS_PER_UINT'
-	* changed: UInt::Rcl(uint bits, uint c) and UInt::Rcr(uint bits, uint c)
-	  into UInt::Rcl(uint bits, uint c=0) and
-	  UInt::Rcr(uint bits, uint c=0)
-	  they are faster now when the bits is greater than a half of
-	  the TTMATH_BITS_PER_UINT
-	* changed: UInt::CompensationToLeft() it's faster now
-	* changed: more small changes where there were UInt::Rcl(uint c=0) and
-	  UInt::Rcr(uint c=0) used
-	* changed: as the Big type uses UInt::Rcl() and UInt::Rcr() a lot then
-	  it is much faster now (about 5-25%)
-	* added: ASinh(), ACosh(), ATanh() /ATgh()/, ACoth() /ACtgh()/
-	  and to the parser as well
-	* added: UInt::BitAnd(), UInt::BitOr(), UInt::BitXor(), UInt::BitNot(),
-	  Big::BitAnd(), Big::BitOr(), Big::BitXor()
-	* added: to the parser: bitand(), bitor(), bitxor()
-	  /band(), bor(), bxor()/
-	* changed: the way of parsing operators in the mathematical parser
-	  (the parser is not too much greedy now)
+    * fixed:   Big::PowFrac(..) didn't return a correct error code
+               (when 'this' was negative)
+    * added:   Root(x; index) (and to the parser as well)
+    * added:   macro: TTMATH_PRERELEASE_VER (can be either zero or one)
+    * added:   UInt::MulInt(int, UInt<int another_size>::&)
+    * added:   Big::MulUInt(uint)
+    * changed: Big::MulInt(sint)
+    * added:   Big::ToUInt(uint &)
+    * changed: Big::ToInt(sint&)
+    * changed: Factorial() it uses Big::MulUInt() at the beginning
+               (faster now especially more on a 32bit platform)
+    * added:   doxygen.cfg for generating a documentation from the doxygen
+    * changed: UInt::Rcl(uint c=0) and UInt::Rcr(uint c=0) into
+               UInt::Rcl2(uint bits, uint c) and UInt::Rcr2(uint bits, uint c)
+               now they can move more than one bit and they are only private
+    * fixed:   UInt::Rcl(uint bits, uint c) and UInt::Rcr(uint bits, uint c)
+               didn't correctly return a carry if the 'bits' were equal
+               to 'value_size*TTMATH_BITS_PER_UINT'
+    * changed: UInt::Rcl(uint bits, uint c) and UInt::Rcr(uint bits, uint c)
+               into UInt::Rcl(uint bits, uint c=0) and
+               UInt::Rcr(uint bits, uint c=0)
+               they are faster now when the bits is greater than a half of
+               the TTMATH_BITS_PER_UINT
+    * changed: UInt::CompensationToLeft() it's faster now
+    * changed: more small changes where there were UInt::Rcl(uint c=0) and
+               UInt::Rcr(uint c=0) used
+    * changed: as the Big type uses UInt::Rcl() and UInt::Rcr() a lot then
+               it is much faster now (about 5-25%)
+    * added:   ASinh(), ACosh(), ATanh() /ATgh()/, ACoth() /ACtgh()/
+               and to the parser as well
+    * added:   UInt::BitAnd(), UInt::BitOr(), UInt::BitXor(), UInt::BitNot(),
+               Big::BitAnd(), Big::BitOr(), Big::BitXor()
+    * added:   to the parser: bitand(), bitor(), bitxor()
+               /band(), bor(), bxor()/
+    * changed: the way of parsing operators in the mathematical parser
+               (the parser is not too much greedy now)
+ 
     
 Version 0.8.0 (2007.03.28):
-	* added: into the parser: SetFactorialMax()
-	* added: DegToDeg(deg, min, sec), DegToRad(deg), DegToRad(deg, min, sec),
-	  RadToDeg(rad), Ceil(x), Floor(x), Sqrt(x), Sinh(x), Cosh(x),
-	  Tanh(x) /Tgh(x)/, Coth(x) /Ctgh(x)/
-	* changed: class Objects in ttmathobjects.h has been completely rewritten,
-	  we can change the names of user-defined variables or functions, and the
-	  names are case-sensitive now
-	* added: class History which is used in functions which take a lot of time
-	  during calculating e.g. Factorial(x)
-	* added: Tg(x) a wrapper for Tan(x)
-	* changed: CTan(x) is Cot(x) now
-	* added: Ctg(x) a wrapper for Cot(x) 
-	* added: ATg(x) a wrapper for ATan(x)
-	* changed: ACTan(x) is ACot(x) now
-	* added: ACtg(x) a wrapper for ACot(x)
-	* added: UInt::PrintTable() (for debugging etc.)
-	* changed: the methods Big::SetPi() Big::SetE() and Big::SetLn2() have
-	  been rewritten, now they have 128 32bit words (it's about 1232 valid
-	  decimal digits)
-	* fixed: previous values from Big::SetPi() Big::SetE() and
-	  Big::SetLn2() were not too much accurate (last 2-3 words were wrong)
-	* added: Big::SetLn10() (128 32bit words as well)
-	* added: macro: TTMATH_BUILTIN_VARIABLES_SIZE which is equal 128u on
-	  32bit platforms and 64ul on 64bit platforms (128/2=64)
-	* added: macros: TTMATH_PLATFORM32 and TTMATH_PLATFORM64
-	* changed: a small optimisation in UInt::Mul2Big()
-	* added: at the end of ttmath.h: #include "ttmathparser.h"
-	  this is for convenience for a programmer, he can only use #include
-	  with ttmath.h even if he uses the parser
-	* added: to samples: big.cpp, parser.cpp
-	* added/changes/fixed: in copy-constructors and operators= in Int,
-	  Uint and Big (more info in the commit log)
-	* renamed Big::SetDotOne() into Big::Set05()
-	* changes: a few small optimisations in Big
-	* deleted: the word 'virtual' from destructors: UInt, Int, Big
-	  (types in this library are not projected to be base-classes for
-	  another ones derived from them)
-	* and more small changes (look at the commit log)	
+    * added:   into the parser: SetFactorialMax()
+    * added:   DegToDeg(deg, min, sec), DegToRad(deg), DegToRad(deg, min, sec),
+               RadToDeg(rad), Ceil(x), Floor(x), Sqrt(x), Sinh(x), Cosh(x),
+               Tanh(x) /Tgh(x)/, Coth(x) /Ctgh(x)/
+    * changed: class Objects in ttmathobjects.h has been completely rewritten,
+               we can change the names of user-defined variables or functions,
+               and the names are case-sensitive now
+    * added:   class History which is used in functions which take a lot of time
+               during calculating e.g. Factorial(x)
+    * added:   Tg(x) a wrapper for Tan(x)
+    * changed: CTan(x) is Cot(x) now
+    * added:   Ctg(x) a wrapper for Cot(x) 
+    * added:   ATg(x) a wrapper for ATan(x)
+    * changed: ACTan(x) is ACot(x) now
+    * added:   ACtg(x) a wrapper for ACot(x)
+    * added:   UInt::PrintTable() (for debugging etc.)
+    * changed: the methods Big::SetPi() Big::SetE() and Big::SetLn2() have
+               been rewritten, now they have 128 32bit words (it's about
+               1232 valid decimal digits)
+    * fixed:   previous values from Big::SetPi() Big::SetE() and
+               Big::SetLn2() were not too much accurate (last 2-3 words were wrong)
+    * added:   Big::SetLn10() (128 32bit words as well)
+    * added:   macro TTMATH_BUILTIN_VARIABLES_SIZE which is equal 128u on
+               32bit platforms and 64ul on 64bit platforms (128/2=64)
+    * added:   macros TTMATH_PLATFORM32 and TTMATH_PLATFORM64
+    * changed: a small optimisation in UInt::Mul2Big()
+    * added:   at the end of ttmath.h: #include "ttmathparser.h"
+               this is for convenience for a programmer, he can only use #include
+               with ttmath.h even if he uses the parser
+    * added:   to samples: big.cpp, parser.cpp
+    * added/changes/fixed: in copy-constructors and operators= in Int,
+               Uint and Big (more info in the commit log)
+    * renamed: Big::SetDotOne() into Big::Set05()
+    * changes: a few small optimisations in Big
+    * deleted: the word 'virtual' from destructors: UInt, Int, Big
+               (types in this library are not projected to be base-classes for
+               another ones derived from them)
+    * and more small changes (look at the commit log)    
+
 
 Version 0.7.2 (2007.03.09):
-	* added: Big::Mod - the remainder from a division
-	* added: Big::Sgn - the 'sign' from the value (-1,0,1)
-	* added: global functions Mod and Sgn too
-	* added: checking whether a user gives a correct value of a variable or function
-	  (user-defined variables/functions in the mathematical parser)
-	* added: into the parser: logical operators: > < >= <= == != && ||
-	* added: into the parser: logical functions: and() or() not() if()
-	* added: ErrorCode::err_unknown_operator when the parser couldn't read an operator
+    * added:   Big::Mod - the remainder from a division
+    * added:   Big::Sgn - the 'sign' from the value (-1,0,1)
+    * added:   global functions Mod and Sgn too
+    * added:   checking whether a user gives a correct value of a variable or function
+               (user-defined variables/functions in the mathematical parser)
+    * added:   into the parser: logical operators: > < >= <= == != && ||
+    * added:   into the parser: logical functions: and() or() not() if()
+    * added:   ErrorCode::err_unknown_operator when the parser couldn't read an operator
+
 
 Version 0.7.1 (2007.02.27):
-	* fixed the error 'overflow during printing' which was caused
-	  by Big::FromInt(Int<int_size> value) (the sign has to be set at the end)
-	* fixed many small errors
-	* added ATan (arctan), ACTan (arc ctan) functions
+    * fixed:   the error 'overflow during printing' which was caused
+               by Big::FromInt(Int<int_size> value) (the sign has to be set at the end)
+    * fixed:   many small errors
+    * added:   ATan (arctan), ACTan (arc ctan) functions
+
 
 Version 0.7.0 (2007.02.24):
-	* finished support for 64bit platforms
-	* added ASin (arcsin), ACos (arccos) functions
+    * finished: support for 64bit platforms
+    * added:   ASin (arcsin), ACos (arccos) functions
+    
     
 Version 0.6.4 (2007.01.29):
-	* fixed the problem with a sign in the mathematical parser /-(1) was 1/
-	* added UInt::AddInt and UInt::SubInt
-	* changed UInt::AddOne and UInt::SubOne (much faster now)
-	* added UInt::SetBitInWord
-	* changed UInt::SetBit (much faster now)
-	* UInt::AddTwoUints renamed to UInt::AddTwoInts
-	* UInt::FindLeadingBit32 renamed to UInt::FindLeadingBitInWord
-	* added UInt::SetBitInWord
-	* UInt::Mul64 renamed to UInt::MulTwoWords
-	* UInt::Div64 renamed to UInt::DivTwoWords
-	* and more small changes in UInt type
-	* start adding support for Amd64 (not finished yet) (added ttmathuint64.h)
+    * fixed:   the problem with a sign in the mathematical parser /-(1) was 1/
+    * added:   UInt::AddInt and UInt::SubInt
+    * changed: UInt::AddOne and UInt::SubOne (much faster now)
+    * added:   UInt::SetBitInWord
+    * changed: UInt::SetBit (much faster now)
+               UInt::AddTwoUints renamed to UInt::AddTwoInts
+               UInt::FindLeadingBit32 renamed to UInt::FindLeadingBitInWord
+               UInt::Mul64 renamed to UInt::MulTwoWords
+               UInt::Div64 renamed to UInt::DivTwoWords
+    * added:   UInt::SetBitInWord
+    * and more small changes in UInt type
+    * start adding support for Amd64 (not finished yet) (added ttmathuint64.h)
+    
     
 Version 0.6.3 (2007.01.22):
-	* position of arguments (x and base) in logarithm functions are swapped
-	* it's possible to use any multiplication algorithms in the same time
-	  (macros UINT_MUL_VERSION_'X' have gone)
-	* added ExceptionInfo, ReferenceError and RuntimeError classes
-	* the mess in macros has been cleaned up
-	* added TTMATH_RELEASE macro
+    * changed: position of arguments (x and base) in logarithm functions are swapped
+    * changed: it's possible to use any multiplication algorithms in the same time
+               (macros UINT_MUL_VERSION_'X' have gone)
+    * added:   ExceptionInfo, ReferenceError and RuntimeError classes
+    * changed: the mess in macros has been cleaned up
+    * added:   TTMATH_RELEASE macro
+
 
 Version 0.6.2 (2007.01.10):
-	* New division algorithm (radix b) where b is 2^32
+    * added:   New division algorithm (radix b) where b is 2^32

COPYRIGHT

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2007, Tomasz Sowa
+Copyright (c) 2006-2009, Tomasz Sowa
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

README

@@ -7,18 +7,20 @@ subtracting, multiplying, dividing etc. With the library also goes
 a mathematical parser which helps you solving input formulas read directly
 from a user.
 
-TTMath is developed under the (new) BSD licence which means that it is free
-for both personal and commercial use but the library has some technical
-limitations: you can use it only on i386 and Amd64, another platforms are
-not supported (Intel 64bit platforms were not tested but should work as
-well), and you can use this library only with the C++ programming language. 
+TTMath is developed under the BSD licence which means that it is free
+for 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
 compiled first because the whole library is written as the C++ templates.
 This means only C++ developers can use this library and one thing they have
-to do is to use  'include' directive of the preprocessor. How big the
+to do is to use 'include' directive of the preprocessor. How big the
 values can be is set directly in the source code by the programmer.
 
-Author: Tomasz Sowa <t.sowa AnTispam slimaczek.pl>
-Project page: http://sourceforge.net/projects/ttmath
+Author: Tomasz Sowa <t.sowa@ttmath.org>
+Project pages: http://www.ttmath.org
+http://sourceforge.net/projects/ttmath

TODO

@@ -1,5 +0,0 @@
-TODO TTMath Library
-===================
-
-* Add functions for generating random values
-* Add something like NaN to the Big<> type

constgen/Makefile

@@ -0,0 +1,27 @@
+o      = main.o
+CC     = g++
+CFLAGS = -s -O2 -DTTMATH_CONSTANTSGENERATOR
+name   = gen
+
+
+.SUFFIXES: .cpp .o
+
+.cpp.o:
+	$(CC) -c $(CFLAGS) $<
+
+
+all: $(name)
+
+$(name): $(o)
+	$(CC) -o $(name) $(CFLAGS) $(o)
+
+
+
+main.o: main.cpp
+
+
+clean:
+	rm -f *.o
+	rm -f *.s
+	rm -f $(name)
+	rm -f $(name).exe

constgen/main.cpp

@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+/*
+  this simple program is used to make constants which then are put into ttmathbig.h
+*/
+
+
+#include "../ttmath/ttmath.h"
+#include <iostream>
+
+
+void CalcPi()
+{
+	ttmath::Big<1,400> pi;
+	
+	// 3100 digits after commna, taken from: http://zenwerx.com/pi.php
+	pi = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
+	"8214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"
+	"4428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273"
+	"7245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094"
+	"3305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912"
+	"9833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132"
+	"0005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235"
+	"4201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859"
+	"5024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303"
+	"5982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989"
+	"3809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913151"
+	"5574857242454150695950829533116861727855889075098381754637464939319255060400927701671139009848824012"
+	"8583616035637076601047101819429555961989467678374494482553797747268471040475346462080466842590694912"
+	"9331367702898915210475216205696602405803815019351125338243003558764024749647326391419927260426992279"
+	"6782354781636009341721641219924586315030286182974555706749838505494588586926995690927210797509302955"
+	"3211653449872027559602364806654991198818347977535663698074265425278625518184175746728909777727938000"
+	"8164706001614524919217321721477235014144197356854816136115735255213347574184946843852332390739414333"
+	"4547762416862518983569485562099219222184272550254256887671790494601653466804988627232791786085784383"
+	"8279679766814541009538837863609506800642251252051173929848960841284886269456042419652850222106611863"
+	"0674427862203919494504712371378696095636437191728746776465757396241389086583264599581339047802759009"
+	"9465764078951269468398352595709825822620522489407726719478268482601476990902640136394437455305068203"
+	"4962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382"
+	"6868386894277415599185592524595395943104997252468084598727364469584865383673622262609912460805124388"
+	"4390451244136549762780797715691435997700129616089441694868555848406353422072225828488648158456028506"
+	"0168427394522674676788952521385225499546667278239864565961163548862305774564980355936345681743241125"
+	"1507606947945109659609402522887971089314566913686722874894056010150330861792868092087476091782493858"
+	"9009714909675985261365549781893129784821682998948722658804857564014270477555132379641451523746234364"
+	"5428584447952658678210511413547357395231134271661021359695362314429524849371871101457654035902799344"
+	"0374200731057853906219838744780847848968332144571386875194350643021845319104848100537061468067491927"
+	"8191197939952061419663428754440643745123718192179998391015919561814675142691239748940907186494231961"
+	"5679452080951465502252316038819301420937621378559566389377870830390697920773467221825625996615014215";
+
+	std::cout << "---------------- PI ----------------" << std::endl;
+	pi.mantissa.PrintTable(std::cout);
+}
+
+
+void CalcE()
+{
+	ttmath::Big<1,400> e;
+	ttmath::uint steps;
+
+	// macro TTMATH_CONSTANTSGENERATOR has to be defined	
+	e.ExpSurrounding0(1, &steps);
+	std::cout << "---------------- e ----------------" << std::endl;
+	e.mantissa.PrintTable(std::cout);
+	
+	std::cout << "ExpSurrounding0(1): " << steps << " iterations" << std::endl;
+}
+
+
+void CalcLn(int x)
+{
+	ttmath::Big<1,400> ln;
+	ttmath::uint steps;
+
+	// macro TTMATH_CONSTANTSGENERATOR has to be defined	
+	ln.LnSurrounding1(x, &steps);
+	std::cout << "---------------- ln(" << x << ") ----------------" << std::endl;
+	ln.mantissa.PrintTable(std::cout);
+	
+	std::cout << "LnSurrounding1(" << x << "): " << steps << " iterations" << std::endl;
+}
+
+
+
+int main()
+{
+	CalcPi();
+	CalcE();
+	CalcLn(2);
+	CalcLn(10);
+		
+return 0;
+}

doxygen.cfg

@@ -31,7 +31,7 @@ PROJECT_NAME           = TTMath
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.8.0
+PROJECT_NUMBER         = 0.8.2
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 

samples/big.cpp

@@ -32,20 +32,21 @@ MyBig atemp;
 	if( !atemp.Add(b) )
 		std::cout << "a + b = " << atemp << std::endl;
 	else
-		std::cout << "a + b = (carry) " << atemp << std::endl;
+		std::cout << "a + b = (carry)" << std::endl;
+		// it have no sense to print 'atemp' (it's undefined)
 
 	atemp = a;
 	if( !atemp.Sub(b) )
 		std::cout << "a - b = " << atemp << std::endl;
 	else
-		std::cout << "a - b = (carry) " << atemp << std::endl;
+		std::cout << "a - b = (carry)" << std::endl;
 		
 	atemp = a;
 	if( !atemp.Mul(b) )
 		std::cout << "a * b = " << atemp << std::endl;
 	else
-		std::cout << "a * b = (carry: the result is too big) " << std::endl;
-		// it have no sense to print 'atemp' (it's undefined)
+		std::cout << "a * b = (carry)" << std::endl;
+		
 		
 	atemp = a;
 	if( !atemp.Div(b) )
@@ -68,9 +69,8 @@ MyBig a,b;
 	// 'a' will have the max value which can be held in this type
 	a.SetMax();
 	
-	// at the moment conversions from double (or float etc.) are not supported
-	// you cannot do that: b = 456.32f
-	b = "456.32";
+	// conversion from double
+	b = 456.32;
 	
 	// Look at the value 'a' and the product from a+b and a-b
 	// Don't worry this is the nature of floating point numbers
@@ -89,9 +89,9 @@ a * b = 12193540837712.2708
 a / b = 0.0012499665458095765
 Calculating with a carry
 a = 1.624801256070839555e+646457012
-b = 456.32
+b = 456.31999999999999
 a + b = 1.624801256070839555e+646457012
 a - b = 1.624801256070839555e+646457012
-a * b = (carry: the result is too big) 
-a / b = 3.56066193914542329e+646457009
+a * b = (carry)
+a / b = 3.56066193914542334e+646457009
 */

tests/Makefile

@@ -0,0 +1,31 @@
+CC     = g++
+o      = main.o uinttest.o
+CFLAGS = -Wall -O2 -s
+ttmath = ..
+name   = tests
+
+
+
+.SUFFIXES: .cpp .o
+
+.cpp.o:
+	$(CC) -c $(CFLAGS) -I$(ttmath) $<
+
+
+all: $(name)
+
+
+$(name): $(o)
+	$(CC) -o $(name) $(CFLAGS) -I$(ttmath) $(o)
+
+
+main.o: main.cpp uinttest.h
+uinttest.o: uinttest.cpp uinttest.h
+
+
+clean:
+	rm -f *.o
+	rm -f $(name)
+	rm -f $(name).exe
+
+

tests/main.cpp

@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+
+#include <iostream>
+#include <ttmath/ttmath.h>
+#include "uinttest.h"
+
+
+
+const char uint_tests_file[] = "tests.uint32";
+
+
+
+void test_uint()
+{
+	UIntTest test;
+
+	test.set_file_name(uint_tests_file);
+	test.go();
+}
+
+
+
+int main()
+{
+using namespace ttmath;
+
+
+	test_uint();
+
+
+return 0;
+}

tests/tests.uint32

@@ -0,0 +1,92 @@
+# Add
+
+#     min_bits   max_bits   a           b         result       carry
+add   32         0          0           0         0            0
+add   32         0          1           1         2            0
+add   32         0          2342234     3563456   5905690      0
+add   32         0          254455      3453435   3707890      0
+add   32         0          4294967295  0         4294967295   0
+add   32         32         4294967295                                 1         0                                                  1
+add   32         32         4294967295                                 0         4294967295                                         0
+add   64         64         18446744073709551615                       1         0                                                  1
+add   64         64         18446744073709551615                       0         18446744073709551615                               0
+add   96         96         79228162514264337593543950335              1         0                                                  1
+add   96         96         79228162514264337593543950335              0         79228162514264337593543950335                      0
+add   128        128        340282366920938463463374607431768211455    1         0                                                  1
+add   128        128        340282366920938463463374607431768211455    0         340282366920938463463374607431768211455            0
+add   160        160        1461501637330902918203684832716283019655932542975 1 0 1
+add   160        160        1461501637330902918203684832716283019655932542975 0 1461501637330902918203684832716283019655932542975 0
+add   192        192        6277101735386680763835789423207666416102355444464034512895 1 0 1
+add   192        192        6277101735386680763835789423207666416102355444464034512895 0 6277101735386680763835789423207666416102355444464034512895 0
+
+
+# AddInt
+
+#       min_bits max_bits   bits_per_int a               b(int)       index         result           carry
+addint  32       0          32           0               0            0             0                0
+addint  32       0          32           1000            2000         0             3000             0
+addint  64       0          32           562342345       1423445      1             6113650284997065 0                
+addint  64       0          32           5342342455      3423553423  0              8765895878 0
+addint  96       0          32           478895734       46756734     2             862509505820513898647477878                0
+addint  128      0          32           27370506140054471803784984408165997441 24543 3 27372450636847059393422542757339093889 0
+addint  128      128        32           340282366841711102552375003685868034945 2234543 3 177038656721750864719686733515479937 1
+addint  160      160        32           1461501637330902918124457471805283415910032366465 3 3 158457126631793409034731674497 1
+addint  192      0          32           6277101735386680763835789423128439055191355840718134336385 3354 1 6277101735386680763835789423128439055191355855123454647169 0
+addint  192      192        32           6277101735386680763835789423128439055191355840718134336385 3354 5 4901876491607848387655079701569502248322251848964993 1
+
+addint  64       0          64           0               0            0             0                0
+addint  64       0          64           5342342 345534234 0 350876576 0
+addint  64       0          64           5342342455 34235534234 0 39577876689 0
+addint  64       64         64           18446744073709550615 2000 0 999 1
+addint  128      0          64           42895062544824211012058135 3453234 0 42895062544824211015511369 0
+addint  128      0          64           42895062544824211012058135 456234234 1 8458931214807741031021280279 0
+addint  128      128        64           340282366920938426569886460012664978455 45623 1 804702316727431770143767 1
+addint  192      192        64           6277101735386680763835789423207666379208867297044931279895 45623234 1 841563227924816702308613143 1
+addint  192      192        64           6277101735386679588840776445207152040176347835149297122327 45623234 2 15523607057094857017675614218510090830281178135 1
+addint  192      192        64           6277101735386680763835789423207666416102355444464034512895 1 0 0 1
+
+
+
+# AddTwoInts
+# a the value
+# c lower word
+# b higher word
+# index - index of the lower (c) word
+# if there is a carry the result is skipped
+
+#             min_bits   max_bits   bits_per_int    a                    b(int)                 c(int)             index         result                   carry
+addtwoints    64         0          32              0                    0                      0                  0             0                        0
+addtwoints    64         0          32              23542345             3453245                2356252356         0             14831576719870221        0
+addtwoints    64         64         32              4563456879824345332  3453245255             3673623543         0             0                        1
+addtwoints    96         0          32              345345634564352344231 1231354534            345324551          1             22714482299528678798871855271  0
+addtwoints    96         96         32              33333336690445123453645645123                      4241542514         145235414    1    0 1
+addtwoints    128        0          32              921345787234870984751756                           2356245656         3423623455   2    186681013820253010515426931265335245452 0
+addtwoints    128        128        32              259817508127340892734075234234345345346            3452345324         452354345    2    0 1
+addtwoints    160        0          32              458674036702857083457018457034                     435236456          1451234242   1    466702732224470435083940719562 0
+addtwoints    160        0          32              258672084570198475012875019876674534523452543562   935245345          736765636    3    576919584276960743542382023227664277469907669578 0
+addtwoints    192        0          32              2398670187501982374012837086745045                 3253453245         234567536    4    4754927244626858434362642830810490464530603685767816794581 0
+addtwoints    192        192        32              1734564564356435667546738087098769876387468736123143453646 3456345245 3256347435   4    0 1
+
+
+addtwoints    128        0          64              0 0 0 0 0 0          
+addtwoints    128        0          64              14513452345  234512412345 8473567534  0 4325990452636459442359440119399 0
+addtwoints    128        128        64              325434534534536347567567356714513452345  4324546234512412345 8473567534  0  0 1
+addtwoints    192        0          64              8786356223462562562561234 4356879827345 34745638455 1 1482569380039046311960318103044992688410168990618834 0
+addtwoints    192        0          64              875687458745872039847234234048572306857602   12341234356 3472568734534 1 4199505313073142510985676024483326499863441546882 0
+addtwoints    192        192        64              6234554767823878635622346242564564564564564564562562561234 457644356879827345 34844576655 1 0 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tests/uinttest.cpp

@@ -0,0 +1,424 @@
+/*
+ * 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.
+ */
+
+
+#include "uinttest.h"
+
+
+
+void UIntTest::set_file_name(const std::string & f)
+{
+	file_name = f;
+}
+
+
+bool UIntTest::read_uint(uuint & result)
+{
+UInt<1> temp;
+
+	int c = temp.FromString(pline, 10, &pline);
+
+	result = temp.ToUInt();
+
+	if( c )
+	{
+		std::cerr << " carry from reading uint" << std::endl;
+		return false;
+	}
+
+return true;
+}
+
+
+
+template<uuint type_size>
+bool UIntTest::read_uint(UInt<type_size> & result)
+{
+	int c = result.FromString(pline, 10, &pline);
+
+	if( c )
+	{
+		std::cerr << " carry from UInt<>::FromString()" << std::endl;
+		return false;
+	}
+
+return true;
+}
+
+
+bool UIntTest::check_minmax_bits(int type_size)
+{
+	uuint min_bits;
+	uuint max_bits;
+
+	read_uint(min_bits);
+	read_uint(max_bits);
+
+	if( min_bits != 0 && type_size * TTMATH_BITS_PER_UINT < (unsigned int)min_bits )
+		return false;
+
+	if( max_bits != 0 && type_size * TTMATH_BITS_PER_UINT > (unsigned int)max_bits )
+		return false;
+
+return true;
+}
+
+
+bool UIntTest::check_minmax_bits_bitperint(int type_size)
+{
+	if( !check_minmax_bits(type_size) )
+		return false;
+
+	uuint bits;
+	
+	read_uint(bits);
+
+	if( TTMATH_BITS_PER_UINT != bits )
+		return false;
+
+return true;
+}
+
+
+
+bool UIntTest::check_end()
+{
+	skip_white_characters();
+
+	if( *pline!='#' && *pline!= 0 )
+	{
+		std::cerr << "syntax error" << std::endl;
+		return false;
+	}
+
+return true;
+}
+
+
+template<uuint type_size>
+bool UIntTest::check_result_carry(const ttmath::UInt<type_size> & result, const ttmath::UInt<type_size> & new_result,
+						int carry, int new_carry)
+{
+bool ok = true;
+
+	if( new_carry != carry )
+	{
+		std::cerr << "Incorrect carry: " << new_carry << " (expected: " << carry << ")" << std::endl;
+		ok = false;
+	}
+
+	if( new_result != result )
+	{
+		std::cerr << "Incorrect result: " << new_result << " (expected: " << result << ")" << std::endl;
+		ok = false;
+	}
+
+return ok;
+}
+
+
+template<uuint type_size>
+bool UIntTest::check_result_or_carry(const ttmath::UInt<type_size> & result, const ttmath::UInt<type_size> & new_result,
+						int carry, int new_carry)
+{
+	if( new_carry != carry )
+	{
+		std::cerr << "Incorrect carry: " << new_carry << " (expected: " << carry << ")" << std::endl;
+		return false;
+	}
+
+	if( new_carry == 1 )
+		return true;
+
+	if( new_result != result )
+	{
+		std::cerr << "Incorrect result: " << new_result << " (expected: " << result << ")" << std::endl;
+		return false;
+	}
+
+return true;
+}
+
+
+
+template<uuint type_size>
+void UIntTest::test_add()
+{
+	UInt<type_size> a,b,result, new_result;
+
+	if( !check_minmax_bits(type_size) )
+		return;
+
+	read_uint(a);
+	read_uint(b);
+	read_uint(result);
+	
+	uuint carry;
+	read_uint(carry);
+
+	std::cerr << '[' << row << "] Add<" << type_size << ">: ";
+
+	if( !check_end() )
+		return;
+
+	new_result = a;
+	int new_carry = new_result.Add(b);
+
+	if( check_result_carry(result, new_result, carry, new_carry) )
+		std::cerr << "ok" << std::endl;
+}
+
+
+template<uuint type_size>
+void UIntTest::test_addint()
+{
+	UInt<type_size> a, result, new_result;
+
+	if( !check_minmax_bits_bitperint(type_size) )
+		return;
+
+	uuint b, index, carry;
+
+	read_uint(a);
+	read_uint(b);
+	read_uint(index);
+	read_uint(result);
+
+	read_uint(carry);
+
+	std::cerr << '[' << row << "] AddInt<" << type_size << ">: ";
+
+	if( !check_end() )
+		return;
+
+	new_result = a;
+	int new_carry = new_result.AddInt(b, index);
+
+	if( check_result_carry(result, new_result, carry, new_carry) )
+		std::cerr << "ok" << std::endl;
+}
+
+template<uuint type_size>
+void UIntTest::test_addtwoints()
+{
+	UInt<type_size> a, result, new_result;
+
+	if( !check_minmax_bits_bitperint(type_size) )
+		return;
+
+	std::cerr << '[' << row << "] AddTwoInts<" << type_size << ">: ";
+
+	uuint b, c, index, carry;
+
+	read_uint(a);
+	read_uint(b);
+	read_uint(c);
+	read_uint(index);
+	read_uint(result);
+
+	read_uint(carry);
+
+
+	if( !check_end() )
+		return;
+
+	if( index >= type_size - 1 )
+	{
+		std::cerr << "index too large" << std::endl;
+		return;
+	}
+
+
+	new_result = a;
+	int new_carry = new_result.AddTwoInts(b, c, index);
+
+	if( check_result_or_carry(result, new_result, carry, new_carry) )
+		std::cerr << "ok" << std::endl;
+}
+
+
+int UIntTest::upper_char(int c)
+{
+	if( c>='a' && c<='z' )
+		return c - 'a' + 'A';
+
+return c;
+}
+
+
+bool UIntTest::is_white(int c)
+{
+	if( c==' ' || c=='\t' || c==13 )
+		return true;
+
+return false;
+}
+
+
+void UIntTest::skip_white_characters()
+{
+	while( is_white(*pline) )
+		++pline;
+}
+
+
+
+bool UIntTest::read_method()
+{
+	skip_white_characters();
+	
+	if( *pline == '#' )
+		return false;
+	
+	method.clear();
+
+	for(int c = upper_char(*pline) ; c>='A'&& c<='Z' ; c = upper_char(*pline) )
+	{
+		method += c;
+		++pline;
+	}
+
+	if( method.empty() )
+	{
+		skip_white_characters();
+		if( *pline == 0 )
+			return false;
+		else
+		{	
+			std::cerr << '[' << row << "] ";
+			std::cerr << "syntax error" << std::endl;
+			return false;
+		}
+	}
+
+
+return true;
+}
+
+
+
+void UIntTest::test_method()
+{
+const char * p = pline;
+
+	if( method == "ADD" )
+	{
+		pline = p; test_add<1>();
+		pline = p; test_add<2>();
+		pline = p; test_add<3>();
+		pline = p; test_add<4>();
+		pline = p; test_add<5>();
+		pline = p; test_add<6>();
+		pline = p; test_add<7>();
+		pline = p; test_add<8>();
+		pline = p; test_add<9>();
+	}
+	else
+	if( method == "ADDINT" )
+	{
+		pline = p; test_addint<1>();
+		pline = p; test_addint<2>();
+		pline = p; test_addint<3>();
+		pline = p; test_addint<4>();
+		pline = p; test_addint<5>();
+		pline = p; test_addint<6>();
+		pline = p; test_addint<7>();
+		pline = p; test_addint<8>();
+		pline = p; test_addint<9>();
+	}
+	else
+	if( method == "ADDTWOINTS" )
+	{
+		pline = p; test_addtwoints<1>();
+		pline = p; test_addtwoints<2>();
+		pline = p; test_addtwoints<3>();
+		pline = p; test_addtwoints<4>();
+		pline = p; test_addtwoints<5>();
+		pline = p; test_addtwoints<6>();
+		pline = p; test_addtwoints<7>();
+		pline = p; test_addtwoints<8>();
+		pline = p; test_addtwoints<9>();
+	}
+	else
+	{
+		std::cerr << '[' << row << "] ";
+		std::cerr << "method " << method << " is not supported" << std::endl;
+	}
+}
+
+
+bool UIntTest::check_line()
+{
+	std::getline(file, line);
+	
+	pline = line.c_str();
+	
+	if( read_method() )
+		test_method();
+
+
+	if( file.eof() )
+		return false;
+
+
+return true;
+}
+
+
+
+
+void UIntTest::go()
+{
+	file.open(file_name.c_str());
+
+
+	if( !file )
+	{
+		std::cerr << "I can't open the input file" << std::endl;
+		return;
+	}
+
+	row = 1;
+
+	while( check_line() )
+		++row;
+
+}
+
+
+
+

tests/uinttest.h

@@ -0,0 +1,105 @@
+/*
+ * 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 headerfileuinttest
+#define headerfileuinttest
+
+#include <string>
+#include <fstream>
+#include <iostream>
+
+#include <ttmath/ttmath.h>
+
+using namespace ttmath;
+typedef ttmath::uint uuint;
+
+
+class UIntTest
+{
+
+	std::string file_name;
+
+	// current line from the file
+	std::string line;
+	const char * pline;
+
+	std::ifstream file;
+
+
+	std::string method;
+
+	int row;
+
+public:
+
+	void set_file_name(const std::string & f);
+
+	void go();
+
+bool read_uint(uuint & result);
+
+template<uuint type_size>
+bool read_uint(UInt<type_size> & result);
+
+
+	template<uuint type_size> void test_add();
+	template<uuint type_size> void test_addint();
+	template<uuint type_size> void test_addtwoints();
+
+	template<uuint type_size> bool check_result_carry(const ttmath::UInt<type_size> & result, const ttmath::UInt<type_size> & new_result,
+						int carry, int new_carry);
+
+	template<uuint type_size> bool check_result_or_carry(const ttmath::UInt<type_size> & result, const ttmath::UInt<type_size> & new_result,
+						int carry, int new_carry);
+
+int upper_char(int c);
+bool is_white(int c);
+void skip_white_characters();
+bool read_method();
+void test_method();
+bool check_line();
+
+bool check_minmax_bits(int type_size);
+bool check_minmax_bits_bitperint(int type_size);
+bool check_end();
+
+
+};
+
+
+#endif

ttmath/ttmath.h

@@ -1,11 +1,11 @@
 /*
- * This file is a part of TTMath Mathematical Library
+ * 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-2007, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -45,6 +45,12 @@
     \brief Mathematics functions.
 */
 
+#ifdef _MSC_VER
+//warning C4127: conditional expression is constant
+#pragma warning( disable: 4127 )
+#endif
+
+
 #include "ttmathbig.h"
 #include "ttmathobjects.h"
 
@@ -53,6 +59,13 @@
 
 namespace ttmath
 {
+	/*
+ 	 *
+	 *  functions defined here are used only with Big<> types
+	 *
+	 *
+	 */
+
 
 	/*
  	 *
@@ -87,10 +100,21 @@ namespace ttmath
 			 -2.7 = -3
 	*/
 	template<class ValueType>
-	ValueType Round(const ValueType & x)
+	ValueType Round(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType result( x );
-		result.Round();
+		uint c = result.Round();
+
+		if( err )
+			*err = c ? err_overflow : err_ok;
 
 	return result;
 	}
@@ -111,6 +135,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Ceil(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType result(x);
 		uint c = 0;
 
@@ -150,6 +182,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Floor(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType result(x);
 		uint c = 0;
 
@@ -190,8 +230,15 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Ln(const ValueType & x, ErrorCode * err = 0)
 	{
-	ValueType result;
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
 
+		return x; // NaN
+		}
+
+		ValueType result;
 		uint state = result.Ln(x);
 
 		if( err )
@@ -224,8 +271,15 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Log(const ValueType & x, const ValueType & base, ErrorCode * err = 0)
 	{
-	ValueType result;
+		if( x.IsNan() || base.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
 
+		return ValueType(); // default NaN
+		}
+
+		ValueType result;
 		uint state = result.Log(x, base);
 
 		if( err )
@@ -258,8 +312,15 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Exp(const ValueType & x, ErrorCode * err = 0)
 	{
-	ValueType result;
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
 
+		return x; // NaN
+		}
+
+		ValueType result;
 		uint c = result.Exp(x);
 
 		if( err )
@@ -275,6 +336,11 @@ namespace ttmath
 	*
 	*/
 
+
+	/*
+		this namespace consists of auxiliary functions
+		(something like 'private' in a class)
+	*/
 	namespace auxiliaryfunctions
 	{
 
@@ -283,7 +349,7 @@ namespace ttmath
 		(you don't have to call this function) 
 	*/
 	template<class ValueType>
-	void PrepareSin(ValueType & x, bool & change_sign)
+	uint PrepareSin(ValueType & x, bool & change_sign)
 	{
 	ValueType temp;
 
@@ -299,12 +365,10 @@ namespace ttmath
 		// we're reducing the period 2*PI
 		// (for big values there'll always be zero)
 		temp.Set2Pi();
-		if( x > temp )
-		{
-			x.Div( temp );
-			x.RemainFraction();
-			x.Mul( temp );
-		}
+		
+		if( x.Mod(temp) )
+			return 1;
+		
 
 		// we're setting 'x' as being in the range of <0, 0.5PI>
 
@@ -325,6 +389,8 @@ namespace ttmath
 			x.Sub( temp );
 			x = temp - x;
 		}
+
+	return 0;
 	}
 
 	
@@ -411,7 +477,7 @@ namespace ttmath
 			if( c )
 				// Sin is from <-1,1> and cannot make an overflow
 				// but the carry can be from the Taylor series
-				// (then we only breaks our calculations)
+				// (then we only break our calculations)
 				break;
 
 			if( addition )
@@ -443,15 +509,38 @@ namespace ttmath
 		this function calculates the Sine
 	*/
 	template<class ValueType>
-	ValueType Sin(ValueType x)
+	ValueType Sin(ValueType x, ErrorCode * err = 0)
 	{
 	using namespace auxiliaryfunctions;
 
-	ValueType one;
+	ValueType one, result;
 	bool change_sign;	
 	
-		PrepareSin( x, change_sign );
-		ValueType result = Sin0pi05( x );
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
+		if( err )
+			*err = err_ok;
+
+		if( PrepareSin( x, change_sign ) )
+		{
+			// x is too big, we cannnot reduce the 2*PI period
+			// prior to version 0.8.5 the result was zero
+			
+			// result has NaN flag set by default
+
+			if( err )
+				*err = err_overflow; // maybe another error code? err_improper_argument?
+
+		return result; // NaN is set by default
+		}
+
+		result = Sin0pi05( x );
 	
 		one.SetOne();
 
@@ -476,14 +565,30 @@ namespace ttmath
 		we're using the formula cos(x) = sin(x + PI/2)
 	*/
 	template<class ValueType>
-	ValueType Cos(ValueType x)
+	ValueType Cos(ValueType x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType pi05;
 		pi05.Set05Pi();
 
-		x.Add( pi05 );
+		uint c = x.Add( pi05 );
 
-	return Sin(x);
+		if( c )
+		{
+			if( err )
+				*err = err_overflow;
+	
+		return ValueType(); // result is undefined (NaN is set by default)
+		}
+
+	return Sin(x, err);
 	}
 	
 
@@ -500,20 +605,22 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Tan(const ValueType & x, ErrorCode * err = 0)
 	{
-		ValueType result = Cos(x);
+		ValueType result = Cos(x, err);
+		
+		if( err && *err != err_ok )
+			return result;
 
 		if( result.IsZero() )
 		{
 			if( err )
 				*err = err_improper_argument;
 
+			result.SetNan();
+
 		return result;
 		}
 
-		if( err )
-			*err = err_ok;
-
-	return Sin(x) / result;
+	return Sin(x, err) / result;
 	}
 
 
@@ -540,20 +647,22 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Cot(const ValueType & x, ErrorCode * err = 0)
 	{
-		ValueType result = Sin(x);
+		ValueType result = Sin(x, err);
+
+		if( err && *err != err_ok )
+			return result;
 
 		if( result.IsZero() )
 		{
 			if( err )
 				*err = err_improper_argument;
 
+			result.SetNan();
+
 		return result;
 		}
 	
-		if( err )
-			*err = err_ok;
-
-	return Cos(x) / result;
+	return Cos(x, err) / result;
 	}
 
 
@@ -734,16 +843,24 @@ namespace ttmath
 	{
 	using namespace auxiliaryfunctions;
 
-		ValueType one;
+		ValueType result, one;
 		one.SetOne();
 		bool change_sign = false;
 
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
 		if( x.GreaterWithoutSignThan(one) )
 		{
 			if( err )
 				*err = err_improper_argument;
 
-			return one;
+			return result; // NaN is set by default
 		}
 
 		if( x.IsSign() )
@@ -754,8 +871,6 @@ namespace ttmath
 
 		one.exponent.SubOne(); // =0.5
 
-		ValueType result;
-
 		// asin(-x) = -asin(x)
 		if( x.GreaterWithoutSignThan(one) )
 			result = ASin_1(x);	
@@ -784,7 +899,7 @@ namespace ttmath
 	ValueType temp;
 
 		temp.Set05Pi();
-		temp.Sub(ASin(x,err));
+		temp.Sub(ASin(x, err));
 
 	return temp;
 	}
@@ -962,6 +1077,9 @@ namespace ttmath
 		one.SetOne();
 		bool change_sign = false;
 
+		if( x.IsNan() )
+			return result; // NaN is set by default
+
 		// if x is negative we're using the formula:
 		// atan(-x) = -atan(x)
 		if( x.IsSign() )
@@ -1042,6 +1160,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Sinh(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType ex, emx;
 		uint c = 0;
 
@@ -1066,6 +1192,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Cosh(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType ex, emx;
 		uint c = 0;
 
@@ -1090,6 +1224,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Tanh(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType ex, emx, nominator, denominator;
 		uint c = 0;
 
@@ -1130,12 +1272,20 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Coth(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		if( x.IsZero() )
 		{
 			if( err )
 				*err = err_improper_argument;
 
-			return x;
+			return ValueType(); // NaN is set by default
 		}
 
 		ValueType ex, emx, nominator, denominator;
@@ -1187,6 +1337,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType ASinh(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType xx(x), one, result;
 		uint c = 0;
 		one.SetOne();
@@ -1215,6 +1373,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType ACosh(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType xx(x), one, result;
 		uint c = 0;
 		one.SetOne();
@@ -1224,7 +1390,7 @@ namespace ttmath
 			if( err )
 				*err = err_improper_argument;
 
-		return result;
+		return result; // NaN is set by default
 		}
 
 		c += xx.Mul(x);
@@ -1256,6 +1422,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType ATanh(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType nominator(x), denominator, one, result;
 		uint c = 0;
 		one.SetOne();
@@ -1265,7 +1439,7 @@ namespace ttmath
 			if( err )
 				*err = err_improper_argument;
 
-		return result;
+		return result; // NaN is set by default
 		}
 
 		c += nominator.Add(one);
@@ -1301,6 +1475,14 @@ namespace ttmath
 	template<class ValueType>
 	ValueType ACoth(const ValueType & x, ErrorCode * err = 0)
 	{
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return x; // NaN
+		}
+
 		ValueType nominator(x), denominator(x), one, result;
 		uint c = 0;
 		one.SetOne();
@@ -1310,7 +1492,7 @@ namespace ttmath
 			if( err )
 				*err = err_improper_argument;
 
-		return result;
+		return result; // NaN is set by default
 		}
 
 		c += nominator.Add(one);
@@ -1342,7 +1524,7 @@ namespace ttmath
 
 	/*
  	 *
-	 *  functions for converting between degrees and radians
+	 *  functions for converting between degrees, radians and gradians
 	 *
 	 *
 	 */
@@ -1356,14 +1538,26 @@ namespace ttmath
 	template<class ValueType>
 	ValueType DegToRad(const ValueType & x, ErrorCode * err = 0)
 	{
-	ValueType result, delimiter;
+	ValueType result, temp;
 	uint c = 0;
 
-		result.SetPi();
-		c += result.Mul(x);
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
 
-		delimiter = 180;
-		c += result.Div(delimiter);
+		return result; // NaN is set by default
+		}
+
+		result = x;
+
+		// it is better to make division first and then multiplication
+		// the result is more accurate especially when x is: 90,180,270 or 360
+		temp = 180;
+		c += result.Div(temp);
+
+		temp.SetPi();
+		c += result.Mul(temp);
 
 		if( err )
 			*err = c ? err_overflow : err_ok;
@@ -1383,6 +1577,14 @@ namespace ttmath
 	ValueType result, delimiter;
 	uint c = 0;
 
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
 		result = 180;
 		c += result.Mul(x);
 
@@ -1420,12 +1622,12 @@ namespace ttmath
 	ValueType delimiter, multipler;
 	uint c = 0;
 
-		if( m.IsSign() || s.IsSign() )
+		if( d.IsNan() || m.IsNan() || s.IsNan() || m.IsSign() || s.IsSign() )
 		{
 			if( err )
 				*err = err_improper_argument;
 
-			return delimiter;
+		return delimiter ; // NaN is set by default
 		}
 
 		multipler = 60;
@@ -1463,6 +1665,160 @@ namespace ttmath
 	}
 
 
+	/*!
+		this function converts gradians to radians
+		
+		it returns: x * pi / 200
+	*/
+	template<class ValueType>
+	ValueType GradToRad(const ValueType & x, ErrorCode * err = 0)
+	{
+	ValueType result, temp;
+	uint c = 0;
+
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
+		result = x;
+
+		// it is better to make division first and then multiplication
+		// the result is more accurate especially when x is: 100,200,300 or 400
+		temp = 200;
+		c += result.Div(temp);
+
+		temp.SetPi();
+		c += result.Mul(temp);
+
+		if( err )
+			*err = c ? err_overflow : err_ok;
+
+	return result;
+	}
+
+
+	/*!
+		this function converts radians to gradians
+		
+		it returns: x * 200 / pi
+	*/
+	template<class ValueType>
+	ValueType RadToGrad(const ValueType & x, ErrorCode * err = 0)
+	{
+	ValueType result, delimiter;
+	uint c = 0;
+
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
+		result = 200;
+		c += result.Mul(x);
+
+		delimiter.SetPi();
+		c += result.Div(delimiter);
+
+		if( err )
+			*err = c ? err_overflow : err_ok;
+
+	return result;
+	}
+
+
+	/*!
+		this function converts degrees to gradians
+		
+		it returns: x * 200 / 180
+	*/
+	template<class ValueType>
+	ValueType DegToGrad(const ValueType & x, ErrorCode * err = 0)
+	{
+	ValueType result, temp;
+	uint c = 0;
+
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
+		result = x;
+
+		temp = 200;
+		c += result.Mul(temp);
+
+		temp = 180;
+		c += result.Div(temp);
+
+		if( err )
+			*err = c ? err_overflow : err_ok;
+
+	return result;
+	}
+
+
+	/*!
+		this function converts degrees in the long format to gradians
+	*/
+	template<class ValueType>
+	ValueType DegToGrad( const ValueType & d, const ValueType & m, const ValueType & s,
+						 ErrorCode * err = 0)
+	{
+		ValueType temp_deg = DegToDeg(d,m,s,err);
+
+		if( err && *err!=err_ok )
+			return temp_deg;
+
+	return DegToGrad(temp_deg, err);
+	}
+
+
+	/*!
+		this function converts degrees to gradians
+		
+		it returns: x * 180 / 200
+	*/
+	template<class ValueType>
+	ValueType GradToDeg(const ValueType & x, ErrorCode * err = 0)
+	{
+	ValueType result, temp;
+	uint c = 0;
+
+		if( x.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return result; // NaN is set by default
+		}
+
+		result = x;
+
+		temp = 180;
+		c += result.Mul(temp);
+
+		temp = 200;
+		c += result.Div(temp);
+
+		if( err )
+			*err = c ? err_overflow : err_ok;
+
+	return result;
+	}
+
+
+
+
 	/*
  	 *
 	 *  another functions
@@ -1479,12 +1835,12 @@ namespace ttmath
 	template<class ValueType>
 	ValueType Sqrt(ValueType x, ErrorCode * err = 0)
 	{
-		if( x.IsSign() )
+		if( x.IsNan() || x.IsSign() )
 		{
 			if( err )
 				*err = err_improper_argument;
 
-		return x;
+		return ValueType(); // NaN is set by default
 		}
 
 		if( x.IsZero() )
@@ -1522,6 +1878,8 @@ namespace ttmath
 				if( err )
 					*err = err_improper_argument;
 
+				x.SetNan();
+
 			return true;
 			}
 
@@ -1536,10 +1894,12 @@ namespace ttmath
 			{
 				if( x.IsZero() )
 				{
-					// there isn't root(0;0)
+					// there isn't root(0;0) - we assume it's not defined
 					if( err )
 						*err = err_improper_argument;
 
+					x.SetNan();
+
 				return true;
 				}
 		
@@ -1557,7 +1917,7 @@ namespace ttmath
 
 
 		template<class ValueType>
-		bool RootCheckIndexOne(ValueType & x, const ValueType & index, ErrorCode * err)
+		bool RootCheckIndexOne(const ValueType & index, ErrorCode * err)
 		{
 			ValueType one;
 			one.SetOne();
@@ -1589,6 +1949,8 @@ namespace ttmath
 				if( err )
 					*err = err_improper_argument;
 
+				x.SetNan();
+
 			return true;
 			}
 
@@ -1597,11 +1959,12 @@ namespace ttmath
 
 
 		template<class ValueType>
-		bool RootCheckXZero(ValueType & x, const ValueType & index, ErrorCode * err)
+		bool RootCheckXZero(ValueType & x, ErrorCode * err)
 		{
 			if( x.IsZero() )
 			{
 				// root(0;index) is zero (if index!=0)
+				// RootCheckIndexZero() must be called beforehand
 				x.SetZero();
 
 				if( err )
@@ -1637,6 +2000,8 @@ namespace ttmath
 					if( err )
 						*err = err_improper_argument;
 
+					x.SetNan();
+
 					return true;
 				}
 			}
@@ -1666,11 +2031,19 @@ namespace ttmath
 	{
 		using namespace auxiliaryfunctions;
 
+		if( x.IsNan() || index.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return ValueType(); // NaN is set by default
+		}
+
 		if( RootCheckIndexSign(x, index, err) ) return x;
 		if( RootCheckIndexZero(x, index, err) ) return x;
-		if( RootCheckIndexOne (x, index, err) ) return x;
+		if( RootCheckIndexOne (   index, err) ) return x;
 		if( RootCheckIndexFrac(x, index, err) ) return x;
-		if( RootCheckXZero(x, index, err) ) return x;
+		if( RootCheckXZero    (x,        err) ) return x;
 
 		// index integer and index!=0
 		// x!=0
@@ -1685,7 +2058,14 @@ namespace ttmath
 		c += x.PowFrac(newindex); // here can only be a carry
 
 		if( change_sign )
+		{
+			// the value of x should be different from zero
+			// (x is actually tested by RootCheckXZero)
+			TTMATH_ASSERT( x.IsZero() == false )
+
 			x.SetSign();
+		}
+
 
 		if( err )
 			*err = c ? err_overflow : err_ok;
@@ -1714,12 +2094,16 @@ namespace ttmath
 
 		while( !carry && multipler<maxvalue  )
 		{
-			if( stop && stop->WasStopSignal() )
+			if( stop && (multipler & 127)==0 ) // it means 'stop && (multipler % 128)==0'
 			{
-				if( err )
-					*err = err_interrupt;
+				// after each 128 iterations we make a test
+				if( stop->WasStopSignal() )
+				{
+					if( err )
+						*err = err_interrupt;
 
-			return 2;
+					return 2;
+				}
 			}
 			
 			++multipler;
@@ -1743,19 +2127,25 @@ namespace ttmath
 
 		one.SetOne();
 		uint carry = 0;
+		uint iter = 1; // only for testing the stop object
 
 		while( !carry && multipler < x )
 		{
-			if( stop && stop->WasStopSignal() )
+			if( stop && (iter & 31)==0 ) // it means 'stop && (iter % 32)==0'
 			{
-				if( err )
-					*err = err_interrupt;
+				// after each 32 iterations we make a test
+				if( stop->WasStopSignal() )
+				{
+					if( err )
+						*err = err_interrupt;
 
-			return 2;
+					return 2;
+				}
 			}
 			
 			carry += multipler.Add(one);
 			carry += result.Mul(multipler);
+			++iter;
 		}
 
 		if( err )
@@ -1782,16 +2172,16 @@ namespace ttmath
 	static History<ValueType> history;
 	ValueType result;
 
-		result.SetOne();
-		
-		if( x.IsSign() )
+		if( x.IsNan() || x.IsSign() )
 		{
 			if( err )
 				*err = err_improper_argument;
 
-		return result;
+		return result; // NaN set by default
 		}
 
+		result.SetOne();
+
 		if( !x.exponent.IsSign() && !x.exponent.IsZero() )
 		{
 			// when x.exponent>0 there's no sense to calculate the formula
@@ -1800,6 +2190,8 @@ namespace ttmath
 			if( err )
 				*err = err_overflow;
 
+			result.SetNan();
+
 		return result;
 		}
 
@@ -1818,8 +2210,11 @@ namespace ttmath
 			status = FactorialMore(x, err, stop, result);
 
 		if( status == 2 )
+		{
 			// the calculation has been interrupted
+			result.SetNan();
 			return result;
+		}
 
 		err_tmp = status==1 ? err_overflow : err_ok;
 		history.Add(x, result, err_tmp);
@@ -1862,15 +2257,26 @@ namespace ttmath
 		the remainder from a division
 
 		e.g.
-		mod( 12.6 ;  3) =  0.6   because 12.6 = 3*4 + 0.6
-		mod(-12.6 ;  3) = -0.6
+		mod( 12.6 ;  3) =  0.6   because 12.6  = 3*4 + 0.6
+		mod(-12.6 ;  3) = -0.6   bacause -12.6 = 3*(-4) + (-0.6)
 		mod( 12.6 ; -3) =  0.6
 		mod(-12.6 ; -3) = -0.6
 	*/
 	template<class ValueType>
-	ValueType Mod(ValueType a, const ValueType & b)
+	ValueType Mod(ValueType a, const ValueType & b, ErrorCode * err = 0)
 	{
-		a.Mod(b);
+		if( a.IsNan() || b.IsNan() )
+		{
+			if( err )
+				*err = err_improper_argument;
+
+		return ValueType(); // NaN is set by default
+		}
+
+		uint c = a.Mod(b);
+
+		if( err )
+			*err = c ? err_overflow : err_ok;
 
 	return a;
 	}
@@ -1886,4 +2292,10 @@ namespace ttmath
 */
 #include "ttmathparser.h"
 
+
+#ifdef _MSC_VER
+#pragma warning( default: 4127 )
+//warning C4127: conditional expression is constant
+#endif
+
 #endif

ttmath/ttmathint.h

@@ -1,11 +1,11 @@
 /*
- * This file is a part of TTMath Mathematical Library
+ * 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-2007, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -208,7 +208,7 @@ private:
 public:
 
 	/*!
-		this method adds two value with a sign and returns carry
+		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
@@ -469,23 +469,84 @@ public:
 
 
 
+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:
+
 
 	/*!
-		this method convert an UInt<another_size> type to 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
+		an auxiliary method for converting both from UInt and Int
 	*/
 	template<uint argument_size>
-	uint FromInt(const Int<argument_size> & p)
+	uint FromUIntOrInt(const UInt<argument_size> & p, bool UInt_type)
 	{
 		uint min_size = (value_size < argument_size)? value_size : argument_size;
 		uint i;
@@ -496,15 +557,25 @@ public:
 
 		if( value_size > argument_size )
 		{	
-			// 'this' is longer than 'p'
-			uint fill = (p.table[argument_size-1] & TTMATH_UINT_HIGHEST_BIT)? TTMATH_UINT_MAX_VALUE : 0;
+			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;
+			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 )
@@ -514,11 +585,27 @@ public:
 	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
 	*/
-	void FromInt(sint value)
+	uint FromInt(sint value)
 	{
 	uint fill = ( value<0 ) ? TTMATH_UINT_MAX_VALUE : 0;
 
@@ -526,16 +613,46 @@ public:
 			UInt<value_size>::table[i] = fill;
 
 		UInt<value_size>::table[0] = uint(value);
+	
+		// there'll never be a carry here
+	return 0;
 	}
 
 
 	/*!
-		this operator converts an UInt<another_size> type to this class
-
-		it doesn't return a carry
+		this method converts UInt<another_size> into this class
 	*/
 	template<uint argument_size>
-	Int<value_size> & operator=(const Int<argument_size> & p)
+	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;
+	}
+
+
+
+	/*!
+		the default assignment operator
+	*/
+	Int<value_size> & operator=(const Int<value_size> & p)
 	{
 		FromInt(p);
 
@@ -544,9 +661,12 @@ public:
 
 
 	/*!
-		the default assignment operator
+		this operator converts an Int<another_size> type to this class
+
+		it doesn't return a carry
 	*/
-	Int<value_size> & operator=(const Int<value_size> & p)
+	template<uint argument_size>
+	Int<value_size> & operator=(const Int<argument_size> & p)
 	{
 		FromInt(p);
 
@@ -575,11 +695,46 @@ public:
 
 
 	/*!
-		this method converts the uint type to this class
+		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);
+	}
+
+
+
+	/*!
+		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)
 	{
-		UInt<value_size>::FromUInt(i);
+		FromUInt(i);
 
 	return *this;
 	}
@@ -590,10 +745,23 @@ public:
 	*/
 	Int(uint i)
 	{
-		UInt<value_size>::FromUInt(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
 
 	/*!
@@ -630,7 +798,7 @@ public:
 	*/
 	Int<value_size> & operator=(unsigned int i)
 	{
-		UInt<value_size>::FromUInt(uint(i));
+		FromUInt(uint(i));
 
 	return *this;
 	}
@@ -644,7 +812,7 @@ public:
 	*/
 	Int(unsigned int i)
 	{
-		UInt<value_size>::FromUInt(uint(i));
+		FromUInt(uint(i));
 	}
 
 #endif
@@ -678,18 +846,6 @@ public:
 	}
 
 
-	/*!
-		the copy constructor
-	*/
-	template<uint argument_size>
-	Int(const Int<argument_size> & u) : UInt<value_size>::size(value_size)
-	{
-		// look that 'size' we still set as 'value_size' and not as u.value_size
-
-		operator=(u);
-	}
-
-
 	/*!
 		the destructor
 	*/
@@ -697,6 +853,7 @@ public:
 	{
 	}
 
+
 	/*!
 		this method returns the lowest value from table with a sign
 
@@ -742,8 +899,12 @@ public:
 
 		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)
+	uint FromString(const char * s, uint b = 10, const char ** after_source = 0, bool * value_read = 0)
 	{
 	bool is_sign = false;
 	
@@ -760,7 +921,7 @@ public:
 			UInt<value_size>::SkipWhiteCharacters(++s);
 		}
 
-		if( UInt<value_size>::FromString(s,b) )
+		if( UInt<value_size>::FromString(s,b,after_source,value_read) )
 			return 1;
 
 		if( is_sign )
@@ -771,12 +932,15 @@ public:
 
 			/*
 				the reference to mmin will be automatically converted to the reference
-				to a UInt type
+				to UInt type
 				(this value can be equal mmin -- look at a description in ChangeSign())
 			*/
 			if( UInt<value_size>::operator>( mmin ) )
 				return 1;
 
+			/*
+				if the value is equal mmin the method ChangeSign() does nothing (only returns 1 but we ignore it)
+			*/
 			ChangeSign();
 		}
 		else
@@ -799,7 +963,7 @@ public:
 	*/
 	uint FromString(const std::string & s, uint b = 10)
 	{
-		return FromString( s.c_str() );
+		return FromString( s.c_str(), b );
 	}
 
 
@@ -1152,5 +1316,4 @@ public:
 
 } // namespace
 
-
 #endif

ttmath/ttmathobjects.h

@@ -5,7 +5,7 @@
  */
 
 /* 
- * Copyright (c) 2006-2007, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -102,7 +102,7 @@ public:
 		if( (c>='a' && c<='z') || (c>='A' && c<='Z') )
 			return true;
 
-		if( can_be_digit && (c>='0' && c<='9') )
+		if( can_be_digit && ((c>='0' && c<='9') || c=='_') )
 			return true;
 
 	return false;
@@ -130,6 +130,21 @@ public:
 	}
 
 
+	/*!
+		this method returns true if such an object is defined (name exists)
+	*/
+	bool IsDefined(const std::string & name)
+	{
+		Iterator i = table.find(name);
+
+		if( i != table.end() )
+			// we have this object in our table
+			return true;
+
+	return false;
+	}
+
+
 	/*!
 		this method adds one object (variable of function) into the table
 	*/
@@ -258,7 +273,7 @@ public:
 
 
 	/*!
-		this method sets the value of a specific object
+		this method gets the value of a specific object
 	*/
 	ErrorCode GetValue(const std::string & name, std::string & value) const
 	{
@@ -280,7 +295,7 @@ public:
 
 
 	/*!
-		this method sets the value of a specific object
+		this method gets the value of a specific object
 		(this version is used for not copying the whole string)
 	*/
 	ErrorCode GetValue(const std::string & name, const char ** value) const
@@ -303,7 +318,7 @@ public:
 
 
 	/*!
-		this method sets the value and the number of parameters
+		this method gets the value and the number of parameters
 		of a specific object
 	*/
 	ErrorCode GetValueAndParam(const std::string & name, std::string & value, int * param) const

ttmath/ttmathparser.h

@@ -1,11 +1,11 @@
 /*
- * This file is a part of TTMath Mathematical Library
+ * 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-2007, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -61,14 +61,14 @@ namespace ttmath
 /*! 
 	\brief Mathematical parser
 
-	let x will be an input string means an expression for converting:
+	let x will be an input string meaning an expression for converting:
 	
 	x = [+|-]Value[operator[+|-]Value][operator[+|-]Value]...
 	where:
 		an operator can be:
-			^ (pow)  (the highest priority)
+			^ (pow)   (the heighest priority)
 
-			* (mul) 
+			* (mul)   (or multiplication without an operator -- short mul)
 			/ (div)   (* and / have the same priority)
 
 			+ (add)
@@ -85,9 +85,23 @@ namespace ttmath
 
 			|| (logical or) (the lowest priority)
 
+		short mul:
+ 		 if the second Value (Var below) is either a variable or function there might not be 
+		 an operator between them, e.g.
+	        "[+|-]Value Var" is treated as "[+|-]Value * Var" and the multiplication
+	        has the same priority as a normal multiplication:
+			4x       = 4 * x
+			2^3m     = (2^3)* m
+			6h^3     = 6 * (h^3)
+	        2sin(pi) = 2 * sin(pi)
+			etc.
 
-		and Value can be:
-			constant e.g. 100
+		Value can be:
+			constant e.g. 100, can be preceded by operators for changing the base (radix): [#|&]
+			                   # - hex
+							   & - bin
+							   sample: #10  = 16
+							           &10  = 2
 			variable e.g. pi
 			another expression between brackets e.g (x)
 			function e.g. sin(x)
@@ -106,6 +120,11 @@ namespace ttmath
 		                 for separating parameters
 	    "1 < 2"  (the result will be: 1)
 	    "4 < 3"  (the result will be: 0)
+		"2+x"    (of course if the variable 'x' is defined)
+		"4x+10"
+		"#20+10"     = 32 + 10 = 42
+		"10 ^ -&101" = 10 ^ -5 = 0.00001
+		"8 * -&10"   = 8 * -2  = -16
 		etc.
 
 	we can also use a semicolon for separating any 'x' input strings
@@ -122,13 +141,15 @@ class Parser
 private:
 
 /*!
-	there are 5 mathematical operators as follows:
+	there are 5 mathematical operators as follows (with their standard priorities):
 		add (+)
 		sub (-)
 		mul (*)
 		div (/)
 		pow (^)
-	with their standard priorities
+		and 'shortmul' used when there is no any operators between
+		a first parameter and a variable or function
+		(the 'shortmul' has the same priority as the normal multiplication )
 */
 	class MatOperator
 	{
@@ -136,7 +157,7 @@ private:
 
 		enum Type
 		{
-			none,add,sub,mul,div,pow,lt,gt,let,get,eq,neq,lor,land
+			none,add,sub,mul,div,pow,lt,gt,let,get,eq,neq,lor,land,shortmul
 		};
 
 
@@ -173,6 +194,7 @@ private:
 				break;
 
 			case mul:
+			case shortmul:
 			case div:
 				priority = 12;
 				break;
@@ -296,11 +318,21 @@ const char * pstring;
 
 
 /*!
-	the base of the mathematic system (for example it may be '10')
+	the base (radix) of the mathematic system (for example it may be '10')
 */
 int base;
 
 
+/*!
+	the unit of angles used in: sin,cos,tan,cot,asin,acos,atan,acot
+	0 - deg
+	1 - rad (default)
+	2 - grad
+*/
+int deg_rad_grad;
+
+
+
 /*!
 	a pointer to an object which tell us whether we should stop calculating or not
 */
@@ -393,7 +425,6 @@ typedef std::map<std::string, pfunction_var> VariablesTable;
 VariablesTable variables_table;
 
 
-
 /*!
 	you can't calculate the factorial if the argument is greater than 'factorial_max'
 	default value is zero which means there are not any limitations
@@ -410,8 +441,6 @@ static void Error(ErrorCode code)
 }
 
 
-
-
 /*!
 	this method skips the white character from the string
 
@@ -424,9 +453,8 @@ void SkipWhiteCharacters()
 }
 
 
-
 /*!
-	a auxiliary method for RecurrenceParsingVariablesOrFunction(...)
+	an auxiliary method for RecurrenceParsingVariablesOrFunction(...)
 */
 void RecurrenceParsingVariablesOrFunction_CheckStopCondition(bool variable, const std::string & name)
 {
@@ -444,7 +472,7 @@ void RecurrenceParsingVariablesOrFunction_CheckStopCondition(bool variable, cons
 
 
 /*!
-	a auxiliary method for RecurrenceParsingVariablesOrFunction(...)
+	an auxiliary method for RecurrenceParsingVariablesOrFunction(...)
 */
 void RecurrenceParsingVariablesOrFunction_AddName(bool variable, const std::string & name)
 {
@@ -454,8 +482,9 @@ void RecurrenceParsingVariablesOrFunction_AddName(bool variable, const std::stri
 		visited_functions.insert( name );
 }
 
+
 /*!
-	a auxiliary method for RecurrenceParsingVariablesOrFunction(...)
+	an auxiliary method for RecurrenceParsingVariablesOrFunction(...)
 */
 void RecurrenceParsingVariablesOrFunction_DeleteName(bool variable, const std::string & name)
 {
@@ -465,6 +494,7 @@ void RecurrenceParsingVariablesOrFunction_DeleteName(bool variable, const std::s
 		visited_functions.erase( name );
 }
 
+
 /*!
 	this method returns the value of a variable or function
 	by creating a new instance of the mathematical parser 
@@ -599,7 +629,53 @@ private:
 
 
 /*!
-	'silnia' in polish language
+	used by: sin,cos,tan,cot
+*/
+ValueType ConvertAngleToRad(const ValueType & input)
+{
+	if( deg_rad_grad == 1 ) // rad
+		return input;
+
+	ValueType result;
+	ErrorCode err;
+
+	if( deg_rad_grad == 0 ) // deg
+		result = ttmath::DegToRad(input, &err);
+	else // grad
+		result = ttmath::GradToRad(input, &err);
+
+	if( err != err_ok )
+		Error( err );
+
+return result;
+}
+
+
+/*!
+	used by: asin,acos,atan,acot
+*/
+ValueType ConvertRadToAngle(const ValueType & input)
+{
+	if( deg_rad_grad == 1 ) // rad
+		return input;
+
+	ValueType result;
+	ErrorCode err;
+
+	if( deg_rad_grad == 0 ) // deg
+		result = ttmath::RadToDeg(input, &err);
+	else // grad
+		result = ttmath::RadToGrad(input, &err);
+
+	if( err != err_ok )
+		Error( err );
+
+return result;
+}
+
+
+/*!
+	factorial
 	result = 1 * 2 * 3 * 4 * .... * x
 */
 void Factorial(int sindex, int amount_of_args, ValueType & result)
@@ -632,7 +708,11 @@ void Sin(int sindex, int amount_of_args, ValueType & result)
 	if( amount_of_args != 1 )
 		Error( err_improper_amount_of_arguments );
 
-	result = ttmath::Sin(stack[sindex].value);
+	ErrorCode err;
+	result = ttmath::Sin( ConvertAngleToRad(stack[sindex].value), &err );
+
+	if(err != err_ok)
+		Error( err );
 }
 
 void Cos(int sindex, int amount_of_args, ValueType & result)
@@ -640,7 +720,11 @@ void Cos(int sindex, int amount_of_args, ValueType & result)
 	if( amount_of_args != 1 )
 		Error( err_improper_amount_of_arguments );
 
-	result = ttmath::Cos(stack[sindex].value);
+	ErrorCode err;
+	result = ttmath::Cos( ConvertAngleToRad(stack[sindex].value), &err );
+
+	if(err != err_ok)
+		Error( err );
 }
 
 void Tan(int sindex, int amount_of_args, ValueType & result)
@@ -649,7 +733,7 @@ void Tan(int sindex, int amount_of_args, ValueType & result)
 		Error( err_improper_amount_of_arguments );
 
 	ErrorCode err;
-	result = ttmath::Tan(stack[sindex].value, &err);
+	result = ttmath::Tan(ConvertAngleToRad(stack[sindex].value), &err);
 
 	if(err != err_ok)
 		Error( err );
@@ -661,7 +745,7 @@ void Cot(int sindex, int amount_of_args, ValueType & result)
 		Error( err_improper_amount_of_arguments );
 
 	ErrorCode err;
-	result = ttmath::Cot(stack[sindex].value, &err);
+	result = ttmath::Cot(ConvertAngleToRad(stack[sindex].value), &err);
 
 	if(err != err_ok)
 		Error( err );
@@ -681,7 +765,10 @@ void Round(int sindex, int amount_of_args, ValueType & result)
 	if( amount_of_args != 1 )
 		Error( err_improper_amount_of_arguments );
 
-	result = ttmath::Round(stack[sindex].value);
+	result = stack[sindex].value;
+
+	if( result.Round() )
+		Error( err_overflow );
 }
 
 
@@ -766,10 +853,12 @@ void ASin(int sindex, int amount_of_args, ValueType & result)
 		Error( err_improper_amount_of_arguments );
 
 	ErrorCode err;
-	result = ttmath::ASin(stack[sindex].value, &err);
+	ValueType temp = ttmath::ASin(stack[sindex].value, &err);
 
 	if(err != err_ok)
 		Error( err );
+
+	result = ConvertRadToAngle(temp);
 }
 
 
@@ -779,10 +868,12 @@ void ACos(int sindex, int amount_of_args, ValueType & result)
 		Error( err_improper_amount_of_arguments );
 
 	ErrorCode err;
-	result = ttmath::ACos(stack[sindex].value, &err);
+	ValueType temp = ttmath::ACos(stack[sindex].value, &err);
 
 	if(err != err_ok)
 		Error( err );
+
+	result = ConvertRadToAngle(temp);
 }
 
 
@@ -791,7 +882,7 @@ void ATan(int sindex, int amount_of_args, ValueType & result)
 	if( amount_of_args != 1 )
 		Error( err_improper_amount_of_arguments );
 
-	result = ttmath::ATan(stack[sindex].value);
+	result = ConvertRadToAngle(ttmath::ATan(stack[sindex].value));
 }
 
 
@@ -800,7 +891,7 @@ void ACot(int sindex, int amount_of_args, ValueType & result)
 	if( amount_of_args != 1 )
 		Error( err_improper_amount_of_arguments );
 
-	result = ttmath::ACot(stack[sindex].value);
+	result = ConvertRadToAngle(ttmath::ACot(stack[sindex].value));
 }
 
 
@@ -893,7 +984,7 @@ void Not(int sindex, int amount_of_args, ValueType & result)
 
 void DegToRad(int sindex, int amount_of_args, ValueType & result)
 {
-	ErrorCode err;
+	ErrorCode err = err_ok;
 
 	if( amount_of_args == 1 )
 	{
@@ -941,6 +1032,72 @@ void DegToDeg(int sindex, int amount_of_args, ValueType & result)
 		Error( err );
 }
 
+
+void GradToRad(int sindex, int amount_of_args, ValueType & result)
+{
+	ErrorCode err;
+
+	if( amount_of_args != 1 )
+		Error( err_improper_amount_of_arguments );
+	
+	result = ttmath::GradToRad(stack[sindex].value, &err);
+
+	if( err != err_ok )
+		Error( err );
+}
+
+
+void RadToGrad(int sindex, int amount_of_args, ValueType & result)
+{
+	ErrorCode err;
+
+	if( amount_of_args != 1 )
+		Error( err_improper_amount_of_arguments );
+	
+	result = ttmath::RadToGrad(stack[sindex].value, &err);
+
+	if( err != err_ok )
+		Error( err );
+}
+
+
+void DegToGrad(int sindex, int amount_of_args, ValueType & result)
+{
+	ErrorCode err = err_ok;
+
+	if( amount_of_args == 1 )
+	{
+		result = ttmath::DegToGrad(stack[sindex].value, &err);
+	}
+	else
+	if( amount_of_args == 3 )
+	{
+		result = ttmath::DegToGrad(	stack[sindex].value, stack[sindex+2].value,
+									stack[sindex+4].value, &err);
+	}
+	else
+		Error( err_improper_amount_of_arguments );
+
+
+	if( err != err_ok )
+		Error( err );
+}
+
+
+void GradToDeg(int sindex, int amount_of_args, ValueType & result)
+{
+	ErrorCode err;
+
+	if( amount_of_args != 1 )
+		Error( err_improper_amount_of_arguments );
+	
+	result = ttmath::GradToDeg(stack[sindex].value, &err);
+
+	if( err != err_ok )
+		Error( err );
+}
+
+
 void Ceil(int sindex, int amount_of_args, ValueType & result)
 {
 	if( amount_of_args != 1 )
@@ -1158,6 +1315,35 @@ void BitXor(int sindex, int amount_of_args, ValueType & result)
 	}
 }
 
+
+void Sum(int sindex, int amount_of_args, ValueType & result)
+{
+	if( amount_of_args == 0 )
+		Error( err_improper_amount_of_arguments );
+
+	result = stack[sindex].value;
+
+	for(int i=1 ; i<amount_of_args ; ++i )
+		if( result.Add( stack[ sindex + i*2 ].value ) )
+			Error( err_overflow );
+}	
+
+void Avg(int sindex, int amount_of_args, ValueType & result)
+{
+	if( amount_of_args == 0 )
+		Error( err_improper_amount_of_arguments );
+
+	result = stack[sindex].value;
+
+	for(int i=1 ; i<amount_of_args ; ++i )
+		if( result.Add( stack[ sindex + i*2 ].value ) )
+			Error( err_overflow );
+
+	if( result.Div( amount_of_args ) )
+		Error( err_overflow );
+}	
+
+
 /*!
 	this method returns the value from a user-defined function
 
@@ -1235,27 +1421,27 @@ void CallFunction(const std::string & function_name, int amount_of_args, int sin
 
 
 /*!
-	insert a function to the functions' table
+	inserting a function to the functions' table
 
 	function_name - name of the function
 	pf - pointer to the function (to the wrapper)
 */
-void InsertFunctionToTable(const std::string & function_name, pfunction pf)
+void InsertFunctionToTable(const char * function_name, pfunction pf)
 {
-	functions_table.insert( std::make_pair(function_name, pf));
+	functions_table.insert( std::make_pair(std::string(function_name), pf));
 }
 
 
 /*!
-	insert a function to the variables' table
+	inserting a function to the variables' table
 	(this function returns value of variable)
 
 	variable_name - name of the function
 	pf - pointer to the function
 */
-void InsertVariableToTable(const std::string & variable_name, pfunction_var pf)
+void InsertVariableToTable(const char * variable_name, pfunction_var pf)
 {
-	variables_table.insert( std::make_pair(variable_name, pf));
+	variables_table.insert( std::make_pair(std::string(variable_name), pf));
 }
 
 
@@ -1267,76 +1453,82 @@ void CreateFunctionsTable()
 	/*
 		names of functions should consist of small letters
 	*/
-	InsertFunctionToTable(std::string("factorial"), &Parser<ValueType>::Factorial);
-	InsertFunctionToTable(std::string("abs"),   	&Parser<ValueType>::Abs);
-	InsertFunctionToTable(std::string("sin"),   	&Parser<ValueType>::Sin);
-	InsertFunctionToTable(std::string("cos"),   	&Parser<ValueType>::Cos);
-	InsertFunctionToTable(std::string("tan"),   	&Parser<ValueType>::Tan);
-	InsertFunctionToTable(std::string("tg"),	   	&Parser<ValueType>::Tan);
-	InsertFunctionToTable(std::string("cot"),  		&Parser<ValueType>::Cot);
-	InsertFunctionToTable(std::string("ctg"),  		&Parser<ValueType>::Cot);
-	InsertFunctionToTable(std::string("int"),   	&Parser<ValueType>::Int);
-	InsertFunctionToTable(std::string("round"), 	&Parser<ValueType>::Round);
-	InsertFunctionToTable(std::string("ln"),    	&Parser<ValueType>::Ln);
-	InsertFunctionToTable(std::string("log"),   	&Parser<ValueType>::Log);
-	InsertFunctionToTable(std::string("exp"),   	&Parser<ValueType>::Exp);
-	InsertFunctionToTable(std::string("max"),   	&Parser<ValueType>::Max);
-	InsertFunctionToTable(std::string("min"),   	&Parser<ValueType>::Min);
-	InsertFunctionToTable(std::string("asin"),   	&Parser<ValueType>::ASin);
-	InsertFunctionToTable(std::string("acos"),   	&Parser<ValueType>::ACos);
-	InsertFunctionToTable(std::string("atan"),   	&Parser<ValueType>::ATan);
-	InsertFunctionToTable(std::string("atg"),   	&Parser<ValueType>::ATan);
-	InsertFunctionToTable(std::string("acot"),   	&Parser<ValueType>::ACot);
-	InsertFunctionToTable(std::string("actg"),   	&Parser<ValueType>::ACot);
-	InsertFunctionToTable(std::string("sgn"),   	&Parser<ValueType>::Sgn);
-	InsertFunctionToTable(std::string("mod"),   	&Parser<ValueType>::Mod);
-	InsertFunctionToTable(std::string("if"),   		&Parser<ValueType>::If);
-	InsertFunctionToTable(std::string("or"),   		&Parser<ValueType>::Or);
-	InsertFunctionToTable(std::string("and"),  		&Parser<ValueType>::And);
-	InsertFunctionToTable(std::string("not"),  		&Parser<ValueType>::Not);
-	InsertFunctionToTable(std::string("degtorad"),	&Parser<ValueType>::DegToRad);
-	InsertFunctionToTable(std::string("radtodeg"),	&Parser<ValueType>::RadToDeg);
-	InsertFunctionToTable(std::string("degtodeg"),	&Parser<ValueType>::DegToDeg);
-	InsertFunctionToTable(std::string("ceil"),		&Parser<ValueType>::Ceil);
-	InsertFunctionToTable(std::string("floor"),		&Parser<ValueType>::Floor);
-	InsertFunctionToTable(std::string("sqrt"),		&Parser<ValueType>::Sqrt);
-	InsertFunctionToTable(std::string("sinh"),		&Parser<ValueType>::Sinh);
-	InsertFunctionToTable(std::string("cosh"),		&Parser<ValueType>::Cosh);
-	InsertFunctionToTable(std::string("tanh"),		&Parser<ValueType>::Tanh);
-	InsertFunctionToTable(std::string("tgh"),		&Parser<ValueType>::Tanh);
-	InsertFunctionToTable(std::string("coth"),		&Parser<ValueType>::Coth);
-	InsertFunctionToTable(std::string("ctgh"),		&Parser<ValueType>::Coth);
-	InsertFunctionToTable(std::string("root"),		&Parser<ValueType>::Root);
-	InsertFunctionToTable(std::string("asinh"),		&Parser<ValueType>::ASinh);
-	InsertFunctionToTable(std::string("acosh"),		&Parser<ValueType>::ACosh);
-	InsertFunctionToTable(std::string("atanh"),		&Parser<ValueType>::ATanh);
-	InsertFunctionToTable(std::string("atgh"),		&Parser<ValueType>::ATanh);
-	InsertFunctionToTable(std::string("acoth"),		&Parser<ValueType>::ACoth);
-	InsertFunctionToTable(std::string("actgh"),		&Parser<ValueType>::ACoth);
-	InsertFunctionToTable(std::string("bitand"),	&Parser<ValueType>::BitAnd);
-	InsertFunctionToTable(std::string("bitor"),		&Parser<ValueType>::BitOr);
-	InsertFunctionToTable(std::string("bitxor"),	&Parser<ValueType>::BitXor);
-	InsertFunctionToTable(std::string("band"),		&Parser<ValueType>::BitAnd);
-	InsertFunctionToTable(std::string("bor"),		&Parser<ValueType>::BitOr);
-	InsertFunctionToTable(std::string("bxor"),		&Parser<ValueType>::BitXor);
+	InsertFunctionToTable("factorial",	&Parser<ValueType>::Factorial);
+	InsertFunctionToTable("abs",   		&Parser<ValueType>::Abs);
+	InsertFunctionToTable("sin",   		&Parser<ValueType>::Sin);
+	InsertFunctionToTable("cos",   		&Parser<ValueType>::Cos);
+	InsertFunctionToTable("tan",   		&Parser<ValueType>::Tan);
+	InsertFunctionToTable("tg",		  	&Parser<ValueType>::Tan);
+	InsertFunctionToTable("cot",  		&Parser<ValueType>::Cot);
+	InsertFunctionToTable("ctg",  		&Parser<ValueType>::Cot);
+	InsertFunctionToTable("int",	   	&Parser<ValueType>::Int);
+	InsertFunctionToTable("round",	 	&Parser<ValueType>::Round);
+	InsertFunctionToTable("ln",	    	&Parser<ValueType>::Ln);
+	InsertFunctionToTable("log",	   	&Parser<ValueType>::Log);
+	InsertFunctionToTable("exp",	   	&Parser<ValueType>::Exp);
+	InsertFunctionToTable("max",	   	&Parser<ValueType>::Max);
+	InsertFunctionToTable("min",	   	&Parser<ValueType>::Min);
+	InsertFunctionToTable("asin",   	&Parser<ValueType>::ASin);
+	InsertFunctionToTable("acos",   	&Parser<ValueType>::ACos);
+	InsertFunctionToTable("atan",   	&Parser<ValueType>::ATan);
+	InsertFunctionToTable("atg",	   	&Parser<ValueType>::ATan);
+	InsertFunctionToTable("acot",   	&Parser<ValueType>::ACot);
+	InsertFunctionToTable("actg",   	&Parser<ValueType>::ACot);
+	InsertFunctionToTable("sgn",   		&Parser<ValueType>::Sgn);
+	InsertFunctionToTable("mod",   		&Parser<ValueType>::Mod);
+	InsertFunctionToTable("if",   		&Parser<ValueType>::If);
+	InsertFunctionToTable("or",   		&Parser<ValueType>::Or);
+	InsertFunctionToTable("and",  		&Parser<ValueType>::And);
+	InsertFunctionToTable("not",  		&Parser<ValueType>::Not);
+	InsertFunctionToTable("degtorad",	&Parser<ValueType>::DegToRad);
+	InsertFunctionToTable("radtodeg",	&Parser<ValueType>::RadToDeg);
+	InsertFunctionToTable("degtodeg",	&Parser<ValueType>::DegToDeg);
+	InsertFunctionToTable("gradtorad",	&Parser<ValueType>::GradToRad);
+	InsertFunctionToTable("radtograd",	&Parser<ValueType>::RadToGrad);
+	InsertFunctionToTable("degtograd",	&Parser<ValueType>::DegToGrad);
+	InsertFunctionToTable("gradtodeg",	&Parser<ValueType>::GradToDeg);
+	InsertFunctionToTable("ceil",		&Parser<ValueType>::Ceil);
+	InsertFunctionToTable("floor",		&Parser<ValueType>::Floor);
+	InsertFunctionToTable("sqrt",		&Parser<ValueType>::Sqrt);
+	InsertFunctionToTable("sinh",		&Parser<ValueType>::Sinh);
+	InsertFunctionToTable("cosh",		&Parser<ValueType>::Cosh);
+	InsertFunctionToTable("tanh",		&Parser<ValueType>::Tanh);
+	InsertFunctionToTable("tgh",		&Parser<ValueType>::Tanh);
+	InsertFunctionToTable("coth",		&Parser<ValueType>::Coth);
+	InsertFunctionToTable("ctgh",		&Parser<ValueType>::Coth);
+	InsertFunctionToTable("root",		&Parser<ValueType>::Root);
+	InsertFunctionToTable("asinh",		&Parser<ValueType>::ASinh);
+	InsertFunctionToTable("acosh",		&Parser<ValueType>::ACosh);
+	InsertFunctionToTable("atanh",		&Parser<ValueType>::ATanh);
+	InsertFunctionToTable("atgh",		&Parser<ValueType>::ATanh);
+	InsertFunctionToTable("acoth",		&Parser<ValueType>::ACoth);
+	InsertFunctionToTable("actgh",		&Parser<ValueType>::ACoth);
+	InsertFunctionToTable("bitand",		&Parser<ValueType>::BitAnd);
+	InsertFunctionToTable("bitor",		&Parser<ValueType>::BitOr);
+	InsertFunctionToTable("bitxor",		&Parser<ValueType>::BitXor);
+	InsertFunctionToTable("band",		&Parser<ValueType>::BitAnd);
+	InsertFunctionToTable("bor",		&Parser<ValueType>::BitOr);
+	InsertFunctionToTable("bxor",		&Parser<ValueType>::BitXor);
+	InsertFunctionToTable("sum",		&Parser<ValueType>::Sum);
+	InsertFunctionToTable("avg",		&Parser<ValueType>::Avg);
 }
 
 
 /*!
-	this method create the table of variables
+	this method creates the table of variables
 */
 void CreateVariablesTable()
 {
 	/*
 		names of variables should consist of small letters
 	*/
-	InsertVariableToTable(std::string("pi"), &ValueType::SetPi);
-	InsertVariableToTable(std::string("e"),  &ValueType::SetE);
+	InsertVariableToTable("pi", &ValueType::SetPi);
+	InsertVariableToTable("e",  &ValueType::SetE);
 }
 
 
 /*!
-	convert from a big letter to a small one
+	converting from a big letter to a small one
 */
 int ToLowerCase(int c)
 {
@@ -1347,8 +1539,6 @@ return c;
 }
 
 
-
-
 /*!
 	this method read the name of a variable or a function
 	
@@ -1365,29 +1555,31 @@ int character;
 
 
 	result.erase();
-	character = ToLowerCase(*pstring);
+	character = *pstring;
 
 	/*
-		the first letter must be from range 'a' - 'z'
+		the first letter must be from range 'a' - 'z' or 'A' - 'Z'
 	*/
-	if( character<'a' || character>'z' )
+	if( ! (( character>='a' && character<='z' ) || ( character>='A' && character<='Z' )) )
 		Error( err_unknown_character );
 
 
 	do
 	{
-		result   += character;
-		character = ToLowerCase( * ++pstring );
+		result   += static_cast<char>( character );
+		character = * ++pstring;
 	}
 	while(	(character>='a' && character<='z') ||
-			(character>='0' && character<='9')	);
+			(character>='A' && character<='Z') ||
+			(character>='0' && character<='9') ||
+			character=='_' );
 	
 
 	SkipWhiteCharacters();
 	
 
 	/*
-		if there's character '(' that means this name is a name of a function
+		if there's a character '(' that means this name is a name of a function
 	*/
 	if( *pstring == '(' )
 	{
@@ -1456,17 +1648,20 @@ return is_it_name_of_function;
 /*!
 	we're reading a numerical value directly from the string
 */
-void ReadValue(Item & result)
+void ReadValue(Item & result, int reading_base)
 {
 const char * new_stack_pointer;
+bool value_read;
 
-	int carry = result.value.FromString(pstring, base, &new_stack_pointer);
+	int carry = result.value.FromString(pstring, reading_base, &new_stack_pointer, &value_read);
 	pstring   = new_stack_pointer;
 
 	if( carry )
 		Error( err_overflow );
-}
 
+	if( !value_read )
+		Error( err_unknown_character );
+}
 
 
 /*!
@@ -1494,6 +1689,24 @@ return c;
 }
 
 
+/*!
+	this method returns true if 'character' is a proper first digit for the value (or a comma -- can be first too)
+*/
+bool ValueStarts(int character, int base)
+{
+	if( character == TTMATH_COMMA_CHARACTER_1 )
+		return true;
+
+	if( TTMATH_COMMA_CHARACTER_2 != 0 && character == TTMATH_COMMA_CHARACTER_2 )
+		return true;
+
+	if( CharToDigit(character, base) != -1 )
+		return true;
+
+return false;
+}
+
+
 /*!
 	we're reading the item
   
@@ -1553,16 +1766,33 @@ int  character;
 	return 2;
 	}
 	else
-	if( character=='#' || character=='&' || CharToDigit(character, base)!=-1 )
+	if( character == '#' )
 	{
-		/*
-			warning:
-			if we're using for example the base equal 16
-			we can find a first character like 'e' that is there is not e=2.71..
-			but the value 14, for this case we must use something like var::e for variables
-			(not implemented yet)
-		*/
-		ReadValue( result );
+		++pstring;
+		SkipWhiteCharacters();
+
+		// after '#' character we do not allow '-' or '+' (can be white characters)
+		if(	ValueStarts(*pstring, 16) )
+			ReadValue( result, 16 );
+		else
+			Error( err_unknown_character );
+	}
+	else
+	if( character == '&' )
+	{
+		++pstring;
+		SkipWhiteCharacters();
+
+		// after '&' character we do not allow '-' or '+' (can be white characters)
+		if(	ValueStarts(*pstring, 2) )
+			ReadValue( result, 2 );
+		else
+			Error( err_unknown_character );
+	}
+	else
+	if(	ValueStarts(character, base) )
+	{
+		ReadValue( result, base );
 	}
 	else
 	if( character>='a' && character<='z' )
@@ -1598,6 +1828,7 @@ void InsertOperatorToTable(const std::string & name, typename MatOperator::Type
 	operators_table.insert( std::make_pair(name, type) );
 }
 
+
 /*!
 	this method creates the table of operators
 */
@@ -1698,6 +1929,14 @@ int ReadOperator(Item & result)
 		result.type = Item::semicolon;
 		++pstring;
 	}
+	else
+	if( (*pstring>='a' && *pstring<='z') || (*pstring>='A' && *pstring<='Z') )
+	{
+		// short mul (without any operators)
+
+		result.type = Item::mat_operator;
+		result.moperator.SetType( MatOperator::shortmul );
+	}
 	else
 		ReadMathematicalOperator(result);
 
@@ -1760,6 +1999,7 @@ int res;
 		break;
 
 	case MatOperator::mul:
+	case MatOperator::shortmul:
 		if( value1.Mul(value2) ) Error( err_overflow );
 		break;
 
@@ -1777,6 +2017,7 @@ int res;
 
 		break;
 
+
 	default:
 		/*
 			on the stack left an unknown operator but we had to recognize its before
@@ -1854,9 +2095,9 @@ void TryRollingUpStack()
 */
 int ReadValueVariableOrFunctionAndPushItIntoStack(Item & temp)
 {
-int kod = ReadValueVariableOrFunction( temp );
+int code = ReadValueVariableOrFunction( temp );
 	
-	if( kod == 0 )
+	if( code == 0 )
 	{
 		if( stack_index < stack.size() )
 			stack[stack_index] = temp;
@@ -1866,20 +2107,20 @@ int kod = ReadValueVariableOrFunction( temp );
 		++stack_index;
 	}
 
-	if( kod == 2 )
+	if( code == 2 )
 		// there was a final bracket, we didn't push it into the stack 
 		// (it'll be read by the 'ReadOperatorAndCheckFinalBracket' method next)
-		kod = 0;
+		code = 0;
 
 
-return kod;
+return code;
 }
 
 
 
 /*!
 	this method calculate how many parameters there are on the stack
-	and index of the first parameter
+	and the index of the first parameter
 
 	if there aren't any parameters on the stack this method returns
 	'size' equals zero and 'index' pointing after the first bracket
@@ -2161,6 +2402,7 @@ Parser(): default_stack_size(100)
 	puser_functions = 0;
 	pfunction_local_variables = 0;
 	base = 10;
+	deg_rad_grad = 1;
 	error = err_ok;
 	factorial_max.SetZero();
 
@@ -2180,6 +2422,7 @@ Parser<ValueType> & operator=(const Parser<ValueType> & p)
 	puser_functions   = p.puser_functions;
 	pfunction_local_variables = 0;
 	base = p.base;
+	deg_rad_grad = p.deg_rad_grad;
 	error = err_ok;
 	factorial_max = p.factorial_max;
 
@@ -2217,6 +2460,18 @@ void SetBase(int b)
 }
 
 
+/*!
+	the unit of angles used in: sin,cos,tan,cot,asin,acos,atan,acot
+	0 - deg
+	1 - rad (default)
+	2 - grad
+*/
+void SetDegRadGrad(int angle)
+{
+	if( angle >= 0 || angle <= 2 )
+		deg_rad_grad = angle;
+}
+
 /*!
 	this method sets a pointer to the object which tell us whether we should stop
 	calculations

ttmath/ttmathtypes.h

@@ -1,11 +1,11 @@
 /*
- * This file is a part of TTMath Mathematical Library
+ * 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-2007, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -64,7 +64,7 @@
 */
 #define TTMATH_MAJOR_VER		0
 #define TTMATH_MINOR_VER		8
-#define TTMATH_REVISION_VER		1
+#define TTMATH_REVISION_VER		6
 #define TTMATH_PRERELEASE_VER	0
 
 
@@ -83,7 +83,7 @@
 	 gcc -DTTMATH_RELEASE -o myprogram myprogram.cpp 
 	or by defining this macro in your code before using any header files of this library
 
-	if TTMATH_RELEASE is not set then TTMATH_DEBUG is set	
+	if TTMATH_RELEASE is not set then TTMATH_DEBUG is set automatically
 */
 #ifndef TTMATH_RELEASE
 	#define TTMATH_DEBUG
@@ -120,6 +120,20 @@ namespace ttmath
 	typedef unsigned int uint;
 	typedef signed   int sint;
 
+	/*!
+		this type is twice bigger than uint
+		(64bit on a 32bit platforms)
+
+		although C++ Standard - ANSI ISO IEC 14882:2003 doesn't define such a type (long long) 
+		but it is defined in C99 and in upcoming C++0x /3.9.1 (2)/ and many compilers support it
+
+		this type is used in UInt::MulTwoWords and UInt::DivTwoWords when macro TTMATH_NOASM is defined
+		but only on a 32bit platform
+	*/
+	#ifdef TTMATH_NOASM
+		typedef unsigned long long int ulint;
+	#endif
+
 	/*!
 		how many bits there are in the uint type
 	*/
@@ -141,7 +155,7 @@ namespace ttmath
 		which are kept in built-in variables for a Big<> type
 		(these variables are defined in ttmathbig.h)
 	*/
-	#define TTMATH_BUILTIN_VARIABLES_SIZE 128u
+	#define TTMATH_BUILTIN_VARIABLES_SIZE 256u
 
 #else
 
@@ -151,6 +165,15 @@ namespace ttmath
 	typedef unsigned long uint;
 	typedef signed   long sint;
 
+	/*!
+		on 64bit platform we do not define ulint
+		sizeof(long long) is 8 (64bit) but we need 128bit
+
+		on 64 bit platform (when there is defined TTMATH_NOASM macro)
+		methods UInt::MulTwoWords and UInt::DivTwoWords are using other algorithms than those on 32 bit
+	*/
+	//typedef unsigned long long int ulint;
+
 	/*!
 		how many bits there are in the uint type
 	*/
@@ -172,7 +195,7 @@ namespace ttmath
 		which are kept in built-in variables for a Big<> type
 		(these variables are defined in ttmathbig.h)
 	*/
-	#define TTMATH_BUILTIN_VARIABLES_SIZE 64ul
+	#define TTMATH_BUILTIN_VARIABLES_SIZE 128ul
 
 #endif
 }
@@ -182,7 +205,7 @@ namespace ttmath
 /*!
 	characters which represent the comma operator
 
-	TTMATH_COMMA_CHARACTER_1 is used in reading (parsing) and in writing
+	TTMATH_COMMA_CHARACTER_1 is used in reading (parsing) and in writing (default, can be overwritten in ToString() function)
 	TTMATH_COMMA_CHARACTER_2 can be used in reading as an auxiliary comma character
 	that means you can input values for example 1.2345 and 1,2345 as well
 
@@ -197,6 +220,7 @@ namespace ttmath
 #define TTMATH_COMMA_CHARACTER_2 ','
 
 
+
 /*!
 	this variable defines how many iterations are performed
 	during some kind of calculating when we're making any long formulas
@@ -213,6 +237,17 @@ namespace ttmath
 
 
 
+/*!
+	this is a limit when calculating Karatsuba multiplication
+	if the size of a vector is smaller than TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE
+	the Karatsuba algorithm will use standard schoolbook multiplication
+*/
+#ifdef __GNUC__
+#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 3
+#else
+#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 5
+#endif
+
 
 namespace ttmath
 {
@@ -247,7 +282,8 @@ namespace ttmath
 		err_object_exists,
 		err_unknown_object,
 		err_still_calculating,
-		err_too_big_factorial
+		err_too_big_factorial,
+		err_in_short_form_used_function
 	};
 
 
@@ -324,7 +360,7 @@ namespace ttmath
 			foo.Add(foo);
 		but there are only few methods which can do that
 	*/
-	class ReferenceError : public std::logic_error, ExceptionInfo
+	class ReferenceError : public std::logic_error, public ExceptionInfo
 	{
 	public:
 
@@ -356,7 +392,7 @@ namespace ttmath
 		the name and the line of a file where the macro TTMATH_ASSERT
 		was used)
 	*/
-	class RuntimeError : public std::runtime_error, ExceptionInfo
+	class RuntimeError : public std::runtime_error, public ExceptionInfo
 	{
 	public:
 
@@ -405,6 +441,19 @@ namespace ttmath
 	#endif
 
 
+
+	#ifdef TTMATH_DEBUG_LOG
+
+		#define TTMATH_LOG(msg) \
+			PrintLog(msg, std::cout);		
+
+	#else
+
+		#define TTMATH_LOG(msg)
+
+	#endif
+
+
 } // namespace
 
 

ttmath/ttmathuint64.h

@@ -1,986 +0,0 @@
-/*
- * This file is a part of TTMath Mathematical Library
- * and is distributed under the (new) BSD licence.
- * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
- */
-
-/* 
- * Copyright (c) 2006-2007, 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.
- */
-
-
-
-/*!
-	\file ttmathuint.h
-    \brief template class UInt<uint> for 64bit processors
-*/
-
-
-namespace ttmath
-{
-
-	/*!
-	*
-	*	basic mathematic functions
-	*
-	*/
-
-#ifdef TTMATH_PLATFORM64
-
-
-
-	/*!
-		in 64bit platforms we must define additional operators and contructors
-		in order to allow a user initializing the objects in this way:
-			UInt<...> type = 20;
-		or
-			UInt<...> type; 
-			type = 30;
-
-		decimal constants such as 20, 30 etc. are integer literal of type int,
-		if the value is greater it can even be long int,
-		0 is an octal integer of type int
-		(ISO 14882 p2.13.1 Integer literals)
-	*/
-
-	/*!
-		this operator converts the unsigned int type to this class
-
-		***this operator is created only on a 64bit platform***
-		it takes one argument of 32bit
-	*/
-	template<uint value_size>
-	UInt<value_size> & UInt<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
-	*/
-	template<uint value_size>
-	UInt<value_size>::UInt(unsigned int i)
-	{
-		FromUInt(uint(i));
-	}
-
-
-	/*!
-		an operator for converting the signed int to this class
-
-		***this constructor is created only on a 64bit platform***
-		it takes one argument of 32bit
-
-		look at the description of UInt::operator=(sint)
-	*/
-	template<uint value_size>
-	UInt<value_size> & UInt<value_size>::operator=(signed int i)
-	{
-		FromUInt(uint(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
-
-		look at the description of UInt::operator=(sint)
-	*/
-	template<uint value_size>
-	UInt<value_size>::UInt(signed int i)
-	{
-		FromUInt(uint(i));
-	}
-
-
-
-	/*!
-		this method copies the value stored in an another table
-		(warning: first values in temp_table are the highest words -- it's different
-		from our table)
-
-		***this method is created only on a 64bit platform***
-
-		we copy as many words as it is possible
-		
-		if temp_table_len is bigger than value_size we'll try to round 
-		the lowest word from table depending on the last not used bit in temp_table
-		(this rounding isn't a perfect rounding -- look at the description below)
-
-		and if temp_table_len is smaller than value_size we'll clear the rest words
-		in the table
-
-		warning: we're using 'temp_table' as a pointer at 32bit words
-	*/
-	template<uint value_size>
-	void UInt<value_size>::SetFromTable(const unsigned int * temp_table, uint temp_table_len)
-	{
-		uint temp_table_index = 0;
-		sint i; // 'i' with a sign
-
-		for(i=value_size-1 ; i>=0 && temp_table_index<temp_table_len; --i, ++temp_table_index)
-		{
-			table[i] = uint(temp_table[ temp_table_index ]) << 32;
-
-			++temp_table_index;
-
-			if( temp_table_index<temp_table_len )
-				table[i] |= temp_table[ temp_table_index ];
-		}
-
-
-		// rounding mantissa
-		if( temp_table_index < temp_table_len )
-		{
-			if( (temp_table[temp_table_index] & TTMATH_UINT_HIGHEST_BIT) != 0 )
-			{
-				/*
-					very simply rounding
-					if the bit from not used last word from temp_table is set to one
-					we're rouding the lowest word in the table
-
-					in fact there should be a normal addition but
-					we don't use Add() or AddTwoInts() because these methods 
-					can set a carry and then there'll be a small problem
-					for optimization
-				*/
-				if( table[0] != TTMATH_UINT_MAX_VALUE )
-					++table[0];
-			}
-		}
-
-		// cleaning the rest of the mantissa
-		for( ; i >= 0 ; --i)
-			table[i] = 0;
-	}
-
-
-
-	/*!
-		this method adding ss2 to the this and adding carry if it's defined
-		(this = this + ss2 + c)
-
-		***this method is created only on a 64bit platform***
-
-		c must be zero or one (might be a bigger value than 1)
-		function returns carry (1) (if it was)
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::Add(const UInt<value_size> & ss2, uint c)
-	{
-	register uint b = value_size;
-	register uint * p1 = table;
-	register uint * p2 = const_cast<uint*>(ss2.table);
-
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-			
-
-		#ifdef __GNUC__
-			/*
-				this part should be compiled with gcc
-			*/
-			__asm__ __volatile__(
-			
-				"push %%rbx				\n"
-				"push %%rcx				\n"
-				"push %%rdx				\n"
-			
-				"movq $0, %%rax			\n"
-				"subq %%rsi, %%rax		\n"
-
-			"1:							\n"
-				"movq (%%rbx),%%rax		\n"
-				"adcq (%%rdx),%%rax		\n"
-				"movq %%rax,(%%rbx)		\n"
-				
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				
-			"loop 1b					\n"
-
-				"movq $0, %%rax			\n"
-				"adcq %%rax,%%rax		\n"
-				"movq %%rax, %%rsi		\n" 
-
-				"pop %%rdx				\n"
-				"pop %%rcx				\n"
-				"pop %%rbx				\n"
-
-				: "=S" (c)
-				: "0" (c), "c" (b), "b" (p1), "d" (p2)
-				: "%rax", "cc", "memory" );
-
-		#endif
-
-
-	
-	return c;
-	}
-
-
-
-	/*!
-		this method adds one word (at a specific position)
-		and returns a carry (if it was)
-
-		***this method is created only on a 64bit platform***
-
-
-		if we've got (value_size=3):
-			table[0] = 10;
-			table[1] = 30;
-			table[2] = 5;	
-		and we call:
-			AddInt(2,1)
-		then it'll be:
-			table[0] = 10;
-			table[1] = 30 + 2;
-			table[2] = 5;
-
-		of course if there was a carry from table[3] it would be returned
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::AddInt(uint value, uint index)
-	{
-	register uint b = value_size;
-	register uint * p1 = table;
-	register uint c;
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-			__asm__ __volatile__(
-				"push %%rbx						\n"
-				"push %%rcx						\n"
-				"push %%rdx						\n"
-
-				"subq %%rdx, %%rcx 				\n"
-
-				"leaq (%%rbx,%%rdx,8), %%rbx 	\n"
-
-				"movq %%rsi, %%rdx				\n"
-				"clc							\n"
-			"1:									\n"
-
-				"movq (%%rbx), %%rax			\n"
-				"adcq %%rdx, %%rax				\n"
-				"movq %%rax, (%%rbx)			\n"
-
-			"jnc 2f								\n"
-
-				"movq $0, %%rdx					\n"
-
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-
-			"loop 1b							\n"
-
-			"2:									\n"
-
-				"movq $0, %%rax					\n"
-				"adcq %%rax,%%rax				\n"
-
-				"pop %%rdx						\n"
-				"pop %%rcx						\n"
-				"pop %%rbx						\n"
-
-				: "=a" (c)
-				: "c" (b), "d" (index), "b" (p1), "S" (value)
-				: "cc", "memory" );
-
-		#endif
-
-	
-	return c;
-	}
-
-
-
-	/*!
-		this method adds only two unsigned words to the existing value
-		and these words begin on the 'index' position
-		(it's used in the multiplication algorithm 2)
-
-		***this method is created only on a 64bit platform***
-
-		index should be equal or smaller than value_size-2 (index <= value_size-2)
-		x1 - lower word, x2 - higher word
-
-		for example if we've got value_size equal 4 and:
-			table[0] = 3
-			table[1] = 4
-			table[2] = 5
-			table[3] = 6
-		then let
-			x1 = 10
-			x2 = 20
-		and
-			index = 1
-
-		the result of this method will be:
-			table[0] = 3
-			table[1] = 4 + x1 = 14
-			table[2] = 5 + x2 = 25
-			table[3] = 6
-		
-		and no carry at the end of table[3]
-
-		(of course if there was a carry in table[2](5+20) then 
-		this carry would be passed to the table[3] etc.)
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::AddTwoInts(uint x2, uint x1, uint index)
-	{
-	register uint b = value_size;
-	register uint * p1 = table;
-	register uint c;
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-			__asm__ __volatile__(
-			
-				"push %%rbx						\n"
-				"push %%rcx						\n"
-				"push %%rdx						\n"
-
-				"subq %%rdx, %%rcx 				\n"
-				
-				"leaq (%%rbx,%%rdx,8), %%rbx 	\n"
-
-				"movq $0, %%rdx					\n"
-
-				"movq (%%rbx), %%rax			\n"
-				"addq %%rsi, %%rax				\n"
-				"movq %%rax, (%%rbx)			\n"
-
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-
-				"movq (%%rbx), %%rax			\n"
-				"adcq %%rdi, %%rax				\n"
-				"movq %%rax, (%%rbx)			\n"
-			"jnc 2f								\n"
-
-				"dec %%rcx						\n"
-				"dec %%rcx						\n"
-			"jz 2f								\n"
-
-			"1:									\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-
-				"movq (%%rbx), %%rax			\n"
-				"adcq %%rdx, %%rax				\n"
-				"movq %%rax, (%%rbx)			\n"
-
-			"jnc 2f								\n"
-
-			"loop 1b							\n"
-
-			"2:									\n"
-
-				"movq $0, %%rax					\n"
-				"adcq %%rax,%%rax				\n"
-
-				"pop %%rdx						\n"
-				"pop %%rcx						\n"
-				"pop %%rbx						\n"
-
-				: "=a" (c)
-				: "c" (b), "d" (index), "b" (p1), "S" (x1), "D" (x2)
-				: "cc", "memory" );
-
-		#endif
-
-	
-	return c;
-	}
-
-
-
-
-
-	/*!
-		this method's subtracting ss2 from the 'this' and subtracting
-		carry if it has been defined
-		(this = this - ss2 - c)
-
-		***this method is created only on a 64bit platform***
-
-		c must be zero or one (might be a bigger value than 1)
-		function returns carry (1) (if it was)
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::Sub(const UInt<value_size> & ss2, uint c)
-	{
-	register uint b = value_size;
-	register uint * p1 = table;
-	register uint * p2 = const_cast<uint*>(ss2.table);
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-			__asm__  __volatile__(
-			
-				"push %%rbx				\n"
-				"push %%rcx				\n"
-				"push %%rdx				\n"
-
-				"movq $0, %%rax			\n"
-				"subq %%rsi, %%rax		\n"
-
-			"1:							\n"
-				"movq (%%rbx),%%rax		\n"
-				"sbbq (%%rdx),%%rax		\n"
-				"movq %%rax,(%%rbx)		\n"
-				
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				"inc %%rbx				\n"
-				
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				"inc %%rdx				\n"
-				
-			"loop 1b					\n"
-
-				"movq $0, %%rax			\n"
-				"adcq %%rax,%%rax		\n"
-				"movq %%rax, %%rsi		\n" 
-
-				"pop %%rdx				\n"
-				"pop %%rcx				\n"
-				"pop %%rbx				\n"
-
-				: "=S" (c)
-				: "0" (c), "c" (b), "b" (p1), "d" (p2)
-				: "%rax", "cc", "memory" );
-
-		#endif
-
-
-	return c;
-	}
-
-
-	/*!
-		this method subtracts one word (at a specific position)
-		and returns a carry (if it was)
-
-		***this method is created only on a 64bit platform***
-
-		if we've got (value_size=3):
-			table[0] = 10;
-			table[1] = 30;
-			table[2] = 5;	
-		and we call:
-			SubInt(2,1)
-		then it'll be:
-			table[0] = 10;
-			table[1] = 30 - 2;
-			table[2] = 5;
-
-		of course if there was a carry from table[3] it would be returned
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::SubInt(uint value, uint index)
-	{
-	register uint b = value_size;
-	register uint * p1 = table;
-	register uint c;
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-			__asm__ __volatile__(
-			
-				"push %%rbx						\n"
-				"push %%rcx						\n"
-				"push %%rdx						\n"
-
-				"subq %%rdx, %%rcx 				\n"
-
-				"leaq (%%rbx,%%rdx,8), %%rbx 	\n"
-
-				"movq %%rsi, %%rdx					\n"
-				"clc							\n"
-			"1:									\n"
-
-				"movq (%%rbx), %%rax			\n"
-				"sbbq %%rdx, %%rax				\n"
-				"movq %%rax, (%%rbx)			\n"
-
-			"jnc 2f								\n"
-
-				"movq $0, %%rdx					\n"
-
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-				"inc %%rbx						\n"
-
-			"loop 1b							\n"
-
-			"2:									\n"
-
-				"movq $0, %%rax					\n"
-				"adcq %%rax,%%rax				\n"
-
-				"pop %%rdx						\n"
-				"pop %%rcx						\n"
-				"pop %%rbx						\n"
-
-				: "=a" (c)
-				: "c" (b), "d" (index), "b" (p1), "S" (value)
-				: "cc", "memory" );
-
-		#endif
-
-	
-	return c;
-	}
-
-
-	/*!
-		this method moves all bits into the left hand side
-		return value <- this <- c
-
-		the lowest *bits* will be held the 'c' and
-		the state of one additional bit (on the left hand side)
-		will be returned
-
-		for example:
-		let this is 001010000
-		after Rcl2(3, 1) there'll be 010000111 and Rcl2 returns 1
-	
-		***this method is created only on a 64bit platform***
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::Rcl2(uint bits, uint c)
-	{
-		if( bits == 0 )
-			return 0;
-
-	TTMATH_ASSERT( bits>0 && bits<TTMATH_BITS_PER_UINT )
-
-	register sint b = value_size;
-	register uint * p1 = table;
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-		__asm__  __volatile__(
-		
-			"push %%rsi			\n"
-			
-		
-		"2:						\n"
-
-			"xorq %%rax,%%rax	\n"
-			"subq %%rdx,%%rax	\n"
-
-			"push %%rbx			\n"
-			"push %%rcx			\n"
-
-		"1:						\n"
-			"rclq $1,(%%rbx)	\n"
-			
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			"inc %%rbx			\n"
-			
-		"loop 1b				\n"
-			
-			"pop %%rcx			\n"
-			"pop %%rbx			\n"
-
-			"decq %%rsi			\n"
-
-		"jnz 2b					\n"
-
-			"movq $0, %%rdx		\n"
-			"adcq %%rdx, %%rdx	\n"
-
-			"pop %%rsi			\n"
-
-			: "=d" (c)
-			: "0" (c), "c" (b), "b" (p1), "S" (bits)
-			: "%rax", "cc", "memory" );
-
-		#endif
-
-
-	return c;
-	}
-
-
-	/*!
-		this method moves all bits into the right hand side
-		C -> this -> return value
-
-		the highest *bits* will be held the 'c' and
-		the state of one additional bit (on the right hand side)
-		will be returned
-
-		for example:
-		let this is 000000010
-		after Rcr2(2, 1) there'll be 110000000 and Rcr2 returns 1
-
-		***this method is created only on a 64bit platform***
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::Rcr2(uint bits, uint c)
-	{
-		if( bits == 0 )
-			return 0;
-
-	TTMATH_ASSERT( bits>0 && bits<TTMATH_BITS_PER_UINT )
-
-	register sint b = value_size;
-	register uint * p1 = table;
-
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-
-		#ifdef __GNUC__
-			__asm__  __volatile__(
-
-			"push %%rsi			\n"
-
-
-		"2:						\n"
-
-
-			"push %%rbx			\n"
-			"push %%rcx			\n"
-
-			"leaq (%%rbx,%%rcx,8),%%rbx  \n"
-
-			"xorq %%rax, %%rax	\n"
-			"subq %%rdx, %%rax	\n"
-
-		"1:						\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			"dec %%rbx			\n"
-			
-			"rcrq $1,(%%rbx)	\n"
-			
-		"loop 1b				\n"
-
-			"pop %%rcx			\n"
-			"pop %%rbx			\n"
-
-			"decq %%rsi			\n"
-
-		"jnz 2b					\n"
-
-			"movq $0, %%rdx		\n"
-			"adcq %%rdx,%%rdx	\n"
-
-			"pop %%rsi			\n"
-
-			: "=d" (c)
-			: "0" (c), "c" (b), "b" (p1), "S" (bits)
-			: "%rax", "cc", "memory" );
-
-		#endif
-
-
-	return c;
-	}
-
-
-	/*
-		this method returns the number of the highest set bit in one 32-bit word
-		if the 'x' is zero this method returns '-1'
-
-		***this method is created only on a 64bit platform***
-	*/
-	template<uint value_size>
-	sint UInt<value_size>::FindLeadingBitInWord(uint x)
-	{
-	register sint result;
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-			__asm__  __volatile__(
-
-
-			"bsrq %%rbx, %%rax	\n"
-			"jnz 1f				\n"
-			"movq $-1, %%rax	\n"
-		"1:						\n"
-
-			: "=a" (result)
-			: "b" (x)
-			: "cc" );
-
-		#endif
-
-
-	return result;
-	}
-
-
-	/*!
-		this method sets a special bit in the 'value'
-		and returns the result
-
-		***this method is created only on a 64bit platform***
-
-		bit is from <0,31>
-
-		e.g.
-		SetBitInWord(0,0) = 1
-		SetBitInWord(0,2) = 4
-		SetBitInWord(10, 8) = 266
-	*/
-	template<uint value_size>
-	uint UInt<value_size>::SetBitInWord(uint value, uint bit)
-	{
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-			__asm__  __volatile__(
-
-			"btsq %%rbx,%%rax	\n"
-
-			: "=a" (value)
-			: "0" (value), "b" (bit)
-			: "cc" );
-
-		#endif
-
-	return value;
-	}
-
-
-	/*!
-	 *
-	 * Multiplication
-	 *
-	 *
-	*/
-
-
-	/*!
-		multiplication: result2:result1 = a * b
-		result2 - higher word
-		result1 - lower word of the result
-	
-		this methos never returns a carry
-
-		***this method is created only on a 64bit platform***
-
-		it is an auxiliary method for version two of the multiplication algorithm
-	*/
-	template<uint value_size>
-	void UInt<value_size>::MulTwoWords(uint a, uint b, uint * result2, uint * result1)
-	{
-	/*
-		we must use these temporary variables in order to inform the compilator
-		that value pointed with result1 and result2 has changed
-
-		this has no effect in visual studio but it's usefull when
-		using gcc and options like -O
-	*/
-	register uint result1_;
-	register uint result2_;
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-
-		__asm__ __volatile__(
-		
-			"mulq %%rdx			\n"
-
-			: "=a" (result1_), "=d" (result2_)
-			: "0" (a), "1" (b)
-			: "cc" );
-
-		#endif
-
-
-		*result1 = result1_;
-		*result2 = result2_;
-	}
-
-
-
-
-	/*!
-	 *
-	 * Division
-	 *
-	 *
-	*/
-	
-
-	/*!
-		this method calculates 64bits word a:b / 32bits c (a higher, b lower word)
-		r = a:b / c and rest - remainder
-		
-		***this method is created only on a 64bit platform***
-
-		*
-		* WARNING:
-		* if r (one word) is too small for the result or c is equal zero
-		* there'll be a hardware interruption (0)
-		* and probably the end of your program
-		*
-	*/
-	template<uint value_size>
-	void UInt<value_size>::DivTwoWords(uint a,uint b, uint c, uint * r, uint * rest)
-	{
-		register uint r_;
-		register uint rest_;
-		/*
-			these variables have similar meaning like those in
-			the multiplication algorithm MulTwoWords
-		*/
-
-		#ifndef __GNUC__
-			#error "another compiler than GCC is currently not supported in 64bit mode"
-		#endif
-
-		#ifdef __GNUC__
-		
-			__asm__ __volatile__(
-
-			"divq %%rcx				\n"
-
-			: "=a" (r_), "=d" (rest_)
-			: "d" (a), "a" (b), "c" (c)
-			: "cc" );
-
-		#endif
-
-
-		*r = r_;
-		*rest = rest_;
-	}
-
-#endif
-
-} //namespace
-

ttmath/ttmathuint_noasm.h

@@ -0,0 +1,937 @@
+/*
+ * 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 headerfilettmathuint_noasm
+#define headerfilettmathuint_noasm
+
+
+#ifdef TTMATH_NOASM
+
+/*!
+	\file ttmathuint_noasm.h
+    \brief template class UInt<uint> with methods without any assembler code
+
+	this file is included at the end of ttmathuint.h
+*/
+
+
+namespace ttmath
+{
+	template<uint value_size>
+	uint UInt<value_size>::AddTwoWords(uint a, uint b, uint carry, uint * result)
+	{
+	uint temp;
+
+		if( carry == 0 )
+		{
+			temp = a + b;
+
+			if( temp < a )
+				carry = 1;
+		}
+		else
+		{
+			carry = 1;
+			temp  = a + b + carry;
+
+			if( temp > a ) // !(temp<=a)
+				carry = 0;
+		}
+
+		*result = temp;
+
+	return carry;
+	}
+
+
+
+	/*!
+		this method adding ss2 to the this and adding carry if it's defined
+		(this = this + ss2 + c)
+
+		c must be zero or one (might be a bigger value than 1)
+		function returns carry (1) (if it was)
+	*/
+	
+	template<uint value_size>
+	uint UInt<value_size>::Add(const UInt<value_size> & ss2, uint c)
+	{
+	uint i;
+
+		for(i=0 ; i<value_size ; ++i)
+			c = AddTwoWords(table[i], ss2.table[i], c, &table[i]);
+
+		TTMATH_LOG("UInt::Add")
+	
+	return c;
+	}
+
+
+	/*!
+		this method adds one word (at a specific position)
+		and returns a carry (if it was)
+
+		if we've got (value_size=3):
+			table[0] = 10;
+			table[1] = 30;
+			table[2] = 5;	
+		and we call:
+			AddInt(2,1)
+		then it'll be:
+			table[0] = 10;
+			table[1] = 30 + 2;
+			table[2] = 5;
+
+		of course if there was a carry from table[2] it would be returned
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::AddInt(uint value, uint index)
+	{
+	uint i, c;
+
+		TTMATH_ASSERT( index < value_size )
+
+
+		c = AddTwoWords(table[index], value, 0, &table[index]);
+
+		for(i=index+1 ; i<value_size && c ; ++i)
+			c = AddTwoWords(table[i], 0, c, &table[i]);
+
+		TTMATH_LOG("UInt::AddInt")
+	
+	return c;
+	}
+
+
+
+
+
+	/*!
+		this method adds only two unsigned words to the existing value
+		and these words begin on the 'index' position
+		(it's used in the multiplication algorithm 2)
+
+		index should be equal or smaller than value_size-2 (index <= value_size-2)
+		x1 - lower word, x2 - higher word
+
+		for example if we've got value_size equal 4 and:
+			table[0] = 3
+			table[1] = 4
+			table[2] = 5
+			table[3] = 6
+		then let
+			x1 = 10
+			x2 = 20
+		and
+			index = 1
+
+		the result of this method will be:
+			table[0] = 3
+			table[1] = 4 + x1 = 14
+			table[2] = 5 + x2 = 25
+			table[3] = 6
+		
+		and no carry at the end of table[3]
+
+		(of course if there was a carry in table[2](5+20) then 
+		this carry would be passed to the table[3] etc.)
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::AddTwoInts(uint x2, uint x1, uint index)
+	{
+	uint i, c;
+
+		TTMATH_ASSERT( index < value_size - 1 )
+
+
+		c = AddTwoWords(table[index],   x1, 0, &table[index]);
+		c = AddTwoWords(table[index+1], x2, c, &table[index+1]);
+
+		for(i=index+2 ; i<value_size && c ; ++i)
+			c = AddTwoWords(table[i], 0, c, &table[i]);
+
+		TTMATH_LOG("UInt::AddTwoInts")
+	
+	return c;
+	}
+
+
+
+	/*!
+		this static method addes one vector to the other
+		'ss1' is larger in size or equal to 'ss2'
+
+		ss1 points to the first (larger) vector
+		ss2 points to the second vector
+		ss1_size - size of the ss1 (and size of the result too)
+		ss2_size - size of the ss2
+		result - is the result vector (which has size the same as ss1: ss1_size)
+
+		Example:  ss1_size is 5, ss2_size is 3
+		ss1:      ss2:   result (output):
+		  5        1         5+1
+		  4        3         4+3
+		  2        7         2+7
+		  6                  6
+		  9                  9
+	  of course the carry is propagated and will be returned from the last item
+	  (this method is used by the Karatsuba multiplication algorithm)
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::AddVector(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result)
+	{
+	uint i, c = 0;
+
+		TTMATH_ASSERT( ss1_size >= ss2_size )
+		
+		for(i=0 ; i<ss2_size ; ++i)
+			c = AddTwoWords(ss1[i], ss2[i], c, &result[i]);
+
+		for( ; i<ss1_size ; ++i)
+			c = AddTwoWords(ss1[i], 0, c, &result[i]);
+
+		//TTMATH_LOG("UInt::AddVector")
+
+	return c;
+	}
+
+
+
+
+	template<uint value_size>
+	uint UInt<value_size>::SubTwoWords(uint a, uint b, uint carry, uint * result)
+	{
+		if( carry == 0 )
+		{
+			*result = a - b;
+
+			if( a < b )
+				carry = 1;
+		}
+		else
+		{
+			carry   = 1;
+			*result = a - b - carry;
+
+			if( a > b ) // !(a <= b )
+				carry = 0;
+		}
+
+	return carry;
+	}
+
+
+
+
+	/*!
+		this method's subtracting ss2 from the 'this' and subtracting
+		carry if it has been defined
+		(this = this - ss2 - c)
+
+		c must be zero or one (might be a bigger value than 1)
+		function returns carry (1) (if it was)
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::Sub(const UInt<value_size> & ss2, uint c)
+	{
+	uint i;
+
+		for(i=0 ; i<value_size ; ++i)
+			c = SubTwoWords(table[i], ss2.table[i], c, &table[i]);
+
+		TTMATH_LOG("UInt::Sub")
+
+	return c;
+	}
+
+
+
+
+	/*!
+		this method subtracts one word (at a specific position)
+		and returns a carry (if it was)
+
+		if we've got (value_size=3):
+			table[0] = 10;
+			table[1] = 30;
+			table[2] = 5;	
+		and we call:
+			SubInt(2,1)
+		then it'll be:
+			table[0] = 10;
+			table[1] = 30 - 2;
+			table[2] = 5;
+
+		of course if there was a carry from table[2] it would be returned
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::SubInt(uint value, uint index)
+	{
+	uint i, c;
+
+		TTMATH_ASSERT( index < value_size )
+
+
+		c = SubTwoWords(table[index], value, 0, &table[index]);
+
+		for(i=index+1 ; i<value_size && c ; ++i)
+			c = SubTwoWords(table[i], 0, c, &table[i]);
+
+		TTMATH_LOG("UInt::SubInt")
+	
+	return c;
+	}
+
+
+	/*!
+		this static method subtractes one vector from the other
+		'ss1' is larger in size or equal to 'ss2'
+
+		ss1 points to the first (larger) vector
+		ss2 points to the second vector
+		ss1_size - size of the ss1 (and size of the result too)
+		ss2_size - size of the ss2
+		result - is the result vector (which has size the same as ss1: ss1_size)
+
+		Example:  ss1_size is 5, ss2_size is 3
+		ss1:      ss2:   result (output):
+		  5        1         5-1
+		  4        3         4-3
+		  2        7         2-7
+		  6                  6-1  (the borrow from previous item)
+		  9                  9
+		                 return (carry): 0
+	  of course the carry (borrow) is propagated and will be returned from the last item
+	  (this method is used by the Karatsuba multiplication algorithm)
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::SubVector(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result)
+	{
+	uint i, c = 0;
+
+		TTMATH_ASSERT( ss1_size >= ss2_size )
+		
+		for(i=0 ; i<ss2_size ; ++i)
+			c = SubTwoWords(ss1[i], ss2[i], c, &result[i]);
+
+		for( ; i<ss1_size ; ++i)
+			c = SubTwoWords(ss1[i], 0, c, &result[i]);
+
+		//TTMATH_LOG("UInt::SubVector")
+
+	return c;
+	}
+
+
+
+	/*!
+		this method moves all bits into the left hand side
+		return value <- this <- c
+
+		the lowest *bit* will be held the 'c' and
+		the state of one additional bit (on the left hand side)
+		will be returned
+
+		for example:
+		let this is 001010000
+		after Rcl2_one(1) there'll be 010100001 and Rcl2_one returns 0
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::Rcl2_one(uint c)
+	{
+	uint i, new_c;
+
+		if( c != 0 )
+			c = 1;
+
+		for(i=0 ; i<value_size ; ++i)
+		{
+			new_c    = (table[i] & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
+			table[i] = (table[i] << 1) | c;
+			c        = new_c;
+		}
+
+		TTMATH_LOG("UInt::Rcl2_one")
+
+	return c;
+	}
+
+
+
+
+
+
+
+	/*!
+		this method moves all bits into the right hand side
+		c -> this -> return value
+
+		the highest *bit* will be held the 'c' and
+		the state of one additional bit (on the right hand side)
+		will be returned
+
+		for example:
+		let this is 000000010
+		after Rcr2_one(1) there'll be 100000001 and Rcr2_one returns 0
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::Rcr2_one(uint c)
+	{
+	sint i; // signed i
+	uint new_c;
+
+		if( c != 0 )
+			c = TTMATH_UINT_HIGHEST_BIT;
+
+		for(i=sint(value_size)-1 ; i>=0 ; --i)
+		{
+			new_c    = (table[i] & 1) ? TTMATH_UINT_HIGHEST_BIT : 0;
+			table[i] = (table[i] >> 1) | c;
+			c        = new_c;
+		}
+
+		TTMATH_LOG("UInt::Rcr2_one")
+
+	return c;
+	}
+
+
+
+
+	/*!
+		this method moves all bits into the left hand side
+		return value <- this <- c
+
+		the lowest *bits* will be held the 'c' and
+		the state of one additional bit (on the left hand side)
+		will be returned
+
+		for example:
+		let this is 001010000
+		after Rcl2(3, 1) there'll be 010000111 and Rcl2 returns 1
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::Rcl2(uint bits, uint c)
+	{
+		TTMATH_ASSERT( bits>0 && bits<TTMATH_BITS_PER_UINT )
+
+		uint move = TTMATH_BITS_PER_UINT - bits;
+		uint i, new_c;
+
+		if( c != 0 )
+			c = TTMATH_UINT_MAX_VALUE >> move;
+
+		for(i=0 ; i<value_size ; ++i)
+		{
+			new_c    = table[i] >> move;
+			table[i] = (table[i] << bits) | c;
+			c        = new_c;
+		}
+
+		TTMATH_LOG("UInt::Rcl2")
+
+	return (c & 1);
+	}
+
+
+
+
+	/*!
+		this method moves all bits into the right hand side
+		C -> this -> return value
+
+		the highest *bits* will be held the 'c' and
+		the state of one additional bit (on the right hand side)
+		will be returned
+
+		for example:
+		let this is 000000010
+		after Rcr2(2, 1) there'll be 110000000 and Rcr2 returns 1
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::Rcr2(uint bits, uint c)
+	{
+		TTMATH_ASSERT( bits>0 && bits<TTMATH_BITS_PER_UINT )
+
+		uint move = TTMATH_BITS_PER_UINT - bits;
+		sint i; // signed
+		uint new_c;
+
+		if( c != 0 )
+			c = TTMATH_UINT_MAX_VALUE << move;
+
+		for(i=value_size-1 ; i>=0 ; --i)
+		{
+			new_c    = table[i] << move;
+			table[i] = (table[i] >> bits) | c;
+			c        = new_c;
+		}
+
+		TTMATH_LOG("UInt::Rcr2")
+
+	return (c & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
+	}
+
+
+
+
+	/*
+		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)
+	{
+		if( x == 0 )
+			return -1;
+
+		uint bit = TTMATH_BITS_PER_UINT - 1;
+		
+		while( (x & TTMATH_UINT_HIGHEST_BIT) == 0 )
+		{
+			x = x << 1;
+			--bit;
+		}
+
+	return bit;
+	}
+
+
+
+
+
+	/*!
+		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>
+
+		e.g.
+		 uint x = 100;
+		 uint bit = SetBitInWord(x, 3);
+		 now: x = 108 and bit = 0
+	*/
+	template<uint value_size>
+	uint UInt<value_size>::SetBitInWord(uint & value, uint bit)
+	{
+		TTMATH_ASSERT( bit < TTMATH_BITS_PER_UINT )
+
+		uint mask = 1;
+
+		if( bit > 0 )
+			mask = mask << bit;
+
+		uint last = value & mask;
+		value     = value | mask;
+
+	return (last != 0) ? 1 : 0;
+	}
+
+
+
+
+
+
+	/*!
+	 *
+	 * Multiplication
+	 *
+	 *
+	*/
+
+
+	/*!
+		multiplication: result_high:result_low = a * b
+		result_high - higher word of the result
+		result_low  - lower word of the result
+	
+		this methos never returns a carry
+		this method is used in the second version of the multiplication algorithms
+	*/
+	template<uint value_size>
+	void UInt<value_size>::MulTwoWords(uint a, uint b, uint * result_high, uint * result_low)
+	{
+	#ifdef TTMATH_PLATFORM32
+
+		/*
+			on 32bit platforms we have defined 'unsigned long long int' type known as 'ulint' in ttmath namespace
+			this type has 64 bits, then we're using only one multiplication: 32bit * 32bit = 64bit
+		*/
+
+		union uint_
+		{
+			struct
+			{
+				uint low;  // 32 bits
+				uint high; // 32 bits
+			} u_;
+
+			ulint u;       // 64 bits
+		} res;
+
+		res.u = ulint(a) * ulint(b);     // multiply two 32bit words, the result has 64 bits
+
+		*result_high = res.u_.high;
+		*result_low  = res.u_.low;
+
+	#else
+
+		/*
+			64 bits platforms
+
+			we don't have a native type which has 128 bits
+			then we're splitting 'a' and 'b' to 4 parts (high and low halves)
+			and using 4 multiplications (with additions and carry correctness)
+		*/
+
+		uint_ a_;
+		uint_ b_;
+		uint_ res_high1, res_high2;
+		uint_ res_low1,  res_low2;
+		
+		a_.u = a;
+		b_.u = b;
+
+		/*
+			the multiplication is as follows (schoolbook algorithm with O(n^2) ):
+
+                                                   32 bits         32 bits
+
+                                             +--------------------------------+
+                                             |   a_.u_.high   |   a_.u_.low   |
+                                             +--------------------------------+
+                                             |   b_.u_.high   |   b_.u_.low   |
+            +--------------------------------+--------------------------------+
+            |           res_high1.u          |           res_low1.u           |
+            +--------------------------------+--------------------------------+
+            |           res_high2.u          |           res_low2.u           |
+            +--------------------------------+--------------------------------+
+
+                          64 bits                          64 bits
+		*/
+
+
+		uint_ temp;
+
+		res_low1.u        = uint(b_.u_.low) * uint(a_.u_.low);
+
+		temp.u            = uint(res_low1.u_.high) + uint(b_.u_.low) * uint(a_.u_.high);
+		res_low1.u_.high  = temp.u_.low;
+		res_high1.u_.low  = temp.u_.high;
+		res_high1.u_.high = 0;
+
+		res_low2.u_.low   = 0;
+		temp.u            = uint(b_.u_.high) * uint(a_.u_.low);
+		res_low2.u_.high  = temp.u_.low;
+
+		res_high2.u       = uint(b_.u_.high) * uint(a_.u_.high) + uint(temp.u_.high);
+
+		uint c = AddTwoWords(res_low1.u, res_low2.u, 0, &res_low2.u);
+		AddTwoWords(res_high1.u, res_high2.u, c, &res_high2.u);                 // there is no carry from here
+
+		*result_high = res_high2.u;
+		*result_low  = res_low2.u;
+
+	#endif
+	}
+
+
+
+
+	/*!
+	 *
+	 * Division
+	 *
+	 *
+	*/
+	
+
+	/*!
+		this method calculates 64bits word a:b / 32bits c (a higher, b lower word)
+		r = a:b / c and rest - remainder
+		
+		*
+		* WARNING:
+		* the c has to be suitably large for the result being keeped in one word,
+		* if c is equal zero there'll be a hardware interruption (0)
+		* and probably the end of your program
+		*
+	*/
+	template<uint value_size>
+	void UInt<value_size>::DivTwoWords(uint a, uint b, uint c, uint * r, uint * rest)
+	{
+	// (a < c ) for the result to be one word
+	TTMATH_ASSERT( c != 0 && a < c )
+
+	#ifdef TTMATH_PLATFORM32
+
+		union
+		{
+			struct
+			{
+				uint low;  // 32 bits
+				uint high; // 32 bits
+			} u_;
+
+			ulint u;       // 64 bits
+		} ab;
+
+		ab.u_.high = a;
+		ab.u_.low  = b;
+
+		*r    = uint(ab.u / c);
+		*rest = uint(ab.u % c);
+
+	#else
+
+		uint_ c_;
+		c_.u = c;
+
+
+		if( a == 0 )
+		{
+			*r    = b / c;
+			*rest = b % c;
+		}
+		else
+		if( c_.u_.high == 0 )
+		{
+			// higher half of 'c' is zero
+			// then higher half of 'a' is zero too (look at the asserts at the beginning - 'a' is smaller than 'c')
+			uint_ a_, b_, res_, temp1, temp2;
+
+			a_.u = a;
+			b_.u = b;
+
+			temp1.u_.high = a_.u_.low;
+			temp1.u_.low  = b_.u_.high;
+
+			res_.u_.high  = temp1.u / c;
+			temp2.u_.high = temp1.u % c;
+			temp2.u_.low  = b_.u_.low;
+			
+			res_.u_.low  = temp2.u / c;
+			*rest        = temp2.u % c;
+
+			*r = res_.u;
+		}
+		else
+		{
+			return DivTwoWords2(a, b, c,  r,  rest);
+		}
+
+	#endif
+	}
+
+
+#ifdef TTMATH_PLATFORM64
+
+
+	/*!
+		this method is available only on 64bit platforms
+		
+		the same algorithm like the third division algorithm in ttmathuint.h
+		but now with the radix=2^32
+	*/
+	template<uint value_size>
+	void UInt<value_size>::DivTwoWords2(uint a, uint b, uint c, uint * r, uint * rest)
+	{
+		// a is not zero
+		// c_.u_.high is not zero
+
+		uint_ a_, b_, c_, u_, q_;
+		unsigned int u3; // 32 bit
+
+		a_.u  = a;
+		b_.u  = b;
+		c_.u  = c;
+
+		// normalizing
+		uint d = DivTwoWordsNormalize(a_, b_, c_);
+
+		// loop from j=1 to j=0
+		//   the first step (for j=2) is skipped because our result is only in one word,
+		//   (first 'q' were 0 and nothing would be changed)
+		u_.u_.high = a_.u_.high;
+		u_.u_.low  = a_.u_.low;
+		u3         = b_.u_.high;
+		q_.u_.high = DivTwoWordsCalculate(u_, u3, c_);
+		MultiplySubtract(u_, u3, q_.u_.high, c_);
+		
+		u_.u_.high = u_.u_.low;
+		u_.u_.low  = u3;
+		u3         = b_.u_.low;
+		q_.u_.low  = DivTwoWordsCalculate(u_, u3, c_);
+		MultiplySubtract(u_, u3, q_.u_.low, c_);
+
+		*r = q_.u;
+
+		// unnormalizing for the remainder
+		u_.u_.high = u_.u_.low;
+		u_.u_.low  = u3;
+		*rest = DivTwoWordsUnnormalize(u_.u, d);
+	}
+
+
+
+	
+	template<uint value_size>
+	uint UInt<value_size>::DivTwoWordsNormalize(uint_ & a_, uint_ & b_, uint_ & c_)
+	{
+		uint d = 0;
+
+		for( ; (c_.u & TTMATH_UINT_HIGHEST_BIT) == 0 ; ++d )
+		{
+			c_.u = c_.u << 1;
+			
+			uint bc = b_.u & TTMATH_UINT_HIGHEST_BIT; // carry from 'b'
+
+			b_.u = b_.u << 1;
+			a_.u = a_.u << 1; // carry bits from 'a' are simply skipped 
+
+			if( bc )
+				a_.u = a_.u | 1;
+		}
+
+	return d;
+	}
+
+
+	template<uint value_size>
+	uint UInt<value_size>::DivTwoWordsUnnormalize(uint u, uint d)
+	{
+		if( d == 0 )
+			return u;
+
+		u = u >> d;
+
+	return u;
+	}
+
+
+	template<uint value_size>
+	unsigned int UInt<value_size>::DivTwoWordsCalculate(uint_ u_, unsigned int u3, uint_ v_)
+	{
+	bool next_test;
+	uint_ qp_, rp_, temp_;
+
+		qp_.u = u_.u / uint(v_.u_.high);
+		rp_.u = u_.u % uint(v_.u_.high);
+
+		TTMATH_ASSERT( qp_.u_.high==0 || qp_.u_.high==1 )
+
+		do
+		{
+			bool decrease = false;
+
+			if( qp_.u_.high == 1 )
+				decrease = true;
+			else
+			{
+				temp_.u_.high = rp_.u_.low;
+				temp_.u_.low  = u3;
+
+				if( qp_.u * uint(v_.u_.low) > temp_.u )
+					decrease = true;
+			}
+			
+			next_test = false;
+
+			if( decrease )
+			{
+				--qp_.u;
+				rp_.u += v_.u_.high;
+
+				if( rp_.u_.high == 0 ) 
+					next_test = true;
+			}
+		}
+		while( next_test );
+
+	return qp_.u_.low;
+	}
+
+
+	template<uint value_size>
+	void UInt<value_size>::MultiplySubtract(uint_ & u_, unsigned int & u3, unsigned int & q, uint_ v_)
+	{
+	uint_ temp_;
+		
+		uint res_high;
+		uint res_low;
+
+		MulTwoWords(v_.u, q, &res_high, &res_low);
+
+		uint_ sub_res_high_;
+		uint_ sub_res_low_;
+
+		temp_.u_.high = u_.u_.low;
+		temp_.u_.low  = u3;
+
+		uint c = SubTwoWords(temp_.u, res_low, 0, &sub_res_low_.u);
+			
+		temp_.u_.high = 0;
+		temp_.u_.low  = u_.u_.high;
+		c = SubTwoWords(temp_.u, res_high, c, &sub_res_high_.u);
+
+		if( c )
+		{
+			--q;
+
+			c = AddTwoWords(sub_res_low_.u, v_.u, 0, &sub_res_low_.u);
+			AddTwoWords(sub_res_high_.u, 0, c, &sub_res_high_.u);
+		}
+
+		u_.u_.high = sub_res_high_.u_.low;
+		u_.u_.low  = sub_res_low_.u_.high;
+		u3         = sub_res_low_.u_.low;
+	}
+
+#endif // #ifdef TTMATH_PLATFORM64
+
+
+
+} //namespace
+
+
+#endif //ifdef TTMATH_NOASM
+#endif
+
+
+
+