1924 lines
35 KiB
C++
1924 lines
35 KiB
C++
/*
|
|
* 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-2017, 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 headerfilettmathint
|
|
#define headerfilettmathint
|
|
|
|
/*!
|
|
\file ttmathint.h
|
|
\brief template class Int<uint>
|
|
*/
|
|
|
|
#include "ttmathuint.h"
|
|
|
|
namespace ttmath
|
|
{
|
|
|
|
|
|
/*!
|
|
\brief Int implements a big integer value with 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 Int : public UInt<value_size>
|
|
{
|
|
public:
|
|
|
|
/*!
|
|
this method sets the max value which this class can hold
|
|
(all bits will be one besides the last one)
|
|
*/
|
|
void SetMax()
|
|
{
|
|
UInt<value_size>::SetMax();
|
|
UInt<value_size>::table[value_size-1] = ~ TTMATH_UINT_HIGHEST_BIT;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method sets the min value which this class can hold
|
|
(all bits will be zero besides the last one which is one)
|
|
*/
|
|
void SetMin()
|
|
{
|
|
UInt<value_size>::SetZero();
|
|
UInt<value_size>::table[value_size-1] = TTMATH_UINT_HIGHEST_BIT;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method sets -1 as the value
|
|
(-1 is equal the max value in an unsigned type)
|
|
*/
|
|
void SetSignOne()
|
|
{
|
|
UInt<value_size>::SetMax();
|
|
}
|
|
|
|
|
|
/*!
|
|
we change the sign of the value
|
|
|
|
if it isn't possible to change the sign this method returns 1
|
|
else return 0 and changing the sign
|
|
*/
|
|
uint ChangeSign()
|
|
{
|
|
/*
|
|
if the value is equal that one which has been returned from SetMin
|
|
(only the highest bit is set) that means we can't change sign
|
|
because the value is too big (bigger about one)
|
|
|
|
e.g. when value_size = 1 and value is -2147483648 we can't change it to the
|
|
2147483648 because the max value which can be held is 2147483647
|
|
|
|
we don't change the value and we're using this fact somewhere in some methods
|
|
(if we look on our value without the sign we get the correct value
|
|
eg. -2147483648 in Int<1> will be 2147483648 on the UInt<1> type)
|
|
*/
|
|
if( UInt<value_size>::IsOnlyTheHighestBitSet() )
|
|
return 1;
|
|
|
|
UInt<value_size> temp(*this);
|
|
UInt<value_size>::SetZero();
|
|
UInt<value_size>::Sub(temp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this method sets the sign
|
|
|
|
samples
|
|
- 1 -> -1
|
|
- -2 -> -2
|
|
|
|
from a positive value we make a negative value,
|
|
if the value is negative we do nothing
|
|
*/
|
|
void SetSign()
|
|
{
|
|
if( IsSign() )
|
|
return;
|
|
|
|
ChangeSign();
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this method returns true if there's the sign
|
|
|
|
(the highest bit will be converted to the bool)
|
|
*/
|
|
bool IsSign() const
|
|
{
|
|
return UInt<value_size>::IsTheHighestBitSet();
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
it sets an absolute value
|
|
|
|
it can return carry (1) (look on ChangeSign() for details)
|
|
*/
|
|
uint Abs()
|
|
{
|
|
if( !IsSign() )
|
|
return 0;
|
|
|
|
return ChangeSign();
|
|
}
|
|
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* basic mathematic functions
|
|
*
|
|
*/
|
|
|
|
private:
|
|
|
|
uint CorrectCarryAfterAdding(bool p1_is_sign, bool p2_is_sign)
|
|
{
|
|
if( !p1_is_sign && !p2_is_sign )
|
|
{
|
|
if( UInt<value_size>::IsTheHighestBitSet() )
|
|
return 1;
|
|
}
|
|
|
|
if( p1_is_sign && p2_is_sign )
|
|
{
|
|
if( ! UInt<value_size>::IsTheHighestBitSet() )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/*!
|
|
this method adds two value with a sign and returns a carry
|
|
|
|
we're using methods from the base class because values are stored with U2
|
|
we must only make the carry correction
|
|
|
|
this = p1(=this) + p2
|
|
|
|
when p1>=0 i p2>=0 carry is set when the highest bit of value is set
|
|
when p1<0 i p2<0 carry is set when the highest bit of value is clear
|
|
when p1>=0 i p2<0 carry will never be set
|
|
when p1<0 i p2>=0 carry will never be set
|
|
*/
|
|
uint Add(const Int<value_size> & ss2)
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
bool p2_is_sign = ss2.IsSign();
|
|
|
|
UInt<value_size>::Add(ss2);
|
|
|
|
return CorrectCarryAfterAdding(p1_is_sign, p2_is_sign);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method adds one *unsigned* word (at a specific position)
|
|
and returns a carry (if it was)
|
|
|
|
look at a description in UInt<>::AddInt(...)
|
|
*/
|
|
uint AddInt(uint value, uint index = 0)
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
|
|
UInt<value_size>::AddInt(value, index);
|
|
|
|
return CorrectCarryAfterAdding(p1_is_sign, false);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method adds two *unsigned* words to the existing value
|
|
and these words begin on the 'index' position
|
|
|
|
index should be equal or smaller than value_size-2 (index <= value_size-2)
|
|
x1 - lower word, x2 - higher word
|
|
|
|
look at a description in UInt<>::AddTwoInts(...)
|
|
*/
|
|
uint AddTwoInts(uint x2, uint x1, uint index)
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
|
|
UInt<value_size>::AddTwoInts(x2, x1, index);
|
|
|
|
return CorrectCarryAfterAdding(p1_is_sign, false);
|
|
}
|
|
|
|
private:
|
|
|
|
uint CorrectCarryAfterSubtracting(bool p1_is_sign, bool p2_is_sign)
|
|
{
|
|
if( !p1_is_sign && p2_is_sign )
|
|
{
|
|
if( UInt<value_size>::IsTheHighestBitSet() )
|
|
return 1;
|
|
}
|
|
|
|
if( p1_is_sign && !p2_is_sign )
|
|
{
|
|
if( ! UInt<value_size>::IsTheHighestBitSet() )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public:
|
|
|
|
/*!
|
|
this method subtracts two values with a sign
|
|
|
|
we don't use the previous Add because the method ChangeSign can
|
|
sometimes return carry
|
|
|
|
this = p1(=this) - p2
|
|
|
|
- when p1>=0 i p2>=0 carry will never be set
|
|
- when p1<0 i p2<0 carry will never be set
|
|
- when p1>=0 i p2<0 carry is set when the highest bit of value is set
|
|
- when p1<0 i p2>=0 carry is set when the highest bit of value is clear
|
|
*/
|
|
uint Sub(const Int<value_size> & ss2)
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
bool p2_is_sign = ss2.IsSign();
|
|
|
|
UInt<value_size>::Sub(ss2);
|
|
|
|
return CorrectCarryAfterSubtracting(p1_is_sign, p2_is_sign);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method subtracts one *unsigned* word (at a specific position)
|
|
and returns a carry (if it was)
|
|
*/
|
|
uint SubInt(uint value, uint index = 0)
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
|
|
UInt<value_size>::SubInt(value, index);
|
|
|
|
return CorrectCarryAfterSubtracting(p1_is_sign, false);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method adds one to the value and returns carry
|
|
*/
|
|
uint AddOne()
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
|
|
UInt<value_size>::AddOne();
|
|
|
|
return CorrectCarryAfterAdding(p1_is_sign, false);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method subtracts one from the value and returns carry
|
|
*/
|
|
uint SubOne()
|
|
{
|
|
bool p1_is_sign = IsSign();
|
|
|
|
UInt<value_size>::SubOne();
|
|
|
|
return CorrectCarryAfterSubtracting(p1_is_sign, false);
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
|
|
uint CheckMinCarry(bool ss1_is_sign, bool ss2_is_sign)
|
|
{
|
|
/*
|
|
we have to examine the sign of the result now
|
|
but if the result is with the sign then:
|
|
1. if the signs were the same that means the result is too big
|
|
(the result must be without a sign)
|
|
2. if the signs were different that means if the result
|
|
is different from that one which has been returned from SetMin()
|
|
that is carry (result too big) but if the result is equal SetMin()
|
|
there'll be ok (and the next SetSign will has no effect because
|
|
the value is actually negative -- look at description of that case
|
|
in ChangeSign())
|
|
*/
|
|
if( IsSign() )
|
|
{
|
|
if( ss1_is_sign != ss2_is_sign )
|
|
{
|
|
/*
|
|
there can be one case where signs are different and
|
|
the result will be equal the value from SetMin() (only the highest bit is set)
|
|
(this situation is ok)
|
|
*/
|
|
if( !UInt<value_size>::IsOnlyTheHighestBitSet() )
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
// signs were the same
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
|
|
/*!
|
|
multiplication: this = this * ss2
|
|
|
|
it can return a carry
|
|
*/
|
|
uint MulInt(sint ss2)
|
|
{
|
|
bool ss1_is_sign, ss2_is_sign;
|
|
uint c;
|
|
|
|
ss1_is_sign = IsSign();
|
|
|
|
/*
|
|
we don't have to check the carry from Abs (values will be correct
|
|
because next we're using the method MulInt from the base class UInt
|
|
which is without a sign)
|
|
*/
|
|
Abs();
|
|
|
|
if( ss2 < 0 )
|
|
{
|
|
ss2 = -ss2;
|
|
ss2_is_sign = true;
|
|
}
|
|
else
|
|
{
|
|
ss2_is_sign = false;
|
|
}
|
|
|
|
c = UInt<value_size>::MulInt((uint)ss2);
|
|
c += CheckMinCarry(ss1_is_sign, ss2_is_sign);
|
|
|
|
if( ss1_is_sign != ss2_is_sign )
|
|
SetSign();
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
multiplication this = this * ss2
|
|
|
|
it returns carry if the result is too big
|
|
(we're using the method from the base class but we have to make
|
|
one correction in account of signs)
|
|
*/
|
|
uint Mul(Int<value_size> ss2)
|
|
{
|
|
bool ss1_is_sign, ss2_is_sign;
|
|
uint c;
|
|
|
|
ss1_is_sign = IsSign();
|
|
ss2_is_sign = ss2.IsSign();
|
|
|
|
/*
|
|
we don't have to check the carry from Abs (values will be correct
|
|
because next we're using the method Mul from the base class UInt
|
|
which is without a sign)
|
|
*/
|
|
Abs();
|
|
ss2.Abs();
|
|
|
|
c = UInt<value_size>::Mul(ss2);
|
|
c += CheckMinCarry(ss1_is_sign, ss2_is_sign);
|
|
|
|
if( ss1_is_sign != ss2_is_sign )
|
|
SetSign();
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
/*!
|
|
division this = this / ss2
|
|
returned values:
|
|
- 0 - ok
|
|
- 1 - division by zero
|
|
|
|
for example: (result means 'this')
|
|
- 20 / 3 --> result: 6 remainder: 2
|
|
- -20 / 3 --> result: -6 remainder: -2
|
|
- 20 / -3 --> result: -6 remainder: 2
|
|
- -20 / -3 --> result: 6 remainder: -2
|
|
|
|
in other words: this(old) = ss2 * this(new)(result) + remainder
|
|
*/
|
|
uint Div(Int<value_size> ss2, Int<value_size> * remainder = 0)
|
|
{
|
|
bool ss1_is_sign, ss2_is_sign;
|
|
|
|
ss1_is_sign = IsSign();
|
|
ss2_is_sign = ss2.IsSign();
|
|
|
|
/*
|
|
we don't have to test the carry from Abs as well as in Mul
|
|
*/
|
|
Abs();
|
|
ss2.Abs();
|
|
|
|
uint c = UInt<value_size>::Div(ss2, remainder);
|
|
|
|
if( ss1_is_sign != ss2_is_sign )
|
|
SetSign();
|
|
|
|
if( ss1_is_sign && remainder )
|
|
remainder->SetSign();
|
|
|
|
return c;
|
|
}
|
|
|
|
uint Div(const Int<value_size> & ss2, Int<value_size> & remainder)
|
|
{
|
|
return Div(ss2, &remainder);
|
|
}
|
|
|
|
|
|
/*!
|
|
division this = this / ss2 (ss2 is int)
|
|
returned values:
|
|
- 0 - ok
|
|
- 1 - division by zero
|
|
|
|
for example: (result means 'this')
|
|
- 20 / 3 --> result: 6 remainder: 2
|
|
- -20 / 3 --> result: -6 remainder: -2
|
|
- 20 / -3 --> result: -6 remainder: 2
|
|
- -20 / -3 --> result: 6 remainder: -2
|
|
|
|
in other words: this(old) = ss2 * this(new)(result) + remainder
|
|
*/
|
|
uint DivInt(sint ss2, sint * remainder = 0)
|
|
{
|
|
bool ss1_is_sign, ss2_is_sign;
|
|
|
|
ss1_is_sign = IsSign();
|
|
|
|
/*
|
|
we don't have to test the carry from Abs as well as in Mul
|
|
*/
|
|
Abs();
|
|
|
|
if( ss2 < 0 )
|
|
{
|
|
ss2 = -ss2;
|
|
ss2_is_sign = true;
|
|
}
|
|
else
|
|
{
|
|
ss2_is_sign = false;
|
|
}
|
|
|
|
uint rem;
|
|
uint c = UInt<value_size>::DivInt((uint)ss2, &rem);
|
|
|
|
if( ss1_is_sign != ss2_is_sign )
|
|
SetSign();
|
|
|
|
if( remainder )
|
|
{
|
|
if( ss1_is_sign )
|
|
*remainder = -sint(rem);
|
|
else
|
|
*remainder = sint(rem);
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
uint DivInt(sint ss2, sint & remainder)
|
|
{
|
|
return DivInt(ss2, &remainder);
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
|
|
/*!
|
|
power this = this ^ pow
|
|
this can be negative
|
|
pow is >= 0
|
|
*/
|
|
uint Pow2(const Int<value_size> & pow)
|
|
{
|
|
bool was_sign = IsSign();
|
|
uint c = 0;
|
|
|
|
if( was_sign )
|
|
c += Abs();
|
|
|
|
uint c_temp = UInt<value_size>::Pow(pow);
|
|
if( c_temp > 0 )
|
|
return c_temp; // c_temp can be: 0, 1 or 2
|
|
|
|
if( was_sign && (pow.table[0] & 1) == 1 )
|
|
// negative value to the power of odd number is negative
|
|
c += ChangeSign();
|
|
|
|
return (c==0)? 0 : 1;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
|
|
/*!
|
|
power this = this ^ pow
|
|
|
|
return values:
|
|
- 0 - ok
|
|
- 1 - carry
|
|
- 2 - incorrect arguments 0^0 or 0^(-something)
|
|
*/
|
|
uint Pow(Int<value_size> pow)
|
|
{
|
|
if( !pow.IsSign() )
|
|
return Pow2(pow);
|
|
|
|
if( UInt<value_size>::IsZero() )
|
|
// if 'pow' is negative then
|
|
// 'this' must be different from zero
|
|
return 2;
|
|
|
|
if( pow.ChangeSign() )
|
|
return 1;
|
|
|
|
Int<value_size> t(*this);
|
|
uint c_temp = t.Pow2(pow);
|
|
if( c_temp > 0 )
|
|
return c_temp;
|
|
|
|
UInt<value_size>::SetOne();
|
|
if( Div(t) )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* convertion methods
|
|
*
|
|
*/
|
|
private:
|
|
|
|
|
|
/*!
|
|
an auxiliary method for converting both from UInt and Int
|
|
*/
|
|
template<uint argument_size>
|
|
uint FromUIntOrInt(const UInt<argument_size> & p, bool UInt_type)
|
|
{
|
|
uint min_size = (value_size < argument_size)? value_size : argument_size;
|
|
uint i;
|
|
|
|
for(i=0 ; i<min_size ; ++i)
|
|
UInt<value_size>::table[i] = p.table[i];
|
|
|
|
|
|
if( value_size > argument_size )
|
|
{
|
|
uint fill;
|
|
|
|
if( UInt_type )
|
|
fill = 0;
|
|
else
|
|
fill = (p.table[argument_size-1] & TTMATH_UINT_HIGHEST_BIT)?
|
|
TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
// 'this' is longer than 'p'
|
|
for( ; i<value_size ; ++i)
|
|
UInt<value_size>::table[i] = fill;
|
|
}
|
|
else
|
|
{
|
|
uint test = (UInt<value_size>::table[value_size-1] & TTMATH_UINT_HIGHEST_BIT)?
|
|
TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
if( UInt_type && test!=0 )
|
|
return 1;
|
|
|
|
for( ; i<argument_size ; ++i)
|
|
if( p.table[i] != test )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public:
|
|
|
|
/*!
|
|
this method converts an Int<another_size> type into this class
|
|
|
|
this operation has mainly sense if the value from p
|
|
can be held in this type
|
|
|
|
it returns a carry if the value 'p' is too big
|
|
*/
|
|
template<uint argument_size>
|
|
uint FromInt(const Int<argument_size> & p)
|
|
{
|
|
return FromUIntOrInt(p, false);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the sint type into this class
|
|
*/
|
|
uint FromInt(sint value)
|
|
{
|
|
uint fill = ( value<0 ) ? TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
for(uint i=1 ; i<value_size ; ++i)
|
|
UInt<value_size>::table[i] = fill;
|
|
|
|
UInt<value_size>::table[0] = uint(value);
|
|
|
|
// there'll never be a carry here
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts UInt<another_size> into this class
|
|
*/
|
|
template<uint argument_size>
|
|
uint FromUInt(const UInt<argument_size> & p)
|
|
{
|
|
return FromUIntOrInt(p, true);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts UInt<another_size> into this class
|
|
*/
|
|
template<uint argument_size>
|
|
uint FromInt(const UInt<argument_size> & p)
|
|
{
|
|
return FromUIntOrInt(p, true);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the uint type into this class
|
|
*/
|
|
uint FromUInt(uint value)
|
|
{
|
|
for(uint i=1 ; i<value_size ; ++i)
|
|
UInt<value_size>::table[i] = 0;
|
|
|
|
UInt<value_size>::table[0] = value;
|
|
|
|
// there can be a carry here when the size of this value is equal one word
|
|
// and the 'value' has the highest bit set
|
|
if( value_size==1 && (value & TTMATH_UINT_HIGHEST_BIT)!=0 )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the uint type into this class
|
|
*/
|
|
uint FromInt(uint value)
|
|
{
|
|
return FromUInt(value);
|
|
}
|
|
|
|
|
|
/*!
|
|
the default assignment operator
|
|
*/
|
|
Int<value_size> & operator=(const Int<value_size> & p)
|
|
{
|
|
FromInt(p);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts an Int<another_size> type to this class
|
|
|
|
it doesn't return a carry
|
|
*/
|
|
template<uint argument_size>
|
|
Int<value_size> & operator=(const Int<argument_size> & p)
|
|
{
|
|
FromInt(p);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the sint type to this class
|
|
*/
|
|
Int<value_size> & operator=(sint i)
|
|
{
|
|
FromInt(i);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting the uint to this class
|
|
*/
|
|
Int(sint i)
|
|
{
|
|
FromInt(i);
|
|
}
|
|
|
|
|
|
/*!
|
|
a copy constructor
|
|
*/
|
|
Int(const Int<value_size> & u) : UInt<value_size>()
|
|
{
|
|
FromInt(u);
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for copying from another types
|
|
*/
|
|
template<uint argument_size>
|
|
Int(const Int<argument_size> & u)
|
|
{
|
|
// look that 'size' we still set as 'value_size' and not as u.value_size
|
|
FromInt(u);
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
this operator converts an UInt<another_size> type to this class
|
|
|
|
it doesn't return a carry
|
|
*/
|
|
template<uint argument_size>
|
|
Int<value_size> & operator=(const UInt<argument_size> & p)
|
|
{
|
|
FromUInt(p);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the Uint type to this class
|
|
*/
|
|
Int<value_size> & operator=(uint i)
|
|
{
|
|
FromUInt(i);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting the uint to this class
|
|
*/
|
|
Int(uint i)
|
|
{
|
|
FromUInt(i);
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for copying from another types
|
|
*/
|
|
template<uint argument_size>
|
|
Int(const UInt<argument_size> & u)
|
|
{
|
|
// look that 'size' we still set as 'value_size' and not as u.value_size
|
|
FromUInt(u);
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
|
|
/*!
|
|
this method converts unsigned 64 bit int type to this class
|
|
***this method is created only on a 32bit platform***
|
|
*/
|
|
uint FromUInt(ulint n)
|
|
{
|
|
uint c = UInt<value_size>::FromUInt(n);
|
|
|
|
if( c )
|
|
return 1;
|
|
|
|
if( value_size == 1 )
|
|
return ((UInt<value_size>::table[0] & TTMATH_UINT_HIGHEST_BIT) == 0) ? 0 : 1;
|
|
|
|
if( value_size == 2 )
|
|
return ((UInt<value_size>::table[1] & TTMATH_UINT_HIGHEST_BIT) == 0) ? 0 : 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts unsigned 64 bit int type to this class
|
|
***this method is created only on a 32bit platform***
|
|
*/
|
|
uint FromInt(ulint n)
|
|
{
|
|
return FromUInt(n);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts signed 64 bit int type to this class
|
|
***this method is created only on a 32bit platform***
|
|
*/
|
|
uint FromInt(slint n)
|
|
{
|
|
uint mask = (n < 0) ? TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
UInt<value_size>::table[0] = (uint)(ulint)n;
|
|
|
|
if( value_size == 1 )
|
|
{
|
|
if( uint(ulint(n) >> 32) != mask )
|
|
return 1;
|
|
|
|
return ((UInt<value_size>::table[0] & TTMATH_UINT_HIGHEST_BIT) == (mask & TTMATH_UINT_HIGHEST_BIT)) ? 0 : 1;
|
|
}
|
|
|
|
UInt<value_size>::table[1] = (uint)(ulint(n) >> 32);
|
|
|
|
for(uint i=2 ; i<value_size ; ++i)
|
|
UInt<value_size>::table[i] = mask;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts unsigned 64 bit int type to this class
|
|
***this operator is created only on a 32bit platform***
|
|
*/
|
|
Int<value_size> & operator=(ulint n)
|
|
{
|
|
FromUInt(n);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting unsigned 64 bit int to this class
|
|
***this constructor is created only on a 32bit platform***
|
|
*/
|
|
Int(ulint n)
|
|
{
|
|
FromUInt(n);
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts signed 64 bit int type to this class
|
|
***this operator is created only on a 32bit platform***
|
|
*/
|
|
Int<value_size> & operator=(slint n)
|
|
{
|
|
FromInt(n);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting signed 64 bit int to this class
|
|
***this constructor is created only on a 32bit platform***
|
|
*/
|
|
Int(slint n)
|
|
{
|
|
FromInt(n);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM64
|
|
|
|
/*!
|
|
this method converts 32 bit unsigned int type to this class
|
|
***this operator is created only on a 64bit platform***
|
|
*/
|
|
uint FromUInt(unsigned int i)
|
|
{
|
|
return FromUInt(uint(i));
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts 32 bit unsigned int type to this class
|
|
***this operator is created only on a 64bit platform***
|
|
*/
|
|
uint FromInt(unsigned int i)
|
|
{
|
|
return FromUInt(i);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts 32 bit signed int type to this class
|
|
***this operator is created only on a 64bit platform***
|
|
*/
|
|
uint FromInt(signed int i)
|
|
{
|
|
return FromInt(sint(i));
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts 32 bit unsigned int type to this class
|
|
***this operator is created only on a 64bit platform***
|
|
*/
|
|
Int<value_size> & operator=(unsigned int i)
|
|
{
|
|
FromUInt(i);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting 32 bit unsigned int to this class
|
|
***this constructor is created only on a 64bit platform***
|
|
*/
|
|
Int(unsigned int i)
|
|
{
|
|
FromUInt(i);
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts 32 bit signed int type to this class
|
|
***this operator is created only on a 64bit platform***
|
|
*/
|
|
Int<value_size> & operator=(signed int i)
|
|
{
|
|
FromInt(i);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting 32 bit signed int to this class
|
|
***this constructor is created only on a 64bit platform***
|
|
*/
|
|
Int(signed int i)
|
|
{
|
|
FromInt(i);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*!
|
|
a constructor for converting string to this class (with the base=10)
|
|
*/
|
|
Int(const char * s)
|
|
{
|
|
FromString(s);
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting a string to this class (with the base=10)
|
|
*/
|
|
Int(const std::string & s)
|
|
{
|
|
FromString( s.c_str() );
|
|
}
|
|
|
|
|
|
#ifndef TTMATH_DONT_USE_WCHAR
|
|
|
|
/*!
|
|
a constructor for converting string to this class (with the base=10)
|
|
*/
|
|
Int(const wchar_t * s)
|
|
{
|
|
FromString(s);
|
|
}
|
|
|
|
|
|
/*!
|
|
a constructor for converting a string to this class (with the base=10)
|
|
*/
|
|
Int(const std::wstring & s)
|
|
{
|
|
FromString( s.c_str() );
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*!
|
|
a default constructor
|
|
|
|
we don't clear table etc.
|
|
*/
|
|
Int()
|
|
{
|
|
}
|
|
|
|
|
|
/*!
|
|
the destructor
|
|
*/
|
|
~Int()
|
|
{
|
|
}
|
|
|
|
|
|
/*!
|
|
this method returns the lowest value from table with a sign
|
|
|
|
we must be sure when we using this method whether the value
|
|
will hold in an sint type or not (the rest value from table must be zero or -1)
|
|
*/
|
|
sint ToInt() const
|
|
{
|
|
return sint( UInt<value_size>::table[0] );
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to uint type
|
|
can return a carry if the value is too long to store it in uint type
|
|
*/
|
|
uint ToUInt(uint & result) const
|
|
{
|
|
uint c = UInt<value_size>::ToUInt(result);
|
|
|
|
if( value_size == 1 )
|
|
return (result & TTMATH_UINT_HIGHEST_BIT) == 0 ? 0 : 1;
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to uint type
|
|
can return a carry if the value is too long to store it in uint type
|
|
*/
|
|
uint ToInt(uint & result) const
|
|
{
|
|
return ToUInt(result);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to sint type
|
|
can return a carry if the value is too long to store it in sint type
|
|
*/
|
|
uint ToInt(sint & result) const
|
|
{
|
|
result = sint( UInt<value_size>::table[0] );
|
|
uint mask = IsSign() ? TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
if( (result & TTMATH_UINT_HIGHEST_BIT) != (mask & TTMATH_UINT_HIGHEST_BIT) )
|
|
return 1;
|
|
|
|
for(uint i=1 ; i<value_size ; ++i)
|
|
if( UInt<value_size>::table[i] != mask )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM32
|
|
|
|
/*!
|
|
this method converts the value to ulint type (64 bit unsigned integer)
|
|
can return a carry if the value is too long to store it in ulint type
|
|
*** this method is created only on a 32 bit platform ***
|
|
*/
|
|
uint ToUInt(ulint & result) const
|
|
{
|
|
uint c = UInt<value_size>::ToUInt(result);
|
|
|
|
if( value_size == 1 )
|
|
return (UInt<value_size>::table[0] & TTMATH_UINT_HIGHEST_BIT) == 0 ? 0 : 1;
|
|
|
|
if( value_size == 2 )
|
|
return (UInt<value_size>::table[1] & TTMATH_UINT_HIGHEST_BIT) == 0 ? 0 : 1;
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to ulint type (64 bit unsigned integer)
|
|
can return a carry if the value is too long to store it in ulint type
|
|
*** this method is created only on a 32 bit platform ***
|
|
*/
|
|
uint ToInt(ulint & result) const
|
|
{
|
|
return ToUInt(result);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to slint type (64 bit signed integer)
|
|
can return a carry if the value is too long to store it in slint type
|
|
*** this method is created only on a 32 bit platform ***
|
|
*/
|
|
uint ToInt(slint & result) const
|
|
{
|
|
if( value_size == 1 )
|
|
{
|
|
result = slint(sint(UInt<value_size>::table[0]));
|
|
}
|
|
else
|
|
{
|
|
uint low = UInt<value_size>::table[0];
|
|
uint high = UInt<value_size>::table[1];
|
|
|
|
result = low;
|
|
result |= (ulint(high) << TTMATH_BITS_PER_UINT);
|
|
|
|
uint mask = IsSign() ? TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
if( (high & TTMATH_UINT_HIGHEST_BIT) != (mask & TTMATH_UINT_HIGHEST_BIT) )
|
|
return 1;
|
|
|
|
for(uint i=2 ; i<value_size ; ++i)
|
|
if( UInt<value_size>::table[i] != mask )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TTMATH_PLATFORM64
|
|
|
|
/*!
|
|
this method converts the value to a 32 bit unsigned integer
|
|
can return a carry if the value is too long to store it in this type
|
|
*** this method is created only on a 64 bit platform ***
|
|
*/
|
|
uint ToUInt(unsigned int & result) const
|
|
{
|
|
uint c = UInt<value_size>::ToUInt(result);
|
|
|
|
if( c || IsSign() )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to a 32 bit unsigned integer
|
|
can return a carry if the value is too long to store it in this type
|
|
*** this method is created only on a 64 bit platform ***
|
|
*/
|
|
uint ToInt(unsigned int & result) const
|
|
{
|
|
return ToUInt(result);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to a 32 bit signed integer
|
|
can return a carry if the value is too long to store it in this type
|
|
*** this method is created only on a 64 bit platform ***
|
|
*/
|
|
uint ToInt(int & result) const
|
|
{
|
|
uint first = UInt<value_size>::table[0];
|
|
|
|
result = int(first);
|
|
uint mask = IsSign() ? TTMATH_UINT_MAX_VALUE : 0;
|
|
|
|
if( (first >> 31) != (mask >> 31) )
|
|
return 1;
|
|
|
|
for(uint i=1 ; i<value_size ; ++i)
|
|
if( UInt<value_size>::table[i] != mask )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
/*!
|
|
an auxiliary method for converting to a string
|
|
*/
|
|
template<class string_type>
|
|
void ToStringBase(string_type & result, uint b = 10) const
|
|
{
|
|
if( IsSign() )
|
|
{
|
|
Int<value_size> temp(*this);
|
|
temp.Abs();
|
|
temp.UInt<value_size>::ToStringBase(result, b, true);
|
|
}
|
|
else
|
|
{
|
|
UInt<value_size>::ToStringBase(result, b, false);
|
|
}
|
|
}
|
|
|
|
public:
|
|
|
|
/*!
|
|
this method converts the value to a string with a base equal 'b'
|
|
*/
|
|
void ToString(std::string & result, uint b = 10) const
|
|
{
|
|
return ToStringBase(result, b);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to a string with a base equal 'b'
|
|
*/
|
|
std::string ToString(uint b = 10) const
|
|
{
|
|
std::string result;
|
|
ToStringBase(result, b);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
#ifndef TTMATH_DONT_USE_WCHAR
|
|
|
|
/*!
|
|
this method converts the value to a string with a base equal 'b'
|
|
*/
|
|
void ToString(std::wstring & result, uint b = 10) const
|
|
{
|
|
return ToStringBase(result, b);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts the value to a string with a base equal 'b'
|
|
*/
|
|
std::wstring ToWString(uint b = 10) const
|
|
{
|
|
std::wstring result;
|
|
ToStringBase(result, b);
|
|
|
|
return result;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
private:
|
|
|
|
/*!
|
|
an auxiliary method for converting from a string
|
|
*/
|
|
template<class char_type>
|
|
uint FromStringBase(const char_type * s, uint b = 10, const char_type ** after_source = 0, bool * value_read = 0)
|
|
{
|
|
bool is_sign = false;
|
|
|
|
Misc::SkipWhiteCharacters(s);
|
|
|
|
if( *s == '-' )
|
|
{
|
|
is_sign = true;
|
|
Misc::SkipWhiteCharacters(++s);
|
|
}
|
|
else
|
|
if( *s == '+' )
|
|
{
|
|
Misc::SkipWhiteCharacters(++s);
|
|
}
|
|
|
|
if( UInt<value_size>::FromString(s,b,after_source,value_read) )
|
|
return 1;
|
|
|
|
if( is_sign )
|
|
{
|
|
Int<value_size> mmin;
|
|
|
|
mmin.SetMin();
|
|
|
|
/*
|
|
the reference to mmin will be automatically converted to the reference
|
|
to UInt type
|
|
(this value can be equal mmin -- look at a description in ChangeSign())
|
|
*/
|
|
if( UInt<value_size>::operator>( mmin ) )
|
|
return 1;
|
|
|
|
/*
|
|
if the value is equal mmin the method ChangeSign() does nothing (only returns 1 but we ignore it)
|
|
*/
|
|
ChangeSign();
|
|
}
|
|
else
|
|
{
|
|
Int<value_size> mmax;
|
|
|
|
mmax.SetMax();
|
|
|
|
if( UInt<value_size>::operator>( mmax ) )
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/*!
|
|
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
|
|
(between '-' and a first digit can be white characters too)
|
|
|
|
after_source (if exists) is pointing at the end of the parsed string
|
|
|
|
value_read (if exists) tells whether something has actually been read (at least one digit)
|
|
*/
|
|
uint FromString(const char * s, uint b = 10, const char ** after_source = 0, bool * value_read = 0)
|
|
{
|
|
return FromStringBase(s, b, after_source, value_read);
|
|
}
|
|
|
|
|
|
/*!
|
|
this method converts a string into its value
|
|
*/
|
|
uint FromString(const wchar_t * s, uint b = 10, const wchar_t ** after_source = 0, bool * value_read = 0)
|
|
{
|
|
return FromStringBase(s, b, after_source, value_read);
|
|
}
|
|
|
|
|
|
/*!
|
|
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)
|
|
*/
|
|
Int<value_size> & operator=(const char * s)
|
|
{
|
|
FromString(s);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
#ifndef TTMATH_DONT_USE_WCHAR
|
|
|
|
|
|
/*!
|
|
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::wstring & s, uint b = 10)
|
|
{
|
|
return FromString( s.c_str(), b );
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts a string into its value (with base = 10)
|
|
*/
|
|
Int<value_size> & operator=(const wchar_t * s)
|
|
{
|
|
FromString(s);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
this operator converts a string into its value (with base = 10)
|
|
*/
|
|
Int<value_size> & operator=(const std::wstring & s)
|
|
{
|
|
FromString( s.c_str() );
|
|
|
|
return *this;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*!
|
|
this operator converts a string into its value (with base = 10)
|
|
*/
|
|
Int<value_size> & operator=(const std::string & s)
|
|
{
|
|
FromString( s.c_str() );
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* methods for comparing
|
|
*
|
|
*
|
|
*/
|
|
|
|
bool operator==(const Int<value_size> & l) const
|
|
{
|
|
return UInt<value_size>::operator==(l);
|
|
}
|
|
|
|
bool operator!=(const Int<value_size> & l) const
|
|
{
|
|
return UInt<value_size>::operator!=(l);
|
|
}
|
|
|
|
bool operator<(const Int<value_size> & l) const
|
|
{
|
|
sint i=value_size-1;
|
|
|
|
sint a1 = sint(UInt<value_size>::table[i]);
|
|
sint a2 = sint(l.table[i]);
|
|
|
|
if( a1 != a2 )
|
|
return a1 < a2;
|
|
|
|
|
|
for(--i ; i>=0 ; --i)
|
|
{
|
|
if( UInt<value_size>::table[i] != l.table[i] )
|
|
// comparison as unsigned int
|
|
return UInt<value_size>::table[i] < l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return false;
|
|
}
|
|
|
|
|
|
bool operator>(const Int<value_size> & l) const
|
|
{
|
|
sint i=value_size-1;
|
|
|
|
sint a1 = sint(UInt<value_size>::table[i]);
|
|
sint a2 = sint(l.table[i]);
|
|
|
|
if( a1 != a2 )
|
|
return a1 > a2;
|
|
|
|
|
|
for(--i ; i>=0 ; --i)
|
|
{
|
|
if( UInt<value_size>::table[i] != l.table[i] )
|
|
// comparison as unsigned int
|
|
return UInt<value_size>::table[i] > l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return false;
|
|
}
|
|
|
|
|
|
bool operator<=(const Int<value_size> & l) const
|
|
{
|
|
sint i=value_size-1;
|
|
|
|
sint a1 = sint(UInt<value_size>::table[i]);
|
|
sint a2 = sint(l.table[i]);
|
|
|
|
if( a1 != a2 )
|
|
return a1 < a2;
|
|
|
|
|
|
for(--i ; i>=0 ; --i)
|
|
{
|
|
if( UInt<value_size>::table[i] != l.table[i] )
|
|
// comparison as unsigned int
|
|
return UInt<value_size>::table[i] < l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return true;
|
|
}
|
|
|
|
|
|
bool operator>=(const Int<value_size> & l) const
|
|
{
|
|
sint i=value_size-1;
|
|
|
|
sint a1 = sint(UInt<value_size>::table[i]);
|
|
sint a2 = sint(l.table[i]);
|
|
|
|
if( a1 != a2 )
|
|
return a1 > a2;
|
|
|
|
|
|
for(--i ; i>=0 ; --i)
|
|
{
|
|
if( UInt<value_size>::table[i] != l.table[i] )
|
|
// comparison as unsigned int
|
|
return UInt<value_size>::table[i] > l.table[i];
|
|
}
|
|
|
|
// they're equal
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
*
|
|
* standard mathematical operators
|
|
*
|
|
*/
|
|
|
|
|
|
/*!
|
|
an operator for changing the sign
|
|
|
|
it's not changing 'this' but the changed value will be returned
|
|
*/
|
|
Int<value_size> operator-() const
|
|
{
|
|
Int<value_size> temp(*this);
|
|
|
|
temp.ChangeSign();
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
Int<value_size> operator-(const Int<value_size> & p2) const
|
|
{
|
|
Int<value_size> temp(*this);
|
|
|
|
temp.Sub(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
Int<value_size> & operator-=(const Int<value_size> & p2)
|
|
{
|
|
Sub(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
Int<value_size> operator+(const Int<value_size> & p2) const
|
|
{
|
|
Int<value_size> temp(*this);
|
|
|
|
temp.Add(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
Int<value_size> & operator+=(const Int<value_size> & p2)
|
|
{
|
|
Add(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
Int<value_size> operator*(const Int<value_size> & p2) const
|
|
{
|
|
Int<value_size> temp(*this);
|
|
|
|
temp.Mul(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
Int<value_size> & operator*=(const Int<value_size> & p2)
|
|
{
|
|
Mul(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
Int<value_size> operator/(const Int<value_size> & p2) const
|
|
{
|
|
Int<value_size> temp(*this);
|
|
|
|
temp.Div(p2);
|
|
|
|
return temp;
|
|
}
|
|
|
|
|
|
Int<value_size> & operator/=(const Int<value_size> & p2)
|
|
{
|
|
Div(p2);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
Int<value_size> operator%(const Int<value_size> & p2) const
|
|
{
|
|
Int<value_size> temp(*this);
|
|
Int<value_size> remainder;
|
|
|
|
temp.Div(p2, remainder);
|
|
|
|
return remainder;
|
|
}
|
|
|
|
|
|
Int<value_size> & operator%=(const Int<value_size> & p2)
|
|
{
|
|
Int<value_size> remainder;
|
|
|
|
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
|
|
*
|
|
*/
|
|
|
|
private:
|
|
|
|
/*!
|
|
an auxiliary method for outputing to standard streams
|
|
*/
|
|
template<class ostream_type, class string_type>
|
|
static ostream_type & OutputToStream(ostream_type & s, const Int<value_size> & l)
|
|
{
|
|
string_type ss;
|
|
|
|
l.ToString(ss);
|
|
s << ss;
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
/*!
|
|
output to standard streams
|
|
*/
|
|
friend std::ostream & operator<<(std::ostream & s, const Int<value_size> & l)
|
|
{
|
|
return OutputToStream<std::ostream, std::string>(s, l);
|
|
}
|
|
|
|
|
|
#ifndef TTMATH_DONT_USE_WCHAR
|
|
|
|
/*!
|
|
output to standard streams
|
|
*/
|
|
friend std::wostream & operator<<(std::wostream & s, const Int<value_size> & l)
|
|
{
|
|
return OutputToStream<std::wostream, std::wstring>(s, l);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
private:
|
|
|
|
/*!
|
|
an auxiliary method for converting from a string
|
|
*/
|
|
template<class istream_type, class string_type, class char_type>
|
|
static istream_type & InputFromStream(istream_type & s, Int<value_size> & l)
|
|
{
|
|
string_type ss;
|
|
|
|
// char or wchar_t for operator>>
|
|
char_type z;
|
|
|
|
// operator>> omits white characters if they're set for ommiting
|
|
s >> z;
|
|
|
|
if( z=='-' || z=='+' )
|
|
{
|
|
ss += z;
|
|
s >> z; // we're reading a next character (white characters can be ommited)
|
|
}
|
|
|
|
// we're reading only digits (base=10)
|
|
while( s.good() && Misc::CharToDigit(z, 10)>=0 )
|
|
{
|
|
ss += z;
|
|
z = static_cast<char_type>(s.get());
|
|
}
|
|
|
|
// we're leaving the last readed character
|
|
// (it's not belonging to the value)
|
|
s.unget();
|
|
|
|
l.FromString(ss);
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/*!
|
|
input from standard streams
|
|
*/
|
|
friend std::istream & operator>>(std::istream & s, Int<value_size> & l)
|
|
{
|
|
return InputFromStream<std::istream, std::string, char>(s, l);
|
|
}
|
|
|
|
|
|
#ifndef TTMATH_DONT_USE_WCHAR
|
|
|
|
/*!
|
|
input from standard streams
|
|
*/
|
|
friend std::wistream & operator>>(std::wistream & s, Int<value_size> & l)
|
|
{
|
|
return InputFromStream<std::wistream, std::wstring, wchar_t>(s, l);
|
|
}
|
|
#endif
|
|
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#endif
|