toosoon-utils/lib/math.d.ts

Utility functions & classes

/**
 * Check if a number is even
 *
 * @param {number} value Value to check
 * @returns {boolean} `true` if the given number is even, `false` otherwise
 */
export declare function isEven(value: number): boolean;
/**
 * Check if a number is odd
 *
 * @param {number} value Value to check
 * @returns {boolean} `true` if the given number is odd, `false` otherwise
 */
export declare function isOdd(value: number): boolean;
/**
 * Check if a number is a power of 2
 *
 * @param {number} value Value to check
 * @returns {boolean} `true` if the given number is a power of 2, `false` otherwise
 */
export declare function isPowerOf2(value: number): boolean;
/**
 * Compute the closest greater power of 2 for a number
 *
 * @param {number} value Value to compute power of 2 for
 * @returns {number} Computed power of 2
 */
export declare function toPowerOf2(value: number): number;
/**
 * Return the sign (positive or negative) of a number
 *
 * @param {number} value Value to check
 * @returns {number} `1` if the given number is positive, `-1` if it is negative, `0` otherwise
 */
export declare function sign(value: number): number;
/**
 * Constrain a number between two bounds
 *
 * @param {number} value Value to constrain
 * @param {number} [min=0] Minimum boundary
 * @param {number} [max=1] Maximum boundary
 * @returns {number} Clamped value
 */
export declare function clamp(value: number, min?: number, max?: number): number;
/**
 * Round a number up to a nearest multiple
 *
 * @param {number} value Value to round
 * @param {number} [multiple=1] Multiple to round to
 * @returns {number} Closest multiple
 */
export declare function snap(value: number, multiple?: number): number;
/**
 * Interpolate a number between two bounds using Linear interpolation (lerping)
 *
 * @param {number} t Normalized time value to interpolate
 * @param {number} min Minimum boundary
 * @param {number} max Maximum boundary
 * @returns {number} Lerped value
 */
export declare function lerp(t: number, min: number, max: number): number;
/**
 * Normalize a number between two bounds
 *
 * @param {number} value Value to normalize
 * @param {number} min Minimum boundary
 * @param {number} max Maximum boundary
 * @returns {number} Normalized value
 */
export declare function normalize(value: number, min: number, max: number): number;
/**
 * Re-map a number from one range to another
 *
 * @param {number} value Value to re-map
 * @param {number} currentMin Lower bound of the value's current range
 * @param {number} currentMax Upper bound of the value's current range
 * @param {number} targetMin Lower bound of the value's target range
 * @param {number} targetMax Upper bound of the value's target range
 * @returns {number} Re-mapped value
 */
export declare function map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
/**
 * Interpolate a number between two bounds using Triangular interpolation
 *
 * @param {number} t Normalized time value to interpolate
 * @param {number} min Minimum boundary
 * @param {number} max Maximum boundary
 * @param {number} peak Peak value controling the interpolation triangle shape
 *                        - peak <= min : linear (same as lerp)
 *                        - peak >= max : linear (same as lerp)
 *                        - peak > min && peak < max : triangular
 * @returns {number} Interpolated value
 */
export declare function triLerp(t: number, min: number, max: number, peak: number): number;
/**
 * Interpolate a number between two bounds using Exponential interpolation
 *
 * @param {number} t Normalized time value to interpolate
 * @param {number} min Minimum boundary
 * @param {number} max Maximum boundary
 * @param {number} power Exponent controling the interpolation curve shape
 *                         - power > 1 : ease-in
 *                         - power < 1 : ease-out
 *                         - power = 1 : linear (same as lerp)
 * @returns {number} Interpolated value
 */
export declare function expLerp(t: number, min: number, max: number, power: number): number;
/**
 * Interpolate a number using Quadratic Bézier interpolation
 *
 * @param {number} t Normalized time value to interpolate
 * @param {number} p1 Start point
 * @param {number} cp Control point
 * @param {number} p2 End point
 * @returns {number} Interpolated value
 */
export declare function quadraticBezier(t: number, p1: number, cp: number, p2: number): number;
/**
 * Interpolate a number using Cubic Bézier interpolation
 *
 * @param {number} t Normalized time value to interpolate
 * @param {number} p1  Start point
 * @param {number} cp1 First control point
 * @param {number} cp2 Second control point
 * @param {number} p2  End point
 * @returns {number} Interpolated value
 */
export declare function cubicBezier(t: number, p1: number, cp1: number, cp2: number, p2: number): number;
/**
 * Interpolate a number using Catmull-Rom interpolation
 *
 * @param {number} t Normalized time value to interpolate
 * @param {number} p1  Start point
 * @param {number} cp1 First control point
 * @param {number} cp2 Second control point
 * @param {number} p2  End point
 * @returns {number} Interpolated value
 */
export declare function catmullRom(t: number, p1: number, cp1: number, cp2: number, p2: number): number;
/**
 * Re-map the [0, 1] interval into [0, 1] parabola, such that corners are remaped to 0 and the center to 1
 *  - parabola(0) = parabola(1) = 0
 *  - parabola(0.5) = 1
 *
 * @param {number} x Normalized coordinate on X axis
 * @param {number} [power=1] Parabola exponent
 * @returns {number} Normalized re-mapped value
 */
export declare function parabola(x: number, power?: number): number;
/**
 * Compare two numbers
 *
 * @param {number} value Value to compare to the edge
 * @param {number} edge Value of the edge
 * @returns {number} `0` if value < edge, `1` otherwise
 */
export declare function step(value: number, edge: number): number;
/**
 * Interpolate a number between two bounds using Hermite interpolation
 *
 * @param {number} value Value to interpolate
 * @param {number} min Minimum boundary
 * @param {number} max Maximum boundary
 * @returns {number} Interpolated value
 */
export declare function smoothstep(value: number, min: number, max: number): number;
/**
 * Compute the fractional part of a number
 *
 * @param {number} value Value to compute the fractional part of
 * @returns {number} Fractional part of the given number
 */
export declare function fract(value: number): number;
/**
 * Compute the value of a number modulo another
 *
 * @param {number} value Value to modulate
 * @param {number} modulo Value to modulate by
 * @returns {number} Computed value
 */
export declare function mod(value: number, modulo: number): number;
/**
 * Move back and forth a number between 0 and a length, so that it is never larger than length and never smaller than 0
 *
 * @param {number} value Value to modulate
 * @param {number} length Total length
 * @returns {number} Computed value
 */
export declare function pingPong(value: number, length: number): number;
/**
 * Compute the sum of an array of numbers
 *
 * @param {number[]} numbers Array of numbers to compute the sum from
 * @returns {number} Total sum
 */
export declare function sum(numbers: number[]): number;
/**
 * Compute the average of an array of numbers
 *
 * @param {number[]} numbers Array of numbers to compute the average from
 * @returns {number} Total average
 */
export declare function average(numbers: number[]): number;
/**
 * Smoothly interpolate a number toward another
 *
 * @param {number} value Value to interpolate
 * @param {number} target Destination of the interpolation
 * @param {number} damping A higher value will make the movement more sudden, and a lower value will make the movement more gradual
 * @param {number} delta Delta time (in seconds)
 * @returns {number} Interpolated number
 */
export declare function damp(value: number, target: number, damping: number, delta: number): number;