mapFolding 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

mapFolding/syntheticModules/numbaCount_doTheNeedful.py

@@ -1,13 +1,198 @@
-from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countInitialize, countSequential, countParallel
-from numba import uint16, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def doTheNeedful(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], mapShape: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    countInitialize(connectionGraph, gapsWhere, my, track)
-    if my[indexMy.taskDivisions] > 0:
-        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
+from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from numba import jit
+
+def countInitialize(state: ComputationState) -> ComputationState:
+    while state.leaf1ndex > 0:
+        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
+            state.dimensionsUnconstrained = state.dimensionsTotal
+            state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+            state.indexDimension = 0
+            while state.indexDimension < state.dimensionsTotal:
+                state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                if state.leafConnectee == state.leaf1ndex:
+                    state.dimensionsUnconstrained -= 1
+                else:
+                    while state.leafConnectee != state.leaf1ndex:
+                        state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                        if state.countDimensionsGapped[state.leafConnectee] == 0:
+                            state.gap1ndexCeiling += 1
+                        state.countDimensionsGapped[state.leafConnectee] += 1
+                        state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                state.indexDimension += 1
+            if not state.dimensionsUnconstrained:
+                indexLeaf = 0
+                while indexLeaf < state.leaf1ndex:
+                    state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
+                    state.gap1ndexCeiling += 1
+                    indexLeaf += 1
+            state.indexMiniGap = state.gap1ndex
+            while state.indexMiniGap < state.gap1ndexCeiling:
+                state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                    state.gap1ndex += 1
+                state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                state.indexMiniGap += 1
+        if state.leaf1ndex > 0:
+            state.gap1ndex -= 1
+            state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+            state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+            state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+            state.leaf1ndex += 1
+        if state.gap1ndex > 0:
+            break
+    return state
+
+@jit(_nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+def countParallel(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeElephino, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> DatatypeFoldsTotal:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                groupsOfFolds += 1
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                        while leafConnectee != leaf1ndex:
+                            if leaf1ndex != taskDivisions or leafConnectee % taskDivisions == taskIndex:
+                                gapsWhere[gap1ndexCeiling] = leafConnectee
+                                if countDimensionsGapped[leafConnectee] == 0:
+                                    gap1ndexCeiling += 1
+                                countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
+        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        if leaf1ndex > 0:
+            gap1ndex -= 1
+            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+            gapRangeStart[leaf1ndex] = gap1ndex
+            leaf1ndex += 1
+    foldGroups[taskIndex] = groupsOfFolds
+    return groupsOfFolds
+
+@jit(_nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+def countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeElephino, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> tuple[tuple[DatatypeLeavesTotal, ...], DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, Array3D, DatatypeLeavesTotal, Array1DLeavesTotal, DatatypeLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DFoldsTotal, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal]:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                groupsOfFolds += 1
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if countDimensionsGapped[leafConnectee] == 0:
+                                gap1ndexCeiling += 1
+                            countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
+        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        if leaf1ndex > 0:
+            gap1ndex -= 1
+            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+            gapRangeStart[leaf1ndex] = gap1ndex
+            leaf1ndex += 1
+    foldGroups[taskIndex] = groupsOfFolds
+    return (mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+
+def doTheNeedful(state: ComputationState) -> ComputationState:
+    state = countInitialize(state)
+    if state.taskDivisions > 0:
+        dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
+        with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
+            for indexSherpa in range(state.taskDivisions):
+                stateParallel = deepcopy(state)
+                stateParallel.taskIndex = indexSherpa
+                mapShape: tuple[DatatypeLeavesTotal, ...] = stateParallel.mapShape
+                leavesTotal: DatatypeLeavesTotal = stateParallel.leavesTotal
+                taskDivisions: DatatypeLeavesTotal = stateParallel.taskDivisions
+                concurrencyLimit: DatatypeElephino = stateParallel.concurrencyLimit
+                connectionGraph: Array3D = stateParallel.connectionGraph
+                dimensionsTotal: DatatypeLeavesTotal = stateParallel.dimensionsTotal
+                countDimensionsGapped: Array1DLeavesTotal = stateParallel.countDimensionsGapped
+                dimensionsUnconstrained: DatatypeLeavesTotal = stateParallel.dimensionsUnconstrained
+                gapRangeStart: Array1DElephino = stateParallel.gapRangeStart
+                gapsWhere: Array1DLeavesTotal = stateParallel.gapsWhere
+                leafAbove: Array1DLeavesTotal = stateParallel.leafAbove
+                leafBelow: Array1DLeavesTotal = stateParallel.leafBelow
+                foldGroups: Array1DFoldsTotal = stateParallel.foldGroups
+                foldsTotal: DatatypeFoldsTotal = stateParallel.foldsTotal
+                gap1ndex: DatatypeLeavesTotal = stateParallel.gap1ndex
+                gap1ndexCeiling: DatatypeElephino = stateParallel.gap1ndexCeiling
+                groupsOfFolds: DatatypeFoldsTotal = stateParallel.groupsOfFolds
+                indexDimension: DatatypeLeavesTotal = stateParallel.indexDimension
+                indexLeaf: DatatypeLeavesTotal = stateParallel.indexLeaf
+                indexMiniGap: DatatypeElephino = stateParallel.indexMiniGap
+                leaf1ndex: DatatypeElephino = stateParallel.leaf1ndex
+                leafConnectee: DatatypeElephino = stateParallel.leafConnectee
+                taskIndex: DatatypeLeavesTotal = stateParallel.taskIndex
+                dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+            for indexSherpa in range(state.taskDivisions):
+                state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
     else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)
+        mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+        leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+        taskDivisions: DatatypeLeavesTotal = state.taskDivisions
+        concurrencyLimit: DatatypeElephino = state.concurrencyLimit
+        connectionGraph: Array3D = state.connectionGraph
+        dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+        countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+        dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+        gapRangeStart: Array1DElephino = state.gapRangeStart
+        gapsWhere: Array1DLeavesTotal = state.gapsWhere
+        leafAbove: Array1DLeavesTotal = state.leafAbove
+        leafBelow: Array1DLeavesTotal = state.leafBelow
+        foldGroups: Array1DFoldsTotal = state.foldGroups
+        foldsTotal: DatatypeFoldsTotal = state.foldsTotal
+        gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+        gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+        groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+        indexDimension: DatatypeLeavesTotal = state.indexDimension
+        indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+        indexMiniGap: DatatypeElephino = state.indexMiniGap
+        leaf1ndex: DatatypeElephino = state.leaf1ndex
+        leafConnectee: DatatypeElephino = state.leafConnectee
+        taskIndex: DatatypeLeavesTotal = state.taskIndex
+        mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex = countSequential(mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+        state = ComputationState(mapShape=mapShape, leavesTotal=leavesTotal, taskDivisions=taskDivisions, concurrencyLimit=concurrencyLimit, countDimensionsGapped=countDimensionsGapped, dimensionsUnconstrained=dimensionsUnconstrained, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, foldGroups=foldGroups, foldsTotal=foldsTotal, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, groupsOfFolds=groupsOfFolds, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, taskIndex=taskIndex)
+    return state

mapFolding/theDao.py

@@ -1,12 +1,32 @@
-from concurrent.futures import ProcessPoolExecutor
+"""
+Core computational algorithm for map folding counting and enumeration.
+
+This module implements the core algorithms for enumerating and counting the various ways
+a rectangular map can be folded. It uses a functional state-transformation approach, where
+each function performs a specific state mutation and returns the updated state. The module
+provides three main counting algorithms:
+
+1. countInitialize: Sets up the initial state for computation
+2. countSequential: Processes the folding computation sequentially
+3. countParallel: Distributes the computation across multiple processes
+
+All algorithms operate on a ComputationState object that tracks the folding process, including:
+- A "leaf" is a unit square in the map
+- A "gap" is a potential position where a new leaf can be folded
+- Connections track how leaves can connect above/below each other
+- Leaves are enumerated starting from 1, not 0; hence, leaf1ndex not leafIndex
+
+The doTheNeedful function is the main entry point that orchestrates the computation strategy
+based on task divisions and concurrency parameters.
+"""
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
 from mapFolding.theSSOT import ComputationState
-import concurrent.futures
-import copy
-import multiprocessing
+from multiprocessing import set_start_method as multiprocessing_set_start_method
 
 # When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
 if __name__ == '__main__':
-	multiprocessing.set_start_method('spawn')
+	multiprocessing_set_start_method('spawn')
 
 def activeLeafConnectedToItself(state: ComputationState) -> bool:
 	return state.leafConnectee == state.leaf1ndex
@@ -23,7 +43,7 @@ def activeLeafIsTheFirstLeaf(state: ComputationState) -> bool:
 def allDimensionsAreUnconstrained(state: ComputationState) -> bool:
 	return not state.dimensionsUnconstrained
 
-def backtrack(state: ComputationState) -> ComputationState:
+def undoLastLeafPlacement(state: ComputationState) -> ComputationState:
 	state.leaf1ndex -= 1
 	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
 	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
@@ -103,7 +123,7 @@ def loopUpToDimensionsTotal(state: ComputationState) -> bool:
 def noGapsHere(state: ComputationState) -> bool:
 	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
 
-def placeLeaf(state: ComputationState) -> ComputationState:
+def insertLeafAtGap(state: ComputationState) -> ComputationState:
 	state.gap1ndex -= 1
 	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
 	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
@@ -143,7 +163,7 @@ def countInitialize(state: ComputationState) -> ComputationState:
 					state = filterCommonGaps(state)
 					state = incrementIndexMiniGap(state)
 		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
+			state = insertLeafAtGap(state)
 		if state.gap1ndex > 0:
 			break
 	return state
@@ -170,9 +190,9 @@ def countParallel(state: ComputationState) -> ComputationState:
 					state = filterCommonGaps(state)
 					state = incrementIndexMiniGap(state)
 		while noGapsHere(state):
-			state = backtrack(state)
+			state = undoLastLeafPlacement(state)
 		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
+			state = insertLeafAtGap(state)
 	state.foldGroups[state.taskIndex] = state.groupsOfFolds
 	return state
 
@@ -197,23 +217,24 @@ def countSequential(state: ComputationState) -> ComputationState:
 					state = filterCommonGaps(state)
 					state = incrementIndexMiniGap(state)
 		while noGapsHere(state):
-			state = backtrack(state)
+			state = undoLastLeafPlacement(state)
 		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
+			state = insertLeafAtGap(state)
 	state.foldGroups[state.taskIndex] = state.groupsOfFolds
 	return state
 
 def doTheNeedful(state: ComputationState) -> ComputationState:
 	state = countInitialize(state)
 	if state.taskDivisions > 0:
-		dictionaryConcurrency: dict[int, concurrent.futures.Future[ComputationState]] = {}
+		dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
 		with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
 			for indexSherpa in range(state.taskDivisions):
-				stateParallel = copy.deepcopy(state)
+				stateParallel = deepcopy(state)
 				stateParallel.taskIndex = indexSherpa
 				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, stateParallel)
 			for indexSherpa in range(state.taskDivisions):
 				state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
-		return state
 	else:
-		return countSequential(state)
+		state = countSequential(state)
+
+	return state

mapFolding/theSSOT.py

@@ -1,3 +1,21 @@
+"""
+Single Source of Truth module for configuration, types, and computational state management.
+
+This module defines the core data structures, type definitions, and configuration settings
+used throughout the mapFolding package. It implements the Single Source of Truth (SSOT)
+principle to ensure consistency across the package's components.
+
+Key features:
+1. The ComputationState dataclass, which encapsulates the state of the folding computation
+2. Unified type definitions for integers and arrays used in the computation
+3. Configuration settings for synthetic module generation and dispatching
+4. Path resolution and management for package resources and job output
+5. Dynamic dispatch functionality for algorithm implementations
+
+The module differentiates between "the" identifiers (package defaults) and other identifiers
+to avoid namespace collisions when transforming algorithms.
+"""
+
 from collections.abc import Callable
 from importlib import import_module as importlib_import_module
 from inspect import getfile as inspect_getfile
@@ -20,12 +38,11 @@ Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
 """
 
 # I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
+# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 packageFlowSynthetic = 'numba'
-# packageFlowSynthetic = 'multiprocessing'
-Z0Z_packageFlow = 'algorithm'
-# https://github.com/hunterhogan/mapFolding/issues/4
-# Z0Z_packageFlow = packageFlowSynthetic
-
+# Z0Z_packageFlow = 'algorithm'
+Z0Z_packageFlow = packageFlowSynthetic
+Z0Z_concurrencyPackage = 'multiprocessing'
 # =============================================================================
 # The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
 # Evaluate When Packaging Evaluate When Packaging Evaluate When Packaging
@@ -38,8 +55,7 @@ moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
 dataclassModulePACKAGING: str = 'theSSOT'
 dataclassIdentifierPACKAGING: str = 'ComputationState'
 dataclassInstancePACKAGING: str = 'state'
-dataclassInstance_Pre_ParallelPACKAGING = dataclassInstancePACKAGING + 'PARALLEL'
-dataclassInstance_Post_ParallelPACKAGING = dataclassInstancePACKAGING + 'COMPLETE'
+dataclassInstanceTaskDistributionPACKAGING = dataclassInstancePACKAGING + 'Parallel'
 
 sourceInitializeCallablePACKAGING = 'countInitialize'
 sourceSequentialCallablePACKAGING = 'countSequential'
@@ -48,7 +64,7 @@ sourceParallelCallablePACKAGING = 'countParallel'
 try:
 	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNamePACKAGING: str = "mapFolding"
+	thePackageNamePACKAGING = "mapFolding"
 
 # =============================================================================
 # The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
@@ -62,14 +78,9 @@ def getPathPackageINSTALLING() -> Path:
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding
-
 # =============================================================================
 # The right way, perhaps.
 
-# =====================
 # Create enduring identifiers from the hopefully transient identifiers above.
 thePackageName: Final[str] = thePackageNamePACKAGING
 thePathPackage: Path = getPathPackageINSTALLING()
@@ -94,16 +105,17 @@ theDispatcherCallable: str = dispatcherCallablePACKAGING
 theDataclassModule: str = dataclassModulePACKAGING
 theDataclassIdentifier: str = dataclassIdentifierPACKAGING
 theDataclassInstance: str = dataclassInstancePACKAGING
-theDataclassInstance_Pre_Parallel: str = dataclassInstance_Pre_ParallelPACKAGING
-theDataclassInstance_Post_Parallel: str = dataclassInstance_Post_ParallelPACKAGING
+theDataclassInstanceTaskDistribution: str = dataclassInstanceTaskDistributionPACKAGING
 
 theFileExtension: str = fileExtensionINSTALLING
 
 theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
 
 # =============================================================================
-# The right way.
+
+# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 concurrencyPackage: str = Z0Z_packageFlow
+concurrencyPackage = Z0Z_concurrencyPackage
 
 # =============================================================================
 # The relatively flexible type system needs a different paradigm, but I don't
@@ -141,30 +153,30 @@ class ComputationState:
 	taskDivisions: DatatypeLeavesTotal
 	concurrencyLimit: DatatypeElephino
 
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'description': 'A 3D array representing the connection graph of the map.'})
+	connectionGraph: Array3D = dataclasses.field(init=False)
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 
-	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	gapRangeStart: Array1DElephino = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
 
 	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
 	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
-	groupsOfFolds: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
 	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
 	leaf1ndex: DatatypeElephino = DatatypeElephino(1)
 	leafConnectee: DatatypeElephino = DatatypeElephino(0)
-	taskIndex: DatatypeLeavesTotal = dataclasses.field(default=DatatypeLeavesTotal(0), metadata={'myType': DatatypeLeavesTotal})
-	# taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 
-	def __post_init__(self):
+	def __post_init__(self) -> None:
 		from mapFolding.beDRY import makeConnectionGraph, makeDataContainer
 		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
 		self.connectionGraph = makeConnectionGraph(self.mapShape, self.leavesTotal, numpyLeavesTotal)
@@ -189,14 +201,9 @@ class ComputationState:
 		if self.leafBelow is None:
 			self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
 
-	def getFoldsTotal(self):
+	def getFoldsTotal(self) -> None:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
 
-	# factory? constructor?
-	# state.taskIndex = state.taskIndex.type(indexSherpa)
-	# self.fieldName = self.fieldName.fieldType(indexSherpa)
-	# state.taskIndex.toMyType(indexSherpa)
-
 # =============================================================================
 # The most right way I know how to implement.
 
@@ -208,8 +215,7 @@ def getSourceAlgorithm() -> ModuleType:
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
 	return moduleImported
 
-# dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
-def getAlgorithmDispatcher():
+def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
 	moduleImported: ModuleType = getSourceAlgorithm()
 	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
@@ -238,7 +244,7 @@ def getNumpyDtypeDefault() -> type[signedinteger[Any]]:
 # =============================================================================
 # The coping way.
 
-class FREAKOUT(Exception): pass
+class raiseIfNoneGitHubIssueNumber3(Exception): pass
 
 # =============================================================================
 # Temporary or transient or something; probably still the wrong way
@@ -266,13 +272,8 @@ def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
 	# NOTE but this part, if the package flow is synthetic, probably needs to be delegated
 	# to the authority for creating _that_ synthetic flow.
 
-	# Automated system
-	# moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	# dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
-
-	# Hardcoded while I am refactoring "someAssemblyRequired"
-	from mapFolding.syntheticModules.numbaCountSequential import flattenData
-	dispatcherCallable = flattenData
+	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
@@ -281,8 +282,10 @@ def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
 - Lazy Initialization
 - Separate configuration from business logic
 
+----
 theSSOT and yourSSOT
 
+----
 delay realization/instantiation until a concrete value is desired
 moment of truth: when the value is needed, not when the value is defined
 """