public static string RandomTextString(RandomGenerator rand) {
int length = rand.UniformInt(0x2000);
var sb = new StringBuilder();
for (var i = 0; i < length; ++i) {
int x = rand.UniformInt(100);
if (x < 95) {
// ASCII
sb.Append((char)(0x20 + rand.UniformInt(0x60)));
} else if (x < 98) {
// Supplementary character
x = rand.UniformInt(0x400) + 0xd800;
sb.Append((char)x);
x = rand.UniformInt(0x400) + 0xdc00;
sb.Append((char)x);
} else {
// BMP character
x = 0x20 + rand.UniformInt(0xffe0);
if (x >= 0xd800 && x < 0xe000) {
// surrogate code unit, generate ASCII instead
x = 0x20 + rand.UniformInt(0x60);
}
sb.Append((char)x);
}
}
return sb.ToString();
}
public static String RandomDecimalString(RandomGenerator r)
{
int count = r.UniformInt(40) + 1;
var sb = new StringBuilder();
if (r.UniformInt(2) == 0) {
sb.Append('-');
}
for (var i = 0; i < count; ++i) {
if (i == 0 && count > 1) {
sb.Append((char)('1' + r.UniformInt(9)));
} else {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
if (r.UniformInt(2) == 0) {
sb.Append('.');
count = r.UniformInt(30) + 1;
for (var i = 0; i < count; ++i) {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
if (r.UniformInt(2) == 0) {
sb.Append('E');
count = (r.UniformInt(100) < 10) ? r.UniformInt(5000) :
r.UniformInt(20);
if (count != 0) {
sb.Append(r.UniformInt(2) == 0 ? '+' : '-');
}
sb.Append(TestCommon.IntToString(count));
}
return sb.ToString();
}
public static byte[] RandomByteStringShort(RandomGenerator rand) {
int x = rand.UniformInt(50);
var bytes = new byte[x];
for (var i = 0; i < x; ++i) {
bytes[i] = unchecked((byte)rand.UniformInt(256));
}
return bytes;
}
public static ERational RandomERational(RandomGenerator rand) {
EInteger bigintA = RandomEInteger(rand);
EInteger bigintB = RandomEInteger(rand);
if (bigintB.IsZero) {
bigintB = EInteger.One;
}
return ERational.Create(bigintA, bigintB);
}
public static string RandomLatinOne(RandomGenerator rnd)
{
int length = rnd.UniformInt(50) + 1;
var sb = new StringBuilder();
for (var i = 0; i < length; ++i) {
var c = (char)rnd.UniformInt(256);
sb.Append(c);
}
return sb.ToString();
}
public static CBORObject RandomCBORArray(RandomGenerator rand, int depth)
{
int x = rand.UniformInt(100);
int count = (x < 80) ? 2 : ((x < 93) ? 1 : ((x < 98) ? 0 : 10));
CBORObject cborRet = CBORObject.NewArray();
for (var i = 0; i < count; ++i) {
cborRet.Add(RandomCBORObject(rand, depth + 1));
}
return cborRet;
}
public static long RandomInt64(RandomGenerator rand) {
long r = rand.UniformInt(0x10000);
r |= ((long)rand.UniformInt(0x10000)) << 16;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 32;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 48;
}
}
return r;
}
public static CBORObject RandomCBORMap(RandomGenerator rand, int depth)
{
int x = rand.UniformInt(100);
int count = (x < 80) ? 2 : ((x < 93) ? 1 : ((x < 98) ? 0 : 10));
CBORObject cborRet = CBORObject.NewMap();
for (var i = 0; i < count; ++i) {
CBORObject key = RandomCBORObject(rand, depth + 1);
CBORObject value = RandomCBORObject(rand, depth + 1);
cborRet[key] = value;
}
return cborRet;
}
public static String RandomBigIntString(RandomGenerator r)
{
int count = r.UniformInt(50) + 1;
var sb = new StringBuilder();
if (r.UniformInt(2) == 0) {
sb.Append('-');
}
for (var i = 0; i < count; ++i) {
if (i == 0) {
sb.Append((char)('1' + r.UniformInt(9)));
} else {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
return sb.ToString();
}
public static double RandomDouble(RandomGenerator rand, int exponent) {
if (exponent == Int32.MaxValue) {
exponent = rand.UniformInt(2047);
}
long r = rand.UniformInt(0x10000);
r |= ((long)rand.UniformInt(0x10000)) << 16;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 32;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 48;
}
}
r &= ~0x7ff0000000000000L; // clear exponent
r |= ((long)exponent) << 52; // set exponent
return BitConverter.ToDouble(BitConverter.GetBytes((long)r), 0);
}
public void TestAdd() {
try {
EFloat.Zero.Add(null, EContext.Unlimited);
Assert.Fail("Should have failed");
} catch (ArgumentNullException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
var fr = new RandomGenerator();
TestAddCloseExponent(fr, 0);
TestAddCloseExponent(fr, 100);
TestAddCloseExponent(fr, -100);
TestAddCloseExponent(fr, Int32.MinValue);
TestAddCloseExponent(fr, Int32.MaxValue);
}
public void TestShiftLeft() {
EInteger bigint = EInteger.One;
bigint <<= 100;
TestCommon.CompareTestEqualAndConsistent(bigint << 12, bigint >> -12);
TestCommon.CompareTestEqualAndConsistent(bigint << -12, bigint >> 12);
var r = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
EInteger bigintB = bigintA;
for (int j = 0; j < 100; ++j) {
EInteger ba = bigintA;
ba <<= j;
TestCommon.CompareTestEqualAndConsistent(bigintB, ba);
int negj = -j;
ba = bigintA;
ba >>= negj;
TestCommon.CompareTestEqualAndConsistent(bigintB, ba);
bigintB *= (EInteger)2;
}
}
}
public void TestPow() {
var r = new RandomGenerator();
for (var i = 0; i < 200; ++i) {
int power = 1 + r.UniformInt(8);
EInteger bigintA = RandomBigInteger(r);
EInteger bigintB = bigintA;
for (int j = 1; j < power; ++j) {
bigintB *= bigintA;
}
DoTestPow(bigintA.ToString(), power, bigintB.ToString());
}
}
public void TestMultiplyDivideA() {
var r = new RandomGenerator();
for (var i = 1; i < 25; ++i) {
for (var j = 1; j < i; ++j) {
EInteger bigA, bigB;
int highWord;
bigA = AllOnesInteger(i);
bigB = AllOnesInteger(j);
TestMultiplyDivideOne(bigA, bigB);
highWord = r.UniformInt(0x8000, 0x10000);
bigA = EInteger.FromInt32(highWord).ShiftLeft(i * 16).Add(bigA);
bigB = EInteger.FromInt32(highWord).ShiftLeft(j * 16).Add(bigB);
TestMultiplyDivideOne(bigA, bigB);
bigA = ZerosAndOnesInteger(i);
bigB = ZerosAndOnesInteger(j);
TestMultiplyDivideOne(bigA, bigB);
highWord = r.UniformInt(0x8000, 0x10000);
bigA = EInteger.FromInt32(highWord).ShiftLeft(i * 16).Add(bigA);
bigB = EInteger.FromInt32(highWord).ShiftLeft(j * 16).Add(bigB);
TestMultiplyDivideOne(bigA, bigB);
}
}
EInteger startIntA = ZerosAndOnesInteger(100);
EInteger startIntB = ZerosAndOnesInteger(50);
for (var i = 1; i < 500; ++i) {
EInteger bigA = FuzzInteger(startIntA, r.UniformInt(1, 100), r);
EInteger bigB = FuzzInteger(startIntB, r.UniformInt(1, 50), r);
TestMultiplyDivideOne(bigA, bigB);
}
{
EInteger ei1 = EInteger.FromRadixString(
"101000101010100000001000100000101000000000100000101000100010101000001010000000001010101000101010100010100",
16);
EInteger ei2 = EInteger.FromRadixString(
"100000000000100010000000100000000010001000100010000010101010100000000000000000000",
16);
TestMultiplyDivideOne(ei1, ei2);
ei1 = EInteger.FromString
("44461738044811866704570272160729755524383493147516085922742403681586307620758054502667856562873477505768158700319760453047044081412393321568753479912147358343844563186048273758088945022589574729044743021988362306225753942249201773678443992606696524197361479929661991788310321409367753462284203449631729626517511224343015354155975783754763572354740724506742793459644155837703671449155713000260325445046273385372701820583016334341594713806706345456633635125343104401883366671083569152");
ei2 = EInteger.FromString
("6667912688606651657935168942074070387623462798286393292334546164025938697493268465740399785103348978411106010660409247384863031649363973174034406552719188394559243700794785023362300512913065060420313203793021880700852215978918600154969735168");
TestMultiplyDivideOne (ei1, ei2);
}
for (var i = 0; i < 1000; ++i) {
EInteger bigA, bigB;
do {
bigA = WordAlignedInteger(r);
bigB = WordAlignedInteger(r);
} while (bigA.CompareTo(bigB) <= 0);
TestMultiplyDivideOne(bigA, bigB);
}
for (var i = 0; i < 10000; ++i) {
EInteger bigA = RandomObjects.RandomEInteger(r);
EInteger bigB = RandomObjects.RandomEInteger(r);
TestMultiplyDivideOne(bigA, bigB);
}
TestMultiplyDivideOne(EInteger.FromInt32(-985), EInteger.FromInt32(0));
}
private static EInteger FuzzInteger(
EInteger ei,
int fuzzes,
RandomGenerator r) {
byte[] bytes = ei.ToBytes(true);
int bits = ei.GetUnsignedBitLength();
for (var i = 0; i < fuzzes; ++i) {
int bit = r.UniformInt(bits);
bytes[bit / 8] ^= (byte)(1 << (bit & 0x07));
}
return EInteger.FromBytes(bytes, true);
}
public void TestDivide() {
int intA, intB;
DoTestDivide
("39401404978667143593022554770633078187236345017741021112301638514137074723630749875836463116600753265992771999563776"
,
"6277005955876855982708123588802319701019026907066160578560",
"6277101735386680763835789423207589043669308487479442014208");
DoTestDivide ("340277174703306882242637262502835978240",
"79226953606891185567396986880", "4294967296");
DoTestDivide (
"44461738044811866704570272160729755524383493147516085922742403681586307620758054502667856562873477505768158700319760453047044081412393321568753479912147358343844563186048273758088945022589574729044743021988362306225753942249201773678443992606696524197361479929661991788310321409367753462284203449631729626517511224343015354155975783754763572354740724506742793459644155837703671449155713000260325445046273385372701820583016334341594713806706345456633635125343104401883366671083569152",
"6667912688606651657935168942074070387623462798286393292334546164025938697493268465740399785103348978411106010660409247384863031649363973174034406552719188394559243700794785023362300512913065060420313203793021880700852215978918600154969735168",
"6668014432879854274079851790721257797144739185760979705624542990230371779898108261760364709743735387156366994446448705720136517621612785459920009307944044809722559761949909348022458684413967432579072465854783948147327367860791365121685323776");
DoTestDivide(
"9999999999999999999999",
"281474976710655",
"35527136");
DoTestDivide("2472320648", "2831812081", "0");
DoTestDivide("-2472320648", "2831812081", "0");
var fr = new RandomGenerator();
for (var i = 0; i < 10000; ++i) {
intA = fr.UniformInt(0x1000000);
intB = fr.UniformInt(0x1000000);
if (intB == 0) {
continue;
}
int c = intA / intB;
var bigintA = (EInteger)intA;
var bigintB = (EInteger)intB;
EInteger bigintC = bigintA / (EInteger)bigintB;
Assert.AreEqual((int)bigintC, c);
}
DoTestDivide ("4294901760", "281470681808895", "0");
DoTestDivide ("281470681808895", "281470681808895", "1");
DoTestDivide ("281195803901951", "281470681808895", "0");
DoTestDivide ("281470681808895", "79226953606891185567396986880",
"0");
DoTestDivide ("1208907373151751269056511", "281470681808895",
"4294967295");
DoTestDivide ("1208907373151751269056511",
"79226953606891185567396986880", "0");
DoTestDivide ("79226953606891185567396986880",
"79226953606891185567396986880", "1");
DoTestDivide ("79226953606891185567396986880",
"79226953606891185567396986880", "1");
DoTestDivide ("79149582354435849300215791616",
"281470681808895", "281200094609408");
DoTestDivide ("79149582354435849304510693376",
"79226953606891185567396986880", "0");
DoTestDivide ("340277174703229510990181926235654782976",
"79226953606891185567396986880", "4294967295");
DoTestDivide ("340277174703229510990181926235654782976",
"79226953606891185567396986880", "4294967295");
DoTestDivide ("79226953606891185567396986880",
"6277005955876855982708123588802319701019026907066160578560",
"0");
DoTestDivide ("22278626849872979772991819660510225504468991",
"79226953606891185567396986880", "281200094609408");
DoTestDivide
("6270875973713392427274690200693718464284551950581721071616",
"79226953606891185567396986880",
"79150790081217380608951451648");
DoTestDivide
("6277005955876855982708123588802242329766571570798979383296",
"6277005955876855982708123588802319701019026907066160578560",
"0");
DoTestDivide
("6277005955876855982708123588802242329766571570798979383296",
"6277005955876855982708123588802319701019026907066160578560",
"0");
DoTestDivide
("26959535297282185466869868771998681536704617202858716036715199266816",
"6277005955876855982708123588802319701019026907066160578560",
"4294967295");
DoTestDivide
("496829980752160275550680055858571148163286974448396184421327120687227627818219200249856"
,
"6277005955876855982708123588802319701019026907066160578560",
"79150790081217380608951451648");
DoTestDivide
("2135954443842118711369801686589217620410698847025641089415087336821733096438436218376946913837056"
,
"6277005955876855982708123588802319701019026907066160578560",
"340282366920861091030327650447175712768");
}
public void TestCanFitInInt() {
var r = new RandomGenerator();
for (var i = 0; i < 2000; ++i) {
EInteger bigintA = RandomBigInteger(r);
Assert.AreEqual(
bigintA.CanFitInInt32(),
bigintA.GetSignedBitLength() <= 31);
Assert.AreEqual(
bigintA.CanFitInInt64(),
bigintA.GetSignedBitLength() <= 63);
}
}
public static EInteger RandomBigInteger(RandomGenerator r) {
int selection = r.UniformInt(100);
int count = r.UniformInt(60) + 1;
if (selection < 40) {
count = r.UniformInt(7) + 1;
}
if (selection < 50) {
count = r.UniformInt(15) + 1;
}
var bytes = new byte[count];
for (var i = 0; i < count; ++i) {
bytes[i] = (byte)((int)r.UniformInt(256));
}
return BigFromBytes(bytes);
}
public void TestToRadixString() {
var fr = new RandomGenerator();
try {
EInteger.One.ToRadixString(-1);
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
EInteger.One.ToRadixString(0);
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
EInteger.One.ToRadixString(1);
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
EInteger.One.ToRadixString(37);
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
EInteger.One.ToRadixString(Int32.MinValue);
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
EInteger.One.ToRadixString(Int32.MaxValue);
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
for (int i = 2; i <= 36; ++i) {
for (int j = 0; j < 100; ++j) {
StringAndBigInt sabi = StringAndBigInt.Generate(fr, i);
// Upper case result expected
string expected = ToUpperCaseAscii(sabi.StringValue);
var k = 0;
// Expects result with no unnecessary leading zeros
bool negative = sabi.BigIntValue.Sign < 0;
if (expected[0] == '-') {
++k;
}
while (k < expected.Length - 1) {
if (expected[k] == '0') {
++k;
} else {
break;
}
}
expected = expected.Substring(k);
if (negative) {
expected = "-" + expected;
}
Assert.AreEqual(
expected,
sabi.BigIntValue.ToRadixString(i));
}
}
var r = new RandomGenerator();
for (var radix = 2; radix < 36; ++radix) {
for (var i = 0; i < 80; ++i) {
EInteger bigintA = RandomBigInteger(r);
String s = bigintA.ToRadixString(radix);
EInteger big2 = EInteger.FromRadixString(s, radix);
Assert.AreEqual(big2.ToRadixString(radix), s);
}
}
}
public void TestShiftRight() {
EInteger bigint = EInteger.One;
bigint <<= 80;
TestCommon.CompareTestEqualAndConsistent(bigint << 12, bigint >> -12);
TestCommon.CompareTestEqualAndConsistent(bigint << -12, bigint >> 12);
var r = new RandomGenerator();
EInteger minusone = EInteger.Zero;
minusone -= EInteger.One;
for (var i = 0; i < 1000; ++i) {
int smallint = r.UniformInt(0x7fffffff);
var bigintA = (EInteger)smallint;
string str = bigintA.ToString();
for (int j = 32; j < 80; ++j) {
DoTestShiftRight2(str, j, EInteger.Zero);
DoTestShiftRight2("-" + str, j, minusone);
}
}
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
bigintA = bigintA.Abs();
EInteger bigintB = bigintA;
for (int j = 0; j < 100; ++j) {
EInteger ba = bigintA;
ba >>= j;
TestCommon.CompareTestEqualAndConsistent(bigintB, ba);
int negj = -j;
ba = bigintA;
ba <<= negj;
TestCommon.CompareTestEqualAndConsistent(bigintB, ba);
bigintB /= (EInteger)2;
}
}
}
public void TestSqrt() {
var r = new RandomGenerator();
for (var i = 0; i < 20; ++i) {
EInteger bigintA = RandomBigInteger(r);
if (bigintA.Sign < 0) {
bigintA = -bigintA;
}
if (bigintA.Sign == 0) {
bigintA = EInteger.One;
}
EInteger sqr = bigintA.Multiply(bigintA);
EInteger sr = sqr.Sqrt();
TestCommon.CompareTestEqual(bigintA, sr);
}
for (var i = 0; i < 10000; ++i) {
EInteger bigintA = RandomBigInteger(r);
if (bigintA.Sign < 0) {
bigintA = -bigintA;
}
if (bigintA.Sign == 0) {
bigintA = EInteger.One;
}
EInteger sr = bigintA.Sqrt();
EInteger srsqr = sr * (EInteger)sr;
sr += EInteger.One;
EInteger sronesqr = sr * (EInteger)sr;
if (srsqr.CompareTo(bigintA) > 0) {
Assert.Fail(srsqr + " not " + bigintA +
" or less (TestSqrt, sqrt=" + sr + ")");
}
if (sronesqr.CompareTo(bigintA) <= 0) {
Assert.Fail(srsqr + " not greater than " + bigintA +
" (TestSqrt, sqrt=" + sr + ")");
}
}
}
public void TestGcd() {
try {
EInteger.Zero.Gcd(null);
Assert.Fail("Should have failed");
} catch (ArgumentNullException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
{
string stringTemp = EInteger.Zero.Gcd(BigFromString(
"244")).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = EInteger.Zero.Gcd(BigFromString(
"-244")).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = BigFromString(
"244").Gcd(EInteger.Zero).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = BigFromString(
"-244").Gcd(EInteger.Zero).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = EInteger.One.Gcd(BigFromString("244")).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = EInteger.One.Gcd(BigFromString(
"-244")).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = BigFromString("244").Gcd(EInteger.One).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = BigFromString(
"-244").Gcd(EInteger.One).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = BigFromString("15").Gcd(BigFromString(
"15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
{
string stringTemp = BigFromString("-15").Gcd(
BigFromString("15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
{
string stringTemp = BigFromString("15").Gcd(
BigFromString("-15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
{
string stringTemp = BigFromString(
"-15").Gcd(BigFromString("-15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
var prime = 0;
var rand = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
while (true) {
prime = rand.UniformInt(0x7fffffff);
prime |= 1;
if (IsPrime(prime)) {
break;
}
}
var bigprime = (EInteger)prime;
EInteger ba = RandomBigInteger(rand);
if (ba.IsZero) {
continue;
}
ba *= (EInteger)bigprime;
Assert.AreEqual(
bigprime,
bigprime.Gcd(ba));
}
TestGcdPair((EInteger)(-1867), (EInteger)(-4456), EInteger.One);
TestGcdPair((EInteger)4604, (EInteger)(-4516), (EInteger)4);
TestGcdPair((EInteger)(-1756), (EInteger)4525, EInteger.One);
TestGcdPair((EInteger)1568, (EInteger)(-4955), EInteger.One);
TestGcdPair((EInteger)2519, (EInteger)2845, EInteger.One);
TestGcdPair((EInteger)(-1470), (EInteger)132, (EInteger)6);
TestGcdPair((EInteger)(-2982), (EInteger)2573, EInteger.One);
TestGcdPair((EInteger)(-244), (EInteger)(-3929), EInteger.One);
TestGcdPair((EInteger)(-3794), (EInteger)(-2325), EInteger.One);
TestGcdPair((EInteger)(-2667), (EInteger)2123, EInteger.One);
TestGcdPair((EInteger)(-3712), (EInteger)(-1850), (EInteger)2);
TestGcdPair((EInteger)2329, (EInteger)3874, EInteger.One);
TestGcdPair((EInteger)1384, (EInteger)(-4278), (EInteger)2);
TestGcdPair((EInteger)213, (EInteger)(-1217), EInteger.One);
TestGcdPair((EInteger)1163, (EInteger)2819, EInteger.One);
TestGcdPair((EInteger)1921, (EInteger)(-579), EInteger.One);
TestGcdPair((EInteger)3886, (EInteger)(-13), EInteger.One);
TestGcdPair((EInteger)(-3270), (EInteger)(-3760), (EInteger)10);
TestGcdPair((EInteger)(-3528), (EInteger)1822, (EInteger)2);
TestGcdPair((EInteger)1547, (EInteger)(-333), EInteger.One);
TestGcdPair((EInteger)2402, (EInteger)2850, (EInteger)2);
TestGcdPair((EInteger)4519, (EInteger)1296, EInteger.One);
TestGcdPair((EInteger)1821, (EInteger)2949, (EInteger)3);
TestGcdPair((EInteger)(-2634), (EInteger)(-4353), (EInteger)3);
TestGcdPair((EInteger)(-1728), (EInteger)199, EInteger.One);
TestGcdPair((EInteger)(-4646), (EInteger)(-1418), (EInteger)2);
TestGcdPair((EInteger)(-35), (EInteger)(-3578), EInteger.One);
TestGcdPair((EInteger)(-2244), (EInteger)(-3250), (EInteger)2);
TestGcdPair((EInteger)(-3329), (EInteger)1039, EInteger.One);
TestGcdPair((EInteger)(-3064), (EInteger)(-4730), (EInteger)2);
TestGcdPair((EInteger)(-1214), (EInteger)4130, (EInteger)2);
TestGcdPair((EInteger)(-3038), (EInteger)(-3184), (EInteger)2);
TestGcdPair((EInteger)(-209), (EInteger)(-1617), (EInteger)11);
TestGcdPair((EInteger)(-1101), (EInteger)(-2886), (EInteger)3);
TestGcdPair((EInteger)(-3021), (EInteger)(-4499), EInteger.One);
TestGcdPair((EInteger)3108, (EInteger)1815, (EInteger)3);
TestGcdPair((EInteger)1195, (EInteger)4618, EInteger.One);
TestGcdPair((EInteger)(-3643), (EInteger)2156, EInteger.One);
TestGcdPair((EInteger)(-2067), (EInteger)(-3780), (EInteger)3);
TestGcdPair((EInteger)4251, (EInteger)1607, EInteger.One);
TestGcdPair((EInteger)438, (EInteger)741, (EInteger)3);
TestGcdPair((EInteger)(-3692), (EInteger)(-2135), EInteger.One);
TestGcdPair((EInteger)(-1076), (EInteger)2149, EInteger.One);
TestGcdPair((EInteger)(-3224), (EInteger)(-1532), (EInteger)4);
TestGcdPair((EInteger)(-3713), (EInteger)1721, EInteger.One);
TestGcdPair((EInteger)3038, (EInteger)(-2657), EInteger.One);
TestGcdPair((EInteger)4977, (EInteger)(-110), EInteger.One);
TestGcdPair((EInteger)(-3305), (EInteger)(-922), EInteger.One);
TestGcdPair((EInteger)1902, (EInteger)2481, (EInteger)3);
TestGcdPair((EInteger)(-4804), (EInteger)(-1378), (EInteger)2);
TestGcdPair((EInteger)(-1446), (EInteger)(-4226), (EInteger)2);
TestGcdPair((EInteger)(-1409), (EInteger)3303, EInteger.One);
TestGcdPair((EInteger)(-1626), (EInteger)(-3193), EInteger.One);
TestGcdPair((EInteger)912, (EInteger)(-421), EInteger.One);
TestGcdPair((EInteger)751, (EInteger)(-1755), EInteger.One);
TestGcdPair((EInteger)3135, (EInteger)(-3581), EInteger.One);
TestGcdPair((EInteger)(-4941), (EInteger)(-2885), EInteger.One);
TestGcdPair((EInteger)4744, (EInteger)3240, (EInteger)8);
TestGcdPair((EInteger)3488, (EInteger)4792, (EInteger)8);
TestGcdPair((EInteger)3632, (EInteger)3670, (EInteger)2);
TestGcdPair((EInteger)(-4821), (EInteger)(-1749), (EInteger)3);
TestGcdPair((EInteger)4666, (EInteger)2013, EInteger.One);
TestGcdPair((EInteger)810, (EInteger)(-3466), (EInteger)2);
TestGcdPair((EInteger)2199, (EInteger)161, EInteger.One);
TestGcdPair((EInteger)(-1137), (EInteger)(-1620), (EInteger)3);
TestGcdPair((EInteger)(-472), (EInteger)66, (EInteger)2);
TestGcdPair((EInteger)3825, (EInteger)2804, EInteger.One);
TestGcdPair((EInteger)(-2895), (EInteger)1942, EInteger.One);
TestGcdPair((EInteger)1576, (EInteger)(-4209), EInteger.One);
TestGcdPair((EInteger)(-277), (EInteger)(-4415), EInteger.One);
for (var i = 0; i < 1000; ++i) {
prime = rand.UniformInt(0x7fffffff);
if (rand.UniformInt(2) == 0) {
prime = -prime;
}
int intB = rand.UniformInt(0x7fffffff);
if (rand.UniformInt(2) == 0) {
intB = -intB;
}
var biga = (EInteger)prime;
var bigb = (EInteger)intB;
EInteger ba = biga.Gcd(bigb);
EInteger bb = bigb.Gcd(biga);
Assert.AreEqual(ba, bb);
}
}
public void TestToString() {
var bi = (EInteger)3;
AssertBigIntegersEqual("3", bi);
var negseven = (EInteger)(-7);
AssertBigIntegersEqual("-7", negseven);
var other = (EInteger)(-898989);
AssertBigIntegersEqual("-898989", other);
other = (EInteger)898989;
AssertBigIntegersEqual("898989", other);
var r = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
ExtraTest.TestStringEqualRoundTrip(bigintA);
}
// Test serialization of relatively big numbers
for (var i = 0; i < 20; ++i) {
EInteger bigintA = RandomBigInteger(r);
bigintA = bigintA.ShiftLeft(r.UniformInt(2000) + (16 * 500));
bigintA = bigintA.Subtract(RandomBigInteger(r));
ExtraTest.TestStringEqualRoundTrip(bigintA);
}
}
public void TestGetDigitCount() {
var r = new RandomGenerator();
{
object objectTemp = 39;
object objectTemp2 = EInteger.FromString(
"101754295360222878437145684059582837272").GetDigitCount();
Assert.AreEqual(objectTemp, objectTemp2);
}
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
String str = bigintA.Abs().ToString();
Assert.AreEqual(str.Length, bigintA.GetDigitCount(), str);
}
}
public void TestAddSubtract() {
var r = new RandomGenerator();
for (var i = 0; i < 10000; ++i) {
EInteger bigintA = RandomBigInteger(r);
EInteger bigintB = RandomBigInteger(r);
EInteger bigintC = bigintA + (EInteger)bigintB;
EInteger bigintD = bigintC - (EInteger)bigintB;
if (!bigintD.Equals(bigintA)) {
Assert.AreEqual(
bigintA,
bigintD,
"TestAddSubtract " + bigintA + "; " + bigintB);
}
bigintD = bigintC - (EInteger)bigintA;
if (!bigintD.Equals(bigintB)) {
Assert.AreEqual(
bigintB,
bigintD,
"TestAddSubtract " + bigintA + "; " + bigintB);
}
bigintC = bigintA - (EInteger)bigintB;
bigintD = bigintC + (EInteger)bigintB;
if (!bigintD.Equals(bigintA)) {
Assert.AreEqual(
bigintA,
bigintD,
"TestAddSubtract " + bigintA + "; " + bigintB);
}
}
}
public void TestIsEven() {
var r = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
EInteger mod = bigintA.Remainder(BigValueOf(2));
Assert.AreEqual(mod.IsZero, bigintA.IsEven);
if (bigintA.IsEven) {
bigintA = bigintA.Add(EInteger.One);
Assert.IsTrue(!bigintA.IsEven);
} else {
bigintA = bigintA.Add(EInteger.One);
Assert.IsTrue(bigintA.IsEven);
}
}
}
public void TestCompareTo() {
var r = new RandomGenerator();
for (var i = 0; i < 500; ++i) {
EInteger bigintA = RandomBigInteger(r);
EInteger bigintB = RandomBigInteger(r);
EInteger bigintC = RandomBigInteger(r);
TestCommon.CompareTestRelations(bigintA, bigintB, bigintC);
TestCommon.CompareTestConsistency(bigintA, bigintB, bigintC);
}
}
public void TestMultiply() {
try {
EInteger.One.Multiply(null);
Assert.Fail("Should have failed");
} catch (ArgumentNullException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
var r = new RandomGenerator();
for (var i = 0; i < 10000; ++i) {
EInteger bigintA = RandomBigInteger(r);
EInteger bigintB = bigintA + EInteger.One;
EInteger bigintC = bigintA * (EInteger)bigintB;
// Test near-squaring
if (bigintA.IsZero || bigintB.IsZero) {
Assert.AreEqual(EInteger.Zero, bigintC);
}
if (bigintA.Equals(EInteger.One)) {
Assert.AreEqual(bigintB, bigintC);
}
if (bigintB.Equals(EInteger.One)) {
Assert.AreEqual(bigintA, bigintC);
}
bigintB = bigintA;
// Test squaring
bigintC = bigintA * (EInteger)bigintB;
if (bigintA.IsZero || bigintB.IsZero) {
Assert.AreEqual(EInteger.Zero, bigintC);
}
if (bigintA.Equals(EInteger.One)) {
Assert.AreEqual(bigintB, bigintC);
}
if (bigintB.Equals(EInteger.One)) {
Assert.AreEqual(bigintA, bigintC);
}
}
DoTestMultiply(
"39258416159456516340113264558732499166970244380745050",
"39258416159456516340113264558732499166970244380745051",
"1541223239349076530208308657654362309553698742116222355477449713742236585667505604058123112521437480247550");
DoTestMultiply(
"5786426269322750882632312999752639738983363095641642905722171221986067189342123124290107105663618428969517616421742429671402859775667602123564",
"331378991485809774307751183645559883724387697397707434271522313077548174328632968616330900320595966360728317363190772921",
"1917500101435169880779183578665955372346028226046021044867189027856189131730889958057717187493786883422516390996639766012958050987359732634213213442579444095928862861132583117668061032227577386757036981448703231972963300147061503108512300577364845823910107210444");
}
public void TestEquals() {
Assert.IsFalse(EInteger.One.Equals(null));
Assert.IsFalse(EInteger.Zero.Equals(null));
Assert.IsFalse(EInteger.One.Equals(EInteger.Zero));
Assert.IsFalse(EInteger.Zero.Equals(EInteger.One));
TestCommon.AssertEqualsHashCode(
EInteger.Zero,
EInteger.FromString("-0"));
TestCommon.AssertEqualsHashCode(
EInteger.FromString("0"),
EInteger.FromString("-0"));
TestCommon.AssertEqualsHashCode(
EInteger.Zero,
EInteger.One);
var r = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomObjects.RandomEInteger(r);
EInteger bigintB = RandomObjects.RandomEInteger(r);
TestCommon.AssertEqualsHashCode(bigintA, bigintB);
}
}
private static EInteger WordAlignedInteger(RandomGenerator r) {
int size = r.UniformInt(150) + 1;
EInteger ei = EInteger.Zero;
for (var i = 0; i < size; ++i) {
ei = ei.ShiftLeft(16).Add(EInteger.FromInt32(r.UniformInt(0x10000) |
0x8000));
}
return ei;
}
