mapFolding 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

mapFolding/someAssemblyRequired/transformationTools.py

@@ -22,11 +22,13 @@ from autoflake import fix_code as autoflake_fix_code
 from collections.abc import Callable, Mapping
 from copy import deepcopy
 from mapFolding.beDRY import outfitCountFolds
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
+	astModuleToIngredientsFunction,
 	be,
+	DeReConstructField2ast,
 	DOT,
+	extractClassDef,
 	grab,
 	ifThis,
 	importLogicalPath2Callable,
@@ -44,6 +46,7 @@ from mapFolding.someAssemblyRequired import (
 	个,
 )
 from mapFolding.theSSOT import ComputationState, raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, Literal, overload
@@ -52,59 +55,6 @@ import dataclasses
 import pickle
 import python_minifier
 
-def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
-	"""
-	Extract a function definition from an AST module and create an IngredientsFunction.
-
-	This function finds a function definition with the specified identifier in the given
-	AST module and wraps it in an IngredientsFunction object along with its import context.
-
-	Parameters:
-		astModule: The AST module containing the function definition.
-		identifierFunctionDef: The name of the function to extract.
-
-	Returns:
-		An IngredientsFunction object containing the function definition and its imports.
-
-	Raises:
-		raiseIfNoneGitHubIssueNumber3: If the function definition is not found.
-	"""
-	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
-
-def extractClassDef(module: ast.AST, identifier: ast_Identifier) -> ast.ClassDef | None:
-	"""
-	Extract a class definition with a specific name from an AST module.
-
-	This function searches through an AST module for a class definition that
-	matches the provided identifier and returns it if found.
-
-	Parameters:
-		module: The AST module to search within.
-		identifier: The name of the class to find.
-
-	Returns:
-		The matching class definition AST node, or None if not found.
-	"""
-	return NodeTourist(ifThis.isClassDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)
-
-def extractFunctionDef(module: ast.AST, identifier: ast_Identifier) -> ast.FunctionDef | None:
-	"""
-	Extract a function definition with a specific name from an AST module.
-
-	This function searches through an AST module for a function definition that
-	matches the provided identifier and returns it if found.
-
-	Parameters:
-		module: The AST module to search within.
-		identifier: The name of the function to find.
-
-	Returns:
-		astFunctionDef: The matching function definition AST node, or None if not found.
-	"""
-	return NodeTourist(ifThis.isFunctionDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)
-
 def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.FunctionDef]:
 	"""
 	Create a dictionary mapping function names to their AST definitions.
@@ -228,120 +178,6 @@ def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: bool =
 	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
 	return pathFilenameJob
 
-@dataclasses.dataclass
-class DeReConstructField2ast:
-	"""
-	Transform a dataclass field into AST node representations for code generation.
-
-	This class extracts and transforms a dataclass Field object into various AST node
-	representations needed for code generation. It handles the conversion of field
-	attributes, type annotations, and metadata into AST constructs that can be used
-	to reconstruct the field in generated code.
-
-	The class is particularly important for decomposing dataclass fields (like those in
-	ComputationState) to enable their use in specialized contexts like Numba-optimized
-	functions, where the full dataclass cannot be directly used but its contents need
-	to be accessible.
-
-	Each field is processed according to its type and metadata to create appropriate
-	variable declarations, type annotations, and initialization code as AST nodes.
-	"""
-	dataclassesDOTdataclassLogicalPathModule: dataclasses.InitVar[str_nameDOTname]
-	dataclassClassDef: dataclasses.InitVar[ast.ClassDef]
-	dataclassesDOTdataclassInstance_Identifier: dataclasses.InitVar[ast_Identifier]
-	field: dataclasses.InitVar[dataclasses.Field[Any]]
-
-	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-
-	name: ast_Identifier = dataclasses.field(init=False)
-	typeBuffalo: type[Any] | str | Any = dataclasses.field(init=False)
-	default: Any | None = dataclasses.field(init=False)
-	default_factory: Callable[..., Any] | None = dataclasses.field(init=False)
-	repr: bool = dataclasses.field(init=False)
-	hash: bool | None = dataclasses.field(init=False)
-	init: bool = dataclasses.field(init=False)
-	compare: bool = dataclasses.field(init=False)
-	metadata: dict[Any, Any] = dataclasses.field(init=False)
-	kw_only: bool = dataclasses.field(init=False)
-
-	astName: ast.Name = dataclasses.field(init=False)
-	ast_keyword_field__field: ast.keyword = dataclasses.field(init=False)
-	ast_nameDOTname: ast.Attribute = dataclasses.field(init=False)
-	astAnnotation: ast.expr = dataclasses.field(init=False)
-	ast_argAnnotated: ast.arg = dataclasses.field(init=False)
-	astAnnAssignConstructor: ast.AnnAssign|ast.Assign = dataclasses.field(init=False)
-	Z0Z_hack: tuple[ast.AnnAssign|ast.Assign, str] = dataclasses.field(init=False)
-
-	def __post_init__(self, dataclassesDOTdataclassLogicalPathModule: str_nameDOTname, dataclassClassDef: ast.ClassDef, dataclassesDOTdataclassInstance_Identifier: ast_Identifier, field: dataclasses.Field[Any]) -> None:
-		self.compare = field.compare
-		self.default = field.default if field.default is not dataclasses.MISSING else None
-		self.default_factory = field.default_factory if field.default_factory is not dataclasses.MISSING else None
-		self.hash = field.hash
-		self.init = field.init
-		self.kw_only = field.kw_only if field.kw_only is not dataclasses.MISSING else False
-		self.metadata = dict(field.metadata)
-		self.name = field.name
-		self.repr = field.repr
-		self.typeBuffalo = field.type
-
-		self.astName = Make.Name(self.name)
-		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
-		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
-
-		sherpa = NodeTourist(ifThis.isAnnAssign_targetIs(ifThis.isName_Identifier(self.name)), Then.extractIt(DOT.annotation)).captureLastMatch(dataclassClassDef)
-		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
-		else: self.astAnnotation = sherpa
-
-		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
-		"""
-from ast import Module, Expr, Subscript, Name, Tuple, Load
-Subscript(
-value=Name(id='ndarray', ctx=Load()),
-slice=Tuple(
-	elts=[
-	Subscript(
-		value=Name(id='tuple', ctx=Load()),
-		slice=Name(id='int', ctx=Load()),
-		ctx=Load()),
-	Subscript(
-		value=Name(id='dtype', ctx=Load()),
-		slice=Name(id='NumPyLeavesTotal', ctx=Load()),
-		ctx=Load())],
-	ctx=Load()),
-ctx=Load()
-)
-
-		"""
-		dtype = self.metadata.get('dtype', None)
-		if dtype:
-			moduleWithLogicalPath: str_nameDOTname = 'numpy'
-			annotationType = 'ndarray'
-			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, annotationType)
-			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, 'dtype')
-			axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Name('uint8'))
-			dtype_asnameName: ast.Name = self.astAnnotation # type: ignore
-			if dtype_asnameName.id == 'Array3D':
-				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8'), Make.Name('uint8')]))
-			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))
-			constructor = 'array'
-			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, constructor)
-			dtypeIdentifier: ast_Identifier = dtype.__name__
-			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, dtypeIdentifier, dtype_asnameName.id)
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, ast_expr, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
-			self.astAnnAssignConstructor = Make.Assign([self.astName], Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
-			self.Z0Z_hack = (self.astAnnAssignConstructor, 'array')
-		elif isinstance(self.astAnnotation, ast.Name):
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
-			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
-		elif isinstance(self.astAnnotation, ast.Subscript):
-			elementConstructor: ast_Identifier = self.metadata['elementConstructor']
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
-			takeTheTuple: ast.Tuple = deepcopy(self.astAnnotation.slice) # type: ignore
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
-			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)
-		if isinstance(self.astAnnotation, ast.Name):
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id) # pyright: ignore [reportUnknownArgumentType, reportUnknownMemberType, reportIJustCalledATypeGuardMethod_WTF]
-
 def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier) -> ShatteredDataclass:
 	"""
 	Decompose a dataclass definition into AST components for manipulation and code generation.
@@ -404,8 +240,8 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 	shatteredDataclass.repack = Make.Assign(listTargets=[Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_astKeywords=shatteredDataclass.list_keyword_field__field4init))
 	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
 
-	shatteredDataclass.ledger.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
-	shatteredDataclass.ledger.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
+	shatteredDataclass.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
+	shatteredDataclass.imports.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
 
 	return shatteredDataclass
 
@@ -448,6 +284,27 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 
 # END of acceptable classes and functions ======================================================
 def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> IngredientsFunction:
+	"""
+	Removes unused parameters from a function's AST definition, return statement, and annotation.
+
+	This function analyzes the Abstract Syntax Tree (AST) of a given function and removes
+	any parameters that are not referenced within the function body. It updates the
+	function signature, the return statement (if it's a tuple containing unused variables),
+	and the return type annotation accordingly.
+
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		An object containing the AST representation of a function to be processed.
+
+	Returns
+	-------
+	IngredientsFunction
+		The modified IngredientsFunction object with unused parameters and corresponding
+		return elements/annotations removed from its AST.
+
+	The modification is done in-place on the original AST nodes within the IngredientsFunction object.
+	"""
 	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
 	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
 	listName: list[ast.Name] = []
@@ -459,6 +316,18 @@ def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> Ingredie
 	for arg_Identifier in list_IdentifiersNotUsed:
 		remove_arg = NodeChanger(ifThis.is_arg_Identifier(arg_Identifier), Then.removeIt)
 		remove_arg.visit(ingredientsFunction.astFunctionDef)
+
+	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
+
+	listName: list[ast.Name] = [Make.Name(ast_arg.arg) for ast_arg in list_argCuzMyBrainRefusesToThink]
+	replaceReturn = NodeChanger(be.Return, Then.replaceWith(Make.Return(Make.Tuple(listName))))
+	replaceReturn.visit(ingredientsFunction.astFunctionDef)
+
+	list_annotation: list[ast.expr] = [ast_arg.annotation for ast_arg in list_argCuzMyBrainRefusesToThink if ast_arg.annotation is not None]
+	ingredientsFunction.astFunctionDef.returns = Make.Subscript(Make.Name('tuple'), Make.Tuple(list_annotation))
+
+	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
+
 	return ingredientsFunction
 
 def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
@@ -514,7 +383,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	instance_Identifier = recipeFlow.dataclassInstance
 	getTheOtherRecord_damn = recipeFlow.dataclassInstanceTaskDistribution
 	shatteredDataclass = shatter_dataclassesDOTdataclass(recipeFlow.logicalPathModuleDataclass, recipeFlow.sourceDataclassIdentifier, instance_Identifier)
-	ingredientsDispatcher.imports.update(shatteredDataclass.ledger)
+	ingredientsDispatcher.imports.update(shatteredDataclass.imports)
 
 	# How can I use dataclass settings as the SSOT for specific actions? https://github.com/hunterhogan/mapFolding/issues/16
 	# Change callable parameters and Call to the callable at the same time ====
@@ -542,6 +411,13 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 
 		replaceCall2concurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), listArguments=[Make.Name(recipeFlow.callableParallel)] + listParameters)))
 
+		def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
+			# TODO I cannot remember why I made this function. It doesn't fit with how I normally do things.
+			def workhorse(node: ast.AST) -> ast.AST:
+				NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
+				return node
+			return workhorse
+
 		# NOTE I am dissatisfied with this logic for many reasons, including that it requires separate NodeCollector and NodeReplacer instances.
 		astCallConcurrencyResult: list[ast.Call] = []
 		get_astCallConcurrencyResult = NodeTourist(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), getIt(astCallConcurrencyResult))
@@ -581,12 +457,6 @@ def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFun
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	return ingredientsCaller
 
-def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
-	def workhorse(node: ast.AST) -> ast.AST:
-		NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
-		return node
-	return workhorse
-
 dictionaryEstimates: dict[tuple[int, ...], int] = {
 	(2,2,2,2,2,2,2,2): 798148657152000,
 	(2,21): 776374224866624,

mapFolding/syntheticModules/daoOfMapFolding.py

@@ -0,0 +1,74 @@
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from numba import jit
+
+@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                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
+                if not dimensionsUnconstrained:
+                    indexLeaf = 0
+                    while indexLeaf < leaf1ndex:
+                        gapsWhere[gap1ndexCeiling] = indexLeaf
+                        gap1ndexCeiling += 1
+                        indexLeaf += 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
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    gap1ndex: DatatypeElephino = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    connectionGraph: Array3D = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
+    return state

mapFolding/syntheticModules/dataPacking.py

@@ -0,0 +1,25 @@
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.syntheticModules.theorem2Numba import count
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    gap1ndex: DatatypeElephino = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    connectionGraph: Array3D = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
+    return state

mapFolding/syntheticModules/initializeCount.py

@@ -0,0 +1,49 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def initializeGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
+    while state.groupsOfFolds == 0:
+        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                state.groupsOfFolds += 1
+            else:
+                state.dimensionsUnconstrained = state.dimensionsTotal
+                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+                state.indexDimension = 0
+                while state.indexDimension < state.dimensionsTotal:
+                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                    if state.leafConnectee == state.leaf1ndex:
+                        state.dimensionsUnconstrained -= 1
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                            if state.countDimensionsGapped[state.leafConnectee] == 0:
+                                state.gap1ndexCeiling += 1
+                            state.countDimensionsGapped[state.leafConnectee] += 1
+                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                    state.indexDimension += 1
+                if not state.dimensionsUnconstrained:
+                    state.indexLeaf = 0
+                    while state.indexLeaf < state.leaf1ndex:
+                        state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+                        state.gap1ndexCeiling += 1
+                        state.indexLeaf += 1
+                state.indexMiniGap = state.gap1ndex
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                        state.gap1ndex += 1
+                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                    state.indexMiniGap += 1
+        while state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state.leaf1ndex -= 1
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+        if state.leaf1ndex > 0:
+            state.gap1ndex -= 1
+            state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+            state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+            state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+            state.leaf1ndex += 1
+    return state

mapFolding/syntheticModules/theorem2.py

@@ -0,0 +1,49 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def count(state: MapFoldingState) -> MapFoldingState:
+    while state.leaf1ndex > 4:
+        if state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                state.groupsOfFolds += 1
+            else:
+                state.dimensionsUnconstrained = state.dimensionsTotal
+                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+                state.indexDimension = 0
+                while state.indexDimension < state.dimensionsTotal:
+                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                    if state.leafConnectee == state.leaf1ndex:
+                        state.dimensionsUnconstrained -= 1
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                            if state.countDimensionsGapped[state.leafConnectee] == 0:
+                                state.gap1ndexCeiling += 1
+                            state.countDimensionsGapped[state.leafConnectee] += 1
+                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                    state.indexDimension += 1
+                if not state.dimensionsUnconstrained:
+                    state.indexLeaf = 0
+                    while state.indexLeaf < state.leaf1ndex:
+                        state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+                        state.gap1ndexCeiling += 1
+                        state.indexLeaf += 1
+                state.indexMiniGap = state.gap1ndex
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                        state.gap1ndex += 1
+                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                    state.indexMiniGap += 1
+        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state.leaf1ndex -= 1
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+        state.gap1ndex -= 1
+        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+        state.leaf1ndex += 1
+    state.groupsOfFolds *= 2
+    return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -0,0 +1,45 @@
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from numba import jit
+
+@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+    while leaf1ndex > 4:
+        if leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                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 gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        gap1ndex -= 1
+        leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+        leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+        leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+        leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+        gapRangeStart[leaf1ndex] = gap1ndex
+        leaf1ndex += 1
+    groupsOfFolds *= 2
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)

mapFolding/syntheticModules/theorem2Trimmed.py

@@ -0,0 +1,43 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def count(state: MapFoldingState) -> MapFoldingState:
+    while state.leaf1ndex > 4:
+        if state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                state.groupsOfFolds += 1
+            else:
+                state.dimensionsUnconstrained = state.dimensionsTotal
+                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+                state.indexDimension = 0
+                while state.indexDimension < state.dimensionsTotal:
+                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                    if state.leafConnectee == state.leaf1ndex:
+                        state.dimensionsUnconstrained -= 1
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                            if state.countDimensionsGapped[state.leafConnectee] == 0:
+                                state.gap1ndexCeiling += 1
+                            state.countDimensionsGapped[state.leafConnectee] += 1
+                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                    state.indexDimension += 1
+                state.indexMiniGap = state.gap1ndex
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                        state.gap1ndex += 1
+                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                    state.indexMiniGap += 1
+        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state.leaf1ndex -= 1
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+        state.gap1ndex -= 1
+        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+        state.leaf1ndex += 1
+    state.groupsOfFolds *= 2
+    return state

{mapfolding-0.9.3.dist-info → mapfolding-0.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.3
+Version: 0.9.5
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -32,6 +32,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: autoflake
+Requires-Dist: cytoolz
 Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba