mapFolding 0.7.0__py3-none-any.whl → 0.8.0__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,5 +1,18 @@
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
 from mapFolding.theSSOT import ComputationState
-import copy
+from multiprocessing import set_start_method as multiprocessing_set_start_method
+
+"""
+- 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
+"""
+
+# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+if __name__ == '__main__':
+	multiprocessing_set_start_method('spawn')
 
 def activeLeafConnectedToItself(state: ComputationState) -> bool:
 	return state.leafConnectee == state.leaf1ndex
@@ -16,7 +29,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]
@@ -96,7 +109,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]]
@@ -136,42 +149,38 @@ 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
 
-def countParallel(statePARALLEL: ComputationState) -> ComputationState:
-	stateCOMPLETE = copy.deepcopy(statePARALLEL)
-	for indexSherpa in range(statePARALLEL.taskDivisions):
-		state = copy.deepcopy(statePARALLEL)
-		state.taskIndex = indexSherpa
-		while activeLeafGreaterThan0(state):
-			if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
-				if activeLeafGreaterThanLeavesTotal(state):
-					state.groupsOfFolds += 1
-				else:
-					state = initializeVariablesToFindGaps(state)
-					while loopUpToDimensionsTotal(state):
-						if dimensionsUnconstrainedCondition(state):
-							state = decrementDimensionsUnconstrained(state)
-						else:
-							state = initializeLeafConnectee(state)
-							while loopingLeavesConnectedToActiveLeaf(state):
-								if thisIsMyTaskIndex(state):
-									state = countGaps(state)
-								state = updateLeafConnectee(state)
-						state = incrementIndexDimension(state)
-					state = initializeIndexMiniGap(state)
-					while loopingToActiveGapCeiling(state):
-						state = filterCommonGaps(state)
-						state = incrementIndexMiniGap(state)
-			while noGapsHere(state):
-				state = backtrack(state)
-			if thereIsAnActiveLeaf(state):
-				state = placeLeaf(state)
-		stateCOMPLETE.foldGroups[state.taskIndex] = state.groupsOfFolds
-	return stateCOMPLETE
+def countParallel(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					if dimensionsUnconstrainedCondition(state):
+						state = decrementDimensionsUnconstrained(state)
+					else:
+						state = initializeLeafConnectee(state)
+						while loopingLeavesConnectedToActiveLeaf(state):
+							if thisIsMyTaskIndex(state):
+								state = countGaps(state)
+							state = updateLeafConnectee(state)
+					state = incrementIndexDimension(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = undoLastLeafPlacement(state)
+		if thereIsAnActiveLeaf(state):
+			state = insertLeafAtGap(state)
+	state.foldGroups[state.taskIndex] = state.groupsOfFolds
+	return state
 
 def countSequential(state: ComputationState) -> ComputationState:
 	while activeLeafGreaterThan0(state):
@@ -194,15 +203,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:
-		return countParallel(state)
+		dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
+		with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
+			for indexSherpa in range(state.taskDivisions):
+				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]
 	else:
-		return countSequential(state)
+		state = countSequential(state)
+
+	return state

mapFolding/theSSOT.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from importlib import import_module as importlib_import_module
 from inspect import getfile as inspect_getfile
 from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray, signedinteger
@@ -19,33 +20,33 @@ 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'
-Z0Z_packageFlow = 'algorithm'
-# 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
 
 sourceAlgorithmPACKAGING: str = 'theDao'
 datatypePackagePACKAGING: Final[str] = 'numpy'
-dispatcherCallableAsStrPACKAGING: str = 'doTheNeedful'
+dispatcherCallablePACKAGING: str = 'doTheNeedful'
 moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
 
-dataclassModuleAsStrPACKAGING: str = 'theSSOT'
-dataclassIdentifierAsStrPACKAGING: str = 'ComputationState'
-dataclassInstanceAsStrPACKAGING: str = 'state'
-dataclassInstance_Pre_ParallelAsStrPACKAGING = dataclassInstanceAsStrPACKAGING + 'PARALLEL'
-dataclassInstance_Post_ParallelAsStrPACKAGING = dataclassInstanceAsStrPACKAGING + 'COMPLETE'
+dataclassModulePACKAGING: str = 'theSSOT'
+dataclassIdentifierPACKAGING: str = 'ComputationState'
+dataclassInstancePACKAGING: str = 'state'
+dataclassInstanceTaskDistributionPACKAGING = dataclassInstancePACKAGING + 'Parallel'
 
-Z0Z_initializeCallableAsStrPACKAGING = 'countInitialize'
-Z0Z_sequentialCallableAsStrPACKAGING = 'countSequential'
-Z0Z_parallelCallableAsStrPACKAGING = 'countParallel'
+sourceInitializeCallablePACKAGING = 'countInitialize'
+sourceSequentialCallablePACKAGING = 'countSequential'
+sourceParallelCallablePACKAGING = 'countParallel'
 
 try:
-	thePackageNameIsPACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNameIsPACKAGING: str = "mapFolding"
+	thePackageNamePACKAGING = "mapFolding"
 
 # =============================================================================
 # The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
@@ -54,21 +55,16 @@ except Exception:
 fileExtensionINSTALLING: str = '.py'
 
 def getPathPackageINSTALLING() -> Path:
-	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNameIsPACKAGING)))
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNamePACKAGING)))
 	if pathPackage.is_file():
 		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] = thePackageNameIsPACKAGING
+thePackageName: Final[str] = thePackageNamePACKAGING
 thePathPackage: Path = getPathPackageINSTALLING()
 
 """
@@ -81,27 +77,27 @@ NOTE on semiotics: `theIdentifier` vs `identifier`
 """
 
 theSourceAlgorithm: str = sourceAlgorithmPACKAGING
+theSourceInitializeCallable = sourceInitializeCallablePACKAGING
+theSourceSequentialCallable = sourceSequentialCallablePACKAGING
+theSourceParallelCallable = sourceParallelCallablePACKAGING
 theDatatypePackage: Final[str] = datatypePackagePACKAGING
 
-theDispatcherCallableAsStr: str = dispatcherCallableAsStrPACKAGING
+theDispatcherCallable: str = dispatcherCallablePACKAGING
 
-theDataclassModuleAsStr: str = dataclassModuleAsStrPACKAGING
-theDataclassIdentifierAsStr: str = dataclassIdentifierAsStrPACKAGING
-theDataclassInstanceAsStr: str = dataclassInstanceAsStrPACKAGING
-theDataclassInstance_Pre_ParallelAsStr: str = dataclassInstance_Pre_ParallelAsStrPACKAGING
-theDataclassInstance_Post_ParallelAsStr: str = dataclassInstance_Post_ParallelAsStrPACKAGING
+theDataclassModule: str = dataclassModulePACKAGING
+theDataclassIdentifier: str = dataclassIdentifierPACKAGING
+theDataclassInstance: str = dataclassInstancePACKAGING
+theDataclassInstanceTaskDistribution: str = dataclassInstanceTaskDistributionPACKAGING
 
 theFileExtension: str = fileExtensionINSTALLING
 
 theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
 
-Z0Z_initializeCallableAsStr = Z0Z_initializeCallableAsStrPACKAGING
-Z0Z_sequentialCallableAsStr = Z0Z_sequentialCallableAsStrPACKAGING
-Z0Z_parallelCallableAsStr = Z0Z_parallelCallableAsStrPACKAGING
-
 # =============================================================================
-# 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
@@ -137,17 +133,18 @@ class ComputationState:
 	mapShape: tuple[DatatypeLeavesTotal, ...]
 	leavesTotal: DatatypeLeavesTotal
 	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)
@@ -158,10 +155,10 @@ class ComputationState:
 	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)
@@ -186,29 +183,23 @@ 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.
 
 theLogicalPathModuleSourceAlgorithm: str = '.'.join([thePackageName, theSourceAlgorithm])
 theLogicalPathModuleDispatcher: str = theLogicalPathModuleSourceAlgorithm
-theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModuleAsStr])
+theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModule])
 
 def getSourceAlgorithm() -> ModuleType:
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
 	return moduleImported
 
-def getAlgorithmDispatcher():
+def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
 	moduleImported: ModuleType = getSourceAlgorithm()
-	# TODO I think I need to use `inspect` to type the return value
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallableAsStr)
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
 
 def getPathSyntheticModules() -> Path:
@@ -235,29 +226,36 @@ 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
 
 # THIS IS A STUPID SYSTEM BUT I CAN'T FIGURE OUT AN IMPROVEMENT
+# NOTE This section for _default_ values probably has value
+# https://github.com/hunterhogan/mapFolding/issues/4
 theFormatStrModuleSynthetic = "{packageFlow}Count"
 theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
 
-theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallableAsStr)
+theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallable)
 theLogicalPathModuleDispatcherSynthetic: str = '.'.join([thePackageName, theModuleOfSyntheticModules, theModuleDispatcherSynthetic])
 
 # =============================================================================
 # The most right way I know how to implement.
 
+# https://github.com/hunterhogan/mapFolding/issues/4
 if Z0Z_packageFlow == packageFlowSynthetic: # pyright: ignore [reportUnnecessaryComparison]
+	# NOTE this as a default value _might_ have value
 	theLogicalPathModuleDispatcher = theLogicalPathModuleDispatcherSynthetic
 
-def getPackageDispatcher():
+# https://github.com/hunterhogan/mapFolding/issues/4
+# dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
+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.
+
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallableAsStr)
-	from mapFolding.syntheticModules.numbaCountSequential import flattenData
-	dispatcherCallable = flattenData
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
@@ -266,8 +264,10 @@ def getPackageDispatcher():
 - 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
 """

{mapfolding-0.7.0.dist-info → mapfolding-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.7.0
+Version: 0.8.0
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -38,12 +38,11 @@ Requires-Dist: tomli
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
-Requires-Dist: updateCitation; extra == "testing"
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
 
@@ -113,14 +112,14 @@ Available OEIS sequences:
 
 ### 4. **Customizing your algorithm**
 
-- mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)
+- Renovations in progress: ~~mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)~~
   - Synthesize a Numba-optimized module for a specific mapShape
   - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
   - Use the existing transformation options
   - Or create new ways of transforming the algorithm from its source to a specific job
-- mapFolding\someAssemblyRequired\makeJob.py
+- Renovations in progress: ~~mapFolding\someAssemblyRequired\makeJob.py~~
   - Initialize data for a specific mapShape
-- mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)
+- Renovations in progress: ~~mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)~~
   - Synthesize one or more Numba-optimized modules for parallel or sequential computation
   - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
   - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
@@ -131,7 +130,7 @@ Available OEIS sequences:
   - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
   - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
   - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
-- mapFolding\theSSOT.py (and/or theSSOTnumba.py and/ or theSSOT____.py, if they exist)
+- mapFolding\theSSOT.py
   - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
   - Create new settings or groups of settings
 - mapFolding\beDRY.py