smath 1.10.0 → 1.12.0

package/README.md

@@ -7,7 +7,7 @@ Small math? Simple math? Or supplemental math? Canonically, "SMath" is pronounce
 SMath is also packaged with an executabe that can be run directly through `npx` in the terminal - even outside of a NodeJS project! In fact, open your terminal now, and type the following to show a list of valid `npx smath` commands!
 
 ```shell
-npx smath
+npx smath help
 ```
 
 Commands are all structured like this.
@@ -21,3 +21,5 @@ This example command returns the value 0.4.
 ```shell
 npx smath normalize 4 0 10
 ```
+
+> Most `SMath` functions are available through `npx`, except for calculus functions which require a functional argument.

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 "use strict";
-var _a, _b;
+var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 var _1 = require(".");
 var func = ((_a = process.argv[2]) !== null && _a !== void 0 ? _a : '').toLowerCase(), nums = process.argv.slice(3).map(function (arg, i) {
@@ -19,14 +19,15 @@ if (func.includes('help')) {
     console.log('  help                     : Show this page');
     console.log('  approx <a> <b> [eps]     : Check if `a` and `b` are approximately equal');
     console.log('  clamp <n> <min> <max>    : Clamp `n` between `min` and `max`');
-    console.log('  expand <n> <min> <max>   : Expand normalized `n` between `min` and `max`');
-    console.log('  linspace <min> <max> <n> : Generate `n` linearly spaced numbers between `min` and `max`');
-    console.log('  logspace <min> <max> <n> : Generate `n` logarithmically spaced numbers between `min` and `max`');
     console.log('  normalize <n> <min> <max>: Normalize `n` between `min` and `max`');
+    console.log('  expand <n> <min> <max>   : Expand normalized `n` between `min` and `max`');
     console.log('  translate <n> <min1> <max1> <min2> <max2>');
     console.log('                           : Linearly interpolate `n` from `min1`, `max1` to `min2`, `max2`');
+    console.log('  linspace <min> <max> <n> : Generate `n` linearly spaced numbers between `min` and `max`');
+    console.log('  logspace <min> <max> <n> : Generate `n` logarithmically spaced numbers between `min` and `max`');
     console.log('  factorial <n>            : Compute `n!` (factorial)');
     console.log('  factors <n>              : List the prime factors of `n`');
+    console.log('  round2 <n> <base>        : Round `n` to a multiple of any `base`');
     console.log('  error <exp> <act>        : Calculate the normaized percent error between `exp` and `act`');
     console.log('  sum <c0> [c1] ... [cn]   : Compute a total of `n` numbers');
     console.log('  prod <c0> [c1] ... [cn]  : Compute a product of `n` numbers');
@@ -40,7 +41,8 @@ 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('  rseq <min> <max>         : Randomize a sequence of integers from `min` to `max`');
+    console.log('  rat <n> [eps]            : Decompose `n` into a ratio');
+    console.log('  mixed <n> [eps]          : Decompose `n` into a mixed number');
     process.exit(1);
 }
 switch (func) {
@@ -52,10 +54,18 @@ switch (func) {
         console.log(_1.SMath.clamp(nums[0], nums[1], nums[2]));
         break;
     }
+    case ('normalize'): {
+        console.log(_1.SMath.normalize(nums[0], nums[1], nums[2]));
+        break;
+    }
     case ('expand'): {
         console.log(_1.SMath.expand(nums[0], nums[1], nums[2]));
         break;
     }
+    case ('translate'): {
+        console.log(_1.SMath.translate(nums[0], nums[1], nums[2], nums[3], nums[4]));
+        break;
+    }
     case ('linspace'): {
         console.log(_1.SMath.linspace(nums[0], nums[1], nums[2]));
         break;
@@ -64,14 +74,6 @@ switch (func) {
         console.log(_1.SMath.logspace(nums[0], nums[1], nums[2]));
         break;
     }
-    case ('normalize'): {
-        console.log(_1.SMath.normalize(nums[0], nums[1], nums[2]));
-        break;
-    }
-    case ('translate'): {
-        console.log(_1.SMath.translate(nums[0], nums[1], nums[2], nums[3], nums[4]));
-        break;
-    }
     case ('factorial'): {
         console.log(_1.SMath.factorial(nums[0]));
         break;
@@ -80,6 +82,10 @@ switch (func) {
         console.log(_1.SMath.factors(nums[0]));
         break;
     }
+    case ('round2'): {
+        console.log(_1.SMath.round2(nums[0], nums[1]));
+        break;
+    }
     case ('error'): {
         console.log(_1.SMath.error(nums[0], nums[1]));
         break;
@@ -132,8 +138,12 @@ switch (func) {
         console.log(_1.SMath.rdist(nums[0], nums[1], nums[2]));
         break;
     }
-    case ('rseq'): {
-        console.log(_1.SMath.rseq(nums[0], nums[1]));
+    case ('rat'): {
+        console.log(_1.SMath.rat(nums[0], (_c = nums[1]) !== null && _c !== void 0 ? _c : 1e-6));
+        break;
+    }
+    case ('mixed'): {
+        console.log(_1.SMath.mixed(nums[0], (_d = nums[1]) !== null && _d !== void 0 ? _d : 1e-6));
         break;
     }
     case (''): {

package/dist/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SMath = void 0;
 /**
@@ -193,6 +204,21 @@ var SMath;
         return f;
     }
     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;
+    }
+    SMath.round2 = round2;
     /**
      * Calculate the relative normalized error or deviation from any
      * value to an accepted value. An error of 0 indicates that the
@@ -397,34 +423,13 @@ var SMath;
         return distribution;
     }
     SMath.rdist = rdist;
-    /**
-     * Randomize a sequence of integers from `min` to `max`.
-     * @param min The minimum integer in the randomized sequence
-     * @param max The maximum integer in the randomized sequence
-     * @returns A randomized sequence of integers from `min` to `max`
-     * @example
-     * ```js
-     * const sequence = SMath.rseq(-2, 2); // [ 2, 0, 1, -2, -1 ]
-     * ```
-     * @deprecated Use `SMath.shuffle()` instead
-     */
-    function rseq(min, max) {
-        min |= 0;
-        max |= 0;
-        max++;
-        var rawData = [];
-        for (var i = min; i < max; i++) {
-            rawData.push({ index: runif(-1, 1), value: i });
-        }
-        return rawData.sort(function (a, b) { return a.index - b.index; }).map(function (a) { return a.value; });
-    }
-    SMath.rseq = rseq;
     /**
      * 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) {
@@ -544,4 +549,46 @@ var SMath;
         return ((b - a) / Ndx) * sum(linspace(a, b, Ndx).map(function (x) { return f(x); }));
     }
     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 };
+    }
+    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));
+    }
+    SMath.mixed = mixed;
 })(SMath || (exports.SMath = SMath = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.10.0",
+  "version": "1.12.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": "22.10.1",
-    "t6": "1.1.8"
+    "@types/node": "22.10.5",
+    "t6": "1.1.9"
   }
 }

package/types/index.d.ts

@@ -120,6 +120,18 @@ export declare namespace SMath {
      * ```
      */
     function factors(n: number): Array<number>;
+    /**
+     * 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: number, base: number): number;
     /**
      * Calculate the relative normalized error or deviation from any
      * value to an accepted value. An error of 0 indicates that the
@@ -263,24 +275,13 @@ export declare namespace SMath {
      * ```
      */
     function rdist(count: number, mean?: number, stdev?: number): Array<number>;
-    /**
-     * Randomize a sequence of integers from `min` to `max`.
-     * @param min The minimum integer in the randomized sequence
-     * @param max The maximum integer in the randomized sequence
-     * @returns A randomized sequence of integers from `min` to `max`
-     * @example
-     * ```js
-     * const sequence = SMath.rseq(-2, 2); // [ 2, 0, 1, -2, -1 ]
-     * ```
-     * @deprecated Use `SMath.shuffle()` instead
-     */
-    function rseq(min: number, max: number): Array<number>;
     /**
      * 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<T>(stack: Array<T>): Array<T>;
@@ -323,4 +324,36 @@ export declare namespace SMath {
      * ```
      */
     function integrate(f: (x: number) => number, a: number, b: number, Ndx?: number): number;
+    /**
+     * 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: number, epsilon?: number): {
+        num: number;
+        den: number;
+    };
+    /**
+     * 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: number, epsilon?: number): {
+        whole: number;
+        num: number;
+        den: number;
+    };
 }