mapFolding 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

citations/updateCitation.py

@@ -0,0 +1,67 @@
+from cffconvert.cli.create_citation import create_citation
+from typing import Any, Dict
+import cffconvert
+import pathlib
+import tomli
+import inspect
+import json
+
+"""
+Tentative plan:
+- Commit and push to GitHub
+- GitHub Action gathers information from the sources of truth
+- If the citation needs to be updated, write to both
+    - pathFilenameCitationSSOT
+    - pathFilenameCitationDOTcffRepo
+- Commit and push to GitHub
+    - this complicates things
+    - I want the updated citation to be in the `commit` field of itself
+"""
+
+"""cffconvert.Citation fields and the source of truth
+abstract: pathFilenameCitationSSOT
+authors: pathFilenamePackageSSOT
+cff-version: pathFilenameCitationSSOT
+commit: workflows['Make GitHub Release']
+contact: pathFilenamePackageSSOT
+date-released: workflows['Make GitHub Release']
+doi: pathFilenameCitationSSOT
+identifiers: workflows['Make GitHub Release']
+keywords: pathFilenamePackageSSOT
+license: pathFilenamePackageSSOT
+license-url: pathFilenamePackageSSOT
+message: pathFilenameCitationSSOT
+preferred-citation: pathFilenameCitationSSOT
+references: to be determined
+repository: pathFilenamePackageSSOT
+repository-artifact: (https://pypi.org/pypi/{package_name}/json').json()['releases']
+repository-code: workflows['Make GitHub Release']
+title: pathFilenamePackageSSOT
+type: pathFilenameCitationSSOT
+url: pathFilenamePackageSSOT
+version: pathFilenamePackageSSOT
+"""
+# Prefer reliable, dynamic values over hardcoded ones
+packageName: str = 'mapFolding'
+pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
+pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
+
+filenameGitHubAction = 'updateCitation.yml'
+pathFilenameGitHubAction = pathRepoRoot / '.github' / 'workflows' / filenameGitHubAction
+
+filenameCitationDOTcff = 'CITATION.cff'
+pathCitations = pathRepoRoot / packageName / 'citations'
+pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
+pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
+
+tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
+
+citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
+
+path_cffconvert = pathlib.Path(inspect.getfile(cffconvert)).parent
+pathFilenameSchema = path_cffconvert / "schemas/1.2.0/schema.json"
+scheme: Dict[str, Any] = json.loads(pathFilenameSchema.read_text())
+schemaSpecifications: Dict[str, Any] = scheme['properties']
+
+for property, subProperties in schemaSpecifications.items():
+    print(property, subProperties.get('items', None))

{mapFolding-0.3.3.dist-info → mapFolding-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.3
+Version: 0.3.4
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -29,12 +29,14 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: cffconvert; extra == "testing"
 Requires-Dist: more_itertools; 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: python_minifier; extra == "testing"
+Requires-Dist: tomli; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 

mapFolding-0.3.4.dist-info/RECORD

@@ -0,0 +1,26 @@
+benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
+citations/updateCitation.py,sha256=3AUPo9_4SfH8AwQBMRl7KygAXoMRjQSqFl3ERWxtrtk,2541
+reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
+reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
+reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
+reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
+reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
+reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
+reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
+reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
+reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+someAssemblyRequired/__init__.py,sha256=7iODZE6dM4h52spgivUvAuVsvYdSx-_YcSTz1gX82Vw,89
+someAssemblyRequired/generalizeSourceCode.py,sha256=qyJD0ZdG0t-SYTItL_JjaIXm3-joWt3e-2nMSAH4Dbg,6392
+someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
+someAssemblyRequired/makeJob.py,sha256=iaLjr-FhFloTF6wSuwOpurgpqJulZht9CxNo9MDidbg,949
+someAssemblyRequired/synthesizeModuleJob.py,sha256=xLak-ZZ1zQ92jBobhJqbnA1Fua9ofiRvLdK1fmD8s_s,7271
+someAssemblyRequired/synthesizeModules.py,sha256=JGOx69DGCcCntRtw7aOXXcmERCHqVyhFo1oiKh3P8Mg,8842
+syntheticModules/__init__.py,sha256=nDtS5UFMKN-F5pTp0qKA0J0I-XR3n3OFxV2bosieBu8,131
+syntheticModules/countInitialize.py,sha256=QqKfQxCmUJuJutNxOZ0VfqYEHnuk7XSkCYx7RKz3kn4,4239
+syntheticModules/countParallel.py,sha256=77JzO3TsccjSUJRExZ0Nxdqowd_Sm0_2bRziVx5XMI4,5355
+syntheticModules/countSequential.py,sha256=QixgcN9R5zcrmJjxSO4oOCYViWogA35HbDNlni9hw8o,3655
+mapFolding-0.3.4.dist-info/METADATA,sha256=v8MJLZBzqS2hBp4trsRjjLzn8RAsddUPg16IiI9J1cg,7617
+mapFolding-0.3.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.3.4.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.3.4.dist-info/top_level.txt,sha256=yVG9dNZywoaddcsUdEDg7o0XOBzJd_4Z-sDaXGHpiMY,69
+mapFolding-0.3.4.dist-info/RECORD,,

{mapFolding-0.3.3.dist-info → mapFolding-0.3.4.dist-info}/top_level.txt

@@ -1,4 +1,5 @@
 benchmarks
+citations
 reference
 someAssemblyRequired
 syntheticModules

someAssemblyRequired/__init__.py

@@ -1,2 +1,2 @@
 from .makeJob import makeStateJob
-from .generalizeSourceCode import makeInlineFunction
+# from .generalizeSourceCode import makeInlineFunction

someAssemblyRequired/generalizeSourceCode.py

@@ -1,16 +1,17 @@
 from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
+from typing import Dict, Optional, List, Set, Union
 import ast
 
 class RecursiveInlinerWithEnum(ast.NodeTransformer):
     """Process AST nodes to inline functions and substitute enum values.
     Also handles function decorators during inlining."""
 
-    def __init__(self, dictionaryFunctions, dictionaryEnumValues):
+    def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef], dictionaryEnumValues: Dict[str, int]) -> None:
         self.dictionaryFunctions = dictionaryFunctions
         self.dictionaryEnumValues = dictionaryEnumValues
         self.processed = set()
 
-    def inlineFunctionBody(self, functionName):
+    def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
         if functionName in self.processed:
             return None
 
@@ -21,7 +22,7 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
             self.visit(node)
         return inlineDefinition
 
-    def visit_Attribute(self, node):
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
         # 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}"
@@ -29,7 +30,7 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
                 return ast.Constant(value=self.dictionaryEnumValues[enumPath])
         return self.generic_visit(node)
 
-    def visit_Call(self, node):
+    def visit_Call(self, node: ast.Call) -> ast.AST:
         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.inlineFunctionBody(callNode.func.id)
@@ -39,10 +40,10 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
                     return self.visit(lastStmt.value)
                 elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
                     return self.visit(lastStmt.value)
-                return None
+                return ast.Constant(value=None)
         return callNode
 
-    def visit_Expr(self, node):
+    def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
         if isinstance(node.value, ast.Call):
             if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
                 inlineDefinition = self.inlineFunctionBody(node.value.func.id)
@@ -50,18 +51,18 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
                     return [self.visit(stmt) for stmt in inlineDefinition.body]
         return self.generic_visit(node)
 
-def findRequiredImports(node):
+def findRequiredImports(node: ast.AST) -> Set[str]:
     """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):
+        def visit_Name(self, node: ast.Name) -> None:
             if node.id in {'numba'}:
                 requiredImports.add(node.id)
             self.generic_visit(node)
 
-        def visitDecorator(self, node):
+        def visitDecorator(self, node: ast.AST) -> None:
             if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
                 if node.func.id == 'jit':
                     requiredImports.add('numba')
@@ -70,7 +71,7 @@ def findRequiredImports(node):
     ImportFinder().visit(node)
     return requiredImports
 
-def generateImports(requiredImports):
+def generateImports(requiredImports: Set[str]) -> str:
     """Generate import statements based on required modules."""
     importStatements = {'import numba', 'from mapFolding import indexMy, indexTrack'}
 
@@ -84,7 +85,7 @@ def generateImports(requiredImports):
 
     return '\n'.join(importStatements)
 
-def makeInlineFunction(sourceCode, targetFunctionName, dictionaryEnumValues, skipEnum=False, **keywordArguments):
+def makeInlineFunction(sourceCode: str, targetFunctionName: str, dictionaryEnumValues: Dict[str, int], skipEnum: bool=False, **keywordArguments: Optional[str]):
     datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
     datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
     datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)

someAssemblyRequired/makeJob.py

@@ -5,8 +5,10 @@ import pathlib
 import pickle
 
 def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
-    from syntheticModules import countInitialize
+
     stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+
+    from syntheticModules import countInitialize
     countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
 
     pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])

someAssemblyRequired/synthesizeModules.py

@@ -1,19 +1,104 @@
-from mapFolding import indexMy, indexTrack, getAlgorithmSource
+from mapFolding import indexMy, indexTrack, getAlgorithmSource, ParametersNumba, parametersNumbaDEFAULT, hackSSOTdtype
 from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
-from someAssemblyRequired import makeInlineFunction
 import pathlib
 import inspect
+import numpy
+import numba
+from typing import Dict, Optional, List, Set, Union, Sequence
+import ast
 
 algorithmSource = getAlgorithmSource()
 
-def getDictionaryEnumValues():
+class RecursiveInliner(ast.NodeTransformer):
+    def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef]):
+        self.dictionaryFunctions = dictionaryFunctions
+        self.processed = set()
+
+    def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
+        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_Call(self, node: ast.Call) -> ast.AST:
+        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.inlineFunctionBody(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 ast.Constant(value=None)
+        return callNode
+
+    def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
+        if isinstance(node.value, ast.Call):
+            if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
+                inlineDefinition = self.inlineFunctionBody(node.value.func.id)
+                if inlineDefinition:
+                    return [self.visit(stmt) for stmt in inlineDefinition.body]
+        return self.generic_visit(node)
+
+def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False, **keywordArguments: Optional[str]):
+    def makeNumbaParameterSignatureElement(signatureElement: ast.arg):
+        if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
+
+            annotationShape = signatureElement.annotation.slice.elts[0]
+            if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
+                shapeAsListSlices = [ast.Slice() for axis in range(len(annotationShape.slice.elts))]
+                shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
+                shapeAST = ast.Tuple(elts=shapeAsListSlices, ctx=ast.Load())
+            else:
+                shapeAST = ast.Slice(step=ast.Constant(value=1))
+
+            annotationDtype = signatureElement.annotation.slice.elts[1]
+            if isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute):
+                datatypeAST = annotationDtype.slice.attr
+            else:
+                datatypeAST = None
+
+            ndarrayName = signatureElement.arg
+            Z0Z_hackyStr = hackSSOTdtype[ndarrayName]
+            Z0Z_hackyStr = Z0Z_hackyStr[0] + 'ata' + Z0Z_hackyStr[1:]
+            datatype_attr = keywordArguments.get(Z0Z_hackyStr, None) or datatypeAST or eval(Z0Z_hackyStr+'DEFAULT')
+
+            datatypeNumba = ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr=datatype_attr, ctx=ast.Load())
+
+            return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
+
+    # callableSourceDecorators = [decorator for decorator in callableInlined.decorator_list]
+
+    listNumbaParameterSignature: List[ast.Subscript] = []
+    for parameter in astCallable.args.args:
+        signatureElement = makeNumbaParameterSignatureElement(parameter)
+        if signatureElement:
+            listNumbaParameterSignature.append(signatureElement)
+
+    astArgsNumbaSignature = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
+
+    parametersNumba = parametersNumbaDEFAULT if not parallel else ParametersNumba({**parametersNumbaDEFAULT, 'parallel': True})
+    listKeywordsNumbaSignature = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
+
+    astDecoratorNumba = ast.Call(func=ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr='jit', ctx=ast.Load()), args=[astArgsNumbaSignature], keywords=listKeywordsNumbaSignature)
+
+    astCallable.decorator_list = [astDecoratorNumba]
+    return astCallable
+
+def getDictionaryEnumValues() -> Dict[str, int]:
     dictionaryEnumValues = {}
     for enumIndex in [indexMy, indexTrack]:
         for memberName, memberValue in enumIndex._member_map_.items():
             dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
     return dictionaryEnumValues
 
-def unpackArrays(codeInlined: str, callableTarget: str) -> str:
+def unpackArrays(codeInlined: str) -> str:
     dictionaryReplaceScalars = {
         'my[indexMy.dimensionsTotal.value]': 'dimensionsTotal',
         'my[indexMy.dimensionsUnconstrained.value]': 'dimensionsUnconstrained',
@@ -54,25 +139,32 @@ def unpackArrays(codeInlined: str, callableTarget: str) -> str:
 
     return codeInlined
 
-def inlineMapFoldingNumba(**keywordArguments):
-    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
-    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
-    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
+def inlineMapFoldingNumba(**keywordArguments: Optional[str]):
     dictionaryEnumValues = getDictionaryEnumValues()
     codeSource = inspect.getsource(algorithmSource)
     pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
 
-    listCallables = [ 'countInitialize', 'countParallel', 'countSequential', ]
-
     listPathFilenamesDestination: list[pathlib.Path] = []
+    listCallables = [ 'countInitialize', 'countParallel', 'countSequential', ]
     for callableTarget in listCallables:
-        skipEnum = (callableTarget == 'countInitialize')
-        skipEnum = (callableTarget == 'countSequential')
-        pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
-        codeInlined, callableInlinedDecorators, importsRequired = makeInlineFunction(codeSource, callableTarget, dictionaryEnumValues, skipEnum, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
-        codeUnpacked = unpackArrays(codeInlined, callableTarget)
-        pathFilenameDestination.write_text(importsRequired + "\n" + codeUnpacked)
-        listPathFilenamesDestination.append(pathFilenameDestination)
+        codeParsed: ast.Module = ast.parse(codeSource, type_comments=True)
+        codeSourceImportStatements = {statement for statement in codeParsed.body if isinstance(statement, (ast.Import, ast.ImportFrom))}
+        dictionaryFunctions = {statement.name: statement for statement in codeParsed.body if isinstance(statement, ast.FunctionDef)}
+        callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctions)
+        parallel = callableTarget == 'countParallel'
+        callableInlined = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
+        if callableInlined:
+            ast.fix_missing_locations(callableInlined)
+            callableDecorated = decorateCallableWithNumba(callableInlined, parallel, **keywordArguments)
+
+            importsRequired = "\n".join([ast.unparse(importStatement) for importStatement in codeSourceImportStatements])
+            callableInlined = ast.unparse(callableDecorated)
+            codeUnpacked = unpackArrays(callableInlined) if callableTarget == 'countSequential' else callableInlined
+            # inlinedCode = ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
+
+            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
+            pathFilenameDestination.write_text(importsRequired + "\n" + codeUnpacked)
+            listPathFilenamesDestination.append(pathFilenameDestination)
 
 if __name__ == '__main__':
     inlineMapFoldingNumba()

syntheticModules/countInitialize.py

@@ -1,44 +1,47 @@
-from mapFolding import indexMy, indexTrack
+from numpy import integer
 import numba
-@numba.jit((numba.uint8[:,:,::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
-def countInitialize(connectionGraph, gapsWhere, my, track):
-    while my[7] > 0:
-        if my[7] <= 1 or track[1, 0] == 1:
-            my[1] = my[0]
-            my[3] = track[3, my[7] - 1]
-            my[4] = 0
-            while my[4] < my[0]:
-                if connectionGraph[my[4], my[7], my[7]] == my[7]:
-                    my[1] -= 1
+import numpy
+from mapFolding import indexMy, indexTrack
+from typing import Any, Tuple
+@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
+    while my[indexMy.leaf1ndex.value] > 0:
+        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
+            my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
+            my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+            my[indexMy.indexDimension.value] = 0
+            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
+                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
+                    my[indexMy.dimensionsUnconstrained.value] -= 1
                 else:
-                    my[8] = connectionGraph[my[4], my[7], my[7]]
-                    while my[8] != my[7]:
-                        gapsWhere[my[3]] = my[8]
-                        if track[2, my[8]] == 0:
-                            my[3] += 1
-                        track[2, my[8]] += 1
-                        my[8] = connectionGraph[my[4], my[7], track[1, my[8]]]
-                my[4] += 1
-            if not my[1]:
-                my[5] = 0
-                while my[5] < my[7]:
-                    gapsWhere[my[3]] = my[5]
-                    my[3] += 1
-                    my[5] += 1
-            my[6] = my[2]
-            while my[6] < my[3]:
-                gapsWhere[my[2]] = gapsWhere[my[6]]
-                if track[2, gapsWhere[my[6]]] == my[1]:
-                    my[2] += 1
-                track[2, gapsWhere[my[6]]] = 0
-                my[6] += 1
-        if my[7] > 0:
-            my[2] -= 1
-            track[0, my[7]] = gapsWhere[my[2]]
-            track[1, my[7]] = track[1, track[0, my[7]]]
-            track[1, track[0, my[7]]] = my[7]
-            track[0, track[1, my[7]]] = my[7]
-            track[3, my[7]] = my[2]
-            my[7] += 1
-        if my[2] > 0:
+                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
+                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+                            my[indexMy.gap1ndexCeiling.value] += 1
+                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+                my[indexMy.indexDimension.value] += 1
+            if not my[indexMy.dimensionsUnconstrained.value]:
+                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
+            my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
+                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+                    my[indexMy.gap1ndex.value] += 1
+                track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+                my[indexMy.indexMiniGap.value] += 1
+        if my[indexMy.leaf1ndex.value] > 0:
+            my[indexMy.gap1ndex.value] -= 1
+            track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
+            track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
+            track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+            track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+            track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
+            my[indexMy.leaf1ndex.value] += 1
+        if my[indexMy.gap1ndex.value] > 0:
             return

syntheticModules/countParallel.py

@@ -1,51 +1,54 @@
-from mapFolding import indexMy, indexTrack
+from numpy import integer
+from typing import Any, Tuple
 import numba
-@numba.jit((numba.uint8[:,:,::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
-def countParallel(connectionGraph, foldGroups, gapsWherePARALLEL, myPARALLEL, trackPARALLEL):
-    for indexSherpa in numba.prange(myPARALLEL[9]):
+from mapFolding import indexMy, indexTrack
+import numpy
+@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
+def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWherePARALLEL: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], myPARALLEL: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], trackPARALLEL: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
+    for indexSherpa in numba.prange(myPARALLEL[indexMy.taskDivisions.value]):
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[10] = indexSherpa
+        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
         groupsOfFolds: int = 0
-        while my[7] > 0:
-            if my[7] <= 1 or track[1, 0] == 1:
-                if my[7] > foldGroups[-1]:
+        while my[indexMy.leaf1ndex.value] > 0:
+            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
+                if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
                     groupsOfFolds = groupsOfFolds + 1
                 else:
-                    my[1] = my[0]
-                    my[3] = track[3, my[7] - 1]
-                    my[4] = 0
-                    while my[4] < my[0]:
-                        if connectionGraph[my[4], my[7], my[7]] == my[7]:
-                            my[1] -= 1
+                    my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
+                    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+                    my[indexMy.indexDimension.value] = 0
+                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
+                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
+                            my[indexMy.dimensionsUnconstrained.value] -= 1
                         else:
-                            my[8] = connectionGraph[my[4], my[7], my[7]]
-                            while my[8] != my[7]:
-                                if my[7] != my[9] or my[8] % my[9] == my[10]:
-                                    gapsWhere[my[3]] = my[8]
-                                    if track[2, my[8]] == 0:
-                                        my[3] += 1
-                                    track[2, my[8]] += 1
-                                my[8] = connectionGraph[my[4], my[7], track[1, my[8]]]
-                        my[4] += 1
-                    my[6] = my[2]
-                    while my[6] < my[3]:
-                        gapsWhere[my[2]] = gapsWhere[my[6]]
-                        if track[2, gapsWhere[my[6]]] == my[1]:
-                            my[2] += 1
-                        track[2, gapsWhere[my[6]]] = 0
-                        my[6] += 1
-            while my[7] > 0 and my[2] == track[3, my[7] - 1]:
-                my[7] -= 1
-                track[1, track[0, my[7]]] = track[1, my[7]]
-                track[0, track[1, my[7]]] = track[0, my[7]]
-            if my[7] > 0:
-                my[2] -= 1
-                track[0, my[7]] = gapsWhere[my[2]]
-                track[1, my[7]] = track[1, track[0, my[7]]]
-                track[1, track[0, my[7]]] = my[7]
-                track[0, track[1, my[7]]] = my[7]
-                track[3, my[7]] = my[2]
-                my[7] += 1
-        foldGroups[my[10]] = groupsOfFolds
+                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
+                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
+                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+                                        my[indexMy.gap1ndexCeiling.value] += 1
+                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+                        my[indexMy.indexDimension.value] += 1
+                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
+                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+                            my[indexMy.gap1ndex.value] += 1
+                        track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+                        my[indexMy.indexMiniGap.value] += 1
+            while my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
+                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]]
+            if my[indexMy.leaf1ndex.value] > 0:
+                my[indexMy.gap1ndex.value] -= 1
+                track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
+                track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
+                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+                track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
+                my[indexMy.leaf1ndex.value] += 1
+        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds

syntheticModules/countSequential.py

@@ -1,7 +1,10 @@
-from mapFolding import indexMy, indexTrack
+from numpy import integer
+from typing import Any, Tuple
 import numba
-@numba.jit((numba.uint8[:,:,::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
-def countSequential(connectionGraph, foldGroups, gapsWhere, my, track):
+from mapFolding import indexMy, indexTrack
+import numpy
+@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
     doFindGaps = True
     dimensionsTotal = my[indexMy.dimensionsTotal.value]
     dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]

mapFolding-0.3.3.dist-info/RECORD

@@ -1,25 +0,0 @@
-benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
-reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
-reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
-reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
-reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
-reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
-reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
-reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-someAssemblyRequired/__init__.py,sha256=iZpBslk8OnCmaUoqAivva7Hl7GJYrjwRV_owcBbgfcM,87
-someAssemblyRequired/generalizeSourceCode.py,sha256=6LsUe-5uqGXcrtXWrP70BrUgnjkJKrQo8y1KyFZdb-k,6024
-someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-someAssemblyRequired/makeJob.py,sha256=W85W7vWsNsu9mBsgU3Cx-FPYIdLLnyzR4GwdcYsWZv4,947
-someAssemblyRequired/synthesizeJob.py,sha256=xLak-ZZ1zQ92jBobhJqbnA1Fua9ofiRvLdK1fmD8s_s,7271
-someAssemblyRequired/synthesizeModules.py,sha256=yR9oFsZe3sbgDe2XoS9MbaIqNz-hOq6qOFzHMhPn4rc,3737
-syntheticModules/__init__.py,sha256=nDtS5UFMKN-F5pTp0qKA0J0I-XR3n3OFxV2bosieBu8,131
-syntheticModules/countInitialize.py,sha256=rRn1gtR1PWxpQ8Mw-_QRZT7ujRP_1H04QizJE9RlZ7o,1839
-syntheticModules/countParallel.py,sha256=aZQvSEeWeJ-47eyMyIisq1baAAl-H6W0RYIlVPv_D_U,2559
-syntheticModules/countSequential.py,sha256=Uf1Zd-r3wsmVoHOWyNOQQiFO6k6xmFG6Oo3dqwAqBQo,3216
-mapFolding-0.3.3.dist-info/METADATA,sha256=SfukFXyZtDIdmQ4Gzgl8ePyov_factyZ4Te7LSh0UYc,7530
-mapFolding-0.3.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.3.dist-info/top_level.txt,sha256=tZHrMCdFq5ghJY_MAv_GhcpmQecelcIcoxgzLnF1-V4,59
-mapFolding-0.3.3.dist-info/RECORD,,