3216 lines
52 KiB
C++
3216 lines
52 KiB
C++
/*
|
|
* This file is a part of TTMath Mathematical Library
|
|
* and is distributed under the (new) BSD licence.
|
|
* Author: Tomasz Sowa <t.sowa@slimaczek.pl>
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2006-2007, 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 headerfilettmathuint
|
|
#define headerfilettmathuint
|
|
|
|
/*!
|
|
\file ttmathuint.h
|
|
\brief template class UInt<uint>
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
|
|
#include "ttmathtypes.h"
|
|
|
|
|
|
|
|
namespace ttmath
|
|
{
|
|
|
|
/*!
|
|
\brief UInt implements a big integer value without a sign
|
|
|
|
value_size - how many bytes specify our value
|
|
on 32bit platforms: value_size=1 -> 4 bytes -> 32 bits
|
|
on 64bit platforms: value_size=1 -> 8 bytes -> 64 bits
|
|
value_size = 1,2,3,4,5,6....
|
|
*/
|
|
template<uint value_size>
|
|
class UInt
|
|
{
|
|
public:
|
|
|
|
/*!
|
|
buffer for this integer value
|
|
the first value (index 0) means the lowest word of this value
|
|
*/
|
|
uint table[value_size];
|
|
|
|
|
|
/*!
|
|
this method is only for debugging purposes or when we want to make
|
|
a table of a variable (constant) in ttmathbig.h
|
|
|
|
it prints the table in a nice form of several columns
|
|
*/
|
|
void PrintTable(std::ostream & output) const
|
|
{
|
|
// how many columns there'll be
|
|
const int columns = 8;
|
|
|
|
int c = 1;
|
|
for(int i=value_size-1 ; i>=0 ; --i)
|
|
{
|
|
output << "0x" << std::setfill('0');
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
output << std::setw(8);
|
|
#else
|
|
output << std::setw(16);
|
|
#endif
|
|
|
|
output << std::hex << table[i];
|
|
|
|
if( i>0 )
|
|
{
|
|
output << ", ";
|
|
|
|
if( ++c > columns )
|
|
{
|
|
output << std::endl;
|
|
c = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
output << std::endl;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
it returns the size of the table
|
|
*/
|
|
uint Size() const
|
|
{
|
|
return value_size;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method sets value zero
|
|
*/
|
|
void SetZero()
|
|
{
|
|
for(uint i=0 ; i<value_size ; ++i)
|
|
table[i] = 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method sets value one
|
|
*/
|
|
void SetOne()
|
|
{
|
|
SetZero();
|
|
table[0] = 1;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method sets the max value which this class can hold
|
|
(all bits will be one)
|
|
*/
|
|
void SetMax()
|
|
{
|
|
for(uint i=0 ; i<value_size ; ++i)
|
|
table[i] = TTMATH_UINT_MAX_VALUE;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method sets the min value which this class can hold
|
|
(for an unsigned integer value the zero is the smallest value)
|
|
*/
|
|
void SetMin()
|
|
{
|
|
SetZero();
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
/*!
|
|
this method copies the value stored in an another table
|
|
(warning: first values in temp_table are the highest words -- it's different
|
|
from our table)
|
|
|
|
we copy as many words as it is possible
|
|
|
|
if temp_table_len is bigger than value_size we'll try to round
|
|
the lowest word from table depending on the last not used bit in temp_table
|
|
(this rounding isn't a perfect rounding -- look at the description below)
|
|
|
|
and if temp_table_len is smaller than value_size we'll clear the rest words
|
|
in the table
|
|
*/
|
|
void SetFromTable(const uint * temp_table, uint temp_table_len)
|
|
{
|
|
uint temp_table_index = 0;
|
|
sint i; // 'i' with a sign
|
|
|
|
for(i=value_size-1 ; i>=0 && temp_table_index<temp_table_len; --i, ++temp_table_index)
|
|
table[i] = temp_table[ temp_table_index ];
|
|
|
|
|
|
// rounding mantissa
|
|
if( temp_table_index < temp_table_len )
|
|
{
|
|
if( (temp_table[temp_table_index] & TTMATH_UINT_HIGHEST_BIT) != 0 )
|
|
{
|
|
/*
|
|
very simply rounding
|
|
if the bit from not used last word from temp_table is set to one
|
|
we're rouding the lowest word in the table
|
|
|
|
in fact there should be a normal addition but
|
|
we don't use Add() or AddTwoInts() because these methods
|
|
can set a carry and then there'll be a small problem
|
|
for optimization
|
|
*/
|
|
if( table[0] != TTMATH_UINT_MAX_VALUE )
|
|
++table[0];
|
|
}
|
|
}
|
|
|
|
// cleaning the rest of the mantissa
|
|
for( ; i>=0 ; --i)
|
|
table[i] = 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
*
|
|
* basic mathematic functions
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
this method adding ss2 to the this and adding carry if it's defined
|
|
(this = this + ss2 + c)
|
|
|
|
c must be zero or one (might be a bigger value than 1)
|
|
function returns carry (1) (if it was)
|
|
*/
|
|
uint Add(const UInt<value_size> & ss2, uint c=0)
|
|
{
|
|
register uint b = value_size;
|
|
register uint * p1 = table;
|
|
register uint * p2 = const_cast<uint*>(ss2.table);
|
|
|
|
|
|
#ifndef __GNUC__
|
|
|
|
// this part might be compiled with for example visual c
|
|
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
|
|
mov ecx,[b]
|
|
|
|
mov ebx,[p1]
|
|
mov edx,[p2]
|
|
|
|
mov eax,0
|
|
sub eax,[c]
|
|
|
|
p:
|
|
mov eax,[ebx]
|
|
adc eax,[edx]
|
|
mov [ebx],eax
|
|
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
inc edx
|
|
inc edx
|
|
inc edx
|
|
inc edx
|
|
|
|
loop p
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop edx
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
|
|
// this part should be compiled with gcc
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
"push %%edx \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"subl %%esi, %%eax \n"
|
|
|
|
"1: \n"
|
|
"movl (%%ebx),%%eax \n"
|
|
"adcl (%%edx),%%eax \n"
|
|
"movl %%eax,(%%ebx) \n"
|
|
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"inc %%edx \n"
|
|
"inc %%edx \n"
|
|
"inc %%edx \n"
|
|
"inc %%edx \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"adcl %%eax,%%eax \n"
|
|
"movl %%eax, %%esi \n"
|
|
|
|
"pop %%edx \n"
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=S" (c)
|
|
: "0" (c), "c" (b), "b" (p1), "d" (p2)
|
|
: "%eax", "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method adds one word (at a specific position)
|
|
and returns a carry (if it was)
|
|
|
|
e.g.
|
|
|
|
if we've got (value_size=3):
|
|
table[0] = 10;
|
|
table[1] = 30;
|
|
table[2] = 5;
|
|
and we call:
|
|
AddInt(2,1)
|
|
then it'll be:
|
|
table[0] = 10;
|
|
table[1] = 30 + 2;
|
|
table[2] = 5;
|
|
|
|
of course if there was a carry from table[3] it would be returned
|
|
*/
|
|
uint AddInt(uint value, uint index = 0)
|
|
{
|
|
register uint b = value_size;
|
|
register uint * p1 = table;
|
|
register uint c;
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
|
|
mov ecx, [b]
|
|
sub ecx, [index]
|
|
|
|
mov edx, [index]
|
|
mov eax, [p1]
|
|
|
|
lea ebx, [eax+4*edx]
|
|
mov edx, [value]
|
|
|
|
clc
|
|
p:
|
|
mov eax, [ebx]
|
|
adc eax, edx
|
|
mov [ebx], eax
|
|
|
|
jnc end
|
|
mov edx, 0
|
|
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
loop p
|
|
|
|
end:
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop edx
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
"push %%edx \n"
|
|
|
|
"subl %%edx, %%ecx \n"
|
|
|
|
"leal (%%ebx,%%edx,4), %%ebx \n"
|
|
|
|
"movl %%esi, %%edx \n"
|
|
"clc \n"
|
|
"1: \n"
|
|
|
|
"movl (%%ebx), %%eax \n"
|
|
"adcl %%edx, %%eax \n"
|
|
"movl %%eax, (%%ebx) \n"
|
|
|
|
"jnc 2f \n"
|
|
|
|
"movl $0, %%edx \n"
|
|
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"2: \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"adcl %%eax,%%eax \n"
|
|
|
|
"pop %%edx \n"
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=a" (c)
|
|
: "c" (b), "d" (index), "b" (p1), "S" (value)
|
|
: "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this method adds only two unsigned words to the existing value
|
|
and these words begin on the 'index' position
|
|
(it's used in the multiplication algorithm 2)
|
|
|
|
index should be equal or smaller than value_size-2 (index <= value_size-2)
|
|
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
|
|
table[3] = 6
|
|
|
|
and no carry at the end of table[3]
|
|
|
|
(of course if there was a carry in table[2](5+20) then
|
|
this carry would be passed to the table[3] etc.)
|
|
*/
|
|
uint AddTwoInts(uint x2, uint x1, uint index)
|
|
{
|
|
register uint b = value_size;
|
|
register uint * p1 = table;
|
|
register uint c;
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
|
|
mov ecx, [b]
|
|
sub ecx, [index]
|
|
|
|
mov edx, [index]
|
|
mov eax, [p1]
|
|
|
|
lea ebx, [eax+4*edx]
|
|
|
|
mov edx, 0
|
|
|
|
mov eax, [ebx]
|
|
add eax, [x1]
|
|
mov [ebx], eax
|
|
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
mov eax, [ebx]
|
|
adc eax, [x2]
|
|
mov [ebx], eax
|
|
jnc end
|
|
|
|
dec ecx
|
|
dec ecx
|
|
jz end
|
|
|
|
p:
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
mov eax,[ebx]
|
|
adc eax, edx
|
|
mov [ebx], eax
|
|
|
|
jnc end
|
|
|
|
loop p
|
|
|
|
end:
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop edx
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
"push %%edx \n"
|
|
|
|
"subl %%edx, %%ecx \n"
|
|
|
|
"leal (%%ebx,%%edx,4), %%ebx \n"
|
|
|
|
"movl $0, %%edx \n"
|
|
|
|
"movl (%%ebx), %%eax \n"
|
|
"addl %%esi, %%eax \n"
|
|
"movl %%eax, (%%ebx) \n"
|
|
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"movl (%%ebx), %%eax \n"
|
|
"adcl %%edi, %%eax \n"
|
|
"movl %%eax, (%%ebx) \n"
|
|
"jnc 2f \n"
|
|
|
|
"dec %%ecx \n"
|
|
"dec %%ecx \n"
|
|
"jz 2f \n"
|
|
|
|
"1: \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"movl (%%ebx), %%eax \n"
|
|
"adcl %%edx, %%eax \n"
|
|
"movl %%eax, (%%ebx) \n"
|
|
|
|
"jnc 2f \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"2: \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"adcl %%eax,%%eax \n"
|
|
|
|
"pop %%edx \n"
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=a" (c)
|
|
: "c" (b), "d" (index), "b" (p1), "S" (x1), "D" (x2)
|
|
: "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
this method's subtracting ss2 from the 'this' and subtracting
|
|
carry if it has been defined
|
|
(this = this - ss2 - c)
|
|
|
|
c must be zero or one (might be a bigger value than 1)
|
|
function returns carry (1) (if it was)
|
|
*/
|
|
uint Sub(const UInt<value_size> & ss2, uint c=0)
|
|
{
|
|
register uint b = value_size;
|
|
register uint * p1 = table;
|
|
register uint * p2 = const_cast<uint*>(ss2.table);
|
|
|
|
#ifndef __GNUC__
|
|
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
|
|
mov ecx,[b]
|
|
|
|
mov ebx,[p1]
|
|
mov edx,[p2]
|
|
|
|
mov eax,0
|
|
sub eax,[c]
|
|
|
|
p:
|
|
mov eax,[ebx]
|
|
sbb eax,[edx]
|
|
mov [ebx],eax
|
|
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
inc edx
|
|
inc edx
|
|
inc edx
|
|
inc edx
|
|
|
|
loop p
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop edx
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
"push %%edx \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"subl %%esi, %%eax \n"
|
|
|
|
"1: \n"
|
|
"movl (%%ebx),%%eax \n"
|
|
"sbbl (%%edx),%%eax \n"
|
|
"movl %%eax,(%%ebx) \n"
|
|
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"inc %%edx \n"
|
|
"inc %%edx \n"
|
|
"inc %%edx \n"
|
|
"inc %%edx \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"adcl %%eax,%%eax \n"
|
|
"movl %%eax, %%esi \n"
|
|
|
|
"pop %%edx \n"
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=S" (c)
|
|
: "0" (c), "c" (b), "b" (p1), "d" (p2)
|
|
: "%eax", "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method subtracts one word (at a specific position)
|
|
and returns a carry (if it was)
|
|
|
|
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;
|
|
|
|
of course if there was a carry from table[3] it would be returned
|
|
*/
|
|
uint SubInt(uint value, uint index = 0)
|
|
{
|
|
register uint b = value_size;
|
|
register uint * p1 = table;
|
|
register uint c;
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
push edx
|
|
|
|
mov ecx, [b]
|
|
sub ecx, [index]
|
|
|
|
mov edx, [index]
|
|
mov eax, [p1]
|
|
|
|
lea ebx, [eax+4*edx]
|
|
mov edx, [value]
|
|
|
|
clc
|
|
p:
|
|
mov eax, [ebx]
|
|
sbb eax, edx
|
|
mov [ebx], eax
|
|
|
|
jnc end
|
|
mov edx, 0
|
|
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
loop p
|
|
|
|
end:
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop edx
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
"push %%edx \n"
|
|
|
|
"subl %%edx, %%ecx \n"
|
|
|
|
"leal (%%ebx,%%edx,4), %%ebx \n"
|
|
|
|
"movl %%esi, %%edx \n"
|
|
"clc \n"
|
|
"1: \n"
|
|
|
|
"movl (%%ebx), %%eax \n"
|
|
"sbbl %%edx, %%eax \n"
|
|
"movl %%eax, (%%ebx) \n"
|
|
|
|
"jnc 2f \n"
|
|
|
|
"movl $0, %%edx \n"
|
|
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"2: \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"adcl %%eax,%%eax \n"
|
|
|
|
"pop %%edx \n"
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=a" (c)
|
|
: "c" (b), "d" (index), "b" (p1), "S" (value)
|
|
: "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*!
|
|
this method adds one to the existing value
|
|
*/
|
|
uint AddOne()
|
|
{
|
|
return AddInt(1);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method subtracts one from the existing value
|
|
*/
|
|
uint SubOne()
|
|
{
|
|
return SubInt(1);
|
|
}
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
|
|
/*!
|
|
this method moving once all bits into the left side
|
|
return value <- this <- C
|
|
|
|
the lowest bit will hold value of 'c' and
|
|
function returns the highest bit
|
|
*/
|
|
uint Rcl(uint c=0)
|
|
{
|
|
register sint b = value_size;
|
|
register uint * p1 = table;
|
|
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
|
|
mov ecx,[b]
|
|
mov ebx,[p1]
|
|
|
|
mov eax,0
|
|
sub eax,[c]
|
|
|
|
p:
|
|
rcl dword ptr[ebx],1
|
|
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
inc ebx
|
|
|
|
loop p
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
|
|
"movl $0,%%eax \n"
|
|
"subl %%edx,%%eax \n"
|
|
|
|
"1: \n"
|
|
"rcll $1,(%%ebx) \n"
|
|
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
"inc %%ebx \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"movl $0, %%edx \n"
|
|
"adcl %%edx,%%edx \n"
|
|
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=d" (c)
|
|
: "0" (c), "c" (b), "b" (p1)
|
|
: "%eax", "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method moving once all bits into the right side
|
|
C -> *this -> return value
|
|
|
|
the highest bit will be held value of 'c' and
|
|
function returns the lowest bit
|
|
*/
|
|
uint Rcr(uint c=0)
|
|
{
|
|
register sint b = value_size;
|
|
register uint * p1 = table;
|
|
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
push ebx
|
|
push ecx
|
|
|
|
mov ebx,[p1]
|
|
mov ecx,[b]
|
|
|
|
lea ebx,[ebx+4*ecx]
|
|
|
|
mov eax,0
|
|
sub eax,[c]
|
|
|
|
p:
|
|
dec ebx
|
|
dec ebx
|
|
dec ebx
|
|
dec ebx
|
|
|
|
rcr dword ptr [ebx],1
|
|
|
|
loop p
|
|
|
|
mov eax,0
|
|
adc eax,eax
|
|
mov [c],eax
|
|
|
|
pop ecx
|
|
pop ebx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"push %%ebx \n"
|
|
"push %%ecx \n"
|
|
|
|
"leal (%%ebx,%%ecx,4),%%ebx \n"
|
|
|
|
"movl $0, %%eax \n"
|
|
"subl %%edx, %%eax \n"
|
|
|
|
"1: \n"
|
|
"dec %%ebx \n"
|
|
"dec %%ebx \n"
|
|
"dec %%ebx \n"
|
|
"dec %%ebx \n"
|
|
|
|
"rcrl $1,(%%ebx) \n"
|
|
|
|
"loop 1b \n"
|
|
|
|
"movl $0, %%edx \n"
|
|
"adcl %%edx,%%edx \n"
|
|
|
|
"pop %%ecx \n"
|
|
"pop %%ebx \n"
|
|
|
|
: "=d" (c)
|
|
: "0" (c), "c" (b), "b" (p1)
|
|
: "%eax", "cc", "memory" );
|
|
|
|
#endif
|
|
|
|
|
|
return c;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
this method moving all bits into the left side 'bits' times
|
|
return value <- this <- C
|
|
|
|
bits is from a range of <0, man * TTMATH_BITS_PER_UINT>
|
|
or it can be even bigger then all bits will be set to 'c'
|
|
|
|
the value c will be set into the lowest bits
|
|
and the method returns state of the last moved bit
|
|
*/
|
|
uint Rcl(uint bits, uint c)
|
|
{
|
|
sint first;
|
|
sint second;
|
|
uint last_c = 0;
|
|
|
|
if( bits > value_size*TTMATH_BITS_PER_UINT )
|
|
bits = value_size*TTMATH_BITS_PER_UINT;
|
|
|
|
sint all_words = sint(bits) / sint(TTMATH_BITS_PER_UINT);
|
|
|
|
if( all_words > 0 )
|
|
{
|
|
// copying the first part of the value
|
|
for(first = value_size-1, second=first-all_words ; second>=0 ; --first, --second)
|
|
{
|
|
last_c = table[first] & 1;
|
|
table[first] = table[second];
|
|
}
|
|
|
|
// sets the rest bits of value into 'c'
|
|
uint mask = (c!=0)? TTMATH_UINT_MAX_VALUE : 0;
|
|
for( ; first>=0 ; --first )
|
|
table[first] = mask;
|
|
}
|
|
|
|
sint rest_bits = sint(bits) % sint(TTMATH_BITS_PER_UINT);
|
|
for( ; rest_bits > 0 ; --rest_bits )
|
|
last_c = Rcl(c);
|
|
|
|
return last_c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method moving all bits into the right side 'bits' times
|
|
c -> this -> return value
|
|
|
|
bits is from a range of <0, man * TTMATH_BITS_PER_UINT>
|
|
or it can be even bigger then all bits will be set to 'c'
|
|
|
|
the value c will be set into the highest bits
|
|
and the method returns state of the last moved bit
|
|
*/
|
|
uint Rcr(uint bits, uint c)
|
|
{
|
|
sint first;
|
|
sint second;
|
|
sint last_c = 0;
|
|
|
|
if( bits > value_size*TTMATH_BITS_PER_UINT )
|
|
bits = value_size*TTMATH_BITS_PER_UINT;
|
|
|
|
sint all_words = sint(bits) / sint(TTMATH_BITS_PER_UINT);
|
|
|
|
if( all_words > 0 )
|
|
{
|
|
// copying the first part of the value
|
|
for(first=0, second=all_words ; second<sint(value_size) ; ++first, ++second)
|
|
{
|
|
last_c = table[first] & TTMATH_UINT_HIGHEST_BIT;
|
|
table[first] = table[second];
|
|
}
|
|
|
|
if( last_c )
|
|
last_c = 1;
|
|
|
|
// sets the rest bits of value into 'c'
|
|
uint mask = (c!=0)? TTMATH_UINT_MAX_VALUE : 0;
|
|
for( ; first<sint(value_size) ; ++first )
|
|
table[first] = mask;
|
|
}
|
|
|
|
sint rest_bits = sint(bits) % sint(TTMATH_BITS_PER_UINT);
|
|
for( ; rest_bits > 0 ; --rest_bits )
|
|
last_c = Rcr(c);
|
|
|
|
return last_c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method moves all bits into the left side
|
|
(it returns value how many bits have been moved)
|
|
*/
|
|
uint CompensationToLeft()
|
|
{
|
|
uint moving = 0;
|
|
|
|
// a - index a last word which is different from zero
|
|
sint a;
|
|
for(a=value_size-1 ; a>=0 && table[a]==0 ; --a);
|
|
|
|
if( a < 0 )
|
|
{
|
|
// there's a value zero
|
|
return moving;
|
|
}
|
|
|
|
if( a != value_size-1 )
|
|
{
|
|
moving += ( value_size-1 - a ) * TTMATH_BITS_PER_UINT;
|
|
|
|
// moving all words
|
|
sint i;
|
|
for(i=value_size-1 ; a>=0 ; --i, --a)
|
|
table[i] = table[a];
|
|
|
|
// setting the rest word to zero
|
|
for(; i>=0 ; --i)
|
|
table[i] = 0;
|
|
}
|
|
|
|
// moving the rest bits (max TTMATH_BITS_PER_UINT -- only one word)
|
|
while( !IsTheHighestBitSet() )
|
|
{
|
|
Rcl();
|
|
++moving;
|
|
}
|
|
|
|
return moving;
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
/*
|
|
this method returns the number of the highest set bit in one 32-bit word
|
|
if the 'x' is zero this method returns '-1'
|
|
*/
|
|
static sint FindLeadingBitInWord(uint x)
|
|
{
|
|
register sint result;
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
|
|
bsr eax, x
|
|
jnz found
|
|
mov eax, -1
|
|
found:
|
|
mov result, eax
|
|
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"bsrl %1, %0 \n"
|
|
"jnz 1f \n"
|
|
"movl $-1, %0 \n"
|
|
"1: \n"
|
|
|
|
: "=R" (result)
|
|
: "R" (x)
|
|
: "cc" );
|
|
|
|
#endif
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
this method looks for the highest set bit
|
|
|
|
result:
|
|
if 'this' is not zero:
|
|
return value - true
|
|
'table_id' - the index of a word <0..value_size-1>
|
|
'index' - the index of this set bit in the word <0..31>
|
|
|
|
if 'this' is zero:
|
|
return value - false
|
|
both 'table_id' and 'index' are zero
|
|
*/
|
|
bool FindLeadingBit(uint & table_id, uint & index) const
|
|
{
|
|
for(table_id=value_size-1 ; table_id!=0 && table[table_id]==0 ; --table_id);
|
|
|
|
if( table_id==0 && table[table_id]==0 )
|
|
{
|
|
// is zero
|
|
index = 0;
|
|
|
|
return false;
|
|
}
|
|
|
|
// table[table_id] != 0
|
|
index = FindLeadingBitInWord( table[table_id] );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
/*!
|
|
this method sets a special bit in the 'value'
|
|
and returns the result
|
|
|
|
bit is from <0,31>
|
|
|
|
e.g.
|
|
SetBitInWord(0,0) = 1
|
|
SetBitInWord(0,2) = 4
|
|
SetBitInWord(10, 8) = 266
|
|
*/
|
|
static uint SetBitInWord(uint value, uint bit)
|
|
{
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push ebx
|
|
push eax
|
|
mov eax, value
|
|
mov ebx, bit
|
|
bts eax, ebx
|
|
mov value, eax
|
|
pop eax
|
|
pop ebx
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
__asm__ __volatile__(
|
|
|
|
"btsl %%ebx,%%eax \n"
|
|
|
|
: "=a" (value)
|
|
: "0" (value), "b" (bit)
|
|
: "cc" );
|
|
|
|
#endif
|
|
|
|
return value;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*!
|
|
it sets the bit bit_index
|
|
|
|
bit_index bigger or equal zero
|
|
*/
|
|
void SetBit(uint bit_index)
|
|
{
|
|
uint index = bit_index / TTMATH_BITS_PER_UINT;
|
|
if( index >= value_size )
|
|
return;
|
|
|
|
bit_index %= TTMATH_BITS_PER_UINT;
|
|
|
|
table[index] = SetBitInWord(table[index], bit_index);
|
|
}
|
|
|
|
|
|
/*!
|
|
*
|
|
* Multiplication
|
|
*
|
|
*
|
|
*/
|
|
|
|
public:
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
|
|
/*!
|
|
multiplication: result2:result1 = a * b
|
|
result2 - higher word
|
|
result1 - lower word of the result
|
|
|
|
this method never returns a carry
|
|
|
|
it is an auxiliary method for version two of the multiplication algorithm
|
|
*/
|
|
static void MulTwoWords(uint a, uint b, uint * result2, uint * result1)
|
|
{
|
|
/*
|
|
we must use these temporary variables in order to inform the compilator
|
|
that value pointed with result1 and result2 has changed
|
|
|
|
this has no effect in visual studio but it's usefull when
|
|
using gcc and options like -O
|
|
*/
|
|
register uint result1_;
|
|
register uint result2_;
|
|
|
|
#ifndef __GNUC__
|
|
|
|
__asm
|
|
{
|
|
push eax
|
|
push edx
|
|
|
|
mov eax, [a]
|
|
mul dword ptr [b]
|
|
|
|
mov [result2_], edx
|
|
mov [result1_], eax
|
|
|
|
pop edx
|
|
pop eax
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"mull %%edx \n"
|
|
|
|
: "=a" (result1_), "=d" (result2_)
|
|
: "0" (a), "1" (b)
|
|
: "cc" );
|
|
|
|
#endif
|
|
|
|
|
|
*result1 = result1_;
|
|
*result2 = result2_;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
multiplication: this = this * ss2
|
|
|
|
it returns a carry if it has been
|
|
*/
|
|
uint MulInt(uint ss2)
|
|
{
|
|
uint r2,r1;
|
|
|
|
UInt<value_size> u( *this );
|
|
SetZero();
|
|
|
|
for(uint x1=0 ; x1<value_size ; ++x1)
|
|
{
|
|
MulTwoWords(u.table[x1], ss2, &r2, &r1 );
|
|
|
|
|
|
if( x1 <= value_size - 2 )
|
|
{
|
|
if( AddTwoInts(r2,r1,x1) )
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
// last iteration:
|
|
// x1 = value_size - 1;
|
|
|
|
if( r2 )
|
|
return 1;
|
|
|
|
if( AddInt(r1, x1) )
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
the multiplication 'this' = 'this' * ss2
|
|
*/
|
|
uint Mul(const UInt<value_size> & ss2, uint algorithm = 2)
|
|
{
|
|
switch( algorithm )
|
|
{
|
|
case 1:
|
|
return Mul1(ss2);
|
|
|
|
case 2:
|
|
default:
|
|
return Mul2(ss2);
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
the multiplication 'result' = 'this' * ss2
|
|
|
|
since the 'result' is twice bigger than 'this' and 'ss2'
|
|
this method never returns a carry
|
|
*/
|
|
void MulBig(const UInt<value_size> & ss2,
|
|
UInt<value_size*2> & result,
|
|
uint algorithm = 2)
|
|
{
|
|
switch( algorithm )
|
|
{
|
|
case 1:
|
|
return Mul1Big(ss2, result);
|
|
|
|
case 2:
|
|
default:
|
|
return Mul2Big(ss2, result);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
the first version of the multiplication algorithm
|
|
*/
|
|
|
|
/*!
|
|
multiplication: this = this * ss2
|
|
|
|
it returns carry if it has been
|
|
*/
|
|
uint Mul1(const UInt<value_size> & ss2)
|
|
{
|
|
TTMATH_REFERENCE_ASSERT( ss2 )
|
|
|
|
UInt<value_size> ss1( *this );
|
|
SetZero();
|
|
|
|
for(uint i=0; i < value_size*TTMATH_BITS_PER_UINT ; ++i)
|
|
{
|
|
if( Add(*this) )
|
|
return 1;
|
|
|
|
if( ss1.Rcl() )
|
|
if( Add(ss2) )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
multiplication: result = this * ss2
|
|
|
|
result is twice bigger than 'this' and 'ss2'
|
|
this method never returns carry
|
|
*/
|
|
void Mul1Big(const UInt<value_size> & ss2_, UInt<value_size*2> & result)
|
|
{
|
|
UInt<value_size*2> ss2;
|
|
uint i;
|
|
|
|
// copying *this into result and ss2_ into ss2
|
|
for(i=0 ; i<value_size ; ++i)
|
|
{
|
|
result.table[i] = table[i];
|
|
ss2.table[i] = ss2_.table[i];
|
|
}
|
|
|
|
// cleaning the highest bytes in result and ss2
|
|
for( ; i < value_size*2 ; ++i)
|
|
{
|
|
result.table[i] = 0;
|
|
ss2.table[i] = 0;
|
|
}
|
|
|
|
// multiply
|
|
// (there will not be a carry)
|
|
result.Mul1( ss2 );
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
the second version of the multiplication algorithm
|
|
|
|
this algorithm is similar to the 'schoolbook method' which is done by hand
|
|
*/
|
|
|
|
/*!
|
|
multiplication: this = this * ss2
|
|
|
|
it returns carry if it has been
|
|
*/
|
|
uint Mul2(const UInt<value_size> & ss2)
|
|
{
|
|
UInt<value_size*2> result;
|
|
uint i;
|
|
|
|
Mul2Big(ss2, result);
|
|
|
|
// copying result
|
|
for(i=0 ; i<value_size ; ++i)
|
|
table[i] = result.table[i];
|
|
|
|
// testing carry
|
|
for( ; i<value_size*2 ; ++i)
|
|
if( result.table[i] != 0 )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
multiplication: result = this * ss2
|
|
|
|
result is twice bigger than this and ss2
|
|
this method never returns carry
|
|
*/
|
|
void Mul2Big(const UInt<value_size> & ss2, UInt<value_size*2> & result)
|
|
{
|
|
uint r2,r1;
|
|
uint x1size=value_size, x2size=value_size;
|
|
uint x1start=0, x2start=0;
|
|
|
|
result.SetZero();
|
|
|
|
if( value_size > 2 )
|
|
{
|
|
// if the value_size is smaller than or equal to 2
|
|
// there is no sense to set x1size (and others) to another values
|
|
|
|
for(x1size=value_size ; x1size>0 && table[x1size-1]==0 ; --x1size);
|
|
for(x2size=value_size ; x2size>0 && ss2.table[x2size-1]==0 ; --x2size);
|
|
|
|
if( x1size==0 || x2size==0 )
|
|
return;
|
|
|
|
for(x1start=0 ; x1start<x1size && table[x1start]==0 ; ++x1start);
|
|
for(x2start=0 ; x2start<x2size && ss2.table[x2start]==0 ; ++x2start);
|
|
}
|
|
|
|
for(uint x1=x1start ; x1<x1size ; ++x1)
|
|
{
|
|
for(uint x2=x2start ; x2<x2size ; ++x2)
|
|
{
|
|
MulTwoWords(table[x1], ss2.table[x2], &r2, &r1);
|
|
result.AddTwoInts(r2,r1,x2+x1);
|
|
// here will never be a carry
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* Division
|
|
*
|
|
*
|
|
*/
|
|
|
|
public:
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
|
|
/*!
|
|
this method calculates 64bits word a:b / 32bits c (a higher, b lower word)
|
|
r = a:b / c and rest - remainder
|
|
|
|
*
|
|
* WARNING:
|
|
* if r (one word) is too small for the result or c is equal zero
|
|
* there'll be a hardware interruption (0)
|
|
* and probably the end of your program
|
|
*
|
|
*/
|
|
static void DivTwoWords(uint a, uint b, uint c, uint * r, uint * rest)
|
|
{
|
|
register uint r_;
|
|
register uint rest_;
|
|
/*
|
|
these variables have similar meaning like those in
|
|
the multiplication algorithm MulTwoWords
|
|
*/
|
|
|
|
#ifndef __GNUC__
|
|
__asm
|
|
{
|
|
push eax
|
|
push edx
|
|
|
|
mov edx, [a]
|
|
mov eax, [b]
|
|
div dword ptr [c]
|
|
|
|
mov [r_], eax
|
|
mov [rest_], edx
|
|
|
|
pop edx
|
|
pop eax
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __GNUC__
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"divl %%ecx \n"
|
|
|
|
: "=a" (r_), "=d" (rest_)
|
|
: "d" (a), "a" (b), "c" (c)
|
|
: "cc" );
|
|
|
|
#endif
|
|
|
|
|
|
*r = r_;
|
|
*rest = rest_;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*!
|
|
division by one unsigned word
|
|
*/
|
|
uint DivInt(uint divisor, uint * remainder = 0)
|
|
{
|
|
if( divisor == 1 )
|
|
{
|
|
SetZero();
|
|
|
|
if( remainder )
|
|
*remainder = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
UInt<value_size> dividend(*this);
|
|
SetZero();
|
|
|
|
sint i; // i must be with a sign
|
|
uint r = 0;
|
|
|
|
// we're looking for the last word in ss1
|
|
for(i=value_size-1 ; i>0 && dividend.table[i]==0 ; --i);
|
|
|
|
for( ; i>=0 ; --i)
|
|
DivTwoWords(r, dividend.table[i], divisor, &table[i], &r);
|
|
|
|
if( remainder )
|
|
*remainder = r;
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint DivInt(uint divisor, uint & remainder)
|
|
{
|
|
return DivInt(divisor, &remainder);
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
division this = this / ss2
|
|
|
|
return values:
|
|
0 - ok
|
|
1 - division by zero
|
|
'this' will be the quotient
|
|
'remainder' - remainder
|
|
*/
|
|
uint Div( const UInt<value_size> & divisor,
|
|
UInt<value_size> * remainder = 0,
|
|
uint algorithm = 3)
|
|
{
|
|
switch( algorithm )
|
|
{
|
|
case 1:
|
|
return Div1(divisor, remainder);
|
|
|
|
case 2:
|
|
return Div2(divisor, remainder);
|
|
|
|
case 3:
|
|
default:
|
|
return Div3(divisor, remainder);
|
|
}
|
|
}
|
|
|
|
uint Div(const UInt<value_size> & divisor, UInt<value_size> & remainder, uint algorithm = 3)
|
|
{
|
|
return Div(divisor, &remainder, algorithm);
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
/*!
|
|
return values:
|
|
0 - none has to be done
|
|
1 - division by zero
|
|
2 - division should be made
|
|
*/
|
|
uint Div_StandardTest( const UInt<value_size> & v,
|
|
uint & m, uint & n,
|
|
UInt<value_size> * remainder = 0)
|
|
{
|
|
switch( Div_CalculatingSize(v, m, n) )
|
|
{
|
|
case 4: // 'this' is equal v
|
|
if( remainder )
|
|
remainder->SetZero();
|
|
|
|
SetOne();
|
|
return 0;
|
|
|
|
case 3: // 'this' is smaller than v
|
|
if( remainder )
|
|
*remainder = *this;
|
|
|
|
SetZero();
|
|
return 0;
|
|
|
|
case 2: // 'this' is zero
|
|
if( remainder )
|
|
remainder->SetZero();
|
|
|
|
SetZero();
|
|
return 0;
|
|
|
|
case 1: // v is zero
|
|
return 1;
|
|
}
|
|
|
|
return 2;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
return values:
|
|
0 - ok
|
|
'm' - is the index (from 0) of last non-zero word in table ('this')
|
|
'n' - is the index (from 0) of last non-zero word in v.table
|
|
1 - v is zero
|
|
2 - 'this' is zero
|
|
3 - 'this' is smaller than v
|
|
4 - 'this' is equal v
|
|
|
|
if the return value is different than zero the 'm' and 'n' are undefined
|
|
*/
|
|
uint Div_CalculatingSize(const UInt<value_size> & v, uint & m, uint & n)
|
|
{
|
|
for(n = value_size-1 ; n!=0 && v.table[n]==0 ; --n);
|
|
|
|
if( n==0 && v.table[n]==0 )
|
|
return 1;
|
|
|
|
for(m = value_size-1 ; m!=0 && table[m]==0 ; --m);
|
|
|
|
if( m==0 && table[m]==0 )
|
|
return 2;
|
|
|
|
if( m < n )
|
|
return 3;
|
|
else
|
|
if( m == n )
|
|
{
|
|
uint i;
|
|
for(i = n ; i!=0 && table[i]==v.table[i] ; --i);
|
|
|
|
if( table[i] < v.table[i] )
|
|
return 3;
|
|
else
|
|
if (table[i] == v.table[i] )
|
|
return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/*!
|
|
the first division's algorithm
|
|
radix 2
|
|
*/
|
|
uint Div1(const UInt<value_size> & divisor, UInt<value_size> * remainder = 0)
|
|
{
|
|
uint m,n, test;
|
|
|
|
test = Div_StandardTest(divisor, m, n, remainder);
|
|
if( test < 2 )
|
|
return test;
|
|
|
|
if( !remainder )
|
|
{
|
|
UInt<value_size> rem;
|
|
|
|
return Div1_Calculate(divisor, rem);
|
|
}
|
|
|
|
return Div1_Calculate(divisor, *remainder);
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
|
|
uint Div1_Calculate(const UInt<value_size> & divisor, UInt<value_size> & rest)
|
|
{
|
|
TTMATH_REFERENCE_ASSERT( divisor )
|
|
|
|
sint loop;
|
|
sint c;
|
|
|
|
rest.SetZero();
|
|
loop = value_size * TTMATH_BITS_PER_UINT;
|
|
c = 0;
|
|
|
|
|
|
div_a:
|
|
c = Rcl(c);
|
|
c = rest.Add(rest,c);
|
|
c = rest.Sub(divisor,c);
|
|
|
|
c = !c;
|
|
|
|
if(!c)
|
|
goto div_d;
|
|
|
|
|
|
div_b:
|
|
--loop;
|
|
if(loop)
|
|
goto div_a;
|
|
|
|
c = Rcl(c);
|
|
return 0;
|
|
|
|
|
|
div_c:
|
|
c = Rcl(c);
|
|
c = rest.Add(rest,c);
|
|
c = rest.Add(divisor);
|
|
|
|
if(c)
|
|
goto div_b;
|
|
|
|
|
|
div_d:
|
|
--loop;
|
|
if(loop)
|
|
goto div_c;
|
|
|
|
c = Rcl(c);
|
|
c = rest.Add(divisor);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
|
|
/*!
|
|
the second division algorithm
|
|
|
|
return values:
|
|
0 - ok
|
|
1 - division by zero
|
|
*/
|
|
uint Div2(const UInt<value_size> & divisor, UInt<value_size> * remainder = 0)
|
|
{
|
|
TTMATH_REFERENCE_ASSERT( divisor )
|
|
|
|
uint bits_diff;
|
|
uint status = Div2_Calculate(divisor, remainder, bits_diff);
|
|
if( status < 2 )
|
|
return status;
|
|
|
|
if( CmpBiggerEqual(divisor) )
|
|
{
|
|
Div2(divisor, remainder);
|
|
SetBit(bits_diff);
|
|
}
|
|
else
|
|
{
|
|
if( remainder )
|
|
*remainder = *this;
|
|
|
|
SetZero();
|
|
SetBit(bits_diff);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
uint Div2(const UInt<value_size> & divisor, UInt<value_size> & remainder)
|
|
{
|
|
return Div2(divisor, &remainder);
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
/*!
|
|
return values:
|
|
0 - we've calculated the division
|
|
1 - division by zero
|
|
2 - we have to still calculate
|
|
|
|
*/
|
|
uint Div2_Calculate(const UInt<value_size> & divisor, UInt<value_size> * remainder,
|
|
uint & bits_diff)
|
|
{
|
|
uint table_id, index;
|
|
uint divisor_table_id, divisor_index;
|
|
|
|
uint status = Div2_FindLeadingBitsAndCheck( divisor, remainder,
|
|
table_id, index,
|
|
divisor_table_id, divisor_index);
|
|
|
|
if( status < 2 )
|
|
return status;
|
|
|
|
// here we know that 'this' is greater than divisor
|
|
// then 'index' is greater or equal 'divisor_index'
|
|
bits_diff = index - divisor_index;
|
|
|
|
UInt<value_size> divisor_copy(divisor);
|
|
divisor_copy.Rcl(bits_diff, 0);
|
|
|
|
if( CmpSmaller(divisor_copy, table_id) )
|
|
{
|
|
divisor_copy.Rcr();
|
|
--bits_diff;
|
|
}
|
|
|
|
Sub(divisor_copy, 0);
|
|
|
|
return 2;
|
|
}
|
|
|
|
|
|
/*!
|
|
return values:
|
|
0 - we've calculated the division
|
|
1 - division by zero
|
|
2 - we have to still calculate
|
|
*/
|
|
uint Div2_FindLeadingBitsAndCheck( const UInt<value_size> & divisor,
|
|
UInt<value_size> * remainder,
|
|
uint & table_id, uint & index,
|
|
uint & divisor_table_id, uint & divisor_index)
|
|
{
|
|
if( !divisor.FindLeadingBit(divisor_table_id, divisor_index) )
|
|
// division by zero
|
|
return 1;
|
|
|
|
if( !FindLeadingBit(table_id, index) )
|
|
{
|
|
// zero is divided by something
|
|
|
|
SetZero();
|
|
|
|
if( remainder )
|
|
remainder->SetZero();
|
|
|
|
return 0;
|
|
}
|
|
|
|
divisor_index += divisor_table_id * TTMATH_BITS_PER_UINT;
|
|
index += table_id * TTMATH_BITS_PER_UINT;
|
|
|
|
if( divisor_table_id == 0 )
|
|
{
|
|
// dividor has only one 32-bit word
|
|
|
|
uint r;
|
|
DivInt(divisor.table[0], &r);
|
|
|
|
if( remainder )
|
|
{
|
|
remainder->SetZero();
|
|
remainder->table[0] = r;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
if( Div2_DivisorGreaterOrEqual( divisor, remainder,
|
|
table_id, index,
|
|
divisor_table_id, divisor_index) )
|
|
return 0;
|
|
|
|
|
|
return 2;
|
|
}
|
|
|
|
|
|
/*!
|
|
return values:
|
|
true if divisor is equal or greater than 'this'
|
|
*/
|
|
bool Div2_DivisorGreaterOrEqual( const UInt<value_size> & divisor,
|
|
UInt<value_size> * remainder,
|
|
uint table_id, uint index,
|
|
uint divisor_table_id, uint divisor_index )
|
|
{
|
|
if( divisor_index > index )
|
|
{
|
|
// divisor is greater than this
|
|
|
|
if( remainder )
|
|
*remainder = *this;
|
|
|
|
SetZero();
|
|
|
|
return true;
|
|
}
|
|
|
|
if( divisor_index == index )
|
|
{
|
|
// table_id == divisor_table_id as well
|
|
|
|
uint i;
|
|
for(i = table_id ; i!=0 && table[i]==divisor.table[i] ; --i);
|
|
|
|
if( table[i] < divisor.table[i] )
|
|
{
|
|
// divisor is greater than 'this'
|
|
|
|
if( remainder )
|
|
*remainder = *this;
|
|
|
|
SetZero();
|
|
|
|
return true;
|
|
}
|
|
else
|
|
if( table[i] == divisor.table[i] )
|
|
{
|
|
// divisor is equal 'this'
|
|
|
|
if( remainder )
|
|
remainder->SetZero();
|
|
|
|
SetOne();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/*!
|
|
the third division algorithm
|
|
|
|
this algorithm is described in the following book:
|
|
"The art of computer programming 2" (4.3.1 page 272)
|
|
Donald E. Knuth
|
|
*/
|
|
uint Div3(const UInt<value_size> & v, UInt<value_size> * remainder = 0)
|
|
{
|
|
TTMATH_REFERENCE_ASSERT( v )
|
|
|
|
uint m,n, test;
|
|
|
|
test = Div_StandardTest(v, m, n, remainder);
|
|
if( test < 2 )
|
|
return test;
|
|
|
|
if( n == 0 )
|
|
{
|
|
uint r;
|
|
DivInt( v.table[0], &r );
|
|
|
|
if( remainder )
|
|
{
|
|
remainder->SetZero();
|
|
remainder->table[0] = r;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// we can only use the third division algorithm when
|
|
// the divisor is greater or equal 2^32 (has more than one 32-bit word)
|
|
++m;
|
|
++n;
|
|
m = m - n;
|
|
Div3_Division(v, remainder, m, n);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
void Div3_Division(UInt<value_size> v, UInt<value_size> * remainder, uint m, uint n)
|
|
{
|
|
TTMATH_ASSERT( n>=2 )
|
|
|
|
UInt<value_size+1> uu, vv;
|
|
UInt<value_size> q;
|
|
uint d, u_value_size, u0, u1, u2, v1, v0, j=m;
|
|
|
|
u_value_size = Div3_Normalize(v, n, d);
|
|
|
|
if( j+n == value_size )
|
|
u2 = u_value_size;
|
|
else
|
|
u2 = table[j+n];
|
|
|
|
Div3_MakeBiggerV(v, vv);
|
|
|
|
for(uint i = j+1 ; i<value_size ; ++i)
|
|
q.table[i] = 0;
|
|
|
|
while( true )
|
|
{
|
|
u1 = table[j+n-1];
|
|
u0 = table[j+n-2];
|
|
v1 = v.table[n-1];
|
|
v0 = v.table[n-2];
|
|
|
|
uint qp = Div3_Calculate(u2,u1,u0, v1,v0);
|
|
|
|
Div3_MakeNewU(uu, j, n, u2);
|
|
Div3_MultiplySubtract(uu, vv, qp);
|
|
Div3_CopyNewU(uu, j, n);
|
|
|
|
q.table[j] = qp;
|
|
|
|
// the next loop
|
|
if( j-- == 0 )
|
|
break;
|
|
|
|
u2 = table[j+n];
|
|
}
|
|
|
|
if( remainder )
|
|
Div3_Unnormalize(remainder, n, d);
|
|
|
|
*this = q;
|
|
}
|
|
|
|
|
|
void Div3_MakeNewU(UInt<value_size+1> & uu, uint j, uint n, uint u_max)
|
|
{
|
|
uint i;
|
|
|
|
for(i=0 ; i<n ; ++i, ++j)
|
|
uu.table[i] = table[j];
|
|
|
|
// 'n' is from <1..value_size> so and 'i' is from <0..value_size>
|
|
// then table[i] is always correct (look at the declaration of 'uu')
|
|
uu.table[i] = u_max;
|
|
|
|
for( ++i ; i<value_size+1 ; ++i)
|
|
uu.table[i] = 0;
|
|
}
|
|
|
|
|
|
void Div3_CopyNewU(const UInt<value_size+1> & uu, uint j, uint n)
|
|
{
|
|
uint i;
|
|
|
|
for(i=0 ; i<n ; ++i)
|
|
table[i+j] = uu.table[i];
|
|
|
|
if( i+j < value_size )
|
|
table[i+j] = uu.table[i];
|
|
}
|
|
|
|
|
|
/*!
|
|
we're making the new 'vv'
|
|
the value is actually the same but the 'table' is bigger (value_size+1)
|
|
*/
|
|
void Div3_MakeBiggerV(const UInt<value_size> & v, UInt<value_size+1> & vv)
|
|
{
|
|
for(uint i=0 ; i<value_size ; ++i)
|
|
vv.table[i] = v.table[i];
|
|
|
|
vv.table[value_size] = 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
we're moving all bits from 'v' into the left side of the n-1 word
|
|
(the highest bit at v.table[n-1] will be equal one,
|
|
the bits from 'this' we're moving the same times as 'v')
|
|
|
|
return values:
|
|
d - how many times we've moved
|
|
return - the next-left value from 'this' (that after table[value_size-1])
|
|
*/
|
|
uint Div3_Normalize(UInt<value_size> & v, uint n, uint & d)
|
|
{
|
|
uint c = 0;
|
|
|
|
for( d = 0 ; (v.table[n-1] & TTMATH_UINT_HIGHEST_BIT) == 0 ; ++d )
|
|
{
|
|
// we can move the bits only to the 'n-1' index but at the moment
|
|
// we don't have such method
|
|
// maybe it's time to write it now?
|
|
v.Rcl(0);
|
|
|
|
c <<= 1;
|
|
|
|
if( Rcl(0) )
|
|
c += 1;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
void Div3_Unnormalize(UInt<value_size> * remainder, uint n, uint d)
|
|
{
|
|
for(uint i=n ; i<value_size ; ++i)
|
|
table[i] = 0;
|
|
|
|
Rcr(d,0);
|
|
|
|
*remainder = *this;
|
|
}
|
|
|
|
|
|
uint Div3_Calculate(uint u2, uint u1, uint u0, uint v1, uint v0)
|
|
{
|
|
UInt<2> u_temp;
|
|
uint rp;
|
|
bool next_test;
|
|
|
|
u_temp.table[1] = u2;
|
|
u_temp.table[0] = u1;
|
|
u_temp.DivInt(v1, &rp);
|
|
|
|
TTMATH_ASSERT( u_temp.table[1]==0 || u_temp.table[1]==1 )
|
|
|
|
do
|
|
{
|
|
bool decrease = false;
|
|
|
|
if( u_temp.table[1] == 1 )
|
|
decrease = true;
|
|
else
|
|
{
|
|
UInt<2> temp1, temp2;
|
|
|
|
UInt<2>::MulTwoWords(u_temp.table[0], v0, temp1.table+1, temp1.table);
|
|
temp2.table[1] = rp;
|
|
temp2.table[0] = u0;
|
|
|
|
if( temp1 > temp2 )
|
|
decrease = true;
|
|
}
|
|
|
|
next_test = false;
|
|
|
|
if( decrease )
|
|
{
|
|
u_temp.SubOne();
|
|
|
|
rp += v1;
|
|
|
|
if( rp >= v1 ) // it means that there wasn't a carry (r<b from the book)
|
|
next_test = true;
|
|
}
|
|
}
|
|
while( next_test );
|
|
|
|
|
|
return u_temp.table[0];
|
|
}
|
|
|
|
|
|
|
|
void Div3_MultiplySubtract( UInt<value_size+1> & uu,
|
|
const UInt<value_size+1> & vv, uint & qp)
|
|
{
|
|
UInt<value_size+1> vv_temp(vv);
|
|
vv_temp.MulInt(qp);
|
|
|
|
if( uu.Sub(vv_temp) )
|
|
{
|
|
// there was a carry
|
|
|
|
//
|
|
// !!! this part of code was not tested
|
|
//
|
|
|
|
--qp;
|
|
uu.Add(vv);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
/*!
|
|
this method sets n firt bits to value zero
|
|
|
|
For example:
|
|
let n=2 then if there's a value 111 (bin) there'll be '100' (bin)
|
|
*/
|
|
void ClearFirstBits(uint n)
|
|
{
|
|
if( n >= value_size*TTMATH_BITS_PER_UINT )
|
|
{
|
|
SetZero();
|
|
return;
|
|
}
|
|
|
|
uint * p = table;
|
|
|
|
// first we're clearing the whole words
|
|
while( n >= TTMATH_BITS_PER_UINT )
|
|
{
|
|
*p++ = 0;
|
|
n -= TTMATH_BITS_PER_UINT;
|
|
}
|
|
|
|
if( n == 0 )
|
|
return;
|
|
|
|
// and then we're clearing one word which has left
|
|
// mask -- all bits are set to one
|
|
uint mask = TTMATH_UINT_MAX_VALUE;
|
|
|
|
mask = mask << n;
|
|
|
|
(*p) &= mask;
|
|
}
|
|
|
|
|
|
/*!
|
|
it returns true if the highest bit of the value is set
|
|
*/
|
|
bool IsTheHighestBitSet() const
|
|
{
|
|
return (table[value_size-1] & TTMATH_UINT_HIGHEST_BIT) != 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
it returns true if the lowest bit of the value is set
|
|
*/
|
|
bool IsTheLowestBitSet() const
|
|
{
|
|
return (*table & 1) != 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
it returns true if the value is equal zero
|
|
*/
|
|
bool IsZero() const
|
|
{
|
|
for(uint i=0 ; i<value_size ; ++i)
|
|
if(table[i] != 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* convertion method
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
/*!
|
|
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';
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts an UInt<another_size> type to this class
|
|
|
|
this operation has mainly sense if the value from p is
|
|
equal or smaller than that one which is returned from UInt<value_size>::SetMax()
|
|
|
|
it returns a carry if the value 'p' is too big
|
|
*/
|
|
template<uint argument_size>
|
|
uint FromUInt(const UInt<argument_size> & p)
|
|
{
|
|
uint min_size = (value_size < argument_size)? value_size : argument_size;
|
|
uint i;
|
|
|
|
for(i=0 ; i<min_size ; ++i)
|
|
table[i] = p.table[i];
|
|
|
|
|
|
if( value_size > argument_size )
|
|
{
|
|
// 'this' is longer than 'p'
|
|
|
|
for( ; i<value_size ; ++i)
|
|
table[i] = 0;
|
|
}
|
|
else
|
|
{
|
|
for( ; i<argument_size ; ++i)
|
|
if( p.table[i] != 0 )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the uint type to this class
|
|
*/
|
|
void FromUInt(uint value)
|
|
{
|
|
for(uint i=1 ; i<value_size ; ++i)
|
|
table[i] = 0;
|
|
|
|
table[0] = value;
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts an UInt<another_size> type to this class
|
|
|
|
it doesn't return a carry
|
|
*/
|
|
template<uint argument_size>
|
|
UInt<value_size> & operator=(const UInt<argument_size> & p)
|
|
{
|
|
FromUInt(p);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
the assignment operator
|
|
*/
|
|
UInt<value_size> & operator=(const UInt<value_size> & p)
|
|
{
|
|
FromUInt(p);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the uint type to this class
|
|
*/
|
|
UInt<value_size> & operator=(uint i)
|
|
{
|
|
FromUInt(i);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting the uint to this class
|
|
*/
|
|
UInt(uint i)
|
|
{
|
|
FromUInt(i);
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this method converts the sint type to this class
|
|
|
|
we provide operator(sint) and the constructor(sint) in order to allow
|
|
the programmer do that:
|
|
UInt<..> type = 10;
|
|
|
|
this constant 10 has the int type (signed int), if we don't give such
|
|
operators and constructors the compiler will not compile the program,
|
|
because it has to make a conversion and doesn't know into which type
|
|
(the UInt class has operator=(const char*), operator=(uint) etc.)
|
|
*/
|
|
UInt<value_size> & operator=(sint i)
|
|
{
|
|
FromUInt(uint(i));
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting the sint to this class
|
|
|
|
look at the description of UInt::operator=(sint)
|
|
*/
|
|
UInt(sint i)
|
|
{
|
|
FromUInt(uint(i));
|
|
}
|
|
|
|
/*!
|
|
a constructor for converting a string to this class (with the base=10)
|
|
*/
|
|
UInt(const char * s)
|
|
{
|
|
FromString(s);
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting a string to this class (with the base=10)
|
|
*/
|
|
UInt(const std::string & s)
|
|
{
|
|
FromString( s.c_str() );
|
|
}
|
|
|
|
|
|
/*!
|
|
a default constructor
|
|
|
|
we don't clear table etc.
|
|
*/
|
|
UInt()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
a copy constructor
|
|
*/
|
|
UInt(const UInt<value_size> & u)
|
|
{
|
|
FromUInt(u);
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
a template for producting constructors for copying from another types
|
|
*/
|
|
template<uint argument_size>
|
|
UInt(const UInt<argument_size> & u)
|
|
{
|
|
// look that 'size' we still set as 'value_size' and not as u.value_size
|
|
FromUInt(u);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*!
|
|
a destructor
|
|
*/
|
|
~UInt()
|
|
{
|
|
}
|
|
|
|
|
|
/*!
|
|
this method returns the lowest value from table
|
|
|
|
we must be sure when we using this method whether the value
|
|
will hold in an uint type or not (the rest value from the table must be zero)
|
|
*/
|
|
uint ToUInt() const
|
|
{
|
|
return table[0];
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to a string with a base equal 'b'
|
|
*/
|
|
void ToString(std::string & result, uint b = 10) const
|
|
{
|
|
UInt<value_size> temp( *this );
|
|
char character;
|
|
uint rem;
|
|
|
|
result.clear();
|
|
|
|
if( b<2 || b>16 )
|
|
return;
|
|
|
|
do
|
|
{
|
|
temp.DivInt(b, &rem);
|
|
character = DigitToChar( rem );
|
|
result.insert(result.begin(), character);
|
|
}
|
|
while( !temp.IsZero() );
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
this method's ommiting any white characters from the string
|
|
*/
|
|
static void SkipWhiteCharacters(const char * & c)
|
|
{
|
|
while( (*c==' ' ) || (*c=='\t') || (*c==13 ) || (*c=='\n') )
|
|
++c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts a string into its value
|
|
it returns carry=1 if the value will be too big or an incorrect base 'b' is given
|
|
|
|
string is ended with a non-digit value, for example:
|
|
"12" will be translated to 12
|
|
as well as:
|
|
"12foo" will be translated to 12 too
|
|
|
|
existing first white characters will be ommited
|
|
*/
|
|
uint FromString(const char * s, uint b = 10)
|
|
{
|
|
UInt<value_size> base( b );
|
|
UInt<value_size> temp;
|
|
sint z;
|
|
|
|
SetZero();
|
|
temp.SetZero();
|
|
SkipWhiteCharacters(s);
|
|
|
|
if( b<2 || b>16 )
|
|
return 1;
|
|
|
|
for( ; (z=CharToDigit(*s, b)) != -1 ; ++s)
|
|
{
|
|
temp.table[0] = z;
|
|
|
|
if( Mul(base) )
|
|
return 1;
|
|
|
|
if( Add(temp) )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this method converts a string into its value
|
|
|
|
(it returns carry=1 if the value will be too big or an incorrect base 'b' is given)
|
|
*/
|
|
uint FromString(const std::string & s, uint b = 10)
|
|
{
|
|
return FromString( s.c_str(), b );
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this operator converts a string into its value (with base = 10)
|
|
*/
|
|
UInt<value_size> & operator=(const char * s)
|
|
{
|
|
FromString(s);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts a string into its value (with base = 10)
|
|
*/
|
|
UInt<value_size> & operator=(const std::string & s)
|
|
{
|
|
FromString( s.c_str() );
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
*
|
|
* methods for comparing
|
|
*
|
|
*/
|
|
|
|
|
|
bool CmpSmaller(const UInt<value_size> & l, sint index = -1) const
|
|
{
|
|
sint i;
|
|
|
|
if( index==-1 || index>=sint(value_size) )
|
|
i = value_size - 1;
|
|
else
|
|
i = index;
|
|
|
|
|
|
for( ; i>=0 ; --i)
|
|
{
|
|
if( table[i] != l.table[i] )
|
|
return table[i] < l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
bool CmpBigger(const UInt<value_size> & l, sint index = -1) const
|
|
{
|
|
sint i;
|
|
|
|
if( index==-1 || index>=sint(value_size) )
|
|
i = value_size - 1;
|
|
else
|
|
i = index;
|
|
|
|
|
|
for( ; i>=0 ; --i)
|
|
{
|
|
if( table[i] != l.table[i] )
|
|
return table[i] > l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return false;
|
|
}
|
|
|
|
|
|
bool CmpEqual(const UInt<value_size> & l, sint index = -1) const
|
|
{
|
|
sint i;
|
|
|
|
if( index==-1 || index>=sint(value_size) )
|
|
i = value_size - 1;
|
|
else
|
|
i = index;
|
|
|
|
|
|
for( ; i>=0 ; --i)
|
|
if( table[i] != l.table[i] )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CmpSmallerEqual(const UInt<value_size> & l, sint index=-1) const
|
|
{
|
|
sint i;
|
|
|
|
if( index==-1 || index>=sint(value_size) )
|
|
i = value_size - 1;
|
|
else
|
|
i = index;
|
|
|
|
|
|
for( ; i>=0 ; --i)
|
|
{
|
|
if( table[i] != l.table[i] )
|
|
return table[i] < l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return true;
|
|
}
|
|
|
|
bool CmpBiggerEqual(const UInt<value_size> & l, sint index=-1) const
|
|
{
|
|
sint i;
|
|
|
|
if( index==-1 || index>=sint(value_size) )
|
|
i = value_size - 1;
|
|
else
|
|
i = index;
|
|
|
|
|
|
for( ; i>=0 ; --i)
|
|
{
|
|
if( table[i] != l.table[i] )
|
|
return table[i] > l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return true;
|
|
}
|
|
|
|
|
|
//
|
|
|
|
bool operator<(const UInt<value_size> & l) const
|
|
{
|
|
return CmpSmaller(l);
|
|
}
|
|
|
|
|
|
|
|
bool operator>(const UInt<value_size> & l) const
|
|
{
|
|
return CmpBigger(l);
|
|
}
|
|
|
|
|
|
bool operator==(const UInt<value_size> & l) const
|
|
{
|
|
return CmpEqual(l);
|
|
}
|
|
|
|
|
|
|
|
bool operator!=(const UInt<value_size> & l) const
|
|
{
|
|
return !operator==(l);
|
|
}
|
|
|
|
|
|
bool operator<=(const UInt<value_size> & l) const
|
|
{
|
|
return CmpSmallerEqual(l);
|
|
}
|
|
|
|
bool operator>=(const UInt<value_size> & l) const
|
|
{
|
|
return CmpBiggerEqual(l);
|
|
}
|
|
|
|
|
|
/*!
|
|
*
|
|
* standard mathematical operators
|
|
*
|
|
*/
|
|
|
|
UInt<value_size> operator-(const UInt<value_size> & p2) const
|
|
{
|
|
UInt<value_size> temp(*this);
|
|
|
|
temp.Sub(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
UInt<value_size> & operator-=(const UInt<value_size> & p2)
|
|
{
|
|
Sub(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
UInt<value_size> operator+(const UInt<value_size> & p2) const
|
|
{
|
|
UInt<value_size> temp(*this);
|
|
|
|
temp.Add(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
UInt<value_size> & operator+=(const UInt<value_size> & p2)
|
|
{
|
|
Add(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
UInt<value_size> operator*(const UInt<value_size> & p2) const
|
|
{
|
|
UInt<value_size> temp(*this);
|
|
|
|
temp.Mul(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
UInt<value_size> & operator*=(const UInt<value_size> & p2)
|
|
{
|
|
Mul(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
UInt<value_size> operator/(const UInt<value_size> & p2) const
|
|
{
|
|
UInt<value_size> temp(*this);
|
|
|
|
temp.Div(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
UInt<value_size> & operator/=(const UInt<value_size> & p2)
|
|
{
|
|
Div(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
UInt<value_size> operator%(const UInt<value_size> & p2) const
|
|
{
|
|
UInt<value_size> temp(*this);
|
|
UInt<value_size> remainder;
|
|
|
|
temp.Div( p2, remainder );
|
|
|
|
return remainder;
|
|
}
|
|
|
|
|
|
UInt<value_size> & operator%=(const UInt<value_size> & p2)
|
|
{
|
|
UInt<value_size> temp(*this);
|
|
UInt<value_size> remainder;
|
|
|
|
temp.Div( p2, remainder );
|
|
|
|
operator=(remainder);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
Prefix operator e.g ++variable
|
|
*/
|
|
UInt<value_size> & operator++()
|
|
{
|
|
AddOne();
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
Postfix operator e.g variable++
|
|
*/
|
|
UInt<value_size> operator++(int)
|
|
{
|
|
UInt<value_size> temp( *this );
|
|
|
|
AddOne();
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
UInt<value_size> & operator--()
|
|
{
|
|
SubOne();
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
UInt<value_size> operator--(int)
|
|
{
|
|
UInt<value_size> temp( *this );
|
|
|
|
SubOne();
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* input/output operators for standard streams
|
|
*
|
|
* (they are very simple, in the future they should be changed)
|
|
*
|
|
*/
|
|
|
|
friend std::ostream & operator<<(std::ostream & s, const UInt<value_size> & l)
|
|
{
|
|
std::string ss;
|
|
|
|
l.ToString(ss);
|
|
s << ss;
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
|
|
friend std::istream & operator>>(std::istream & s, UInt<value_size> & l)
|
|
{
|
|
std::string ss;
|
|
|
|
// char for operator>>
|
|
unsigned char z;
|
|
|
|
// operator>> omits white characters if they're set for ommiting
|
|
s >> z;
|
|
|
|
// we're reading only digits (base=10)
|
|
while( s.good() && CharToDigit(z, 10)>=0 )
|
|
{
|
|
ss += z;
|
|
z = s.get();
|
|
}
|
|
|
|
// we're leaving the last readed character
|
|
// (it's not belonging to the value)
|
|
s.unget();
|
|
|
|
l.FromString(ss);
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM64
|
|
|
|
// these methods are for 64bit processors and are defined in 'ttmathuint64.h'
|
|
UInt<value_size> & operator=(unsigned int i);
|
|
UInt(unsigned int i);
|
|
UInt<value_size> & operator=(signed int i);
|
|
UInt(signed int i);
|
|
void SetFromTable(const unsigned int * temp_table, uint temp_table_len);
|
|
uint Add(const UInt<value_size> & ss2, uint c=0);
|
|
uint AddInt(uint value, uint index = 0);
|
|
uint AddTwoInts(uint x2, uint x1, uint index);
|
|
uint Sub(const UInt<value_size> & ss2, uint c=0);
|
|
uint SubInt(uint value, uint index = 0);
|
|
uint Rcl(uint c=0);
|
|
uint Rcr(uint c=0);
|
|
static sint FindLeadingBitInWord(uint x);
|
|
static uint SetBitInWord(uint value, uint bit);
|
|
static void MulTwoWords(uint a, uint b, uint * result2, uint * result1);
|
|
static void DivTwoWords(uint a,uint b, uint c, uint * r, uint * rest);
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
} //namespace
|
|
|
|
|
|
#include "ttmathuint64.h"
|
|
|
|
|
|
#endif
|