Index
Modules:
adix/althash
,
adix/amoft
,
adix/bist
,
adix/bitop
,
adix/bltab
,
adix/btree
,
adix/cpuCT
,
adix/cumsum
,
adix/ditab
,
adix/lghisto
,
adix/lptabz
,
adix/memutil
,
adix/metab
,
adix/mvstat
,
adix/nsort
,
adix/sequint
,
adix/tdigest
,
adix/uniqce
,
adix/xlang
.
API symbols
`$`:
ditab: `$`[K](s: DITab[K, void]): string
ditab: `$`[K, V: not void](t: DITab[K, V]): string
lghisto: `$`[C](s: LgHisto[C]; nonZero = true): string
lptabz: `$`[K, Z; z: static int](s: LPTabz[K, void, Z, z]): string
lptabz: `$`[K, V: not void; Z; z: static int](t: LPTabz[K, V, Z, z]): string
mvstat: `$`[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): string
sequint: `$`(s: SeqUint): string
`&=`:
xlang: `&=`[T, U](a: var T; b: U)
`>>=`:
xlang: `>>=`[T, U](a: var T; b: U)
`<<=`:
xlang: `<<=`[T, U](a: var T; b: U)
`<=`:
ditab: `<=`[K](s, t: DITab[K, void]): bool
lptabz: `<=`[K, Z; z: static int](s, t: LPTabz[K, void, Z, z]): bool
`<`:
ditab: `<`[K](s, t: DITab[K, void]): bool
lptabz: `<`[K, Z; z: static int](s, t: LPTabz[K, void, Z, z]): bool
`*`:
ditab: `*`[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: `*`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
`+=`:
mvstat: `+=`[F](a: var BasicStats[F]; b: BasicStats[F])
`+`:
ditab: `+`[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: `+`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
mvstat: `+`[F](a, b: BasicStats[F]): BasicStats[F]
`-+-`:
ditab: `-+-`[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: `-+-`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
`-`:
ditab: `-`[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: `-`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
`==`:
ditab: `==`[K, V](x, y: DITab[K, V]): bool
ditab: `==`[K](s, t: DITab[K, void]): bool
lptabz: `==`[K, Z; z: static int](s, t: LPTabz[K, void, Z, z]): bool
lptabz: `==`[K, V: not void; Z; z: static int](x, y: LPTabz[K, V, Z, z]): bool
`[]=`:
bist: `[]=`[T](t: var Bist[T]; i: int; x: T)
ditab: `[]=`[K, V](t: var DITab[K, V]; key: K; val: V)
lptabz: `[]=`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V)
sequint: `[]=`(s: var SeqUint; i: int | uint; x: int | uint)
`[]`:
bist: `[]`[T](t: Bist[T]; i: int): T
bist: `[]`[T](t: var Bist[T]; i: int): var T
ditab: `[]`[K, V](t: DITab[K, V]; key: K): V
ditab: `[]`[K, V](t: var DITab[K, V]; key: K): var V
lptabz: `[]`[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): V
lptabz: `[]`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K): var V
sequint: `[]`(s: SeqUint; i: int | uint): uint
`^=`:
xlang: `^=`[T, U](a: var T; b: U)
`{}=`:
ditab: `{}=`[K, V](t: var DITab[K, V]; key: K; val: V)
lptabz: `{}=`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V)
`{}`:
ditab: `{}`[K, V](t: DITab[K, V]; key: K): V
ditab: `{}`[K, V](t: var DITab[K, V]; key: K): var V
lptabz: `{}`[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): V
lptabz: `{}`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K): var V
`|=`:
xlang: `|=`[T, U](a: var T; b: U)
add:
lghisto: add[F, C](s: var LgHisto[C]; x: F; w = 1.C)
lptabz: add[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V)
lptabz: add[K, Z; z: static int](t: var LPTabz[K, void, Z, z]; key: K)
mvstat: add[F](a: var BasicStats[F]; b: BasicStats[F])
sequint: add(s: var SeqUint; v: uint)
tdigest: add(s: var DigesT; x: float; w = 1)
tdigest: add(s: var DigesT; others: var openArray[DigesT])
addr0:
sequint: addr0(s: SeqUint): pointer
allItems:
lptabz: allItems[K, Z; z: static int](s: LPTabz[K, void, Z, z]; key: K): K
allValues:
lptabz: allValues[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K; vals: var seq[V]): bool
lptabz: allValues[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): V
lptabz: allValues[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; vals: var seq[V]): K
AMOft:
amoft: AMOft
BasicStats:
mvstat: BasicStats
basicStats:
mvstat: basicStats[F: SomeFloat](xs: openArray[F]): BasicStats[F]
binAB:
lghisto: binAB[F, C](s: LgHisto[C]; x: F): (float, float)
bins:
lghisto: bins[C](s: LgHisto[C]): (float, float, C)
Bist:
bist: Bist
bist:
lghisto: bist[C](s: LgHisto[C]): Bist[C]
bits:
sequint: bits(s: SeqUint): int
blDenom:
bltab: blDenom
blGrowPow2:
bltab: blGrowPow2
blInitialSize:
bltab: blInitialSize
blMinFree:
bltab: blMinFree
blNumer:
bltab: blNumer
blRehash:
bltab: blRehash
blRobinHood:
bltab: blRobinHood
blSentinel:
bltab: blSentinel
BLTab:
bltab: BLTab
blValueBits:
bltab: blValueBits
btLinearNode:
btree: btLinearNode(Ob, K, Pos: type; M: untyped; Ix, Ln: type)
btPool:
btree: btPool(Ob, Pos: type; nodeSize: int; Ix, Ln: type)
card:
ditab: card[K](s: DITab[K, void]): int
lptabz: card[K, Z; z: static int](s: LPTabz[K, void, Z, z]): int
ccPreDefs:
cpuCT: ccPreDefs
cdf:
bist: cdf[T](t: Bist[T]; i: int): T
lghisto: cdf[F, C](s: LgHisto[C]; x: F): C
mvstat: cdf[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]; x: float): float
tdigest: cdf(s: var DigesT; x: float): float
ceilPow2:
bitop: ceilPow2(x: int): int
cfor:
xlang: cfor(init, test, update, body: untyped)
clear:
bist: clear[T](t: var Bist[T])
bltab: clear(s: var BLTab)
ditab: clear[K, V](t: var DITab[K, V])
lptabz: clear[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z])
mvstat: clear[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C])
sequint: clear(s: var SeqUint)
compress:
tdigest: compress(s: var DigesT)
contains:
bltab: contains(s: BLTab; hc: Hash): bool
ditab: contains[K, V](t: DITab[K, V]; key: K): bool
lptabz: contains[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): bool
containsOrIncl:
bltab: containsOrIncl(s: var BLTab; hc: Hash): bool
ditab: containsOrIncl[K](t: var DITab[K, void]; key: K): bool
lptabz: containsOrIncl[K, Z; z: static int](t: var LPTabz[K, void, Z, z]; key: K): bool
count:
bist: count[T](t: Bist[T]): int
CtMnSketch:
amoft: CtMnSketch
cumsum:
cumsum: cumsum[T](c: var openArray[T])
cumsum: cumsum[T](c: ptr T; n: uint)
cumsum: cumsum[T](c: ptr UncheckedArray[T]; n: uint)
cumsum: cumsum(c: ptr UncheckedArray[uint16]; n: uint)
cumsum: cumsum(c: ptr UncheckedArray[uint32]; n: uint)
cumsum: cumsum(c: ptr UncheckedArray[uint64]; n: uint)
cumsum: cumsum(c: ptr UncheckedArray[uint8]; n: uint)
dbg:
althash: dbg(x)
debugDump:
bltab: debugDump(s: BLTab; label = "")
ditab: debugDump[K, V](t: DITab[K, V]; label = "")
lptabz: debugDump[K, V, Z; z: static int](s: LPTabz[K, V, Z, z]; label = "")
defBTree:
btree: defBTree(Ob: type; K: type = void; Pos: type = void; ObSize: type = void; nodeSize: int = 16; Ix: type = int16; Ln: type = uint16; allocProcs = btPool; nodeProcs = btLinearNode)
del:
ditab: del[K, V](t: var DITab[K, V]; key: K)
lptabz: del[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K)
depths:
bltab: depths(s: BLTab): seq[int]
ditab: depths[K, V](t: DITab[K, V]): seq[int]
lptabz: depths[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): seq[int]
depthStats:
ditab: depthStats[K, V](s: DITab[K, V]): tuple[m1, m2: float, mx: int]
lptabz: depthStats[K, V, Z; z: static int](s: LPTabz[K, V, Z, z]): tuple[m1, m2: float, mx: int]
diDenom:
ditab: diDenom
difference:
ditab: difference[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: difference[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
DigesT:
tdigest: DigesT
diGrowPow2:
ditab: diGrowPow2
diInitialSize:
ditab: diInitialSize
diMinFree:
ditab: diMinFree
diNumer:
ditab: diNumer
diRehash:
ditab: diRehash
diRobinHood:
ditab: diRobinHood
DISet:
ditab: DISet
disjoint:
ditab: disjoint[K](s1, s2: DITab[K, void]): bool
lptabz: disjoint[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): bool
DITab:
ditab: DITab
editKey:
ditab: editKey[K, V](t: var DITab[K, V]; old, new: K)
lptabz: editKey[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; old, new: K)
editOrInit:
ditab: editOrInit[K, V](t: var DITab[K, V]; key: K; v, body1, body2: untyped)
lptabz: editOrInit[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; v, found, missing: untyped): untyped
excl:
ditab: excl[K](s: var DITab[K, void]; other: DITab[K, void])
ditab: excl[K](s: var DITab[K, void]; elt: K)
lptabz: excl[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; elt: K)
lptabz: excl[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; other: LPTabz[K, void, Z, z])
floorPow2:
bitop: floorPow2(x: int): int
fromCnts:
bist: fromCnts[T](t: var Bist[T])
fromIx:
lghisto: fromIx[F, C](s: LgHisto[C]; i: int; offset: F = 0.5): F
getCap:
bltab: getCap(s: BLTab): int
ditab: getCap[K, V](t: var DITab[K, V]): int
lptabz: getCap[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): int
getItOrFail:
lptabz: getItOrFail[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; k: K; found, missing): untyped
getOrDefault:
ditab: getOrDefault[K, V](t: DITab[K, V]; key: K; default = default(V)): V
lptabz: getOrDefault[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K; default = default(V)): V
getSalt:
althash: getSalt
Group:
tdigest: Group
groups:
tdigest: groups(s: DigesT): Group
hash:
althash: hash(hsh, salt: Hash): Hash
ditab: hash[K](s: DITab[K, void]): Hash
lptabz: hash[K, Z; z: static int](s: LPTabz[K, void, Z, z]): Hash
hashDegski:
althash: hashDegski[T: Ordinal | enum](x: T): Hash
hashIdentity:
althash: hashIdentity[T: Ordinal | enum](x: T): Hash
hashMoreMur:
althash: hashMoreMur[T: Ordinal | enum](x: T): Hash
hashNASAM:
althash: hashNASAM[T: Ordinal | enum](x: T): Hash
hashRevFib:
althash: hashRevFib(x: int32 | uint32): Hash
althash: hashRevFib(x: uint): Hash
althash: hashRevFib(x: int64 | uint64): Hash
hashRoMu1:
althash: hashRoMu1(x: SomeOrdinal | Hash): Hash
althash: hashRoMu1(x: uint): Hash
hashRoMu2:
althash: hashRoMu2(x: SomeOrdinal | Hash): Hash
hashSplit64:
althash: hashSplit64[T: Ordinal | enum](x: T): Hash
hashSplitMix:
althash: hashSplitMix[T: Ordinal | enum](x: T): Hash
hashWangYi1:
althash: hashWangYi1[T: Ordinal | enum](x: T): Hash
hashWY0:
althash: hashWY0[T: Ordinal | enum](x: T): Hash
hasKey:
ditab: hasKey[K, V](t: DITab[K, V]; key: K): bool
lptabz: hasKey[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): bool
hasKeyOrPut:
ditab: hasKeyOrPut[K, V](t: var DITab[K, V]; key: K; val: V): bool
lptabz: hasKeyOrPut[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V): bool
hcodes:
ditab: hcodes[K, V](t: DITab[K, V]): (int, Hash)
lptabz: hcodes[K, Z; z: static int](s: LPTabz[K, void, Z, z]): (int, Hash)
high:
lghisto: high[C](s: LgHisto[C]): float
sequint: high(s: SeqUint): int
inc:
amoft: inc[K, C](a: var AMOft[K, C]; key: K; r = 1)
amoft: inc[K, C](cs: var CtMnSketch[K, C]; key: K; r = 1): C
bist: inc[T](t: var Bist[T]; i, d: SomeInteger)
ditab: inc[K, V: SomeInteger](t: var DITab[K, V]; key: K; amount: SomeInteger = 1)
lptabz: inc[K, V, Z; z: static int](c: var LPTabz[K, V, Z, z]; key: K; amount: V = 1)
incl:
ditab: incl[K](s: var DITab[K, void]; other: DITab[K, void])
ditab: incl[K](s: var DITab[K, void]; elt: K)
lptabz: incl[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; elt: K)
lptabz: incl[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; other: LPTabz[K, void, Z, z])
indexBy:
ditab: indexBy[A, K, V](collection: A; index: proc (x: V): K): DITab[K, V]
lptabz: indexBy[A, K, V, Z; z: static int](collection: A; index: proc (x: V): K): LPTabz[ K, V, Z, z]
init:
bltab: init(s: var BLTab; size, mask: int)
ditab: init[K, V](t: var DITab[K, V]; initialSize = 0; numer = 0; denom = 0; minFree = 0; growPow2 = 0; rehash = false; robinhood = false)
lghisto: init[C](s: var LgHisto[C]; a = 1e-16; b = 1e+20; n = 8300)
lptabz: init[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; initialSize = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = lpRehash; robinhood = lpRobinHood)
mvstat: init[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]; a = 1e-16; b = 1e+20; n = 8300; options: set[Option] = {})
sequint: init(s: var SeqUint; initialSize = 0; numBound = 0)
tdigest: init(s: var DigesT; cpr = 100.0; scale = scLog; mainLen = 0; nBuf = 0)
initAMOft:
amoft: initAMOft[K, C](k, w: int; d = 4; salts: seq[int] = @[]): AMOft[K, C]
initBist:
bist: initBist[T](len: int): Bist[T]
initBLTab:
bltab: initBLTab(size, mask: int): BLTab
initCtMnSketch:
amoft: initCtMnSketch[K, C](w: int; d = 4; salts: seq[int] = @[]): CtMnSketch[K, C]
initDigesT:
tdigest: initDigesT(cpr = 100.0; scale = scLog; mainLen = 0; nBuf = 0): DigesT
initDISet:
ditab: initDISet[K](initialSize = 0; numer = diNumer; denom = diDenom; minFree = diMinFree; growPow2 = diGrowPow2; rehash = diRehash; robinhood = diRobinHood): DISet[K]
initDITab:
ditab: initDITab[K, V](initialSize = 0; numer = 0; denom = 0; minFree = 0; growPow2 = 0; rehash = false; robinhood = false): DITab[K, V]
initLgHisto:
lghisto: initLgHisto[C](a = 1e-16; b = 1e+20; n = 8300): LgHisto[C]
initLPSet:
lptabz: initLPSet[K](initialSize = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = lpRehash; robinhood = lpRobinHood): LPSet[K]
initLPSetz:
lptabz: initLPSetz[K, Z; z: static int](initialSize = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = lpRehash; robinhood = lpRobinHood): LPSetz[K, Z, z]
initLPTab:
lptabz: initLPTab[K, V](initialSize = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = lpRehash; robinhood = lpRobinHood): LPTab[K, V]
initLPTabz:
lptabz: initLPTabz[K, V, Z; z: static int](initialSize = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = lpRehash; robinhood = lpRobinHood): LPTabz[K, V, Z, z]
initMovingStat:
mvstat: initMovingStat[F: SomeFloat; C: SomeInteger](a = 1e-16; b = 1e+20; n = 8300; options: set[Option] = {}): MovingStat[F, C]
initSeqUint:
sequint: initSeqUint(initialSize = 0; numBound = 0): SeqUint
initSet:
metab: initSet[K](sz = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = rDefault; robinHood = rhDefault): Set[K]
initTab:
metab: initTab[K, V](sz = lpInitialSize; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = rDefault; robinHood = rhDefault): Tab[K, V]
initUniqCe:
uniqce: initUniqCe[F: SomeFloat](k = 1024): UniqCe[F]
intersection:
ditab: intersection[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: intersection[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
invCDF:
bist: invCDF[T](t: Bist[T]; s: T; s0: var T): int
bist: invCDF[T](t: Bist[T]; s: T; s0, s1: var T): int
isPow2:
bitop: isPow2(x: int): bool
items:
bltab: items(s: BLTab): Hash
ditab: items[K](t: DITab[K, void]): K
lptabz: items[K, Z; z: static int](s: LPTabz[K, void, Z, z]): K
sequint: items(s: SeqUint): uint
jaccard:
uniqce: jaccard[F: SomeFloat](a: UniqCe[F]; b: UniqCe[F]): float32
keys:
ditab: keys[K, V](t: DITab[K, V]): K
lptabz: keys[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): K
kurtosis:
mvstat: kurtosis[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: kurtosis[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: kurtosis[T: SomeNumber](xs: openArray[T]; accum = 32): float
kurtosisS:
mvstat: kurtosisS[F: SomeFloat; C: SomeInteger](s`gensym35: MovingStat[F, C]): float
mvstat: kurtosisS[T: SomeNumber](xs`gensym35: openArray[T]; accum`gensym35 = 32): float
mvstat: kurtosisS[F: SomeFloat; C: SomeInteger](s`gensym35: var MovingStat[F, C]): float
len:
bist: len[T](t: Bist[T]): int
bltab: len(s: BLTab): int
ditab: len[K, V](t: DITab[K, V]): int
lptabz: len[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): int
sequint: len(s: SeqUint): int
lg:
bitop: lg(x: int): int
lgCeil:
bitop: lgCeil(x: int): int
lgFloor:
bitop: lgFloor(x: int): int
LgHisto:
lghisto: LgHisto
lgPow2:
bitop: lgPow2(x: int): int
load:
bltab: load(t: var BLTab; path: string)
lptabz: load[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; path: string)
loadBLTab:
bltab: loadBLTab(path: string): BLTab
loadLPTabz:
lptabz: loadLPTabz[K, V, Z; z: static int](path: string): LPTabz[K, V, Z, z]
low:
lghisto: low[C](s: LgHisto[C]): float
sequint: low(s: SeqUint): int
lpDenom:
lptabz: lpDenom
lpGrowPow2:
lptabz: lpGrowPow2
lpInitialSize:
lptabz: lpInitialSize
lpMaxWarn:
lptabz: lpMaxWarn
lpMinFree:
lptabz: lpMinFree
lpNumer:
lptabz: lpNumer
lpRehash:
lptabz: lpRehash
lpRobinHood:
lptabz: lpRobinHood
LPSet:
lptabz: LPSet
LPSetz:
lptabz: LPSetz
LPTab:
lptabz: LPTab
LPTabz:
lptabz: LPTabz
lpWarn:
lptabz: lpWarn
map:
ditab: map[K, A](data: DITab[K, void]; op: proc (x: K): A {.closure.}): DITab[A, void]
lptabz: map[K, A, Z; z: static int](data: LPTabz[K, void, Z, z]; op: proc (x: K): A {.closure.}): LPTabz[A, void, Z, z]
max:
bist: max[T](t: Bist[T]): int
mean:
mvstat: mean[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: mean[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: mean[T: SomeNumber](xs: openArray[T]): float
merge:
ditab: merge[K, V: SomeInteger](c: var DITab[K, V]; b: DITab[K, V])
lghisto: merge[C](dst: var LgHisto[C]; src: LgHisto[C])
lptabz: merge[K, V, Z; z: static int](c: var LPTabz[K, V, Z, z]; b: LPTabz[K, V, Z, z])
mergeNew:
tdigest: mergeNew(s: var DigesT; force = false; cpr = -1.0)
mgetOrPut:
ditab: mgetOrPut[K, V](t: var DITab[K, V]; key: K; val: V): var V
ditab: mgetOrPut[K, V](t: var DITab[K, V]; key: K; val: V; had: var bool): var V
lptabz: mgetOrPut[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V): var V
lptabz: mgetOrPut[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V; had: var bool): var V
min:
bist: min[T](t: Bist[T]): int
missingOrExcl:
bltab: missingOrExcl(s: var BLTab; hc: Hash): bool
ditab: missingOrExcl[K, V](t: var DITab[K, V]; key: K): bool
lptabz: missingOrExcl[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K): bool
mitems:
ditab: mitems[K](t: var DITab[K, void]): var K
lptabz: mitems[K, Z; z: static int](s: var LPTabz[K, void, Z, z]): var K
mmap:
bltab: mmap(t: var BLTab; path: string)
lptabz: mmap[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; path: string)
mostCommon:
amoft: mostCommon[K, C](a: AMOft[K, C]; k = 0): (K, C)
lptabz: mostCommon[K](xs: openArray[K]; n = 10): (K, int)
MovingStat:
mvstat: MovingStat
mpairs:
ditab: mpairs[K, V: not void](t: DITab[K, V]): (K, var V)
lptabz: mpairs[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]): (K, var V)
mvalues:
ditab: mvalues[K, V](t: var DITab[K, V]): var V
lptabz: mvalues[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]): var V
nBin:
lghisto: nBin[C](s: LgHisto[C]): int
nInv:
mvstat: nInv[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): F
mvstat: nInv[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): F
normalized:
althash: normalized[T](x: openArray[T]): seq[float]
nsort:
nsort: nsort[O, W](obs: var openArray[O]; off: W; xf = xfNone; b0 = 0)
nsort: nsort(obs, tmp: pointer; n, sz: int; off: uint8; xf: XForm; b0 = 0): pointer
nsort: nsort[W: Ui248](obs, tmp: pointer; n, sz: int; off: W; xf: XForm; b0 = 0): pointer
nsortBy:
nsort: nsortBy(x, field: untyped; b0 = 0): untyped
nsortByRaw:
nsort: nsortByRaw(x, field: untyped; b0 = 0): untyped
nsortByTag:
nsort: nsortByTag(x, field: untyped; b0 = 0): untyped
nthKey:
ditab: nthKey[K](t: DITab[K, void]; n: int): K
lptabz: nthKey[K, Z; z: static int](t: LPTabz[K, void, Z, z]; n: int): K
nthPair:
ditab: nthPair[K, V: not void](t: DITab[K, V]; n: int): (K, V)
ditab: nthPair[K, V: not void](t: var DITab[K, V]; n: int): (K, ptr V)
lptabz: nthPair[K, V: not void; Z; z: static int](t: LPTabz[K, V, Z, z]; n: int): (K, V)
lptabz: nthPair[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]; n: int): ( K, ptr V)
numItems:
lptabz: numItems[K, Z; z: static int](t: LPTabz[K, void, Z, z]; key: K): int
lptabz: numItems[K, Z; z: static int](t: LPTabz[K, void, Z, z]): (K, int)
nUnique:
uniqce: nUnique[F: SomeFloat](uc: UniqCe[F]): float32
nUniqueErr:
uniqce: nUniqueErr[F: SomeFloat](uc: UniqCe[F]): float32
Option:
mvstat: Option
orderFit:
btree: orderFit(target, wtSz, ixSz, obSz, lnSz: int): int
OrderStats:
Option.OrderStats
overflows:
lghisto: overflows[C](s: LgHisto[C]): int
pairs:
bltab: pairs(s: BLTab): tuple[a: int, b: Hash]
ditab: pairs[K](t: DITab[K, void]): (int, K)
ditab: pairs[K, V: not void](t: DITab[K, V]): (K, V)
lptabz: pairs[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): (K, V)
lptabz: pairs[K, Z; z: static int](t: LPTabz[K, void, Z, z]): (int, K)
sequint: pairs(s: SeqUint): (int, uint)
pmf:
bist: pmf[T](t: Bist[T]; i: int): T
pop:
ditab: pop[K](t: var DITab[K, void]): K
ditab: pop[K](s: var DITab[K, void]; key: var K): bool
ditab: pop[K, V: not void](t: var DITab[K, V]): (K, V)
ditab: pop[K, V: not void](t: var DITab[K, V]; key: K; val: var V): bool
lghisto: pop[F, C](s: var LgHisto[C]; x: F; w = 1.C)
lptabz: pop[K, Z; z: static int](t: var LPTabz[K, void, Z, z]): K
lptabz: pop[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; key: var K): bool
lptabz: pop[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]): (K, V)
lptabz: pop[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: var V): bool
mvstat: pop[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]; x: SomeNumber)
pullDown:
memutil: pullDown[T](x: var seq[T]; i, n: int)
push:
mvstat: push[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]; x: SomeNumber)
uniqce: push[F: SomeFloat](uc: var UniqCe[F]; h: F)
pushUp:
memutil: pushUp[T](x: var seq[T]; i, n: int)
quantile:
bist: quantile[T](t: Bist[T]; q: float): float
bist: quantile[T](t: Bist[T]; q: float; iL, iH: var int): float
lghisto: quantile[F, C](s: LgHisto[C]; q: F): F
mvstat: quantile[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]; q: float): float
tdigest: quantile(s: var DigesT; q: float): float
raiseNotFound:
althash: raiseNotFound[K](key: K)
range:
mvstat: range[F: SomeFloat](xs: openArray[F]): (F, F)
reverseBits:
bitop: reverseBits(x: uint32): uint32
bitop: reverseBits(x: uint64): uint64
reverseBitsByte:
bitop: reverseBitsByte(x: uint8): uint8
rightSize:
ditab: rightSize(count: int; numer = 0; denom = 0; minFree = 0): int
lptabz: rightSize(count: int; numer = 0; denom = 0; minFree = 0): int
rightSz:
metab: rightSz(x: Natural): int
rotateLeftBits:
bitop: rotateLeftBits(a: uint64; numBits: int): uint64
rotateRightBits:
bitop: rotateRightBits(a: uint64; numBits: int): uint64
save:
bltab: save(t: BLTab; pathStub: string)
lptabz: save[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; pathStub: string)
Scale:
tdigest: Scale
scLog:
Scale.scLog
secureSalt:
althash: secureSalt(x: pointer): Hash
SeqUint:
sequint: SeqUint
Set:
metab: Set
setCap:
ditab: setCap[K, V](t: var DITab[K, V]; newSize = -1)
lptabz: setCap[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; newSize = -1)
setLen:
sequint: setLen(s: var SeqUint; size: int)
setOrIncl:
ditab: setOrIncl[K](t: var DITab[K, void]; key: K): bool
lptabz: setOrIncl[K, Z; z: static int](t: var LPTabz[K, void, Z, z]; key: K): bool
setPolicy:
ditab: setPolicy[K, V](t: var DITab[K, V]; numer = 0; denom = 0; minFree = 0; growPow2 = 0; rehash = 0; robinhood = 0)
lptabz: setPolicy[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; numer = lpNumer; denom = lpDenom; minFree = lpMinFree; growPow2 = lpGrowPow2; rehash = lpRehash; robinhood = lpRobinHood)
skewness:
mvstat: skewness[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: skewness[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: skewness[T: SomeNumber](xs: openArray[T]; accum = 32): float
skewnessS:
mvstat: skewnessS[F: SomeFloat; C: SomeInteger](s`gensym28: MovingStat[F, C]): float
mvstat: skewnessS[T: SomeNumber](xs`gensym28: openArray[T]; accum`gensym28 = 32): float
mvstat: skewnessS[F: SomeFloat; C: SomeInteger](s`gensym28: var MovingStat[F, C]): float
space:
bist: space[T](t: Bist[T]): int
lghisto: space[C](s: LgHisto[C]): int
tdigest: space(s: DigesT): int
standardDeviation:
mvstat: standardDeviation[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: standardDeviation[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: standardDeviation[T: SomeNumber](xs: openArray[T]; accum = 32): float
standardDeviationS:
mvstat: standardDeviationS[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: standardDeviationS[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: standardDeviationS[T: SomeNumber](xs: openArray[T]; accum = 32): float
stderror:
mvstat: stderror[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: stderror[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: stderror[T: SomeNumber](xs: openArray[T]; accum = 32): float
sum:
mvstat: sum[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
symmetricDifference:
ditab: symmetricDifference[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: symmetricDifference[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[ K, void, Z, z]
Tab:
metab: Tab
take:
ditab: take[K](t: var DITab[K, void]; key: var K): bool
ditab: take[K, V: not void](t: var DITab[K, V]; key: K; val: var V): bool
lptabz: take[K, Z; z: static int](t: var LPTabz[K, void, Z, z]; key: var K): bool
lptabz: take[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: var V): bool
toCnts:
bist: toCnts[T](t: var Bist[T])
toDITab:
ditab: toDITab[K, V: not void](pairs: openArray[(K, V)]; dups = false): DITab[K, V]
ditab: toDITab[K](keys: openArray[K]; dups = false): DITab[K, void]
toIx:
lghisto: toIx[F, C](s: LgHisto[C]; x: F): int
toLPTabz:
lptabz: toLPTabz[K; V: not void; Z; z: static int](pairs: openArray[(K, V)]; dups = false): LPTabz[K, V, Z, z]
lptabz: toLPTabz[K; V: void; Z; z: static int](keys: openArray[K]; dups = false): LPTabz[ K, V, Z, z]
topByVal:
ditab: topByVal[K, V](c: DITab[K, V]; n = 10; min = V.low): (K, V)
lptabz: topByVal[K, V, Z; z: static int](c: LPTabz[K, V, Z, z]; n = 10; min = V.low): ( K, V)
toSet:
metab: toSet[K](keys: openArray[K]; dups = false): Set[K]
toTab:
metab: toTab[K, V](pairs: openArray[(K, V)]; dups = false): Tab[K, V]
underflows:
lghisto: underflows[C](s: LgHisto[C]): int
union:
ditab: union[K](s1, s2: DITab[K, void]): DITab[K, void]
lptabz: union[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
uniqce: union[F: SomeFloat](a: var UniqCe[F]; b: UniqCe[F])
uniqce: union[F: SomeFloat](a: UniqCe[F]; b: UniqCe[F]): UniqCe[F]
UniqCe:
uniqce: UniqCe
values:
ditab: values[K, V](t: DITab[K, V]): V
lptabz: values[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): V
variance:
mvstat: variance[F: SomeFloat; C: SomeInteger](s: MovingStat[F, C]): float
mvstat: variance[F: SomeFloat; C: SomeInteger](s: var MovingStat[F, C]): float
mvstat: variance[T: SomeNumber](xs: openArray[T]; accum = 32): float
varianceS:
mvstat: varianceS[F: SomeFloat; C: SomeInteger](s`gensym21: MovingStat[F, C]): float
mvstat: varianceS[T: SomeNumber](xs`gensym21: openArray[T]; accum`gensym21 = 32): float
mvstat: varianceS[F: SomeFloat; C: SomeInteger](s`gensym21: var MovingStat[F, C]): float
verb:
nsort: verb
vmaddrSalt:
althash: vmaddrSalt(x: pointer): Hash
weight:
tdigest: weight(s: DigesT): int
withIt:
lptabz: withIt[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; k: K; edit, init): untyped
withValue:
ditab: withValue[K, V](t: var DITab[K, V]; key: K; value, body: untyped)
ditab: withValue[K, V](t: var DITab[K, V]; key: K; value, body1, body2: untyped)
lptabz: withValue[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; value, found: untyped): untyped
lptabz: withValue[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; value, found, missing: untyped): untyped
x86bmi2:
X86Feature.x86bmi2
X86Feature:
cpuCT: X86Feature
x86features:
cpuCT: x86features
x86sse2:
X86Feature.x86sse2
x86ssse3:
X86Feature.x86ssse3
xfFlt:
XForm.xfFlt
xfFltRev:
XForm.xfFltRev
xfNone:
XForm.xfNone
XForm:
nsort: XForm
xfRev:
XForm.xfRev
xfSgn:
XForm.xfSgn
xfSgnRev:
XForm.xfSgnRev
zeroSalt:
althash: zeroSalt(x: pointer): Hash