smath 0.0.4 → 1.0.2

package/README.md

@@ -1,5 +1,49 @@
-# smath
 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

@@ -6,7 +6,7 @@ var Polate = (function () {
     }
     Polate.normalize = function (n, min, max) {
         if (min === max) {
-            return min;
+            return 0;
         }
         return (n - min) / (max - min);
     };

package/dist/SMath.js

@@ -5,7 +5,7 @@ var SMath = (function () {
     function SMath() {
     }
     SMath.isNumber = function (n) {
-        return typeof n === 'number';
+        return typeof n === 'number' && n !== Infinity && n !== -Infinity;
     };
     SMath.clamp = function (n, min, max) {
         if (n < min) {
@@ -20,6 +20,9 @@ var SMath = (function () {
         if (epsilon === void 0) { epsilon = 1e-6; }
         return a - b < epsilon && b - a < epsilon;
     };
+    SMath.round = function (n, d) {
+        return Math.round(n * Math.pow(10, d)) / (Math.pow(10, d));
+    };
     return SMath;
 }());
 exports.SMath = SMath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "0.0.4",
+  "version": "1.0.2",
   "description": "Small math function library",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -14,7 +14,7 @@
     "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": [
@@ -46,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/Polate.d.ts

@@ -1,13 +1,17 @@
 /**
  * Contains useful interpolation and extrapolation functions.
  */
-export declare class Polate {
+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 Polate {
      * @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 Polate {
      * @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

@@ -1,11 +1,16 @@
 /**
- * Small Math function library
+ * Contains a small math function library.
  */
-export declare class SMath {
+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;
     /**
@@ -14,6 +19,11 @@ export declare class SMath {
      * @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;
     /**
@@ -22,6 +32,22 @@ export declare class SMath {
      * @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;
+    /**
+     * Round a number to any number of decimal places.
+     * @param n The number to round
+     * @param d The number of places on the right side of the decimal
+     * @returns The rounded number
+     * @example
+     * ```js
+     * const pi = SMath.round(3.1416, 2); // 3.14
+     * ```
+     */
+    static round(n: number, d: number): number;
 }

package/types/index.d.ts

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