smath 1.2.0 → 1.3.0

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

package/dist/{bin.js → src/bin.js}

@@ -3,6 +3,9 @@
 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) {

package/dist/src/index.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMath = void 0;
+/**
+ * @packageDocumentation
+ * Small math function library
+ *
+ * Exports the public-facing API for `smath`
+ */
+/**
+ * Contains a small math function library including
+ * useful interpolation and extrapolation functions.
+ */
+var SMath = /** @class */ (function () {
+    function SMath() {
+    }
+    /**
+     * Compute the average, or mean, of a set of numbers.
+     * @param n Any amount of numeric inputs
+     * @returns The average, or mean
+     * @example
+     * ```js
+     * const mean = SMath.avg(1, 2, 3, 4); // 2.5
+     * ```
+     */
+    SMath.avg = function () {
+        var n = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            n[_i] = arguments[_i];
+        }
+        return n.reduce(function (prev, curr) { return prev + curr; }) / n.length;
+    };
+    /**
+     * 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
+     * ```
+     */
+    SMath.clamp = function (n, min, max) {
+        if (n < min) {
+            return min;
+        }
+        if (n > max) {
+            return max;
+        }
+        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
+     * @param min The minimum value in the range
+     * @param max The maximum value in the range
+     * @returns A normalized value
+     * @example
+     * ```js
+     * const y = SMath.normalize(18, 9, 99); // 0.1
+     * ```
+     */
+    SMath.normalize = function (n, min, max) {
+        if (min === max) {
+            return 0;
+        }
+        return (n - min) / (max - min);
+    };
+    /**
+     * Expand a normalized number `n` to the range `min, max`
+     * @param n A normalized number
+     * @param min The minimum value in the range
+     * @param max The maximum value in the range
+     * @returns A value within the number range
+     * @example
+     * ```js
+     * const y = SMath.expand(0.25, 4, 6); // 4.5
+     * ```
+     */
+    SMath.expand = function (n, min, max) {
+        return (max - min) * n + min;
+    };
+    /**
+     * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
+     * @param n The number to translate
+     * @param min1 The minimum value from the initial range
+     * @param max1 The maximum value from the initial range
+     * @param min2 The minimum value for the final range
+     * @param max2 The maximum value for the final range
+     * @returns A translated number in the final range
+     * @example
+     * ```js
+     * const C = 20,
+     *       F = SMath.translate(C, 0, 100, 32, 212); // 68
+     * ```
+     */
+    SMath.translate = function (n, min1, max1, min2, max2) {
+        return this.expand(this.normalize(n, min1, max1), min2, max2);
+    };
+    /**
+     * Generate an array of linearly spaced numbers.
+     * @param min The initial value of the linear space
+     * @param max The final value of the linear space
+     * @param count The number of values in the space
+     * @returns The linear space as an array of numbers
+     * @example
+     * ```js
+     * const space = SMath.linspace(1, 5, 6);
+     * // [ 1, 1.8, 2.6, 3.4, 4.2, 5 ]
+     * ```
+     */
+    SMath.linspace = function (min, max, count) {
+        var space = [];
+        for (var i = 0; i < count; i++) {
+            space[i] = this.translate(i, 0, count - 1, min, max);
+        }
+        return space;
+    };
+    /**
+     * Generate an array of logarithmically spaced numbers.
+     * @param min The initial magnitude of the space
+     * @param max The final magnitude of the space
+     * @param count The number of values in the space
+     * @returns The logarithmic space as an array of numbers
+     * @example
+     * ```js
+     * const space = SMath.logspace(0, 2, 5);
+     * // [ 1, 3.2, 10, 31.6, 100 ]
+     * ```
+     */
+    SMath.logspace = function (min, max, count) {
+        return this.linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
+    };
+    return SMath;
+}());
+exports.SMath = SMath;

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "smath",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/smath",
-  "bin": "dist/bin.js",
-  "main": "dist/index.js",
-  "types": "types/index.d.ts",
+  "bin": "dist/src/bin.js",
+  "main": "dist/src/index.js",
+  "types": "types/src/index.d.ts",
   "files": [
-    "dist",
-    "types"
+    "dist/src",
+    "types/src"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc --removeComments",
-    "types": "rm -rf types && tsc --declaration --declarationDir types --emitDeclarationOnly",
-    "test": "tsc --noEmit",
+    "build": "rm -rf dist && tsc",
+    "test": "npm run build && node dist/test/index.js",
     "clean": "rm -rf node_modules package-lock.json dist types docs",
     "docs": "rm -rf docs && typedoc --includeVersion --disableSources --hideGenerator src",
-    "prepack": "npm run build && npm run types",
+    "prepack": "npm run build",
     "postpack": "rm -rf dist types"
   },
   "keywords": [
@@ -50,6 +49,7 @@
   "devDependencies": {
     "@types/node": "20.11.30",
     "typedoc": "0.25.12",
-    "typescript": "5.4.2"
+    "typescript": "5.4.3",
+    "xpt": "0.2.0"
   }
-}
+}

package/dist/index.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SMath = void 0;
-var SMath = (function () {
-    function SMath() {
-    }
-    SMath.avg = function () {
-        var n = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            n[_i] = arguments[_i];
-        }
-        return n.reduce(function (prev, curr) { return prev + curr; }) / n.length;
-    };
-    SMath.clamp = function (n, min, max) {
-        if (n < min) {
-            return min;
-        }
-        if (n > max) {
-            return max;
-        }
-        return n;
-    };
-    SMath.approx = function (a, b, epsilon) {
-        if (epsilon === void 0) { epsilon = 1e-6; }
-        return a - b < epsilon && b - a < epsilon;
-    };
-    SMath.normalize = function (n, min, max) {
-        if (min === max) {
-            return 0;
-        }
-        return (n - min) / (max - min);
-    };
-    SMath.expand = function (n, min, max) {
-        return (max - min) * n + min;
-    };
-    SMath.translate = function (n, min1, max1, min2, max2) {
-        return this.expand(this.normalize(n, min1, max1), min2, max2);
-    };
-    SMath.linspace = function (min, max, count) {
-        var space = [];
-        for (var i = 0; i < count; i++) {
-            space[i] = this.translate(i, 0, count - 1, min, max);
-        }
-        return space;
-    };
-    SMath.logspace = function (min, max, count) {
-        return this.linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
-    };
-    return SMath;
-}());
-exports.SMath = SMath;