smath 1.14.0 → 1.15.0

package/dist/bin.js

@@ -41,9 +41,14 @@ if (func.includes('help')) {
     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');
+    console.log('  shuffle <c0> [c1] ... [cn]');
+    console.log('                           : Shuffle an array of arbirary elements');
+    console.log('  selectRandom <c0> [c1] ... [cn]');
+    console.log('                           : Select a number at random from a list');
+    console.log('  selectRandomWeighted <c0> [c1] ... [cn]');
+    console.log('                           : Select an index at random from a list of weights');
     console.log('  rat <n> [eps]            : Decompose `n` into a ratio');
     console.log('  mixed <n> [eps]          : Decompose `n` into a mixed number');
-    console.log('  toHex <n> [length]       : Convert decimal `n` into hexadecimal');
     process.exit(1);
 }
 switch (func) {
@@ -139,6 +144,18 @@ switch (func) {
         console.log(SMath.rdist(nums[0], nums[1], nums[2]));
         break;
     }
+    case ('shuffle'): {
+        console.log(SMath.shuffle(nums));
+        break;
+    }
+    case ('selectRandom'): {
+        console.log(SMath.selectRandom(nums));
+        break;
+    }
+    case ('selectRandomWeighted'): {
+        console.log(SMath.selectRandomWeighted(nums));
+        break;
+    }
     case ('rat'): {
         console.log(SMath.rat(nums[0], (_c = nums[1]) !== null && _c !== void 0 ? _c : 1e-6));
         break;

package/dist/index.js

@@ -35,6 +35,8 @@ exports.rint = rint;
 exports.rnorm = rnorm;
 exports.rdist = rdist;
 exports.shuffle = shuffle;
+exports.selectRandom = selectRandom;
+exports.selectRandomWeighted = selectRandomWeighted;
 exports.lim = lim;
 exports.differentiate = differentiate;
 exports.integrate = integrate;
@@ -228,7 +230,12 @@ function round2(n, base) {
  * const e = SMath.error(22.5, 25); // -0.1
  */
 function error(experimental, actual) {
-    return (experimental - actual) / actual;
+    if (experimental === 0 && actual === 0) {
+        return 0;
+    }
+    else {
+        return (experimental - actual) / actual;
+    }
 }
 /**
  * Add up all the inputs.
@@ -394,6 +401,32 @@ function shuffle(stack) {
     }
     return rawData.sort(function (a, b) { return a.index - b.index; }).map(function (a) { return a.value; });
 }
+/**
+ * Select a single item from an array at random with uniform weights.
+ * @param stack An array of arbirary item
+ * @returns A single randomly selected item
+ * @example
+ * const selected = SMath.selectRandom([10, 20, 30, 40]); // 30
+ */
+function selectRandom(stack) {
+    return stack[rint(0, stack.length - 1)];
+}
+/**
+ * Select a single index in an array at random with different weights.
+ * @param weights The weights for each item
+ * @returns The index of the randomly selected item
+ */
+function selectRandomWeighted(weights) {
+    var startWeights = [];
+    var accumulation = 0;
+    for (var _i = 0, weights_1 = weights; _i < weights_1.length; _i++) {
+        var weight = weights_1[_i];
+        accumulation += clamp(0, weight, Infinity);
+        startWeights.push(accumulation);
+    }
+    var random = runif(0, accumulation);
+    return startWeights.findIndex(function (weight) { return random < weight; });
+}
 /**
  * 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.14.0",
+  "version": "1.15.0",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/",
   "bin": "dist/bin.js",

package/types/index.d.ts

@@ -233,6 +233,20 @@ export declare function rdist(count: number, mean?: number, stdev?: number): num
  * const shuffled = SMath.shuffle(['a', 'b', 'c']); // [ 'c', 'a', 'b' ]
  */
 export declare function shuffle<T>(stack: T[]): T[];
+/**
+ * Select a single item from an array at random with uniform weights.
+ * @param stack An array of arbirary item
+ * @returns A single randomly selected item
+ * @example
+ * const selected = SMath.selectRandom([10, 20, 30, 40]); // 30
+ */
+export declare function selectRandom<T>(stack: T[]): T;
+/**
+ * Select a single index in an array at random with different weights.
+ * @param weights The weights for each item
+ * @returns The index of the randomly selected item
+ */
+export declare function selectRandomWeighted(weights: number[]): 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.