changed version: 0.8.6 now

git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@222 e52654a7-88a9-db11-a3e9-0013d4bc506e
fixed: powering algorithm in:
2009-10-25 15:55:15 +00:00 · 2009-10-16 21:38:25 +00:00 · 2009-10-15 01:40:13 +00:00 · 2009-10-07 17:33:03 +00:00 · 2009-06-16 20:28:52 +00:00
50 changed files with 3808 additions and 40559 deletions
--- a/251
+++ b/251
@ -1,254 +1,3 @@
-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)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,6 +0,0 @@
-# CMake configuration for ttmath
-cmake_minimum_required (VERSION 3.0)
-project(ttmath)
-enable_testing()
-include_directories(${ttmath_SOURCE_DIR})
-add_subdirectory(samples)
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-Copyright (c) 2006-2017, Tomasz Sowa
+Copyright (c) 2006-2009, Tomasz Sowa
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
--- a/35
+++ b/35
@ -1,23 +1,26 @@
-A bignum library for C++
+TTMath - a bignum library for C++

 TTMath is a small library which allows one to perform arithmetic operations
-with big unsigned integer, big signed integer and big floating point numbers.
-It provides standard mathematical operations like adding, subtracting,
-multiplying, dividing. With the library also goes a mathematical parser to
-help you solving mathematical expressions.
+with big unsigned integer, big signed integer and big floating point
+numbers. It provides standard mathematical operations like adding,
+subtracting, multiplying, dividing etc. With the library also goes
+a mathematical parser which helps you solving input formulas read directly
+from a user.

-TTMath is developed under the BSD licence which means that it is free for
-both personal and commercial use.
+TTMath is developed under the BSD licence which means that it is free
+for both personal and commercial use.
+
+The library has some technical limitations:
+ * there are only two platforms that are supported: x86 and x86_64,
+ * you can use this library only with the C++ programming language.

 The main goal of the library is to allow one to use big values in the same
-way as the standard types like int or float. It does not need to be compiled
-first because the whole library is written as the C++ templates. This means
-only C++ developers can use this library and one thing they have to do is
-to use 'include' directive of the preprocessor. How big the values can be
-is set at compile time.
+way as the standard types like int, float, etc. It does not need to be
+compiled first because the whole library is written as the C++ templates.
+This means only C++ developers can use this library and one thing they have
+to do is to use 'include' directive of the preprocessor. How big the
+values can be is set directly in the source code by the programmer.

 Author: Tomasz Sowa <t.sowa@ttmath.org>
-WWW:    http://www.ttmath.org
-
-Contributors:
-Christian Kaiser <chk@online.de>
+Project pages: http://www.ttmath.org
+http://sourceforge.net/projects/ttmath
--- a/constgen/Makefile
+++ b/constgen/Makefile
@ -1,6 +1,6 @@
 o      = main.o
-CC     = clang++
-CFLAGS = -O2 -DTTMATH_CONSTANTSGENERATOR
+CC     = g++
+CFLAGS = -s -O2 -DTTMATH_CONSTANTSGENERATOR
 name   = gen


@ -13,7 +13,7 @@ name   = gen
 all: $(name)

 $(name): $(o)
-	$(CC) -o $(name) -s $(CFLAGS) $(o)
+	$(CC) -o $(name) $(CFLAGS) $(o)



--- a/constgen/main.cpp
+++ b/constgen/main.cpp
@ -1,7 +1,7 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
--- a/doxygen.cfg
+++ b/doxygen.cfg
--- a/makerelease.sh
+++ b/makerelease.sh
@ -1,137 +0,0 @@
-#!/usr/bin/env bash
-
-a=""
-b=""
-c=""
-p=""
-d=""
-doxygen=""
-
-# reading until not empty
-
-while [ -z $a ]
-do
-	echo -n "Major: " ; read a
-done
-
-
-while [ -z $b ]
-do
-	echo -n "Minor: " ; read b;
-done
-
-
-while [ -z $c ]
-do
-	echo -n "Revision: " ; read c;
-done
-
-
-while [ -z $p ]
-do
-	echo -n "Prerelease? (y/n): " ; read p;
-done
-
-
-while [ -z $d ]
-do
-	echo -n "Add date? (y/n): " ; read d;
-done
-
-
-while [ -z $doxygen ]
-do
-	echo -n "Clean make and add to the package doxygen doc? (y/n): " ; read doxygen;
-done
-
-
-mkdir -p releases
-package_dir_name="ttmath-$a.$b.$c"
-datestr=""
-
-
-if [ $p = "y" -o $p = "Y" ]
-then
-	package_dir_name=${package_dir_name}.prerelease
-fi
-
-package_dir_name=${package_dir_name}-src
-
-if [ $d = "y" -o $d = "Y" ]
-then
-	datestr=`/bin/date "+%G.%m.%d"`;
-	package_dir_name=${package_dir_name}-$datestr
-fi
-
-
-
-
-dir="releases/"${package_dir_name}
-package=${package_dir_name}.tar.gz
-
-
-if [ -d $dir ]
-then
-	echo "Directory $dir exists! (exiting)";
-	exit 1;
-fi
-
-if [ -f "releases/"${package} ] ; then
-	echo "File releases/${package} exists! (exiting)"
-	exit 1;
-fi
-
-
-mkdir $dir
-
-
-
-if [ $doxygen = "y" -o $doxygen = "Y" ]
-then
-
-	echo "------------------------------------------------------"
-	echo "creating doxygen doc"
-	echo "------------------------------------------------------"
-
-	rm -rf doc/doxygen
-	doxygen doxygen.cfg
-
-	cp -r doc $dir/
-fi
-
-
-echo "------------------------------------------------------"
-echo "make clean in samples"
-echo "------------------------------------------------------"
-
-make -C samples clean 
-make -C constgen clean
-
-
-echo "------------------------------------------------------"
-echo "making source package"
-echo "------------------------------------------------------"
-
-mkdir $dir/ttmath
-mkdir $dir/samples
-mkdir $dir/res
-
-cp ttmath/*  $dir/ttmath/
-
-cp samples/* $dir/samples/
-# cmake is not ready yet (cmake will generate Makefile which overwrites our own one)
-rm $dir/samples/CMakeLists.txt
-
-cp COPYRIGHT         $dir/
-cp README            $dir/
-cp CHANGELOG         $dir/
-
-cp res/ttmath_logo.svg	$dir/res/
-
-cd releases
-tar -czf $package ${package_dir_name}
-
-echo "the package has been created to:" releases/${package}
-
-exit 0
-
--- a/res/ttmath_logo.svg
+++ b/res/ttmath_logo.svg
@ -1,96 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="38.084499"
-   height="38.083"
-   id="svg2"
-   version="1.1"
-   inkscape:version="0.48.4 r9939"
-   sodipodi:docname="ttmath_logo.svg">
-  <defs
-     id="defs4" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="11.2"
-     inkscape:cx="24.511255"
-     inkscape:cy="17.621314"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     inkscape:window-width="1440"
-     inkscape:window-height="830"
-     inkscape:window-x="0"
-     inkscape:window-y="25"
-     inkscape:window-maximized="1"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0" />
-  <metadata
-     id="metadata7">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-350.08291,-424.26987)">
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#231f20;fill-opacity:1;stroke:none;stroke-width:1.625;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 369.125,424.28125 c -10.50699,0 -19.03125,8.52426 -19.03125,19.03125 0,10.50603 8.52426,19.03125 19.03125,19.03125 10.50746,0 19.03125,-8.52522 19.03125,-19.03125 0,-10.50699 -8.52379,-19.03125 -19.03125,-19.03125 z"
-       id="path3773" />
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#ffaa35;fill-opacity:1;stroke:none;stroke-width:1.62500000000000000;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 369.125,425.90625 c 9.62928,0 17.40625,7.77748 17.40625,17.40625 0,9.62773 -7.77697,17.40625 -17.40625,17.40625 -9.62877,0 -17.40625,-7.77852 -17.40625,-17.40625 0,-9.62877 7.77748,-17.40625 17.40625,-17.40625 z"
-       id="path2999-2" />
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#231f20;fill-opacity:1;stroke:none;stroke-width:1.5;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 368.1875,432.65625 -0.1875,0.5 -6.34375,16.71875 -1.40625,-4 -0.5,-1.40625 -0.84375,1.25 -2.0625,3.125 1.25,0.8125 1.25,-1.875 1.5625,4.53125 0.6875,1.9375 0.71875,-1.9375 6.90625,-18.15625 8.65625,0 0,-1.5 -9.15625,0 -0.53125,0 z"
-       id="path3003-3"
-       inkscape:connector-curvature="0" />
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#231f20;fill-opacity:1;stroke:none;stroke-width:1.5;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 359.84375,434.34375 0,3 -3,0 0,1.5 3,0 0,3.21875 1.5,0 0,-3.21875 3,0 0,-1.5 -3,0 0,-3 -1.5,0 z"
-       id="path3005-3"
-       inkscape:connector-curvature="0" />
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#231f20;fill-opacity:1;stroke:none;stroke-width:0.9375;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 371.0625,443.5625 0,0.46875 -0.125,4.6875 0,0.15625 0.125,0.15625 c 0,0 0.37411,0.46147 0.9375,0.9375 0.2817,0.23802 0.59509,0.49145 0.96875,0.6875 0.37366,0.19605 0.8013,0.32003 1.25,0.34375 0.93515,0.0491 1.77613,-0.36791 2.40625,-0.78125 0.63012,-0.41334 1.0625,-0.84375 1.0625,-0.84375 l 0.125,-0.15625 0,-0.1875 -0.0937,-5 0,-0.46875 -0.46875,0 -5.71875,0 -0.46875,0 z"
-       id="path3009-7"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cccccsscsccccccccc" />
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#231f20;fill-opacity:1;stroke:none;stroke-width:0.9375;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 377.65625,450.375 -0.0312,0.0312 -0.21875,0.125 c -2.30252,1.65271 -4.15395,1.52806 -6.1125,-0.1562 -1.78014,2.66032 -3.73192,7.25254 -4.29375,8.18745 -0.56183,0.93491 -0.17739,2.37424 -0.28125,3.375 l 0.5625,-0.0312 8.03125,-0.71875 0.125,-0.0312 0.0937,-0.0625 6.96875,-4.5625 0.1875,-0.125 0.0937,-0.0625 -0.0625,-0.3125 c 0.0108,-0.11043 0.0366,-0.43638 0,-0.96875 -0.0466,-1.03041 -0.48309,-1.60724 -0.93745,-2.24995 -0.5467,-0.58055 -1.33798,-1.08483 -2.15625,-1.5 -0.91162,-0.46254 -1.66155,-0.7891 -1.71875,-0.8125 l -0.0625,-0.0312 -0.1875,-0.0937 z"
-       id="path3013-6"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cccczcccccccccccscccc" />
-    <path
-       style="font-size:medium;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-indent:0;text-align:start;text-decoration:none;line-height:normal;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;text-anchor:start;baseline-shift:baseline;color:#000000;fill:#231f20;fill-opacity:1;stroke:none;stroke-width:0.625;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;font-family:Sans;-inkscape-font-specification:Sans"
-       d="m 374.0625,438.21875 c -1.68685,0.1362 -5.3125,0.8125 -5.3125,0.8125 l -0.125,0.0312 -0.0625,0.125 -1.375,2.09375 -0.0312,0.0625 0,0.0937 0.1875,6.15625 0.0312,0.15625 0.125,0.0937 0.3125,0.21875 0.5,0.3125 -0.0312,-0.59375 -0.0937,-5.90625 c 0.081,-0.0694 0.35604,-0.32331 0.6875,-0.4375 l 0.0312,0 c 0.0323,-0.01 0.0883,0.01 0.125,0 l 1.46875,-0.0937 c 0.1093,0.60186 0.39332,1.20774 0.4812,1.8125 1.27397,-0.0782 2.40491,-0.17552 3.5031,-0.16892 1.08715,0.0103 2.17115,0.13001 3.2344,0.12517 l 0.0312,-0.6125 c 0,0 0.0422,-0.16533 0.0625,-0.28125 l 0.40625,-0.9375 c 0.004,-0.005 -0.004,-0.0267 0,-0.0312 l 0.0312,0 c 0.17093,-0.1709 0.53319,-0.25585 0.8125,-0.375 0.26159,-0.11159 0.42068,-0.28594 0.75,-0.375 l 0.0312,0 0.125,-0.0312 2.28125,-0.1875 0.0312,0 0.28125,0 0,-0.0312 0,-0.28125 0,-0.71875 0,-0.25 -0.25,-0.0625 -3.75,-0.71875 c -0.0114,-10e-4 -0.02,0.001 -0.0312,0 -1.37083,-0.13192 -2.78705,-0.1247 -4.40625,0 l -0.0312,0 -0.0312,0 z"
-       id="path3017-6"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="ccccccccccccccccccccccccccsccccccccccccccccc" />
-  </g>
-</svg>
--- a/res/ttmath_logo_for_doxygen_doc.png
+++ b/res/ttmath_logo_for_doxygen_doc.png
--- a/samples/CMakeLists.txt
+++ b/samples/CMakeLists.txt
@ -1,16 +0,0 @@
-# CMake configuration for ttmath/samples
-
-# Building with Visual C++ x86_64 needs to compile the asm utilities first
-if (MSVC AND "x${CMAKE_VS_PLATFORM_NAME}" STREQUAL "xx64")
-  set(TTMATH_MSVC64_ASM ttmathuint_x86_64_msvc.asm) 
-  enable_language(ASM_MASM)
-  message(STATUS "Enabled MASM to compile '${TTMATH_MSVC64_ASM}'")
-  set(TTMATH_SRC_ASM ${ttmath_SOURCE_DIR}/ttmath/${TTMATH_MSVC64_ASM})
-endif()
-
-set(SAMPLES big big2 int uint parser)
-foreach(sample ${SAMPLES})
-	add_executable(${sample} ${sample}.cpp ${TTMATH_SRC_ASM})
-	# Allow to run all utilities at once as a test
-	add_test(${sample} ${sample})
-endforeach()
--- a/samples/Makefile
+++ b/samples/Makefile
@ -1,6 +1,5 @@
 CC     = g++
-#CC     = clang++
-CFLAGS = -Wall -pedantic -O2 -I.. -DTTMATH_DONT_USE_WCHAR
+CFLAGS = -Wall -pedantic -s -O2 -I.. 


 .SUFFIXES: .cpp .o
@ -9,29 +8,25 @@ CFLAGS = -Wall -pedantic -O2 -I.. -DTTMATH_DONT_USE_WCHAR
 	$(CC) -c $(CFLAGS) $<


-all: uint int big big2 parser
+all: uint int big parser


 uint: uint.o
-	$(CC) -o uint -s $(CFLAGS) uint.o
+	$(CC) -o uint $(CFLAGS) uint.o

 int: int.o
-	$(CC) -o int -s $(CFLAGS) int.o
+	$(CC) -o int $(CFLAGS) int.o

 big: big.o
-	$(CC) -o big -s $(CFLAGS) big.o
-
-big2: big2.o
-	$(CC) -o big2 -s $(CFLAGS) big2.o
+	$(CC) -o big $(CFLAGS) big.o

 parser: parser.o
-	$(CC) -o parser -s $(CFLAGS) parser.o
+	$(CC) -o parser $(CFLAGS) parser.o


 uint.o:		uint.cpp
 int.o:		int.cpp
 big.o:		big.cpp
-big2.o:		big2.cpp
 parser.o:	parser.cpp


@ -41,7 +36,6 @@ clean:
 	rm -f uint
 	rm -f int
 	rm -f big
-	rm -f big2
 	rm -f parser
-# on MS Windows suffixes .exe will be automatically added
+# on MS Windows can automatically be added suffixes .exe to the names of output programs
 	rm -f *.exe
--- a/samples/big.cpp
+++ b/samples/big.cpp
@ -5,10 +5,8 @@
 // this type has 2 words for its mantissa and 1 word for its exponent
 // (on a 32bit platform one word means a word of 32 bits,
 // and on a 64bit platform one word means a word of 64 bits)
-
-// Big<exponent, mantissa>
 typedef ttmath::Big<1,2> MyBig;
-
+ 
       
 void SimpleCalculating(const MyBig & a, const MyBig & b)
 {
@ -58,7 +56,6 @@ MyBig atemp;
 	
 }

-
 int main()
 {
 MyBig a,b;
@ -88,13 +85,13 @@ a = 123456.543456
 b = 98767878.124322
 a + b = 98891334.667778
 a - b = -98644421.580866
-a * b = 12193540837712.27076
-a / b = 0.00124996654580957646
+a * b = 12193540837712.2708
+a / b = 0.0012499665458095765
 Calculating with a carry
-a = 1.6248012560666408782e+646457012
-b = 456.319999999999993
-a + b = 1.6248012560666408782e+646457012
-a - b = 1.6248012560666408782e+646457012
+a = 1.624801256070839555e+646457012
+b = 456.31999999999999
+a + b = 1.624801256070839555e+646457012
+a - b = 1.624801256070839555e+646457012
 a * b = (carry)
-a / b = 3.560661939136222174e+646457009
+a / b = 3.56066193914542334e+646457009
 */
--- a/samples/big2.cpp
+++ b/samples/big2.cpp
@ -1,113 +0,0 @@
-#include <ttmath/ttmath.h>
-#include <iostream>
-
-
-// this is a similar example to big.cpp
-// but now we're using TTMATH_BITS() macro
-// this macro returns how many words we need to store
-// the given number of bits
-
-// TTMATH_BITS(64) 
-//   on a 32bit platform the macro returns 2 (2*32=64)
-//   on a 64bit platform the macro returns 1
-
-// TTMATH_BITS(128)
-//   on a 32bit platform the macro returns 4 (4*32=128)
-//   on a 64bit platform the macro returns 2 (2*64=128)
-
-// Big<exponent, mantissa>
-typedef ttmath::Big<TTMATH_BITS(64), TTMATH_BITS(128)> MyBig;
-
-// consequently on a 32bit platform we define: Big<2, 4>
-// and on a 64bit platform: Big<1, 2>
-// and the calculations will be the same on both platforms       
-       
-       
-void SimpleCalculating(const MyBig & a, const MyBig & b)
-{
-	std::cout << "Simple calculating" << std::endl;
-	std::cout << "a = " << a << std::endl;
-	std::cout << "b = " << b << std::endl;
-	std::cout << "a + b = " << a+b << std::endl;
-	std::cout << "a - b = " << a-b << std::endl;
-	std::cout << "a * b = " << a*b << std::endl;
-	std::cout << "a / b = " << a/b << std::endl;
-}
-
-
-void CalculatingWithCarry(const MyBig & a, const MyBig & b)
-{
-MyBig atemp;
-
-	std::cout << "Calculating with a carry" << std::endl;
-	std::cout << "a = " << a << std::endl;
-	std::cout << "b = " << b << std::endl;
-
-	atemp = a;
-	if( !atemp.Add(b) )
-		std::cout << "a + b = " << atemp << std::endl;
-	else
-		std::cout << "a + b = (carry)" << std::endl;
-		// it have no sense to print 'atemp' (it's undefined)
-
-	atemp = a;
-	if( !atemp.Sub(b) )
-		std::cout << "a - b = " << atemp << std::endl;
-	else
-		std::cout << "a - b = (carry)" << std::endl;
-		
-	atemp = a;
-	if( !atemp.Mul(b) )
-		std::cout << "a * b = " << atemp << std::endl;
-	else
-		std::cout << "a * b = (carry)" << std::endl;
-		
-		
-	atemp = a;
-	if( !atemp.Div(b) )
-		std::cout << "a / b = " << atemp << std::endl;
-	else
-		std::cout << "a / b = (carry or division by zero) " << std::endl;
-	
-}
-
-
-int main()
-{
-MyBig a,b;
-	
-	// conversion from 'const char *'
-	a = "123456.543456";
-	b = "98767878.124322";
-	
-	SimpleCalculating(a,b);
-	
-	// 'a' will have the max value which can be held in this type
-	a.SetMax();
-	
-	// conversion from double
-	b = 456.32;
-	
-	// Look at the value 'a' and the product from a+b and a-b
-	// Don't worry this is the nature of floating point numbers
-	CalculatingWithCarry(a,b);
-}
-
-/*
-the result (the same on a 32 or 64bit platform):
-
-Simple calculating
-a = 123456.543456
-b = 98767878.124322
-a + b = 98891334.667778
-a - b = -98644421.580866
-a * b = 12193540837712.270763536832
-a / b = 0.0012499665458095764605964485261668609133
-Calculating with a carry
-a = 2.34953455457111777368832820909595050034e+2776511644261678604
-b = 456.3199999999999931787897367030382156
-a + b = 2.34953455457111777368832820909595050034e+2776511644261678604
-a - b = 2.34953455457111777368832820909595050034e+2776511644261678604
-a * b = (carry)
-a / b = 5.1488748127873374141170361292780486452e+2776511644261678601
-*/
--- a/samples/parser.cpp
+++ b/samples/parser.cpp
@ -29,11 +29,6 @@ const char equation[] = " (34 + 24) * 123 - 34.32 ^ 6 * sin(2.56) - atan(10)";

 /*
 the result (on 32 bit platform):
-897705014.525731067
-*/

-
-/*
-the result (on 64 bit platform):
-897705014.5257310676097719585259773124
+-897705014.52573107
 */
--- a/tests/Makefile
+++ b/tests/Makefile
@ -1,6 +1,6 @@
-CC     = clang++
+CC     = g++
 o      = main.o uinttest.o
-CFLAGS = -Wall -O2
+CFLAGS = -Wall -O2 -s
 ttmath = ..
 name   = tests

@ -16,7 +16,7 @@ all: $(name)


 $(name): $(o)
-	$(CC) -o $(name) -s $(CFLAGS) -I$(ttmath) $(o)
+	$(CC) -o $(name) $(CFLAGS) -I$(ttmath) $(o)


 main.o: main.cpp uinttest.h
--- a/tests/main.cpp
+++ b/tests/main.cpp
@ -1,7 +1,7 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
--- a/tests/uinttest.cpp
+++ b/tests/uinttest.cpp
@ -1,7 +1,7 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
--- a/tests/uinttest.h
+++ b/tests/uinttest.h
@ -1,7 +1,7 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
--- a/tests2/Makefile
+++ b/tests2/Makefile
@ -1,133 +0,0 @@
-#CC     = g++6
-#CFLAGS = -Wall -pedantic -O3 -s -I.. -Wl,-rpath=/usr/local/lib/gcc6
-#CFLAGS = -Wall -pedantic -O3 -DTTMATH_NOASM -s -I.. -Wl,-rpath=/usr/local/lib/gcc6
-
-CC     = clang++
-CFLAGS = -Wall -pedantic -O3 -s -I..
-#CFLAGS = -Wall -pedantic -O3 -DTTMATH_NOASM -s -I..
-
-
-
-.SUFFIXES: .cpp .o
-
-.cpp.o:
-	$(CC) -c $(CFLAGS) $<
-
-
-
-
-all: big_64_64 big_64_128 big_64_192 big_64_256 big_64_512 big_64_1024 big_64_2048 big_64_4096 big_128_512 big_256_1024 big_512_2048 big_128_4096
-
-
-
-
-
-
-big_64_64: main.cpp
-	$(CC) -o big_64_64 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=64 main.cpp
-
-big_64_128: main.cpp
-	$(CC) -o big_64_128 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=128 main.cpp
-
-big_64_192: main.cpp
-	$(CC) -o big_64_192 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=192 main.cpp
-
-big_64_256: main.cpp
-	$(CC) -o big_64_256 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=256 main.cpp
-
-big_64_512: main.cpp
-	$(CC) -o big_64_512 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=512 main.cpp
-
-big_64_1024: main.cpp
-	$(CC) -o big_64_1024 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=1024 main.cpp
-
-big_64_2048: main.cpp
-	$(CC) -o big_64_2048 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=2048 main.cpp
-
-big_64_4096: main.cpp
-	$(CC) -o big_64_4096 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=64 -DTTMATH_TEST_BIG_MANTISSA=4096 main.cpp
-
-big_128_512: main.cpp
-	$(CC) -o big_128_512 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=128 -DTTMATH_TEST_BIG_MANTISSA=512 main.cpp
-
-big_256_1024: main.cpp
-	$(CC) -o big_256_1024 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=256 -DTTMATH_TEST_BIG_MANTISSA=1024 main.cpp
-
-big_512_2048: main.cpp
-	$(CC) -o big_512_2048 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=512 -DTTMATH_TEST_BIG_MANTISSA=2048 main.cpp
-
-big_128_4096: main.cpp
-	$(CC) -o big_128_4096 -s $(CFLAGS) -DTTMATH_TEST_BIG_EXPONENT=128 -DTTMATH_TEST_BIG_MANTISSA=4096 main.cpp
-
-
-
-
-test: all
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=64"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_64 "foo" | tee big_64_64.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=128"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_128 "foo" | tee big_64_128.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=192"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_192 "foo" | tee big_64_192.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=256"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_256 "foo" | tee big_64_256.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=512"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_512 "foo" | tee big_64_512.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=1024"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_1024 "foo" | tee big_64_1024.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=2048"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_2048 "foo" | tee big_64_2048.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=64 and mantissa=4096"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_64_4096 "foo" | tee big_64_4096.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=128 and mantissa=512"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_128_512 "foo" | tee big_128_512.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=128 and mantissa=4096"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_128_4096 "foo" | tee big_128_4096.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=256 and mantissa=1024"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_256_1024 "foo" | tee big_256_1024.out
-
-	@echo "****************************************************************************"
-	@echo "making tests for exponent=512 and mantissa=2048"
-	@echo "****************************************************************************"
-	cat tests.txt | xargs -S 4096 -I foo ./big_512_2048 "foo" | tee big_512_2048.out
-
-	./check_files.sh
-
-
-clean:
-	rm -f *.out
-	rm -f big_64_64 big_64_128 big_64_192 big_64_256 big_64_512 big_64_1024 big_64_2048 big_64_4096 big_128_512 big_256_1024 big_512_2048 big_128_4096
-# on MS Windows suffixes .exe will be automatically added
-	rm -f *.exe
--- a/tests2/big_128_4096.expected
+++ b/tests2/big_128_4096.expected
--- a/tests2/big_128_512.expected
+++ b/tests2/big_128_512.expected
--- a/tests2/big_256_1024.expected
+++ b/tests2/big_256_1024.expected
--- a/tests2/big_512_2048.expected
+++ b/tests2/big_512_2048.expected
--- a/tests2/big_64_1024.expected
+++ b/tests2/big_64_1024.expected
--- a/tests2/big_64_128.expected
+++ b/tests2/big_64_128.expected
--- a/tests2/big_64_192.expected
+++ b/tests2/big_64_192.expected
--- a/tests2/big_64_2048.expected
+++ b/tests2/big_64_2048.expected
--- a/tests2/big_64_256.expected
+++ b/tests2/big_64_256.expected
--- a/tests2/big_64_4096.expected
+++ b/tests2/big_64_4096.expected
--- a/tests2/big_64_512.expected
+++ b/tests2/big_64_512.expected
--- a/tests2/big_64_64.expected
+++ b/tests2/big_64_64.expected
--- a/tests2/check_files.sh
+++ b/tests2/check_files.sh
@ -1,31 +0,0 @@
-#!/bin/sh
-
-was_error=0
-
-for expected in *.expected ; do
-
-	out=`basename $expected .expected`.out
-	
-	if [ -f $out ] ; then
-		diff -u $out $expected
-		
-		if [ `diff -u $out $expected | wc -l` -ne 0 ] ; then
-			was_error=1
-		fi
-	else
-		echo "there is no file: $out"
-		was_error=1
-	fi
-
-done
-
-
-if [ $was_error -eq 0 ] ; then
-	echo "****************************************************************************"
-	echo "             congratulations: all tests passed successfully"
-	echo "****************************************************************************"
-else
-	echo "****************************************************************************"
-	echo "             error: not all tests passed successfully"
-	echo "****************************************************************************"
-fi
--- a/tests2/main.cpp
+++ b/tests2/main.cpp
@ -1,39 +0,0 @@
-#include <ttmath/ttmath.h>
-#include <iostream>
-
-int main(int argc, char ** argv)
-{
-	typedef ttmath::Big<TTMATH_BITS(TTMATH_TEST_BIG_EXPONENT), TTMATH_BITS(TTMATH_TEST_BIG_MANTISSA)> MyBig;
-	ttmath::Parser<MyBig> parser;
-	std::string all_input;
-
-	for(int i=1 ; i<argc ; ++i)
-	{
-		if( i > 1 )
-			all_input += ' ';
-			
-		all_input += argv[i];
-	}
-
-	std::cout << all_input << " = ";
-	ttmath::ErrorCode err = parser.Parse(all_input);
-
-	if( err == ttmath::err_ok )
-	{
-		for(size_t i=0 ; i < parser.stack.size() ; ++i)
-		{
-			if( i > 0 )
-				std::cout << " ; ";
-			
-			std::cout << parser.stack[i].value;
-		}
-		
-		std::cout << std::endl;
-	}
-	else
-	{
-		std::cout << "error: " << static_cast<int>(err) << std::endl;
-	}
-	
-	return 0;
-}
--- a/tests2/tests.txt
+++ b/tests2/tests.txt
--- a/ttmath/ttmath.h
+++ b/ttmath/ttmath.h
--- a/ttmath/ttmathbig.h
+++ b/ttmath/ttmathbig.h
--- a/ttmath/ttmathdec.h
+++ b/ttmath/ttmathdec.h
@ -1,419 +0,0 @@
-/*
- * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
- */
-
-/* 
- * Copyright (c) 2012, Tomasz Sowa
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *    
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *    
- *  * Neither the name Tomasz Sowa nor the names of contributors to this
- *    project may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef headerfilettmathdec
-#define headerfilettmathdec
-
-#include "ttmathtypes.h"
-#include "ttmaththreads.h"
-#include "ttmathuint.h"
-
-
-
-namespace ttmath
-{
-
-template<uint value_size, uint dec_digits>
-class Dec
-{
-public:
-
-	UInt<value_size> value;
-	unsigned char info;
-
-
-	/*!
-		Sign
-		the mask of a bit from 'info' which means that there is a sign
-		(when the bit is set)
-	*/
-	#define TTMATH_DEC_SIGN 128
-
-
-	/*!
-		Not a number
-		if this bit is set that there is not a valid number
-	*/
-	#define TTMATH_DEC_NAN  64
-
-
-
-
-	Dec()
-	{
-		info = TTMATH_DEC_NAN;
-	}
-
-
-	Dec(const char * s)
-	{
-		info = TTMATH_DEC_NAN;
-		FromString(s);
-	}
-
-
-	Dec<value_size, dec_digits> & operator=(const char * s)
-	{
-		FromString(s);
-
-	return *this;
-	}
-
-
-	uint FromString(const char * s, const char ** after_source = 0, bool * value_read = 0)
-	{
-		return FromStringBase(s, after_source, value_read);
-	}
-
-
-	void ToString(std::string & result) const
-	{
-		ToStringBase(result);
-	}
-
-
-	/*!
-		this method clears a specific bit in the 'info' variable
-
-		bit is one of: 
-	*/
-	void ClearInfoBit(unsigned char bit)
-	{
-		info = info & (~bit);
-	}
-
-
-	/*!
-		this method sets a specific bit in the 'info' variable
-
-		bit is one of: 
-
-	*/
-	void SetInfoBit(unsigned char bit)
-	{
-		info = info | bit;
-	}
-
-
-	/*!
-		this method returns true if a specific bit in the 'info' variable is set
-
-		bit is one of: 
-	*/
-	bool IsInfoBit(unsigned char bit) const
-	{
-		return (info & bit) != 0;
-	}
-
-
-	bool IsNan() const 
-	{
-		return IsInfoBit(TTMATH_DEC_NAN);
-	}
-
-
-	bool IsSign() const 
-	{
-		return IsInfoBit(TTMATH_DEC_SIGN);
-	}
-
-
-	/*!
-		this method sets the sign
-
-			e.g.
-			-1 -> -1
-			2  -> -2
-
-		we do not check whether there is a zero or not, if you're using this method
-		you must be sure that the value is (or will be afterwards) different from zero
-	*/
-	void SetSign()
-	{
-		SetInfoBit(TTMATH_DEC_SIGN);
-	}
-
-
-	void SetNaN()
-	{
-		SetInfoBit(TTMATH_DEC_NAN);
-	}
-
-
-	void Abs()
-	{
-		ClearInfoBit(TTMATH_DEC_SIGN);
-	}
-
-
-
-	uint Add(const Dec<value_size, dec_digits> & arg)
-	{
-	uint c = 0;
-
-		if( IsSign() == arg.IsSign() )
-		{
-			c += value.Add(arg.value);		
-		}
-		else
-		{
-			bool is_sign;
-
-			if( value > arg.value )
-			{
-				is_sign = IsSign();
-				value.Sub(arg.value);
-			}
-			else
-			{
-				is_sign = arg.IsSign();
-				UInt<value_size> temp(this->value);
-				value = arg.value;
-				value.Sub(temp);
-			}
-
-			is_sign ? SetSign() : Abs();
-		}
-
-		if( c )
-			SetNaN();
-
-	return (c==0)? 0 : 1;
-	}
-
-/*
-	uint Sub(const Dec<value_size, dec_digits> & arg)
-	{
-	}
-*/
-
-private:
-
-
-
-
-
-
-#ifndef TTMATH_MULTITHREADS
-
-	/*!
-	*/
-	void SetMultipler(UInt<value_size> & result)
-	{
-		// this guardian is initialized before the program runs (static POD type)
-		static int guardian = 0;
-		static UInt<value_size> multipler;
-	
-		if( guardian == 0 )
-		{
-			multipler = 10;
-			multipler.Pow(dec_digits);
-			guardian = 1;
-		}
-
-		result = multipler;
-	}
-
-#else
-
-	/*!
-	*/
-	void SetMultipler(UInt<value_size> & result)
-	{
-		// this guardian is initialized before the program runs (static POD type)
-		volatile static sig_atomic_t guardian = 0;
-		static UInt<value_size> * pmultipler;
-	
-		// double-checked locking
-		if( guardian == 0 )
-		{
-			ThreadLock thread_lock;
-
-			// locking
-			if( thread_lock.Lock() )
-			{
-				static UInt<value_size> multipler;
-
-				if( guardian == 0 )
-				{
-					pmultipler = &multipler;
-					multipler = 10;
-					multipler.Pow(dec_digits);
-					guardian = 1;
-				}
-			}
-			else
-			{
-				// there was a problem with locking, we store the result directly in 'result' object
-				result = 10;
-				result.Pow(dec_digits);
-				
-			return;
-			}
-
-			// automatically unlocking
-		}
-
-		result = *pmultipler;
-	}
-
-#endif
-
-
-
-	/*!
-		an auxiliary method for converting from a string
-	*/
-	template<class char_type>
-	uint FromStringBase(const char_type * s, const char_type ** after_source = 0, bool * value_read = 0)
-	{
-		UInt<value_size> multipler;
-		const char_type * after;
-		uint c = 0;
-		info = 0;
-
-		Misc::SkipWhiteCharacters(s);
-
-		if( *s == '-' )
-		{
-			s += 1;
-			SetSign();
-		}
-		else
-		if( *s == '+' )
-		{
-			s += 1;
-		}
-
-		c += value.FromString(s, 10, &after, value_read);
-
-		if( after_source )
-			*after_source = after;
-
-		SetMultipler(multipler);
-		c += value.Mul(multipler);
-
-		if( *after == '.' )
-			c += FromStringBaseAfterComma(after+1, after_source);
-
-		if( c )
-			SetInfoBit(TTMATH_DEC_NAN);
-
-	return (c==0)? 0 : 1;
-	}
-
-
-	template<class char_type>
-	uint FromStringBaseAfterComma(const char_type * s, const char_type ** after_source = 0, bool * value_read = 0)
-	{
-		UInt<value_size> temp;
-		UInt<value_size> multipler;
-		sint z;
-		uint c = 0;
-		size_t i = dec_digits;
-
-		SetMultipler(multipler);
-
-		for( ; i>0 && (z=Misc::CharToDigit(*s, 10)) != -1 ; --i, ++s )
-		{
-			multipler.DivInt(10);
-			temp.SetZero();
-
-			if( value_read )
-				*value_read = true;
-
-			if( c == 0 )
-			{
-				temp.table[0] = z;
-				c += temp.Mul(multipler);
-				c += value.Add(temp);
-			}
-		}
-
-		if( i == 0 && (z=Misc::CharToDigit(*s, 10)) != -1 && z >= 5 )
-			c += value.AddOne();
-
-		if( after_source )
-		{
-			while( (z=Misc::CharToDigit(*s, 10)) != -1 )
-				s += 1;
-
-			*after_source = s;
-		}
-
-	return c;
-	}
-
-
-
-	template<class string_type>
-	void ToStringBase(string_type & result) const
-	{
-		if( IsNan() )
-		{
-			result = "NaN";
-			return;
-		}
-
-		value.ToStringBase(result, 10, IsSign());
-
-		if( dec_digits > 0 )
-		{
-			size_t size = result.size();
-
-			if( IsSign() && size > 0 )
-				size -= 1;
-
-			if( dec_digits >= size )
-			{
-				size_t zeroes = dec_digits - size + 1;
-				size_t start  = IsSign() ? 1 : 0;
-				result.insert(start, zeroes, '0');
-			}
-
-			result.insert(result.end() - dec_digits, '.');
-		}
-	}
-
-
-
-};
-
-
-} // namespace
-
-#endif
--- a/ttmath/ttmathint.h
+++ b/ttmath/ttmathint.h
--- a/ttmath/ttmathmisc.h
+++ b/ttmath/ttmathmisc.h
@ -1,250 +0,0 @@
-/*
- * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
- */
-
-/* 
- * Copyright (c) 2006-2010, Tomasz Sowa
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *    
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *    
- *  * Neither the name Tomasz Sowa nor the names of contributors to this
- *    project may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef headerfilettmathmisc
-#define headerfilettmathmisc
-
-
-/*!
-	\file ttmathmisc.h
-    \brief some helpful functions
-*/
-
-
-#include <string>
-
-
-namespace ttmath
-{
-
-/*!
-	some helpful functions
-*/
-class Misc
-{
-public:
-
-
-/*
- *
- *	AssignString(result, str)
- *	result = str
- *
- */
-
-/*!
-	result = str
-*/
-static void AssignString(std::string & result, const char * str)
-{
-	result = str;
-}
-
-
-#ifndef TTMATH_DONT_USE_WCHAR
-
-/*!
-	result = str
-*/
-static void AssignString(std::wstring & result, const char * str)
-{
-	result.clear();
-
-	for( ; *str ; ++str )
-		result += *str;
-}
-
-
-/*!
-	result = str
-*/
-static void AssignString(std::wstring & result, const std::string & str)
-{
-	return AssignString(result, str.c_str());
-}
-
-
-/*!
-	result = str
-*/
-static void AssignString(std::string & result, const wchar_t * str)
-{
-	result.clear();
-
-	for( ; *str ; ++str )
-		result += static_cast<char>(*str);
-}
-
-
-/*!
-	result = str
-*/
-static void AssignString(std::string & result, const std::wstring & str)
-{
-	return AssignString(result, str.c_str());
-}
-
-#endif
-
-
-/*
- *
- *	AddString(result, str)
- *	result += str
- *
- */
-
-
-/*!
-	result += str
-*/
-static void AddString(std::string & result, const char * str)
-{
-	result += str;
-}
-
-
-#ifndef TTMATH_DONT_USE_WCHAR
-
-/*!
-	result += str
-*/
-static void AddString(std::wstring & result, const char * str)
-{
-	for( ; *str ; ++str )
-		result += *str;
-}
-
-#endif
-
-
-/*
-	this method omits any white characters from the string
-	char_type is char or wchar_t
-*/
-template<class char_type>
-static void SkipWhiteCharacters(const char_type * & c)
-{
-	// 13 is at the end in a DOS text file (\r\n)
-	while( (*c==' ' ) || (*c=='\t') || (*c==13 ) || (*c=='\n') )
-		++c;
-}
-
-
-
-
-/*!
-	this static method converts one character into its value
-
-	for example:
-	-  1 -> 1
-	-  8 -> 8
-	-  A -> 10
-	-  f -> 15
-
-	this method don't check whether c is correct or not
-*/
-static uint CharToDigit(uint c)
-{
-	if(c>='0' && c<='9')
-		return c-'0';
-
-	if(c>='a' && c<='z')
-		return c-'a'+10;
-
-return c-'A'+10;
-}
-
-
-/*!
-	this method changes a character 'c' into its value
-	(if there can't be a correct value it returns -1)
-
-	for example:
-	-  c=2, base=10 -> function returns 2
-	-  c=A, base=10 -> function returns -1
-	-  c=A, base=16 -> function returns 10
-*/
-static sint CharToDigit(uint c, uint base)
-{
-	if( c>='0' && c<='9' )
-		c=c-'0';
-	else
-	if( c>='a' && c<='z' )
-		c=c-'a'+10;
-	else
-	if( c>='A' && c<='Z' )
-		c=c-'A'+10;
-	else
-		return -1;
-
-
-	if( c >= base )
-		return -1;
-
-
-return sint(c);
-}
-
-
-
-/*!
-	this method converts a digit into a char
-	digit should be from <0,F>
-	(we don't have to get a base)
-	
-	for example:
-	-  1  -> 1
-	-  8  -> 8
-	-  10 -> A
-	-  15 -> F
-*/
-static uint DigitToChar(uint digit)
-{
-	if( digit < 10 )
-		return digit + '0';
-
-return digit - 10 + 'A';
-}
-
-
-}; // struct Misc
-
-}
-
-
-#endif
--- a/ttmath/ttmathobjects.h
+++ b/ttmath/ttmathobjects.h
@ -1,11 +1,11 @@
 /*
 * This file is a part of TTMath Mathematical Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
- * Copyright (c) 2006-2017, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
@ -44,13 +44,12 @@
    \brief Mathematic functions.
 */

+#include "ttmathtypes.h"
+
 #include <string>
-#include <vector>
 #include <list>
 #include <map>

-#include "ttmathtypes.h"
-#include "ttmathmisc.h"


 namespace ttmath
@ -74,14 +73,13 @@ public:
 	struct Item
 	{
 		// name of a variable of a function
-		// internally we store variables and funcions as std::string (not std::wstring even when wide characters are used)
 		std::string value;

 		// number of parameters required by the function
 		// (if there's a variable this 'param' is ignored)
 		int param;

-		Item() { param = 0; }
+		Item() {}
 		Item(const std::string & v, int p) : value(v), param(p) {}
 	};

@ -114,8 +112,7 @@ public:
 	/*!
 		this method returns true if the name can be as a name of an object
 	*/
-	template<class string_type>
-	static bool IsNameCorrect(const string_type & name)
+	static bool IsNameCorrect(const std::string & name)
 	{
 		if( name.empty() )
 			return false;
@ -123,7 +120,7 @@ public:
 		if( !CorrectCharacter(name[0], false) )
 			return false;

-		typename string_type::const_iterator i = name.begin();
+		std::string::const_iterator i=name.begin();

 		for(++i ; i!=name.end() ; ++i)
 			if( !CorrectCharacter(*i, true) )
@ -148,27 +145,6 @@ public:
 	}


-
-#ifndef TTMATH_DONT_USE_WCHAR
-
-	/*!
-		this method returns true if such an object is defined (name exists)
-	*/
-	bool IsDefined(const std::wstring & name)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return false;
-
-		Misc::AssignString(str_tmp1, name);
-
-	return IsDefined(str_tmp1);
-	}
-
-#endif
-
-
 	/*!
 		this method adds one object (variable of function) into the table
 	*/
@ -189,27 +165,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-	/*!
-		this method adds one object (variable of function) into the table
-	*/
-	ErrorCode Add(const std::wstring & name, const std::wstring & value, int param = 0)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-		Misc::AssignString(str_tmp2, value);
-		
-	return Add(str_tmp1, str_tmp2, param);
-	}
-
-#endif
-
-
 	/*!
 		this method returns 'true' if the table is empty
 	*/
@ -267,28 +222,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-
-	/*!
-		this method changes the value and the number of parameters for a specific object
-	*/
-	ErrorCode EditValue(const std::wstring & name, const std::wstring & value, int param = 0)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-		Misc::AssignString(str_tmp2, value);
-		
-	return EditValue(str_tmp1, str_tmp2, param);
-	}
-
-#endif
-
-
 	/*!
 		this method changes the name of a specific object
 	*/
@ -320,29 +253,6 @@ public:
 	}


-
-#ifndef TTMATH_DONT_USE_WCHAR
-
-
-	/*!
-		this method changes the name of a specific object
-	*/
-	ErrorCode EditName(const std::wstring & old_name, const std::wstring & new_name)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(old_name) || !IsNameCorrect(new_name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, old_name);
-		Misc::AssignString(str_tmp2, new_name);
-
-	return EditName(str_tmp1, str_tmp2);
-	}
-
-#endif
-
-
 	/*!
 		this method deletes an object
 	*/
@ -362,27 +272,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-
-	/*!
-		this method deletes an object
-	*/
-	ErrorCode Delete(const std::wstring & name)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-
-	return Delete(str_tmp1);
-	}	
-		
-#endif
-
-
 	/*!
 		this method gets the value of a specific object
 	*/
@ -405,28 +294,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-	/*!
-		this method gets the value of a specific object
-	*/
-	ErrorCode GetValue(const std::wstring & name, std::wstring & value)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-		ErrorCode err = GetValue(str_tmp1, str_tmp2);
-		Misc::AssignString(value, str_tmp2);
-
-	return err;
-	}
-
-#endif
-
-
 	/*!
 		this method gets the value of a specific object
 		(this version is used for not copying the whole string)
@ -450,27 +317,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-	/*!
-		this method gets the value of a specific object
-		(this version is used for not copying the whole string)
-	*/
-	ErrorCode GetValue(const std::wstring & name, const char ** value)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-
-	return GetValue(str_tmp1, value);
-	}
-
-#endif
-
-
 	/*!
 		this method gets the value and the number of parameters
 		of a specific object
@ -484,7 +330,7 @@ public:

 		if( i == table.end() )
 		{
-			value.clear();
+			value.empty();
 			*param = 0;
 			return err_unknown_object;
 		}
@ -496,29 +342,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-	/*!
-		this method gets the value and the number of parameters
-		of a specific object
-	*/
-	ErrorCode GetValueAndParam(const std::wstring & name, std::wstring & value, int * param)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-		ErrorCode err = GetValueAndParam(str_tmp1, str_tmp2, param);
-		Misc::AssignString(value, str_tmp2);
-
-	return err;
-	}
-
-#endif
-
-
 	/*!
 		this method sets the value and the number of parameters
 		of a specific object
@ -545,31 +368,6 @@ public:
 	}


-#ifndef TTMATH_DONT_USE_WCHAR
-
-
-	/*!
-		this method sets the value and the number of parameters
-		of a specific object
-		(this version is used for not copying the whole string
-		but in fact we make one copying during AssignString())
-	*/
-	ErrorCode GetValueAndParam(const std::wstring & name, const char ** value, int * param)
-	{
-		// we should check whether the name (in wide characters) are correct
-		// before calling AssignString() function
-		if( !IsNameCorrect(name) )
-			return err_incorrect_name;
-
-		Misc::AssignString(str_tmp1, name);
-
-	return GetValueAndParam(str_tmp1, value, param);
-	}
-
-
-#endif
-
-
 	/*!
 		this method returns a pointer into the table
 	*/
@ -582,7 +380,6 @@ public:
 private:

 	Table table;
-	std::string str_tmp1, str_tmp2;

 }; // end of class Objects

@ -629,11 +426,11 @@ public:
 	
 	/*!
 		default constructor
-		default max size of the History's container is 15 items
+		default max size of the History's container is 10 items
 	*/
 	History()
 	{
-		buffer_max_size = 15;
+		buffer_max_size = 10;
 	}


@ -690,121 +487,10 @@ public:
 	return false;
 	}

-
-	/*!
-		this methods deletes an item
-
-		we assume that there is only one item with the 'key'
-		(this methods removes the first one)
-	*/
-	bool Remove(const ValueType & key)
-	{
-		typename buffer_type::iterator i = buffer.begin();
-
-		for( ; i != buffer.end() ; ++i )
-		{
-			if( i->key == key )
-			{
-				buffer.erase(i);
-				return true;
-			}
-		}
-
-	return false;
-	}
-
-
 }; // end of class History



-/*!
-	this is an auxiliary class used when calculating Gamma() or Factorial()
-
-	in multithreaded environment you can provide an object of this class to
-	the Gamma() or Factorial() function, e.g;
-
-		typedef Big<1, 3> MyBig;
-		MyBig x = 123456;
-		CGamma<MyBig> cgamma;
-		std::cout << Gamma(x, cgamma);
-
-	each thread should have its own CGamma<> object
-
-	in a single-thread environment a CGamma<> object is a static variable
-	and you don't have to explicitly use it, e.g.
-
-		typedef Big<1, 3> MyBig;
-		MyBig x = 123456;
-		std::cout << Gamma(x);
-*/
-template<class ValueType>
-struct CGamma
-{
-	/*!
-		this table holds factorials
-			1
-			1
-			2
-			6
-			24
-			120
-			720
-			.......
-	*/
-	std::vector<ValueType> fact;
-
-
-	/*!
-		this table holds Bernoulli numbers
-			1
-			-0.5
-			0.166666666666666666666666667
-			0
-			-0.0333333333333333333333333333
-			0
-			0.0238095238095238095238095238
-			0
-			-0.0333333333333333333333333333
-			0
-			0.075757575757575757575757576
-			.....
-	*/
-	std::vector<ValueType> bern;
-
-
-	/*!
-		here we store some calculated values
-		(this is for speeding up, if the next argument of Gamma() or Factorial()
-		is in the 'history' then the result we are not calculating but simply
-		return from the 'history' object)
-	*/
-	History<ValueType> history;
-
-
-	/*!
-		this method prepares some coefficients: factorials and Bernoulli numbers
-		stored in 'fact' and 'bern' objects
-		
-		how many values should be depends on the size of the mantissa - if
-		the mantissa is larger then we must calculate more values
-		    for a mantissa which consists of 256 bits (8 words on a 32bit platform)
-			we have to calculate about 30 values (the size of fact and bern will be 30),
-			and for a 2048 bits mantissa we have to calculate 306 coefficients
-
-		you don't have to call this method, these coefficients will be automatically calculated
-		when they are needed
-
-		you must note that calculating these coefficients is a little time-consuming operation,
-		(especially when the mantissa is large) and first call to Gamma() or Factorial()
-		can take more time than next calls, and in the end this is the point when InitAll()
-		comes in handy: you can call this method somewhere at the beginning of your program
-	*/
-	void InitAll();
-	// definition is in ttmath.h
-};
-
-


 } // namespace
--- a/ttmath/ttmathparser.h
+++ b/ttmath/ttmathparser.h
--- a/ttmath/ttmaththreads.h
+++ b/ttmath/ttmaththreads.h
@ -1,252 +0,0 @@
-/*
- * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
- */
-
-/* 
- * Copyright (c) 2006-2009, Tomasz Sowa
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *    
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *    
- *  * Neither the name Tomasz Sowa nor the names of contributors to this
- *    project may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-
-#ifndef headerfilettmaththreads
-#define headerfilettmaththreads
-
-#include "ttmathtypes.h"
-
-#ifdef TTMATH_WIN32_THREADS
-#include <windows.h>
-#include <cstdio>
-#endif
-
-#ifdef TTMATH_POSIX_THREADS
-#include <pthread.h>
-#endif
-
-
-
-/*!
-	\file ttmaththreads.h
-    \brief Some objects used in multithreads environment
-*/
-
-
-namespace ttmath
-{
-
-
-#ifdef TTMATH_WIN32_THREADS
-
-	/*
-		we use win32 threads
-	*/
-
-
-	/*!
-		in multithreads environment you should use TTMATH_MULTITHREADS_HELPER macro
-		somewhere in *.cpp file
-
-		(at the moment in win32 this macro does nothing)
-	*/
-	#define TTMATH_MULTITHREADS_HELPER
-
-
-	/*!
-		objects of this class are used to synchronize
-	*/
-	class ThreadLock
-	{
-		HANDLE mutex_handle;
-
-
-		void CreateName(char * buffer) const
-		{
-			#ifdef _MSC_VER
-			#pragma warning (disable : 4996)
-			// warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead.
-			#endif
-
-			sprintf(buffer, "TTMATH_LOCK_%ul", (unsigned long)GetCurrentProcessId());
-
-			#ifdef _MSC_VER
-			#pragma warning (default : 4996)
-			#endif
-		}
-
-
-	public:
-
-		bool Lock()
-		{
-		char buffer[50];
-
-			CreateName(buffer);
-			mutex_handle = CreateMutexA(0, false, buffer);
-
-			if( mutex_handle == 0 )
-				return false;
-
-			WaitForSingleObject(mutex_handle, INFINITE);
-
-		return true;
-		}
-
-
-		ThreadLock()
-		{
-			mutex_handle = 0;
-		}
-
-
-		~ThreadLock()
-		{
-			if( mutex_handle != 0 )
-			{
-				ReleaseMutex(mutex_handle);
-				CloseHandle(mutex_handle);
-			}
-		}
-	};
-
-#endif  // #ifdef TTMATH_WIN32_THREADS
-
-
-
-
-
-#ifdef TTMATH_POSIX_THREADS
-
-	/*
-		we use posix threads
-	*/
-
-
-	/*!
-		in multithreads environment you should use TTMATH_MULTITHREADS_HELPER macro
-		somewhere in *.cpp file
-		(this macro defines a pthread_mutex_t object used by TTMath library)
-	*/
-	#define TTMATH_MULTITHREADS_HELPER                          \
-	namespace ttmath                                            \
-	{                                                           \
-	pthread_mutex_t ttmath_mutex = PTHREAD_MUTEX_INITIALIZER;   \
-	}
-
-
-	/*!
-		ttmath_mutex will be defined by TTMATH_MULTITHREADS_HELPER macro 
-	*/
-	extern pthread_mutex_t ttmath_mutex;
-
-
-	/*!
-		\brief objects of this class are used to synchronize
-
-		this is a simple skeleton of a program in multithreads environment:
-
-			#define TTMATH_MULTITHREADS
-			#include<ttmath/ttmath.h>
-
-			TTMATH_MULTITHREADS_HELPER
-
-			int main()
-			{
-			[...]
-			}
-
-		make sure that macro TTMATH_MULTITHREADS is defined and (somewhere in *.cpp file)
-		use TTMATH_MULTITHREADS_HELPER macro (outside of any classes/functions/namespaces scope)
-	*/
-	class ThreadLock
-	{
-	public:
-
-		/*!
- 	 		lock the current thread
-
- 	 		it uses a global mutex created by TTMATH_MULTITHREADS_HELPER macro
-		*/
-		bool Lock()
-		{
-			if( pthread_mutex_lock(&ttmath_mutex) != 0 )
-				return false;
-
-		return true;
-		}
-
-
-		~ThreadLock()
-		{
-			pthread_mutex_unlock(&ttmath_mutex);
-		}
-	};
-
-#endif // #ifdef TTMATH_POSIX_THREADS
-
-
-
-
-#if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS)
-
-	/*!
-		we don't use win32 and pthreads
-	*/
-
-	/*!
-	*/
-	#define TTMATH_MULTITHREADS_HELPER
-
-
-	/*!
-		objects of this class are used to synchronize
-		actually we don't synchronize, the method Lock() returns always 'false'
-	*/
-	class ThreadLock
-	{
-	public:
-
-		bool Lock()
-		{
-			return false;
-		}
-	};
-
-
-#endif // #if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS)
-
-
-
-
-
-} // namespace
-
-#endif
-
--- a/ttmath/ttmathtypes.h
+++ b/ttmath/ttmathtypes.h
@ -1,11 +1,11 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
- * Copyright (c) 2006-2019, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
@ -54,123 +54,63 @@

 #include <stdexcept>
 #include <sstream>
-#include <vector>
-
-#ifndef _MSC_VER
-#include <stdint.h>
-// for uint64_t and int64_t on a 32 bit platform
-#endif
-


 /*!
-	the major version of the library
+	the version of the library

-	the version present to the end user is constructed in this way:
-
-		TTMATH_MAJOR_VER.TTMATH_MINOR_VER.TTMATH_REVISION_VER.[prerelease if TTMATH_PRERELEASE_VER==1]
+	TTMATH_PRERELEASE_VER is either zero or one
+	if zero that means this is the release version of the library
 */
 #define TTMATH_MAJOR_VER		0
-
-/*!
-	the minor version of the library
-
-	the version present to the end user is constructed in this way:
-
-		TTMATH_MAJOR_VER.TTMATH_MINOR_VER.TTMATH_REVISION_VER.[prerelease if TTMATH_PRERELEASE_VER==1]
-*/
-#define TTMATH_MINOR_VER		9
-
-/*!
-	the revision version of the library
-
-	the version present to the end user is constructed in this way:
-
-		TTMATH_MAJOR_VER.TTMATH_MINOR_VER.TTMATH_REVISION_VER.[prerelease if TTMATH_PRERELEASE_VER==1]
-*/
-#define TTMATH_REVISION_VER		4
-
-/*!
-	TTMATH_PRERELEASE_VER is either zero or one
-	zero means that this is the release version of the library
-	(one means something like beta)
-
-	the version present to the end user is constructed in this way:
-
-		TTMATH_MAJOR_VER.TTMATH_MINOR_VER.TTMATH_REVISION_VER.[prerelease if TTMATH_PRERELEASE_VER==1]
-*/
-#define TTMATH_PRERELEASE_VER	1
-
+#define TTMATH_MINOR_VER		8
+#define TTMATH_REVISION_VER		6
+#define TTMATH_PRERELEASE_VER	0


 /*!
-	you can define a platform explicitly by defining either
-	TTMATH_PLATFORM32 or TTMATH_PLATFORM64 macro
+	TTMATH_DEBUG
+	this macro enables further testing during writing your code
+	you don't have to define it in a release mode
+
+	if this macro is set then macros TTMATH_ASSERT and TTMATH_REFERENCE_ASSERT
+	are set as well	and these macros can throw an exception if a condition in it
+	is not fulfilled (look at the definition of TTMATH_ASSERT and TTMATH_REFERENCE_ASSERT)
+
+	TTMATH_RELEASE
+	if you are confident that your code is perfect you can define TTMATH_RELEASE
+	macro for example by using -D option in gcc
+	 gcc -DTTMATH_RELEASE -o myprogram myprogram.cpp 
+	or by defining this macro in your code before using any header files of this library
+
+	if TTMATH_RELEASE is not set then TTMATH_DEBUG is set automatically
 */
-#if !defined TTMATH_PLATFORM32 && !defined TTMATH_PLATFORM64
-
-	#if !defined _M_X64 && !defined __x86_64__
-
-		/*
-			other platforms than x86 and amd64 are not recognized at the moment
-			so you should set TTMATH_PLATFORMxx manually
-		*/
-
-		// we're using a 32bit platform
-		#define TTMATH_PLATFORM32
-
-	#else
-
-		//	we're using a 64bit platform
-		#define TTMATH_PLATFORM64
-
-	#endif
-
+#ifndef TTMATH_RELEASE
+	#define TTMATH_DEBUG
 #endif


-/*!
-	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
-*/
-#ifndef TTMATH_FORCEASM
-
-	#if !defined __i386__  && !defined _X86_ && !defined  _M_IX86 && !defined __x86_64__  && !defined _M_X64
-		/*!
-			x86 architecture:
-			__i386__    defined by GNU C
-			_X86_  	    defined by MinGW32
-			_M_IX86     defined by Visual Studio, Intel C/C++, Digital Mars and Watcom C/C++
-
-			amd64 architecture:
-			__x86_64__  defined by GNU C, CLANG (LLVM) and Sun Studio
-			_M_X64  	defined by Visual Studio
-
-			asm version is available only for x86 or amd64 platforms
-		*/
-		#define TTMATH_NOASM
-	#endif
-
-
-
-	#if !defined _MSC_VER && !defined __GNUC__
-		/*!
-			another compilers than MS VC or GCC or CLANG (LLVM) by default use no asm version
-			(CLANG defines __GNUC__ too)
-		*/
-		#define TTMATH_NOASM
-	#endif
-
-#endif
-

 namespace ttmath
 {

+#if !defined _M_X64 && !defined __x86_64__
+
+	/*!
+		we're using a 32bit platform
+	*/
+	#define TTMATH_PLATFORM32
+
+#else
+
+	/*!
+		we're using a 64bit platform
+	*/
+	#define TTMATH_PLATFORM64
+
+#endif
+
+

 #ifdef TTMATH_PLATFORM32

@ -181,18 +121,17 @@ namespace ttmath
 	typedef signed   int sint;

 	/*!
-		on 32 bit platform ulint and slint will be equal 64 bits
+		this type is twice bigger than uint
+		(64bit on a 32bit platforms)
+
+		although C++ Standard - ANSI ISO IEC 14882:2003 doesn't define such a type (long long) 
+		but it is defined in C99 and in upcoming C++0x /3.9.1 (2)/ and many compilers support it
+
+		this type is used in UInt::MulTwoWords and UInt::DivTwoWords when macro TTMATH_NOASM is defined
+		but only on a 32bit platform
 	*/
-	#ifdef _MSC_VER
-		// long long on MS Windows (Visual and GCC mingw compilers) have 64 bits
-		// stdint.h is not available on Visual Studio prior to VS 2010 version
+	#ifdef TTMATH_NOASM
 		typedef unsigned long long int ulint;
-		typedef signed   long long int slint;
-	#else
-		// we do not use 'long' here because there is a difference in unix and windows
-		// environments: in unix 'long' has 64 bits but in windows it has only 32 bits
-		typedef uint64_t ulint;
-		typedef int64_t  slint;
 	#endif

 	/*!
@ -218,34 +157,22 @@ namespace ttmath
 	*/
 	#define TTMATH_BUILTIN_VARIABLES_SIZE 256u

-	/*!
-		this macro returns the number of machine words 
-		capable to hold min_bits bits
-		e.g. TTMATH_BITS(128) returns 4
-	*/
-	#define TTMATH_BITS(min_bits) ((min_bits-1)/32 + 1)
-
 #else

-	#ifdef _MSC_VER
-		/* in VC 'long' type has 32 bits, __int64 is VC extension */
-		typedef unsigned __int64 uint;
-		typedef signed   __int64 sint;
-	#else
-		/*!
-			on 64bit platforms one word (uint, sint) will be equal 64bits
-		*/
-		typedef uint64_t uint;
-
-		/*!
-			on 64bit platforms one word (uint, sint) will be equal 64bits
-		*/
-		typedef int64_t sint;
-	#endif 
+	/*!
+		on 64bit platforms one word (uint, sint) will be equal 64bits
+	*/
+	typedef unsigned long uint;
+	typedef signed   long sint;

 	/*!
-		on 64bit platforms we do not define ulint and slint
+		on 64bit platform we do not define ulint
+		sizeof(long long) is 8 (64bit) but we need 128bit
+
+		on 64 bit platform (when there is defined TTMATH_NOASM macro)
+		methods UInt::MulTwoWords and UInt::DivTwoWords are using other algorithms than those on 32 bit
 	*/
+	//typedef unsigned long long int ulint;

 	/*!
 		how many bits there are in the uint type
@ -270,28 +197,27 @@ namespace ttmath
 	*/
 	#define TTMATH_BUILTIN_VARIABLES_SIZE 128ul

-	/*!
-		this macro returns the number of machine words 
-		capable to hold min_bits bits
-		e.g. TTMATH_BITS(128) returns 2
-	*/
-	#define TTMATH_BITS(min_bits) ((min_bits-1)/64 + 1)
-
 #endif
 }


-#if defined(TTMATH_MULTITHREADS) && !defined(TTMATH_MULTITHREADS_NOSYNC)
-	#if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS)

-		#if defined(_WIN32)
-			#define TTMATH_WIN32_THREADS
-		#elif defined(unix) || defined(__unix__) || defined(__unix)
-			#define TTMATH_POSIX_THREADS
-		#endif
+/*!
+	characters which represent the comma operator

-	#endif
-#endif
+	TTMATH_COMMA_CHARACTER_1 is used in reading (parsing) and in writing (default, can be overwritten in ToString() function)
+	TTMATH_COMMA_CHARACTER_2 can be used in reading as an auxiliary comma character
+	that means you can input values for example 1.2345 and 1,2345 as well
+
+	if you don't want it just put 0 there e.g.
+		#define TTMATH_COMMA_CHARACTER_2 0
+	then only TTMATH_COMMA_CHARACTER_1 will be used
+
+	don't put there any special character which is used by the parser
+	(for example a semicolon ';' shouldn't be there)
+*/
+#define TTMATH_COMMA_CHARACTER_1 '.'
+#define TTMATH_COMMA_CHARACTER_2 ','



@ -316,54 +242,16 @@ namespace ttmath
 	if the size of a vector is smaller than TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE
 	the Karatsuba algorithm will use standard schoolbook multiplication
 */
-#ifdef TTMATH_DEBUG_LOG
-	// if TTMATH_DEBUG_LOG is defined then we should use the same size regardless of the compiler
-	#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 3
+#ifdef __GNUC__
+#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 3
 #else
-	#ifdef __GNUC__
-		#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 3
-	#else
-		#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 5
-	#endif
+#define TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE 5
 #endif


-/*!
-	this is a special value used when calculating the Gamma(x) function
-	if x is greater than this value then the Gamma(x) will be calculated using
-	some kind of series
-
-	don't use smaller values than about 100
-*/
-#define TTMATH_GAMMA_BOUNDARY 2000
-
-
-
-
-
 namespace ttmath
 {

-	/*!
-		lib type codes:
-		-  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
-	*/
-	enum LibTypeCode
-	{
-	  asm_vc_32 = 0,
-	  asm_gcc_32,
-	  asm_vc_64,
-	  asm_gcc_64,
-	  no_asm_32,
-	  no_asm_64
-	};
-
-
 	/*!
 		error codes
 	*/
@ -394,142 +282,11 @@ namespace ttmath
 		err_object_exists,
 		err_unknown_object,
 		err_still_calculating,
-		err_in_short_form_used_function,
-		err_percent_from,
-		err_assignment_requires_variable
+		err_too_big_factorial,
+		err_in_short_form_used_function
 	};


-	/*!
-		this struct is used when converting to/from a string
-		/temporarily only in Big::ToString() and Big::FromString()/
-	*/
-	struct Conv
-	{
-		/*!
-			base (radix) on which the value will be shown (or read)
-			default: 10
-		*/
-		uint base;
-
-
-		/*!
-			used only in Big::ToString()
-			if true the value will be always shown in the scientific mode, e.g: 123e+30
-			default: false
-		*/
-		bool scient;
-
-
-		/*!
-			used only in Big::ToString()
-			if scient is false then the value will be printed in the scientific mode
-			only if the exponent is greater than scien_from
-			default: 15
-		*/
-		sint scient_from;
-
-
-		/*!
-			if 'base_round' is true and 'base' is different from 2, 4, 8, or 16
-			and the result value is not an integer then we make an additional rounding
-			(after converting the last digit from the result is skipped)
-			default: true
-
-			e.g.
-
-				Conv c;
-				c.base_round = false;
-				Big<1, 1> a = "0.1";                       // decimal input
-				std::cout << a.ToString(c) << std::endl;   // the result is: 0.099999999
-		*/
-		bool base_round;
-
-
-		/*!
-			used only in Big::ToString()
-			tells how many digits after comma are possible
-			default: -1 which means all digits are printed
-
-			set it to zero if you want integer value only
-
-			for example when the value is:
-				12.345678 and 'round' is 4
-			then the result will be 
-				12.3457   (the last digit was rounded)
-		*/
-		sint round;
-
-
-		/*!
-			if true that not mattered digits in the mantissa will be cut off
-			(zero characters at the end -- after the comma operator)
-			e.g. 1234,78000 will be: 1234,78
-			default: true
-		*/
-		bool trim_zeroes;
-
-
-		/*!
-			the main comma operator (used when reading and writing)
-			default is a dot '.'
-		*/
-		uint comma;
-
-
-		/*!
-			additional comma operator (used only when reading) 
-			if you don't want it just set it to zero
-			default is a comma ','
-
-			this allowes you to convert from a value:
-			123.45 as well as from 123,45
-		*/
-		uint comma2;
-
-
-		/*!
-			it sets the character which is used for grouping
-			if group=' ' then: 1234,56789 will be printed as: 1 234,567 89
-
-			if you don't want grouping just set it to zero (which is default)
-		*/
-		uint group;
-
-
-		/*!
-			how many digits should be grouped (it is used if 'group' is non zero)
-			default: 3
-		*/
-		uint group_digits;
-
-
-		/*!
-		*/
-		uint group_exp; // not implemented yet
-
-
-
-
-		Conv()
-		{
-			// default values
-			base         = 10;
-			scient       = false;
-			scient_from  = 15;
-			base_round   = true;
-			round        = -1;
-			trim_zeroes  = true;
-			comma        = '.';
-			comma2       = ',';
-			group        = 0;
-			group_digits = 3;
-			group_exp    = 0;
-		}
-	};
-
-
-
 	/*!
 		this simple class can be used in multithreading model
 		(you can write your own class derived from this one)
@ -582,24 +339,37 @@ namespace ttmath
 		In the library is used macro TTMATH_REFERENCE_ASSERT which
 		can throw an exception of this type

-		** from version 0.9.2 this macro is removed from all methods
-		   in public interface so you don't have to worry about it **
-
 		If you compile with gcc you can get a small benefit 
-		from using method Where() (it returns std::string) with
+		from using method Where() (it returns std::string with
 		the name and the line of a file where the macro TTMATH_REFERENCE_ASSERT
 		was used)
+
+		What is the 'reference' error?
+		Some kind of methods use a reference as their argument to another object,
+		and the another object not always can be the same which is calling, e.g.
+			Big<1,2> foo(10);
+			foo.Mul(foo); // this is incorrect
+		above method Mul is making something more with 'this' object and 
+		'this' cannot be passed as the argument because the result will be undefined
+
+		macro TTMATH_REFERENCE_ASSERT helps us to solve the above problem
+
+		note! some methods can use 'this' object as the argument
+		for example this code is correct:
+			UInt<2> foo(10);
+			foo.Add(foo);
+		but there are only few methods which can do that
 	*/
 	class ReferenceError : public std::logic_error, public ExceptionInfo
 	{
 	public:

-		ReferenceError() : std::logic_error("reference error")
+		ReferenceError() : std::logic_error ("reference error")
 		{
 		}

 		ReferenceError(const char * f, int l) :
-							std::logic_error("reference error"), ExceptionInfo(f,l)
+							std::logic_error ("reference error"), ExceptionInfo(f,l)
 		{
 		}

@ -618,7 +388,7 @@ namespace ttmath
 		of this type

 		if you compile with gcc you can get a small benefit 
-		from using method Where() (it returns std::string) with
+		from using method Where() (it returns std::string with
 		the name and the line of a file where the macro TTMATH_ASSERT
 		was used)
 	*/
@ -626,12 +396,12 @@ namespace ttmath
 	{
 	public:

-		RuntimeError() : std::runtime_error("internal error")
+		RuntimeError() : std::runtime_error ("internal error")
 		{
 		}

 		RuntimeError(const char * f, int l) :
-						std::runtime_error("internal error"), ExceptionInfo(f,l)
+						std::runtime_error ("internal error"), ExceptionInfo(f,l)
 		{
 		}

@ -644,21 +414,8 @@ namespace ttmath


 	/*!
-		TTMATH_DEBUG
-		this macro enables further testing during writing your code
-		you don't have to define it in a release mode
-
-		if this macro is set then macros TTMATH_ASSERT and TTMATH_REFERENCE_ASSERT
-		are set as well	and these macros can throw an exception if a condition in it
-		is not fulfilled (look at the definition of TTMATH_ASSERT and TTMATH_REFERENCE_ASSERT)
-
-		TTMATH_DEBUG is set automatically if DEBUG or _DEBUG are defined
+		look at the description of macros TTMATH_RELEASE and TTMATH_DEBUG
 	*/
-	#if defined DEBUG || defined _DEBUG
-		#define TTMATH_DEBUG
-	#endif
-
-
 	#ifdef TTMATH_DEBUG

 		#if defined(__FILE__) && defined(__LINE__)
@ -686,22 +443,18 @@ namespace ttmath


 	#ifdef TTMATH_DEBUG_LOG
-		#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);
+
+		#define TTMATH_LOG(msg) \
+			PrintLog(msg, std::cout);		
+
 	#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


-
-
 } // namespace


 #endif
-
--- a/ttmath/ttmathuint.h
+++ b/ttmath/ttmathuint.h
--- a/ttmath/ttmathuint_noasm.h
+++ b/ttmath/ttmathuint_noasm.h
@ -1,11 +1,11 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
- * Copyright (c) 2006-2010, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
@ -39,69 +39,18 @@
 #define headerfilettmathuint_noasm


+#ifdef TTMATH_NOASM
+
 /*!
 	\file ttmathuint_noasm.h
-    \brief template class UInt<uint> with methods without any assembler code (used for no-asm version of ttmath)
+    \brief template class UInt<uint> with methods without any assembler code

 	this file is included at the end of ttmathuint.h
 */

-#ifdef TTMATH_NOASM
-
-

 namespace ttmath
 {
-
-	/*!
-		returning the string represents the currect type of the library
-		we have following types:
-		-  asm_vc_32   - with asm code designed for Microsoft Visual C++ (32 bits)
-		-  asm_gcc_32  - with asm code designed for GCC (32 bits)
-		-  asm_vc_64   - with asm for VC (64 bit)
-		-  asm_gcc_64  - with asm for GCC (64 bit)
-		-  no_asm_32   - pure C++ version (32 bit) - without any asm code
-		-  no_asm_64   - pure C++ version (64 bit) - without any asm code
-	*/
-	template<uint value_size>
-	const char * UInt<value_size>::LibTypeStr()
-	{
-		#ifdef TTMATH_PLATFORM32
-			static const char info[] = "no_asm_32";
-		#endif		
-
-		#ifdef TTMATH_PLATFORM64
-			static const char info[] = "no_asm_64";
-		#endif
-
-	return info;
-	}
-
-	
-	/*!
-		returning the currect type of the library
-	*/
-	template<uint value_size>
-	LibTypeCode UInt<value_size>::LibType()
-	{
-		#ifdef TTMATH_PLATFORM32
-			LibTypeCode info = no_asm_32;
-		#endif		
-
-		#ifdef TTMATH_PLATFORM64
-			LibTypeCode info = no_asm_64;
-		#endif
-
-	return info;
-	}
-
-
-	/*!
-		this method adds two words together
-		returns carry
-
-		this method is created only when TTMATH_NOASM macro is defined
-	*/
 	template<uint value_size>
 	uint UInt<value_size>::AddTwoWords(uint a, uint b, uint carry, uint * result)
 	{
@ -146,7 +95,7 @@ namespace ttmath
 		for(i=0 ; i<value_size ; ++i)
 			c = AddTwoWords(table[i], ss2.table[i], c, &table[i]);

-		TTMATH_LOGC("UInt::Add", c)
+		TTMATH_LOG("UInt::Add")
 	
 	return c;
 	}
@ -157,17 +106,12 @@ namespace ttmath
 		and returns a carry (if it was)

 		if we've got (value_size=3):
-
 			table[0] = 10;
 			table[1] = 30;
-			table[2] = 5;
-
+			table[2] = 5;	
 		and we call:
-
 			AddInt(2,1)
-
 		then it'll be:
-
 			table[0] = 10;
 			table[1] = 30 + 2;
 			table[2] = 5;
@ -187,7 +131,7 @@ namespace ttmath
 		for(i=index+1 ; i<value_size && c ; ++i)
 			c = AddTwoWords(table[i], 0, c, &table[i]);

-		TTMATH_LOGC("UInt::AddInt", c)
+		TTMATH_LOG("UInt::AddInt")
 	
 	return c;
 	}
@ -205,23 +149,17 @@ namespace ttmath
 		x1 - lower word, x2 - higher word

 		for example if we've got value_size equal 4 and:
-
 			table[0] = 3
 			table[1] = 4
 			table[2] = 5
 			table[3] = 6
-
 		then let
-
 			x1 = 10
 			x2 = 20
-
 		and
-
 			index = 1

 		the result of this method will be:
-
 			table[0] = 3
 			table[1] = 4 + x1 = 14
 			table[2] = 5 + x2 = 25
@ -246,7 +184,7 @@ namespace ttmath
 		for(i=index+2 ; i<value_size && c ; ++i)
 			c = AddTwoWords(table[i], 0, c, &table[i]);

-		TTMATH_LOGC("UInt::AddTwoInts", c)
+		TTMATH_LOG("UInt::AddTwoInts")
 	
 	return c;
 	}
@ -257,20 +195,19 @@ namespace ttmath
 		this static method addes one vector to the other
 		'ss1' is larger in size or equal to 'ss2'

-		-  ss1 points to the first (larger) vector
-		-  ss2 points to the second vector
-		-  ss1_size - size of the ss1 (and size of the result too)
-		-  ss2_size - size of the ss2
-		-  result - is the result vector (which has size the same as ss1: ss1_size)
-
-			Example:  ss1_size is 5, ss2_size is 3
-			ss1:      ss2:   result (output):
-			  5        1         5+1
-			  4        3         4+3
-			  2        7         2+7
-			  6                  6
-			  9                  9
+		ss1 points to the first (larger) vector
+		ss2 points to the second vector
+		ss1_size - size of the ss1 (and size of the result too)
+		ss2_size - size of the ss2
+		result - is the result vector (which has size the same as ss1: ss1_size)

+		Example:  ss1_size is 5, ss2_size is 3
+		ss1:      ss2:   result (output):
+		  5        1         5+1
+		  4        3         4+3
+		  2        7         2+7
+		  6                  6
+		  9                  9
 	  of course the carry is propagated and will be returned from the last item
 	  (this method is used by the Karatsuba multiplication algorithm)
 	*/
@ -287,7 +224,7 @@ namespace ttmath
 		for( ; i<ss1_size ; ++i)
 			c = AddTwoWords(ss1[i], 0, c, &result[i]);

-		TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size)
+		//TTMATH_LOG("UInt::AddVector")

 	return c;
 	}
@ -295,12 +232,6 @@ 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)
 	{
@ -342,7 +273,7 @@ namespace ttmath
 		for(i=0 ; i<value_size ; ++i)
 			c = SubTwoWords(table[i], ss2.table[i], c, &table[i]);

-		TTMATH_LOGC("UInt::Sub", c)
+		TTMATH_LOG("UInt::Sub")

 	return c;
 	}
@ -355,17 +286,12 @@ namespace ttmath
 		and returns a carry (if it was)

 		if we've got (value_size=3):
-
 			table[0] = 10;
 			table[1] = 30;
 			table[2] = 5;	
-
 		and we call:
-
 			SubInt(2,1)
-
 		then it'll be:
-
 			table[0] = 10;
 			table[1] = 30 - 2;
 			table[2] = 5;
@ -385,7 +311,7 @@ namespace ttmath
 		for(i=index+1 ; i<value_size && c ; ++i)
 			c = SubTwoWords(table[i], 0, c, &table[i]);

-		TTMATH_LOGC("UInt::SubInt", c)
+		TTMATH_LOG("UInt::SubInt")
 	
 	return c;
 	}
@ -395,19 +321,19 @@ namespace ttmath
 		this static method subtractes one vector from the other
 		'ss1' is larger in size or equal to 'ss2'

-		-  ss1 points to the first (larger) vector
-		-  ss2 points to the second vector
-		-  ss1_size - size of the ss1 (and size of the result too)
-		-  ss2_size - size of the ss2
-		-  result - is the result vector (which has size the same as ss1: ss1_size)
+		ss1 points to the first (larger) vector
+		ss2 points to the second vector
+		ss1_size - size of the ss1 (and size of the result too)
+		ss2_size - size of the ss2
+		result - is the result vector (which has size the same as ss1: ss1_size)

-			Example:  ss1_size is 5, ss2_size is 3
-			ss1:      ss2:   result (output):
-			  5        1         5-1
-			  4        3         4-3
-			  2        7         2-7
-			  6                  6-1  (the borrow from previous item)
-			  9                  9
+		Example:  ss1_size is 5, ss2_size is 3
+		ss1:      ss2:   result (output):
+		  5        1         5-1
+		  4        3         4-3
+		  2        7         2-7
+		  6                  6-1  (the borrow from previous item)
+		  9                  9
 		                 return (carry): 0
 	  of course the carry (borrow) is propagated and will be returned from the last item
 	  (this method is used by the Karatsuba multiplication algorithm)
@ -425,7 +351,7 @@ namespace ttmath
 		for( ; i<ss1_size ; ++i)
 			c = SubTwoWords(ss1[i], 0, c, &result[i]);

-		TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size)
+		//TTMATH_LOG("UInt::SubVector")

 	return c;
 	}
@ -459,7 +385,7 @@ namespace ttmath
 			c        = new_c;
 		}

-		TTMATH_LOGC("UInt::Rcl2_one", c)
+		TTMATH_LOG("UInt::Rcl2_one")

 	return c;
 	}
@ -498,9 +424,7 @@ namespace ttmath
 			c        = new_c;
 		}

-		c = (c != 0)? 1 : 0;
-
-		TTMATH_LOGC("UInt::Rcr2_one", c)
+		TTMATH_LOG("UInt::Rcr2_one")

 	return c;
 	}
@ -538,7 +462,7 @@ namespace ttmath
 			c        = new_c;
 		}

-		TTMATH_LOGC("UInt::Rcl2", (c & 1))
+		TTMATH_LOG("UInt::Rcl2")

 	return (c & 1);
 	}
@ -577,19 +501,18 @@ namespace ttmath
 			c        = new_c;
 		}

-		c = (c & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
+		TTMATH_LOG("UInt::Rcr2")

-		TTMATH_LOGC("UInt::Rcr2", c)
-
-	return c;
+	return (c & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
 	}




-	/*!
+	/*
 		this method returns the number of the highest set bit in x
 		if the 'x' is zero this method returns '-1'
+
 	*/
 	template<uint value_size>
 	sint UInt<value_size>::FindLeadingBitInWord(uint x)
@ -610,41 +533,18 @@ 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>::FindLowestBitInWord(uint x)
-	{
-		if( x == 0 )
-			return -1;
-
-		uint bit = 0;
-		
-		while( (x & 1) == 0 )
-		{
-			x = x >> 1;
-			++bit;
-		}
-
-	return bit;
-	}
-


 	/*!
 		this method sets a special bit in the 'value'
 		and returns the last state of the bit (zero or one)

-		bit is from <0,TTMATH_BITS_PER_UINT-1>
+		bit is from <0,63>

 		e.g.
-
-			uint x = 100;
-			uint bit = SetBitInWord(x, 3);
-
-		now: x = 108 and bit = 0
+		 uint x = 100;
+		 uint bit = SetBitInWord(x, 3);
+		 now: x = 108 and bit = 0
 	*/
 	template<uint value_size>
 	uint UInt<value_size>::SetBitInWord(uint & value, uint bit)
@ -677,11 +577,10 @@ namespace ttmath

 	/*!
 		multiplication: result_high:result_low = a * b
-		-  result_high - higher word of the result
-		-  result_low  - lower word of the result
+		result_high - higher word of the result
+		result_low  - lower word of the result
 	
 		this methos never returns a carry
-
 		this method is used in the second version of the multiplication algorithms
 	*/
 	template<uint value_size>
@ -842,11 +741,11 @@ namespace ttmath
 			temp1.u_.high = a_.u_.low;
 			temp1.u_.low  = b_.u_.high;

-			res_.u_.high  = (unsigned int)(temp1.u / c);
-			temp2.u_.high = (unsigned int)(temp1.u % c);
+			res_.u_.high  = temp1.u / c;
+			temp2.u_.high = temp1.u % c;
 			temp2.u_.low  = b_.u_.low;
 			
-			res_.u_.low  = (unsigned int)(temp2.u / c);
+			res_.u_.low  = temp2.u / c;
 			*rest        = temp2.u % c;

 			*r = res_.u;
--- a/ttmath/ttmathuint_x86.h
+++ b/ttmath/ttmathuint_x86.h
@ -1,7 +1,7 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
@ -35,10 +35,16 @@
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

+
+
 #ifndef headerfilettmathuint_x86
 #define headerfilettmathuint_x86


+#ifndef TTMATH_NOASM
+#ifdef TTMATH_PLATFORM32
+
+
 /*!
 	\file ttmathuint_x86.h
    \brief template class UInt<uint> with assembler code for 32bit x86 processors
@ -47,12 +53,6 @@
 */


-#ifndef TTMATH_NOASM
-#ifdef TTMATH_PLATFORM32
-
-
-
-

 /*!
    \brief a namespace for the TTMath library
@ -60,51 +60,6 @@
 namespace ttmath
 {

-	/*!
-		returning the string represents the currect type of the library
-
-		we have following types:
-		-  asm_vc_32   - with asm code designed for Microsoft Visual C++ (32 bits)
-		-  asm_gcc_32  - with asm code designed for GCC (32 bits)
-		-  asm_vc_64   - with asm for VC (64 bit)
-		-  asm_gcc_64  - with asm for GCC (64 bit)
-		-  no_asm_32   - pure C++ version (32 bit) - without any asm code
-		-  no_asm_64   - pure C++ version (64 bit) - without any asm code
-	*/
-	template<uint value_size>
-	const char * UInt<value_size>::LibTypeStr()
-	{
-		#ifndef __GNUC__
-			static const char info[] = "asm_vc_32";
-		#endif		
-
-		#ifdef __GNUC__
-			static const char info[] = "asm_gcc_32";
-		#endif
-
-	return info;
-	}
-
-
-	/*!
-		returning the currect type of the library
-	*/
-	template<uint value_size>
-	LibTypeCode UInt<value_size>::LibType()
-	{
-		#ifndef __GNUC__
-			LibTypeCode info = asm_vc_32;
-		#endif		
-
-		#ifdef __GNUC__
-			LibTypeCode info = asm_gcc_32;
-		#endif
-
-	return info;
-	}
-
-
-
 	/*!
 	*
 	*	basic mathematic functions
@ -197,7 +152,7 @@ namespace ttmath
 				: "cc", "memory" );
 		#endif

-		TTMATH_LOGC("UInt::Add", c)
+		TTMATH_LOG("UInt::Add")

 	return c;
 	}
@ -211,17 +166,12 @@ namespace ttmath
 		e.g.

 		if we've got (value_size=3):
-
 			table[0] = 10;
 			table[1] = 30;
-			table[2] = 5;
-
+			table[2] = 5;	
 		and we call:
-
 			AddInt(2,1)
-
 		then it'll be:
-
 			table[0] = 10;
 			table[1] = 30 + 2;
 			table[2] = 5;
@ -303,7 +253,7 @@ namespace ttmath

 		#endif
 	
-		TTMATH_LOGC("UInt::AddInt", c)
+		TTMATH_LOG("UInt::AddInt")

 	return c;
 	}
@ -320,23 +270,17 @@ namespace ttmath
 		x1 - lower word, x2 - higher word

 		for example if we've got value_size equal 4 and:
-
 			table[0] = 3
 			table[1] = 4
 			table[2] = 5
 			table[3] = 6
-
 		then let
-
 			x1 = 10
 			x2 = 20
-
 		and
-
 			index = 1

 		the result of this method will be:
-
 			table[0] = 3
 			table[1] = 4 + x1 = 14
 			table[2] = 5 + x2 = 25
@ -430,7 +374,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::AddTwoInts", c)
+		TTMATH_LOG("UInt::AddTwoInts")
 	
 	return c;
 	}
@ -562,7 +506,7 @@ namespace ttmath

 		#endif

-		TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size)
+		TTMATH_LOG("UInt::AddVector")

 	return c;
 	}
@ -650,7 +594,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Sub", c)
+		TTMATH_LOG("UInt::Sub")

 	return c;
 	}
@ -665,17 +609,12 @@ namespace ttmath
 		e.g.

 		if we've got (value_size=3):
-
 			table[0] = 10;
 			table[1] = 30;
 			table[2] = 5;	
-
 		and we call:
-
 			SubInt(2,1)
-
 		then it'll be:
-
 			table[0] = 10;
 			table[1] = 30 - 2;
 			table[2] = 5;
@ -757,7 +696,7 @@ namespace ttmath

 		#endif
 		
-		TTMATH_LOGC("UInt::SubInt", c)
+		TTMATH_LOG("UInt::SubInt")
 	
 	return c;
 	}
@ -895,7 +834,7 @@ namespace ttmath

 		#endif

-		TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size)
+		TTMATH_LOG("UInt::SubVector")

 	return c;
 	}
@ -973,7 +912,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcl2_one", c)
+		TTMATH_LOG("UInt::Rcl2_one")

 	return c;
 	}
@ -1045,7 +984,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcr2_one", c)
+		TTMATH_LOG("UInt::Rcr2_one")

 	return c;
 	}
@ -1179,7 +1118,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcl2", c)
+		TTMATH_LOG("UInt::Rcl2")

 	return c;
 	}
@ -1313,7 +1252,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcr2", c)
+		TTMATH_LOG("UInt::Rcr2")

 	return c;
 	}
@ -1370,50 +1309,6 @@ namespace ttmath



-	/*
-		this method returns the number of the smallest set bit in one 32-bit word
-		if the 'x' is zero this method returns '-1'
-	*/
-	template<uint value_size>
-	sint UInt<value_size>::FindLowestBitInWord(uint x)
-	{
-	sint result;
-
-		#ifndef __GNUC__
-			__asm
-			{
-				push eax
-				push edx
-
-				mov edx,-1
-				bsf eax,[x]
-				cmovz eax,edx
-				mov [result], eax
-
-				pop edx
-				pop eax
-			}
-		#endif
-
-
-		#ifdef __GNUC__
-		uint dummy;
-
-				__asm__ (
-
-				"movl $-1, %1          \n"
-				"bsfl %2, %0           \n"
-				"cmovz %1, %0          \n"
-
-				: "=r" (result), "=&r" (dummy)
-				: "r" (x)
-				: "cc" );
-
-		#endif
-
-	return result;
-	}
-


 	/*!
@ -1422,10 +1317,9 @@ namespace ttmath

 		bit is from <0,31>
 		e.g.
-
-			uint x = 100;
-			uint bit = SetBitInWord(x, 3);
-			now: x = 108 and bit = 0
+		 uint x = 100;
+		 uint bit = SetBitInWord(x, 3);
+		 now: x = 108 and bit = 0
 	*/
 	template<uint value_size>
 	uint UInt<value_size>::SetBitInWord(uint & value, uint bit)
--- a/ttmath/ttmathuint_x86_64.h
+++ b/ttmath/ttmathuint_x86_64.h
@ -1,11 +1,11 @@
 /*
 * This file is a part of TTMath Bignum Library
- * and is distributed under the 3-Clause BSD Licence.
- * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@slimaczek.pl>
 */

 /* 
- * Copyright (c) 2006-2010, Tomasz Sowa
+ * Copyright (c) 2006-2009, Tomasz Sowa
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
@ -52,91 +52,9 @@
 */


-/*!
-	\file ttmathuint_x86_64_msvc.asm
-	\brief some asm routines for x86_64 when using Microsoft compiler
-
-	this file should be first compiled:
-	- compile with debug info:    ml64.exe /c /Zd /Zi ttmathuint_x86_64_msvc.asm
-	- compile without debug info: ml64.exe /c ttmathuint_x86_64_msvc.asm
-
-	this creates ttmathuint_x86_64_msvc.obj file which can be linked with your program
-
-	(you can use win64_assemble.bat file from ttmath subdirectory)
-*/
-
-
-#ifndef __GNUC__
-#include <intrin.h>
-#endif
-
-
 namespace ttmath
 {

-	#ifndef __GNUC__
-
-		extern "C"
-			{
-			uint __fastcall ttmath_adc_x64(uint* p1, const uint* p2, uint nSize, uint c);
-			uint __fastcall ttmath_addindexed_x64(uint* p1, uint nSize, uint nPos, uint nValue);
-			uint __fastcall ttmath_addindexed2_x64(uint* p1, uint nSize, uint nPos, uint nValue1, uint nValue2);
-			uint __fastcall ttmath_addvector_x64(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result);
-			uint __fastcall ttmath_sbb_x64(uint* p1, const uint* p2, uint nSize, uint c);
-			uint __fastcall ttmath_subindexed_x64(uint* p1, uint nSize, uint nPos, uint nValue);
-			uint __fastcall ttmath_subvector_x64(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result);
-			uint __fastcall ttmath_rcl_x64(uint* p1, uint nSize, uint nLowestBit);
-			uint __fastcall ttmath_rcr_x64(uint* p1, uint nSize, uint nLowestBit);
-			uint __fastcall ttmath_div_x64(uint* pnValHi, uint* pnValLo, uint nDiv);
-			uint __fastcall ttmath_rcl2_x64(uint* p1, uint nSize, uint nBits, uint c);
-			uint __fastcall ttmath_rcr2_x64(uint* p1, uint nSize, uint nBits, uint c);
-			};
-	#endif
-
-
-	/*!
-		returning the string represents the currect type of the library
-		we have following types:
-		  asm_vc_32   - with asm code designed for Microsoft Visual C++ (32 bits)
-		  asm_gcc_32  - with asm code designed for GCC (32 bits)
-		  asm_vc_64   - with asm for VC (64 bit)
-		  asm_gcc_64  - with asm for GCC (64 bit)
-		  no_asm_32   - pure C++ version (32 bit) - without any asm code
-		  no_asm_64   - pure C++ version (64 bit) - without any asm code
-	*/
-	template<uint value_size>
-	const char * UInt<value_size>::LibTypeStr()
-	{
-		#ifndef __GNUC__
-			static const char info[] = "asm_vc_64";
-		#endif		
-
-		#ifdef __GNUC__
-			static const char info[] = "asm_gcc_64";
-		#endif
-
-	return info;
-	}
-
-
-	/*!
-		returning the currect type of the library
-	*/
-	template<uint value_size>
-	LibTypeCode UInt<value_size>::LibType()
-	{
-		#ifndef __GNUC__
-			LibTypeCode info = asm_vc_64;
-		#endif		
-
-		#ifdef __GNUC__
-			LibTypeCode info = asm_gcc_64;
-		#endif
-
-	return info;
-	}
-
-
 	/*!
 	*
 	*	basic mathematic functions
@ -165,7 +83,7 @@ namespace ttmath
 		// this algorithm doesn't require it

 		#ifndef __GNUC__
-			c = ttmath_adc_x64(p1,p2,b,c);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

 		#ifdef __GNUC__
@ -195,7 +113,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Add", c)
+		TTMATH_LOG("UInt::Add")
 	
 	return c;
 	}
@ -210,17 +128,12 @@ namespace ttmath


 		if we've got (value_size=3):
-
 			table[0] = 10;
 			table[1] = 30;
-			table[2] = 5;
-
+			table[2] = 5;	
 		and we call:
-
 			AddInt(2,1)
-
 		then it'll be:
-
 			table[0] = 10;
 			table[1] = 30 + 2;
 			table[2] = 5;
@ -237,10 +150,9 @@ namespace ttmath
 		TTMATH_ASSERT( index < value_size )

 		#ifndef __GNUC__
-			c = ttmath_addindexed_x64(p1,b,index,value);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy, dummy2;
 	
@ -267,7 +179,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::AddInt", c)
+		TTMATH_LOG("UInt::AddInt")
 	
 	return c;
 	}
@ -285,23 +197,17 @@ namespace ttmath
 		x1 - lower word, x2 - higher word

 		for example if we've got value_size equal 4 and:
-
 			table[0] = 3
 			table[1] = 4
 			table[2] = 5
 			table[3] = 6
-
 		then let
-
 			x1 = 10
 			x2 = 20
-
 		and
-
 			index = 1

 		the result of this method will be:
-
 			table[0] = 3
 			table[1] = 4 + x1 = 14
 			table[2] = 5 + x2 = 25
@ -322,10 +228,9 @@ namespace ttmath
 		TTMATH_ASSERT( index < value_size - 1 )

 		#ifndef __GNUC__
-			c = ttmath_addindexed2_x64(p1,b,index,x1,x2);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy, dummy2;

@ -356,7 +261,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::AddTwoInts", c)
+		TTMATH_LOG("UInt::AddTwoInts")

 	return c;
 	}
@ -367,19 +272,19 @@ namespace ttmath
 		this static method addes one vector to the other
 		'ss1' is larger in size or equal to 'ss2'

-		-  ss1 points to the first (larger) vector
-		-  ss2 points to the second vector
-		-  ss1_size - size of the ss1 (and size of the result too)
-		-  ss2_size - size of the ss2
-		-  result - is the result vector (which has size the same as ss1: ss1_size)
+		ss1 points to the first (larger) vector
+		ss2 points to the second vector
+		ss1_size - size of the ss1 (and size of the result too)
+		ss2_size - size of the ss2
+		result - is the result vector (which has size the same as ss1: ss1_size)

-			Example:  ss1_size is 5, ss2_size is 3
-			ss1:      ss2:   result (output):
-		  	  5        1         5+1
-			  4        3         4+3
-			  2        7         2+7
-			  6                  6
-			  9                  9
+		Example:  ss1_size is 5, ss2_size is 3
+		ss1:      ss2:   result (output):
+		  5        1         5+1
+		  4        3         4+3
+		  2        7         2+7
+		  6                  6
+		  9                  9
 	  of course the carry is propagated and will be returned from the last item
 	  (this method is used by the Karatsuba multiplication algorithm)
 	*/
@ -388,16 +293,15 @@ namespace ttmath
 	{
 		TTMATH_ASSERT( ss1_size >= ss2_size )

+		uint rest = ss1_size - ss2_size;
 		uint c;

 		#ifndef __GNUC__
-			 c = ttmath_addvector_x64(ss1, ss2, ss1_size, ss2_size, result);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy1, dummy2, dummy3;	
-		uint rest = ss1_size - ss2_size;
 			
 			//	this part should be compiled with gcc
 		
@ -439,13 +343,15 @@ namespace ttmath

 		#endif

-		TTMATH_VECTOR_LOGC("UInt::AddVector", c, result, ss1_size)
+		TTMATH_LOG("UInt::AddVector")

 	return c;
 	}



+
+
 	/*!
 		this method's subtracting ss2 from the 'this' and subtracting
 		carry if it has been defined
@ -463,14 +369,14 @@ namespace ttmath
 	uint * p1 = table;
 	const uint * p2 = ss2.table;
 	
+
 		// we don't have to use TTMATH_REFERENCE_ASSERT here
 		// this algorithm doesn't require it

 		#ifndef __GNUC__
-			c = ttmath_sbb_x64(p1,p2,b,c);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy, dummy2;

@ -495,13 +401,12 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Sub", c)
+		TTMATH_LOG("UInt::Sub")

 	return c;
 	}


-
 	/*!
 		this method subtracts one word (at a specific position)
 		and returns a carry (if it was)
@ -509,17 +414,12 @@ namespace ttmath
 		***this method is created only on a 64bit platform***

 		if we've got (value_size=3):
-
 			table[0] = 10;
 			table[1] = 30;
 			table[2] = 5;	
-
 		and we call:
-
 			SubInt(2,1)
-
 		then it'll be:
-
 			table[0] = 10;
 			table[1] = 30 - 2;
 			table[2] = 5;
@ -532,17 +432,15 @@ namespace ttmath
 	uint b = value_size;
 	uint * p1 = table;
 	uint c;
+	uint dummy, dummy2;

 		TTMATH_ASSERT( index < value_size )

 		#ifndef __GNUC__
-			c = ttmath_subindexed_x64(p1,b,index,value);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
-			uint dummy, dummy2;
-
 			__asm__ __volatile__(
 			
 				"subq %%rdx, %%rcx 				\n"
@ -566,29 +464,31 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::SubInt", c)
+		TTMATH_LOG("UInt::SubInt")

 	return c;
 	}


+
+
 	/*!
 		this static method subtractes one vector from the other
 		'ss1' is larger in size or equal to 'ss2'

-		-  ss1 points to the first (larger) vector
-		-  ss2 points to the second vector
-		-  ss1_size - size of the ss1 (and size of the result too)
-		-  ss2_size - size of the ss2
-		-  result - is the result vector (which has size the same as ss1: ss1_size)
+		ss1 points to the first (larger) vector
+		ss2 points to the second vector
+		ss1_size - size of the ss1 (and size of the result too)
+		ss2_size - size of the ss2
+		result - is the result vector (which has size the same as ss1: ss1_size)

-			Example:  ss1_size is 5, ss2_size is 3
-			ss1:      ss2:   result (output):
-			  5        1         5-1
-			  4        3         4-3
-			  2        7         2-7
-			  6                  6-1  (the borrow from previous item)
-			  9                  9
+		Example:  ss1_size is 5, ss2_size is 3
+		ss1:      ss2:   result (output):
+		  5        1         5-1
+		  4        3         4-3
+		  2        7         2-7
+		  6                  6-1  (the borrow from previous item)
+		  9                  9
 		               return (carry): 0
 	  of course the carry (borrow) is propagated and will be returned from the last item
 	  (this method is used by the Karatsuba multiplication algorithm)
@ -598,20 +498,20 @@ namespace ttmath
 	{
 		TTMATH_ASSERT( ss1_size >= ss2_size )

+		uint rest = ss1_size - ss2_size;
 		uint c;

 		#ifndef __GNUC__
-			c = ttmath_subvector_x64(ss1, ss2, ss1_size, ss2_size, result);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
-		
-		//	the asm code is nearly the same as in AddVector
-		//	only two instructions 'adc' are changed to 'sbb'
-		
+
+		/*
+			the asm code is nearly the same as in AddVector
+			only two instructions 'adc' are changed to 'sbb'
+		*/
 		uint dummy1, dummy2, dummy3;
-		uint rest = ss1_size - ss2_size;

 			__asm__ __volatile__(
 				"mov %%rdx, %%r8					\n"
@ -651,12 +551,13 @@ namespace ttmath

 		#endif

-		TTMATH_VECTOR_LOGC("UInt::SubVector", c, result, ss1_size)
+		TTMATH_LOG("UInt::SubVector")

 	return c;
 	}


+
 	/*!
 		this method moves all bits into the left hand side
 		return value <- this <- c
@ -676,13 +577,12 @@ namespace ttmath
 	{
 	sint b = value_size;
 	uint * p1 = table;
-
+	

 		#ifndef __GNUC__
-			c = ttmath_rcl_x64(p1,b,c);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy, dummy2;

@ -706,7 +606,7 @@ namespace ttmath
 	
 		#endif

-		TTMATH_LOGC("UInt::Rcl2_one", c)
+		TTMATH_LOG("UInt::Rcl2_one")

 	return c;
 	}
@ -734,10 +634,9 @@ namespace ttmath
 	

 		#ifndef __GNUC__
-			c = ttmath_rcr_x64(p1,b,c);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy;

@ -759,7 +658,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcr2_one", c)
+		TTMATH_LOG("UInt::Rcr2_one")

 	return c;
 	}
@ -790,10 +689,9 @@ namespace ttmath


 		#ifndef __GNUC__
-			c = ttmath_rcl2_x64(p1,b,bits,c);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy, dummy2, dummy3;

@ -833,7 +731,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcl2", c)
+		TTMATH_LOG("UInt::Rcl2")

 	return c;
 	}
@ -860,16 +758,14 @@ namespace ttmath

 	sint b = value_size;
 	uint * p1 = table;
-
+	uint dummy, dummy2, dummy3;

 		#ifndef __GNUC__
-			c = ttmath_rcr2_x64(p1,b,bits,c);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif


 		#ifdef __GNUC__
-			uint dummy, dummy2, dummy3;
-
 			__asm__  __volatile__(

 			"movq %%rcx, %%rsi				\n"
@ -909,7 +805,7 @@ namespace ttmath

 		#endif

-		TTMATH_LOGC("UInt::Rcr2", c)
+		TTMATH_LOG("UInt::Rcr2")

 	return c;
 	}
@ -926,19 +822,11 @@ namespace ttmath
 	{
 	sint result;

-	
+
 		#ifndef __GNUC__
-
-			unsigned long nIndex = 0;
-
-			if( _BitScanReverse64(&nIndex,x) == 0 )
-				result = -1;
-			else
-				result = nIndex;
-
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		uint dummy;

@ -959,50 +847,6 @@ namespace ttmath
 	}


-	/*
-		this method returns the number of the highest set bit in one 64-bit word
-		if the 'x' is zero this method returns '-1'
-
-		***this method is created only on a 64bit platform***
-	*/
-	template<uint value_size>
-	sint UInt<value_size>::FindLowestBitInWord(uint x)
-	{
-	sint result;
-
-	
-		#ifndef __GNUC__
-
-			unsigned long nIndex = 0;
-
-			if( _BitScanForward64(&nIndex,x) == 0 )
-				result = -1;
-			else
-				result = nIndex;
-
-		#endif
-
-
-		#ifdef __GNUC__
-		uint dummy;
-
-				__asm__ (
-
-				"movq $-1, %1          \n"
-				"bsfq %2, %0           \n"
-				"cmovz %1, %0          \n"
-
-				: "=r" (result), "=&r" (dummy)
-				: "r" (x)
-				: "cc" );
-
-		#endif
-
-
-	return result;
-	}
-
-
 	/*!
 		this method sets a special bit in the 'value'
 		and returns the last state of the bit (zero or one)
@ -1026,10 +870,9 @@ namespace ttmath


 		#ifndef __GNUC__
-			old_bit = _bittestandset64((__int64*)&value,bit) != 0;
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__

 			__asm__ (
@ -1060,8 +903,8 @@ namespace ttmath

 	/*!
 		multiplication: result_high:result_low = a * b
-		-  result_high - higher word of the result
-		-  result_low  - lower word of the result
+		result_high - higher word of the result
+		result_low  - lower word of the result
 	
 		this methos never returns a carry
 		this method is used in the second version of the multiplication algorithms
@ -1081,12 +924,10 @@ namespace ttmath
 	uint result1_;
 	uint result2_;

-
 		#ifndef __GNUC__
-			result1_ = _umul128(a,b,&result2_);
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__

 		__asm__ (
@ -1140,16 +981,10 @@ namespace ttmath

 		TTMATH_ASSERT( c != 0 )

-
 		#ifndef __GNUC__
-
-			ttmath_div_x64(&a,&b,c);
-			r_    = a;
-			rest_ = b;
-			
+			#error "another compiler than GCC is currently not supported in 64bit mode"
 		#endif

-
 		#ifdef __GNUC__
 		
 			__asm__ (
@ -1167,6 +1002,7 @@ namespace ttmath
 		*rest = rest_;
 	}

+
 } //namespace


--- a/ttmath/ttmathuint_x86_64_msvc.asm
+++ b/ttmath/ttmathuint_x86_64_msvc.asm
@ -1,551 +0,0 @@
-;
-; This file is a part of TTMath Bignum Library
-; and is distributed under the 3-Clause BSD Licence.
-; Author: Christian Kaiser <chk@online.de>, Tomasz Sowa <t.sowa@ttmath.org>
-;
-
-; 
-; Copyright (c) 2009-2017, Christian Kaiser, Tomasz Sowa
-; All rights reserved.
-; 
-; Redistribution and use in source and binary forms, with or without
-; modification, are permitted provided that the following conditions are met:
-; 
-;  * Redistributions of source code must retain the above copyright notice,
-;    this list of conditions and the following disclaimer.
-;    
-;  * Redistributions in binary form must reproduce the above copyright
-;    notice, this list of conditions and the following disclaimer in the
-;    documentation and/or other materials provided with the distribution.
-;    
-;  * Neither the name Christian Kaiser nor the names of contributors to this
-;    project may be used to endorse or promote products derived
-;    from this software without specific prior written permission.
-;
-; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-; THE POSSIBILITY OF SUCH DAMAGE.
-;
-
-;
-; compile with debug info:    ml64.exe /c /Zd /Zi ttmathuint_x86_64_msvc.asm
-; compile without debug info: ml64.exe /c ttmathuint_x86_64_msvc.asm
-; this creates ttmathuint_x86_64_msvc.obj file which can be linked with your program
-;
-
-; doxygen info is put to ttmathuint_x86_64.h file
-
-
-PUBLIC	ttmath_adc_x64
-PUBLIC	ttmath_addindexed_x64
-PUBLIC	ttmath_addindexed2_x64
-PUBLIC	ttmath_addvector_x64
-
-PUBLIC	ttmath_sbb_x64
-PUBLIC	ttmath_subindexed_x64
-PUBLIC	ttmath_subvector_x64
-
-PUBLIC	ttmath_rcl_x64
-PUBLIC	ttmath_rcr_x64
-
-PUBLIC	ttmath_rcl2_x64
-PUBLIC	ttmath_rcr2_x64
-
-PUBLIC	ttmath_div_x64
-
-;
-; Microsoft x86_64 convention: http://msdn.microsoft.com/en-us/library/9b372w95.aspx
-;
-;	"rax, rcx, rdx, r8-r11 are volatile."
-;	"rbx, rbp, rdi, rsi, r12-r15 are nonvolatile."
-;
-
-
-.CODE
-
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_adc_x64				PROC
-        ; rcx = p1
-        ; rdx = p2
-        ; r8 = nSize
-        ; r9 = nCarry
-
-        xor		rax, rax
-        xor		r11, r11
-        sub		rax, r9		; sets CARRY if r9 != 0
-
-		ALIGN 16
- loop1:
-		mov		rax,qword ptr [rdx + r11 * 8]
-		adc		qword ptr [rcx + r11 * 8], rax
-		lea		r11, [r11+1]
-		dec		r8
-		jnz		loop1
-
-		setc	al
-		movzx	rax, al
-
-		ret
-
-ttmath_adc_x64				ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_addindexed_x64	PROC
-
-        ; rcx = p1
-        ; rdx = nSize
-        ; r8 = nPos
-        ; r9 = nValue
-
-		xor		rax, rax			; rax = result
-		sub		rdx, r8				; rdx = remaining count of uints
-
-		add		qword ptr [rcx + r8 * 8], r9
-		jc		next1
-
-		ret
-
-next1:
-		mov		r9, 1
-
-		ALIGN 16
-loop1:
-		dec		rdx
-		jz		done_with_cy
-		lea		r8, [r8+1]
-		add		qword ptr [rcx + r8 * 8], r9
-		jc		loop1
-
-		ret
-
-done_with_cy:
-		lea		rax, [rax+1]		; rax = 1
-
-		ret
-
-ttmath_addindexed_x64	ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_addindexed2_x64	PROC
-
-        ; rcx = p1 (pointer)
-        ; rdx = b  (value size)
-        ; r8 = nPos
-        ; r9 = nValue1
-        ; [rsp+0x28] = nValue2
-
-		xor		rax, rax			; return value
-		mov		r11, rcx			; table
-		sub		rdx, r8				; rdx = remaining count of uints
-		mov		r10, [rsp+028h]		; r10 = nValue2
-
-		add		qword ptr [r11 + r8 * 8], r9
-		lea		r8, [r8+1]
-		lea		rdx, [rdx-1]
-		adc		qword ptr [r11 + r8 * 8], r10
-		jc		next
-		ret
-
-		ALIGN 16
-loop1:
-		lea		r8, [r8+1]
-		add		qword ptr [r11 + r8 * 8], 1
-		jc		next
-		ret
-
-next:
-		dec		rdx					; does not modify CY too...
-		jnz		loop1
-		lea		rax, [rax+1]
-		ret
-
-ttmath_addindexed2_x64	ENDP
-
-
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-
-ttmath_addvector_x64				PROC
-        ; rcx = ss1
-        ; rdx = ss2
-        ; r8 = ss1_size
-        ; r9 = ss2_size
-        ; [rsp+0x28] = result
-
-		mov		r10, [rsp+028h]
-		sub		r8, r9
-        xor		r11, r11				; r11=0, cf=0
-
-		ALIGN 16
- loop1:
-		mov		rax, qword ptr [rcx + r11 * 8]
-		adc		rax, qword ptr [rdx + r11 * 8]
-		mov		qword ptr [r10 + r11 * 8], rax
-		inc		r11
-		dec		r9
-		jnz		loop1
-
-		adc		r9, r9					; r9 has the cf state
-
-		or		r8, r8
-		jz		done
-
-		neg		r9						; setting cf from r9
-		mov		r9, 0					; don't use xor here (cf is used)
- loop2:
-		mov		rax, qword ptr [rcx + r11 * 8]
-		adc		rax, r9
-		mov		qword ptr [r10 + r11 * 8], rax
-		inc		r11
-		dec		r8
-		jnz		loop2
-
-		adc		r8, r8
-		mov		rax, r8
-		
-		ret
-
-done:
-		mov		rax, r9
-		ret
-
-ttmath_addvector_x64				ENDP
-
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_sbb_x64				PROC
-
-        ; rcx = p1
-        ; rdx = p2
-        ; r8 = nCount
-        ; r9 = nCarry
-
-        xor		rax, rax
-        xor		r11, r11
-        sub		rax, r9				; sets CARRY if r9 != 0
-
-		ALIGN 16
- loop1:
-		mov		rax,qword ptr [rdx + r11 * 8]
-		sbb		qword ptr [rcx + r11 * 8], rax
-		lea		r11, [r11+1]
-		dec		r8
-		jnz		loop1
-
-		setc	al
-		movzx	rax, al
-
-		ret
-
-ttmath_sbb_x64				ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_subindexed_x64	PROC
-        ; rcx = p1
-        ; rdx = nSize
-        ; r8 = nPos
-        ; r9 = nValue
-
-		sub		rdx, r8				; rdx = remaining count of uints
-
-		ALIGN 16
-loop1:
-		sub		qword ptr [rcx + r8 * 8], r9
-		jnc		done
-
-		lea		r8, [r8+1]
-		mov		r9, 1
-		dec		rdx
-		jnz		loop1
-
-		mov		rax, 1
-		ret
-
-done:
-		xor		rax, rax
-		ret
-
-ttmath_subindexed_x64	ENDP
-
-
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-;	the same asm code as in addvector_x64 only two instructions 'adc' changed to 'sbb'
-
-ttmath_subvector_x64				PROC
-        ; rcx = ss1
-        ; rdx = ss2
-        ; r8 = ss1_size
-        ; r9 = ss2_size
-        ; [rsp+0x28] = result
-
-		mov		r10, [rsp+028h]
-		sub		r8, r9
-        xor		r11, r11				; r11=0, cf=0
-
-		ALIGN 16
- loop1:
-		mov		rax, qword ptr [rcx + r11 * 8]
-		sbb		rax, qword ptr [rdx + r11 * 8]
-		mov		qword ptr [r10 + r11 * 8], rax
-		inc		r11
-		dec		r9
-		jnz		loop1
-
-		adc		r9, r9					; r9 has the cf state
-
-		or		r8, r8
-		jz		done
-
-		neg		r9						; setting cf from r9
-		mov		r9, 0					; don't use xor here (cf is used)
- loop2:
-		mov		rax, qword ptr [rcx + r11 * 8]
-		sbb		rax, r9
-		mov		qword ptr [r10 + r11 * 8], rax
-		inc		r11
-		dec		r8
-		jnz		loop2
-
-		adc		r8, r8
-		mov		rax, r8
-		
-		ret
-
-done:
-		mov		rax, r9
-		ret
-
-ttmath_subvector_x64				ENDP
-
-
-
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_rcl_x64	PROC
-        ; rcx = p1
-        ; rdx = b
-        ; r8 = nLowestBit
-
-		mov		r11, rcx			; table
-		xor		r10, r10
-		neg		r8					; CY set if r8 <> 0
-
-		ALIGN 16
-loop1:
-		rcl		qword ptr [r11 + r10 * 8], 1
-		lea		r10, [r10+1]
-		dec		rdx
-		jnz		loop1
-
-		setc	al
-		movzx	rax, al
-
-        ret
-
-ttmath_rcl_x64	ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_rcr_x64	PROC
-        ; rcx = p1
-        ; rdx = nSize
-        ; r8 = nLowestBit
-
-		xor		r10, r10
-		neg		r8					; CY set if r8 <> 0
-
-		ALIGN 16
-loop1:
-		rcr		qword ptr -8[rcx + rdx * 8], 1
-		dec		rdx
-		jnz		loop1
-
-		setc	al
-		movzx	rax, al
-
-        ret
-
-ttmath_rcr_x64	ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_div_x64	PROC
-
-        ; rcx = &Hi
-        ; rdx = &Lo
-        ; r8 = nDiv
-
-        mov		r11, rcx
-        mov		r10, rdx
-
-        mov		rdx, qword ptr [r11]
-        mov		rax, qword ptr [r10]
-        div		r8
-        mov		qword ptr [r10], rdx ; remainder
-        mov		qword ptr [r11], rax ; value
-
-        ret
-
-ttmath_div_x64	ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_rcl2_x64	PROC
-        ; rcx = p1
-        ; rdx = nSize
-        ; r8 = bits
-        ; r9 = c
-
-        push	rbx
-
-        mov		r10, rcx	; r10 = p1
-        xor		rax, rax
-
-        mov		rcx, 64
-        sub		rcx, r8
-
-        mov		r11, -1
-        shr		r11, cl		; r11 = mask
-
-		mov		rcx, r8		; rcx = count of bits
-
-		mov		rbx, rax	; rbx = old value = 0
-		or		r9, r9
-		cmovnz	rbx, r11	; if (c) then old value = mask
-
-        mov		r9, rax		; r9 = index (0..nSize-1)
-
-		ALIGN 16
-loop1:
-		rol		qword ptr [r10+r9*8], cl
-		mov		rax, qword ptr [r10+r9*8]
-		and		rax, r11
-		xor		qword ptr [r10+r9*8], rax
-		or		qword ptr [r10+r9*8], rbx
-		mov		rbx, rax
-
-		lea		r9, [r9+1]
-		dec		rdx
-
-		jnz		loop1
-
-		and		rax, 1
-		pop		rbx
-        ret
-
-ttmath_rcl2_x64	ENDP
-
-;----------------------------------------
-
-        ALIGN       8
-
-;----------------------------------------
-
-ttmath_rcr2_x64	PROC
-        ; rcx = p1
-        ; rdx = nSize
-        ; r8 = bits
-        ; r9 = c
-
-        push	rbx
-        mov		r10, rcx	; r10 = p1
-        xor		rax, rax
-
-        mov		rcx, 64
-        sub		rcx, r8
-
-        mov		r11, -1
-        shl		r11, cl		; r11 = mask
-
-		mov		rcx, r8		; rcx = count of bits
-
-		mov		rbx, rax	; rbx = old value = 0
-		or		r9, r9
-		cmovnz	rbx, r11	; if (c) then old value = mask
-
-        mov		r9, rdx		; r9 = index (0..nSize-1)
-		lea		r9, [r9-1]
-
-		ALIGN 16
-loop1:
-		ror		qword ptr [r10+r9*8], cl
-		mov		rax, qword ptr [r10+r9*8]
-		and		rax, r11
-		xor		qword ptr [r10+r9*8], rax
-		or		qword ptr [r10+r9*8], rbx
-		mov		rbx, rax
-
-		lea		r9, [r9-1]
-		dec		rdx
-
-		jnz		loop1
-
-		rol		rax, 1
-		and		rax, 1
-		pop		rbx
-
-        ret
-
-ttmath_rcr2_x64	ENDP
-
-END
--- a/ttmath/win64_assemble.bat
+++ b/ttmath/win64_assemble.bat
@ -1,9 +0,0 @@
-rem make sure this is a proper path to the 64 bit assembler
-"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64\ml64.exe" /c ttmathuint_x86_64_msvc.asm
-rem ml64.exe will produce ttmathuint_x86_64_msvc.obj which should be added (linked) to your project
-
-rem or you can assemble with debug info
-rem ml64.exe /c /Zd /Zi ttmathuint_x86_64_msvc.asm
-
-rem be nice, most Windows users just click on the file
-pause
Author	SHA1	Message	Date
Tomasz Sowa	5584adb23d	changed version: 0.8.6 now git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@222 e52654a7-88a9-db11-a3e9-0013d4bc506e	2009-10-25 15:55:15 +00:00
Tomasz Sowa	a4bb0b6f64	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 git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@215 e52654a7-88a9-db11-a3e9-0013d4bc506e	2009-10-16 21:38:25 +00:00
Tomasz Sowa	e046aba6d2	fixed: buffer overflow in Big::ToInt(Int<int_size> & result) git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@211 e52654a7-88a9-db11-a3e9-0013d4bc506e	2009-10-15 01:40:13 +00:00
Tomasz Sowa	5ef27bdbd0	Some fixes from trunk: 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') git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@204 e52654a7-88a9-db11-a3e9-0013d4bc506e	2009-10-07 17:33:03 +00:00
Tomasz Sowa	b80f73f16b	creating 0.8.x branch of the ttmath library (copied from trunk) git-svn-id: svn://ttmath.org/publicrep/ttmath/branches/0.8.x@166 e52654a7-88a9-db11-a3e9-0013d4bc506e	2009-06-16 20:28:52 +00:00