View source code
Display the source code in std/bigint.d from which this page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

Struct std.bigint.BigInt

A struct representing an arbitrary precision integer.

struct BigInt ;

All arithmetic operations are supported, except unsigned shift right (>>>). Bitwise operations (|, &, ^, ~) are supported, and behave as if BigInt was an infinite length 2's complement number.

BigInt implements value semantics using copy-on-write. This means that assignment is cheap, but operations such as x++ will cause heap allocation. (But note that for most bigint operations, heap allocation is inevitable anyway.)


this Construct a BigInt from a decimal or hexadecimal string. The number must be in the form of a decimal or hex literal. It may have a leading + or - sign, followed by 0x or 0X if hexadecimal. Underscores are permitted in any location after the 0x and/or the sign of the number.
this Construct a BigInt from a built-in integral type.
this Construct a BigInt from another BigInt.


uintLength[get] ulongNumber of significant uints which are used in storing this number. The absolute value of this BigInt is always < 232*uintLength
ulongLength[get] ulongNumber of significant ulongs which are used in storing this number. The absolute value of this BigInt is always < 264*ulongLength


getDigit Gets the nth number in the underlying representation that makes up the whole BigInt.
opAssign Assignment from built-in integer types.
opAssign Assignment from another BigInt.
opBinary Implements binary operators between BigInts.
opBinary Implements binary operators between BigInt's and built-in integers.
opBinary Implements a narrowing remainder operation with built-in integer types.
opBinaryRight Implements operators with built-in integers on the left-hand side and BigInt on the right-hand side.
opCast Implements casting to bool.
opCast Implements casting to integer types.
opCast Implements casting to/from qualified BigInt's.
opCmp Implements 3-way comparisons of BigInt with BigInt or BigInt with built-in numeric types.
opEquals Implements BigInt equality test with other BigInt's and built-in numeric types.
opOpAssign Implements assignment operators from built-in integers of the form BigInt op= integer.
opOpAssign Implements assignment operators of the form BigInt op= BigInt.
opUnary Implements BigInt unary operators.
toString Convert the BigInt to string, passing it to the given sink.


BigInt a = "9588669891916142";
BigInt b = "7452469135154800";
auto c = a * b;
writeln(c); // BigInt("71459266416693160362545788781600")
auto d = b * a;
writeln(d); // BigInt("71459266416693160362545788781600")
writeln(d); // c
d = c * BigInt("794628672112");
writeln(d); // BigInt("56783581982794522489042432639320434378739200")
auto e = c + d;
writeln(e); // BigInt("56783581982865981755459125799682980167520800")
auto f = d + c;
writeln(f); // e
auto g = f - c;
writeln(g); // d
g = f - d;
writeln(g); // c
e = 12345678;
g = c + e;
auto h = g / b;
auto i = g % b;
writeln(h); // a
writeln(i); // e
BigInt j = "-0x9A56_57f4_7B83_AB78";
BigInt k = j;
j ^^= 11;
writeln(k^^11); // j


Don Clugston


Boost License 1.0.