mapFolding 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

mapFolding/syntheticModules/{numbaCount_doTheNeedful.py → numbaCount.py}

@@ -4,7 +4,7 @@ from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeaves
 from numba import jit
 
 def countInitialize(state: ComputationState) -> ComputationState:
-    while state.leaf1ndex > 0:
+    while state.gap1ndex == 0:
         if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
             state.dimensionsUnconstrained = state.dimensionsTotal
             state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -42,12 +42,10 @@ def countInitialize(state: ComputationState) -> ComputationState:
             state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
             state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
             state.leaf1ndex += 1
-        if state.gap1ndex > 0:
-            break
     return state
 
 @jit(_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 countParallel(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeElephino, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> DatatypeFoldsTotal:
+def countParallel(leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> DatatypeFoldsTotal:
     while leaf1ndex > 0:
         if leaf1ndex <= 1 or leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -92,7 +90,7 @@ def countParallel(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: Dataty
     return groupsOfFolds
 
 @jit(_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 countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeElephino, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> tuple[tuple[DatatypeLeavesTotal, ...], DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, Array3D, DatatypeLeavesTotal, Array1DLeavesTotal, DatatypeLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DFoldsTotal, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal]:
+def countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> tuple[tuple[DatatypeLeavesTotal, ...], DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, Array3D, DatatypeLeavesTotal, Array1DLeavesTotal, DatatypeLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DFoldsTotal, DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 0:
         if leaf1ndex <= 1 or leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -124,6 +122,9 @@ def countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: Data
             leaf1ndex -= 1
             leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
             leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        if leaf1ndex == 3 and groupsOfFolds:
+            groupsOfFolds *= 2
+            break
         if leaf1ndex > 0:
             gap1ndex -= 1
             leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
@@ -158,16 +159,16 @@ def doTheNeedful(state: ComputationState) -> ComputationState:
                 leafBelow: Array1DLeavesTotal = state.leafBelow
                 foldGroups: Array1DFoldsTotal = state.foldGroups
                 foldsTotal: DatatypeFoldsTotal = state.foldsTotal
-                gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+                gap1ndex: DatatypeElephino = state.gap1ndex
                 gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
                 groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
                 indexDimension: DatatypeLeavesTotal = state.indexDimension
                 indexLeaf: DatatypeLeavesTotal = state.indexLeaf
                 indexMiniGap: DatatypeElephino = state.indexMiniGap
-                leaf1ndex: DatatypeElephino = state.leaf1ndex
-                leafConnectee: DatatypeElephino = state.leafConnectee
+                leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+                leafConnectee: DatatypeLeavesTotal = state.leafConnectee
                 taskIndex: DatatypeLeavesTotal = state.taskIndex
-                dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+                dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, leavesTotal, taskDivisions, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
             for indexSherpa in range(stateParallel.taskDivisions):
                 stateParallel.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
         state = stateParallel
@@ -186,14 +187,14 @@ def doTheNeedful(state: ComputationState) -> ComputationState:
         leafBelow: Array1DLeavesTotal = state.leafBelow
         foldGroups: Array1DFoldsTotal = state.foldGroups
         foldsTotal: DatatypeFoldsTotal = state.foldsTotal
-        gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+        gap1ndex: DatatypeElephino = state.gap1ndex
         gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
         groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
         indexDimension: DatatypeLeavesTotal = state.indexDimension
         indexLeaf: DatatypeLeavesTotal = state.indexLeaf
         indexMiniGap: DatatypeElephino = state.indexMiniGap
-        leaf1ndex: DatatypeElephino = state.leaf1ndex
-        leafConnectee: DatatypeElephino = state.leafConnectee
+        leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+        leafConnectee: DatatypeLeavesTotal = state.leafConnectee
         taskIndex: DatatypeLeavesTotal = state.taskIndex
         mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex = countSequential(mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
         state = ComputationState(mapShape=mapShape, leavesTotal=leavesTotal, taskDivisions=taskDivisions, concurrencyLimit=concurrencyLimit, countDimensionsGapped=countDimensionsGapped, dimensionsUnconstrained=dimensionsUnconstrained, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, foldGroups=foldGroups, foldsTotal=foldsTotal, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, groupsOfFolds=groupsOfFolds, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, taskIndex=taskIndex)

mapFolding/theDao.py

@@ -1,23 +1,22 @@
 """
 Core computational algorithm for map folding counting and enumeration.
 
-This module implements the core algorithms for enumerating and counting the various ways
-a rectangular map can be folded. It uses a functional state-transformation approach, where
-each function performs a specific state mutation and returns the updated state. The module
-provides three main counting algorithms:
-
-1. countInitialize: Sets up the initial state for computation
-2. countSequential: Processes the folding computation sequentially
-3. countParallel: Distributes the computation across multiple processes
-
-All algorithms operate on a ComputationState object that tracks the folding process, including:
-- A "leaf" is a unit square in the map
-- A "gap" is a potential position where a new leaf can be folded
-- Connections track how leaves can connect above/below each other
-- Leaves are enumerated starting from 1, not 0; hence, leaf1ndex not leafIndex
-
-The doTheNeedful function is the main entry point that orchestrates the computation strategy
-based on task divisions and concurrency parameters.
+This module implements the core algorithms for enumerating and counting the various ways a rectangular map can be
+folded. It uses a functional state-transformation approach, where each function performs a specific state mutation and
+returns the updated state. The module provides three main counting algorithms:
+
+1. `countInitialize`: Sets up the initial state for computation.
+2. `countSequential`: Processes the folding computation sequentially.
+3. `countParallel`: Distributes the computation across multiple processes.
+
+All algorithms operate on a `ComputationState` object that tracks the folding process, including:
+- A "leaf" is a unit square in the map.
+- A "gap" is a potential position where a new leaf can be folded.
+- Connections track how leaves can connect above/below each other.
+- Leaves are enumerated starting from 1, not 0; hence, `leaf1ndex` not `leafIndex`.
+
+The `doTheNeedful` function is the main entry point that orchestrates the computation strategy based on task divisions and
+concurrency parameters.
 """
 from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
@@ -43,12 +42,6 @@ def activeLeafIsTheFirstLeaf(state: ComputationState) -> bool:
 def allDimensionsAreUnconstrained(state: ComputationState) -> bool:
 	return not state.dimensionsUnconstrained
 
-def undoLastLeafPlacement(state: ComputationState) -> ComputationState:
-	state.leaf1ndex -= 1
-	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
-	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
-	return state
-
 def countGaps(state: ComputationState) -> ComputationState:
 	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
 	if state.countDimensionsGapped[state.leafConnectee] == 0:
@@ -100,6 +93,16 @@ def initializeVariablesToFindGaps(state: ComputationState) -> ComputationState:
 	state.indexDimension = 0
 	return state
 
+def insertLeafAtGap(state: ComputationState) -> ComputationState:
+	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
+
 def insertUnconstrainedLeaf(state: ComputationState) -> ComputationState:
 	state.indexLeaf = 0
 	while state.indexLeaf < state.leaf1ndex:
@@ -123,28 +126,24 @@ def loopUpToDimensionsTotal(state: ComputationState) -> bool:
 def noGapsHere(state: ComputationState) -> bool:
 	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
 
-def insertLeafAtGap(state: ComputationState) -> ComputationState:
-	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
-
 def thereIsAnActiveLeaf(state: ComputationState) -> bool:
 	return state.leaf1ndex > 0
 
 def thisIsMyTaskIndex(state: ComputationState) -> bool:
 	return (state.leaf1ndex != state.taskDivisions) or (state.leafConnectee % state.taskDivisions == state.taskIndex)
 
+def undoLastLeafPlacement(state: ComputationState) -> ComputationState:
+	state.leaf1ndex -= 1
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+	return state
+
 def updateLeafConnectee(state: ComputationState) -> ComputationState:
 	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
 	return state
 
 def countInitialize(state: ComputationState) -> ComputationState:
-	while activeLeafGreaterThan0(state):
+	while state.gap1ndex == 0:
 		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
 				state = initializeVariablesToFindGaps(state)
 				while loopUpToDimensionsTotal(state):
@@ -164,8 +163,6 @@ def countInitialize(state: ComputationState) -> ComputationState:
 					state = incrementIndexMiniGap(state)
 		if thereIsAnActiveLeaf(state):
 			state = insertLeafAtGap(state)
-		if state.gap1ndex > 0:
-			break
 	return state
 
 def countParallel(state: ComputationState) -> ComputationState:
@@ -218,6 +215,10 @@ def countSequential(state: ComputationState) -> ComputationState:
 					state = incrementIndexMiniGap(state)
 		while noGapsHere(state):
 			state = undoLastLeafPlacement(state)
+		if state.leaf1ndex == 3 and state.groupsOfFolds:
+			state.groupsOfFolds *= 2
+			# print('break')
+			break
 		if thereIsAnActiveLeaf(state):
 			state = insertLeafAtGap(state)
 	state.foldGroups[state.taskIndex] = state.groupsOfFolds

mapFolding/theSSOT.py

@@ -1,25 +1,25 @@
 """
 Single Source of Truth module for configuration, types, and computational state management.
 
-This module defines the core data structures, type definitions, and configuration settings
-used throughout the mapFolding package. It implements the Single Source of Truth (SSOT)
-principle to ensure consistency across the package's components.
+This module defines the core data structures, type definitions, and configuration settings used throughout the
+mapFolding package. It implements the Single Source of Truth (SSOT) principle to ensure consistency across the package's
+components.
 
 Key features:
-1. The ComputationState dataclass, which encapsulates the state of the folding computation
-2. Unified type definitions for integers and arrays used in the computation
-3. Configuration settings for synthetic module generation and dispatching
-4. Path resolution and management for package resources and job output
-5. Dynamic dispatch functionality for algorithm implementations
-
-The module differentiates between "the" identifiers (package defaults) and other identifiers
-to avoid namespace collisions when transforming algorithms.
+1. The `ComputationState` dataclass, which encapsulates the state of the folding computation.
+2. Unified type definitions for integers and arrays used in the computation.
+3. Configuration settings for synthetic module generation and dispatching.
+4. Path resolution and management for package resources and job output.
+5. Dynamic dispatch functionality for algorithm implementations.
+
+The module differentiates between "the" identifiers (package defaults) and other identifiers to avoid namespace
+collisions when transforming algorithms.
 """
 
 from collections.abc import Callable
 from importlib import import_module as importlib_import_module
 from inspect import getfile as inspect_getfile
-from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, integer, ndarray
+from numpy import dtype, int64 as numpy_int64, integer, ndarray
 from pathlib import Path
 from tomli import load as tomli_load
 from types import ModuleType
@@ -42,10 +42,10 @@ def getPathPackageINSTALLING() -> Path:
 # I believe these values should be dynamically determined, so I have conspicuously marked them "HARDCODED"
 # and created downstream logic that assumes the values were dynamically determined.
 # Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-logicalPathModuleDispatcherHARDCODED: str = 'mapFolding.syntheticModules.numbaCount_doTheNeedful'
+logicalPathModuleDispatcherHARDCODED: str = 'mapFolding.syntheticModules.numbaCount'
 callableDispatcherHARDCODED: str = 'doTheNeedful'
 concurrencyPackageHARDCODED = 'multiprocessing'
-# from mapFolding.someAssemblyRequired.synthesizeNumbaFlow.theNumbaFlow
+# from mapFolding.someAssemblyRequired.toolboxNumba.theNumbaFlow
 
 # PackageSettings in theSSOT.py and immutability https://github.com/hunterhogan/mapFolding/issues/11
 @dataclasses.dataclass
@@ -53,10 +53,9 @@ class PackageSettings:
 	"""
 	Centralized configuration settings for the mapFolding package.
 
-	This class implements the Single Source of Truth (SSOT) principle for package
-	configuration, providing a consistent interface for accessing package settings,
-	paths, and dispatch functions. The primary instance of this class, named `The`,
-	is imported and used throughout the package to retrieve configuration values.
+	This class implements the Single Source of Truth (SSOT) principle for package configuration, providing a consistent
+	interface for accessing package settings, paths, and dispatch functions. The primary instance of this class, named
+	`The`, is imported and used throughout the package to retrieve configuration values.
 	"""
 
 	logicalPathModuleDispatcher: str | None = None
@@ -151,10 +150,10 @@ The = PackageSettings(logicalPathModuleDispatcher=logicalPathModuleDispatcherHAR
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 
 DatatypeLeavesTotal: TypeAlias = int
-NumPyLeavesTotal: TypeAlias = numpy_int16 # this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers must accommodate at least 256 leaves
+NumPyLeavesTotal: TypeAlias = numpy_int64
 
 DatatypeElephino: TypeAlias = int
-NumPyElephino: TypeAlias = numpy_int16
+NumPyElephino: TypeAlias = numpy_int64
 
 DatatypeFoldsTotal: TypeAlias = int
 NumPyFoldsTotal: TypeAlias = numpy_int64
@@ -169,18 +168,15 @@ class ComputationState:
 	"""
 	Represents the complete state of a map folding computation.
 
-	This dataclass encapsulates all the information required to compute the number of
-	possible ways to fold a map, including the map dimensions, leaf connections,
-	computation progress, and fold counting. It serves as the central data structure
-	that flows through the entire computational algorithm.
+	This dataclass encapsulates all the information required to compute the number of possible ways to fold a map,
+	including the map dimensions, leaf connections, computation progress, and fold counting. It serves as the central
+	data structure that flows through the entire computational algorithm.
 
 	Fields are categorized into:
-	1. Input parameters (mapShape, leavesTotal, etc.)
-	2. Core computational structures (connectionGraph, etc.)
-	3. Tracking variables for the folding algorithm state
-	4. Result accumulation fields (foldsTotal, groupsOfFolds)
-
-	The data structures and algorithms are based on Lunnon's 1971 paper on map folding.
+	1. Input parameters (`mapShape`, `leavesTotal`, etc.).
+	2. Core computational structures (`connectionGraph`, etc.).
+	3. Tracking variables for the folding algorithm state.
+	4. Result accumulation fields (`foldsTotal`, `groupsOfFolds`).
 	"""
 	# NOTE Python is anti-DRY, again, `DatatypeLeavesTotal` metadata needs to match the type
 	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
@@ -226,7 +222,7 @@ class ComputationState:
 	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
 	"""The final computed total number of distinct folding patterns."""
 
-	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)
 	"""Current index into gaps array during algorithm execution."""
 
 	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
@@ -244,10 +240,10 @@ class ComputationState:
 	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
 	"""Index used when filtering common gaps."""
 
-	leaf1ndex: DatatypeElephino = DatatypeElephino(1)
+	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
 	"""Active leaf being processed in the folding algorithm. Starts at 1, not 0."""
 
-	leafConnectee: DatatypeElephino = DatatypeElephino(0)
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	"""Leaf that is being connected to the active leaf."""
 
 	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)

mapFolding/toolboxFilesystem.py

@@ -1,20 +1,19 @@
 """
 Filesystem utilities for managing map folding computation results.
 
-This module provides functions for standardized handling of files related to the mapFolding
-package, with a focus on saving, retrieving, and naming computation results. It implements
-consistent naming conventions and path resolution strategies to ensure that:
+This module provides functions for standardized handling of files related to the mapFolding package, with a focus on
+saving, retrieving, and naming computation results. It implements consistent naming conventions and path resolution
+strategies to ensure that:
 
 1. Computation results are stored in a predictable location.
 2. Filenames follow a consistent pattern based on map dimensions.
 3. Results can be reliably retrieved for future reference.
 4. The system handles file operations safely with appropriate error handling.
 
-The module serves as the standardized interface between the computational components
-of the package and the filesystem, abstracting away the details of file operations
-and path management. It provides robust fallback mechanisms to preserve computation
-results even in the face of filesystem errors, which is critical for long-running
-computations that may take days to complete.
+The module serves as the standardized interface between the computational components of the package and the filesystem,
+abstracting away the details of file operations and path management. It provides robust fallback mechanisms to preserve
+computation results even in the face of filesystem errors, which is critical for long-running computations that may take
+days to complete.
 
 The functions here adhere to a consistent approach to path handling:
 - Cross-platform compatibility through the use of `pathlib`.
@@ -33,9 +32,9 @@ def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 	"""
 	Create a standardized filename for a computed `foldsTotal` value.
 
-	This function generates a consistent, filesystem-safe filename based on map dimensions.
-	Standardizing filenames ensures that results can be reliably stored and retrieved,
-	avoiding potential filesystem incompatibilities or Python naming restrictions.
+	This function generates a consistent, filesystem-safe filename based on map dimensions. Standardizing filenames
+	ensures that results can be reliably stored and retrieved, avoiding potential filesystem incompatibilities or Python
+	naming restrictions.
 
 	Parameters:
 		mapShape: A sequence of integers representing the dimensions of the map.
@@ -49,7 +48,7 @@ def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 		- Safe filesystem characters
 		- Unique extension (.foldsTotal)
 		- Python-safe strings (no starting with numbers, no reserved words)
-		- The 'p' prefix comes from Lunnan's original code.
+		- The 'p' prefix comes from Lunnon's original code.
 	"""
 	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
 
@@ -57,14 +56,13 @@ def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal
 	"""
 	Get a standardized path and filename for the computed `foldsTotal` value.
 
-	This function resolves paths for storing computation results, handling different
-	input types including directories, absolute paths, or relative paths. It ensures
-	that all parent directories exist in the resulting path.
+	This function resolves paths for storing computation results, handling different input types including directories,
+	absolute paths, or relative paths. It ensures that all parent directories exist in the resulting path.
 
 	Parameters:
 		mapShape: List of dimensions for the map folding problem.
-		pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename.
-			If None, uses default path. If a directory, appends standardized filename.
+		pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename. If None, uses
+			default path. If a directory, appends standardized filename.
 
 	Returns:
 		pathFilenameFoldsTotal: Absolute path and filename for storing the `foldsTotal` value.
@@ -91,10 +89,9 @@ def getPathRootJobDEFAULT() -> Path:
 	"""
 	Get the default root directory for map folding computation jobs.
 
-	This function determines the appropriate default directory for storing computation
-	results based on the current runtime environment. It uses platform-specific
-	directories for normal environments and adapts to special environments like
-	Google Colab.
+	This function determines the appropriate default directory for storing computation results based on the current
+	runtime environment. It uses platform-specific directories for normal environments and adapts to special
+	environments like Google Colab.
 
 	Returns:
 		pathJobDEFAULT: Path to the default directory for storing computation results
@@ -112,10 +109,7 @@ def getPathRootJobDEFAULT() -> Path:
 
 def _saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> None:
 	"""
-	Internal helper function to save a `foldsTotal` value to a file.
-
-	This is a low-level function used by the public `saveFoldsTotal` function.
-	It handles the basic file operation without extensive error handling.
+	Standardized function to save a `foldsTotal` value to a file.
 
 	Parameters:
 		pathFilename: Path where the `foldsTotal` value should be saved
@@ -129,9 +123,8 @@ def saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> N
 	"""
 	Save `foldsTotal` value to disk with multiple fallback mechanisms.
 
-	This function attempts to save the computed `foldsTotal` value to the specified
-	location, with backup strategies in case the primary save attempt fails.
-	The robustness is critical since these computations may take days to complete.
+	This function attempts to save the computed `foldsTotal` value to the specified location, with backup strategies in
+	case the primary save attempt fails. The robustness is critical since these computations may take days to complete.
 
 	Parameters:
 		pathFilename: Target save location for the `foldsTotal` value
@@ -165,9 +158,8 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 	"""
 	Preemptively test file write capabilities before beginning computation.
 
-	This function performs validation checks on the target file location before
-	a potentially long-running computation begins. It tests several critical
-	aspects of filesystem functionality to ensure results can be saved:
+	This function performs validation checks on the target file location before a potentially long-running computation
+	begins. It tests several critical aspects of filesystem functionality to ensure results can be saved:
 
 	1. Checks if the file already exists to prevent accidental overwrites.
 	2. Verifies that parent directories exist.
@@ -182,8 +174,8 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 		FileNotFoundError: If parent directories don't exist or if write tests fail.
 
 	Notes:
-		This function helps prevent a situation where a computation runs for
-		hours or days only to discover at the end that results cannot be saved.
+		This function helps prevent a situation where a computation runs for hours or days only to discover at the end
+		that results cannot be saved.
 	"""
 	if Path(pathFilename).exists():
 		raise FileExistsError(f"`{pathFilename = }` exists: a battle of overwriting might cause tears.")
@@ -201,17 +193,16 @@ def writeStringToHere(this: str, pathFilename: PathLike[str] | PurePath) -> None
 	"""
 	Write a string to a file, creating parent directories if needed.
 
-	This utility function provides a consistent interface for writing string content
-	to files across the package. It handles path creation and ensures proper
-	string conversion.
+	This utility function provides a consistent interface for writing string content to files across the package. It
+	handles path creation and ensures proper string conversion.
 
 	Parameters:
 		this: The string content to write to the file.
 		pathFilename: The target file path where the string should be written.
 
 	Notes:
-		This function creates all parent directories in the path if they don't exist,
-		making it safe to use with newly created directory structures.
+		This function creates all parent directories in the path if they don't exist, making it safe to use with newly
+		created directory structures.
 	"""
 	pathFilename = Path(pathFilename)
 	pathFilename.parent.mkdir(parents=True, exist_ok=True)

{mapfolding-0.9.0.dist-info → mapfolding-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.0
+Version: 0.9.2
 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
@@ -38,6 +38,7 @@ Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Requires-Dist: python_minifier
+Requires-Dist: sympy
 Requires-Dist: tomli
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing

mapfolding-0.9.2.dist-info/RECORD

@@ -0,0 +1,47 @@
+mapFolding/__init__.py,sha256=RwSpDoCykIukgnlZNf8HSmICtuk6xFuoovYvSuqzK_g,4253
+mapFolding/basecamp.py,sha256=WQxSTucEuTA_ee7Wlfkd5RIClzEsal5OHaCwcT8g3rU,4747
+mapFolding/beDRY.py,sha256=3GDFCzFHEL3uPAEGVxrUj8TX-MGHDObwn9KoMVEMKAc,16074
+mapFolding/oeis.py,sha256=TYJKlCBrYSVhTCFret5QS5B_rs_MNEF8yFU0vLuu5OQ,17138
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=kc3rzTX3yts0PxgPCXFbgWvaqsBexsiU5ib2pzpvID0,10019
+mapFolding/theSSOT.py,sha256=ozmfoUPVtbuB_i-m8On80nDGzqBSFHTvNrh6srHMrzY,16596
+mapFolding/toolboxFilesystem.py,sha256=kVZoU-NBvfYSvI4R8mEpMXRUZee-1JV0fjtMFWPhk8Y,9818
+mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,2206
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnonWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
+mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
+mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
+mapFolding/someAssemblyRequired/RecipeJob.py,sha256=JL5Xkmp8ritVMhL1pGhX7eEw5fde3FVD8-9-vZOZwWI,5399
+mapFolding/someAssemblyRequired/__init__.py,sha256=kMoIH57T68hHArRiW6EBuuC-JNpxTXgmjH2aqN-NjWE,4106
+mapFolding/someAssemblyRequired/_theTypes.py,sha256=pkMnYGtIAvIgudcvmbhZwmNnczY3Gk_ZmcS_7vfSZsU,4342
+mapFolding/someAssemblyRequired/_tool_Make.py,sha256=0TGZtCUt6uu8h47N833qZ9IIjbn_yhoPFsBDEotQp9A,7222
+mapFolding/someAssemblyRequired/_tool_Then.py,sha256=0Xb-MfKJhXjoVBTC7CSjpgCxxilL_WquL4WzKQWMR5A,4464
+mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=6m80_ThGF47WWIkYweEdc3LRq96fHklys7IpoFSqN7A,13288
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=zXjE70W1XodEGo2H1PofLoDbjtTKaJVlfv5I49jMz3o,23609
+mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=TuRC5CD_6tTjjLuvGgPbnqCSvIP3Vp2k2r592Dcpff4,7642
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=0i4iBBzHY9Io0XrsmXD814P52C_igvv_Aeur4udR8jI,15571
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=cHpX8dn1Fr_TWpDgVhYx6ObmEeD6slYeMWeE9laJadI,10754
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=goxIq-LGu-lRkdzvCrKYDp9hJyKzL_TtNZnSP6zLbY8,35833
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/numbaCount.py,sha256=zM-bp07c9tEDdvidwzZ_bJTd0JC0VUkYEEiHG--P1tQ,15525
+mapfolding-0.9.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=UIvSWWz_anRXBELKPOdhfRoZ4hArHQTvghHrRquDHHw,1940
+tests/conftest.py,sha256=G8vhDSTdTbYZUFBUKLFOUOzDL1Ja6NVZmICCh4biZas,14298
+tests/test_computations.py,sha256=MbnK9kRRwH3UI7aVMreNuEbzNVC2hP0Gq2mR-xjuxrI,6205
+tests/test_filesystem.py,sha256=T2DkjBoI3lW6tCxd5BilPmUFrVukNKLjOOZVZxLM560,3004
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=UMlK4JPInalpOZuPvTnUrgXWCJOxAw-OsPs6CxMR254,3753
+tests/test_tasks.py,sha256=yrExYvFP23TEA3ta0IotMNmi59rwQ3Y9hA3fwvIhxTE,2851
+mapfolding-0.9.2.dist-info/METADATA,sha256=Ec4d3Oalth5tiJ-9Cnxap4kp6ehPFVxij_YtkaunuyQ,7466
+mapfolding-0.9.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mapfolding-0.9.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.9.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.9.2.dist-info/RECORD,,

tests/test_computations.py

@@ -87,6 +87,7 @@ that provide consistent, informative error messages and simplify test validation
 
 from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n, validateListDimensions
 from mapFolding.oeis import settingsOEIS
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
 from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
 from pathlib import Path, PurePosixPath
 from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
@@ -115,7 +116,7 @@ def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTes
 
 @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: list[int], pathFilenameTmpTesting: Path) -> None:
-	from mapFolding.someAssemblyRequired.toolboxNumba import RecipeJob, SpicesJobNumba
+	from mapFolding.someAssemblyRequired.toolboxNumba import SpicesJobNumba
 	from mapFolding.someAssemblyRequired.synthesizeNumbaJob import makeJobNumba
 	mapShape = validateListDimensions(oneTestCuzTestsOverwritingTests)
 	state = makeInitializedComputationState(mapShape)

tests/test_other.py

@@ -14,20 +14,15 @@ import sys
 	(['a'], ValueError, ValueError),  # string
 	([-4, 2], [-4, 2], ValueError),  # negative
 	([-3], [-3], ValueError),  # negative
-	([0, 0], [0, 0], NotImplementedError),  # no positive dimensions
-	([0, 5, 6], [0, 5, 6], (5, 6)),  # zeros ignored
-	([0], [0], NotImplementedError),  # edge case
 	([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], (1, 2, 3, 4, 5)),  # sequential
 	([1, sys.maxsize], [1, sys.maxsize], (1, sys.maxsize)),  # maxint
 	([7.5], ValueError, ValueError),  # float
 	([1] * 1000, [1] * 1000, (1,) * 1000),  # long list
 	([11], [11], NotImplementedError),  # single dimension
-	([13, 0, 17], [13, 0, 17], (13, 17)),  # zeros handled
 	([2, 2, 2, 2], [2, 2, 2, 2], (2, 2, 2, 2)),  # repeated dimensions
 	([2, 3, 4], [2, 3, 4], (2, 3, 4)),
 	([2, 3], [2, 3], (2, 3)),
 	([2] * 11, [2] * 11, (2,) * 11),  # power of 2
-	([3, 2], [3, 2], (2, 3)),  # return value is sorted
 	([3] * 5, [3] * 5, (3,) * 5),  # power of 3
 	([None], TypeError, TypeError),  # None
 	([True], TypeError, TypeError),  # bool
@@ -36,8 +31,6 @@ import sys
 	([complex(1,1)], ValueError, ValueError),  # complex number
 	([float('inf')], ValueError, ValueError),  # infinity
 	([float('nan')], ValueError, ValueError),  # NaN
-	([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], (1, sys.maxsize - 1)),  # near maxint
-	([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], (2, sys.maxsize // 2, sys.maxsize // 2)),  # overflow protection
 	([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], (sys.maxsize, sys.maxsize)),  # overflow protection
 	(range(3, 7), [3, 4, 5, 6], (3, 4, 5, 6)),  # range sequence type
 	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type