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

mapFolding/filesystem.py

@@ -0,0 +1,95 @@
+"""Filesystem functions for mapFolding package."""
+from pathlib import Path, PurePath
+from typing import Any
+import os
+
+def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
+	"""Imagine your computer has been counting folds for 9 days, and when it tries to save your newly discovered value,
+	the filename is invalid. I bet you think this function is more important after that thought experiment.
+
+	Make a standardized filename for the computed value `foldsTotal`.
+
+	The filename takes into account
+		- the dimensions of the map, aka `mapShape`, aka `listDimensions`
+		- no spaces in the filename
+		- safe filesystem characters
+		- unique extension
+		- Python-safe strings:
+			- no starting with a number
+			- no reserved words
+			- no dashes or other special characters
+			- uh, I can't remember, but I found some other frustrating limitations
+		- if 'p' is still the first character of the filename, I picked that because it was the original identifier for the map shape in Lunnan's code
+
+	Parameters:
+		mapShape: A sequence of integers representing the dimensions of the map.
+
+	Returns:
+		filenameFoldsTotal: A filename string in format 'pMxN.foldsTotal' where M,N are sorted dimensions
+	"""
+	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
+
+def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: str | os.PathLike[str] | None = None) -> Path:
+	"""Get a standardized path and filename for the computed value `foldsTotal`.
+
+	If you provide a directory, the function will append a standardized filename. If you provide a filename
+	or a relative path and filename, the function will prepend the default path.
+
+	Parameters:
+		mapShape: List of dimensions for the map folding problem.
+		pathLikeWriteFoldsTotal (pathJobRootDEFAULT): Path, filename, or relative path and filename. If None, uses default path.
+			Defaults to None.
+
+	Returns:
+		pathFilenameFoldsTotal: Absolute path and filename.
+	"""
+	from mapFolding.theSSOT import getPathJobRootDEFAULT
+
+	if pathLikeWriteFoldsTotal is None:
+		pathFilenameFoldsTotal = getPathJobRootDEFAULT() / getFilenameFoldsTotal(mapShape)
+	else:
+		pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
+		if pathLikeSherpa.is_dir():
+			pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
+		elif pathLikeSherpa.is_file() and pathLikeSherpa.is_absolute():
+			pathFilenameFoldsTotal = pathLikeSherpa
+		else:
+			pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
+
+	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+	return pathFilenameFoldsTotal
+
+def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
+	"""
+	Save foldsTotal with multiple fallback mechanisms.
+
+	Parameters:
+		pathFilename: Target save location
+		foldsTotal: Critical computed value to save
+	"""
+	try:
+		pathFilenameFoldsTotal = Path(pathFilename)
+		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+		pathFilenameFoldsTotal.write_text(str(foldsTotal))
+	except Exception as ERRORmessage:
+		try:
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			print(ERRORmessage)
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+			filenameInfixUnique = ''.join(randomnessPlanB)
+			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+			writeStreamFallback = open(pathFilenamePlanB, 'w')
+			writeStreamFallback.write(str(foldsTotal))
+			writeStreamFallback.close()
+			print(str(pathFilenamePlanB))
+		except Exception:
+			print(foldsTotal)
+	return None
+
+def writeStringToHere(this: str, pathFilename: str | os.PathLike[Any] | PurePath) -> None:
+	"""Write the string `this` to the file at `pathFilename`."""
+	pathFilename = Path(pathFilename)
+	pathFilename.parent.mkdir(parents=True, exist_ok=True)
+	pathFilename.write_text(str(this))
+	return None

mapFolding/noHomeYet.py

@@ -0,0 +1,20 @@
+from functools import cache
+from mapFolding.oeis import settingsOEIS
+
+@cache
+def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
+	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
+	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
+
+	for settings in settingsOEIS.values():
+		sequence = settings['valuesKnown']
+
+		for n, foldingsTotal in sequence.items():
+			mapShape = settings['getMapShape'](n)
+			mapShape = sorted(mapShape)
+			dictionaryMapDimensionsToFoldsTotalKnown[tuple(mapShape)] = foldingsTotal
+	return dictionaryMapDimensionsToFoldsTotalKnown
+
+def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
+	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
+	return lookupFoldsTotal.get(tuple(mapShape), -1)

mapFolding/oeis.py

@@ -1,9 +1,9 @@
 """Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS); _only_ things that implement _only_ the OEIS."""
 from collections.abc import Callable
 from datetime import datetime, timedelta
-from mapFolding import countFolds, pathPackage
+from mapFolding.theSSOT import thePathPackage
 from pathlib import Path
-from typing import Any, cast, Final, TYPE_CHECKING
+from typing import Any, Final, TYPE_CHECKING
 import argparse
 import pathlib
 import random
@@ -23,11 +23,11 @@ cacheDays = 7
 """
 Section: make `settingsOEIS`"""
 
-pathCache: Path = pathPackage / ".cache"
+pathCache: Path = thePathPackage / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
-	getMapShape: Callable[[int], list[int]]
+	getMapShape: Callable[[int], tuple[int, ...]]
 	offset: int
 	valuesBenchmark: list[int]
 	valuesKnown: dict[int, int]
@@ -35,38 +35,45 @@ class SettingsOEIS(TypedDict):
 	valuesTestValidation: list[int]
 	valueUnknown: int
 
-settingsOEIShardcodedValues: dict[str, dict[str, Any]] = {
-    'A001415': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: sorted([2, n])), # type: ignore
-        'valuesBenchmark': [14],
-        'valuesTestParallelization': [*range(3, 7)],
-        'valuesTestValidation': [random.randint(2, 9)],
-    },
-    'A001416': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: sorted([3, n])), # type: ignore
-        'valuesBenchmark': [9],
-        'valuesTestParallelization': [*range(3, 5)],
-        'valuesTestValidation': [random.randint(2, 6)],
-    },
-    'A001417': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: [2] * n),	# type: ignore
-        'valuesBenchmark': [6],
-        'valuesTestParallelization': [*range(2, 4)],
-        'valuesTestValidation': [random.randint(2, 4)],
-    },
-    'A195646': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: [3] * n), # type: ignore
-        'valuesBenchmark': [3],
-        'valuesTestParallelization': [*range(2, 3)],
-        'valuesTestValidation': [2],
-    },
-    'A001418': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: [n, n]), # type: ignore
-        'valuesBenchmark': [5],
-        'valuesTestParallelization': [*range(2, 4)],
-        'valuesTestValidation': [random.randint(2, 4)],
-    },
+class SettingsOEIShardcodedValues(TypedDict):
+	getMapShape: Callable[[int], tuple[int, ...]]
+	valuesBenchmark: list[int]
+	valuesTestParallelization: list[int]
+	valuesTestValidation: list[int]
+
+settingsOEIShardcodedValues: dict[str, SettingsOEIShardcodedValues] = {
+	'A001415': {
+		'getMapShape': lambda n: (2, n) if n >= 2 else (n, 2),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],
+	},
+	'A001416': {
+		'getMapShape': lambda n: (3, n) if n >= 3 else (n, 3),
+		'valuesBenchmark': [9],
+		'valuesTestParallelization': [*range(3, 5)],
+		'valuesTestValidation': [random.randint(2, 6)],
+	},
+	'A001417': {
+		'getMapShape': lambda n: tuple(2 for _dimension in range(n)),
+		'valuesBenchmark': [6],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],
+	},
+	'A195646': {
+		'getMapShape': lambda n: tuple(3 for _dimension in range(n)),
+		'valuesBenchmark': [3],
+		'valuesTestParallelization': [*range(2, 3)],
+		'valuesTestValidation': [2],
+	},
+	'A001418': {
+		'getMapShape': lambda n: (n, n),
+		'valuesBenchmark': [5],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],
+	},
 }
+
 oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
@@ -286,16 +293,16 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 	if not isinstance(n, int) or n < 0:
 		raise ValueError("`n` must be non-negative integer.")
 
-	listDimensions: list[int] = settingsOEIS[oeisID]['getMapShape'](n)
+	mapShape: tuple[int, ...] = settingsOEIS[oeisID]['getMapShape'](n)
 
-	if n <= 1 or len(listDimensions) < 2:
+	if n <= 1 or len(mapShape) < 2:
 		offset: int = settingsOEIS[oeisID]['offset']
 		if n < offset:
 			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at n={n}.")
 		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
-
-	return countFolds(listDimensions)
+	from mapFolding.basecamp import countFolds
+	return countFolds(mapShape)
 
 def OEIS_for_n() -> None:
 	"""Command-line interface for oeisIDfor_n."""

mapFolding/reference/flattened.py

@@ -0,0 +1,377 @@
+"""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)