This module incorporates code for various mathematical operations.


large_prime: Int = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab

A large prime number. The value is near 4 x 10^114.


base_q(n: Int, q: Int) -> List<Int>

Convert a integer n into some base q. This method should scale with any integer and any logical base.

maths.base_q(123, 7)

decay(start_amt: Int, scale: Int, num: Int) -> Int

Decay some starting amount logarithmically until zero. The function evaluates y = a - log(n) and when n >= 2^a the function equals zero but will return zero whenever the result is less than the scale. This is a great way to reduce some integer amount of something over time by incrementing n.

maths.decay(start_amount, lovelace_scaling, datum.current_int)

effective_ratio(amt: Int, pct: Int, scale: Int) -> Int

Calculates the ratio of the amount amt multiplied by the scale by the percentage pct. The scale allows for finer calculations.

maths.effective_ratio(123456789, 40, 1000) == 3086419725

from_int(self: Int) -> ByteArray

Convert a integer into a hexadecimal bytearray. This works for all integers but odd length bytearrays will be prefixed with a zero. This function combined with the to_int function allows a string to represent a number and still be used for calculations, pushing the 2^64 - 1 integer boundary.


gcd(a: Int, b: Int) -> Int

Computes greatest common divisor of two numbers.

maths.gcd(20, 15)

is_in_range(n: Int, lb: Int, ub: Int) -> Bool

Verify that some integer n is greater than the lower bound, lb, and less than or equal to the upper bound, ub. The function is exclusive for lb but inclusive for lb + 1.

maths.is_in_range(5, 0, 10)

legendre_symbol(a: Int, p: Int) -> Int

Calculate the Legendre symbol (a/p) using the Euler’s criterion. This implementation assumes that ‘a’ and ‘p’ are positive integers.

maths.legendre_symbol(10, 19)

list_powmod(lst: List<Int>, g: Int, q: Int) -> Int

Computes the power mod product of a list of integers.

maths.list_pow_mod([1,2,3], 2, 19)

list_product(lst: List<Int>) -> Int

Computes the product of a list of integers.


list_sum(lst: List<Int>) -> Int

Computes the sum of a list of integers.


powmod(n: Int, e: Int, q: Int) -> Int

Calculate n to the power of e modulo q using the exponentiation by squaring method. At each multiplication a modulo is calculated, allowing very large n and e values.

maths.powmod(3, 2, 5)

ratio(amt: Int, pct: Int) -> Int

Calculates the ratio of the amount amt by a percentage pct. This can be used to calculate rough percentages. The function ratio is just a special case of the effective ratio function.

maths.ratio(123, 40)

scaling(amt: Int, pct: Int) -> Int

Find the optimal scaling for a number such that it has three trailing zeros. This should be used in combination with the effective ratio for optimal calculations.

maths.scaling(123, 40)

to_int(self: ByteArray) -> Int

Convert a hexadecimal bytearray into its base 10 representation. This only works with even length bytearrays so arbitrary numbers in hexadecimal form will not in general work.

Search Document