mapFolding 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

mapFolding/syntheticModules/numbaCountSequential.py

@@ -0,0 +1,110 @@
+from mapFolding.theDao import countInitialize, countParallel
+from mapFolding.theSSOT import Array1DElephino, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from numba import jit
+
+@jit(_nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, nopython=True, parallel=False)
+def countSequential(
+	connectionGraph: Array3D,
+	countDimensionsGapped: Array1DLeavesTotal,
+	dimensionsTotal: DatatypeLeavesTotal,
+	dimensionsUnconstrained: DatatypeLeavesTotal,
+	gap1ndex: DatatypeLeavesTotal,
+	gap1ndexCeiling: DatatypeElephino,
+	gapRangeStart: Array1DElephino,
+	gapsWhere: Array1DLeavesTotal,
+	groupsOfFolds: DatatypeFoldsTotal,
+	indexDimension: DatatypeLeavesTotal,
+	indexMiniGap: DatatypeElephino,
+	leaf1ndex: DatatypeElephino,
+	leafAbove: Array1DLeavesTotal,
+	leafBelow: Array1DLeavesTotal,
+	leafConnectee: DatatypeElephino,
+	leavesTotal: 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:
+					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
+	return groupsOfFolds
+
+def flattenData(state: ComputationState) -> ComputationState:
+
+	state = countInitialize(state)
+	if state.taskDivisions > 0:
+		return countParallel(state)
+
+	connectionGraph: Array3D = state.connectionGraph
+	countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+	dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+	dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+	gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+	gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+	gapRangeStart: Array1DElephino = state.gapRangeStart
+	gapsWhere: Array1DLeavesTotal = state.gapsWhere
+	groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+	indexDimension: DatatypeLeavesTotal = state.indexDimension
+	indexMiniGap: DatatypeElephino = state.indexMiniGap
+	leaf1ndex: DatatypeElephino = state.leaf1ndex
+	leafAbove: Array1DLeavesTotal = state.leafAbove
+	leafBelow: Array1DLeavesTotal = state.leafBelow
+	leafConnectee: DatatypeElephino = state.leafConnectee
+	leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+
+	groupsOfFolds = countSequential(
+		connectionGraph = connectionGraph,
+		countDimensionsGapped = countDimensionsGapped,
+		dimensionsTotal = dimensionsTotal,
+		dimensionsUnconstrained = dimensionsUnconstrained,
+		gap1ndex = gap1ndex,
+		gap1ndexCeiling = gap1ndexCeiling,
+		gapRangeStart = gapRangeStart,
+		gapsWhere = gapsWhere,
+		groupsOfFolds = groupsOfFolds,
+		indexDimension = indexDimension,
+		indexMiniGap = indexMiniGap,
+		leaf1ndex = leaf1ndex,
+		leafAbove = leafAbove,
+		leafBelow = leafBelow,
+		leafConnectee = leafConnectee,
+		leavesTotal = leavesTotal,
+		)
+
+	state.groupsOfFolds = state.foldGroups[state.taskIndex] = groupsOfFolds
+
+	return state

mapFolding/syntheticModules/numbaCount_doTheNeedful.py

@@ -0,0 +1,13 @@
+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)
+    else:
+        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -0,0 +1,12 @@
+from  import 
+from mapFolding.syntheticModules.numbaCount import countInitialize, countParallel, countSequential
+from mapFolding.theSSOT import ComputationState
+import copy
+
+@(ComputationState(ComputationState), _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(computationStateInitialized: ComputationState) -> ComputationState:
+    computationStateInitialized = countInitialize(computationStateInitialized)
+    if computationStateInitialized.taskDivisions > 0:
+        return countParallel(computationStateInitialized)
+    else:
+        return countSequential(computationStateInitialized)

mapFolding/syntheticModules/numba_doTheNeedfulExample.py

@@ -0,0 +1,13 @@
+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)
+    else:
+        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/theDao.py

@@ -1,232 +1,208 @@
-from mapFolding import indexMy, indexTrack
-from numba import prange
-from numpy import dtype, integer, ndarray
-from typing import Any
-
-# `.value` is not necessary for this module or most modules. But, this module is transformed into Numba "jitted" functions, and Numba won't use `Enum` for an ndarray index without `.value`.
-def activeLeafConnectedToItself(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
-
-def activeLeafGreaterThan0(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value] > 0
-
-def activeLeafGreaterThanLeavesTotal(foldGroups: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value] > foldGroups[-1]
-
-def activeLeafIsTheFirstLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value] <= 1
-
-def allDimensionsAreUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return not my[indexMy.dimensionsUnconstrained.value]
-
-def backtrack(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-	my[indexMy.leaf1ndex.value] -= 1
-	track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
-	track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
-
-def countGaps(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-	gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-	if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-		incrementGap1ndexCeiling(my=my)
-	track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-
-def decrementDimensionsUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.dimensionsUnconstrained.value] -= 1
-
-def dimensionsUnconstrainedCondition(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
-
-def filterCommonGaps(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-	gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-	if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-		incrementActiveGap(my=my)
-	track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-
-def incrementActiveGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.gap1ndex.value] += 1
-
-def incrementGap1ndexCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.gap1ndexCeiling.value] += 1
-
-def incrementIndexDimension(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.indexDimension.value] += 1
-
-def incrementIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.indexMiniGap.value] += 1
-
-def initializeIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-
-def initializeLeafConnectee(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-
-def initializeVariablesToFindGaps(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-	my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-	my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-	my[indexMy.indexDimension.value] = 0
-
-def insertUnconstrainedLeaf(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.indexLeaf.value] = 0
-	while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
-		gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
-		my[indexMy.gap1ndexCeiling.value] += 1
-		my[indexMy.indexLeaf.value] += 1
-
-def leafBelowSentinelIs1(track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
-	return track[indexTrack.leafBelow.value, 0] == 1
-
-def loopingLeavesConnectedToActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
-
-def loopingToActiveGapCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
-
-def loopUpToDimensionsTotal(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
-
-def noGapsHere(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-
-def placeLeaf(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-	my[indexMy.gap1ndex.value] -= 1
-	track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-	track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-	track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-	track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-	track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-	my[indexMy.leaf1ndex.value] += 1
-
-def thereIsAnActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value] > 0
-
-def thisIsMyTaskIndex(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
-
-def updateLeafConnectee(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-
-def countInitialize(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
-						, gapsWhere: ndarray[tuple[int]			 , dtype[integer[Any]]]
-						,		 my: ndarray[tuple[int]			 , dtype[integer[Any]]]
-						,	  track: ndarray[tuple[int, int]	 , dtype[integer[Any]]]
-					) -> None:
-
-	while activeLeafGreaterThan0(my=my):
-		if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
-			initializeVariablesToFindGaps(my=my, track=track)
-			while loopUpToDimensionsTotal(my=my):
-				if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-					decrementDimensionsUnconstrained(my=my)
-				else:
-					initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
-					while loopingLeavesConnectedToActiveLeaf(my=my):
-						countGaps(gapsWhere=gapsWhere, my=my, track=track)
-						updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
-				incrementIndexDimension(my=my)
-			if allDimensionsAreUnconstrained(my=my):
-				insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
-			initializeIndexMiniGap(my=my)
-			while loopingToActiveGapCeiling(my=my):
-				filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-				incrementIndexMiniGap(my=my)
-		if thereIsAnActiveLeaf(my=my):
-			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-		if my[indexMy.gap1ndex.value] > 0:
-			return
-
-def countParallel(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
-					,  foldGroups: ndarray[tuple[int]		   , dtype[integer[Any]]]
-					,   gapsWhere: ndarray[tuple[int]		   , dtype[integer[Any]]]
-					,		   my: ndarray[tuple[int]		   , dtype[integer[Any]]]
-					,		track: ndarray[tuple[int, int]	   , dtype[integer[Any]]]
-				) -> None:
-
-	gapsWherePARALLEL = gapsWhere.copy()
-	myPARALLEL = my.copy()
-	trackPARALLEL = track.copy()
-
-	taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-
-	for indexSherpa in prange(taskDivisionsPrange):
-		groupsOfFolds: int = 0
-
-		gapsWhere = gapsWherePARALLEL.copy()
-		my = myPARALLEL.copy()
-		track = trackPARALLEL.copy()
-
-		my[indexMy.taskIndex.value] = indexSherpa
-
-		while activeLeafGreaterThan0(my=my):
-			if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
-				if activeLeafGreaterThanLeavesTotal(foldGroups=foldGroups, my=my):
-					groupsOfFolds += 1
+from mapFolding.theSSOT import ComputationState
+import copy
+
+def activeLeafConnectedToItself(state: ComputationState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def activeLeafGreaterThan0(state: ComputationState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: ComputationState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: ComputationState) -> bool:
+	return state.leaf1ndex <= 1
+
+def allDimensionsAreUnconstrained(state: ComputationState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def backtrack(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]
+	return state
+
+def countGaps(state: ComputationState) -> ComputationState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def decrementDimensionsUnconstrained(state: ComputationState) -> ComputationState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def dimensionsUnconstrainedCondition(state: ComputationState) -> bool:
+	return state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex] == state.leaf1ndex
+
+def filterCommonGaps(state: ComputationState) -> ComputationState:
+	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+		state = incrementActiveGap(state)
+	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+	return state
+
+def incrementActiveGap(state: ComputationState) -> ComputationState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: ComputationState) -> ComputationState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexDimension(state: ComputationState) -> ComputationState:
+	state.indexDimension += 1
+	return state
+
+def incrementIndexMiniGap(state: ComputationState) -> ComputationState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: ComputationState) -> ComputationState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeLeafConnectee(state: ComputationState) -> ComputationState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def initializeVariablesToFindGaps(state: ComputationState) -> ComputationState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertUnconstrainedLeaf(state: ComputationState) -> ComputationState:
+	indexLeaf = 0
+	while indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
+		state.gap1ndexCeiling += 1
+		indexLeaf += 1
+	return state
+
+def leafBelowSentinelIs1(state: ComputationState) -> bool:
+	return state.leafBelow[0] == 1
+
+def loopingLeavesConnectedToActiveLeaf(state: ComputationState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingToActiveGapCeiling(state: ComputationState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def loopUpToDimensionsTotal(state: ComputationState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def noGapsHere(state: ComputationState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def placeLeaf(state: ComputationState) -> ComputationState:
+	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
+	return state
+
+def thereIsAnActiveLeaf(state: ComputationState) -> bool:
+	return state.leaf1ndex > 0
+
+def thisIsMyTaskIndex(state: ComputationState) -> bool:
+	return (state.leaf1ndex != state.taskDivisions) or (state.leafConnectee % state.taskDivisions == state.taskIndex)
+
+def updateLeafConnectee(state: ComputationState) -> ComputationState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def countInitialize(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					state = initializeLeafConnectee(state)
+					if activeLeafConnectedToItself(state):
+						state = decrementDimensionsUnconstrained(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = countGaps(state)
+							state = updateLeafConnectee(state)
+					state = incrementIndexDimension(state)
+				if allDimensionsAreUnconstrained(state):
+					state = insertUnconstrainedLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		if thereIsAnActiveLeaf(state):
+			state = placeLeaf(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:
-					initializeVariablesToFindGaps(my=my, track=track)
-					while loopUpToDimensionsTotal(my=my):
-						if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-							decrementDimensionsUnconstrained(my=my)
+					state = initializeVariablesToFindGaps(state)
+					while loopUpToDimensionsTotal(state):
+						if dimensionsUnconstrainedCondition(state):
+							state = decrementDimensionsUnconstrained(state)
 						else:
-							initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
-							while loopingLeavesConnectedToActiveLeaf(my=my):
-								if thisIsMyTaskIndex(my=my):
-									countGaps(gapsWhere=gapsWhere, my=my, track=track)
-								updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
-						incrementIndexDimension(my=my)
-					initializeIndexMiniGap(my=my)
-					while loopingToActiveGapCeiling(my=my):
-						filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-						incrementIndexMiniGap(my=my)
-			while noGapsHere(my=my, track=track):
-				backtrack(my=my, track=track)
-			if thereIsAnActiveLeaf(my=my):
-				placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-		foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
-
-def countSequential( connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
-						, foldGroups: ndarray[tuple[int]		  , dtype[integer[Any]]]
-						,  gapsWhere: ndarray[tuple[int]		  , dtype[integer[Any]]]
-						,		  my: ndarray[tuple[int]		  , dtype[integer[Any]]]
-						,	   track: ndarray[tuple[int, int]	  , dtype[integer[Any]]]
-					) -> None:
-
-	groupsOfFolds: int = 0
-
-	while activeLeafGreaterThan0(my=my):
-		if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
-			if activeLeafGreaterThanLeavesTotal(foldGroups=foldGroups, my=my):
-				groupsOfFolds += 1
+							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 countSequential(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
 			else:
-				initializeVariablesToFindGaps(my=my, track=track)
-				while loopUpToDimensionsTotal(my=my):
-					initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
-					if activeLeafConnectedToItself(my=my):
-						decrementDimensionsUnconstrained(my=my)
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					state = initializeLeafConnectee(state)
+					if activeLeafConnectedToItself(state):
+						state = decrementDimensionsUnconstrained(state)
 					else:
-						while loopingLeavesConnectedToActiveLeaf(my=my):
-							countGaps(gapsWhere=gapsWhere, my=my, track=track)
-							updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
-					incrementIndexDimension(my=my)
-				initializeIndexMiniGap(my=my)
-				while loopingToActiveGapCeiling(my=my):
-					filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-					incrementIndexMiniGap(my=my)
-		while noGapsHere(my=my, track=track):
-			backtrack(my=my, track=track)
-		if thereIsAnActiveLeaf(my=my):
-			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-	foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
-
-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.value] > 0:
-		countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
+						while loopingLeavesConnectedToActiveLeaf(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)
+	state.foldGroups[state.taskIndex] = state.groupsOfFolds
+	return state
+
+def doTheNeedful(state: ComputationState) -> ComputationState:
+	state = countInitialize(state)
+	if state.taskDivisions > 0:
+		return countParallel(state)
 	else:
-		countSequential(connectionGraph, foldGroups, gapsWhere, my, track)
+		return countSequential(state)