public static void AssertBigIntegersEqual(string a, BigInteger b)
{
Assert.AreEqual(a,b.ToString());
BigInteger a2=BigInteger.fromString(a);
Assert.AreEqual(a2,b);
AssertEqualsHashCode(a2,b);
}
public BitShiftAccumulator(BigInteger bigint,
int lastDiscarded,
int olderDiscarded
)
{
if (bigint.Sign < 0)
throw new ArgumentException("bigint is negative");
shiftedBigInt = bigint;
discardedBitCount = new FastInteger(0);
bitsAfterLeftmost = (olderDiscarded != 0) ? 1 : 0;
bitLeftmost = (lastDiscarded != 0) ? 1 : 0;
}
public DigitShiftAccumulator(BigInteger bigint,
int lastDiscarded,
int olderDiscarded
)
{
if(bigint.canFitInInt()){
shiftedSmall=(int)bigint;
if(shiftedSmall<0)
throw new ArgumentException("bigint is negative");
isSmall=true;
} else {
shiftedBigInt = bigint;
isSmall = false;
}
bitsAfterLeftmost = (olderDiscarded != 0) ? 1 : 0;
bitLeftmost = lastDiscarded;
}
/// <summary> </summary>
/// <param name='value'>A Decimal object.</param>
/// <returns>A CBORObject object.</returns>
public static CBORObject FromObject(decimal value)
{
if (Math.Round(value) == value) {
// This is an integer
if (value >= 0 && value <= UInt64.MaxValue) {
return FromObject((ulong)value);
} else if (value >= Int64.MinValue && value <= Int64.MaxValue) {
return FromObject((long)value);
} else {
return FromObject(DecimalToBigInteger(value));
}
} else {
int[] bits = Decimal.GetBits(value);
byte[] data=new byte[13];
data[0]=(byte)((bits[0])&0xFF);
data[1]=(byte)((bits[0]>>8)&0xFF);
data[2]=(byte)((bits[0]>>16)&0xFF);
data[3]=(byte)((bits[0]>>24)&0xFF);
data[4]=(byte)((bits[1])&0xFF);
data[5]=(byte)((bits[1]>>8)&0xFF);
data[6]=(byte)((bits[1]>>16)&0xFF);
data[7]=(byte)((bits[1]>>24)&0xFF);
data[8]=(byte)((bits[2])&0xFF);
data[9]=(byte)((bits[2]>>8)&0xFF);
data[10]=(byte)((bits[2]>>16)&0xFF);
data[11]=(byte)((bits[2]>>24)&0xFF);
data[12]=0;
BigInteger mantissa=new BigInteger((byte[])data);
bool negative = (bits[3] >> 31) != 0;
int scale = (bits[3] >> 16) & 0xFF;
if (negative) mantissa = -mantissa;
return FromObjectAndTag(
new CBORObject[]{
FromObject(-scale),
FromObject(mantissa)
}, 4);
}
}
public static BigInteger Pow(BigInteger bigValue, int power){
if((bigValue)==null)throw new ArgumentNullException("bigValue");
if((power)<0)throw new ArgumentException("power"+" not greater or equal to "+"0"+" ("+Convert.ToString((power),System.Globalization.CultureInfo.InvariantCulture)+")");
return bigValue.pow(power);
}
/// <summary> </summary>
/// <param name='bigintFirst'>A BigInteger object.</param>
/// <param name='bigintSecond'>A BigInteger object.</param>
/// <returns>A BigInteger object.</returns>
public static BigInteger GreatestCommonDivisor(BigInteger bigintFirst, BigInteger bigintSecond){
if((bigintFirst)==null)throw new ArgumentNullException("bigintFirst");
return bigintFirst.gcd(bigintSecond);
}
public static BigInteger Pow(BigInteger bigValue, BigInteger power){
if((bigValue)==null)throw new ArgumentNullException("bigValue");
if((power)==null)throw new ArgumentNullException("power");
if((power.Sign)<0)throw new ArgumentException("power.Sign"+" not greater or equal to "+"0"+" ("+Convert.ToString((power.Sign),System.Globalization.CultureInfo.InvariantCulture)+")");
BigInteger val=BigInteger.One;
while(power.Sign>0){
BigInteger p=(power>(BigInteger)5000000) ?
(BigInteger)5000000 : power;
val*=bigValue.pow((int)p);
power-=p;
}
return val;
}
/// <summary> Shifts a number until it reaches the given number of bits,
/// gathering information on whether the last bit discarded is set and
/// whether the discarded bits to the right of that bit are set. Assumes
/// that the big integer being shifted is positive. </summary>
private void ShiftBigToBits(int bits)
{
byte[] bytes = shiftedBigInt.ToByteArray();
knownBitLength = ByteArrayBitLength(bytes);
// Shift by the difference in bit length
if (knownBitLength.CompareToInt(bits) > 0) {
FastInteger bitShift = FastInteger.Copy(knownBitLength).SubtractInt(bits);
FastInteger tmpBitShift = FastInteger.Copy(bitShift);
while (tmpBitShift.Sign > 0 && !shiftedBigInt.IsZero) {
int bs = tmpBitShift.MinInt32(1000000);
shiftedBigInt >>= bs;
tmpBitShift.SubtractInt(bs);
}
knownBitLength.SetInt(bits);
if (bits < SmallBitLength) {
// Shifting to small number of bits,
// convert to small integer
isSmall = true;
shiftedSmall = (int)shiftedBigInt;
}
bitsAfterLeftmost |= bitLeftmost;
discardedBitCount.Add(bitShift);
for (int i = 0; i < bytes.Length; i++) {
if (bitShift.CompareToInt(8)>0) {
// Discard all the bits, they come
// after the leftmost bit
bitsAfterLeftmost |= bytes[i];
bitShift.SubtractInt(8);
} else {
// 8 or fewer bits left.
// Get the bottommost bitShift minus 1 bits
bitsAfterLeftmost |= ((bytes[i] << (9 - bitShift.AsInt32())) & 0xFF);
// Get the bit just above those bits
bitLeftmost = (bytes[i] >> ((bitShift.AsInt32()) - 1)) & 0x01;
break;
}
}
bitsAfterLeftmost = (bitsAfterLeftmost != 0) ? 1 : 0;
}
}
/// <summary> </summary>
/// <param name='dividend'>A BigInteger object.</param>
/// <param name='divisor'>A BigInteger object.</param>
/// <param name='remainder'>A BigInteger object.</param>
/// <returns>A BigInteger object.</returns>
public static BigInteger DivRem(BigInteger dividend, BigInteger divisor, out BigInteger remainder)
{
if((dividend)==null)throw new ArgumentNullException("dividend");
BigInteger[] result=dividend.divideAndRemainder(divisor);
remainder=result[1];
return result[0];
}
/// <summary> Does an OR operation between two BigInteger instances.
/// </summary>
/// <remarks>Each BigInteger instance is treated as a two's complement
/// representation for the purposes of this operator.</remarks>
/// <returns>A BigInteger object.</returns>
/// <param name='first'>A BigInteger object.</param>
/// <param name='second'>A BigInteger object.</param>
public static BigInteger Or(BigInteger first, BigInteger second){
if((first)==null)throw new ArgumentNullException("first");
if((second)==null)throw new ArgumentNullException("second");
BigInteger xa=new BigInteger().Allocate(first.wordCount);
Array.Copy(first.reg,xa.reg,xa.reg.Length);
BigInteger xb=new BigInteger().Allocate(second.wordCount);
Array.Copy(second.reg,xb.reg,xb.reg.Length);
xa.negative=first.negative;
xa.wordCount=first.wordCount;
xb.negative=second.negative;
xb.wordCount=second.wordCount;
xa.reg=CleanGrow(xa.reg,Math.Max(xa.reg.Length,xb.reg.Length));
xb.reg=CleanGrow(xb.reg,Math.Max(xa.reg.Length,xb.reg.Length));
if(xa.Sign<0){ TwosComplement(xa.reg,0,(int)xa.reg.Length); }
if(xb.Sign<0){ TwosComplement(xb.reg,0,(int)xb.reg.Length); }
xa.negative|=(xb.Sign<0);
OrWords((xa.reg),(xa.reg),(xb.reg),(int)xa.reg.Length);
if(xa.Sign<0){ TwosComplement(xa.reg,0,(int)xa.reg.Length); }
xa.wordCount=xa.CalcWordCount();
if(xa.wordCount==0)xa.negative=false;
return xa;
}
/// <summary> Calculates the remainder when a BigInteger raised to a
/// certain power is divided by another BigInteger. </summary>
/// <param name='bigintValue'>A BigInteger object.</param>
/// <param name='pow'>A BigInteger object.</param>
/// <param name='mod'>A BigInteger object.</param>
/// <returns>(bigintValue^pow)%mod</returns>
public static BigInteger ModPow(BigInteger bigintValue, BigInteger pow, BigInteger mod) {
if ((bigintValue) == null) throw new ArgumentNullException("bigintValue");
return bigintValue.ModPow(pow, mod);
}
private static decimal BigIntegerToDecimal(BigInteger bi)
{
if(bi.Sign<0){
if(bi.CompareTo(DecimalMinValue)<0)
throw new OverflowException();
bi=-bi;
return EncodeDecimal(bi,0,true);
}
if(bi.CompareTo(DecimalMaxValue)>0)
throw new OverflowException();
return EncodeDecimal(bi,0,false);
}
private static BigInteger DecimalToBigInteger(decimal dec)
{
int[] bits=Decimal.GetBits(dec);
byte[] data=new byte[13];
data[0]=(byte)((bits[0])&0xFF);
data[1]=(byte)((bits[0]>>8)&0xFF);
data[2]=(byte)((bits[0]>>16)&0xFF);
data[3]=(byte)((bits[0]>>24)&0xFF);
data[4]=(byte)((bits[1])&0xFF);
data[5]=(byte)((bits[1]>>8)&0xFF);
data[6]=(byte)((bits[1]>>16)&0xFF);
data[7]=(byte)((bits[1]>>24)&0xFF);
data[8]=(byte)((bits[2])&0xFF);
data[9]=(byte)((bits[2]>>8)&0xFF);
data[10]=(byte)((bits[2]>>16)&0xFF);
data[11]=(byte)((bits[2]>>24)&0xFF);
data[12]=0;
int scale=(bits[3]>>16)&0xFF;
BigInteger bigint=new BigInteger((byte[])data);
for(int i=0;i<scale;i++){
bigint/=(BigInteger)10;
}
if((bits[3]>>31)!=0){
bigint=-bigint;
}
return bigint;
}
public void TestBigInteger()
{
BigInteger bi = (BigInteger)3;
AssertBigIntString("3", bi);
BigInteger negseven = (BigInteger)(-7);
AssertBigIntString("-7", negseven);
BigInteger other = (BigInteger)(-898989);
AssertBigIntString("-898989", other);
other = (BigInteger)898989;
AssertBigIntString("898989", other);
for (int i = 0; i < 500; i++) {
TestCommon.AssertSer(
CBORObject.FromObject(bi),
String.Format(CultureInfo.InvariantCulture, "{0}", bi));
bi *= (BigInteger)negseven;
}
BigInteger[] ranges = new BigInteger[]{
(BigInteger)Int64.MinValue-(BigInteger)512,
(BigInteger)Int64.MinValue+(BigInteger)512,
BigInteger.Zero-(BigInteger)512,
BigInteger.Zero+(BigInteger)512,
(BigInteger)Int64.MaxValue-(BigInteger)512,
(BigInteger)Int64.MaxValue+(BigInteger)512,
((BigInteger.One<<64)-BigInteger.One)-(BigInteger)512,
((BigInteger.One<<64)-BigInteger.One)+(BigInteger)512,
};
for (int i = 0; i < ranges.Length; i += 2) {
BigInteger bigintTemp = ranges[i];
while (true) {
TestCommon.AssertSer(
CBORObject.FromObject(bigintTemp),
String.Format(CultureInfo.InvariantCulture, "{0}", bigintTemp));
if (bigintTemp.Equals(ranges[i + 1])) break;
bigintTemp = bigintTemp + BigInteger.One;
}
}
}
public bool Equals(BigInteger other)
{
return this.Equals((object)other);
}
public void TestTags()
{
BigInteger maxuint = ((BigInteger.One << 64) - BigInteger.One);
BigInteger[] ranges = new BigInteger[]{
(BigInteger)6,
(BigInteger)65539,
(BigInteger)Int32.MaxValue-(BigInteger)500,
(BigInteger)Int32.MaxValue+(BigInteger)500,
(BigInteger)Int64.MaxValue-(BigInteger)500,
(BigInteger)Int64.MaxValue+(BigInteger)500,
((BigInteger.One<<64)-BigInteger.One)-(BigInteger)500,
maxuint,
};
for (int i = 0; i < ranges.Length; i += 2) {
BigInteger bigintTemp = ranges[i];
while (true) {
CBORObject obj = CBORObject.FromObjectAndTag(0, bigintTemp);
Assert.IsTrue(obj.IsTagged, "obj not tagged");
BigInteger[] tags = obj.GetTags();
Assert.AreEqual(1, tags.Length);
Assert.AreEqual(bigintTemp, tags[0]);
if (!obj.InnermostTag.Equals(bigintTemp))
Assert.AreEqual(bigintTemp, obj.InnermostTag,
String.Format(CultureInfo.InvariantCulture,
"obj tag doesn't match: {0}", obj));
TestCommon.AssertSer(
obj,
String.Format(CultureInfo.InvariantCulture, "{0}(0)", bigintTemp));
if (!(bigintTemp.Equals(maxuint))) {
// Test multiple tags
CBORObject obj2 = CBORObject.FromObjectAndTag(obj, bigintTemp + BigInteger.One);
BigInteger[] bi = obj2.GetTags();
if (bi.Length != 2)
Assert.AreEqual(2, bi.Length,
String.Format(CultureInfo.InvariantCulture,
"Expected 2 tags: {0}", obj2));
if (!bi[0].Equals((BigInteger)bigintTemp + BigInteger.One))
Assert.AreEqual(bigintTemp + BigInteger.One, bi[0],
String.Format(CultureInfo.InvariantCulture,
"Outer tag doesn't match: {0}", obj2));
if (!(bi[1].Equals((BigInteger)bigintTemp)))
Assert.AreEqual(bigintTemp, bi[1],
String.Format(CultureInfo.InvariantCulture,
"Inner tag doesn't match: {0}", obj2));
if (!(obj2.InnermostTag.Equals((BigInteger)bigintTemp)))
Assert.AreEqual(bigintTemp, obj2.InnermostTag,
String.Format(CultureInfo.InvariantCulture,
"Innermost tag doesn't match: {0}", obj2));
TestCommon.AssertSer(
obj2,
String.Format(CultureInfo.InvariantCulture, "{0}({1}(0))",
bigintTemp + BigInteger.One, bigintTemp));
}
if (bigintTemp.Equals(ranges[i + 1])) break;
bigintTemp = bigintTemp + BigInteger.One;
}
}
}
public void AssertBigIntString(string s, BigInteger bi)
{
Assert.AreEqual(s, bi.ToString());
}
public void AssertAdd(BigInteger bi, BigInteger bi2, string s)
{
AssertBigIntString(s, bi + (BigInteger)bi2);
AssertBigIntString(s, bi2 + (BigInteger)bi);
BigInteger negbi = BigInteger.Zero-(BigInteger)bi;
BigInteger negbi2 = BigInteger.Zero-(BigInteger)bi2;
AssertBigIntString(s, bi - (BigInteger)negbi2);
AssertBigIntString(s, bi2 - (BigInteger)negbi);
}
/// <summary> </summary>
/// <param name='other'>A BigInteger object.</param>
/// <returns>A Boolean object.</returns>
public bool Equals(BigInteger other) {
if (other == null) return false;
return this.CompareTo(other) == 0;
}
internal static BigInteger FindPowerOfTenFromBig(BigInteger bigintExponent)
{
int sign=bigintExponent.Sign;
if(sign<0)return BigInteger.Zero;
if (sign == 0) return BigInteger.One;
if (bigintExponent.CompareTo(BigInt36) <= 0) {
return FindPowerOfTen((int)bigintExponent);
}
FastInteger intcurexp = FastInteger.FromBig(bigintExponent);
BigInteger mantissa = BigInteger.One;
BigInteger bigpow = BigInteger.Zero;
while (intcurexp.Sign > 0) {
if (intcurexp.CompareToInt(18) <= 0) {
bigpow = FindPowerOfTen(intcurexp.AsInt32());
mantissa *= (BigInteger)bigpow;
break;
} else if (intcurexp.CompareToInt(9999999) <= 0) {
int val = intcurexp.AsInt32();
bigpow = FindPowerOfFive(val);
bigpow <<= val;
mantissa *= (BigInteger)bigpow;
break;
} else {
if (bigpow.IsZero) {
bigpow = FindPowerOfFive(9999999);
bigpow <<= 9999999;
}
mantissa *= bigpow;
intcurexp.AddInt(-9999999);
}
}
return mantissa;
}
/// <summary> Returns a BigInteger with every bit flipped. </summary>
/// <param name='a'>A BigInteger object.</param>
/// <returns>A BigInteger object.</returns>
public static BigInteger Not(BigInteger a){
if((a)==null)throw new ArgumentNullException("a");
BigInteger xa=new BigInteger().Allocate(a.wordCount);
Array.Copy(a.reg,xa.reg,xa.reg.Length);
xa.negative=a.negative;
xa.wordCount=a.wordCount;
if(xa.Sign<0){ TwosComplement(xa.reg,0,(int)xa.reg.Length); }
xa.negative=!(xa.Sign<0);
NotWords((xa.reg),(int)xa.reg.Length);
if(xa.Sign<0){ TwosComplement(xa.reg,0,(int)xa.reg.Length); }
xa.wordCount=xa.CalcWordCount();
if(xa.wordCount==0)xa.negative=false;
return xa;
}
public BigInteger[] FindCachedPowerOrSmaller(BigInteger bi)
{
BigInteger[] ret=null;
BigInteger minValue=BigInteger.Zero;
lock(outputs){
for(int i=0;i<size;i++){
if(inputs[i].CompareTo(bi)<=0 && inputs[i].CompareTo(minValue)>=0){
//Console.WriteLine("Have cached power ({0}, {1})",inputs[i],bi);
ret=new BigInteger[]{inputs[i],outputs[i]};
minValue=inputs[i];
}
}
}
return ret;
}
/// <summary> </summary>
/// <param name='a'>A BigInteger instance.</param>
/// <param name='b'>Another BigInteger instance.</param>
/// <remarks>Each BigInteger instance is treated as a two's complement
/// representation for the purposes of this operator.</remarks>
/// <returns>A BigInteger object.</returns>
public static BigInteger Xor(BigInteger a, BigInteger b){
if((a)==null)throw new ArgumentNullException("a");
if((b)==null)throw new ArgumentNullException("b");
BigInteger xa=new BigInteger().Allocate(a.wordCount);
Array.Copy(a.reg,xa.reg,xa.reg.Length);
BigInteger xb=new BigInteger().Allocate(b.wordCount);
Array.Copy(b.reg,xb.reg,xb.reg.Length);
xa.negative=a.negative;
xa.wordCount=a.wordCount;
xb.negative=b.negative;
xb.wordCount=b.wordCount;
xa.reg=CleanGrow(xa.reg,Math.Max(xa.reg.Length,xb.reg.Length));
xb.reg=CleanGrow(xb.reg,Math.Max(xa.reg.Length,xb.reg.Length));
if(xa.Sign<0){ TwosComplement(xa.reg,0,(int)xa.reg.Length); }
if(xb.Sign<0){ TwosComplement(xb.reg,0,(int)xb.reg.Length); }
xa.negative^=(xb.Sign<0);
XorWords((xa.reg),(xa.reg),(xb.reg),(int)xa.reg.Length);
if(xa.Sign<0){ TwosComplement(xa.reg,0,(int)xa.reg.Length); }
xa.wordCount=xa.CalcWordCount();
if(xa.wordCount==0)xa.negative=false;
return xa;
}
public static string BigIntToString(BigInteger bigint)
{
return bigint.ToString();
}
internal static BigInteger FindPowerOfFiveFromBig(BigInteger diff)
{
int sign=diff.Sign;
if(sign<0)return BigInteger.Zero;
if (sign == 0) return BigInteger.One;
FastInteger intcurexp = FastInteger.FromBig(diff);
if (intcurexp.CompareToInt(54) <= 0) {
return FindPowerOfFive(intcurexp.AsInt32());
}
BigInteger mantissa = BigInteger.One;
BigInteger bigpow;
BigInteger origdiff=diff;
bigpow=powerOfFiveCache.GetCachedPower(origdiff);
if(bigpow!=null)return bigpow;
BigInteger[] otherPower=powerOfFiveCache.FindCachedPowerOrSmaller(origdiff);
if(otherPower!=null){
intcurexp.SubtractBig(otherPower[0]);
bigpow=otherPower[1];
mantissa=bigpow;
} else {
bigpow = BigInteger.Zero;
}
while (intcurexp.Sign > 0) {
if (intcurexp.CompareToInt(27) <= 0) {
bigpow = FindPowerOfFive(intcurexp.AsInt32());
mantissa *= (BigInteger)bigpow;
break;
} else if (intcurexp.CompareToInt(9999999) <= 0) {
bigpow = BigInteger.Pow(FindPowerOfFive(1), intcurexp.AsInt32());
mantissa *= (BigInteger)bigpow;
break;
} else {
if (bigpow.IsZero)
bigpow = BigInteger.Pow(FindPowerOfFive(1), 9999999);
mantissa *= bigpow;
intcurexp.AddInt(-9999999);
}
}
powerOfFiveCache.AddPower(origdiff,mantissa);
return mantissa;
}
private void ShiftRightBig(int bits)
{
if (bits <= 0) return;
if (shiftedBigInt.IsZero) {
discardedBitCount.AddInt(bits);
bitsAfterLeftmost |= bitLeftmost;
bitLeftmost = 0;
knownBitLength=new FastInteger(1);
return;
}
byte[] bytes = shiftedBigInt.ToByteArray();
knownBitLength = ByteArrayBitLength(bytes);
FastInteger bitDiff = new FastInteger(0);
FastInteger bitShift=null;
if (knownBitLength.CompareToInt(bits)<0) {
bitDiff = new FastInteger(bits).Subtract(knownBitLength);
bitShift=FastInteger.Copy(knownBitLength);
} else {
bitShift=new FastInteger(bits);
}
if (knownBitLength.CompareToInt(bits)<=0) {
isSmall = true;
shiftedSmall = 0;
knownBitLength.SetInt(1);
} else {
FastInteger tmpBitShift = FastInteger.Copy(bitShift);
while (tmpBitShift.Sign > 0 && !shiftedBigInt.IsZero) {
int bs = tmpBitShift.MinInt32(1000000);
shiftedBigInt >>= bs;
tmpBitShift.SubtractInt(bs);
}
knownBitLength.Subtract(bitShift);
}
discardedBitCount.AddInt(bits);
bitsAfterLeftmost |= bitLeftmost;
for (int i = 0; i < bytes.Length; i++) {
if (bitShift.CompareToInt(8)>0) {
// Discard all the bits, they come
// after the leftmost bit
bitsAfterLeftmost |= bytes[i];
bitShift.SubtractInt(8);
} else {
// 8 or fewer bits left.
// Get the bottommost bitShift minus 1 bits
bitsAfterLeftmost |= ((bytes[i] << (9 - bitShift.AsInt32())) & 0xFF);
// Get the bit just above those bits
bitLeftmost = (bytes[i] >> ((bitShift.AsInt32()) - 1)) & 0x01;
break;
}
}
bitsAfterLeftmost = (bitsAfterLeftmost != 0) ? 1 : 0;
if (bitDiff.Sign > 0) {
// Shifted more bits than the bit length
bitsAfterLeftmost |= bitLeftmost;
bitLeftmost = 0;
}
}
/// <summary> </summary>
/// <param name='input'>A BigInteger object.</param>
/// <param name='output'>A BigInteger object.</param>
/// <returns></returns>
public void AddPower(BigInteger input, BigInteger output)
{
lock(outputs){
if(size<MaxSize){
// Shift newer entries down
for(int i=size;i>0;i--){
inputs[i]=inputs[i-1];
outputs[i]=outputs[i-1];
}
inputs[0]=input;
outputs[0]=output;
size++;
} else {
// Shift newer entries down
for(int i=MaxSize-1;i>0;i--){
inputs[i]=inputs[i-1];
outputs[i]=outputs[i-1];
}
inputs[0]=input;
outputs[0]=output;
}
}
}
private static decimal EncodeDecimal(BigInteger bigmant,
int scale, bool neg)
{
if((scale)<0)throw new ArgumentException("scale"+" not greater or equal to "+"0"+" ("+Convert.ToString((scale),System.Globalization.CultureInfo.InvariantCulture)+")");
if((scale)>28)throw new ArgumentException("scale"+" not less or equal to "+"28"+" ("+Convert.ToString((scale),System.Globalization.CultureInfo.InvariantCulture)+")");
byte[] data=bigmant.ToByteArray();
int a=0;
int b=0;
int c=0;
for(int i=0;i<Math.Min(4,data.Length);i++){
a|=(((int)data[i])&0xFF)<<((i)*8);
}
for(int i=4;i<Math.Min(8,data.Length);i++){
b|=(((int)data[i])&0xFF)<<((i-4)*8);
}
for(int i=8;i<Math.Min(12,data.Length);i++){
c|=(((int)data[i])&0xFF)<<((i-8)*8);
}
int d = (scale << 16);
if (neg) d |= (1 << 31);
return new Decimal(new int[] { a, b, c, d });
}
/// <summary> </summary>
/// <param name='bi'>A BigInteger object.</param>
/// <returns>A BigInteger object.</returns>
public BigInteger GetCachedPower(BigInteger bi)
{
lock(outputs){
for(int i=0;i<size;i++){
if(bi.Equals(inputs[i])){
if(i!=0){
BigInteger tmp;
// Move to head of cache if it isn't already
tmp=inputs[i];inputs[i]=inputs[0];inputs[0]=tmp;
tmp=outputs[i];outputs[i]=outputs[0];outputs[0]=tmp;
// Move formerly newest to next newest
if(i!=1){
tmp=inputs[i];inputs[i]=inputs[1];inputs[1]=tmp;
tmp=outputs[i];outputs[i]=outputs[1];outputs[1]=tmp;
}
}
return outputs[0];
}
}
}
return null;
}
public static BigInteger Abs(BigInteger thisValue){
if((thisValue)==null)throw new ArgumentNullException("thisValue");
return thisValue.abs();
}
