mcs/class/System.Numerics/Test/System.Numerics/BigIntegerTest.cs

   1 // BigIntegerTest.cs
   2 //
   3 // Authors:
   4 // Rodrigo Kumpera <rkumpera@novell.com>
   5 //
   6 // Copyright (C) 2010 Novell, Inc (http://www.novell.com)
   7 //
   8
   9 using System;
  10 using System.Numerics;
  11 using NUnit.Framework;
  12
  13
  14 namespace MonoTests.System.Numerics
  15 {
  16         [TestFixture]
  17         public class BigIntegerTest
  18         {
  19                 static byte[] huge_a = new byte[] {0x1D, 0x33, 0xFB, 0xFE, 0xB1, 0x2, 0x85, 0x44, 0xCA, 0xDC, 0xFB, 0x70, 0xD, 0x39, 0xB1, 0x47, 0xB6, 0xE6, 0xA2, 0xD1, 0x19, 0x1E, 0x9F, 0xE4, 0x3C, 0x1E, 0x16, 0x56, 0x13, 0x9C, 0x4D, 0xD3, 0x5C, 0x74, 0xC9, 0xBD, 0xFA, 0x56, 0x40, 0x58, 0xAC, 0x20, 0x6B, 0x55, 0xA2, 0xD5, 0x41, 0x38, 0xA4, 0x6D, 0xF6, 0x8C, };
  20
  21                 static byte[] huge_b = new byte[] {0x96, 0x5, 0xDA, 0xFE, 0x93, 0x17, 0xC1, 0x93, 0xEC, 0x2F, 0x30, 0x2D, 0x8F, 0x28, 0x13, 0x99, 0x70, 0xF4, 0x4C, 0x60, 0xA6, 0x49, 0x24, 0xF9, 0xB3, 0x4A, 0x41, 0x67, 0xDC, 0xDD, 0xB1, 0xA5, 0xA6, 0xC0, 0x3D, 0x57, 0x9A, 0xCB, 0x29, 0xE2, 0x94, 0xAC, 0x6C, 0x7D, 0xEF, 0x3E, 0xC6, 0x7A, 0xC1, 0xA8, 0xC8, 0xB0, 0x20, 0x95, 0xE6, 0x4C, 0xE1, 0xE0, 0x4B, 0x49, 0xD5, 0x5A, 0xB7, };
  22
  23                 static byte[] huge_add = new byte[] {0xB3, 0x38, 0xD5, 0xFD, 0x45, 0x1A, 0x46, 0xD8, 0xB6, 0xC, 0x2C, 0x9E, 0x9C, 0x61, 0xC4, 0xE0, 0x26, 0xDB, 0xEF, 0x31, 0xC0, 0x67, 0xC3, 0xDD, 0xF0, 0x68, 0x57, 0xBD, 0xEF, 0x79, 0xFF, 0x78, 0x3, 0x35, 0x7, 0x15, 0x95, 0x22, 0x6A, 0x3A, 0x41, 0xCD, 0xD7, 0xD2, 0x91, 0x14, 0x8, 0xB3, 0x65, 0x16, 0xBF, 0x3D, 0x20, 0x95, 0xE6, 0x4C, 0xE1, 0xE0, 0x4B, 0x49, 0xD5, 0x5A, 0xB7, };
  24
  25                 static byte[] a_m_b = new byte[] { 0x87, 0x2D, 0x21, 0x0, 0x1E, 0xEB, 0xC3, 0xB0, 0xDD, 0xAC, 0xCB, 0x43, 0x7E, 0x10, 0x9E, 0xAE, 0x45, 0xF2, 0x55, 0x71, 0x73, 0xD4, 0x7A, 0xEB, 0x88, 0xD3, 0xD4, 0xEE, 0x36, 0xBE, 0x9B, 0x2D, 0xB6, 0xB3, 0x8B, 0x66, 0x60, 0x8B, 0x16, 0x76, 0x17, 0x74, 0xFE, 0xD7, 0xB2, 0x96, 0x7B, 0xBD, 0xE2, 0xC4, 0x2D, 0xDC, 0xDE, 0x6A, 0x19, 0xB3, 0x1E, 0x1F, 0xB4, 0xB6, 0x2A, 0xA5, 0x48, };\r
  26                 static byte[] b_m_a = new byte[] { 0x79, 0xD2, 0xDE, 0xFF, 0xE1, 0x14, 0x3C, 0x4F, 0x22, 0x53, 0x34, 0xBC, 0x81, 0xEF, 0x61, 0x51, 0xBA, 0xD, 0xAA, 0x8E, 0x8C, 0x2B, 0x85, 0x14, 0x77, 0x2C, 0x2B, 0x11, 0xC9, 0x41, 0x64, 0xD2, 0x49, 0x4C, 0x74, 0x99, 0x9F, 0x74, 0xE9, 0x89, 0xE8, 0x8B, 0x1, 0x28, 0x4D, 0x69, 0x84, 0x42, 0x1D, 0x3B, 0xD2, 0x23, 0x21, 0x95, 0xE6, 0x4C, 0xE1, 0xE0, 0x4B, 0x49, 0xD5, 0x5A, 0xB7, };\r
  27
  28                 static byte[] huge_mul = new byte[] { 0xFE, 0x83, 0xE1, 0x9B, 0x8D, 0x61, 0x40, 0xD1, 0x60, 0x19, 0xBD, 0x38, 0xF0, 0xFF, 0x90, 0xAE, 0xDD, 0xAE, 0x73, 0x2C, 0x20, 0x23, 0xCF, 0x6, 0x7A, 0xB4, 0x1C, 0xE7, 0xD9, 0x64, 0x96, 0x2C, 0x87, 0x7E, 0x1D, 0xB3, 0x8F, 0xD4, 0x33, 0xBA, 0xF4, 0x22, 0xB4, 0xDB, 0xC0, 0x5B, 0xA5, 0x64, 0xA0, 0xBC, 0xCA, 0x3E, 0x94, 0x95, 0xDA, 0x49, 0xE2, 0xA8, 0x33, 0xA2, 0x6A, 0x33, 0xB1, 0xF2, 0xEA, 0x99, 0x32, 0xD0, 0xB2, 0xAE, 0x55, 0x75, 0xBD, 0x19, 0xFC, 0x9A, 0xEC, 0x54, 0x87, 0x2A, 0x6, 0xCC, 0x78, 0xDA, 0x88, 0xBB, 0xAB, 0xA5, 0x47, 0xEF, 0xC7, 0x2B, 0xC7, 0x5B, 0x32, 0x31, 0xCD, 0xD9, 0x53, 0x96, 0x1A, 0x9D, 0x9A, 0x57, 0x40, 0x51, 0xB6, 0x5D, 0xC, 0x17, 0xD1, 0x86, 0xE9, 0xA4, 0x20, };
  29
  30                 static byte[] huge_div = new byte[] { 0x0, };\r
  31                 static byte[] huge_rem = new byte[] { 0x1D, 0x33, 0xFB, 0xFE, 0xB1, 0x2, 0x85, 0x44, 0xCA, 0xDC, 0xFB, 0x70, 0xD, 0x39, 0xB1, 0x47, 0xB6, 0xE6, 0xA2, 0xD1, 0x19, 0x1E, 0x9F, 0xE4, 0x3C, 0x1E, 0x16, 0x56, 0x13, 0x9C, 0x4D, 0xD3, 0x5C, 0x74, 0xC9, 0xBD, 0xFA, 0x56, 0x40, 0x58, 0xAC, 0x20, 0x6B, 0x55, 0xA2, 0xD5, 0x41, 0x38, 0xA4, 0x6D, 0xF6, 0x8C, };\r
  32                 static byte[][] add_a = new byte[][] {
  33                         new byte[] {1},
  34                         new byte[] {0xFF},
  35                         huge_a
  36                 };
  37
  38                 static byte[][] add_b = new byte[][] {
  39                         new byte[] {1},
  40                         new byte[] {1},
  41                         huge_b
  42                 };
  43
  44                 static byte[][] add_c = new byte[][] {
  45                         new byte[] {2},
  46                         new byte[] {0},
  47                         huge_add
  48                 };
  49
  50                 [Test]
  51                 public void Mul () {
  52                         long[] values = new long [] { -1000000000L, -1000, -1, 0, 1, 1000, 100000000L };
  53                         for (int i = 0; i < values.Length; ++i) {
  54                                 for (int j = 0; j < values.Length; ++j) {
  55                                         var a = new BigInteger (values [i]);
  56                                         var b = new BigInteger (values [j]);
  57                                         var c = a * b;
  58                                         Assert.AreEqual (values [i] * values [j], (long)c, "#_" + i + "_" + j);
  59                                 }
  60                         }
  61                 }
  62
  63                 [Test]
  64                 public void TestHugeMul () {
  65                         var a = new BigInteger (huge_a);
  66                         var b = new BigInteger (huge_b);
  67                         Assert.AreEqual (huge_mul, (a * b).ToByteArray (), "#1");
  68                 }
  69
  70
  71                 [Test]
  72                 public void DivRem () {
  73                         long[] values = new long [] { -10000000330L, -5000, -1, 0, 1, 1000, 333, 10234544400L };
  74                         for (int i = 0; i < values.Length; ++i) {
  75                                 for (int j = 0; j < values.Length; ++j) {
  76                                         if (values [j] == 0)
  77                                                 continue;
  78                                         var a = new BigInteger (values [i]);
  79                                         var b = new BigInteger (values [j]);
  80                                         BigInteger c, d;
  81                                         c = BigInteger.DivRem (a, b, out d);
  82
  83                                         Assert.AreEqual (values [i] / values [j], (long)c, "#a_" + i + "_" + j);
  84                                         Assert.AreEqual (values [i] % values [j], (long)d, "#b_" + i + "_" + j);
  85                                 }
  86                         }
  87                 }
  88
  89                 [Test]
  90                 public void TestHugeDivRem () {
  91                         var a = new BigInteger (huge_a);
  92                         var b = new BigInteger (huge_b);
  93                         BigInteger c, d;
  94                         c = BigInteger.DivRem (a, b, out d);
  95
  96                         Assert.AreEqual (huge_div, c.ToByteArray (), "#1");
  97                         Assert.AreEqual (huge_rem, d.ToByteArray (), "#2");
  98                 }
  99
 100                 [Test]
 101                 public void Pow () {
 102                         try {
 103                                 BigInteger.Pow (1, -1);
 104                                 Assert.Fail ("#1");
 105                         } catch (ArgumentOutOfRangeException) {}
 106
 107                         Assert.AreEqual (1, (int)BigInteger.Pow (99999, 0), "#2");
 108                         Assert.AreEqual (99999, (int)BigInteger.Pow (99999, 1), "#5");
 109                         Assert.AreEqual (59049, (int)BigInteger.Pow (3, 10), "#4");
 110                         Assert.AreEqual (177147, (int)BigInteger.Pow (3, 11), "#5");
 111                         Assert.AreEqual (-177147, (int)BigInteger.Pow (-3, 11), "#6");
 112                 }
 113
 114                 [Test]
 115                 public void ModPow () {
 116                         try {
 117                                 BigInteger.ModPow (1, -1, 5);
 118                                 Assert.Fail ("#1");
 119                         } catch (ArgumentOutOfRangeException) {}
 120                         try {
 121                                 BigInteger.ModPow (1, 5, 0);
 122                                 Assert.Fail ("#2");
 123                         } catch (DivideByZeroException) {}
 124
 125                         Assert.AreEqual (4L, (long)BigInteger.ModPow (3, 2, 5), "#2");
 126                         Assert.AreEqual (20L, (long)BigInteger.ModPow (555, 10, 71), "#3");
 127                         Assert.AreEqual (20L, (long)BigInteger.ModPow (-555, 10, 71), "#3");
 128                         Assert.AreEqual (-24L, (long)BigInteger.ModPow (-555, 11, 71), "#3");
 129                 }
 130
 131                 [Test]
 132                 public void GCD () {
 133                         Assert.AreEqual (999999, (int)BigInteger.GreatestCommonDivisor (999999, 0), "#1");
 134                         Assert.AreEqual (999999, (int)BigInteger.GreatestCommonDivisor (0, 999999), "#2");
 135                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (999999, 1), "#3");
 136                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (1, 999999), "#4");
 137                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (1, 0), "#5");
 138                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (0, 1), "#6");
 139
 140                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (999999, -1), "#7");
 141                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (-1, 999999), "#8");
 142                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (-1, 0), "#9");
 143                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (0, -1), "#10");
 144
 145                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (12345678, 8765432), "#11");
 146                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (-12345678, 8765432), "#12");
 147                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (12345678, -8765432), "#13");
 148                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (-12345678, -8765432), "#14");
 149
 150                         Assert.AreEqual (40, (int)BigInteger.GreatestCommonDivisor (5581 * 40, 6671 * 40), "#15");
 151                 }
 152
 153                 [Test]
 154                 public void Log () {
 155                         double delta = 0.000000000000001d;
 156
 157                         Assert.AreEqual (double.NegativeInfinity, BigInteger.Log (0), "#1");
 158                         Assert.AreEqual (0d, BigInteger.Log (1), "#2");
 159                         Assert.AreEqual (double.NaN, BigInteger.Log (-1), "#3");
 160                         Assert.AreEqual (2.3025850929940459d, BigInteger.Log (10), delta, "#4");
 161                         Assert.AreEqual (6.9077552789821368d, BigInteger.Log (1000), delta, "#5");
 162                         Assert.AreEqual (double.NaN, BigInteger.Log (-234), "#6");
 163                 }
 164
 165                 [Test]
 166                 public void LogN () {
 167                         double delta = 0.000000000000001d;
 168
 169                         Assert.AreEqual (double.NaN, BigInteger.Log (10, 1), "#1");
 170                         Assert.AreEqual (double.NaN, BigInteger.Log (10, 0), "#2");
 171                         Assert.AreEqual (double.NaN, BigInteger.Log (10, -1), "#3");
 172
 173                         Assert.AreEqual (double.NaN, BigInteger.Log (10, double.NaN), "#4");
 174                         Assert.AreEqual (double.NaN, BigInteger.Log (10, double.NegativeInfinity), "#5");
 175                         Assert.AreEqual (double.NaN, BigInteger.Log (10, double.PositiveInfinity), "#6");
 176
 177                         Assert.AreEqual (0d, BigInteger.Log (1, 0), "#7");
 178                         Assert.AreEqual (double.NaN, BigInteger.Log (1, double.NegativeInfinity), "#8");
 179                         Assert.AreEqual (0, BigInteger.Log (1, double.PositiveInfinity), "#9");
 180                         Assert.AreEqual (double.NaN, BigInteger.Log (1, double.NaN), "#10");
 181
 182                         Assert.AreEqual (-2.5129415947320606d, BigInteger.Log (10, 0.4), delta, "#11");
 183                 }
 184
 185                 [Test]
 186                 public void DivRemByZero () {
 187                         try {
 188                                 BigInteger c, d;
 189                                 c = BigInteger.DivRem (100, 0, out d);
 190                                 Assert.Fail ("#1");
 191                         } catch (DivideByZeroException) {}
 192                 }
 193
 194                 [Test]
 195                 public void TestAdd () {
 196                         for (int i = 0; i < add_a.Length; ++i) {
 197                                 var a = new BigInteger (add_a [i]);
 198                                 var b = new BigInteger (add_b [i]);
 199                                 var c = new BigInteger (add_c [i]);
 200
 201                                 Assert.AreEqual (c, a + b, "#" + i + "a");
 202                                 Assert.AreEqual (c, b + a, "#" + i + "b");
 203                                 Assert.AreEqual (c, BigInteger.Add (a, b), "#" + i + "c");
 204                                 Assert.AreEqual (add_c [i], (a + b).ToByteArray (), "#" + i + "d");
 205                         }
 206                 }
 207
 208                 [Test]
 209                 public void TestAdd2 () {
 210                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 211                         for (int i = 0; i < values.Length; ++i) {
 212                                 for (int j = 0; j < values.Length; ++j) {
 213                                         var a = new BigInteger (values [i]);
 214                                         var b = new BigInteger (values [j]);
 215                                         var c = a + b;
 216                                         Assert.AreEqual (values [i] + values [j], (long)c, "#_" + i + "_" + j);
 217                                 }
 218                         }
 219                 }
 220
 221                 [Test]
 222                 public void TestHugeSub () {
 223                         var a = new BigInteger (huge_a);
 224                         var b = new BigInteger (huge_b);
 225                         Assert.AreEqual (a_m_b, (a - b).ToByteArray (), "#1");
 226                         Assert.AreEqual (b_m_a, (b - a).ToByteArray (), "#2");
 227                 }
 228
 229                 [Test]
 230                 public void TestSub () {
 231                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 232                         for (int i = 0; i < values.Length; ++i) {
 233                                 for (int j = 0; j < values.Length; ++j) {
 234                                         var a = new BigInteger (values [i]);
 235                                         var b = new BigInteger (values [j]);
 236                                         var c = a - b;
 237                                         var d = BigInteger.Subtract (a, b);
 238
 239                                         Assert.AreEqual (values [i] - values [j], (long)c, "#_" + i + "_" + j);
 240                                         Assert.AreEqual (values [i] - values [j], (long)d, "#_" + i + "_" + j);
 241                                 }
 242                         }
 243                 }
 244
 245                 [Test]
 246                 public void TestMin () {
 247                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 248                         for (int i = 0; i < values.Length; ++i) {
 249                                 for (int j = 0; j < values.Length; ++j) {
 250                                         var a = new BigInteger (values [i]);
 251                                         var b = new BigInteger (values [j]);
 252                                         var c = BigInteger.Min (a, b);
 253
 254                                         Assert.AreEqual (Math.Min (values [i], values [j]), (long)c, "#_" + i + "_" + j);
 255                                 }
 256                         }
 257                 }
 258
 259                 [Test]
 260                 public void TestMax () {
 261                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 262                         for (int i = 0; i < values.Length; ++i) {
 263                                 for (int j = 0; j < values.Length; ++j) {
 264                                         var a = new BigInteger (values [i]);
 265                                         var b = new BigInteger (values [j]);
 266                                         var c = BigInteger.Max (a, b);
 267
 268                                         Assert.AreEqual (Math.Max (values [i], values [j]), (long)c, "#_" + i + "_" + j);
 269                                 }
 270                         }
 271                 }
 272
 273                 [Test]
 274                 public void TestAbs () {
 275                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 276                         for (int i = 0; i < values.Length; ++i) {
 277                                 var a = new BigInteger (values [i]);
 278                                 var c = BigInteger.Abs (a);
 279
 280                                 Assert.AreEqual (Math.Abs (values [i]), (long)c, "#_" + i);
 281                         }
 282                 }
 283
 284                 [Test]
 285                 public void TestNegate () {
 286                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 287                         for (int i = 0; i < values.Length; ++i) {
 288                                 var a = new BigInteger (values [i]);
 289                                 var c = -a;
 290                                 var d = BigInteger.Negate (a);
 291
 292                                 Assert.AreEqual (-values [i], (long)c, "#_" + i);
 293                                 Assert.AreEqual (-values [i], (long)d, "#_" + i);
 294                         }
 295                 }
 296
 297                 [Test]
 298                 public void TestInc () {
 299                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 300                         for (int i = 0; i < values.Length; ++i) {
 301                                 var a = new BigInteger (values [i]);
 302                                 var b = ++a;
 303
 304                                 Assert.AreEqual (++values [i], (long)b, "#_" + i);
 305                         }
 306                 }
 307
 308                 [Test]
 309                 public void TestDec () {
 310                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 311                         for (int i = 0; i < values.Length; ++i) {
 312                                 var a = new BigInteger (values [i]);
 313                                 var b = --a;
 314
 315                                 Assert.AreEqual (--values [i], (long)b, "#_" + i);
 316                         }
 317                 }
 318
 319                 [Test]
 320                 public void TestBitwiseOps () {
 321                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L, 0xFFFF00000000L };
 322                         for (int i = 0; i < values.Length; ++i) {
 323                                 for (int j = 0; j < values.Length; ++j) {
 324                                         var a = new BigInteger (values [i]);
 325                                         var b = new BigInteger (values [j]);
 326
 327
 328                                         Assert.AreEqual (values [i] | values [j], (long)(a | b) , "#b_" + i + "_" + j);
 329                                         Assert.AreEqual (values [i] & values [j], (long)(a & b) , "#a_" + i + "_" + j);
 330                                         Assert.AreEqual (values [i] ^ values [j], (long)(a ^ b) , "#c_" + i + "_" + j);
 331                                         Assert.AreEqual (~values [i], (long)~a , "#d_" + i + "_" + j);
 332                                 }
 333                         }
 334                 }
 335
 336                 [Test]
 337                 public void TestLeftShift () {
 338                         Assert.AreEqual (new byte[] {0x00, 0x28},
 339                                 (new BigInteger(0x0A) << 10).ToByteArray (), "#1");
 340                         Assert.AreEqual (new byte[] {0x00, 0xD8},
 341                                 (new BigInteger(-10) << 10).ToByteArray (), "#2");
 342                         Assert.AreEqual (new byte[] {0x00, 0x00, 0xFF},
 343                                 (new BigInteger(-1) << 16).ToByteArray (), "#3");
 344                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A},
 345                                 (new BigInteger(0x0A) << 80).ToByteArray (), "#4");
 346                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6},
 347                                 (new BigInteger(-10) << 80).ToByteArray (), "#5");
 348                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF},
 349                                 (new BigInteger(-1) << 80).ToByteArray (), "#6");
 350                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xD9},
 351                                 (new BigInteger(-1234) << 75).ToByteArray (), "#7");
 352                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x91, 0x00},
 353                                 (new BigInteger(0x1234) << 75).ToByteArray (), "#8");
 354
 355                         Assert.AreEqual (new byte[] {0xFF, 0x00}, (new BigInteger(0xFF00) << -8).ToByteArray (), "#9");
 356                 }
 357
 358                 [Test]
 359                 public void TestRightShift () {
 360                         Assert.AreEqual (new byte[] {0x16, 0xB0, 0x4C, 0x02},
 361                                 (new BigInteger(1234567899L) >> 5).ToByteArray (), "#1");
 362
 363                         Assert.AreEqual (new byte[] {0x2C, 0x93, 0x00},
 364                                 (new BigInteger(1234567899L) >> 15).ToByteArray (), "#2");
 365
 366                         Assert.AreEqual (new byte[] {0xFF, 0xFF, 0x7F},
 367                                 (new BigInteger(long.MaxValue - 100) >> 40).ToByteArray (), "#3");
 368
 369                         Assert.AreEqual (new byte[] {0xE9, 0x4F, 0xB3, 0xFD},
 370                                 (new BigInteger(-1234567899L) >> 5).ToByteArray (), "#4");
 371
 372                         Assert.AreEqual (new byte[] {0xD3, 0x6C, 0xFF},
 373                                 (new BigInteger(-1234567899L) >> 15).ToByteArray (), "#5");
 374
 375                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x80},
 376                                 (new BigInteger(long.MinValue + 100) >> 40).ToByteArray (), "#6");
 377
 378                         Assert.AreEqual (new byte[] { 0xFF },
 379                                 (new BigInteger(-1234567899L) >> 90).ToByteArray (), "#7");
 380
 381                         Assert.AreEqual (new byte[] {0x00},
 382                                 (new BigInteger(999999) >> 90).ToByteArray (), "#8");
 383
 384                         Assert.AreEqual (new byte[] {0x00, 0x00, 0xFF, 0x00}, (new BigInteger(0xFF00) >> -8).ToByteArray (), "#9");
 385                 }
 386
 387                 [Test]
 388                 public void CompareOps () {
 389                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 390                         for (int i = 0; i < values.Length; ++i) {
 391                                 for (int j = 0; j < values.Length; ++j) {
 392                                         var a = new BigInteger (values [i]);
 393                                         var b = new BigInteger (values [j]);
 394
 395                                         Assert.AreEqual (values [i].CompareTo (values [j]), a.CompareTo (b), "#a_" + i + "_" + j);
 396                                         Assert.AreEqual (values [i].CompareTo (values [j]), BigInteger.Compare (a, b), "#b_" + i + "_" + j);
 397
 398                                         Assert.AreEqual (values [i] < values [j], a < b, "#c_" + i + "_" + j);
 399                                         Assert.AreEqual (values [i] <= values [j], a <= b, "#d_" + i + "_" + j);
 400                                         Assert.AreEqual (values [i] == values [j], a == b, "#e_" + i + "_" + j);
 401                                         Assert.AreEqual (values [i] != values [j], a != b, "#f_" + i + "_" + j);
 402                                         Assert.AreEqual (values [i] >= values [j], a >= b, "#g_" + i + "_" + j);
 403                                         Assert.AreEqual (values [i] > values [j], a > b, "#h_" + i + "_" + j);
 404                                 }
 405                         }
 406                 }
 407
 408                 [Test]
 409                 public void CompareOps2 () {
 410                         BigInteger a = new BigInteger (100000000000L);
 411                         BigInteger b = new BigInteger (28282828282UL);
 412
 413                         Assert.IsTrue (a >= b, "#1");
 414                         Assert.IsTrue (a >= b, "#2");
 415                         Assert.IsFalse (a < b, "#3");
 416                         Assert.IsFalse (a <= b, "#4");
 417                         Assert.AreEqual (1, a.CompareTo (b), "#5");
 418                 }
 419
 420                 [Test]
 421                 public void CompareULong () {
 422                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L, 0xAA00000000L };
 423                         ulong[] uvalues = new ulong [] {0, 1, 1000, 100000000000L, 999999, 28282828282, 0xAA00000000, ulong.MaxValue };
 424                         for (int i = 0; i < values.Length; ++i) {
 425                                 for (int j = 0; j < uvalues.Length; ++j) {
 426                                         var a = new BigInteger (values [i]);
 427                                         var b = uvalues [j];
 428                                         var c = new BigInteger (b);
 429
 430                                         Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
 431
 432                                         Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
 433                                         Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
 434                                         Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
 435                                         Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
 436                                         Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
 437                                         Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
 438
 439                                         Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
 440                                         Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
 441                                         Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
 442                                         Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
 443                                         Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
 444                                         Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
 445                                 }
 446                         }
 447                 }
 448
 449                 [Test]
 450                 public void CompareLong () {
 451                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 9999999, 100000000000L, 0xAA00000000, long.MaxValue, long.MinValue };
 452
 453                         for (int i = 0; i < values.Length; ++i) {
 454                                 for (int j = 0; j < values.Length; ++j) {
 455                                         var a = new BigInteger (values [i]);
 456                                         var b = values [j];
 457                                         var c = new BigInteger (b);
 458
 459                                         Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
 460
 461                                         Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
 462                                         Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
 463                                         Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
 464                                         Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
 465                                         Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
 466                                         Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
 467
 468                                         Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
 469                                         Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
 470                                         Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
 471                                         Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
 472                                         Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
 473                                         Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
 474                                 }
 475                         }
 476                 }
 477
 478                 [Test]
 479                 public void TestEquals () {
 480                                 var a = new BigInteger (10);
 481                                 var b = new BigInteger (10);
 482                                 var c = new BigInteger (-10);
 483
 484                                 Assert.AreEqual (a, b, "#1");
 485                                 Assert.AreNotEqual (a, c, "#2");
 486                                 Assert.AreNotEqual (a, 10, "#3");
 487                 }
 488
 489                 [Test]
 490                 public void ByteArrayCtor ()
 491                 {
 492                         try {
 493                                 new BigInteger (null);
 494                                 Assert.Fail ("#1");
 495                         } catch (ArgumentNullException) {}
 496
 497                         Assert.AreEqual (0, (int)new BigInteger (new byte [0]), "#2");
 498                 }
 499
 500                 [Test]
 501                 public void IntCtorRoundTrip ()
 502                 {
 503                         int[] values = new int [] {
 504                                 int.MinValue, -0x2F33BB, -0x1F33, -0x33, 0, 0x33,
 505                                 0x80, 0x8190, 0xFF0011, 0x1234, 0x11BB99, 0x44BB22CC,
 506                                 int.MaxValue };
 507                         foreach (var val in values) {
 508                                 var a = new BigInteger (val);
 509                                 var b = new BigInteger (a.ToByteArray ());
 510
 511                                 Assert.AreEqual (val, (int)a, "#a_" + val);
 512                                 Assert.AreEqual (val, (int)b, "#b_" + val);
 513                         }
 514                 }
 515
 516                 [Test]
 517                 public void LongCtorRoundTrip ()
 518                 {
 519                         long[] values = new long [] {
 520                                 0, long.MinValue, long.MaxValue, -1, 1L + int.MaxValue, -1L + int.MinValue, 0x1234, 0xFFFFFFFFL, 0x1FFFFFFFFL, -0xFFFFFFFFL, -0x1FFFFFFFFL,
 521                                 0x100000000L, -0x100000000L, 0x100000001L, -0x100000001L };
 522                         foreach (var val in values) {
 523                                 var a = new BigInteger (val);
 524                                 var b = new BigInteger (a.ToByteArray ());
 525
 526                                 Assert.AreEqual (val, (long)a, "#a_" + val);
 527                                 Assert.AreEqual (val, (long)b, "#b_" + val);
 528                         }
 529                 }
 530
 531                 [Test]
 532                 public void ByteArrayCtorRoundTrip ()
 533                 {
 534                         var arr = new byte [] { 1,2,3,4,5,6,7,8,9 };
 535                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#1");
 536
 537                         arr = new byte [] { 1,2,3,4,5,6,7,8,0xFF, 0x0};
 538                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#2");
 539
 540                         arr = new byte [] { 1,2,3,4,5,6,7,8,9, 0xF0 };
 541                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#3");
 542
 543                         arr = new byte [] { 1};
 544                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#4");
 545
 546                         arr = new byte [] { 1,2 };
 547                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#5");
 548
 549                         arr = new byte [] { 1,2,3 };
 550                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#6");
 551
 552                         arr = new byte [] { 1,2,3,4 };
 553                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#7");
 554
 555                         arr = new byte [] { 1,2,3,4,5 };
 556                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#8");
 557
 558                         arr = new byte [] { 1,2,3,4,5,6 };
 559                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#9");
 560
 561                         arr = new byte [] { 1,2,3,4,5,6,7 };
 562                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#10");
 563
 564                         arr = new byte [] { 1,2,3,4,5 };
 565                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#11");
 566
 567                         arr = new byte [] { 0 };
 568                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#12");
 569
 570                         arr = new byte [] { 0xFF, 00 };
 571                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#13");
 572
 573                         arr = new byte [] { 1, 0, 0, 0, 0, 0, };
 574                         Assert.AreEqual (new byte [1] {1}, new BigInteger (arr).ToByteArray (), "#14");
 575                 }
 576
 577                 [Test]
 578                 public void TestIntCtorProperties ()
 579                 {
 580                         BigInteger a = new BigInteger (10);
 581                         Assert.IsTrue (a.IsEven, "#1");
 582                         Assert.IsFalse (a.IsOne, "#2");
 583                         Assert.IsFalse (a.IsPowerOfTwo, "#3");
 584                         Assert.IsFalse (a.IsZero, "#4");
 585                         Assert.AreEqual (1, a.Sign, "#5");
 586
 587                         Assert.IsFalse (new BigInteger (11).IsEven, "#6");
 588                         Assert.IsTrue (new BigInteger (1).IsOne, "#7");
 589                         Assert.IsTrue (new BigInteger (32).IsPowerOfTwo, "#8");
 590                         Assert.IsTrue (new BigInteger (0).IsZero, "#9");
 591                         Assert.AreEqual (0, new BigInteger (0).Sign, "#10");
 592                         Assert.AreEqual (-1, new BigInteger (-99999).Sign, "#11");
 593
 594                         Assert.IsFalse (new BigInteger (0).IsPowerOfTwo, "#12");
 595                         Assert.IsFalse (new BigInteger (-16).IsPowerOfTwo, "#13");
 596                         Assert.IsTrue (new BigInteger (1).IsPowerOfTwo, "#14");
 597                 }
 598
 599                 /*[Test]
 600                 public void TestIntCtorToString ()
 601                 {
 602                         Assert.AreEqual ("5555", new BigInteger (5555).ToString (), "#1");
 603                         Assert.AreEqual ("-99999", new BigInteger (-99999).ToString (), "#2");
 604                 }*/
 605
 606                 [Test]
 607                 public void TestToIntOperator ()
 608                 {
 609                         try {
 610                                 int v = (int)new BigInteger (huge_a);
 611                                 Assert.Fail ("#1");
 612                         } catch (OverflowException) {}
 613
 614                         try {
 615                                 int v = (int)new BigInteger (1L + int.MaxValue);
 616                                 Assert.Fail ("#2");
 617                         } catch (OverflowException) {}
 618
 619                         try {
 620                                 int v = (int)new BigInteger (-1L + int.MinValue);
 621                                 Assert.Fail ("#3");
 622                         } catch (OverflowException) {}
 623
 624                         Assert.AreEqual (int.MaxValue, (int)new BigInteger (int.MaxValue), "#4");
 625                         Assert.AreEqual (int.MinValue, (int)new BigInteger (int.MinValue), "#5");
 626                 }
 627
 628
 629                 [Test]
 630                 public void TestToLongOperator ()
 631                 {
 632                         try {
 633                                 long v = (long)new BigInteger (huge_a);
 634                                 Assert.Fail ("#1");
 635                         } catch (OverflowException) {}
 636
 637                         //long.MaxValue + 1
 638                         try {
 639                                 long v = (long)new BigInteger (new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00 });
 640                                 Assert.Fail ("#2");
 641                         } catch (OverflowException) {}
 642
 643                         //TODO long.MinValue - 1
 644                         try {
 645                                 long v = (long)new BigInteger (new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF });
 646                                 Assert.Fail ("#3");
 647                         } catch (OverflowException) {}
 648
 649                         Assert.AreEqual (long.MaxValue, (long)new BigInteger (long.MaxValue), "#4");
 650                         Assert.AreEqual (long.MinValue, (long)new BigInteger (long.MinValue), "#5");
 651                 }
 652
 653                 [Test]
 654                 public void TestIntCtorToByteArray ()
 655                 {
 656                         Assert.AreEqual (new byte[] { 0xFF }, new BigInteger (-1).ToByteArray (), "#1");
 657                         Assert.AreEqual (new byte[] { 0xD4, 0xFE }, new BigInteger (-300).ToByteArray (), "#2");
 658                         Assert.AreEqual (new byte[] { 0x80, 0x00 }, new BigInteger (128).ToByteArray (), "#3");
 659                         Assert.AreEqual (new byte[] { 0x00, 0x60 }, new BigInteger (0x6000).ToByteArray (), "#4");
 660                         Assert.AreEqual (new byte[] { 0x00, 0x80, 0x00 }, new BigInteger (0x8000).ToByteArray (), "#5");
 661                         Assert.AreEqual (new byte[] { 0xDD, 0xBC, 0x00, 0x7A }, new BigInteger (0x7A00BCDD).ToByteArray (), "#6");
 662                         Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0x7F }, new BigInteger (int.MaxValue).ToByteArray (), "#7");
 663                         Assert.AreEqual (new byte[] { 0x00, 0x00, 0x00, 0x80 }, new BigInteger (int.MinValue).ToByteArray (), "#8");
 664                         Assert.AreEqual (new byte[] { 0x01, 0x00, 0x00, 0x80 }, new BigInteger (int.MinValue + 1).ToByteArray (), "#9");
 665                         Assert.AreEqual (new byte[] { 0x7F }, new BigInteger (0x7F).ToByteArray (), "#10");
 666                         Assert.AreEqual (new byte[] { 0x45, 0xCC, 0xD0 }, new BigInteger (-0x2F33BB).ToByteArray (), "#11");
 667                         Assert.AreEqual (new byte[] { 0 }, new BigInteger (0).ToByteArray (), "#12");
 668                 }
 669
 670                 [Test]
 671                 public void TestLongCtorToByteArray ()
 672                 {
 673                         Assert.AreEqual (new byte[] { 0x01 }, new BigInteger (0x01L).ToByteArray (), "#1");
 674                         Assert.AreEqual (new byte[] { 0x02, 0x01 }, new BigInteger (0x0102L).ToByteArray (), "#2");
 675                         Assert.AreEqual (new byte[] { 0x03, 0x02, 0x01 }, new BigInteger (0x010203L).ToByteArray (), "#3");
 676                         Assert.AreEqual (new byte[] { 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x01020304L).ToByteArray (), "#4");
 677                         Assert.AreEqual (new byte[] { 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x0102030405L).ToByteArray (), "#5");
 678                         Assert.AreEqual (new byte[] { 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x010203040506L).ToByteArray (), "#6");
 679                         Assert.AreEqual (new byte[] { 0x07, 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x01020304050607L).ToByteArray (), "#7");
 680                         Assert.AreEqual (new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x0102030405060708L).ToByteArray (), "#8");
 681
 682                         Assert.AreEqual (new byte[] { 0xFF }, new BigInteger (-0x01L).ToByteArray (), "#1m");
 683                         Assert.AreEqual (new byte[] { 0xFE, 0xFE}, new BigInteger (-0x0102L).ToByteArray (), "#2m");
 684                         Assert.AreEqual (new byte[] { 0xFD, 0xFD, 0xFE }, new BigInteger (-0x010203L).ToByteArray (), "#3m");
 685                         Assert.AreEqual (new byte[] { 0xFC, 0xFC, 0xFD, 0xFE}, new BigInteger (-0x01020304L).ToByteArray (), "#4m");
 686                         Assert.AreEqual (new byte[] { 0xFB, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x0102030405L).ToByteArray (), "#5m");
 687                         Assert.AreEqual (new byte[] { 0xFA, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x010203040506L).ToByteArray (), "#6m");
 688                         Assert.AreEqual (new byte[] { 0xF9, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x01020304050607L).ToByteArray (), "#7m");
 689                         Assert.AreEqual (new byte[] { 0xF8, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x0102030405060708L).ToByteArray (), "#8m");
 690
 691
 692                         Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, new BigInteger (long.MaxValue).ToByteArray (), "#9");
 693                         Assert.AreEqual (new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, new BigInteger (long.MinValue).ToByteArray (), "#10");
 694
 695                         Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0x7F, 0xFF }, new BigInteger (-2147483649L).ToByteArray (), "11");
 696                 }
 697
 698                 [Test]
 699                 public void IComparable () {
 700                         var a = new BigInteger (99);
 701                         Assert.AreEqual (-1, a.CompareTo (100), "#1");
 702                         Assert.AreEqual (1, a.CompareTo (null), "#2");
 703                 }
 704
 705                 [Test]
 706                 public void ShortOperators () {
 707                         Assert.AreEqual (22, (int)new BigInteger ((short)22), "#1");
 708                         Assert.AreEqual (-22, (int)new BigInteger ((short)-22), "#2");
 709
 710                         try {
 711                                 short x = (short)new BigInteger (10000000);
 712                                 Assert.Fail ("#3");
 713                         } catch (OverflowException) {}
 714
 715                         try {
 716                                 short x = (short)new BigInteger (-10000000);
 717                                 Assert.Fail ("#4");
 718                         } catch (OverflowException) {}
 719                 }
 720
 721                 [Test]
 722                 public void DoubleCtor () {
 723                         try {
 724                                 new BigInteger (double.NaN);
 725                                 Assert.Fail ("#1");
 726                         } catch (OverflowException) {}
 727                         try {
 728                                 new BigInteger (double.NegativeInfinity);
 729                                 Assert.Fail ("#2");
 730                         } catch (OverflowException) {}
 731                         try {
 732                                 new BigInteger (double.PositiveInfinity);
 733                                 Assert.Fail ("#3");
 734                         } catch (OverflowException) {}
 735
 736                         Assert.AreEqual (10000, (int)new BigInteger (10000.2), "#4");
 737                         Assert.AreEqual (10000, (int)new BigInteger (10000.9), "#5");
 738
 739                         Assert.AreEqual (10000, (int)new BigInteger (10000.2), "#6");
 740                         Assert.AreEqual (0, (int)new BigInteger (0.9), "#7");
 741
 742                         Assert.AreEqual (12345678999L, (long)new BigInteger (12345678999.33), "#8");
 743                 }
 744         }
 745 }