mapFolding 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

mapFolding/__init__.py

@@ -1,6 +1,6 @@
 from .theSSOT import *
-from .beDRY import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
-from .beDRY import getLeavesTotal, parseDimensions, validateListDimensions
+from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
+from .beDRY import getFilenameFoldsTotal, outfitCountFolds
 from .startHere import countFolds
 from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
 

mapFolding/babbage.py

@@ -6,7 +6,7 @@ import numba
 import numpy
 
 @numba.jit(cache=True)
-def _countFolds(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> int:
+def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
     """
     What in tarnation is this stupid module and function?
 
@@ -27,4 +27,4 @@ def _countFolds(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[inte
     """
     # TODO learn if I really must change this jitted function to get the super jit to recompile
     # print('babbage')
-    return countFoldsCompiled(connectionGraph, foldsTotal, my, gapsWhere, the, track)
+    countFoldsCompiled(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)

mapFolding/beDRY.py

@@ -1,13 +1,17 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding.importPackages import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from mapFolding import dtypeDefault, dtypeLarge
 from mapFolding import indexMy, indexThe, indexTrack, computationState
+from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from numpy import integer
+from numpy.typing import NDArray
 from typing import Any, List, Optional, Sequence, Type, Union
-import numpy
 import numba
-from numpy.typing import NDArray
-from numpy import integer
+import numpy
 import sys
 
+def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
+    return str(sorted(listDimensions)).replace(' ', '') + '.foldsTotal'
+
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
     How many leaves are in the map.
@@ -32,7 +36,7 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
         return productDimensions
 
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, the: NDArray[integer[Any]], CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
+def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
     """
     Determines whether or how to divide the computation into tasks.
 
@@ -46,15 +50,12 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
         - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
     concurrencyLimit:
         Maximum number of concurrent tasks allowed
-    the:
-        Array of settings, including `leavesTotal`
-    CPUlimit: for error reporting
     listDimensions: for error reporting
+    CPUlimit: for error reporting
 
     Returns
     -------
-    the
-        Updated settings, including for `taskDivisions`
+    taskDivisions:
 
     Raises
     ------
@@ -65,26 +66,27 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
     -----
     Task divisions cannot exceed total leaves to prevent duplicate counting of folds.
     """
-
     if not computationDivisions:
-        the[indexThe.taskDivisions] = 0
-    elif isinstance(computationDivisions, int):
-        the[indexThe.taskDivisions] = computationDivisions
+        return 0
+    else:
+        leavesTotal = getLeavesTotal(listDimensions)
+    if isinstance(computationDivisions, int):
+        taskDivisions = computationDivisions
     elif isinstance(computationDivisions, str):
         computationDivisions = computationDivisions.lower()
         if computationDivisions == "maximum":
-            the[indexThe.taskDivisions] = the[indexThe.leavesTotal]
+            taskDivisions = leavesTotal
         elif computationDivisions == "cpu":
-            the[indexThe.taskDivisions] = min(concurrencyLimit, the[indexThe.leavesTotal])
+            taskDivisions = min(concurrencyLimit, leavesTotal)
     else:
         raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
 
-    if the[indexThe.taskDivisions] > the[indexThe.leavesTotal]:
-        raise ValueError(f"Problem: `taskDivisions`, ({the[indexThe.taskDivisions]}), is greater than `leavesTotal`, ({the[indexThe.leavesTotal]}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.\n\nFor those parameters, I received {computationDivisions=}, {CPUlimit=}, and {listDimensions=}.\n\nPotential solutions: get a different hobby or set `computationDivisions` to a different value.")
+    if taskDivisions > leavesTotal:
+        raise ValueError(f"Problem: `taskDivisions`, ({taskDivisions}), is greater than `leavesTotal`, ({leavesTotal}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.\n\nFor those parameters, I received {computationDivisions=}, {CPUlimit=}, and {listDimensions=}.\n\nPotential solutions: get a different hobby or set `computationDivisions` to a different value.")
 
-    return the
+    return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = numpy.int64) -> NDArray[integer[Any]]:
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
     """
     Constructs a multi-dimensional connection graph representing the connections between the leaves of a map with the given dimensions.
     Also called a Cartesian product decomposition or dimensional product mapping.
@@ -94,16 +96,17 @@ def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = n
     Returns:
         connectionGraph: A 3D numpy array with shape of (dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1).
     """
+    datatype = keywordArguments.get('datatype', dtypeDefault)
     mapShape = validateListDimensions(listDimensions)
     leavesTotal = getLeavesTotal(mapShape)
-    arrayDimensions = numpy.array(mapShape, dtype=dtype)
+    arrayDimensions = numpy.array(mapShape, dtype=datatype)
     dimensionsTotal = len(arrayDimensions)
 
     # Step 1: find the cumulative product of the map's dimensions
-    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=dtype)
+    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
 
     # Step 2: create a coordinate system
-    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtype)
+    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=datatype)
 
     for dimension1ndex in range(1, dimensionsTotal + 1):
         for leaf1ndex in range(1, leavesTotal + 1):
@@ -113,7 +116,7 @@ def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = n
             )
 
     # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
+    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
 
     for dimension1ndex in range(1, dimensionsTotal + 1):
         for activeLeaf1ndex in range(1, leavesTotal + 1):
@@ -139,7 +142,13 @@ def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = n
 
     return connectionGraph
 
-def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, dtypeDefault: Optional[Type] = numpy.int64, dtypeLarge: Optional[Type] = numpy.int64, ) -> computationState:
+def makeDataContainer(shape, datatype: Optional[Type] = None):
+    """Create a container, probably numpy.ndarray, with the given shape and datatype."""
+    if datatype is None:
+        datatype = dtypeDefault
+    return numpy.zeros(shape, dtype=datatype)
+
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
     """
     Initializes and configures the computation state for map folding computations.
 
@@ -148,42 +157,53 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     listDimensions:
         The dimensions of the map to be folded
     computationDivisions (None):
-        Specifies how to divide the computation tasks
+        Specifies how to divide computations:
+        - None: no division of the computation into tasks; sets task divisions to 0
+        - int: direct set the number of task divisions; cannot exceed the map's total leaves
+        - "maximum": divides into `leavesTotal`-many `taskDivisions`
+        - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
     CPUlimit (None):
-        Limits the CPU usage for computations
-    dtypeDefault (numpy.int64):
-        The default numpy dtype to use for arrays
-    dtypeLarge (numpy.int64):
-        The numpy dtype to use for larger arrays
+        Whether and how to limit the CPU usage. See notes for details.
 
     Returns
     -------
     computationState
         An initialized computation state containing:
         - connectionGraph: Graph representing connections in the map
-        - foldsTotal: Array tracking total folds
+        - foldsSubTotals: Array tracking total folds
         - mapShape: Validated and sorted dimensions of the map
         - my: Array for internal state tracking
         - gapsWhere: Array tracking gap positions
-        - the: Configured task divisions
+        - the: Static settings and metadata
         - track: Array for tracking computation progress
+
+    Limits on CPU usage `CPUlimit`:
+        - `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
+        - `True`: Yes, limit the CPU usage; limits to 1 CPU.
+        - Integer `>= 1`: Limits usage to the specified number of CPUs.
+        - Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
+        - Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
+        - Integer `<= -1`: Subtract the absolute value from total CPUs.
     """
+    datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
+    datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
 
-    the = numpy.zeros(len(indexThe), dtype=dtypeDefault)
+    the = makeDataContainer(len(indexThe), datatypeDefault)
 
     mapShape = tuple(sorted(validateListDimensions(listDimensions)))
     the[indexThe.leavesTotal] = getLeavesTotal(mapShape)
     the[indexThe.dimensionsTotal] = len(mapShape)
     concurrencyLimit = setCPUlimit(CPUlimit)
+    the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
 
     stateInitialized = computationState(
-        connectionGraph = makeConnectionGraph(mapShape, dtype=dtypeDefault),
-        foldsTotal = numpy.zeros(the[indexThe.leavesTotal], dtype=numpy.int64),
+        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
+        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
         mapShape = mapShape,
-        my = numpy.zeros(len(indexMy), dtype=dtypeLarge),
-        gapsWhere = numpy.zeros(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, dtype=dtypeDefault),
-        the = getTaskDivisions(computationDivisions, concurrencyLimit, the, CPUlimit, listDimensions),
-        track = numpy.zeros((len(indexTrack), the[indexThe.leavesTotal] + 1), dtype=dtypeLarge)
+        my = makeDataContainer(len(indexMy), datatypeLarge),
+        gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeDefault),
+        the = the,
+        track = makeDataContainer((len(indexTrack), the[indexThe.leavesTotal] + 1), datatypeLarge)
         )
 
     stateInitialized['my'][indexMy.leaf1ndex.value] = 1

mapFolding/lovelace.py

@@ -1,145 +1,217 @@
-"""
-The algorithm for counting folds.
+from mapFolding import indexMy, indexThe, indexTrack
+from numpy import integer
+from numpy.typing import NDArray
+from typing import Any
+import numba
+import numpy
 
-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.
+def activeGapIncrement(my: NDArray[integer[Any]]):
+    my[indexMy.gap1ndex.value] += 1
 
-After initialization, the folds are either counted sequentially or counted with inefficiently divided parallel tasks.
+def activeLeafGreaterThan0Condition(my: NDArray[integer[Any]]):
+    return my[indexMy.leaf1ndex.value] > 0
 
-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.
+def activeLeafGreaterThanLeavesTotalCondition(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    return my[indexMy.leaf1ndex.value] > the[indexThe.leavesTotal.value]
 
-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.
+def activeLeafIsTheFirstLeafCondition(my: NDArray[integer[Any]]):
+    return my[indexMy.leaf1ndex.value] <= 1
 
-The complexity of this module is due to me allegedly applying Numba's features. Allegedly.
+def activeLeafNotEqualToTaskDivisionsCondition(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value]
 
-(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
+def allDimensionsAreUnconstrained(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    return my[indexMy.dimensionsUnconstrained.value] == the[indexThe.dimensionsTotal.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 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]
+def backtrack(my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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(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
+def backtrackCondition(my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 
-@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:
+def countGaps(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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[integer[Any]]):
+    my[indexMy.dimension1ndex.value] += 1
+
+def dimensionsUnconstrainedCondition(connectionGraph: NDArray[integer[Any]], my: NDArray[integer[Any]]):
+    return connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
+
+def dimensionsUnconstrainedIncrement(my: NDArray[integer[Any]]):
+    my[indexMy.dimensionsUnconstrained.value] += 1
+
+def filterCommonGaps(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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
+
+def findGapsInitializeVariables(my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    my[indexMy.dimensionsUnconstrained.value] = 0
+    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+    my[indexMy.dimension1ndex.value] = 1
+
+def foldsSubTotalIncrement(foldsSubTotals: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    foldsSubTotals[my[indexMy.taskIndex.value]] += the[indexThe.leavesTotal.value]
+
+def gap1ndexCeilingIncrement(my: NDArray[integer[Any]]):
+    my[indexMy.gap1ndexCeiling.value] += 1
+
+def indexMiniGapIncrement(my: NDArray[integer[Any]]):
+    my[indexMy.indexMiniGap.value] += 1
+
+def indexMiniGapInitialization(my: NDArray[integer[Any]]):
+    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+
+def insertUnconstrainedLeaf(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]]):
+    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[integer[Any]]):
+    return track[indexTrack.leafBelow.value, 0] == 1
+
+def leafConnecteeInitialization(connectionGraph: NDArray[integer[Any]], my: NDArray[integer[Any]]):
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+
+def leafConnecteeUpdate(connectionGraph: NDArray[integer[Any]], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+
+def loopingLeavesConnectedToActiveLeaf(my: NDArray[integer[Any]]):
+    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
+
+def loopingTheDimensions(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    return my[indexMy.dimension1ndex.value] <= the[indexThe.dimensionsTotal.value]
+
+def loopingToActiveGapCeiling(my: NDArray[integer[Any]]):
+    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+
+def placeLeaf(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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[integer[Any]]):
+    return my[indexMy.leaf1ndex.value] > 0
+
+def taskIndexCondition(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    return my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value] == my[indexMy.taskIndex.value]
+
+def thereAreComputationDivisionsYouMightSkip(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+    if activeLeafNotEqualToTaskDivisionsCondition(my=my, the=the):
+        return True
+    if taskIndexCondition(my=my, the=the):
+        return True
+    return False
+
+def initialize(connectionGraph: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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]
+            break
+
+def countParallel(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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
+                        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)
+
+def countSequential(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+    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):
+                            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(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()
+def doTaskIndices(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+
+    stateGapsWhere = gapsWhere.copy()
     stateMy = my.copy()
-    statePotentialGaps = gapsWhere.copy()
     stateTrack = track.copy()
 
     for indexSherpa in numba.prange(the[indexThe.taskDivisions.value]):
-        my = stateMy.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
-        foldsSubTotal, _1, _2, _3 = doWhile(connectionGraph, stateFoldsSubTotal.copy(), my, statePotentialGaps.copy(), the, stateTrack.copy(), initializeUnconstrainedLeaf=False)
+        mySherpa = stateMy.copy()
+        mySherpa[indexMy.taskIndex.value] = indexSherpa
+        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=stateGapsWhere.copy(), my=mySherpa, the=the, track=stateTrack.copy())
 
-        foldsTotal[indexSherpa] = foldsSubTotal[indexSherpa]
+    return foldsSubTotals
 
-    return foldsTotal
+def countFoldsCompiled(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
 
-@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)
+    initialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=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)
+    if the[indexThe.taskDivisions.value] > 0:
+        doTaskIndices(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
+    else:
+        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
 
-    # Return an `int` integer
-    return numpy.sum(foldsTotal).item()
+numba.jit_module(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)