# FixUtil Documentation

Back to summary

`import "util/bigint";`

## BigInteger class

This class allows to work easilly with arbitrary big integers.

Note: the non-class functions are using a shorter `bigint` prefix for functions.

- Initialization
- Operations
- Properties

### Initialization

`static function create(): BigInteger
static function create(value: Integer): BigInteger
`
  Creates a new big integer with given value (or zero).
`static function from_uint(value: Integer): BigInteger`
  Creates a new big integer with given unsigned integer value.
`static function from_string(s: String): BigInteger`
  Creates a new big integer from string representation, throwing an error on improper format.
`static function from_hex_string(s: String): BigInteger`
  Creates a new big integer from hexadecimal string representation (can be negative and can contain an optional `0x` prefix), throwing an error on improper format.
`static function from_bytes_BE(bytes: Byte[]): BigInteger
static function from_bytes_BE(bytes: Byte[], off: Integer, len: Integer): BigInteger
static function from_bytes_LE(bytes: Byte[]): BigInteger
static function from_bytes_LE(bytes: Byte[], off: Integer, len: Integer): BigInteger
`
  Creates a new big positive integer from bytes representing the number. The bytes can be in either Big Endian (BE) or Little Endian (LE) ordering and optionally you can pass an offset and length within the provided array.

### Operations

`function add(other: BigInteger): BigInteger`
  Adds two big integers and returns the result.
`function sub(other: BigInteger): BigInteger`
  Subtracts two big integers and returns the result.
`function mul(other: BigInteger): BigInteger`
  Multiplies two big integers and returns the result.
`function div(other: BigInteger): BigInteger`
  Divides two big integers and returns the quotient.
`function rem(other: BigInteger): BigInteger`
  Divides two big integers and returns the remainder.
`function divrem(other: BigInteger): BigInteger`
  Divides two big integers and returns the result as two values (first is the quotient and the second is the remainder). You need to explicitly check for errors by comparing the first value to `null`.
`function mod(other: BigInteger): BigInteger`
  Divides two big integers and returns the modulus.
`function abs(): BigInteger`
  Returns the absolute value.
`function shl(amount: Integer): BigInteger`
  Shifts the bits left (towards high order part) and returns the result.
`function shr(amount: Integer): BigInteger`
  Shifts the bits right (towards low order part) and returns the result.
`function modpow(exponent: BigInteger, modulus: BigInteger): BigInteger`
  Computes modular exponentiation and returns the result.
`function modinverse(modulus: BigInteger): BigInteger`
  Computes modular multiplicative inverse and returns the result.

### Properties

`function is_zero(): Boolean`
  Returns true when the value is zero.
`function cmp_lt(other: Integer): Boolean
function cmp_le(other: Integer): Boolean
function cmp_gt(other: Integer): Boolean
function cmp_ge(other: Integer): Boolean
`
  Returns the result of comparison. There are 4 variants:
  lt - less than
  le - less than or equal
  gt - greater than
  ge - greater than or equal
`function get_bitsize(): Integer`
  Returns the number of bits used to represent the value.
`function is_bit_set(pos: Integer): Boolean`
  Returns whether a bit on given position is set.
`function to_int(): Integer`
  Returns the value as a 32-bit signed integer, throwing an error in case it can't fit.
`function to_uint(): Integer`
  Returns the value as a 32-bit unsigned integer, throwing an error in case it can't fit.
`function to_string(): String`
  Returns the string representation of the value.
`function to_hex_string(): String
function to_hex_string(use_prefix: Boolean): String
`
  Returns the hex string representation of the value. Optionally you can disable prepending of the `0x` prefix.
`function to_bytes_BE(): Byte[]
function to_bytes_LE(): Byte[]
`
  Returns the byte representation of the value. Negative numbers are not supported. The bytes can be in either Big Endian (BE) or Little Endian (LE) ordering.