Display the source code in std/bigint.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

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.)

Constructors

Name	Description
`this` (s)	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` (isNegative, magnitude)	Construct a `BigInt` from a sign and a magnitude.
`this` (x)	Construct a `BigInt` from a built-in integral type.
`this` (x)	Construct a `BigInt` from another `BigInt`.

Properties

Name	Type	Description
`uintLength`[get]	`ulong`	Number of significant `uint`s which are used in storing this number. The absolute value of this `BigInt` is always < 2^{32*uintLength}
`ulongLength`[get]	`ulong`	Number of significant `ulong`s which are used in storing this number. The absolute value of this `BigInt` is always < 2^{64*ulongLength}

Methods

Name	Description
`getDigit` (n)	Gets the nth number in the underlying representation that makes up the whole `BigInt`.
`opAssign` (x)	Assignment from built-in integer types.
`opAssign` (x)	Assignment from another BigInt.
`opBinary` (y)	Implements binary operators between `BigInt`s.
`opBinary` (y)	Implements binary operators between `BigInt`'s and built-in integers.
`opBinary` (y)	Implements a narrowing remainder operation with built-in integer types.
`opBinaryRight` (y)	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 floating point types.
`opCast` ()	Implements casting to/from qualified `BigInt`'s.
`opCmp` (y)	Implements 3-way comparisons of `BigInt` with `BigInt` or `BigInt` with built-in numeric types.
`opEquals` (y)	Implements `BigInt` equality test with other `BigInt`'s and built-in numeric types.
`opOpAssign` (y)	Implements assignment operators from built-in integers of the form `BigInt op= integer`.
`opOpAssign` (y)	Implements assignment operators of the form `BigInt op= BigInt`.
`opUnary` ()	Implements `BigInt` unary operators.
`toHash` ()
`toInt` ()
`toLong` ()
`toString` (sink, formatString)	Convert the `BigInt` to `string`, passing it to the given sink.

Example

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

Authors

Don Clugston

License

Boost License 1.0.