Index

Modules: nint128, nint128/arithmetic/addition, nint128/arithmetic/division, nint128/arithmetic/minus, nint128/arithmetic/multiplication, nint128/arithmetic/subtraction, nint128/bitwise/bitand, nint128/bitwise/bitnot, nint128/bitwise/bitor, nint128/bitwise/bitxor, nint128/bitwise/shift, nint128/comparisons/equal, nint128/comparisons/greaterthan, nint128/comparisons/greaterthanorequal, nint128/comparisons/lessthan, nint128/comparisons/lessthanorequal, nint128/comparisons/notequal, nint128/nint128_arithmetic, nint128/nint128_bitops, nint128/nint128_bitwise, nint128/nint128_cast, nint128/nint128_cint128, nint128/nint128_comparisons, nint128/nint128_endians, nint128/nint128_io, nint128/nint128_math, nint128/nint128_types, nint128/vendor/stew/endians2.

API symbols

`$`:

• nint128_io: proc `$`(x: SomeInt128): string

`*=`:

• multiplication: proc `*=`[T: SomeInt128](x: var T; y: T)

`*`:

• multiplication: proc `*`(a, b: Int128): Int128
• multiplication: proc `*`(a, b: UInt128): UInt128
• multiplication: proc `*`(a: UInt128; b: uint64): UInt128
• multiplication: template `*`(a: uint64; b: UInt128): UInt128

`+=`:

• addition: proc `+=`[T: SomeInt128](x: var T; y: T)
• addition: proc `+=`[T: SomeInt128](x: var T; y: uint64)

`+`:

• addition: proc `+`(x, y: Int128): Int128
• addition: proc `+`(x: Int128; y: uint64): Int128
• addition: proc `+`(x, y: UInt128): UInt128
• addition: proc `+`(x: UInt128; y: uint64): UInt128
• addition: template `+`[T: SomeInt128](x: uint64; y: T): T

`-=`:

• subtraction: proc `-=`[T: SomeInt128](x: var T; y: T)
• subtraction: proc `-=`[T: SomeInt128](x: var T; y: uint64)

`-`:

• minus: proc `-`(x: Int128): Int128
• minus: proc `-`(x: UInt128): UInt128
• subtraction: proc `-`(x, y: Int128): Int128
• subtraction: proc `-`(x: Int128; y: uint64): Int128
• subtraction: proc `-`(x, y: UInt128): UInt128
• subtraction: proc `-`(x: UInt128; y: uint64): UInt128
• subtraction: template `-`[T: SomeInt128](x: uint64; y: T): T

`<=`:

• lessthanorequal: proc `<=`(x, y: Int128): bool
• lessthanorequal: proc `<=`(x, y: UInt128): bool

`<`:

• lessthan: proc `<`(x, y: Int128): bool
• lessthan: proc `<`(x, y: UInt128): bool

`==`:

• equal: proc `==`(x, y: Int128): bool
• equal: proc `==`(x, y: UInt128): bool

`and`:

• bitand: proc `and`(x, y: Int128): Int128
• bitand: proc `and`(x, y: UInt128): UInt128

`div`:

• division: proc `div`(x, y: Int128): Int128
• division: proc `div`(x: UInt128; y: static[UInt128]): UInt128
• division: proc `div`(x, y: UInt128): UInt128

`mod`:

• division: proc `mod`(x, y: Int128): Int128
• division: proc `mod`(x: UInt128; y: static[UInt128]): UInt128
• division: proc `mod`(x, y: UInt128): UInt128

`not`:

• bitnot: proc `not`(x: Int128): Int128
• bitnot: proc `not`(x: UInt128): UInt128

`or`:

• bitor: proc `or`(x, y: Int128): Int128
• bitor: proc `or`(x, y: UInt128): UInt128

`shl`:

• shift: proc `shl`[T: SomeInteger](x: Int128; y: T): Int128
• shift: proc `shl`[T: SomeInteger](x: UInt128; y: T): UInt128
• nint128_bitwise: template `shl`[T: SomeInt128](x: T; y: SomeInt128): T

`shr`:

• shift: proc `shr`[T: SomeInteger](x: Int128; y: T): Int128
• shift: proc `shr`[T: SomeInteger](x: UInt128; y: T): UInt128
• nint128_bitwise: template `shr`[T: SomeInt128](x: T; y: SomeInt128): T

`xor`:

• bitxor: proc `xor`(x, y: Int128): Int128
• bitxor: proc `xor`(x, y: UInt128): UInt128

abs:

• nint128_math: proc abs(x: Int128): Int128

add64Plus64ToI128:

• nint128_arithmetic: proc add64Plus64ToI128(x, y: uint64): Int128

add64Plus64ToU128:

• nint128_arithmetic: proc add64Plus64ToU128(x, y: uint64): UInt128

bitslice:

• nint128_bitops: proc bitslice(x: var Int128; slice: Slice[int])
• nint128_bitops: proc bitslice(x: var UInt128; slice: Slice[int])

CInt128:

• nint128_cint128: object CInt128

clearBit:

• nint128_bitops: proc clearBit[T: SomeInt128](x: var T; bit: range[0 .. 127])

countLeadingZeroBits:

• nint128_bitops: proc countLeadingZeroBits(x: SomeInt128): int

countSetBits:

• nint128_bitops: proc countSetBits(x: SomeInt128): int

countTrailingZeroBits:

• nint128_bitops: proc countTrailingZeroBits(x: SomeInt128): int

CUInt128:

• nint128_cint128: object CUInt128

dec:

• nint128_arithmetic: proc dec[T: SomeInt128](x: var T; y: T = one(T))

div128by64to64:

• division: proc div128by64to64(x: UInt128; y: uint64; remainder: var uint64): uint64

divmod:

• division: proc divmod(x, y: Int128): tuple[q, r: Int128]
• division: proc divmod(x, y: UInt128): tuple[q, r: UInt128]

fastLog2:

• nint128_bitops: proc fastLog2(x: SomeInt128): int

flipBit:

• nint128_bitops: proc flipBit[T: SomeInt128](x: var T; bit: range[0 .. 127])

floorSqrt:

• nint128_math: proc floorSqrt(x: Int128): Int128

fromBE:

• nint128_endians: proc fromBE(x: UInt128): UInt128
• endians2: proc fromBE[T: SomeEndianInt](x: T): T

fromBytes:

• nint128_endians: proc fromBytes(T: typedesc[UInt128]; x: openArray[byte]; endian: Endianness = system.cpuEndian): UInt128
• endians2: proc fromBytes(T: typedesc[SomeEndianInt]; x: openArray[byte]; endian: Endianness = system.cpuEndian): T:type

fromBytesBE:

• nint128_endians: proc fromBytesBE(T: typedesc[UInt128]; x: openArray[byte]): UInt128
• endians2: proc fromBytesBE(T: typedesc[SomeEndianInt]; x: openArray[byte]): T:type

fromBytesLE:

• nint128_endians: proc fromBytesLE(T: typedesc[UInt128]; x: openArray[byte]): UInt128
• endians2: proc fromBytesLE(T: typedesc[SomeEndianInt]; x: openArray[byte]): T:type

fromLE:

• nint128_endians: proc fromLE(x: UInt128): UInt128
• endians2: proc fromLE[T: SomeEndianInt](x: T): T

GreaterThan:

• greaterthan: template GreaterThan(x, y: SomeInt128): bool

GreaterThanOrEqual:

• greaterthanorequal: template GreaterThanOrEqual(x, y: SomeInt128): bool

gt:

• greaterthan: proc gt(x, y: Int128): bool
• greaterthan: proc gt(x, y: UInt128): bool

gte:

• greaterthanorequal: proc gte(x, y: Int128): bool
• greaterthanorequal: proc gte(x, y: UInt128): bool

high:

• nint128_types: proc high(x: typedesc[Int128]): Int128
• nint128_types: proc high(x: typedesc[UInt128]): UInt128

i128:

• nint128: proc i128(x: string): Int128
• nint128: proc i128[T: SomeInteger](x: T): Int128

inc:

• nint128_arithmetic: proc inc[T: SomeInt128](x: var T; y: T = one(T))

Int128:

• nint128_types: object Int128

isNegative:

• nint128_comparisons: proc isNegative(x: Int128): bool

low:

• nint128_types: proc low(x: typedesc[Int128]): Int128
• nint128_types: proc low(x: typedesc[UInt128]): UInt128

mul128by128ToTwo128:

• multiplication: proc mul128by128ToTwo128(a, b: UInt128; hi: var UInt128): UInt128
• multiplication: proc mul128by128ToTwo128(a, b: UInt128; hi, lo: var UInt128): bool

mul64by64To128:

• multiplication: proc mul64by64To128(a, b: uint64): UInt128
• multiplication: proc mul64by64To128(a, b: uint64; hi: var uint64): uint64

ne:

• notequal: proc ne(x, y: Int128): bool
• notequal: proc ne(x, y: UInt128): bool

nint128Cast:

• nint128_cast: template nint128Cast[T](x: Int128 | UInt128): T

notEqual:

• notequal: template notEqual(x, y: SomeInt128): bool

one:

• nint128_types: proc one[T: SomeInt128](x: typedesc[T]): T

parseInt128:

• nint128_io: proc parseInt128(x: string): Int128

parseUInt128:

• nint128_io: proc parseUInt128(x: string): UInt128

setBit:

• nint128_bitops: proc setBit[T: SomeInt128](x: var T; bit: range[0 .. 127])

shouldUseCInt128:

• nint128_cint128: proc shouldUseCInt128(cproc: string): bool

SomeEndianInt:

• endians2: type SomeEndianInt

SomeInt128:

• nint128_types: type SomeInt128

swapBytes:

• nint128_endians: proc swapBytes(x: UInt128): UInt128
• endians2: proc swapBytes[T: SomeEndianInt](x: T): T

ten:

• nint128_types: proc ten[T: SomeInt128](x: typedesc[T]): T

testBit:

• nint128_bitops: proc testBit[T: SomeInt128](x: var T; bit: range[0 .. 127]): bool

toBE:

• nint128_endians: proc toBE(x: UInt128): UInt128
• endians2: proc toBE[T: SomeEndianInt](x: T): T

toBin:

• nint128_io: proc toBin(x: UInt128): string
• nint128_io: proc toBin(x: UInt128; len: range[1 .. 128]): string

toBytes:

• nint128_endians: proc toBytes(x: UInt128; endian: Endianness = system.cpuEndian): array[16, byte]
• endians2: proc toBytes(x: SomeEndianInt; endian: Endianness = system.cpuEndian): array[ sizeof(x), byte]

toBytesBE:

• nint128_endians: proc toBytesBE(x: UInt128): array[16, byte]
• endians2: proc toBytesBE(x: SomeEndianInt): array[sizeof(x), byte]

toBytesLE:

• nint128_endians: proc toBytesLE(x: UInt128): array[16, byte]
• endians2: proc toBytesLE(x: SomeEndianInt): array[sizeof(x), byte]

toHex:

• nint128_io: proc toHex(x: UInt128): string
• nint128_io: proc toHex(x: UInt128; len: range[1 .. 32]): string

toLE:

• nint128_endians: proc toLE(x: UInt128): UInt128
• endians2: proc toLE[T: SomeEndianInt](x: T): T

toOct:

• nint128_io: proc toOct(x: UInt128): string
• nint128_io: proc toOct(x: UInt128; len: range[1 .. 43]): string

toString:

• nint128_io: proc toString[T: SomeInt128](x: T): string

u128:

• nint128: proc u128(x: SomeInteger): UInt128
• nint128: proc u128(x: string): UInt128

UInt128:

• nint128_types: object UInt128

zero:

• nint128_types: proc zero[T: SomeInt128](x: typedesc[T]): T