smath 1.2.0 → 1.3.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/1710998183)
+![Relative date](https://img.shields.io/date/1711138380)
 ![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.1
 ```
 
 ## Bugs and Requests

package/dist/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/index.js

@@ -1,9 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SMath = void 0;
-var SMath = (function () {
+/**
+ * @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++) {
@@ -11,6 +30,18 @@ var SMath = (function () {
         }
         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;
@@ -20,22 +51,82 @@ var SMath = (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
+     * @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++) {
@@ -43,6 +134,18 @@ var SMath = (function () {
         }
         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); });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/smath",
   "bin": "dist/bin.js",
@@ -11,12 +11,11 @@
     "types"
   ],
   "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": "tsc --outDir tmp test/index.ts && { node tmp/test/index.js ; rm -r tmp ; }",
     "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"
   }
-}
+}