Index

Documents: IxMap Purpose.

Modules: ixmap/arrayutils, ixmap/axis, ixmap/basic, ixmap/indexing, ixmap/initialization, ixmap/iterators, ixmap/ixarray, ixmap/macros, ixmap/transforms, ixmap/types.

API symbols

`$`:

• basic: `$`(x: IxMap): string

`&`:

• arrayutils: `&`[N, M: static[int]; T](a: array[N, T]; b: array[M, T]): auto

`==`:

• basic: `==`[D1, D2: static[int]](x: IxMap[D1]; y: IxMap[D2]): bool

`[]`:

• indexing: `[]`[D: static[int]](srcexpr: IxMap[D]; idxs: varargs[untyped]): untyped

`^@`:

• indexing: `^@`[D, N: static[int]](ix: IxMap[D]; coords: array[N, IxInt]): int

AllAxes:

• types: AllAxes

AnyAxis:

• types: AnyAxis

Axis:

• types: Axis

AxisSpec:

• types: AxisSpec

broadcast:

• basic: broadcast(ix: untyped; rest: varargs[untyped]): auto

broadcast2:

• basic: broadcast2[D1, D2: static[int]](ix1: IxMap[D1]; ix2: IxMap[D2]): auto

buryAxis:

• axis: buryAxis[D: static[int]](ix: var IxMap[D]; x: int)

collapse:

• indexing: collapse[D: static[int]](x: IxMap[D]; dim: int; idx: SomeInteger or BackwardsIndex): auto

constrBracketIndex:

• macros: constrBracketIndex(dims: int; srcexpr: NimNode; ixlist: NimNode): NimNode

constrCopy:

• macros: constrCopy(axes: static[set[Axis]]; dest, src: untyped): untyped

constrIndexing:

• macros: constrIndexing(D: static[int]; srcexpr: NimNode; ixs: NimNode): NimNode

constrLoopTower:

• macros: constrLoopTower[N, M: static[int]; T, U](coords: array[N, T]; shape: array[M, U]; body: untyped): untyped

constrOffset:

• macros: constrOffset[D, L: static[int]; T, U](axes: static[set[Axis]]; initial: int; stride: array[D, T]; coords: array[L, U]): untyped

constrStrideSort:

• macros: constrStrideSort(dims: static[int]; primary: array; arrays: varargs[array]): untyped

contiguousStrides:

• ixarray: contiguousStrides[D: static[int]](shape: IxArray[D]): IxArray[D]

coordOffsets:

• iterators: coordOffsets[D: static[int]](src: IxMap[D]): (IxArray[D], int)

coords:

• iterators: coords[D: static[int]](src: IxMap[D]): IxArray[D]

diagonal:

• transforms: diagonal[D: static[int]](x: IxMap[D]): IxMap[1]

filter:

• types: filter(dim: Axis; axes: set[Axis]): set[Axis]

foldArgsR:

• macros: foldArgsR(op: untyped; initial: untyped; args: varargs[untyped]): untyped

index:

• iterators: index[T](u: var openArray[T]; ix: IxMap): var T
• iterators: index[T](u: openArray[T]; ix: IxMap): lent T

initIxMap:

• initialization: initIxMap[D: static[int]; T](shape: array[D, T]): IxMap[D]
• initialization: initIxMap[D: static[int]; T, U](shape: array[D, T]; stride: array[D, U]; offset: int = 0): IxMap[D]
• initialization: initIxMap(offset: int): IxMap[0]

initLoopIx:

• initialization: initLoopIx[D: static[int]; T](shape: array[D, T]): IxMap[D]

insert:

• arrayutils: insert[N: static[int]; T](arr: array[N, T]; idx: int; val: sink T): auto

isRowMajor:

• axis: isRowMajor(x: IxMap): bool

IxArray:

• ixarray: IxArray

IxInt:

• ixarray: IxInt

IxMap:

• types: IxMap

liftAxis:

• axis: liftAxis[D: static[int]](ix: var IxMap[D]; n: int)

longMax:

• arrayutils: longMax[N, M: static[int]; T](a`gensym0: array[N, T]; b`gensym0: array[M, T]): auto

longMin:

• arrayutils: longMin[N, M: static[int]; T](a`gensym5: array[N, T]; b`gensym5: array[M, T]): auto

makeRowMajor:

• axis: makeRowMajor(x: var IxMap)

ndims:

• basic: ndims(x: IxMap): int

newAxis:

• axis: newAxis[D: static[int]](x: IxMap[D]; dim: int | BackwardsIndex; num: int = 1): auto

NewAxis:

• indexing: NewAxis

normalize:

• initialization: normalize[D: static[int]](x: var IxMap[D])

offsets:

• iterators: offsets[D: static[int]](src: IxMap[D]): int

orthogonal:

• types: orthogonal(dim: Axis; axes: set[Axis]): set[Axis]

pairs:

• types: pairs(axes: set[Axis]): (int, Axis)

popAxis:

• axis: popAxis[D: static[int]](src: sink IxMap[D]; axis: AxisSpec): auto

popAxisM:

• axis: popAxisM[D: static[int]](src: var IxMap[D]; axis: AxisSpec): auto

qq:

• macros: qq(q: untyped): untyped

remove:

• arrayutils: remove[N: static[int]; T](arr: array[N, T]; idx: int): auto

rep:

• indexing: rep(x: int): NewAxis

reverse:

• transforms: reverse[D: static[int]](x: sink IxMap[D]): IxMap[D]
• transforms: reverse[D: static[int]](x: sink IxMap[D]; n: int): IxMap[D]

revert:

• initialization: revert[D: static[int]](x: var IxMap[D])

rollLeft:

• arrayutils: rollLeft[I, T](arr: var array[I, T]; r: Slice[int])

rollRight:

• arrayutils: rollRight[I, T](arr: var array[I, T]; r: Slice[int])

select:

• indexing: select(ix: IxMap; dim: static[int]; idx: AnyIndexing): auto

shape:

• basic: shape[D: static[int]](x: IxMap[D]): IxArray[D]

shortDotProduct:

• arrayutils: shortDotProduct[N, M: static[int]; T, U, R](initial: R; x: array[N, T]; y: array[M, U]): untyped

shortMax:

• arrayutils: shortMax[N, M: static[int]; T](a`gensym0: array[N, T]; b`gensym0: array[M, T]): auto

shortMin:

• arrayutils: shortMin[N, M: static[int]; T](a`gensym5: array[N, T]; b`gensym5: array[M, T]): auto

size:

• basic: size(x: IxMap): int

slice:

• indexing: slice[D: static[int]; S](x: sink IxMap[D]; dim: int; idx: S): IxMap[D]

sliceM:

• indexing: sliceM[D: static[int]](x: var IxMap[D]; dim: int; idx: AnyStrided | HSlice)

split:

• axis: split[D: static[int]](src: IxMap[D]; N: static[int]): auto

StaticAxes:

• types: StaticAxes

submaps:

• iterators: submaps[D: static[int]](src: IxMap[D]; axis: AxisSpec): auto

swapAxes:

• axis: swapAxes[D: static[int]](ix: var IxMap[D]; x, y: int)

toInt:

• types: toInt(ix: IxMap[0]): int

toIntArray:

• types: toIntArray[D: static[int]](x: IxArray[D]): array[D, int]

toIxArray:

• types: toIxArray[D: static[int]; T: SomeInteger](x: array[D, T]): IxArray[D]

transpose:

• transforms: transpose[D: static[int]](x: sink IxMap[D]): IxMap[D]

withCoords:

• iterators: withCoords[D: static[int]; T](u: openArray[T]; ix: IxMap[D]): (IxArray[D], lent T)

withOffsets:

• iterators: withOffsets[D: static[int]; T](u: openArray[T]; ix: IxMap[D]): (IxArray[D], lent T)

zipImpl2:

• iterators: zipImpl2[T1, T2](t: tuple[a: openArray[T1], b: openArray[T2]]; ix1: IxMap; ix2: distinct IxMap): (lent T1, lent T2)

zipImpl3:

• iterators: zipImpl3[T1, T2, T3](t: tuple[a: openArray[T1], b: openArray[T2], c: openArray[T3]]; ix1: IxMap; ix2: distinct IxMap; ix3: distinct IxMap): (lent T1, lent T2, lent T3)

zipIndex:

• iterators: zipIndex(u: tuple; ix1: IxMap; ix2: distinct IxMap): untyped
• iterators: zipIndex(u: tuple; ix1: IxMap; ix2: distinct IxMap; ix3: distinct IxMap): untyped