Index

Modules: docs/changelog, nimplex, utils/plotting, utils/stitching.

API symbols

args:

• nimplex: let args

attainable2elemental:

• nimplex: proc attainable2elemental(simplexPoints: Tensor[SomeNumber]; components: seq[seq[SomeNumber]]): Tensor[float]

benchmark:

• nimplex: template benchmark(benchmarkName: string; code: untyped)

compareNodes:

• stitching: proc compareNodes(a: int; b: int; nodeCoordinateTensor: Tensor[int]; priorityList: seq[int]): int

configValidation:

• nimplex: proc configValidation(config: string)

echoHelp:

• nimplex: proc echoHelp()

findStitchingPoints:

• stitching: proc findStitchingPoints(dim: int; ndiv: int; maxDim: int = 3; components: seq[string] = generateAlphabetSequence(dim); offset: int = 0): Table[string, seq[int]]

findSubspace:

• stitching: proc findSubspace[T](lst: seq[T]; maxDim: int = 3): seq[seq[T]]

generateAlphabetSequence:

• stitching: proc generateAlphabetSequence(length: int): seq[string]

isSubspace:

• stitching: proc isSubspace(subSpace: seq[int]; space: seq[int]): bool

nDivValidation:

• nimplex: proc nDivValidation(config: string; nDiv: int; dim: int)

nonZeroComps:

• stitching: proc nonZeroComps(p: Tensor[int]): seq[int]

outFunction:

• nimplex: proc outFunction(config: string; npyName: string; outputData: Tensor)

outFunction_graph:

• nimplex: proc outFunction_graph(config: string; dim: int; ndiv: int; npyName: string; outputData: (Tensor, seq))

permutations:

• stitching: proc permutations[T](s: seq[T]): seq[seq[T]]

pure_component_indexes:

• nimplex: proc pure_component_indexes(dim: int; ndiv: int): seq[int]

pure_component_indexes_internal:

• nimplex: proc pure_component_indexes_internal(dim: int; ndiv: int): seq[int]

simplex2cartesian:

• plotting: proc simplex2cartesian(simplexPoints: Tensor[float]): Tensor[float]

simplex_graph:

• nimplex: proc simplex_graph(dim: int; ndiv: int): (Tensor[int], seq[seq[int]])

simplex_graph_3C:

• nimplex: proc simplex_graph_3C(ndiv: int): (Tensor[int], seq[seq[int]])

simplex_graph_3C_fractional:

• nimplex: proc simplex_graph_3C_fractional(ndiv: int): (Tensor[float], seq[seq[int]])

simplex_graph_fractional:

• nimplex: proc simplex_graph_fractional(dim: int; ndiv: int): (Tensor[float], seq[seq[int]])

simplex_grid:

• nimplex: proc simplex_grid(dim: int; ndiv: int): Tensor[int]

simplex_grid_fractional:

• nimplex: proc simplex_grid_fractional(dim: int; ndiv: int): Tensor[float]

simplex_internal_grid:

• nimplex: proc simplex_internal_grid(dim: int; ndiv: int): Tensor[int]

simplex_internal_grid_fractional:

• nimplex: proc simplex_internal_grid_fractional(dim: int; ndiv: int): Tensor[float]

simplex_sampling_mc:

• nimplex: proc simplex_sampling_mc(dim: int; samples: int): Tensor[float]

sortNodes:

• stitching: proc sortNodes(nodes: var seq[int]; coordinateTensor: Tensor[int]; priorityList: seq[int]): void

space2name:

• stitching: proc space2name(space: seq[int]; components: seq[string]): string

taskRouter:

• nimplex: proc taskRouter(config: string; dim: int; ndiv: int; npyName: string)