mapFolding 0.2.0__py3-none-any.whl

mapFolding/beDRY.py

@@ -0,0 +1,219 @@
+"""A relatively stable API for oft-needed functionality."""
+from mapFolding.importPackages import intInnit, defineConcurrencyLimit, oopsieKwargsie
+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
+import sys
+
+def getLeavesTotal(listDimensions: Sequence[int]) -> int:
+    """
+    Calculate the product of non-zero, non-negative integers in the given list.
+
+    Parameters:
+        listDimensions: A list of integers representing dimensions.
+
+    Returns:
+        productDimensions: The product of all positive integer dimensions. Returns 0 if all dimensions are 0.
+    """
+    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("Product would exceed maximum integer size")
+            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"
+
+    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
+    elif isinstance(computationDivisions, str):
+        computationDivisions = computationDivisions.lower()
+        if computationDivisions == "maximum":
+            the[indexThe.taskDivisions] = the[indexThe.leavesTotal]
+        elif computationDivisions == "cpu":
+            the[indexThe.taskDivisions] = min(concurrencyLimit, the[indexThe.leavesTotal])
+    else:
+        raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
+
+    if the[indexThe.taskDivisions] > the[indexThe.leavesTotal]:
+        raise ValueError(f"Problem: `taskDivisions`, ({the[indexThe.taskDivisions]}), is greater than `leavesTotal`, ({the[indexThe.leavesTotal]}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.\n\nFor those parameters, I received {computationDivisions=}, {CPUlimit=}, and {listDimensions=}.\n\nPotential solutions: get a different hobby or set `computationDivisions` to a different value.")
+
+    return the
+
+def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = numpy.int64) -> numpy.typing.NDArray[numpy.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.
+
+    Parameters:
+        listDimensions: A validated 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)
+    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]
+
+    # Step 2: create a coordinate system
+    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtype)
+
+    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
+            )
+
+    # Step 3: create and fill the connection graph
+    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
+
+    for dimension1ndex in range(1, dimensionsTotal + 1):
+        for activeLeaf1ndex in range(1, leavesTotal + 1):
+            for connectee1ndex in range(1, activeLeaf1ndex + 1):
+                # Base coordinate conditions
+                isFirstCoord = coordinateSystem[dimension1ndex, connectee1ndex] == 1
+                isLastCoord = coordinateSystem[dimension1ndex, connectee1ndex] == arrayDimensions[dimension1ndex - 1]
+                exceedsActive = connectee1ndex + cumulativeProduct[dimension1ndex - 1] > activeLeaf1ndex
+
+                # Parity check
+                isEvenParity = (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == \
+                                (coordinateSystem[dimension1ndex, connectee1ndex] & 1)
+
+                # Determine connection value
+                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 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:
+    the = numpy.zeros(len(indexThe), dtype=dtypeDefault)
+
+    mapShape = tuple(sorted(validateListDimensions(listDimensions)))
+    the[indexThe.leavesTotal] = getLeavesTotal(mapShape)
+    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,
+        track = numpy.zeros((len(indexTrack), the[indexThe.leavesTotal] + 1), dtype=dtypeLarge)
+        )
+
+    stateInitialized['my'][indexMy.leaf1ndex.value] = 1
+
+    return stateInitialized
+
+def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
+    """
+    Parse and validate a list of dimensions.
+
+    Parameters:
+        listDimensions: List 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
+    Raises:
+        ValueError: If any dimension is negative or if the list is empty
+        TypeError: If any element cannot be converted to integer (raised by intInnit)
+    """
+    listValidated = intInnit(dimensions, parameterName)
+    listNonNegative = []
+    for dimension in listValidated:
+        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[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.
+    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
+    Returns:
+        concurrencyLimit: The actual concurrency limit that was set
+    Raises:
+        TypeError: If CPUlimit is not of the expected types
+    """
+    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.
+
+    Parameters:
+        listDimensions: A list of integer dimensions to be validated.
+
+    Returns:
+        validDimensions: A list, with at least two elements, of only positive integers.
+
+    Raises:
+        ValueError: If the input listDimensions is None.
+        NotImplementedError: If the resulting list of positive dimensions has fewer than two elements.
+    """
+    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:
+        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

mapFolding/benchmarks/benchmarking.py

@@ -0,0 +1,66 @@
+import multiprocessing
+from typing import Callable
+import numpy
+import pathlib
+import time
+
+pathRecordedBenchmarks = pathlib.Path('mapFolding/benchmarks/marks')
+pathRecordedBenchmarks.mkdir(parents=True, exist_ok=True)
+pathFilenameRecordedBenchmarks = pathRecordedBenchmarks / "benchmarks.npy"
+
+def recordBenchmarks():
+    """Decorator to benchmark a function."""
+    def AzeemTheWrapper(functionTarget: Callable):
+        def djZeph(*arguments, **keywordArguments):
+            timeStart = time.perf_counter_ns()
+            returnValueTarget = functionTarget(*arguments, **keywordArguments)
+            timeElapsed = (time.perf_counter_ns() - timeStart) / 1e9
+
+            # Extract mapShape from arguments
+            mapShape = keywordArguments['mapShape']
+            # mapShape = tuple(arguments)[2]
+            # leavesTotal = tuple(arguments[3])[4]
+
+            # Store benchmark data in single file
+            benchmarkEntry = numpy.array([(timeElapsed, mapShape)], dtype=[('time', 'f8'), ('mapShape', 'O')])
+            # benchmarkEntry = numpy.array([(timeElapsed, leavesTotal)], dtype=[('time', 'f8'), ('leaves', 'O')])
+
+            if pathFilenameRecordedBenchmarks.exists():
+                arrayExisting = numpy.load(str(pathFilenameRecordedBenchmarks), allow_pickle=True)
+                arrayBenchmark = numpy.concatenate([arrayExisting, benchmarkEntry])
+            else:
+                arrayBenchmark = benchmarkEntry
+
+            numpy.save(str(pathFilenameRecordedBenchmarks), arrayBenchmark)
+            return returnValueTarget
+
+        return djZeph
+    return AzeemTheWrapper
+
+def runBenchmarks(benchmarkIterations: int = 30) -> None:
+    """Run benchmark iterations.
+
+    Parameters:
+        benchmarkIterations (30): Number of benchmark iterations to run
+    """
+    # TODO warmUp (False): Whether to perform one warm-up iteration
+
+    import itertools
+    from tqdm.auto import tqdm
+    from mapFolding.oeis import settingsOEIS, oeisIDfor_n
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+    max_workers = 6
+
+    listParametersOEIS = [(oeisIdentifier, dimensionValue) for oeisIdentifier, settings in settingsOEIS.items() for dimensionValue in settings['valuesBenchmark']]
+    # for (oeisIdentifier, dimensionValue), iterationIndex in tqdm(itertools.product(listParametersOEIS, range(benchmarkIterations)), total=len(listParametersOEIS) * benchmarkIterations):
+    #     oeisIDfor_n(oeisIdentifier, dimensionValue)
+    listCartesianProduct = list(itertools.product(listParametersOEIS, range(benchmarkIterations)))
+    with ProcessPoolExecutor(max_workers) as concurrencyManager:
+        listConcurrency = [concurrencyManager.submit(oeisIDfor_n, *parameters[0]) for parameters in listCartesianProduct]
+        for complete in tqdm(as_completed(listConcurrency), total=len(listCartesianProduct)):
+            pass
+
+if __name__ == '__main__':
+    multiprocessing.set_start_method('spawn')
+    pathFilenameRecordedBenchmarks.unlink(missing_ok=True)
+    runBenchmarks(30)

mapFolding/benchmarks/test_benchmarks.py

@@ -0,0 +1,74 @@
+from ...tests.conftest import *
+from .benchmarking import recordBenchmarks, runBenchmarks
+import numpy
+import pathlib
+import pytest
+import unittest.mock
+from typing import List
+
+def test_recordBenchmarks_decorator(pathBenchmarksTesting: pathlib.Path,
+                                    listDimensionsTestFunctionality: List[int],
+                                    mockBenchmarkTimer: unittest.mock.MagicMock):
+    """Test that the decorator correctly records benchmark data."""
+    @recordBenchmarks()
+    def functionTest(listDimensions: List[int]) -> int:
+        return sum(listDimensions)
+
+    with mockBenchmarkTimer:
+        mockBenchmarkTimer.side_effect = [0, 1e9]
+        result = functionTest(listDimensionsTestFunctionality)
+
+    # Verify function still works normally
+    assert result == sum(listDimensionsTestFunctionality)
+
+    # Verify benchmark data was saved
+    arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
+    assert len(arrayBenchmarks) == 1
+    assert arrayBenchmarks[0]['time'] == 1.0
+    assert tuple(arrayBenchmarks[0]['dimensions']) == tuple(listDimensionsTestFunctionality)
+
+def test_recordBenchmarks_multiple_calls(pathBenchmarksTesting: pathlib.Path,
+                                        listDimensionsTestFunctionality: List[int],
+                                        mockBenchmarkTimer: unittest.mock.MagicMock):
+    """Test that multiple function calls append to benchmark data."""
+    @recordBenchmarks()
+    def functionTest(listDimensions: List[int]) -> int:
+        return sum(listDimensions)
+
+    with mockBenchmarkTimer:
+        mockBenchmarkTimer.side_effect = [0, 1e9, 2e9, 4e9]
+        functionTest(listDimensionsTestFunctionality)
+        functionTest(listDimensionsTestFunctionality)
+
+    arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
+    assert len(arrayBenchmarks) == 2
+    assert arrayBenchmarks[0]['time'] == 1.0
+    assert arrayBenchmarks[1]['time'] == 2.0
+
+# NOTE This test tries to collect benchmark data without ensuring that a function is decorated.
+# def test_runBenchmarks_integration(pathBenchmarksTesting: pathlib.Path, listDimensionsTestFunctionality: List[int]):
+#     """Test runBenchmarks creates valid benchmark data."""
+#     countIterations = 2
+#     runBenchmarks(countIterations)
+
+#     arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
+#     assert len(arrayBenchmarks) > 0  # Should have recorded some benchmarks
+
+#     # Verify data structure integrity
+#     assert arrayBenchmarks.dtype.names == ('time', 'dimensions')
+#     assert all(isinstance(record['time'], float) for record in arrayBenchmarks)
+#     assert all(isinstance(record['dimensions'], tuple) for record in arrayBenchmarks)
+
+#     # Verify at least one benchmark entry matches our test dimensions
+#     assert any(tuple(listDimensionsTestFunctionality) == record['dimensions'] for record in arrayBenchmarks)
+
+# NOTE This test tries to collect benchmark data without ensuring that a function is decorated.
+# @pytest.mark.parametrize("countIterations", [1, 2])
+# def test_runBenchmarks_iterations(countIterations: int, pathBenchmarksTesting: pathlib.Path, listDimensionsTestFunctionality: List[int]):
+#     """Test runBenchmarks records data for each iteration."""
+#     runBenchmarks(countIterations)
+#     arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
+
+#     # Should have at least countIterations entries for our test dimensions
+#     countMatches = sum(1 for record in arrayBenchmarks if tuple(listDimensionsTestFunctionality) == record['dimensions'])
+#     assert countMatches >= countIterations

mapFolding/importPackages.py

@@ -0,0 +1,5 @@
+"""Experiment"""
+from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie

mapFolding/lovelace.py

@@ -0,0 +1,121 @@
+from mapFolding import indexMy, indexThe, indexTrack
+from numpy import integer
+from numpy.typing import NDArray
+from typing import Any, 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]]):
+    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:
+        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:
+        return False
+    else:
+        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]], Z0Z_initializeUnconstrainedLeaf: Optional[bool] ):
+    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]
+            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
+                    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]:
+                            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
+                if insertUnconstrainedLeaf(my, the, Z0Z_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
+        if initializationConditionUnconstrainedLeaf(my, Z0Z_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]]):
+
+    stateFoldsSubTotal = foldsTotal.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(), Z0Z_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):
+    if obviousFlagForNumba:
+        foldsTotal, _1, _2, _3 = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, Z0Z_initializeUnconstrainedLeaf=False)
+    else:
+        foldsTotal = doTaskIndices(connectionGraph, foldsTotal, my, gapsWhere, the, track)
+
+    return foldsTotal
+
+@numba.jit(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
+def countFoldsCompiled(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> int:
+
+    _0, my, gapsWhere, track = doWhile(connectionGraph, foldsTotal, my, gapsWhere, the, track, Z0Z_initializeUnconstrainedLeaf=True)
+
+    obviousFlagForNumba = the[indexThe.taskDivisions.value] == int(False)
+
+    foldsTotal = countFoldsCompileBranch(connectionGraph, foldsTotal, my, gapsWhere, the, track, obviousFlagForNumba)
+
+    return numpy.sum(foldsTotal).item()