Index

Modules: stint, stint/endians2, stint/int_modarith, stint/intops, stint/io, stint/literals_stint, stint/modular_arithmetic, stint/private/datatypes, stint/private/uint_addsub, stint/private/uint_bitwise, stint/private/uint_div, stint/private/uint_mul, stint/private/uint_shift, stint/uintops.

API symbols

`$`:

• io: proc `$`(num: StInt or StUint): string

`'i128`:

• stint: proc `'i128`(s: static string): Int128

`'i256`:

• stint: proc `'i256`(s: static string): Int256

`'u128`:

• stint: proc `'u128`(s: static string): UInt128

`'u256`:

• stint: proc `'u256`(s: static string): UInt256

`*`:

• intops: proc `*`(a, b: StInt): StInt
• literals_stint: proc `*`[bits: static[int]](a`gensym14: StUint[bits]; b`gensym14: int{lit}): StUint[ bits]
• literals_stint: proc `*`[bits: static[int]](a`gensym15: int{lit}; b`gensym15: StUint[bits]): StUint[ bits]
• literals_stint: proc `*`[bits: static[int]](a`gensym16: StInt[bits]; b`gensym16: int{lit}): StInt[ bits]
• literals_stint: proc `*`[bits: static[int]](a`gensym17: int{lit}; b`gensym17: StInt[bits]): StInt[ bits]
• uintops: proc `*`(a, b: StUint): StUint

`+=`:

• intops: proc `+=`(a: var StInt; b: SomeUnsignedInt)
• intops: proc `+=`(a: var StInt; b: StInt)
• literals_stint: proc `+=`[bits: static[int]](a`gensym6: StUint[bits]; b`gensym6: int{lit}): StUint[ bits]
• literals_stint: proc `+=`[bits: static[int]](a`gensym7: StInt[bits]; b`gensym7: int{lit}): StInt[bits]
• uint_addsub: proc `+=`(a: var StUint; b: SomeUnsignedInt)
• uint_addsub: proc `+=`(a: var StUint; b: StUint)

`+`:

• intops: proc `+`(a: StInt; b: SomeUnsignedInt): StInt
• intops: proc `+`(a, b: StInt): StInt
• literals_stint: proc `+`[bits: static[int]](a`gensym2: StUint[bits]; b`gensym2: int{lit}): StUint[ bits]
• literals_stint: proc `+`[bits: static[int]](a`gensym3: int{lit}; b`gensym3: StUint[bits]): StUint[ bits]
• literals_stint: proc `+`[bits: static[int]](a`gensym4: StInt[bits]; b`gensym4: int{lit}): StInt[bits]
• literals_stint: proc `+`[bits: static[int]](a`gensym5: int{lit}; b`gensym5: StInt[bits]): StInt[bits]
• uintops: proc `+`(a: StUint; b: SomeUnsignedInt): StUint
• uintops: proc `+`(a, b: StUint): StUint

`-=`:

• intops: proc `-=`(a: var StInt; b: StInt)
• literals_stint: proc `-=`[bits: static[int]](a`gensym12: StUint[bits]; b`gensym12: int{lit}): StUint[ bits]
• literals_stint: proc `-=`[bits: static[int]](a`gensym13: StInt[bits]; b`gensym13: int{lit}): StInt[ bits]
• uint_addsub: proc `-=`(a: var StUint; b: StUint)

`-`:

• intops: proc `-`(a: StInt): StInt
• intops: proc `-`(a, b: StInt): StInt
• literals_stint: proc `-`[bits: static[int]](a`gensym8: StUint[bits]; b`gensym8: int{lit}): StUint[ bits]
• literals_stint: proc `-`[bits: static[int]](a`gensym9: int{lit}; b`gensym9: StUint[bits]): StUint[ bits]
• literals_stint: proc `-`[bits: static[int]](a`gensym10: StInt[bits]; b`gensym10: int{lit}): StInt[ bits]
• literals_stint: proc `-`[bits: static[int]](a`gensym11: int{lit}; b`gensym11: StInt[bits]): StInt[ bits]
• uintops: proc `-`(a, b: StUint): StUint

`<=`:

• intops: proc `<=`(a, b: StInt): bool
• literals_stint: proc `<=`[bits: static[int]](a`gensym28: StUint[bits]; b`gensym28: int{lit}): bool
• literals_stint: proc `<=`[bits: static[int]](a`gensym29: int{lit}; b`gensym29: StUint[bits]): bool
• literals_stint: proc `<=`[bits: static[int]](a`gensym30: StInt[bits]; b`gensym30: int{lit}): bool
• literals_stint: proc `<=`[bits: static[int]](a`gensym31: int{lit}; b`gensym31: StInt[bits]): bool
• uintops: proc `<=`(a, b: StUint): bool

`<`:

• intops: proc `<`(a, b: StInt): bool
• literals_stint: proc `<`[bits: static[int]](a`gensym24: StUint[bits]; b`gensym24: int{lit}): bool
• literals_stint: proc `<`[bits: static[int]](a`gensym25: int{lit}; b`gensym25: StUint[bits]): bool
• literals_stint: proc `<`[bits: static[int]](a`gensym26: StInt[bits]; b`gensym26: int{lit}): bool
• literals_stint: proc `<`[bits: static[int]](a`gensym27: int{lit}; b`gensym27: StInt[bits]): bool
• uintops: proc `<`(a, b: StUint): bool

`==`:

• intops: proc `==`(a, b: StInt): bool
• literals_stint: proc `==`[bits: static[int]](a`gensym32: StUint[bits]; b`gensym32: int{lit}): bool
• literals_stint: proc `==`[bits: static[int]](a`gensym33: int{lit}; b`gensym33: StUint[bits]): bool
• literals_stint: proc `==`[bits: static[int]](a`gensym34: StInt[bits]; b`gensym34: int{lit}): bool
• literals_stint: proc `==`[bits: static[int]](a`gensym35: int{lit}; b`gensym35: StInt[bits]): bool
• uintops: proc `==`(a, b: StUint): bool

`[]=`:

• datatypes: template `[]=`(a: var StInt; i: SomeInteger or BackwardsIndex; val: Word)
• datatypes: template `[]=`(a: var StUint; i: SomeInteger or BackwardsIndex; val: Word)

`[]`:

• datatypes: template `[]`(a: StInt; i: SomeInteger or BackwardsIndex): Word
• datatypes: template `[]`(a: StUint; i: SomeInteger or BackwardsIndex): Word

`and`:

• intops: proc `and`(a, b: StInt): StInt
• literals_stint: proc `and`[bits: static[int]](a`gensym40: StUint[bits]; b`gensym40: int{lit}): StUint[ bits]
• literals_stint: proc `and`[bits: static[int]](a`gensym41: int{lit}; b`gensym41: StUint[bits]): StUint[ bits]
• literals_stint: proc `and`[bits: static[int]](a`gensym42: StInt[bits]; b`gensym42: int{lit}): StInt[ bits]
• literals_stint: proc `and`[bits: static[int]](a`gensym43: int{lit}; b`gensym43: StInt[bits]): StInt[ bits]
• uintops: proc `and`(a, b: StUint): StUint

`div`:

• intops: proc `div`(n, d: StInt): StInt
• literals_stint: proc `div`[bits: static[int]](a`gensym18: StUint[bits]; b`gensym18: int{lit}): StUint[ bits]
• literals_stint: proc `div`[bits: static[int]](a`gensym19: StInt[bits]; b`gensym19: int{lit}): StInt[ bits]
• uintops: proc `div`(x, y: StUint): StUint

`mod`:

• intops: proc `mod`(x, y: StInt): StInt
• literals_stint: proc `mod`[bits: static[int]](a`gensym20: StUint[bits]; b`gensym20: int{lit}): StUint[ bits]
• literals_stint: proc `mod`[bits: static[int]](a`gensym21: StInt[bits]; b`gensym21: int{lit}): StInt[ bits]
• uintops: proc `mod`(x, y: StUint): StUint

`not`:

• intops: proc `not`(a: StInt): StInt
• uintops: proc `not`(a: StUint): StUint

`or`:

• intops: proc `or`(a, b: StInt): StInt
• literals_stint: proc `or`[bits: static[int]](a`gensym36: StUint[bits]; b`gensym36: int{lit}): StUint[ bits]
• literals_stint: proc `or`[bits: static[int]](a`gensym37: int{lit}; b`gensym37: StUint[bits]): StUint[ bits]
• literals_stint: proc `or`[bits: static[int]](a`gensym38: StInt[bits]; b`gensym38: int{lit}): StInt[ bits]
• literals_stint: proc `or`[bits: static[int]](a`gensym39: int{lit}; b`gensym39: StInt[bits]): StInt[ bits]
• uintops: proc `or`(a, b: StUint): StUint

`shl`:

• intops: proc `shl`(a: StInt; k: SomeInteger): StInt
• uintops: proc `shl`(a: StUint; k: Natural): StUint

`shr`:

• intops: proc `shr`(a: StInt; k: SomeInteger): StInt
• uintops: proc `shr`(a: StUint; k: Natural): StUint

`xor`:

• intops: proc `xor`(a, b: StInt): StInt
• literals_stint: proc `xor`[bits: static[int]](a`gensym44: StUint[bits]; b`gensym44: int{lit}): StUint[ bits]
• literals_stint: proc `xor`[bits: static[int]](a`gensym45: int{lit}; b`gensym45: StUint[bits]): StUint[ bits]
• literals_stint: proc `xor`[bits: static[int]](a`gensym46: StInt[bits]; b`gensym46: int{lit}): StInt[ bits]
• literals_stint: proc `xor`[bits: static[int]](a`gensym47: int{lit}; b`gensym47: StInt[bits]): StInt[ bits]
• uintops: proc `xor`(a, b: StUint): StUint

abs:

• intops: proc abs(a: StInt): StInt

addmod:

• int_modarith: proc addmod(a, b, m: StInt): StInt
• modular_arithmetic: proc addmod(a, b, m: StUint): StUint

bitand:

• uint_bitwise: proc bitand(r: var StUint; a, b: StUint)

bitnot:

• uint_bitwise: proc bitnot(r: var StUint; a: StUint)

bitor:

• uint_bitwise: proc bitor(r: var StUint; a, b: StUint)

bitxor:

• uint_bitwise: proc bitxor(r: var StUint; a, b: StUint)

clearBit:

• intops: proc clearBit(a: var StInt; k: Natural)
• uintops: proc clearBit(a: var StUint; k: Natural)

clearExtraBitsOverMSB:

• datatypes: template clearExtraBitsOverMSB(a: var StUint | StInt)

copyWords:

• datatypes: proc copyWords(a: var openArray[Word]; startA: int; b: openArray[Word]; startB: int; numWords: int)

countOnes:

• uint_bitwise: proc countOnes(a: StUint): int

customLiteral:

• io: proc customLiteral(T: type SomeBigInteger; s: static string): T:type

diff:

• uint_addsub: proc diff(r: var StUint; a, b: StUint)

divmod:

• intops: proc divmod(n, d: StInt): tuple[quot, rem: StInt]
• literals_stint: proc divmod[bits: static[int]](a`gensym22: StUint[bits]; b`gensym22: int{lit}): StUint[ bits]
• literals_stint: proc divmod[bits: static[int]](a`gensym23: StInt[bits]; b`gensym23: int{lit}): StInt[ bits]
• uintops: proc divmod(x, y: StUint): tuple[quot, rem: StUint]

divRem:

• uint_div: proc divRem(q, r: var openArray[Word]; a, b: openArray[Word])

dumpHex:

• io: proc dumpHex(a: StInt or StUint; order: static[Endianness] = bigEndian): string

firstOne:

• uint_bitwise: proc firstOne(a: StUint): int

fromBytes:

• endians2: proc fromBytes[bits: static int](T: typedesc[StInt[bits]]; x: openArray[byte]; srcEndian: Endianness): T:type
• endians2: proc fromBytes[bits: static int](T: typedesc[StUint[bits]]; src: array[bits div 8, byte]; srcEndian: Endianness): T:type
• endians2: proc fromBytes[bits: static int](T: typedesc[StUint[bits]]; src: openArray[byte]; srcEndian: Endianness): T:type

fromBytesBE:

• endians2: proc fromBytesBE[bits: static int](T: typedesc[StInt[bits]]; x: openArray[byte]): T:type
• endians2: proc fromBytesBE[bits: static int](T: typedesc[StUint[bits]]; src: array[bits div 8, byte]): T:type
• endians2: proc fromBytesBE[bits: static int](T: typedesc[StUint[bits]]; src: openArray[byte]): T:type

fromBytesLE:

• endians2: proc fromBytesLE[bits: static int](T: typedesc[StInt[bits]]; x: openArray[byte]): T:type
• endians2: proc fromBytesLE[bits: static int](T: typedesc[StUint[bits]]; src: array[bits div 8, byte]): T:type
• endians2: proc fromBytesLE[bits: static int](T: typedesc[StUint[bits]]; src: openArray[byte]): T:type

fromDecimal:

• io: proc fromDecimal(T: typedesc[StUint | StInt]; s: string): T:type

fromHex:

• io: proc fromHex(T: typedesc[StUint | StInt]; s: string): T:type

GCC_Compatible:

• datatypes: const GCC_Compatible

getBit:

• intops: proc getBit(a: StInt; k: Natural): bool
• uintops: proc getBit(a: StUint; k: Natural): bool

hash:

• io: template hash(num: StUint | StInt): Hash

hexToUint:

• io: proc hexToUint[bits: static[int]](hexString: string): StUint[bits]

high:

• intops: proc high[bits](_: typedesc[StInt[bits]]): StInt[bits]
• uintops: proc high[bits](_: typedesc[StUint[bits]]): StUint[bits]

i128:

• stint: proc i128(n: SomeInteger): Int128
• stint: proc i128(s: string): Int128

i256:

• stint: proc i256(n: SomeInteger): Int256
• stint: proc i256(s: string): Int256

inc:

• intops: proc inc(a: var StInt; w: Word = 1)
• uint_addsub: proc inc(a: var StUint; w: Word = 1)

initFromBytesBE:

• io: template initFromBytesBE(x: var StInt; ba: openArray[byte])
• io: template initFromBytesBE(x: var StUint; ba: openArray[byte])

initFromBytesLE:

• io: template initFromBytesLE(x: var StInt; ba: openArray[byte])
• io: template initFromBytesLE(x: var StUint; ba: openArray[byte])

Int128:

• stint: type Int128

Int256:

• stint: type Int256

isEven:

• intops: proc isEven(a: StInt): bool
• uintops: proc isEven(a: StUint): bool

isNegative:

• intops: proc isNegative(a: StInt): bool

isOdd:

• intops: proc isOdd(a: StInt): bool
• uintops: proc isOdd(a: StUint): bool

isOne:

• intops: proc isOne(a: StInt): bool
• uintops: proc isOne(a: StUint): bool

isPositive:

• intops: proc isPositive(a: StInt): bool

isZero:

• intops: proc isZero(a: StInt): bool
• uintops: proc isZero(a: StUint): bool

leadingZeros:

• uint_bitwise: proc leadingZeros(a: StUint): int

leastSignificantWord:

• io: template leastSignificantWord(a: SomeBigInteger): Word

len:

• datatypes: template len(a: StInt): int
• datatypes: template len(a: StUint): int

Limbs:

• datatypes: type Limbs

limbs:

• datatypes: template limbs(a: StInt): untyped

low:

• intops: proc low[bits](_: typedesc[StInt[bits]]): StInt[bits]
• uintops: proc low[bits](_: typedesc[StUint[bits]]): StUint[bits]

mostSignificantWord:

• io: template mostSignificantWord(a: SomeBigInteger): Word

mtoIsNeg:

• literals_stint: template mtoIsNeg{ a < 0 }(a: StInt): bool

mtoIsNegOrZero:

• literals_stint: template mtoIsNegOrZero{ a <= 0 }(a: StInt): bool

mtoIsPos:

• literals_stint: template mtoIsPos{ 0 < a }(a: StInt): bool

mtoIsPosOrZero:

• literals_stint: template mtoIsPosOrZero{ 0 <= a }(a: StInt): bool

mtoIsZeroL:

• literals_stint: template mtoIsZeroL{ a == 0 }(a: StUint or StInt): bool

mtoIsZeroR:

• literals_stint: template mtoIsZeroR{ 0 == a }(a: StUint or StInt): bool

mulmod:

• int_modarith: proc mulmod(a, b, m: StInt): StInt
• modular_arithmetic: proc mulmod(a, b, m: StUint): StUint

neg:

• intops: proc neg(a: StInt): StInt

negate:

• intops: proc negate(a: var StInt)

one:

• intops: proc one[bits: static[int]](T: typedesc[StInt[bits]]): T:type
• uintops: proc one[bits: static[int]](T: typedesc[StUint[bits]]): T:type

parity:

• uint_bitwise: proc parity(a: StUint): int

parse:

• io: proc parse[bits: static[int]](input: string; T: typedesc[StInt[bits]]; radix: static[uint8] = 10): T:type
• io: proc parse[bits: static[int]](input: string; T: typedesc[StUint[bits]]; radix: static[uint8] = 10): T:type

pow:

• intops: proc pow(a: StInt; e: Natural): StInt
• intops: proc pow[aBits, eBits](a: StInt[aBits]; e: StInt[eBits]): StInt[aBits]
• uintops: proc pow(a: StUint; e: Natural): StUint
• uintops: proc pow[aBits, eBits](a: StUint[aBits]; e: StUint[eBits]): StUint[aBits]

powmod:

• int_modarith: proc powmod(base, exp, m: StInt): StInt
• modular_arithmetic: proc powmod(a, b, m: StUint): StUint

prod:

• uint_mul: proc prod[rLen, aLen, bLen: static int](r: var Limbs[rLen]; a: Limbs[aLen]; b: Limbs[bLen])

prod_high_words:

• uint_mul: proc prod_high_words[rLen, aLen, bLen: static int](r: var Limbs[rLen]; a: Limbs[aLen]; b: Limbs[bLen]; lowestWordIndex: static int)

readIntBE:

• io: proc readIntBE[bits: static[int]](ba: openArray[byte]): StInt[bits]

readIntLE:

• io: proc readIntLE[bits: static[int]](ba: openArray[byte]): StInt[bits]

readUintBE:

• io: proc readUintBE[bits: static[int]](ba: openArray[byte]): StUint[bits]

readUintLE:

• io: proc readUintLE[bits: static[int]](ba: openArray[byte]): StUint[bits]

setBit:

• intops: proc setBit(a: var StInt; k: Natural)
• uintops: proc setBit(a: var StUint; k: Natural)

setOne:

• intops: proc setOne(a: var StInt)
• uintops: proc setOne(a: var StUint)

setZero:

• intops: proc setZero(a: var StInt)
• uintops: proc setZero(a: var StUint)

shiftLeft:

• uint_shift: proc shiftLeft(r: var StUint; a: StUint; k: SomeInteger)

shiftRight:

• uint_shift: proc shiftRight(r: var StUint; a: StUint; k: SomeInteger)

shlLarge:

• uint_shift: proc shlLarge(r: var Limbs; a: Limbs; w, shift: SomeInteger)

shlSmall:

• uint_shift: proc shlSmall(r: var Limbs; a: Limbs; k: SomeInteger)

shlWords:

• uint_shift: proc shlWords(r: var Limbs; a: Limbs; w: SomeInteger)

shortDiv:

• uint_div: proc shortDiv(a: var Limbs; k: Word): Word

shrLarge:

• uint_shift: proc shrLarge(r: var Limbs; a: Limbs; w, shift: SomeInteger)

shrSmall:

• uint_shift: proc shrSmall(r: var Limbs; a: Limbs; k: SomeInteger)

shrWords:

• uint_shift: proc shrWords(r: var Limbs; a: Limbs; w: SomeInteger)

sign:

• intops: proc sign(a: StInt): int

SignedWord:

• datatypes: type SignedWord

signedWordType:

• io: template signedWordType(_: type SomeBigInteger): type

SomeBigInteger:

• datatypes: type SomeBigInteger

staticFor:

• datatypes: macro staticFor(idx: untyped{nkIdent}; start, stopEx: static int; body: untyped): untyped

stint:

• io: proc stint(a: StInt; bits: static[int]): StInt[bits]
• io: proc stint(a: StUint; bits: static[int]): StInt[bits]
• io: proc stint[T: SomeInteger](n: T; bits: static[int]): StInt[bits]

StInt:

• datatypes: object StInt

stuint:

• io: proc stuint(a: StInt; bits: static[int]): StUint[bits]
• io: proc stuint(a: StUint; bits: static[int]): StUint[bits]
• io: proc stuint[T: SomeInteger](n: T; bits: static[int]): StUint[bits]

StUint:

• datatypes: object StUint

submod:

• int_modarith: proc submod(a, b, m: StInt): StInt
• modular_arithmetic: proc submod(a, b, m: StUint): StUint

sum:

• uint_addsub: proc sum(r: var StUint; a: StUint; b: SomeUnsignedInt)
• uint_addsub: proc sum(r: var StUint; a, b: StUint)

swap:

• io: proc swap(a, b: var (StUint | StInt))

to:

• io: proc to(a: SomeInteger; T: typedesc[StInt]): T:type
• io: proc to(a: SomeUnsignedInt; T: typedesc[StUint]): T:type

toByteArrayBE:

• io: proc toByteArrayBE[bits: static[int]](n: StUint[bits]): array[bits div 8, byte]

toByteArrayLE:

• io: template toByteArrayLE[bits: static[int]](n: StInt[bits]): array[bits div 8, byte]
• io: template toByteArrayLE[bits: static[int]](n: StUint[bits]): array[bits div 8, byte]

toBytes:

• endians2: proc toBytes[bits: static int](x: StInt[bits]; endian: Endianness): array[bits div 8, byte]
• endians2: proc toBytes[bits: static int](x: StUint[bits]; endian: Endianness): array[ bits div 8, byte]

toBytesBE:

• endians2: proc toBytesBE[bits: static int](src: StInt[bits]): array[bits div 8, byte]
• endians2: proc toBytesBE[bits: static int](src: StUint[bits]): array[bits div 8, byte]

toBytesLE:

• endians2: proc toBytesLE[bits: static int](src: StInt[bits]): array[bits div 8, byte]
• endians2: proc toBytesLE[bits: static int](src: StUint[bits]): array[bits div 8, byte]

toHex:

• io: proc toHex[bits: static[int]](num: StInt[bits] or StUint[bits]): string

toString:

• io: proc toString[bits: static[int]](num: StInt[bits]; radix: static[uint8] = 10): string
• io: proc toString[bits: static[int]](num: StUint[bits]; radix: static[uint8] = 10): string

trailingZeros:

• uint_bitwise: proc trailingZeros(a: StUint): int

truncate:

• io: proc truncate(num: StInt; T: typedesc[SomeInteger]): T:type
• io: proc truncate(num: StUint; T: typedesc[SomeInteger]): T:type

u128:

• stint: proc u128(n: SomeInteger): UInt128
• stint: proc u128(s: string): UInt128

u256:

• stint: proc u256(n: SomeInteger): UInt256
• stint: proc u256(s: string): UInt256

UInt128:

• stint: type UInt128

uint128:

• datatypes: object uint128

UInt256:

• stint: type UInt256

usedBitsAndWords:

• datatypes: proc usedBitsAndWords(a: openArray[Word]): tuple[bits, words: int]

Word:

• datatypes: type Word

WordBitWidth:

• datatypes: const WordBitWidth

wordsRequired:

• datatypes: proc wordsRequired(bits: int): int

wordType:

• io: template wordType(_: type SomeBigInteger): type

X86:

• datatypes: const X86

zero:

• intops: proc zero[bits: static[int]](T: typedesc[StInt[bits]]): T:type
• uintops: proc zero[bits: static[int]](T: typedesc[StUint[bits]]): T:type