tessl/npm-thi-ng--math

Assorted common math functions & utilities for TypeScript/JavaScript applications

—

Pending

Overview

Eval results

Files

Epsilon-Based Equality

Name: tessl/npm-thi-ng--math
Author: tessl

Floating-point equality comparison functions using epsilon tolerance to handle precision issues in numeric computations.

Capabilities

Fixed Epsilon Comparison

Basic epsilon-based equality checking with a fixed tolerance value.

/**
 * Checks if two numbers are equal within a fixed epsilon tolerance
 * Returns true if |a - b| <= eps
 * @param a - First value to compare
 * @param b - Second value to compare  
 * @param eps - Epsilon tolerance (default: 1e-6)
 * @returns True if values are equal within tolerance
 */
function eqDelta(a: number, b: number, eps?: number): boolean;

Scaled Epsilon Comparison

Adaptive epsilon-based equality that scales tolerance based on the magnitude of input values.

/**
 * Checks if two numbers are equal using scaled epsilon tolerance
 * Epsilon is factored with the largest absolute value: ε = ε * max(1, |a|, |b|)
 * More appropriate for comparing larger numbers where absolute differences may be larger
 * @param a - First value to compare
 * @param b - Second value to compare
 * @param eps - Base epsilon tolerance (default: 1e-6) 
 * @returns True if values are equal within scaled tolerance
 */
function eqDeltaScaled(a: number, b: number, eps?: number): boolean;

Usage Examples

import { eqDelta, eqDeltaScaled } from "@thi.ng/math/eqdelta";

// Fixed epsilon comparison
eqDelta(0.1 + 0.2, 0.3); // true (handles floating-point precision)
eqDelta(1.000001, 1.0); // false (difference exceeds default epsilon)
eqDelta(1.000001, 1.0, 1e-5); // true (with larger epsilon)

// Scaled epsilon comparison
eqDeltaScaled(1000.1, 1000.0); // true (scaled epsilon allows larger absolute difference)
eqDeltaScaled(0.1, 0.0); // false (scaled epsilon doesn't help with small numbers)

// Practical applications
const isNearZero = (x: number, eps = 1e-10) => eqDelta(x, 0, eps);
const isNearOne = (x: number, eps = 1e-10) => eqDelta(x, 1, eps);

// For large numbers, scaled comparison is better
const largeA = 1e10 + 1;
const largeB = 1e10;
eqDelta(largeA, largeB); // false (absolute difference is 1)
eqDeltaScaled(largeA, largeB); // true (relative difference is tiny)

// Comparing computation results
const computed = Math.sqrt(2) * Math.sqrt(2);
const expected = 2;
eqDelta(computed, expected); // true (handles computation precision errors)

// Array comparison with epsilon
const arraysEqual = (a: number[], b: number[], eps?: number) =>
  a.length === b.length && a.every((val, i) => eqDelta(val, b[i], eps));

arraysEqual([0.1 + 0.2, 0.4 + 0.5], [0.3, 0.9]); // true

Install with Tessl CLI