mapFolding 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

mapFolding/syntheticModules/numbaCount.py

@@ -0,0 +1,158 @@
+from mapFolding import indexMy, indexTrack
+from numba import jit, int64, prange, uint16
+from numpy import ndarray, dtype, integer
+from typing import Tuple, Any
+
+@jit((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 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 my[indexMy.leaf1ndex.value] > 0:
+        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
+            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
+            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
+                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
+                    my[indexMy.dimensionsUnconstrained.value] -= 1
+                else:
+                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
+                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+                            my[indexMy.gap1ndexCeiling.value] += 1
+                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+                my[indexMy.indexDimension.value] += 1
+            if not my[indexMy.dimensionsUnconstrained.value]:
+                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.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
+                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+                    my[indexMy.gap1ndex.value] += 1
+                track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+                my[indexMy.indexMiniGap.value] += 1
+        if my[indexMy.leaf1ndex.value] > 0:
+            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
+        if my[indexMy.gap1ndex.value] > 0:
+            return
+
+@jit((uint16[:, :, ::1], int64[::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=True, no_cpython_wrapper=True, nopython=True, parallel=True)
+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 my[indexMy.leaf1ndex.value] > 0:
+            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
+                if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
+                    groupsOfFolds += 1
+                else:
+                    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
+                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
+                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
+                            my[indexMy.dimensionsUnconstrained.value] -= 1
+                        else:
+                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
+                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
+                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+                                        my[indexMy.gap1ndexCeiling.value] += 1
+                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+                        my[indexMy.indexDimension.value] += 1
+                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
+                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+                            my[indexMy.gap1ndex.value] += 1
+                        track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+                        my[indexMy.indexMiniGap.value] += 1
+            while my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
+                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]]
+            if my[indexMy.leaf1ndex.value] > 0:
+                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
+        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
+
+@jit((uint16[:, :, ::1], int64[::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=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+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:
+    leafBelow = track[indexTrack.leafBelow.value]
+    gapRangeStart = track[indexTrack.gapRangeStart.value]
+    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
+    leafAbove = track[indexTrack.leafAbove.value]
+    leaf1ndex = my[indexMy.leaf1ndex.value]
+    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
+    dimensionsTotal = my[indexMy.dimensionsTotal.value]
+    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
+    indexDimension = my[indexMy.indexDimension.value]
+    leafConnectee = my[indexMy.leafConnectee.value]
+    indexMiniGap = my[indexMy.indexMiniGap.value]
+    gap1ndex = my[indexMy.gap1ndex.value]
+    taskIndex = my[indexMy.taskIndex.value]
+    groupsOfFolds: int = 0
+    while leaf1ndex > 0:
+        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:
+                    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

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,17 +1,10 @@
-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 jit
-from numba import uint8
-from numba import int64
-from numpy import ndarray
-from numpy import integer
-from numpy import dtype
-from typing import Tuple
-from typing import Any
+from mapFolding.syntheticModules.numbaCount import countParallel, countSequential, countInitialize
+from numba import jit, int64, uint16
+from numpy import ndarray, dtype, integer
+from typing import Tuple, Any
 
-@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)
+@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.value] > 0:

mapFolding/theDao.py

@@ -3,17 +3,17 @@ from numba import prange
 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 ndarray 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`.
+def activeLeafConnectedToItself(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
 
-def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value]
+def activeLeafGreaterThan0(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leaf1ndex.value] > 0
 
-def activeLeafGreaterThanLeavesTotalCondition(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+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 activeLeafIsTheFirstLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+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:
@@ -24,44 +24,47 @@ def backtrack(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple
 	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]
-
-def gap1ndexCeilingIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-	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)
+		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 dimensionsUnconstrainedDecrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-	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)
+		incrementActiveGap(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
+def incrementActiveGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+	my[indexMy.gap1ndex.value] += 1
 
-def indexDimensionIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+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 indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexMiniGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] += 1
 
-def indexMiniGapInitialization(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+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]:
@@ -69,23 +72,20 @@ def insertUnconstrainedLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]],
 		my[indexMy.gap1ndexCeiling.value] += 1
 		my[indexMy.indexLeaf.value] += 1
 
-def leafBelowSentinelIs1Condition(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+def leafBelowSentinelIs1(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
 	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]]
-
-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]]]
-
 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 loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.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
@@ -96,37 +96,40 @@ def placeLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[T
 	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]
+def thereIsAnActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leaf1ndex.value] > 0
 
-def thereAreComputationDivisionsYouMightSkip(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+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 activeLeafGreaterThan0Condition(my=my):
-		if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-			findGapsInitializeVariables(my=my, track=track)
+	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):
-					dimensionsUnconstrainedDecrement(my=my)
+					decrementDimensionsUnconstrained(my=my)
 				else:
-					leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+					initializeLeafConnectee(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)
+						updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
+				incrementIndexDimension(my=my)
 			if allDimensionsAreUnconstrained(my=my):
 				insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
-			indexMiniGapInitialization(my=my)
+			initializeIndexMiniGap(my=my)
 			while loopingToActiveGapCeiling(my=my):
 				filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-				indexMiniGapIncrement(my=my)
-		if placeLeafCondition(my=my):
+				incrementIndexMiniGap(my=my)
+		if thereIsAnActiveLeaf(my=my):
 			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 		if my[indexMy.gap1ndex.value] > 0:
 			return
@@ -153,29 +156,29 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
 
 		my[indexMy.taskIndex.value] = indexSherpa
 
-		while activeLeafGreaterThan0Condition(my=my):
-			if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-				if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+		while activeLeafGreaterThan0(my=my):
+			if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
+				if activeLeafGreaterThanLeavesTotal(foldGroups=foldGroups, my=my):
 					groupsOfFolds += 1
 				else:
-					findGapsInitializeVariables(my=my, track=track)
+					initializeVariablesToFindGaps(my=my, track=track)
 					while loopUpToDimensionsTotal(my=my):
 						if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-							dimensionsUnconstrainedDecrement(my=my)
+							decrementDimensionsUnconstrained(my=my)
 						else:
-							leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+							initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
 							while loopingLeavesConnectedToActiveLeaf(my=my):
-								if thereAreComputationDivisionsYouMightSkip(my=my):
+								if thisIsMyTaskIndex(my=my):
 									countGaps(gapsWhere=gapsWhere, my=my, track=track)
-								leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-						indexDimensionIncrement(my=my)
-					indexMiniGapInitialization(my=my)
+								updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
+						incrementIndexDimension(my=my)
+					initializeIndexMiniGap(my=my)
 					while loopingToActiveGapCeiling(my=my):
 						filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-						indexMiniGapIncrement(my=my)
-			while backtrackCondition(my=my, track=track):
+						incrementIndexMiniGap(my=my)
+			while noGapsHere(my=my, track=track):
 				backtrack(my=my, track=track)
-			if placeLeafCondition(my=my):
+			if thereIsAnActiveLeaf(my=my):
 				placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 		foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
@@ -188,28 +191,28 @@ def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[intege
 
 	groupsOfFolds: int = 0
 
-	while activeLeafGreaterThan0Condition(my=my):
-		if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-			if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+	while activeLeafGreaterThan0(my=my):
+		if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
+			if activeLeafGreaterThanLeavesTotal(foldGroups=foldGroups, my=my):
 				groupsOfFolds += 1
 			else:
-				findGapsInitializeVariables(my=my, track=track)
+				initializeVariablesToFindGaps(my=my, track=track)
 				while loopUpToDimensionsTotal(my=my):
-					if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-						dimensionsUnconstrainedDecrement(my=my)
+					initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
+					if activeLeafConnectedToItself(my=my):
+						decrementDimensionsUnconstrained(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)
+							updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
+					incrementIndexDimension(my=my)
+				initializeIndexMiniGap(my=my)
 				while loopingToActiveGapCeiling(my=my):
 					filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-					indexMiniGapIncrement(my=my)
-		while backtrackCondition(my=my, track=track):
+					incrementIndexMiniGap(my=my)
+		while noGapsHere(my=my, track=track):
 			backtrack(my=my, track=track)
-		if placeLeafCondition(my=my):
+		if thereIsAnActiveLeaf(my=my):
 			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 	foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds