smath 0.0.3 → 1.0.1

package/README.md

@@ -1,2 +1,49 @@
-# smath
-Small math function library
+Small math function library
+
+![NPM Version](https://img.shields.io/npm/v/smath)
+![NPM Downloads](https://img.shields.io/npm/dt/smath)
+
+## Installation
+
+`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.
+
+```shell
+npm i smath@latest
+```
+
+## Getting Started
+
+**Example:** A temperature conversion tool.
+
+```js
+import { SMath, Polate } from 'smath';
+
+// Define some constants to
+// define the number ranges
+const C_Freeze = 0,
+    C_Boil = 100,
+    F_Freeze = 32,
+    F_Boil = 212;
+
+// Use the `Polate` class to
+// translate the temperature in the
+// C number range to a temperature
+// in the F number range
+const C = 20,
+    F_expected = 68,
+    F_actual = Polate.translate(C, C_Freeze, C_Boil, F_Freeze, F_Boil);
+
+// Use the `SMath` class to
+// determine whether the number
+// translation is valid
+const valid = SMath.approx(F_expected, F_actual);
+if (!valid) {
+    throw 'Invalid result.';
+}
+```
+
+Visit the [official documentation](https://npm.nicfv.com/smath/) to learn more!
+
+## Contribute
+
+`smath` is an open source software package hosted on a [GitHub repository](https://github.com/nicfv/npm). Bug reports and feature requests can be submitted in [issues](https://github.com/nicfv/npm/issues). Contributions are also accepted by submitting a [pull request](https://github.com/nicfv/npm/pulls). Please follow the code styling if submitting a pull request.

package/dist/Polate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polate = void 0;
+var Polate = (function () {
+    function Polate() {
+    }
+    Polate.normalize = function (n, min, max) {
+        if (min === max) {
+            return min;
+        }
+        return (n - min) / (max - min);
+    };
+    Polate.expand = function (n, min, max) {
+        return (max - min) * n + min;
+    };
+    Polate.translate = function (n, min1, max1, min2, max2) {
+        return this.expand(this.normalize(n, min1, max1), min2, max2);
+    };
+    return Polate;
+}());
+exports.Polate = Polate;

package/dist/SMath.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMath = void 0;
+var SMath = (function () {
+    function SMath() {
+    }
+    SMath.isNumber = function (n) {
+        return typeof n === 'number';
+    };
+    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;
+    };
+    return SMath;
+}());
+exports.SMath = SMath;

package/dist/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Interpolator"), exports);
+__exportStar(require("./Polate"), exports);
+__exportStar(require("./SMath"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "0.0.3",
+  "version": "1.0.1",
   "description": "Small math function library",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -14,15 +14,30 @@
     "types": "rm -rf types && tsc --declaration --declarationDir types --emitDeclarationOnly",
     "test": "tsc --noEmit",
     "clean": "rm -rf node_modules package-lock.json dist types docs",
-    "docs": "rm -rf docs && typedoc src",
+    "docs": "rm -rf docs && typedoc --includeVersion --disableSources --hideGenerator src",
     "prepublishOnly": "npm run build && npm run types"
   },
-  "keywords": [],
+  "keywords": [
+    "small",
+    "math",
+    "function",
+    "library",
+    "simple",
+    "number",
+    "interpolate",
+    "interpolation",
+    "extrapolate",
+    "extrapolation"
+  ],
   "author": {
     "name": "Nicolas Ventura",
     "email": "smath@nicolasventura.com",
     "url": "https://nicolasventura.com/"
   },
+  "funding": {
+    "type": "paypal",
+    "url": "https://www.paypal.com/donate/?business=UM6EEKPW8GXA2&no_recurring=0&item_name=Open+source+development&currency_code=USD"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/nicfv/npm",
@@ -31,7 +46,7 @@
   "homepage": "https://npm.nicfv.com/smath",
   "license": "MIT",
   "devDependencies": {
-    "typedoc": "^0.25.9",
+    "typedoc": "^0.25.10",
     "typescript": "^5.3.3"
   }
 }

package/types/{Interpolator.d.ts → Polate.d.ts}

@@ -1,13 +1,17 @@
 /**
- * Contains useful interpolation functions.
+ * Contains useful interpolation and extrapolation functions.
  */
-export declare class Interpolator {
+export declare abstract class Polate {
     /**
      * 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 = Polate.normalize(18, 9, 99); // 0.1
+     * ```
      */
     static normalize(n: number, min: number, max: number): number;
     /**
@@ -16,6 +20,10 @@ export declare class Interpolator {
      * @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 = Polate.expand(0.25, 4, 6); // 4.5
+     * ```
      */
     static expand(n: number, min: number, max: number): number;
     /**
@@ -26,6 +34,11 @@ export declare class Interpolator {
      * @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 = Polate.translate(C, 0, 100, 32, 212); // 68
+     * ```
      */
     static translate(n: number, min1: number, max1: number, min2: number, max2: number): number;
 }

package/types/SMath.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Contains a small math function library.
+ */
+export declare abstract class SMath {
+    /**
+     * Determine if a value is numeric.
+     * @param n Any value to check
+     * @returns True if `n` is a number
+     * @example
+     * ```js
+     * const b1 = SMath.isNumber(2),   // true
+     *       b2 = SMath.isNumber('2'); // false
+     * ```
+     */
+    static isNumber(n: any): 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;
+    /**
+     * 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
+     * ```
+     */
+    static approx(a: number, b: number, epsilon?: number): boolean;
+}

package/types/index.d.ts

@@ -1 +1,8 @@
-export * from './Interpolator';
+/**
+ * @packageDocumentation
+ * Small math function library
+ *
+ * Exports the public-facing API for `smath`
+ */
+export * from './Polate';
+export * from './SMath';

package/dist/Interpolator.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Interpolator = void 0;
-var Interpolator = (function () {
-    function Interpolator() {
-    }
-    Interpolator.normalize = function (n, min, max) {
-        if (min === max) {
-            return min;
-        }
-        return (n - min) / (max - min);
-    };
-    Interpolator.expand = function (n, min, max) {
-        return (max - min) * n + min;
-    };
-    Interpolator.translate = function (n, min1, max1, min2, max2) {
-        return this.expand(this.normalize(n, min1, max1), min2, max2);
-    };
-    return Interpolator;
-}());
-exports.Interpolator = Interpolator;