math

The size of a number, ignoring its sign. abs(-5) and abs(5) are both 5.

print("size", abs(-5))

How far apart two numbers are — the difference with the sign dropped, computed wide so opposite extremes cannot wrap. Faults when even that gap does not fit.

print(absDiff(3, 10))

The current value moved towards the target by at most step, never overshooting. For easing a value in without a fraction.

print("eased", approach(0, 100, 10))

The angle from one point toward another, in whole degrees 0 to 359 — 0 is right, 90 is up. Feed it the difference of two positions.

print(atan2Deg(0, 10))

The average of two numbers, rounded down, worked out so it cannot overflow on the way.

print("mid", average(10, 21))

True when value is from low to high, ends included. Reads better than two comparisons joined with and.

if between(fatigue(), 80, 100) { print("nearly tired") }

A number written in base two, as text.

print("bits", binaryOf(5))

The bits set in both numbers — the bitwise AND, for reading a mask.

print("masked", bitAnd(prayerMask(), 2))

The bits set in either number — the bitwise OR, for combining flags.

print("flags", bitOr(1, 4))

The bits set in one number but not the other — the bitwise XOR.

print("toggled", bitXor(5, 1))

The distance between two points when diagonal steps count as one — the larger of the two differences, how RSC's own tiles measure reach.

print(chebyshev(0, 0, 3, 4))

The value held between low and high: below low it becomes low, above high it becomes high. Refuses when low is above high.

uiProgress("bag", clamp(120, 0, 100), 100)

How many ways k things can be chosen from n when order does not matter. Computed wide; faults when the answer does not fit.

print(combinations(5, 2))

The number written with a comma every three digits, for a readout: 1234567 becomes 1,234,567.

print("gp", commas(1000000))

The cosine of an angle multiplied up into a whole number — the partner of sinScaled, for circling a point.

print(cosScaled(0, 1000))

How many bits are set in a number — its population count.

print("bits", countBits(255))

The shortest turn between two angles, 0 to 180 — 350 and 10 are twenty degrees apart, not three hundred and forty.

print(degreesBetween(350, 10))

A random roll from 1 to the number of sides. Refuses fewer than one side.

print("roll", dice(6))

How many digits a number has, ignoring any minus sign. digits(1000) is 4.

print("width", digits(1000))

The straight-line distance between two points, rounded to the nearest whole number — the screen-pixel partner of the tile distance.

print(distance(0, 0, 3, 4))

The factorial of a number — n times every number below it. Refuses below zero or above 20, where it stops fitting in a whole number.

print("5!", factorial(5))

The n-th Fibonacci number: fib(0) is 0, fib(1) is 1, each after is the sum of the two before. Faults past fib(92), the last that fits.

print(fib(10))

Whole division that rounds towards minus infinity, unlike '/' which rounds towards zero. floorDiv(-7, 2) is -4 where -7 / 2 is -3. Refuses divide by zero.

print("rows", floorDiv(0 - 7, 2))

The remainder that always has the sign of b, unlike '%' which takes the sign of a. This is the one you want to cycle an index: floorMod(-1, 4) is 3, not -1. Refuses a zero wrap.

let corner = floorMod(0 - 1, 4)  print(corner)

The greatest common divisor of two numbers — the largest that divides both.

print("gcd", gcd(24, 36))

A repeatable number for a piece of text — the same text always gives the same number. For bucketing or a stable per-name choice, not for security.

print("bucket", floorMod(hash("mining"), 4))

A number written in base sixteen, as text.

print("hex", hexOf(255))

True when a number divides by two exactly.

if isEven(4) { print("even") }

True when a number does not divide by two exactly.

if isOdd(3) { print("odd") }

True when the number is exactly a power of two: 1, 2, 4, 8 and so on. Zero and negatives are not.

if isPowerOfTwo(64) { print("it is") }

True when the number is prime. Exact for every number the language holds — this is a real primality proof, not a guess — and instant even at the top of the range. Zero, one and negatives are not prime.

if isPrime(1000003) { print("prime") }

The number a percentage of the way from one to another: lerp(0, 200, 25) is 50. Computed wide, so big ends cannot wrap; faults on overflow.

print(lerp(0, 200, 25))

How many times 10 divides into a number, rounded down — one less than how many digits it has. Refuses zero and below.

print(log10(2500))

How many times 2 divides into a number, rounded down: log2(1000) is 9. Refuses zero and below, which have no logarithm.

print(log2(1024))

The distance between two points walking only along the axes — the sum of the two differences, how movement on a grid actually costs.

print(manhattan(0, 0, 3, 4))

A number moved from one range onto another, keeping its proportion — 50 of 0..100 becomes 128 of 0..255. Rounded down; refuses a zero-width input range.

print("scaled", mapRange(50, 0, 100, 0, 255))

The larger of two numbers.

The largest of three numbers — max of a pair already exists; this saves nesting it for a third.

print("higher", max(3, 8))
print(max(3, 1, 2))

The smaller of two numbers.

The smallest of three numbers — min of a pair already exists; this saves nesting it for a third.

print("lower", min(3, 8))
print(min(3, 1, 2))

value times 'by', divided by 'over', computed wide so the middle cannot wrap — THE safe way to take a ratio of a big number. Faults on overflow and refuses dividing by zero.

print(mulDiv(1000000, 3, 4))

The smallest power of two that is the number or bigger: 100 rounds to 128. Faults past the largest one a number can hold.

print(nextPowerOfTwo(100))

The first prime STRICTLY after a number: nextPrime(10) is 11, nextPrime(11) is 13. Faults past the largest prime a number can hold.

print(nextPrime(100))

The first run of digits in a line as a number, ignoring commas, or none when there is no number. 'You now have 1,234 coins' reads as 1234.

if numberIn("you have 5 coins") == none { return 600 }

True about one time in n, at random. oneIn(100) is a one-percent chance. Refuses fewer than one.

if oneIn(50) { print("rare") }

The number right-aligned in spaces to at least the given width, so rows of them line up in a label. A number already wider is unchanged.

uiLabel("count", padded(7, 4))

The whole number a string spells, or none when it is not a plain number. Test the none the way you would test a nearest-thing that was not found.

if parseInt("42") == none { print("not a number") }

What percentage part is of whole, from 0 to 100, rounded down. Refuses a zero whole, which has no percentage.

uiProgress("done", percentOf(15, 30), 100)

How many ways k things can be picked from n when order matters. Computed wide; faults when the answer does not fit.

print(permutations(5, 2))

One of the values at random, each as likely as its weight — pickWeighted of 600, 900 with weights 3, 1 answers 600 three times in four. None for empty lists; refuses mismatched sizes and negative weights.

print(pickWeighted(range(0, 3), range(1, 4)))

The base raised to the exponent, as a whole number. Refuses a negative exponent (that is a fraction) and faults if the result is too big to hold.

print("kb", pow(2, 10))

base to the power of exponent, wrapped by the modulus at every step — huge powers without huge numbers. Refuses a negative exponent and a modulus under 1.

print(powMod(2, 100, 1000))

A random number from low to high, BOTH ends included — randomBelow counts from zero; this one you aim. Refuses low above high.

print(randBetween(600, 900))

Minus one or one, chosen at random — a coin flip as a number to multiply by.

print("drift", randomSign() * 3)

The number with its digits reversed, the sign kept: 1234 answers 4321. Faults when the mirrored digits do not fit a whole number.

print(reverseNumber(1234))

The k-th root of a number, rounded down: root(1000, 3) is 10. Refuses a negative number and a root below 2.

print(root(1000, 3))

The value rounded to the nearest multiple of step. roundTo(23, 10) is 20. Refuses a step of zero or less.

print("nearest ten", roundTo(23, 10))

value times numerator over denominator, worked out with room to spare so the middle step cannot overflow. The fixed-point workhorse: scale(ms, 3, 2) is half again as long. Refuses a zero denominator.

print("longer", scale(600, 3, 2))

The number with its bits moved left, which doubles it once per place. Refuses a shift outside 0 to 63.

print("kb", shiftLeft(1, 10))

The number with its bits moved right, which halves it once per place. Refuses a shift outside 0 to 63.

print("halved", shiftRight(1024, 2))

Minus one for a negative number, zero for zero, one for a positive number.

if sign(0 - 4) < 0 { print("negative") }

The sine of an angle multiplied up into a whole number: sinScaled(90, 1000) is 1000 — how trigonometry crosses into a whole-number language.

print(sinScaled(90, 1000))

The whole-number square root, rounded down like distance() is. sqrt(10) is 3. For a fraction, work in tenths or hundredths with sqrtScaled-style maths. Refuses a negative number.

print("side", sqrt(144))

The digits of a number added together, the sign ignored: 1234 answers 10.

print(sumOfDigits(1234))

Every whole number from one to n added together. Refuses a negative n.

print("triangle", sumTo(100))

Where a value sits between two ends, as a percentage: unlerp(0, 200, 50) is 25 — the reverse of lerp. Refuses equal ends, between which nothing has a place.

print(unlerp(0, 200, 50))

The average of the values with each counting its weight's worth, rounded toward zero. None when the weights add to nothing; refuses mismatched sizes and negative weights.

print(weightedMean(range(0, 3), range(1, 4)))

The value wrapped round into the range low to high, so it never falls off either end — an index that keeps cycling. Refuses an empty range.

let corner = wrap(5, 0, 4)  print(corner)