mapFolding 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

mapFolding/lovelace.py

@@ -1,145 +1,213 @@
-"""
-The algorithm for counting folds.
-
-Starting from established data structures, the algorithm initializes some baseline values. The initialization uses a loop that is not used after the first fold is counted.
-
-After initialization, the folds are either counted sequentially or counted with inefficiently divided parallel tasks.
-
-All three of these actions--initialization, sequential counting, and parallel counting--use nearly identical logic. Without Numba, all of the logic is in one function with exactly one additional
-conditional statement for initialization and exactly one additional conditional statement for parallel counting.
-
-Numba's just-in-time (jit) compiler, especially super jit, is capable of radically increasing throughput and dramatically reducing the size of the compiled code, especially by ejecting unused code.
-
-The complexity of this module is due to me allegedly applying Numba's features. Allegedly.
-
-(The flow starts with the last function.)
-"""
 from mapFolding import indexMy, indexThe, indexTrack
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, Tuple, Optional
 import numba
-import numpy
-
-@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def ifComputationDivisions(my: NDArray[integer[Any]], the: NDArray[integer[Any]]) -> bool:
-    if the[indexThe.taskDivisions.value] == 0:
-        return True
-    return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value] or \
-            (my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value]) == my[indexMy.taskIndex.value]
-
-@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def insertUnconstrainedLeaf(my: NDArray[integer[Any]], the: NDArray[integer[Any]], initializeUnconstrainedLeaf: Optional[bool]) -> bool:
-    if initializeUnconstrainedLeaf:
-        return my[indexMy.dimensionsUnconstrained.value] == the[indexThe.dimensionsTotal.value]
-    else:
-        return False
-
-@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def initializationConditionUnconstrainedLeaf(my: NDArray[integer[Any]], initializeUnconstrainedLeaf: Optional[bool]) -> bool:
-    if initializeUnconstrainedLeaf is None or initializeUnconstrainedLeaf is False:
-        return False
-    else:
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def activeGapIncrement(my):
+    my[indexMy.gap1ndex.value] += 1
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def activeLeafGreaterThan0Condition(my):
+    return my[indexMy.leaf1ndex.value] > 0
+
+@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def activeLeafGreaterThanLeavesTotalCondition(my, the):
+    return my[indexMy.leaf1ndex.value] > the[indexThe.leavesTotal.value]
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def activeLeafIsTheFirstLeafCondition(my):
+    return my[indexMy.leaf1ndex.value] <= 1
+
+@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def allDimensionsAreUnconstrained(my, the):
+    return my[indexMy.dimensionsUnconstrained.value] == the[indexThe.dimensionsTotal.value]
+
+@numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def backtrack(my, track):
+    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]]
+
+@numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def backtrackCondition(my, track):
+    return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def gap1ndexCeilingIncrement(my):
+    my[indexMy.gap1ndexCeiling.value] += 1
+
+@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countGaps(gapsWhere, my, track):
+    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
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def dimension1ndexIncrement(my):
+    my[indexMy.dimension1ndex.value] += 1
+
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def dimensionsUnconstrainedCondition(connectionGraph, my):
+    return connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def dimensionsUnconstrainedIncrement(my):
+    my[indexMy.dimensionsUnconstrained.value] += 1
+
+@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def filterCommonGaps(gapsWhere, my, the, track):
+    gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+    if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == the[indexThe.dimensionsTotal.value] - my[indexMy.dimensionsUnconstrained.value]:
+        activeGapIncrement(my=my)
+    track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+
+@numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def findGapsInitializeVariables(my, track):
+    my[indexMy.dimensionsUnconstrained.value] = 0
+    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+    my[indexMy.dimension1ndex.value] = 1
+
+@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def foldsSubTotalIncrement(foldsSubTotals, my, the):
+    foldsSubTotals[my[indexMy.taskIndex.value]] += the[indexThe.leavesTotal.value]
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def indexMiniGapIncrement(my):
+    my[indexMy.indexMiniGap.value] += 1
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def indexMiniGapInitialization(my):
+    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+
+@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def insertUnconstrainedLeaf(gapsWhere, my):
+    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
+
+@numba.jit((numba.int64[:,::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def leafBelowSentinelIs1Condition(track):
+    return track[indexTrack.leafBelow.value, 0] == 1
+
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def leafConnecteeInitialization(connectionGraph, my):
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def leafConnecteeUpdate(connectionGraph, my, track):
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def loopingLeavesConnectedToActiveLeaf(my):
+    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
+
+@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def loopingTheDimensions(my, the):
+    return my[indexMy.dimension1ndex.value] <= the[indexThe.dimensionsTotal.value]
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def loopingToActiveGapCeiling(my):
+    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+
+@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def placeLeaf(gapsWhere, my, track):
+    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
+
+@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def placeLeafCondition(my):
+    return my[indexMy.leaf1ndex.value] > 0
+
+@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def thereAreComputationDivisionsYouMightSkip(my, the):
+    return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value] or my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value] == my[indexMy.taskIndex.value]
+
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countInitialize(connectionGraph, gapsWhere, my, the, track):
+    while activeLeafGreaterThan0Condition(my=my):
+        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+            findGapsInitializeVariables(my=my, track=track)
+            while loopingTheDimensions(my=my, the=the):
+                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                    dimensionsUnconstrainedIncrement(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, the=the):
+                insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
+            indexMiniGapInitialization(my=my)
+            while loopingToActiveGapCeiling(my=my):
+                filterCommonGaps(gapsWhere=gapsWhere, my=my, the=the, track=track)
+                indexMiniGapIncrement(my=my)
+        if placeLeafCondition(my=my):
+            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
         if my[indexMy.gap1ndex.value] > 0:
-            return True
-        else:
-            return False
-
-@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def doWhile(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]], initializeUnconstrainedLeaf: Optional[bool]) -> Tuple[NDArray[integer[Any]], NDArray[integer[Any]], NDArray[integer[Any]], NDArray[integer[Any]]]:
-    while my[indexMy.leaf1ndex.value] > 0:
-        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-            if my[indexMy.leaf1ndex.value] > the[indexThe.leavesTotal.value]:
-                foldsTotal[my[indexMy.taskIndex.value]] += the[indexThe.leavesTotal.value]
+            return
+
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track):
+    while activeLeafGreaterThan0Condition(my=my):
+        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+            if activeLeafGreaterThanLeavesTotalCondition(my=my, the=the):
+                foldsSubTotalIncrement(foldsSubTotals=foldsSubTotals, my=my, the=the)
             else:
-                my[indexMy.dimensionsUnconstrained.value] = 0
-                my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-                my[indexMy.dimension1ndex.value] = 1
-                while my[indexMy.dimension1ndex.value] <= the[indexThe.dimensionsTotal.value]:
-                    if connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                        my[indexMy.dimensionsUnconstrained.value] += 1
+                findGapsInitializeVariables(my=my, track=track)
+                while loopingTheDimensions(my=my, the=the):
+                    if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                        dimensionsUnconstrainedIncrement(my=my)
                     else:
-                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                        while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                            # NOTE This conditional check should only be in the parallel counting branch
-                            if ifComputationDivisions(my, the):
-                                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.dimension1ndex.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                    my[indexMy.dimension1ndex.value] += 1
-                # NOTE This `if` statement and `while` loop should be absent from the code that does the counting
-                if insertUnconstrainedLeaf(my, the, initializeUnconstrainedLeaf):
-                    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]]] == the[indexThe.dimensionsTotal.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
-        # NOTE This check and break should be absent from the code that does the counting
-        if initializationConditionUnconstrainedLeaf(my, initializeUnconstrainedLeaf):
-            break
-    return foldsTotal, my, gapsWhere, track
-
-@numba.jit(parallel=True, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def doTaskIndices(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> NDArray[integer[Any]]:
-    """This is the only function with the `parallel=True` option.
-    Make a copy of the initialized state because all task divisions can start from this baseline.
-    Run the counting algorithm but with conditional execution of a few lines of code, so each task has an incomplete count that does not overlap with other tasks."""
-    stateFoldsSubTotal = foldsTotal.copy()
-    stateMy = my.copy()
-    statePotentialGaps = gapsWhere.copy()
-    stateTrack = track.copy()
-
+                        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, the=the, 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)
+
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1],numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=True, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countParallel(connectionGraph, foldsSubTotals, gapsWherePARALLEL, myPARALLEL, the, trackPARALLEL):
     for indexSherpa in numba.prange(the[indexThe.taskDivisions.value]):
-        my = stateMy.copy()
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
         my[indexMy.taskIndex.value] = indexSherpa
-        foldsSubTotal, _1, _2, _3 = doWhile(connectionGraph, stateFoldsSubTotal.copy(), my, statePotentialGaps.copy(), the, stateTrack.copy(), initializeUnconstrainedLeaf=False)
-
-        foldsTotal[indexSherpa] = foldsSubTotal[indexSherpa]
-
-    return foldsTotal
-
-@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def countFoldsCompileBranch(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]], obviousFlagForNumba: bool) -> NDArray[integer[Any]]:
-    """Allegedly, `obviousFlagForNumba` allows Numba to compile two versions: one for parallel execution and one leaner version for sequential execution."""
-    if obviousFlagForNumba:
-        foldsTotal, _1, _2, _3 = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, initializeUnconstrainedLeaf=False)
-    else:
-        foldsTotal = doTaskIndices(connectionGraph, foldsTotal, my, gapsWhere, the, track)
-
-    return foldsTotal
-
-@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def countFoldsCompiled(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> int:
-    # ^ Receive the data structures.
-
-    # Initialize baseline values primarily to eliminate the need for the logic of `insertUnconstrainedLeaf`
-    _0, my, gapsWhere, track = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, initializeUnconstrainedLeaf=True)
-
-    obviousFlagForNumba = the[indexThe.taskDivisions.value] == int(False)
-
-    # Call the function that will branch to sequential or parallel counting
-    foldsTotal = countFoldsCompileBranch(connectionGraph, foldsTotal, my, gapsWhere, the, track, obviousFlagForNumba)
-
-    # Return an `int` integer
-    return numpy.sum(foldsTotal).item()
+        track = trackPARALLEL.copy()
+        while activeLeafGreaterThan0Condition(my=my):
+            if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+                if activeLeafGreaterThanLeavesTotalCondition(my=my, the=the):
+                    foldsSubTotalIncrement(foldsSubTotals=foldsSubTotals, my=my, the=the)
+                else:
+                    findGapsInitializeVariables(my=my, track=track)
+                    while loopingTheDimensions(my=my, the=the):
+                        if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                            dimensionsUnconstrainedIncrement(my=my)
+                        else:
+                            leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                            while loopingLeavesConnectedToActiveLeaf(my=my):
+                                if thereAreComputationDivisionsYouMightSkip(my=my, the=the):
+                                    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, the=the, 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)