mapFolding 0.12.1__tar.gz → 0.12.3__tar.gz

mapfolding-0.12.3/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: mapFolding
+Version: 0.12.3
+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: Issues, https://github.com/hunterhogan/mapFolding/issues
+Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
+Keywords: A000136,A001415,A001416,A001417,A001418,A195646,AST manipulation,Numba optimization,OEIS,algorithmic optimization,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,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.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astToolkit>=0.5.0
+Requires-Dist: hunterMakesPy
+Requires-Dist: numba
+Requires-Dist: numba_progress
+Requires-Dist: numpy
+Requires-Dist: platformdirs
+Provides-Extra: development
+Requires-Dist: mypy; extra == "development"
+Requires-Dist: pyupgrade; extra == "development"
+Requires-Dist: setuptools-scm; extra == "development"
+Provides-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"
+Dynamic: license-file
+
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
+[![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/)
+
+A computational framework that starts with Lunnon's 1971 algorithm for counting distinct ways to fold maps and improves it. Plus there is a comprehensive AST transformation system for transforming algorithms for optimization and research.
+
+(Yo, the rest is AI generated and I don't have the energy to proofread it. This package helped me compute two previously unknown values: I'm sure others can improve it.)
+
+## The Mathematical Problem
+
+Map folding is a combinatorial problem: given a rectangular grid of unit squares, how many distinct ways can you fold it? "Distinct" means that foldings producing identical final shapes are counted as one. This problem connects to combinatorial geometry, integer sequences, and computational complexity theory.
+
+The calculations extend the Online Encyclopedia of Integer Sequences (OEIS):
+
+- **A001415**: 2×n strips (computed through n=20 for the first time)
+- **A001418**: n×n squares
+- **A001416**: 3×n strips
+- **A001417**: n-dimensional hypercubes
+- **A195646**: 3×3×...×3 hypercubes
+
+```python
+from mapFolding import oeisIDfor_n
+
+# How many ways can you fold a 2×4 strip?
+foldsTotal = oeisIDfor_n('A001415', 4)
+```
+
+## The Computational Challenge
+
+For larger maps, these calculations require hours or days to complete. A 2×20 strip requires processing leaves through billions of recursive operations. The package addresses this through systematic algorithm transformation: converting readable Python implementations into specialized, Numba-optimized modules that achieve order-of-magnitude performance improvements.
+
+## What This Package Provides
+
+### Core Functionality
+
+- **Complete implementation** of Lunnon's recursive algorithm
+- **Mathematical validation** through OEIS integration and caching
+- **Type-safe computational state** management with automatic initialization
+- **Result persistence** for long-running calculations
+
+### Algorithm Transformation System
+
+- **AST manipulation framework** for converting dataclass-based algorithms to optimized implementations
+- **Automatic code generation** that produces standalone, highly optimized computation modules
+- **Dataclass decomposition** to enable Numba compatibility while preserving readable source code
+- **Comprehensive optimization** including dead code elimination, static value embedding, and aggressive compilation settings
+
+### Educational Resources
+
+- **Historical implementations** showing algorithm evolution from 1971 to present
+- **Performance comparison** studies demonstrating optimization techniques
+- **Complete test suite** with patterns for validating custom implementations
+- **Reference documentation** for extending the transformation framework
+
+## Use Cases
+
+**Mathematical Research**: Explore folding pattern properties, extend known sequences, or validate theoretical results against computed values.
+
+**Algorithm Optimization Learning**: Study a complete transformation pipeline that converts high-level algorithms into production-ready optimized code.
+
+**Performance Computing Education**: Examine techniques for achieving maximum Python performance through Numba integration, AST manipulation, and specialized code generation.
+
+**Combinatorial Problem Solving**: Use the framework as a template for optimizing other recursive combinatorial algorithms.
+
+## Example Usage
+
+```python
+from mapFolding import countFolds
+
+# Count folding patterns for a 3×3 square
+result = countFolds([3, 3])
+
+# Access OEIS sequences directly
+from mapFolding import oeisIDfor_n
+strip_foldings = oeisIDfor_n('A001415', 6)  # 2×6 strip
+
+# Generate optimized code for specific dimensions
+from mapFolding.someAssemblyRequired import makeJobTheorem2Numba
+# Creates specialized modules for maximum performance
+```
+
+## Repository Structure
+
+- `mapFolding/`: Core implementation with modular architecture
+- `reference/`: Historical algorithm implementations and performance studies
+- `someAssemblyRequired/`: AST transformation framework
+- `tests/`: Comprehensive validation suite
+- `jobs/`: Generated optimized modules for specific calculations
+
+## Performance Characteristics
+
+- **Pure Python baseline**: Educational implementations for understanding
+- **NumPy optimization**: ~10× improvement through vectorized operations
+- **Numba compilation**: ~100× improvement through native code generation
+- **Specialized modules**: ~1000× improvement through static optimization and embedded constants
+
+Actual performance varies by map dimensions and available hardware.
+
+## 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)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
+[![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.12.3/README.md

@@ -0,0 +1,115 @@
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
+[![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/)
+
+A computational framework that starts with Lunnon's 1971 algorithm for counting distinct ways to fold maps and improves it. Plus there is a comprehensive AST transformation system for transforming algorithms for optimization and research.
+
+(Yo, the rest is AI generated and I don't have the energy to proofread it. This package helped me compute two previously unknown values: I'm sure others can improve it.)
+
+## The Mathematical Problem
+
+Map folding is a combinatorial problem: given a rectangular grid of unit squares, how many distinct ways can you fold it? "Distinct" means that foldings producing identical final shapes are counted as one. This problem connects to combinatorial geometry, integer sequences, and computational complexity theory.
+
+The calculations extend the Online Encyclopedia of Integer Sequences (OEIS):
+
+- **A001415**: 2×n strips (computed through n=20 for the first time)
+- **A001418**: n×n squares
+- **A001416**: 3×n strips
+- **A001417**: n-dimensional hypercubes
+- **A195646**: 3×3×...×3 hypercubes
+
+```python
+from mapFolding import oeisIDfor_n
+
+# How many ways can you fold a 2×4 strip?
+foldsTotal = oeisIDfor_n('A001415', 4)
+```
+
+## The Computational Challenge
+
+For larger maps, these calculations require hours or days to complete. A 2×20 strip requires processing leaves through billions of recursive operations. The package addresses this through systematic algorithm transformation: converting readable Python implementations into specialized, Numba-optimized modules that achieve order-of-magnitude performance improvements.
+
+## What This Package Provides
+
+### Core Functionality
+
+- **Complete implementation** of Lunnon's recursive algorithm
+- **Mathematical validation** through OEIS integration and caching
+- **Type-safe computational state** management with automatic initialization
+- **Result persistence** for long-running calculations
+
+### Algorithm Transformation System
+
+- **AST manipulation framework** for converting dataclass-based algorithms to optimized implementations
+- **Automatic code generation** that produces standalone, highly optimized computation modules
+- **Dataclass decomposition** to enable Numba compatibility while preserving readable source code
+- **Comprehensive optimization** including dead code elimination, static value embedding, and aggressive compilation settings
+
+### Educational Resources
+
+- **Historical implementations** showing algorithm evolution from 1971 to present
+- **Performance comparison** studies demonstrating optimization techniques
+- **Complete test suite** with patterns for validating custom implementations
+- **Reference documentation** for extending the transformation framework
+
+## Use Cases
+
+**Mathematical Research**: Explore folding pattern properties, extend known sequences, or validate theoretical results against computed values.
+
+**Algorithm Optimization Learning**: Study a complete transformation pipeline that converts high-level algorithms into production-ready optimized code.
+
+**Performance Computing Education**: Examine techniques for achieving maximum Python performance through Numba integration, AST manipulation, and specialized code generation.
+
+**Combinatorial Problem Solving**: Use the framework as a template for optimizing other recursive combinatorial algorithms.
+
+## Example Usage
+
+```python
+from mapFolding import countFolds
+
+# Count folding patterns for a 3×3 square
+result = countFolds([3, 3])
+
+# Access OEIS sequences directly
+from mapFolding import oeisIDfor_n
+strip_foldings = oeisIDfor_n('A001415', 6)  # 2×6 strip
+
+# Generate optimized code for specific dimensions
+from mapFolding.someAssemblyRequired import makeJobTheorem2Numba
+# Creates specialized modules for maximum performance
+```
+
+## Repository Structure
+
+- `mapFolding/`: Core implementation with modular architecture
+- `reference/`: Historical algorithm implementations and performance studies
+- `someAssemblyRequired/`: AST transformation framework
+- `tests/`: Comprehensive validation suite
+- `jobs/`: Generated optimized modules for specific calculations
+
+## Performance Characteristics
+
+- **Pure Python baseline**: Educational implementations for understanding
+- **NumPy optimization**: ~10× improvement through vectorized operations
+- **Numba compilation**: ~100× improvement through native code generation
+- **Specialized modules**: ~1000× improvement through static optimization and embedded constants
+
+Actual performance varies by map dimensions and available hardware.
+
+## 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)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
+[![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.12.3/mapFolding/__init__.py

@@ -0,0 +1,88 @@
+"""Computational toolkit for analyzing multi-dimensional map folding patterns.
+
+(AI generated docstring)
+
+The mapFolding package provides a complete implementation of Lunnon's 1971 algorithm
+for counting distinct folding patterns in multi-dimensional maps. This toolkit
+transforms the complex combinatorial mathematics of map folding into accessible
+computational tools, enabling researchers and practitioners to analyze folding
+patterns across dimensions from simple 2D strips to complex multi-dimensional
+hypercubes.
+
+The package architecture follows Domain-Driven Design principles, organizing
+functionality around mathematical concepts rather than implementation details.
+The computational framework integrates type safety, persistent result storage,
+and mathematical validation through OEIS sequence integration.
+
+Core Transformation Tools:
+    countFolds: Primary interface for computing folding pattern counts
+    MapFoldingState: Computational state management for recursive analysis
+    Connection graph generation: Mathematical foundation for folding relationships
+    Task division utilities: Experimental parallel computation options
+    OEIS integration: Mathematical validation and sequence discovery
+
+Primary Use Cases:
+    Mathematical research into folding pattern properties and relationships
+    Educational exploration of combinatorial mathematics concepts
+    Computational validation of theoretical results
+    Extension of known mathematical sequences through new discoveries
+
+The package handles the full spectrum of map folding analysis, from simple
+educational examples to research-grade computations requiring multi-day processing
+time. Results integrate seamlessly with the mathematical community through
+comprehensive OEIS connectivity and standardized result persistence.
+
+For researchers: The computational foundation supports both replication of
+established results and discovery of new mathematical relationships.
+
+For educators: The clear interfaces and type safety enable confident exploration
+of combinatorial concepts without computational complexity barriers.
+
+For practitioners: The robust result persistence and type safety ensure
+reliable completion of complex analytical tasks.
+"""
+
+from mapFolding._theTypes import (
+	Array1DElephino as Array1DElephino,
+	Array1DFoldsTotal as Array1DFoldsTotal,
+	Array1DLeavesTotal as Array1DLeavesTotal,
+	Array3D as Array3D,
+	DatatypeElephino as DatatypeElephino,
+	DatatypeFoldsTotal as DatatypeFoldsTotal,
+	DatatypeLeavesTotal as DatatypeLeavesTotal,
+	NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal,
+	NumPyIntegerType as NumPyIntegerType,
+	NumPyLeavesTotal as NumPyLeavesTotal,
+)
+
+from mapFolding._theSSOT import packageSettings as packageSettings
+
+from mapFolding.beDRY import (
+	getConnectionGraph as getConnectionGraph,
+	getLeavesTotal as getLeavesTotal,
+	getTaskDivisions as getTaskDivisions,
+	makeDataContainer as makeDataContainer,
+	setProcessorLimit as setProcessorLimit,
+	validateListDimensions as validateListDimensions,
+)
+
+from mapFolding.dataBaskets import MapFoldingState as MapFoldingState
+
+from mapFolding.filesystemToolkit import (
+	getFilenameFoldsTotal as getFilenameFoldsTotal,
+	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
+	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
+	saveFoldsTotal as saveFoldsTotal,
+	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
+)
+
+from mapFolding.basecamp import countFolds as countFolds
+
+from mapFolding.oeis import (
+	clearOEIScache as clearOEIScache,
+	getFoldsTotalKnown as getFoldsTotalKnown,
+	getOEISids as getOEISids,
+	OEIS_for_n as OEIS_for_n,
+	oeisIDfor_n as oeisIDfor_n,
+)

mapfolding-0.12.3/mapFolding/_theSSOT.py

@@ -0,0 +1,81 @@
+"""
+Foundation layer for the map folding computational ecosystem.
+
+(AI generated docstring)
+
+This module establishes the fundamental configuration infrastructure that underpins
+all map folding operations. Map folding, as defined by Lunnon's 1971 algorithm,
+requires precise coordination of computational resources, type systems, and data
+flow management to solve the complex combinatorial problem of counting distinct
+folding patterns across multi-dimensional maps.
+
+The Single Source Of Truth (SSOT) principle governs this foundation, ensuring that
+package identity, filesystem locations, and concurrency configuration remain
+consistent across all computational phases. During packaging, static metadata is
+resolved from pyproject.toml. During installation, filesystem-dependent paths are
+dynamically discovered. During runtime, the `packageSettings` instance provides
+unified access to all configuration values, enabling the sophisticated computational
+framework that follows.
+
+This configuration foundation supports the type system definition, core utility
+functions, computational state management, result persistence, and ultimately the
+main computational interface that users interact with to solve map folding problems.
+"""
+
+from hunterMakesPy import PackageSettings
+import dataclasses
+
+packageNameHARDCODED = "mapFolding"
+"""Hardcoded package name used as fallback when dynamic resolution fails."""
+
+concurrencyPackageHARDCODED = 'multiprocessing'
+"""Default package identifier for concurrent execution operations."""
+
+@dataclasses.dataclass
+class mapFoldingPackageSettings(PackageSettings):
+	"""Centralized configuration container for all package-wide settings.
+
+	(AI generated docstring)
+
+	This dataclass serves as the single source of truth for package configuration,
+	providing both static and dynamically-resolved values needed throughout the
+	package lifecycle. The metadata on each field indicates when that value is
+	determined - either during packaging or at installation/runtime.
+
+	The design supports different evaluation phases to optimize performance and
+	reliability. Packaging-time values can be determined during package creation,
+	while installing-time values require filesystem access or module introspection.
+
+	Attributes
+	----------
+	fileExtension : str = '.py'
+		Standard file extension for Python modules in this package.
+	packageName : str
+		Canonical name of the package as defined in project configuration.
+	pathPackage : Path
+		Absolute filesystem path to the installed package directory.
+	concurrencyPackage : str | None = None
+		Package identifier for concurrent execution operations.
+
+	"""
+
+	concurrencyPackage: str | None = None
+	"""
+	Package identifier for concurrent execution operations.
+
+	(AI generated docstring)
+
+	Specifies which Python package should be used for parallel processing
+	in computationally intensive operations. When None, the default concurrency
+	package specified in the module constants is used. Accepted values include
+	'multiprocessing' for standard parallel processing and 'numba' for
+	specialized numerical computations.
+	"""
+
+concurrencyPackage = concurrencyPackageHARDCODED
+"""Active concurrency package configuration for the current session."""
+
+packageSettings = mapFoldingPackageSettings(
+	identifierPackageFALLBACK=packageNameHARDCODED
+	, concurrencyPackage=concurrencyPackage)
+"""Global package settings."""

mapfolding-0.12.3/mapFolding/_theTypes.py

@@ -0,0 +1,148 @@
+"""
+Type system architecture for map folding computational domains.
+
+(AI generated docstring)
+
+Building upon the configuration foundation, this module defines the complete type
+hierarchy that ensures type safety and semantic clarity throughout the map folding
+computational framework. The type system recognizes three distinct computational
+domains, each with specific data characteristics and performance requirements
+that emerge from Lunnon's algorithm implementation.
+
+The Leaves domain handles map sections, their indices, and dimensional parameters.
+The Elephino domain manages internal computational state, gap calculations, and
+temporary indices used during the recursive folding analysis. The Folds domain
+represents final pattern counts and computation results. Each domain employs both
+Python types for general computation and NumPy types for performance-critical
+array operations.
+
+This dual-type strategy enables the core utility functions to operate with type
+safety while maintaining the computational efficiency required for analyzing
+complex multi-dimensional folding patterns. The array types built from these
+base types provide the structured data containers that computational state
+management depends upon.
+"""
+from numpy import dtype, integer, ndarray, uint8 as numpy_uint8, uint16 as numpy_uint16, uint64 as numpy_uint64
+from typing import Any, TypeAlias, TypeVar
+
+NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
+"""
+Generic type variable for NumPy integer types used in computational operations.
+
+(AI generated docstring)
+
+This type variable enables generic programming with NumPy integer types while
+maintaining type safety. It supports covariant relationships between different
+NumPy integer types and their array containers.
+"""
+
+DatatypeLeavesTotal: TypeAlias = int
+"""
+Python type for leaf-related counts and indices in map folding computations.
+
+(AI generated docstring)
+
+Represents quantities related to individual map sections (leaves), including
+total leaf counts, leaf indices, and dimensional parameters. Uses standard
+Python integers for compatibility with general computations while enabling
+conversion to NumPy types when performance optimization is needed.
+"""
+
+NumPyLeavesTotal: TypeAlias = numpy_uint8
+"""
+NumPy type for efficient leaf-related computations and array operations.
+
+(AI generated docstring)
+
+Corresponds to `DatatypeLeavesTotal` but optimized for NumPy operations.
+Uses 8-bit unsigned integers since leaf counts in practical map folding
+scenarios typically remain small (under 256).
+"""
+
+DatatypeElephino: TypeAlias = int
+"""
+Python type for internal computational indices and intermediate values.
+
+(AI generated docstring)
+
+Used for temporary variables, gap indices, and other internal computational
+state that doesn't directly correspond to leaves or final fold counts. The
+name follows the package convention for internal computational domains.
+"""
+
+NumPyElephino: TypeAlias = numpy_uint16
+"""
+NumPy type for internal computational operations requiring moderate value ranges.
+
+(AI generated docstring)
+
+Corresponds to `DatatypeElephino` with 16-bit unsigned integer storage,
+providing sufficient range for internal computations while maintaining
+memory efficiency in array operations.
+"""
+
+DatatypeFoldsTotal: TypeAlias = int
+"""
+Python type for final fold counts and pattern totals.
+
+(AI generated docstring)
+
+Represents the ultimate results of map folding computations - the total number
+of distinct folding patterns possible for a given map configuration. These
+values can grow exponentially with map size, requiring flexible integer types.
+"""
+
+NumPyFoldsTotal: TypeAlias = numpy_uint64
+"""
+NumPy type for large fold count computations and high-precision results.
+
+(AI generated docstring)
+
+Corresponds to `DatatypeFoldsTotal` using 64-bit unsigned integers to
+accommodate the exponentially large values that can result from map folding
+computations on even moderately-sized maps.
+"""
+
+Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
+"""
+Three-dimensional NumPy array type for connection graph representations.
+
+(AI generated docstring)
+
+Used to store the connectivity relationships between map leaves in a
+3D array structure. The array uses `NumPyLeavesTotal` element type since
+the stored values represent leaf indices and connection states.
+"""
+
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
+"""
+One-dimensional NumPy array type for leaf-related data sequences.
+
+(AI generated docstring)
+
+Stores sequences of leaf counts, indices, or related values in efficient
+array format. Common uses include leaf sequences, gap locations, and
+dimensional data where each element relates to the leaves domain.
+"""
+
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
+"""
+One-dimensional NumPy array type for internal computational sequences.
+
+(AI generated docstring)
+
+Used for storing sequences of internal computational values such as
+gap range starts, temporary indices, and other intermediate results
+that require the elephino computational domain's value range.
+"""
+
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]
+"""
+One-dimensional NumPy array type for sequences of fold count results.
+
+(AI generated docstring)
+
+Stores sequences of fold totals and pattern counts, using the large
+integer type to accommodate the potentially enormous values that
+result from complex map folding computations.
+"""