Spaces:
Running
Running
File size: 3,997 Bytes
30c32c8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
class MathUtil {
/**
* Convert a value from degrees to radians.
* @param {!number} deg Value in degrees.
* @return {!number} Equivalent value in radians.
*/
static degToRad (deg) {
return deg * Math.PI / 180;
}
/**
* Convert a value from radians to degrees.
* @param {!number} rad Value in radians.
* @return {!number} Equivalent value in degrees.
*/
static radToDeg (rad) {
return rad * 180 / Math.PI;
}
/**
* Clamp a number between two limits.
* If n < min, return min. If n > max, return max. Else, return n.
* @param {!number} n Number to clamp.
* @param {!number} min Minimum limit.
* @param {!number} max Maximum limit.
* @return {!number} Value of n clamped to min and max.
*/
static clamp (n, min, max) {
return Math.min(Math.max(n, min), max);
}
/**
* Keep a number between two limits, wrapping "extra" into the range.
* e.g., wrapClamp(7, 1, 5) == 2
* wrapClamp(0, 1, 5) == 5
* wrapClamp(-11, -10, 6) == 6, etc.
* @param {!number} n Number to wrap.
* @param {!number} min Minimum limit.
* @param {!number} max Maximum limit.
* @return {!number} Value of n wrapped between min and max.
*/
static wrapClamp (n, min, max) {
const range = (max - min) + 1;
return n - (Math.floor((n - min) / range) * range);
}
/**
* Convert a value from tan function in degrees.
* @param {!number} angle in degrees
* @return {!number} Correct tan value
*/
static tan (angle) {
angle = angle % 360;
switch (angle) {
case -270:
case 90:
return Infinity;
case -90:
case 270:
return -Infinity;
default:
return Math.round(Math.tan((Math.PI * angle) / 180) * 1e10) / 1e10;
}
}
/**
* Given an array of unique numbers,
* returns a reduced array such that each element of the reduced array
* represents the position of that element in a sorted version of the
* original array.
* E.g. [5, 19. 13, 1] => [1, 3, 2, 0]
* @param {Array<number>} elts The elements to sort and reduce
* @return {Array<number>} The array of reduced orderings
*/
static reducedSortOrdering (elts) {
const sorted = elts.slice(0).sort((a, b) => a - b);
return elts.map(e => sorted.indexOf(e));
}
/**
* Return a random number given an inclusive range and a number in that
* range that should be excluded.
*
* For instance, (1, 5, 3) will only pick 1, 2, 4, or 5 (with equal
* probability)
*
* @param {number} lower - The lower bound (inlcusive)
* @param {number} upper - The upper bound (inclusive), such that lower <= upper
* @param {number} excluded - The number to exclude (MUST be in the range)
* @return {number} A random integer in the range [lower, upper] that is not "excluded"
*/
static inclusiveRandIntWithout (lower, upper, excluded) {
// Note that subtraction is the number of items in the
// inclusive range [lower, upper] minus 1 already
// (e.g. in the set {3, 4, 5}, 5 - 3 = 2).
const possibleOptions = upper - lower;
const randInt = lower + Math.floor(Math.random() * possibleOptions);
if (randInt >= excluded) {
return randInt + 1;
}
return randInt;
}
/**
* Scales a number from one range to another.
* @param {number} i number to be scaled
* @param {number} iMin input range minimum
* @param {number} iMax input range maximum
* @param {number} oMin output range minimum
* @param {number} oMax output range maximum
* @return {number} scaled number
*/
static scale (i, iMin, iMax, oMin, oMax) {
const p = (i - iMin) / (iMax - iMin);
return (p * (oMax - oMin)) + oMin;
}
}
module.exports = MathUtil;
|