Skip to main content

numberUtil

An utility module for working with numbers.

print(numberUtil.e) --> 2.7182818284590
print(numberUtil.nan(3)) --> false

Properties​

e​

Read only
</>
numberUtil.e: number<2.7182818284590>

A mathematical constant, also known as Euler's number.

phi​

Read only
</>
numberUtil.phi: number<1.618033988749895>

A mathematical constant, also known as the golden ratio.

tau​

Read only
</>
numberUtil.tau: number<6.283185307179586>

A mathematical constant, it is the circle constant representing the ratio between circumference and radius.

g​

Read only
</>
numberUtil.g: number<6.6743e-11>

A mathematical constant, used in calculating the gravitational attraction between two objects.

ga​

Read only
</>
numberUtil.ga: number<137.5>

A mathematical constant (the golden angle), which is the smaller of the two angles created by sectioning the circumference of a circle.

ec​

Read only
</>
numberUtil.ec: number<0.577215664901>

A mathematical constant (also known as Euler's constant - not to be confused with Euler's number i.e e which approximately equals to 2.718).

Functions​

to24H​

</>
numberUtil.to24H(
hour: number,
preset: "am" | "pm"
) → number

Returns the given hour formatted to the 12 hour clock.

print(numberUtil.to24H(12, "am")) --> 0
print(numberUtil.to24H(5, "pm")) --> 17
print(numberUtil.to24H(12, "pm")) --> 12
print(numberUtil.to24H(11, "pm")) --> 23
print(numberUtil.to24H(11, "am")) --> 11

to12H​

</>
numberUtil.to12H(hour: number) → number

Returns the given hour formatted to the 12 hour clock.

print(numberUtil.to12H(24)) --> 12
print(numberUtil.to12H(17)) --> 5

sphericalLerp​

</>
numberUtil.sphericalLerp(
t: number,
w0: number,
x0: number,
y0: number,
z0: number,
w1: number,
x1: number,
y1: number,
z1: number,
d: number
) → number

Returns a result on based on spherical linear interpolation.

secant​

</>
numberUtil.secant(number: number) → number

The ratio of the hypotenuse to the shorter side adjacent to an acute angle (in a right-angled triangle); the reciprocal of a cosine.

print(numberUtil.secant(1)) --> 1.8508157176809255

root​

</>
numberUtil.root(
number: number,
numberRoot: number
) → number

Returns the root of number.

print(numberUtil.root(2, 3)) --> 1.2599210498948732 (same as cube root of 2)
print(numberUtil.root(2, 2)) --> 1.4142135623730951 (same as square root of 2)

quadraticLerp​

</>
numberUtil.quadraticLerp(
number: number,
goal: number,
alpha: number
) → number

Quadraticly interpolates number to goal, with alpha being the multiplier.

print(numberUtil.quadraticLerp(2, 5, 0.7)) --> 4.1

quadraticBezier​

</>
numberUtil.quadraticBezier(
t: number,
p0: number,
p1: number,
p2: number
) → number

Returns the quadratic bezier from the arguments.

print(numberUtil.quadraticBezier(0, 0.5, 3, 5)) --> 0.5

nextOrder​

</>
numberUtil.nextOrder() → () → number

Returns a function which returns a numerical value, which is always incremented by 1.

local nextOrder = numberUtil.nextOrder() 
print(nextOrder()) --> 1
print(nextOrder()) --> 2
print(nextOrder()) --> 3

nan​

</>
numberUtil.nan(number: number) → boolean

Returns a boolean indicating if number is NaN (Not A Number).

print(numberUtil.nan(0 / 0)) --> true

mode​

</>
numberUtil.mode(...: number) → number?

From a set of numbers ..., returns the number which is the most frequent.

print(numberUtil.mode(1, 2, 3, 3)) --> 3
print(numberUtil.mode(1, 2, 3)) --> nil (no numbers repeat)

median​

</>
numberUtil.median(...: number) → number

Returns the median of the set of numbers ....

print(numberUtil.median(2, 2)) --> 4

mean​

</>
numberUtil.mean(...: number) → number

Returns the mean of the set of numbers ....

print(numberUtil.mean(3, 5)) --> 2

logarithmicLerp​

</>
numberUtil.logarithmicLerp(
number: number,
goal: number,
alpha: number
) → number

Logarithmicly lerps number to goal, with alpha being the multiplier.

print(numberUtil.logarithmicLerp(1, 2, 3)) --> 0.125

lerp​

</>
numberUtil.lerp(
number: number,
goal: number,
alpha: number
) → number

Interpolates number to goal, with alpha being the multiplier.

print(numberUtil.lerp(2, 5, 0.7)) --> 4.1

inverseLerp​

</>
numberUtil.inverseLerp(
min: number,
max: number,
alpha: number
) → number

Inverse lerp is the inverse operation of the lerp node. It can be used to determine what the input to a lerp was based on its output. 

print(numberUtil.inverseLerp(2, 5, 0.7)) --> -0.43333333333333335

hms​

</>
numberUtil.hms(number: number) → (
number,
number,
number
)

Returns a string which is just number formatted to the HMS (Hour, Minutes, Seconds) format.

print(numberUtil.hms(21660)) --> 6, 1, 0

factors​

</>
numberUtil.factors(number: number) → {number}

Returns a read only array of all factors of number.

print(numberUtil.factors(2)) --> {1, 2}

factorial​

</>
numberUtil.factorial(number: number) → number

Returns the factorial of number.

print(numberUtil.factorial(3)) --> 6

exponentialLerp​

</>
numberUtil.exponentialLerp(
number: number,
goal: number,
alpha: number
) → number

Exponentially lerps number to goal, with alpha being the multiplier.

print(numberUtil.exponentialLerp(1, 5, 3)) --> 125

cubicBezier​

</>
numberUtil.cubicBezier(
t: number,
p0: number,
p1: number,
p2: number,
p3: number
) → number

Returns the cubic bezier from the arguments.

print(cubicBezier(2, 0.15, 0, 0.1, 0)) --> -1.35

cotan​

</>
numberUtil.cotan(number: number) → number

A trigonometric function that in a right-angled triangle is the ratio of the length of the adjacent side to that of the opposite side; the reciprocal of tangent. 

print(numberUtil.cotan(1)) --> 0.6420926159343306

cosec​

</>
numberUtil.cosec(number: number) → number

Returns the reciprocal of math.sign(number).

print(numberUtil.cosec(1)) --> 1.1883951057781212

commas​

</>
numberUtil.commas(target: number) → string

Returns a number (stringified), formatted with commas.

print(numberUtil.commas(15000)) --> 15,000

comb​

</>
numberUtil.comb(
number: number,
k: number
) → number

Returns the number of ways picking k unordered outcomes from number possibilities, without repetition.

NOTE

If the value of k is greater than number, then the method will return 0.

print(numberUtil.comb(2, 1)) --> 2

close​

</>
numberUtil.close(
number: number,
to: number,
eplison: number?
) → boolean

Returns a boolean indicating if the difference between number and to is lower than or equal to eplsion.

print(numberUtil.close(0.1 + 0.2, 0.3)) --> true
print(numberUtil.close(0.1 + 0.2, 0.3, 0)) --> false
  • If eplison is not specified, then it will default to 1e-2.

clampTo​

</>
numberUtil.clampTo(
number: number,
min: number,
max: number,
clamp: number
) → number

Clamps number to clamp, if number is greater than max or lower than min.

print(numberUtil.clampTo(1, 2, 5, 150)) --> 150

average​

</>
numberUtil.average(
sum: number,
...: number
) → number

Returns the average of ... numbers against sum.

print(numberUtil.average(100, 50, 25)) --> 0.75
Show raw api
{
    "functions": [
        {
            "name": "to24H",
            "desc": "Returns the given hour formatted to the 12 hour clock.\n\n```lua\nprint(numberUtil.to24H(12, \"am\")) --> 0\nprint(numberUtil.to24H(5, \"pm\")) --> 17\nprint(numberUtil.to24H(12, \"pm\")) --> 12\nprint(numberUtil.to24H(11, \"pm\")) --> 23\nprint(numberUtil.to24H(11, \"am\")) --> 11\n```",
            "params": [
                {
                    "name": "hour",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "preset",
                    "desc": "",
                    "lua_type": "\"am\" | \"pm\""
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 89,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "to12H",
            "desc": "Returns the given hour formatted to the 12 hour clock.\n\n```lua\nprint(numberUtil.to12H(24)) --> 12\nprint(numberUtil.to12H(17)) --> 5\n```",
            "params": [
                {
                    "name": "hour",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 114,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "sphericalLerp",
            "desc": "Returns a result on based on [spherical linear interpolation](https://en.wikipedia.org/wiki/Slerp).",
            "params": [
                {
                    "name": "t",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "w0",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "x0",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "y0",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "z0",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "w1",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "x1",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "y1",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "z1",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "d",
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 123,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "secant",
            "desc": "The ratio of the hypotenuse to the shorter side adjacent to an acute angle (in a right-angled triangle); the reciprocal of a cosine.\n\n```lua\nprint(numberUtil.secant(1)) --> 1.8508157176809255\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 159,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "root",
            "desc": "Returns the `root` of `number`.\n\n```lua\nprint(numberUtil.root(2, 3)) --> 1.2599210498948732 (same as cube root of 2)\nprint(numberUtil.root(2, 2)) --> 1.4142135623730951 (same as square root of 2)\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "numberRoot",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 172,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "quadraticLerp",
            "desc": "Quadraticly interpolates `number` to `goal`, with `alpha` being the multiplier.\n\n```lua\nprint(numberUtil.quadraticLerp(2, 5, 0.7)) --> 4.1\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "goal",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "alpha",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 184,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "quadraticBezier",
            "desc": "Returns the quadratic bezier from the arguments.\n\n```lua\nprint(numberUtil.quadraticBezier(0, 0.5, 3, 5)) --> 0.5\n```",
            "params": [
                {
                    "name": "t",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p0",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p1",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p2",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 196,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "nextOrder",
            "desc": "Returns a function which returns a numerical value, which is always incremented by 1.\n\n```lua\nlocal nextOrder = numberUtil.nextOrder() \nprint(nextOrder()) --> 1\nprint(nextOrder()) --> 2\nprint(nextOrder()) --> 3\n```",
            "params": [],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "() -> number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 211,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "nan",
            "desc": "Returns a boolean indicating if `number` is NaN (Not A Number). \n\n```lua\nprint(numberUtil.nan(0 / 0)) --> true\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "boolean\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 228,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "mode",
            "desc": "From a set of numbers `...`, returns the number which is the most frequent.\n\n```lua\nprint(numberUtil.mode(1, 2, 3, 3)) --> 3\nprint(numberUtil.mode(1, 2, 3)) --> nil (no numbers repeat)\n```",
            "params": [
                {
                    "name": "...",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number?\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 247,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "median",
            "desc": "Returns the median of the set of numbers `...`.\n\n```lua\nprint(numberUtil.median(2, 2)) --> 4\n```",
            "params": [
                {
                    "name": "...",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 280,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "mean",
            "desc": "Returns the mean of the set of numbers `...`.\n\n```lua\nprint(numberUtil.mean(3, 5)) --> 2\n```",
            "params": [
                {
                    "name": "...",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 298,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "logarithmicLerp",
            "desc": "Logarithmicly lerps `number` to `goal`, with `alpha` being the multiplier.\n\n```lua\nprint(numberUtil.logarithmicLerp(1, 2, 3)) --> 0.125\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "goal",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "alpha",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 317,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "lerp",
            "desc": "Interpolates `number` to `goal`, with `alpha` being the multiplier.\n\n```lua\nprint(numberUtil.lerp(2, 5, 0.7)) --> 4.1\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "goal",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "alpha",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 329,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "inverseLerp",
            "desc": "Inverse lerp is the inverse operation of the lerp node. It can be used to determine what the input to a lerp was \nbased on its output. \n\n```lua\nprint(numberUtil.inverseLerp(2, 5, 0.7)) --> -0.43333333333333335\n```",
            "params": [
                {
                    "name": "min",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "max",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "alpha",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 342,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "hms",
            "desc": "Returns a string which is just `number` formatted to the HMS (Hour, Minutes, Seconds) format.\n\n```lua\nprint(numberUtil.hms(21660)) --> 6, 1, 0 \n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 354,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "factors",
            "desc": "Returns a read only array of all factors of `number`.\n\n```lua\nprint(numberUtil.factors(2)) --> {1, 2}\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "{ number }\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 365,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "factorial",
            "desc": "Returns the factorial of `number`.\n\n```lua\nprint(numberUtil.factorial(3)) --> 6\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 389,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "exponentialLerp",
            "desc": "Exponentially lerps `number` to `goal`, with `alpha` being the multiplier.\n\n```lua\nprint(numberUtil.exponentialLerp(1, 5, 3)) --> 125\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "goal",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "alpha",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 405,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "cubicBezier",
            "desc": "Returns the cubic bezier from the arguments.\n\n```lua\nprint(cubicBezier(2, 0.15, 0, 0.1, 0)) --> -1.35\n```",
            "params": [
                {
                    "name": "t",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p0",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p1",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p2",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "p3",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 417,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "cotan",
            "desc": "A trigonometric function that in a right-angled triangle is the ratio of the length of the adjacent side to\nthat of the opposite side; the reciprocal of tangent.\n\n```lua\nprint(numberUtil.cotan(1)) --> 0.6420926159343306\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 430,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "cosec",
            "desc": "Returns the reciprocal of `math.sign(number)`.\n\n```lua\nprint(numberUtil.cosec(1)) --> 1.1883951057781212\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 442,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "commas",
            "desc": "Returns a number (stringified), formatted with commas.\n\n```lua\nprint(numberUtil.commas(15000)) --> 15,000\n```",
            "params": [
                {
                    "name": "target",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "string\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 454,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "comb",
            "desc": "Returns the number of ways picking `k` unordered outcomes from `number` possibilities, without repetition.\n\n:::note\nIf the value of `k` is greater than `number`, then the method will return `0`.\n:::\n\n```lua\nprint(numberUtil.comb(2, 1)) --> 2\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "k",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 481,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "close",
            "desc": "Returns a boolean indicating if the difference between `number` and `to` is lower than or equal to `eplsion`.\n\n```lua\nprint(numberUtil.close(0.1 + 0.2, 0.3)) --> true\nprint(numberUtil.close(0.1 + 0.2, 0.3, 0)) --> false\n```\n\n- If `eplison` is not specified, then it will default to `1e-2`.",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "to",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "eplison",
                    "desc": "",
                    "lua_type": "number?"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "boolean\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 501,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "clampTo",
            "desc": "Clamps `number` to `clamp`, if `number` is greater than `max` or lower than `min`.\n\n```lua\nprint(numberUtil.clampTo(1, 2, 5, 150)) --> 150\n```",
            "params": [
                {
                    "name": "number",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "min",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "max",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "clamp",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 513,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "average",
            "desc": "Returns the average of `...` numbers against `sum`.\n\n```lua\nprint(numberUtil.average(100, 50, 25)) --> 0.75\n```",
            "params": [
                {
                    "name": "sum",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "...",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "number\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 529,
                "path": "src/numberUtil/init.luau"
            }
        }
    ],
    "properties": [
        {
            "name": "e",
            "desc": " \n\nA mathematical constant, also known as Euler's number. ",
            "lua_type": "number <2.7182818284590>",
            "tags": [
                "Read only"
            ],
            "source": {
                "line": 19,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "phi",
            "desc": " \n\nA mathematical constant, also known as the golden ratio.",
            "lua_type": "number <1.618033988749895>",
            "tags": [
                "Read only"
            ],
            "source": {
                "line": 27,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "tau",
            "desc": " \n\nA mathematical constant, it is the circle constant representing the ratio between circumference and radius.",
            "lua_type": "number <6.283185307179586>",
            "tags": [
                "Read only"
            ],
            "source": {
                "line": 35,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "g",
            "desc": " \n\nA mathematical constant, used in calculating the gravitational attraction between two objects.",
            "lua_type": "number <6.6743e-11>",
            "tags": [
                "Read only"
            ],
            "source": {
                "line": 43,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "ga",
            "desc": " \n\nA mathematical constant (the golden angle), which is the smaller of the two angles created by\nsectioning the circumference of a circle.",
            "lua_type": "number <137.5>",
            "tags": [
                "Read only"
            ],
            "source": {
                "line": 52,
                "path": "src/numberUtil/init.luau"
            }
        },
        {
            "name": "ec",
            "desc": " \n\nA mathematical constant (also known as Euler's constant - **not** to be confused with Euler's *number* i.e `e`\nwhich approximately equals to `2.718`).",
            "lua_type": "number <0.577215664901>",
            "tags": [
                "Read only"
            ],
            "source": {
                "line": 61,
                "path": "src/numberUtil/init.luau"
            }
        }
    ],
    "types": [],
    "name": "numberUtil",
    "desc": " \n\nAn utility module for working with numbers.\n \n```lua\nprint(numberUtil.e) --> 2.7182818284590\nprint(numberUtil.nan(3)) --> false\n```",
    "source": {
        "line": 11,
        "path": "src/numberUtil/init.luau"
    }
}