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

mapFolding/__init__.py

@@ -1,12 +1,3 @@
-"""Test concept: Import priority levels. Larger priority values should be imported before smaller priority values.
-This seems to be a little silly: no useful information is encoded in the priority value, so I don't know if a
-new import should have a lower or higher priority.
-Crazy concept: Python doesn't cram at least two import roles into one system, call it `import` and tell us how
-awesome Python is. Alternatively, I learn about the secret system for mapping physical names to logical names."""
-
-# TODO Across the entire package, restructure computationDivisions.
-# test modules need updating still
-
 from .theSSOT import *
 from .beDRY import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
 from .beDRY import getLeavesTotal, parseDimensions, validateListDimensions

mapFolding/babbage.py

@@ -6,7 +6,25 @@ 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]]):
+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:
+    """
+    What in tarnation is this stupid module and function?
+
+    - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
+    - This function is not in the same module as `countFoldsCompiled`, which is the function that does the hard, so that we can delay `numba.jit` compilation of `countFoldsCompiled`.
+    - `countFoldsCompiled` is not merely "jitted", it is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
+    - The function in this module is jitted, so it can talk to `countFoldsCompiled`, and because it isn't so arrogant, it will talk to the low-class `countFolds` with only a few restrictions, such as:
+        - No `TypedDict`
+        - No Python v 3.13
+        - The plebs must clean up their own memory problems
+        - No oversized integers
+        - No global variables, only global constants
+        - They don't except pleb nonlocal variables either
+        - Python "class": they are all inferior to a jit
+        - No `**kwargs`
+        - and just a few dozen-jillion other things.
+
+    """
     # 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)

mapFolding/beDRY.py

@@ -4,19 +4,19 @@ from mapFolding import indexMy, indexThe, indexTrack, computationState
 from typing import Any, List, Optional, Sequence, Type, Union
 import numpy
 import numba
-import numba.extending
-import numpy.typing
+from numpy.typing import NDArray
+from numpy import integer
 import sys
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
-    Calculate the product of non-zero, non-negative integers in the given list.
+    How many leaves are in the map.
 
     Parameters:
         listDimensions: A list of integers representing dimensions.
 
     Returns:
-        productDimensions: The product of all positive integer dimensions. Returns 0 if all dimensions are 0.
+        productDimensions: The product of all positive integer dimensions.
     """
     listNonNegative = parseDimensions(listDimensions, 'listDimensions')
     listPositive = [dimension for dimension in listNonNegative if dimension > 0]
@@ -27,18 +27,46 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
         productDimensions = 1
         for dimension in listPositive:
             if dimension > sys.maxsize // productDimensions:
-                raise OverflowError("Product would exceed maximum integer size")
+                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(CPUlimit, computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, listDimensions, the: numpy.typing.NDArray[numpy.integer[Any]], ):
-    # TODO remove after restructuring the tests
-    if isinstance(computationDivisions, bool) and computationDivisions:
-        computationDivisions = "maximum"
+def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, the: NDArray[integer[Any]], CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
+    """
+    Determines whether or how to divide the computation into tasks.
+
+    Parameters
+    ----------
+    computationDivisions (None):
+        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`
+    concurrencyLimit:
+        Maximum number of concurrent tasks allowed
+    the:
+        Array of settings, including `leavesTotal`
+    CPUlimit: for error reporting
+    listDimensions: for error reporting
+
+    Returns
+    -------
+    the
+        Updated settings, including for `taskDivisions`
+
+    Raises
+    ------
+    ValueError
+        If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves
+
+    Notes
+    -----
+    Task divisions cannot exceed total leaves to prevent duplicate counting of folds.
+    """
 
     if not computationDivisions:
-        # Coding it this way should cover `None`, `False`, and `0`.
         the[indexThe.taskDivisions] = 0
     elif isinstance(computationDivisions, int):
         the[indexThe.taskDivisions] = computationDivisions
@@ -56,25 +84,23 @@ def getTaskDivisions(CPUlimit, computationDivisions: Optional[Union[int, str]],
 
     return the
 
-def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = numpy.int64) -> numpy.typing.NDArray[numpy.integer[Any]]:
+def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = numpy.int64) -> NDArray[integer[Any]]:
     """
-    Constructs a connection graph for a given list of dimensions.
-    This function generates a multi-dimensional connection graph based on the provided list of dimensions.
-    The graph represents the connections between leaves in a Cartesian product decomposition or dimensional product mapping.
+    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.
 
     Parameters:
-        listDimensions: A validated sequence of integers representing the dimensions of the map.
+        listDimensions: A sequence of integers representing the dimensions of the map.
     Returns:
         connectionGraph: A 3D numpy array with shape of (dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1).
     """
-    leavesTotal = getLeavesTotal(listDimensions)
-    arrayDimensions = numpy.array(listDimensions, dtype=dtype)
+    mapShape = validateListDimensions(listDimensions)
+    leavesTotal = getLeavesTotal(mapShape)
+    arrayDimensions = numpy.array(mapShape, dtype=dtype)
     dimensionsTotal = len(arrayDimensions)
 
     # Step 1: find the cumulative product of the map's dimensions
-    cumulativeProduct = numpy.ones(dimensionsTotal + 1, dtype=dtype)
-    for index in range(1, dimensionsTotal + 1):
-        cumulativeProduct[index] = cumulativeProduct[index - 1] * arrayDimensions[index - 1]
+    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=dtype)
 
     # Step 2: create a coordinate system
     coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtype)
@@ -113,13 +139,36 @@ 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[int, float, bool]] = None,
-    dtypeDefault: Optional[Type] = numpy.int64, # TODO consider allowing a type or a "signal", such as "minimum", "safe", "maximum"
-    dtypeLarge: Optional[Type] = numpy.int64, # Can/should I use numba types?
-    ) -> computationState:
+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:
+    """
+    Initializes and configures the computation state for map folding computations.
+
+    Parameters
+    ----------
+    listDimensions:
+        The dimensions of the map to be folded
+    computationDivisions (None):
+        Specifies how to divide the computation tasks
+    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
+
+    Returns
+    -------
+    computationState
+        An initialized computation state containing:
+        - connectionGraph: Graph representing connections in the map
+        - foldsTotal: 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
+        - track: Array for tracking computation progress
+    """
+
     the = numpy.zeros(len(indexThe), dtype=dtypeDefault)
 
     mapShape = tuple(sorted(validateListDimensions(listDimensions)))
@@ -127,15 +176,13 @@ def outfitFoldings(
     the[indexThe.dimensionsTotal] = len(mapShape)
     concurrencyLimit = setCPUlimit(CPUlimit)
 
-    the = getTaskDivisions(CPUlimit, computationDivisions, concurrencyLimit, listDimensions, the)
-
     stateInitialized = computationState(
         connectionGraph = makeConnectionGraph(mapShape, dtype=dtypeDefault),
         foldsTotal = numpy.zeros(the[indexThe.leavesTotal], dtype=numpy.int64),
         mapShape = mapShape,
         my = numpy.zeros(len(indexMy), dtype=dtypeLarge),
         gapsWhere = numpy.zeros(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, dtype=dtypeDefault),
-        the = the,
+        the = getTaskDivisions(computationDivisions, concurrencyLimit, the, CPUlimit, listDimensions),
         track = numpy.zeros((len(indexTrack), the[indexThe.leavesTotal] + 1), dtype=dtypeLarge)
         )
 
@@ -145,10 +192,10 @@ def outfitFoldings(
 
 def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
     """
-    Parse and validate a list of dimensions.
+    Parse and validate dimensions are non-negative integers.
 
     Parameters:
-        listDimensions: List of integers representing dimensions
+        dimensions: Sequence of integers representing dimensions
         parameterName ('unnamed parameter'): Name of the parameter for error messages. Defaults to 'unnamed parameter'
     Returns:
         listNonNegative: List of validated non-negative integers
@@ -168,43 +215,41 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
 
     return listNonNegative
 
-def setCPUlimit(CPUlimit: Union[int, float, bool, None]):
-    """Sets CPU limit for concurrent operations using Numba.
-    This function configures the number of CPU threads that Numba can use for parallel execution.
-    Note that this setting only affects Numba-jitted functions that have not yet been imported.
+def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
+    """Sets CPU limit for Numba concurrent operations. Note that it can only affect Numba-jitted functions that have not yet been imported.
+
     Parameters:
-        CPUlimit (Union[int, float, bool, None]): The CPU limit to set.
-            - If int/float: Specifies number of CPU threads to use
-            - If bool: True uses all available CPUs, False uses 1 CPU
-            - If None: Uses system default
+        CPUlimit: whether and how to limit the CPU usage. See notes for details.
     Returns:
         concurrencyLimit: The actual concurrency limit that was set
     Raises:
         TypeError: If CPUlimit is not of the expected types
+
+    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.
     """
     if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
         CPUlimit = oopsieKwargsie(CPUlimit)
 
     concurrencyLimit = defineConcurrencyLimit(CPUlimit)
-    # NOTE `set_num_threads` only affects "jitted" functions that have _not_ yet been "imported"
     numba.set_num_threads(concurrencyLimit)
 
     return concurrencyLimit
 
 def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
     """
-    Validates and processes a list of dimensions.
-
-    This function ensures that the input list of dimensions is not None,
-    parses it to ensure all dimensions are non-negative, and then filters
-    out any dimensions that are not greater than zero. If the resulting
-    list has fewer than two dimensions, a NotImplementedError is raised.
+    Validates and sorts a sequence of at least two positive dimensions.
 
     Parameters:
-        listDimensions: A list of integer dimensions to be validated.
+        listDimensions: A sequence of integer dimensions to be validated.
 
     Returns:
-        validDimensions: A list, with at least two elements, of only positive integers.
+        dimensionsValidSorted: A list, with at least two elements, of only positive integers.
 
     Raises:
         ValueError: If the input listDimensions is None.
@@ -213,7 +258,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
     if not listDimensions:
         raise ValueError(f"listDimensions is a required parameter.")
     listNonNegative = parseDimensions(listDimensions, 'listDimensions')
-    validDimensions = [dimension for dimension in listNonNegative if dimension > 0]
-    if len(validDimensions) < 2:
+    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 validDimensions
+    return sorted(dimensionsValid)

mapFolding/lovelace.py

@@ -1,27 +1,43 @@
+"""
+The algorithm for counting folds.
+
+Starting from established data structures, the algorithm initializes some baseline values. The initialization uses a loop that is not used after the first fold is counted.
+
+After initialization, the folds are either counted sequentially or counted with inefficiently divided parallel tasks.
+
+All three of these actions--initialization, sequential counting, and parallel counting--use nearly identical logic. Without Numba, all of the logic is in one function with exactly one additional
+conditional statement for initialization and exactly one additional conditional statement for parallel counting.
+
+Numba's just-in-time (jit) compiler, especially super jit, is capable of radically increasing throughput and dramatically reducing the size of the compiled code, especially by ejecting unused code.
+
+The complexity of this module is due to me allegedly applying Numba's features. Allegedly.
+
+(The flow starts with the last function.)
+"""
 from mapFolding import indexMy, indexThe, indexTrack
 from numpy import integer
 from numpy.typing import NDArray
-from typing import Any, Optional
+from typing import Any, Tuple, Optional
 import numba
 import numpy
 
 @numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def ifComputationDivisions(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+def ifComputationDivisions(my: NDArray[integer[Any]], the: NDArray[integer[Any]]) -> bool:
     if the[indexThe.taskDivisions.value] == 0:
         return True
     return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value] or \
             (my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value]) == my[indexMy.taskIndex.value]
 
 @numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def insertUnconstrainedLeaf(my: NDArray[integer[Any]], the: NDArray[integer[Any]], Z0Z_initializeUnconstrainedLeaf: Optional[bool]):
-    if Z0Z_initializeUnconstrainedLeaf:
+def insertUnconstrainedLeaf(my: NDArray[integer[Any]], the: NDArray[integer[Any]], initializeUnconstrainedLeaf: Optional[bool]) -> bool:
+    if initializeUnconstrainedLeaf:
         return my[indexMy.dimensionsUnconstrained.value] == the[indexThe.dimensionsTotal.value]
     else:
         return False
 
 @numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def initializationConditionUnconstrainedLeaf(my: NDArray[integer[Any]], Z0Z_initializeUnconstrainedLeaf: Optional[bool]):
-    if Z0Z_initializeUnconstrainedLeaf is None or Z0Z_initializeUnconstrainedLeaf is False:
+def initializationConditionUnconstrainedLeaf(my: NDArray[integer[Any]], initializeUnconstrainedLeaf: Optional[bool]) -> bool:
+    if initializeUnconstrainedLeaf is None or initializeUnconstrainedLeaf is False:
         return False
     else:
         if my[indexMy.gap1ndex.value] > 0:
@@ -30,7 +46,7 @@ def initializationConditionUnconstrainedLeaf(my: NDArray[integer[Any]], Z0Z_init
             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]], Z0Z_initializeUnconstrainedLeaf: Optional[bool] ):
+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]:
@@ -45,6 +61,7 @@ def doWhile(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[
                     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:
@@ -52,7 +69,8 @@ def doWhile(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[
                                 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
-                if insertUnconstrainedLeaf(my, the, Z0Z_initializeUnconstrainedLeaf):
+                # 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]
@@ -77,13 +95,16 @@ def doWhile(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[
             track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
             track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
             my[indexMy.leaf1ndex.value] += 1
-        if initializationConditionUnconstrainedLeaf(my, Z0Z_initializeUnconstrainedLeaf):
+        # NOTE This check and break should be absent from the code that does the counting
+        if initializationConditionUnconstrainedLeaf(my, initializeUnconstrainedLeaf):
             break
     return foldsTotal, my, gapsWhere, track
 
 @numba.jit(parallel=True, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def doTaskIndices(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
-
+def doTaskIndices(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> NDArray[integer[Any]]:
+    """This is the only function with the `parallel=True` option.
+    Make a copy of the initialized state because all task divisions can start from this baseline.
+    Run the counting algorithm but with conditional execution of a few lines of code, so each task has an incomplete count that does not overlap with other tasks."""
     stateFoldsSubTotal = foldsTotal.copy()
     stateMy = my.copy()
     statePotentialGaps = gapsWhere.copy()
@@ -92,18 +113,17 @@ def doTaskIndices(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[in
     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(), Z0Z_initializeUnconstrainedLeaf=False)
+        foldsSubTotal, _1, _2, _3 = doWhile(connectionGraph, stateFoldsSubTotal.copy(), my, statePotentialGaps.copy(), the, stateTrack.copy(), initializeUnconstrainedLeaf=False)
 
         foldsTotal[indexSherpa] = foldsSubTotal[indexSherpa]
 
     return foldsTotal
 
 @numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def countFoldsCompileBranch(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]],
-                            my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]],
-                            obviousFlagForNumba: bool):
+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, Z0Z_initializeUnconstrainedLeaf=False)
+        foldsTotal, _1, _2, _3 = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, initializeUnconstrainedLeaf=False)
     else:
         foldsTotal = doTaskIndices(connectionGraph, foldsTotal, my, gapsWhere, the, track)
 
@@ -111,11 +131,15 @@ def countFoldsCompileBranch(connectionGraph: NDArray[integer[Any]], 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.
 
-    _0, my, gapsWhere, track = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, Z0Z_initializeUnconstrainedLeaf=True)
+    # Initialize baseline values primarily to eliminate the need for the logic of `insertUnconstrainedLeaf`
+    _0, my, gapsWhere, track = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, initializeUnconstrainedLeaf=True)
 
     obviousFlagForNumba = the[indexThe.taskDivisions.value] == int(False)
 
+    # Call the function that will branch to sequential or parallel counting
     foldsTotal = countFoldsCompileBranch(connectionGraph, foldsTotal, my, gapsWhere, the, track, obviousFlagForNumba)
 
+    # Return an `int` integer
     return numpy.sum(foldsTotal).item()

mapFolding/oeis.py

@@ -148,6 +148,28 @@ def _getOEISidValues(oeisID: str) -> Dict[int, int]:
     return _parseBFileOEIS(OEISbFile, oeisID)
 
 def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
+    """
+    Creates a dictionary mapping OEIS IDs to their corresponding settings.
+
+    This function initializes settings for each implemented OEIS sequence by combining
+    hardcoded values with dynamically retrieved OEIS sequence values.
+
+    Returns:
+        Dict[str, SettingsOEIS]: A dictionary where:
+            - Keys are OEIS sequence IDs (str)
+            - Values are SettingsOEIS objects containing:
+                - description: Text description of the sequence
+                - getDimensions: Function to get dimensions
+                - valuesBenchmark: Benchmark values
+                - valuesKnown: Known values from OEIS
+                - valuesTestValidation: Values for test validation
+                - valueUnknown: First unknown value in sequence
+
+    Note:
+        Relies on global variables:
+        - oeisIDsImplemented: List of implemented OEIS sequence IDs
+        - settingsOEIShardcodedValues: Dictionary of hardcoded settings per sequence
+    """
     settingsTarget = {}
     for oeisID in oeisIDsImplemented:
         valuesKnownSherpa = _getOEISidValues(oeisID)

mapFolding/startHere.py

@@ -1,27 +1,38 @@
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, Tuple
-import numba
-import numpy
 from mapFolding import outfitFoldings
-# from mapFolding.benchmarks.benchmarking import recordBenchmarks
-from typing import Optional, Union, Sequence, Type
+from typing import Optional, Sequence, Type, Union
 import os
 import pathlib
 
-# TODO the current tests expect positional `listDimensions, computationDivisions`, so after restructuring you can arrange the parameters however you want.
-def countFolds(
-    listDimensions: Sequence[int],
-    computationDivisions: Optional[Union[int, str]] = None,
-    CPUlimit: Optional[Union[int, float, bool]] = None,
-    writeFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None,
-    **keywordArguments: Optional[Type]
-    ):
-    """keywordArguments:
-    dtypeDefault: Optional[Type]
-    dtypeLarge: Optional[Type]
-
-    writeFoldsTotal: path, filename, or pathFilename
+def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None, computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[int, float, bool]] = None, **keywordArguments: Optional[Type]) -> int:
+    """Count the total number of possible foldings for a given map dimensions.
+
+    Parameters:
+        listDimensions: List of integers representing the dimensions of the map to be folded.
+        writeFoldsTotal (None): Path or filename to write the total fold count.
+            If a directory is provided, creates a file with default name based on map dimensions.
+        computationDivisions (None):
+            Whether and how to divide the computational work. See notes for details.
+        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.
+
+    Computation divisions:
+        - 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`
+
+    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.
+
+    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)
 
@@ -33,6 +44,7 @@ def countFolds(
             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)
@@ -48,6 +60,10 @@ def countFolds(
 
     return foldsTotal
 
+# from numpy import integer
+# from numpy.typing import NDArray
+# 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]]):
 #     from mapFolding.babbage import _countFolds

{mapFolding-0.2.0.dist-info → mapFolding-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.0
+Version: 0.2.1
 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
@@ -32,11 +32,11 @@ from mapFolding import countFolds
 foldsTotal = countFolds( [2,10] )
 ```
 
-The directory `mapFolding/reference` has
+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_,
 - multiple referential versions of the procedure with explanatory comments including
-- `hunterNumba.py` a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
+- [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)
@@ -97,13 +97,13 @@ Cache cleared from C:\apps\mapFolding\mapFolding\.cache
 
 ### The typo-laden algorithm published in 1971
 
-The full paper, W. F. Lunnon, Multi-dimensional map-folding, _The Computer Journal_, Volume 14, Issue 1, 1971, Pages 75–80, [https://doi.org/10.1093/comjnl/14.1.75](https://doi.org/10.1093/comjnl/14.1.75) ([BibTex](mapFolding/citations/Lunnon.bibtex) citation) is available at the DOI link. (As of 3 January 2025, the paper is a PDF of images, not text, and can be accessed without cost or login.)
+The full paper, W. F. Lunnon, Multi-dimensional map-folding, _The Computer Journal_, Volume 14, Issue 1, 1971, Pages 75–80, [https://doi.org/10.1093/comjnl/14.1.75](https://doi.org/10.1093/comjnl/14.1.75) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/Lunnon.bibtex) citation) is available at the DOI link. (As of 3 January 2025, the paper is a PDF of images, not text, and can be accessed without cost or login.)
 
-In [`foldings.txt`](mapFolding/reference/foldings.txt), you can find a text transcription of the algorithm as it was printed in 1971. In [`foldings.AA`](mapFolding/reference/foldings.AA), I have corrected obvious transcription errors, documented with comments, and I have reformatted line breaks and indentation. For contemporary readers, the result is likely easier to read than the text transcription or the original paper are easy to read. This is especially true if you view the document with semantic highlighting, such as with [Algol 60 syntax highlighter](https://github.com/PolariTOON/language-algol60).
+In [`foldings.txt`](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference/foldings.txt), you can find a text transcription of the algorithm as it was printed in 1971. In [`foldings.AA`](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference/foldings.AA), I have corrected obvious transcription errors, documented with comments, and I have reformatted line breaks and indentation. For contemporary readers, the result is likely easier to read than the text transcription or the original paper are easy to read. This is especially true if you view the document with semantic highlighting, such as with [Algol 60 syntax highlighter](https://github.com/PolariTOON/language-algol60).
 
 ### Java implementation(s) and improvements
 
-[archmageirvine](https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java) ([BibTex](mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
+[archmageirvine](https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
 
 ```java
 /**
@@ -122,49 +122,12 @@ In [`foldings.txt`](mapFolding/reference/foldings.txt), you can find a text tran
 
 ~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
 
-"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](mapFolding/citations/Physics_for_the_Birds.bibtex) citation)
+"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/Physics_for_the_Birds.bibtex) citation)
 
 [![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
 
-## Install this package
-
-### From Github
-
-```sh
-pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
-```
-
-### From a local directory
-
-#### Windows
-
-```powershell
-git clone https://github.com/hunterhogan/mapFolding.git \path\to\mapFolding
-pip install mapFolding@file:\path\to\mapFolding
-```
-
-#### POSIX
-
-```bash
-git clone https://github.com/hunterhogan/mapFolding.git /path/to/mapFolding
-pip install mapFolding@file:/path/to/mapFolding
-```
-
-## Install updates
-
-```sh
-pip install --upgrade mapFolding@git+https://github.com/hunterhogan/mapFolding.git
-```
-
-## Creating a virtual environment before installation
-
-You can isolate `mapFolding` in a virtual environment. For example, use the following commands to create a directory for the virtual environment, activate the virtual environment, and install the package. In the future, you will likely need to activate the virtual environment before using `mapFolding` again. From the command line, in a directory you want to install in.
+## Installation
 
 ```sh
-py -m venv mapFolding
-cd mapFolding
-cd Scripts
-activate
-cd ..
-pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+pip install mapFolding
 ```

{mapFolding-0.2.0.dist-info → mapFolding-0.2.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-mapFolding/__init__.py,sha256=fQGYxmjMofT1id_svln0L3htMBVUbMVj1UWIP74QhAQ,974
-mapFolding/babbage.py,sha256=tmz4ZEvMds1nPK7kb_oyl89AsGyuU0MB5udC8AAIL-I,633
-mapFolding/beDRY.py,sha256=JUGAuLpQYD-B_mSrgpw4E-JNM_N3gJ2VfY-FkrBP3yA,11135
+mapFolding/__init__.py,sha256=3kQQWyOBriVg9wO5btGE1Cq3lNqJz6CudrkOxVWcsy8,368
+mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
+mapFolding/beDRY.py,sha256=QACsmdskZplzMpYGUu7DSTSCE7x5JFApEyUqvUh0H0c,12613
 mapFolding/importPackages.py,sha256=Pno5VXaNiyJKG2Jtj4sB_h6EG50IJ7tQKyivVoKFMxo,303
-mapFolding/lovelace.py,sha256=NdQDPYpe7yU8GS9WIv_Rb4nOE9cPt0-XPKOiLfyE_Z4,9369
-mapFolding/oeis.py,sha256=pI08RrA39AVAU7U6h_1IowadxXC4K6n2OQd7vgTbTTI,11096
-mapFolding/startHere.py,sha256=37wU-VmM92bOZkFw4Wpiz3u0_1TiLsob94HZUPBwFQg,2433
+mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
+mapFolding/oeis.py,sha256=c8oCAcWgLvwC-bBZzGty8yth1vWtT8lWcKQeCiNGYgw,12078
+mapFolding/startHere.py,sha256=Z73A2bm35XygF6bpz710S8G2tVRdU_5-nO-nDgTaDhM,5068
 mapFolding/theSSOT.py,sha256=-t23-gPLPNWWBEeSi1mKkNCeeQA4y1AA_oPKC7tZwe4,1970
 mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
 mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
@@ -19,10 +19,10 @@ mapFolding/reference/rotatedEntryPoint.py,sha256=6WVvEcGwDgRPa7dDs7ODAHUJjHDZDID
 tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
 tests/conftest.py,sha256=ur6l5nDnWju7zOEMXqoNGYHY-Hf9GApOm4VT9pXtMtY,10594
 tests/test_oeis.py,sha256=h-NhWRoarl3v6qoB0RpnaUPuMGrQpWyfmsL0FXsGauU,7972
-tests/test_other.py,sha256=AZYRvZYL-wdDiKcbAFEBTV4a22CANmbl8mj8yVGBQ6g,4852
-tests/test_tasks.py,sha256=bBXsMfxb6WXz15eFjUxoS67wzRqusX_9XhetXaY-RnQ,944
-mapFolding-0.2.0.dist-info/METADATA,sha256=EC2InFN5XJ1LqKGptTerqGvuJQntDQdyMFG4WIvR6WU,6602
-mapFolding-0.2.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.0.dist-info/RECORD,,
+tests/test_other.py,sha256=3Qc6fA39q5u_U0JhFUB9mdBd5_XcVC7IP9DwlNuG9p8,4716
+tests/test_tasks.py,sha256=Hn4N8OVVfDeNjL7ad5ELKKDgdOn8sDBj6IebPGpLIlE,1254
+mapFolding-0.2.1.dist-info/METADATA,sha256=r7QVig9M5_DReHsPG_wyyRNJe0UkggfUotMf8tfoF7I,5914
+mapFolding-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.1.dist-info/RECORD,,

tests/test_other.py

@@ -21,7 +21,7 @@ import sys
     ([2, 3, 4], [2, 3, 4], [2, 3, 4], [2, 3, 4], 24),
     ([2, 3], [2, 3], [2, 3], [2, 3], 6),
     ([2] * 11, [2] * 11, [2] * 11, [2] * 11, 2048),  # power of 2
-    ([3, 2], [3, 2], [3, 2], [3, 2], 6),  # return value is the input when valid
+    ([3, 2], [3, 2], [3, 2], [2, 3], 6),  # return value is the input when valid
     ([3] * 5, [3] * 5, [3] * 5, [3, 3, 3, 3, 3], 243),  # power of 3
     ([None], TypeError, TypeError, TypeError, TypeError),  # None
     ([True], TypeError, TypeError, TypeError, TypeError),  # bool
@@ -30,8 +30,8 @@ import sys
     ([complex(1,1)], ValueError, ValueError, ValueError, ValueError),  # complex number
     ([float('inf')], ValueError, ValueError, ValueError, ValueError),  # infinity
     ([float('nan')], ValueError, ValueError, ValueError, ValueError),  # NaN
-    ([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], sys.maxsize - 1),  # near maxint
-    ([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], OverflowError),  # overflow protection
+    ([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [1, sys.maxsize - 1], sys.maxsize - 1),  # near maxint
+    ([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [2, sys.maxsize // 2, sys.maxsize // 2], OverflowError),  # overflow protection
     ([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], OverflowError),  # overflow protection
     (range(3, 7), [3, 4, 5, 6], [3, 4, 5, 6], [3, 4, 5, 6], 360),  # range sequence type
     (tuple([3, 5, 7]), [3, 5, 7], [3, 5, 7], [3, 5, 7], 105),  # tuple sequence type
@@ -64,8 +64,5 @@ def test_oopsieKwargsie() -> None:
     for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
         testFunction()
 
-def test_countFolds_invalid_computationDivisions() -> None:
-    standardComparison(ValueError, countFolds, [2, 2], {"wrong": "value"})
-
 def test_parseListDimensions_noDimensions() -> None:
     standardComparison(ValueError, parseDimensions, [])

tests/test_tasks.py

@@ -4,15 +4,18 @@ from typing import List, Dict, Tuple
 
 # TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
 
-def test_foldings_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
-    standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, True)
+def test_countFolds_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
+    standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')
 
 def test_defineConcurrencyLimit() -> None:
     testSuite = makeTestSuiteConcurrencyLimit(defineConcurrencyLimit)
     for testName, testFunction in testSuite.items():
         testFunction()
 
-@pytest.mark.parametrize("cpuLimitValue", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(cpuLimitValue: Dict[str, bool] | List[str]) -> None:
+@pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
+def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
     # This forces CPUlimit = oopsieKwargsie(cpuLimitValue).
-    standardComparison(ValueError, countFolds, [2, 2], True, cpuLimitValue)
+    standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
+
+def test_countFolds_invalid_computationDivisions(listDimensionsTestFunctionality: List[int]) -> None:
+    standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})