bignum

stable

Arbitrary-precision integer arithmetic using base-10^9 digit arrays, supporting addition, subtraction, multiplication, division, power, GCD, and comparisons on numbers of any size.

use plugin bignum::{from_string, from_int, add, …}

12 functions Math

Runs with the native Zolo host

Plugin snippets can be edited in the Playground, but native capabilities are executed locally with the Zolo CLI.

/ filter jk navigate Esc clear

Functions (12)

from_string Parses a decimal string (optionally prefixed with + or -) into a BigNum.
from_int Creates a BigNum from a native Zolo integer.
add Adds two BigNum values and returns a new BigNum.
sub Subtracts b from a and returns a new BigNum.
mul Multiplies two BigNum values using schoolbook multiplication.
div Integer division truncated toward zero.
rem Returns the remainder after integer division.
pow Raises a BigNum to a non-negative integer exponent using fast exponentiation.
gcd Computes the greatest common divisor of two BigNums using Euclidean algorithm.
compare Returns -1 if a < b, 0 if a == b, or 1 if a > b.
to_string Converts a BigNum back to its decimal string representation.
digit_count Returns the number of decimal digits in the BigNum (excluding sign).

From import to result

01Import only what you use
02Copy the smallest example
03Run it with the Zolo CLI

from_string(s) → BigNum

Parses a decimal string (optionally prefixed with + or -) into a BigNum.

Parses a decimal string (optionally prefixed with + or -) into a BigNum. Use this when you have a large number that exceeds native integer range.

use plugin bignum::{from_string, to_string, add}

let a = from_string("999999999999999999999999999999")
let b = from_string("1")
let result = add(a, b)
print(to_string(result))

from_int(val) → BigNum

Creates a BigNum from a native Zolo integer.

Creates a BigNum from a native Zolo integer. Useful when starting arithmetic that will grow beyond native int bounds.

use plugin bignum::{from_int, mul, to_string}

let n = from_int(1000000)
let squared = mul(n, n)
print(to_string(squared))

add(a, b) → BigNum

Adds two BigNum values and returns a new BigNum.

Adds two BigNum values and returns a new BigNum. Handles mixed signs correctly.

use plugin bignum::{from_string, add, to_string}

let x = from_string("123456789012345678901234567890")
let y = from_string("987654321098765432109876543210")
print(to_string(add(x, y)))

sub(a, b) → BigNum

Subtracts b from a and returns a new BigNum.

use plugin bignum::{from_string, sub, to_string}

let x = from_string("1000000000000000000000")
let y = from_string("1")
print(to_string(sub(x, y)))

mul(a, b) → BigNum

Multiplies two BigNum values using schoolbook multiplication.

use plugin bignum::{from_int, mul, to_string}

let factorial = from_int(1)
let i = from_int(1)
let limit = from_int(20)
// compute 20! manually
print(to_string(mul(from_int(2432902008176640000), from_int(1))))

div(a, b) → BigNum

Integer division truncated toward zero.

Integer division truncated toward zero. Raises an error on division by zero.

use plugin bignum::{from_string, div, to_string}

let a = from_string("1000000000000000000000")
let b = from_string("7")
print(to_string(div(a, b)))

rem(a, b) → BigNum

Returns the remainder after integer division.

Returns the remainder after integer division. Sign matches the dividend.

use plugin bignum::{from_string, rem, to_string}

let a = from_string("1000000000000000000007")
let b = from_string("7")
print(to_string(rem(a, b)))

pow(a, exp) → BigNum

Raises a BigNum to a non-negative integer exponent using fast exponentiation.

use plugin bignum::{from_int, pow, to_string, digit_count}

let two = from_int(2)
let p = pow(two, 100)
print("2^100 has {digit_count(p)} digits: {to_string(p)}")

gcd(a, b) → BigNum

Computes the greatest common divisor of two BigNums using Euclidean algorithm.

use plugin bignum::{from_string, gcd, to_string}

let a = from_string("123456789012345678901234567890")
let b = from_string("987654321098765432109876543210")
print(to_string(gcd(a, b)))

compare(a, b) → int

Returns -1 if a < b, 0 if a == b, or 1 if a > b.

Returns -1 if a < b, 0 if a == b, or 1 if a > b. Useful for sorting or conditional logic.

use plugin bignum::{from_string, compare}

let a = from_string("999999999999999")
let b = from_string("1000000000000000")
let ord = compare(a, b)
print("order: {ord}")

to_string(a) → string

Converts a BigNum back to its decimal string representation.

use plugin bignum::{from_string, pow, to_string}

let base = from_string("10")
let result = pow(base, 50)
print(to_string(result))

digit_count(a) → int

Returns the number of decimal digits in the BigNum (excluding sign).

use plugin bignum::{from_string, pow, from_int, digit_count}

let two = from_int(2)
let p = pow(two, 1000)
print("2^1000 has {digit_count(p)} decimal digits")

View source code