Comparison Methods

/**
 * Compares this BigNumber with n
 * @param {string|number|BigNumber} n - Value to compare with
 * @param {number} [base] - Base of n if string
 * @returns {number} 1 if greater, -1 if less, 0 if equal, null if either is NaN
 */
comparedTo(n, base): number

const x = new BigNumber(5);
const y = new BigNumber(3);

x.comparedTo(y);        // 1 (5 > 3)
y.comparedTo(x);        // -1 (3 < 5)
x.comparedTo(5);        // 0 (5 == 5)
x.comparedTo(NaN);      // null

// With different bases
x.comparedTo('110', 2); // -1 (5 < 6 in binary)

/**
 * Tests if this BigNumber equals n
 * @param {string|number|BigNumber} n - Value to compare with
 * @param {number} [base] - Base of n if string
 * @returns {boolean} True if equal, false otherwise
 */
isEqualTo(n, base): boolean

/**
 * Alias for isEqualTo
 */
eq(n, base): boolean

const x = new BigNumber(0);
const y = new BigNumber('1e-324');

x.isEqualTo(y);         // false (BigNumber is more precise)
x.eq('1e-324');         // false

// JavaScript comparison vs BigNumber
0 === 1e-324;           // true (JavaScript precision limit)
new BigNumber(0).isEqualTo('1e-324');  // false (exact comparison)

// Equal values in different bases
new BigNumber(255).eq('ff', 16);      // true
new BigNumber(-0).eq(0);              // true (-0 === 0)

// NaN comparison
new BigNumber(NaN).eq(NaN);           // false (NaN never equals NaN)

/**
 * Tests if this BigNumber is greater than n
 * @param {string|number|BigNumber} n - Value to compare with
 * @param {number} [base] - Base of n if string
 * @returns {boolean} True if greater, false otherwise
 */
isGreaterThan(n, base): boolean

/**
 * Alias for isGreaterThan
 */
gt(n, base): boolean

const x = new BigNumber(0.1);
const y = new BigNumber(0.3).minus(0.2);  // Exact 0.1

x.isGreaterThan(y);     // false (both are exactly 0.1)

// JavaScript floating point vs BigNumber precision
0.1 > (0.3 - 0.2);      // true (due to floating point error)
new BigNumber(0.1).gt(new BigNumber(0.3).minus(0.2));  // false (exact)

// Base comparisons
new BigNumber(11, 3).gt(11.1, 2);  // true

/**
 * Tests if this BigNumber is less than n
 * @param {string|number|BigNumber} n - Value to compare with
 * @param {number} [base] - Base of n if string
 * @returns {boolean} True if less, false otherwise
 */
isLessThan(n, base): boolean

/**
 * Alias for isLessThan
 */
lt(n, base): boolean

const x = new BigNumber(0.3).minus(0.2);  // Exact 0.1
const y = new BigNumber(0.1);

x.isLessThan(y);        // false (both exactly 0.1)

// Precision comparison
(0.3 - 0.2) < 0.1;      // true (JavaScript floating point)
new BigNumber(0.3).minus(0.2).lt(0.1);  // false (exact arithmetic)

// Base comparison
new BigNumber(11.1, 2).lt(11, 3);  // true

/**
 * Tests if this BigNumber is greater than or equal to n
 * @param {string|number|BigNumber} n - Value to compare with
 * @param {number} [base] - Base of n if string
 * @returns {boolean} True if greater or equal, false otherwise
 */
isGreaterThanOrEqualTo(n, base): boolean

/**
 * Alias for isGreaterThanOrEqualTo
 */
gte(n, base): boolean

const x = new BigNumber(0.3).minus(0.2);  // Exact 0.1
const y = new BigNumber(0.1);

x.isGreaterThanOrEqualTo(y);  // true (equal)
x.gte(0.05);                  // true (greater)

// Edge case comparisons
(0.3 - 0.2) >= 0.1;           // false (JavaScript precision)
new BigNumber(0.3).minus(0.2).gte(0.1);  // true (exact)

// Base comparisons
new BigNumber(10, 18).gte('i', 36);  // true

/**
 * Tests if this BigNumber is less than or equal to n
 * @param {string|number|BigNumber} n - Value to compare with
 * @param {number} [base] - Base of n if string
 * @returns {boolean} True if less or equal, false otherwise
 */
isLessThanOrEqualTo(n, base): boolean

/**
 * Alias for isLessThanOrEqualTo
 */
lte(n, base): boolean

const x = new BigNumber(0.1);
const y = new BigNumber(0.3).minus(0.2);  // Exact 0.1

x.isLessThanOrEqualTo(y);     // true (equal)
x.lte(0.2);                   // true (less)

// Precision edge cases
0.1 <= (0.3 - 0.2);           // false (JavaScript floating point)
new BigNumber(0.1).lte(new BigNumber(0.3).minus(0.2));  // true (exact)

// Base comparison
new BigNumber(10, 18).lte('i', 36);  // true

const nan = new BigNumber(NaN);
const num = new BigNumber(5);

nan.comparedTo(num);    // null
nan.isEqualTo(num);     // false
nan.isGreaterThan(num); // false
nan.isLessThan(num);    // false
nan.eq(NaN);            // false (NaN never equals anything)

const inf = new BigNumber(Infinity);
const negInf = new BigNumber(-Infinity);
const num = new BigNumber(1000000);

inf.isGreaterThan(num);     // true
negInf.isLessThan(num);     // true
inf.eq(Infinity);           // true
inf.eq(negInf);             // false

const zero = new BigNumber(0);
const negZero = new BigNumber(-0);
const tiny = new BigNumber('1e-1000');

zero.eq(negZero);           // true (-0 equals 0)
zero.isGreaterThan(tiny);   // false
zero.isLessThan(tiny);      // true

// JavaScript precision problems
console.log(0.1 + 0.2 === 0.3);  // false
console.log(0.1 + 0.2 > 0.3);    // true

// BigNumber exact comparisons
const a = new BigNumber(0.1);
const b = new BigNumber(0.2);
const c = new BigNumber(0.3);

console.log(a.plus(b).eq(c));     // true
console.log(a.plus(b).gt(c));     // false