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

mapFolding/oeis.py

@@ -65,6 +65,40 @@ settingsOEIShardcodedValues = {
 oeisIDsImplemented: Final[List[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
+def _validateOEISid(oeisIDcandidate: str):
+    """
+    Validates an OEIS sequence ID against implemented sequences.
+
+    If the provided ID is recognized within the application's implemented
+    OEIS sequences, the function returns the verified ID in uppercase.
+    Otherwise, a KeyError is raised indicating that the sequence is not
+    directly supported.
+
+    Parameters:
+        oeisIDcandidate: The OEIS sequence identifier to validate.
+
+    Returns:
+        oeisID: The validated and possibly modified OEIS sequence ID, if recognized.
+
+    Raises:
+        KeyError: If the provided sequence ID is not directly implemented.
+    """
+    if oeisIDcandidate in oeisIDsImplemented:
+        return oeisIDcandidate
+    else:
+        oeisIDcleaned = str(oeisIDcandidate).upper().strip()
+        if oeisIDcleaned in oeisIDsImplemented:
+            return oeisIDcleaned
+        else:
+            raise KeyError(
+                f"OEIS ID {oeisIDcandidate} is not directly implemented.\n"
+                f"Available sequences:\n{_formatOEISsequenceInfo()}"
+            )
+
+def _getFilenameOEISbFile(oeisID: str) -> str:
+    oeisID = _validateOEISid(oeisID)
+    return f"b{oeisID[1:]}.txt"
+
 def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
     """
     Parses the content of an OEIS b-file for a given sequence ID.
@@ -101,8 +135,6 @@ try:
 except NameError:
     _pathCache = pathlib.Path.home() / ".mapFoldingCache"
 
-_formatFilenameCache = "{oeisID}.txt"
-
 def _getOEISidValues(oeisID: str) -> Dict[int, int]:
     """
     Retrieves the specified OEIS sequence as a dictionary mapping integer indices
@@ -122,7 +154,7 @@ def _getOEISidValues(oeisID: str) -> Dict[int, int]:
         IOError: If there is an error reading from or writing to the local cache.
     """
 
-    pathFilenameCache = _pathCache / _formatFilenameCache.format(oeisID=oeisID)
+    pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
     cacheDays = 7
 
     tryCache = False
@@ -137,7 +169,7 @@ def _getOEISidValues(oeisID: str) -> Dict[int, int]:
         except (ValueError, IOError):
             tryCache = False
 
-    urlOEISbFile = f"https://oeis.org/{oeisID}/b{oeisID[1:]}.txt"
+    urlOEISbFile = f"https://oeis.org/{oeisID}/{_getFilenameOEISbFile(oeisID)}"
     httpResponse: urllib.response.addinfourl = urllib.request.urlopen(urlOEISbFile)
     OEISbFile = httpResponse.read().decode('utf-8')
 
@@ -212,36 +244,6 @@ def _formatOEISsequenceInfo() -> str:
         for oeisID in oeisIDsImplemented
     )
 
-def _validateOEISid(oeisIDcandidate: str):
-    """
-    Validates an OEIS sequence ID against implemented sequences.
-
-    If the provided ID is recognized within the application's implemented
-    OEIS sequences, the function returns the verified ID in uppercase.
-    Otherwise, a KeyError is raised indicating that the sequence is not
-    directly supported.
-
-    Parameters:
-        oeisIDcandidate: The OEIS sequence identifier to validate.
-
-    Returns:
-        oeisID: The validated and possibly modified OEIS sequence ID, if recognized.
-
-    Raises:
-        KeyError: If the provided sequence ID is not directly implemented.
-    """
-    if oeisIDcandidate in oeisIDsImplemented:
-        return oeisIDcandidate
-    else:
-        oeisIDcleaned = str(oeisIDcandidate).upper().strip()
-        if oeisIDcleaned in oeisIDsImplemented:
-            return oeisIDcleaned
-        else:
-            raise KeyError(
-                f"OEIS ID {oeisIDcandidate} is not directly implemented.\n"
-                f"Available sequences:\n{_formatOEISsequenceInfo()}"
-            )
-
 """
 Section: public functions"""
 
@@ -308,7 +310,7 @@ def clearOEIScache() -> None:
         return
     else:
         for oeisID in settingsOEIS:
-            pathFilenameCache = _pathCache / _formatFilenameCache.format(oeisID=oeisID)
+            pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
             pathFilenameCache.unlink(missing_ok=True)
 
     print(f"Cache cleared from {_pathCache}")

mapFolding/reference/flattened.py

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

mapFolding/reference/hunterNumba.py

@@ -46,15 +46,15 @@ def countFolds(listDimensions: List[int]) -> int:
 
     """Step for... for... for...: fill the connection graph"""
     for dimension1ndex in range(1, dimensionsTotal + 1):
-        for activeLeaf1ndex in range(1, leavesTotal + 1):
-            for leaf1ndexConnectee in range(1, activeLeaf1ndex + 1):
-                connectionGraph[dimension1ndex, activeLeaf1ndex, leaf1ndexConnectee] = (0 if leaf1ndexConnectee == 0
-                                else ((leaf1ndexConnectee if coordinateSystem[dimension1ndex, leaf1ndexConnectee] == 1
-                                            else leaf1ndexConnectee - cumulativeProduct[dimension1ndex - 1])
-                                    if (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == (coordinateSystem[dimension1ndex, leaf1ndexConnectee] & 1)
-                                    else (leaf1ndexConnectee if coordinateSystem[dimension1ndex, leaf1ndexConnectee] == listDimensions[dimension1ndex-1]
-                                            or leaf1ndexConnectee + cumulativeProduct[dimension1ndex - 1] > activeLeaf1ndex
-                                            else leaf1ndexConnectee + cumulativeProduct[dimension1ndex - 1])))
+        for leaf1ndex in range(1, leavesTotal + 1):
+            for leafConnectee in range(1, leaf1ndex + 1):
+                connectionGraph[dimension1ndex, leaf1ndex, leafConnectee] = (0 if leafConnectee == 0
+                                else ((leafConnectee if coordinateSystem[dimension1ndex, leafConnectee] == 1
+                                            else leafConnectee - cumulativeProduct[dimension1ndex - 1])
+                                    if (coordinateSystem[dimension1ndex, leaf1ndex] & 1) == (coordinateSystem[dimension1ndex, leafConnectee] & 1)
+                                    else (leafConnectee if coordinateSystem[dimension1ndex, leafConnectee] == listDimensions[dimension1ndex-1]
+                                            or leafConnectee + cumulativeProduct[dimension1ndex - 1] > leaf1ndex
+                                            else leafConnectee + cumulativeProduct[dimension1ndex - 1])))
 
     """Indices of array `track` (to "track" the execution state), which is a collection of one-dimensional arrays each of length `leavesTotal + 1`."""
     leafAbove = numba.literally(0)
@@ -66,67 +66,67 @@ def countFolds(listDimensions: List[int]) -> int:
     gapsWhere = numpy.zeros(integerLarge(integerLarge(leavesTotal) * integerLarge(leavesTotal) + 1), dtype=dtypeMaximum)
 
     foldsTotal = integerLarge(0)
-    activeLeaf1ndex = integerSmall(1)
-    activeGap1ndex = integerSmall(0)
+    leaf1ndex = integerSmall(1)
+    gap1ndex = integerSmall(0)
 
-    while activeLeaf1ndex > 0:
-        if activeLeaf1ndex <= 1 or track[leafBelow, 0] == 1:
-            if activeLeaf1ndex > leavesTotal:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or track[leafBelow, 0] == 1:
+            if leaf1ndex > leavesTotal:
                 foldsTotal += leavesTotal
             else:
                 dimensionsUnconstrained = integerSmall(0)
-                """Track possible gaps for activeLeaf1ndex in each section"""
-                gap1ndexCeiling = track[gapRangeStart, activeLeaf1ndex - 1]
+                """Track possible gaps for leaf1ndex in each section"""
+                gap1ndexCeiling = track[gapRangeStart, leaf1ndex - 1]
 
-                """Count possible gaps for activeLeaf1ndex in each section"""
+                """Count possible gaps for leaf1ndex in each section"""
                 dimension1ndex = integerSmall(1)
                 while dimension1ndex <= dimensionsTotal:
-                    if connectionGraph[dimension1ndex, activeLeaf1ndex, activeLeaf1ndex] == activeLeaf1ndex:
+                    if connectionGraph[dimension1ndex, leaf1ndex, leaf1ndex] == leaf1ndex:
                         dimensionsUnconstrained += 1
                     else:
-                        leaf1ndexConnectee = connectionGraph[dimension1ndex, activeLeaf1ndex, activeLeaf1ndex]
-                        while leaf1ndexConnectee != activeLeaf1ndex:
-                            gapsWhere[gap1ndexCeiling] = leaf1ndexConnectee
-                            if track[countDimensionsGapped, leaf1ndexConnectee] == 0:
+                        leafConnectee = connectionGraph[dimension1ndex, leaf1ndex, leaf1ndex]
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if track[countDimensionsGapped, leafConnectee] == 0:
                                 gap1ndexCeiling += 1
-                            track[countDimensionsGapped, leaf1ndexConnectee] += 1
-                            leaf1ndexConnectee = connectionGraph[dimension1ndex, activeLeaf1ndex, track[leafBelow, leaf1ndexConnectee]]
+                            track[countDimensionsGapped, leafConnectee] += 1
+                            leafConnectee = connectionGraph[dimension1ndex, leaf1ndex, track[leafBelow, leafConnectee]]
                     dimension1ndex += 1
 
-                """If activeLeaf1ndex is unconstrained in all sections, it can be inserted anywhere"""
+                """If leaf1ndex is unconstrained in all sections, it can be inserted anywhere"""
                 if dimensionsUnconstrained == dimensionsTotal:
-                    leaf1ndex = integerSmall(0)
-                    while leaf1ndex < activeLeaf1ndex:
-                        gapsWhere[gap1ndexCeiling] = leaf1ndex
+                    indexLeaf = integerSmall(0)
+                    while indexLeaf < leaf1ndex:
+                        gapsWhere[gap1ndexCeiling] = indexLeaf
                         gap1ndexCeiling += 1
-                        leaf1ndex += 1
+                        indexLeaf += 1
 
                 """Filter gaps that are common to all sections"""
-                indexMiniGap = activeGap1ndex
+                indexMiniGap = gap1ndex
                 while indexMiniGap < gap1ndexCeiling:
-                    gapsWhere[activeGap1ndex] = gapsWhere[indexMiniGap]
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
                     if track[countDimensionsGapped, gapsWhere[indexMiniGap]] == dimensionsTotal - dimensionsUnconstrained:
-                        activeGap1ndex += 1
+                        gap1ndex += 1
                     """Reset track[countDimensionsGapped] for next iteration"""
                     track[countDimensionsGapped, gapsWhere[indexMiniGap]] = 0
                     indexMiniGap += 1
 
         """Recursive backtracking steps"""
-        while activeLeaf1ndex > 0 and activeGap1ndex == track[gapRangeStart, activeLeaf1ndex - 1]:
-            activeLeaf1ndex -= 1
-            track[leafBelow, track[leafAbove, activeLeaf1ndex]] = track[leafBelow, activeLeaf1ndex]
-            track[leafAbove, track[leafBelow, activeLeaf1ndex]] = track[leafAbove, activeLeaf1ndex]
+        while leaf1ndex > 0 and gap1ndex == track[gapRangeStart, leaf1ndex - 1]:
+            leaf1ndex -= 1
+            track[leafBelow, track[leafAbove, leaf1ndex]] = track[leafBelow, leaf1ndex]
+            track[leafAbove, track[leafBelow, leaf1ndex]] = track[leafAbove, leaf1ndex]
 
         """Place leaf in valid position"""
-        if activeLeaf1ndex > 0:
-            activeGap1ndex -= 1
-            track[leafAbove, activeLeaf1ndex] = gapsWhere[activeGap1ndex]
-            track[leafBelow, activeLeaf1ndex] = track[leafBelow, track[leafAbove, activeLeaf1ndex]]
-            track[leafBelow, track[leafAbove, activeLeaf1ndex]] = activeLeaf1ndex
-            track[leafAbove, track[leafBelow, activeLeaf1ndex]] = activeLeaf1ndex
+        if leaf1ndex > 0:
+            gap1ndex -= 1
+            track[leafAbove, leaf1ndex] = gapsWhere[gap1ndex]
+            track[leafBelow, leaf1ndex] = track[leafBelow, track[leafAbove, leaf1ndex]]
+            track[leafBelow, track[leafAbove, leaf1ndex]] = leaf1ndex
+            track[leafAbove, track[leafBelow, leaf1ndex]] = leaf1ndex
             """Save current gap index"""
-            track[gapRangeStart, activeLeaf1ndex] = activeGap1ndex
+            track[gapRangeStart, leaf1ndex] = gap1ndex
             """Move to next leaf"""
-            activeLeaf1ndex += 1
+            leaf1ndex += 1
 
     return int(foldsTotal)

mapFolding/reference/lunnan.py

@@ -9,11 +9,11 @@ def foldings(p, job=None):
     p.insert(0, None)  # NOTE mimics Atlas `array` type
 
     if job is None:
-        global f
-        f = 0
+        global G
+        G = 0
         def job(A, B):
-            global f
-            f = f + 1
+            global G
+            G = G + 1
         return foldings(p, job)
     # perform job (A, B) on each folding of a p[1] x ... x p[d] map,
     # where A and B are the above and below vectors. p[d + 1] < 0 terminates p;
@@ -150,4 +150,4 @@ def foldings(p, job=None):
             else:
                 break
 
-    return f #if job.__closure__ else None
+    return G #if job.__closure__ else None

mapFolding/reference/lunnanNumpy.py

@@ -13,7 +13,7 @@ def foldings(p: List[int]) -> int:
         p: A list of integers representing the dimensions of the map.
 
     Returns:
-        f: The number of distinct foldings for the given map dimensions.
+        G: The number of distinct foldings for the given map dimensions.
 
     NOTE If there are fewer than two dimensions, any dimensions are not positive, or any dimensions are not integers, the output will be unreliable.
     """
@@ -65,14 +65,14 @@ def foldings(p: List[int]) -> int:
     # P[i] = p[1] x ... x p[i], C[i][m] = i-th co-ordinate of leaf m,
     # D[i][l][m] = leaf connected to m in section i when inserting l;
 
-    f: int = 0
+    G: int = 0
     l: int = 1
 
     # kick off with null folding
     while l > 0:
         if l <= 1 or B[0] == 1: # NOTE This statement is part of a significant divergence from the 1971 paper. As a result, this version is greater than one order of magnitude faster.
             if l > n:
-                f = f + n # NOTE Due to `B[0] == 1`, this implementation increments the counted foldings in batches of `n`-many foldings, rather than immediately incrementing when a folding is found, i.e. `f = f + 1`
+                G = G + n # NOTE Due to `B[0] == 1`, this implementation increments the counted foldings in batches of `n`-many foldings, rather than immediately incrementing when a folding is found, i.e. `G = G + 1`
             else:
                 dd: int = 0
                 gg: int = gapter[l - 1]
@@ -120,4 +120,4 @@ def foldings(p: List[int]) -> int:
             A[B[l]] = l
             gapter[l] = g
             l = l + 1
-    return f
+    return G