mapFolding 0.2.4__tar.gz → 0.2.6__tar.gz

{mapfolding-0.2.4 → mapfolding-0.2.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.4
-Summary: Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
+Version: 0.2.6
+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,16 +14,11 @@ 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"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pytest-order; extra == "testing"
-Requires-Dist: pytest-dependency; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
@@ -41,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
 
@@ -133,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.4 → mapfolding-0.2.6}/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.4 → mapfolding-0.2.6}/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.4 → mapfolding-0.2.6}/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-0.2.4 → mapfolding-0.2.6}/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-0.2.6/mapFolding/importSelector.py

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

{mapfolding-0.2.4 → mapfolding-0.2.6}/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-0.2.4/mapFolding/JAX/lunnanJAX.py → mapfolding-0.2.6/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