mapFolding 0.7.1__tar.gz → 0.8.1__tar.gz

{mapfolding-0.7.1 → mapfolding-0.8.1}/PKG-INFO

@@ -1,18 +1,17 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.7.1
-Summary: Count distinct ways to fold a map (or a strip of stamps)
+Version: 0.8.1
+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,combinatorics,folding,map folding,OEIS,optimization,stamp folding
+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 :: End Users/Desktop
-Classifier: Intended Audience :: Other Audience
 Classifier: Intended Audience :: Science/Research
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
@@ -23,7 +22,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
@@ -38,12 +40,12 @@ 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: pytest; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
-Requires-Dist: updateCitation; extra == "testing"
+Dynamic: license-file
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
 
@@ -52,8 +54,6 @@ Requires-Dist: updateCitation; extra == "testing"
 [![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/)
-![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding)
-![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ---
 
@@ -101,44 +101,49 @@ Available OEIS sequences:
 
 ### 2. **Algorithm Zoo** 🦒
 
-- **Lunnon’s 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
+- **Lunnon's 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
 - The /reference directory.
 - **Numba-JIT Accelerated**: Up to 1000× faster than pure Python ([benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
 
-### 3. **For Researchers** 🔬
-
-- Change multiple minute settings, such as the bit width of the data types.
-- Transform the algorithm using AST
-- Create hyper-optimized modules to compute a specific map.
-
-### 4. **Customizing your algorithm**
-
-- mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)
-  - Synthesize a Numba-optimized module for a specific mapShape
-  - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
-  - Use the existing transformation options
-  - Or create new ways of transforming the algorithm from its source to a specific job
-- mapFolding\someAssemblyRequired\makeJob.py
-  - Initialize data for a specific mapShape
-- mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)
-  - Synthesize one or more Numba-optimized modules for parallel or sequential computation
-  - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
-  - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
-  - Use the existing transformation options
-  - Or create new ways of transforming the algorithm from its source to a new module
-  - Use your new module in synthesizeNumbaJob.py, above, as the source to create a mapShape-specific job module
-- mapFolding\theDao.py
-  - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
-  - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
-  - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
-- mapFolding\theSSOT.py (and/or theSSOTnumba.py and/ or theSSOT____.py, if they exist)
-  - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
-  - Create new settings or groups of settings
-- mapFolding\beDRY.py
-  - Functions to handle common tasks, such as parsing parameters or creating the `connectionGraph` for a mapShape (a Cartesian product decomposition)
-- mapFolding\someAssemblyRequired
-  - Create new transformations to optimize the algorithm, such as for JAX, CuPy, or CUDA
-  - (mapFolding\reference\jax.py has a once-functional JAX implementation, and synthesizeModuleJAX.py might be a useful starting point)
+### 3. **For Researchers and Power Users** 🔬
+
+This package provides a sophisticated code transformation framework that can turn readable algorithm implementations into highly-optimized computational engines:
+
+- **Algorithmic Exploration**: Study the core algorithm in `theDao.py`, which uses a functional state-transformation approach with clear, isolated functions
+- **Performance Optimization**: Generate specialized implementations with the `someAssemblyRequired` transformation pipeline:
+  - AST-based code analysis and manipulation
+  - Dataclass "shattering" to decompose complex state objects into primitive components
+  - Just-in-time compilation with Numba and various optimization profiles
+  - LLVM IR extraction for low-level algorithmic analysis
+
+- **Extensible Design**: The transformation framework is abstract and generic, enabling:
+  - Creation of new optimization targets beyond the included Numba implementation
+  - Customization of compilation parameters and optimization levels
+  - Development of specialized algorithms for specific map dimensions
+
+### 4. **Customization and Extension Guide**
+
+The package architecture supports multiple levels of customization:
+
+- **Basic Usage**: Work with the high-level API in `basecamp.py` for standard computations
+- **Algorithm Modification**:
+  - 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
+  - Use utility functions in `beDRY.py` for common operations
+
+- **Advanced Transformation**:
+  - The `someAssemblyRequired` package provides tools to transform code at the AST level:
+    - `transformationTools.py` contains utilities for AST manipulation and code generation
+    - `transformDataStructures.py` handles complex data structure transformations
+    - `ingredientsNumba.py` provides Numba-specific configuration profiles
+    - `synthesizeNumbaFlow.py` orchestrates the transformation process
+
+- **Custom Deployment**:
+  - Generate specialized implementations for specific dimensions
+  - Create optimized modules that can be executed as standalone scripts
+  - Extract LLVM IR for further analysis or optimization
+
+The package's multi-level design allows you to start with simple API calls and progressively delve deeper into optimization as your computational needs grow.
 
 ## Map-folding Video
 
@@ -155,4 +160,4 @@ Available OEIS sequences:
 [![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.png)](https://creativecommons.org/licenses/by-nc/4.0/)
+[![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.7.1 → mapfolding-0.8.1}/README.md

@@ -5,8 +5,6 @@
 [![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/)
-![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding)
-![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ---
 
@@ -54,44 +52,49 @@ Available OEIS sequences:
 
 ### 2. **Algorithm Zoo** 🦒
 
-- **Lunnon’s 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
+- **Lunnon's 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
 - The /reference directory.
 - **Numba-JIT Accelerated**: Up to 1000× faster than pure Python ([benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
 
-### 3. **For Researchers** 🔬
-
-- Change multiple minute settings, such as the bit width of the data types.
-- Transform the algorithm using AST
-- Create hyper-optimized modules to compute a specific map.
-
-### 4. **Customizing your algorithm**
-
-- mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)
-  - Synthesize a Numba-optimized module for a specific mapShape
-  - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
-  - Use the existing transformation options
-  - Or create new ways of transforming the algorithm from its source to a specific job
-- mapFolding\someAssemblyRequired\makeJob.py
-  - Initialize data for a specific mapShape
-- mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)
-  - Synthesize one or more Numba-optimized modules for parallel or sequential computation
-  - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
-  - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
-  - Use the existing transformation options
-  - Or create new ways of transforming the algorithm from its source to a new module
-  - Use your new module in synthesizeNumbaJob.py, above, as the source to create a mapShape-specific job module
-- mapFolding\theDao.py
-  - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
-  - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
-  - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
-- mapFolding\theSSOT.py (and/or theSSOTnumba.py and/ or theSSOT____.py, if they exist)
-  - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
-  - Create new settings or groups of settings
-- mapFolding\beDRY.py
-  - Functions to handle common tasks, such as parsing parameters or creating the `connectionGraph` for a mapShape (a Cartesian product decomposition)
-- mapFolding\someAssemblyRequired
-  - Create new transformations to optimize the algorithm, such as for JAX, CuPy, or CUDA
-  - (mapFolding\reference\jax.py has a once-functional JAX implementation, and synthesizeModuleJAX.py might be a useful starting point)
+### 3. **For Researchers and Power Users** 🔬
+
+This package provides a sophisticated code transformation framework that can turn readable algorithm implementations into highly-optimized computational engines:
+
+- **Algorithmic Exploration**: Study the core algorithm in `theDao.py`, which uses a functional state-transformation approach with clear, isolated functions
+- **Performance Optimization**: Generate specialized implementations with the `someAssemblyRequired` transformation pipeline:
+  - AST-based code analysis and manipulation
+  - Dataclass "shattering" to decompose complex state objects into primitive components
+  - Just-in-time compilation with Numba and various optimization profiles
+  - LLVM IR extraction for low-level algorithmic analysis
+
+- **Extensible Design**: The transformation framework is abstract and generic, enabling:
+  - Creation of new optimization targets beyond the included Numba implementation
+  - Customization of compilation parameters and optimization levels
+  - Development of specialized algorithms for specific map dimensions
+
+### 4. **Customization and Extension Guide**
+
+The package architecture supports multiple levels of customization:
+
+- **Basic Usage**: Work with the high-level API in `basecamp.py` for standard computations
+- **Algorithm Modification**:
+  - 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
+  - Use utility functions in `beDRY.py` for common operations
+
+- **Advanced Transformation**:
+  - The `someAssemblyRequired` package provides tools to transform code at the AST level:
+    - `transformationTools.py` contains utilities for AST manipulation and code generation
+    - `transformDataStructures.py` handles complex data structure transformations
+    - `ingredientsNumba.py` provides Numba-specific configuration profiles
+    - `synthesizeNumbaFlow.py` orchestrates the transformation process
+
+- **Custom Deployment**:
+  - Generate specialized implementations for specific dimensions
+  - Create optimized modules that can be executed as standalone scripts
+  - Extract LLVM IR for further analysis or optimization
+
+The package's multi-level design allows you to start with simple API calls and progressively delve deeper into optimization as your computational needs grow.
 
 ## Map-folding Video
 
@@ -108,4 +111,4 @@ Available OEIS sequences:
 [![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.png)](https://creativecommons.org/licenses/by-nc/4.0/)
+[![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.1/mapFolding/__init__.py

@@ -0,0 +1,38 @@
+"""
+Map folding enumeration and counting algorithms with optimization capabilities.
+
+This package implements algorithms to count and enumerate the various ways
+a rectangular map can be folded, based on the mathematical problem described
+in Lunnon's 1971 paper. It provides multiple layers of functionality, from
+high-level user interfaces to low-level algorithmic optimizations and code
+transformation tools.
+
+Core modules:
+- basecamp: Public API with simplified interfaces for end users
+- theDao: Core computational algorithm using a functional state-transformation approach
+- beDRY: Utility functions for common operations and parameter management
+- theSSOT: Single Source of Truth for configuration, types, and state management
+- oeis: Interface to the Online Encyclopedia of Integer Sequences for known results
+
+Extended functionality:
+- someAssemblyRequired: Code transformation framework that optimizes the core algorithm
+  through AST manipulation, dataclass transformation, and compilation techniques
+
+Special directories:
+- .cache/: Stores cached data from external sources like OEIS to improve performance
+- syntheticModules/: Contains dynamically generated, optimized implementations of the
+  core algorithm created by the code transformation framework
+
+This package strives to balance algorithm readability and understandability with
+high-performance computation capabilities, allowing users to compute map folding
+totals for larger dimensions than previously feasible.
+"""
+from mapFolding.basecamp import countFolds as countFolds
+from mapFolding.oeis import clearOEIScache, getOEISids, OEIS_for_n
+
+__all__ = [
+    'clearOEIScache',
+    'countFolds',
+    'getOEISids',
+    'OEIS_for_n',
+]

{mapfolding-0.7.1 → mapfolding-0.8.1}/mapFolding/basecamp.py

@@ -1,3 +1,17 @@
+"""
+Public API for the map folding algorithm with simplified interface.
+
+This module provides the main entry point for users of the mapFolding package,
+abstracting away the complexities of the computational algorithm. It offers
+a high-level interface to count the total number of possible ways to fold
+a rectangular map of specified dimensions, with options for customizing the
+computation process and saving results.
+
+The primary function is countFolds, which handles parameter validation,
+computation state management, dispatching to the appropriate algorithm
+implementation, and optional persistence of results.
+"""
+
 from collections.abc import Sequence
 from mapFolding.beDRY import outfitCountFolds, setCPUlimit, validateListDimensions
 from mapFolding.filesystem import getPathFilenameFoldsTotal, saveFoldsTotal

{mapfolding-0.7.1 → mapfolding-0.8.1}/mapFolding/beDRY.py

@@ -1,30 +1,26 @@
-"""A relatively stable API for oft-needed functionality."""
-from mapFolding.theSSOT import (
-	Array3D,
-	ComputationState,
-	getDatatypePackage,
-	getNumpyDtypeDefault,
-)
+"""
+Utility functions for maintaining DRY (Don't Repeat Yourself) principles in the mapFolding package.
+
+This module provides a collection of helper functions that abstract common operations needed
+throughout the package, preventing code duplication and ensuring consistency. The functions
+manage core aspects of the computation process, including:
+
+1. Resource allocation and system limits management
+2. Data structure initialization and manipulation
+3. Parameter validation and interpretation
+4. Construction of specialized arrays and matrices for the folding algorithm
+
+The functions in this module serve as a relatively stable API for other modules to use,
+particularly for initializing computation state, validating inputs, and creating data
+structures needed by the folding algorithms.
+"""
 from collections.abc import Sequence
+from mapFolding.theSSOT import Array3D, ComputationState, getDatatypePackage, getNumpyDtypeDefault
 from sys import maxsize as sysMaxsize
 from typing import Any
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 import numpy
 
-def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
-	if not listDimensions:
-		raise ValueError("listDimensions is a required parameter.")
-	listValidated: list[int] = intInnit(listDimensions, 'listDimensions')
-	listNonNegative: list[int] = []
-	for dimension in listValidated:
-		if dimension < 0:
-			raise ValueError(f"Dimension {dimension} must be non-negative")
-		listNonNegative.append(dimension)
-	dimensionsValid = [dimension for dimension in listNonNegative if dimension > 0]
-	if len(dimensionsValid) < 2:
-		raise NotImplementedError(f"This function requires listDimensions, {listDimensions}, to have at least two dimensions greater than 0. You may want to look at https://oeis.org/.")
-	return tuple(sorted(dimensionsValid))
-
 def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	productDimensions = 1
 	for dimension in mapShape:
@@ -33,7 +29,59 @@ def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 		productDimensions *= dimension
 	return productDimensions
 
-def getNumpyDtype(datatype: type[numpy.signedinteger[Any]] | None = None) -> type[numpy.signedinteger[Any]]:
+def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, leavesTotal: int) -> int:
+	"""
+	Determines whether to divide the computation into tasks and how many divisions.
+
+	Parameters
+	----------
+	computationDivisions (None)
+		Specifies how to divide computations:
+		- `None`: no division of the computation into tasks; sets task divisions to 0.
+		- int: direct set the number of task divisions; cannot exceed the map's total leaves.
+		- `'maximum'`: divides into `leavesTotal`-many `taskDivisions`.
+		- `'cpu'`: limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`.
+	concurrencyLimit
+		Maximum number of concurrent tasks allowed.
+	CPUlimit
+		for error reporting.
+	listDimensions
+		for error reporting.
+
+	Returns
+	-------
+	taskDivisions
+		How many tasks must finish before the job can compute the total number of folds; `0` means no tasks, only job.
+
+	Raises
+	------
+	ValueError
+		If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves.
+
+	Notes
+	-----
+	Task divisions should not exceed total leaves or the folds will be over-counted.
+	"""
+	taskDivisions = 0
+	if not computationDivisions:
+		pass
+	elif isinstance(computationDivisions, int):
+		taskDivisions = computationDivisions
+	elif isinstance(computationDivisions, str): # type: ignore
+		# 'Unnecessary isinstance call; "str" is always an instance of "str", so sayeth Pylance'. Yeah, well "User is not always an instance of "correct input" so sayeth the programmer.
+		computationDivisions = computationDivisions.lower()
+		if computationDivisions == 'maximum':
+			taskDivisions = leavesTotal
+		elif computationDivisions == 'cpu':
+			taskDivisions = min(concurrencyLimit, leavesTotal)
+	else:
+		raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
+
+	if taskDivisions > leavesTotal:
+		raise ValueError(f"Problem: `taskDivisions`, ({taskDivisions}), is greater than `leavesTotal`, ({leavesTotal}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.")
+	return int(max(0, taskDivisions))
+
+def interpretParameter_datatype(datatype: type[numpy.signedinteger[Any]] | None = None) -> type[numpy.signedinteger[Any]]:
 	"""An imperfect way to reduce code duplication."""
 	if 'numpy' == getDatatypePackage():
 		numpyDtype = datatype or getNumpyDtypeDefault()
@@ -42,7 +90,7 @@ def getNumpyDtype(datatype: type[numpy.signedinteger[Any]] | None = None) -> typ
 	return numpyDtype
 
 def makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: type[numpy.signedinteger[Any]] | None = None) -> Array3D:
-	numpyDtype = getNumpyDtype(datatype)
+	numpyDtype = interpretParameter_datatype(datatype)
 	dimensionsTotal = len(mapShape)
 	cumulativeProduct = numpy.multiply.accumulate([1] + list(mapShape), dtype=numpyDtype)
 	arrayDimensions = numpy.array(mapShape, dtype=numpyDtype)
@@ -69,9 +117,15 @@ def makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: t
 	return connectionGraph
 
 def makeDataContainer(shape: int | tuple[int, ...], datatype: type[numpy.signedinteger[Any]] | None = None) -> numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[Any]]]:
-	numpyDtype = getNumpyDtype(datatype)
+	numpyDtype = interpretParameter_datatype(datatype)
 	return numpy.zeros(shape, dtype=numpyDtype)
 
+def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str | None = None, concurrencyLimit: int = 1) -> ComputationState:
+	leavesTotal = getLeavesTotal(mapShape)
+	taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
+	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions, concurrencyLimit)
+	return computationStateInitialized
+
 def setCPUlimit(CPUlimit: Any | None) -> int:
 	"""Sets CPU limit for concurrent operations.
 
@@ -106,66 +160,23 @@ def setCPUlimit(CPUlimit: Any | None) -> int:
 		concurrencyLimit: int = defineConcurrencyLimit(CPUlimit, get_num_threads())
 		set_num_threads(concurrencyLimit)
 		concurrencyLimit = get_num_threads()
-	elif concurrencyPackage == 'algorithm':
+	elif concurrencyPackage == 'multiprocessing':
 		# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
-		concurrencyLimit: int = defineConcurrencyLimit(CPUlimit)
+		concurrencyLimit = defineConcurrencyLimit(CPUlimit)
 	else:
 		raise NotImplementedError(f"I received {concurrencyPackage=} but I don't know what to do with that.")
 	return concurrencyLimit
 
-def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, leavesTotal: int) -> int:
-	"""
-	Determines whether to divide the computation into tasks and how many divisions.
-
-	Parameters
-	----------
-	computationDivisions (None)
-		Specifies how to divide computations:
-		- `None`: no division of the computation into tasks; sets task divisions to 0.
-		- int: direct set the number of task divisions; cannot exceed the map's total leaves.
-		- `'maximum'`: divides into `leavesTotal`-many `taskDivisions`.
-		- `'cpu'`: limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`.
-	concurrencyLimit
-		Maximum number of concurrent tasks allowed.
-	CPUlimit
-		for error reporting.
-	listDimensions
-		for error reporting.
-
-	Returns
-	-------
-	taskDivisions
-		How many tasks must finish before the job can compute the total number of folds; `0` means no tasks, only job.
-
-	Raises
-	------
-	ValueError
-		If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves.
-
-	Notes
-	-----
-	Task divisions should not exceed total leaves or the folds will be over-counted.
-	"""
-	taskDivisions = 0
-	if not computationDivisions:
-		pass
-	elif isinstance(computationDivisions, int):
-		taskDivisions = computationDivisions
-	elif isinstance(computationDivisions, str): # type: ignore 'Unnecessary isinstance call; "str" is always an instance of "str", so sayeth Pylance'. Yeah, well "User is not always an instance of "correct input" so sayeth the programmer.
-		computationDivisions = computationDivisions.lower()
-		if computationDivisions == 'maximum':
-			taskDivisions = leavesTotal
-		elif computationDivisions == 'cpu':
-			taskDivisions = min(concurrencyLimit, leavesTotal)
-	else:
-		raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
-
-	if taskDivisions > leavesTotal:
-		raise ValueError(f"Problem: `taskDivisions`, ({taskDivisions}), is greater than `leavesTotal`, ({leavesTotal}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.")
-	return int(max(0, taskDivisions))
-
-def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str | None = None, concurrencyLimit: int = 1) -> ComputationState:
-	leavesTotal = getLeavesTotal(mapShape)
-	taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
-	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions, concurrencyLimit)
-	return computationStateInitialized
+def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
+	if not listDimensions:
+		raise ValueError("listDimensions is a required parameter.")
+	listValidated: list[int] = intInnit(listDimensions, 'listDimensions')
+	listNonNegative: list[int] = []
+	for dimension in listValidated:
+		if dimension < 0:
+			raise ValueError(f"Dimension {dimension} must be non-negative")
+		listNonNegative.append(dimension)
+	dimensionsValid = [dimension for dimension in listNonNegative if dimension > 0]
+	if len(dimensionsValid) < 2:
+		raise NotImplementedError(f"This function requires listDimensions, {listDimensions}, to have at least two dimensions greater than 0. You may want to look at https://oeis.org/.")
+	return tuple(sorted(dimensionsValid))