smath 1.6.1 → 1.7.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/1711574450)
+![Relative date](https://img.shields.io/date/1712351152)
 ![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.1
+npm i smath@1.7.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

@@ -251,7 +251,7 @@ var SMath = /** @class */ (function () {
      * ```
      */
     SMath.median = function (data) {
-        data.sort();
+        data.sort(function (a, b) { return a - b; });
         if (data.length % 2) {
             return data[(data.length - 1) / 2];
         }
@@ -307,6 +307,75 @@ var SMath = /** @class */ (function () {
     SMath.stdevs = function (data) {
         return Math.sqrt(this.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...
+     * ```
+     */
+    SMath.runif = function (min, max) {
+        return this.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
+     * ```
+     */
+    SMath.rint = function (min, max) {
+        min |= 0;
+        max |= 0;
+        if (min < 0) {
+            min--;
+        }
+        if (max < 0) {
+            max--;
+        }
+        return this.runif(min, max + 1) | 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...
+     * ```
+     */
+    SMath.rnorm = function (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... ]
+     * ```
+     */
+    SMath.rdist = function (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] = this.rnorm(mean, stdev);
+        }
+        return distribution;
+    };
     /**
      * Take the limit of a function. A return value of `NaN` indicates
      * that no limit exists either due to a discontinuity or imaginary value.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/smath",
   "bin": "dist/bin.js",
@@ -28,6 +28,16 @@
     "avg",
     "average",
     "mean",
+    "calculus",
+    "statistics",
+    "numeric",
+    "numerical",
+    "analysis",
+    "random",
+    "distribution",
+    "population",
+    "normal",
+    "normalize",
     "interpolate",
     "interpolation",
     "extrapolate",
@@ -47,9 +57,9 @@
   "repository": "github:nicfv/npm",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "20.11.30",
-    "exray": "1.0.2",
+    "@types/node": "20.12.4",
+    "exray": "1.0.3",
     "typedoc": "0.25.12",
-    "typescript": "5.4.3"
+    "typescript": "5.4.4"
   }
 }

package/types/index.d.ts

@@ -218,6 +218,51 @@ export declare abstract class SMath {
      * ```
      */
     static 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...
+     * ```
+     */
+    static 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
+     * ```
+     */
+    static 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...
+     * ```
+     */
+    static 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... ]
+     * ```
+     */
+    static 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.