@eryx/number Module

Returns a new Integer with the same value. This is useful when you want an explicit copy before passing the value around or transforming it.

Returns the absolute value of the integer. Negative inputs become positive; zero and positive values are unchanged.

Returns the sign of the integer. The result is -1 for negative values, 0 for zero, and 1 for positive values.

Compares this integer with another integer-like value. This is the explicit comparison method behind the ordering operators.

Checks whether the integer is exactly zero. This is a convenience predicate for branchy arithmetic code.

Checks whether the integer is exactly one. This is often handy in algorithms with multiplicative identities.

Checks whether the integer is even. Evenness is determined by the low bit, so this works efficiently even for very large values.

Checks whether the integer is odd. This is the complement of isEven().

Divides two integers using truncating division. The quotient is rounded toward zero.

Divides two integers using floor division. The quotient is rounded toward negative infinity.

Divides two integers using ceiling division. The quotient is rounded toward positive infinity.

Divides two integers and returns both the quotient and remainder. The quotient rounding rule is controlled by mode, and the remainder follows that choice.

Computes the greatest common divisor of two integers. The result is always non-negative.

Computes the least common multiple of two integers. This is useful for normalising periods, denominators, or modular steps.

Computes the extended greatest common divisor. The returned coefficients satisfy g = self * x + other * y.

Raises the integer to a non-negative integral power. Use this when you want exact integer exponentiation without leaving the integer domain.

Computes modular exponentiation. This evaluates self^exponent mod modulus efficiently, even for very large values.

Computes the modular multiplicative inverse. If no inverse exists because the values are not coprime, this returns nil.

Performs a probabilistic primality test. More repetitions increase confidence for composite detection.

Finds the next probable prime greater than this integer. This is useful for search-based number theory and cryptographic helpers.

Returns the number of significant bits required to represent the integer. Zero has a bit length of 0.

Counts the number of set bits in the integer. This is also known as the population count or Hamming weight.

Checks whether a specific bit is set. Bit positions are zero-based, where bit 0 is the least significant bit.

Returns a copy of the integer with the given bit set to 1. Bit positions are zero-based.

Returns a copy of the integer with the given bit cleared to 0. Bit positions are zero-based.

Returns a copy of the integer with the given bit toggled. Bit positions are zero-based.

Computes the bitwise AND of two integers. This uses two's-complement style infinite-width semantics, matching GMP's integer bit operations.

Computes the bitwise OR of two integers. This uses two's-complement style infinite-width semantics.

Computes the bitwise XOR of two integers. This uses two's-complement style infinite-width semantics.

Computes the bitwise complement of the integer. This uses two's-complement style infinite-width semantics.

Shifts the integer left by the given number of bits. Negative shift counts reverse direction and behave like a right shift.

Shifts the integer right by the given number of bits. Negative shift counts reverse direction and behave like a left shift.

Formats the integer as a string in the chosen base. Base 10 is the default, and other bases are useful for binary, hexadecimal, and compact serialisation.

Converts the integer to a Luau number. This conversion is intended for ergonomic interop with ordinary numeric code.

Converts the integer into an exact Rational with denominator 1. This is useful when you want to move from integer arithmetic into rational arithmetic without losing precision.

Promotes the integer into the floating-point domain. This is useful when you want MPFR-backed operations starting from an exact integer value.

Converts the integer to a signed 64-bit integer. Use this when you explicitly need a fixed-width signed representation.

Converts the integer to an unsigned 64-bit integer. Use this when you explicitly need a fixed-width unsigned representation.

Checks whether the integer can be represented as a Luau number. This is useful before crossing back into APIs that expect ordinary numbers.

Checks whether the integer fits in a signed 64-bit integer. This is a non-throwing guard for toI64().

Checks whether the integer fits in an unsigned 64-bit integer. This is a non-throwing guard for toU64().

Returns a new Rational with the same value. This is useful when you want an explicit copy before passing the value into other code.

Returns the absolute value of the rational. Negative inputs become positive; zero and positive values are unchanged.

Returns the sign of the rational. The result is -1 for negative values, 0 for zero, and 1 for positive values.

Compares this rational with another rational-like value. This is the explicit comparison method behind the ordering operators.

Returns the reciprocal of the rational. This swaps the numerator and denominator, preserving the sign.

Returns the rational in canonical reduced form. This normalises the sign and reduces the numerator and denominator by their greatest common divisor.

Returns the numerator of the rational. The returned Integer reflects the current exact value of self.

Returns the denominator of the rational. In canonical form, this is always positive.

Checks whether the rational is exactly zero. This is a convenience predicate for branchy arithmetic code.

Checks whether the rational is exactly one. This is often useful in code that works with multiplicative identities.

Checks whether the rational is a whole integer value. This is true when the denominator is 1 after canonicalisation.

Rounds the rational down to the nearest integer. This uses floor semantics, rounding toward negative infinity.

Rounds the rational up to the nearest integer. This uses ceiling semantics, rounding toward positive infinity.

Truncates the rational toward zero. This is useful when you want integer projection without floor/ceiling behaviour.

Rounds the rational to the nearest integer using the chosen mode. This supports explicit tie-breaking strategies such as nearest-even.

Formats the rational as a string in the chosen base. Whole-valued rationals may render without a slash; fractional values render as numerator/denominator.

Formats the rational as a decimal string. Exact terminating decimals can be emitted directly; otherwise this rounds to the requested number of digits.

Converts the rational to a Luau number. This is intended for ergonomic interop with ordinary numeric code when exact rational arithmetic is no longer required.

Converts the rational to an Integer using the chosen rounding mode. This is useful when you want an explicit and exact integer projection step.

Converts the rational to a Float using the chosen precision and rounding mode. This is useful when you want to leave the exact rational domain with explicit floating-point control.

Returns a new Float with the same numeric value. This is useful when you want an explicit copy, optionally at the same precision as the original.

Returns the absolute value of the float. Negative inputs become positive; zero and positive values are unchanged.

Returns the sign of the float. The result is -1 for negative values, 0 for zero, and 1 for positive values. @param self The Float whose sign should be inspected.

Compares this float with another float-like value. This is the explicit comparison method behind the ordering operators.

Computes the square root of the float. This stays in the floating-point domain and uses MPFR's rounding behaviour.

Rounds the float down to the nearest integer. This uses floor semantics, rounding toward negative infinity.

Rounds the float up to the nearest integer. This uses ceiling semantics, rounding toward positive infinity.

Truncates the float toward zero. This is useful when you want integer projection without floor/ceiling behaviour.

Rounds the float to an Integer using the chosen rounding mode. This supports explicit tie-breaking strategies such as nearest-even.

Returns the precision of the float in bits. This is the stored MPFR precision for the current value.

Returns a copy of the float at a different precision. The value is rounded to the requested precision using the chosen rounding mode.

Checks whether the float is exactly zero. This is a convenience predicate for branchy arithmetic code.

Checks whether the float is finite. This distinguishes ordinary numeric values from nan, inf, and -inf.

Checks whether the float is nan. This is useful when you need to distinguish invalid or undefined floating-point results.

Checks whether the float is positive or negative infinity. This is useful when you need to handle overflow-style or unbounded results explicitly.

Formats the float as a string in the chosen base. When digits is omitted, the formatter emits a compact representation suitable for display.

Converts the float to a Luau number. This is intended for ergonomic interop with ordinary numeric code.

Converts the float to an Integer using the chosen rounding mode. This is useful when you want an explicit and exact integer projection step.

Returns a new Number with the same value and kind. This is useful when you want an explicit copy before passing it into other code.

Reports whether the dynamic number is currently storing an integer or a float. This is useful when you need to branch on the exact runtime representation.

Checks whether the dynamic number is currently backed by an integer value. This is a convenience predicate for representation-sensitive code.

Checks whether the dynamic number is currently backed by a float value. This is a convenience predicate for representation-sensitive code.

Returns the exact Integer view when this Number is integer-kind. If the value is float-kind, this returns nil instead of rounding implicitly.

Returns the exact Float view when this Number is float-kind. If the value is integer-kind, this returns nil instead of promoting implicitly.

Returns the absolute value of the dynamic number. The result stays in the same numeric domain as the underlying representation.

Returns the sign of the dynamic number. The result is -1 for negative values, 0 for zero, and 1 for positive values.

Compares this dynamic number with another dynamic or plain numeric value. This is the explicit comparison method behind the ordering operators.

Rounds the dynamic number down to the nearest integer-valued Number. This uses floor semantics and always returns integer-kind Number storage.

Rounds the dynamic number up to the nearest integer-valued Number. This uses ceiling semantics and always returns integer-kind Number storage.

Truncates the dynamic number toward zero. This always returns integer-kind Number storage.

Rounds the dynamic number to the nearest integer-valued Number using the chosen mode. This supports explicit tie-breaking strategies such as nearest-even.

Formats the dynamic number as a string in the chosen base. Integer-kind values use integer formatting, while float-kind values use MPFR formatting rules.

Converts the dynamic number to a Luau number. This is intended for ergonomic interop with ordinary numeric code.

Converts the dynamic number to an Integer using the chosen rounding mode. This is useful when you want an explicit and exact integer projection step.

Converts the dynamic number to a Float, optionally changing its precision. Integer-kind values are promoted into the floating-point domain, and float-kind values may be rounded to a new precision.