smath 1.13.3 → 1.15.0

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 "use strict";
-var _a, _b, _c, _d, _e;
+var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 var SMath = require(".");
 var func = ((_a = process.argv[2]) !== null && _a !== void 0 ? _a : '').toLowerCase(), nums = process.argv.slice(3).map(function (arg, i) {
@@ -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;
@@ -147,11 +164,6 @@ switch (func) {
         console.log(SMath.mixed(nums[0], (_d = nums[1]) !== null && _d !== void 0 ? _d : 1e-6));
         break;
     }
-    case ('tohex'): {
-        console.warn('toHex() is deprecated!');
-        console.log(SMath.toHex(nums[0], (_e = nums[1]) !== null && _e !== void 0 ? _e : 0));
-        break;
-    }
     case (''): {
         console.error('Missing argument. Use with "help" for a list of commands.');
         process.exit(1);

package/dist/index.js

@@ -35,12 +35,13 @@ 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;
 exports.rat = rat;
 exports.mixed = mixed;
-exports.toHex = toHex;
 /**
  * @packageDocumentation
  * Small math function library
@@ -229,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.
@@ -395,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.
@@ -407,8 +439,8 @@ function shuffle(stack) {
  * 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; }
+    if (h === void 0) { h = 1e-6; }
+    if (discontinuity_cutoff === void 0) { discontinuity_cutoff = 1e-3; }
     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)) {
@@ -416,46 +448,46 @@ function lim(f, x, h, discontinuity_cutoff) {
     }
     // Check the limit approaching from the left
     if (Number.isFinite(left1) && Number.isFinite(left2)) {
-        if (left2 > left1 + 2 * h) {
-            left = Infinity;
+        if (approx(left1, left2, discontinuity_cutoff)) {
+            left = left2; // Converges
+        }
+        else if (left1 > 0 && left2 > left1) {
+            left = Infinity; // Diverges to +inf
         }
-        else if (left2 < left1 - 2 * h) {
-            left = -Infinity;
+        else if (left1 < 0 && left2 < left1) {
+            left = -Infinity; // Diverges to -inf
         }
         else {
-            left = avg([left1, left2]);
+            left = NaN; // Diverges
         }
     }
-    else if (left1 === left2) { // Handles +/-Infinity case
-        left = left1;
-    }
     else {
-        left = NaN;
+        left = NaN; // Discontinuous
     }
     // Check the limit approaching from the right
     if (Number.isFinite(right1) && Number.isFinite(right2)) {
-        if (right2 > right1 + 2 * h) {
-            right = Infinity;
+        if (approx(right1, right2, discontinuity_cutoff)) {
+            right = right2; // Converges
         }
-        else if (right2 < right1 - 2 * h) {
-            right = -Infinity;
+        else if (right1 > 0 && right2 > right1) {
+            right = Infinity; // Diverges to +inf
+        }
+        else if (right1 < 0 && right2 < right1) {
+            right = -Infinity; // Diverges to -inf
         }
         else {
-            right = avg([right1, right2]);
+            right = NaN; // Diverges
         }
     }
-    else if (right1 === right2) { // Handles +/-Infinity case
-        right = right1;
-    }
     else {
-        right = NaN;
+        right = NaN; // Discontinuous
     }
     // 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]);
+    else if (Number.isNaN(left) && Number.isNaN(right)) {
+        return center;
     }
     else if (!Number.isNaN(left) && Number.isNaN(right)) {
         return left;
@@ -463,6 +495,9 @@ function lim(f, x, h, discontinuity_cutoff) {
     else if (Number.isNaN(left) && !Number.isNaN(right)) {
         return right;
     }
+    else if (approx(left, right, discontinuity_cutoff)) {
+        return avg([left, right]);
+    }
     else {
         return NaN;
     }
@@ -471,14 +506,14 @@ function lim(f, x, h, discontinuity_cutoff) {
  * 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
+ * @param epsilon Small step value
  * @returns `f'(x)`
  * @example
  * 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);
+function differentiate(f, x, epsilon) {
+    if (epsilon === void 0) { epsilon = 1e-6; }
+    return lim(function (h) { return (f(x + h) - f(x - h)) / (2 * h); }, 0, epsilon);
 }
 /**
  * Compute the definite integral of a function.
@@ -491,7 +526,7 @@ function differentiate(f, x, h) {
  * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
  */
 function integrate(f, a, b, Ndx) {
-    if (Ndx === void 0) { Ndx = 1e3; }
+    if (Ndx === void 0) { Ndx = 1e6; }
     return ((b - a) / Ndx) * sum(linspace(a, b, Ndx).map(function (x) { return f(x); }));
 }
 /**
@@ -531,16 +566,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
- * const hex = SMath.toHex(10, 2); // '0A'
- * @deprecated Use native `number.toString(16)`
- */
-function toHex(n, length) {
-    if (length === void 0) { length = 0; }
-    return (n < 0 ? '-' : '') + (n < 0 ? -n : n).toString(16).padStart(length, '0').toUpperCase();
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.13.3",
+  "version": "1.15.0",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/",
   "bin": "dist/bin.js",
@@ -52,7 +52,7 @@
   "repository": "github:nicfv/npm",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "24.3.0",
+    "@types/node": "25.0.10",
     "t6": "1.2.1"
   }
 }

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.
@@ -249,12 +263,12 @@ export declare function lim(f: (x: number) => number, x: number, h?: number, dis
  * 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
+ * @param epsilon Small step value
  * @returns `f'(x)`
  * @example
  * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
  */
-export declare function differentiate(f: (x: number) => number, x: number, h?: number): number;
+export declare function differentiate(f: (x: number) => number, x: number, epsilon?: number): number;
 /**
  * Compute the definite integral of a function.
  * @param f Function `f(x)`
@@ -294,13 +308,3 @@ export declare function mixed(n: number, epsilon?: number): {
     num: number;
     den: number;
 };
-/**
- * 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
- * const hex = SMath.toHex(10, 2); // '0A'
- * @deprecated Use native `number.toString(16)`
- */
-export declare function toHex(n: number, length?: number): string;