public UniformInt ( int maxExclusive ) : int | ||
maxExclusive | int | One plus the largest possible value of /// the random number. |
return | int |
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 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 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 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 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 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 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 bool Extra() { var rand = new RandomGenerator(); for (var i = 0; i < 20; ++i) { var array = new byte[rand.UniformInt(100000) + 1]; rand.GetBytes(array, 0, array.Length); DateTime utcn = DateTime.UtcNow; CBORTest.TestRandomOne(array); var span = DateTime.UtcNow - utcn; if (span.Seconds > 3) { Console.WriteLine("----" + i + ": " + span.Seconds + " " + array.Length); } } return(false); }
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); } }
private static byte[] RandomBytes(RandomGenerator rnd) { int count = 10 + rnd.UniformInt(350); var arr = new byte[count]; for (var i = 0; i < count; ++i) { arr[i] = (byte)rnd.UniformInt(0x100); } return arr; }
public static string RandomString(RandomGenerator rnd) { int count = 10 + rnd.UniformInt(350); var sb = new StringBuilder(count * 2); int ui; string problemChars = " \t\u0000\u0010\u001b\u001f" + "\u007f\u008f\u009f%\\/*?|:<>\"\u0028\u0029" + "\u00a0\u3000\u180e\u1680\u2000\u200b\u205f\u202f\ufeff" + "\ufffe\uffff\ufdd0\ufdef"; for (var i = 0; i < count; ++i) { var ch = 0; ui = rnd.UniformInt(100); if (ui < 2) { ch = rnd.UniformInt(0x110000); } else if (ui < 4) { ch = rnd.UniformInt(0x10000); } else if (ui < 10) { ch = rnd.UniformInt(0x3000); } else if (ui < 80) { ch = 0x20 + rnd.UniformInt(0x5f); } else if (ui < 83) { ch = 0x20; } else if (ui < 86) { ch = (char)'.'; } else { ui = rnd.UniformInt(problemChars.Length); ch = problemChars[ui]; } if ((ch & 0xf800) == 0xd800) { ch &= 0xff; } if (ch < 0x10000) { sb.Append((char)ch); } else { ch -= 0x10000; int lead = (ch >> 10) + 0xd800; int trail = (ch & 0x3ff) + 0xdc00; sb.Append((char)lead); sb.Append((char)trail); } } string ret = sb.ToString(); return ret; }
public static EInteger RandomSmallIntegral(RandomGenerator r) { int count = r.UniformInt(20) + 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 EInteger.FromString(sb.ToString()); }
public static float RandomSingle(RandomGenerator rand, int exponent) { if (exponent == Int32.MaxValue) { exponent = rand.UniformInt(255); } int r = rand.UniformInt(0x10000); if (rand.UniformInt(2) == 0) { r |= ((int)rand.UniformInt(0x10000)) << 16; } r &= ~0x7f800000; // clear exponent r |= ((int)exponent) << 23; // set exponent return BitConverter.ToSingle(BitConverter.GetBytes((int)r), 0); }
public static EInteger RandomEInteger(RandomGenerator r) { int selection = r.UniformInt(100); if (selection < 40) { StringAndBigInt sabi = StringAndBigInt.Generate(r, 16); return sabi.BigIntValue; } if (selection < 50) { StringAndBigInt sabi = StringAndBigInt.Generate( r, 2 + r.UniformInt(35)); return sabi.BigIntValue; } else { int count = r.UniformInt(60) + 1; var bytes = new byte[count]; for (var i = 0; i < count; ++i) { bytes[i] = (byte)((int)r.UniformInt(256)); } return EInteger.FromBytes(bytes, true); } }
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 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 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 void TestAddCloseExponent(RandomGenerator fr, int exp) { for (var i = 0; i < 1000; ++i) { EInteger exp1 = EInteger.FromInt32(exp) .Add(EInteger.FromInt32(fr.UniformInt(32) - 16)); EInteger exp2 = exp1 .Add(EInteger.FromInt32(fr.UniformInt(18) - 9)); EInteger mant1 = RandomObjects.RandomEInteger(fr); EInteger mant2 = RandomObjects.RandomEInteger(fr); EDecimal decA = EDecimal.Create(mant1, exp1); EDecimal decB = EDecimal.Create(mant2, exp2); EDecimal decC = decA.Add(decB); EDecimal decD = decC.Subtract(decA); TestCommon.CompareTestEqual(decD, decB); decD = decC.Subtract(decB); TestCommon.CompareTestEqual(decD, decA); } }
public void TestToDouble() { // test for correct rounding double dbl; dbl = EDecimal.FromString( "1.972579273363468721491642554610734805464744567871093749999999999999") .ToDouble(); { string stringTemp = EFloat.FromDouble(dbl).ToPlainString(); Assert.AreEqual( "1.9725792733634686104693400920950807631015777587890625", stringTemp); } var fr = new RandomGenerator(); dbl = DoubleOverflowToInfinity.ToDouble(); Assert.IsTrue(Double.IsPositiveInfinity(dbl)); dbl = DoubleOverflowToInfinity.Negate().ToDouble(); Assert.IsTrue(Double.IsNegativeInfinity(dbl)); dbl = DoubleUnderflowToZero.ToDouble(); Assert.IsTrue(dbl == 0.0); dbl = DoubleUnderflowToZero.Negate().ToDouble(); Assert.IsTrue(dbl == 0.0); for (var i = 0; i < 10000; ++i) { EDecimal edec; if (fr.UniformInt(100) < 10) { string decimals = RandomObjects.RandomBigIntString(fr); if (decimals[0] == '-') { decimals = decimals.Substring(1); } string edecstr = RandomObjects.RandomBigIntString(fr) + "." + decimals + "e" + RandomObjects.RandomBigIntString(fr); edec = EDecimal.FromString(edecstr); } else { edec = RandomObjects.RandomEDecimal(fr); } if (edec.IsFinite) { dbl = edec.ToDouble(); if (Double.IsNegativeInfinity(dbl)) { Assert.IsTrue(edec.IsNegative); TestCommon.CompareTestGreaterEqual(edec.Abs(), DoubleOverflowToInfinity); } else if (Double.IsPositiveInfinity(dbl)) { Assert.IsTrue(!edec.IsNegative); TestCommon.CompareTestGreaterEqual(edec.Abs(), DoubleOverflowToInfinity); } else if (dbl == 0.0) { TestCommon.CompareTestLessEqual(edec.Abs(), DoubleUnderflowToZero); Assert.AreEqual(edec.IsNegative, EDecimal.FromDouble(dbl).IsNegative); } else { Assert.IsTrue(!Double.IsNaN(dbl)); edec = edec.Abs(); TestCommon.CompareTestGreater(edec, DoubleUnderflowToZero); TestCommon.CompareTestLess(edec, DoubleOverflowToInfinity); EDecimal halfUlp = GetHalfUlp(dbl); EDecimal difference = EDecimal.FromDouble(dbl).Abs() .Subtract(edec).Abs(); TestCommon.CompareTestLessEqual(difference, halfUlp); } } } }
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; }
public static EFloat RandomEFloat(RandomGenerator r) { if (r.UniformInt(100) == 0) { int x = r.UniformInt(3); if (x == 0) { return EFloat.PositiveInfinity; } if (x == 1) { return EFloat.NegativeInfinity; } if (x == 2) { return EFloat.NaN; } } return EFloat.Create( RandomEInteger(r), (EInteger)(r.UniformInt(400) - 200)); }
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 TestToSingle() { var fr = new RandomGenerator(); float sng; sng = SingleOverflowToInfinity.ToSingle(); Assert.IsTrue(Single.IsPositiveInfinity(sng)); sng = SingleOverflowToInfinity.Negate().ToSingle(); Assert.IsTrue(Single.IsNegativeInfinity(sng)); sng = SingleUnderflowToZero.ToSingle(); Assert.IsTrue(sng == 0.0); sng = SingleUnderflowToZero.Negate().ToSingle(); Assert.IsTrue(sng == 0.0); for (var i = 0; i < 10000; ++i) { EDecimal edec; if (fr.UniformInt(100) < 10) { string decimals = RandomObjects.RandomBigIntString(fr); if (decimals[0] == '-') { decimals = decimals.Substring(1); } string edecstr = RandomObjects.RandomBigIntString(fr) + "." + decimals + "e" + RandomObjects.RandomBigIntString(fr); edec = EDecimal.FromString(edecstr); } else { edec = RandomObjects.RandomEDecimal(fr); } if (edec.IsFinite) { sng = edec.ToSingle(); if (Single.IsNegativeInfinity(sng)) { Assert.IsTrue(edec.IsNegative); TestCommon.CompareTestGreaterEqual(edec.Abs(), SingleOverflowToInfinity); } else if (Single.IsPositiveInfinity(sng)) { Assert.IsTrue(!edec.IsNegative); TestCommon.CompareTestGreaterEqual(edec.Abs(), SingleOverflowToInfinity); } else if (sng == 0.0f) { TestCommon.CompareTestLessEqual(edec.Abs(), SingleUnderflowToZero); Assert.AreEqual(edec.IsNegative, EDecimal.FromSingle(sng).IsNegative); } else { Assert.IsTrue(!Single.IsNaN(sng)); edec = edec.Abs(); TestCommon.CompareTestGreater(edec, SingleUnderflowToZero); TestCommon.CompareTestLess(edec, SingleOverflowToInfinity); EDecimal halfUlp = GetHalfUlp(sng); EDecimal difference = EDecimal.FromSingle(sng).Abs() .Subtract(edec).Abs(); TestCommon.CompareTestLessEqual(difference, halfUlp); } } } }
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 TestRandomNonsense() { var rand = new RandomGenerator(); for (var i = 0; i < 200; ++i) { var array = new byte[rand.UniformInt(1000000) + 1]; for (int j = 0; j < array.Length; ++j) { if (j + 3 <= array.Length) { int r = rand.UniformInt(0x1000000); array[j] = (byte)(r & 0xff); array[j + 1] = (byte)((r >> 8) & 0xff); array[j + 2] = (byte)((r >> 16) & 0xff); j += 2; } else { array[j] = (byte)rand.UniformInt(256); } } using (var ms = new MemoryStream(array)) { var iobj = 0; while (iobj < 25 && ms.Position != ms.Length) { ++iobj; try { CBORObject o = CBORObject.Read(ms); try { if (o == null) { Assert.Fail("object read is null"); } else { CBORObject.DecodeFromBytes(o.EncodeToBytes()); } } catch (Exception ex) { Assert.Fail(ex.ToString()); throw new InvalidOperationException(String.Empty, ex); } String jsonString = String.Empty; try { if (o.Type == CBORType.Array || o.Type == CBORType.Map) { jsonString = o.ToJSONString(); CBORObject.FromJSONString(jsonString); TestWriteToJSON(o); } } catch (Exception ex) { Assert.Fail(jsonString + "\n" + ex); throw new InvalidOperationException(String.Empty, ex); } } catch (CBORException) { new Object(); // Expected exception } } } } }
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 TestRandomSlightlyModified() { var rand = new RandomGenerator(); // Test slightly modified objects for (var i = 0; i < 200; ++i) { CBORObject originalObject = CBORTestCommon.RandomCBORObject(rand); byte[] array = originalObject.EncodeToBytes(); // Console.WriteLine(originalObject); int count2 = rand.UniformInt(10) + 1; for (int j = 0; j < count2; ++j) { int index = rand.UniformInt(array.Length); array[index] = unchecked((byte)rand.UniformInt(256)); } using (var inputStream = new MemoryStream(array)) { while (inputStream.Position != inputStream.Length) { try { CBORObject o = CBORObject.Read(inputStream); byte[] encodedBytes = (o == null) ? null : o.EncodeToBytes(); try { CBORObject.DecodeFromBytes(encodedBytes); } catch (Exception ex) { Assert.Fail(ex.ToString()); throw new InvalidOperationException(String.Empty, ex); } String jsonString = String.Empty; try { if (o == null) { Assert.Fail("object is null"); } if (o != null && (o.Type == CBORType.Array || o.Type == CBORType.Map)) { jsonString = o.ToJSONString(); // reread JSON string to test validity CBORObject.FromJSONString(jsonString); TestWriteToJSON(o); } } catch (Exception ex) { Assert.Fail(jsonString + "\n" + ex); throw new InvalidOperationException(String.Empty, ex); } } catch (CBORException ex) { // Expected exception Console.WriteLine(ex.Message); } } } } }
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 static EDecimal RandomEDecimal(RandomGenerator r) { if (r.UniformInt(100) == 0) { int x = r.UniformInt(3); if (x == 0) { return EDecimal.PositiveInfinity; } if (x == 1) { return EDecimal.NegativeInfinity; } if (x == 2) { return EDecimal.NaN; } // Signaling NaN currently not generated because // it doesn't round-trip as well } string str = RandomDecimalString(r); return EDecimal.FromString(str); }