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

mapFolding/__init__.py

@@ -1,7 +1,6 @@
 from .theSSOT import *
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
-from .beDRY import getLeavesTotal, parseDimensions, validateListDimensions
+from .beDRY import getFilenameFoldsTotal, outfitCountFolds
 from .startHere import countFolds
 from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
 

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
@@ -6,7 +7,7 @@ import numba
 import numpy
 
 @numba.jit(cache=True)
-def _countFolds(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> int:
+def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
     """
     What in tarnation is this stupid module and function?
 
@@ -25,6 +26,10 @@ def _countFolds(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[inte
         - 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')
-    return countFoldsCompiled(connectionGraph, foldsTotal, my, gapsWhere, the, 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

@@ -1,14 +1,16 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from mapFolding import dtypeDefault, dtypeLarge
 from mapFolding import indexMy, indexThe, indexTrack, computationState
-from mapFolding import dtypeDefault, dtypeLarge, dtypeSmall
+from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from numpy import integer
+from numpy.typing import NDArray
 from typing import Any, List, Optional, Sequence, Type, Union
-import numpy
 import numba
-from numpy.typing import NDArray
-from numpy import integer
+import numpy
 import sys
-import operator
+
+def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
+    return str(sorted(listDimensions)).replace(' ', '') + '.foldsTotal'
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -146,7 +148,7 @@ def makeDataContainer(shape, datatype: Optional[Type] = None):
         datatype = dtypeDefault
     return numpy.zeros(shape, dtype=datatype)
 
-def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
     """
     Initializes and configures the computation state for map folding computations.
 
@@ -155,21 +157,33 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     listDimensions:
         The dimensions of the map to be folded
     computationDivisions (None):
-        Specifies how to divide the computation tasks
+        Specifies how to divide computations:
+        - None: no division of the computation into tasks; sets task divisions to 0
+        - int: direct set the number of task divisions; cannot exceed the map's total leaves
+        - "maximum": divides into `leavesTotal`-many `taskDivisions`
+        - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
     CPUlimit (None):
-        Limits the CPU usage for computations
+        Whether and how to limit the CPU usage. See notes for details.
 
     Returns
     -------
     computationState
         An initialized computation state containing:
         - connectionGraph: Graph representing connections in the map
-        - foldsTotal: Array tracking total folds
+        - foldsSubTotals: Array tracking total folds
         - mapShape: Validated and sorted dimensions of the map
         - my: Array for internal state tracking
         - gapsWhere: Array tracking gap positions
         - the: Static settings and metadata
         - track: Array for tracking computation progress
+
+    Limits on CPU usage `CPUlimit`:
+        - `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
+        - `True`: Yes, limit the CPU usage; limits to 1 CPU.
+        - Integer `>= 1`: Limits usage to the specified number of CPUs.
+        - Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
+        - Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
+        - Integer `<= -1`: Subtract the absolute value from total CPUs.
     """
     datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
     datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
@@ -181,10 +195,10 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     the[indexThe.dimensionsTotal] = len(mapShape)
     concurrencyLimit = setCPUlimit(CPUlimit)
     the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
-    
+
     stateInitialized = computationState(
         connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
-        foldsTotal = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
+        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
         mapShape = mapShape,
         my = makeDataContainer(len(indexMy), datatypeLarge),
         gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeDefault),
@@ -216,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)