@tlua/gmod 1.0.4 → 1.0.6

package/types/math.d.tlua

@@ -40,31 +40,21 @@
  */
 interface MathLib {
     ease: MatheaseLib;
-}
 
-/**
- * The math library is a standard Lua library that provides functions for manipulating numbers. In Garry's Mod several additional math functions have been added.
- * @source https://wiki.facepunch.com/gmod/math
- */
-interface MathLib {
     /**
      * Calculates the difference between two angles.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.AngleDifference
      */
     AngleDifference(a: number, b: number): number;
-}
 
-interface MathLib {
     /**
      * Gradually approaches the target value by the specified amount.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Approach
      */
     Approach(current: number, target: number, change: number): number;
-}
 
-interface MathLib {
     /**
      * Increments an angle towards another by specified rate.
      *
@@ -75,45 +65,35 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.ApproachAngle
      */
     ApproachAngle(currentAngle: number, targetAngle: number, rate: number): number;
-}
 
-interface MathLib {
     /**
      * Basic code for Bézier-Spline algorithm.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.BSplinePoint
      */
     BSplinePoint(fraction: number, points: table, fractionMax: number): Vector;
-}
 
-interface MathLib {
     /**
      * Converts a binary string into a number.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.BinToInt
      */
     BinToInt(string: string): number;
-}
 
-interface MathLib {
     /**
      * Cubic Hermite spline algorithm.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.CHSpline
      */
     CHSpline(frac: number, point0: Vector, tan0: Vector, point1: Vector, tan1: Vector): Vector;
-}
 
-interface MathLib {
     /**
      * Clamps a number between a minimum and maximum value.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Clamp
      */
     Clamp(input: number, min: number, max: number): number;
-}
 
-interface MathLib {
     /**
      * Lerp point between 4 control points with cubic bezier.
      *
@@ -123,9 +103,7 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.CubicBezier
      */
     CubicBezier(frac: number, p0: Vector, p1: Vector, p2: Vector, p3: Vector): Vector;
-}
 
-interface MathLib {
     /**
      * Returns the difference between two points in 2D space. Alias of [math.Distance](https://wiki.facepunch.com/gmod/math.Distance).
      *
@@ -134,18 +112,14 @@ interface MathLib {
      * @deprecated You should use math.Distance instead
      */
     Dist(x1: number, y1: number, x2: number, y2: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the difference between two points in 2D space.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Distance
      */
     Distance(x1: number, y1: number, x2: number, y2: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the squared difference between two points in 2D space. This is computationally faster than [math.Distance](https://wiki.facepunch.com/gmod/math.Distance).
      *
@@ -153,36 +127,28 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.DistanceSqr
      */
     DistanceSqr(x1: number, y1: number, x2: number, y2: number): number;
-}
 
-interface MathLib {
     /**
      * Calculates the progress of a value fraction, taking in to account given easing fractions
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.EaseInOut
      */
     EaseInOut(progress: number, easeIn?: number, easeOut?: number): number;
-}
 
-interface MathLib {
     /**
      * Simple function that calculates [factorial](https://en.wikipedia.org/wiki/Factorial) of a whole number.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Factorial
      */
     Factorial(val_in: number): number;
-}
 
-interface MathLib {
     /**
      * Converts an integer to a binary (base-2) string.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.IntToBin
      */
     IntToBin(int: number): string;
-}
 
-interface MathLib {
     /**
      * Checks if two floating point numbers are nearly equal.
      *
@@ -193,18 +159,14 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.IsNearlyEqual
      */
     IsNearlyEqual(a: number, b: number, tolerance?: number): boolean;
-}
 
-interface MathLib {
     /**
      * Normalizes angle, so it returns value between -180 and 180.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.NormalizeAngle
      */
     NormalizeAngle(angle: number): number;
-}
 
-interface MathLib {
     /**
      * Lerp point between 3 control points with quadratic bezier.
      *
@@ -214,9 +176,7 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.QuadraticBezier
      */
     QuadraticBezier(frac: number, p0: Vector, p1: Vector, p2: Vector): Vector;
-}
 
-interface MathLib {
     /**
      * Returns a random float between min and max.
      *
@@ -226,27 +186,21 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.Rand
      */
     Rand(min: number, max: number): number;
-}
 
-interface MathLib {
     /**
      * Remaps the value from one range to another
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Remap
      */
     Remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
-}
 
-interface MathLib {
     /**
      * Rounds the given value to the nearest whole number or to the given decimal places.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Round
      */
     Round(value: number, decimals?: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the mathematical negative/positive sign of the input number.
      *
@@ -254,72 +208,56 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.Sign
      */
     Sign(value: number): number;
-}
 
-interface MathLib {
     /**
      * Snaps a number to the closest multiplicative of given number. See also [Angle:SnapTo](https://wiki.facepunch.com/gmod/Angle:SnapTo).
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.SnapTo
      */
     SnapTo(input: number, snapTo: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the fraction of where the current time is relative to the start and end times
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.TimeFraction
      */
     TimeFraction(start: number, _end: number, current: number): number;
-}
 
-interface MathLib {
     /**
      * Trim unwanted decimal places.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.Truncate
      */
     Truncate(num: number, digits?: number): number;
-}
 
-interface MathLib {
     /**
      * Calculates the absolute value of a number (effectively removes any negative sign).
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.abs
      */
     abs(x: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the [arccosine](https://en.wikipedia.org/wiki/Arccosine) of the given number.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.acos
      */
     acos(cos: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the [arcsine](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) of the given number.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.asin
      */
     asin(normal: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the [arctangent](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) of the given number.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.atan
      */
     atan(normal: number): number;
-}
 
-interface MathLib {
     /**
      * functions like [math.atan](https://wiki.facepunch.com/gmod/math.atan)(y / x), except it also takes into account the quadrant of the angle and so doesn't have a limited range of output.
      *
@@ -330,9 +268,7 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.atan2
      */
     atan2(y: number, x: number): number;
-}
 
-interface MathLib {
     /**
      * **INTERNAL**: Use [math.BSplinePoint](https://wiki.facepunch.com/gmod/math.BSplinePoint) instead.
      *
@@ -343,9 +279,7 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.calcBSplineN
      */
     calcBSplineN(i: number, k: number, t: number, tinc: number): number;
-}
 
-interface MathLib {
     /**
      * Ceils or rounds a number up.
      *
@@ -354,546 +288,441 @@ interface MathLib {
      * @source https://wiki.facepunch.com/gmod/math.ceil
      */
     ceil(number: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the [cosine](https://en.wikipedia.org/wiki/Trigonometric_functions#cos) of given angle.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.cos
      */
     cos(number: number): number;
-}
 
-interface MathLib {
     /**
      * Returns the [hyperbolic cosine](https://en.wikipedia.org/wiki/Cosh_(mathematical_function)) of the given angle.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.cosh
      */
     cosh(number: number): number;
-}
 
-interface MathLib {
     /**
      * Converts radians to degrees.
      * @realm shared and menu
      * @source https://wiki.facepunch.com/gmod/math.deg
      */
     deg(radians: number): number;
-}
 
-interface MatheaseLib {
     /**
-     * Eases in by reversing the direction of the ease slightly before returning.
-     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
-     *
-     *
+     * Returns e to the power of the input.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InBack
+     * @source https://wiki.facepunch.com/gmod/math.exp
      */
-    InBack(fraction: number): number;
-}
+    exp(exponent: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in like a bouncy ball.
-     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
-     *
+     * Floors or rounds a number down.
      *
+     * 	See [math.ceil](https://wiki.facepunch.com/gmod/math.ceil) for the inverse of this function.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InBounce
-     */
-    InBounce(fraction: number): number;
-}
-
-interface MatheaseLib {
-    /**
-     * Eases in using a circular function.
-     * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InCirc
+     * @source https://wiki.facepunch.com/gmod/math.floor
      */
-    InCirc(fraction: number): number;
-}
+    floor(number: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in by cubing the fraction.
+     * Returns the modulus of the specified values.
+     *
+     * While this is similar to the `%` operator, **it will return a negative value if the first argument is negative**, whereas the % operator will return a **positive** value **even if the first operand is negative**.
+     *
+     * This function is also slower than the `%` operator.
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InCubic
+     * @source https://wiki.facepunch.com/gmod/math.fmod
      */
-    InCubic(fraction: number): number;
-}
+    fmod(base: number, modulator: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in like a rubber band.
-     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     * **Lua reference description**: Returns `m` and `e` such that `x = m2e`, `e` is an integer and the absolute value of `m` is in the range ((0.5, 1) (or zero when x is zero).
+     *
+     * Used to split the number value into a normalized fraction and an exponent. Two values are returned: the first is a multiplier in the range `1/2` (**inclusive**) to `1` (**exclusive**) and the second is an integer exponent.
      *
+     * The result is such that `x = m*2^e`.
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InElastic
+     * @source https://wiki.facepunch.com/gmod/math.frexp
      */
-    InElastic(fraction: number): number;
-}
+    frexp(x: number): (number, number);
 
-interface MatheaseLib {
     /**
-     * Eases in using an exponential equation with a base of 2 and where the fraction is used in the exponent.
+     * Takes a normalised number and returns the floating point representation.
+     *
+     * Effectively it returns the result of `normalizedFraction * 2.0 ^ exponent`. [math.frexp](https://wiki.facepunch.com/gmod/math.frexp) is the opposite function.
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InExpo
+     * @source https://wiki.facepunch.com/gmod/math.ldexp
      */
-    InExpo(fraction: number): number;
-}
+    ldexp(normalizedFraction: number, exponent: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out by reversing the direction of the ease slightly before returning on both ends.
-     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     * With one argument, return the natural logarithm of x (to base e).
      *
+     * With two arguments, return the logarithm of x to the given base, calculated as log(x)/log(base).
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutBack
+     * @source https://wiki.facepunch.com/gmod/math.log
      */
-    InOutBack(fraction: number): number;
-}
+    log(x: number, base?: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out like a bouncy ball.
-     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
-     *
-     *
+     * Returns the base-10 logarithm of x. This is usually more accurate than math.log(x, 10).
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutBounce
+     * @source https://wiki.facepunch.com/gmod/math.log10
      */
-    InOutBounce(fraction: number): number;
-}
+    log10(x: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out using a circular function.
+     * Returns the largest value of all arguments.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutCirc
+     * @source https://wiki.facepunch.com/gmod/math.max
      */
-    InOutCirc(fraction: number): number;
-}
+    max(...: any): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out by cubing the fraction.
+     * Returns the smallest value of all arguments.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutCubic
+     * @source https://wiki.facepunch.com/gmod/math.min
      */
-    InOutCubic(fraction: number): number;
-}
+    min(...: any): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out like a rubber band.
-     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
-     *
+     * Returns the modulus of the specified values. Same as [math.fmod](https://wiki.facepunch.com/gmod/math.fmod).
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutElastic
+     * @source https://wiki.facepunch.com/gmod/math.mod
+     * @deprecated This is removed in Lua versions later than what GMod is currently using. You should use the % operator or math.fmod instead.
      */
-    InOutElastic(fraction: number): number;
-}
+    mod(base: number, modulator: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out using an exponential equation with a base of 2 and where the fraction is used in the exponent.
+     * Returns the integral and fractional component of the modulo operation.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutExpo
+     * @source https://wiki.facepunch.com/gmod/math.modf
      */
-    InOutExpo(fraction: number): number;
-}
+    modf(base: number): (number, number);
 
-interface MatheaseLib {
     /**
-     * Eases in and out by squaring the fraction.
+     * Returns x raised to the power y.
+     * In particular, math.pow(1.0, x) and math.pow(x, 0.0) always return 1.0, even when x is a zero or a [nan](https://wiki.facepunch.com/gmod/nan). If both x and y are finite, x is negative, and y is not an integer then math.pow(x, y) is undefined.
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutQuad
+     * @source https://wiki.facepunch.com/gmod/math.pow
      */
-    InOutQuad(fraction: number): number;
-}
+    pow(x: number, y: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out by raising the fraction to the power of 4.
+     * Converts an angle in degrees to it's equivalent in radians.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutQuart
+     * @source https://wiki.facepunch.com/gmod/math.rad
      */
-    InOutQuart(fraction: number): number;
-}
+    rad(degrees: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out by raising the fraction to the power of 5.
+     * When called without arguments, returns a uniform pseudo-random real number in the range 0 to 1 which includes 0 but excludes 1.
+     *
+     * When called with an integer number m, returns a uniform pseudo-random integer in the range 1 to m inclusive.
+     *
+     * When called with two integer numbers m and n, returns a uniform pseudo-random integer in the range m to n inclusive.
+     *
+     * See also [math.Rand](https://wiki.facepunch.com/gmod/math.Rand)
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutQuint
+     * @source https://wiki.facepunch.com/gmod/math.random
      */
-    InOutQuint(fraction: number): number;
-}
+    random(m?: number, n?: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in and out using [math.sin](https://wiki.facepunch.com/gmod/math.sin).
+     * Seeds the random number generator. The same seed will guarantee the same sequence of numbers each time with [math.random](https://wiki.facepunch.com/gmod/math.random).
+     *
+     * For shared random values across predicted realms, use [util.SharedRandom](https://wiki.facepunch.com/gmod/util.SharedRandom).
+     *
+     * **WARNING**: Usage of this function affects **ALL** random numbers in the game. This means that improper use (such as setting the seed to a static value that doesn't change with time) can negatively affect other addons or the base game.
+     *
+     * It is a good idea to set the seed back to at least something like [Global.SysTime](https://wiki.facepunch.com/gmod/Global.SysTime) in those cases.
+     *
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InOutSine
+     * @source https://wiki.facepunch.com/gmod/math.randomseed
      */
-    InOutSine(fraction: number): number;
-}
+    randomseed(seed: number): void;
 
-interface MatheaseLib {
     /**
-     * Eases in by squaring the fraction.
+     * Returns the [sine](https://en.wikipedia.org/wiki/Trigonometric_functions) of given angle.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InQuad
+     * @source https://wiki.facepunch.com/gmod/math.sin
      */
-    InQuad(fraction: number): number;
-}
+    sin(number: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in by raising the fraction to the power of 4.
+     * Returns the [hyperbolic sine](https://en.wikipedia.org/wiki/Hyperbolic_functions) of the given angle.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InQuart
+     * @source https://wiki.facepunch.com/gmod/math.sinh
      */
-    InQuart(fraction: number): number;
-}
+    sinh(number: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in by raising the fraction to the power of 5.
+     * Returns the square root of the number.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InQuint
+     * @source https://wiki.facepunch.com/gmod/math.sqrt
      */
-    InQuint(fraction: number): number;
-}
+    sqrt(value: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases in using [math.sin](https://wiki.facepunch.com/gmod/math.sin).
+     * Returns the tangent of the given angle.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.InSine
+     * @source https://wiki.facepunch.com/gmod/math.tan
      */
-    InSine(fraction: number): number;
+    tan(value: number): number;
+
+    /**
+     * Returns the [hyperbolic tangent](https://en.wikipedia.org/wiki/Hyperbolic_functions) of the given number.
+     * @realm shared and menu
+     * @source https://wiki.facepunch.com/gmod/math.tanh
+     */
+    tanh(number: number): number;
 }
 
 interface MatheaseLib {
     /**
-     * Eases out by reversing the direction of the ease slightly before finishing.
+     * Eases in by reversing the direction of the ease slightly before returning.
      * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
      *
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutBack
+     * @source https://wiki.facepunch.com/gmod/math.ease.InBack
      */
-    OutBack(fraction: number): number;
-}
+    InBack(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out like a bouncy ball.
+     * Eases in like a bouncy ball.
      * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
      *
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutBounce
+     * @source https://wiki.facepunch.com/gmod/math.ease.InBounce
      */
-    OutBounce(fraction: number): number;
-}
+    InBounce(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out using a circular function.
+     * Eases in using a circular function.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutCirc
+     * @source https://wiki.facepunch.com/gmod/math.ease.InCirc
      */
-    OutCirc(fraction: number): number;
-}
+    InCirc(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out by cubing the fraction.
+     * Eases in by cubing the fraction.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutCubic
+     * @source https://wiki.facepunch.com/gmod/math.ease.InCubic
      */
-    OutCubic(fraction: number): number;
-}
+    InCubic(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out like a rubber band.
+     * Eases in like a rubber band.
      * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
      *
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutElastic
+     * @source https://wiki.facepunch.com/gmod/math.ease.InElastic
      */
-    OutElastic(fraction: number): number;
-}
+    InElastic(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out using an exponential equation with a base of 2 and where the fraction is used in the exponent.
+     * Eases in using an exponential equation with a base of 2 and where the fraction is used in the exponent.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutExpo
+     * @source https://wiki.facepunch.com/gmod/math.ease.InExpo
      */
-    OutExpo(fraction: number): number;
-}
+    InExpo(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out by squaring the fraction.
+     * Eases in and out by reversing the direction of the ease slightly before returning on both ends.
+     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     *
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutQuad
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutBack
      */
-    OutQuad(fraction: number): number;
-}
+    InOutBack(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out by raising the fraction to the power of 4.
+     * Eases in and out like a bouncy ball.
+     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     *
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutQuart
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutBounce
      */
-    OutQuart(fraction: number): number;
-}
+    InOutBounce(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out by raising the fraction to the power of 5.
+     * Eases in and out using a circular function.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutQuint
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutCirc
      */
-    OutQuint(fraction: number): number;
-}
+    InOutCirc(fraction: number): number;
 
-interface MatheaseLib {
     /**
-     * Eases out using [math.sin](https://wiki.facepunch.com/gmod/math.sin).
+     * Eases in and out by cubing the fraction.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ease.OutSine
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutCubic
      */
-    OutSine(fraction: number): number;
-}
+    InOutCubic(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns e to the power of the input.
+     * Eases in and out like a rubber band.
+     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     *
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.exp
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutElastic
      */
-    exp(exponent: number): number;
-}
+    InOutElastic(fraction: number): number;
 
-interface MathLib {
     /**
-     * Floors or rounds a number down.
-     *
-     * 	See [math.ceil](https://wiki.facepunch.com/gmod/math.ceil) for the inverse of this function.
+     * Eases in and out using an exponential equation with a base of 2 and where the fraction is used in the exponent.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.floor
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutExpo
      */
-    floor(number: number): number;
-}
+    InOutExpo(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the modulus of the specified values.
-     *
-     * While this is similar to the `%` operator, **it will return a negative value if the first argument is negative**, whereas the % operator will return a **positive** value **even if the first operand is negative**.
-     *
-     * This function is also slower than the `%` operator.
-     *
+     * Eases in and out by squaring the fraction.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.fmod
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutQuad
      */
-    fmod(base: number, modulator: number): number;
-}
+    InOutQuad(fraction: number): number;
 
-interface MathLib {
     /**
-     * **Lua reference description**: Returns `m` and `e` such that `x = m2e`, `e` is an integer and the absolute value of `m` is in the range ((0.5, 1) (or zero when x is zero).
-     *
-     * Used to split the number value into a normalized fraction and an exponent. Two values are returned: the first is a multiplier in the range `1/2` (**inclusive**) to `1` (**exclusive**) and the second is an integer exponent.
-     *
-     * The result is such that `x = m*2^e`.
-     *
+     * Eases in and out by raising the fraction to the power of 4.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.frexp
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutQuart
      */
-    frexp(x: number): (number, number);
-}
+    InOutQuart(fraction: number): number;
 
-interface MathLib {
     /**
-     * Takes a normalised number and returns the floating point representation.
-     *
-     * Effectively it returns the result of `normalizedFraction * 2.0 ^ exponent`. [math.frexp](https://wiki.facepunch.com/gmod/math.frexp) is the opposite function.
-     *
+     * Eases in and out by raising the fraction to the power of 5.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.ldexp
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutQuint
      */
-    ldexp(normalizedFraction: number, exponent: number): number;
-}
+    InOutQuint(fraction: number): number;
 
-interface MathLib {
     /**
-     * With one argument, return the natural logarithm of x (to base e).
-     *
-     * With two arguments, return the logarithm of x to the given base, calculated as log(x)/log(base).
-     *
+     * Eases in and out using [math.sin](https://wiki.facepunch.com/gmod/math.sin).
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.log
+     * @source https://wiki.facepunch.com/gmod/math.ease.InOutSine
      */
-    log(x: number, base?: number): number;
-}
+    InOutSine(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the base-10 logarithm of x. This is usually more accurate than math.log(x, 10).
+     * Eases in by squaring the fraction.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.log10
+     * @source https://wiki.facepunch.com/gmod/math.ease.InQuad
      */
-    log10(x: number): number;
-}
+    InQuad(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the largest value of all arguments.
+     * Eases in by raising the fraction to the power of 4.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.max
+     * @source https://wiki.facepunch.com/gmod/math.ease.InQuart
      */
-    max(...: any): number;
-}
+    InQuart(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the smallest value of all arguments.
+     * Eases in by raising the fraction to the power of 5.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.min
+     * @source https://wiki.facepunch.com/gmod/math.ease.InQuint
      */
-    min(...: any): number;
-}
+    InQuint(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the modulus of the specified values. Same as [math.fmod](https://wiki.facepunch.com/gmod/math.fmod).
-     *
+     * Eases in using [math.sin](https://wiki.facepunch.com/gmod/math.sin).
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.mod
-     * @deprecated This is removed in Lua versions later than what GMod is currently using. You should use the % operator or math.fmod instead.
+     * @source https://wiki.facepunch.com/gmod/math.ease.InSine
      */
-    mod(base: number, modulator: number): number;
-}
+    InSine(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the integral and fractional component of the modulo operation.
+     * Eases out by reversing the direction of the ease slightly before finishing.
+     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     *
+     *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.modf
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutBack
      */
-    modf(base: number): (number, number);
-}
+    OutBack(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns x raised to the power y.
-     * In particular, math.pow(1.0, x) and math.pow(x, 0.0) always return 1.0, even when x is a zero or a [nan](https://wiki.facepunch.com/gmod/nan). If both x and y are finite, x is negative, and y is not an integer then math.pow(x, y) is undefined.
+     * Eases out like a bouncy ball.
+     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
+     *
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.pow
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutBounce
      */
-    pow(x: number, y: number): number;
-}
+    OutBounce(fraction: number): number;
 
-interface MathLib {
     /**
-     * Converts an angle in degrees to it's equivalent in radians.
+     * Eases out using a circular function.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.rad
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutCirc
      */
-    rad(degrees: number): number;
-}
+    OutCirc(fraction: number): number;
 
-interface MathLib {
     /**
-     * When called without arguments, returns a uniform pseudo-random real number in the range 0 to 1 which includes 0 but excludes 1.
-     *
-     * When called with an integer number m, returns a uniform pseudo-random integer in the range 1 to m inclusive.
-     *
-     * When called with two integer numbers m and n, returns a uniform pseudo-random integer in the range m to n inclusive.
-     *
-     * See also [math.Rand](https://wiki.facepunch.com/gmod/math.Rand)
-     *
+     * Eases out by cubing the fraction.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.random
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutCubic
      */
-    random(m?: number, n?: number): number;
-}
+    OutCubic(fraction: number): number;
 
-interface MathLib {
     /**
-     * Seeds the random number generator. The same seed will guarantee the same sequence of numbers each time with [math.random](https://wiki.facepunch.com/gmod/math.random).
-     *
-     * For shared random values across predicted realms, use [util.SharedRandom](https://wiki.facepunch.com/gmod/util.SharedRandom).
-     *
-     * **WARNING**: Usage of this function affects **ALL** random numbers in the game. This means that improper use (such as setting the seed to a static value that doesn't change with time) can negatively affect other addons or the base game.
-     *
-     * It is a good idea to set the seed back to at least something like [Global.SysTime](https://wiki.facepunch.com/gmod/Global.SysTime) in those cases.
+     * Eases out like a rubber band.
+     * 	**NOTE**: This doesn't work properly when used with [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) as it clamps the fraction between 0 and 1. Using your own version of [Global.Lerp](https://wiki.facepunch.com/gmod/Global.Lerp) that is unclamped would be necessary instead.
      *
      *
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.randomseed
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutElastic
      */
-    randomseed(seed: number): void;
-}
+    OutElastic(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the [sine](https://en.wikipedia.org/wiki/Trigonometric_functions) of given angle.
+     * Eases out using an exponential equation with a base of 2 and where the fraction is used in the exponent.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.sin
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutExpo
      */
-    sin(number: number): number;
-}
+    OutExpo(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the [hyperbolic sine](https://en.wikipedia.org/wiki/Hyperbolic_functions) of the given angle.
+     * Eases out by squaring the fraction.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.sinh
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutQuad
      */
-    sinh(number: number): number;
-}
+    OutQuad(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the square root of the number.
+     * Eases out by raising the fraction to the power of 4.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.sqrt
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutQuart
      */
-    sqrt(value: number): number;
-}
+    OutQuart(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the tangent of the given angle.
+     * Eases out by raising the fraction to the power of 5.
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.tan
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutQuint
      */
-    tan(value: number): number;
-}
+    OutQuint(fraction: number): number;
 
-interface MathLib {
     /**
-     * Returns the [hyperbolic tangent](https://en.wikipedia.org/wiki/Hyperbolic_functions) of the given number.
+     * Eases out using [math.sin](https://wiki.facepunch.com/gmod/math.sin).
      * @realm shared and menu
-     * @source https://wiki.facepunch.com/gmod/math.tanh
+     * @source https://wiki.facepunch.com/gmod/math.ease.OutSine
      */
-    tanh(number: number): number;
+    OutSine(fraction: number): number;
 }
-