# BigInt class Null safety

An arbitrarily large integer value.

Big integers are signed and can have an arbitrary number of significant digits, only limited by memory.

To create a big integer from the provided number, use BigInt.from.

``````var bigInteger = BigInt.from(-1); // -1
bigInteger = BigInt.from(0.9999); // 0
bigInteger = BigInt.from(-10.99); // -10
bigInteger = BigInt.from(0x7FFFFFFFFFFFFFFF); // 9223372036854775807
bigInteger = BigInt.from(1e+30); // 1000000000000000019884624838656
``````

To parse a large integer value from a string, use parse or tryParse.

``````var value = BigInt.parse('0x1ffffffffffffffff'); // 36893488147419103231
value = BigInt.parse('12345678901234567890'); // 12345678901234567890
``````

To check whether a big integer can be represented as an int without losing precision, use isValidInt.

``````print(bigNumber.isValidInt); // false
``````

To convert a big integer into an int, use toInt. To convert a big integer into an double, use toDouble.

``````var bigValue = BigInt.from(10).pow(3);
print(bigValue.isValidInt); // true
print(bigValue.toInt()); // 1000
print(bigValue.toDouble()); // 1000.0
``````

See also:

Implemented types

## Constructors

BigInt.from(num value)
Creates a big integer from the provided `value` number.
factory

## Properties

bitLength int
Returns the minimum number of bits required to store this big integer.
read-only
hashCode int
The hash code for this object.
read-only, inherited
isEven bool
Whether this big integer is even.
read-only
isNegative bool
Whether this number is negative.
read-only
isOdd bool
Whether this big integer is odd.
read-only
isValidInt bool
Whether this big integer can be represented as an `int` without losing precision.
read-only
runtimeType Type
A representation of the runtime type of the object.
read-only, inherited
sign int
Returns the sign of this big integer.
read-only

## Methods

abs()
Returns the absolute value of this integer.
compareTo(BigInt other) int
Compares this to `other`.
override
gcd(BigInt other)
Returns the greatest common divisor of this big integer and `other`.
modInverse(BigInt modulus)
Returns the modular multiplicative inverse of this big integer modulo `modulus`.
modPow(BigInt exponent, BigInt modulus)
Returns this integer to the power of `exponent` modulo `modulus`.
noSuchMethod(Invocation invocation) → dynamic
Invoked when a non-existent method or property is accessed.
inherited
pow(int exponent)
Returns `this` to the power of `exponent`.
remainder(BigInt other)
Returns the remainder of the truncating division of `this` by `other`.
toDouble()
Returns this BigInt as a double.
toInt() int
Returns this BigInt as an int.
toRadixString(int radix)
Converts this to a string representation in the given `radix`.
toSigned(int width)
Returns the least significant `width` bits of this integer, extending the highest retained bit to the sign. This is the same as truncating the value to fit in `width` bits using an signed 2-s complement representation. The returned value has the same bit value in all positions higher than `width`.
toString()
Returns a String-representation of this integer.
override
toUnsigned(int width)
Returns the least significant `width` bits of this big integer as a non-negative number (i.e. unsigned representation). The returned value has zeros in all bit positions higher than `width`.

## Operators

operator %(BigInt other)
Euclidean modulo operator.
operator &(BigInt other)
Bit-wise and operator.
operator *(BigInt other)
Multiplies `other` by this big integer.
operator +(BigInt other)
Adds `other` to this big integer.
operator -(BigInt other)
Subtracts `other` from this big integer.
operator /(BigInt other)
Double division operator.
operator <(BigInt other) bool
Whether this big integer is numerically smaller than `other`.
operator <<(int shiftAmount)
Shift the bits of this integer to the left by `shiftAmount`.
operator <=(BigInt other) bool
Whether `other` is numerically greater than this big integer.
operator ==(Object other) bool
The equality operator.
inherited
operator >(BigInt other) bool
Whether this big integer is numerically greater than `other`.
operator >=(BigInt other) bool
Whether `other` is numerically smaller than this big integer.
operator >>(int shiftAmount)
Shift the bits of this integer to the right by `shiftAmount`.
operator ^(BigInt other)
Bit-wise exclusive-or operator.
operator unary-()
Return the negative value of this integer.
operator |(BigInt other)
Bit-wise or operator.
operator ~()
The bit-wise negate operator.
operator ~/(BigInt other)
Truncating integer division operator.

## Static Properties

one
A big integer with the numerical value 1.
read-only
two
A big integer with the numerical value 2.
read-only
zero
A big integer with the numerical value 0.
read-only

## Static Methods

parse(String source, {int? radix})
Parses `source` as a, possibly signed, integer literal and returns its value.
tryParse(String source, {int? radix}) BigInt?
Parses `source` as a, possibly signed, integer literal and returns its value.