You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
620 lines
36 KiB
620 lines
36 KiB
Version 0.9.4_prerelease (....): |
|
* fixed: cannot compile on MS Windows when compiling with GCC (Mingw) for 64 bit platform: |
|
incorrect size of ttmath::uint and ::sint were used |
|
they were 'long' but 'long' is a 32bit type on Windows |
|
* fixed: a crash in Big::Add() (buffer overflow) |
|
there was an offset calculated from Int type by using Abs() method and a carry was not checked |
|
(if there is a carry we should not make addition -- the argument is too small) |
|
this had no impact on calculated values because there was a crash (bus error) immediately |
|
following program could crash (64bit): |
|
typedef ttmath::Big<1, 8> MyBig; |
|
ttmath::Parser<MyBig> parser; |
|
parser.Parse("2^(2^63) + 1"); |
|
* fixed: similar problems were in methods Big::BitAnd() Big::BitOr() and Big::BitXor() (bitwise operations) |
|
and they could return incorrect values |
|
* fixed: in x86_64 asm code (*.asm for Win64) there was in some places esp register used, |
|
there should be rsp used instead |
|
this affects MS Windows users when they use the asm version (ttmathuint_x86_64_msvc.asm) |
|
|
|
|
|
Version 0.9.3 (2012.11.28): |
|
* fixed: in Big::FromDouble(double value) (only 32 bit version) |
|
buffer overflow in referencing to UInt<2> |
|
this was used when 'value' was in so called "unnormalized" state |
|
(E=0 and F is nonzero) |
|
it produced incorrect mantissa (on about 8th decimal digit up) |
|
* added: Parser::InitCGamma() |
|
initializing coefficients used when calculating the gamma (or factorial) function |
|
this speed up the next calculations |
|
you don't have to call this method explicitly |
|
these coefficients will be calculated when needed |
|
* added: option 'group_digits' to Conv struct |
|
you can set how many digits should be grouped |
|
* changed: small optimizations in UInt::ToString() and Big::FromString() |
|
|
|
|
|
Version 0.9.2 (2010.09.23): |
|
* fixed: Big::Add() sometimes incorrectly rounded the last bit from its mantissa |
|
* fixed: Big::BigAnd() Big::BigOr() Big::BigXor() should have set NaN |
|
when the argument was negative (they only returned 2) |
|
* fixed: recurrence calling in Big::FromString(const std::string &, uint, const wchar_t **, bool *) |
|
it should have the signature: Big::FromString(const std::string &, uint, const char **, bool *) |
|
* fixed: Big::ToString method |
|
in some cases when in the output string the exponent should be equal zero |
|
the method changes the exponent to one so the last digit from the mantissa |
|
was lost |
|
* fixed: Big::ToDouble(double &) set always +INF (infinity) |
|
when the value was too large (even for negative values) |
|
(it should set -INF in such a case) |
|
* added: some missing operators |
|
UInt::operator~() /* bitwise neg */ |
|
UInt::operator&() /* bitwise and */ |
|
UInt::operator&=() |
|
UInt::operator|() /* bitwise or */ |
|
UInt::operator|=() |
|
UInt::operator^() /* bitwise xor */ |
|
UInt::operator^=() |
|
Big::operator&() |
|
Big::operator&=() |
|
Big::operator|() |
|
Big::operator|=() |
|
Big::operator^() |
|
Big::operator^=() |
|
for Big<> we do not define bitwise neg |
|
Big::operator++() |
|
Big::operator++(int) |
|
Big::operator--() |
|
Big::operator--(int) |
|
* added: macro TTMATH_DONT_USE_WCHAR |
|
if defined then the library does not use wide characters |
|
(wchar_t, std::wstring, ...) this is a workaround for some compilers |
|
* added: bool UInt::IsOnlyTheHighestBitSet() |
|
bool UInt::IsOnlyTheLowestBitSet() |
|
returning true if only the highest/lowest bit is set |
|
* added: uint Int::MulInt(sint ss2) |
|
* added: void UInt::Swap(UInt<value_size> & ss2) |
|
void Big::Swap(UInt<value_size> & ss2) |
|
method for swapping this for an argument |
|
* added: macro TTMATH_BIG_DEFAULT_CLEAR |
|
when defined the default constructor from Big<> clears its mantissa and exponent |
|
Big<1, 2> var; |
|
var.mantissa and var.exponent will be set to zero |
|
(but var has the NaN flag set too - it is not zero value, this is mainly for debug purposes) |
|
* added: only on 32bit platforms: |
|
uint UInt::FromUInt(uint64_t n) |
|
uint Int::FromInt(int64_t n) |
|
void Big::FromUInt(uint64_t n) |
|
void Big::FromInt(int64_t n) |
|
and appropriate constructors and operators |
|
* added: TTMATH_FORCEASM macro |
|
asm version of the library is available by default only for: |
|
x86 and amd64 platforms and for Microsoft Visual and GCC compilers, |
|
but you can force using asm version (the same asm as for Microsoft Visual) |
|
by defining TTMATH_FORCEASM macro |
|
you have to be sure that your compiler accept such an asm format |
|
* added: some missing methods for converting |
|
for UInt<>, Int<> and Big<> classes: |
|
uint ToUInt() |
|
sint ToInt() |
|
ToUInt(uint32_t &) |
|
ToInt(uint32_t &) |
|
ToInt(int32_t &) |
|
ToUInt(uint64_t &) |
|
ToInt(uint64_t &) |
|
ToInt(int64_t &) |
|
FromUInt(uint32_t &) |
|
FromInt(uint32_t &) |
|
FromInt(int32_t &) |
|
FromUInt(uint64_t &) |
|
FromInt(uint64_t &) |
|
FromInt(int64_t &) |
|
and appropriate constructors and operators |
|
* added: double Big::ToDouble() /there was only Big::ToDouble(double &) / |
|
uint Big::ToFloat(float &) |
|
float Big::ToFloat() |
|
* changed: now asm version is available only on x86 and amd64 |
|
(and only for GCC and MS VC compilers) |
|
* removed: macro TTMATH_RELEASE (now the 'release' version is default) |
|
for debug version define TTMATH_DEBUG macro |
|
TTMATH_DEBUG is also automatically defined when DEBUG or _DEBUG is set |
|
* removed: macro TTMATH_REFERENCE_ASSERT from all methods in public interface |
|
|
|
|
|
Version 0.9.1 (2010.02.07): |
|
* fixed: the parser didn't use characters for changing the base (# and &) |
|
those characters were skipped |
|
(this bug was introduced in 0.9.0) |
|
* fixed: added in the parser: operator's associativity |
|
operator ^ (powering) is right-associative: |
|
sample: 2^3^4 is equal 2^(3^4) and it is: 2.41e+24 |
|
previously was: 2^3^4 = (2^3)^4 = 4096 |
|
* fixed: in Big::ToString_CreateNewMantissaAndExponent() changed the formula: |
|
new_exp_ = [log base (2^exponent)] + 1 |
|
now the part '+ 1' is only made when the logarithm is positive and with fraction |
|
if the value is negative we can only skip the fraction, previously |
|
we lost some last digits from the new mantissa |
|
Consider this binary value (32 bit mantissa): |
|
(bin)1.0000000000000000000000000000011 |
|
previously ToString() gave 1, now we have: 1.000000001 |
|
* changed: in Big::ToString() the base rounding is made only if the result value |
|
would not be an integer, e.g. if the value is 1.999999999999 then |
|
the base rounding will not be done - because as the result would be 2 |
|
* added: IEEE 754 half-to-even rounding (bankers' rounding) to the following |
|
floating point algorithms: Big::Add, Big::Sub, Big::Mul, Big::Div |
|
* added: static sint UInt<value_size>::FindLowestBitInWord(uint x) |
|
this method is looking for the lowest set bit in a word |
|
* added: UInt::FindLowestBit(uint & table_id, uint & index) |
|
this method is looking for the lowest set bit |
|
|
|
|
|
Version 0.9.0 (2009.11.25): |
|
* 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: x86_64 asm code for Microsoft Visual compiler |
|
file: ttmathuint_x86_64_msvc.asm |
|
(this file should be compiled first because MS VC doesn't support inline assembler in x86_64 mode) |
|
* added: flag TTMATH_BIG_ZERO to Big<> class |
|
if this flag is set then there is a value zero |
|
Big::IsZero() is faster now |
|
* added: Big::ClearInfoBit(unsigned char) |
|
Big::SetInfoBit(unsigned char) |
|
Big::IsInfoBit(unsigned char) |
|
some methods for manipulating the info flags |
|
* added: macro: TTMATH_BITS(min_bits) |
|
which returns the number of machine words |
|
capable to hold min_bits bits |
|
* added: bool Parser::Calculated() |
|
this method returns true is something was calculated |
|
(at least one mathematical operator was used or a function or variable) |
|
* added: to the parser: operator percentage |
|
e.g. 1000-50%=1000-(1000*0,5)=500 |
|
* added: struct: Conv |
|
consists of some parameters used |
|
in ToString() and FromString() |
|
* added: Big::ToString() can group digits |
|
e.g. 1234567 -> 1`234`567 |
|
* added: Parser::SetGroup(int g) |
|
Parser::SetComma(int c, int c2 = 0) |
|
Parser::SetParamSep(int s) |
|
* added: std::string UInt::ToString(uint b = 10) |
|
std::wstring UInt::ToWString(uint b = 10) |
|
std::string Int::ToString(uint b = 10) |
|
std::wstring Int::ToWString(uint b = 10) |
|
uint Big::ToString(std::string & result, const Conv & conv) |
|
uint Big::ToString(std::wstring & result, const Conv & conv) |
|
std::string Big::ToString(const Conv & conv) |
|
std::string Big::ToString() |
|
std::wstring Big::ToWString(const Conv & conv) |
|
std::wstring Big::ToWString() |
|
* added: uint FromString(const char * source, const Conv & conv, const char **, bool *) |
|
uint FromString(const wchar_t * source, const Conv & conv, const wchar_t **, bool *) |
|
uint FromString(const std::string & string, const Conv & conv, const wchar_t **, bool *) |
|
uint FromString(const std::wstring & string, const Conv & conv, const wchar_t **, bool *) |
|
* added: UInt::Sqrt() - a new algorithm for calculating the square root |
|
* added: to the parser: function frac() - returns a value without the integer part |
|
(only fraction remains) |
|
* added: Int::DivInt(sint divisor, sint * remainder) |
|
* added: const char * UInt::LibTypeStr() |
|
const char * Big::LibTypeStr() |
|
LibTypeCode UInt::LibType() |
|
LibTypeCode Big::LibType() |
|
returning a string/enum represents the currect type of the library |
|
we have following types: |
|
asm_vc_32 - with asm code designed for Microsoft Visual C++ (32 bits) |
|
asm_gcc_32 - with asm code designed for GCC (32 bits) |
|
asm_vc_64 - with asm for VC (64 bit) |
|
asm_gcc_64 - with asm for GCC (64 bit) |
|
no_asm_32 - pure C++ version (32 bit) - without any asm code |
|
no_asm_64 - pure C++ version (64 bit) - without any asm code |
|
* added: UInt::operator>>(int) |
|
UInt::operator>>=(int) |
|
UInt::operator<<(int) |
|
UInt::operator<<=(int) |
|
* changed: Factorial() is using the Gamma() function now |
|
* changed: Big::Div(ss2) |
|
Big::Mod(ss2) |
|
they return 2 when ss2 is zero |
|
previously returned 1 |
|
* changed: algorithms in Big::Sqrt() and ttmath::Root(x ; n) |
|
they were not too much accurate for some integers |
|
e.g. Root(16;4) returned a value very closed to 2 (not exactly 2) |
|
* changed: added specializations to Big::ToString() when the base is equal 4, 8 or 16 |
|
the previous version was not accurate on some last digits (after the comma operator) |
|
consider this binary value (32 bit mantissa): |
|
base 2: 1.1111 1111 1111 1111 1111 1111 1110 101 |
|
previous ToString() gave: |
|
base 4: 1.33333333333332 |
|
base 8: 1.777777777 |
|
base 16: 1.FFFFFF |
|
now we have: |
|
base 4: 1.3333333333333222 |
|
base 8: 1.77777777724 |
|
base 16: 1.FFFFFFEA |
|
* changed: in Big::ToString() some additional rounding (base_round) is now made only |
|
when the value is not an integer |
|
* changed: another compilers than MS VC or GCC by default use no asm version (TTMATH_NOASM) |
|
* removed: Parser<>::SetFactorialMax() method |
|
the factorial() is such a fast now that we don't need the method longer |
|
* removed: ErrorCode::err_too_big_factorial |
|
* removed: macros: TTMATH_COMMA_CHARACTER_1 and TTMATH_COMMA_CHARACTER_2 |
|
the comma characters we have in Conv struct now |
|
|
|
|
|
Version 0.8.6 (2009.10.25): |
|
* fixed: UInt::SetBitInWord(uint & value, uint bit) set 1 if the bit was |
|
equal 1 (should be set 2) |
|
this affected only no-asm parts - when macro TTMATH_NOASM was defined |
|
* fixed: UInt<value_size>::MulInt(uint ss2) |
|
there was a buffer overflow when value_size was equal 1 |
|
* fixed: UInt::AddVector() and UInt::SubVector() didn't want to compile |
|
when macro TTMATH_NOASM was defined |
|
* fixed: Big::operator>> didn't correctly recognize values in scientific mode (with 'e' character) |
|
* fixed: Int::FromString(const tt_string & s, uint b = 10) |
|
didn't use 'b' (always was '10') |
|
* fixed: buffer overflow in Big::ToInt(Int<int_size> & result) |
|
* fixed: powering algorithm in: |
|
UInt::Pow(UInt<value_size> pow) |
|
Big::Pow(UInt<pow_size> pow) |
|
Big::PowUInt(Big<exp, man> pow) |
|
when 'pow' was sufficient large the algorithm returned carry |
|
but the result could have been calculated correctly |
|
|
|
|
|
Version 0.8.5 (2009.06.16): |
|
* 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
|
|
|