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

package/dist/bin.js

@@ -17,13 +17,6 @@ if (func.includes('help')) {
     console.log('Key: <required> [optional]');
     console.log('Arguments:');
     console.log('  help                     : Show this page');
-    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`');
@@ -33,38 +26,19 @@ if (func.includes('help')) {
     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('  factors <n>              : List the prime factors of `n`');
     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');
+    console.log('  avg <c0> [c1] ... [cn]   : Take an average of `n` numbers');
+    console.log('  median <c0> [c1] ... [cn]: Take the median 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');
     process.exit(1);
 }
 switch (func) {
-    case ('sum'): {
-        console.log(_1.SMath.sum(nums));
-        break;
-    }
-    case ('prod'): {
-        console.log(_1.SMath.prod(nums));
-        break;
-    }
-    case ('avg'): {
-        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;
@@ -97,10 +71,46 @@ switch (func) {
         console.log(_1.SMath.factorial(nums[0]));
         break;
     }
+    case ('factors'): {
+        console.log(_1.SMath.factors(nums[0]));
+        break;
+    }
     case ('error'): {
         console.log(_1.SMath.error(nums[0], nums[1]));
         break;
     }
+    case ('sum'): {
+        console.log(_1.SMath.sum(nums));
+        break;
+    }
+    case ('prod'): {
+        console.log(_1.SMath.prod(nums));
+        break;
+    }
+    case ('avg'): {
+        console.log(_1.SMath.avg(nums));
+        break;
+    }
+    case ('median'): {
+        console.log(_1.SMath.median(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 (''): {
         console.error('Missing argument. Use with "help" for a list of commands.');
         process.exit(1);

package/dist/index.js

@@ -14,86 +14,6 @@ exports.SMath = void 0;
 var SMath = /** @class */ (function () {
     function SMath() {
     }
-    /**
-     * Add up all the inputs.
-     * If none are present, returns 0.
-     * @param n An array of numeric inputs
-     * @returns The sum total
-     * @example
-     * ```js
-     * const y = SMath.sum([1, 2, 3]); // 6
-     * ```
-     */
-    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 An array of numeric inputs
-     * @returns The product
-     * @example
-     * ```js
-     * const y = SMath.prod([2, 2, 3, 5]); // 60
-     * ```
-     */
-    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 An array of numeric inputs
-     * @returns The average, or mean
-     * @example
-     * ```js
-     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
-     * ```
-     */
-    SMath.avg = function (n) {
-        return this.sum(n) / n.length;
-    };
-    /**
-     * Compute the variance of a **complete population**.
-     * @param n An array of numeric inputs
-     * @returns The population variance
-     * @example
-     * ```js
-     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
-     * ```
-     */
-    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 An array of numeric inputs
-     * @returns The sample variance
-     * @example
-     * ```js
-     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
-     * ```
-     */
-    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
@@ -236,6 +156,35 @@ var SMath = /** @class */ (function () {
             return n * this.factorial(n - 1);
         }
     };
+    /**
+     * Factorize `n` into its prime factors.
+     * @param n Any positive integer
+     * @returns The array of prime factors
+     * @example
+     * ```js
+     * const y = SMath.factors(12); // [ 2, 2, 3 ]
+     * ```
+     */
+    SMath.factors = function (n) {
+        if (n < 0 || (n | 0) !== n) {
+            throw new Error('Input must be a positive integer!');
+        }
+        if (n <= 3) {
+            return [n];
+        }
+        var f = [];
+        var i = 2;
+        while (n > 1 && i <= n) {
+            if ((n / i) === ((n / i) | 0)) {
+                n /= i;
+                f.push(i);
+            }
+            else {
+                i++;
+            }
+        }
+        return f;
+    };
     /**
      * Calculate the relative normalized error or deviation from any
      * value to an accepted value. An error of 0 indicates that the
@@ -254,6 +203,215 @@ var SMath = /** @class */ (function () {
     SMath.error = function (experimental, actual) {
         return (experimental - actual) / actual;
     };
+    /**
+     * Add up all the inputs.
+     * If none are present, returns 0.
+     * @param data An array of numeric inputs
+     * @returns The sum total
+     * @example
+     * ```js
+     * const y = SMath.sum([1, 2, 3]); // 6
+     * ```
+     */
+    SMath.sum = function (data) {
+        return data.reduce(function (a, b) { return a + b; }, 0);
+    };
+    /**
+     * Multiply all the inputs.
+     * If none are present, returns 1.
+     * @param data An array of numeric inputs
+     * @returns The product
+     * @example
+     * ```js
+     * const y = SMath.prod([2, 2, 3, 5]); // 60
+     * ```
+     */
+    SMath.prod = function (data) {
+        return data.reduce(function (a, b) { return a * b; }, 1);
+    };
+    /**
+     * Compute the average, or mean, of a set of numbers.
+     * @param data An array of numeric inputs
+     * @returns The average, or mean
+     * @example
+     * ```js
+     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
+     * ```
+     */
+    SMath.avg = function (data) {
+        return this.sum(data) / data.length;
+    };
+    /**
+     * Compute the median of a set of numbers.
+     * @param data An array of numeric inputs
+     * @returns The median of the dataset
+     * @example
+     * ```js
+     * const y = SMath.median([2, 5, 3, 1]); // 2.5
+     * ```
+     */
+    SMath.median = function (data) {
+        data.sort();
+        if (data.length % 2) {
+            return data[(data.length - 1) / 2];
+        }
+        return this.avg([data[data.length / 2 - 1], data[data.length / 2]]);
+    };
+    /**
+     * Compute the variance of a **complete population**.
+     * @param data An array of numeric inputs
+     * @returns The population variance
+     * @example
+     * ```js
+     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
+     * ```
+     */
+    SMath.varp = function (data) {
+        var mean = this.avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
+        return this.sum(squares) / data.length;
+    };
+    /**
+     * Compute the variance of a **sample**.
+     * @param data An array of numeric inputs
+     * @returns The sample variance
+     * @example
+     * ```js
+     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
+     * ```
+     */
+    SMath.vars = function (data) {
+        var mean = this.avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
+        return this.sum(squares) / (data.length - 1);
+    };
+    /**
+     * Compute the standard deviation of a **complete population**.
+     * @param data An array of numeric inputs
+     * @returns The population standard deviation
+     * @example
+     * ```js
+     * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
+     * ```
+     */
+    SMath.stdevp = function (data) {
+        return Math.sqrt(this.varp(data));
+    };
+    /**
+     * Compute the standard deviation of a **sample**.
+     * @param data An array of numeric inputs
+     * @returns The sample standard deviation
+     * @example
+     * ```js
+     * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
+     * ```
+     */
+    SMath.stdevs = function (data) {
+        return Math.sqrt(this.vars(data));
+    };
+    /**
+     * Take the limit of a function. A return value of `NaN` indicates
+     * that no limit exists either due to a discontinuity or imaginary value.
+     * @param f Function `f(x)`
+     * @param x The x-value where to take the limit
+     * @param h The approach distance
+     * @param discontinuity_cutoff The discontinuity cutoff
+     * @returns `lim(f(x->x))`
+     * @example
+     * ```js
+     * const y = SMath.lim(Math.log, 0); // -Infinity
+     * ```
+     */
+    SMath.lim = function (f, x, h, discontinuity_cutoff) {
+        if (h === void 0) { h = 1e-3; }
+        if (discontinuity_cutoff === void 0) { discontinuity_cutoff = 1; }
+        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)) {
+            return center;
+        }
+        // Check the limit approaching from the left
+        if (Number.isFinite(left1) && Number.isFinite(left2)) {
+            if (left2 > left1 + 2 * h) {
+                left = Infinity;
+            }
+            else if (left2 < left1 - 2 * h) {
+                left = -Infinity;
+            }
+            else {
+                left = this.avg([left1, left2]);
+            }
+        }
+        else if (left1 === left2) { // Handles +/-Infinity case
+            left = left1;
+        }
+        else {
+            left = NaN;
+        }
+        // Check the limit approaching from the right
+        if (Number.isFinite(right1) && Number.isFinite(right2)) {
+            if (right2 > right1 + 2 * h) {
+                right = Infinity;
+            }
+            else if (right2 < right1 - 2 * h) {
+                right = -Infinity;
+            }
+            else {
+                right = this.avg([right1, right2]);
+            }
+        }
+        else if (right1 === right2) { // Handles +/-Infinity case
+            right = right1;
+        }
+        else {
+            right = NaN;
+        }
+        // Check if limits match or are close
+        if (left === right) { // Handles +/-Infinity case
+            return left;
+        }
+        else if (SMath.approx(left, right, discontinuity_cutoff)) {
+            return this.avg([left, right]);
+        }
+        else if (!Number.isNaN(left) && Number.isNaN(right)) {
+            return left;
+        }
+        else if (Number.isNaN(left) && !Number.isNaN(right)) {
+            return right;
+        }
+        else {
+            return NaN;
+        }
+    };
+    /**
+     * 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
+     * @returns `f'(x)`
+     * @example
+     * ```js
+     * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
+     * ```
+     */
+    SMath.differentiate = function (f, x, h) {
+        if (h === void 0) { h = 1e-3; }
+        return (f(x + h) - f(x - h)) / (2 * h);
+    };
+    /**
+     * Compute the definite integral of a function.
+     * @param f Function `f(x)`
+     * @param a The miminum integral bound
+     * @param b The maximum integral bound
+     * @param Ndx The number of rectangles to compute
+     * @returns `F(b)-F(a)`
+     * @example
+     * ```js
+     * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
+     * ```
+     */
+    SMath.integrate = function (f, a, b, Ndx) {
+        if (Ndx === void 0) { Ndx = 1e3; }
+        return ((b - a) / Ndx) * this.sum(this.linspace(a, b, Ndx).map(function (x) { return f(x); }));
+    };
     return SMath;
 }());
 exports.SMath = SMath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/smath",
   "bin": "dist/bin.js",

package/types/index.d.ts

@@ -9,70 +9,6 @@
  * useful interpolation and extrapolation functions.
  */
 export declare abstract class SMath {
-    /**
-     * Add up all the inputs.
-     * If none are present, returns 0.
-     * @param n An array of numeric inputs
-     * @returns The sum total
-     * @example
-     * ```js
-     * const y = SMath.sum([1, 2, 3]); // 6
-     * ```
-     */
-    static sum(n: Array<number>): number;
-    /**
-     * Multiply all the inputs.
-     * If none are present, returns 1.
-     * @param n An array of numeric inputs
-     * @returns The product
-     * @example
-     * ```js
-     * const y = SMath.prod([2, 2, 3, 5]); // 60
-     * ```
-     */
-    static prod(n: Array<number>): number;
-    /**
-     * Compute the average, or mean, of a set of numbers.
-     * @param n An array of numeric inputs
-     * @returns The average, or mean
-     * @example
-     * ```js
-     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
-     * ```
-     */
-    static avg(n: Array<number>): number;
-    /**
-     * Compute the variance of a **complete population**.
-     * @param n An array of numeric inputs
-     * @returns The population variance
-     * @example
-     * ```js
-     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
-     * ```
-     */
-    static varp(n: Array<number>): number;
-    /**
-     * Compute the variance of a **sample**.
-     * @param n An array of numeric inputs
-     * @returns The sample variance
-     * @example
-     * ```js
-     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
-     * ```
-     */
-    static vars(n: Array<number>): number;
-    /**
-     * Compute the standard deviation of a **complete population**.
-     * @param n An array of numeric inputs
-     * @returns The population standard deviation
-     */
-    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
@@ -174,6 +110,16 @@ export declare abstract class SMath {
      * ```
      */
     static factorial(n: number): number;
+    /**
+     * Factorize `n` into its prime factors.
+     * @param n Any positive integer
+     * @returns The array of prime factors
+     * @example
+     * ```js
+     * const y = SMath.factors(12); // [ 2, 2, 3 ]
+     * ```
+     */
+    static factors(n: number): Array<number>;
     /**
      * Calculate the relative normalized error or deviation from any
      * value to an accepted value. An error of 0 indicates that the
@@ -190,4 +136,125 @@ export declare abstract class SMath {
      * ```
      */
     static error(experimental: number, actual: number): number;
+    /**
+     * Add up all the inputs.
+     * If none are present, returns 0.
+     * @param data An array of numeric inputs
+     * @returns The sum total
+     * @example
+     * ```js
+     * const y = SMath.sum([1, 2, 3]); // 6
+     * ```
+     */
+    static sum(data: Array<number>): number;
+    /**
+     * Multiply all the inputs.
+     * If none are present, returns 1.
+     * @param data An array of numeric inputs
+     * @returns The product
+     * @example
+     * ```js
+     * const y = SMath.prod([2, 2, 3, 5]); // 60
+     * ```
+     */
+    static prod(data: Array<number>): number;
+    /**
+     * Compute the average, or mean, of a set of numbers.
+     * @param data An array of numeric inputs
+     * @returns The average, or mean
+     * @example
+     * ```js
+     * const y = SMath.avg([1, 2, 4, 4]); // 2.75
+     * ```
+     */
+    static avg(data: Array<number>): number;
+    /**
+     * Compute the median of a set of numbers.
+     * @param data An array of numeric inputs
+     * @returns The median of the dataset
+     * @example
+     * ```js
+     * const y = SMath.median([2, 5, 3, 1]); // 2.5
+     * ```
+     */
+    static median(data: Array<number>): number;
+    /**
+     * Compute the variance of a **complete population**.
+     * @param data An array of numeric inputs
+     * @returns The population variance
+     * @example
+     * ```js
+     * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
+     * ```
+     */
+    static varp(data: Array<number>): number;
+    /**
+     * Compute the variance of a **sample**.
+     * @param data An array of numeric inputs
+     * @returns The sample variance
+     * @example
+     * ```js
+     * const y = SMath.vars([1, 2, 4, 4]); // 2.25
+     * ```
+     */
+    static vars(data: Array<number>): number;
+    /**
+     * Compute the standard deviation of a **complete population**.
+     * @param data An array of numeric inputs
+     * @returns The population standard deviation
+     * @example
+     * ```js
+     * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
+     * ```
+     */
+    static stdevp(data: Array<number>): number;
+    /**
+     * Compute the standard deviation of a **sample**.
+     * @param data An array of numeric inputs
+     * @returns The sample standard deviation
+     * @example
+     * ```js
+     * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
+     * ```
+     */
+    static stdevs(data: Array<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.
+     * @param f Function `f(x)`
+     * @param x The x-value where to take the limit
+     * @param h The approach distance
+     * @param discontinuity_cutoff The discontinuity cutoff
+     * @returns `lim(f(x->x))`
+     * @example
+     * ```js
+     * const y = SMath.lim(Math.log, 0); // -Infinity
+     * ```
+     */
+    static lim(f: (x: number) => number, x: number, h?: number, discontinuity_cutoff?: number): number;
+    /**
+     * 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
+     * @returns `f'(x)`
+     * @example
+     * ```js
+     * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
+     * ```
+     */
+    static differentiate(f: (x: number) => number, x: number, h?: number): number;
+    /**
+     * Compute the definite integral of a function.
+     * @param f Function `f(x)`
+     * @param a The miminum integral bound
+     * @param b The maximum integral bound
+     * @param Ndx The number of rectangles to compute
+     * @returns `F(b)-F(a)`
+     * @example
+     * ```js
+     * const y = SMath.integrate(x => 3 * x ** 2, 1, 2); // 7
+     * ```
+     */
+    static integrate(f: (x: number) => number, a: number, b: number, Ndx?: number): number;
 }