Index

Modules: ../docs/changelog, nimcso, nimcso/bitArrayAutoconfigured.

API symbols

`$`:

• nimcso: proc `$`(elSol: ElSolution): string
• bitArrayAutoconfigured: proc `$`(b: BitArray): string

`<`:

• nimcso: proc `<`(a, b: ElSolution): bool

`==`:

• nimcso: proc `==`(a, b: ElSolution): bool
• bitArrayAutoconfigured: proc `==`(a, b: var BitArray): bool

`>`:

• nimcso: proc `>`(a, b: ElSolution): bool

`[]=`:

• bitArrayAutoconfigured: proc `[]=`(b: var BitArray; i: int; v: bool)

`[]`:

• bitArrayAutoconfigured: proc `[]`(b: BitArray; i: int): bool

`and`:

• bitArrayAutoconfigured: proc `and`(a, b: BitArray): BitArray

`not`:

• bitArrayAutoconfigured: proc `not`(a: BitArray): BitArray

`or`:

• bitArrayAutoconfigured: proc `or`(a, b: BitArray): BitArray

algorithmSearch:

• nimcso: proc algorithmSearch(verbose: bool = true): seq[ElSolution]

BitArray:

• bitArrayAutoconfigured: object BitArray

bruteForce:

• nimcso: proc bruteForce(verbose: bool = true): seq[ElSolution]

bruteForceInt:

• nimcso: proc bruteForceInt(verbose: bool = true): seq[ElSolution]

clear:

• bitArrayAutoconfigured: proc clear(b: var BitArray)

configPath:

• nimcso: const configPath

count:

• bitArrayAutoconfigured: proc count(b: BitArray): int

crossover:

• nimcso: proc crossover(elSol1: var ElSolution; elSol2: var ElSolution; presenceArrays: seq[BitArray] | seq[seq[bool]]): void

dataN:

• nimcso: const dataN

elementN:

• nimcso: const elementN

elementOrder:

• nimcso: const elementOrder

ElSolution:

• nimcso: type ElSolution

firstFalse:

• bitArrayAutoconfigured: proc firstFalse(b: BitArray): (bool, int)

geneticSearch:

• nimcso: proc geneticSearch(verbose: bool = true; initialSolutionsN: Natural = 100; searchWidth: Natural = 100; maxIterations: Natural = 1000; minIterations: Natural = 10; mutationsN: Natural = 1): seq[ ElSolution]

getNextNodes:

• nimcso: proc getNextNodes(elSol: ElSolution; exclusions: BitArray; presenceBitArrays: seq[BitArray] | seq[seq[bool]]): seq[ElSolution]

getPresenceBitArrays:

• nimcso: proc getPresenceBitArrays(): seq[BitArray]

getPresenceBoolArrays:

• nimcso: proc getPresenceBoolArrays(): seq[seq[bool]]

getPresenceIntArray:

• nimcso: proc getPresenceIntArray(): array[dataN, uint64]

getPresenceTensor:

• nimcso: proc getPresenceTensor(): Tensor[int8]

hash:

• nimcso: proc hash(elSol: ElSolution): Hash
• bitArrayAutoconfigured: proc hash(b: BitArray): Hash

items:

• bitArrayAutoconfigured: iterator items(b: BitArray): bool

leastPreventing:

• nimcso: proc leastPreventing(verbose: bool = true): seq[ElSolution]

lenInt64:

• bitArrayAutoconfigured: const lenInt64

mostCommon:

• nimcso: proc mostCommon(verbose: bool = true): seq[ElSolution]

mutate:

• nimcso: proc mutate(elSol: var ElSolution; presenceArrays: seq[BitArray] | seq[seq[bool]]): void

newElSolution:

• nimcso: proc newElSolution(elBA: BitArray; pBA: seq[BitArray] | seq[seq[bool]]): ElSolution
• nimcso: proc newElSolution(elementSet: seq[string]; pBA: seq[BitArray] | seq[seq[bool]]): ElSolution

newElSolutionRandomN:

• nimcso: proc newElSolutionRandomN(order: int; pBA: seq[BitArray] | seq[seq[bool]]): ElSolution

pairs:

• bitArrayAutoconfigured: iterator pairs(b: BitArray): (int, bool)

presentInData:

• nimcso: proc presentInData(elList: BitArray; pBAs: seq[BitArray] | seq[seq[bool]]): int

preventedData:

• nimcso: proc preventedData(elList: BitArray; presenceBitArrays: seq[BitArray]): int
• nimcso: proc preventedData(elList: BitArray; presenceBoolArrays: seq[seq[bool]]): int
• nimcso: proc preventedData(elList: Tensor[int8]; presenceTensor: Tensor[int8]): int
• nimcso: proc preventedData(elList: uint64; presenceIntArray: array[dataN, uint64]): int

randomize:

• nimcso: proc randomize(elSol: var ElSolution): void

saveFilteredDataset:

• nimcso: proc saveFilteredDataset(path: string = "filteredDataset.csv"): void

saveResults:

• nimcso: proc saveResults(results: seq[ElSolution]; path: string = "results.csv"; separator: string = "-"): void

setPrevented:

• nimcso: proc setPrevented(elSol: var ElSolution; presenceArrays: seq[BitArray] | seq[seq[bool]]): void

singleSolution:

• nimcso: proc singleSolution(args: seq[string]; verbose: bool = true): seq[ElSolution]

styledEcho:

• bitArrayAutoconfigured: proc styledEcho(b: BitArray)

styledEchoAnnotated:

• bitArrayAutoconfigured: proc styledEchoAnnotated(b: BitArray)

toBoolArray:

• bitArrayAutoconfigured: proc toBoolArray(b: BitArray): array[elementN, bool]

toSetPositions:

• bitArrayAutoconfigured: proc toSetPositions(b: BitArray): seq[int]

unsafeGet:

• bitArrayAutoconfigured: proc unsafeGet(b: BitArray; i: int): bool

unsafeSetFalse:

• bitArrayAutoconfigured: proc unsafeSetFalse(b: var BitArray; i: int)

unsafeSetTrue:

• bitArrayAutoconfigured: proc unsafeSetTrue(b: var BitArray; i: int)