mapFolding 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py

@@ -1,7 +1,7 @@
 from mapFolding import (
 	computationState,
 	EnumIndices,
-	formatModuleNameDEFAULT,
+	formatFilenameModuleDEFAULT,
 	FREAKOUT,
 	getAlgorithmDispatcher,
 	getAlgorithmSource,
@@ -36,7 +36,7 @@ from numpy import integer
 from numpy.typing import NDArray
 from types import ModuleType
 from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
-from Z0Z_tools import autoDecodingRLE
+from Z0Z_tools import autoDecodingRLE, updateExtendPolishDictionaryLists
 import ast
 import autoflake
 import collections
@@ -49,9 +49,41 @@ import numpy
 import os
 import pathlib
 import python_minifier
+import warnings
 
 youOughtaKnow = collections.namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
 
+# idk how to use this
+class ASTBodyTransformer:
+	"""
+	A helper class to apply multiple transformations on an AST FunctionDef's body.
+	This abstraction eliminates the need to write repetitive loops for removals,
+	replacements, or insertions.
+	"""
+	def __init__(self, functionDefinition: ast.FunctionDef) -> None:
+		self.functionDefinition = functionDefinition
+
+	def replaceIn_body(self, predicate: Callable[[ast.stmt], bool], replacementBuilder: Callable[[ast.stmt], Optional[ast.stmt]]) -> None:
+		newBody: List[ast.stmt] = []
+		for statement in self.functionDefinition.body:
+			if predicate(statement):
+				replacementStatement = replacementBuilder(statement)
+				if replacementStatement is not None:
+					newBody.append(replacementStatement)
+			else:
+				newBody.append(statement)
+		self.functionDefinition.body = newBody
+
+	def atIndexInsert(self, index: int, statement: ast.stmt) -> None:
+		self.functionDefinition.body.insert(index, statement)
+
+	def removeAllOf(self, predicate: Callable[[ast.stmt], bool]) -> None:
+		self.replaceIn_body(predicate, lambda stmt: None)
+
+	def Z0Z_apply(self) -> ast.FunctionDef:
+		ast.fix_missing_locations(self.functionDefinition)
+		return self.functionDefinition
+
 # Generic
 class ifThis:
 	"""Generic AST node predicate builder."""
@@ -71,10 +103,27 @@ class ifThis:
 	def isCallWithName(callableName: str) -> Callable[[ast.AST], bool]:
 		return lambda node: (isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == callableName)
 
+	@staticmethod
+	def isAssignTarget(identifier: str):
+		return lambda node: (isinstance(node, ast.Assign)
+								and node.targets
+								and isinstance(node.targets[0], ast.Name)
+								and node.targets[0].id == identifier)
+
 	@staticmethod
 	def anyOf(*predicates: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
 		return lambda node: any(pred(node) for pred in predicates)
 
+	@staticmethod
+	def isUnpackingAnArray(identifier:str):
+		return lambda node: (isinstance(node, ast.Assign)
+						and  isinstance(node.targets[0], ast.Name)
+						and  isinstance(node.value, ast.Subscript)
+						and  isinstance(node.value.value, ast.Name)
+						and  node.value.value.id == identifier
+						and  isinstance(node.value.slice, ast.Attribute)
+						)
+
 class Then:
 	"""Generic actions."""
 	@staticmethod
@@ -103,9 +152,8 @@ class NodeReplacer(ast.NodeTransformer):
 	None from the replacement builder indicates that the node should be removed.
 
 	Attributes:
-		findMe (Callable[[ast.AST], bool]): A function that determines whether a node should be replaced.
-		nodeReplacementBuilder (Callable[[ast.AST], Optional[ast.AST]]): A function that returns a new node
-			or None to remove the node.
+		findMe: A function that determines whether a node should be replaced.
+		nodeReplacementBuilder: A function that returns a new node or None to remove the node.
 
 	Methods:
 		visit(node: ast.AST) -> Optional[ast.AST]:
@@ -142,19 +190,42 @@ class UniversalImportTracker:
 				self.setImport.add(alias.name)
 		elif isinstance(astImport_, ast.ImportFrom):
 			if astImport_.module is not None:
-				self.dictionaryImportFrom[astImport_.module].update(alias.name for alias in astImport_.names)
+				self.dictionaryImportFrom[astImport_.module].update((alias.name, alias.asname) for alias in astImport_.names)
 
-	def addImportFromStr(self, module: str, name: str) -> None:
-		self.dictionaryImportFrom[module].add(name)
+	def addImportStr(self, module: str) -> None:
+		self.setImport.add(module)
 
-	def addImportStr(self, name: str) -> None:
-		self.setImport.add(name)
+	def addImportFromStr(self, module: str, name: str, asname: Optional[str] = None) -> None:
+		self.dictionaryImportFrom[module].add((name, asname))
 
 	def makeListAst(self) -> List[Union[ast.ImportFrom, ast.Import]]:
-		listAstImportFrom = [ast.ImportFrom(module=module, names=[ast.alias(name=name, asname=None)], level=0) for module, names in self.dictionaryImportFrom.items() for name in names]
-		listAstImport = [ast.Import(names=[ast.alias(name=name, asname=None)]) for name in self.setImport]
+		listAstImportFrom = []
+		for module, setOfNameTuples in sorted(self.dictionaryImportFrom.items()):
+			listAliases = []
+			for name, asname in setOfNameTuples:
+				listAliases.append(ast.alias(name=name, asname=asname))
+			listAstImportFrom.append(ast.ImportFrom(module=module, names=listAliases, level=0))
+
+		listAstImport = [ast.Import(names=[ast.alias(name=name, asname=None)]) for name in sorted(self.setImport)]
 		return listAstImportFrom + listAstImport
 
+	def update(self, *fromTracker: 'UniversalImportTracker') -> None:
+		"""
+		Update this tracker with imports from one or more other trackers.
+
+		Parameters:
+			*fromTracker: One or more UniversalImportTracker objects to merge from.
+		"""
+		# Merge all import-from dictionaries
+		dictionaryMerged = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(tracker.dictionaryImportFrom for tracker in fromTracker), destroyDuplicates=True, reorderLists=True)
+
+		# Convert lists back to sets for each module's imports
+		self.dictionaryImportFrom = {module: set(listNames) for module, listNames in dictionaryMerged.items()}
+
+		# Update direct imports
+		for tracker in fromTracker:
+			self.setImport.update(tracker.setImport)
+
 # Intricate and specialized
 class RecursiveInliner(ast.NodeTransformer):
 	"""

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -64,6 +64,7 @@ def writeJobNumba(mapShape: Sequence[int]
 	pythonSource = inspect.getsource(algorithmSource)
 	astModule = ast.parse(pythonSource)
 	setFunctionDef = {statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
+
 	if not callableTarget:
 		if len(setFunctionDef) == 1:
 			FunctionDefTarget = setFunctionDef.pop()
@@ -71,7 +72,8 @@ def writeJobNumba(mapShape: Sequence[int]
 		else:
 			raise ValueError(f"I did not receive a `callableTarget` and {algorithmSource.__name__=} has more than one callable: {setFunctionDef}. Please select one.")
 	else:
-		FunctionDefTarget = setFunctionDef.pop() if callableTarget in {statement.name for statement in setFunctionDef} else None
+		listFunctionDefTarget = [statement for statement in setFunctionDef if statement.name == callableTarget]
+		FunctionDefTarget = listFunctionDefTarget[0] if listFunctionDefTarget else None
 	if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
 
 	# NOTE `allImports` is a complementary container to `FunctionDefTarget`; the `FunctionDefTarget` cannot track its own imports very well.
@@ -86,13 +88,15 @@ def writeJobNumba(mapShape: Sequence[int]
 			case 'my':
 				FunctionDefTarget, allImports = findAndReplaceArraySubscriptIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], ['taskIndex', 'dimensionsTotal'], allImports)
 			case 'track':
-				FunctionDefTarget, allImports = findAndReplaceArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
+				FunctionDefTarget, allImports = findAndReplaceTrackArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
 			case 'connectionGraph':
 				FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
 			case 'gapsWhere':
 				FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
 			case 'foldGroups':
 				FunctionDefTarget = removeAssignTargetFrom_body(FunctionDefTarget, pirateScowl.arg)
+				# FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
+				# continue
 		FunctionDefTarget.args.args.remove(pirateScowl)
 
 	# NOTE replace identifiers with static values with their values
@@ -110,8 +114,6 @@ def writeJobNumba(mapShape: Sequence[int]
 	FunctionDefTarget, allImports = insertReturnStatementIn_body(FunctionDefTarget, stateJob['foldGroups'], allImports)
 
 	# NOTE add the perfect decorator
-	datatype = hackSSOTdatatype(Z0Z_identifierCountFolds)
-	FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
 	FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
 	if thisIsNumbaDotJit(FunctionDefTarget.decorator_list[0]):
 		astCall = cast(ast.Call, FunctionDefTarget.decorator_list[0])
@@ -124,21 +126,7 @@ def writeJobNumba(mapShape: Sequence[int]
 	ast.fix_missing_locations(astModule)
 	pythonSource = ast.unparse(astModule)
 	pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-	pythonSource = python_minifier.minify(pythonSource, remove_annotations = False,
-		remove_pass = False,
-		remove_literal_statements = False,
-		combine_imports = True,
-		hoist_literals = False,
-		rename_locals = False,
-		rename_globals = False,
-		remove_object_base = False,
-		convert_posargs_to_args = False,
-		preserve_shebang = True,
-		remove_asserts = False,
-		remove_debug = False,
-		remove_explicit_return_none = False,
-		remove_builtin_exception_brackets = False,
-		constant_folding = False)
+	# pythonSource = python_minifier.minify(pythonSource, remove_annotations = False, remove_pass = False, remove_literal_statements = False, combine_imports = True, hoist_literals = False, rename_locals = False, rename_globals = False, remove_object_base = False, convert_posargs_to_args = False, preserve_shebang = True, remove_asserts = False, remove_debug = False, remove_explicit_return_none = False, remove_builtin_exception_brackets = False, constant_folding = False)
 
 	# NOTE put on disk
 	if pathFilenameWriteJob is None:
@@ -155,17 +143,18 @@ def writeJobNumba(mapShape: Sequence[int]
 
 if __name__ == '__main__':
 	mapShape = [5,5]
-	from mapFolding.syntheticModules import numba_countSequential
-	algorithmSource: ModuleType = numba_countSequential
+	from mapFolding.syntheticModules import numbaCount
+	algorithmSource: ModuleType = numbaCount
 
-	callableTarget = None
+	callableTarget = 'countSequential'
 
 	parametersNumba = parametersNumbaDEFAULT
+	parametersNumba['boundscheck'] = True
 
 	pathFilenameWriteJob = None
 
 	setDatatypeFoldsTotal('int64', sourGrapes=True)
-	setDatatypeElephino('uint8', sourGrapes=True)
+	setDatatypeElephino('int16', sourGrapes=True)
 	setDatatypeLeavesTotal('uint8', sourGrapes=True)
 	Z0Z_setDatatypeModuleScalar('numba')
 	Z0Z_setDecoratorCallable('jit')

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -4,42 +4,82 @@ everything I am doing. I would rather benefit from humanity's
 collective wisdom."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: Optional[bool] = False, algorithmSource: Optional[ModuleType] = None, relativePathWrite: Optional[pathlib.Path] = None, formatFilenameWrite: Optional[str] = None) -> List[youOughtaKnow]:
-	if relativePathWrite and relativePathWrite.is_absolute():
-		raise ValueError("The path to write the module must be relative to the root of the package.")
-	if not algorithmSource:
-		algorithmSource = getAlgorithmSource()
+def getFunctionDef(algorithmSource: ModuleType, *arguments, **keywordArguments) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	pythonSource = inspect.getsource(algorithmSource)
+	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
+	FunctionDefTarget, allImports = makeFunctionDef(astModule, *arguments, **keywordArguments)
+	return FunctionDefTarget, allImports
 
-	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+def makePythonSource(listFunctionDefs: List[ast.FunctionDef], listAstImports: List[ast.Import|ast.ImportFrom], additional_imports: List[str]) -> str:
+	astModule = ast.Module(body=cast(List[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
+	ast.fix_missing_locations(astModule)
+	pythonSource = ast.unparse(astModule)
+	if not pythonSource: raise FREAKOUT
+	pythonSource = autoflake.fix_code(pythonSource, additional_imports)
+	return pythonSource
+
+def writePythonAsModule(pythonSource: str, listCallableSynthesized: List[str], relativePathWrite: Optional[pathlib.Path], filenameWrite: Optional[str], formatFilenameWrite: Optional[str]) -> List[youOughtaKnow]:
+	pathFilename = None
+	if not relativePathWrite:
+		pathWrite = getPathSyntheticModules()
+	else:
+		pathWrite = getPathPackage() / relativePathWrite
 
-	def doThisStuff(callableTarget: str, parametersNumba: Optional[ParametersNumba], inlineCallables: bool, unpackArrays: bool, allImports: Optional[UniversalImportTracker], relativePathWrite: Optional[pathlib.Path], formatFilenameWrite: Optional[str]) -> youOughtaKnow:
-		pythonSource = inspect.getsource(algorithmSource)
-		pythonSource = makeAstModuleForOneCallable(pythonSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
-		if not pythonSource: raise FREAKOUT
-		pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+	if not formatFilenameWrite:
+		formatFilenameWrite = formatFilenameModuleDEFAULT
 
-		if not relativePathWrite:
-			pathWrite = getPathSyntheticModules()
+	if not filenameWrite:
+		if len(listCallableSynthesized) == 1:
+			callableTarget = listCallableSynthesized[0]
 		else:
-			pathWrite = getPathPackage() / relativePathWrite
-		if not formatFilenameWrite:
-			formatFilenameWrite = formatModuleNameDEFAULT + '.py'
-		pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
+			callableTarget = 'count'
+		filenameWrite = formatFilenameWrite.format(callableTarget=callableTarget)
+	else:
+		if not filenameWrite.endswith('.py'):
+			warnings.warn(f"Filename {filenameWrite=} does not end with '.py'.")
 
-		pathFilename.write_text(pythonSource)
+	pathFilename = pathWrite / filenameWrite
 
-		howIsThisStillAThing = getPathPackage().parent
-		dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
-		ImaModule = '.'.join(dumbassPythonNamespace)
+	pathFilename.write_text(pythonSource)
+
+	howIsThisStillAThing = getPathPackage().parent
+	dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
+	ImaModule = '.'.join(dumbassPythonNamespace)
+
+	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+
+	for callableTarget in listCallableSynthesized:
 		astImportFrom = ast.ImportFrom(module=ImaModule, names=[ast.alias(name=callableTarget, asname=None)], level=0)
+		stuff = youOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
+		listStuffYouOughtaKnow.append(stuff)
 
-		return youOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
+	return listStuffYouOughtaKnow
 
+def makeFlowNumbaOptimized(listCallablesInline: List[str]
+							, callableDispatcher: Optional[bool] = False
+							, algorithmSource: Optional[ModuleType] = None
+							, relativePathWrite: Optional[pathlib.Path] = None
+							, filenameModuleWrite: Optional[str] = None
+							, formatFilenameWrite: Optional[str] = None
+							) -> List[youOughtaKnow]:
+	if relativePathWrite and relativePathWrite.is_absolute():
+		raise ValueError("The path to write the module must be relative to the root of the package.")
+	if not algorithmSource:
+		algorithmSource = getAlgorithmSource()
+
+	Z0Z_filenameModuleWrite = 'numbaCount.py'
+
+	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+	additional_imports = ['mapFolding', 'numba', 'numpy']
+
+	listFunctionDefs: List[ast.FunctionDef] = []
+	allImportsModule = UniversalImportTracker()
 	for callableTarget in listCallablesInline:
 		parametersNumba = None
 		inlineCallables = True
 		unpackArrays 	= False
 		allImports 		= None
+		filenameWrite 	= None
 		match callableTarget:
 			case 'countParallel':
 				parametersNumba = parametersNumbaSuperJitParallel
@@ -48,7 +88,17 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 				unpackArrays = True
 			case 'countInitialize':
 				parametersNumba = parametersNumbaDEFAULT
-		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
+		FunctionDefTarget, allImports = getFunctionDef(algorithmSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
+		listFunctionDefs.append(FunctionDefTarget)
+		allImportsModule.update(allImports)
+
+	listAstImports = allImportsModule.makeListAst()
+	pythonSource = makePythonSource(listFunctionDefs, listAstImports, additional_imports)
+
+	filenameWrite = filenameModuleWrite or Z0Z_filenameModuleWrite
+
+	listStuff = writePythonAsModule(pythonSource, listCallablesInline, relativePathWrite, filenameWrite, formatFilenameWrite)
+	listStuffYouOughtaKnow.extend(listStuff)
 
 	if callableDispatcher:
 		callableTarget 	= getAlgorithmDispatcher().__name__
@@ -56,22 +106,24 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 		inlineCallables	= False
 		unpackArrays	= False
 		allImports 		= UniversalImportTracker()
+		filenameWrite 	= None
 		for stuff in listStuffYouOughtaKnow:
 			statement = stuff.astForCompetentProgrammers
 			if isinstance(statement, (ast.Import, ast.ImportFrom)):
 				allImports.addAst(statement)
+		FunctionDefTarget, allImports = getFunctionDef(algorithmSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
+		listAstImports = allImports.makeListAst()
+
+		pythonSource = makePythonSource([FunctionDefTarget], listAstImports, additional_imports)
 
-		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
+		listStuff = writePythonAsModule(pythonSource, [callableTarget], relativePathWrite, filenameWrite, formatFilenameWrite)
+		listStuffYouOughtaKnow.extend(listStuff)
 
 	return listStuffYouOughtaKnow
 
 if __name__ == '__main__':
-	setDatatypeModule('numpy', sourGrapes=True)
-	setDatatypeFoldsTotal('int64', sourGrapes=True)
-	setDatatypeElephino('uint8', sourGrapes=True)
-	setDatatypeLeavesTotal('uint8', sourGrapes=True)
-	Z0Z_setDatatypeModuleScalar('numba')
-	Z0Z_setDecoratorCallable('jit')
+	# Z0Z_setDatatypeModuleScalar('numba')
+	# Z0Z_setDecoratorCallable('jit')
 	listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
 	callableDispatcher = True
 	makeFlowNumbaOptimized(listCallablesInline, callableDispatcher)

mapFolding/syntheticModules/numbaCount.py

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

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,17 +1,10 @@
-from mapFolding.syntheticModules.numba_countInitialize import countInitialize
-from mapFolding.syntheticModules.numba_countParallel import countParallel
-from mapFolding.syntheticModules.numba_countSequential import countSequential
 from mapFolding import indexMy
-from numba import int64
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
+from mapFolding.syntheticModules.numbaCount import countParallel, countSequential, countInitialize
+from numba import jit, int64, uint16
+from numpy import ndarray, dtype, integer
+from typing import Tuple, Any
 
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
 def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], mapShape: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     countInitialize(connectionGraph, gapsWhere, my, track)
     if my[indexMy.taskDivisions.value] > 0: