mapFolding 0.2.3__tar.gz → 0.2.5__tar.gz

{mapfolding-0.2.3 → mapfolding-0.2.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.3
-Summary: Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
+Version: 0.2.5
+Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 Project-URL: homepage, https://github.com/hunterhogan/mapFolding
 Requires-Python: <3.13,>=3.10
@@ -14,9 +14,6 @@ Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: ipywidgets; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
-Provides-Extra: jax
-Requires-Dist: jax; extra == "jax"
-Requires-Dist: jaxtyping; extra == "jax"
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
@@ -39,7 +36,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 - [hunterNumba.py](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference), a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
 - miscellaneous notes.
 
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) ![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) [![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ## Simple, easy usage based on OEIS IDs
 
@@ -131,3 +128,8 @@ In [`foldings.txt`](https://github.com/hunterhogan/mapFolding/blob/main/mapFoldi
 ```sh
 pip install mapFolding
 ```
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)

{mapfolding-0.2.3 → mapfolding-0.2.5}/README.md

@@ -14,7 +14,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 - [hunterNumba.py](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference), a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
 - miscellaneous notes.
 
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) ![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) [![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ## Simple, easy usage based on OEIS IDs
 
@@ -106,3 +106,8 @@ In [`foldings.txt`](https://github.com/hunterhogan/mapFolding/blob/main/mapFoldi
 ```sh
 pip install mapFolding
 ```
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)

{mapfolding-0.2.3 → mapfolding-0.2.5}/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-0.2.3 → mapfolding-0.2.5}/mapFolding/babbage.py

@@ -1,4 +1,5 @@
-from mapFolding.lovelace import countFoldsCompiled
+from mapFolding.importSelector import countSequential, countParallel, countInitialize
+from mapFolding import indexThe
 from numpy import integer
 from numpy.typing import NDArray
 from typing import Any, Tuple
@@ -25,6 +26,10 @@ def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[
         - and just a few dozen-jillion other things.
 
     """
-    # TODO learn if I really must change this jitted function to get the super jit to recompile
-    # print('babbage')
-    countFoldsCompiled(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
+    # print("babbage")
+    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=track)
+
+    if the[indexThe.taskDivisions.value] > 0:
+        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, the=the, trackPARALLEL=track)
+    else:
+        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)

{mapfolding-0.2.3 → mapfolding-0.2.5}/mapFolding/beDRY.py

@@ -1,5 +1,5 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge
+from mapFolding import dtypeDefault, dtypeLarge, pathJobDEFAULT
 from mapFolding import indexMy, indexThe, indexTrack, computationState
 from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
 from numpy import integer
@@ -7,10 +7,12 @@ 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') + '.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.
@@ -148,7 +158,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.
 
@@ -230,11 +240,42 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
             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
 
+import tempfile
+import shutil
+import logging
+import os
+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
+    """
+    """Thoughts
+    Everything in a try block
+    Save it multiple times with multiple packages
+    no need for context managers, especially because they can cause errors"""
+    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)
+            import os
+            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+            open(pathFilenamePlanB, 'w').write(str(foldsTotal))
+            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-0.2.3 → mapfolding-0.2.5}/mapFolding/benchmarks/benchmarking.py

@@ -1,5 +1,6 @@
-import multiprocessing
+"""An incompetent benchmarking module for mapFolding."""
 from typing import Callable
+import multiprocessing
 import numpy
 import pathlib
 import time
@@ -57,7 +58,7 @@ def runBenchmarks(benchmarkIterations: int = 30) -> None:
     listCartesianProduct = list(itertools.product(listParametersOEIS, range(benchmarkIterations)))
     with ProcessPoolExecutor(max_workers) as concurrencyManager:
         listConcurrency = [concurrencyManager.submit(oeisIDfor_n, *parameters[0]) for parameters in listCartesianProduct]
-        for complete in tqdm(as_completed(listConcurrency), total=len(listCartesianProduct)):
+        for _complete in tqdm(as_completed(listConcurrency), total=len(listCartesianProduct)):
             pass
 
 if __name__ == '__main__':

mapfolding-0.2.5/mapFolding/importSelector.py

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

mapfolding-0.2.5/mapFolding/lovelace.py

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

mapfolding-0.2.3/mapFolding/JAX/lunnanJAX.py → mapfolding-0.2.5/mapFolding/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-0.2.5/mapFolding/someAssemblyRequired/inlineAfunction.py

@@ -0,0 +1,152 @@
+from mapFolding import indexMy, indexThe, indexTrack
+import ast
+import copy
+import pathlib
+
+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 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 inlineFunctionBody(self, functionName):
+        if functionName in self.processed:
+            return None
+
+        self.processed.add(functionName)
+        inlineDefinition = self.dictionaryFunctions[functionName]
+        # Recursively process the function body
+        for node in ast.walk(inlineDefinition):
+            self.visit(node)
+        return inlineDefinition
+
+    def visit_Attribute(self, node):
+        # Substitute enum identifiers (e.g., indexMy.leaf1ndex.value)
+        if isinstance(node.value, ast.Attribute) and isinstance(node.value.value, ast.Name):
+            enumPath = f"{node.value.value.id}.{node.value.attr}.{node.attr}"
+            if enumPath in self.dictionaryEnumValues:
+                return ast.Constant(value=self.dictionaryEnumValues[enumPath])
+        return self.generic_visit(node)
+
+    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.inlineFunctionBody(callNode.func.id)
+            if inlineDefinition and inlineDefinition.body:
+                lastStmt = inlineDefinition.body[-1]
+                if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
+                    return self.visit(lastStmt.value)
+                elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
+                    return self.visit(lastStmt.value)
+                return None
+        return callNode
+
+    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.inlineFunctionBody(node.value.func.id)
+                if inlineDefinition:
+                    return [self.visit(stmt) for stmt in inlineDefinition.body]
+        return self.generic_visit(node)
+
+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):
+            if node.id in {'numba'}:
+                requiredImports.add(node.id)
+            self.generic_visit(node)
+
+        def visitDecorator(self, node):
+            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+                if node.func.id == 'jit':
+                    requiredImports.add('numba')
+            self.generic_visit(node)
+
+    ImportFinder().visit(node)
+    return requiredImports
+
+def generateImports(requiredImports):
+    """Generate import statements based on required modules."""
+    importStatements = []
+
+    # Map of module names to their import statements
+    importMapping = {
+        'numba': 'import numba',
+    }
+
+    for moduleName in sorted(requiredImports):
+        if moduleName in importMapping:
+            importStatements.append(importMapping[moduleName])
+
+    return '\n'.join(importStatements)
+
+def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues):
+    dictionaryParsed = ast.parse(sourceCode)
+    dictionaryFunctions = {
+        element.name: element
+        for element in dictionaryParsed.body
+        if isinstance(element, ast.FunctionDef)
+    }
+    nodeTarget = dictionaryFunctions[targetFunctionName]
+    nodeInliner = RecursiveInlinerWithEnum(dictionaryFunctions, dictionaryEnumValues)
+    nodeInlined = nodeInliner.visit(nodeTarget)
+    ast.fix_missing_locations(nodeInlined)
+
+    # Generate imports
+    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
+
+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.with_stem(callableTarget)
+        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()

mapfolding-0.2.5/mapFolding/someAssemblyRequired/jobsAndTasks.py

@@ -0,0 +1,47 @@
+from typing import Any, Optional, Sequence, Type, Union
+
+def Z0Z_makeJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
+    from mapFolding import outfitCountFolds
+    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+    from mapFolding.countInitialize import countInitialize
+    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['the'], stateUniversal['track'])
+    from mapFolding import getPathFilenameFoldsTotal
+    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
+    import pathlib
+    suffix = pathFilenameChopChop.suffix
+    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
+    pathJob.mkdir(parents=True, exist_ok=True)
+    pathFilenameJob = pathJob / 'stateJob.pkl'
+
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathFilenameJob.parent)
+    stateJob = {**stateUniversal, 'pathFilenameFoldsTotal': pathFilenameFoldsTotal}
+
+    del stateJob['mapShape']
+
+    import pickle
+    pathFilenameJob.write_bytes(pickle.dumps(stateJob))
+    return pathFilenameJob
+
+def runJob(pathFilename):
+    from typing import Final
+    import numpy
+    from pathlib import Path
+    pathFilenameJob = Path(pathFilename)
+    from pickle import loads
+    stateJob = loads(pathFilenameJob.read_bytes())
+
+    connectionGraph: numpy.ndarray = stateJob['connectionGraph']
+    foldsSubTotals: numpy.ndarray = stateJob['foldsSubTotals']
+    gapsWhere: numpy.ndarray = stateJob['gapsWhere']
+    my: numpy.ndarray = stateJob['my']
+    pathFilenameFoldsTotal: Final[Path] = stateJob['pathFilenameFoldsTotal']
+    the: Final[numpy.ndarray] = stateJob['the']
+    track: numpy.ndarray = stateJob['track']
+
+    from mapFolding.countSequentialNoNumba import countSequential
+    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track)
+
+    print(foldsSubTotals.sum().item())
+    Path(pathFilenameFoldsTotal).parent.mkdir(parents=True, exist_ok=True)
+    Path(pathFilenameFoldsTotal).write_text(str(foldsSubTotals.sum().item()))
+    print(pathFilenameFoldsTotal)