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

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/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/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/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/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/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/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/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/lovelace.py

@@ -1,100 +1,118 @@
 from mapFolding import indexMy, indexThe, indexTrack
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any
 import numba
-import numpy
 
-def activeGapIncrement(my: NDArray[integer[Any]]):
+@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
 
-def activeLeafGreaterThan0Condition(my: NDArray[integer[Any]]):
+@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
 
-def activeLeafGreaterThanLeavesTotalCondition(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+@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 activeLeafIsTheFirstLeafCondition(my: NDArray[integer[Any]]):
+@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
 
-def activeLeafNotEqualToTaskDivisionsCondition(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
-    return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value]
-
-def allDimensionsAreUnconstrained(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+@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 backtrack(my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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]]
 
-def backtrackCondition(my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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]
 
-def countGaps(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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
 
-def dimension1ndexIncrement(my: NDArray[integer[Any]]):
+@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
 
-def dimensionsUnconstrainedCondition(connectionGraph: NDArray[integer[Any]], my: NDArray[integer[Any]]):
+@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]
 
-def dimensionsUnconstrainedIncrement(my: NDArray[integer[Any]]):
+@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
 
-def filterCommonGaps(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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
 
-def findGapsInitializeVariables(my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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
 
-def foldsSubTotalIncrement(foldsSubTotals: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+@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 gap1ndexCeilingIncrement(my: NDArray[integer[Any]]):
-    my[indexMy.gap1ndexCeiling.value] += 1
-
-def indexMiniGapIncrement(my: NDArray[integer[Any]]):
+@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
 
-def indexMiniGapInitialization(my: NDArray[integer[Any]]):
+@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]
 
-def insertUnconstrainedLeaf(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]]):
+@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
 
-def leafBelowSentinelIs1Condition(track: NDArray[integer[Any]]):
+@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
 
-def leafConnecteeInitialization(connectionGraph: NDArray[integer[Any]], my: NDArray[integer[Any]]):
+@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]]
 
-def leafConnecteeUpdate(connectionGraph: NDArray[integer[Any]], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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]]]
 
-def loopingLeavesConnectedToActiveLeaf(my: NDArray[integer[Any]]):
+@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]
 
-def loopingTheDimensions(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
+@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 loopingToActiveGapCeiling(my: NDArray[integer[Any]]):
+@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]
 
-def placeLeaf(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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]]]
@@ -103,20 +121,16 @@ def placeLeaf(gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], track
     track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
     my[indexMy.leaf1ndex.value] += 1
 
-def placeLeafCondition(my: NDArray[integer[Any]]):
+@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
 
-def taskIndexCondition(my: NDArray[integer[Any]], the: NDArray[integer[Any]]):
-    return my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value] == my[indexMy.taskIndex.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 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: NDArray[integer[Any]], the: NDArray[integer[Any]]):
-    if activeLeafNotEqualToTaskDivisionsCondition(my=my, the=the):
-        return True
-    if taskIndexCondition(my=my, the=the):
-        return True
-    return False
-
-def initialize(connectionGraph: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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)
@@ -138,35 +152,10 @@ def initialize(connectionGraph: NDArray[integer[Any]], gapsWhere: NDArray[intege
         if placeLeafCondition(my=my):
             placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
         if my[indexMy.gap1ndex.value] > 0:
-            break
+            return
 
-def countParallel(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
-    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)
-
-def countSequential(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+@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):
@@ -191,27 +180,34 @@ def countSequential(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDAr
         if placeLeafCondition(my=my):
             placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 
-@numba.jit(parallel=True, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
-def doTaskIndices(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
-
-    stateGapsWhere = gapsWhere.copy()
-    stateMy = my.copy()
-    stateTrack = track.copy()
-
+@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]):
-        mySherpa = stateMy.copy()
-        mySherpa[indexMy.taskIndex.value] = indexSherpa
-        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=stateGapsWhere.copy(), my=mySherpa, the=the, track=stateTrack.copy())
-
-    return foldsSubTotals
-
-def countFoldsCompiled(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
-
-    initialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=track)
-
-    if the[indexThe.taskDivisions.value] > 0:
-        doTaskIndices(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
-    else:
-        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
-
-numba.jit_module(parallel=False, _nrt=True, boundscheck=False, error_model='numpy', fastmath=True, forceinline=True, looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nogil=True, nopython=True)
+        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/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/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.dist-info → mapFolding-0.2.4.dist-info}/METADATA

@@ -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.dist-info → mapFolding-0.2.4.dist-info}/RECORD

@@ -1,14 +1,18 @@
 mapFolding/__init__.py,sha256=wnf2EzHR2unVha6-Y0gRoSPaE4PDdT4VngINa_dfT2E,337
-mapFolding/babbage.py,sha256=LCtyapF8SKsECqBifqbLm7bR_i4n8VJ647w_TQxnQvE,1930
-mapFolding/beDRY.py,sha256=UE4IRrb5lXN4nTuUghHfieNm2FBHgz7oBj_EqUgkadI,13800
-mapFolding/lovelace.py,sha256=r4dkTGh_AgaVsWOsdPRdpPWVx3TjVjbWfPCVu3UTm6U,13495
+mapFolding/babbage.py,sha256=51fO7lwcTsTvSMwzKW1G2nGslGoEQt19IgnqZi8znao,2222
+mapFolding/beDRY.py,sha256=XawGabR1vhzOfdA46HSXmisA5EmxisTKdA3D98KDeac,13699
+mapFolding/countInitialize.py,sha256=pIeH52OwDMfuHXT2T4BbPmMm6r7zJnGc-e0QVQCKyDc,1824
+mapFolding/countParallel.py,sha256=1sLGIlMj_xZ4bFkG1srOPcDUCrSKc1q3x2QN_8l_sgY,2451
+mapFolding/countSequential.py,sha256=QSXwK3o8YBcxNrir_wGMXgqp38hXYTJanYXFLxUPCPo,1993
+mapFolding/importSelector.py,sha256=OY_LuUrLW5SFV6qM1tSgI2Rnfi5Bj3Fhdrkryo0WycE,392
+mapFolding/inlineAfunction.py,sha256=KO2snTNSGX-4urRtTOYqAZBCsBCaMfr5bo6rNZR9MPA,5102
+mapFolding/lovelace.py,sha256=iu7anbA_TacIAjc4EKkeBVxIJKAMdrYgvR4evzMZ1WY,15193
 mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
-mapFolding/startHere.py,sha256=glGxmefrWpxyuqrzXrbCvIo84yvPnv8l8l7Rmff2sAo,5105
-mapFolding/theSSOT.py,sha256=rAyx034y33QC7IiRKaW89CMGGvqe2p-QBc3_fO-zEGM,2101
+mapFolding/startHere.py,sha256=or7QhxgMls2hvP_I2eTBP5tffLrc3SMiE5Gz_Ik2aJY,4328
+mapFolding/theSSOT.py,sha256=3Zty4rYWOqrwivuCaKA71R0HM4rjmvtkL_Bsn4ZhwFo,2318
 mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
 mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
-mapFolding/benchmarks/benchmarking.py,sha256=kv85F6V9pGhZvTOImArOuxyg5rywA_T6JLH_qFXM8BM,3018
-mapFolding/benchmarks/test_benchmarks.py,sha256=c4ANeR3jgqpKXFoxDeZkmAHxSuenMwsjmrhKJ1_XPqY,3659
+mapFolding/benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
 mapFolding/reference/flattened.py,sha256=X9nvRzg7YDcpCtSDTL4YiidjshlX9rg2e6JVCY6i2u0,16547
 mapFolding/reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
 mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
@@ -18,13 +22,14 @@ mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0T
 mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
 mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
 tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=WE3DETPaQ4zuUiw8pweTry4rp1PxvUPgeb8CN8eh5JI,13574
+tests/conftest.py,sha256=AWB3m_jxMlkmOmGvk2ApJEk2ro5v8gmmJDcyLwN1oow,13761
 tests/pythons_idiotic_namespace.py,sha256=oOLDBergQqqhGuRpsXUnFD-R_6AlJipNKYHw-kk_OKw,33
 tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
-tests/test_other.py,sha256=5DwOZsjezBHZzr4-9qEnybBYJEGsozBm2n9p0KYvs9E,10664
+tests/test_other.py,sha256=amhsy7VWzpuW_slBOTFPhC7e4o4k6Yp4xweNK1VHZnc,11906
 tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
-mapFolding-0.2.3.dist-info/METADATA,sha256=nEQXgDmmuu2NJko4R4gPUdjIrm1upUGwMIOn0s0JOOc,6442
-mapFolding-0.2.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.3.dist-info/RECORD,,
+tests/test_temporary.py,sha256=4FIEc9KGRpNsgU_eh8mXG49PSPqo8WLeZEyFI4Dpy3U,1127
+mapFolding-0.2.4.dist-info/METADATA,sha256=w1OgxNLylmuYfEKUsSIChm_8jLtjV63_OB04n8Btjm8,6543
+mapFolding-0.2.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.4.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.4.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.4.dist-info/RECORD,,

tests/conftest.py

@@ -26,7 +26,6 @@ from mapFolding.oeis import _parseBFileOEIS
 from mapFolding.oeis import _validateOEISid
 from mapFolding.oeis import oeisIDsImplemented
 from mapFolding.oeis import settingsOEIS
-from mapFolding import *
 
 __all__ = [
     'OEIS_for_n',
@@ -135,6 +134,14 @@ def setupTeardownTestData() -> Generator[None, None, None]:
     yield
     cleanupTempFileRegister()
 
+@pytest.fixture(autouse=True)
+def setupWarningsAsErrors():
+    """Convert all warnings to errors for all tests."""
+    import warnings
+    warnings.filterwarnings("error")
+    yield
+    warnings.resetwarnings()
+
 @pytest.fixture
 def pathTempTesting(request: pytest.FixtureRequest) -> pathlib.Path:
     """Create a unique temp directory for each test function."""

tests/test_other.py

@@ -1,12 +1,14 @@
-from pathlib import Path
-from typing import List, Optional, Dict, Any, Union
+import pathlib
 from tests.conftest import *
 from tests.pythons_idiotic_namespace import *
+from typing import List, Optional
+import itertools
+import numba
+import numpy
 import pytest
+import random
 import sys
 import unittest.mock
-import numpy
-import numba
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -65,7 +67,7 @@ def test_getLeavesTotal_edge_cases() -> None:
 ])
 def test_countFolds_writeFoldsTotal(
     listDimensionsTestFunctionality: List[int],
-    pathTempTesting: Path,
+    pathTempTesting: pathlib.Path,
     mockFoldingFunction,
     foldsValue: int,
     writeFoldsTarget: Optional[str]
@@ -97,18 +99,19 @@ def test_oopsieKwargsie() -> None:
     for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
         testFunction()
 
-# TODO mock CPU counts?
-# @pytest.mark.parametrize("CPUlimit, expectedLimit", [
-#     (None, numba.config.NUMBA_DEFAULT_NUM_THREADS),
-#     (False, numba.config.NUMBA_DEFAULT_NUM_THREADS),
-#     (True, 1),
-#     (4, 4),
-#     (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
-#     (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
-#     (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)),
-# ])
-# def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
-#     standardComparison(expectedLimit, setCPUlimit, CPUlimit)
+@pytest.mark.parametrize("CPUlimit, expectedLimit", [
+    (None, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (False, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (True, 1),
+    (4, 4),
+    (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)), # type: ignore
+    (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)), # type: ignore
+    (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)), # type: ignore
+    (0, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (1, 1),
+])
+def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
+    standardComparison(expectedLimit, setCPUlimit, CPUlimit)
 
 def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
@@ -119,80 +122,147 @@ def test_makeConnectionGraph_datatype(listDimensionsTestFunctionality: List[int]
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality, datatype=datatype)
     assert connectionGraph.dtype == datatype, f"Expected datatype {datatype}, but got {connectionGraph.dtype}."
 
-# @pytest.mark.parametrize("computationDivisions,CPUlimit,datatypeOverrides", [
-#     (None, None, {}),  # Basic case
-#     ("maximum", True, {"datatypeDefault": numpy.int32}),  # Max divisions, min CPU, custom dtype
-#     ("cpu", 4, {"datatypeLarge": numpy.int64}),  # CPU-based divisions, fixed CPU limit
-#     (3, 0.5, {}),  # Fixed divisions, fractional CPU
-# ])
-# def test_outfitCountFolds(
-#     listDimensionsTestFunctionality: List[int],
-#     computationDivisions: Optional[Union[int, str]],
-#     CPUlimit: Optional[Union[bool, float, int]],
-#     datatypeOverrides: Dict[str, Any]
-# ) -> None:
-#     """Test outfitCountFolds as a nexus of configuration and initialization.
-
-#     Strategy:
-#     1. Validate structure against computationState TypedDict
-#     2. Compare with direct function calls
-#     3. Verify enum-based indexing
-#     4. Check datatypes and shapes
-#     """
-#     # Get initialized state
-#     stateInitialized = outfitCountFolds(
-#         listDimensionsTestFunctionality,
-#         computationDivisions=computationDivisions,
-#         CPUlimit=CPUlimit,
-#         **datatypeOverrides
-#     )
-
-#     # 1. TypedDict structure validation
-#     for keyRequired in computationState.__annotations__:
-#         assert keyRequired in stateInitialized, f"Missing required key: {keyRequired}"
-#         assert stateInitialized[keyRequired] is not None, f"Key has None value: {keyRequired}"
-
-#         # Type checking
-#         expectedType = computationState.__annotations__[keyRequired]
-#         assert isinstance(stateInitialized[keyRequired], expectedType), \
-#             f"Type mismatch for {keyRequired}: expected {expectedType}, got {type(stateInitialized[keyRequired])}"
-
-#     # 2. Compare with direct function calls
-#     directMapShape = tuple(sorted(validateListDimensions(listDimensionsTestFunctionality)))
-#     assert stateInitialized['mapShape'] == directMapShape
-
-#     directConnectionGraph = makeConnectionGraph(
-#         directMapShape,
-#         datatype=datatypeOverrides.get('datatypeDefault', dtypeDefault)
-#     )
-#     assert numpy.array_equal(stateInitialized['connectionGraph'], directConnectionGraph)
-
-#     # 3. Enum-based indexing validation
-#     for arrayName, indexEnum in [
-#         ('my', indexMy),
-#         ('the', indexThe),
-#         ('track', indexTrack)
-#     ]:
-#         array = stateInitialized[arrayName]
-#         assert array.shape[0] >= len(indexEnum), \
-#             f"Array {arrayName} too small for enum {indexEnum.__name__}"
-
-#         # Test each enum index
-#         for enumMember in indexEnum:
-#             assert array[enumMember.value] >= 0, \
-#                 f"Negative value at {arrayName}[{enumMember.name}]"
-
-#     # 4. Special value checks
-#     assert stateInitialized['my'][indexMy.leaf1ndex.value] == 1, \
-#         "Initial leaf index should be 1"
-
-#     # 5. Shape consistency
-#     leavesTotal = getLeavesTotal(listDimensionsTestFunctionality)
-#     assert stateInitialized['foldsSubTotals'].shape == (leavesTotal,), \
-#         "foldsSubTotals shape mismatch"
-#     assert stateInitialized['gapsWhere'].shape == (leavesTotal * leavesTotal + 1,), \
-#         "gapsWhere shape mismatch"
-#     assert stateInitialized['track'].shape == (len(indexTrack), leavesTotal + 1), \
-#         "track shape mismatch"
-
-# TODO test `outfitCountFolds`; no negative values in arrays; compare datatypes to the typeddict; compare the connection graph to making a graph
+
+"""5 parameters
+listDimensionsTestFunctionality
+
+computationDivisions
+    None
+    random: int, first included: 2, first excluded: leavesTotal
+    maximum
+    cpu
+
+CPUlimit
+    None
+    True
+    False
+    0
+    1
+    -1
+    random: 0 < float < 1
+    random: -1 < float < 0
+    random: int, first included: 2, first excluded: (min(leavesTotal, 16) - 1)
+    random: int, first included: -1 * (min(leavesTotal, 16) - 1), first excluded: -1
+
+datatypeDefault
+    None
+    numpy.int64
+    numpy.intc
+    numpy.uint16
+
+datatypeLarge
+    None
+    numpy.int64
+    numpy.intp
+    numpy.uint32
+
+"""
+
+@pytest.fixture
+def parameterIterator():
+    """Generate random combinations of parameters for outfitCountFolds testing."""
+    parameterSets = {
+        'computationDivisions': [
+            None,
+            'maximum',
+            'cpu',
+        ],
+        'CPUlimit': [
+            None, True, False, 0, 1, -1,
+        ],
+        'datatypeDefault': [
+            None,
+            numpy.int64,
+            numpy.intc,
+            numpy.uint16
+        ],
+        'datatypeLarge': [
+            None,
+            numpy.int64,
+            numpy.intp,
+            numpy.uint32
+        ]
+    }
+
+    def makeParametersDynamic(listDimensions):
+        """Add context-dependent parameter values."""
+        parametersDynamic = parameterSets.copy()
+        leavesTotal = getLeavesTotal(listDimensions)
+        concurrencyLimit = min(leavesTotal, 16)
+
+        # Add dynamic computationDivisions
+        parametersDynamic['computationDivisions'].extend(
+            [random.randint(2, leavesTotal-1) for iterator in range(3)]
+        )
+
+        # Add dynamic CPUlimit values
+        parameterDynamicCPU = [
+            random.random(),  # 0 to 1
+            -random.random(), # -1 to 0
+        ]
+        parameterDynamicCPU.extend(
+            [random.randint(2, concurrencyLimit-1) for iterator in range(2)]
+        )
+        parameterDynamicCPU.extend(
+            [random.randint(-concurrencyLimit+1, -2) for iterator in range(2)]
+        )
+        parametersDynamic['CPUlimit'].extend(parameterDynamicCPU)
+
+        return parametersDynamic
+
+    def generateCombinations(listDimensions):
+        parametersDynamic = makeParametersDynamic(listDimensions)
+        parameterKeys = list(parametersDynamic.keys())
+        parameterValues = [parametersDynamic[key] for key in parameterKeys]
+
+        # Shuffle each parameter list
+        for valueList in parameterValues:
+            random.shuffle(valueList)
+
+        # Use zip_longest to iterate, filling with None when shorter lists are exhausted
+        for combination in itertools.zip_longest(*parameterValues, fillvalue=None):
+            yield dict(zip(parameterKeys, combination))
+
+    return generateCombinations
+
+def test_outfitCountFolds_basic(listDimensionsTestFunctionality, parameterIterator):
+    """Basic validation of outfitCountFolds return value structure."""
+    parameters = next(parameterIterator(listDimensionsTestFunctionality))
+
+    stateInitialized = outfitCountFolds(
+        listDimensionsTestFunctionality,
+        **{k: v for k, v in parameters.items() if v is not None}
+    )
+
+    # Basic structure tests
+    assert isinstance(stateInitialized, dict)
+    assert len(stateInitialized) == 7  # 6 ndarray + 1 tuple
+
+    # Check for specific keys
+    requiredKeys = set(computationState.__annotations__.keys())
+    assert set(stateInitialized.keys()) == requiredKeys
+
+    # Check types more carefully
+    for key, value in stateInitialized.items():
+        if key == 'mapShape':
+            assert isinstance(value, tuple)
+            assert all(isinstance(dim, int) for dim in value)
+        else:
+            assert isinstance(value, numpy.ndarray), f"{key} should be ndarray but is {type(value)}"
+            assert issubclass(value.dtype.type, numpy.integer), \
+                f"{key} should have integer dtype but has {value.dtype}"
+
+def test_pathJobDEFAULT_colab():
+    """Test that pathJobDEFAULT is set correctly when running in Google Colab."""
+    # Mock sys.modules to simulate running in Colab
+    with unittest.mock.patch.dict('sys.modules', {'google.colab': unittest.mock.MagicMock()}):
+        # Force reload of theSSOT to trigger Colab path logic
+        import importlib
+        import mapFolding.theSSOT
+        importlib.reload(mapFolding.theSSOT)
+
+        # Check that path was set to Colab-specific value
+        assert mapFolding.theSSOT.pathJobDEFAULT == pathlib.Path("/content/drive/MyDrive") / "jobs"
+
+    # Reload one more time to restore original state
+    importlib.reload(mapFolding.theSSOT)

tests/test_temporary.py

@@ -0,0 +1,25 @@
+from tests.conftest import *
+from typing import Dict, List, Tuple
+import importlib
+import pytest
+
+@pytest.fixture(scope="session", autouse=True)
+def runSecondSetAfterAll(request: pytest.FixtureRequest):
+    """Run after all other tests complete."""
+    def toggleAndRerun():
+        import mapFolding.importSelector
+        import mapFolding.babbage
+        mapFolding.importSelector.useLovelace = not mapFolding.importSelector.useLovelace
+        importlib.reload(mapFolding.importSelector)
+        importlib.reload(mapFolding.babbage)
+
+    request.addfinalizer(toggleAndRerun)
+
+@pytest.mark.order(after="runSecondSetAfterAll")
+def test_myabilitytodealwithbs(oeisID: str):
+    for n in settingsOEIS[oeisID]['valuesTestValidation']:
+        standardComparison(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+
+@pytest.mark.order(after="runSecondSetAfterAll")
+def test_eff_em_el(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
+    standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')

mapFolding/benchmarks/test_benchmarks.py

@@ -1,74 +0,0 @@
-from ...tests.conftest import *
-from .benchmarking import recordBenchmarks, runBenchmarks
-import numpy
-import pathlib
-import pytest
-import unittest.mock
-from typing import List
-
-def test_recordBenchmarks_decorator(pathBenchmarksTesting: pathlib.Path,
-                                    listDimensionsTestFunctionality: List[int],
-                                    mockBenchmarkTimer: unittest.mock.MagicMock):
-    """Test that the decorator correctly records benchmark data."""
-    @recordBenchmarks()
-    def functionTest(listDimensions: List[int]) -> int:
-        return sum(listDimensions)
-
-    with mockBenchmarkTimer:
-        mockBenchmarkTimer.side_effect = [0, 1e9]
-        result = functionTest(listDimensionsTestFunctionality)
-
-    # Verify function still works normally
-    assert result == sum(listDimensionsTestFunctionality)
-
-    # Verify benchmark data was saved
-    arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-    assert len(arrayBenchmarks) == 1
-    assert arrayBenchmarks[0]['time'] == 1.0
-    assert tuple(arrayBenchmarks[0]['dimensions']) == tuple(listDimensionsTestFunctionality)
-
-def test_recordBenchmarks_multiple_calls(pathBenchmarksTesting: pathlib.Path,
-                                        listDimensionsTestFunctionality: List[int],
-                                        mockBenchmarkTimer: unittest.mock.MagicMock):
-    """Test that multiple function calls append to benchmark data."""
-    @recordBenchmarks()
-    def functionTest(listDimensions: List[int]) -> int:
-        return sum(listDimensions)
-
-    with mockBenchmarkTimer:
-        mockBenchmarkTimer.side_effect = [0, 1e9, 2e9, 4e9]
-        functionTest(listDimensionsTestFunctionality)
-        functionTest(listDimensionsTestFunctionality)
-
-    arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-    assert len(arrayBenchmarks) == 2
-    assert arrayBenchmarks[0]['time'] == 1.0
-    assert arrayBenchmarks[1]['time'] == 2.0
-
-# NOTE This test tries to collect benchmark data without ensuring that a function is decorated.
-# def test_runBenchmarks_integration(pathBenchmarksTesting: pathlib.Path, listDimensionsTestFunctionality: List[int]):
-#     """Test runBenchmarks creates valid benchmark data."""
-#     countIterations = 2
-#     runBenchmarks(countIterations)
-
-#     arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-#     assert len(arrayBenchmarks) > 0  # Should have recorded some benchmarks
-
-#     # Verify data structure integrity
-#     assert arrayBenchmarks.dtype.names == ('time', 'dimensions')
-#     assert all(isinstance(record['time'], float) for record in arrayBenchmarks)
-#     assert all(isinstance(record['dimensions'], tuple) for record in arrayBenchmarks)
-
-#     # Verify at least one benchmark entry matches our test dimensions
-#     assert any(tuple(listDimensionsTestFunctionality) == record['dimensions'] for record in arrayBenchmarks)
-
-# NOTE This test tries to collect benchmark data without ensuring that a function is decorated.
-# @pytest.mark.parametrize("countIterations", [1, 2])
-# def test_runBenchmarks_iterations(countIterations: int, pathBenchmarksTesting: pathlib.Path, listDimensionsTestFunctionality: List[int]):
-#     """Test runBenchmarks records data for each iteration."""
-#     runBenchmarks(countIterations)
-#     arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-
-#     # Should have at least countIterations entries for our test dimensions
-#     countMatches = sum(1 for record in arrayBenchmarks if tuple(listDimensionsTestFunctionality) == record['dimensions'])
-#     assert countMatches >= countIterations