@lvlte/ulp 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ulp = exports.FLOAT64_MIN = void 0;
+exports.eps = eps;
+exports.exponent = exponent;
+exports.nextFloat = nextFloat;
+exports.prevFloat = prevFloat;
+exports.FLOAT64_MIN = Math.pow(2, -1022);
+function eps(x = 1) {
+    if (Number.isFinite(x)) {
+        x = Math.abs(x);
+        if (x <= exports.FLOAT64_MIN) {
+            return Number.MIN_VALUE;
+        }
+        return Math.pow(2, (_exponent(x) - 52));
+    }
+    return NaN;
+}
+exports.ulp = eps;
+function exponent(x) {
+    if (Number.isFinite(x) && x !== 0) {
+        return _exponent(Math.abs(x));
+    }
+    return NaN;
+}
+function _exponent(x) {
+    const s = x.toString(2);
+    return x < 1 ? -(s.split('1', 1)[0].length - 1) : s.split('.', 1)[0].length - 1;
+}
+function nextFloat(x) {
+    switch (x) {
+        case -Infinity:
+            return -Number.MAX_VALUE;
+        case Infinity:
+        case Number.MAX_VALUE:
+            return Infinity;
+        case -Number.MIN_VALUE:
+            return -0;
+        default:
+            if (!Number.isFinite(x)) {
+                return NaN;
+            }
+    }
+    const e = eps(x);
+    const y = x + e / 2;
+    return y > x ? y : x + e;
+}
+function prevFloat(x) {
+    return typeof x === 'number' ? -nextFloat(-x) : NaN;
+}

package/dist/index.d.ts

@@ -5,7 +5,8 @@ export declare const FLOAT64_MIN: number;
 /**
  * Return the unit in the last place or unit of least precision (ulp) of x, that
  * is, the distance between two consecutive representable floating-point numbers
- * at x.
+ * at x. If x is a power of 2, the distance on either side of x is different, in
+ * which case the larger distance is returned.
  *
  * @param x The input number (default: 1)
  * @returns The ulp of x, or `NaN` if `x` is not a finite number.
@@ -19,7 +20,25 @@ export declare const ulp: typeof eps;
  * Exponent of a normalized floating-point number x.
  *
  * @param x The input number
- * @returns The largest integer `y` such that `2^y ≤ |x|`, or `NaN` if x is not
- * a finite number / if x is ±0.
+ * @returns The largest integer `y` such that `2^y ≤ |x|`. If `x` is not a
+ * finite number or equals ±0, returns `NaN`.
  */
 export declare function exponent(x: number): number;
+/**
+ * Return the smallest representable floating-point number that comes after `x`
+ * on the float64 number line (towards +∞).
+ *
+ * @param x The input number
+ * @returns The smallest floating-point number `y` such that `y > x`. If `x` is
+ * `±Infinity` or `NaN`, returns `x`.
+ */
+export declare function nextFloat(x: number): number;
+/**
+ * Return the largest representable floating-point number that comes before `x`
+ * on the float64 number line (towards -∞).
+ *
+ * @param x The input number
+ * @returns The largest floating-point number `y` such that `y < x`. If `x` is
+ * `±Infinity` or `NaN`, returns `x`.
+ */
+export declare function prevFloat(x: number): number;

package/dist/index.js

@@ -1,4 +1,3 @@
-import { modf } from '@lvlte/modf';
 export const FLOAT64_MIN = Math.pow(2, -1022);
 export function eps(x = 1) {
     if (Number.isFinite(x)) {
@@ -18,9 +17,27 @@ export function exponent(x) {
     return NaN;
 }
 function _exponent(x) {
-    const [ipart, fpart] = modf(x);
-    if (ipart > 0) {
-        return ipart.toString(2).split('.', 1)[0].length - 1;
+    const s = x.toString(2);
+    return x < 1 ? -(s.split('1', 1)[0].length - 1) : s.split('.', 1)[0].length - 1;
+}
+export function nextFloat(x) {
+    switch (x) {
+        case -Infinity:
+            return -Number.MAX_VALUE;
+        case Infinity:
+        case Number.MAX_VALUE:
+            return Infinity;
+        case -Number.MIN_VALUE:
+            return -0;
+        default:
+            if (!Number.isFinite(x)) {
+                return NaN;
+            }
     }
-    return -(fpart.toString(2).split('1', 1)[0].length - 1);
+    const e = eps(x);
+    const y = x + e / 2;
+    return y > x ? y : x + e;
+}
+export function prevFloat(x) {
+    return typeof x === 'number' ? -nextFloat(-x) : NaN;
 }

package/package.json

@@ -1,25 +1,21 @@
 {
   "name": "@lvlte/ulp",
-  "version": "1.1.0",
-  "description": "Compute the unit in last place of a given IEEE-754 64-bit number",
+  "version": "1.2.0",
+  "description": "Compute the ULP of a given number / Get the closest representable number that comes before/after it on the float64 number line",
   "license": "MIT",
   "author": "Eric Lavault <lvlte.code@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/lvlte/ulp"
+    "url": "git+https://github.com/lvlte/ulp.git"
   },
   "type": "module",
-  "main": "./dist/cjs/index.js",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.ts",
-        "default": "./dist/cjs/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
   "engines": {
@@ -32,35 +28,33 @@
     "test": "jest",
     "prebuild": "rimraf dist && make-dir dist",
     "build": "tsc && tsc -p tsconfig-cjs.json",
-    "postbuild": "(echo { && echo   \"type\": \"commonjs\" && echo }) > ./dist/cjs/package.json",
-    "prepublishOnly": "npm test && npm run build && tsc --emitDeclarationOnly true --removeComments false && tsc -p tsconfig-cjs.json --emitDeclarationOnly true --removeComments false"
+    "postbuild": "mv dist/cjs/index.js dist/index.cjs && rimraf dist/cjs",
+    "prepublishOnly": "npm test && npm run build && tsc --emitDeclarationOnly true --removeComments false"
   },
   "keywords": [
     "number",
     "epsilon",
-    "function",
     "precision",
     "eps",
     "ulp",
+    "nextFloat",
+    "prevFloat",
+    "next",
+    "previous",
     "float",
     "float64",
     "IEEE-754",
     "rounding",
     "tolerance",
-    "compare",
-    "equal",
     "ULP"
   ],
   "devDependencies": {
-    "@lvlte/tsconfig": "^1.0.1",
+    "@lvlte/tsconfig": "^1.1.0",
     "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
     "make-dir-cli": "^4.0.0",
     "rimraf": "^6.0.1",
     "ts-jest": "29.2.5",
-    "typescript": "^5.9.2"
-  },
-  "dependencies": {
-    "@lvlte/modf": "^1.1.0"
+    "typescript": "^5.9.3"
   }
 }

package/readme.md

@@ -1,7 +1,10 @@
 # ulp (epsilon function)
 
 > Compute the [unit of least precision](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
-of a given IEEE-754 64-bit number.
+of a given IEEE-754 64-bit number : `eps(x)` (alias `ulp(x)`).<br>
+> Get the closest representable number that comes before/after it on the float64
+number line : `nextFloat(x)`, `prevFloat(x)`.
+
 
 ## Install
 
@@ -13,28 +16,43 @@ npm install @lvlte/ulp
 
 ```js
 // ESM
-import { eps } from '@lvlte/ulp';
+import { eps, nextFloat, prevFloat } from '@lvlte/ulp';
 ```
 ```js
 // CJS
-const { eps } = require('@lvlte/ulp');
+const { eps, nextFloat, prevFloat } = require('@lvlte/ulp');
+```
+```js
+console.log( eps() );                               // 2.220446049250313e-16
+console.log( eps() === eps(1) );                    // true
+console.log( eps() === Number.EPSILON );            // true
+
+console.log( eps(Number.MAX_SAFE_INTEGER) );        // 1
+console.log( eps(Number.MAX_SAFE_INTEGER + 1) );    // 2
+
+console.log( eps(0) );                              // 5e-324
+console.log( eps(0) === Number.MIN_VALUE );         // true
+
+console.log( eps(Infinity) );                       // NaN
 ```
 ```js
-console.log(eps());                             // 2.220446049250313e-16
-console.log(eps() === eps(1));                  // true
-console.log(eps() === Number.EPSILON);          // true
+console.log( nextFloat(0) );                        // 5e-324
+console.log( nextFloat(0) === Number.MIN_VALUE );   // true
 
-console.log(eps(Number.MAX_SAFE_INTEGER));      // 1
-console.log(eps(Number.MAX_SAFE_INTEGER + 1));  // 2
+console.log( nextFloat(1) );                        // 1.0000000000000002
+console.log( nextFloat(1) === 1 + eps(1) );         // true
 
-console.log(eps(0));                            // 5e-324
-console.log(eps(0) === Number.MIN_VALUE);       // true
+console.log( nextFloat(Number.MAX_SAFE_INTEGER) );  // 9007199254740992
+console.log( nextFloat(9007199254740992) );         // 9007199254740994
+console.log( nextFloat(Number.MAX_VALUE) );         // Infinity
 
-console.log(eps(Infinity));                     // NaN
+console.log( prevFloat(0) );                        // -5e-324
+console.log( prevFloat(1) );                        // 0.9999999999999999
+console.log( prevFloat(9007199254740992) );         // 9007199254740991
+console.log( prevFloat(Infinity) );                 // 1.7976931348623157e+308
 ```
 
 ## Use case
 
-- Check whether two floating point numbers can be considered equal.
-- Approximate a floating point number x as a rational number.
-- Get the next/previous float on the float64 number line.
+- Use the proper tolerance to check whether two floating-point numbers should be considered equal.
+- Use the proper tolerance to approximate a floating-point number as a rational number.

package/dist/cjs/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * The smallest positive normal number representable by IEEE-754 float64.
- */
-export declare const FLOAT64_MIN: number;
-/**
- * Return the unit in the last place or unit of least precision (ulp) of x, that
- * is, the distance between two consecutive representable floating-point numbers
- * at x.
- *
- * @param x The input number (default: 1)
- * @returns The ulp of x, or `NaN` if `x` is not a finite number.
- */
-export declare function eps(x?: number): number;
-/**
- * @borrows eps as ulp
- */
-export declare const ulp: typeof eps;
-/**
- * Exponent of a normalized floating-point number x.
- *
- * @param x The input number
- * @returns The largest integer `y` such that `2^y ≤ |x|`, or `NaN` if x is not
- * a finite number / if x is ±0.
- */
-export declare function exponent(x: number): number;

package/dist/cjs/index.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ulp = exports.FLOAT64_MIN = void 0;
-exports.eps = eps;
-exports.exponent = exponent;
-const modf_1 = require("@lvlte/modf");
-exports.FLOAT64_MIN = Math.pow(2, -1022);
-function eps(x = 1) {
-    if (Number.isFinite(x)) {
-        x = Math.abs(x);
-        if (x <= exports.FLOAT64_MIN) {
-            return Number.MIN_VALUE;
-        }
-        return Math.pow(2, (_exponent(x) - 52));
-    }
-    return NaN;
-}
-exports.ulp = eps;
-function exponent(x) {
-    if (Number.isFinite(x) && x !== 0) {
-        return _exponent(Math.abs(x));
-    }
-    return NaN;
-}
-function _exponent(x) {
-    const [ipart, fpart] = (0, modf_1.modf)(x);
-    if (ipart > 0) {
-        return ipart.toString(2).split('.', 1)[0].length - 1;
-    }
-    return -(fpart.toString(2).split('1', 1)[0].length - 1);
-}

package/dist/cjs/package.json

@@ -1,3 +0,0 @@
-{ 
-  "type": "commonjs" 
-}