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 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
This commit is contained in:
parent
31b8c242bd
commit
a8eb29e57d
781
CHANGELOG
781
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<ValueType> class
|
||||
is used with Gamma() and Factorial() in multithreaded environment
|
||||
* added: multithread support for Big<> class
|
||||
you should compile with TTMATH_MULTITHREADS
|
||||
and use TTMATH_MULTITHREADS_HELPER macro somewhere in your *.cpp file
|
||||
* added: Big::AboutEqual(const Big<exp,man> & ss2, int nBitsToIgnore)
|
||||
Big::AboutEqualWithoutSign(const Big<exp,man> & 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<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
|
||||
* 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<ValueType> class
|
||||
is used with Gamma() and Factorial() in multithreaded environment
|
||||
* added: multithread support for Big<> class
|
||||
you should compile with TTMATH_MULTITHREADS
|
||||
and use TTMATH_MULTITHREADS_HELPER macro somewhere in your *.cpp file
|
||||
* added: Big::AboutEqual(const Big<exp,man> & ss2, int nBitsToIgnore)
|
||||
Big::AboutEqualWithoutSign(const Big<exp,man> & 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<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)
|
||||
|
||||
|
||||
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<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
|
||||
|
||||
|
||||
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<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)
|
||||
|
||||
|
||||
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<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
|
||||
|
||||
|
||||
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
|
||||
|
|
|
@ -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
|
||||
|
||||
|
||||
|
|
|
@ -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<class char_type, class ostream_type>
|
||||
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<value_size ; ++i)
|
||||
output << " table[" << i << "]: " << table[i] << std::endl;
|
||||
for(uint i=0 ; i<vector_len ; ++i)
|
||||
output << " table[" << i << "]: " << vector[i] << std::endl;
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
this method is used when macro TTMATH_DEBUG_LOG is defined
|
||||
*/
|
||||
template<class char_type, class ostream_type>
|
||||
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<class char_type, class ostream_type>
|
||||
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<class char_type, class ostream_type>
|
||||
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<value_size> u( *this );
|
||||
UInt<value_size> u(*this);
|
||||
SetZero();
|
||||
|
||||
for(uint x1=0 ; x1<value_size ; ++x1)
|
||||
if( ss2 == 0 )
|
||||
{
|
||||
MulTwoWords(u.table[x1], ss2, &r2, &r1 );
|
||||
|
||||
|
||||
if( x1 <= value_size - 2 )
|
||||
{
|
||||
if( AddTwoInts(r2,r1,x1) )
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// last iteration:
|
||||
// x1 = value_size - 1;
|
||||
|
||||
if( r2 )
|
||||
return 1;
|
||||
|
||||
if( AddInt(r1, x1) )
|
||||
return 1;
|
||||
}
|
||||
TTMATH_LOGC("UInt::MulInt(uint)", 0)
|
||||
return 0;
|
||||
}
|
||||
|
||||
TTMATH_LOG("UInt::MulInt(uint)")
|
||||
for(x1=0 ; x1<value_size-1 ; ++x1)
|
||||
{
|
||||
MulTwoWords(u.table[x1], ss2, &r2, &r1);
|
||||
c += AddTwoInts(r2,r1,x1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
// x1 = value_size-1 (last word)
|
||||
MulTwoWords(u.table[x1], ss2, &r2, &r1);
|
||||
c += (r2!=0) ? 1 : 0;
|
||||
c += AddInt(r1, x1);
|
||||
|
||||
TTMATH_LOGC("UInt::MulInt(uint)", c)
|
||||
|
||||
return (c==0)? 0 : 1;
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
multiplication: result = this * ss2
|
||||
|
||||
|
@ -802,17 +824,22 @@ public:
|
|||
if so there will not be a carry
|
||||
*/
|
||||
template<uint result_size>
|
||||
uint MulInt(uint ss2, UInt<result_size> & result)
|
||||
void MulInt(uint ss2, UInt<result_size> & 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<x1size && table[x1start]==0 ; ++x1start);
|
||||
|
@ -835,10 +862,9 @@ public:
|
|||
result.AddTwoInts(r2,r1,x1);
|
||||
}
|
||||
|
||||
TTMATH_VECTOR_LOG("UInt::MulInt(uint, UInt<>)", 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<value_size>(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<value_size> & divisor, UInt<value_size> * remainder = 0)
|
||||
|
@ -2190,7 +2216,7 @@ public:
|
|||
|
||||
return values:
|
||||
0 - ok
|
||||
1 - carry or
|
||||
1 - carry
|
||||
2 - incorrect argument (0^0)
|
||||
*/
|
||||
uint Pow(UInt<value_size> 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<argument_size ; ++i)
|
||||
if( p.table[i] != 0 )
|
||||
{
|
||||
TTMATH_LOG("UInt::FromUInt(UInt<>)")
|
||||
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<argument_size>)")
|
||||
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
@ -2393,7 +2417,8 @@ public:
|
|||
*/
|
||||
UInt<value_size> & operator=(const UInt<value_size> & p)
|
||||
{
|
||||
FromUInt(p);
|
||||
for(uint i=0 ; i<value_size ; ++i)
|
||||
table[i] = p.table[i];
|
||||
|
||||
TTMATH_LOG("UInt::operator=(UInt<>)")
|
||||
|
||||
|
@ -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<value_size ; ++i)
|
||||
|
@ -2614,7 +2620,8 @@ public:
|
|||
*/
|
||||
UInt(const UInt<value_size> & u)
|
||||
{
|
||||
FromUInt(u);
|
||||
for(uint i=0 ; i<value_size ; ++i)
|
||||
table[i] = u.table[i];
|
||||
|
||||
TTMATH_LOG("UInt::UInt(UInt<>)")
|
||||
}
|
||||
|
@ -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<argument_size>)")
|
||||
}
|
||||
|
||||
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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 value_size>
|
||||
uint UInt<value_size>::AddTwoWords(uint a, uint b, uint carry, uint * result)
|
||||
{
|
||||
|
@ -95,7 +102,7 @@ namespace ttmath
|
|||
for(i=0 ; i<value_size ; ++i)
|
||||
c = AddTwoWords(table[i], ss2.table[i], c, &table[i]);
|
||||
|
||||
TTMATH_LOG("UInt::Add")
|
||||
TTMATH_LOGC("UInt::Add", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -131,7 +138,7 @@ namespace ttmath
|
|||
for(i=index+1 ; i<value_size && c ; ++i)
|
||||
c = AddTwoWords(table[i], 0, c, &table[i]);
|
||||
|
||||
TTMATH_LOG("UInt::AddInt")
|
||||
TTMATH_LOGC("UInt::AddInt", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -184,7 +191,7 @@ namespace ttmath
|
|||
for(i=index+2 ; i<value_size && c ; ++i)
|
||||
c = AddTwoWords(table[i], 0, c, &table[i]);
|
||||
|
||||
TTMATH_LOG("UInt::AddTwoInts")
|
||||
TTMATH_LOGC("UInt::AddTwoInts", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -224,7 +231,7 @@ namespace ttmath
|
|||
for( ; i<ss1_size ; ++i)
|
||||
c = AddTwoWords(ss1[i], 0, c, &result[i]);
|
||||
|
||||
TTMATH_LOG("UInt::AddVector")
|
||||
TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -232,6 +239,12 @@ namespace ttmath
|
|||
|
||||
|
||||
|
||||
/*!
|
||||
this method subtractes one word from the other
|
||||
returns carry
|
||||
|
||||
this method is created only when TTMATH_NOASM macro is defined
|
||||
*/
|
||||
template<uint value_size>
|
||||
uint UInt<value_size>::SubTwoWords(uint a, uint b, uint carry, uint * result)
|
||||
{
|
||||
|
@ -273,7 +286,7 @@ namespace ttmath
|
|||
for(i=0 ; i<value_size ; ++i)
|
||||
c = SubTwoWords(table[i], ss2.table[i], c, &table[i]);
|
||||
|
||||
TTMATH_LOG("UInt::Sub")
|
||||
TTMATH_LOGC("UInt::Sub", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -311,7 +324,7 @@ namespace ttmath
|
|||
for(i=index+1 ; i<value_size && c ; ++i)
|
||||
c = SubTwoWords(table[i], 0, c, &table[i]);
|
||||
|
||||
TTMATH_LOG("UInt::SubInt")
|
||||
TTMATH_LOGC("UInt::SubInt", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -351,7 +364,7 @@ namespace ttmath
|
|||
for( ; i<ss1_size ; ++i)
|
||||
c = SubTwoWords(ss1[i], 0, c, &result[i]);
|
||||
|
||||
TTMATH_LOG("UInt::SubVector")
|
||||
TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -385,7 +398,7 @@ namespace ttmath
|
|||
c = new_c;
|
||||
}
|
||||
|
||||
TTMATH_LOG("UInt::Rcl2_one")
|
||||
TTMATH_LOGC("UInt::Rcl2_one", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -424,7 +437,7 @@ namespace ttmath
|
|||
c = new_c;
|
||||
}
|
||||
|
||||
TTMATH_LOG("UInt::Rcr2_one")
|
||||
TTMATH_LOGC("UInt::Rcr2_one", c)
|
||||
|
||||
return c;
|
||||
}
|
||||
|
@ -462,7 +475,7 @@ namespace ttmath
|
|||
c = new_c;
|
||||
}
|
||||
|
||||
TTMATH_LOG("UInt::Rcl2")
|
||||
TTMATH_LOGC("UInt::Rcl2", c)
|
||||
|
||||
return (c & 1);
|
||||
}
|
||||
|
@ -501,7 +514,7 @@ namespace ttmath
|
|||
c = new_c;
|
||||
}
|
||||
|
||||
TTMATH_LOG("UInt::Rcr2")
|
||||
TTMATH_LOGC("UInt::Rcr2", c)
|
||||
|
||||
return (c & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
|
||||
}
|
||||
|
@ -509,10 +522,9 @@ namespace ttmath
|
|||
|
||||
|
||||
|
||||
/*
|
||||
/*!
|
||||
this method returns the number of the highest set bit in x
|
||||
if the 'x' is zero this method returns '-1'
|
||||
|
||||
*/
|
||||
template<uint value_size>
|
||||
sint UInt<value_size>::FindLeadingBitInWord(uint x)
|
||||
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue