smath 1.13.2 → 1.14.0

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 "use strict";
-var _a, _b, _c, _d, _e;
+var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 var SMath = require(".");
 var func = ((_a = process.argv[2]) !== null && _a !== void 0 ? _a : '').toLowerCase(), nums = process.argv.slice(3).map(function (arg, i) {
@@ -147,10 +147,6 @@ switch (func) {
         console.log(SMath.mixed(nums[0], (_d = nums[1]) !== null && _d !== void 0 ? _d : 1e-6));
         break;
     }
-    case ('tohex'): {
-        console.log(SMath.toHex(nums[0], (_e = nums[1]) !== null && _e !== void 0 ? _e : 0));
-        break;
-    }
     case (''): {
         console.error('Missing argument. Use with "help" for a list of commands.');
         process.exit(1);

package/dist/index.js

@@ -40,7 +40,6 @@ exports.differentiate = differentiate;
 exports.integrate = integrate;
 exports.rat = rat;
 exports.mixed = mixed;
-exports.toHex = toHex;
 /**
  * @packageDocumentation
  * Small math function library
@@ -55,10 +54,8 @@ exports.toHex = toHex;
  * @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
- * ```
  */
 function approx(a, b, epsilon) {
     if (epsilon === void 0) { epsilon = 1e-6; }
@@ -71,10 +68,8 @@ function approx(a, b, epsilon) {
  * @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
- * ```
  */
 function clamp(n, min, max) {
     if (n < min) {
@@ -92,9 +87,7 @@ function clamp(n, min, max) {
  * @param max The maximum value in the range
  * @returns A normalized value
  * @example
- * ```js
  * const y = SMath.normalize(18, 9, 99); // 0.1
- * ```
  */
 function normalize(n, min, max) {
     if (min === max) {
@@ -109,9 +102,7 @@ function normalize(n, min, max) {
  * @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
- * ```
  */
 function expand(n, min, max) {
     return (max - min) * n + min;
@@ -125,10 +116,8 @@ function expand(n, min, max) {
  * @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
- * ```
  */
 function translate(n, min1, max1, min2, max2) {
     return expand(normalize(n, min1, max1), min2, max2);
@@ -140,10 +129,8 @@ function translate(n, min1, max1, min2, max2) {
  * @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 ]
- * ```
  */
 function linspace(min, max, count) {
     var space = [];
@@ -159,10 +146,8 @@ function linspace(min, max, count) {
  * @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 ]
- * ```
  */
 function logspace(min, max, count) {
     return linspace(min, max, count).map(function (n) { return Math.pow(10, n); });
@@ -172,9 +157,7 @@ function logspace(min, max, count) {
  * @param n Any positive integer
  * @returns `n!`
  * @example
- * ```js
  * const y = SMath.factorial(5); // 120
- * ```
  */
 function factorial(n) {
     if (n < 0 || (n | 0) !== n) {
@@ -195,9 +178,7 @@ function factorial(n) {
  * @param n Any positive integer
  * @returns The array of prime factors
  * @example
- * ```js
  * const y = SMath.factors(12); // [ 2, 2, 3 ]
- * ```
  */
 function factors(n) {
     if (n < 0 || (n | 0) !== n) {
@@ -226,9 +207,7 @@ function factors(n) {
  * @param base Any base to round to
  * @returns `n` rounded to the nearest multiple of `base`
  * @example
- * ```js
  * const y = SMath.round2(Math.PI, 0.2); // 3.2
- * ```
  */
 function round2(n, base) {
     var rounded = base ? base * Math.round(n / base) : n;
@@ -246,9 +225,7 @@ function round2(n, base) {
  * @param actual The accepted or theoretical value
  * @returns The relative (normalized) error
  * @example
- * ```js
  * const e = SMath.error(22.5, 25); // -0.1
- * ```
  */
 function error(experimental, actual) {
     return (experimental - actual) / actual;
@@ -259,9 +236,7 @@ function error(experimental, actual) {
  * @param data An array of numeric inputs
  * @returns The sum total
  * @example
- * ```js
  * const y = SMath.sum([1, 2, 3]); // 6
- * ```
  */
 function sum(data) {
     return data.reduce(function (a, b) { return a + b; }, 0);
@@ -272,9 +247,7 @@ function sum(data) {
  * @param data An array of numeric inputs
  * @returns The product
  * @example
- * ```js
  * const y = SMath.prod([2, 2, 3, 5]); // 60
- * ```
  */
 function prod(data) {
     return data.reduce(function (a, b) { return a * b; }, 1);
@@ -284,9 +257,7 @@ function prod(data) {
  * @param data An array of numeric inputs
  * @returns The average, or mean
  * @example
- * ```js
  * const y = SMath.avg([1, 2, 4, 4]); // 2.75
- * ```
  */
 function avg(data) {
     return sum(data) / data.length;
@@ -296,9 +267,7 @@ function avg(data) {
  * @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
- * ```
  */
 function median(data) {
     data.sort(function (a, b) { return a - b; });
@@ -312,9 +281,7 @@ function median(data) {
  * @param data An array of numeric inputs
  * @returns The population variance
  * @example
- * ```js
  * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
- * ```
  */
 function varp(data) {
     var mean = avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
@@ -325,9 +292,7 @@ function varp(data) {
  * @param data An array of numeric inputs
  * @returns The sample variance
  * @example
- * ```js
  * const y = SMath.vars([1, 2, 4, 4]); // 2.25
- * ```
  */
 function vars(data) {
     var mean = avg(data), squares = data.map(function (x) { return Math.pow((x - mean), 2); });
@@ -338,9 +303,7 @@ function vars(data) {
  * @param data An array of numeric inputs
  * @returns The population standard deviation
  * @example
- * ```js
  * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
- * ```
  */
 function stdevp(data) {
     return Math.sqrt(varp(data));
@@ -350,9 +313,7 @@ function stdevp(data) {
  * @param data An array of numeric inputs
  * @returns The sample standard deviation
  * @example
- * ```js
  * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
- * ```
  */
 function stdevs(data) {
     return Math.sqrt(vars(data));
@@ -363,9 +324,7 @@ function stdevs(data) {
  * @param max The maximum bound
  * @returns A random float within the range
  * @example
- * ```js
  * const y = SMath.runif(-2, 2); // 0.376...
- * ```
  */
 function runif(min, max) {
     return expand(Math.random(), min, max);
@@ -376,9 +335,7 @@ function runif(min, max) {
  * @param max The maximum bound (inclusive)
  * @returns A random integer within the range
  * @example
- * ```js
  * const y = SMath.rint(-4, 3); // -4
- * ```
  */
 function rint(min, max) {
     min |= 0;
@@ -397,9 +354,7 @@ function rint(min, max) {
  * @param stdev The standard deviation of the population
  * @returns A random float
  * @example
- * ```js
  * const y = SMath.rnorm(2, 3); // 1.627...
- * ```
  */
 function rnorm(mean, stdev) {
     if (mean === void 0) { mean = 0; }
@@ -413,9 +368,7 @@ function rnorm(mean, stdev) {
  * @param stdev The standard deviation of the population
  * @returns A population of random floats
  * @example
- * ```js
  * const dataset = SMath.rdist(3); // [ 1.051..., -0.779..., -2.254... ]
- * ```
  */
 function rdist(count, mean, stdev) {
     if (mean === void 0) { mean = 0; }
@@ -431,9 +384,7 @@ function rdist(count, mean, stdev) {
  * @param stack An array of arbitrary elements
  * @returns The `stack` array in a random order
  * @example
- * ```js
  * const shuffled = SMath.shuffle(['a', 'b', 'c']); // [ 'c', 'a', 'b' ]
- * ```
  */
 function shuffle(stack) {
     var rawData = [];
@@ -452,13 +403,11 @@ function shuffle(stack) {
  * @param discontinuity_cutoff The discontinuity cutoff
  * @returns `lim(f(x->x))`
  * @example
- * ```js
  * const y = SMath.lim(Math.log, 0); // -Infinity
- * ```
  */
 function lim(f, x, h, discontinuity_cutoff) {
-    if (h === void 0) { h = 1e-3; }
-    if (discontinuity_cutoff === void 0) { discontinuity_cutoff = 1; }
+    if (h === void 0) { h = 1e-6; }
+    if (discontinuity_cutoff === void 0) { discontinuity_cutoff = 1e-3; }
     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)) {
@@ -466,46 +415,46 @@ function lim(f, x, h, discontinuity_cutoff) {
     }
     // Check the limit approaching from the left
     if (Number.isFinite(left1) && Number.isFinite(left2)) {
-        if (left2 > left1 + 2 * h) {
-            left = Infinity;
+        if (approx(left1, left2, discontinuity_cutoff)) {
+            left = left2; // Converges
         }
-        else if (left2 < left1 - 2 * h) {
-            left = -Infinity;
+        else if (left1 > 0 && left2 > left1) {
+            left = Infinity; // Diverges to +inf
+        }
+        else if (left1 < 0 && left2 < left1) {
+            left = -Infinity; // Diverges to -inf
         }
         else {
-            left = avg([left1, left2]);
+            left = NaN; // Diverges
         }
     }
-    else if (left1 === left2) { // Handles +/-Infinity case
-        left = left1;
-    }
     else {
-        left = NaN;
+        left = NaN; // Discontinuous
     }
     // Check the limit approaching from the right
     if (Number.isFinite(right1) && Number.isFinite(right2)) {
-        if (right2 > right1 + 2 * h) {
-            right = Infinity;
+        if (approx(right1, right2, discontinuity_cutoff)) {
+            right = right2; // Converges
         }
-        else if (right2 < right1 - 2 * h) {
-            right = -Infinity;
+        else if (right1 > 0 && right2 > right1) {
+            right = Infinity; // Diverges to +inf
+        }
+        else if (right1 < 0 && right2 < right1) {
+            right = -Infinity; // Diverges to -inf
         }
         else {
-            right = avg([right1, right2]);
+            right = NaN; // Diverges
         }
     }
-    else if (right1 === right2) { // Handles +/-Infinity case
-        right = right1;
-    }
     else {
-        right = NaN;
+        right = NaN; // Discontinuous
     }
     // Check if limits match or are close
     if (left === right) { // Handles +/-Infinity case
         return left;
     }
-    else if (approx(left, right, discontinuity_cutoff)) {
-        return avg([left, right]);
+    else if (Number.isNaN(left) && Number.isNaN(right)) {
+        return center;
     }
     else if (!Number.isNaN(left) && Number.isNaN(right)) {
         return left;
@@ -513,6 +462,9 @@ function lim(f, x, h, discontinuity_cutoff) {
     else if (Number.isNaN(left) && !Number.isNaN(right)) {
         return right;
     }
+    else if (approx(left, right, discontinuity_cutoff)) {
+        return avg([left, right]);
+    }
     else {
         return NaN;
     }
@@ -521,16 +473,14 @@ function lim(f, x, h, discontinuity_cutoff) {
  * 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
+ * @param epsilon Small step value
  * @returns `f'(x)`
  * @example
- * ```js
  * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
- * ```
  */
-function differentiate(f, x, h) {
-    if (h === void 0) { h = 1e-3; }
-    return (f(x + h) - f(x - h)) / (2 * h);
+function differentiate(f, x, epsilon) {
+    if (epsilon === void 0) { epsilon = 1e-6; }
+    return lim(function (h) { return (f(x + h) - f(x - h)) / (2 * h); }, 0, epsilon);
 }
 /**
  * Compute the definite integral of a function.
@@ -540,12 +490,10 @@ function differentiate(f, x, h) {
  * @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
- * ```
  */
 function integrate(f, a, b, Ndx) {
-    if (Ndx === void 0) { Ndx = 1e3; }
+    if (Ndx === void 0) { Ndx = 1e6; }
     return ((b - a) / Ndx) * sum(linspace(a, b, Ndx).map(function (x) { return f(x); }));
 }
 /**
@@ -555,9 +503,7 @@ function integrate(f, a, b, Ndx) {
  * @param epsilon Maximum absolute error
  * @returns An object containing the fraction's numerator and denominator
  * @example
- * ```js
  * const frac = SMath.rat(0.625); // { num: 5, den: 8 }
- * ```
  */
 function rat(n, epsilon) {
     if (epsilon === void 0) { epsilon = 1e-6; }
@@ -581,25 +527,9 @@ function rat(n, epsilon) {
  * @param epsilon Maximum absolute error
  * @returns An object containing the whole part and fraction numerator and denominator
  * @example
- * ```js
  * const frac = SMath.mixed(-8 / 6); // { whole: -1, num: 1, den: 3 }
- * ```
  */
 function mixed(n, epsilon) {
     if (epsilon === void 0) { epsilon = 1e-6; }
     return __assign({ whole: n | 0 }, rat(n < -1 ? (n | 0) - n : n - (n | 0), epsilon));
 }
-/**
- * Convert any number to its hexadecimal equivalent.
- * @param n A decimal number to convert
- * @param length The minimum number of digits to show
- * @returns The number `n` converted to hexadecimal
- * @example
- * ```js
- * const hex = SMath.toHex(10, 2); // '0A'
- * ```
- */
-function toHex(n, length) {
-    if (length === void 0) { length = 0; }
-    return (n < 0 ? '-' : '') + (n < 0 ? -n : n).toString(16).padStart(length, '0').toUpperCase();
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.13.2",
+  "version": "1.14.0",
   "description": "Small math function library",
   "homepage": "https://npm.nicfv.com/",
   "bin": "dist/bin.js",
@@ -52,7 +52,7 @@
   "repository": "github:nicfv/npm",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "24.3.0",
+    "@types/node": "25.0.10",
     "t6": "1.2.1"
   }
 }

package/types/index.d.ts

@@ -12,10 +12,8 @@
  * @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
- * ```
  */
 export declare function approx(a: number, b: number, epsilon?: number): boolean;
 /**
@@ -25,10 +23,8 @@ export declare function approx(a: number, b: number, epsilon?: number): boolean;
  * @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
- * ```
  */
 export declare function clamp(n: number, min: number, max: number): number;
 /**
@@ -38,9 +34,7 @@ export declare function clamp(n: number, min: number, max: number): number;
  * @param max The maximum value in the range
  * @returns A normalized value
  * @example
- * ```js
  * const y = SMath.normalize(18, 9, 99); // 0.1
- * ```
  */
 export declare function normalize(n: number, min: number, max: number): number;
 /**
@@ -50,9 +44,7 @@ export declare function normalize(n: number, min: number, max: number): number;
  * @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
- * ```
  */
 export declare function expand(n: number, min: number, max: number): number;
 /**
@@ -64,10 +56,8 @@ export declare function expand(n: number, min: number, max: number): number;
  * @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
- * ```
  */
 export declare function translate(n: number, min1: number, max1: number, min2: number, max2: number): number;
 /**
@@ -77,10 +67,8 @@ export declare function translate(n: number, min1: number, max1: number, min2: n
  * @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 ]
- * ```
  */
 export declare function linspace(min: number, max: number, count: number): number[];
 /**
@@ -90,10 +78,8 @@ export declare function linspace(min: number, max: number, count: number): numbe
  * @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 ]
- * ```
  */
 export declare function logspace(min: number, max: number, count: number): number[];
 /**
@@ -101,9 +87,7 @@ export declare function logspace(min: number, max: number, count: number): numbe
  * @param n Any positive integer
  * @returns `n!`
  * @example
- * ```js
  * const y = SMath.factorial(5); // 120
- * ```
  */
 export declare function factorial(n: number): number;
 /**
@@ -111,9 +95,7 @@ export declare function factorial(n: number): number;
  * @param n Any positive integer
  * @returns The array of prime factors
  * @example
- * ```js
  * const y = SMath.factors(12); // [ 2, 2, 3 ]
- * ```
  */
 export declare function factors(n: number): number[];
 /**
@@ -123,9 +105,7 @@ export declare function factors(n: number): number[];
  * @param base Any base to round to
  * @returns `n` rounded to the nearest multiple of `base`
  * @example
- * ```js
  * const y = SMath.round2(Math.PI, 0.2); // 3.2
- * ```
  */
 export declare function round2(n: number, base: number): number;
 /**
@@ -139,9 +119,7 @@ export declare function round2(n: number, base: number): number;
  * @param actual The accepted or theoretical value
  * @returns The relative (normalized) error
  * @example
- * ```js
  * const e = SMath.error(22.5, 25); // -0.1
- * ```
  */
 export declare function error(experimental: number, actual: number): number;
 /**
@@ -150,9 +128,7 @@ export declare function error(experimental: number, actual: number): number;
  * @param data An array of numeric inputs
  * @returns The sum total
  * @example
- * ```js
  * const y = SMath.sum([1, 2, 3]); // 6
- * ```
  */
 export declare function sum(data: number[]): number;
 /**
@@ -161,9 +137,7 @@ export declare function sum(data: number[]): number;
  * @param data An array of numeric inputs
  * @returns The product
  * @example
- * ```js
  * const y = SMath.prod([2, 2, 3, 5]); // 60
- * ```
  */
 export declare function prod(data: number[]): number;
 /**
@@ -171,9 +145,7 @@ export declare function prod(data: number[]): number;
  * @param data An array of numeric inputs
  * @returns The average, or mean
  * @example
- * ```js
  * const y = SMath.avg([1, 2, 4, 4]); // 2.75
- * ```
  */
 export declare function avg(data: number[]): number;
 /**
@@ -181,9 +153,7 @@ export declare function avg(data: number[]): number;
  * @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
- * ```
  */
 export declare function median(data: number[]): number;
 /**
@@ -191,9 +161,7 @@ export declare function median(data: number[]): number;
  * @param data An array of numeric inputs
  * @returns The population variance
  * @example
- * ```js
  * const y = SMath.varp([1, 2, 4, 4]); // 1.6875
- * ```
  */
 export declare function varp(data: number[]): number;
 /**
@@ -201,9 +169,7 @@ export declare function varp(data: number[]): number;
  * @param data An array of numeric inputs
  * @returns The sample variance
  * @example
- * ```js
  * const y = SMath.vars([1, 2, 4, 4]); // 2.25
- * ```
  */
 export declare function vars(data: number[]): number;
 /**
@@ -211,9 +177,7 @@ export declare function vars(data: number[]): number;
  * @param data An array of numeric inputs
  * @returns The population standard deviation
  * @example
- * ```js
  * const y = SMath.stdevp([1, 2, 3, 4]); // 1.118...
- * ```
  */
 export declare function stdevp(data: number[]): number;
 /**
@@ -221,9 +185,7 @@ export declare function stdevp(data: number[]): number;
  * @param data An array of numeric inputs
  * @returns The sample standard deviation
  * @example
- * ```js
  * const y = SMath.stdevs([1, 2, 3, 4]); // 1.29...
- * ```
  */
 export declare function stdevs(data: number[]): number;
 /**
@@ -232,9 +194,7 @@ export declare function stdevs(data: number[]): number;
  * @param max The maximum bound
  * @returns A random float within the range
  * @example
- * ```js
  * const y = SMath.runif(-2, 2); // 0.376...
- * ```
  */
 export declare function runif(min: number, max: number): number;
 /**
@@ -243,9 +203,7 @@ export declare function runif(min: number, max: number): number;
  * @param max The maximum bound (inclusive)
  * @returns A random integer within the range
  * @example
- * ```js
  * const y = SMath.rint(-4, 3); // -4
- * ```
  */
 export declare function rint(min: number, max: number): number;
 /**
@@ -254,9 +212,7 @@ export declare function rint(min: number, max: number): number;
  * @param stdev The standard deviation of the population
  * @returns A random float
  * @example
- * ```js
  * const y = SMath.rnorm(2, 3); // 1.627...
- * ```
  */
 export declare function rnorm(mean?: number, stdev?: number): number;
 /**
@@ -266,9 +222,7 @@ export declare function rnorm(mean?: number, stdev?: number): number;
  * @param stdev The standard deviation of the population
  * @returns A population of random floats
  * @example
- * ```js
  * const dataset = SMath.rdist(3); // [ 1.051..., -0.779..., -2.254... ]
- * ```
  */
 export declare function rdist(count: number, mean?: number, stdev?: number): number[];
 /**
@@ -276,9 +230,7 @@ export declare function rdist(count: number, mean?: number, stdev?: number): num
  * @param stack An array of arbitrary elements
  * @returns The `stack` array in a random order
  * @example
- * ```js
  * const shuffled = SMath.shuffle(['a', 'b', 'c']); // [ 'c', 'a', 'b' ]
- * ```
  */
 export declare function shuffle<T>(stack: T[]): T[];
 /**
@@ -290,23 +242,19 @@ export declare function shuffle<T>(stack: T[]): T[];
  * @param discontinuity_cutoff The discontinuity cutoff
  * @returns `lim(f(x->x))`
  * @example
- * ```js
  * const y = SMath.lim(Math.log, 0); // -Infinity
- * ```
  */
 export declare function 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
+ * @param epsilon Small step value
  * @returns `f'(x)`
  * @example
- * ```js
  * const y = SMath.differentiate(x => 3 * x ** 2, 2); // 12
- * ```
  */
-export declare function differentiate(f: (x: number) => number, x: number, h?: number): number;
+export declare function differentiate(f: (x: number) => number, x: number, epsilon?: number): number;
 /**
  * Compute the definite integral of a function.
  * @param f Function `f(x)`
@@ -315,9 +263,7 @@ export declare function differentiate(f: (x: number) => number, x: number, h?: n
  * @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
- * ```
  */
 export declare function integrate(f: (x: number) => number, a: number, b: number, Ndx?: number): number;
 /**
@@ -327,9 +273,7 @@ export declare function integrate(f: (x: number) => number, a: number, b: number
  * @param epsilon Maximum absolute error
  * @returns An object containing the fraction's numerator and denominator
  * @example
- * ```js
  * const frac = SMath.rat(0.625); // { num: 5, den: 8 }
- * ```
  */
 export declare function rat(n: number, epsilon?: number): {
     num: number;
@@ -343,23 +287,10 @@ export declare function rat(n: number, epsilon?: number): {
  * @param epsilon Maximum absolute error
  * @returns An object containing the whole part and fraction numerator and denominator
  * @example
- * ```js
  * const frac = SMath.mixed(-8 / 6); // { whole: -1, num: 1, den: 3 }
- * ```
  */
 export declare function mixed(n: number, epsilon?: number): {
     whole: number;
     num: number;
     den: number;
 };
-/**
- * Convert any number to its hexadecimal equivalent.
- * @param n A decimal number to convert
- * @param length The minimum number of digits to show
- * @returns The number `n` converted to hexadecimal
- * @example
- * ```js
- * const hex = SMath.toHex(10, 2); // '0A'
- * ```
- */
-export declare function toHex(n: number, length?: number): string;