Variable SafeIntConst

Type Declaration

• abs: (x: WithSmallInt) => ToNonNegative<SafeInt>

  Returns the absolute value of a safe integer.

  Note: Math.abs(MIN_SAFE_INTEGER) would exceed MAX_SAFE_INTEGER, so this function clamps the result to maintain the safe integer guarantee.

  Example

  const negative = asSafeInt(-900);
  const absolute = SafeInt.abs(negative);
  
  assert(absolute === 900);
  assert.ok(SafeInt.is(absolute));
  Copy

• add: (x: WithSmallInt, y: WithSmallInt) => SafeInt

  Adds two SafeInt values.

  Example

  const sum = SafeInt.add(asSafeInt(9), asSafeInt(4));
  
  assert(sum === 13);
  assert.ok(SafeInt.is(sum));
  Copy

• clamp: (x: number) => SafeInt

  Clamps a number to the safe integer range.

  Example

  const aboveRange = SafeInt.clamp(1e20);
  const withinRange = SafeInt.clamp(123);
  const belowRange = SafeInt.clamp(-1e20);
  
  assert(aboveRange === Number.MAX_SAFE_INTEGER);
  assert(withinRange === 123);
  assert(belowRange === Number.MIN_SAFE_INTEGER);
  Copy

• div: (x: WithSmallInt, y: ToNonZeroIntWithSmallInt<SafeInt>) => SafeInt

  Divides one SafeInt by another using floor division.

  Performs mathematical floor division: ⌊a / b⌋. The divisor must be non-zero (enforced by type constraints).

  Example

  const quotient = SafeInt.div(asSafeInt(-17), asSafeInt(5));
  
  assert(quotient === -4);
  assert.ok(SafeInt.is(quotient));
  Copy

• is: (a: number) => a is SafeInt

  Type guard that checks if a value is a safe integer.

  Example

  assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
  assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
  assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
  Copy

  See

  isSafeInt for usage examples

• Readonlymax: (...values: readonly WithSmallInt<SafeInt, 40>[]) => SafeInt

  Returns the maximum value from a list of safe integers.

  Example

  const largest = SafeInt.max(asSafeInt(25), asSafeInt(-14), asSafeInt(99));
  
  assert(largest === 99);
  Copy

• ReadonlyMAX_VALUE: SafeUint

  The maximum safe integer value (2^53 - 1).

• Readonlymin: (...values: readonly WithSmallInt<SafeInt, 40>[]) => SafeInt

  Returns the minimum value from a list of safe integers.

  Example

  const smallest = SafeInt.min(asSafeInt(25), asSafeInt(-14), asSafeInt(99));
  
  assert(smallest === -14);
  Copy

• ReadonlyMIN_VALUE: SafeInt

  The minimum safe integer value (-(2^53 - 1)).

• mul: (x: WithSmallInt, y: WithSmallInt) => SafeInt

  Multiplies two SafeInt values.

  Example

  const product = SafeInt.mul(asSafeInt(-8), asSafeInt(7));
  
  assert(product === -56);
  assert.ok(SafeInt.is(product));
  Copy

• pow: (x: WithSmallInt, y: WithSmallInt) => SafeInt

  Raises a SafeInt to the power of another SafeInt.

  Example

  const base = asSafeInt(3);
  const exponent = asSafeInt(5);
  const power = SafeInt.pow(base, exponent);
  
  assert(power === 243);
  assert.ok(SafeInt.is(power));
  Copy

• random: (min?: WithSmallInt<SafeInt, 40>, max?: WithSmallInt<SafeInt, 40>) => SafeInt

  Generates a random safe integer within the specified range (inclusive).

  The range is inclusive on both ends. If min > max, they are automatically swapped.

  Example

  const min = asSafeInt(-10);
  const max = asSafeInt(10);
  const randomValue = SafeInt.random(min, max);
  
  assert.ok(SafeInt.is(randomValue));
  assert.ok(randomValue >= -10 && randomValue <= 10);
  Copy

• sub: (x: WithSmallInt, y: WithSmallInt) => SafeInt

  Subtracts one SafeInt from another.

  Example

  const difference = SafeInt.sub(asSafeInt(9), asSafeInt(14));
  
  assert(difference === -5);
  assert.ok(SafeInt.is(difference));
  Copy