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

mapFolding/__init__.py

@@ -1,6 +1,6 @@
 from .theSSOT import *
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getFilenameFoldsTotal, outfitCountFolds
+from .beDRY import getFilenameFoldsTotal, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
 from .startHere import countFolds
 from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
 

mapFolding/babbage.py

@@ -1,5 +1,5 @@
 from mapFolding.importSelector import countSequential, countParallel, countInitialize
-from mapFolding import indexThe
+from mapFolding import indexMy
 from numpy import integer
 from numpy.typing import NDArray
 from typing import Any, Tuple
@@ -7,7 +7,7 @@ import numba
 import numpy
 
 @numba.jit(cache=True)
-def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+def _countFolds(connectionGraph: NDArray[integer[Any]], foldGroups: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
     """
     What in tarnation is this stupid module and function?
 
@@ -27,9 +27,9 @@ def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[
 
     """
     # print("babbage")
-    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=track)
+    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, track=track)
 
-    if the[indexThe.taskDivisions.value] > 0:
-        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, the=the, trackPARALLEL=track)
+    if my[indexMy.taskDivisions.value] > 0:
+        countParallel(connectionGraph=connectionGraph, foldGroups=foldGroups, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, trackPARALLEL=track)
     else:
-        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
+        countSequential(connectionGraph=connectionGraph, foldGroups=foldGroups, gapsWhere=gapsWhere, my=my, track=track)

mapFolding/beDRY.py

@@ -1,16 +1,18 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge
-from mapFolding import indexMy, indexThe, indexTrack, computationState
+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(' ', '') + '.foldsTotal'
+    return str(sorted(listDimensions)).replace(', ', 'x').replace('[', 'p').replace(']', '') + '.foldsTotal'
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -36,6 +38,14 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
         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.
@@ -91,10 +101,11 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
     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:
+    Parameters
         listDimensions: A sequence of integers representing the dimensions of the map.
-    Returns:
-        connectionGraph: A 3D numpy array with shape of (dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1).
+
+    Returns
+        connectionGraph: A 3D numpy array with shape of (dimensionsTotal, leavesTotal + 1, leavesTotal + 1).
     """
     datatype = keywordArguments.get('datatype', dtypeDefault)
     mapShape = validateListDimensions(listDimensions)
@@ -106,39 +117,37 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
     cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
 
     # Step 2: create a coordinate system
-    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=datatype)
+    coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=datatype)
 
-    for dimension1ndex in range(1, dimensionsTotal + 1):
+    for indexDimension in range(dimensionsTotal):
         for leaf1ndex in range(1, leavesTotal + 1):
-            coordinateSystem[dimension1ndex, leaf1ndex] = (
-                ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) %
-                arrayDimensions[dimension1ndex - 1] + 1
+            coordinateSystem[indexDimension, leaf1ndex] = (
+                ((leaf1ndex - 1) // cumulativeProduct[indexDimension]) %
+                arrayDimensions[indexDimension] + 1
             )
 
     # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
+    connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
 
-    for dimension1ndex in range(1, dimensionsTotal + 1):
+    for indexDimension in range(dimensionsTotal):
         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
+                isFirstCoord = coordinateSystem[indexDimension, connectee1ndex] == 1
+                isLastCoord = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
+                exceedsActive = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
 
                 # Parity check
-                isEvenParity = (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == \
-                                (coordinateSystem[dimension1ndex, connectee1ndex] & 1)
+                isEvenParity = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == \
+                                (coordinateSystem[indexDimension, connectee1ndex] & 1)
 
                 # Determine connection value
                 if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex
                 elif isEvenParity and not isFirstCoord:
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[dimension1ndex - 1]
+                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[indexDimension]
                 elif not isEvenParity and not (isLastCoord or exceedsActive):
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[dimension1ndex - 1]
-                else:
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[indexDimension]
 
     return connectionGraph
 
@@ -148,7 +157,7 @@ def makeDataContainer(shape, datatype: Optional[Type] = 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]) -> computationState:
+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.
 
@@ -187,36 +196,38 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
     """
     datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
     datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
+    datatypeSmall = keywordArguments.get('datatypeSmall', dtypeSmall)
 
-    the = makeDataContainer(len(indexThe), datatypeDefault)
+    my = makeDataContainer(len(indexMy), 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)
+    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=datatypeDefault),
-        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
+        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeSmall),
+        foldGroups = foldGroups,
         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)
+        my = my,
+        gapsWhere = makeDataContainer(int(leavesTotal) * int(leavesTotal) + 1, datatypeSmall),
+        track = makeDataContainer((len(indexTrack), leavesTotal + 1), datatypeDefault)
         )
 
-    stateInitialized['my'][indexMy.leaf1ndex.value] = 1
 
     return stateInitialized
 
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
+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 ('unnamed parameter'): Name of the parameter for error messages. Defaults to 'unnamed parameter'
+        parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'
     Returns:
         listNonNegative: List of validated non-negative integers
     Raises:
@@ -232,6 +243,33 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
 
     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.
 

mapFolding/importSelector.py

@@ -1,12 +1,7 @@
-# useLovelace = True
-useLovelace = False
+from mapFolding.lovelace import countSequential
+from mapFolding.lovelace import countParallel
+from mapFolding.lovelace import countInitialize
 
-if useLovelace:
-    from mapFolding.lovelace import countSequential
-    from mapFolding.lovelace import countParallel
-    from mapFolding.lovelace import countInitialize
-
-else:
-    from mapFolding.countSequential import countSequential
-    from mapFolding.countParallel import countParallel
-    from mapFolding.countInitialize import countInitialize
+# from mapFolding.someAssemblyRequired.countSequential import countSequential
+# from mapFolding.someAssemblyRequired.countParallel import countParallel
+# from mapFolding.someAssemblyRequired.countInitialize import countInitialize

mapFolding/lovelace.py

@@ -1,4 +1,4 @@
-from mapFolding import indexMy, indexThe, indexTrack
+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)
@@ -10,16 +10,16 @@ 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(my, the):
-    return my[indexMy.leaf1ndex.value] > the[indexThe.leavesTotal.value]
+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, the):
-    return my[indexMy.dimensionsUnconstrained.value] == the[indexThe.dimensionsTotal.value]
+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):
@@ -44,20 +44,20 @@ def countGaps(gapsWhere, my, track):
 
 @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.dimension1ndex.value] += 1
+    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.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
+    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, the, track):
+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]]] == the[indexThe.dimensionsTotal.value] - my[indexMy.dimensionsUnconstrained.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
 
@@ -65,11 +65,11 @@ def filterCommonGaps(gapsWhere, my, the, track):
 def findGapsInitializeVariables(my, track):
     my[indexMy.dimensionsUnconstrained.value] = 0
     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-    my[indexMy.dimension1ndex.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(foldsSubTotals, my, the):
-    foldsSubTotals[my[indexMy.taskIndex.value]] += the[indexThe.leavesTotal.value]
+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):
@@ -93,19 +93,19 @@ def leafBelowSentinelIs1Condition(track):
 
 @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.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+    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.dimension1ndex.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+    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, the):
-    return my[indexMy.dimension1ndex.value] <= the[indexThe.dimensionsTotal.value]
+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):
@@ -126,15 +126,15 @@ 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, the):
-    return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value] or my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value] == my[indexMy.taskIndex.value]
+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], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countInitialize(connectionGraph, gapsWhere, my, the, track):
+@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, the=the):
+            while loopingTheDimensions(my=my):
                 if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                     dimensionsUnconstrainedIncrement(my=my)
                 else:
@@ -143,26 +143,26 @@ def countInitialize(connectionGraph, gapsWhere, my, the, track):
                         countGaps(gapsWhere=gapsWhere, my=my, track=track)
                         leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
                 dimension1ndexIncrement(my=my)
-            if allDimensionsAreUnconstrained(my=my, the=the):
+            if allDimensionsAreUnconstrained(my=my):
                 insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
             indexMiniGapInitialization(my=my)
             while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, the=the, track=track)
+                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], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track):
+@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(my=my, the=the):
-                foldsSubTotalIncrement(foldsSubTotals=foldsSubTotals, my=my, the=the)
+            if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                foldsSubTotalIncrement(foldGroups=foldGroups, my=my)
             else:
                 findGapsInitializeVariables(my=my, track=track)
-                while loopingTheDimensions(my=my, the=the):
+                while loopingTheDimensions(my=my):
                     if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                         dimensionsUnconstrainedIncrement(my=my)
                     else:
@@ -173,39 +173,39 @@ def countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track):
                     dimension1ndexIncrement(my=my)
                 indexMiniGapInitialization(my=my)
                 while loopingToActiveGapCeiling(my=my):
-                    filterCommonGaps(gapsWhere=gapsWhere, my=my, the=the, track=track)
+                    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],numba.int64[:,::1]), parallel=True, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countParallel(connectionGraph, foldsSubTotals, gapsWherePARALLEL, myPARALLEL, the, trackPARALLEL):
-    for indexSherpa in numba.prange(the[indexThe.taskDivisions.value]):
+@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(my=my, the=the):
-                    foldsSubTotalIncrement(foldsSubTotals=foldsSubTotals, my=my, the=the)
+                if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                    foldsSubTotalIncrement(foldGroups=foldGroups, my=my)
                 else:
                     findGapsInitializeVariables(my=my, track=track)
-                    while loopingTheDimensions(my=my, the=the):
+                    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, the=the):
+                                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, the=the, track=track)
+                        filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
                         indexMiniGapIncrement(my=my)
             while backtrackCondition(my=my, track=track):
                 backtrack(my=my, track=track)

mapFolding/{JAX/lunnanJAX.py → reference/jax.py}

@@ -1,3 +1,5 @@
+"""I was able to implement the algorithm with JAX, but I didn't see an advantage and it's a pain in the ass.
+I don't maintain this module."""
 from mapFolding import validateListDimensions, getLeavesTotal, makeConnectionGraph
 from typing import List, Tuple
 import jax

mapFolding/{inlineAfunction.py → someAssemblyRequired/inlineAfunction.py}

@@ -1,19 +1,22 @@
 from mapFolding import indexMy, indexThe, indexTrack
 import ast
+import copy
 import pathlib
 
-dictionaryEnumValues = {}
-for enumIndex in [indexMy, indexThe, indexTrack]:
-    for memberName, memberValue in enumIndex._member_map_.items():
-        dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
+def getDictionaryEnumValues():
+    dictionaryEnumValues = {}
+    for enumIndex in [indexMy, indexThe, indexTrack]:
+        for memberName, memberValue in enumIndex._member_map_.items():
+            dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
+    return dictionaryEnumValues
 
-class RecursiveInliner(ast.NodeTransformer):
+class RecursiveInlinerWithEnum(ast.NodeTransformer):
     def __init__(self, dictionaryFunctions, dictionaryEnumValues):
         self.dictionaryFunctions = dictionaryFunctions
         self.dictionaryEnumValues = dictionaryEnumValues
         self.processed = set()  # Track processed functions to avoid infinite recursion
 
-    def inline_function_body(self, functionName):
+    def inlineFunctionBody(self, functionName):
         if functionName in self.processed:
             return None
 
@@ -35,7 +38,7 @@ class RecursiveInliner(ast.NodeTransformer):
     def visit_Call(self, node):
         callNode = self.generic_visit(node)
         if isinstance(callNode, ast.Call) and isinstance(callNode.func, ast.Name) and callNode.func.id in self.dictionaryFunctions:
-            inlineDefinition = self.inline_function_body(callNode.func.id)
+            inlineDefinition = self.inlineFunctionBody(callNode.func.id)
             if inlineDefinition and inlineDefinition.body:
                 lastStmt = inlineDefinition.body[-1]
                 if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
@@ -48,23 +51,23 @@ class RecursiveInliner(ast.NodeTransformer):
     def visit_Expr(self, node):
         if isinstance(node.value, ast.Call):
             if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
-                inlineDefinition = self.inline_function_body(node.value.func.id)
+                inlineDefinition = self.inlineFunctionBody(node.value.func.id)
                 if inlineDefinition:
                     return [self.visit(stmt) for stmt in inlineDefinition.body]
         return self.generic_visit(node)
 
-def find_required_imports(node):
-    """Find all modules that need to be imported based on AST analysis."""
+def findRequiredImports(node):
+    """Find all modules that need to be imported based on AST analysis.
+    NOTE: due to hardcoding, this is a glorified regex. No, wait, this is less versatile than regex."""
     requiredImports = set()
 
     class ImportFinder(ast.NodeVisitor):
         def visit_Name(self, node):
-            # Common modules we might need
             if node.id in {'numba'}:
                 requiredImports.add(node.id)
             self.generic_visit(node)
 
-        def visit_Decorator(self, node):
+        def visitDecorator(self, node):
             if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
                 if node.func.id == 'jit':
                     requiredImports.add('numba')
@@ -73,7 +76,7 @@ def find_required_imports(node):
     ImportFinder().visit(node)
     return requiredImports
 
-def generate_imports(requiredImports):
+def generateImports(requiredImports):
     """Generate import statements based on required modules."""
     importStatements = []
 
@@ -88,7 +91,7 @@ def generate_imports(requiredImports):
 
     return '\n'.join(importStatements)
 
-def inline_functions(sourceCode, targetFunctionName, dictionaryEnumValues):
+def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues):
     dictionaryParsed = ast.parse(sourceCode)
     dictionaryFunctions = {
         element.name: element
@@ -96,29 +99,54 @@ def inline_functions(sourceCode, targetFunctionName, dictionaryEnumValues):
         if isinstance(element, ast.FunctionDef)
     }
     nodeTarget = dictionaryFunctions[targetFunctionName]
-    nodeInliner = RecursiveInliner(dictionaryFunctions, dictionaryEnumValues)
+    nodeInliner = RecursiveInlinerWithEnum(dictionaryFunctions, dictionaryEnumValues)
     nodeInlined = nodeInliner.visit(nodeTarget)
     ast.fix_missing_locations(nodeInlined)
 
     # Generate imports
-    requiredImports = find_required_imports(nodeInlined)
-    importStatements = generate_imports(requiredImports)
+    requiredImports = findRequiredImports(nodeInlined)
+    importStatements = generateImports(requiredImports)
 
     # Combine imports with inlined code
     inlinedCode = importStatements + '\n\n' + ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
     return inlinedCode
 
-pathFilenameSource = pathlib.Path("/apps/mapFolding/mapFolding/lovelace.py")
-codeSource = pathFilenameSource.read_text()
-
-listCallables = [
-    'countSequential',
-    'countParallel',
-    'countInitialize',
-]
-listPathFilenamesDestination = []
-for callableTarget in listCallables:
-    pathFilenameDestination = pathFilenameSource.with_stem(callableTarget)
-    codeInlined = inline_functions(codeSource, callableTarget, dictionaryEnumValues)
-    pathFilenameDestination.write_text(codeInlined)
-    listPathFilenamesDestination.append(pathFilenameDestination)
+def Z0Z_inlineMapFolding():
+    dictionaryEnumValues = getDictionaryEnumValues()
+
+    pathFilenameSource = pathlib.Path("/apps/mapFolding/mapFolding/lovelace.py")
+    codeSource = pathFilenameSource.read_text()
+
+    listCallables = [
+        'countInitialize',
+        'countParallel',
+        'countSequential',
+    ]
+
+    listPathFilenamesDestination: list[pathlib.Path] = []
+    for callableTarget in listCallables:
+        pathFilenameDestination = pathFilenameSource.parent / "someAssemblyRequired" / pathFilenameSource.with_stem(callableTarget).name
+        codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues)
+        pathFilenameDestination.write_text(codeInlined)
+        listPathFilenamesDestination.append(pathFilenameDestination)
+
+    listNoNumba = [
+        'countInitialize',
+        'countSequential',
+    ]
+
+    listPathFilenamesNoNumba = []
+    for pathFilename in listPathFilenamesDestination:
+        if pathFilename.stem in listNoNumba:
+            pathFilenameNoNumba = pathFilename.with_name(pathFilename.stem + 'NoNumba' + pathFilename.suffix)
+        else:
+            continue
+        codeNoNumba = pathFilename.read_text()
+        for codeLine in copy.copy(codeNoNumba.splitlines()):
+            if 'numba' in codeLine:
+                codeNoNumba = codeNoNumba.replace(codeLine, '')
+        pathFilenameNoNumba.write_text(codeNoNumba)
+        listPathFilenamesNoNumba.append(pathFilenameNoNumba)
+
+if __name__ == '__main__':
+    Z0Z_inlineMapFolding()