mapFolding 0.3.11__py3-none-any.whl → 0.4.0__py3-none-any.whl

mapFolding/syntheticModules/numba_countSequential.py

@@ -3,9 +3,9 @@ from mapFolding import indexTrack
 from numba import uint8
 from numba import jit
 from numba import int64
-from numpy import ndarray
-from numpy import dtype
 from numpy import integer
+from numpy import dtype
+from numpy import ndarray
 from typing import Any
 from typing import Tuple
 
@@ -25,33 +25,33 @@ def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
     gap1ndex = my[indexMy.gap1ndex.value]
     taskIndex = my[indexMy.taskIndex.value]
     groupsOfFolds: int = 0
-    doFindGaps = True
     while leaf1ndex:
-        if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:
-            groupsOfFolds += 1
-        elif doFindGaps:
-            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:
-                        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
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > foldGroups[-1]:
+                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:
+                            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 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
             leaf1ndex -= 1
             leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,17 +1,17 @@
+from mapFolding.syntheticModules.numba_countInitialize import countInitialize
+from mapFolding.syntheticModules.numba_countParallel import countParallel
+from mapFolding.syntheticModules.numba_countSequential import countSequential
 from mapFolding import indexMy
 from numba import uint8
 from numba import jit
 from numba import int64
-from numpy import ndarray
-from numpy import dtype
 from numpy import integer
+from numpy import dtype
+from numpy import ndarray
 from typing import Any
 from typing import Tuple
-from mapFolding.syntheticModules.numba_countInitialize import countInitialize
-from mapFolding.syntheticModules.numba_countParallel import countParallel
-from mapFolding.syntheticModules.numba_countSequential import countSequential
 
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=True, cache=True, error_model='python', fastmath=False, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[::1], uint8[:, ::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.value] > 0:

mapFolding/theDao.py

@@ -4,227 +4,226 @@ from numpy import dtype, integer, ndarray
 from typing import Any, Tuple
 
 def activeGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    # `.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 index without `.value`.
-    my[indexMy.gap1ndex.value] += 1
+	# `.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`.
+	my[indexMy.gap1ndex.value] += 1
 
 def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.leaf1ndex.value]
+	return my[indexMy.leaf1ndex.value]
 
 def activeLeafGreaterThanLeavesTotalCondition(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.leaf1ndex.value] > foldGroups[-1]
+	return my[indexMy.leaf1ndex.value] > foldGroups[-1]
 
 def activeLeafIsTheFirstLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.leaf1ndex.value] <= 1
+	return my[indexMy.leaf1ndex.value] <= 1
 
 def allDimensionsAreUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return not my[indexMy.dimensionsUnconstrained.value]
+	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]]
+	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 backtrackCondition(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+	return my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 
 def gap1ndexCeilingIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.gap1ndexCeiling.value] += 1
+	my[indexMy.gap1ndexCeiling.value] += 1
 
 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:
-        gap1ndexCeilingIncrement(my=my)
-    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-
-def dimension1ndexIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.indexDimension.value] += 1
+	gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+	if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+		gap1ndexCeilingIncrement(my=my)
+	track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.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]
+	return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
 
 def dimensionsUnconstrainedDecrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.dimensionsUnconstrained.value] -= 1
+	my[indexMy.dimensionsUnconstrained.value] -= 1
 
 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]:
-        activeGapIncrement(my=my)
-    track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+	gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+	if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+		activeGapIncrement(my=my)
+	track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
 
 def findGapsInitializeVariables(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
+	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 indexDimensionIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+	my[indexMy.indexDimension.value] += 1
 
 def indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.indexMiniGap.value] += 1
+	my[indexMy.indexMiniGap.value] += 1
 
 def indexMiniGapInitialization(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+	my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
 
 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
+	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 leafBelowSentinelIs1Condition(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
-    return track[indexTrack.leafBelow.value, 0] == 1
+	return track[indexTrack.leafBelow.value, 0] == 1
 
 def leafConnecteeInitialization(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]]
+	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
 
 def leafConnecteeUpdate(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]]]
+	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
 
 def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
+	return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopingTheDimensions(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
+def loopUpToDimensionsTotal(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
 def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
 
 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
+	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 placeLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-    return my[indexMy.leaf1ndex.value]
+	return my[indexMy.leaf1ndex.value]
 
 def thereAreComputationDivisionsYouMightSkip(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]
+	return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.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 activeLeafGreaterThan0Condition(my=my):
-        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-            findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
-                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-                    dimensionsUnconstrainedDecrement(my=my)
-                else:
-                    leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
-                    while loopingLeavesConnectedToActiveLeaf(my=my):
-                        countGaps(gapsWhere=gapsWhere, my=my, track=track)
-                        leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                dimension1ndexIncrement(my=my)
-            if allDimensionsAreUnconstrained(my=my):
-                insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
-            indexMiniGapInitialization(my=my)
-            while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-                indexMiniGapIncrement(my=my)
-        if placeLeafCondition(my=my):
-            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-        if my[indexMy.gap1ndex.value] > 0:
-            return
+						, gapsWhere: ndarray[Tuple[int]		  , dtype[integer[Any]]]
+						,		my: ndarray[Tuple[int]		  , dtype[integer[Any]]]
+						,	 track: ndarray[Tuple[int, int]	 , dtype[integer[Any]]]
+					) -> None:
+
+	while activeLeafGreaterThan0Condition(my=my):
+		if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+			findGapsInitializeVariables(my=my, track=track)
+			while loopUpToDimensionsTotal(my=my):
+				if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+					dimensionsUnconstrainedDecrement(my=my)
+				else:
+					leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+					while loopingLeavesConnectedToActiveLeaf(my=my):
+						countGaps(gapsWhere=gapsWhere, my=my, track=track)
+						leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+				indexDimensionIncrement(my=my)
+			if allDimensionsAreUnconstrained(my=my):
+				insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
+			indexMiniGapInitialization(my=my)
+			while loopingToActiveGapCeiling(my=my):
+				filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+				indexMiniGapIncrement(my=my)
+		if placeLeafCondition(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 activeLeafGreaterThan0Condition(my=my):
-            if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-                if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
-                    groupsOfFolds += 1
-                else:
-                    findGapsInitializeVariables(my=my, track=track)
-                    while loopingTheDimensions(my=my):
-                        if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-                            dimensionsUnconstrainedDecrement(my=my)
-                        else:
-                            leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
-                            while loopingLeavesConnectedToActiveLeaf(my=my):
-                                if thereAreComputationDivisionsYouMightSkip(my=my):
-                                    countGaps(gapsWhere=gapsWhere, my=my, track=track)
-                                leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                        dimension1ndexIncrement(my=my)
-                    indexMiniGapInitialization(my=my)
-                    while loopingToActiveGapCeiling(my=my):
-                        filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-                        indexMiniGapIncrement(my=my)
-            while backtrackCondition(my=my, track=track):
-                backtrack(my=my, track=track)
-            if placeLeafCondition(my=my):
-                placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
+					,  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 activeLeafGreaterThan0Condition(my=my):
+			if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+				if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+					groupsOfFolds += 1
+				else:
+					findGapsInitializeVariables(my=my, track=track)
+					while loopUpToDimensionsTotal(my=my):
+						if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+							dimensionsUnconstrainedDecrement(my=my)
+						else:
+							leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+							while loopingLeavesConnectedToActiveLeaf(my=my):
+								if thereAreComputationDivisionsYouMightSkip(my=my):
+									countGaps(gapsWhere=gapsWhere, my=my, track=track)
+								leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+						indexDimensionIncrement(my=my)
+					indexMiniGapInitialization(my=my)
+					while loopingToActiveGapCeiling(my=my):
+						filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+						indexMiniGapIncrement(my=my)
+			while backtrackCondition(my=my, track=track):
+				backtrack(my=my, track=track)
+			if placeLeafCondition(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
-    doFindGaps = True # Frankly, I can't figure out if `doFindGaps` is or is not faster. Furthermore, I have a strong feeling there is an even better way.
-
-    while activeLeafGreaterThan0Condition(my=my):
-        if ((doFindGaps := activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track))
-                and activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my)):
-            groupsOfFolds += 1
-        elif doFindGaps:
-            findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
-                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-                    dimensionsUnconstrainedDecrement(my=my)
-                else:
-                    leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
-                    while loopingLeavesConnectedToActiveLeaf(my=my):
-                        countGaps(gapsWhere=gapsWhere, my=my, track=track)
-                        leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                dimension1ndexIncrement(my=my)
-            indexMiniGapInitialization(my=my)
-            while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-                indexMiniGapIncrement(my=my)
-        while backtrackCondition(my=my, track=track):
-            backtrack(my=my, track=track)
-        if placeLeafCondition(my=my):
-            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-    foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
+						, 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 activeLeafGreaterThan0Condition(my=my):
+		if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+			if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+				groupsOfFolds += 1
+			else:
+				findGapsInitializeVariables(my=my, track=track)
+				while loopUpToDimensionsTotal(my=my):
+					if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+						dimensionsUnconstrainedDecrement(my=my)
+					else:
+						leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+						while loopingLeavesConnectedToActiveLeaf(my=my):
+							countGaps(gapsWhere=gapsWhere, my=my, track=track)
+							leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+					indexDimensionIncrement(my=my)
+				indexMiniGapInitialization(my=my)
+				while loopingToActiveGapCeiling(my=my):
+					filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+					indexMiniGapIncrement(my=my)
+		while backtrackCondition(my=my, track=track):
+			backtrack(my=my, track=track)
+		if placeLeafCondition(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)
-    else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)
+					, 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)
+	else:
+		countSequential(connectionGraph, foldGroups, gapsWhere, my, track)