package core:math/big

Source

DIGIT :: distinct u64

Endianness :: enum i8 {
	Little   = -1, 
	Platform = 0, 
	Big      = 1, 
}

Error :: enum u8 {
	None                    = 0, 
	Out_Of_Memory           = 1, 
	Invalid_Pointer         = 2, 
	Invalid_Argument        = 3, 
	Mode_Not_Implemented    = 4,    // Allocation
	Assignment_To_Immutable = 10, 
	Max_Iterations_Reached  = 11, 
	Buffer_Overflow         = 12, 
	Integer_Overflow        = 13, 
	Integer_Underflow       = 14, 
	Division_by_Zero        = 30, 
	Math_Domain_Error       = 31, 
	Cannot_Open_File        = 50, 
	Cannot_Read_File        = 51, 
	Cannot_Write_File       = 52, 
	Unimplemented           = 127, 
	Okay                    = None, 
}

Flag :: enum u8 {
	NaN, 
	Inf, 
	Immutable, 
}

Flags :: bit_set[Flag; u8]

Int :: struct {
	used:  int,
	digit: [dynamic]DIGIT,
	sign:  Sign,
	flags: bit_set[Flag; u8],
}

Order :: enum i8 {
	LSB_First = -1, 
	MSB_First = 1, 
}

Primality_Flag :: enum u8 {
	Blum_Blum_Shub = 0, // Make prime congruent to 3 mod 4
	Safe           = 1, // Make sure (p-1)/2 is prime as well (implies .Blum_Blum_Shub)
	Second_MSB_On  = 3, // Make the 2nd highest bit one
}

Primality_Flags :: bit_set[Primality_Flag; u8]

Rat :: struct {
	a: Int,
	b: Int,
}

Sign :: enum u8 {
	Zero_or_Positive = 0, 
	Negative         = 1, 
}

Error_String: [Error]string : #sparse[Error]string{.None = "None", .Out_Of_Memory = "Out of memory", .Invalid_Pointer = "Invalid pointer", .Invalid_Argument = "Invalid argument", .Mode_Not_Implemented = "Allocation mode not implemented", .Assignment_To_Immutable = "Assignment to immutable", .Max_Iterations_Reached = "Max iterations reached", .Buffer_Overflow = "Buffer overflow", .Integer_Overflow = "Integer overflow", .Integer_Underflow = "Integer underflow", .Division_by_Zero = "Division by zero", .Math_Domain_Error = "Math domain error", .Cannot_Open_File = "Cannot_Open_File", .Cannot_Read_File = "Cannot_Read_File", .Cannot_Write_File = "Cannot_Write_File", .Unimplemented = "Unimplemented"}

ITOA_COUNT :: 18

ITOA_DIVISOR :: DIGIT(1_000_000_000_000_000_000)

MATH_BIG_USE_FROBENIUS_TEST :: !MATH_BIG_USE_LUCAS_SELFRIDGE_TEST

MATH_BIG_USE_LUCAS_SELFRIDGE_TEST :: #config(MATH_BIG_USE_LUCAS_SELFRIDGE_TEST, false)

-define:MATH_BIG_USE_LUCAS_SELFRIDGE_TEST=false

RADIX_TABLE_REVERSE_SIZE :: 80

FACTORIAL_BINARY_SPLIT_CUTOFF: int = …

FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS: int = …

FACTORIAL_MAX_N: int = …

INT_INF: ^Int = …

INT_MINUS_INF: ^Int = …

INT_MINUS_ONE: ^Int = …

INT_NAN: ^Int = …

INT_ONE: ^Int = …

INT_ZERO: ^Int = …

MAX_ITERATIONS_RANDOM_PRIME: int = …

MAX_ITERATIONS_ROOT_N: int = …

MUL_KARATSUBA_CUTOFF: int = …

MUL_TOOM_CUTOFF: int = …

RADIX_TABLE: string = …

@(rodata)
RADIX_TABLE_REVERSE: [80]u8 = …

@(thread_local)
RANDOM_PRIME_ITERATIONS_USED: int

SQR_KARATSUBA_CUTOFF: int = …

SQR_TOOM_CUTOFF: int = …

USE_MILLER_RABIN_ONLY: bool = …

assert_if_nil_int :: proc(integers: ..^Int, loc := #caller_location) {…}

assert_if_nil_rat :: proc(rationals: ..^Rat, loc := #caller_location) {…}

assert_initialized :: proc(a: ^Int, loc := #caller_location) {…}

clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {…}

clear_if_uninitialized_multi :: proc(
	args:      ..^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

clear_if_uninitialized_single :: proc(
	arg:       ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

combinations_with_repetition :: proc(dest: ^Int, n, r: int) -> (error: Error) {…}

combinations_without_repetition :: proc(dest: ^Int, n, r: int) -> (error: Error) {…}

copy_digits :: proc(
	dest, src: ^Int, 
	digits:    int, 
	offset:    int = int(0), 
	allocator := context.allocator, 
) -> (err: Error) {…}

count_bits :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err: Error) {…}

digit_log :: proc(a: DIGIT, base: DIGIT) -> (log: int, err: Error) {…}

error_if_immutable_multi :: proc(args: ..^Int) -> (err: Error) {…}

error_if_immutable_single :: proc(arg: ^Int) -> (err: Error) {…}

ilog2 :: proc(value: $T) -> (log2: T) {…}

int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_add_digit :: proc(
	dest, a:   ^Int, 
	digit:     DIGIT, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_add_rat :: proc(
	dst:       ^Rat, 
	x:         ^Int, 
	y:         ^Rat, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_addmod :: proc(
	remainder, number, addend, modulus: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_atoi :: proc(
	res:       ^Int, 
	input:     string, 
	radix:     i8 = i8(10), 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_bit_and :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_bit_complement :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_bit_or :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_bit_xor :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_bitfield_extract :: proc(
	a:             ^Int, 
	offset, count: int, 
	allocator := context.allocator, 
) -> (res: _WORD, err: Error) {…}

int_bitfield_extract_single :: proc(
	a:         ^Int, 
	offset:    int, 
	allocator := context.allocator, 
) -> (bit: _WORD, err: Error) {…}

int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -> (err: Error) {…}

int_clear :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_cmp :: int_compare

int_cmp_digit :: int_compare_digit

int_cmp_mag :: int_compare_magnitude

int_compare :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (comparison: int, err: Error) {…}

int_compare_digit :: proc(
	a:         ^Int, 
	b:         DIGIT, 
	allocator := context.allocator, 
) -> (comparison: int, err: Error) {…}

int_compare_magnitude :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (res: int, err: Error) {…}

int_copy :: proc(
	dest, src: ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_count_lsb :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err: Error) {…}

int_destroy :: proc(integers: ..^Int) {…}

int_div :: proc(
	quotient, numerator, denominator: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_div_digit :: proc(
	quotient, numerator: ^Int, 
	denominator:         DIGIT, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_div_rat :: proc(
	dst:       ^Rat, 
	x:         ^Int, 
	y:         ^Rat, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_divmod :: proc(
	quotient, remainder, numerator, denominator: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_divmod_digit :: proc(
	quotient, numerator: ^Int, 
	denominator:         DIGIT, 
	allocator := context.allocator, 
) -> (remainder: DIGIT, err: Error) {…}

int_double :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_equals :: proc(a, b: ^Int, allocator := context.allocator) -> (equals: bool, err: Error) {…}

int_equals_abs :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (equals: bool, err: Error) {…}

int_equals_digit :: proc(
	a:         ^Int, 
	b:         DIGIT, 
	allocator := context.allocator, 
) -> (equals: bool, err: Error) {…}

int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator) -> (err: Error) {…}

int_from_bytes_big :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_from_bytes_big_python :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_from_bytes_little :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_from_bytes_little_python :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_gcd :: proc(res, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_gcd_lcm :: proc(
	res_gcd, res_lcm, a, b: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_get :: proc(a: ^Int, $T: typeid, allocator := context.allocator) -> (res: T, err: Error) {…}

int_get_float :: proc(a: ^Int, allocator := context.allocator) -> (res: f64, err: Error) {…}

int_get_i128 :: proc(a: ^Int, allocator := context.allocator) -> (res: i128, err: Error) {…}

int_get_i32 :: proc(a: ^Int, allocator := context.allocator) -> (res: i32, err: Error) {…}

int_get_i64 :: proc(a: ^Int, allocator := context.allocator) -> (res: i64, err: Error) {…}

int_get_u128 :: proc(a: ^Int, allocator := context.allocator) -> (res: u128, err: Error) {…}

int_get_u32 :: proc(a: ^Int, allocator := context.allocator) -> (res: u32, err: Error) {…}

int_get_u64 :: proc(a: ^Int, allocator := context.allocator) -> (res: u64, err: Error) {…}

int_greater_than :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (greater_than: bool, err: Error) {…}

int_greater_than_abs :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (greater_than: bool, err: Error) {…}

int_greater_than_digit :: proc(
	a:         ^Int, 
	b:         DIGIT, 
	allocator := context.allocator, 
) -> (greater_than: bool, err: Error) {…}

int_greater_than_or_equal :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (greater_than_or_equal: bool, err: Error) {…}

int_greater_than_or_equal_abs :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (greater_than_or_equal: bool, err: Error) {…}

int_greater_than_or_equal_digit :: proc(
	a:         ^Int, 
	b:         DIGIT, 
	allocator := context.allocator, 
) -> (greater_than_or_equal: bool, err: Error) {…}

int_grow :: proc(
	a:            ^Int, 
	digits:       int, 
	allow_shrink: bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_halve :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_inf :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_init_multi :: proc(integers: ..^Int, allocator := context.allocator) -> (err: Error) {…}

int_is_even :: proc(a: ^Int, allocator := context.allocator) -> (even: bool, err: Error) {…}

int_is_initialized :: proc(a: ^Int) -> bool {…}

int_is_negative :: proc(
	a:         ^Int, 
	allocator := context.allocator, 
) -> (negative: bool, err: Error) {…}

int_is_odd :: proc(a: ^Int, allocator := context.allocator) -> (odd: bool, err: Error) {…}

int_is_positive :: proc(
	a:         ^Int, 
	allocator := context.allocator, 
) -> (positive: bool, err: Error) {…}

int_is_power_of_two :: proc(
	a:         ^Int, 
	allocator := context.allocator, 
) -> (res: bool, err: Error) {…}

int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (square: bool, err: Error) {…}

int_is_zero :: proc(a: ^Int, allocator := context.allocator) -> (zero: bool, err: Error) {…}

int_itoa_cstring :: proc(
	a:         ^Int, 
	radix:     i8 = i8(10), 
	allocator := context.allocator, 
) -> (res: cstring, err: Error) {…}

int_itoa_raw :: proc(
	a:              ^Int, 
	radix:          i8, 
	buffer:         []u8, 
	size:           int = int(-1), 
	zero_terminate: bool = false, 
) -> (written: int, err: Error) {…}

int_itoa_string :: proc(
	a:              ^Int, 
	radix:          i8 = i8(10), 
	zero_terminate: bool = false, 
	allocator := context.allocator, 
) -> (res: string, err: Error) {…}

int_lcm :: proc(res, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_less_than :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (less_than: bool, err: Error) {…}

int_less_than_abs :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (less_than: bool, err: Error) {…}

int_less_than_digit :: proc(
	a:         ^Int, 
	b:         DIGIT, 
	allocator := context.allocator, 
) -> (less_than: bool, err: Error) {…}

int_less_than_or_equal :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (less_than_or_equal: bool, err: Error) {…}

int_less_than_or_equal_abs :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (less_than_or_equal: bool, err: Error) {…}

int_less_than_or_equal_digit :: proc(
	a:         ^Int, 
	b:         DIGIT, 
	allocator := context.allocator, 
) -> (less_than_or_equal: bool, err: Error) {…}

int_log :: proc(
	a:         ^Int, 
	base:      DIGIT, 
	allocator := context.allocator, 
) -> (res: int, err: Error) {…}

int_minus_inf :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_minus_one :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_mod :: proc(
	remainder, numerator, denominator: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_mod_bits :: proc(
	remainder, numerator: ^Int, 
	bits:                 int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_mod_digit :: proc(
	numerator:   ^Int, 
	denominator: DIGIT, 
	allocator := context.allocator, 
) -> (remainder: DIGIT, err: Error) {…}

int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_mul_digit :: proc(
	dest, src:  ^Int, 
	multiplier: DIGIT, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_mul_rat :: proc(
	dst:       ^Rat, 
	x:         ^Int, 
	y:         ^Rat, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_mulmod :: proc(
	remainder, number, multiplicand, modulus: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_nan :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_one :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allocator) -> (err: Error) {…}

int_pow_int :: proc(
	dest:        ^Int, 
	base, power: int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_random :: proc(dest: ^Int, bits: int, allocator := context.allocator) -> (err: Error) {…}

int_random_digit :: internal_int_random_digit

int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.allocator) -> (err: Error) {…}

int_set_from_integer :: proc(
	dest:      ^Int, 
	src:       $T, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.allocator) -> (err: Error) {…}

int_shr :: proc(dest, source: ^Int, bits: int, allocator := context.allocator) -> (err: Error) {…}

int_shr_signed :: proc(
	dest, src: ^Int, 
	bits:      int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_shrmod :: proc(
	quotient, remainder, numerator: ^Int, 
	bits:                           int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_sqr :: proc(dest, src: ^Int) -> (err: Error) {…}

int_sqrmod :: proc(
	remainder, number, modulus: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) -> (err: Error) {…}

int_sub_digit :: proc(
	dest, a:   ^Int, 
	digit:     DIGIT, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_sub_rat :: proc(
	dst:       ^Rat, 
	x:         ^Int, 
	y:         ^Rat, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_submod :: proc(
	remainder, number, decrease, modulus: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_swap :: proc(a, b: ^Int) {…}

int_to_bytes_big :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_to_bytes_big_python :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_to_bytes_little :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_to_bytes_little_python :: proc(
	a:         ^Int, 
	buf:       []u8, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

int_to_bytes_size :: proc(
	a:         ^Int, 
	signed:    bool = false, 
	allocator := context.allocator, 
) -> (size_in_bytes: int, err: Error) {…}

int_to_cstring :: int_itoa_cstring

int_to_string :: int_itoa_string

internal_assert_initialized :: proc(a: ^Int, loc := #caller_location) {…}

internal_clamp :: proc(a: ^Int) -> (err: Error) {…}

internal_clear_if_uninitialized_multi :: proc(
	args:      ..^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_clear_if_uninitialized_single :: proc(
	arg:       ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_copy_digits :: proc(
	dest, src: ^Int, 
	digits:    int, 
	offset:    int = int(0), 
) -> (err: Error) {…}

internal_count_bits :: proc(a: ^Int) -> (count: int) {…}

internal_digit_log :: proc(a: DIGIT, base: DIGIT) -> (log: int, err: Error) {…}

internal_error_if_immutable_multi :: proc "contextless" (args: ..^Int) -> (err: Error) {…}

internal_error_if_immutable_single :: proc "contextless" (arg: ^Int) -> (err: Error) {…}

internal_get_low_u32 :: proc(a: ^Int) -> u32 {…}

internal_get_low_u64 :: proc(a: ^Int) -> u64 {…}

internal_int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_add_digit :: proc(
	dest, a:   ^Int, 
	digit:     DIGIT, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_add_signed :: proc(
	dest, a, b: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_add_unsigned :: proc(
	dest, a, b: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_addmod :: proc(
	remainder, number, addend, modulus: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_allocated_cap :: proc(a: ^Int) -> (cap: int) {…}

internal_int_and :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WORD, err: Error) {…}

internal_int_bitfield_extract_bool :: proc(a: ^Int, offset: int) -> (val: bool, err: Error) {…}

internal_int_bitfield_extract_single :: proc(a: ^Int, offset: int) -> (bit: _WORD, err: Error) {…}

internal_int_bitfield_set_single :: proc(a: ^Int, offset: int) -> (err: Error) {…}

internal_int_bitfield_toggle_single :: proc(a: ^Int, offset: int) -> (err: Error) {…}

internal_int_bitfield_unset_single :: proc(a: ^Int, offset: int) -> (err: Error) {…}

internal_int_clear :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_compare :: proc(a, b: ^Int) -> (comparison: int) {…}

internal_int_compare_digit :: proc(a: ^Int, b: DIGIT) -> (comparison: int) {…}

internal_int_compare_magnitude :: proc(a, b: ^Int) -> (comparison: int) {…}

internal_int_complement :: proc(
	dest, src: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_copy :: proc(
	dest, src: ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_count_lsb :: proc(a: ^Int) -> (count: int, err: Error) {…}

internal_int_decr :: proc(dest: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_destroy :: proc(integers: ..^Int) {…}

internal_int_div :: proc(
	quotient, numerator, denominator: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_divmod :: proc(
	quotient, remainder, numerator, denominator: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_divmod_digit :: proc(
	quotient, numerator: ^Int, 
	denominator:         DIGIT, 
	allocator := context.allocator, 
) -> (remainder: DIGIT, err: Error) {…}

internal_int_equals :: proc(a, b: ^Int) -> (equals: bool) {…}

internal_int_equals_abs :: proc(a, b: ^Int) -> (equals: bool) {…}

internal_int_equals_digit :: proc(a: ^Int, b: DIGIT) -> (equals: bool) {…}

internal_int_exponent_mod :: internal_int_power_modulo

internal_int_extended_euclidean :: proc(
	a, b, U1, U2, U3: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_factorial :: proc(
	res:       ^Int, 
	n:         int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_gcd :: proc(res_gcd, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_gcd_lcm :: proc(
	res_gcd, res_lcm, a, b: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_get :: proc(a: ^Int, $T: typeid) -> (res: T, err: Error) {…}

internal_int_get_float :: proc(a: ^Int) -> (res: f64, err: Error) {…}

internal_int_get_i128 :: proc(a: ^Int) -> (res: i128, err: Error) {…}

internal_int_get_i32 :: proc(a: ^Int) -> (res: i32, err: Error) {…}

internal_int_get_i64 :: proc(a: ^Int) -> (res: i64, err: Error) {…}

internal_int_get_u128 :: proc(a: ^Int) -> (res: u128, err: Error) {…}

internal_int_get_u32 :: proc(a: ^Int) -> (res: u32, err: Error) {…}

internal_int_get_u64 :: proc(a: ^Int) -> (res: u64, err: Error) {…}

internal_int_greater_than :: proc(a, b: ^Int) -> (greater_than: bool) {…}

internal_int_greater_than_abs :: proc(a, b: ^Int) -> (greater_than: bool) {…}

internal_int_greater_than_digit :: proc(a: ^Int, b: DIGIT) -> (greater_than: bool) {…}

internal_int_greater_than_or_equal :: proc(a, b: ^Int) -> (greater_than_or_equal: bool) {…}

internal_int_greater_than_or_equal_abs :: proc(a, b: ^Int) -> (greater_than_or_equal: bool) {…}

internal_int_greater_than_or_equal_digit :: proc(
	a: ^Int, 
	b: DIGIT, 
) -> (greater_than_or_equal: bool) {…}

internal_int_grow :: proc(
	a:            ^Int, 
	digits:       int, 
	allow_shrink: bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_incr :: proc(dest: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_inf :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_init_multi :: proc(
	integers:  ..^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_inverse_modulo :: proc(
	dest, a, b: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_invmod :: internal_int_inverse_modulo

internal_int_is_even :: proc(a: ^Int) -> (even: bool) {…}

internal_int_is_initialized :: proc(a: ^Int) -> (initialized: bool) {…}

internal_int_is_negative :: proc(a: ^Int) -> (negative: bool) {…}

internal_int_is_odd :: proc(a: ^Int) -> (odd: bool) {…}

internal_int_is_positive :: proc(a: ^Int) -> (positive: bool) {…}

internal_int_is_power_of_two :: proc(a: ^Int) -> (power_of_two: bool) {…}

internal_int_is_prime :: proc(
	a:                   ^Int, 
	miller_rabin_trials: int = int(-1), 
	miller_rabin_only:   bool = USE_MILLER_RABIN_ONLY, 
	allocator := context.allocator, 
) -> (is_prime: bool, err: Error) {…}

internal_int_is_square :: proc(
	a:         ^Int, 
	allocator := context.allocator, 
) -> (square: bool, err: Error) {…}

internal_int_is_zero :: proc(a: ^Int) -> (zero: bool) {…}

internal_int_kronecker :: proc(
	a, p:      ^Int, 
	allocator := context.allocator, 
) -> (kronecker: int, err: Error) {…}

internal_int_lcm :: proc(res_lcm, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_legendre :: internal_int_kronecker

internal_int_less_than :: proc(a, b: ^Int) -> (less_than: bool) {…}

internal_int_less_than_abs :: proc(a, b: ^Int) -> (less_than: bool) {…}

internal_int_less_than_digit :: proc(a: ^Int, b: DIGIT) -> (less_than: bool) {…}

internal_int_less_than_or_equal :: proc(a, b: ^Int) -> (less_than_or_equal: bool) {…}

internal_int_less_than_or_equal_abs :: proc(a, b: ^Int) -> (less_than_or_equal: bool) {…}

internal_int_less_than_or_equal_digit :: proc(a: ^Int, b: DIGIT) -> (less_than_or_equal: bool) {…}

internal_int_log :: proc(a: ^Int, base: DIGIT) -> (res: int, err: Error) {…}

internal_int_minus_inf :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_minus_one :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mod :: proc(
	remainder, numerator, denominator: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mod_bits :: proc(
	remainder, numerator: ^Int, 
	bits:                 int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mod_digit :: proc(
	numerator:   ^Int, 
	denominator: DIGIT, 
	allocator := context.allocator, 
) -> (remainder: DIGIT, err: Error) {…}

internal_int_mul :: proc(
	dest, src, multiplier: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mul_denom :: proc(
	dst, x, y: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mul_digit :: proc(
	dest, src:  ^Int, 
	multiplier: DIGIT, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mul_integer :: proc(
	dest, a:   ^Int, 
	b:         $T, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_mulmod :: proc(
	remainder, number, multiplicand, modulus: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_nan :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_one :: proc(
	a:         ^Int, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_or :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error) {…}

internal_int_pack :: proc(
	a:     ^Int, 
	buf:   []$T, 
	nails: int = 0, 
	order: Order = Order.LSB_First, 
) -> (written: int, err: Error) {…}

internal_int_pack_count :: proc(a: ^Int, $T: typeid, nails: int = 0) -> (size_needed: int) {…}

internal_int_pow :: proc(
	dest, base: ^Int, 
	power:      int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_pow_int :: proc(
	dest:        ^Int, 
	base, power: int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_power_modulo :: proc(
	res, G, X, P: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_power_of_two :: proc(
	a:         ^Int, 
	power:     int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_powmod :: internal_int_power_modulo

internal_int_prime_frobenius_underwood :: proc(
	N:         ^Int, 
	allocator := context.allocator, 
) -> (result: bool, err: Error) {…}

internal_int_prime_is_divisible :: proc(
	a:         ^Int, 
	allocator := context.allocator, 
) -> (res: bool, err: Error) {…}

internal_int_prime_miller_rabin :: proc(
	a, b:      ^Int, 
	allocator := context.allocator, 
) -> (probably_prime: bool, err: Error) {…}

internal_int_prime_next_prime :: proc(
	a:         ^Int, 
	trials:    int, 
	bbs_style: bool, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_prime_strong_lucas_selfridge :: proc(
	a:         ^Int, 
	allocator := context.allocator, 
) -> (lucas_selfridge: bool, err: Error) {…}

internal_int_random :: proc(
	dest:      ^Int, 
	bits:      int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_random_digit :: proc() -> (res: DIGIT) {…}

internal_int_read_from_ascii_file :: proc(
	a:         ^Int, 
	filename:  string, 
	radix:     i8 = i8(10), 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_root_n :: proc(
	dest, src: ^Int, 
	n:         int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_scale_denom :: proc(
	dst, x, y: ^Int, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_set_from_integer :: proc(
	dest:      ^Int, 
	src:       $T, 
	minimize:  bool = false, 
	allocator := context.allocator, 
) -> (err: Error) {…}

internal_int_shl :: proc(
	dest, src: ^Int, 
	bits:      int, 
	allocator := context.allocator, 
) -> (err: Error) {…}