Variable PositiveSafeIntConst

Type Declaration

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

  Adds two PositiveSafeInt values.

  Example

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

• clamp: (x: number) => PositiveSafeInt

  Clamps a number to the positive safe integer range.

  Example

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

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

  Divides one PositiveSafeInt by another using floor division.

  Example

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

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

  Type guard to check if a value is a PositiveSafeInt.

  Example

  assert.ok(isPositiveSafeInt(1));
  assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
  assert.notOk(isPositiveSafeInt(0));
  assert.ok(PositiveSafeInt.is(42));
  Copy

  See

  isPositiveSafeInt for usage examples

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

  Returns the larger of two PositiveSafeInt values.

  Example

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

• ReadonlyMAX_VALUE: SafeUint

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

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

  Returns the smaller of two PositiveSafeInt values.

  Example

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

• ReadonlyMIN_VALUE: 1

  The minimum value for a positive safe integer.

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

  Multiplies two PositiveSafeInt values.

  Example

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

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

  Raises a PositiveSafeInt to the power of another PositiveSafeInt.

  Example

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

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

  Generates a random PositiveSafeInt value within the valid range.

  Example

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

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

  Subtracts one PositiveSafeInt from another.

  Example

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