4 // Rodrigo Kumpera <rkumpera@novell.com>
6 // Copyright (C) 2010 Novell, Inc (http://www.novell.com)
10 using System.Numerics;
11 using System.Globalization;
12 using System.Threading;
13 using NUnit.Framework;
16 namespace MonoTests.System.Numerics
19 public class BigIntegerTest
21 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, };
23 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, };
25 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, };
27 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, };
28 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, };
30 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, };
32 static byte[] huge_div = new byte[] { 0x0, };
33 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, };
34 static byte[][] add_a = new byte[][] {
40 static byte[][] add_b = new byte[][] {
46 static byte[][] add_c = new byte[][] {
54 long[] values = new long [] { -1000000000L, -1000, -1, 0, 1, 1000, 100000000L };
55 for (int i = 0; i < values.Length; ++i) {
56 for (int j = 0; j < values.Length; ++j) {
57 var a = new BigInteger (values [i]);
58 var b = new BigInteger (values [j]);
60 Assert.AreEqual (values [i] * values [j], (long)c, "#_" + i + "_" + j);
66 public void TestHugeMul () {
67 var a = new BigInteger (huge_a);
68 var b = new BigInteger (huge_b);
69 Assert.AreEqual (huge_mul, (a * b).ToByteArray (), "#1");
74 public void DivRem () {
75 long[] values = new long [] { -10000000330L, -5000, -1, 0, 1, 1000, 333, 10234544400L };
76 for (int i = 0; i < values.Length; ++i) {
77 for (int j = 0; j < values.Length; ++j) {
80 var a = new BigInteger (values [i]);
81 var b = new BigInteger (values [j]);
83 c = BigInteger.DivRem (a, b, out d);
85 Assert.AreEqual (values [i] / values [j], (long)c, "#a_" + i + "_" + j);
86 Assert.AreEqual (values [i] % values [j], (long)d, "#b_" + i + "_" + j);
92 public void TestHugeDivRem () {
93 var a = new BigInteger (huge_a);
94 var b = new BigInteger (huge_b);
96 c = BigInteger.DivRem (a, b, out d);
98 Assert.AreEqual (huge_div, c.ToByteArray (), "#1");
99 Assert.AreEqual (huge_rem, d.ToByteArray (), "#2");
105 BigInteger.Pow (1, -1);
107 } catch (ArgumentOutOfRangeException) {}
109 Assert.AreEqual (1, (int)BigInteger.Pow (99999, 0), "#2");
110 Assert.AreEqual (99999, (int)BigInteger.Pow (99999, 1), "#5");
111 Assert.AreEqual (59049, (int)BigInteger.Pow (3, 10), "#4");
112 Assert.AreEqual (177147, (int)BigInteger.Pow (3, 11), "#5");
113 Assert.AreEqual (-177147, (int)BigInteger.Pow (-3, 11), "#6");
117 public void ModPow () {
119 BigInteger.ModPow (1, -1, 5);
121 } catch (ArgumentOutOfRangeException) {}
123 BigInteger.ModPow (1, 5, 0);
125 } catch (DivideByZeroException) {}
127 Assert.AreEqual (4L, (long)BigInteger.ModPow (3, 2, 5), "#2");
128 Assert.AreEqual (20L, (long)BigInteger.ModPow (555, 10, 71), "#3");
129 Assert.AreEqual (20L, (long)BigInteger.ModPow (-555, 10, 71), "#3");
130 Assert.AreEqual (-24L, (long)BigInteger.ModPow (-555, 11, 71), "#3");
135 Assert.AreEqual (999999, (int)BigInteger.GreatestCommonDivisor (999999, 0), "#1");
136 Assert.AreEqual (999999, (int)BigInteger.GreatestCommonDivisor (0, 999999), "#2");
137 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (999999, 1), "#3");
138 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (1, 999999), "#4");
139 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (1, 0), "#5");
140 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (0, 1), "#6");
142 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (999999, -1), "#7");
143 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (-1, 999999), "#8");
144 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (-1, 0), "#9");
145 Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (0, -1), "#10");
147 Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (12345678, 8765432), "#11");
148 Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (-12345678, 8765432), "#12");
149 Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (12345678, -8765432), "#13");
150 Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (-12345678, -8765432), "#14");
152 Assert.AreEqual (40, (int)BigInteger.GreatestCommonDivisor (5581 * 40, 6671 * 40), "#15");
157 double delta = 0.000000000000001d;
159 Assert.AreEqual (double.NegativeInfinity, BigInteger.Log (0), "#1");
160 Assert.AreEqual (0d, BigInteger.Log (1), "#2");
161 Assert.AreEqual (double.NaN, BigInteger.Log (-1), "#3");
162 Assert.AreEqual (2.3025850929940459d, BigInteger.Log (10), delta, "#4");
163 Assert.AreEqual (6.9077552789821368d, BigInteger.Log (1000), delta, "#5");
164 Assert.AreEqual (double.NaN, BigInteger.Log (-234), "#6");
168 public void LogN () {
169 double delta = 0.000000000000001d;
171 Assert.AreEqual (double.NaN, BigInteger.Log (10, 1), "#1");
172 Assert.AreEqual (double.NaN, BigInteger.Log (10, 0), "#2");
173 Assert.AreEqual (double.NaN, BigInteger.Log (10, -1), "#3");
175 Assert.AreEqual (double.NaN, BigInteger.Log (10, double.NaN), "#4");
176 Assert.AreEqual (double.NaN, BigInteger.Log (10, double.NegativeInfinity), "#5");
177 Assert.AreEqual (double.NaN, BigInteger.Log (10, double.PositiveInfinity), "#6");
179 Assert.AreEqual (0d, BigInteger.Log (1, 0), "#7");
180 Assert.AreEqual (double.NaN, BigInteger.Log (1, double.NegativeInfinity), "#8");
181 Assert.AreEqual (0, BigInteger.Log (1, double.PositiveInfinity), "#9");
182 Assert.AreEqual (double.NaN, BigInteger.Log (1, double.NaN), "#10");
184 Assert.AreEqual (-2.5129415947320606d, BigInteger.Log (10, 0.4), delta, "#11");
188 public void DivRemByZero () {
191 c = BigInteger.DivRem (100, 0, out d);
193 } catch (DivideByZeroException) {}
197 public void TestAdd () {
198 for (int i = 0; i < add_a.Length; ++i) {
199 var a = new BigInteger (add_a [i]);
200 var b = new BigInteger (add_b [i]);
201 var c = new BigInteger (add_c [i]);
203 Assert.AreEqual (c, a + b, "#" + i + "a");
204 Assert.AreEqual (c, b + a, "#" + i + "b");
205 Assert.AreEqual (c, BigInteger.Add (a, b), "#" + i + "c");
206 Assert.AreEqual (add_c [i], (a + b).ToByteArray (), "#" + i + "d");
211 public void TestAdd2 () {
212 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
213 for (int i = 0; i < values.Length; ++i) {
214 for (int j = 0; j < values.Length; ++j) {
215 var a = new BigInteger (values [i]);
216 var b = new BigInteger (values [j]);
218 Assert.AreEqual (values [i] + values [j], (long)c, "#_" + i + "_" + j);
224 public void TestHugeSub () {
225 var a = new BigInteger (huge_a);
226 var b = new BigInteger (huge_b);
227 Assert.AreEqual (a_m_b, (a - b).ToByteArray (), "#1");
228 Assert.AreEqual (b_m_a, (b - a).ToByteArray (), "#2");
232 public void TestSub () {
233 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
234 for (int i = 0; i < values.Length; ++i) {
235 for (int j = 0; j < values.Length; ++j) {
236 var a = new BigInteger (values [i]);
237 var b = new BigInteger (values [j]);
239 var d = BigInteger.Subtract (a, b);
241 Assert.AreEqual (values [i] - values [j], (long)c, "#_" + i + "_" + j);
242 Assert.AreEqual (values [i] - values [j], (long)d, "#_" + i + "_" + j);
248 public void TestMin () {
249 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
250 for (int i = 0; i < values.Length; ++i) {
251 for (int j = 0; j < values.Length; ++j) {
252 var a = new BigInteger (values [i]);
253 var b = new BigInteger (values [j]);
254 var c = BigInteger.Min (a, b);
256 Assert.AreEqual (Math.Min (values [i], values [j]), (long)c, "#_" + i + "_" + j);
262 public void TestMax () {
263 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
264 for (int i = 0; i < values.Length; ++i) {
265 for (int j = 0; j < values.Length; ++j) {
266 var a = new BigInteger (values [i]);
267 var b = new BigInteger (values [j]);
268 var c = BigInteger.Max (a, b);
270 Assert.AreEqual (Math.Max (values [i], values [j]), (long)c, "#_" + i + "_" + j);
276 public void TestAbs () {
277 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
278 for (int i = 0; i < values.Length; ++i) {
279 var a = new BigInteger (values [i]);
280 var c = BigInteger.Abs (a);
282 Assert.AreEqual (Math.Abs (values [i]), (long)c, "#_" + i);
287 public void TestNegate () {
288 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
289 for (int i = 0; i < values.Length; ++i) {
290 var a = new BigInteger (values [i]);
292 var d = BigInteger.Negate (a);
294 Assert.AreEqual (-values [i], (long)c, "#_" + i);
295 Assert.AreEqual (-values [i], (long)d, "#_" + i);
300 public void TestInc () {
301 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
302 for (int i = 0; i < values.Length; ++i) {
303 var a = new BigInteger (values [i]);
306 Assert.AreEqual (++values [i], (long)b, "#_" + i);
311 public void TestDec () {
312 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
313 for (int i = 0; i < values.Length; ++i) {
314 var a = new BigInteger (values [i]);
317 Assert.AreEqual (--values [i], (long)b, "#_" + i);
322 public void TestBitwiseOps () {
323 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L, 0xFFFF00000000L };
324 for (int i = 0; i < values.Length; ++i) {
325 for (int j = 0; j < values.Length; ++j) {
326 var a = new BigInteger (values [i]);
327 var b = new BigInteger (values [j]);
330 Assert.AreEqual (values [i] | values [j], (long)(a | b) , "#b_" + i + "_" + j);
331 Assert.AreEqual (values [i] & values [j], (long)(a & b) , "#a_" + i + "_" + j);
332 Assert.AreEqual (values [i] ^ values [j], (long)(a ^ b) , "#c_" + i + "_" + j);
333 Assert.AreEqual (~values [i], (long)~a , "#d_" + i + "_" + j);
339 public void TestLeftShift () {
340 Assert.AreEqual (new byte[] {0x00, 0x28},
341 (new BigInteger(0x0A) << 10).ToByteArray (), "#1");
342 Assert.AreEqual (new byte[] {0x00, 0xD8},
343 (new BigInteger(-10) << 10).ToByteArray (), "#2");
344 Assert.AreEqual (new byte[] {0x00, 0x00, 0xFF},
345 (new BigInteger(-1) << 16).ToByteArray (), "#3");
346 Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A},
347 (new BigInteger(0x0A) << 80).ToByteArray (), "#4");
348 Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6},
349 (new BigInteger(-10) << 80).ToByteArray (), "#5");
350 Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF},
351 (new BigInteger(-1) << 80).ToByteArray (), "#6");
352 Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xD9},
353 (new BigInteger(-1234) << 75).ToByteArray (), "#7");
354 Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x91, 0x00},
355 (new BigInteger(0x1234) << 75).ToByteArray (), "#8");
357 Assert.AreEqual (new byte[] {0xFF, 0x00}, (new BigInteger(0xFF00) << -8).ToByteArray (), "#9");
361 public void TestRightShift () {
362 Assert.AreEqual (new byte[] {0x16, 0xB0, 0x4C, 0x02},
363 (new BigInteger(1234567899L) >> 5).ToByteArray (), "#1");
365 Assert.AreEqual (new byte[] {0x2C, 0x93, 0x00},
366 (new BigInteger(1234567899L) >> 15).ToByteArray (), "#2");
368 Assert.AreEqual (new byte[] {0xFF, 0xFF, 0x7F},
369 (new BigInteger(long.MaxValue - 100) >> 40).ToByteArray (), "#3");
371 Assert.AreEqual (new byte[] {0xE9, 0x4F, 0xB3, 0xFD},
372 (new BigInteger(-1234567899L) >> 5).ToByteArray (), "#4");
374 Assert.AreEqual (new byte[] {0xD3, 0x6C, 0xFF},
375 (new BigInteger(-1234567899L) >> 15).ToByteArray (), "#5");
377 Assert.AreEqual (new byte[] {0x00, 0x00, 0x80},
378 (new BigInteger(long.MinValue + 100) >> 40).ToByteArray (), "#6");
380 Assert.AreEqual (new byte[] { 0xFF },
381 (new BigInteger(-1234567899L) >> 90).ToByteArray (), "#7");
383 Assert.AreEqual (new byte[] {0x00},
384 (new BigInteger(999999) >> 90).ToByteArray (), "#8");
386 Assert.AreEqual (new byte[] {0x00, 0x00, 0xFF, 0x00}, (new BigInteger(0xFF00) >> -8).ToByteArray (), "#9");
390 public void CompareOps () {
391 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
392 for (int i = 0; i < values.Length; ++i) {
393 for (int j = 0; j < values.Length; ++j) {
394 var a = new BigInteger (values [i]);
395 var b = new BigInteger (values [j]);
397 Assert.AreEqual (values [i].CompareTo (values [j]), a.CompareTo (b), "#a_" + i + "_" + j);
398 Assert.AreEqual (values [i].CompareTo (values [j]), BigInteger.Compare (a, b), "#b_" + i + "_" + j);
400 Assert.AreEqual (values [i] < values [j], a < b, "#c_" + i + "_" + j);
401 Assert.AreEqual (values [i] <= values [j], a <= b, "#d_" + i + "_" + j);
402 Assert.AreEqual (values [i] == values [j], a == b, "#e_" + i + "_" + j);
403 Assert.AreEqual (values [i] != values [j], a != b, "#f_" + i + "_" + j);
404 Assert.AreEqual (values [i] >= values [j], a >= b, "#g_" + i + "_" + j);
405 Assert.AreEqual (values [i] > values [j], a > b, "#h_" + i + "_" + j);
411 public void CompareOps2 () {
412 BigInteger a = new BigInteger (100000000000L);
413 BigInteger b = new BigInteger (28282828282UL);
415 Assert.IsTrue (a >= b, "#1");
416 Assert.IsTrue (a >= b, "#2");
417 Assert.IsFalse (a < b, "#3");
418 Assert.IsFalse (a <= b, "#4");
419 Assert.AreEqual (1, a.CompareTo (b), "#5");
423 public void CompareULong () {
424 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L, 0xAA00000000L };
425 ulong[] uvalues = new ulong [] {0, 1, 1000, 100000000000L, 999999, 28282828282, 0xAA00000000, ulong.MaxValue };
426 for (int i = 0; i < values.Length; ++i) {
427 for (int j = 0; j < uvalues.Length; ++j) {
428 var a = new BigInteger (values [i]);
430 var c = new BigInteger (b);
432 Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
434 Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
435 Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
436 Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
437 Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
438 Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
439 Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
441 Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
442 Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
443 Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
444 Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
445 Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
446 Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
452 public void CompareLong () {
453 long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 9999999, 100000000000L, 0xAA00000000, long.MaxValue, long.MinValue };
455 for (int i = 0; i < values.Length; ++i) {
456 for (int j = 0; j < values.Length; ++j) {
457 var a = new BigInteger (values [i]);
459 var c = new BigInteger (b);
461 Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
463 Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
464 Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
465 Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
466 Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
467 Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
468 Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
470 Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
471 Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
472 Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
473 Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
474 Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
475 Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
481 public void TestEquals () {
482 var a = new BigInteger (10);
483 var b = new BigInteger (10);
484 var c = new BigInteger (-10);
486 Assert.AreEqual (a, b, "#1");
487 Assert.AreNotEqual (a, c, "#2");
488 Assert.AreNotEqual (a, 10, "#3");
492 public void ByteArrayCtor ()
495 new BigInteger (null);
497 } catch (ArgumentNullException) {}
499 Assert.AreEqual (0, (int)new BigInteger (new byte [0]), "#2");
503 public void IntCtorRoundTrip ()
505 int[] values = new int [] {
506 int.MinValue, -0x2F33BB, -0x1F33, -0x33, 0, 0x33,
507 0x80, 0x8190, 0xFF0011, 0x1234, 0x11BB99, 0x44BB22CC,
509 foreach (var val in values) {
510 var a = new BigInteger (val);
511 var b = new BigInteger (a.ToByteArray ());
513 Assert.AreEqual (val, (int)a, "#a_" + val);
514 Assert.AreEqual (val, (int)b, "#b_" + val);
519 public void LongCtorRoundTrip ()
521 long[] values = new long [] {
522 0, long.MinValue, long.MaxValue, -1, 1L + int.MaxValue, -1L + int.MinValue, 0x1234, 0xFFFFFFFFL, 0x1FFFFFFFFL, -0xFFFFFFFFL, -0x1FFFFFFFFL,
523 0x100000000L, -0x100000000L, 0x100000001L, -0x100000001L };
524 foreach (var val in values) {
525 var a = new BigInteger (val);
526 var b = new BigInteger (a.ToByteArray ());
528 Assert.AreEqual (val, (long)a, "#a_" + val);
529 Assert.AreEqual (val, (long)b, "#b_" + val);
534 public void ByteArrayCtorRoundTrip ()
536 var arr = new byte [] { 1,2,3,4,5,6,7,8,9 };
537 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#1");
539 arr = new byte [] { 1,2,3,4,5,6,7,8,0xFF, 0x0};
540 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#2");
542 arr = new byte [] { 1,2,3,4,5,6,7,8,9, 0xF0 };
543 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#3");
545 arr = new byte [] { 1};
546 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#4");
548 arr = new byte [] { 1,2 };
549 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#5");
551 arr = new byte [] { 1,2,3 };
552 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#6");
554 arr = new byte [] { 1,2,3,4 };
555 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#7");
557 arr = new byte [] { 1,2,3,4,5 };
558 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#8");
560 arr = new byte [] { 1,2,3,4,5,6 };
561 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#9");
563 arr = new byte [] { 1,2,3,4,5,6,7 };
564 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#10");
566 arr = new byte [] { 1,2,3,4,5 };
567 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#11");
569 arr = new byte [] { 0 };
570 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#12");
572 arr = new byte [] { 0xFF, 00 };
573 Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#13");
575 arr = new byte [] { 1, 0, 0, 0, 0, 0, };
576 Assert.AreEqual (new byte [1] {1}, new BigInteger (arr).ToByteArray (), "#14");
580 public void TestIntCtorProperties ()
582 BigInteger a = new BigInteger (10);
583 Assert.IsTrue (a.IsEven, "#1");
584 Assert.IsFalse (a.IsOne, "#2");
585 Assert.IsFalse (a.IsPowerOfTwo, "#3");
586 Assert.IsFalse (a.IsZero, "#4");
587 Assert.AreEqual (1, a.Sign, "#5");
589 Assert.IsFalse (new BigInteger (11).IsEven, "#6");
590 Assert.IsTrue (new BigInteger (1).IsOne, "#7");
591 Assert.IsTrue (new BigInteger (32).IsPowerOfTwo, "#8");
592 Assert.IsTrue (new BigInteger (0).IsZero, "#9");
593 Assert.AreEqual (0, new BigInteger (0).Sign, "#10");
594 Assert.AreEqual (-1, new BigInteger (-99999).Sign, "#11");
596 Assert.IsFalse (new BigInteger (0).IsPowerOfTwo, "#12");
597 Assert.IsFalse (new BigInteger (-16).IsPowerOfTwo, "#13");
598 Assert.IsTrue (new BigInteger (1).IsPowerOfTwo, "#14");
602 public void TestIntCtorToString ()
604 Assert.AreEqual ("5555", new BigInteger (5555).ToString (), "#1");
605 Assert.AreEqual ("-99999", new BigInteger (-99999).ToString (), "#2");
609 public void TestToStringFmt ()
611 Assert.AreEqual ("123456789123456", new BigInteger (123456789123456).ToString ("D2"), "#1");
612 Assert.AreEqual ("0000000005", new BigInteger (5).ToString ("d10"), "#2");
613 Assert.AreEqual ("0A8", new BigInteger (168).ToString ("X"), "#3");
614 Assert.AreEqual ("0", new BigInteger (0).ToString ("X"), "#4");
615 Assert.AreEqual ("1", new BigInteger (1).ToString ("X"), "#5");
616 Assert.AreEqual ("0A", new BigInteger (10).ToString ("X"), "#6");
617 Assert.AreEqual ("F6", new BigInteger (-10).ToString ("X"), "#7");
619 Assert.AreEqual ("10000000000000000000000000000000000000000000000000000000", BigInteger.Pow (10, 55).ToString ("G"), "#8");
621 Assert.AreEqual ("10000000000000000000000000000000000000000000000000000000", BigInteger.Pow (10, 55).ToString ("R"), "#9");
624 Assert.AreEqual ("000000000A", new BigInteger (10).ToString ("X10"), "#10");
625 Assert.AreEqual ("0000000010", new BigInteger (10).ToString ("G10"), "#11");
629 public void TestToStringFmtProvider ()
631 NumberFormatInfo info = new NumberFormatInfo ();
632 info.NegativeSign = ">";
633 info.PositiveSign = "%";
635 Assert.AreEqual ("10", new BigInteger (10).ToString (info), "#1");
636 Assert.AreEqual (">10", new BigInteger (-10).ToString (info), "#2");
637 Assert.AreEqual ("0A", new BigInteger (10).ToString ("X", info), "#3");
638 Assert.AreEqual ("F6", new BigInteger (-10).ToString ("X", info), "#4");
639 Assert.AreEqual ("10", new BigInteger (10).ToString ("G", info), "#5");
640 Assert.AreEqual (">10", new BigInteger (-10).ToString ("G", info), "#6");
641 Assert.AreEqual ("10", new BigInteger (10).ToString ("D", info), "#7");
642 Assert.AreEqual (">10", new BigInteger (-10).ToString ("D", info), "#8");
643 Assert.AreEqual ("10", new BigInteger (10).ToString ("R", info), "#9");
644 Assert.AreEqual (">10", new BigInteger (-10).ToString ("R", info), "#10");
646 info = new NumberFormatInfo ();
647 info.NegativeSign = "#$%";
648 Assert.AreEqual ("#$%10", new BigInteger (-10).ToString (info), "#2");
649 Assert.AreEqual ("#$%10", new BigInteger (-10).ToString (null, info), "#2");
651 info = new NumberFormatInfo ();
652 Assert.AreEqual ("-10", new BigInteger (-10).ToString (info), "#2");
657 public void TestToIntOperator ()
660 int v = (int)new BigInteger (huge_a);
662 } catch (OverflowException) {}
665 int v = (int)new BigInteger (1L + int.MaxValue);
667 } catch (OverflowException) {}
670 int v = (int)new BigInteger (-1L + int.MinValue);
672 } catch (OverflowException) {}
674 Assert.AreEqual (int.MaxValue, (int)new BigInteger (int.MaxValue), "#4");
675 Assert.AreEqual (int.MinValue, (int)new BigInteger (int.MinValue), "#5");
680 public void TestToLongOperator ()
683 long v = (long)new BigInteger (huge_a);
685 } catch (OverflowException) {}
689 long v = (long)new BigInteger (new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00 });
691 } catch (OverflowException) {}
693 //TODO long.MinValue - 1
695 long v = (long)new BigInteger (new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF });
697 } catch (OverflowException) {}
699 Assert.AreEqual (long.MaxValue, (long)new BigInteger (long.MaxValue), "#4");
700 Assert.AreEqual (long.MinValue, (long)new BigInteger (long.MinValue), "#5");
704 public void TestIntCtorToByteArray ()
706 Assert.AreEqual (new byte[] { 0xFF }, new BigInteger (-1).ToByteArray (), "#1");
707 Assert.AreEqual (new byte[] { 0xD4, 0xFE }, new BigInteger (-300).ToByteArray (), "#2");
708 Assert.AreEqual (new byte[] { 0x80, 0x00 }, new BigInteger (128).ToByteArray (), "#3");
709 Assert.AreEqual (new byte[] { 0x00, 0x60 }, new BigInteger (0x6000).ToByteArray (), "#4");
710 Assert.AreEqual (new byte[] { 0x00, 0x80, 0x00 }, new BigInteger (0x8000).ToByteArray (), "#5");
711 Assert.AreEqual (new byte[] { 0xDD, 0xBC, 0x00, 0x7A }, new BigInteger (0x7A00BCDD).ToByteArray (), "#6");
712 Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0x7F }, new BigInteger (int.MaxValue).ToByteArray (), "#7");
713 Assert.AreEqual (new byte[] { 0x00, 0x00, 0x00, 0x80 }, new BigInteger (int.MinValue).ToByteArray (), "#8");
714 Assert.AreEqual (new byte[] { 0x01, 0x00, 0x00, 0x80 }, new BigInteger (int.MinValue + 1).ToByteArray (), "#9");
715 Assert.AreEqual (new byte[] { 0x7F }, new BigInteger (0x7F).ToByteArray (), "#10");
716 Assert.AreEqual (new byte[] { 0x45, 0xCC, 0xD0 }, new BigInteger (-0x2F33BB).ToByteArray (), "#11");
717 Assert.AreEqual (new byte[] { 0 }, new BigInteger (0).ToByteArray (), "#12");
721 public void TestLongCtorToByteArray ()
723 Assert.AreEqual (new byte[] { 0x01 }, new BigInteger (0x01L).ToByteArray (), "#1");
724 Assert.AreEqual (new byte[] { 0x02, 0x01 }, new BigInteger (0x0102L).ToByteArray (), "#2");
725 Assert.AreEqual (new byte[] { 0x03, 0x02, 0x01 }, new BigInteger (0x010203L).ToByteArray (), "#3");
726 Assert.AreEqual (new byte[] { 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x01020304L).ToByteArray (), "#4");
727 Assert.AreEqual (new byte[] { 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x0102030405L).ToByteArray (), "#5");
728 Assert.AreEqual (new byte[] { 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x010203040506L).ToByteArray (), "#6");
729 Assert.AreEqual (new byte[] { 0x07, 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x01020304050607L).ToByteArray (), "#7");
730 Assert.AreEqual (new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x0102030405060708L).ToByteArray (), "#8");
732 Assert.AreEqual (new byte[] { 0xFF }, new BigInteger (-0x01L).ToByteArray (), "#1m");
733 Assert.AreEqual (new byte[] { 0xFE, 0xFE}, new BigInteger (-0x0102L).ToByteArray (), "#2m");
734 Assert.AreEqual (new byte[] { 0xFD, 0xFD, 0xFE }, new BigInteger (-0x010203L).ToByteArray (), "#3m");
735 Assert.AreEqual (new byte[] { 0xFC, 0xFC, 0xFD, 0xFE}, new BigInteger (-0x01020304L).ToByteArray (), "#4m");
736 Assert.AreEqual (new byte[] { 0xFB, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x0102030405L).ToByteArray (), "#5m");
737 Assert.AreEqual (new byte[] { 0xFA, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x010203040506L).ToByteArray (), "#6m");
738 Assert.AreEqual (new byte[] { 0xF9, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x01020304050607L).ToByteArray (), "#7m");
739 Assert.AreEqual (new byte[] { 0xF8, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x0102030405060708L).ToByteArray (), "#8m");
742 Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, new BigInteger (long.MaxValue).ToByteArray (), "#9");
743 Assert.AreEqual (new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, new BigInteger (long.MinValue).ToByteArray (), "#10");
745 Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0x7F, 0xFF }, new BigInteger (-2147483649L).ToByteArray (), "11");
749 public void IComparable () {
750 var a = new BigInteger (99);
751 Assert.AreEqual (-1, a.CompareTo (100), "#1");
752 Assert.AreEqual (1, a.CompareTo (null), "#2");
756 public void ShortOperators () {
757 Assert.AreEqual (22, (int)new BigInteger ((short)22), "#1");
758 Assert.AreEqual (-22, (int)new BigInteger ((short)-22), "#2");
761 short x = (short)new BigInteger (10000000);
763 } catch (OverflowException) {}
766 short x = (short)new BigInteger (-10000000);
768 } catch (OverflowException) {}
772 public void DoubleCtor () {
774 new BigInteger (double.NaN);
776 } catch (OverflowException) {}
778 new BigInteger (double.NegativeInfinity);
780 } catch (OverflowException) {}
782 new BigInteger (double.PositiveInfinity);
784 } catch (OverflowException) {}
786 Assert.AreEqual (10000, (int)new BigInteger (10000.2), "#4");
787 Assert.AreEqual (10000, (int)new BigInteger (10000.9), "#5");
789 Assert.AreEqual (10000, (int)new BigInteger (10000.2), "#6");
790 Assert.AreEqual (0, (int)new BigInteger (0.9), "#7");
792 Assert.AreEqual (12345678999L, (long)new BigInteger (12345678999.33), "#8");
796 public void DoubleConversion () {
797 Assert.AreEqual (999d, (double)new BigInteger (999), "#1");
798 Assert.AreEqual (double.PositiveInfinity, (double)BigInteger.Pow (2, 1024), "#2");
799 Assert.AreEqual (double.NegativeInfinity, (double)BigInteger.Pow (-2, 1025), "#3");
804 public void DecimalCtor () {
805 Assert.AreEqual (999, (int)new BigInteger (999.99m), "#1");
806 Assert.AreEqual (-10000, (int)new BigInteger (-10000m), "#2");
807 Assert.AreEqual (0, (int)new BigInteger (0m), "#3");
811 public void DecimalConversion () {
812 Assert.AreEqual (999m, (decimal)new BigInteger (999), "#1");
815 var x = (decimal)BigInteger.Pow (2, 1024);
817 } catch (OverflowException) {}
820 var x = (decimal)BigInteger.Pow (-2, 1025);
822 } catch (OverflowException) {}
824 Assert.AreEqual (0m, (decimal)new BigInteger (0), "#4");
825 Assert.AreEqual (1m, (decimal)new BigInteger (1), "#5");
826 Assert.AreEqual (-1m, (decimal)new BigInteger (-1), "#6");
827 Assert.AreEqual (9999999999999999999999999999m,
828 (decimal)new BigInteger (9999999999999999999999999999m), "#7");
832 public void Parse () {
834 BigInteger.Parse (null);
836 } catch (ArgumentNullException) {}
839 BigInteger.Parse ("");
841 } catch (FormatException) {}
845 BigInteger.Parse (" ");
847 } catch (FormatException) {}
850 BigInteger.Parse ("hh");
852 } catch (FormatException) {}
855 BigInteger.Parse ("-");
857 } catch (FormatException) {}
860 BigInteger.Parse ("-+");
862 } catch (FormatException) {}
864 Assert.AreEqual (10, (int)BigInteger.Parse("+10"), "#7");
865 Assert.AreEqual (10, (int)BigInteger.Parse("10 "), "#8");
866 Assert.AreEqual (-10, (int)BigInteger.Parse("-10 "), "#9");
870 public void TryParse () {
871 BigInteger x = BigInteger.One;
872 Assert.IsFalse (BigInteger.TryParse (null, out x), "#1");
873 Assert.AreEqual (0, (int)x, "#1a");
874 Assert.IsFalse (BigInteger.TryParse ("", out x), "#2");
875 Assert.IsFalse (BigInteger.TryParse (" ", out x), "#3");
876 Assert.IsFalse (BigInteger.TryParse (" -", out x), "#4");
877 Assert.IsFalse (BigInteger.TryParse (" +", out x), "#5");
878 Assert.IsFalse (BigInteger.TryParse (" FF", out x), "#6");
880 Assert.IsTrue (BigInteger.TryParse (" 99", out x), "#7");
881 Assert.AreEqual (99, (int)x, "#8");
883 Assert.IsTrue (BigInteger.TryParse ("+133", out x), "#9");
884 Assert.AreEqual (133, (int)x, "#10");
886 Assert.IsTrue (BigInteger.TryParse ("-010", out x), "#11");
887 Assert.AreEqual (-10, (int)x, "#12");
891 public void TryParseWeirdCulture () {
892 var old = Thread.CurrentThread.CurrentCulture;
893 var cur = (CultureInfo)old.Clone ();
895 NumberFormatInfo ninfo = new NumberFormatInfo ();
896 ninfo.NegativeSign = ">";
897 ninfo.PositiveSign = "%";
898 cur.NumberFormat = ninfo;
900 Thread.CurrentThread.CurrentCulture = cur;
902 BigInteger x = BigInteger.Zero;
905 Assert.IsTrue (BigInteger.TryParse ("%11", out x), "#1");
906 Assert.AreEqual (11, (int)x, "#2");
908 Assert.IsTrue (BigInteger.TryParse (">11", out x), "#3");
909 Assert.AreEqual (-11, (int)x, "#4");
911 Thread.CurrentThread.CurrentCulture = old;