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

mapFolding/__init__.py

@@ -1,7 +1,6 @@
 from .theSSOT import *
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
-from .beDRY import getLeavesTotal, parseDimensions, validateListDimensions
+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,14 +1,16 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from mapFolding import dtypeDefault, dtypeLarge
 from mapFolding import indexMy, indexThe, indexTrack, computationState
-from mapFolding import dtypeDefault, dtypeLarge, dtypeSmall
+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
-import operator
+
+def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
+    return str(sorted(listDimensions)).replace(' ', '') + '.foldsTotal'
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -146,7 +148,7 @@ def makeDataContainer(shape, datatype: Optional[Type] = None):
         datatype = dtypeDefault
     return numpy.zeros(shape, dtype=datatype)
 
-def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
+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.
 
@@ -155,21 +157,33 @@ 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
+        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: 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)
@@ -181,10 +195,10 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     the[indexThe.dimensionsTotal] = len(mapShape)
     concurrencyLimit = setCPUlimit(CPUlimit)
     the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
-    
+
     stateInitialized = computationState(
         connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
-        foldsTotal = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
+        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
         mapShape = mapShape,
         my = makeDataContainer(len(indexMy), datatypeLarge),
         gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeDefault),

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)

mapFolding/reference/flattened.py

@@ -0,0 +1,376 @@
+"""The algorithm flattened into semantic sections.
+This version is not maintained, so you may see differences from the current version."""
+from numpy import integer
+from numpy.typing import NDArray
+from typing import List, Any, Final, Optional, Union, Sequence, Tuple, Type, TypedDict
+import enum
+import numpy
+import sys
+
+def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUlimit: Optional[Union[int, float, bool]] = None):
+    def doWhile():
+
+        while activeLeafGreaterThan0Condition():
+
+            if activeLeafIsTheFirstLeafCondition() or leafBelowSentinelIs1Condition():
+
+                if activeLeafGreaterThanLeavesTotalCondition():
+                    foldsSubTotalsIncrement()
+
+                else:
+
+                    findGapsInitializeVariables()
+                    while loopingTheDimensions():
+
+                        if dimensionsUnconstrainedCondition():
+                            dimensionsUnconstrainedIncrement()
+
+                        else:
+
+                            leafConnecteeInitialization()
+                            while loopingLeavesConnectedToActiveLeaf():
+                                if thereAreComputationDivisionsYouMightSkip():
+                                    countGaps()
+                                leafConnecteeUpdate()
+
+                        dimension1ndexIncrement()
+
+                    if allDimensionsAreUnconstrained():
+                        insertUnconstrainedLeaf()
+
+                    indexMiniGapInitialization()
+                    while loopingToActiveGapCeiling():
+                        filterCommonGaps()
+                        indexMiniGapIncrement()
+
+            while backtrackCondition():
+                backtrack()
+
+            if placeLeafCondition():
+                placeLeaf()
+
+    def activeGapIncrement():
+        my[indexMy.gap1ndex] += 1
+
+    def activeLeafGreaterThan0Condition():
+        return my[indexMy.leaf1ndex] > 0
+
+    def activeLeafGreaterThanLeavesTotalCondition():
+        return my[indexMy.leaf1ndex] > the[indexThe.leavesTotal]
+
+    def activeLeafIsTheFirstLeafCondition():
+        return my[indexMy.leaf1ndex] <= 1
+
+    def activeLeafNotEqualToTaskDivisionsCondition():
+        return my[indexMy.leaf1ndex] != the[indexThe.taskDivisions]
+
+    def allDimensionsAreUnconstrained():
+        return my[indexMy.dimensionsUnconstrained] == the[indexThe.dimensionsTotal]
+
+    def backtrack():
+        my[indexMy.leaf1ndex] -= 1
+        track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
+        track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
+
+    def backtrackCondition():
+        return my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
+
+    def computationDivisionsCondition():
+        return the[indexThe.taskDivisions] == int(False)
+
+    def countGaps():
+        gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
+        if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
+            gap1ndexCeilingIncrement()
+        track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
+
+    def dimension1ndexIncrement():
+        my[indexMy.dimension1ndex] += 1
+
+    def dimensionsUnconstrainedCondition():
+        return connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]
+
+    def dimensionsUnconstrainedIncrement():
+        my[indexMy.dimensionsUnconstrained] += 1
+
+    def filterCommonGaps():
+        gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
+        if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == the[indexThe.dimensionsTotal] - my[indexMy.dimensionsUnconstrained]:
+            activeGapIncrement()
+        track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
+
+    def findGapsInitializeVariables():
+        my[indexMy.dimensionsUnconstrained] = 0
+        my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
+        my[indexMy.dimension1ndex] = 1
+
+    def foldsSubTotalsIncrement():
+        foldsSubTotals[my[indexMy.taskIndex]] += the[indexThe.leavesTotal]
+
+    def gap1ndexCeilingIncrement():
+        my[indexMy.gap1ndexCeiling] += 1
+
+    def indexMiniGapIncrement():
+        my[indexMy.indexMiniGap] += 1
+
+    def indexMiniGapInitialization():
+        my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
+
+    def insertUnconstrainedLeaf():
+        my[indexMy.indexLeaf] = 0
+        while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
+            gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
+            my[indexMy.gap1ndexCeiling] += 1
+            my[indexMy.indexLeaf] += 1
+
+    def leafBelowSentinelIs1Condition():
+        return track[indexTrack.leafBelow, 0] == 1
+
+    def leafConnecteeInitialization():
+        my[indexMy.leafConnectee] = connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
+
+    def leafConnecteeUpdate():
+        my[indexMy.leafConnectee] = connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
+
+    def loopingLeavesConnectedToActiveLeaf():
+        return my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]
+
+    def loopingTheDimensions():
+        return my[indexMy.dimension1ndex] <= the[indexThe.dimensionsTotal]
+
+    def loopingToActiveGapCeiling():
+        return my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]
+
+    def placeLeaf():
+        my[indexMy.gap1ndex] -= 1
+        track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
+        track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
+        track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
+        track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
+        track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
+        my[indexMy.leaf1ndex] += 1
+
+    def placeLeafCondition():
+        return my[indexMy.leaf1ndex] > 0
+
+    def taskIndexCondition():
+        return my[indexMy.leafConnectee] % the[indexThe.taskDivisions] == my[indexMy.taskIndex]
+
+    def thereAreComputationDivisionsYouMightSkip():
+        if computationDivisionsCondition():
+            return True
+        if activeLeafNotEqualToTaskDivisionsCondition():
+            return True
+        if taskIndexCondition():
+            return True
+        return False
+
+    stateUniversal = outfitFoldings(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit)
+    connectionGraph: Final[numpy.ndarray] = stateUniversal['connectionGraph']
+    foldsSubTotals = stateUniversal['foldsSubTotals']
+    gapsWhere = stateUniversal['gapsWhere']
+    my = stateUniversal['my']
+    the: Final[numpy.ndarray] = stateUniversal['the']
+    track = stateUniversal['track']
+
+    if the[indexThe.taskDivisions] == int(False):
+        doWhile()
+    else:
+        stateUniversal['my'] = my.copy()
+        stateUniversal['gapsWhere'] = gapsWhere.copy()
+        stateUniversal['track'] = track.copy()
+        for indexSherpa in range(the[indexThe.taskDivisions]):
+            my = stateUniversal['my'].copy()
+            my[indexMy.taskIndex] = indexSherpa
+            gapsWhere = stateUniversal['gapsWhere'].copy()
+            track = stateUniversal['track'].copy()
+            doWhile()
+
+    return numpy.sum(foldsSubTotals).item()
+
+@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
+class EnumIndices(enum.IntEnum):
+    """Base class for index enums."""
+    @staticmethod
+    def _generate_next_value_(name, start, count, last_values):
+        """0-indexed."""
+        return count
+
+    def __index__(self) -> int:
+        """Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
+        same as `array.array`. See NumPy.org; I think it will be very popular someday."""
+        return self
+
+class indexMy(EnumIndices):
+    """Indices for dynamic values."""
+    dimension1ndex = enum.auto()
+    dimensionsUnconstrained = enum.auto()
+    gap1ndex = enum.auto()
+    gap1ndexCeiling = enum.auto()
+    indexLeaf = enum.auto()
+    indexMiniGap = enum.auto()
+    leaf1ndex = enum.auto()
+    leafConnectee = enum.auto()
+    taskIndex = enum.auto()
+
+class indexThe(EnumIndices):
+    """Indices for static values."""
+    dimensionsTotal = enum.auto()
+    leavesTotal = enum.auto()
+    taskDivisions = enum.auto()
+
+class indexTrack(EnumIndices):
+    """Indices for state tracking array."""
+    leafAbove = enum.auto()
+    leafBelow = enum.auto()
+    countDimensionsGapped = enum.auto()
+    gapRangeStart = enum.auto()
+
+class computationState(TypedDict):
+    connectionGraph: NDArray[integer[Any]]
+    foldsSubTotals: NDArray[integer[Any]]
+    mapShape: Tuple[int, ...]
+    my: NDArray[integer[Any]]
+    gapsWhere: NDArray[integer[Any]]
+    the: NDArray[integer[Any]]
+    track: NDArray[integer[Any]]
+
+dtypeLarge = numpy.int64
+dtypeDefault = dtypeLarge
+
+def getLeavesTotal(listDimensions: Sequence[int]) -> int:
+    """
+    How many leaves are in the map.
+
+    Parameters:
+        listDimensions: A list of integers representing dimensions.
+
+    Returns:
+        productDimensions: The product of all positive integer dimensions.
+    """
+    listNonNegative = parseDimensions(listDimensions, 'listDimensions')
+    listPositive = [dimension for dimension in listNonNegative if dimension > 0]
+
+    if not listPositive:
+        return 0
+    else:
+        productDimensions = 1
+        for dimension in listPositive:
+            if dimension > sys.maxsize // productDimensions:
+                raise OverflowError(f"I received {dimension=} in {listDimensions=}, but the product of the dimensions exceeds the maximum size of an integer on this system.")
+            productDimensions *= dimension
+
+        return productDimensions
+
+def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
+    if not computationDivisions:
+        return 0
+    else:
+        leavesTotal = getLeavesTotal(listDimensions)
+    if isinstance(computationDivisions, int):
+        taskDivisions = computationDivisions
+    elif isinstance(computationDivisions, str):
+        computationDivisions = computationDivisions.lower()
+        if computationDivisions == "maximum":
+            taskDivisions = leavesTotal
+        elif computationDivisions == "cpu":
+            taskDivisions = min(concurrencyLimit, leavesTotal)
+    else:
+        raise ValueError("Not my problem.")
+
+    if taskDivisions > leavesTotal:
+        raise ValueError("What are you doing?")
+
+    return taskDivisions
+
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
+    datatype = keywordArguments.get('datatype', dtypeDefault)
+    mapShape = validateListDimensions(listDimensions)
+    leavesTotal = getLeavesTotal(mapShape)
+    arrayDimensions = numpy.array(mapShape, dtype=datatype)
+    dimensionsTotal = len(arrayDimensions)
+
+    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
+    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=datatype)
+    for dimension1ndex in range(1, dimensionsTotal + 1):
+        for leaf1ndex in range(1, leavesTotal + 1):
+            coordinateSystem[dimension1ndex, leaf1ndex] = ( ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) % arrayDimensions[dimension1ndex - 1] + 1 )
+
+    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):
+            for connectee1ndex in range(1, activeLeaf1ndex + 1):
+                isFirstCoord = coordinateSystem[dimension1ndex, connectee1ndex] == 1
+                isLastCoord = coordinateSystem[dimension1ndex, connectee1ndex] == arrayDimensions[dimension1ndex - 1]
+                exceedsActive = connectee1ndex + cumulativeProduct[dimension1ndex - 1] > activeLeaf1ndex
+                isEvenParity = (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == (coordinateSystem[dimension1ndex, connectee1ndex] & 1)
+
+                if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
+                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+                elif isEvenParity and not isFirstCoord:
+                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[dimension1ndex - 1]
+                elif not isEvenParity and not (isLastCoord or exceedsActive):
+                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[dimension1ndex - 1]
+                else:
+                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+    return connectionGraph
+
+def makeDataContainer(shape, datatype: Optional[Type] = None):
+    if datatype is None:
+        datatype = dtypeDefault
+    return numpy.zeros(shape, dtype=datatype)
+
+def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
+    datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
+    datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
+
+    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, datatype=datatypeDefault),
+        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
+        mapShape = mapShape,
+        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] = 1
+    return stateInitialized
+
+def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
+    # listValidated = intInnit(dimensions, parameterName)
+    listNOTValidated = dimensions if isinstance(dimensions, (list, tuple)) else list(dimensions)
+    listNonNegative = []
+    for dimension in listNOTValidated:
+        if dimension < 0:
+            raise ValueError(f"Dimension {dimension} must be non-negative")
+        listNonNegative.append(dimension)
+    if not listNonNegative:
+        raise ValueError("At least one dimension must be non-negative")
+    return listNonNegative
+
+def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
+    # if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
+    #     CPUlimit = oopsieKwargsie(CPUlimit)
+    # concurrencyLimit = defineConcurrencyLimit(CPUlimit)
+    # numba.set_num_threads(concurrencyLimit)
+    concurrencyLimitHARDCODED = 1
+    concurrencyLimit = concurrencyLimitHARDCODED
+    return concurrencyLimit
+
+def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
+    if not listDimensions:
+        raise ValueError(f"listDimensions is a required parameter.")
+    listNonNegative = parseDimensions(listDimensions, 'listDimensions')
+    dimensionsValid = [dimension for dimension in listNonNegative if dimension > 0]
+    if len(dimensionsValid) < 2:
+        raise NotImplementedError(f"This function requires listDimensions, {listDimensions}, to have at least two dimensions greater than 0. You may want to look at https://oeis.org/.")
+    return sorted(dimensionsValid)

mapFolding/startHere.py

@@ -1,4 +1,4 @@
-from mapFolding import outfitFoldings
+from mapFolding import outfitCountFolds, getFilenameFoldsTotal
 from typing import Optional, Sequence, Type, Union
 import os
 import pathlib
@@ -15,7 +15,7 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
         CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
         **keywordArguments: Additional arguments including `dtypeDefault` and `dtypeLarge` for data type specifications.
     Returns:
-        foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
+        foldsSubTotals: Total number of distinct ways to fold a map of the given dimensions.
 
     Computation divisions:
         - None: no division of the computation into tasks; sets task divisions to 0
@@ -34,20 +34,22 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
     N.B.: You probably don't want to divide the computation into tasks.
         If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time, it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the computation time. If logicalCores >= leavesTotal, it will probably be faster. If logicalCores <= 2 * leavesTotal, it will almost certainly be slower for all map dimensions.
     """
-    stateUniversal = outfitFoldings(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
+    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
 
     pathFilenameFoldsTotal = None
     if writeFoldsTotal is not None:
         pathFilenameFoldsTotal = pathlib.Path(writeFoldsTotal)
         if pathFilenameFoldsTotal.is_dir():
-            filenameFoldsTotalDEFAULT = str(sorted(stateUniversal['mapShape'])).replace(' ', '') + '.foldsTotal'
+            filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(stateUniversal['mapShape'])
             pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
         pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 
     # NOTE Don't import a module with a numba.jit function until you want the function to compile and to freeze all settings for that function.
     from mapFolding.babbage import _countFolds
-    foldsTotal = _countFolds(**stateUniversal)
-    # foldsTotal = benchmarkSherpa(**stateUniversal)
+    _countFolds(**stateUniversal)
+    # foldsSubTotals = benchmarkSherpa(**stateUniversal)
+
+    foldsTotal = stateUniversal['foldsSubTotals'].sum().item()
 
     if pathFilenameFoldsTotal is not None:
         try:
@@ -63,6 +65,6 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
 # from typing import Any, Tuple
 # from mapFolding.benchmarks.benchmarking import recordBenchmarks
 # @recordBenchmarks()
-# def benchmarkSherpa(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]]):
+# def benchmarkSherpa(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]]):
 #     from mapFolding.babbage import _countFolds
-#     return _countFolds(connectionGraph, foldsTotal, mapShape, my, gapsWhere, the, track)
+#     return _countFolds(connectionGraph, foldsSubTotals, gapsWhere, mapShape, my, the, track)

mapFolding/theSSOT.py

@@ -15,7 +15,7 @@ except NameError:
     _pathModule = pathlib.Path.cwd()
 
 pathJobDEFAULT = _pathModule / "jobs"
-"""filenameFoldsTotal = str(sorted(mapShape)).replace(' ', '') + '.foldsTotal'"""
+
 if 'google.colab' in sys.modules:
     pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
 
@@ -59,7 +59,7 @@ class indexTrack(EnumIndices):
 
 class computationState(TypedDict):
     connectionGraph: numpy.typing.NDArray[numpy.integer[Any]]
-    foldsTotal: numpy.ndarray[numpy.int64, numpy.dtype[numpy.int64]]
+    foldsSubTotals: numpy.ndarray[numpy.int64, numpy.dtype[numpy.int64]]
     mapShape: Tuple[int, ...]
     my: numpy.typing.NDArray[numpy.integer[Any]]
     gapsWhere: numpy.typing.NDArray[numpy.integer[Any]]

{mapFolding-0.2.2.dist-info → mapFolding-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.2
+Version: 0.2.3
 Summary: Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 Project-URL: homepage, https://github.com/hunterhogan/mapFolding
@@ -25,7 +25,7 @@ Requires-Dist: pytest-xdist; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
-`mapFolding.countFolds()` will accept arbitrary values for the map's dimensions.
+The function `mapFolding.countFolds()` counts distinct ways to fold maps and strips of stamps. The function accepts two or more dimensions:
 
 ```python
 from mapFolding import countFolds
@@ -34,12 +34,12 @@ foldsTotal = countFolds( [2,10] )
 
 The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference) has
 
-- a verbatim transcription of the "procedure" published in _The Computer Journal_,
+- a verbatim transcription of Lunnon's "procedure" published in 1971 by _The Computer Journal_,
 - multiple referential versions of the procedure with explanatory comments including
 - [hunterNumba.py](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference), a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
 - miscellaneous notes.
 
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) ![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ## Simple, easy usage based on OEIS IDs
 

{mapFolding-0.2.2.dist-info → mapFolding-0.2.3.dist-info}/RECORD

@@ -1,14 +1,15 @@
-mapFolding/__init__.py,sha256=POxXTSE6Qu1G8k-YlSXHzbe-_JGuHk-L9p5SLRng4vA,439
-mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
-mapFolding/beDRY.py,sha256=ZrUXCNqnumTQ1XX8RT5gGdRr-a-o8QxEiGrerUxKtYg,12784
-mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
+mapFolding/__init__.py,sha256=wnf2EzHR2unVha6-Y0gRoSPaE4PDdT4VngINa_dfT2E,337
+mapFolding/babbage.py,sha256=LCtyapF8SKsECqBifqbLm7bR_i4n8VJ647w_TQxnQvE,1930
+mapFolding/beDRY.py,sha256=UE4IRrb5lXN4nTuUghHfieNm2FBHgz7oBj_EqUgkadI,13800
+mapFolding/lovelace.py,sha256=r4dkTGh_AgaVsWOsdPRdpPWVx3TjVjbWfPCVu3UTm6U,13495
 mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
-mapFolding/startHere.py,sha256=RGdFoJJdrJ_0tmLIKZn1WnHP0NCZwvQG7C2p4EUHOe4,5034
-mapFolding/theSSOT.py,sha256=yRW6aHyJxheL-Znk537LQA6xUPHz6FfoXY-0Ayh3Lsg,2178
+mapFolding/startHere.py,sha256=glGxmefrWpxyuqrzXrbCvIo84yvPnv8l8l7Rmff2sAo,5105
+mapFolding/theSSOT.py,sha256=rAyx034y33QC7IiRKaW89CMGGvqe2p-QBc3_fO-zEGM,2101
 mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
 mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
 mapFolding/benchmarks/benchmarking.py,sha256=kv85F6V9pGhZvTOImArOuxyg5rywA_T6JLH_qFXM8BM,3018
 mapFolding/benchmarks/test_benchmarks.py,sha256=c4ANeR3jgqpKXFoxDeZkmAHxSuenMwsjmrhKJ1_XPqY,3659
+mapFolding/reference/flattened.py,sha256=X9nvRzg7YDcpCtSDTL4YiidjshlX9rg2e6JVCY6i2u0,16547
 mapFolding/reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
 mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
 mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
@@ -16,13 +17,14 @@ mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v
 mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
 mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
 mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
-tests/conftest.py,sha256=VFYSd7-tHWd-LUKnTY24PIJhq9quP9S3sK2SYusNNog,12875
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=WE3DETPaQ4zuUiw8pweTry4rp1PxvUPgeb8CN8eh5JI,13574
+tests/pythons_idiotic_namespace.py,sha256=oOLDBergQqqhGuRpsXUnFD-R_6AlJipNKYHw-kk_OKw,33
 tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
-tests/test_other.py,sha256=cf8DbkZxm_DHNq9lkMe7auXye_XspruU9qiNZATkxr4,6930
+tests/test_other.py,sha256=5DwOZsjezBHZzr4-9qEnybBYJEGsozBm2n9p0KYvs9E,10664
 tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
-mapFolding-0.2.2.dist-info/METADATA,sha256=BSCXcKZDhAtOWr8A5pZMG8bZnm5YBLf-6uMN9qs8JDk,5914
-mapFolding-0.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.2.dist-info/RECORD,,
+mapFolding-0.2.3.dist-info/METADATA,sha256=nEQXgDmmuu2NJko4R4gPUdjIrm1upUGwMIOn0s0JOOc,6442
+mapFolding-0.2.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.3.dist-info/RECORD,,

tests/__init__.py

@@ -1 +1 @@
-from .conftest import makeDictionaryFoldsTotalKnown
+from tests.conftest import makeDictionaryFoldsTotalKnown

tests/conftest.py

@@ -14,10 +14,10 @@ from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
 from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
 from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie
 from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexThe, indexTrack
-from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from mapFolding import getLeavesTotal, parseDimensions, validateListDimensions
-from mapFolding import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
-from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache
+from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie, outfitCountFolds
+from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache, getFilenameFoldsTotal
+from mapFolding.beDRY import getLeavesTotal, parseDimensions, validateListDimensions
+from mapFolding.beDRY import getTaskDivisions, makeConnectionGraph, setCPUlimit
 from mapFolding.beDRY import makeDataContainer
 from mapFolding.oeis import OEIS_for_n
 from mapFolding.oeis import _getFilenameOEISbFile
@@ -26,6 +26,7 @@ from mapFolding.oeis import _parseBFileOEIS
 from mapFolding.oeis import _validateOEISid
 from mapFolding.oeis import oeisIDsImplemented
 from mapFolding.oeis import settingsOEIS
+from mapFolding import *
 
 __all__ = [
     'OEIS_for_n',
@@ -37,10 +38,11 @@ __all__ = [
     'countFolds',
     'defineConcurrencyLimit',
     'expectSystemExit',
+    'getFilenameFoldsTotal',
     'getLeavesTotal',
     'getOEISids',
-    'indexThe',
     'getTaskDivisions',
+    'indexThe',
     'intInnit',
     'makeConnectionGraph',
     'makeDataContainer',
@@ -50,7 +52,7 @@ __all__ = [
     'oeisIDfor_n',
     'oeisIDsImplemented',
     'oopsieKwargsie',
-    'outfitFoldings',
+    'outfitCountFolds',
     'parseDimensions',
     'setCPUlimit',
     'settingsOEIS',
@@ -227,6 +229,22 @@ def oeisID_1random() -> str:
     """Return one random valid OEIS ID."""
     return random.choice(oeisIDsImplemented)
 
+@pytest.fixture
+def mockFoldingFunction():
+    """Creates a mock function that simulates _countFolds behavior."""
+    def make_mock(foldsValue: int, listDimensions: List[int]):
+        arraySize = getLeavesTotal(listDimensions)
+        # The array needs to sum to our target value
+        mock_array = makeDataContainer(arraySize)
+        mock_array[arraySize - 1] = foldsValue  # Put entire value in last position
+
+        def mock_countfolds(**keywordArguments):
+            keywordArguments['foldsSubTotals'][:] = mock_array
+            return None
+
+        return mock_countfolds
+    return make_mock
+
 """
 Section: Standardized test structures"""
 

tests/pythons_idiotic_namespace.py

@@ -0,0 +1 @@
+from mapFolding.theSSOT import *

tests/test_other.py

@@ -1,14 +1,13 @@
 from pathlib import Path
-from typing import List
-from .conftest import *
+from typing import List, Optional, Dict, Any, Union
+from tests.conftest import *
+from tests.pythons_idiotic_namespace import *
 import pytest
 import sys
 import unittest.mock
 import numpy
 import numba
 
-# TODO test `outfitFoldings`; no negative values in arrays; compare datatypes to the typeddict; commpare the connection graph to making a graPH
-
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
     (['a'], ValueError, ValueError, ValueError, ValueError),  # string
@@ -59,18 +58,34 @@ def test_getLeavesTotal_edge_cases() -> None:
     standardComparison(6, getLeavesTotal, listOriginal)
     standardComparison([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
 
-def test_countFolds_writeFoldsTotal_file(listDimensionsTestFunctionality: List[int], pathFilenameFoldsTotalTesting: Path) -> None:
-    with unittest.mock.patch("mapFolding.babbage._countFolds", return_value=12345):
-        standardComparison(12345, countFolds, listDimensionsTestFunctionality, pathFilenameFoldsTotalTesting)
-    standardComparison("12345", lambda: pathFilenameFoldsTotalTesting.read_text())
+@pytest.mark.parametrize("foldsValue,writeFoldsTarget", [
+    (756839, "foldsTotalTest.txt"),  # Direct file
+    (2640919, "foldsTotalTest.txt"), # Direct file
+    (7715177, None),                  # Directory, will use default filename
+])
+def test_countFolds_writeFoldsTotal(
+    listDimensionsTestFunctionality: List[int],
+    pathTempTesting: Path,
+    mockFoldingFunction,
+    foldsValue: int,
+    writeFoldsTarget: Optional[str]
+) -> None:
+    """Test writing folds total to either a file or directory."""
+    # For directory case, use the directory path directly
+    if writeFoldsTarget is None:
+        pathWriteTarget = pathTempTesting
+        filenameFoldsTotalExpected = getFilenameFoldsTotal(listDimensionsTestFunctionality)
+    else:
+        pathWriteTarget = pathTempTesting / writeFoldsTarget
+        filenameFoldsTotalExpected = writeFoldsTarget
+
+    mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
+
+    with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
+        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathWriteTarget)
 
-def test_countFolds_writeFoldsTotal_directory(listDimensionsTestFunctionality: List[int], pathTempTesting: Path) -> None:
-    with unittest.mock.patch("mapFolding.babbage._countFolds", return_value=67890):
-        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathTempTesting)
-    standardComparison(67890, lambda: returned)
-    # Construct expected filename from sorted dimensions
-    expectedName = str(sorted(listDimensionsTestFunctionality)).replace(' ', '') + '.foldsTotal'
-    standardComparison("67890", lambda: (pathTempTesting / expectedName).read_text())
+    standardComparison(foldsValue, lambda: returned)  # Check return value
+    standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
 
 def test_intInnit() -> None:
     """Test integer parsing using the test suite generator."""
@@ -103,3 +118,81 @@ def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[i
 def test_makeConnectionGraph_datatype(listDimensionsTestFunctionality: List[int], datatype) -> None:
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality, datatype=datatype)
     assert connectionGraph.dtype == datatype, f"Expected datatype {datatype}, but got {connectionGraph.dtype}."
+
+# @pytest.mark.parametrize("computationDivisions,CPUlimit,datatypeOverrides", [
+#     (None, None, {}),  # Basic case
+#     ("maximum", True, {"datatypeDefault": numpy.int32}),  # Max divisions, min CPU, custom dtype
+#     ("cpu", 4, {"datatypeLarge": numpy.int64}),  # CPU-based divisions, fixed CPU limit
+#     (3, 0.5, {}),  # Fixed divisions, fractional CPU
+# ])
+# def test_outfitCountFolds(
+#     listDimensionsTestFunctionality: List[int],
+#     computationDivisions: Optional[Union[int, str]],
+#     CPUlimit: Optional[Union[bool, float, int]],
+#     datatypeOverrides: Dict[str, Any]
+# ) -> None:
+#     """Test outfitCountFolds as a nexus of configuration and initialization.
+
+#     Strategy:
+#     1. Validate structure against computationState TypedDict
+#     2. Compare with direct function calls
+#     3. Verify enum-based indexing
+#     4. Check datatypes and shapes
+#     """
+#     # Get initialized state
+#     stateInitialized = outfitCountFolds(
+#         listDimensionsTestFunctionality,
+#         computationDivisions=computationDivisions,
+#         CPUlimit=CPUlimit,
+#         **datatypeOverrides
+#     )
+
+#     # 1. TypedDict structure validation
+#     for keyRequired in computationState.__annotations__:
+#         assert keyRequired in stateInitialized, f"Missing required key: {keyRequired}"
+#         assert stateInitialized[keyRequired] is not None, f"Key has None value: {keyRequired}"
+
+#         # Type checking
+#         expectedType = computationState.__annotations__[keyRequired]
+#         assert isinstance(stateInitialized[keyRequired], expectedType), \
+#             f"Type mismatch for {keyRequired}: expected {expectedType}, got {type(stateInitialized[keyRequired])}"
+
+#     # 2. Compare with direct function calls
+#     directMapShape = tuple(sorted(validateListDimensions(listDimensionsTestFunctionality)))
+#     assert stateInitialized['mapShape'] == directMapShape
+
+#     directConnectionGraph = makeConnectionGraph(
+#         directMapShape,
+#         datatype=datatypeOverrides.get('datatypeDefault', dtypeDefault)
+#     )
+#     assert numpy.array_equal(stateInitialized['connectionGraph'], directConnectionGraph)
+
+#     # 3. Enum-based indexing validation
+#     for arrayName, indexEnum in [
+#         ('my', indexMy),
+#         ('the', indexThe),
+#         ('track', indexTrack)
+#     ]:
+#         array = stateInitialized[arrayName]
+#         assert array.shape[0] >= len(indexEnum), \
+#             f"Array {arrayName} too small for enum {indexEnum.__name__}"
+
+#         # Test each enum index
+#         for enumMember in indexEnum:
+#             assert array[enumMember.value] >= 0, \
+#                 f"Negative value at {arrayName}[{enumMember.name}]"
+
+#     # 4. Special value checks
+#     assert stateInitialized['my'][indexMy.leaf1ndex.value] == 1, \
+#         "Initial leaf index should be 1"
+
+#     # 5. Shape consistency
+#     leavesTotal = getLeavesTotal(listDimensionsTestFunctionality)
+#     assert stateInitialized['foldsSubTotals'].shape == (leavesTotal,), \
+#         "foldsSubTotals shape mismatch"
+#     assert stateInitialized['gapsWhere'].shape == (leavesTotal * leavesTotal + 1,), \
+#         "gapsWhere shape mismatch"
+#     assert stateInitialized['track'].shape == (len(indexTrack), leavesTotal + 1), \
+#         "track shape mismatch"
+
+# TODO test `outfitCountFolds`; no negative values in arrays; compare datatypes to the typeddict; compare the connection graph to making a graph