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

mapFolding/__init__.py

@@ -1,6 +1,6 @@
 from .theSSOT import *
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getFilenameFoldsTotal, outfitCountFolds
+from .beDRY import getFilenameFoldsTotal, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
 from .startHere import countFolds
 from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
 

mapFolding/beDRY.py

@@ -1,5 +1,5 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge
+from mapFolding import dtypeDefault, dtypeLarge, pathJobDEFAULT
 from mapFolding import indexMy, indexThe, indexTrack, computationState
 from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
 from numpy import integer
@@ -7,10 +7,12 @@ from numpy.typing import NDArray
 from typing import Any, List, Optional, Sequence, Type, Union
 import numba
 import numpy
+import os
+import pathlib
 import sys
 
 def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
-    return str(sorted(listDimensions)).replace(' ', '') + '.foldsTotal'
+    return str(sorted(listDimensions)).replace(', ', 'x') + '.foldsTotal'
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -36,6 +38,14 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
         return productDimensions
 
+def getPathFilenameFoldsTotal(listDimensions: Sequence[int], pathishWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
+    pathFilenameFoldsTotal = pathlib.Path(pathishWriteFoldsTotal) if pathishWriteFoldsTotal is not None else pathJobDEFAULT
+    if pathFilenameFoldsTotal.is_dir():
+        filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(listDimensions)
+        pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
+    pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+    return pathFilenameFoldsTotal
+
 def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
     """
     Determines whether or how to divide the computation into tasks.
@@ -148,7 +158,7 @@ def makeDataContainer(shape, datatype: Optional[Type] = None):
         datatype = dtypeDefault
     return numpy.zeros(shape, dtype=datatype)
 
-def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type[Any]]) -> computationState:
     """
     Initializes and configures the computation state for map folding computations.
 
@@ -232,6 +242,40 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
 
     return listNonNegative
 
+import tempfile
+import shutil
+import logging
+import os
+def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int) -> None:
+    """
+    Save foldsTotal with multiple fallback mechanisms.
+
+    Parameters:
+        pathFilename: Target save location
+        foldsTotal: Critical computed value to save
+    """
+    """Thoughts
+    Everything in a try block
+    Save it multiple times with multiple packages
+    no need for context managers, especially because they can cause errors"""
+    try:
+        pathFilenameFoldsTotal = pathlib.Path(pathFilename)
+        pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+        pathFilenameFoldsTotal.write_text(str(foldsTotal))
+    except Exception as ERRORmessage:
+        try:
+            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+            print(ERRORmessage)
+            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+            randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+            filenameInfixUnique = ''.join(randomnessPlanB)
+            import os
+            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+            open(pathFilenamePlanB, 'w').write(str(foldsTotal))
+            print(str(pathFilenamePlanB))
+        except:
+            print(foldsTotal)
+
 def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
     """Sets CPU limit for Numba concurrent operations. Note that it can only affect Numba-jitted functions that have not yet been imported.
 

mapFolding/importSelector.py

@@ -1,12 +1,7 @@
-# useLovelace = True
-useLovelace = False
+from mapFolding.lovelace import countSequential
+from mapFolding.lovelace import countParallel
+from mapFolding.lovelace import countInitialize
 
-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
+# from mapFolding.countSequential import countSequential
+# from mapFolding.countParallel import countParallel
+# from mapFolding.countInitialize import countInitialize

mapFolding/{JAX/lunnanJAX.py → reference/jax.py}

@@ -1,3 +1,5 @@
+"""I was able to implement the algorithm with JAX, but I didn't see an advantage and it's a pain in the ass.
+I don't maintain this module."""
 from mapFolding import validateListDimensions, getLeavesTotal, makeConnectionGraph
 from typing import List, Tuple
 import jax

mapFolding/{inlineAfunction.py → someAssemblyRequired/inlineAfunction.py}

@@ -1,19 +1,22 @@
 from mapFolding import indexMy, indexThe, indexTrack
 import ast
+import copy
 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
+def getDictionaryEnumValues():
+    dictionaryEnumValues = {}
+    for enumIndex in [indexMy, indexThe, indexTrack]:
+        for memberName, memberValue in enumIndex._member_map_.items():
+            dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
+    return dictionaryEnumValues
 
-class RecursiveInliner(ast.NodeTransformer):
+class RecursiveInlinerWithEnum(ast.NodeTransformer):
     def __init__(self, dictionaryFunctions, dictionaryEnumValues):
         self.dictionaryFunctions = dictionaryFunctions
         self.dictionaryEnumValues = dictionaryEnumValues
         self.processed = set()  # Track processed functions to avoid infinite recursion
 
-    def inline_function_body(self, functionName):
+    def inlineFunctionBody(self, functionName):
         if functionName in self.processed:
             return None
 
@@ -35,7 +38,7 @@ class RecursiveInliner(ast.NodeTransformer):
     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)
+            inlineDefinition = self.inlineFunctionBody(callNode.func.id)
             if inlineDefinition and inlineDefinition.body:
                 lastStmt = inlineDefinition.body[-1]
                 if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
@@ -48,23 +51,23 @@ class RecursiveInliner(ast.NodeTransformer):
     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)
+                inlineDefinition = self.inlineFunctionBody(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."""
+def findRequiredImports(node):
+    """Find all modules that need to be imported based on AST analysis.
+    NOTE: due to hardcoding, this is a glorified regex. No, wait, this is less versatile than regex."""
     requiredImports = set()
 
     class ImportFinder(ast.NodeVisitor):
         def visit_Name(self, node):
-            # Common modules we might need
             if node.id in {'numba'}:
                 requiredImports.add(node.id)
             self.generic_visit(node)
 
-        def visit_Decorator(self, node):
+        def visitDecorator(self, node):
             if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
                 if node.func.id == 'jit':
                     requiredImports.add('numba')
@@ -73,7 +76,7 @@ def find_required_imports(node):
     ImportFinder().visit(node)
     return requiredImports
 
-def generate_imports(requiredImports):
+def generateImports(requiredImports):
     """Generate import statements based on required modules."""
     importStatements = []
 
@@ -88,7 +91,7 @@ def generate_imports(requiredImports):
 
     return '\n'.join(importStatements)
 
-def inline_functions(sourceCode, targetFunctionName, dictionaryEnumValues):
+def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues):
     dictionaryParsed = ast.parse(sourceCode)
     dictionaryFunctions = {
         element.name: element
@@ -96,29 +99,54 @@ def inline_functions(sourceCode, targetFunctionName, dictionaryEnumValues):
         if isinstance(element, ast.FunctionDef)
     }
     nodeTarget = dictionaryFunctions[targetFunctionName]
-    nodeInliner = RecursiveInliner(dictionaryFunctions, dictionaryEnumValues)
+    nodeInliner = RecursiveInlinerWithEnum(dictionaryFunctions, dictionaryEnumValues)
     nodeInlined = nodeInliner.visit(nodeTarget)
     ast.fix_missing_locations(nodeInlined)
 
     # Generate imports
-    requiredImports = find_required_imports(nodeInlined)
-    importStatements = generate_imports(requiredImports)
+    requiredImports = findRequiredImports(nodeInlined)
+    importStatements = generateImports(requiredImports)
 
     # Combine imports with inlined code
     inlinedCode = importStatements + '\n\n' + ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
     return inlinedCode
 
-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)
+def Z0Z_inlineMapFolding():
+    dictionaryEnumValues = getDictionaryEnumValues()
+
+    pathFilenameSource = pathlib.Path("/apps/mapFolding/mapFolding/lovelace.py")
+    codeSource = pathFilenameSource.read_text()
+
+    listCallables = [
+        'countInitialize',
+        'countParallel',
+        'countSequential',
+    ]
+
+    listPathFilenamesDestination: list[pathlib.Path] = []
+    for callableTarget in listCallables:
+        pathFilenameDestination = pathFilenameSource.with_stem(callableTarget)
+        codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues)
+        pathFilenameDestination.write_text(codeInlined)
+        listPathFilenamesDestination.append(pathFilenameDestination)
+
+    listNoNumba = [
+        'countInitialize',
+        'countSequential',
+    ]
+
+    listPathFilenamesNoNumba = []
+    for pathFilename in listPathFilenamesDestination:
+        if pathFilename.stem in listNoNumba:
+            pathFilenameNoNumba = pathFilename.with_name(pathFilename.stem + 'NoNumba' + pathFilename.suffix)
+        else:
+            continue
+        codeNoNumba = pathFilename.read_text()
+        for codeLine in copy.copy(codeNoNumba.splitlines()):
+            if 'numba' in codeLine:
+                codeNoNumba = codeNoNumba.replace(codeLine, '')
+        pathFilenameNoNumba.write_text(codeNoNumba)
+        listPathFilenamesNoNumba.append(pathFilenameNoNumba)
+
+if __name__ == '__main__':
+    Z0Z_inlineMapFolding()

mapFolding/someAssemblyRequired/jobsAndTasks.py

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

mapFolding/someAssemblyRequired/makeNuitkaSource.py

@@ -0,0 +1,99 @@
+"""NOTE make a special venv for nuitka, then run nuitka from that venv"""
+from pathlib import Path
+from pickle import loads
+from typing import Final
+import numpy
+from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
+
+"""
+Section: configure every time"""
+
+# TODO configure this
+mapShape = [3]*3
+# NOTE ^^^^^^ pay attention
+
+"""
+Section: settings"""
+
+pathFilenameData = Z0Z_makeJob(mapShape)
+
+pathJob = pathFilenameData.parent
+
+pathFilenameAlgorithm = Path('/apps/mapFolding/mapFolding/countSequentialNoNumba.py')
+pathFilenameDestination = Path(f"/apps/mapFolding/nn/{pathJob.name}.py")
+
+"""
+Section: did you handle and include this stuff?"""
+
+lineImportNumPy = "import numpy"
+linePrintFoldsTotal = "print(foldsSubTotals.sum().item())"
+linesAlgorithm = """"""
+linesData = """"""
+settingsNuitkaProject=f"""
+# nuitka-project: --mode=onefile
+# nuitka-project: --onefile-no-compression
+# nuitka-project: --lto=yes
+# nuitka-project: --clang
+# nuitka-project: --output-dir={pathJob}
+# nuitka-project: --output-filename={pathJob.name}.exe
+"""
+# nuitka-project:
+"""
+Section: do the work"""
+
+WTFamIdoing = pathFilenameAlgorithm.read_text()
+for lineSource in WTFamIdoing.splitlines():
+    ImaIndent = '    '
+    if lineSource.startswith(ImaIndent):
+        lineSource = lineSource[len(ImaIndent):None]
+    elif lineSource.startswith('#'):
+        continue
+    elif not lineSource:
+        continue
+    elif lineSource.startswith('def '):
+        continue
+    else:
+        raise NotImplementedError("You didn't anticipate this.")
+    linesAlgorithm = "\n".join([linesAlgorithm
+                            , lineSource
+                            ])
+
+stateJob = loads(pathFilenameData.read_bytes())
+connectionGraph: Final[numpy.ndarray] = stateJob['connectionGraph']
+foldsSubTotals: numpy.ndarray = stateJob['foldsSubTotals']
+gapsWhere: numpy.ndarray = stateJob['gapsWhere']
+my: numpy.ndarray = stateJob['my']
+the: numpy.ndarray = stateJob['the']
+track: numpy.ndarray = stateJob['track']
+
+pathFilenameFoldsTotal = stateJob['pathFilenameFoldsTotal']
+lineDataPathFilenameFoldsTotal = "pathFilenameFoldsTotal = r'" + str(pathFilenameFoldsTotal) + "'\n"
+
+def archivistFormatsArrayToCode(arrayTarget: numpy.ndarray, identifierName: str) -> str:
+    """Format numpy array into a code string that recreates the array."""
+    arrayAsTypeStr = numpy.array2string(
+        arrayTarget,
+        threshold=10000,
+        max_line_width=100,
+        separator=','
+        )
+    return f"{identifierName} = numpy.array({arrayAsTypeStr}, dtype=numpy.{arrayTarget.dtype})\n"
+
+linesData = "\n".join([linesData
+            , lineDataPathFilenameFoldsTotal
+            , archivistFormatsArrayToCode(the, 'the')
+            , archivistFormatsArrayToCode(my, 'my')
+            , archivistFormatsArrayToCode(foldsSubTotals, 'foldsSubTotals')
+            , archivistFormatsArrayToCode(gapsWhere, 'gapsWhere')
+            , archivistFormatsArrayToCode(connectionGraph, 'connectionGraph')
+            , archivistFormatsArrayToCode(track, 'track')
+            ])
+
+linesAll = "\n".join([settingsNuitkaProject
+            , lineImportNumPy
+            , linesData
+            , linesAlgorithm
+            , linePrintFoldsTotal
+            ])
+
+pathFilenameDestination.write_text(linesAll)

mapFolding/someAssemblyRequired/makeNumbaJob.py

@@ -0,0 +1,121 @@
+"""Create a python module hardcoded to compute a map's foldsTotal.
+NumPy ndarray.
+Numba optimized.
+Absolutely no other imports.
+"""
+from mapFolding import datatypeLarge, dtypeLarge, dtypeDefault
+from mapFolding.someAssemblyRequired.inlineAfunction import Z0Z_inlineMapFolding
+from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
+import importlib
+import llvmlite.binding
+import numpy
+import pathlib
+import pickle
+
+listDimensions = [3,7]
+
+# NOTE this overwrites files
+Z0Z_inlineMapFolding()
+
+identifierCallableLaunch = "goGoGadgetAbsurdity"
+
+def archivistFormatsArrayToCode(arrayTarget: numpy.ndarray, identifierName: str) -> str:
+    """Format numpy array into a code string that recreates the array."""
+    arrayAsTypeStr = numpy.array2string(arrayTarget, threshold=10000, max_line_width=200, separator=',')
+    return f"{identifierName} = numpy.array({arrayAsTypeStr}, dtype=numpy.{arrayTarget.dtype})"
+
+def writeModuleWithNumba(listDimensions):
+    numpy_dtypeLarge = dtypeLarge
+    numpy_dtypeDefault = dtypeDefault
+
+    parametersNumba = f"numba.types.{datatypeLarge}(), cache=True, parallel=False, boundscheck=False, \
+        error_model='numpy', fastmath=True, nogil=True, nopython=True, _nrt=True, forceinline=True, \
+            inline=True, looplift=True, no_cfunc_wrapper=False, no_cpython_wrapper=False"
+
+    pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge)
+
+    pathFilenameAlgorithm = pathlib.Path('/apps/mapFolding/mapFolding/countSequentialNoNumba.py')
+    pathFilenameDestination = pathFilenameData.with_stem(pathFilenameData.parent.name).with_suffix(".py")
+
+    lineNumba = f"@numba.jit({parametersNumba})"
+
+    linesImport = "\n".join([
+                        "import numpy"
+                        , "import numba"
+                        ])
+
+    stateJob = pickle.loads(pathFilenameData.read_bytes())
+
+    ImaIndent = '    '
+    linesDataDynamic = """"""
+    linesDataDynamic = "\n".join([linesDataDynamic
+            , ImaIndent + archivistFormatsArrayToCode(stateJob['my'], 'my')
+            , ImaIndent + archivistFormatsArrayToCode(stateJob['foldsSubTotals'], 'foldsSubTotals')
+            , ImaIndent + archivistFormatsArrayToCode(stateJob['gapsWhere'], 'gapsWhere')
+            , ImaIndent + archivistFormatsArrayToCode(stateJob['track'], 'track')
+            ])
+
+    linesDataStatic = """"""
+    linesDataStatic = "\n".join([linesDataStatic
+            , ImaIndent + archivistFormatsArrayToCode(stateJob['the'], 'the')
+            , ImaIndent + archivistFormatsArrayToCode(stateJob['connectionGraph'], 'connectionGraph')
+            ])
+
+    pathFilenameFoldsTotal: pathlib.Path = stateJob['pathFilenameFoldsTotal']
+
+    linesAlgorithm = """"""
+    for lineSource in pathFilenameAlgorithm.read_text().splitlines():
+        if lineSource.startswith('#'):
+            continue
+        elif not lineSource:
+            continue
+        elif lineSource.startswith('def '):
+            lineSource = "\n".join([lineNumba
+                                , f"def {identifierCallableLaunch}():"
+                                , linesDataDynamic
+                                , linesDataStatic
+                                ])
+        linesAlgorithm = "\n".join([linesAlgorithm
+                            , lineSource
+                            ])
+
+    lineReturn = f"{ImaIndent}return foldsSubTotals.sum().item()"
+
+    linesLaunch = """"""
+    linesLaunch = linesLaunch + f"""
+if __name__ == '__main__':
+    foldsTotal = {identifierCallableLaunch}()"""
+
+    linesWriteFoldsTotal = """"""
+    linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
+                                    , "    print(foldsTotal)"
+                                    , f"    open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    ])
+
+    linesAll = "\n".join([
+                        linesImport
+                        , linesAlgorithm
+                        , f"{ImaIndent}print(foldsSubTotals.sum().item())"
+                        , lineReturn
+                        , linesLaunch
+                        , linesWriteFoldsTotal
+                        ])
+
+    pathFilenameDestination.write_text(linesAll)
+
+    return pathFilenameDestination
+
+def writeModuleLLVM(pathFilenamePythonFile: pathlib.Path) -> pathlib.Path:
+    pathRootPackage = pathlib.Path('c:/apps/mapFolding')
+    relativePathModule = pathFilenamePythonFile.relative_to(pathRootPackage)
+    moduleTarget = '.'.join(relativePathModule.parts)[0:-len(relativePathModule.suffix)]
+    moduleTargetImported = importlib.import_module(moduleTarget)
+    linesLLVM = moduleTargetImported.__dict__[identifierCallableLaunch].inspect_llvm()[()]
+    moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
+    pathFilenameLLVM = pathFilenamePythonFile.with_suffix(".ll")
+    pathFilenameLLVM.write_text(str(moduleLLVM))
+    return pathFilenameLLVM
+
+if __name__ == '__main__':
+    pathFilenamePythonFile = writeModuleWithNumba(listDimensions)
+    pathFilenameLLVM = writeModuleLLVM(pathFilenamePythonFile)

mapFolding/startHere.py

@@ -1,15 +1,14 @@
-from mapFolding import outfitCountFolds, getFilenameFoldsTotal
-from typing import Optional, Sequence, Type, Union
+from mapFolding import outfitCountFolds, getPathFilenameFoldsTotal, saveFoldsTotal
+from typing import Any, Optional, Sequence, Type, Union
 import os
-import pathlib
 
-def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None, computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[int, float, bool]] = None, **keywordArguments: Optional[Type]) -> int:
+def countFolds(listDimensions: Sequence[int], pathishWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None, computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[int, float, bool]] = None, **keywordArguments: Optional[Type[Any]]) -> int:
     """Count the total number of possible foldings for a given map dimensions.
 
     Parameters:
         listDimensions: List of integers representing the dimensions of the map to be folded.
-        writeFoldsTotal (None): Path or filename to write the total fold count.
-            If a directory is provided, creates a file with default name based on map dimensions.
+        pathishWriteFoldsTotal (None): Path, filename, or pathFilename to write the total fold count to.
+            If a directory is provided, creates a file with a default name based on map dimensions.
         computationDivisions (None):
             Whether and how to divide the computational work. See notes for details.
         CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
@@ -37,12 +36,8 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
     stateUniversal = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
 
     pathFilenameFoldsTotal = None
-    if writeFoldsTotal is not None:
-        pathFilenameFoldsTotal = pathlib.Path(writeFoldsTotal)
-        if pathFilenameFoldsTotal.is_dir():
-            filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(stateUniversal['mapShape'])
-            pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
-        pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+    if pathishWriteFoldsTotal is not None:
+        pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathishWriteFoldsTotal)
 
     from mapFolding.babbage import _countFolds
     _countFolds(**stateUniversal)
@@ -50,10 +45,6 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
     foldsTotal = stateUniversal['foldsSubTotals'].sum().item()
 
     if pathFilenameFoldsTotal is not None:
-        try:
-            pathFilenameFoldsTotal.write_text(str(foldsTotal))
-        except Exception as ERRORmessage:
-            print(ERRORmessage)
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
+        saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
 
     return foldsTotal

{mapFolding-0.2.4.dist-info → mapFolding-0.2.5.dist-info}/METADATA

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

{mapFolding-0.2.4.dist-info → mapFolding-0.2.5.dist-info}/RECORD

@@ -1,35 +1,33 @@
-mapFolding/__init__.py,sha256=wnf2EzHR2unVha6-Y0gRoSPaE4PDdT4VngINa_dfT2E,337
+mapFolding/__init__.py,sha256=yZ_rcMMCco346M62nKzp90GPp9OV1UkkWSxKzP3ISPA,380
 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/beDRY.py,sha256=IhBnlo-Lg8DBaebTDAyJ7OiGUce9OFbNUNHJmlB04L0,15835
+mapFolding/importSelector.py,sha256=sc9IGk8CpCNerFbuYnrroBH-itqsxjeBc4VYjiesOQo,310
 mapFolding/lovelace.py,sha256=iu7anbA_TacIAjc4EKkeBVxIJKAMdrYgvR4evzMZ1WY,15193
 mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
-mapFolding/startHere.py,sha256=or7QhxgMls2hvP_I2eTBP5tffLrc3SMiE5Gz_Ik2aJY,4328
+mapFolding/startHere.py,sha256=Bu4boZnxlx66IU7RIsBRq00JScE0DWqKLAclUMPGOSM,3892
 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=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
+mapFolding/reference/jax.py,sha256=bB34dGdi3VSz4cRFbmCPn_erAmQ3FyrSED8uJ7CsES0,14961
 mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
 mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
 mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
 mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
 mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+mapFolding/someAssemblyRequired/inlineAfunction.py,sha256=Hxytb9xgJV_Mnh8us0mA_oKwanEQWJSj3hJc25nI9Mk,6143
+mapFolding/someAssemblyRequired/jobsAndTasks.py,sha256=u2ZtZ8xlQJALqQqQ8N7uBTNDbjG4OQ9nJsJZG5rLI8o,2189
+mapFolding/someAssemblyRequired/makeNuitkaSource.py,sha256=jTK34OWzm6OsgFPd2mHwETxFo2X83io0M4YiEHRgk3U,3262
+mapFolding/someAssemblyRequired/makeNumbaJob.py,sha256=YZ9JzzEieQH4sMqX84VGbpOJmdBatPanfmXFZ5V1Ex4,5109
 tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
 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=amhsy7VWzpuW_slBOTFPhC7e4o4k6Yp4xweNK1VHZnc,11906
+tests/test_other.py,sha256=1EtLe0te7qqdazFKvKIOHPYW_ENsqAu11nzJO0yAE_Q,12012
 tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
-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,,
+mapFolding-0.2.5.dist-info/METADATA,sha256=pKBorE-WQsa2LVETIUORCw-ae3cDPtUcLbE395-oVhs,6652
+mapFolding-0.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.5.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.5.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.5.dist-info/RECORD,,

tests/test_other.py

@@ -84,7 +84,7 @@ def test_countFolds_writeFoldsTotal(
     mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
 
     with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
-        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathWriteTarget)
+        returned = countFolds(listDimensionsTestFunctionality, pathishWriteFoldsTotal=pathWriteTarget)
 
     standardComparison(foldsValue, lambda: returned)  # Check return value
     standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
@@ -224,33 +224,33 @@ def parameterIterator():
             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}"
+# Must mock the set cpu count to avoid errors on GitHub
+# 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."""

mapFolding/JAX/taskJAX.py

@@ -1,313 +0,0 @@
-from mapFolding import validateListDimensions, getLeavesTotal
-from typing import List, Tuple
-import jax
-import jaxtyping
-
-dtypeDefault = jax.numpy.int32
-dtypeMaximum = jax.numpy.int32
-
-def countFolds(listDimensions: List[int]):
-    """Calculate foldings across multiple devices using pmap"""
-    p = validateListDimensions(listDimensions)
-    n = getLeavesTotal(p)
-
-    # Get number of devices (GPUs/TPUs)
-    deviceCount = jax.device_count()
-
-    if deviceCount > 1:
-        # Split work across devices
-        tasksPerDevice = (n + deviceCount - 1) // deviceCount
-        paddedTaskCount = tasksPerDevice * deviceCount
-
-        # Create padded array of task indices
-        arrayTaskIndices = jax.numpy.arange(paddedTaskCount, dtype=dtypeDefault)
-        arrayTaskIndices = arrayTaskIndices.reshape((deviceCount, tasksPerDevice))
-
-        # Create pmapped function
-        parallelFoldingsTask = jax.pmap(lambda x: jax.vmap(lambda y: foldingsTask(tuple(p), y))(x))
-
-        # Run computation across devices
-        arrayResults = parallelFoldingsTask(arrayTaskIndices)
-
-        # Sum valid results (ignore padding)
-        return jax.numpy.sum(arrayResults[:, :min(tasksPerDevice, n - tasksPerDevice * (deviceCount-1))])
-    else:
-        # Fall back to sequential execution if no multiple devices available
-        arrayTaskIndices = jax.numpy.arange(n, dtype=dtypeDefault)
-        batchedFoldingsTask = jax.vmap(lambda x: foldingsTask(tuple(p), x))
-        return jax.numpy.sum(batchedFoldingsTask(arrayTaskIndices))
-
-def foldingsTask(p, taskIndex) -> jaxtyping.UInt32:
-    arrayDimensions = jax.numpy.asarray(p, dtype=dtypeDefault)
-    leavesTotal = jax.numpy.prod(arrayDimensions)
-    dimensionsTotal = jax.numpy.size(arrayDimensions)
-
-    """How to build a leaf connection graph, also called a "Cartesian Product Decomposition"
-    or a "Dimensional Product Mapping", with sentinels:
-    Step 1: find the cumulative product of the map's dimensions"""
-    cumulativeProduct = jax.numpy.ones(dimensionsTotal + 1, dtype=dtypeDefault)
-    cumulativeProduct = cumulativeProduct.at[1:].set(jax.numpy.cumprod(arrayDimensions))
-
-    """Step 2: for each dimension, create a coordinate system """
-    """coordinateSystem[dimension1ndex][leaf1ndex] holds the dimension1ndex-th coordinate of leaf leaf1ndex"""
-    coordinateSystem = jax.numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
-
-    # Create mesh of indices for vectorized computation
-    dimension1ndices, leaf1ndices = jax.numpy.meshgrid(
-        jax.numpy.arange(1, dimensionsTotal + 1),
-        jax.numpy.arange(1, leavesTotal + 1),
-        indexing='ij'
-    )
-
-    # Compute all coordinates at once using broadcasting
-    coordinateSystem = coordinateSystem.at[1:, 1:].set(
-        ((leaf1ndices - 1) // cumulativeProduct.at[dimension1ndices - 1].get()) %
-        arrayDimensions.at[dimension1ndices - 1].get() + 1
-    )
-    del dimension1ndices, leaf1ndices
-
-    """Step 3: create a huge empty connection graph"""
-    connectionGraph = jax.numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
-
-    # Create 3D mesh of indices for vectorized computation
-    dimension1ndices, activeLeaf1ndices, connectee1ndices = jax.numpy.meshgrid(
-        jax.numpy.arange(1, dimensionsTotal + 1),
-        jax.numpy.arange(1, leavesTotal + 1),
-        jax.numpy.arange(1, leavesTotal + 1),
-        indexing='ij'
-    )
-
-    # Create masks for valid indices
-    maskActiveConnectee = connectee1ndices <= activeLeaf1ndices
-
-    # Calculate coordinate parity comparison
-    coordsParity = (coordinateSystem.at[dimension1ndices, activeLeaf1ndices].get() & 1) == \
-                    (coordinateSystem.at[dimension1ndices, connectee1ndices].get() & 1)
-
-    # Compute distance conditions
-    isFirstCoord = coordinateSystem.at[dimension1ndices, connectee1ndices].get() == 1
-    isLastCoord = coordinateSystem.at[dimension1ndices, connectee1ndices].get() == \
-                    arrayDimensions.at[dimension1ndices - 1].get()
-    exceedsActive = connectee1ndices + cumulativeProduct.at[dimension1ndices - 1].get() > activeLeaf1ndices
-
-    # Compute connection values for even and odd parities
-    evenParityValues = jax.numpy.where(
-        isFirstCoord,
-        connectee1ndices,
-        connectee1ndices - cumulativeProduct.at[dimension1ndices - 1].get()
-    )
-
-    oddParityValues = jax.numpy.where(
-        jax.numpy.logical_or(isLastCoord, exceedsActive),
-        connectee1ndices,
-        connectee1ndices + cumulativeProduct.at[dimension1ndices - 1].get()
-    )
-
-    # Combine based on parity and valid indices
-    connectionValues = jax.numpy.where(
-        coordsParity,
-        evenParityValues,
-        oddParityValues
-    )
-
-    # Update only valid connections
-    connectionGraph = connectionGraph.at[dimension1ndices, activeLeaf1ndices, connectee1ndices].set(
-        jax.numpy.where(maskActiveConnectee, connectionValues, 0)
-    )
-
-    def doNothing(argument):
-        return argument
-
-    def while_activeLeaf1ndex_greaterThan_0(comparisonValues: Tuple):
-        comparand = comparisonValues[6]
-        return comparand > 0
-
-    def countFoldings(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        _0, leafBelow, _2, _3, _4, _5, activeLeaf1ndex, _7 = allValues
-
-        sentinel = leafBelow.at[0].get().astype(jax.numpy.int32)
-
-        allValues = jax.lax.cond(findGapsCondition(sentinel, activeLeaf1ndex),
-                            lambda argumentX: dao(findGapsDo(argumentX)),
-                            lambda argumentY: jax.lax.cond(incrementCondition(sentinel, activeLeaf1ndex), lambda argumentZ: dao(incrementDo(argumentZ)), dao, argumentY),
-                            allValues)
-
-        return allValues
-
-    def findGapsCondition(leafBelowSentinel, activeLeafNumber):
-        return jax.numpy.logical_or(jax.numpy.logical_and(leafBelowSentinel == 1, activeLeafNumber <= leavesTotal), activeLeafNumber <= 1)
-
-    def findGapsDo(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        def for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1(comparisonValues: Tuple):
-            return comparisonValues[-1] <= dimensionsTotal
-
-        def for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1_do(for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-            def ifLeafIsUnconstrainedCondition(comparand):
-                return jax.numpy.equal(connectionGraph[comparand, activeLeaf1ndex, activeLeaf1ndex], activeLeaf1ndex)
-
-            def ifLeafIsUnconstrainedDo(unconstrainedValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                unconstrained_unconstrainedLeaf = unconstrainedValues[3]
-                unconstrained_unconstrainedLeaf = 1 + unconstrained_unconstrainedLeaf
-                return (unconstrainedValues[0], unconstrainedValues[1], unconstrainedValues[2], unconstrained_unconstrainedLeaf)
-
-            def ifLeafIsUnconstrainedElse(unconstrainedValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                def while_leaf1ndexConnectee_notEquals_activeLeaf1ndex(comparisonValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                    return comparisonValues[-1] != activeLeaf1ndex
-
-                def countGaps(countGapsDoValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                    # if taskDivisions == False or activeLeaf1ndex != leavesTotal or leaf1ndexConnectee % leavesTotal == taskIndex:
-                    def taskDivisionComparison():
-                        return jax.numpy.logical_or(activeLeaf1ndex != leavesTotal, jax.numpy.equal(countGapsLeaf1ndexConnectee % leavesTotal, taskIndex))
-                        # return taskDivisions == False or jax.numpy.logical_or(activeLeaf1ndex != leavesTotal, jax.numpy.equal(countGapsLeaf1ndexConnectee % leavesTotal, taskIndex))
-
-                    def taskDivisionDo(taskDivisionDoValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
-                        taskDivisionCountDimensionsGapped, taskDivisionPotentialGaps, taskDivisionGap1ndexLowerBound = taskDivisionDoValues
-
-                        taskDivisionPotentialGaps = taskDivisionPotentialGaps.at[taskDivisionGap1ndexLowerBound].set(countGapsLeaf1ndexConnectee)
-                        taskDivisionGap1ndexLowerBound = jax.numpy.where(
-                            jax.numpy.equal(taskDivisionCountDimensionsGapped.at[countGapsLeaf1ndexConnectee].get(), 0), taskDivisionGap1ndexLowerBound + 1, taskDivisionGap1ndexLowerBound)
-                        taskDivisionCountDimensionsGapped = taskDivisionCountDimensionsGapped.at[countGapsLeaf1ndexConnectee].add(1)
-
-                        return (taskDivisionCountDimensionsGapped, taskDivisionPotentialGaps, taskDivisionGap1ndexLowerBound)
-
-                    countGapsLeaf1ndexConnectee = countGapsDoValues[3]
-                    taskDivisionValues = (countGapsDoValues[0], countGapsDoValues[1], countGapsDoValues[2])
-                    taskDivisionValues = jax.lax.cond(taskDivisionComparison(), taskDivisionDo, doNothing, taskDivisionValues)
-
-                    countGapsLeaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, leafBelow.at[countGapsLeaf1ndexConnectee].get()].get().astype(jax.numpy.int32)
-
-                    return (taskDivisionValues[0], taskDivisionValues[1], taskDivisionValues[2], countGapsLeaf1ndexConnectee)
-
-                unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf = unconstrainedValues
-
-                leaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, activeLeaf1ndex].get().astype(jax.numpy.int32)
-
-                countGapsValues = (unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, leaf1ndexConnectee)
-                countGapsValues = jax.lax.while_loop(while_leaf1ndexConnectee_notEquals_activeLeaf1ndex, countGaps, countGapsValues)
-                unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, leaf1ndexConnectee = countGapsValues
-
-                return (unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf)
-
-            dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf, dimensionNumber = for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values
-
-            ifLeafIsUnconstrainedValues = (dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf)
-            ifLeafIsUnconstrainedValues = jax.lax.cond(ifLeafIsUnconstrainedCondition(dimensionNumber), ifLeafIsUnconstrainedDo, ifLeafIsUnconstrainedElse, ifLeafIsUnconstrainedValues)
-            dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf = ifLeafIsUnconstrainedValues
-
-            dimensionNumber = 1 + dimensionNumber
-            return (dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf, dimensionNumber)
-
-        def almostUselessCondition(comparand):
-            return comparand == dimensionsTotal
-
-        def almostUselessConditionDo(for_leaf1ndex_in_range_activeLeaf1ndexValues: Tuple[jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            def for_leaf1ndex_in_range_activeLeaf1ndex(comparisonValues):
-                return comparisonValues[-1] < activeLeaf1ndex
-
-            def for_leaf1ndex_in_range_activeLeaf1ndex_do(for_leaf1ndex_in_range_activeLeaf1ndexValues: Tuple[jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                leafInRangePotentialGaps, gapNumberLowerBound, leafNumber = for_leaf1ndex_in_range_activeLeaf1ndexValues
-                leafInRangePotentialGaps = leafInRangePotentialGaps.at[gapNumberLowerBound].set(leafNumber)
-                gapNumberLowerBound = 1 + gapNumberLowerBound
-                leafNumber = 1 + leafNumber
-                return (leafInRangePotentialGaps, gapNumberLowerBound, leafNumber)
-            return jax.lax.while_loop(for_leaf1ndex_in_range_activeLeaf1ndex, for_leaf1ndex_in_range_activeLeaf1ndex_do, for_leaf1ndex_in_range_activeLeaf1ndexValues)
-
-        def for_range_from_activeGap1ndex_to_gap1ndexCeiling(comparisonValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            return comparisonValues[-1] < gap1ndexCeiling
-
-        def miniGapDo(gapToGapValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            gapToGapCountDimensionsGapped, gapToGapPotentialGaps, activeGapNumber, index = gapToGapValues
-            gapToGapPotentialGaps = gapToGapPotentialGaps.at[activeGapNumber].set(gapToGapPotentialGaps.at[index].get())
-            activeGapNumber = jax.numpy.where(jax.numpy.equal(gapToGapCountDimensionsGapped.at[gapToGapPotentialGaps.at[index].get()].get(), dimensionsTotal - unconstrainedLeaf), activeGapNumber + 1, activeGapNumber).astype(jax.numpy.int32)
-            gapToGapCountDimensionsGapped = gapToGapCountDimensionsGapped.at[gapToGapPotentialGaps.at[index].get()].set(0)
-            index = 1 + index
-            return (gapToGapCountDimensionsGapped, gapToGapPotentialGaps, activeGapNumber, index)
-
-        _0, leafBelow, countDimensionsGapped, gapRangeStart, gapsWhere, _5, activeLeaf1ndex, activeGap1ndex = allValues
-
-        unconstrainedLeaf = jax.numpy.int32(0)
-        dimension1ndex = jax.numpy.int32(1)
-        gap1ndexCeiling = gapRangeStart.at[activeLeaf1ndex - 1].get().astype(jax.numpy.int32)
-        activeGap1ndex = gap1ndexCeiling
-        for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values = (countDimensionsGapped, gapsWhere, gap1ndexCeiling, unconstrainedLeaf, dimension1ndex)
-        for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values = jax.lax.while_loop(for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1, for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1_do, for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values)
-        countDimensionsGapped, gapsWhere, gap1ndexCeiling, unconstrainedLeaf, dimension1ndex = for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values
-        del dimension1ndex
-
-        leaf1ndex = jax.numpy.int32(0)
-        for_leaf1ndex_in_range_activeLeaf1ndexValues = (gapsWhere, gap1ndexCeiling, leaf1ndex)
-        for_leaf1ndex_in_range_activeLeaf1ndexValues = jax.lax.cond(almostUselessCondition(unconstrainedLeaf), almostUselessConditionDo, doNothing, for_leaf1ndex_in_range_activeLeaf1ndexValues)
-        gapsWhere, gap1ndexCeiling, leaf1ndex = for_leaf1ndex_in_range_activeLeaf1ndexValues
-        del leaf1ndex
-
-        indexMiniGap = activeGap1ndex
-        miniGapValues = (countDimensionsGapped, gapsWhere, activeGap1ndex, indexMiniGap)
-        miniGapValues = jax.lax.while_loop(for_range_from_activeGap1ndex_to_gap1ndexCeiling, miniGapDo, miniGapValues)
-        countDimensionsGapped, gapsWhere, activeGap1ndex, indexMiniGap = miniGapValues
-        del indexMiniGap
-
-        return (allValues[0], leafBelow, countDimensionsGapped, gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
-
-    def incrementCondition(leafBelowSentinel, activeLeafNumber):
-        return jax.numpy.logical_and(activeLeafNumber > leavesTotal, leafBelowSentinel == 1)
-
-    def incrementDo(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        foldingsSubTotal = allValues[5]
-        foldingsSubTotal = leavesTotal + foldingsSubTotal
-        return (allValues[0], allValues[1], allValues[2], allValues[3], allValues[4], foldingsSubTotal, allValues[6], allValues[7])
-
-    def dao(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        def whileBacktrackingCondition(backtrackingValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
-            comparand = backtrackingValues[2]
-            return jax.numpy.logical_and(comparand > 0, jax.numpy.equal(activeGap1ndex, gapRangeStart.at[comparand - 1].get()))
-
-        def whileBacktrackingDo(backtrackingValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
-            backtrackAbove, backtrackBelow, activeLeafNumber = backtrackingValues
-
-            activeLeafNumber = activeLeafNumber - 1
-            backtrackBelow = backtrackBelow.at[backtrackAbove.at[activeLeafNumber].get()].set(backtrackBelow.at[activeLeafNumber].get())
-            backtrackAbove = backtrackAbove.at[backtrackBelow.at[activeLeafNumber].get()].set(backtrackAbove.at[activeLeafNumber].get())
-
-            return (backtrackAbove, backtrackBelow, activeLeafNumber)
-
-        def if_activeLeaf1ndex_greaterThan_0(activeLeafNumber):
-            return activeLeafNumber > 0
-
-        def if_activeLeaf1ndex_greaterThan_0_do(leafPlacementValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            placeLeafAbove, placeLeafBelow, placeGapRangeStart, activeLeafNumber, activeGapNumber = leafPlacementValues
-            activeGapNumber = activeGapNumber - 1
-            placeLeafAbove = placeLeafAbove.at[activeLeafNumber].set(gapsWhere.at[activeGapNumber].get())
-            placeLeafBelow = placeLeafBelow.at[activeLeafNumber].set(placeLeafBelow.at[placeLeafAbove.at[activeLeafNumber].get()].get())
-            placeLeafBelow = placeLeafBelow.at[placeLeafAbove.at[activeLeafNumber].get()].set(activeLeafNumber)
-            placeLeafAbove = placeLeafAbove.at[placeLeafBelow.at[activeLeafNumber].get()].set(activeLeafNumber)
-            placeGapRangeStart = placeGapRangeStart.at[activeLeafNumber].set(activeGapNumber)
-
-            activeLeafNumber = 1 + activeLeafNumber
-            return (placeLeafAbove, placeLeafBelow, placeGapRangeStart, activeLeafNumber, activeGapNumber)
-
-        leafAbove, leafBelow, _2, gapRangeStart, gapsWhere, _5, activeLeaf1ndex, activeGap1ndex = allValues
-
-        whileBacktrackingValues = (leafAbove, leafBelow, activeLeaf1ndex)
-        whileBacktrackingValues = jax.lax.while_loop(whileBacktrackingCondition, whileBacktrackingDo, whileBacktrackingValues)
-        leafAbove, leafBelow, activeLeaf1ndex = whileBacktrackingValues
-
-        if_activeLeaf1ndex_greaterThan_0_values = (leafAbove, leafBelow, gapRangeStart, activeLeaf1ndex, activeGap1ndex)
-        if_activeLeaf1ndex_greaterThan_0_values = jax.lax.cond(if_activeLeaf1ndex_greaterThan_0(activeLeaf1ndex), if_activeLeaf1ndex_greaterThan_0_do, doNothing, if_activeLeaf1ndex_greaterThan_0_values)
-        leafAbove, leafBelow, gapRangeStart, activeLeaf1ndex, activeGap1ndex = if_activeLeaf1ndex_greaterThan_0_values
-
-        return (leafAbove, leafBelow, allValues[2], gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
-
-    # Dynamic values
-    A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    gap = jax.numpy.zeros(leavesTotal * leavesTotal + 1, dtype=dtypeMaximum)
-
-    foldingsSubTotal = jax.numpy.int32(0)
-    l = jax.numpy.int32(1)
-    g = jax.numpy.int32(0)
-
-    foldingsValues = (A, B, count, gapter, gap, foldingsSubTotal, l, g)
-    foldingsValues = jax.lax.while_loop(while_activeLeaf1ndex_greaterThan_0, countFoldings, foldingsValues)
-    return foldingsValues[5]

mapFolding/countInitialize.py

@@ -1,44 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

tests/test_temporary.py

@@ -1,25 +0,0 @@
-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')