smath 1.4.0 → 1.5.1

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/1711423325)
+![Relative date](https://img.shields.io/date/1711486263)
 ![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.4.0
+npm i smath@1.5.1
 ```
 
 ## Bugs and Requests

package/dist/bin.js

@@ -1,98 +1,112 @@
 #!/usr/bin/env node
 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 var _1 = require(".");
-var args = process.argv.slice(2);
-/**
- * Try to convert an argument into a numeric value.
- */
-function N(index, defaultVal) {
-    if (defaultVal === void 0) { defaultVal = NaN; }
-    if (index >= args.length) {
-        if (Number.isFinite(defaultVal)) {
-            return defaultVal;
-        }
-        else {
-            console.error('Required argument ' + index + ' is missing!');
-            process.exit(1);
-        }
-    }
-    var arg = Number.parseFloat(args[index]);
-    if (Number.isFinite(arg)) {
-        return arg;
-    }
-    else if (Number.isFinite(defaultVal)) {
-        return defaultVal;
+var func = ((_a = process.argv[2]) !== null && _a !== void 0 ? _a : '').toLowerCase(), nums = process.argv.slice(3).map(function (arg, i) {
+    var num = Number.parseFloat(arg);
+    if (Number.isFinite(num)) {
+        return num;
     }
     else {
-        console.error('Argument #' + index + ' is ' + arg + ' but a number was expected.');
+        console.error('Argument #' + i + ' is "' + arg + '" but a number was expected.');
         process.exit(1);
     }
-}
-if (args.length < 1 || args[0].includes('help')) {
+});
+if (func.includes('help')) {
     console.log('Key: <required> [optional]');
     console.log('Arguments:');
     console.log('  help                     : Show this page');
-    console.log('  approx <a> <b> [eps]     : Check if `a` and `b` are approximately equal');
+    console.log('  sum <c0> [c1] ... [cn]   : Compute a total of `n` numbers');
+    console.log('  prod <c0> [c1] ... [cn]  : Compute a product of `n` numbers');
     console.log('  avg <c0> [c1] ... [cn]   : Take an average of `n` numbers');
+    console.log('  varp <c0> [c1] ... [cn]  : Compute the population variance of `n` numbers');
+    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('  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>');
-    console.log('                           : Normalize `n` between `min` and `max`');
+    console.log('  normalize <n> <min> <max>: Normalize `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('  factorial <n>            : Compute `n!` (factorial)');
     console.log('  error <exp> <act>        : Calculate the normaized percent error between `exp` and `act`');
     process.exit(1);
 }
-switch (args[0]) {
-    case ('approx'): {
-        console.log(_1.SMath.approx(N(1), N(2), N(3, 1e-6)));
+switch (func) {
+    case ('sum'): {
+        console.log(_1.SMath.sum(nums));
+        break;
+    }
+    case ('prod'): {
+        console.log(_1.SMath.prod(nums));
         break;
     }
     case ('avg'): {
-        if (args.length < 2) {
-            console.error('Need at least 1 argument.');
-            process.exit(1);
-        }
-        var operands = [];
-        for (var i = 1; i < args.length; i++) {
-            operands.push(N(i));
-        }
-        console.log(_1.SMath.avg.apply(_1.SMath, operands));
+        console.log(_1.SMath.avg(nums));
+        break;
+    }
+    case ('varp'): {
+        console.log(_1.SMath.varp(nums));
+        break;
+    }
+    case ('vars'): {
+        console.log(_1.SMath.vars(nums));
+        break;
+    }
+    case ('stdevp'): {
+        console.log(_1.SMath.stdevp(nums));
+        break;
+    }
+    case ('stdevs'): {
+        console.log(_1.SMath.stdevs(nums));
+        break;
+    }
+    case ('approx'): {
+        console.log(_1.SMath.approx(nums[0], nums[1], (_b = nums[2]) !== null && _b !== void 0 ? _b : 1e-6));
         break;
     }
     case ('clamp'): {
-        console.log(_1.SMath.clamp(N(1), N(2), N(3)));
+        console.log(_1.SMath.clamp(nums[0], nums[1], nums[2]));
         break;
     }
     case ('expand'): {
-        console.log(_1.SMath.expand(N(1), N(2), N(3)));
+        console.log(_1.SMath.expand(nums[0], nums[1], nums[2]));
         break;
     }
     case ('linspace'): {
-        console.log(_1.SMath.linspace(N(1), N(2), N(3)));
+        console.log(_1.SMath.linspace(nums[0], nums[1], nums[2]));
         break;
     }
     case ('logspace'): {
-        console.log(_1.SMath.logspace(N(1), N(2), N(3)));
+        console.log(_1.SMath.logspace(nums[0], nums[1], nums[2]));
         break;
     }
     case ('normalize'): {
-        console.log(_1.SMath.normalize(N(1), N(2), N(3)));
+        console.log(_1.SMath.normalize(nums[0], nums[1], nums[2]));
         break;
     }
     case ('translate'): {
-        console.log(_1.SMath.translate(N(1), N(2), N(3), N(4), N(5)));
+        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;
     }
     case ('error'): {
-        console.log(_1.SMath.error(N(1), N(2)));
+        console.log(_1.SMath.error(nums[0], nums[1]));
         break;
     }
+    case (''): {
+        console.error('Missing argument. Use with "help" for a list of commands.');
+        process.exit(1);
+    }
     default: {
-        console.error('Unknown argument "' + args[0] + '". Use with "help" for a list of commands.');
+        console.error('Unknown argument "' + func + '". Use with "help" for a list of commands.');
         process.exit(1);
     }
 }

package/dist/index.js

@@ -17,86 +17,98 @@ var SMath = /** @class */ (function () {
     /**
      * Add up all the inputs.
      * If none are present, returns 0.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The sum total
      * @example
      * ```js
-     * const sum = SMath.sum(1, 2, 3); // 6
+     * const y = SMath.sum([1, 2, 3]); // 6
      * ```
      */
-    SMath.sum = function () {
-        var n = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            n[_i] = arguments[_i];
-        }
+    SMath.sum = function (n) {
         return n.reduce(function (a, b) { return a + b; }, 0);
     };
     /**
      * Multiply all the inputs.
      * If none are present, returns 1.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The product
      * @example
      * ```js
-     * const prod = SMath.prod(2, 2, 3, 5); // 60
+     * const y = SMath.prod([2, 2, 3, 5]); // 60
      * ```
      */
-    SMath.prod = function () {
-        var n = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            n[_i] = arguments[_i];
-        }
+    SMath.prod = function (n) {
         return n.reduce(function (a, b) { return a * b; }, 1);
     };
     /**
      * Compute the average, or mean, of a set of numbers.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The average, or mean
      * @example
      * ```js
-     * const mean = SMath.avg(1, 2, 3, 4); // 2.5
+     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
      * ```
      */
-    SMath.avg = function () {
-        var n = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            n[_i] = arguments[_i];
-        }
-        return this.sum.apply(this, n) / n.length;
+    SMath.avg = function (n) {
+        return this.sum(n) / n.length;
     };
     /**
      * Compute the variance of a **complete population**.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The population variance
      * @example
      * ```js
-     * const pvar = SMath.pvar(1, 2, 3, 4); // 1.25
+     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
      * ```
      */
-    SMath.pvar = function () {
-        var n = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            n[_i] = arguments[_i];
-        }
-        var mean = this.avg.apply(this, n), squares = n.map(function (x) { return Math.pow((x - mean), 2); });
-        return this.sum.apply(this, squares) / n.length;
+    SMath.varp = function (n) {
+        var mean = this.avg(n), squares = n.map(function (x) { return Math.pow((x - mean), 2); });
+        return this.sum(squares) / n.length;
     };
     /**
      * Compute the variance of a **sample**.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The sample variance
      * @example
      * ```js
-     * const svar = SMath.svar(1, 2, 3, 4); // 1.666...
+     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
      * ```
      */
-    SMath.svar = function () {
-        var n = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            n[_i] = arguments[_i];
-        }
-        var mean = this.avg.apply(this, n), squares = n.map(function (x) { return Math.pow((x - mean), 2); });
-        return this.sum.apply(this, squares) / (n.length - 1);
+    SMath.vars = function (n) {
+        var mean = this.avg(n), squares = n.map(function (x) { return Math.pow((x - mean), 2); });
+        return this.sum(squares) / (n.length - 1);
+    };
+    /**
+     * Compute the standard deviation of a **complete population**.
+     * @param n An array of numeric inputs
+     * @returns The population standard deviation
+     */
+    SMath.stdevp = function (n) {
+        return Math.sqrt(this.varp(n));
+    };
+    /**
+     * Compute the standard deviation of a **sample**.
+     * @param n An array of numeric inputs
+     * @returns The sample standard deviation
+     */
+    SMath.stdevs = function (n) {
+        return Math.sqrt(this.vars(n));
+    };
+    /**
+     * Check if two numbers are approximately equal with a maximum abolute error.
+     * @param a Any number
+     * @param b Any number
+     * @param epsilon Maximum absolute error
+     * @returns True if `a` is approximately `b`
+     * @example
+     * ```js
+     * const b1 = SMath.approx(1 / 3, 0.33, 1e-6), // false
+     *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
+     * ```
+     */
+    SMath.approx = function (a, b, epsilon) {
+        if (epsilon === void 0) { epsilon = 1e-6; }
+        return a - b < epsilon && b - a < epsilon;
     };
     /**
      * Clamp a number within a range.
@@ -119,22 +131,6 @@ var SMath = /** @class */ (function () {
         }
         return n;
     };
-    /**
-     * Check if two numbers are approximately equal with a maximum abolute error.
-     * @param a Any number
-     * @param b Any number
-     * @param epsilon Maximum absolute error
-     * @returns True if `a` is approximately `b`
-     * @example
-     * ```js
-     * const b1 = SMath.approx(1 / 3, 0.33, 1e-6), // false
-     *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
-     * ```
-     */
-    SMath.approx = function (a, b, epsilon) {
-        if (epsilon === void 0) { epsilon = 1e-6; }
-        return a - b < epsilon && b - a < epsilon;
-    };
     /**
      * Normalize the number `n` from the range `min, max` to the range `0, 1`
      * @param n The number to normalize
@@ -223,7 +219,7 @@ var SMath = /** @class */ (function () {
      * @returns `n!`
      * @example
      * ```js
-     * const factorial = SMath.factorial(5); // 120
+     * const y = SMath.factorial(5); // 120
      * ```
      */
     SMath.factorial = function (n) {
@@ -231,7 +227,7 @@ var SMath = /** @class */ (function () {
             throw new Error('Input must be a positive integer.');
         }
         else if (n === 0) {
-            return 0;
+            return 1;
         }
         else if (n <= 2) {
             return n;
@@ -252,7 +248,7 @@ var SMath = /** @class */ (function () {
      * @returns The relative (normalized) error
      * @example
      * ```js
-     * const error = SMath.error(22.5, 25); // -0.1
+     * const e = SMath.error(22.5, 25); // -0.1
      * ```
      */
     SMath.error = function (experimental, actual) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/smath",
   "bin": "dist/bin.js",
@@ -48,7 +48,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "20.11.30",
-    "exray": "1.0.1",
+    "exray": "1.0.2",
     "typedoc": "0.25.12",
     "typescript": "5.4.3"
   }

package/types/index.d.ts

@@ -12,68 +12,67 @@ export declare abstract class SMath {
     /**
      * Add up all the inputs.
      * If none are present, returns 0.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The sum total
      * @example
      * ```js
-     * const sum = SMath.sum(1, 2, 3); // 6
+     * const y = SMath.sum([1, 2, 3]); // 6
      * ```
      */
-    static sum(...n: Array<number>): number;
+    static sum(n: Array<number>): number;
     /**
      * Multiply all the inputs.
      * If none are present, returns 1.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The product
      * @example
      * ```js
-     * const prod = SMath.prod(2, 2, 3, 5); // 60
+     * const y = SMath.prod([2, 2, 3, 5]); // 60
      * ```
      */
-    static prod(...n: Array<number>): number;
+    static prod(n: Array<number>): number;
     /**
      * Compute the average, or mean, of a set of numbers.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The average, or mean
      * @example
      * ```js
-     * const mean = SMath.avg(1, 2, 3, 4); // 2.5
+     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
      * ```
      */
-    static avg(...n: Array<number>): number;
+    static avg(n: Array<number>): number;
     /**
      * Compute the variance of a **complete population**.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The population variance
      * @example
      * ```js
-     * const pvar = SMath.pvar(1, 2, 3, 4); // 1.25
+     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
      * ```
      */
-    static pvar(...n: Array<number>): number;
+    static varp(n: Array<number>): number;
     /**
      * Compute the variance of a **sample**.
-     * @param n Any amount of numeric inputs
+     * @param n An array of numeric inputs
      * @returns The sample variance
      * @example
      * ```js
-     * const svar = SMath.svar(1, 2, 3, 4); // 1.666...
+     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
      * ```
      */
-    static svar(...n: Array<number>): number;
+    static vars(n: Array<number>): number;
     /**
-     * Clamp a number within a range.
-     * @param n The number to clamp
-     * @param min The minimum value of the range
-     * @param max The maximum value of the range
-     * @returns A clamped number
-     * @example
-     * ```js
-     * const n1 = SMath.clamp(5, 0, 10),  // 5
-     *       n2 = SMath.clamp(-2, 0, 10); // 0
-     * ```
+     * Compute the standard deviation of a **complete population**.
+     * @param n An array of numeric inputs
+     * @returns The population standard deviation
      */
-    static clamp(n: number, min: number, max: number): number;
+    static stdevp(n: Array<number>): number;
+    /**
+     * Compute the standard deviation of a **sample**.
+     * @param n An array of numeric inputs
+     * @returns The sample standard deviation
+     */
+    static stdevs(n: Array<number>): number;
     /**
      * Check if two numbers are approximately equal with a maximum abolute error.
      * @param a Any number
@@ -87,6 +86,19 @@ export declare abstract class SMath {
      * ```
      */
     static approx(a: number, b: number, epsilon?: number): boolean;
+    /**
+     * Clamp a number within a range.
+     * @param n The number to clamp
+     * @param min The minimum value of the range
+     * @param max The maximum value of the range
+     * @returns A clamped number
+     * @example
+     * ```js
+     * const n1 = SMath.clamp(5, 0, 10),  // 5
+     *       n2 = SMath.clamp(-2, 0, 10); // 0
+     * ```
+     */
+    static 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
@@ -158,7 +170,7 @@ export declare abstract class SMath {
      * @returns `n!`
      * @example
      * ```js
-     * const factorial = SMath.factorial(5); // 120
+     * const y = SMath.factorial(5); // 120
      * ```
      */
     static factorial(n: number): number;
@@ -174,7 +186,7 @@ export declare abstract class SMath {
      * @returns The relative (normalized) error
      * @example
      * ```js
-     * const error = SMath.error(22.5, 25); // -0.1
+     * const e = SMath.error(22.5, 25); // -0.1
      * ```
      */
     static error(experimental: number, actual: number): number;