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

mapFolding/__init__.py

@@ -1,4 +1,5 @@
 from .theSSOT import *
+from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 from .beDRY import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
 from .beDRY import getLeavesTotal, parseDimensions, validateListDimensions
 from .startHere import countFolds

mapFolding/beDRY.py

@@ -1,12 +1,14 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding.importPackages import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
 from mapFolding import indexMy, indexThe, indexTrack, computationState
+from mapFolding import dtypeDefault, dtypeLarge, dtypeSmall
 from typing import Any, List, Optional, Sequence, Type, Union
 import numpy
 import numba
 from numpy.typing import NDArray
 from numpy import integer
 import sys
+import operator
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -32,7 +34,7 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
         return productDimensions
 
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, the: NDArray[integer[Any]], CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
+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.
 
@@ -46,15 +48,12 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
         - "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
+    CPUlimit: for error reporting
 
     Returns
     -------
-    the
-        Updated settings, including for `taskDivisions`
+    taskDivisions:
 
     Raises
     ------
@@ -65,26 +64,27 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
     -----
     Task divisions cannot exceed total leaves to prevent duplicate counting of folds.
     """
-
     if not computationDivisions:
-        the[indexThe.taskDivisions] = 0
-    elif isinstance(computationDivisions, int):
-        the[indexThe.taskDivisions] = computationDivisions
+        return 0
+    else:
+        leavesTotal = getLeavesTotal(listDimensions)
+    if isinstance(computationDivisions, int):
+        taskDivisions = computationDivisions
     elif isinstance(computationDivisions, str):
         computationDivisions = computationDivisions.lower()
         if computationDivisions == "maximum":
-            the[indexThe.taskDivisions] = the[indexThe.leavesTotal]
+            taskDivisions = leavesTotal
         elif computationDivisions == "cpu":
-            the[indexThe.taskDivisions] = min(concurrencyLimit, the[indexThe.leavesTotal])
+            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 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.")
+    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 the
+    return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = numpy.int64) -> NDArray[integer[Any]]:
+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.
@@ -94,16 +94,17 @@ def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = n
     Returns:
         connectionGraph: A 3D numpy array with shape of (dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1).
     """
+    datatype = keywordArguments.get('datatype', dtypeDefault)
     mapShape = validateListDimensions(listDimensions)
     leavesTotal = getLeavesTotal(mapShape)
-    arrayDimensions = numpy.array(mapShape, dtype=dtype)
+    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=dtype)
+    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
 
     # Step 2: create a coordinate system
-    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtype)
+    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=datatype)
 
     for dimension1ndex in range(1, dimensionsTotal + 1):
         for leaf1ndex in range(1, leavesTotal + 1):
@@ -113,7 +114,7 @@ def makeConnectionGraph(listDimensions: Sequence[int], dtype: Optional[Type] = n
             )
 
     # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
+    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):
@@ -139,7 +140,13 @@ 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[bool, float, int]] = None, dtypeDefault: Optional[Type] = numpy.int64, dtypeLarge: Optional[Type] = numpy.int64, ) -> computationState:
+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 outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
     """
     Initializes and configures the computation state for map folding computations.
 
@@ -151,10 +158,6 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
         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
     -------
@@ -165,25 +168,28 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
         - mapShape: Validated and sorted dimensions of the map
         - my: Array for internal state tracking
         - gapsWhere: Array tracking gap positions
-        - the: Configured task divisions
+        - the: Static settings and metadata
         - track: Array for tracking computation progress
     """
+    datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
+    datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
 
-    the = numpy.zeros(len(indexThe), dtype=dtypeDefault)
+    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, dtype=dtypeDefault),
-        foldsTotal = numpy.zeros(the[indexThe.leavesTotal], dtype=numpy.int64),
+        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
+        foldsTotal = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
         mapShape = mapShape,
-        my = numpy.zeros(len(indexMy), dtype=dtypeLarge),
-        gapsWhere = numpy.zeros(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, dtype=dtypeDefault),
-        the = getTaskDivisions(computationDivisions, concurrencyLimit, the, CPUlimit, listDimensions),
-        track = numpy.zeros((len(indexTrack), the[indexThe.leavesTotal] + 1), dtype=dtypeLarge)
+        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.value] = 1

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/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

mapFolding/reference/lunnanWhile.py

@@ -12,7 +12,7 @@ def foldings(p: Sequence[int]) -> int:
         p: An array 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.
     """
@@ -29,7 +29,7 @@ def foldings(p: Sequence[int]) -> int:
     B = [0] * (n + 1)
     count = [0] * (n + 1)
     gapter = [0] * (n + 1)
-    gap = [0] * (n * n + 1)    
+    gap = [0] * (n * n + 1)
 
     # B[m] is the leaf below leaf m in the current folding,
     # A[m] the leaf above. count[m] is the no. of sections in which
@@ -64,13 +64,13 @@ def foldings(p: Sequence[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 > n:
-            f = f + 1
+            G = G + 1
         else:
             dd: int = 0
             gg: int = gapter[l - 1]
@@ -118,4 +118,4 @@ def foldings(p: Sequence[int]) -> int:
             A[B[l]] = l
             gapter[l] = g
             l = l + 1
-    return f
+    return G