Index
      Modules: 
adix, 
adix/althash, 
adix/amoft, 
adix/bist, 
adix/bitop, 
adix/bltab, 
adix/btree, 
adix/cpuCT, 
adix/cumsum, 
adix/ditab, 
adix/embist, 
adix/hist, 
adix/lghisto, 
adix/lmbist, 
adix/lna, 
adix/lptabz, 
adix/memutil, 
adix/metab, 
adix/mvstat, 
adix/nsort, 
adix/oats, 
adix/sequint, 
adix/stat, 
adix/tdigest, 
adix/topk, 
adix/uniqce, 
adix/ways, 
adix/xhist1.
API symbols
- `$`:
 
- bist: proc `$`[T](t: Bist[T]): string
 
          - ditab: proc `$`[K](s: DITab[K, void]): string
 
          - ditab: proc `$`[K, V: not void](t: DITab[K, V]): string
 
          - hist: proc `$`[N](h: Hist[N]): string
 
          - lghisto: proc `$`[C](s: LgHisto[C]; nonZero = true): string
 
          - lptabz: proc `$`[K, Z; z: static int](s: LPTabz[K, void, Z, z]): string
 
          - lptabz: proc `$`[K, V: not void; Z; z: static int](t: LPTabz[K, V, Z, z]): string
 
          - mvstat: proc `$`[F: SomeFloat; C: SomeNumber](s: MovingStat[F, C]): string
 
          - sequint: proc `$`(s: SeqUint): string
 
          
 
- `&=`:
 
- `*`:
 
- ditab: proc `*`[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc `*`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
 
          
 
- `+=`:
 
- `+`:
 
- ditab: proc `+`[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc `+`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
 
          - mvstat: proc `+`[F](a, b: BasicStats[F]): BasicStats[F]
 
          
 
- `-+-`:
 
- ditab: proc `-+-`[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc `-+-`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
 
          
 
- `-`:
 
- ditab: proc `-`[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc `-`[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
 
          
 
- `<<=`:
 
- `<=`:
 
- `<`:
 
- `==`:
 
- ditab: proc `==`[K, V](x, y: DITab[K, V]): bool
 
          - ditab: proc `==`[K](s, t: DITab[K, void]): bool
 
          - lptabz: proc `==`[K, Z; z: static int](s, t: LPTabz[K, void, Z, z]): bool
 
          - lptabz: proc `==`[K, V: not void; Z; z: static int](x, y: LPTabz[K, V, Z, z]): bool
 
          
 
- `>>=`:
 
- `[]=`:
 
- bist: proc `[]=`[T](t: var Bist[T]; i: int; x: T)
 
          - ditab: proc `[]=`[K, V](t: var DITab[K, V]; key: K; val: V)
 
          - lptabz: proc `[]=`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V)
 
          - oats: proc `[]=`[K, Q, V](t: var VPOat[K, Q, V]; q: Q; v: V)
 
          - sequint: proc `[]=`(s: var SeqUint; i: int | uint; x: int | uint)
 
          
 
- `[]`:
 
- bist: proc `[]`[T](t: Bist[T]; i: int): T
 
          - bist: proc `[]`[T](t: var Bist[T]; i: int): var T
 
          - ditab: proc `[]`[K, V](t: DITab[K, V]; key: K): V
 
          - ditab: proc `[]`[K, V](t: var DITab[K, V]; key: K): var V
 
          - lptabz: proc `[]`[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): V
 
          - lptabz: proc `[]`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K): var V
 
          - oats: proc `[]`[K, Q, V](t: VOat[K, Q, V]; q: Q): V
 
          - sequint: proc `[]`(s: SeqUint; i: int | uint): uint
 
          
 
- `^=`:
 
- `{}=`:
 
- `{}`:
 
- ditab: proc `{}`[K, V](t: DITab[K, V]; key: K): V
 
          - ditab: proc `{}`[K, V](t: var DITab[K, V]; key: K): var V
 
          - lptabz: proc `{}`[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): V
 
          - lptabz: proc `{}`[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K): var V
 
          
 
- `|=`:
 
- add:
 
- lghisto: proc add[F, C](s: var LgHisto[C]; x: F; w = 1.C)
 
          - lptabz: proc add[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V)
 
          - lptabz: proc add[K, Z; z: static int](t: var LPTabz[K, void, Z, z]; key: K)
 
          - mvstat: proc add[F](a: var BasicStats[F]; b: BasicStats[F])
 
          - sequint: proc add(s: var SeqUint; v: uint)
 
          - tdigest: proc add(s: var DigesT; x: float; w = 1)
 
          - tdigest: proc add(s: var DigesT; others: var openArray[DigesT])
 
          
 
- addr0:
 
- allItems:
 
- allValues:
 
- lptabz: proc allValues[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K;
                                  vals: var seq[V]): bool
 
          - lptabz: iterator allValues[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K): V
 
          - lptabz: iterator allValues[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; vals: var seq[V]): K
 
          
 
- AMOft:
 
- Ascending:
 
- ascending:
 
- BasicStats:
 
- basicStats:
 
- binAB:
 
- bins:
 
- Bist:
 
- bist:
 
- bits:
 
- blDenom:
 
- blGrowPow2:
 
- blInitialSize:
 
- blMinFree:
 
- blNumer:
 
- blRehash:
 
- blRobinHood:
 
- blSentinel:
 
- BLTab:
 
- blValueBits:
 
- btLinearNode:
 
- btPool:
 
- card:
 
- ccPreDefs:
 
- cdf:
 
- ceilPow2:
 
- Cheap:
 
- clear:
 
- compress:
 
- contains:
 
- containsOrIncl:
 
- count:
 
- Counted:
 
- CtMnSketch:
 
- cumsum:
 
- dbg:
 
- debugDump:
 
- dec:
 
- def:
 
- defBTree:
 
- defMove:
 
- del:
 
- depths:
 
- depthStats:
 
- ditab: proc depthStats[K, V](s: DITab[K, V]): tuple[m1, m2: float, mx: int]
 
          - lptabz: proc depthStats[K, V, Z; z: static int](s: LPTabz[K, V, Z, z]): tuple[m1, m2: float,
    mx: int]
 
          
 
- Descending:
 
- descending:
 
- diDenom:
 
- difference:
 
- ditab: proc difference[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc difference[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void,
    Z, z]
 
          
 
- diffs:
 
- diffs2:
 
- DigesT:
 
- diGrowPow2:
 
- diInitialSize:
 
- diMinFree:
 
- diNumer:
 
- diRehash:
 
- diRobinHood:
 
- DISet:
 
- disjoint:
 
- DITab:
 
- editKey:
 
- editOrInit:
 
- ditab: template editOrInit[K, V](t: var DITab[K, V]; key: K; v, body1, body2: untyped)
 
          - lptabz: template editOrInit[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K;
                                   v, found, missing: untyped): untyped
 
          
 
- EMBist:
 
- excl:
 
- ditab: proc excl[K](s: var DITab[K, void]; other: DITab[K, void])
 
          - ditab: proc excl[K](s: var DITab[K, void]; elt: K)
 
          - lptabz: proc excl[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; elt: K)
 
          - lptabz: proc excl[K, Z; z: static int](s: var LPTabz[K, void, Z, z];
                          other: LPTabz[K, void, Z, z])
 
          
 
- exportDefs:
 
- floorPow2:
 
- fromCnts:
 
- fromIx:
 
- getCap:
 
- getItOrFail:
 
- getOrDefault:
 
- ditab: proc getOrDefault[K, V](t: DITab[K, V]; key: K; def = default(V)): V
 
          - lptabz: proc getOrDefault[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]; key: K;
                                     def = default(V)): V
 
          - oats: proc getOrDefault[K, Q, V](t: VOat[K, Q, V]; q: Q; def = default(V)): V
 
          
 
- getSalt:
 
- Group:
 
- groups:
 
- hash:
 
- hashDegski:
 
- hashIdentity:
 
- hashMoreMur:
 
- hashNASAM:
 
- hashRevFib:
 
- hashRoMu1:
 
- hashRoMu2:
 
- hashSplit64:
 
- hashSplitMix:
 
- hashWangYi1:
 
- hashWY0:
 
- hasKey:
 
- hasKeyOrPut:
 
- hcodes:
 
- high:
 
- Hist:
 
- inc:
 
- amoft: proc inc[K, C](a: var AMOft[K, C]; key: K; r = 1)
 
          - amoft: proc inc[K, C](cs: var CtMnSketch[K, C]; key: K; r = 1): C
 
          - bist: proc inc[T](t: var Bist[T]; i: int; d: T)
 
          - ditab: proc inc[K, V: SomeInteger](t: var DITab[K, V]; key: K; amount: SomeInteger = 1)
 
          - embist: proc inc[F](d: var EMBist[F]; i: int; w: F = 1)
 
          - hist: proc inc[N](h: var Hist[N]; i: int; w: N = 1)
 
          - lmbist: proc inc[T](d: var LMBist[T]; i: int; w: T)
 
          - lptabz: proc inc[K, V, Z; z: static int](c: var LPTabz[K, V, Z, z]; key: K; amount: V = 1)
 
          
 
- incl:
 
- ditab: proc incl[K](s: var DITab[K, void]; other: DITab[K, void])
 
          - ditab: proc incl[K](s: var DITab[K, void]; elt: K)
 
          - lptabz: proc incl[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; elt: K)
 
          - lptabz: proc incl[K, Z; z: static int](s: var LPTabz[K, void, Z, z];
                          other: LPTabz[K, void, Z, z])
 
          - oats: proc incl[K, Q](t: var POat[K, Q]; q: Q)
 
          
 
- indexBy:
 
- init:
 
- initAMOft:
 
- initBist:
 
- initBLTab:
 
- initCtMnSketch:
 
- initDigesT:
 
- initDISet:
 
- initDITab:
 
- initEMBist:
 
- initHist:
 
- initLgHisto:
 
- initLMBist:
 
- initLPSet:
 
- initLPSetz:
 
- initLPTab:
 
- initLPTabz:
 
- initMovingStat:
 
- initSeqUint:
 
- initSet:
 
- initTab:
 
- initTopK:
 
- initUniqCe:
 
- intersection:
 
- ditab: proc intersection[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc intersection[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K,
    void, Z, z]
 
          
 
- invCDF:
 
- isPow2:
 
- items:
 
- jaccard:
 
- keys:
 
- kurtosis:
 
- kurtosisS:
 
- kWayMerge:
 
- last:
 
- len:
 
- lg:
 
- lgCeil:
 
- lgFloor:
 
- LgHisto:
 
- lgPow2:
 
- LMBist:
 
- lna:
 
- load:
 
- loadBLTab:
 
- loadLPTabz:
 
- low:
 
- lpDenom:
 
- lpGrowPow2:
 
- lpInitialSize:
 
- lpMinFree:
 
- lpNumer:
 
- lpRehash:
 
- lpRobinHood:
 
- LPSet:
 
- LPSetz:
 
- LPTab:
 
- LPTabz:
 
- lpWarn:
 
- map:
 
- ditab: proc map[K, A](data: DITab[K, void]; op: proc (x: K): A {.closure.}): DITab[A, void]
 
          - lptabz: proc 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:
 
- maybeOrdered:
 
- mean:
 
- merge:
 
- ditab: proc merge[K, V: SomeInteger](c: var DITab[K, V]; b: DITab[K, V])
 
          - lghisto: proc merge[C](dst: var LgHisto[C]; src: LgHisto[C])
 
          - lptabz: proc merge[K, V, Z; z: static int](c: var LPTabz[K, V, Z, z]; b: LPTabz[K, V, Z, z])
 
          
 
- mergeNew:
 
- mgetOrPut:
 
- ditab: proc mgetOrPut[K, V](t: var DITab[K, V]; key: K; val: V): var V
 
          - ditab: proc mgetOrPut[K, V](t: var DITab[K, V]; key: K; val: V; had: var bool): var V
 
          - lptabz: proc mgetOrPut[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V): var V
 
          - lptabz: proc mgetOrPut[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K; val: V;
                                  had: var bool): var V
 
          - oats: proc mgetOrPut[K, Q, V](t: var VPOat[K, Q, V]; q: Q; v: V): var V
 
          
 
- min:
 
- missingOrExcl:
 
- mitems:
 
- mmap:
 
- mostCommon:
 
- MovingStat:
 
- mpairs:
 
- mvalues:
 
- nBin:
 
- nCDF:
 
- nInv:
 
- normalized:
 
- nPDF:
 
- nsort:
 
- nsortBy:
 
- nsortByRaw:
 
- nsortByTag:
 
- nthKey:
 
- nthPair:
 
- ditab: proc nthPair[K, V: not void](t: DITab[K, V]; n: int): (K, V)
 
          - ditab: proc nthPair[K, V: not void](t: var DITab[K, V]; n: int): (K, ptr V)
 
          - lptabz: proc nthPair[K, V: not void; Z; z: static int](t: LPTabz[K, V, Z, z]; n: int): (K, V)
 
          - lptabz: proc nthPair[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]; n: int): (
    K, ptr V)
 
          
 
- numItems:
 
- nUnique:
 
- nUniqueErr:
 
- Oat:
 
- oatCounted:
 
- oatKStack:
 
- oatSeq:
 
- oatSlot:
 
- oatSlots:
 
- Option:
 
- orderFit:
 
- OrderStats:
 
- overflows:
 
- pairs:
 
- bltab: iterator pairs(s: BLTab): tuple[a: int, b: Hash]
 
          - ditab: iterator pairs[K](t: DITab[K, void]): (int, K)
 
          - ditab: iterator pairs[K, V: not void](t: DITab[K, V]): (K, V)
 
          - lptabz: iterator pairs[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): (K, V)
 
          - lptabz: iterator pairs[K, Z; z: static int](t: LPTabz[K, void, Z, z]): (int, K)
 
          - oats: iterator pairs[K, Q, V](t: VOat[K, Q, V]): (K, V)
 
          - sequint: iterator pairs(s: SeqUint): (int, uint)
 
          
 
- Partn:
 
- pmf:
 
- POat:
 
- pop:
 
- ditab: proc pop[K](t: var DITab[K, void]): K
 
          - ditab: proc pop[K](s: var DITab[K, void]; key: var K): bool
 
          - ditab: proc pop[K, V: not void](t: var DITab[K, V]): (K, V)
 
          - ditab: proc pop[K, V: not void](t: var DITab[K, V]; key: K; val: var V): bool
 
          - lghisto: proc pop[F, C](s: var LgHisto[C]; x: F; w = 1.C)
 
          - lptabz: proc pop[K, Z; z: static int](t: var LPTabz[K, void, Z, z]): K
 
          - lptabz: proc pop[K, Z; z: static int](s: var LPTabz[K, void, Z, z]; key: var K): bool
 
          - lptabz: proc pop[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]): (K, V)
 
          - lptabz: proc pop[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K;
                                      val: var V): bool
 
          - mvstat: proc pop[F: SomeFloat; C: SomeNumber](s: var MovingStat[F, C]; x: SomeNumber)
 
          
 
- pullDown:
 
- push:
 
- pushUp:
 
- PutKey:
 
- quantile:
 
- raiseNotFound:
 
- ran:
 
- range:
 
- ratios:
 
- Resizable:
 
- returns:
 
- reverseBits:
 
- reverseBitsByte:
 
- rightSize:
 
- rightSz:
 
- ROat:
 
- rotateLeftBits:
 
- rotateRightBits:
 
- save:
 
- SavedHash:
 
- saw:
 
- scale:
 
- Scale:
 
- scLog:
 
- secureSalt:
 
- SeqUint:
 
- Set:
 
- setCap:
 
- setLen:
 
- setOrIncl:
 
- setPolicy:
 
- size:
 
- skewness:
 
- skewnessS:
 
- space:
 
- standardDeviation:
 
- standardDeviationS:
 
- stderror:
 
- succPairs:
 
- sum:
 
- symmetricDifference:
 
- ditab: proc symmetricDifference[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc symmetricDifference[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[
    K, void, Z, z]
 
          
 
- Tab:
 
- take:
 
- ditab: proc take[K](t: var DITab[K, void]; key: var K): bool
 
          - ditab: proc take[K, V: not void](t: var DITab[K, V]; key: K; val: var V): bool
 
          - lptabz: proc take[K, Z; z: static int](t: var LPTabz[K, void, Z, z]; key: var K): bool
 
          - lptabz: proc take[K, V: not void; Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K;
                                       val: var V): bool
 
          
 
- toCnts:
 
- toDITab:
 
- toIx:
 
- toLPTabz:
 
- tooFull:
 
- topByVal:
 
- ditab: iterator topByVal[K, V](c: DITab[K, V]; n = 10; min = V.low; order = Cheap): (K, V)
 
          - lptabz: iterator topByVal[K, V, Z; z: static int](c: LPTabz[K, V, Z, z]; n = 10; min = V.low;
                                 order = Cheap): (K, V)
 
          - oats: iterator topByVal[K, Q, V](s: VOat[K, Q, V]; n = 10; min = V.low; order = topk.Cheap): (
    K, V)
 
          
 
- TopK:
 
- TopKOrder:
 
- toSet:
 
- tot:
 
- toTab:
 
- underflows:
 
- union:
 
- ditab: proc union[K](s1, s2: DITab[K, void]): DITab[K, void]
 
          - lptabz: proc union[K, Z; z: static int](s1, s2: LPTabz[K, void, Z, z]): LPTabz[K, void, Z, z]
 
          - uniqce: proc union[F: SomeFloat](a: var UniqCe[F]; b: UniqCe[F])
 
          - uniqce: proc union[F: SomeFloat](a: UniqCe[F]; b: UniqCe[F]): UniqCe[F]
 
          
 
- UniqCe:
 
- up:
 
- upSert:
 
- Valued:
 
- values:
 
- ditab: iterator values[K, V](t: DITab[K, V]): V
 
          - lptabz: iterator values[K, V, Z; z: static int](t: LPTabz[K, V, Z, z]): V
 
          - oats: iterator values[K, Q, V](t: VOat[K, Q, V]): V
 
          
 
- variance:
 
- varianceS:
 
- verb:
 
- vmaddrSalt:
 
- VOat:
 
- VPOat:
 
- VROat:
 
- weight:
 
- withIt:
 
- withValue:
 
- ditab: template withValue[K, V](t: var DITab[K, V]; key: K; value, body: untyped)
 
          - ditab: template withValue[K, V](t: var DITab[K, V]; key: K; value, body1, body2: untyped)
 
          - lptabz: template withValue[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K;
                                  value, found: untyped): untyped
 
          - lptabz: template withValue[K, V, Z; z: static int](t: var LPTabz[K, V, Z, z]; key: K;
                                  value, found, missing: untyped): untyped
 
          
 
- x86bmi2:
 
- X86Feature:
 
- x86features:
 
- x86sse2:
 
- x86ssse3:
 
- xfFlt:
 
- xfFltRev:
 
- xfNone:
 
- XForm:
 
- xfRev:
 
- xfSgn:
 
- xfSgnRev:
 
- zeroSalt:
 
      
        
        
        Made with Nim. Generated: 2025-11-01 12:08:02 UTC