mapFolding 0.2.3__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.3
+Version: 0.2.4
 Summary: Algorithm(s) for counting 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
@@ -22,6 +22,8 @@ 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)
 

{mapfolding-0.2.3 → mapfolding-0.2.4}/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.4}/mapFolding/beDRY.py

@@ -230,9 +230,6 @@ 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
 
 def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:

{mapfolding-0.2.3 → mapfolding-0.2.4}/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.4/mapFolding/countInitialize.py

@@ -0,0 +1,44 @@
+import numba
+
+@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 my[6] > 0:
+        if my[6] <= 1 or track[1, 0] == 1:
+            my[1] = 0
+            my[3] = track[3, my[6] - 1]
+            my[0] = 1
+            while my[0] <= the[0]:
+                if connectionGraph[my[0], my[6], my[6]] == my[6]:
+                    my[1] += 1
+                else:
+                    my[7] = connectionGraph[my[0], my[6], my[6]]
+                    while my[7] != my[6]:
+                        gapsWhere[my[3]] = my[7]
+                        if track[2, my[7]] == 0:
+                            my[3] += 1
+                        track[2, my[7]] += 1
+                        my[7] = connectionGraph[my[0], my[6], track[1, my[7]]]
+                my[0] += 1
+            if my[1] == the[0]:
+                my[4] = 0
+                while my[4] < my[6]:
+                    gapsWhere[my[3]] = my[4]
+                    my[3] += 1
+                    my[4] += 1
+            my[5] = my[2]
+            while my[5] < my[3]:
+                gapsWhere[my[2]] = gapsWhere[my[5]]
+                if track[2, gapsWhere[my[5]]] == the[0] - my[1]:
+                    my[2] += 1
+                track[2, gapsWhere[my[5]]] = 0
+                my[5] += 1
+        if my[6] > 0:
+            my[2] -= 1
+            track[0, my[6]] = gapsWhere[my[2]]
+            track[1, my[6]] = track[1, track[0, my[6]]]
+            track[1, track[0, my[6]]] = my[6]
+            track[0, track[1, my[6]]] = my[6]
+            track[3, my[6]] = my[2]
+            my[6] += 1
+        if my[2] > 0:
+            return

mapfolding-0.2.4/mapFolding/countParallel.py

@@ -0,0 +1,49 @@
+import numba
+
+@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[2]):
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        my[8] = indexSherpa
+        track = trackPARALLEL.copy()
+        while my[6] > 0:
+            if my[6] <= 1 or track[1, 0] == 1:
+                if my[6] > the[1]:
+                    foldsSubTotals[my[8]] += the[1]
+                else:
+                    my[1] = 0
+                    my[3] = track[3, my[6] - 1]
+                    my[0] = 1
+                    while my[0] <= the[0]:
+                        if connectionGraph[my[0], my[6], my[6]] == my[6]:
+                            my[1] += 1
+                        else:
+                            my[7] = connectionGraph[my[0], my[6], my[6]]
+                            while my[7] != my[6]:
+                                if my[6] != the[2] or my[7] % the[2] == my[8]:
+                                    gapsWhere[my[3]] = my[7]
+                                    if track[2, my[7]] == 0:
+                                        my[3] += 1
+                                    track[2, my[7]] += 1
+                                my[7] = connectionGraph[my[0], my[6], track[1, my[7]]]
+                        my[0] += 1
+                    my[5] = my[2]
+                    while my[5] < my[3]:
+                        gapsWhere[my[2]] = gapsWhere[my[5]]
+                        if track[2, gapsWhere[my[5]]] == the[0] - my[1]:
+                            my[2] += 1
+                        track[2, gapsWhere[my[5]]] = 0
+                        my[5] += 1
+            while my[6] > 0 and my[2] == track[3, my[6] - 1]:
+                my[6] -= 1
+                track[1, track[0, my[6]]] = track[1, my[6]]
+                track[0, track[1, my[6]]] = track[0, my[6]]
+            if my[6] > 0:
+                my[2] -= 1
+                track[0, my[6]] = gapsWhere[my[2]]
+                track[1, my[6]] = track[1, track[0, my[6]]]
+                track[1, track[0, my[6]]] = my[6]
+                track[0, track[1, my[6]]] = my[6]
+                track[3, my[6]] = my[2]
+                my[6] += 1

mapfolding-0.2.4/mapFolding/countSequential.py

@@ -0,0 +1,43 @@
+import numba
+
+@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 my[6] > 0:
+        if my[6] <= 1 or track[1, 0] == 1:
+            if my[6] > the[1]:
+                foldsSubTotals[my[8]] += the[1]
+            else:
+                my[1] = 0
+                my[3] = track[3, my[6] - 1]
+                my[0] = 1
+                while my[0] <= the[0]:
+                    if connectionGraph[my[0], my[6], my[6]] == my[6]:
+                        my[1] += 1
+                    else:
+                        my[7] = connectionGraph[my[0], my[6], my[6]]
+                        while my[7] != my[6]:
+                            gapsWhere[my[3]] = my[7]
+                            if track[2, my[7]] == 0:
+                                my[3] += 1
+                            track[2, my[7]] += 1
+                            my[7] = connectionGraph[my[0], my[6], track[1, my[7]]]
+                    my[0] += 1
+                my[5] = my[2]
+                while my[5] < my[3]:
+                    gapsWhere[my[2]] = gapsWhere[my[5]]
+                    if track[2, gapsWhere[my[5]]] == the[0] - my[1]:
+                        my[2] += 1
+                    track[2, gapsWhere[my[5]]] = 0
+                    my[5] += 1
+        while my[6] > 0 and my[2] == track[3, my[6] - 1]:
+            my[6] -= 1
+            track[1, track[0, my[6]]] = track[1, my[6]]
+            track[0, track[1, my[6]]] = track[0, my[6]]
+        if my[6] > 0:
+            my[2] -= 1
+            track[0, my[6]] = gapsWhere[my[2]]
+            track[1, my[6]] = track[1, track[0, my[6]]]
+            track[1, track[0, my[6]]] = my[6]
+            track[0, track[1, my[6]]] = my[6]
+            track[3, my[6]] = my[2]
+            my[6] += 1

mapfolding-0.2.4/mapFolding/importSelector.py

@@ -0,0 +1,12 @@
+# useLovelace = True
+useLovelace = False
+
+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

mapfolding-0.2.4/mapFolding/inlineAfunction.py

@@ -0,0 +1,124 @@
+from mapFolding import indexMy, indexThe, indexTrack
+import ast
+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
+
+class RecursiveInliner(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):
+        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.inline_function_body(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.inline_function_body(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."""
+    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):
+            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 generate_imports(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 inline_functions(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 = RecursiveInliner(dictionaryFunctions, dictionaryEnumValues)
+    nodeInlined = nodeInliner.visit(nodeTarget)
+    ast.fix_missing_locations(nodeInlined)
+
+    # Generate imports
+    requiredImports = find_required_imports(nodeInlined)
+    importStatements = generate_imports(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)

mapfolding-0.2.4/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-0.2.4}/mapFolding/startHere.py

@@ -44,10 +44,8 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
             pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
         pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 
-    # NOTE Don't import a module with a numba.jit function until you want the function to compile and to freeze all settings for that function.
     from mapFolding.babbage import _countFolds
     _countFolds(**stateUniversal)
-    # foldsSubTotals = benchmarkSherpa(**stateUniversal)
 
     foldsTotal = stateUniversal['foldsSubTotals'].sum().item()
 
@@ -59,12 +57,3 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
             print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
 
     return foldsTotal
-
-# from numpy import integer
-# from numpy.typing import NDArray
-# from typing import Any, Tuple
-# from mapFolding.benchmarks.benchmarking import recordBenchmarks
-# @recordBenchmarks()
-# def benchmarkSherpa(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]]):
-#     from mapFolding.babbage import _countFolds
-#     return _countFolds(connectionGraph, foldsSubTotals, gapsWhere, mapShape, my, the, track)

{mapfolding-0.2.3 → mapfolding-0.2.4}/mapFolding/theSSOT.py

@@ -5,9 +5,17 @@ import numpy.typing
 import pathlib
 import sys
 
-dtypeLarge = numpy.int64
-dtypeDefault = dtypeLarge
-dtypeSmall = dtypeDefault
+datatypeModule = 'numpy'
+
+datatypeLarge = 'int64'
+datatypeDefault = datatypeLarge
+datatypeSmall = datatypeDefault
+
+make_dtype = lambda _datatype: eval(f"{datatypeModule}.{_datatype}")
+
+dtypeLarge = make_dtype(datatypeLarge)
+dtypeDefault = make_dtype(datatypeDefault)
+dtypeSmall = make_dtype(datatypeSmall)
 
 try:
     _pathModule = pathlib.Path(__file__).parent
@@ -59,9 +67,9 @@ class indexTrack(EnumIndices):
 
 class computationState(TypedDict):
     connectionGraph: numpy.typing.NDArray[numpy.integer[Any]]
-    foldsSubTotals: numpy.ndarray[numpy.int64, numpy.dtype[numpy.int64]]
+    foldsSubTotals: numpy.typing.NDArray[numpy.integer[Any]]
+    gapsWhere: numpy.typing.NDArray[numpy.integer[Any]]
     mapShape: Tuple[int, ...]
     my: numpy.typing.NDArray[numpy.integer[Any]]
-    gapsWhere: numpy.typing.NDArray[numpy.integer[Any]]
     the: numpy.typing.NDArray[numpy.integer[Any]]
     track: numpy.typing.NDArray[numpy.integer[Any]]

{mapfolding-0.2.3 → mapfolding-0.2.4}/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.3
+Version: 0.2.4
 Summary: Algorithm(s) for counting 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
@@ -22,6 +22,8 @@ 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)
 

{mapfolding-0.2.3 → mapfolding-0.2.4}/mapFolding.egg-info/SOURCES.txt

@@ -3,6 +3,11 @@ pyproject.toml
 mapFolding/__init__.py
 mapFolding/babbage.py
 mapFolding/beDRY.py
+mapFolding/countInitialize.py
+mapFolding/countParallel.py
+mapFolding/countSequential.py
+mapFolding/importSelector.py
+mapFolding/inlineAfunction.py
 mapFolding/lovelace.py
 mapFolding/oeis.py
 mapFolding/startHere.py
@@ -16,7 +21,6 @@ mapFolding.egg-info/top_level.txt
 mapFolding/JAX/lunnanJAX.py
 mapFolding/JAX/taskJAX.py
 mapFolding/benchmarks/benchmarking.py
-mapFolding/benchmarks/test_benchmarks.py
 mapFolding/reference/flattened.py
 mapFolding/reference/hunterNumba.py
 mapFolding/reference/irvineJavaPort.py
@@ -30,4 +34,5 @@ tests/conftest.py
 tests/pythons_idiotic_namespace.py
 tests/test_oeis.py
 tests/test_other.py
-tests/test_tasks.py
+tests/test_tasks.py
+tests/test_temporary.py