mapFolding 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

mapFolding/theSSOT.py

@@ -1,22 +1,8 @@
 from collections.abc import Callable
-from mapFolding.theSSOTdatatypes import (
-	EnumIndices,
-	indexMy,
-	indexTrack,
-	reportDatatypeLimit,
-	setDatatypeModule,
-	setDatatypeElephino,
-	setDatatypeFoldsTotal,
-	setDatatypeLeavesTotal,
-	getDatatypeModule,
-	setInStone,
-	hackSSOTdtype,
-	hackSSOTdatatype,
-)
+from mapFolding.theSSOTdatatypes import *
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from numpy import dtype, integer, ndarray
 from pathlib import Path
-from sys import modules as sysModules
 from types import ModuleType
 from typing import Any, Final, TYPE_CHECKING, cast
 
@@ -34,49 +20,29 @@ else:
 - Configuration Registry
 - Write-Once, Read-Many (WORM) / Immutable Initialization
 - Lazy Initialization
-- Separation of configuration from business logic
+- Separate configuration from business logic
+
+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
 """
 
-myPackageNameIs = "mapFolding"
-
-moduleOfSyntheticModules = "syntheticModules"
-# TODO I'm not sure if this is the right tool for the job.
-formatFilenameModuleDEFAULT = "numba_{callableTarget}.py"
-dispatcherCallableNameDEFAULT = "doTheNeedful"
-
-def getPathPackage() -> Path:
-	import importlib, inspect
-	pathPackage = Path(inspect.getfile(importlib.import_module(myPackageNameIs)))
-	if pathPackage.is_file():
-		pathPackage = pathPackage.parent
-	return pathPackage
-
-def getPathJobRootDEFAULT() -> Path:
-	if 'google.colab' in sysModules:
-		pathJobDEFAULT = Path("/content/drive/MyDrive") / "jobs"
-	else:
-		pathJobDEFAULT = getPathPackage() / "jobs"
-	return pathJobDEFAULT
+"""
+listDimensions: list[int]
+mapShape
+tupleDimensions: tuple[int, ...]
+dimensionsTuple
+dimensionTuple
+"""
 
 def getPathSyntheticModules() -> Path:
-	pathSyntheticModules = getPathPackage() / moduleOfSyntheticModules
-	return pathSyntheticModules
-
-def getAlgorithmSource() -> ModuleType:
-	from mapFolding import theDao
-	return theDao
+	return pathPackage / moduleOfSyntheticModules
 
 def getAlgorithmDispatcher() -> Callable[..., None]:
-	algorithmSource = getAlgorithmSource()
+	algorithmSource: ModuleType = getAlgorithmSource()
 	return cast(Callable[..., None], algorithmSource.doTheNeedful) # 'doTheNeedful' is duplicated and there is not a SSOT for it
 
-def getDispatcherCallable() -> Callable[..., None]:
-	from mapFolding.syntheticModules import numba_doTheNeedful
-	return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
-
 # NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
 class computationState(TypedDict):
 	connectionGraph:	ndarray[tuple[int, int, int], dtype[integer[Any]]]
@@ -133,7 +99,7 @@ class ParametersNumba(TypedDict):
 	nopython: bool
 	parallel: bool
 	pipeline_class: NotRequired[type[numbaCompilerBase]]
-	signature_or_function: NotRequired[Any | Callable | str | tuple]
+	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
 
 parametersNumbaFailEarly: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'python', 'fastmath': False, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False, }

mapFolding/theSSOTdatatypes.py

@@ -1,18 +1,9 @@
+from mapFolding.theConfiguration import *
 from collections import defaultdict
-from typing import Any, cast, Final, TYPE_CHECKING
+from typing import Any, cast, Final
 import enum
-import numba
-import numpy
-
-try:
-	from typing import NotRequired
-except Exception:
-	from typing_extensions import NotRequired # type: ignore
-
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict
+import numba # type: ignore
+import numpy # type: ignore
 
 class EnumIndices(enum.IntEnum):
 	@staticmethod
@@ -51,20 +42,18 @@ _datatypeDefault: Final[dict[str, str]] = {
 	'foldsTotal': 'int64',
 	'leavesTotal': 'uint16',
 }
-_datatypeModule = ''
-_datatypeModuleDEFAULT: Final[str] = 'numpy'
-
-_datatype: dict[str, str] = defaultdict(str)
+_datatypeModule: str = ''
+_registryOfDatatypes: dict[str, str] = defaultdict(str)
 
 def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: bool | None = False) -> str:
-	global _datatype
-	if not _datatype[identifier]:
-		_datatype[identifier] = datatype
-	elif _datatype[identifier] == datatype:
+	global _registryOfDatatypes
+	if not _registryOfDatatypes[identifier]:
+		_registryOfDatatypes[identifier] = datatype
+	elif _registryOfDatatypes[identifier] == datatype:
 		pass
 	elif sourGrapes:
-		raise Exception(f"Datatype is '{_datatype[identifier]}' not '{datatype}', so you can take your ball and go home.")
-	return _datatype[identifier]
+		raise Exception(f"Datatype is '{_registryOfDatatypes[identifier]}' not '{datatype}', so you can take your ball and go home.")
+	return _registryOfDatatypes[identifier]
 
 def setDatatypeModule(datatypeModule: str, sourGrapes: bool | None = False) -> str:
 	global _datatypeModule
@@ -86,29 +75,29 @@ def setDatatypeLeavesTotal(datatype: str, sourGrapes: bool | None = False) -> st
 	return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
 
 def _get_datatype(identifier: str) -> str:
-	global _datatype
-	if not _datatype[identifier]:
+	global _registryOfDatatypes
+	if not _registryOfDatatypes[identifier]:
 		if identifier in indexMy._member_names_:
-			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+			_registryOfDatatypes[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
 		elif identifier in indexTrack._member_names_:
-			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+			_registryOfDatatypes[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
 		else:
-			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('foldsTotal')
-	return _datatype[identifier]
+			_registryOfDatatypes[identifier] = _datatypeDefault.get(identifier) or _get_datatype('foldsTotal')
+	return _registryOfDatatypes[identifier]
 
 def getDatatypeModule() -> str:
 	global _datatypeModule
 	if not _datatypeModule:
-		_datatypeModule = _datatypeModuleDEFAULT
+		_datatypeModule = datatypeModulePACKAGING
 	return _datatypeModule
 
 def setInStone(identifier: str) -> type[Any]:
-	datatypeModule = getDatatypeModule()
-	datatypeStr = _get_datatype(identifier)
+	datatypeModule: str = getDatatypeModule()
+	datatypeStr: str = _get_datatype(identifier)
 	return cast(type[Any], getattr(eval(datatypeModule), datatypeStr))
 
 def hackSSOTdtype(identifier: str) -> type[Any]:
-	_hackSSOTdtype={
+	_hackSSOTdtype: dict[str, str]={
 	'connectionGraph': 	'dtypeLeavesTotal',
 	'dtypeElephino': 	'dtypeElephino',
 	'dtypeFoldsTotal': 	'dtypeFoldsTotal',
@@ -119,7 +108,7 @@ def hackSSOTdtype(identifier: str) -> type[Any]:
 	'my': 				'dtypeElephino',
 	'track': 			'dtypeElephino',
 	}
-	RubeGoldBerg = _hackSSOTdtype[identifier]
+	RubeGoldBerg: str = _hackSSOTdtype[identifier]
 	if RubeGoldBerg == 'dtypeElephino':
 		return setInStone('elephino')
 	elif RubeGoldBerg == 'dtypeFoldsTotal':
@@ -129,7 +118,7 @@ def hackSSOTdtype(identifier: str) -> type[Any]:
 	raise Exception("Dude, you forgot to set a value in `hackSSOTdtype`.")
 
 def hackSSOTdatatype(identifier: str) -> str:
-	_hackSSOTdatatype={
+	_hackSSOTdatatype: dict[str, str]={
 	'connectionGraph':	 		'datatypeLeavesTotal',
 	'countDimensionsGapped': 	'datatypeLeavesTotal',
 	'datatypeElephino': 		'datatypeElephino',
@@ -156,7 +145,7 @@ def hackSSOTdatatype(identifier: str) -> str:
 	'taskIndex': 				'datatypeLeavesTotal',
 	'track':	 				'datatypeElephino',
 	}
-	RubeGoldBerg = _hackSSOTdatatype[identifier]
+	RubeGoldBerg: str = _hackSSOTdatatype[identifier]
 	if RubeGoldBerg == 'datatypeElephino':
 		return _get_datatype('elephino')
 	elif RubeGoldBerg == 'datatypeFoldsTotal':

mapFolding/theWrongWay.py

@@ -0,0 +1,7 @@
+from typing import Final
+
+datatypeModulePACKAGING: Final[str] = 'numpy'
+myPackageNameIsPACKAGING: str = "mapFolding"
+listCallablesDispatcheesHARDCODED: list[str] = ['countInitialize', 'countParallel', 'countSequential']
+additional_importsHARDCODED: list[str] = ['numba']
+algorithmSourcePACKAGING: str = 'theDao'

{mapFolding-0.5.0.dist-info → mapfolding-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.5.0
+Version: 0.6.0
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -16,12 +16,12 @@ Classifier: Intended Audience :: Other Audience
 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: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
@@ -33,7 +33,9 @@ Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: autoflake; extra == "testing"
+Requires-Dist: mypy; extra == "testing"
 Requires-Dist: more_itertools; extra == "testing"
+Requires-Dist: numba_progress; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
@@ -152,4 +154,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.svg)](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.png)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.6.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mapFolding/__init__.py,sha256=pggwv9wBf1jqZUxp8qO1Si1LswyTGZQLoRqdO0ptiS4,2707
+mapFolding/basecamp.py,sha256=Y2yBE89IviRcVOvLM1mRWocqPHVkmZ2awAZVkDTDTAo,3571
+mapFolding/beDRY.py,sha256=5D-9AwbtBULTQ4N5WX57ZXqw6mCmPa31eCU2xpQXlf4,15750
+mapFolding/oeis.py,sha256=qxNrmEfx5IYc5tw312J3Jk3xO-nAeaM8unxmxM7R8Cs,11924
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theConfiguration.py,sha256=vKLwflVNzthbZlOWTwEC4xqh0rp9Xoyz-hUAT7a5CSA,2098
+mapFolding/theDao.py,sha256=A-cDyixGLROAehYxf4k0srVjoe4aSeXJK_k40irfndU,12626
+mapFolding/theSSOT.py,sha256=55sy05nmAaPpDAiuA6t27u20obHMzY8NTD_XR2Ffgos,4940
+mapFolding/theSSOTdatatypes.py,sha256=V5G99QwMMaZV-J3EIPAKIKorV3fz0LHUgwErF9MP01E,5854
+mapFolding/theWrongWay.py,sha256=p7nL3JM9t4mbF1xBn1gZzG1jGs9KRkyGP3XliUPkm-4,312
+mapfolding-0.6.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.6.0.dist-info/METADATA,sha256=cnO-gz66V3NnAdUIAgKKIsT8PgVxqD4I726HqgYVGSc,7768
+mapfolding-0.6.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mapfolding-0.6.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.6.0.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
+mapfolding-0.6.0.dist-info/RECORD,,

{mapFolding-0.5.0.dist-info → mapfolding-0.6.0.dist-info}/WHEEL

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

{mapFolding-0.5.0.dist-info → mapfolding-0.6.0.dist-info}/top_level.txt

@@ -1,2 +1 @@
 mapFolding
-tests

mapFolding/reference/flattened.py

@@ -1,377 +0,0 @@
-"""The algorithm flattened into semantic sections.
-This version is not maintained, so you may see differences from the current version."""
-from numpy import integer
-from numpy.typing import NDArray
-from typing import List, Any, Final, Optional, Union, Sequence, Tuple, Type, TypedDict
-import enum
-import numpy
-import sys
-
-def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUlimit: Optional[Union[int, float, bool]] = None):
-	def doWhile():
-
-		while activeLeafGreaterThan0Condition():
-
-			if activeLeafIsTheFirstLeafCondition() or leafBelowSentinelIs1Condition():
-
-				if activeLeafGreaterThanLeavesTotalCondition():
-					foldsSubTotalsIncrement()
-
-				else:
-
-					findGapsInitializeVariables()
-					while loopingTheDimensions():
-
-						if dimensionsUnconstrainedCondition():
-							dimensionsUnconstrainedIncrement()
-
-						else:
-
-							leafConnecteeInitialization()
-							while loopingLeavesConnectedToActiveLeaf():
-								if thereAreComputationDivisionsYouMightSkip():
-									countGaps()
-								leafConnecteeUpdate()
-
-						dimension1ndexIncrement()
-
-					if allDimensionsAreUnconstrained():
-						insertUnconstrainedLeaf()
-
-					indexMiniGapInitialization()
-					while loopingToActiveGapCeiling():
-						filterCommonGaps()
-						indexMiniGapIncrement()
-
-			while backtrackCondition():
-				backtrack()
-
-			if placeLeafCondition():
-				placeLeaf()
-
-	def activeGapIncrement():
-		my[indexMy.gap1ndex] += 1
-
-	def activeLeafGreaterThan0Condition():
-		return my[indexMy.leaf1ndex] > 0
-
-	def activeLeafGreaterThanLeavesTotalCondition():
-		return my[indexMy.leaf1ndex] > the[indexThe.leavesTotal]
-
-	def activeLeafIsTheFirstLeafCondition():
-		return my[indexMy.leaf1ndex] <= 1
-
-	def activeLeafNotEqualToTaskDivisionsCondition():
-		return my[indexMy.leaf1ndex] != the[indexThe.taskDivisions]
-
-	def allDimensionsAreUnconstrained():
-		return my[indexMy.dimensionsUnconstrained] == the[indexThe.dimensionsTotal]
-
-	def backtrack():
-		my[indexMy.leaf1ndex] -= 1
-		track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
-		track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
-
-	def backtrackCondition():
-		return my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-
-	def computationDivisionsCondition():
-		return the[indexThe.taskDivisions] == int(False)
-
-	def countGaps():
-		gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-		if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-			gap1ndexCeilingIncrement()
-		track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-
-	def dimension1ndexIncrement():
-		my[indexMy.dimension1ndex] += 1
-
-	def dimensionsUnconstrainedCondition():
-		return connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]
-
-	def dimensionsUnconstrainedIncrement():
-		my[indexMy.dimensionsUnconstrained] += 1
-
-	def filterCommonGaps():
-		gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-		if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == the[indexThe.dimensionsTotal] - my[indexMy.dimensionsUnconstrained]:
-			activeGapIncrement()
-		track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-
-	def findGapsInitializeVariables():
-		my[indexMy.dimensionsUnconstrained] = 0
-		my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-		my[indexMy.dimension1ndex] = 1
-
-	def foldsSubTotalsIncrement():
-		foldsSubTotals[my[indexMy.taskIndex]] += the[indexThe.leavesTotal]
-
-	def gap1ndexCeilingIncrement():
-		my[indexMy.gap1ndexCeiling] += 1
-
-	def indexMiniGapIncrement():
-		my[indexMy.indexMiniGap] += 1
-
-	def indexMiniGapInitialization():
-		my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-
-	def insertUnconstrainedLeaf():
-		my[indexMy.indexLeaf] = 0
-		while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
-			gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
-			my[indexMy.gap1ndexCeiling] += 1
-			my[indexMy.indexLeaf] += 1
-
-	def leafBelowSentinelIs1Condition():
-		return track[indexTrack.leafBelow, 0] == 1
-
-	def leafConnecteeInitialization():
-		my[indexMy.leafConnectee] = connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-
-	def leafConnecteeUpdate():
-		my[indexMy.leafConnectee] = connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-
-	def loopingLeavesConnectedToActiveLeaf():
-		return my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]
-
-	def loopingTheDimensions():
-		return my[indexMy.dimension1ndex] <= the[indexThe.dimensionsTotal]
-
-	def loopingToActiveGapCeiling():
-		return my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]
-
-	def placeLeaf():
-		my[indexMy.gap1ndex] -= 1
-		track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-		track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-		track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-		track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-		track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-		my[indexMy.leaf1ndex] += 1
-
-	def placeLeafCondition():
-		return my[indexMy.leaf1ndex] > 0
-
-	def taskIndexCondition():
-		return my[indexMy.leafConnectee] % the[indexThe.taskDivisions] == my[indexMy.taskIndex]
-
-	def thereAreComputationDivisionsYouMightSkip():
-		if computationDivisionsCondition():
-			return True
-		if activeLeafNotEqualToTaskDivisionsCondition():
-			return True
-		if taskIndexCondition():
-			return True
-		return False
-
-	stateUniversal = outfitFoldings(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit)
-	connectionGraph: Final[numpy.ndarray] = stateUniversal['connectionGraph']
-	foldsSubTotals = stateUniversal['foldsSubTotals']
-	gapsWhere = stateUniversal['gapsWhere']
-	my = stateUniversal['my']
-	the: Final[numpy.ndarray] = stateUniversal['the']
-	track = stateUniversal['track']
-
-	if the[indexThe.taskDivisions] == int(False):
-		doWhile()
-	else:
-		stateUniversal['my'] = my.copy()
-		stateUniversal['gapsWhere'] = gapsWhere.copy()
-		stateUniversal['track'] = track.copy()
-		for indexSherpa in range(the[indexThe.taskDivisions]):
-			my = stateUniversal['my'].copy()
-			my[indexMy.taskIndex] = indexSherpa
-			gapsWhere = stateUniversal['gapsWhere'].copy()
-			track = stateUniversal['track'].copy()
-			doWhile()
-
-	return numpy.sum(foldsSubTotals).item()
-
-@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
-class EnumIndices(enum.IntEnum):
-	"""Base class for index enums."""
-	@staticmethod
-	def _generate_next_value_(name, start, count, last_values):
-		"""0-indexed."""
-		return count
-
-	def __index__(self) -> int:
-		"""Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
-		same as `array.array`. See NumPy.org; I think it will be very popular someday."""
-		return self
-
-class indexMy(EnumIndices):
-	"""Indices for dynamic values."""
-	dimension1ndex = enum.auto()
-	dimensionsUnconstrained = enum.auto()
-	gap1ndex = enum.auto()
-	gap1ndexCeiling = enum.auto()
-	indexLeaf = enum.auto()
-	indexMiniGap = enum.auto()
-	leaf1ndex = enum.auto()
-	leafConnectee = enum.auto()
-	taskIndex = enum.auto()
-
-class indexThe(EnumIndices):
-	"""Indices for static values."""
-	dimensionsTotal = enum.auto()
-	leavesTotal = enum.auto()
-	taskDivisions = enum.auto()
-
-class indexTrack(EnumIndices):
-	"""Indices for state tracking array."""
-	leafAbove = enum.auto()
-	leafBelow = enum.auto()
-	countDimensionsGapped = enum.auto()
-	gapRangeStart = enum.auto()
-
-class computationState(TypedDict):
-	connectionGraph: NDArray[integer[Any]]
-	foldsSubTotals: NDArray[integer[Any]]
-	mapShape: Tuple[int, ...]
-	my: NDArray[integer[Any]]
-	gapsWhere: NDArray[integer[Any]]
-	the: NDArray[integer[Any]]
-	track: NDArray[integer[Any]]
-
-dtypeLarge = numpy.int64
-dtypeMedium = dtypeLarge
-
-def getLeavesTotal(listDimensions: Sequence[int]) -> int:
-	"""
-	How many leaves are in the map.
-
-	Parameters:
-		listDimensions: A list of integers representing dimensions.
-
-	Returns:
-		productDimensions: The product of all positive integer dimensions.
-	"""
-	listNonNegative = parseDimensions(listDimensions, 'listDimensions')
-	listPositive = [dimension for dimension in listNonNegative if dimension > 0]
-
-	if not listPositive:
-		return 0
-	else:
-		productDimensions = 1
-		for dimension in listPositive:
-			if dimension > sys.maxsize // productDimensions:
-				raise OverflowError(f"I received {dimension=} in {listDimensions=}, but the product of the dimensions exceeds the maximum size of an integer on this system.")
-			productDimensions *= dimension
-
-		return productDimensions
-
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
-	if not computationDivisions:
-		return 0
-	else:
-		leavesTotal = getLeavesTotal(listDimensions)
-		taskDivisions = 0
-	if isinstance(computationDivisions, int):
-		taskDivisions = computationDivisions
-	elif isinstance(computationDivisions, str):
-		computationDivisions = computationDivisions.lower()
-		if computationDivisions == "maximum":
-			taskDivisions = leavesTotal
-		elif computationDivisions == "cpu":
-			taskDivisions = min(concurrencyLimit, leavesTotal)
-	else:
-		raise ValueError("Not my problem.")
-
-	if taskDivisions > leavesTotal:
-		raise ValueError("What are you doing?")
-
-	return taskDivisions
-
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
-	datatype = keywordArguments.get('datatype', dtypeMedium)
-	mapShape = validateListDimensions(listDimensions)
-	leavesTotal = getLeavesTotal(mapShape)
-	arrayDimensions = numpy.array(mapShape, dtype=datatype)
-	dimensionsTotal = len(arrayDimensions)
-
-	cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
-	coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=datatype)
-	for dimension1ndex in range(1, dimensionsTotal + 1):
-		for leaf1ndex in range(1, leavesTotal + 1):
-			coordinateSystem[dimension1ndex, leaf1ndex] = ( ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) % arrayDimensions[dimension1ndex - 1] + 1 )
-
-	connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
-	for dimension1ndex in range(1, dimensionsTotal + 1):
-		for activeLeaf1ndex in range(1, leavesTotal + 1):
-			for connectee1ndex in range(1, activeLeaf1ndex + 1):
-				isFirstCoord = coordinateSystem[dimension1ndex, connectee1ndex] == 1
-				isLastCoord = coordinateSystem[dimension1ndex, connectee1ndex] == arrayDimensions[dimension1ndex - 1]
-				exceedsActive = connectee1ndex + cumulativeProduct[dimension1ndex - 1] > activeLeaf1ndex
-				isEvenParity = (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == (coordinateSystem[dimension1ndex, connectee1ndex] & 1)
-
-				if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
-					connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
-				elif isEvenParity and not isFirstCoord:
-					connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[dimension1ndex - 1]
-				elif not isEvenParity and not (isLastCoord or exceedsActive):
-					connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[dimension1ndex - 1]
-				else:
-					connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
-	return connectionGraph
-
-def makeDataContainer(shape, datatype: Optional[Type] = None):
-	if datatype is None:
-		datatype = dtypeMedium
-	return numpy.zeros(shape, dtype=datatype)
-
-def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
-	datatypeMedium = keywordArguments.get('datatypeMedium', dtypeMedium)
-	datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
-
-	the = makeDataContainer(len(indexThe), datatypeMedium)
-
-	mapShape = tuple(sorted(validateListDimensions(listDimensions)))
-	the[indexThe.leavesTotal] = getLeavesTotal(mapShape)
-	the[indexThe.dimensionsTotal] = len(mapShape)
-	concurrencyLimit = setCPUlimit(CPUlimit)
-	the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
-
-	stateInitialized = computationState(
-		connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeMedium),
-		foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
-		mapShape = mapShape,
-		my = makeDataContainer(len(indexMy), datatypeLarge),
-		gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeMedium),
-		the = the,
-		track = makeDataContainer((len(indexTrack), the[indexThe.leavesTotal] + 1), datatypeLarge)
-		)
-
-	stateInitialized['my'][indexMy.leaf1ndex] = 1
-	return stateInitialized
-
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
-	# listValidated = intInnit(dimensions, parameterName)
-	listNOTValidated = dimensions if isinstance(dimensions, (list, tuple)) else list(dimensions)
-	listNonNegative = []
-	for dimension in listNOTValidated:
-		if dimension < 0:
-			raise ValueError(f"Dimension {dimension} must be non-negative")
-		listNonNegative.append(dimension)
-	if not listNonNegative:
-		raise ValueError("At least one dimension must be non-negative")
-	return listNonNegative
-
-def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
-	# if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
-	#	 CPUlimit = oopsieKwargsie(CPUlimit)
-	# concurrencyLimit = defineConcurrencyLimit(CPUlimit)
-	# numba.set_num_threads(concurrencyLimit)
-	concurrencyLimitHARDCODED = 1
-	concurrencyLimit = concurrencyLimitHARDCODED
-	return concurrencyLimit
-
-def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
-	if not listDimensions:
-		raise ValueError(f"listDimensions is a required parameter.")
-	listNonNegative = parseDimensions(listDimensions, 'listDimensions')
-	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 sorted(dimensionsValid)