Technical
support e-mail : mktmk<at>narod.ru.
Home
pageааааааааааааааа :
http://mktmk.narod.ru.
Multiprecision unsigned number template library (MUNTL)
Distributed under the GNU LGPL.
Users
guide.
0.
Version list
v1.01 -
adapt for GCC 3.2.2.
v1.00 - project start.
1. The
purpose of program.
The
program (library) is intended for the organization of calculations with the big
precision
for unsigned numbers. For use this program only one header file di.h (25Kb) is necessary. The program works very quickly. As
against other similar programs this program does not use the heap call (new, malloc etc.). All buffers for storage of numbers are allocated
at compile-time. The program does not use GMP and other libraries for work with
long numbers. The program use only pure C++ code.
2.
Conditions of application.
The
program is written on "pure" C++ with template. The program does not
use the
assembler. The program is tested by BCB60 in ANSI-compatibility mode.
The
program is tested by GCC 3.2.2.
Configuration
of test computer: Athlon 1800, Chaintech
7AJA2, 256Mb RAM.
Test
time (file dit.cpp) is 42 second.
3. The
problem description.
Sometimes
it is necessary to have unsigned numbers which length exceeds
ability
of a current platform. For example:
а- Storage of the big numbers (for example
factorials) and operations with them.
а- Emulation of registers of the big length.
а- Indication of many error
in position code.
This
program is intended for the decision of these problems.
4. The input
and output data.
4.1
General description.
Numbers
of the big precision are realized as template class di_unsigned.
This template class have the overloaded arithmetic operations. Due to this,
di_unsigned may use as usual unsigned numbers.
Word
length of numbers di_unsigned do not limited.
Inside a
class di_unsigned the information is stored as array.
4.2
Structure of the project.
Fileа di.hаааааааааа - is template library.
Files dit.cpp, dit.h - is the test of
template library.
Fileа die.cppаааа
ааа- is an example of use template
library.
Fileа readrus.txtааа
- is this users guide in Russian.
Fileа readeng.txtааа
- is this users guide in English.
4.3
Parameters of template.
The
template di_unsigned have 3 parameters.
template
<class T,class Tunit,T
size> class di_unsigned;
The
first parameterа "T"аааа - is type of the counter of bits.
The
second parameter "Tunit" - is type of
internal array which stored the
аааааааааааааааааааааааааааааа information.
The
third parameterа "size"а - is numerical parameter. Determines length
аааааааааааааааааааааааааааааа di_unsigned in bits.
Type
"T" should may contain number
"size". For example if "T" is unsigned char,
parameter
"size" can not be more than 255.
Type
"Tunit" should be unsigned for correct work
of right shifts operator.
For
increase of performance it is recommended to choose "Tunit"
equal to
machine
word for the current platform. For win32 it is recommended use
"unsigned int" as "Tunit".
Unsigned
char and char of the current platform should be one size for correct
work
functions "printtostring".
Unsigned
char and char of the current platform should have even number of bits.
Problems
are possible on the platforms having CHAR_BIT=7.
Is
possible use of di_unsigned with different parameter
"size" in one
arithmetic
expression (see example in a file die.cpp).
This
version not supported use of numbers with different types "T" or
"Tunit"
in one
arithmetic expression.
Type
"T" should may contain size+size1 for
correct work of operation of
multiplication. (Size and size1 is parameter "size" of two di_unsigned operand
in binary
operator).
Type
"T" should may contain size+1 and size1+1
for correct work of operation of
division.
4.4
Example of use di_unsigned.
// Inclusion
of library of templates di_unsigned
#include
<di.h>
//
Inclusion of library of standard input-output
#include
<stdio.h>
// Word
length of the first type
const
unsigned int numberbit1=250;
// Word
length of the second type
const
unsigned int numberbit2=253;
//
Definition of the first type
typedef di_unsigned <
unsigned int, unsigned int,
numberbit1 > big_digit1;
//
Definition of the second type
typedef di_unsigned <
unsigned int, unsigned int,
numberbit2 > big_digit2;
// Use
"unsigned int" as T and Tunitа
int main (int argc, char* argv []) {
//
Length of a text string for print first number
const
unsigned int l1 = ((numberbit1)/CHAR_BIT+1)*2+1;
//
Length of a text string for print second number
const unsigned
int l2 = ((numberbit2)/CHAR_BIT+1)*2+1;
// Text
string for print first number
char
string1 [l1];
// Text
string for print second number
char
string2 [l2];
//
Initialization of three numbers
big_digit1
d1=1;
big_digit2
d2=1;
big_digit2
d3;
// left
shift operatorа
d1
<<= (numberbit1/2+1);
d2
<<= numberbit1/2;
//
increment operator
++d1;
// print
of result
d1.printtostring
(string1, l2);
d2.printtostring
(string2, l2);
printf (" \nd1аа
=0x%s ", string1);
printf (" \nd2аа
=0x%s ", string2);
//
addition operator
d3=d1+d2;
// print
of result
d3.printtostring
(string2, l2);
printf ("\nd1+d2=0x%s", string2);
//
multiplication operator
d3=d1*d2;
// print
of result
d3.printtostring
(string2, l2);
printf ("\nd1*d2=0x%s", string2);
//
division operatorа
d3=d1/d2;
// print
of result
d3.printtostring
(string2, l2);
printf ("\nd1/d2=0x%s", string2);
//
modulus operator
d3=d1%d2;
// print
of result
d3.printtostring
(string2, l2);
printf ("\nd1%sd2 =0x%s", "",
string2);
return 0;
}
4.5 The description
of functions - members.
For a
template di_unsigned the following operators are
determined:
&а - bitwise AND
&= -
bitwise AND with assignment
|а - bitwise inclusive OR
|= -
bitwise inclusive OR with assignment
^а - bitwise exclusive OR
^= - bitwise
exclusive OR with assignment
~а - bitwise complement
=а - assignment
== -
equalityааааааааааааааааааааа
!= -
inequality
>а - greater than
<а - less than
>= -
greater than or equal
<= -
less than or equal
<<а - left shift
<<=
- left shift with assignment
>>а - right shift
>>=
- right shift with assignment
+а - addition
+= -
addition with assignment
-а - subtraction
-= -
subtraction with assignment
++ - preincrement and postincrement
-- - predecrement and postdecrement
*а - multiplication
*= - multiplication
with assignment
/а - division
/= -
division with assignment
%а - modulus operator
%= -
modulus operator with assignment
Additional
functions:
void
clear(); - set "all zero"
void
set();аа - set "all one"
void
clear(const T bit); - clear a bit with specified number
void
set(const T bit);аа - setаа a bit with specified number
bool tst(const T bit)
const; - check a bit with specified number. Return
ааааааааааааааааааааааааааааааа true, if bit is 1 and false in opposite case.
const T getbite() const;аааа
- returns precision of number (parameter "size" of
аааааааааааааааааааааааааааааа template)
bool getcf() const;ааааааааа - returns a status of carry. It is
established
аааааааааааааааааааааааааааааа after operations of addition and subtraction.
di_version ver()
const;ааааааааа - returns version of
library
di_serialnumber sernum()
const;а - returns serial number of
library
operator
const Tunit * () const; - cast to pointer of Tunit. (Return internal
аааааааааааааааа ааааааааааааааааааarray.
Do not modify it.)
void printtostring (char* c_str, T lengthstr); - prints the number to c_str
аааааааааааааааааааааааааааааааааааааааааааааааа
in hex format .
di_unsigned(); - constructor without parameters. It do not
clear internal array.
di_unsigned
(const di_unsigned& d); - constructor
template
<T size1>
di_unsigned
(const di_unsigned <T,Tunit,size1>&
d); - constructor
template
< class Tv >
di_unsigned
(const Tv& val); - constructor. "Tv"
should be unsigned.
аааааааааааааа ааааааааааааааааFor example
unsigned int, unsigned long int.
di_unsigned(const char* c_str); -
constructor. The line c_str should contain
ааааааааааааааааааааааааааааааааа hex string with zero at end. Any invalid
ааааааааааааааааааааааааааааааааа symbol finishes convertion.
Operators of assignment. Parameters - as in the appropriate constructors.
di_unsigned&
operator = (const di_unsigned& d);
template
<T size1>
di_unsigned&
operator = (const di_unsigned <T,Tunit,size1>&
d);
template
< class Tv >
di_unsigned&
operator = (const Tv& val);
di_unsigned&
operator = (const char* c_str);
4.6 Use
of functions - members.
The
binary addition operator "+" returns number with the greater length
from
two
operands. For example, at addition of numbers of 100 and 200 bits this
operator
will return result with length of 200 bits.
The
binary multiplication operator "*" returns number with the length
equal
to the
sum of lengths two operands. For example, at multiplication of numbers
of 100
and 200 bits this operator will return result with length of 300 bits.
The
binary division operator "/" returns number with the length equal to
length
divided.
The
binary modulus operator "%" returns number with length equal length
of
divider.
If user
define DI_EXCEPTIONENABLE macro, the library will throw exception if
division
by zero will occur.
class di_exception {
public:
di_exception(){}
};
By
default DI_EXCEPTIONENABLE do not define.
Any
operators and functions have not check correct of
their parameters.
For
example, if to apply function set(200) to number with
length of 100 bits,
will take
crash of programs.