smath 1.12.1 → 1.13.1

package/dist/index.js

@@ -11,7 +11,36 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SMath = void 0;
+exports.approx = approx;
+exports.clamp = clamp;
+exports.normalize = normalize;
+exports.expand = expand;
+exports.translate = translate;
+exports.linspace = linspace;
+exports.logspace = logspace;
+exports.factorial = factorial;
+exports.factors = factors;
+exports.round2 = round2;
+exports.error = error;
+exports.sum = sum;
+exports.prod = prod;
+exports.avg = avg;
+exports.median = median;
+exports.varp = varp;
+exports.vars = vars;
+exports.stdevp = stdevp;
+exports.stdevs = stdevs;
+exports.runif = runif;
+exports.rint = rint;
+exports.rnorm = rnorm;
+exports.rdist = rdist;
+exports.shuffle = shuffle;
+exports.lim = lim;
+exports.differentiate = differentiate;
+exports.integrate = integrate;
+exports.rat = rat;
+exports.mixed = mixed;
+exports.toHex = toHex;
 /**
  * @packageDocumentation
  * Small math function library
@@ -20,591 +49,555 @@ exports.SMath = void 0;
  * ![NPM Last Update](https://img.shields.io/npm/last-update/smath)
  */
 /**
- * Contains a small math function library including
- * useful interpolation and extrapolation functions.
+ * Check if two numbers are approximately equal with a maximum abolute error.
+ * @param a Any number
+ * @param b Any number
+ * @param epsilon Maximum absolute error
+ * @returns True if `a` is approximately `b`
+ * @example
+ * ```js
+ * const b1 = SMath.approx(1 / 3, 0.33, 1e-6), // false
+ *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
+ * ```
  */
-var SMath;
-(function (SMath) {
-    /**
-     * Check if two numbers are approximately equal with a maximum abolute error.
-     * @param a Any number
-     * @param b Any number
-     * @param epsilon Maximum absolute error
-     * @returns True if `a` is approximately `b`
-     * @example
-     * ```js
-     * const b1 = SMath.approx(1 / 3, 0.33, 1e-6), // false
-     *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
-     * ```
-     */
-    function approx(a, b, epsilon) {
-        if (epsilon === void 0) { epsilon = 1e-6; }
-        return a - b < epsilon && b - a < epsilon;
+function approx(a, b, epsilon) {
+    if (epsilon === void 0) { epsilon = 1e-6; }
+    return a - b < epsilon && b - a < epsilon;
+}
+/**
+ * Clamp a number within a range.
+ * @param n The number to clamp
+ * @param min The minimum value of the range
+ * @param max The maximum value of the range
+ * @returns A clamped number
+ * @example
+ * ```js
+ * const n1 = SMath.clamp(5, 0, 10),  // 5
+ *       n2 = SMath.clamp(-2, 0, 10); // 0
+ * ```
+ */
+function clamp(n, min, max) {
+    if (n < min) {
+        return min;
     }
-    SMath.approx = approx;
-    /**
-     * Clamp a number within a range.
-     * @param n The number to clamp
-     * @param min The minimum value of the range
-     * @param max The maximum value of the range
-     * @returns A clamped number
-     * @example
-     * ```js
-     * const n1 = SMath.clamp(5, 0, 10),  // 5
-     *       n2 = SMath.clamp(-2, 0, 10); // 0
-     * ```
-     */
-    function clamp(n, min, max) {
-        if (n < min) {
-            return min;
-        }
-        if (n > max) {
-            return max;
-        }
-        return n;
+    if (n > max) {
+        return max;
     }
-    SMath.clamp = clamp;
-    /**
-     * Normalize the number `n` from the range `min, max` to the range `0, 1`
-     * @param n The number to normalize
-     * @param min The minimum value in the range
-     * @param max The maximum value in the range
-     * @returns A normalized value
-     * @example
-     * ```js
-     * const y = SMath.normalize(18, 9, 99); // 0.1
-     * ```
-     */
-    function normalize(n, min, max) {
-        if (min === max) {
-            return 0;
-        }
-        return (n - min) / (max - min);
+    return n;
+}
+/**
+ * Normalize the number `n` from the range `min, max` to the range `0, 1`
+ * @param n The number to normalize
+ * @param min The minimum value in the range
+ * @param max The maximum value in the range
+ * @returns A normalized value
+ * @example
+ * ```js
+ * const y = SMath.normalize(18, 9, 99); // 0.1
+ * ```
+ */
+function normalize(n, min, max) {
+    if (min === max) {
+        return 0;
     }
-    SMath.normalize = normalize;
-    /**
-     * Expand a normalized number `n` to the range `min, max`
-     * @param n A normalized number
-     * @param min The minimum value in the range
-     * @param max The maximum value in the range
-     * @returns A value within the number range
-     * @example
-     * ```js
-     * const y = SMath.expand(0.25, 4, 6); // 4.5
-     * ```
-     */
-    function expand(n, min, max) {
-        return (max - min) * n + min;
+    return (n - min) / (max - min);
+}
+/**
+ * Expand a normalized number `n` to the range `min, max`
+ * @param n A normalized number
+ * @param min The minimum value in the range
+ * @param max The maximum value in the range
+ * @returns A value within the number range
+ * @example
+ * ```js
+ * const y = SMath.expand(0.25, 4, 6); // 4.5
+ * ```
+ */
+function expand(n, min, max) {
+    return (max - min) * n + min;
+}
+/**
+ * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
+ * @param n The number to translate
+ * @param min1 The minimum value from the initial range
+ * @param max1 The maximum value from the initial range
+ * @param min2 The minimum value for the final range
+ * @param max2 The maximum value for the final range
+ * @returns A translated number in the final range
+ * @example
+ * ```js
+ * const C = 20,
+ *       F = SMath.translate(C, 0, 100, 32, 212); // 68
+ * ```
+ */
+function translate(n, min1, max1, min2, max2) {
+    return expand(normalize(n, min1, max1), min2, max2);
+}
+/**
+ * Generate an array of linearly spaced numbers.
+ * @param min The initial value of the linear space
+ * @param max The final value of the linear space
+ * @param count The number of values in the space
+ * @returns The linear space as an array of numbers
+ * @example
+ * ```js
+ * const space = SMath.linspace(1, 5, 6);
+ * // [ 1, 1.8, 2.6, 3.4, 4.2, 5 ]
+ * ```
+ */
+function linspace(min, max, count) {
+    var space = [];
+    for (var i = 0; i < count; i++) {
+        space[i] = translate(i, 0, count - 1, min, max);
     }
-    SMath.expand = expand;
-    /**
-     * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
-     * @param n The number to translate
-     * @param min1 The minimum value from the initial range
-     * @param max1 The maximum value from the initial range
-     * @param min2 The minimum value for the final range
-     * @param max2 The maximum value for the final range
-     * @returns A translated number in the final range
-     * @example
-     * ```js
-     * const C = 20,
-     *       F = SMath.translate(C, 0, 100, 32, 212); // 68
-     * ```
-     */
-    function translate(n, min1, max1, min2, max2) {
-        return expand(normalize(n, min1, max1), min2, max2);
+    return space;
+}
+/**
+ * Generate an array of logarithmically spaced numbers.
+ * @param min The initial magnitude of the space
+ * @param max The final magnitude of the space
+ * @param count The number of values in the space
+ * @returns The logarithmic space as an array of numbers
+ * @example
+ * ```js
+ * const space = SMath.logspace(0, 2, 5);
+ * // [ 1, 3.2, 10, 31.6, 100 ]
+ * ```
+ */
+function logspace(min, max, count) {
+    return linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
+}
+/**
+ * Compute the factorial of `n`.
+ * @param n Any positive integer
+ * @returns `n!`
+ * @example
+ * ```js
+ * const y = SMath.factorial(5); // 120
+ * ```
+ */
+function factorial(n) {
+    if (n < 0 || (n | 0) !== n) {
+        throw new Error('Input must be a positive integer.');
     }
-    SMath.translate = translate;
-    /**
-     * Generate an array of linearly spaced numbers.
-     * @param min The initial value of the linear space
-     * @param max The final value of the linear space
-     * @param count The number of values in the space
-     * @returns The linear space as an array of numbers
-     * @example
-     * ```js
-     * const space = SMath.linspace(1, 5, 6);
-     * // [ 1, 1.8, 2.6, 3.4, 4.2, 5 ]
-     * ```
-     */
-    function linspace(min, max, count) {
-        var space = [];
-        for (var i = 0; i < count; i++) {
-            space[i] = translate(i, 0, count - 1, min, max);
-        }
-        return space;
+    else if (n === 0) {
+        return 1;
     }
-    SMath.linspace = linspace;
-    /**
-     * Generate an array of logarithmically spaced numbers.
-     * @param min The initial magnitude of the space
-     * @param max The final magnitude of the space
-     * @param count The number of values in the space
-     * @returns The logarithmic space as an array of numbers
-     * @example
-     * ```js
-     * const space = SMath.logspace(0, 2, 5);
-     * // [ 1, 3.2, 10, 31.6, 100 ]
-     * ```
-     */
-    function logspace(min, max, count) {
-        return linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
+    else if (n <= 2) {
+        return n;
     }
-    SMath.logspace = logspace;
-    /**
-     * Compute the factorial of `n`.
-     * @param n Any positive integer
-     * @returns `n!`
-     * @example
-     * ```js
-     * const y = SMath.factorial(5); // 120
-     * ```
-     */
-    function factorial(n) {
-        if (n < 0 || (n | 0) !== n) {
-            throw new Error('Input must be a positive integer.');
-        }
-        else if (n === 0) {
-            return 1;
-        }
-        else if (n <= 2) {
-            return n;
+    else {
+        return n * factorial(n - 1);
+    }
+}
+/**
+ * Factorize `n` into its prime factors.
+ * @param n Any positive integer
+ * @returns The array of prime factors
+ * @example
+ * ```js
+ * const y = SMath.factors(12); // [ 2, 2, 3 ]
+ * ```
+ */
+function factors(n) {
+    if (n < 0 || (n | 0) !== n) {
+        throw new Error('Input must be a positive integer!');
+    }
+    if (n <= 3) {
+        return [n];
+    }
+    var f = [];
+    var i = 2;
+    while (n > 1 && i <= n) {
+        if ((n / i) === ((n / i) | 0)) {
+            n /= i;
+            f.push(i);
         }
         else {
-            return n * factorial(n - 1);
+            i++;
         }
     }
-    SMath.factorial = factorial;
-    /**
-     * Factorize `n` into its prime factors.
-     * @param n Any positive integer
-     * @returns The array of prime factors
-     * @example
-     * ```js
-     * const y = SMath.factors(12); // [ 2, 2, 3 ]
-     * ```
-     */
-    function factors(n) {
-        if (n < 0 || (n | 0) !== n) {
-            throw new Error('Input must be a positive integer!');
-        }
-        if (n <= 3) {
-            return [n];
-        }
-        var f = [];
-        var i = 2;
-        while (n > 1 && i <= n) {
-            if ((n / i) === ((n / i) | 0)) {
-                n /= i;
-                f.push(i);
-            }
-            else {
-                i++;
-            }
-        }
-        return f;
+    return f;
+}
+/**
+ * Round a number to the nearest multiple of an arbitrary
+ * base. Does not round when the base is set to zero.
+ * @param n Any number to round
+ * @param base Any base to round to
+ * @returns `n` rounded to the nearest multiple of `base`
+ * @example
+ * ```js
+ * const y = SMath.round2(Math.PI, 0.2); // 3.2
+ * ```
+ */
+function round2(n, base) {
+    return base ? base * Math.round(n / base) : n;
+}
+/**
+ * Calculate the relative normalized error or deviation from any
+ * value to an accepted value. An error of 0 indicates that the
+ * two values are identical. An error of -0.1 indicates that the
+ * experimental value is 10% smaller than (90% of) the accepted
+ * value. An error of 1.0 indicates that the experimental value
+ * is 100% greater (or twice the size) of the accepted value.
+ * @param experimental The value observed or produced by a test
+ * @param actual The accepted or theoretical value
+ * @returns The relative (normalized) error
+ * @example
+ * ```js
+ * const e = SMath.error(22.5, 25); // -0.1
+ * ```
+ */
+function error(experimental, actual) {
+    return (experimental - actual) / actual;
+}
+/**
+ * Add up all the inputs.
+ * If none are present, returns 0.
+ * @param data An array of numeric inputs
+ * @returns The sum total
+ * @example
+ * ```js
+ * const y = SMath.sum([1, 2, 3]); // 6
+ * ```
+ */
+function sum(data) {
+    return data.reduce(function (a, b) { return a + b; }, 0);
+}
+/**
+ * Multiply all the inputs.
+ * If none are present, returns 1.
+ * @param data An array of numeric inputs
+ * @returns The product
+ * @example
+ * ```js
+ * const y = SMath.prod([2, 2, 3, 5]); // 60
+ * ```
+ */
+function prod(data) {
+    return data.reduce(function (a, b) { return a * b; }, 1);
+}
+/**
+ * Compute the average, or mean, of a set of numbers.
+ * @param data An array of numeric inputs
+ * @returns The average, or mean
+ * @example
+ * ```js
+ * const y = SMath.avg([1, 2, 4, 4]); // 2.75
+ * ```
+ */
+function avg(data) {
+    return sum(data) / data.length;
+}
+/**
+ * Compute the median of a set of numbers.
+ * @param data An array of numeric inputs
+ * @returns The median of the dataset
+ * @example
+ * ```js
+ * const y = SMath.median([2, 5, 3, 1]); // 2.5
+ * ```
+ */
+function median(data) {
+    data.sort(function (a, b) { return a - b; });
+    if (data.length % 2) {
+        return data[(data.length - 1) / 2];
     }
-    SMath.factors = factors;
-    /**
-     * Round a number to the nearest multiple of an arbitrary
-     * base. Does not round when the base is set to zero.
-     * @param n Any number to round
-     * @param base Any base to round to
-     * @returns `n` rounded to the nearest multiple of `base`
-     * @example
-     * ```js
-     * const y = SMath.round2(Math.PI, 0.2); // 3.2
-     * ```
-     */
-    function round2(n, base) {
-        return base ? base * Math.round(n / base) : n;
+    return avg([data[data.length / 2 - 1], data[data.length / 2]]);
+}
+/**
+ * Compute the variance of a **complete population**.
+ * @param data An array of numeric inputs
+ * @returns The population variance
+ * @example
+ * ```js
+ * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
+ * ```
+ */
+function varp(data) {
+    var mean = avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
+    return sum(squares) / data.length;
+}
+/**
+ * Compute the variance of a **sample**.
+ * @param data An array of numeric inputs
+ * @returns The sample variance
+ * @example
+ * ```js
+ * const y = SMath.vars([1, 2, 4, 4]); // 2.25
+ * ```
+ */
+function vars(data) {
+    var mean = avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
+    return sum(squares) / (data.length - 1);
+}
+/**
+ * Compute the standard deviation of a **complete population**.
+ * @param data An array of numeric inputs
+ * @returns The population standard deviation
+ * @example
+ * ```js
+ * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
+ * ```
+ */
+function stdevp(data) {
+    return Math.sqrt(varp(data));
+}
+/**
+ * Compute the standard deviation of a **sample**.
+ * @param data An array of numeric inputs
+ * @returns The sample standard deviation
+ * @example
+ * ```js
+ * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
+ * ```
+ */
+function stdevs(data) {
+    return Math.sqrt(vars(data));
+}
+/**
+ * Generate a uniformly-distributed floating-point number within the range.
+ * @param min The minimum bound
+ * @param max The maximum bound
+ * @returns A random float within the range
+ * @example
+ * ```js
+ * const y = SMath.runif(-2, 2); // 0.376...
+ * ```
+ */
+function runif(min, max) {
+    return expand(Math.random(), min, max);
+}
+/**
+ * Generate a uniformly-distributed integer within the range.
+ * @param min The minimum bound (inclusive)
+ * @param max The maximum bound (inclusive)
+ * @returns A random integer within the range
+ * @example
+ * ```js
+ * const y = SMath.rint(-4, 3); // -4
+ * ```
+ */
+function rint(min, max) {
+    min |= 0;
+    max |= 0;
+    if (min < 0) {
+        min--;
     }
-    SMath.round2 = round2;
-    /**
-     * Calculate the relative normalized error or deviation from any
-     * value to an accepted value. An error of 0 indicates that the
-     * two values are identical. An error of -0.1 indicates that the
-     * experimental value is 10% smaller than (90% of) the accepted
-     * value. An error of 1.0 indicates that the experimental value
-     * is 100% greater (or twice the size) of the accepted value.
-     * @param experimental The value observed or produced by a test
-     * @param actual The accepted or theoretical value
-     * @returns The relative (normalized) error
-     * @example
-     * ```js
-     * const e = SMath.error(22.5, 25); // -0.1
-     * ```
-     */
-    function error(experimental, actual) {
-        return (experimental - actual) / actual;
+    if (max > 0) {
+        max++;
     }
-    SMath.error = error;
-    /**
-     * Add up all the inputs.
-     * If none are present, returns 0.
-     * @param data An array of numeric inputs
-     * @returns The sum total
-     * @example
-     * ```js
-     * const y = SMath.sum([1, 2, 3]); // 6
-     * ```
-     */
-    function sum(data) {
-        return data.reduce(function (a, b) { return a + b; }, 0);
+    return clamp(runif(min, max), min, max) | 0; // `| 0` pulls toward 0
+}
+/**
+ * Generate a normally-distributed floating-point number.
+ * @param mean The mean of the population distribution
+ * @param stdev The standard deviation of the population
+ * @returns A random float
+ * @example
+ * ```js
+ * const y = SMath.rnorm(2, 3); // 1.627...
+ * ```
+ */
+function rnorm(mean, stdev) {
+    if (mean === void 0) { mean = 0; }
+    if (stdev === void 0) { stdev = 1; }
+    return mean + stdev * Math.sqrt(-2 * Math.log(Math.random())) * Math.cos(2 * Math.PI * Math.random());
+}
+/**
+ * Generate a population of normally-distributed floating-point numbers.
+ * @param count The number of values to generate
+ * @param mean The mean of the population distribution
+ * @param stdev The standard deviation of the population
+ * @returns A population of random floats
+ * @example
+ * ```js
+ * const dataset = SMath.rdist(3); // [ 1.051..., -0.779..., -2.254... ]
+ * ```
+ */
+function rdist(count, mean, stdev) {
+    if (mean === void 0) { mean = 0; }
+    if (stdev === void 0) { stdev = 1; }
+    var distribution = [];
+    for (var i = 0; i < count; i++) {
+        distribution[i] = rnorm(mean, stdev);
     }
-    SMath.sum = sum;
-    /**
-     * Multiply all the inputs.
-     * If none are present, returns 1.
-     * @param data An array of numeric inputs
-     * @returns The product
-     * @example
-     * ```js
-     * const y = SMath.prod([2, 2, 3, 5]); // 60
-     * ```
-     */
-    function prod(data) {
-        return data.reduce(function (a, b) { return a * b; }, 1);
+    return distribution;
+}
+/**
+ * Randomize an array of arbitrary elements.
+ * @param stack An array of arbitrary elements
+ * @returns The `stack` array in a random order
+ * @example
+ * ```js
+ * const shuffled = SMath.shuffle(['a', 'b', 'c']); // [ 'c', 'a', 'b' ]
+ * ```
+ */
+function shuffle(stack) {
+    var rawData = [];
+    for (var _i = 0, stack_1 = stack; _i < stack_1.length; _i++) {
+        var item = stack_1[_i];
+        rawData.push({ index: Math.random(), value: item });
     }
-    SMath.prod = prod;
-    /**
-     * Compute the average, or mean, of a set of numbers.
-     * @param data An array of numeric inputs
-     * @returns The average, or mean
-     * @example
-     * ```js
-     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
-     * ```
-     */
-    function avg(data) {
-        return sum(data) / data.length;
+    return rawData.sort(function (a, b) { return a.index - b.index; }).map(function (a) { return a.value; });
+}
+/**
+ * Take the limit of a function. A return value of `NaN` indicates
+ * that no limit exists either due to a discontinuity or imaginary value.
+ * @param f Function `f(x)`
+ * @param x The x-value where to take the limit
+ * @param h The approach distance
+ * @param discontinuity_cutoff The discontinuity cutoff
+ * @returns `lim(f(x->x))`
+ * @example
+ * ```js
+ * const y = SMath.lim(Math.log, 0); // -Infinity
+ * ```
+ */
+function lim(f, x, h, discontinuity_cutoff) {
+    if (h === void 0) { h = 1e-3; }
+    if (discontinuity_cutoff === void 0) { discontinuity_cutoff = 1; }
+    var center = f(x), left1 = f(x - h), left2 = f(x - h / 2), right1 = f(x + h), right2 = f(x + h / 2);
+    var left, right;
+    if (Number.isFinite(center)) {
+        return center;
     }
-    SMath.avg = avg;
-    /**
-     * Compute the median of a set of numbers.
-     * @param data An array of numeric inputs
-     * @returns The median of the dataset
-     * @example
-     * ```js
-     * const y = SMath.median([2, 5, 3, 1]); // 2.5
-     * ```
-     */
-    function median(data) {
-        data.sort(function (a, b) { return a - b; });
-        if (data.length % 2) {
-            return data[(data.length - 1) / 2];
+    // Check the limit approaching from the left
+    if (Number.isFinite(left1) && Number.isFinite(left2)) {
+        if (left2 > left1 + 2 * h) {
+            left = Infinity;
         }
-        return avg([data[data.length / 2 - 1], data[data.length / 2]]);
-    }
-    SMath.median = median;
-    /**
-     * Compute the variance of a **complete population**.
-     * @param data An array of numeric inputs
-     * @returns The population variance
-     * @example
-     * ```js
-     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
-     * ```
-     */
-    function varp(data) {
-        var mean = avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
-        return sum(squares) / data.length;
-    }
-    SMath.varp = varp;
-    /**
-     * Compute the variance of a **sample**.
-     * @param data An array of numeric inputs
-     * @returns The sample variance
-     * @example
-     * ```js
-     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
-     * ```
-     */
-    function vars(data) {
-        var mean = avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
-        return sum(squares) / (data.length - 1);
-    }
-    SMath.vars = vars;
-    /**
-     * Compute the standard deviation of a **complete population**.
-     * @param data An array of numeric inputs
-     * @returns The population standard deviation
-     * @example
-     * ```js
-     * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
-     * ```
-     */
-    function stdevp(data) {
-        return Math.sqrt(varp(data));
-    }
-    SMath.stdevp = stdevp;
-    /**
-     * Compute the standard deviation of a **sample**.
-     * @param data An array of numeric inputs
-     * @returns The sample standard deviation
-     * @example
-     * ```js
-     * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
-     * ```
-     */
-    function stdevs(data) {
-        return Math.sqrt(vars(data));
-    }
-    SMath.stdevs = stdevs;
-    /**
-     * Generate a uniformly-distributed floating-point number within the range.
-     * @param min The minimum bound
-     * @param max The maximum bound
-     * @returns A random float within the range
-     * @example
-     * ```js
-     * const y = SMath.runif(-2, 2); // 0.376...
-     * ```
-     */
-    function runif(min, max) {
-        return expand(Math.random(), min, max);
-    }
-    SMath.runif = runif;
-    /**
-     * Generate a uniformly-distributed integer within the range.
-     * @param min The minimum bound (inclusive)
-     * @param max The maximum bound (inclusive)
-     * @returns A random integer within the range
-     * @example
-     * ```js
-     * const y = SMath.rint(-4, 3); // -4
-     * ```
-     */
-    function rint(min, max) {
-        min |= 0;
-        max |= 0;
-        if (min < 0) {
-            min--;
+        else if (left2 < left1 - 2 * h) {
+            left = -Infinity;
         }
-        if (max > 0) {
-            max++;
+        else {
+            left = avg([left1, left2]);
         }
-        return clamp(runif(min, max), min, max) | 0; // `| 0` pulls toward 0
     }
-    SMath.rint = rint;
-    /**
-     * Generate a normally-distributed floating-point number.
-     * @param mean The mean of the population distribution
-     * @param stdev The standard deviation of the population
-     * @returns A random float
-     * @example
-     * ```js
-     * const y = SMath.rnorm(2, 3); // 1.627...
-     * ```
-     */
-    function rnorm(mean, stdev) {
-        if (mean === void 0) { mean = 0; }
-        if (stdev === void 0) { stdev = 1; }
-        return mean + stdev * Math.sqrt(-2 * Math.log(Math.random())) * Math.cos(2 * Math.PI * Math.random());
+    else if (left1 === left2) { // Handles +/-Infinity case
+        left = left1;
     }
-    SMath.rnorm = rnorm;
-    /**
-     * Generate a population of normally-distributed floating-point numbers.
-     * @param count The number of values to generate
-     * @param mean The mean of the population distribution
-     * @param stdev The standard deviation of the population
-     * @returns A population of random floats
-     * @example
-     * ```js
-     * const dataset = SMath.rdist(3); // [ 1.051..., -0.779..., -2.254... ]
-     * ```
-     */
-    function rdist(count, mean, stdev) {
-        if (mean === void 0) { mean = 0; }
-        if (stdev === void 0) { stdev = 1; }
-        var distribution = [];
-        for (var i = 0; i < count; i++) {
-            distribution[i] = rnorm(mean, stdev);
-        }
-        return distribution;
-    }
-    SMath.rdist = rdist;
-    /**
-     * Randomize an array of arbitrary elements.
-     * @param stack An array of arbitrary elements
-     * @returns The `stack` array in a random order
-     * @example
-     * ```js
-     * const shuffled = SMath.shuffle(['a', 'b', 'c']); // [ 'c', 'a', 'b' ]
-     * ```
-     */
-    function shuffle(stack) {
-        var rawData = [];
-        for (var _i = 0, stack_1 = stack; _i < stack_1.length; _i++) {
-            var item = stack_1[_i];
-            rawData.push({ index: Math.random(), value: item });
-        }
-        return rawData.sort(function (a, b) { return a.index - b.index; }).map(function (a) { return a.value; });
+    else {
+        left = NaN;
     }
-    SMath.shuffle = shuffle;
-    /**
-     * Take the limit of a function. A return value of `NaN` indicates
-     * that no limit exists either due to a discontinuity or imaginary value.
-     * @param f Function `f(x)`
-     * @param x The x-value where to take the limit
-     * @param h The approach distance
-     * @param discontinuity_cutoff The discontinuity cutoff
-     * @returns `lim(f(x->x))`
-     * @example
-     * ```js
-     * const y = SMath.lim(Math.log, 0); // -Infinity
-     * ```
-     */
-    function lim(f, x, h, discontinuity_cutoff) {
-        if (h === void 0) { h = 1e-3; }
-        if (discontinuity_cutoff === void 0) { discontinuity_cutoff = 1; }
-        var center = f(x), left1 = f(x - h), left2 = f(x - h / 2), right1 = f(x + h), right2 = f(x + h / 2);
-        var left, right;
-        if (Number.isFinite(center)) {
-            return center;
-        }
-        // Check the limit approaching from the left
-        if (Number.isFinite(left1) && Number.isFinite(left2)) {
-            if (left2 > left1 + 2 * h) {
-                left = Infinity;
-            }
-            else if (left2 < left1 - 2 * h) {
-                left = -Infinity;
-            }
-            else {
-                left = avg([left1, left2]);
-            }
-        }
-        else if (left1 === left2) { // Handles +/-Infinity case
-            left = left1;
-        }
-        else {
-            left = NaN;
-        }
-        // Check the limit approaching from the right
-        if (Number.isFinite(right1) && Number.isFinite(right2)) {
-            if (right2 > right1 + 2 * h) {
-                right = Infinity;
-            }
-            else if (right2 < right1 - 2 * h) {
-                right = -Infinity;
-            }
-            else {
-                right = avg([right1, right2]);
-            }
+    // Check the limit approaching from the right
+    if (Number.isFinite(right1) && Number.isFinite(right2)) {
+        if (right2 > right1 + 2 * h) {
+            right = Infinity;
         }
-        else if (right1 === right2) { // Handles +/-Infinity case
-            right = right1;
+        else if (right2 < right1 - 2 * h) {
+            right = -Infinity;
         }
         else {
-            right = NaN;
-        }
-        // Check if limits match or are close
-        if (left === right) { // Handles +/-Infinity case
-            return left;
-        }
-        else if (SMath.approx(left, right, discontinuity_cutoff)) {
-            return avg([left, right]);
-        }
-        else if (!Number.isNaN(left) && Number.isNaN(right)) {
-            return left;
-        }
-        else if (Number.isNaN(left) && !Number.isNaN(right)) {
-            return right;
-        }
-        else {
-            return NaN;
+            right = avg([right1, right2]);
         }
     }
-    SMath.lim = lim;
-    /**
-     * Take the derivative of a function.
-     * @param f Function `f(x)`
-     * @param x The x-value where to evaluate the derivative
-     * @param h Small step value
-     * @returns `f'(x)`
-     * @example
-     * ```js
-     * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
-     * ```
-     */
-    function differentiate(f, x, h) {
-        if (h === void 0) { h = 1e-3; }
-        return (f(x + h) - f(x - h)) / (2 * h);
+    else if (right1 === right2) { // Handles +/-Infinity case
+        right = right1;
     }
-    SMath.differentiate = differentiate;
-    /**
-     * Compute the definite integral of a function.
-     * @param f Function `f(x)`
-     * @param a The miminum integral bound
-     * @param b The maximum integral bound
-     * @param Ndx The number of rectangles to compute
-     * @returns `F(b)-F(a)`
-     * @example
-     * ```js
-     * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
-     * ```
-     */
-    function integrate(f, a, b, Ndx) {
-        if (Ndx === void 0) { Ndx = 1e3; }
-        return ((b - a) / Ndx) * sum(linspace(a, b, Ndx).map(function (x) { return f(x); }));
+    else {
+        right = NaN;
     }
-    SMath.integrate = integrate;
-    /**
-     * Convert an arbitrary decimal number into a simplified fraction (or ratio).
-     * See `mixed()` for instructions on how to break out the whole number part.
-     * @param n The decimal number to convert
-     * @param epsilon Maximum absolute error
-     * @returns An object containing the fraction's numerator and denominator
-     * @example
-     * ```js
-     * const frac = SMath.rat(0.625); // { num: 5, den: 8 }
-     * ```
-     */
-    function rat(n, epsilon) {
-        if (epsilon === void 0) { epsilon = 1e-6; }
-        var num = 0, den = 1, sign = n < 0 ? -1 : 1;
-        while (!approx(sign * n, num / den, epsilon)) {
-            if (sign * n > num / den) {
-                num++;
-            }
-            else {
-                den++;
-            }
-        }
-        return { num: sign * num, den: den };
+    // Check if limits match or are close
+    if (left === right) { // Handles +/-Infinity case
+        return left;
+    }
+    else if (approx(left, right, discontinuity_cutoff)) {
+        return avg([left, right]);
     }
-    SMath.rat = rat;
-    /**
-     * Convert an arbitrary decimal number into a simplified fraction, after
-     * breaking out the whole number part first. See `rat()` for keeping the
-     * number as a ratio without separating the whole number part.
-     * @param n A decimal number to convert
-     * @param epsilon Maximum absolute error
-     * @returns An object containing the whole part and fraction numerator and denominator
-     * @example
-     * ```js
-     * const frac = SMath.mixed(-8 / 6); // { whole: -1, num: 1, den: 3 }
-     * ```
-     */
-    function mixed(n, epsilon) {
-        if (epsilon === void 0) { epsilon = 1e-6; }
-        return __assign({ whole: n | 0 }, rat(n < -1 ? (n | 0) - n : n - (n | 0), epsilon));
+    else if (!Number.isNaN(left) && Number.isNaN(right)) {
+        return left;
     }
-    SMath.mixed = mixed;
-    /**
-     * Convert any number to its hexadecimal equivalent.
-     * @param n A decimal number to convert
-     * @param length The minimum number of digits to show
-     * @returns The number `n` converted to hexadecimal
-     * @example
-     * ```js
-     * const hex = SMath.toHex(10, 2); // '0A'
-     * ```
-     */
-    function toHex(n, length) {
-        if (length === void 0) { length = 0; }
-        return (n < 0 ? '-' : '') + (n < 0 ? -n : n).toString(16).padStart(length, '0').toUpperCase();
+    else if (Number.isNaN(left) && !Number.isNaN(right)) {
+        return right;
     }
-    SMath.toHex = toHex;
-})(SMath || (exports.SMath = SMath = {}));
+    else {
+        return NaN;
+    }
+}
+/**
+ * Take the derivative of a function.
+ * @param f Function `f(x)`
+ * @param x The x-value where to evaluate the derivative
+ * @param h Small step value
+ * @returns `f'(x)`
+ * @example
+ * ```js
+ * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
+ * ```
+ */
+function differentiate(f, x, h) {
+    if (h === void 0) { h = 1e-3; }
+    return (f(x + h) - f(x - h)) / (2 * h);
+}
+/**
+ * Compute the definite integral of a function.
+ * @param f Function `f(x)`
+ * @param a The miminum integral bound
+ * @param b The maximum integral bound
+ * @param Ndx The number of rectangles to compute
+ * @returns `F(b)-F(a)`
+ * @example
+ * ```js
+ * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
+ * ```
+ */
+function integrate(f, a, b, Ndx) {
+    if (Ndx === void 0) { Ndx = 1e3; }
+    return ((b - a) / Ndx) * sum(linspace(a, b, Ndx).map(function (x) { return f(x); }));
+}
+/**
+ * Convert an arbitrary decimal number into a simplified fraction (or ratio).
+ * See `mixed()` for instructions on how to break out the whole number part.
+ * @param n The decimal number to convert
+ * @param epsilon Maximum absolute error
+ * @returns An object containing the fraction's numerator and denominator
+ * @example
+ * ```js
+ * const frac = SMath.rat(0.625); // { num: 5, den: 8 }
+ * ```
+ */
+function rat(n, epsilon) {
+    if (epsilon === void 0) { epsilon = 1e-6; }
+    var num = 0, den = 1;
+    var sign = n < 0 ? -1 : 1;
+    while (!approx(sign * n, num / den, epsilon)) {
+        if (sign * n > num / den) {
+            num++;
+        }
+        else {
+            den++;
+        }
+    }
+    return { num: sign * num, den: den };
+}
+/**
+ * Convert an arbitrary decimal number into a simplified fraction, after
+ * breaking out the whole number part first. See `rat()` for keeping the
+ * number as a ratio without separating the whole number part.
+ * @param n A decimal number to convert
+ * @param epsilon Maximum absolute error
+ * @returns An object containing the whole part and fraction numerator and denominator
+ * @example
+ * ```js
+ * const frac = SMath.mixed(-8 / 6); // { whole: -1, num: 1, den: 3 }
+ * ```
+ */
+function mixed(n, epsilon) {
+    if (epsilon === void 0) { epsilon = 1e-6; }
+    return __assign({ whole: n | 0 }, rat(n < -1 ? (n | 0) - n : n - (n | 0), epsilon));
+}
+/**
+ * Convert any number to its hexadecimal equivalent.
+ * @param n A decimal number to convert
+ * @param length The minimum number of digits to show
+ * @returns The number `n` converted to hexadecimal
+ * @example
+ * ```js
+ * const hex = SMath.toHex(10, 2); // '0A'
+ * ```
+ */
+function toHex(n, length) {
+    if (length === void 0) { length = 0; }
+    return (n < 0 ? '-' : '') + (n < 0 ? -n : n).toString(16).padStart(length, '0').toUpperCase();
+}