Variable UintConst

Type Declaration

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

  Adds two Uint values.

  Example

  const sum = Uint.add(asUint(5), asUint(8));
  
  assert(sum === 13);
  Copy

• clamp: (x: number) => NonNegativeInt

  Clamps a number to the Uint range (non-negative).

  Example

  const clampedNegative = Uint.clamp(-5);
  const clampedPositive = Uint.clamp(42);
  
  assert(clampedNegative === 0);
  assert(clampedPositive === 42);
  Copy

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

  Divides one Uint by another using floor division.

  Example

  const quotient = Uint.div(asUint(10), asUint(4));
  
  assert(quotient === 2);
  Copy

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

  Type guard to check if a value is a Uint.

  Example

  assert.ok(isUint(4));
  assert.notOk(isUint(-1));
  assert.ok(Uint.is(0));
  Copy

  See

  isUint for usage examples

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

  Returns the larger of two Uint values.

  Example

  const largest = Uint.max(asUint(7), asUint(3));
  
  assert(largest === 7);
  Copy

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

  Returns the smaller of two Uint values.

  Example

  const smallest = Uint.min(asUint(7), asUint(3));
  
  assert(smallest === 3);
  Copy

• ReadonlyMIN_VALUE: 0

  The minimum value for an unsigned integer.

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

  Multiplies two Uint values.

  Example

  const product = Uint.mul(asUint(7), asUint(6));
  
  assert(product === 42);
  Copy

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

  Raises a Uint to the power of another Uint.

  Example

  const base = asUint(2);
  const exponent = asUint(5);
  const power = Uint.pow(base, exponent);
  
  assert(power === 32);
  Copy

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

  Generates a random Uint value.

  Example

  const min = asUint(0);
  const max = asUint(3);
  const randomValue = Uint.random(min, max);
  
  assert.ok(Uint.is(randomValue));
  assert.ok(randomValue >= 0 && randomValue <= 3);
  Copy

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

  Subtracts one Uint from another.

  Example

  const difference = Uint.sub(asUint(5), asUint(8));
  
  assert(difference === 0);
  Copy