smath 1.6.2 → 1.8.0

package/README.md

@@ -2,7 +2,7 @@
 
 ![NPM Downloads](https://img.shields.io/npm/dt/smath)
 ![NPM Version](https://img.shields.io/npm/v/smath)
-![Relative date](https://img.shields.io/date/1712342048)
+![Relative date](https://img.shields.io/date/1712851398)
 ![GitHub watchers](https://img.shields.io/github/watchers/nicfv/npm)
 ![GitHub forks](https://img.shields.io/github/forks/nicfv/npm)
 ![GitHub Repo stars](https://img.shields.io/github/stars/nicfv/npm)
@@ -12,7 +12,7 @@
 smath can be installed from the official [npm package repository](https://www.npmjs.com/package/smath). It is highly recommended to install the latest version, which is installed by default with the following command.
 
 ```shell
-npm i smath@1.6.2
+npm i smath@1.8.0
 ```
 
 ## Bugs and Requests

package/dist/bin.js

@@ -36,6 +36,10 @@ if (func.includes('help')) {
     console.log('  vars <c0> [c1] ... [cn]  : Compute the sample variance of `n` numbers');
     console.log('  stdevp <c0> [c1] ... [cn]: Compute the population standard deviation of `n` numbers');
     console.log('  stdevs <c0> [c1] ... [cn]: Compute the sample standard deviation of `n` numbers');
+    console.log('  runif <min> <max>        : Generate a uniformly-distributed random float');
+    console.log('  rint <min> <max>         : Generate a uniformly-distributed random integer, range inclusive');
+    console.log('  rnorm [mean] [stdev]     : Generate a normally-distributed random float');
+    console.log('  rdist <n> [mean] [stdev] : Generate `n` normally-distributed random floats');
     process.exit(1);
 }
 switch (func) {
@@ -111,6 +115,22 @@ switch (func) {
         console.log(_1.SMath.stdevs(nums));
         break;
     }
+    case ('runif'): {
+        console.log(_1.SMath.runif(nums[0], nums[1]));
+        break;
+    }
+    case ('rint'): {
+        console.log(_1.SMath.rint(nums[0], nums[1]));
+        break;
+    }
+    case ('rnorm'): {
+        console.log(_1.SMath.rnorm(nums[0], nums[1]));
+        break;
+    }
+    case ('rdist'): {
+        console.log(_1.SMath.rdist(nums[0], nums[1], nums[2]));
+        break;
+    }
     case (''): {
         console.error('Missing argument. Use with "help" for a list of commands.');
         process.exit(1);

package/dist/index.js

@@ -11,9 +11,8 @@ exports.SMath = void 0;
  * Contains a small math function library including
  * useful interpolation and extrapolation functions.
  */
-var SMath = /** @class */ (function () {
-    function SMath() {
-    }
+var SMath;
+(function (SMath) {
     /**
      * Check if two numbers are approximately equal with a maximum abolute error.
      * @param a Any number
@@ -26,10 +25,11 @@ var SMath = /** @class */ (function () {
      *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
      * ```
      */
-    SMath.approx = function (a, b, epsilon) {
+    function approx(a, b, epsilon) {
         if (epsilon === void 0) { epsilon = 1e-6; }
         return a - b < epsilon && b - a < epsilon;
-    };
+    }
+    SMath.approx = approx;
     /**
      * Clamp a number within a range.
      * @param n The number to clamp
@@ -42,7 +42,7 @@ var SMath = /** @class */ (function () {
      *       n2 = SMath.clamp(-2, 0, 10); // 0
      * ```
      */
-    SMath.clamp = function (n, min, max) {
+    function clamp(n, min, max) {
         if (n < min) {
             return min;
         }
@@ -50,7 +50,8 @@ var SMath = /** @class */ (function () {
             return max;
         }
         return n;
-    };
+    }
+    SMath.clamp = clamp;
     /**
      * Normalize the number `n` from the range `min, max` to the range `0, 1`
      * @param n The number to normalize
@@ -62,12 +63,13 @@ var SMath = /** @class */ (function () {
      * const y = SMath.normalize(18, 9, 99); // 0.1
      * ```
      */
-    SMath.normalize = function (n, min, max) {
+    function normalize(n, min, max) {
         if (min === max) {
             return 0;
         }
         return (n - min) / (max - min);
-    };
+    }
+    SMath.normalize = normalize;
     /**
      * Expand a normalized number `n` to the range `min, max`
      * @param n A normalized number
@@ -79,9 +81,10 @@ var SMath = /** @class */ (function () {
      * const y = SMath.expand(0.25, 4, 6); // 4.5
      * ```
      */
-    SMath.expand = function (n, min, max) {
+    function expand(n, min, max) {
         return (max - min) * n + min;
-    };
+    }
+    SMath.expand = expand;
     /**
      * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
      * @param n The number to translate
@@ -96,9 +99,10 @@ var SMath = /** @class */ (function () {
      *       F = SMath.translate(C, 0, 100, 32, 212); // 68
      * ```
      */
-    SMath.translate = function (n, min1, max1, min2, max2) {
-        return this.expand(this.normalize(n, min1, max1), min2, max2);
-    };
+    function translate(n, min1, max1, min2, max2) {
+        return expand(normalize(n, min1, max1), min2, max2);
+    }
+    SMath.translate = translate;
     /**
      * Generate an array of linearly spaced numbers.
      * @param min The initial value of the linear space
@@ -111,13 +115,14 @@ var SMath = /** @class */ (function () {
      * // [ 1, 1.8, 2.6, 3.4, 4.2, 5 ]
      * ```
      */
-    SMath.linspace = function (min, max, count) {
+    function linspace(min, max, count) {
         var space = [];
         for (var i = 0; i < count; i++) {
-            space[i] = this.translate(i, 0, count - 1, min, max);
+            space[i] = translate(i, 0, count - 1, min, max);
         }
         return space;
-    };
+    }
+    SMath.linspace = linspace;
     /**
      * Generate an array of logarithmically spaced numbers.
      * @param min The initial magnitude of the space
@@ -130,9 +135,10 @@ var SMath = /** @class */ (function () {
      * // [ 1, 3.2, 10, 31.6, 100 ]
      * ```
      */
-    SMath.logspace = function (min, max, count) {
-        return this.linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
-    };
+    function logspace(min, max, count) {
+        return linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
+    }
+    SMath.logspace = logspace;
     /**
      * Compute the factorial of `n`.
      * @param n Any positive integer
@@ -142,7 +148,7 @@ var SMath = /** @class */ (function () {
      * const y = SMath.factorial(5); // 120
      * ```
      */
-    SMath.factorial = function (n) {
+    function factorial(n) {
         if (n < 0 || (n | 0) !== n) {
             throw new Error('Input must be a positive integer.');
         }
@@ -153,9 +159,10 @@ var SMath = /** @class */ (function () {
             return n;
         }
         else {
-            return n * this.factorial(n - 1);
+            return n * factorial(n - 1);
         }
-    };
+    }
+    SMath.factorial = factorial;
     /**
      * Factorize `n` into its prime factors.
      * @param n Any positive integer
@@ -165,7 +172,7 @@ var SMath = /** @class */ (function () {
      * const y = SMath.factors(12); // [ 2, 2, 3 ]
      * ```
      */
-    SMath.factors = function (n) {
+    function factors(n) {
         if (n < 0 || (n | 0) !== n) {
             throw new Error('Input must be a positive integer!');
         }
@@ -184,7 +191,8 @@ var SMath = /** @class */ (function () {
             }
         }
         return f;
-    };
+    }
+    SMath.factors = factors;
     /**
      * Calculate the relative normalized error or deviation from any
      * value to an accepted value. An error of 0 indicates that the
@@ -200,9 +208,10 @@ var SMath = /** @class */ (function () {
      * const e = SMath.error(22.5, 25); // -0.1
      * ```
      */
-    SMath.error = function (experimental, actual) {
+    function error(experimental, actual) {
         return (experimental - actual) / actual;
-    };
+    }
+    SMath.error = error;
     /**
      * Add up all the inputs.
      * If none are present, returns 0.
@@ -213,9 +222,10 @@ var SMath = /** @class */ (function () {
      * const y = SMath.sum([1, 2, 3]); // 6
      * ```
      */
-    SMath.sum = function (data) {
+    function sum(data) {
         return data.reduce(function (a, b) { return a + b; }, 0);
-    };
+    }
+    SMath.sum = sum;
     /**
      * Multiply all the inputs.
      * If none are present, returns 1.
@@ -226,9 +236,10 @@ var SMath = /** @class */ (function () {
      * const y = SMath.prod([2, 2, 3, 5]); // 60
      * ```
      */
-    SMath.prod = function (data) {
+    function prod(data) {
         return data.reduce(function (a, b) { return a * b; }, 1);
-    };
+    }
+    SMath.prod = prod;
     /**
      * Compute the average, or mean, of a set of numbers.
      * @param data An array of numeric inputs
@@ -238,9 +249,10 @@ var SMath = /** @class */ (function () {
      * const y = SMath.avg([1, 2, 4, 4]); // 2.75
      * ```
      */
-    SMath.avg = function (data) {
-        return this.sum(data) / data.length;
-    };
+    function avg(data) {
+        return sum(data) / data.length;
+    }
+    SMath.avg = avg;
     /**
      * Compute the median of a set of numbers.
      * @param data An array of numeric inputs
@@ -250,13 +262,14 @@ var SMath = /** @class */ (function () {
      * const y = SMath.median([2, 5, 3, 1]); // 2.5
      * ```
      */
-    SMath.median = function (data) {
+    function median(data) {
         data.sort(function (a, b) { return a - b; });
         if (data.length % 2) {
             return data[(data.length - 1) / 2];
         }
-        return this.avg([data[data.length / 2 - 1], data[data.length / 2]]);
-    };
+        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
@@ -266,10 +279,11 @@ var SMath = /** @class */ (function () {
      * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
      * ```
      */
-    SMath.varp = function (data) {
-        var mean = this.avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
-        return this.sum(squares) / data.length;
-    };
+    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
@@ -279,10 +293,11 @@ var SMath = /** @class */ (function () {
      * const y = SMath.vars([1, 2, 4, 4]); // 2.25
      * ```
      */
-    SMath.vars = function (data) {
-        var mean = this.avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
-        return this.sum(squares) / (data.length - 1);
-    };
+    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
@@ -292,9 +307,10 @@ var SMath = /** @class */ (function () {
      * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
      * ```
      */
-    SMath.stdevp = function (data) {
-        return Math.sqrt(this.varp(data));
-    };
+    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
@@ -304,9 +320,83 @@ var SMath = /** @class */ (function () {
      * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
      * ```
      */
-    SMath.stdevs = function (data) {
-        return Math.sqrt(this.vars(data));
-    };
+    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--;
+        }
+        if (max < 0) {
+            max--;
+        }
+        return runif(min, max + 1) | 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());
+    }
+    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;
     /**
      * Take the limit of a function. A return value of `NaN` indicates
      * that no limit exists either due to a discontinuity or imaginary value.
@@ -320,7 +410,7 @@ var SMath = /** @class */ (function () {
      * const y = SMath.lim(Math.log, 0); // -Infinity
      * ```
      */
-    SMath.lim = function (f, x, h, discontinuity_cutoff) {
+    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);
@@ -337,7 +427,7 @@ var SMath = /** @class */ (function () {
                 left = -Infinity;
             }
             else {
-                left = this.avg([left1, left2]);
+                left = avg([left1, left2]);
             }
         }
         else if (left1 === left2) { // Handles +/-Infinity case
@@ -355,7 +445,7 @@ var SMath = /** @class */ (function () {
                 right = -Infinity;
             }
             else {
-                right = this.avg([right1, right2]);
+                right = avg([right1, right2]);
             }
         }
         else if (right1 === right2) { // Handles +/-Infinity case
@@ -369,7 +459,7 @@ var SMath = /** @class */ (function () {
             return left;
         }
         else if (SMath.approx(left, right, discontinuity_cutoff)) {
-            return this.avg([left, right]);
+            return avg([left, right]);
         }
         else if (!Number.isNaN(left) && Number.isNaN(right)) {
             return left;
@@ -380,7 +470,8 @@ var SMath = /** @class */ (function () {
         else {
             return NaN;
         }
-    };
+    }
+    SMath.lim = lim;
     /**
      * Take the derivative of a function.
      * @param f Function `f(x)`
@@ -392,10 +483,11 @@ var SMath = /** @class */ (function () {
      * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
      * ```
      */
-    SMath.differentiate = function (f, x, h) {
+    function differentiate(f, x, h) {
         if (h === void 0) { h = 1e-3; }
         return (f(x + h) - f(x - h)) / (2 * h);
-    };
+    }
+    SMath.differentiate = differentiate;
     /**
      * Compute the definite integral of a function.
      * @param f Function `f(x)`
@@ -408,10 +500,9 @@ var SMath = /** @class */ (function () {
      * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
      * ```
      */
-    SMath.integrate = function (f, a, b, Ndx) {
+    function integrate(f, a, b, Ndx) {
         if (Ndx === void 0) { Ndx = 1e3; }
-        return ((b - a) / Ndx) * this.sum(this.linspace(a, b, Ndx).map(function (x) { return f(x); }));
-    };
-    return SMath;
-}());
-exports.SMath = SMath;
+        return ((b - a) / Ndx) * sum(linspace(a, b, Ndx).map(function (x) { return f(x); }));
+    }
+    SMath.integrate = integrate;
+})(SMath || (exports.SMath = SMath = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.6.2",
+  "version": "1.8.0",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/smath",
   "bin": "dist/bin.js",
@@ -14,7 +14,7 @@
     "build": "rm -rf dist types && tsc && node dist/test.js && rm dist/test.js",
     "test": "tsc --noEmit",
     "clean": "rm -rf node_modules package-lock.json dist types docs",
-    "docs": "rm -rf docs && typedoc --includeVersion --disableSources --hideGenerator src",
+    "docs": "rm -rf docs && typedoc --includeVersion --disableSources --hideGenerator --excludePrivate --excludeProtected src",
     "prepack": "npm run build",
     "postpack": "rm -rf dist types"
   },
@@ -33,6 +33,11 @@
     "numeric",
     "numerical",
     "analysis",
+    "random",
+    "distribution",
+    "population",
+    "normal",
+    "normalize",
     "interpolate",
     "interpolation",
     "extrapolate",
@@ -52,9 +57,9 @@
   "repository": "github:nicfv/npm",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "20.12.4",
-    "exray": "1.0.2",
-    "typedoc": "0.25.12",
-    "typescript": "5.4.4"
+    "@types/node": "20.12.7",
+    "exray": "1.0.3",
+    "typedoc": "0.25.13",
+    "typescript": "5.4.5"
   }
 }

package/types/index.d.ts

@@ -8,7 +8,7 @@
  * Contains a small math function library including
  * useful interpolation and extrapolation functions.
  */
-export declare abstract class SMath {
+export declare namespace SMath {
     /**
      * Check if two numbers are approximately equal with a maximum abolute error.
      * @param a Any number
@@ -21,7 +21,7 @@ export declare abstract class SMath {
      *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
      * ```
      */
-    static approx(a: number, b: number, epsilon?: number): boolean;
+    function approx(a: number, b: number, epsilon?: number): boolean;
     /**
      * Clamp a number within a range.
      * @param n The number to clamp
@@ -34,7 +34,7 @@ export declare abstract class SMath {
      *       n2 = SMath.clamp(-2, 0, 10); // 0
      * ```
      */
-    static clamp(n: number, min: number, max: number): number;
+    function clamp(n: number, min: number, max: number): number;
     /**
      * Normalize the number `n` from the range `min, max` to the range `0, 1`
      * @param n The number to normalize
@@ -46,7 +46,7 @@ export declare abstract class SMath {
      * const y = SMath.normalize(18, 9, 99); // 0.1
      * ```
      */
-    static normalize(n: number, min: number, max: number): number;
+    function normalize(n: number, min: number, max: number): number;
     /**
      * Expand a normalized number `n` to the range `min, max`
      * @param n A normalized number
@@ -58,7 +58,7 @@ export declare abstract class SMath {
      * const y = SMath.expand(0.25, 4, 6); // 4.5
      * ```
      */
-    static expand(n: number, min: number, max: number): number;
+    function expand(n: number, min: number, max: number): number;
     /**
      * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
      * @param n The number to translate
@@ -73,7 +73,7 @@ export declare abstract class SMath {
      *       F = SMath.translate(C, 0, 100, 32, 212); // 68
      * ```
      */
-    static translate(n: number, min1: number, max1: number, min2: number, max2: number): number;
+    function translate(n: number, min1: number, max1: number, min2: number, max2: number): number;
     /**
      * Generate an array of linearly spaced numbers.
      * @param min The initial value of the linear space
@@ -86,7 +86,7 @@ export declare abstract class SMath {
      * // [ 1, 1.8, 2.6, 3.4, 4.2, 5 ]
      * ```
      */
-    static linspace(min: number, max: number, count: number): Array<number>;
+    function linspace(min: number, max: number, count: number): Array<number>;
     /**
      * Generate an array of logarithmically spaced numbers.
      * @param min The initial magnitude of the space
@@ -99,7 +99,7 @@ export declare abstract class SMath {
      * // [ 1, 3.2, 10, 31.6, 100 ]
      * ```
      */
-    static logspace(min: number, max: number, count: number): Array<number>;
+    function logspace(min: number, max: number, count: number): Array<number>;
     /**
      * Compute the factorial of `n`.
      * @param n Any positive integer
@@ -109,7 +109,7 @@ export declare abstract class SMath {
      * const y = SMath.factorial(5); // 120
      * ```
      */
-    static factorial(n: number): number;
+    function factorial(n: number): number;
     /**
      * Factorize `n` into its prime factors.
      * @param n Any positive integer
@@ -119,7 +119,7 @@ export declare abstract class SMath {
      * const y = SMath.factors(12); // [ 2, 2, 3 ]
      * ```
      */
-    static factors(n: number): Array<number>;
+    function factors(n: number): Array<number>;
     /**
      * Calculate the relative normalized error or deviation from any
      * value to an accepted value. An error of 0 indicates that the
@@ -135,7 +135,7 @@ export declare abstract class SMath {
      * const e = SMath.error(22.5, 25); // -0.1
      * ```
      */
-    static error(experimental: number, actual: number): number;
+    function error(experimental: number, actual: number): number;
     /**
      * Add up all the inputs.
      * If none are present, returns 0.
@@ -146,7 +146,7 @@ export declare abstract class SMath {
      * const y = SMath.sum([1, 2, 3]); // 6
      * ```
      */
-    static sum(data: Array<number>): number;
+    function sum(data: Array<number>): number;
     /**
      * Multiply all the inputs.
      * If none are present, returns 1.
@@ -157,7 +157,7 @@ export declare abstract class SMath {
      * const y = SMath.prod([2, 2, 3, 5]); // 60
      * ```
      */
-    static prod(data: Array<number>): number;
+    function prod(data: Array<number>): number;
     /**
      * Compute the average, or mean, of a set of numbers.
      * @param data An array of numeric inputs
@@ -167,7 +167,7 @@ export declare abstract class SMath {
      * const y = SMath.avg([1, 2, 4, 4]); // 2.75
      * ```
      */
-    static avg(data: Array<number>): number;
+    function avg(data: Array<number>): number;
     /**
      * Compute the median of a set of numbers.
      * @param data An array of numeric inputs
@@ -177,7 +177,7 @@ export declare abstract class SMath {
      * const y = SMath.median([2, 5, 3, 1]); // 2.5
      * ```
      */
-    static median(data: Array<number>): number;
+    function median(data: Array<number>): number;
     /**
      * Compute the variance of a **complete population**.
      * @param data An array of numeric inputs
@@ -187,7 +187,7 @@ export declare abstract class SMath {
      * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
      * ```
      */
-    static varp(data: Array<number>): number;
+    function varp(data: Array<number>): number;
     /**
      * Compute the variance of a **sample**.
      * @param data An array of numeric inputs
@@ -197,7 +197,7 @@ export declare abstract class SMath {
      * const y = SMath.vars([1, 2, 4, 4]); // 2.25
      * ```
      */
-    static vars(data: Array<number>): number;
+    function vars(data: Array<number>): number;
     /**
      * Compute the standard deviation of a **complete population**.
      * @param data An array of numeric inputs
@@ -207,7 +207,7 @@ export declare abstract class SMath {
      * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
      * ```
      */
-    static stdevp(data: Array<number>): number;
+    function stdevp(data: Array<number>): number;
     /**
      * Compute the standard deviation of a **sample**.
      * @param data An array of numeric inputs
@@ -217,7 +217,52 @@ export declare abstract class SMath {
      * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
      * ```
      */
-    static stdevs(data: Array<number>): number;
+    function stdevs(data: Array<number>): number;
+    /**
+     * 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: number, max: number): number;
+    /**
+     * 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: number, max: number): number;
+    /**
+     * 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?: number, stdev?: number): number;
+    /**
+     * 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: number, mean?: number, stdev?: number): Array<number>;
     /**
      * Take the limit of a function. A return value of `NaN` indicates
      * that no limit exists either due to a discontinuity or imaginary value.
@@ -231,7 +276,7 @@ export declare abstract class SMath {
      * const y = SMath.lim(Math.log, 0); // -Infinity
      * ```
      */
-    static lim(f: (x: number) => number, x: number, h?: number, discontinuity_cutoff?: number): number;
+    function lim(f: (x: number) => number, x: number, h?: number, discontinuity_cutoff?: number): number;
     /**
      * Take the derivative of a function.
      * @param f Function `f(x)`
@@ -243,7 +288,7 @@ export declare abstract class SMath {
      * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
      * ```
      */
-    static differentiate(f: (x: number) => number, x: number, h?: number): number;
+    function differentiate(f: (x: number) => number, x: number, h?: number): number;
     /**
      * Compute the definite integral of a function.
      * @param f Function `f(x)`
@@ -256,5 +301,5 @@ export declare abstract class SMath {
      * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
      * ```
      */
-    static integrate(f: (x: number) => number, a: number, b: number, Ndx?: number): number;
+    function integrate(f: (x: number) => number, a: number, b: number, Ndx?: number): number;
 }