public void TestDivideAndRemainder()
{
// TODO More basic tests
IBigInteger n = new BigInteger(48, _random);
IBigInteger[] qr = n.DivideAndRemainder(one);
Assert.AreEqual(n, qr[0]);
Assert.AreEqual(zero, qr[1]);
for (int rep = 0; rep < 10; ++rep)
{
IBigInteger a = new BigInteger(100 - rep, 0, _random);
IBigInteger b = new BigInteger(100 + rep, 0, _random);
IBigInteger c = new BigInteger(10 + rep, 0, _random);
IBigInteger d = a.Multiply(b).Add(c);
IBigInteger[] es = d.DivideAndRemainder(a);
Assert.AreEqual(b, es[0]);
Assert.AreEqual(c, es[1]);
}
// Special tests for power of two since uses different code path internally
for (int i = 0; i < 100; ++i)
{
int shift = _random.Next(64);
IBigInteger a = one.ShiftLeft(shift);
IBigInteger b = new BigInteger(64 + _random.Next(64), _random);
IBigInteger bShift = b.ShiftRight(shift);
IBigInteger bMod = b.And(a.Subtract(one));
string data = "shift=" + shift + ", b=" + b.ToString(16);
qr = b.DivideAndRemainder(a);
Assert.AreEqual(bShift, qr[0], data);
Assert.AreEqual(bMod, qr[1], data);
qr = b.DivideAndRemainder(a.Negate());
Assert.AreEqual(bShift.Negate(), qr[0], data);
Assert.AreEqual(bMod, qr[1], data);
qr = b.Negate().DivideAndRemainder(a);
Assert.AreEqual(bShift.Negate(), qr[0], data);
Assert.AreEqual(bMod.Negate(), qr[1], data);
qr = b.Negate().DivideAndRemainder(a.Negate());
Assert.AreEqual(bShift, qr[0], data);
Assert.AreEqual(bMod.Negate(), qr[1], data);
}
}
public void TestBitCount()
{
Assert.AreEqual(0, zero.BitCount);
Assert.AreEqual(1, one.BitCount);
Assert.AreEqual(0, minusOne.BitCount);
Assert.AreEqual(1, two.BitCount);
Assert.AreEqual(1, minusTwo.BitCount);
for (int i = 0; i < 100; ++i)
{
IBigInteger pow2 = one.ShiftLeft(i);
Assert.AreEqual(1, pow2.BitCount);
Assert.AreEqual(i, pow2.Negate().BitCount);
}
for (int i = 0; i < 10; ++i)
{
IBigInteger test = new BigInteger(128, 0, _random);
int bitCount = 0;
for (int bit = 0; bit < test.BitLength; ++bit)
{
if (test.TestBit(bit))
{
++bitCount;
}
}
Assert.AreEqual(bitCount, test.BitCount);
}
}
public void TestMultiply()
{
IBigInteger one = BigInteger.One;
Assert.AreEqual(one, one.Negate().Multiply(one.Negate()));
for (int i = 0; i < 100; ++i)
{
int aLen = 64 + _random.Next(64);
int bLen = 64 + _random.Next(64);
IBigInteger a = new BigInteger(aLen, _random).SetBit(aLen);
IBigInteger b = new BigInteger(bLen, _random).SetBit(bLen);
IBigInteger c = new BigInteger(32, _random);
IBigInteger ab = a.Multiply(b);
IBigInteger bc = b.Multiply(c);
Assert.AreEqual(ab.Add(bc), a.Add(c).Multiply(b));
Assert.AreEqual(ab.Subtract(bc), a.Subtract(c).Multiply(b));
}
// Special tests for power of two since uses different code path internally
for (int i = 0; i < 100; ++i)
{
int shift = _random.Next(64);
IBigInteger a = one.ShiftLeft(shift);
IBigInteger b = new BigInteger(64 + _random.Next(64), _random);
IBigInteger bShift = b.ShiftLeft(shift);
Assert.AreEqual(bShift, a.Multiply(b));
Assert.AreEqual(bShift.Negate(), a.Multiply(b.Negate()));
Assert.AreEqual(bShift.Negate(), a.Negate().Multiply(b));
Assert.AreEqual(bShift, a.Negate().Multiply(b.Negate()));
Assert.AreEqual(bShift, b.Multiply(a));
Assert.AreEqual(bShift.Negate(), b.Multiply(a.Negate()));
Assert.AreEqual(bShift.Negate(), b.Negate().Multiply(a));
Assert.AreEqual(bShift, b.Negate().Multiply(a.Negate()));
}
}
public void TestSetBit()
{
Assert.AreEqual(one, zero.SetBit(0));
Assert.AreEqual(one, one.SetBit(0));
Assert.AreEqual(three, two.SetBit(0));
Assert.AreEqual(two, zero.SetBit(1));
Assert.AreEqual(three, one.SetBit(1));
Assert.AreEqual(two, two.SetBit(1));
// TODO Tests for setting bits in negative numbers
// TODO Tests for setting extended bits
for (int i = 0; i < 10; ++i)
{
IBigInteger n = new BigInteger(128, _random);
for (int j = 0; j < 10; ++j)
{
int pos = _random.Next(128);
IBigInteger m = n.SetBit(pos);
bool test = m.ShiftRight(pos).Remainder(two).Equals(one);
Assert.IsTrue(test);
}
}
for (int i = 0; i < 100; ++i)
{
IBigInteger pow2 = one.ShiftLeft(i);
IBigInteger minusPow2 = pow2.Negate();
Assert.AreEqual(pow2, pow2.SetBit(i));
Assert.AreEqual(minusPow2, minusPow2.SetBit(i));
IBigInteger bigI = BigInteger.ValueOf(i);
IBigInteger negI = bigI.Negate();
for (int j = 0; j < 10; ++j)
{
string data = "i=" + i + ", j=" + j;
Assert.AreEqual(bigI.Or(one.ShiftLeft(j)), bigI.SetBit(j), data);
Assert.AreEqual(negI.Or(one.ShiftLeft(j)), negI.SetBit(j), data);
}
}
}
public void TestModPow()
{
try
{
two.ModPow(one, zero);
Assert.Fail("expected ArithmeticException");
}
catch (ArithmeticException) {}
Assert.AreEqual(zero, zero.ModPow(zero, one));
Assert.AreEqual(one, zero.ModPow(zero, two));
Assert.AreEqual(zero, two.ModPow(one, one));
Assert.AreEqual(one, two.ModPow(zero, two));
for (int i = 0; i < 10; ++i)
{
IBigInteger m = BigInteger.ProbablePrime(10 + i * 3, _random);
IBigInteger x = new BigInteger(m.BitLength - 1, _random);
Assert.AreEqual(x, x.ModPow(m, m));
if (x.SignValue != 0)
{
Assert.AreEqual(zero, zero.ModPow(x, m));
Assert.AreEqual(one, x.ModPow(m.Subtract(one), m));
}
IBigInteger y = new BigInteger(m.BitLength - 1, _random);
IBigInteger n = new BigInteger(m.BitLength - 1, _random);
IBigInteger n3 = n.ModPow(three, m);
IBigInteger resX = n.ModPow(x, m);
IBigInteger resY = n.ModPow(y, m);
IBigInteger res = resX.Multiply(resY).Mod(m);
IBigInteger res3 = res.ModPow(three, m);
Assert.AreEqual(res3, n3.ModPow(x.Add(y), m));
IBigInteger a = x.Add(one); // Make sure it's not zero
IBigInteger b = y.Add(one); // Make sure it's not zero
Assert.AreEqual(a.ModPow(b, m).ModInverse(m), a.ModPow(b.Negate(), m));
}
}
public void TestToByteArrayUnsigned()
{
byte[] z = BigInteger.Zero.ToByteArrayUnsigned();
Assert.IsTrue(Arrays.AreEqual(new byte[0], z));
for (int i = 16; i <= 48; ++i)
{
IBigInteger x = BigInteger.ProbablePrime(i, _random);
byte[] b = x.ToByteArrayUnsigned();
Assert.AreEqual((i + 7) / 8, b.Length);
IBigInteger y = new BigInteger(1, b);
Assert.AreEqual(x, y);
x = x.Negate();
b = x.ToByteArrayUnsigned();
Assert.AreEqual(i / 8 + 1, b.Length);
y = new BigInteger(b);
Assert.AreEqual(x, y);
}
}
public void TestBitLength()
{
Assert.AreEqual(0, zero.BitLength);
Assert.AreEqual(1, one.BitLength);
Assert.AreEqual(0, minusOne.BitLength);
Assert.AreEqual(2, two.BitLength);
Assert.AreEqual(1, minusTwo.BitLength);
for (int i = 0; i < 100; ++i)
{
int bit = i + _random.Next(64);
IBigInteger odd = new BigInteger(bit, _random).SetBit(bit + 1).SetBit(0);
IBigInteger pow2 = one.ShiftLeft(bit);
Assert.AreEqual(bit + 2, odd.BitLength);
Assert.AreEqual(bit + 2, odd.Negate().BitLength);
Assert.AreEqual(bit + 1, pow2.BitLength);
Assert.AreEqual(bit, pow2.Negate().BitLength);
}
}
public void TestFlipBit()
{
for (int i = 0; i < 10; ++i)
{
IBigInteger a = new BigInteger(128, 0, _random);
IBigInteger b = a;
for (int x = 0; x < 100; ++x)
{
// Note: Intentionally greater than initial size
int pos = _random.Next(256);
a = a.FlipBit(pos);
b = b.TestBit(pos) ? b.ClearBit(pos) : b.SetBit(pos);
}
Assert.AreEqual(a, b);
}
for (int i = 0; i < 100; ++i)
{
IBigInteger pow2 = one.ShiftLeft(i);
IBigInteger minusPow2 = pow2.Negate();
Assert.AreEqual(zero, pow2.FlipBit(i));
Assert.AreEqual(minusPow2.ShiftLeft(1), minusPow2.FlipBit(i));
IBigInteger bigI = BigInteger.ValueOf(i);
IBigInteger negI = bigI.Negate();
for (int j = 0; j < 10; ++j)
{
string data = "i=" + i + ", j=" + j;
Assert.AreEqual(bigI.Xor(one.ShiftLeft(j)), bigI.FlipBit(j), data);
Assert.AreEqual(negI.Xor(one.ShiftLeft(j)), negI.FlipBit(j), data);
}
}
}
public IBigInteger Add(
IBigInteger value)
{
if (this.SignValue == 0)
return value;
if (this.SignValue != value.SignValue)
{
if (value.SignValue == 0)
return this;
if (value.SignValue < 0)
return Subtract(value.Negate());
return value.Subtract(Negate());
}
return AddToMagnitude(value.Magnitude);
}
public IBigInteger Subtract(
IBigInteger n)
{
if (n.SignValue == 0)
return this;
if (this.SignValue == 0)
return n.Negate();
if (this.SignValue != n.SignValue)
return Add(n.Negate());
int compare = CompareNoLeadingZeroes(0, Magnitude, 0, n.Magnitude);
if (compare == 0)
return Zero;
IBigInteger bigun, lilun;
if (compare < 0)
{
bigun = n;
lilun = this;
}
else
{
bigun = this;
lilun = n;
}
return new BigInteger(this.SignValue*compare, doSubBigLil(bigun.Magnitude, lilun.Magnitude), true);
}
public SimpleBigDecimal Negate()
{
return(new SimpleBigDecimal(bigInt.Negate(), scale));
}
public void TestDivide()
{
for (int i = -5; i <= 5; ++i)
{
try
{
val(i).Divide(zero);
Assert.Fail("expected ArithmeticException");
}
catch (ArithmeticException) {}
}
int product = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9;
int productPlus = product + 1;
IBigInteger bigProduct = val(product);
IBigInteger bigProductPlus = val(productPlus);
for (int divisor = 1; divisor < 10; ++divisor)
{
// Exact division
IBigInteger expected = val(product / divisor);
Assert.AreEqual(expected, bigProduct.Divide(val(divisor)));
Assert.AreEqual(expected.Negate(), bigProduct.Negate().Divide(val(divisor)));
Assert.AreEqual(expected.Negate(), bigProduct.Divide(val(divisor).Negate()));
Assert.AreEqual(expected, bigProduct.Negate().Divide(val(divisor).Negate()));
expected = val((product + 1) / divisor);
Assert.AreEqual(expected, bigProductPlus.Divide(val(divisor)));
Assert.AreEqual(expected.Negate(), bigProductPlus.Negate().Divide(val(divisor)));
Assert.AreEqual(expected.Negate(), bigProductPlus.Divide(val(divisor).Negate()));
Assert.AreEqual(expected, bigProductPlus.Negate().Divide(val(divisor).Negate()));
}
for (int rep = 0; rep < 10; ++rep)
{
IBigInteger a = new BigInteger(100 - rep, 0, _random);
IBigInteger b = new BigInteger(100 + rep, 0, _random);
IBigInteger c = new BigInteger(10 + rep, 0, _random);
IBigInteger d = a.Multiply(b).Add(c);
IBigInteger e = d.Divide(a);
Assert.AreEqual(b, e);
}
// Special tests for power of two since uses different code path internally
for (int i = 0; i < 100; ++i)
{
int shift = _random.Next(64);
IBigInteger a = one.ShiftLeft(shift);
IBigInteger b = new BigInteger(64 + _random.Next(64), _random);
IBigInteger bShift = b.ShiftRight(shift);
string data = "shift=" + shift + ", b=" + b.ToString(16);
Assert.AreEqual(bShift, b.Divide(a), data);
Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
}
// Regression
{
int shift = 63;
IBigInteger a = one.ShiftLeft(shift);
IBigInteger b = new BigInteger(1, Hex.Decode("2504b470dc188499"));
IBigInteger bShift = b.ShiftRight(shift);
string data = "shift=" + shift + ", b=" + b.ToString(16);
Assert.AreEqual(bShift, b.Divide(a), data);
Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
// Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
}
}
