powm

const x = 42.Z;
assert(x.unaryMinus() == -42);   // l-value `this`
assert(42.Z.unaryMinus() == -42); // r-value `this`

assert(mpz(    42).toString ==   `42`);
assert(mpz(   -42).toString ==  `-42`);
assert(mpz(`-101`).toString == `-101`);

assert(mpz(-42).toDecimalString == `-42`);
assert(mpz( 42).toDecimalString ==  `42`);

assert(mpz( 0).toHex == `0`);
assert(mpz( 1).toHex == `1`);
assert(mpz( 9).toHex == `9`);
assert(mpz(10).toHex == `A`);
assert(mpz(14).toHex == `E`);
assert(mpz(15).toHex == `F`);
assert(mpz(16).toHex == `10`);

assert(mpz(-42).absUnsign!ulong == 42);
assert(mpz( 42).absUnsign!ulong == 42);

Z a = 42;
{
    Z b = a + 1.Z;              // r-value `rhs`
    assert(b.mutatingCallCount == 2);
    assert(b == 43);
}

{
    Z b = a - 1.Z;              // r-value `rhs`
    assert(b.mutatingCallCount == 2);
    assert(b == 41);
}

{
    Z b = a * 2.Z;              // r-value `rhs`
    assert(b.mutatingCallCount == 2);
    assert(b == 84);
}

{
    Z b = a / 2.Z;              // r-value `rhs`
    assert(b.mutatingCallCount == 2);
    assert(b == 21);
}

{
    Z b = a % 10.Z;              // r-value `rhs`
    assert(b.mutatingCallCount == 2);
    assert(b == 2);
}

1 const _ = (cast(uint)42).Z;
2 const a = 42.Z;
3 const b = 43UL.Z;
4 const c = 43.0.Z;
5 const z = 0.Z;
6 
7 // `opOpAssign` with `Unsigned`
8 auto w = 42.Z;
9 assert(w == 42);
10 
11 w += 100UL;
12 assert(w == 142);
13 
14 w -= 100.Z;
15 assert(w == 42);
16 
17 w += 100UL;
18 assert(w == 142);
19 
20 w -= 100UL;
21 assert(w == 42);
22 
23 w *= 100UL;
24 assert(w == 4200);
25 
26 w /= 100UL;
27 assert(w == 42);
28 
29 w %= 10UL;
30 assert(w == 2);
31 
32 w ^^= 6UL;
33 assert(w == 64);
34 
35 w = 42;
36 assert(w == 42);
37 
38 w += 100;
39 assert(w == 142);
40 
41 w -= 100;
42 assert(w == 42);
43 
44 w *= 100;
45 assert(w == 4200);
46 
47 w /= 100;
48 assert(w == 42);
49 
50 w *= 100;
51 assert(w == 4200);
52 
53 w /= -100;
54 assert(w == -42);
55 
56 w *= -1;
57 assert(w == 42);
58 
59 w %= 10;
60 assert(w == 2);
61 
62 w = 2;
63 w ^^= 6;
64 assert(w == 64);
65 
66 w = 32.0;
67 assert(w == 32);
68 
69 w = 42UL;
70 assert(w == 42);
71 
72 w /= 2.Z;
73 assert(w == 21);
74 
75 w /= -2.Z;
76 assert(w == -10);
77 
78 w *= -2.Z;
79 assert(w == 20);
80 
81 w %= 3.Z;
82 assert(w == 2);
83 
84 w *= -1.Z;
85 assert(w == -2);
86 
87 w /= -1.Z;
88 assert(w == 2);
89 
90 // equality
91 assert(z == 0);
92 assert(z == cast(uint)0);
93 assert(z == 0L);
94 assert(z == 0UL);
95 assert(z == 0.0f);
96 assert(z == 0.0);
97 
98 // eval cast
99 
100 assert(a);
101 assert(cast(ulong)a == a);
102 assert(cast(ulong)a == 42);
103 assert(cast(long)a == a);
104 assert(cast(long)a == 42);
105 assert(cast(double)a == 42.0);
106 
107 // binary
108 
109 assert(`0b11`.Z == 3);
110 assert(`0B11`.Z == 3);
111 
112 // octal
113 
114 assert(`07`.Z == 7);
115 assert(`010`.Z == 8);
116 
117 // hexadecimal
118 
119 assert(`0x10`.Z == 16);
120 assert(`0X10`.Z == 16);
121 
122 // decimal
123 
124 assert(`101`.Z == 101);
125 assert(`101`.Z == 101);
126 
127 immutable ic = 101UL.Z;
128 
129 assert(a == a.dup);
130 assert(ic == ic.dup);
131 
132 // equality
133 
134 assert(a == a);
135 assert(a == 42.Z);
136 assert(a == 42.0);
137 assert(a == 42);
138 assert(a == cast(uint)42);
139 assert(a == 42UL);
140 assert(_ == 42);
141 assert(c == 43.0);
142 
143 // non-equality
144 
145 assert(a != b);
146 
147 // less than
148 
149 assert(a < b);
150 assert(a < 43.Z);
151 assert(a < 43);
152 assert(a < cast(uint)43);
153 assert(a < 43UL);
154 assert(a < 43.0);
155 
156 assert(-1.Z < 0.Z);
157 assert(-1.Z < 0L);
158 assert(-1.Z < 0UL);
159 assert(-1.Z < 0.0);
160 
161 // greater than
162 
163 assert(b > a);
164 assert(b > 42.Z);
165 assert(b > 42);
166 assert(b > cast(uint)42);
167 assert(b > 42UL);
168 assert(b > 42.0);
169 
170 assert(+1.Z > 0.Z);
171 assert(+1.Z > 0L);
172 assert(+1.Z > 0UL);
173 assert(+1.Z > 0.0);
174 
175 // absolute value
176 
177 assert(abs(a) == a);        // free function
178 assert(a.abs == a);         // UFCS
179 assert(abs(-42.Z) == 42);
180 assert(abs(-a) == a);
181 
182 // absolute value comparison
183 
184 assert(cmpabs(-43.Z,  44.Z) == -1);
185 assert(cmpabs(-43.Z, -44.Z) == -1);
186 assert(cmpabs(-44.Z, -43.Z) == +1);
187 assert(cmpabs(-43.Z, -43.Z) ==  0);
188 
189 assert(cmpabs(-43.Z,  44.0) == -1);
190 assert(cmpabs(-43.Z, -44.0) == -1);
191 assert(cmpabs(-44.Z, -43.0) == +1);
192 assert(cmpabs(-43.Z, -43.0) ==  0);
193 
194 assert(cmpabs(-43.Z, 44) == -1);
195 assert(cmpabs( 43.Z, 44) == -1);
196 assert(cmpabs(-44.Z, 43) == +1);
197 assert(cmpabs( 44.Z, 43) == +1);
198 assert(cmpabs(-43.Z, 43) ==  0);
199 
200 Z _43 = 43;
201 Z _4 = 4;
202 Z _24 = 24;
203 
204 // next prime
205 assert(nextPrime(_4) == 5);
206 assert(nextPrime(24.Z) == 29);
207 
208 assert(nextPrime(_24) == 29);
209 assert(nextPrime(24.Z) == 29);
210 assert(24.Z.nextPrime() == 29);
211 
212 assert(nextPrime(_43) == 47);
213 assert(nextPrime(43.Z) == 47);
214 assert(43.Z.nextPrime() == 47);
215 
216 // greatest common divisor
217 
218 assert(gcd(43.Z,  44.Z) == 1);
219 assert(gcd(4.Z, 24.Z) == 4);
220 assert(gcd(6.Z, 24.Z) == 6);
221 assert(gcd(10.Z, 100.Z) == 10);
222 
223 assert(gcd(43.Z,  44) == 1);
224 assert(gcd(4.Z, 24) == 4);
225 assert(gcd(6.Z, 24) == 6);
226 assert(gcd(10.Z, 100) == 10);
227 
228 assert(gcd(_43,  44) == 1);
229 assert(gcd(_4, 24) == 4);
230 assert(gcd(_4, _24) == 4);
231 assert(gcd(_4, 24.Z) == 4);
232 
233 // least common multiple
234 
235 assert(lcm(43.Z,  44.Z) == 1892);
236 assert(lcm(4.Z, 24.Z) == 24);
237 assert(lcm(6.Z, 24.Z) == 24);
238 assert(lcm(10.Z, 100.Z) == 100);
239 
240 assert(lcm(43.Z,  44) == 1892);
241 assert(lcm(4.Z, 24) == 24);
242 assert(lcm(6.Z, 24) == 24);
243 assert(lcm(10.Z, 100) == 100);
244 
245 assert(lcm(_43,  44) == 1892);
246 assert(lcm(_4, 24) == 24);
247 assert(lcm(_4, _24) == 24);
248 assert(lcm(_4, 24.Z) == 24);
249 
250 // negated value
251 
252 assert(-a == -42);
253 assert(-(-a) == a);
254 
255 auto n = 42.Z;
256 n.negate();
257 assert(n == -42);
258 n.negate();
259 assert(n == 42);
260 n.negate();
261 assert(n == -42);
262 n.absolute();
263 assert(n == 42);
264 n.absolute();
265 assert(n == 42);
266 
267 // addition
268 
269 assert(a + b == b + a);     // commutative
270 assert(a + 43.Z == b + a);
271 assert(a - 43.Z == -(43.Z - a));
272 assert(a + 0 == a);
273 assert(a + 1 != a);
274 assert(0 + a == a);
275 assert(1 + a != a);
276 assert(a + 0UL == a);
277 assert(a + 1UL != a);
278 assert(a + b == 42 + 43);
279 assert(1 + a == 43);
280 assert(a + (-1) == 41);
281 assert(1UL + a == 43);
282 assert(a + 1 == 1 + a);       // commutative
283 assert(a + (-1) == (-1) + a); // commutative
284 assert(1UL + a == a + 1UL);   // commutative
285 
286 // subtraction
287 
288 assert(a - 2 == 40);
289 assert(2 - a == -40);
290 assert(-2 - a == -44);
291 assert(a - 2 == -(2 - a));     // commutative
292 assert(a - (-2) == 44);
293 assert(44UL - 42.Z == 2);
294 
295 // multiplication
296 
297 assert(a * 1UL == a);
298 assert(a * 1 == a);
299 assert(1 * a == a);
300 assert(1UL * a == a);
301 assert((-1) * a == -a);
302 assert(a * 2 != a);
303 assert(a * -2 == -(2*a));
304 assert(a * b == b * a);
305 assert(a * b == 42UL * 43UL);
306 
307 // division
308 
309 assert(27.Z / 3.Z == 9);
310 assert(27.Z /   3  == 9);
311 
312 assert(27.Z / 10.Z  == 2);
313 assert(27.Z /   10   == 2);
314 assert(27.Z /   10UL == 2);
315 
316 assert(27.Z / -3   == -9);
317 assert(27.Z /  3UL ==  9);
318 
319 assert(27.Z / -10   == -2);
320 
321 assert(28   /  3.Z ==  9);
322 assert(28UL /  3.Z ==  9);
323 
324 assert(28   / -3.Z == -9);
325 assert(28UL / -3.Z == -9);
326 
327 // modulo/remainder
328 
329 assert(27.Z % 3.Z == 0);
330 assert(27.Z % 10.Z == 7);
331 
332 assert(27.Z % 3 == 0);
333 assert(-27.Z % 3 == 0);
334 
335 assert(27.Z % 10 == 7);
336 assert(27.Z % 10 == 7);
337 
338 assert(28   % 3.Z == 1);
339 assert(28UL % 3.Z == 1);
340 
341 assert( 28.Z  % -3 == -1); // negative divisor gives negative remainder according to https://en.wikipedia.org/wiki/Remainder
342 assert(-28.Z  %  3 == 1);  // dividend sign doesn't affect remainder
343 
344 //
345 assert( 28.Z  % -3.Z == 1);  // TODO should be -1
346 assert(-28.Z  %  3.Z == -1);  // TODO should be 1
347 assert( 28  % -3.Z == 1);      // TODO should be -1
348 assert(-28  %  3.Z == -1);     // TODO should be 1
349 
350 // modulo/remainder
351 
352 immutable one = 1.Z;
353 const two = 2.Z;
354 immutable three = 3.Z;
355 const four = 4.Z;
356 immutable five = 5.Z;
357 const six = 6.Z;
358 assert(six % one == 0);
359 assert(six % two == 0);
360 assert(six % three == 0);
361 assert(six % four == 2);
362 assert(six % five == 1);
363 assert(six % six == 0);
364 
365 // subtraction
366 
367 assert(six - one == 5);
368 assert(six - 1UL == 5);
369 assert(six - 1 == 5);
370 assert(1 - six == -5);
371 assert(1L - six == -5);
372 assert(1UL - six == -5);
373 
374 // exponentiation
375 
376 assert(0.Z^^0 == 1);
377 assert(3.Z^^3 == 27);
378 assert(3.Z^^3L == 27);
379 assert(2.Z^^8 == 256);
380 assert(2.Z^^8L == 256);
381 assert(2.Z^^8UL == 256);
382 
383 assert(Z.pow(2UL, 8UL) == 256);
384 assert(Z.pow(2UL, 8) == 256);
385 assert(Z.pow(2UL, 8) == 256);
386 assert(Z.pow(2, 8) == 256);
387 assert(Z.pow(-2, 8) == 256);
388 assert(Z.pow(-2, 7) == -128);
389 
390 // disallow power exponent to be an `MpZ`
391 assert(!__traits(compiles, 2^^8.Z == 256));
392 assert(!__traits(compiles, 2L^^8.Z == 256));
393 assert(!__traits(compiles, 2UL^^8.Z == 256));
394 
395 // exponentiation plus modulus
396 
397 assert(2.Z.powm(8.Z, 8.Z) == 0.Z);
398 assert(2.Z.powm(3.Z, 16.Z) == 8.Z);
399 assert(3.Z.powm(3.Z, 16.Z) == 11.Z);
400 
401 assert(2.Z.powm(8, 8.Z) == 0.Z);
402 assert(2.Z.powm(3, 16.Z) == 8.Z);
403 assert(3.Z.powm(3, 16.Z) == 11.Z);
404 
405 // bitwise and, or and xor
406 
407 {
408     foreach (immutable i; 0 .. 10)
409     {
410         foreach (immutable j; 0 .. 10)
411         {
412             assert((i.Z & j.Z) == (i & j));
413             assert((i.Z | j.Z) == (i | j));
414             assert((i.Z ^ j.Z) == (i ^ j));
415 
416             Z x = null;
417 
418             x = i.Z;
419             x &= j.Z;
420             assert(x == (i & j));
421 
422             x = i.Z;
423             x |= j.Z;
424             assert(x == (i | j));
425 
426             x = i.Z;
427             x ^= j.Z;
428             assert(x == (i ^ j));
429         }
430     }
431 }
432 
433 // swap
434 
435 auto x = 42.Z;
436 auto y = 43.Z;
437 
438 assert(x == 42);
439 assert(y == 43);
440 
441 x.swap(y);
442 
443 assert(y == 42);
444 assert(x == 43);
445 
446 swap(x, y);
447 
448 assert(x == 42);
449 assert(y == 43);
450 
451 assert(null.Z.fromString("42") == 42.Z);
452 assert(null.Z.fromString("42") < 43.Z);
453 assert(null.Z.fromString("42") > 41.Z);
454 assert(null.Z.fromString("42") == 42);
455 assert(null.Z.fromString("11", 2) == 3);
456 assert(null.Z.fromString("7", 8) == 7);
457 assert(null.Z.fromString("7") == 7);
458 assert(null.Z.fromString("e", 16) == 14);
459 assert(null.Z.fromString("f", 16) == 15);
460 assert(null.Z.fromString("0xe") == 14);
461 assert(null.Z.fromString("0xf") == 15);
462 assert(null.Z.fromString("10", 16) == 16);
463 assert(null.Z.fromString("10", 32) == 32);
464 
465 // odd and even
466 
467 assert(0.Z.isEven);
468 assert(1.Z.isOdd);
469 assert(2.Z.isEven);
470 assert(3.Z.isOdd);
471 
472 assert((-1).Z.isOdd);
473 assert((-2).Z.isEven);
474 assert((-3).Z.isOdd);
475 
476 assert("300000000000000000000000000000000000000".Z.isEven);
477 assert("300000000000000000000000000000000000001".Z.isOdd);
478 assert("300000000000000000000000000000000000002".Z.isEven);
479 assert("300000000000000000000000000000000000003".Z.isOdd);
480 
481 // negative and positive
482 
483 assert(0.Z.isPositive);
484 assert(1.Z.isPositive);
485 assert(2.Z.isPositive);
486 assert(3.Z.isPositive);
487 
488 assert((-1).Z.isNegative);
489 assert((-2).Z.isNegative);
490 assert((-3).Z.isNegative);
491 
492 // sign function (sgn)
493 
494 assert(long.min.Z.sgn == -1);
495 assert(int.min.Z.sgn  == -1);
496 assert(-2.Z.sgn == -1);
497 assert(-1.Z.sgn == -1);
498 assert( 0.Z.sgn ==  0);
499 assert( 1.Z.sgn ==  1);
500 assert( 2.Z.sgn ==  1);
501 assert(int.max.Z.sgn  == 1);
502 assert(long.max.Z.sgn == 1);
503 
504 assert(!long.min.Z.isZero);
505 assert(!int.min.Z.isZero);
506 assert(!(-2).Z.isZero);
507 assert(!(-1).Z.isZero);
508 assert( 0.Z.isZero);
509 assert(! 1.Z.isZero);
510 assert(! 2.Z.isZero);
511 assert(!int.max.Z.isZero);
512 assert(!long.max.Z.isZero);
513 
514 // fits in type
515 
516 foreach (Integral; AliasSeq!(short, int, long,
517                              ushort, uint, ulong))
518 {
519     assert(Integral.min.Z.fitsIn!Integral);
520     assert(Integral.max.Z.fitsIn!Integral);
521 }
522 
523 // TODO
524 // assert(short.min.Z.fitsIn!short);
525 // assert(short.max.Z.fitsIn!short);
526 // assert(ushort.min.Z.fitsIn!ushort);
527 // assert(ushort.max.Z.fitsIn!ushort);
528 
529 // internal limb count
530 
531 assert(0.Z._limbCount == 0);
532 assert(1.Z._limbCount == 1);
533 assert(2.Z._limbCount == 1);
534 
535 assert(Z.pow(2UL, 32UL)._limbCount == 1);
536 
537 assert(Z.pow(2UL, 63UL)._limbCount == 1);
538 assert(Z.pow(2UL, 63UL + 1)._limbCount == 2);
539 
540 assert(Z.pow(2UL, 127UL)._limbCount == 2);
541 assert(Z.pow(2UL, 127UL + 1)._limbCount == 3);
542 
543 assert(Z.pow(2UL, 255UL)._limbCount == 4);
544 assert(Z.pow(2UL, 255UL + 1)._limbCount == 5);

assert(Z.mersennePrime(15) == 2^^15 - 1);
assert(Z.mersennePrime(15UL) == 2^^15 - 1);

1 alias bigInt = mpz;
2 alias BigInt = Z;     // Phobos naming convention
3 
4 {
5     const BigInt a = "9588669891916142";
6     const BigInt b = "7452469135154800";
7     const c = a * b;
8     assert(c == BigInt("71459266416693160362545788781600"));
9     auto d = b * a;
10     assert(d == BigInt("71459266416693160362545788781600"));
11     assert(d == c);
12     d = c * BigInt("794628672112");
13     assert(d == BigInt("56783581982794522489042432639320434378739200"));
14     auto e = c + d;
15     assert(e == BigInt("56783581982865981755459125799682980167520800"));
16     const f = d + c;
17     assert(f == e);
18     auto g = f - c;
19     assert(g == d);
20     g = f - d;
21     assert(g == c);
22     e = 12_345_678;
23     g = c + e;
24     immutable h = g / b;
25     const i = g % b;
26     assert(h == a);
27     assert(i == e);
28     BigInt j = "-0x9A56_57f4_7B83_AB78";
29     j ^^= 11UL;
30     j ^^= 2L;
31     j ^^= 2;
32 }
33 
34 {
35     auto b = BigInt("1_000_000_000");
36 
37     b += 12_345;
38     assert(b == 1_000_012_345);
39     b += -12_345;
40     assert(b == 1_000_000_000);
41 
42     b -= -12_345;
43     assert(b == 1_000_012_345);
44     b -= +12_345;
45     assert(b == 1_000_000_000);
46 
47     b += 12_345;
48     assert(b == 1_000_012_345);
49 
50     b /= 5UL;
51     assert(b == 200_002_469);
52 }
53 
54 {
55     auto x = BigInt("123");
56     const y = BigInt("321");
57     x += y;
58     assert(x == 444);
59 }
60 
61 {
62     const x = BigInt("123");
63     const y = BigInt("456");
64     const BigInt z = x * y;
65     assert(z == 56_088);
66 }
67 
68 {
69     auto x = BigInt("123");
70     x *= 300;
71     assert(x == 36_900);
72 }
73 
74 {
75     auto x = BigInt("123");
76     x *= -1;
77     assert(x == -123);
78 }
79 
80 {
81     const x  = BigInt("1_000_000_500");
82 
83     immutable ulong ul  = 2_000_000UL;
84     immutable uint ui   = 500_000;
85     immutable ushort us = 30_000;
86     immutable ubyte ub  = 50;
87 
88     immutable long  l = 1_000_000L;
89     immutable int   i = 500_000;
90     immutable short s = 30_000;
91     immutable byte b  = 50;
92 
93     static assert(is(typeof(x % ul)  == ulong));
94     static assert(is(typeof(x % ui)  == uint));
95     static assert(is(typeof(x % us)  == ushort));
96     static assert(is(typeof(x % ub)  == ubyte));
97 
98     static assert(is(typeof(x % l)  == long));
99     static assert(is(typeof(x % i)  == int));
100     static assert(is(typeof(x % s)  == short));
101     static assert(is(typeof(x % b)  == byte));
102 
103     assert(x % ul == 500);
104     assert(x % ui == 500);
105     assert(x % us  == 10_500);
106     assert(x % ub == 0);
107 
108     assert(x % l  == 500L);
109     assert(x % i  == 500);
110     assert(x % s  == 10_500);
111     assert(x % b == 0);
112 }
113 
114 {
115     const x = BigInt("100");
116     const BigInt y = 123 + x;
117     assert(y == BigInt("223"));
118 
119     const BigInt z = 123 - x;
120     assert(z == BigInt("23"));
121 
122     // Dividing a built-in integer type by BigInt always results in
123     // something that fits in a built-in type, so the built-in type is
124     // returned, not BigInt.
125     static assert(is(typeof(1000 / x) == int));
126     assert(1000 / x == 10);
127 }
128 
129 {
130     auto x = BigInt("1234");
131     assert(+x  == BigInt(" 1234"));
132     assert(-x  == BigInt("-1234"));
133     ++x;
134     assert(x == BigInt("1235"));
135     --x;
136     assert(x == BigInt("1234"));
137 }
138 
139 {
140     const x = BigInt("12345");
141     const y = BigInt("12340");
142     immutable int z = 12_345;
143     immutable int w = 54_321;
144     assert(x == x);
145     assert(x != y);
146     assert(x == y + 5);
147     assert(x == z);
148     assert(x != w);
149 }
150 
151 {
152     // non-zero values are regarded as `true`
153     const x = BigInt("1");
154     const y = BigInt("10");
155     assert(x);
156     assert(y);
157 
158     // zero value is regarded as `false`
159     const z = BigInt("0");
160     assert(!z);
161 }
162 
163 {
164     assert(cast(int)BigInt("0") == 0);
165     assert(cast(ubyte)BigInt("0") == 0);
166 
167     assert(cast(ubyte)BigInt(255) == 255);
168     assert(cast(ushort)BigInt(65_535) == 65_535);
169     assert(cast(uint)BigInt(uint.max) == uint.max);
170     assert(cast(ulong)BigInt(ulong.max) == ulong.max);
171 
172     assert(cast(byte)BigInt(-128) == -128);
173     assert(cast(short)BigInt(-32_768) == -32_768);
174     assert(cast(int)BigInt(int.min) == int.min);
175     assert(cast(long)BigInt(long.min) == long.min);
176 
177     assert(cast(byte)BigInt(127) == 127);
178     assert(cast(short)BigInt(32_767) == 32_767);
179     assert(cast(int)BigInt(int.max) == int.max);
180     assert(cast(long)BigInt(long.max) == long.max);
181 
182     // TODO:
183     // import std.conv : to, ConvOverflowException;
184     // import std.exception : assertThrown;
185     // assertThrown!ConvOverflowException(BigInt("256").to!ubyte);
186     // assertThrown!ConvOverflowException(BigInt("-1").to!ubyte);
187 }
188 
189 {
190     // TODO
191     // segfaults because with double free
192     // const(BigInt) x = BigInt("123");
193     // BigInt y = cast()x;    // cast away const
194     // assert(y == x);
195 }
196 
197 {
198     const x = BigInt("100");
199     const y = BigInt("10");
200     const int z = 50;
201     const int w = 200;
202     assert(y < x);
203     assert(x > z);
204     assert(z > y);
205     assert(x < w);
206 }
207 
208 {
209     assert(BigInt("12345").toLong() == 12_345);
210     assert(BigInt("-123450000000000000000000000000").toLong() == long.min);
211     assert(BigInt("12345000000000000000000000000000").toLong() == long.max);
212 }
213 
214 {
215     assert(BigInt("12345").toInt() == 12_345);
216     assert(BigInt("-123450000000000000000000000000").toInt() == int.min);
217     assert(BigInt("12345000000000000000000000000000").toInt() == int.max);
218 }