mapFolding 0.2.6__py3-none-any.whl → 0.3.0__py3-none-any.whl

mapFolding/beDRY.py

@@ -1,319 +0,0 @@
-"""A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge, dtypeSmall, pathJobDEFAULT
-from mapFolding import indexMy, indexTrack, computationState
-from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, List, Optional, Sequence, Type, Union
-import numba
-import numpy
-import os
-import pathlib
-import sys
-
-def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
-    return str(sorted(listDimensions)).replace(', ', 'x').replace('[', 'p').replace(']', '') + '.foldsTotal'
-
-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 getPathFilenameFoldsTotal(listDimensions: Sequence[int], pathishWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
-    pathFilenameFoldsTotal = pathlib.Path(pathishWriteFoldsTotal) if pathishWriteFoldsTotal is not None else pathJobDEFAULT
-    if pathFilenameFoldsTotal.is_dir():
-        filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(listDimensions)
-        pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
-    pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-    return pathFilenameFoldsTotal
-
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
-    """
-    Determines whether or how to divide the computation into tasks.
-
-    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
-    listDimensions: for error reporting
-    CPUlimit: for error reporting
-
-    Returns
-    -------
-    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:
-        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(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
-
-    if taskDivisions > leavesTotal:
-        raise ValueError(f"Problem: `taskDivisions`, ({taskDivisions}), is greater than `leavesTotal`, ({leavesTotal}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.\n\nFor those parameters, I received {computationDivisions=}, {CPUlimit=}, and {listDimensions=}.\n\nPotential solutions: get a different hobby or set `computationDivisions` to a different value.")
-
-    return taskDivisions
-
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
-    """
-    Constructs a multi-dimensional connection graph representing the connections between the leaves of a map with the given dimensions.
-    Also called a Cartesian product decomposition or dimensional product mapping.
-
-    Parameters
-        listDimensions: A sequence of integers representing the dimensions of the map.
-
-    Returns
-        connectionGraph: A 3D numpy array with shape of (dimensionsTotal, leavesTotal + 1, leavesTotal + 1).
-    """
-    datatype = keywordArguments.get('datatype', dtypeDefault)
-    mapShape = validateListDimensions(listDimensions)
-    leavesTotal = getLeavesTotal(mapShape)
-    arrayDimensions = numpy.array(mapShape, dtype=datatype)
-    dimensionsTotal = len(arrayDimensions)
-
-    # Step 1: find the cumulative product of the map's dimensions
-    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
-
-    # Step 2: create a coordinate system
-    coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=datatype)
-
-    for indexDimension in range(dimensionsTotal):
-        for leaf1ndex in range(1, leavesTotal + 1):
-            coordinateSystem[indexDimension, leaf1ndex] = (
-                ((leaf1ndex - 1) // cumulativeProduct[indexDimension]) %
-                arrayDimensions[indexDimension] + 1
-            )
-
-    # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
-
-    for indexDimension in range(dimensionsTotal):
-        for activeLeaf1ndex in range(1, leavesTotal + 1):
-            for connectee1ndex in range(1, activeLeaf1ndex + 1):
-                # Base coordinate conditions
-                isFirstCoord = coordinateSystem[indexDimension, connectee1ndex] == 1
-                isLastCoord = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
-                exceedsActive = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
-
-                # Parity check
-                isEvenParity = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == \
-                                (coordinateSystem[indexDimension, connectee1ndex] & 1)
-
-                # Determine connection value
-                if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
-                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex
-                elif isEvenParity and not isFirstCoord:
-                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[indexDimension]
-                elif not isEvenParity and not (isLastCoord or exceedsActive):
-                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[indexDimension]
-
-    return connectionGraph
-
-def makeDataContainer(shape, datatype: Optional[Type] = None):
-    """Create a container, probably numpy.ndarray, with the given shape and datatype."""
-    if datatype is None:
-        datatype = dtypeDefault
-    return numpy.zeros(shape, dtype=datatype)
-
-def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type[Any]]) -> 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 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):
-        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
-        - 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)
-    datatypeSmall = keywordArguments.get('datatypeSmall', dtypeSmall)
-
-    my = makeDataContainer(len(indexMy), datatypeDefault)
-
-    mapShape = tuple(sorted(validateListDimensions(listDimensions)))
-    concurrencyLimit = setCPUlimit(CPUlimit)
-    my[indexMy.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, mapShape)
-
-    foldGroups = makeDataContainer(max(my[indexMy.taskDivisions] + 1, 2), datatypeLarge)
-    foldGroups[-1] = leavesTotal = getLeavesTotal(mapShape)
-
-    my[indexMy.dimensionsTotal] = len(mapShape)
-    my[indexMy.leaf1ndex] = 1
-    stateInitialized = computationState(
-        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeSmall),
-        foldGroups = foldGroups,
-        mapShape = mapShape,
-        my = my,
-        gapsWhere = makeDataContainer(int(leavesTotal) * int(leavesTotal) + 1, datatypeSmall),
-        track = makeDataContainer((len(indexTrack), leavesTotal + 1), datatypeDefault)
-        )
-
-
-    return stateInitialized
-
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> List[int]:
-    """
-    Parse and validate dimensions are non-negative integers.
-
-    Parameters:
-        dimensions: Sequence of integers representing dimensions
-        parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'
-    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)
-
-    return listNonNegative
-
-def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int) -> None:
-    """
-    Save foldsTotal with multiple fallback mechanisms.
-
-    Parameters:
-        pathFilename: Target save location
-        foldsTotal: Critical computed value to save
-    """
-    try:
-        pathFilenameFoldsTotal = pathlib.Path(pathFilename)
-        pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-        pathFilenameFoldsTotal.write_text(str(foldsTotal))
-    except Exception as ERRORmessage:
-        try:
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-            print(ERRORmessage)
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-            randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
-            filenameInfixUnique = ''.join(randomnessPlanB)
-            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
-            writeStreamFallback = open(pathFilenamePlanB, 'w')
-            writeStreamFallback.write(str(foldsTotal))
-            writeStreamFallback.close()
-            print(str(pathFilenamePlanB))
-        except:
-            print(foldsTotal)
-
-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: 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)
-    numba.set_num_threads(concurrencyLimit)
-
-    return concurrencyLimit
-
-def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
-    """
-    Validates and sorts a sequence of at least two positive dimensions.
-
-    Parameters:
-        listDimensions: A sequence of integer dimensions to be validated.
-
-    Returns:
-        dimensionsValidSorted: 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')
-    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/importSelector.py

@@ -1,7 +0,0 @@
-from mapFolding.lovelace import countSequential
-from mapFolding.lovelace import countParallel
-from mapFolding.lovelace import countInitialize
-
-# from mapFolding.someAssemblyRequired.countSequential import countSequential
-# from mapFolding.someAssemblyRequired.countParallel import countParallel
-# from mapFolding.someAssemblyRequired.countInitialize import countInitialize

mapFolding/lovelace.py

@@ -1,213 +0,0 @@
-from mapFolding import indexMy, indexTrack
-import numba
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def activeGapIncrement(my):
-    my[indexMy.gap1ndex.value] += 1
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def activeLeafGreaterThan0Condition(my):
-    return my[indexMy.leaf1ndex.value] > 0
-
-@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def activeLeafGreaterThanLeavesTotalCondition(foldGroups, my):
-    return my[indexMy.leaf1ndex.value] > foldGroups[-1] # leavesTotal
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def activeLeafIsTheFirstLeafCondition(my):
-    return my[indexMy.leaf1ndex.value] <= 1
-
-@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def allDimensionsAreUnconstrained(my):
-    return my[indexMy.dimensionsUnconstrained.value] == my[indexMy.dimensionsTotal.value]
-
-@numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def backtrack(my, track):
-    my[indexMy.leaf1ndex.value] -= 1
-    track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
-    track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
-
-@numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def backtrackCondition(my, track):
-    return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def gap1ndexCeilingIncrement(my):
-    my[indexMy.gap1ndexCeiling.value] += 1
-
-@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countGaps(gapsWhere, my, track):
-    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-        gap1ndexCeilingIncrement(my=my)
-    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def dimension1ndexIncrement(my):
-    my[indexMy.indexDimension.value] += 1
-
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def dimensionsUnconstrainedCondition(connectionGraph, my):
-    return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def dimensionsUnconstrainedIncrement(my):
-    my[indexMy.dimensionsUnconstrained.value] += 1
-
-@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def filterCommonGaps(gapsWhere, my, track):
-    gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-    if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsTotal.value] - my[indexMy.dimensionsUnconstrained.value]:
-        activeGapIncrement(my=my)
-    track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-
-@numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def findGapsInitializeVariables(my, track):
-    my[indexMy.dimensionsUnconstrained.value] = 0
-    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-    my[indexMy.indexDimension.value] = 0
-
-@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def foldsSubTotalIncrement(foldGroups, my):
-    foldGroups[my[indexMy.taskIndex.value]] += 1
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def indexMiniGapIncrement(my):
-    my[indexMy.indexMiniGap.value] += 1
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def indexMiniGapInitialization(my):
-    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-
-@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def insertUnconstrainedLeaf(gapsWhere, my):
-    my[indexMy.indexLeaf.value] = 0
-    while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
-        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
-        my[indexMy.gap1ndexCeiling.value] += 1
-        my[indexMy.indexLeaf.value] += 1
-
-@numba.jit((numba.int64[:,::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def leafBelowSentinelIs1Condition(track):
-    return track[indexTrack.leafBelow.value, 0] == 1
-
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def leafConnecteeInitialization(connectionGraph, my):
-    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def leafConnecteeUpdate(connectionGraph, my, track):
-    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def loopingLeavesConnectedToActiveLeaf(my):
-    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
-
-@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def loopingTheDimensions(my):
-    return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def loopingToActiveGapCeiling(my):
-    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
-
-@numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def placeLeaf(gapsWhere, my, track):
-    my[indexMy.gap1ndex.value] -= 1
-    track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-    track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-    track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-    track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-    track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-    my[indexMy.leaf1ndex.value] += 1
-
-@numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def placeLeafCondition(my):
-    return my[indexMy.leaf1ndex.value] > 0
-
-@numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def thereAreComputationDivisionsYouMightSkip(my):
-    return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
-
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countInitialize(connectionGraph, gapsWhere, my, track):
-    while activeLeafGreaterThan0Condition(my=my):
-        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-            findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
-                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):
-                insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
-            indexMiniGapInitialization(my=my)
-            while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-                indexMiniGapIncrement(my=my)
-        if placeLeafCondition(my=my):
-            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-        if my[indexMy.gap1ndex.value] > 0:
-            return
-
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countSequential(connectionGraph, foldGroups, gapsWhere, my, track):
-    while activeLeafGreaterThan0Condition(my=my):
-        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-            if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
-                foldsSubTotalIncrement(foldGroups=foldGroups, my=my)
-            else:
-                findGapsInitializeVariables(my=my, track=track)
-                while loopingTheDimensions(my=my):
-                    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, track=track)
-                    indexMiniGapIncrement(my=my)
-        while backtrackCondition(my=my, track=track):
-            backtrack(my=my, track=track)
-        if placeLeafCondition(my=my):
-            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
-
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=True, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countParallel(connectionGraph, foldGroups, gapsWherePARALLEL, myPARALLEL, trackPARALLEL):
-    for indexSherpa in numba.prange(myPARALLEL[indexMy.taskDivisions.value]):
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
-        track = trackPARALLEL.copy()
-        while activeLeafGreaterThan0Condition(my=my):
-            if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-                if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
-                    foldsSubTotalIncrement(foldGroups=foldGroups, my=my)
-                else:
-                    findGapsInitializeVariables(my=my, track=track)
-                    while loopingTheDimensions(my=my):
-                        if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-                            dimensionsUnconstrainedIncrement(my=my)
-                        else:
-                            leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
-                            while loopingLeavesConnectedToActiveLeaf(my=my):
-                                if thereAreComputationDivisionsYouMightSkip(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, 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)