This tutorial shows you how to use `BigInt`

class in Dart, which is used for arbitrary large number. This includes how to create a `BigInt`

instance as well as the lists of available properties, methods, and operators.

Using `int`

, the maximum value is limited at 9223372036854775807, which is the largest 64-bit signed integer. If you need to perform computation with a very big number bigger than it, you can use BigInt.

## Creating `BigInt`

Intances

The class doesn't have default constructor. The only available constructor is:

` BigInt.from(num value);`

It only accepts number (primitive types). If you pass a double, it will be rounded down.

Examples:

```
BigInt.from(5);
BigInt.from(1.6); // Rounded down to 1
```

Dart also provides static properties that allow us to easily create a `BigInt`

instance for these values:

```
BigInt.zero
BigInt.one
BigInt.two
```

You can also use static method `BigInt.parse`

` external static BigInt parse(String source, {int radix});`

Parameters:

`String source`

: the value to be parsed which represents an integer literal. Optionally you can add '+' or '-' sign at the front (default is positive).`int radix`

(optional): set the base of the`source`

. Default is 10, which is the base of decimal number.

If you want to parse a value represented by its binary, you need to set the `radix`

to 2. If the value is hexadecimal, the `radix`

should be set to 16 and you also need to remove the `0x`

prefix.

Unlike using `from`

which rounded down

Examples:

```
BigInt bi = BigInt.parse("9223372036854775807");
BigInt bi = BigInt.parse("1000", radix: 2); // 8
BigInt bi = BigInt.parse("FF", radix: 16); // 256
```

Using `parse`

method, you have to pass a valid value to avoid `FormatException`

being thrown. If you cannot guarantee that the value is always valid, you can use `tryParse`

which has the same parameters and implementation as `parse`

, except it returns `null`

if the value is invalid.

` BigInt bi = BigInt.tryParse("1.1"); // null`

Below are the list of properties, methods and operators of `BigInt`

class.

## Properties

Name | Return | Description |
---|---|---|

`bitLength` |
`int` |
Minimum bit required to store this instance |

`isEven` |
`bool` |
Whether the value is even. |

`isNegative` |
`bool` |
Whether the value is negative. |

`isOdd` |
`bool` |
Whether the value is even. |

`isValildInt` |
`bool` |
Whether it can be converted to integer without losing precision. It will return `false` if the value is larger than the maximum integer value (2^{64}) |

`sign` |
int | Sign of the value (-1 for negative, 0 for 0, 1 for positive). |

`hashCode` |
int | Hash code for the object. |

`runtimeType` |
Type | Runtime type for the object. |

## Method

Name | Return | Description |
---|---|---|

`abs` |
`BigInt` |
Returns the absolute value. |

`compareTo(BigInt other)` |
`int` |
Compares the value with other. Returns -1 if less than `other` , 1 if greater than `other` , 0 if equals with `other` . |

`gcd(BigInt other)` |
`BigInt` |
returns the GCD (Greatest Common Divisor) with `other` . |

`modInverse(BigInt modulus)` |
`BigInt` |
Returns the modular multiplicative inverse of the value modulo `modulus` |

`modPow(BigInt exponent, BigInt modulus)` |
`BigInt` |
Returns the value power of `exponent` modulo `modulus` |

`pow(int exponent)` |
`BigInt` |
Returns value power by `exponent` . |

`remainder(BigInt other)` |
`BigInt` |
Returns the remainder of division with `other` . |

`toDouble()` |
`double` |
Converts to double. |

`toInt()` |
`int` |
Converts to integer. |

`toRadixString(int radix)` |
`String` |
Converts to string in the given `radix` . |

`toSigned(int width)` |
`BigInt` |
Returns the least significant `width` bits of this integer, extending the highest retained bit to the sign. |

`toString()` |
`String` |
Returns the spring representation. |

`toUnsigned(int width)` |
`BigInt` |
Returns the least significant `width` bits of this big integer as a non-negative number (i.e. unsigned representation). |

## Operators

Name | Return | Description |
---|---|---|

+ | `BigInt` |
Addition |

`-` |
`BigInt` |
Subtraction |

`*` |
`BigInt` |
Multiplication |

`/` |
`double` |
Division |

`%` |
`BigInt` |
Modulo |

`&` |
`BigInt` |
Bit-wise and |

`<<` |
`BigInt` |
Shift bits to left |

`>>` |
`double` |
Shift bits to right |

`<` |
`bool` |
Less than |

`<=` |
`bool` |
Less than or equal |

`>` |
`bool` |
Greater than |

`>=` |
`bool` |
Greater than or equal |

`^` |
`BigInt` |
Bit-wise xor |

`unary-` |
`BigInt` |
Negative value |

`|` |
`BigInt` |
Bit-wise or |

`~` |
`BigInt` |
Bit-wise negate |

`~/` |
`BigInt` |
Truncating |

Below are some usage examples of the above operators:

```
BigInt bi1 = BigInt.parse("100000000000000000000000000000000"); // 10 pow 32
BigInt bi2 = BigInt.parse("200000000000000000000000000000000"); // 2 * (10 pow 32)
print(bi1 + bi2); // 3 * (10 pow 32)
print(bi1 - bi2); // -10 pow 32
print(bi1 * bi2); // 2 * (10 pow 64)
print(bi1 / bi2); // 0.5
print(bi1 << 1); // 2 * (10 pow 32)
print(bi1 >> 1); // 5 * (10 pow 31)
print(bi1 & bi2); // 16165108075998070557326583005184
print(bi1 | bi2); // 283834891924001929442673416994816
print(bi1 ^ bi2); // 267669783848003858885346833989632
print(bi1.pow(100)); // 10 pow 3200
```