mapFolding 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

mapFolding/theDao.py

@@ -1,14 +1,28 @@
-from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
-from copy import deepcopy
-from mapFolding.theSSOT import ComputationState
-from multiprocessing import set_start_method as multiprocessing_set_start_method
-
 """
+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.
 """
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
+from mapFolding.theSSOT import ComputationState
+from multiprocessing import set_start_method as multiprocessing_set_start_method
 
 # When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
 if __name__ == '__main__':

mapFolding/theSSOT.py

@@ -1,114 +1,103 @@
+"""
+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.
+
+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.
+"""
+
 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, ndarray, signedinteger
+from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray
 from pathlib import Path
 from sys import modules as sysModules
 from tomli import load as tomli_load
 from types import ModuleType
-from typing import Any, Final, TypeAlias
+from typing import TypeAlias
 import dataclasses
 
-"""
-2025 March 11
-Note to self: fundamental concept in Python:
-Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
-- Local: Inside the function
-- Enclosing: Inside enclosing functions
-- Global: At the uppermost level
-- Builtin: Python's built-in names
-"""
-
-# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 # Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 packageFlowSynthetic = 'numba'
 # Z0Z_packageFlow = 'algorithm'
 Z0Z_packageFlow = packageFlowSynthetic
 Z0Z_concurrencyPackage = 'multiprocessing'
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Evaluate When Packaging Evaluate When Packaging Evaluate When Packaging
 
-sourceAlgorithmPACKAGING: str = 'theDao'
-datatypePackagePACKAGING: Final[str] = 'numpy'
-dispatcherCallablePACKAGING: str = 'doTheNeedful'
-moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
-
-dataclassModulePACKAGING: str = 'theSSOT'
-dataclassIdentifierPACKAGING: str = 'ComputationState'
-dataclassInstancePACKAGING: str = 'state'
-dataclassInstanceTaskDistributionPACKAGING = dataclassInstancePACKAGING + 'Parallel'
-
-sourceInitializeCallablePACKAGING = 'countInitialize'
-sourceSequentialCallablePACKAGING = 'countSequential'
-sourceParallelCallablePACKAGING = 'countParallel'
+# =============================================================================
+# The Wrong Way: Evaluate When Packaging
 
 try:
-	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+	packageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNamePACKAGING = "mapFolding"
+	packageNamePACKAGING = "mapFolding"
 
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Evaluate When Installing Evaluate When Installing Evaluate When Installing
-
-fileExtensionINSTALLING: str = '.py'
+# The Wrong Way: Evaluate When Installing
 
 def getPathPackageINSTALLING() -> Path:
-	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNamePACKAGING)))
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(packageNamePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# =============================================================================
-# The right way, perhaps.
-
-# Create enduring identifiers from the hopefully transient identifiers above.
-thePackageName: Final[str] = thePackageNamePACKAGING
-thePathPackage: Path = getPathPackageINSTALLING()
-
-"""
-NOTE on semiotics: `theIdentifier` vs `identifier`
-
-- This package has a typical, "hardcoded" algorithm for counting map folds.
-- This package has logic for transforming that algorithm into other forms.
-- The transformation logic can transform other algorithms if 1) they are similar enough to the "hardcoded" algorithm and 2) I have written the transformation logic well enough to handle the differences.
-- To avoid confusion and namespace collisions, I differentiate between, for example, `theSourceAlgorithm` of the package and any other `sourceAlgorithm` being transformed by the package.
-"""
-
-theSourceAlgorithm: str = sourceAlgorithmPACKAGING
-theSourceInitializeCallable = sourceInitializeCallablePACKAGING
-theSourceSequentialCallable = sourceSequentialCallablePACKAGING
-theSourceParallelCallable = sourceParallelCallablePACKAGING
-theDatatypePackage: Final[str] = datatypePackagePACKAGING
-
-theDispatcherCallable: str = dispatcherCallablePACKAGING
-
-theDataclassModule: str = dataclassModulePACKAGING
-theDataclassIdentifier: str = dataclassIdentifierPACKAGING
-theDataclassInstance: str = dataclassInstancePACKAGING
-theDataclassInstanceTaskDistribution: str = dataclassInstanceTaskDistributionPACKAGING
-
-theFileExtension: str = fileExtensionINSTALLING
-
-theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
+# The following is an improvement, but it is not the full solution.
+# I hope that the standardized markers, `metadata={'evaluateWhen': 'packaging'}` will help to automate
+# whatever needs to happen so that the following is well implemented.
+@dataclasses.dataclass(frozen=True)
+class PackageSettings:
+	concurrencyPackage = Z0Z_concurrencyPackage
+	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
+	dataclassInstance: str = dataclasses.field(default='state', metadata={'evaluateWhen': 'packaging'})
+	dataclassInstanceTaskDistributionSuffix: str = dataclasses.field(default='Parallel', metadata={'evaluateWhen': 'packaging'})
+	dataclassModule: str = dataclasses.field(default='theSSOT', metadata={'evaluateWhen': 'packaging'})
+	datatypePackage: str = dataclasses.field(default='numpy', metadata={'evaluateWhen': 'packaging'})
+	dispatcherCallable: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
+	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
+	moduleOfSyntheticModules: str = dataclasses.field(default='syntheticModules', metadata={'evaluateWhen': 'packaging'})
+	packageName: str = dataclasses.field(default = packageNamePACKAGING, metadata={'evaluateWhen': 'packaging'})
+	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, init=False, metadata={'evaluateWhen': 'installing'})
+	sourceAlgorithm: str = dataclasses.field(default='theDao', metadata={'evaluateWhen': 'packaging'})
+	sourceConcurrencyManagerIdentifier: str = dataclasses.field(default='submit', metadata={'evaluateWhen': 'packaging'})
+	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
+	sourceInitializeCallable: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
+	sourceParallelCallable: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
+	sourceSequentialCallable: str = dataclasses.field(default='countSequential', metadata={'evaluateWhen': 'packaging'})
+
+	@property # These are not fields, and that annoys me.
+	def dataclassInstanceTaskDistribution(self) -> str:
+		""" Compute the task distribution identifier by concatenating dataclassInstance and dataclassInstanceTaskDistributionSuffix. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
+
+	@property # These are not fields, and that annoys me.
+	def logicalPathModuleSourceAlgorithm(self) -> str:
+		""" Compute the logical path module for the source algorithm by joining packageName and sourceAlgorithm. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return '.'.join([self.packageName, self.sourceAlgorithm])
+
+	@property # These are not fields, and that annoys me.
+	def logicalPathModuleDataclass(self) -> str:
+		""" Compute the logical path module for the dataclass by joining packageName and dataclassModule. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return '.'.join([self.packageName, self.dataclassModule])
+
+The = PackageSettings()
 
 # =============================================================================
-
-# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-concurrencyPackage: str = Z0Z_packageFlow
-concurrencyPackage = Z0Z_concurrencyPackage
-
-# =============================================================================
-# The relatively flexible type system needs a different paradigm, but I don't
-# know what it should be. The system needs to 1) help optimize computation, 2)
-# make it possible to change the basic type of the package (e.g., from numpy
-# to superTypePy), 3) make it possible to synthesize the optimized flow of used
-# by the package, and 4) make it possible to synthesize arbitrary modules with
-# different type systems.
+# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
 
 DatatypeLeavesTotal: TypeAlias = int
-# this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers accommodate
+# 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_int16
 
 DatatypeElephino: TypeAlias = int
@@ -116,18 +105,12 @@ numpyElephino: TypeAlias = numpy_int16
 
 DatatypeFoldsTotal: TypeAlias = int
 numpyFoldsTotal: TypeAlias = numpy_int64
-numpyDtypeDefault = numpyFoldsTotal
 
 Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[numpyLeavesTotal]]
 Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[numpyLeavesTotal]]
 Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[numpyElephino]]
 Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[numpyFoldsTotal]]
 
-# =============================================================================
-# The right way.
-# (The dataclass, not the typing of the dataclass.)
-# (Also, my noobplementation of the dataclass certainly needs improvement.)
-
 @dataclasses.dataclass
 class ComputationState:
 	mapShape: tuple[DatatypeLeavesTotal, ...]
@@ -149,7 +132,7 @@ class ComputationState:
 	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
 	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
-	groupsOfFolds: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
 	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
@@ -173,9 +156,9 @@ class ComputationState:
 		leavesTotalAsInt = int(self.leavesTotal)
 
 		if self.countDimensionsGapped is None:
-			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
+			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
 		if self.gapRangeStart is None:
-			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
 		if self.gapsWhere is None:
 			self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, numpyLeavesTotal)
 		if self.leafAbove is None:
@@ -187,75 +170,50 @@ class ComputationState:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
 
 # =============================================================================
-# The most right way I know how to implement.
-
-theLogicalPathModuleSourceAlgorithm: str = '.'.join([thePackageName, theSourceAlgorithm])
-theLogicalPathModuleDispatcher: str = theLogicalPathModuleSourceAlgorithm
-theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModule])
-
-def getSourceAlgorithm() -> ModuleType:
-	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
-	return moduleImported
-
-def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
-	moduleImported: ModuleType = getSourceAlgorithm()
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
-	return dispatcherCallable
-
-def getPathSyntheticModules() -> Path:
-	return thePathPackage / theModuleOfSyntheticModules
 
 # TODO learn how to see this from the user's perspective
 def getPathJobRootDEFAULT() -> Path:
 	if 'google.colab' in sysModules:
 		pathJobDEFAULT: Path = Path("/content/drive/MyDrive") / "jobs"
 	else:
-		pathJobDEFAULT = thePathPackage / "jobs"
+		pathJobDEFAULT = The.pathPackage / "jobs"
 	return pathJobDEFAULT
 
 _datatypePackage: str = ''
 def getDatatypePackage() -> str:
 	global _datatypePackage
 	if not _datatypePackage:
-		_datatypePackage = theDatatypePackage
+		_datatypePackage = The.datatypePackage
 	return _datatypePackage
 
-def getNumpyDtypeDefault() -> type[signedinteger[Any]]:
-	return numpyDtypeDefault
-
 # =============================================================================
 # The coping way.
 
 class raiseIfNoneGitHubIssueNumber3(Exception): pass
 
 # =============================================================================
-# Temporary or transient or something; probably still the wrong way
-
 # THIS IS A STUPID SYSTEM BUT I CAN'T FIGURE OUT AN IMPROVEMENT
 # NOTE This section for _default_ values probably has value
 # https://github.com/hunterhogan/mapFolding/issues/4
 theFormatStrModuleSynthetic = "{packageFlow}Count"
 theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
 
-theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallable)
-theLogicalPathModuleDispatcherSynthetic: str = '.'.join([thePackageName, theModuleOfSyntheticModules, theModuleDispatcherSynthetic])
+theLogicalPathModuleDispatcher: str = The.logicalPathModuleSourceAlgorithm
 
-# =============================================================================
-# The most right way I know how to implement.
+theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.dispatcherCallable)
+theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
 
-# https://github.com/hunterhogan/mapFolding/issues/4
 if Z0Z_packageFlow == packageFlowSynthetic: # pyright: ignore [reportUnnecessaryComparison]
 	# NOTE this as a default value _might_ have value
 	theLogicalPathModuleDispatcher = theLogicalPathModuleDispatcherSynthetic
 
-# https://github.com/hunterhogan/mapFolding/issues/4
 # dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
 def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
 	# NOTE but this part, if the package flow is synthetic, probably needs to be delegated
 	# to the authority for creating _that_ synthetic flow.
 
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
+	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
 	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
@@ -270,4 +228,13 @@ theSSOT and yourSSOT
 ----
 delay realization/instantiation until a concrete value is desired
 moment of truth: when the value is needed, not when the value is defined
+
+----
+2025 March 11
+Note to self: fundamental concept in Python:
+Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
+- Local: Inside the function
+- Enclosing: Inside enclosing functions
+- Global: At the uppermost level
+- Builtin: Python's built-in names
 """

mapfolding-0.8.2.dist-info/METADATA

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: mapFolding
+Version: 0.8.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
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
+Keywords: A001415,A001416,A001417,A001418,A195646,algorithmic optimization,AST manipulation,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,Numba optimization,OEIS,performance optimization,source code analysis,stamp folding
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: autoflake
+Requires-Dist: more_itertools
+Requires-Dist: numba_progress
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: python_minifier
+Requires-Dist: tomli
+Requires-Dist: Z0Z_tools
+Provides-Extra: testing
+Requires-Dist: mypy; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-env; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pyupgrade; extra == "testing"
+Dynamic: license-file
+
+# mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+[![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
+![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen)
+[![License: CC-BY-NC-4.0](https://img.shields.io/badge/License-CC_BY--NC_4.0-3b434b)](https://creativecommons.org/licenses/by-nc/4.0/)
+
+---
+
+## Quick start
+
+```sh
+pip install mapFolding
+```
+
+`OEIS_for_n` will run a computation from the command line.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
+186086600 distinct folding patterns.
+Time elapsed: 1.605 seconds
+```
+
+Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
+
+```python
+from mapFolding import oeisIDfor_n
+foldsTotal = oeisIDfor_n( 'A001418', 4 )
+```
+
+---
+
+## Features
+
+### 1. Simple, easy usage based on OEIS IDs
+
+`mapFolding` directly implements some IDs from [_The On-Line Encyclopedia of Integer Sequences_](https://oeis.org/) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/oeis.bibtex) citation).
+
+Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> getOEISids
+
+Available OEIS sequences:
+  A001415: Number of ways of folding a 2 X n strip of stamps.
+  A001416: Number of ways of folding a 3 X n strip of stamps.
+  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
+  A001418: Number of ways of folding an n X n sheet of stamps.
+  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
+```
+
+### 2. **Algorithm Zoo: A Historical and Performance Journey** 🦒
+
+This package offers a comprehensive collection of map folding algorithm implementations that showcase its evolution from historical origins to high-performance computation:
+
+- **Historical Implementations**:
+  - Carefully restored versions of Lunnon's 1971 original [algorithm](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt) with corrections
+  - Atlas Autocode reconstruction in the `reference/foldings.AA` file
+
+- **Direct Translations**:
+  - Python translations following the original control flow (`lunnanWhile.py`)
+  - NumPy-based vectorized implementations (`lunnanNumpy.py`)
+
+- **Modern Implementations**:
+  - Java port adaptations (`irvineJavaPort.py`) providing cleaner procedural implementations
+  - Experimental JAX version (`jaxCount.py`) exploring GPU acceleration potential
+  - Semantically decomposed version (`flattened.py`) with clear function boundaries
+
+- **Performance Optimized**:
+  - Numba-JIT accelerated implementations up to 1000× faster than pure Python (see [benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
+  - Algorithmic optimizations showcasing subtle yet powerful performance differences (`total_countPlus1vsPlusN.py`)
+
+The `reference` directory serves as both a historical archive and an educational resource for understanding algorithm evolution.
+
+### 3. **Algorithmic Transformation: From Readability to Speed** 🔬
+
+The package provides a sophisticated transformation framework that bridges the gap between human-readable algorithms and high-performance computation:
+
+- **Core Algorithm Understanding**:
+  - Study the functional state-transformation approach in `theDao.py` with clear, isolated functions
+  - Explore the semantic decomposition in `reference/flattened.py` to understand algorithm sections
+
+- **Code Transformation Pipeline**:
+  - **AST Manipulation**: Analyzes and transforms the algorithm's abstract syntax tree
+  - **Dataclass "Shattering"**: Decomposes complex state objects into primitive components
+  - **Optimization Applications**: Applies domain-specific optimizations for numerical computation
+  - **LLVM Integration**: Extracts LLVM IR for low-level algorithmic analysis
+
+- **Performance Breakthroughs**:
+  - Learn why nearly identical algorithms can have dramatically different performance (`total_countPlus1vsPlusN.py`)
+  - See how memory layout and increment strategy impact computation speed
+  - Understand the batching technique that yields order-of-magnitude improvements
+
+### 4. **Multi-Level Architecture: From Simple API to Full Customization**
+
+The package's architecture supports multiple levels of engagement:
+
+- **Basic Usage**:
+  - Work with the high-level API in `basecamp.py` for standard computations
+  - Access OEIS sequence calculations with minimal code
+
+- **Algorithm Exploration**:
+  - Compare different implementations in the `reference` directory to understand trade-offs
+  - Modify the core algorithm in `theDao.py` while preserving its functional approach
+  - Configure system-wide settings in `theSSOT.py` to adjust data types and performance characteristics
+
+- **Advanced Transformation**:
+  - Use the `someAssemblyRequired` package to transform algorithms at the AST level
+  - Create optimized variants with different compilation settings using:
+    - `transformationTools.py` for AST manipulation
+    - `transformDataStructures.py` for complex data structure transformations
+    - `ingredientsNumba.py` for Numba-specific optimization profiles
+    - `synthesizeNumbaFlow.py` to orchestrate the transformation process
+
+- **Custom Deployment**:
+  - Generate specialized implementations for specific dimensions
+  - Create optimized standalone modules for production use
+  - Extract LLVM IR for further analysis and optimization
+
+The package's multi-level design allows you to start with simple API calls and progressively explore deeper optimization techniques as your computational needs grow.
+
+## Map-folding Video
+
+~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
+
+"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/Physics_for_the_Birds.bibtex) citation)
+
+[![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
+
+---
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.8.2.dist-info/RECORD

@@ -0,0 +1,39 @@
+mapFolding/__init__.py,sha256=hYxPUBU6A1_XCbKEseSDamooTsb1mzN_XHqaRLPvpGk,1701
+mapFolding/basecamp.py,sha256=uPwbb_fi8zqqBbVjb355qanSNUqqJ9aefcf_nrvA7qI,4510
+mapFolding/beDRY.py,sha256=UhH52BryHQNRjphf_PirtMkV45rhdemdC9PmnpACq7I,9397
+mapFolding/filesystem.py,sha256=-pYpWugd0p3TrAz7xf9YIJW-pn1X-iRCGtJgEAF9Rns,5923
+mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
+mapFolding/oeis.py,sha256=TbY8KtAGbQlT6eEsa_7HVMF7bMLN-aBFKclyTMHfqHk,12615
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=Blzm5j24x1BE2nvgXjdzHEeuc2na6kAH9b_eP6PcwlI,9836
+mapFolding/theSSOT.py,sha256=HIU9UVKP0dXlxIO791z_tl1R7r5LiEcKnA5AI7H9SmU,12414
+mapFolding/reference/__init__.py,sha256=7NYyWXyYYSdia2Q8SFJTcD0KvoUBLvvfuvTsaqcvchM,1777
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=espFiX92EPZ1Ub1YQVoBnNYvh2kFg1HR6Qa4djx8Ixg,7253
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnanNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnanWhile.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/someAssemblyRequired/__init__.py,sha256=xA5a-nZjXIwcqEOig5PEZSxde4_m3JJ5Pb0CN4aiRjw,2488
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=bGI8RZY-RnyR9TNF0r0OXwA6fm4TYH2cHy7WzhsnddQ,1895
+mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=g6Z7t35NpoDskzm0OLwTQhHw5CYiYktVYxI2NhCQHww,8435
+mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py,sha256=0179DMPoGJGP6AHs-nIac_aSfVBgpDyuaeCBVKlPRe8,10691
+mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py,sha256=RBSrtr7US2P7mkY-EA-b2WIOxjs2b0WJaCln1ERxOcI,22314
+mapFolding/someAssemblyRequired/transformDataStructures.py,sha256=Uth-WLzCTJTQkU15lsrBGf1ld7nqgLK42DUYM6-Q-n8,8605
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=n_lH9B7E871htRRRVJIDqGuT4WTmGiIgBb3ZjsY7ZjA,40689
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=52RuwJVH2fROvWU2dT8wYcQvLgRuvkNZPq01kujCC_U,15725
+mapfolding-0.8.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=hTpUTW7MtYGP5aeQnnoZMKgTEGCKdLJ8Fnmnv9d4NJw,11115
+tests/test_computations.py,sha256=RHHByyuC8w-qbaag4Iqo_QNYm_7A-9BslbstMOdbZbU,3329
+tests/test_filesystem.py,sha256=Kou0gj5T72oISao6umYfU6L_W5Hi7QS9_IxTv2hU0Pw,3147
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=4iF6JJ192BtDZUEZ0avbVRprCwfCUSOUC8GfCPrGS8M,4232
+tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
+mapfolding-0.8.2.dist-info/METADATA,sha256=8tSQtHxSLzIjIINZCw4EExiSeQV_wpLQXvf4gQ4xFNo,9143
+mapfolding-0.8.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+mapfolding-0.8.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.2.dist-info/RECORD,,

{mapfolding-0.8.0.dist-info → mapfolding-0.8.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.1.0)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any