From a8eb29e57d5d768371163d287d22e15e0f4c52ca Mon Sep 17 00:00:00 2001 From: Tomasz Sowa Date: Sat, 3 Oct 2009 01:10:08 +0000 Subject: [PATCH] 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::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 added: macros: TTMATH_LOGC(msg, carry) TTMATH_VECTOR_LOG(msg, vector, len) TTMATH_VECTOR_LOGC(msg, carry, vector, len) added: UInt::PrintVectorLog() for debugging purposes changed: UInt<> class uses new log macros git-svn-id: svn://ttmath.org/publicrep/ttmath/trunk@203 e52654a7-88a9-db11-a3e9-0013d4bc506e --- CHANGELOG | 781 +++++++++++++++++++------------------ ttmath/ttmathtypes.h | 8 +- ttmath/ttmathuint.h | 230 ++++++----- ttmath/ttmathuint_noasm.h | 42 +- ttmath/ttmathuint_x86.h | 22 +- ttmath/ttmathuint_x86_64.h | 22 +- 6 files changed, 561 insertions(+), 544 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 1cbd8f4..1789feb 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,389 +1,396 @@ -Version 0.9.0 prerelease (2009.09.20): - * fixed: Big::operator>>(std::istream&, Big<> &) didn't recognize values - in scientific mode (with 'e' character) - * added: support for wide characters (wchar_t, std::wstring) - * added: Big::IsInteger() - returns true if the value is integer (without fraction) - (NaN flag is not checked) - * added: global Gamma() function - * added: gamma() function to the parser - * added: CGamma class - is used with Gamma() and Factorial() in multithreaded environment - * added: multithread support for Big<> class - you should compile with TTMATH_MULTITHREADS - and use TTMATH_MULTITHREADS_HELPER macro somewhere in your *.cpp file - * added: Big::AboutEqual(const Big & ss2, int nBitsToIgnore) - Big::AboutEqualWithoutSign(const Big & ss2, int nBitsToIgnore) - the last nBitsToIgnore bits from mantissas will be skipped when comparing - * added: x86_64 asm code for Microsoft Visual compiler - file: ttmathuint_x86_64_msvc.asm - (this file should be compiled first because MS VC doesn't support inline assembler in x86_64 mode) - * added: flag TTMATH_BIG_ZERO to Big<> class - if this flag is set then there is a value zero - Big::IsZero() is faster now - * added: Big::ClearInfoBit(unsigned char) - Big::SetInfoBit(unsigned char) - Big::IsInfoBit(unsigned char) - some methods for manipulating the info flags - * added: macro: TTMATH_BITS(min_bits) +Version 0.9.0 prerelease (2009.10.03): + * fixed: Big::operator>>(std::istream&, Big<> &) didn't recognize values + in scientific mode (with 'e' character) + * 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::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 + * added: support for wide characters (wchar_t, std::wstring) + * added: Big::IsInteger() + returns true if the value is integer (without fraction) + (NaN flag is not checked) + * added: global Gamma() function + * added: gamma() function to the parser + * added: CGamma class + is used with Gamma() and Factorial() in multithreaded environment + * added: multithread support for Big<> class + you should compile with TTMATH_MULTITHREADS + and use TTMATH_MULTITHREADS_HELPER macro somewhere in your *.cpp file + * added: Big::AboutEqual(const Big & ss2, int nBitsToIgnore) + Big::AboutEqualWithoutSign(const Big & ss2, int nBitsToIgnore) + the last nBitsToIgnore bits from mantissas will be skipped when comparing + * added: x86_64 asm code for Microsoft Visual compiler + file: ttmathuint_x86_64_msvc.asm + (this file should be compiled first because MS VC doesn't support inline assembler in x86_64 mode) + * added: flag TTMATH_BIG_ZERO to Big<> class + if this flag is set then there is a value zero + Big::IsZero() is faster now + * added: Big::ClearInfoBit(unsigned char) + Big::SetInfoBit(unsigned char) + Big::IsInfoBit(unsigned char) + some methods for manipulating the info flags + * added: macro: TTMATH_BITS(min_bits) which returns the number of machine words capable to hold min_bits bits - * changed: Factorial() is using the Gamma() function now - * changed: Big::Div(ss2) - Big::Mod(ss2) - they return 2 when ss2 is zero - previously returned 1 - * removed: Parser<>::SetFactorialMax() method - the factorial() is such a fast now that we don't need the method longer - * removed: ErrorCode::err_too_big_factorial - - -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 & ss2, uint algorithm = 100) - void MulBig(const UInt & ss2, UInt & 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 & ss2) - void UInt::Mul3Big(const UInt & ss2, UInt & 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 & ss2) - void MulFastestBig(const UInt & ss2, UInt & 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) - 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 & 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) -> Big::Pow(UInt pow) - it returns 2 when there is: 0^0 - * changed: renamed: Big::PowInt(Int pow) -> Big::Pow(Int 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 pow) and Int::Pow(Int 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 - * changed: Int::FromInt(const Int & p), - Int::FromInt(sint value) (it returns zero now) - Int::operator=(uint i) - Int::Int(uint i) - * added: Int::FromUInt(const UInt & p), - Int::FromUInt(uint value) - and appropriate constructors and assignment - operators as well - * changed: Big::FromInt(Int value), - * added: Big::FromUInt(UInt value), - Big::operator=(const UInt & value) - Big::Big(const UInt & 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::&) - * 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) - - -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 - - -Version 0.7.1 (2007.02.27): - * fixed: the error 'overflow during printing' which was caused - by Big::FromInt(Int 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 - - -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 - 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): - * 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): - * added: New division algorithm (radix b) where b is 2^32 + * changed: Factorial() is using the Gamma() function now + * changed: Big::Div(ss2) + Big::Mod(ss2) + they return 2 when ss2 is zero + previously returned 1 + * removed: Parser<>::SetFactorialMax() method + the factorial() is such a fast now that we don't need the method longer + * removed: ErrorCode::err_too_big_factorial + + +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 & ss2, uint algorithm = 100) + void MulBig(const UInt & ss2, UInt & 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 & ss2) + void UInt::Mul3Big(const UInt & ss2, UInt & 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 & ss2) + void MulFastestBig(const UInt & ss2, UInt & 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) + 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 & 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) -> Big::Pow(UInt pow) + it returns 2 when there is: 0^0 + * changed: renamed: Big::PowInt(Int pow) -> Big::Pow(Int 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 pow) and Int::Pow(Int 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 + * changed: Int::FromInt(const Int & p), + Int::FromInt(sint value) (it returns zero now) + Int::operator=(uint i) + Int::Int(uint i) + * added: Int::FromUInt(const UInt & p), + Int::FromUInt(uint value) + and appropriate constructors and assignment + operators as well + * changed: Big::FromInt(Int value), + * added: Big::FromUInt(UInt value), + Big::operator=(const UInt & value) + Big::Big(const UInt & 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::&) + * 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) + + +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 + + +Version 0.7.1 (2007.02.27): + * fixed: the error 'overflow during printing' which was caused + by Big::FromInt(Int 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 + + +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 + 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): + * 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): + * added: New division algorithm (radix b) where b is 2^32 diff --git a/ttmath/ttmathtypes.h b/ttmath/ttmathtypes.h index bbbb2ba..8d3e533 100644 --- a/ttmath/ttmathtypes.h +++ b/ttmath/ttmathtypes.h @@ -491,9 +491,15 @@ namespace ttmath #ifdef TTMATH_DEBUG_LOG - #define TTMATH_LOG(msg) PrintLog(msg, std::cout); + #define TTMATH_LOG(msg) PrintLog(msg, std::cout); + #define TTMATH_LOGC(msg, carry) PrintLog(msg, carry, std::cout); + #define TTMATH_VECTOR_LOG(msg, vector, len) PrintVectorLog(msg, std::cout, vector, len); + #define TTMATH_VECTOR_LOGC(msg, carry, vector, len) PrintVectorLog(msg, carry, std::cout, vector, len); #else #define TTMATH_LOG(msg) + #define TTMATH_LOGC(msg, carry) + #define TTMATH_VECTOR_LOG(msg, vector, len) + #define TTMATH_VECTOR_LOGC(msg, carry, vector, len) #endif diff --git a/ttmath/ttmathuint.h b/ttmath/ttmathuint.h index 6aee6a3..3efb1db 100644 --- a/ttmath/ttmathuint.h +++ b/ttmath/ttmathuint.h @@ -81,6 +81,12 @@ public: uint table[value_size]; + + /*! + some methods used for debugging purposes + */ + + /*! this method is only for debugging purposes or when we want to make a table of a variable (constant) in ttmathbig.h @@ -122,13 +128,48 @@ public: } + /*! + this method is used when macro TTMATH_DEBUG_LOG is defined + */ template - void PrintLog(const char_type * msg, ostream_type & output) const + static void PrintVectorLog(const char_type * msg, ostream_type & output, const uint * vector, uint vector_len) { output << msg << std::endl; - for(uint i=0 ; i + static void PrintVectorLog(const char_type * msg, uint carry, ostream_type & output, const uint * vector, uint vector_len) + { + PrintVectorLog(msg, output, vector, vector_len); + output << " carry: " << carry << std::endl; + } + + + /*! + this method is used when macro TTMATH_DEBUG_LOG is defined + */ + template + void PrintLog(const char_type * msg, ostream_type & output) const + { + PrintVectorLog(msg, output, table, value_size); + } + + + /*! + this method is used when macro TTMATH_DEBUG_LOG is defined + */ + template + void PrintLog(const char_type * msg, uint carry, ostream_type & output) const + { + PrintVectorLog(msg, output, table, value_size); + output << " carry: " << carry << std::endl; } @@ -243,7 +284,7 @@ public: table[i] = 0; - TTMATH_LOG("UInt32::SetFromTable") + TTMATH_LOG("UInt::SetFromTable") } #endif @@ -308,7 +349,7 @@ public: for( ; i >= 0 ; --i) table[i] = 0; - TTMATH_LOG("UInt64::SetFromTable") + TTMATH_LOG("UInt::SetFromTable") } #endif @@ -436,7 +477,7 @@ public: last_c = Rcl2(rest_bits, c); } - TTMATH_LOG("UInt::Rcl") + TTMATH_LOGC("UInt::Rcl", last_c) return last_c; } @@ -531,7 +572,7 @@ public: last_c = Rcr2(rest_bits, c); } - TTMATH_LOG("UInt::Rcr") + TTMATH_LOGC("UInt::Rcr", last_c) return last_c; } @@ -550,11 +591,7 @@ public: for(a=value_size-1 ; a>=0 && table[a]==0 ; --a); if( a < 0 ) - { - // there's a value zero - TTMATH_LOG("UInt::CompensationToLeft") - return moving; - } + return moving; // all words in table have zero if( a != value_size-1 ) { @@ -583,8 +620,6 @@ public: } - - /*! this method looks for the highest set bit @@ -607,21 +642,14 @@ public: // is zero index = 0; - TTMATH_LOG("UInt::FindLeadingBit") - return false; } // table[table_id] != 0 index = FindLeadingBitInWord( table[table_id] ); - TTMATH_LOG("UInt::FindLeadingBit") - return true; } - - - /*! @@ -639,8 +667,6 @@ public: uint temp = table[index]; uint res = SetBitInWord(temp, bit); - TTMATH_LOG("UInt::GetBit") - return res; } @@ -758,43 +784,39 @@ public: /*! multiplication: this = this * ss2 - it returns a carry if it has been + it can return a carry */ uint MulInt(uint ss2) { - uint r2,r1; + uint r1, r2, x1; + uint c = 0; - UInt u( *this ); + UInt u(*this); SetZero(); - for(uint x1=0 ; x1 - uint MulInt(uint ss2, UInt & result) + void MulInt(uint ss2, UInt & result) const { + TTMATH_ASSERT( result_size > value_size ) + uint r2,r1; uint x1size=value_size; uint x1start=0; - if( value_size >= result_size ) - return 1; - result.SetZero(); + if( ss2 == 0 ) + { + TTMATH_VECTOR_LOG("UInt::MulInt(uint, UInt<>)", result.table, result_size) + return; + } + if( value_size > 2 ) { // if the value_size is smaller than or equal to 2 @@ -820,10 +847,10 @@ public: for(x1size=value_size ; x1size>0 && table[x1size-1]==0 ; --x1size); - if( x1size==0 ) + if( x1size == 0 ) { - TTMATH_LOG("UInt::MulInt(uint, UInt<>)") - return 0; + TTMATH_VECTOR_LOG("UInt::MulInt(uint, UInt<>)", result.table, result_size) + return; } for(x1start=0 ; x1start)", result.table, result_size) - TTMATH_LOG("UInt::MulInt(uint, UInt<>)") - - return 0; + return; } @@ -919,19 +945,19 @@ public: { if( Add(*this) ) { - TTMATH_LOG("UInt::Mul1") + TTMATH_LOGC("UInt::Mul1", 1) return 1; } if( ss1.Rcl(1) ) if( Add(ss2) ) { - TTMATH_LOG("UInt::Mul1") + TTMATH_LOGC("UInt::Mul1", 1) return 1; } } - TTMATH_LOG("UInt::Mul1") + TTMATH_LOGC("UInt::Mul1", 0) return 0; } @@ -1001,7 +1027,7 @@ public: break; } - TTMATH_LOG("UInt::Mul2") + TTMATH_LOGC("UInt::Mul2", c) return c; } @@ -1125,7 +1151,7 @@ public: break; } - TTMATH_LOG("UInt::Mul3") + TTMATH_LOGC("UInt::Mul3", c) return c; } @@ -1347,7 +1373,7 @@ public: break; } - TTMATH_LOG("UInt::MulFastest") + TTMATH_LOGC("UInt::MulFastest", c) return c; } @@ -1384,7 +1410,7 @@ public: uint distancex2 = x2size - x2start; if( distancex1 < 3 || distancex2 < 3 ) - // either 'this' or 'ss2' have only 2 (or 1) item different from zero (side by side) + // either 'this' or 'ss2' have only 2 (or 1) items different from zero (side by side) // (this condition in the future can be improved) return Mul2Big3(table, ss2.table, result, x1start, x1size, x2start, x2size); @@ -1592,7 +1618,7 @@ private: public: /*! - the first division's algorithm + the first division algorithm radix 2 */ uint Div1(const UInt & divisor, UInt * remainder = 0) @@ -2190,7 +2216,7 @@ public: return values: 0 - ok - 1 - carry or + 1 - carry 2 - incorrect argument (0^0) */ uint Pow(UInt pow) @@ -2208,7 +2234,7 @@ public: if( pow.table[0] & 1 ) if( result.Mul(start) ) { - TTMATH_LOG("UInt::Pow(UInt<>)") + TTMATH_LOGC("UInt::Pow(UInt<>)", 1) return 1; } @@ -2216,7 +2242,7 @@ public: // in the second Mul algorithm we can use start.Mul(start) directly (there is no TTMATH_ASSERT_REFERENCE there) if( start.Mul(start_temp) ) { - TTMATH_LOG("UInt::Pow(UInt<>)") + TTMATH_LOGC("UInt::Pow(UInt<>)", 1) return 1; } @@ -2225,7 +2251,7 @@ public: *this = result; - TTMATH_LOG("UInt::Pow(UInt<>)") + TTMATH_LOGC("UInt::Pow(UInt<>)", 0) return 0; } @@ -2311,7 +2337,7 @@ public: /*! * - * conversion method + * conversion methods * */ @@ -2347,12 +2373,12 @@ public: for( ; i)") + TTMATH_LOGC("UInt::FromUInt(UInt<>)", 1) return 1; } } - TTMATH_LOG("UInt::FromUInt(UInt<>)") + TTMATH_LOGC("UInt::FromUInt(UInt<>)", 0) return 0; } @@ -2382,9 +2408,7 @@ public: { FromUInt(p); - TTMATH_LOG("UInt::operator=(UInt)") - - return *this; + return *this; } @@ -2393,7 +2417,8 @@ public: */ UInt & operator=(const UInt & p) { - FromUInt(p); + for(uint i=0 ; i)") @@ -2408,8 +2433,6 @@ public: { FromUInt(i); - TTMATH_LOG("UInt::operator=(uint)") - return *this; } @@ -2420,8 +2443,6 @@ public: UInt(uint i) { FromUInt(i); - - TTMATH_LOG("UInt::UInt(uint)") } @@ -2441,8 +2462,6 @@ public: { FromUInt(uint(i)); - TTMATH_LOG("UInt::operator=(sint)") - return *this; } @@ -2455,8 +2474,6 @@ public: UInt(sint i) { FromUInt(uint(i)); - - TTMATH_LOG("UInt::UInt(sint)") } @@ -2487,8 +2504,6 @@ public: { FromUInt(uint(i)); - TTMATH_LOG("UInt64::operator=(unsigned int)") - return *this; } @@ -2502,8 +2517,6 @@ public: UInt(unsigned int i) { FromUInt(uint(i)); - - TTMATH_LOG("UInt64::UInt(unsigned int)") } @@ -2519,8 +2532,6 @@ public: { FromUInt(uint(i)); - TTMATH_LOG("UInt64::operator=(signed int)") - return *this; } @@ -2536,8 +2547,6 @@ public: UInt(signed int i) { FromUInt(uint(i)); - - TTMATH_LOG("UInt64::UInt(signed int)") } @@ -2553,8 +2562,6 @@ public: UInt(const char * s) { FromString(s); - - TTMATH_LOG("UInt::UInt(const char *)") } @@ -2564,8 +2571,6 @@ public: UInt(const wchar_t * s) { FromString(s); - - TTMATH_LOG("UInt::UInt(const wchar_t *)") } @@ -2590,13 +2595,14 @@ public: /*! a default constructor - we don't clear table etc. + we don't clear the table */ UInt() { // when macro TTMATH_DEBUG_LOG is defined // we set special values to the table // in order to be everywhere the same value of the UInt object + // without this it would be difficult to analyse the log file #ifdef TTMATH_DEBUG_LOG #ifdef TTMATH_PLATFORM32 for(uint i=0 ; i & u) { - FromUInt(u); + for(uint i=0 ; i)") } @@ -2629,8 +2636,6 @@ public: { // look that 'size' we still set as 'value_size' and not as u.value_size FromUInt(u); - - TTMATH_LOG("UInt::UInt(UInt)") } @@ -2717,7 +2722,7 @@ private: SetZero(); temp.SetZero(); - SkipWhiteCharacters(s); + Misc::SkipWhiteCharacters(s); if( after_source ) *after_source = s; @@ -2746,7 +2751,7 @@ private: if( after_source ) *after_source = s; - TTMATH_LOG("UInt::FromString") + TTMATH_LOGC("UInt::FromString", c) return (c==0)? 0 : 1; } @@ -3061,8 +3066,6 @@ public: { Sub(p2); - TTMATH_LOG("UInt::operator-=") - return *this; } @@ -3079,8 +3082,6 @@ public: { Add(p2); - TTMATH_LOG("UInt::operator+=") - return *this; } @@ -3099,8 +3100,6 @@ public: { Mul(p2); - TTMATH_LOG("UInt::operator*=") - return *this; } @@ -3119,8 +3118,6 @@ public: { Div(p2); - TTMATH_LOG("UInt::operator/=") - return *this; } @@ -3145,8 +3142,6 @@ public: operator=(remainder); - TTMATH_LOG("UInt::operator%=") - return *this; } @@ -3158,11 +3153,10 @@ public: { AddOne(); - TTMATH_LOG("UInt::operator++") - return *this; } + /*! Postfix operator e.g variable++ */ @@ -3172,8 +3166,6 @@ public: AddOne(); - TTMATH_LOG("UInt::operator++(int)") - return temp; } @@ -3182,8 +3174,6 @@ public: { SubOne(); - TTMATH_LOG("UInt::operator--") - return *this; } @@ -3194,8 +3184,6 @@ public: SubOne(); - TTMATH_LOG("UInt::operator--(int)") - return temp; } diff --git a/ttmath/ttmathuint_noasm.h b/ttmath/ttmathuint_noasm.h index b315328..a425514 100644 --- a/ttmath/ttmathuint_noasm.h +++ b/ttmath/ttmathuint_noasm.h @@ -51,6 +51,13 @@ namespace ttmath { + + /*! + this method adds two words together + returns carry + + this method is created only when TTMATH_NOASM macro is defined + */ template uint UInt::AddTwoWords(uint a, uint b, uint carry, uint * result) { @@ -95,7 +102,7 @@ namespace ttmath for(i=0 ; i uint UInt::SubTwoWords(uint a, uint b, uint carry, uint * result) { @@ -273,7 +286,7 @@ namespace ttmath for(i=0 ; i sint UInt::FindLeadingBitInWord(uint x) @@ -539,7 +551,7 @@ namespace ttmath this method sets a special bit in the 'value' and returns the last state of the bit (zero or one) - bit is from <0,63> + bit is from <0,TTMATH_BITS_PER_UINT-1> e.g. uint x = 100; @@ -553,7 +565,7 @@ namespace ttmath uint mask = 1; - if( bit > 1 ) + if( bit > 0 ) mask = mask << bit; uint last = value & mask; diff --git a/ttmath/ttmathuint_x86.h b/ttmath/ttmathuint_x86.h index 656f4e3..c26f287 100644 --- a/ttmath/ttmathuint_x86.h +++ b/ttmath/ttmathuint_x86.h @@ -152,7 +152,7 @@ namespace ttmath : "cc", "memory" ); #endif - TTMATH_LOG("UInt::Add") + TTMATH_LOGC("UInt::Add", c) return c; } @@ -253,7 +253,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::AddInt") + TTMATH_LOGC("UInt::AddInt", c) return c; } @@ -374,7 +374,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::AddTwoInts") + TTMATH_LOGC("UInt::AddTwoInts", c) return c; } @@ -506,6 +506,8 @@ namespace ttmath #endif + TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size) + return c; } @@ -592,7 +594,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Sub") + TTMATH_LOGC("UInt::Sub", c) return c; } @@ -694,7 +696,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::SubInt") + TTMATH_LOGC("UInt::SubInt", c) return c; } @@ -832,6 +834,8 @@ namespace ttmath #endif + TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size) + return c; } @@ -908,7 +912,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcl2_one") + TTMATH_LOGC("UInt::Rcl2_one", c) return c; } @@ -980,7 +984,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcr2_one") + TTMATH_LOGC("UInt::Rcr2_one", c) return c; } @@ -1114,7 +1118,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcl2") + TTMATH_LOGC("UInt::Rcl2", c) return c; } @@ -1248,7 +1252,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcr2") + TTMATH_LOGC("UInt::Rcr2", c) return c; } diff --git a/ttmath/ttmathuint_x86_64.h b/ttmath/ttmathuint_x86_64.h index 7559add..44552d7 100644 --- a/ttmath/ttmathuint_x86_64.h +++ b/ttmath/ttmathuint_x86_64.h @@ -142,7 +142,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Add") + TTMATH_LOGC("UInt::Add", c) return c; } @@ -214,7 +214,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::AddInt") + TTMATH_LOGC("UInt::AddInt", c) return c; } @@ -302,7 +302,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::AddTwoInts") + TTMATH_LOGC("UInt::AddTwoInts", c) return c; } @@ -390,7 +390,7 @@ namespace ttmath #endif -// TTMATH_LOG("UInt::AddVector") + TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size) return c; } @@ -452,7 +452,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Sub") + TTMATH_LOGC("UInt::Sub", c) return c; } @@ -523,7 +523,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::SubInt") + TTMATH_LOGC("UInt::SubInt", c) return c; } @@ -613,7 +613,7 @@ namespace ttmath #endif -// TTMATH_LOG("UInt::SubVector") + TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size) return c; } @@ -673,7 +673,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcl2_one") + TTMATH_LOGC("UInt::Rcl2_one", c) return c; } @@ -731,7 +731,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcr2_one") + TTMATH_LOGC("UInt::Rcr2_one", c) return c; } @@ -810,7 +810,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcl2") + TTMATH_LOGC("UInt::Rcl2", c) return c; } @@ -890,7 +890,7 @@ namespace ttmath #endif - TTMATH_LOG("UInt::Rcr2") + TTMATH_LOGC("UInt::Rcr2", c) return c; }