Variable PositiveSafeInt

Type Declaration

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

  Adds two positive safe integers, returning a + b as a PositiveSafeInt.

  Example

  const sum = PositiveSafeInt.add(
    asPositiveSafeInt(1000),
    asPositiveSafeInt(2048),
  );
  
  assert.isTrue(sum === 3048);
  
  assert.isTrue(PositiveSafeInt.is(sum));
  Copy

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

  Divides two positive safe integers using floor division (⌊a / b⌋): the result is a / b rounded toward negative infinity, as a PositiveSafeInt.

  Example

  const quotient = PositiveSafeInt.div(
    asPositiveSafeInt(25),
    asPositiveSafeInt(4),
  );
  
  const clamped = PositiveSafeInt.div(
    asPositiveSafeInt(5),
    asPositiveSafeInt(50),
  );
  
  assert.isTrue(quotient === 6);
  
  assert.isTrue(clamped === 1);
  Copy

• fromNumber: (x: number) => PositiveSafeInt

  Converts an arbitrary number into a PositiveSafeInt, rounding to the nearest integer and saturating the result into the range [MIN_VALUE, MAX_VALUE].

  Unlike asPositiveSafeInt, this is total: out-of-range inputs are clamped to the nearest representable PositiveSafeInt instead of throwing.

  Example

  const belowRange = PositiveSafeInt.fromNumber(0);
  
  const withinRange = PositiveSafeInt.fromNumber(123);
  
  const aboveRange = PositiveSafeInt.fromNumber(Number.MAX_SAFE_INTEGER + 10);
  
  assert.isTrue(belowRange === 1);
  
  assert.isTrue(withinRange === 123);
  
  assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
  Copy

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

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

  Example

  assert.isTrue(isPositiveSafeInt(1));
  
  assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
  
  assert.isFalse(isPositiveSafeInt(0));
  
  assert.isTrue(PositiveSafeInt.is(42));
  Copy

  See

  isPositiveSafeInt for usage examples

• Readonlymax: (...values: readonly WithSmallInt<PositiveSafeInt>[]) => PositiveSafeInt

  Returns the largest of the given positive safe integers.

  Example

  const largest = PositiveSafeInt.max(
    asPositiveSafeInt(10),
    asPositiveSafeInt(5),
  );
  
  assert.isTrue(largest === 10);
  Copy

• MAX_VALUE: SafeUint

  The largest value representable as PositiveSafeInt (the upper saturation target of fromNumber).

• Readonlymin: (...values: readonly WithSmallInt<PositiveSafeInt>[]) => PositiveSafeInt

  Returns the smallest of the given positive safe integers.

  Example

  const smallest = PositiveSafeInt.min(
    asPositiveSafeInt(10),
    asPositiveSafeInt(5),
  );
  
  assert.isTrue(smallest === 5);
  Copy

• MIN_VALUE: 1

  The smallest value representable as PositiveSafeInt (the lower saturation target of fromNumber).

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

  Multiplies two positive safe integers, returning a * b as a PositiveSafeInt.

  Example

  const product = PositiveSafeInt.mul(
    asPositiveSafeInt(50),
    asPositiveSafeInt(20),
  );
  
  assert.isTrue(product === 1000);
  
  assert.isTrue(PositiveSafeInt.is(product));
  Copy

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

  Raises a to the power b, returning a ** b as a PositiveSafeInt (floored to an integer).

  Example

  const base = asPositiveSafeInt(3);
  
  const exponent = asPositiveSafeInt(3);
  
  const power = PositiveSafeInt.pow(base, exponent);
  
  assert.isTrue(power === 27);
  Copy

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

  Generates a random PositiveSafeInt within the given range.

  The range is inclusive on both ends.

  Example

  const min = asPositiveSafeInt(1);
  
  const max = asPositiveSafeInt(6);
  
  const randomValue = PositiveSafeInt.random(min, max);
  
  assert.isTrue(PositiveSafeInt.is(randomValue));
  
  assert.isTrue(randomValue >= 1 && randomValue <= 6);
  Copy

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

  Subtracts two positive safe integers, returning a - b as a PositiveSafeInt.

  Example

  const difference = PositiveSafeInt.sub(
    asPositiveSafeInt(10),
    asPositiveSafeInt(20),
  );
  
  assert.isTrue(difference === 1);
  
  assert.isTrue(PositiveSafeInt.is(difference));
  Copy