mapFolding 0.16.4__py3-none-any.whl → 0.17.1__py3-none-any.whl

mapFolding/algorithms/symmetricFolds.py

@@ -3,34 +3,33 @@
 Notes
 -----
 - About constructing `leafComparison`:
-    - This branch of the algorithm executes IFF `leafBelow[0] == 1`.
-    - Therefore, `leafComparison[0]` must be `1`.
-    - Therefore, the first iteration of the loop is hardcoded to save processing time.
-    - I _feel_ there must be a more efficient way to do this.
+	- The first iteration of the loop is hardcoded to save processing time.
+	- I _feel_ there must be a more efficient way to do this.
 - Some implementation details are based on Numba compatibility. Incompatible:
-    - `numpy.take(..., out=...)`
-    - `numpy.all(..., axis=...)`
+	- `numpy.take(..., out=...)`
+	- `numpy.all(..., axis=...)`
 """
 from mapFolding.dataBaskets import SymmetricFoldsState
-import numpy
 
 def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
-    state.indexLeaf = 1
-    state.leafComparison[0] = 1
-    state.leafConnectee = 1
-
-    while state.leafConnectee < state.leavesTotal + 1:
-        state.indexMiniGap = state.leafBelow[state.indexLeaf]
-        state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
-        state.indexLeaf = state.indexMiniGap
-
-        state.leafConnectee += 1
-
-    state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-    compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-
-    for indexRow in range(len(compared)):
-        state.groupsOfFolds += compared[indexRow].all()
-
-    return state
+	state.indexLeaf = 1
+	state.leafComparison[0] = 1
+	state.leafConnectee = 1
+
+	while state.leafConnectee < state.leavesTotal + 1:
+		state.indexMiniGap = state.leafBelow[state.indexLeaf]
+		state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+		state.indexLeaf = state.indexMiniGap
+
+		state.leafConnectee += 1
+
+	for listTuples in state.indices:
+		state.leafConnectee = 1
+		for indexLeft, indexRight in listTuples:
+			if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+				state.leafConnectee = 0
+				break
+		state.symmetricFolds += state.leafConnectee
+
+	return state
 

mapFolding/basecamp.py

@@ -169,18 +169,20 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 		mapFoldingParallelState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
 
-		# `listStatesParallel` exists so you can research the parallel computation.
+		# NOTE `listStatesParallel` exists so you can research the parallel computation.
 		foldsTotal, _listStatesParallel = doTheNeedful(mapFoldingParallelState, concurrencyLimit)
 
 # ruff: noqa: E701
 	else:
-		match flow:
-			case 'daoOfMapFolding': from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
-			case 'numba': from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
-			case 'theorem2': from mapFolding.syntheticModules.theorem2 import doTheNeedful
-			case 'theorem2Numba': from mapFolding.syntheticModules.theorem2Numba import doTheNeedful
-			case 'theorem2Trimmed': from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
-			case _: from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+		if all(dimension < 2 for dimension in mapShape):
+			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+		else:
+			match flow:
+				case 'numba': from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
+				case 'theorem2': from mapFolding.syntheticModules.theorem2 import doTheNeedful
+				case 'theorem2Numba': from mapFolding.syntheticModules.theorem2Numba import doTheNeedful
+				case 'theorem2Trimmed': from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
+				case 'daoOfMapFolding' | _: from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
 
 		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
@@ -194,6 +196,75 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	return foldsTotal
 
+def eliminateFolds(mapShape: tuple[int, ...]
+				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				, CPUlimit: bool | float | int | None = None  # noqa: FBT001
+				, flow: str | None = None
+				) -> int:
+	"""
+	Compute foldsTotal by elimination.
+
+	Parameters
+	----------
+	mapShape : tuple[int, ...] | None = None
+		Tuple of integers representing the dimensions of the map to be folded. Mathematicians almost always use the term
+		"dimensions", such as in the seminal paper, "Multi-dimensional map-folding". Nevertheless, in contemporary Python
+		programming, in the context of these algorithms, the term "shape" makes it much easier to align the mathematics with the
+		syntax of the programming language.
+	pathLikeWriteFoldsTotal : PathLike[str] | PurePath | None = None
+		A filename, a path of only directories, or a path with directories and a filename to which `countFolds` will write the
+		value of `foldsTotal`. If `pathLikeWriteFoldsTotal` is a path of only directories, `countFolds` creates a filename based
+		on the map dimensions.
+	CPUlimit : bool | float | int | None = None
+		If relevant, whether and how to limit the number of processors `countFolds` will use.
+		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will
+		potentially limit processor usage.
+		- `True`: Yes, limit the processor usage; limits to 1 processor.
+		- `int >= 1`: The maximum number of available processors to use.
+		- `0 < float < 1`: The maximum number of processors to use expressed as a fraction of available processors.
+		- `-1 < float < 0`: The number of processors to *not* use expressed as a fraction of available processors.
+		- `int <= -1`: The number of available processors to *not* use.
+		- If the value of `CPUlimit` is a `float` greater than 1 or less than -1, `countFolds` truncates the value to an `int`
+		with the same sign as the `float`.
+	flow : str | None = None
+		My stupid way of selecting the version of the algorithm to use in the computation.
+
+	Returns
+	-------
+	foldsTotal : int
+		Number of distinct ways to fold a map of the given dimensions.
+	"""
+	from mapFolding.beDRY import setProcessorLimit
+	concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
+
+# ------- memorialization instructions ---------------------------------------------
+
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal: Path | None = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
+	else:
+		pathFilenameFoldsTotal = None
+
+# ------- Algorithm version -----------------------------------------------------
+# ruff: noqa: E701
+	match flow:
+		case 'constraintPropagation': from mapFolding.algorithms.constraintPropagation import doTheNeedful
+		case 'pinned': from mapFolding.algorithms.eliminationPinned import doTheNeedful
+		case 'elimination' | _: from mapFolding.algorithms.elimination import doTheNeedful
+
+	from mapFolding.dataBaskets import EliminationState
+	eliminationState: EliminationState = EliminationState(mapShape)
+	eliminationState = doTheNeedful(eliminationState, concurrencyLimit)
+	foldsTotal = eliminationState.foldsTotal
+
+# ------- Follow memorialization instructions ---------------------------------------------
+
+	if pathFilenameFoldsTotal is not None:
+		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
+
+	return foldsTotal
+
 def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 # TODO , pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 		, CPUlimit: bool | float | int | None = None  # noqa: FBT001
@@ -225,12 +296,11 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 			case 'A000682' | 'A005316':
 				match flow:
 					case 'matrixNumPy':
-						from mapFolding.algorithms.matrixMeandersNumPy import doTheNeedful
-						from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
+						from mapFolding.algorithms.matrixMeandersNumPyndas import doTheNeedful, MatrixMeandersNumPyState as State
 					case 'matrixPandas':
-						from mapFolding.algorithms.matrixMeandersPandas import doTheNeedful
-						from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
-					case _:
+						from mapFolding.algorithms.matrixMeandersNumPyndas import (
+							doTheNeedfulPandas as doTheNeedful, MatrixMeandersNumPyState as State)
+					case 'matrixMeanders' | _:
 						from mapFolding.algorithms.matrixMeanders import doTheNeedful
 						from mapFolding.dataBaskets import MatrixMeandersState as State
 
@@ -291,7 +361,7 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 						from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful
 						symmetricState = doTheNeedful(symmetricState)
 
-				countTotal = symmetricState.groupsOfFolds
+				countTotal = symmetricState.symmetricFolds
 			case _:
 				matched_oeisID = False
 

mapFolding/beDRY.py

@@ -1,13 +1,26 @@
 """Oft-needed computations or actions, especially for multi-dimensional map folding."""
 
-from collections.abc import Sequence
+from collections.abc import Iterable, Iterator, Sequence
+from functools import cache
 from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
 from mapFolding import NumPyIntegerType
+from more_itertools import extract
 from numpy import dtype as numpy_dtype, int64 as numpy_int64, ndarray
 from sys import maxsize as sysMaxsize
 from typing import Any
 import numpy
 
+def exclude[个](iterable: Sequence[个], indices: Iterable[int]) -> Iterator[个]:
+	"""Yield items from `iterable` whose positions are not in `indices`."""
+	lengthIterable: int = len(iterable)
+	def normalizeIndex(index: int) -> int:
+		if index < 0:
+			index = (index + lengthIterable) % lengthIterable
+		return index
+	indicesInclude: list[int] = sorted(set(range(lengthIterable)).difference(map(normalizeIndex, indices)))
+	return extract(iterable, indicesInclude)
+
+@cache
 def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""Calculate the total number of leaves in a map with the given dimensions.
 

mapFolding/dataBaskets.py

@@ -21,12 +21,65 @@ integrity throughout the recursive analysis while providing the structured data
 access patterns that enable efficient result persistence and retrieval.
 """
 from mapFolding import (
-	Array1DElephino, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal,
-	DatatypeLeavesTotal, getConnectionGraph, getLeavesTotal, makeDataContainer)
-from numpy.typing import NDArray
-from typing import TypeAlias
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	getConnectionGraph, getLeavesTotal, makeDataContainer)
 import dataclasses
-import numpy
+
+@dataclasses.dataclass(slots=True)
+class EliminationState:
+	"""Computational state for algorithms to compute foldsTotal by elimination.
+
+	Attributes
+	----------
+	mapShape : tuple[DatatypeLeavesTotal, ...]
+		Dimensions of the map being analyzed for folding patterns.
+	groupsOfFolds : DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+		Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings.
+	dimensionsTotal : DatatypeLeavesTotal
+		Unchanging total number of dimensions in the map.
+	leavesTotal : DatatypeLeavesTotal
+		Unchanging total number of leaves in the map.
+	"""
+
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+	"""Dimensions of the map being analyzed for folding patterns."""
+
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	"""Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings."""
+
+	listPinnedLeaves: list[dict[int, int]] = dataclasses.field(default_factory=list[dict[int, int]], init=True)
+	"""column: leaf or pile: indexLeaf"""
+	pile: DatatypeLeavesTotal = DatatypeLeavesTotal(-1)  # noqa: RUF009
+	pinnedLeaves: dict[int, int] = dataclasses.field(default_factory=dict[int, int], init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+	"""column: leaf or pile: indexLeaf"""
+
+	subsetsTheorem2: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	subsetsTheorem3: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	subsetsTheorem4: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+
+	columnLast: DatatypeLeavesTotal = dataclasses.field(init=False)
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of dimensions in the map."""
+	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of leaves in the map."""
+
+	@property
+	def foldsTotal(self) -> DatatypeFoldsTotal:
+		"""The total number of possible folding patterns for this map.
+
+		Returns
+		-------
+		foldsTotal : DatatypeFoldsTotal
+			The complete count of distinct folding patterns achievable with the current map configuration.
+
+		"""
+		return DatatypeFoldsTotal(self.leavesTotal) * self.groupsOfFolds * self.subsetsTheorem2 * self.subsetsTheorem3 * self.subsetsTheorem4
+
+	def __post_init__(self) -> None:
+		"""Ensure all fields have a value."""
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+		self.columnLast = self.leavesTotal - DatatypeLeavesTotal(1)
 
 @dataclasses.dataclass(slots=True)
 class MapFoldingState:
@@ -203,7 +256,7 @@ class SymmetricFoldsState:
 	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
 	"""Dimensions of the map being analyzed for folding patterns."""
 
-	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	symmetricFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
 	"""Current count of symmetric folds."""
 
 	gap1ndex: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
@@ -237,12 +290,12 @@ class SymmetricFoldsState:
 	leafComparison: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
 	"""Array for finding symmetric folds."""
 
-	arrayGroupOfFolds: Array2DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array2DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	connectionGraph: Array3DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array3DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	"""Unchanging array representing connections between all leaves."""
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 	"""Unchanging total number of dimensions in the map."""
-	indicesArrayGroupOfFolds: Array2DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array2DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	indices: list[list[tuple[int, int]]] = dataclasses.field(init=False)
+	"""Precomputed index pairs for symmetric fold checking."""
 	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 	"""Unchanging total number of leaves in the map."""
 
@@ -259,12 +312,9 @@ class SymmetricFoldsState:
 		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
 
 		leavesTotalAsInt = int(self.leavesTotal)
-
 		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
 
-		self.indicesArrayGroupOfFolds = (numpy.arange(leavesTotalAsInt + 1)[:, None] + numpy.arange(leavesTotalAsInt)[None, :]) % (leavesTotalAsInt + 1)
-		self.indicesArrayGroupOfFolds[..., leavesTotalAsInt // 2:None] = self.indicesArrayGroupOfFolds[..., leavesTotalAsInt - 1: leavesTotalAsInt - leavesTotalAsInt // 2 - 1: -1]
-		self.arrayGroupOfFolds = numpy.zeros_like(self.indicesArrayGroupOfFolds)
+		self.indices = [[((index + folding) % (self.leavesTotal+1), (-2-index + folding) % (self.leavesTotal+1)) for index in range(self.leavesTotal//2)] for folding in range(self.leavesTotal + 1)]
 
 		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
@@ -398,6 +448,7 @@ class MatrixMeandersState:
 	"""The index of the meanders problem being solved."""
 	oeisID: str
 	"""'A000682', semi-meanders, or 'A005316', meanders."""
+
 	boundary: int
 	"""The algorithm analyzes `n` boundaries starting at `boundary = n - 1`."""
 	dictionaryMeanders: dict[int, int]
@@ -408,14 +459,19 @@ class MatrixMeandersState:
 	bitWidth: int = 0
 	"""At the start of an iteration enumerated by `boundary`, the number of bits of the largest value `arcCode`. The
 	`dataclass` computes a `property` from `bitWidth`."""
-
-	@property
-	def MAXIMUMarcCode(self) -> int:
-		"""Compute the maximum value of `arcCode` for the current iteration of the transfer matrix."""
-		return 1 << (2 * self.boundary + 4)
-
-	@property
-	def locatorBits(self) -> int:
+	bitsLocator: int = 0
+	"""An odd-parity bit-mask with `bitWidth` bits."""
+	MAXIMUMarcCode: int = 0
+	"""The maximum value of `arcCode` for the current iteration of the transfer matrix."""
+
+	def reduceBoundary(self) -> None:
+		"""Prepare for the next iteration of the transfer matrix algorithm by reducing `boundary` by 1 and updating related fields."""
+		self.boundary -= 1
+		self.setBitWidth()
+		self.setBitsLocator()
+		self.setMAXIMUMarcCode()
+
+	def setBitsLocator(self) -> None:
 		"""Compute an odd-parity bit-mask with `bitWidth` bits.
 
 		Notes
@@ -429,60 +485,19 @@ class MatrixMeandersState:
 		odd numbers from even numbers, so I avoid using "odd" and "even" in the names of these bit-masks.
 
 		"""
-		return sum(1 << one for one in range(0, self.bitWidth, 2))
-
-@dataclasses.dataclass(slots=True)
-class MatrixMeandersNumPyState(MatrixMeandersState):
-	"""Hold the state of a meanders transfer matrix algorithm computation."""
-
-	arrayArcCodes: NDArray[numpy.uint64] = dataclasses.field(default_factory=lambda: numpy.empty((0,), dtype=numpy.uint64))
-	arrayCrossings: NDArray[numpy.uint64] = dataclasses.field(default_factory=lambda: numpy.empty((0,), dtype=numpy.uint64))
+		self.bitsLocator = sum(1 << one for one in range(0, self.bitWidth, 2))
 
-	bitWidthLimitArcCode: int | None = None
-	bitWidthLimitCrossings: int | None = None
+	def setBitWidth(self) -> None:
+		"""Set `bitWidth` from the current `dictionaryMeanders`."""
+		self.bitWidth = max(self.dictionaryMeanders.keys()).bit_length()
 
-	datatypeArcCode: TypeAlias = numpy.uint64  # noqa: UP040
-	"""The fixed-size integer type used to store `arcCode`."""
-	datatypeCrossings: TypeAlias = numpy.uint64  # noqa: UP040
-	"""The fixed-size integer type used to store `crossings`."""
-
-	indexTarget: int = 0
-	"""What is being indexed depends on the algorithm flavor."""
+	def setMAXIMUMarcCode(self) -> None:
+		"""Compute the maximum value of `arcCode` for the current iteration of the transfer matrix."""
+		self.MAXIMUMarcCode = 1 << (2 * self.boundary + 4)
 
 	def __post_init__(self) -> None:
 		"""Post init."""
-		if self.bitWidthLimitArcCode is None:
-			_bitWidthOfFixedSizeInteger: int = numpy.dtype(self.datatypeArcCode).itemsize * 8 # bits
-
-			_offsetNecessary: int = 3 # For example, `bitsZulu << 3`.
-			_offsetSafety: int = 1 # I don't have mathematical proof of how many extra bits I need.
-			_offset: int = _offsetNecessary + _offsetSafety
-
-			self.bitWidthLimitArcCode = _bitWidthOfFixedSizeInteger - _offset
-
-			del _bitWidthOfFixedSizeInteger, _offsetNecessary, _offsetSafety, _offset
-
-		if self.bitWidthLimitCrossings is None:
-			_bitWidthOfFixedSizeInteger: int = numpy.dtype(self.datatypeCrossings).itemsize * 8 # bits
-
-			_offsetNecessary: int = 0 # I don't know of any.
-			_offsetEstimation: int = 3 # See reference directory.
-			_offsetSafety: int = 1
-			_offset: int = _offsetNecessary + _offsetEstimation + _offsetSafety
-
-			self.bitWidthLimitCrossings = _bitWidthOfFixedSizeInteger - _offset
-
-			del _bitWidthOfFixedSizeInteger, _offsetNecessary, _offsetEstimation, _offsetSafety, _offset
-
-	def makeDictionary(self) -> None:
-		"""Convert from NumPy `ndarray` (*Num*erical *Py*thon *n-d*imensional array) to Python `dict` (*dict*ionary)."""
-		self.dictionaryMeanders = {int(key): int(value) for key, value in zip(self.arrayArcCodes, self.arrayCrossings, strict=True)}
-		self.arrayArcCodes = numpy.empty((0,), dtype=self.datatypeArcCode)
-		self.arrayCrossings = numpy.empty((0,), dtype=self.datatypeCrossings)
+		self.setBitWidth()
+		self.setBitsLocator()
+		self.setMAXIMUMarcCode()
 
-	def makeArray(self) -> None:
-		"""Convert from Python `dict` (*dict*ionary) to NumPy `ndarray` (*Num*erical *Py*thon *n-d*imensional array)."""
-		self.arrayArcCodes = numpy.array(list(self.dictionaryMeanders.keys()), dtype=self.datatypeArcCode)
-		self.arrayCrossings = numpy.array(list(self.dictionaryMeanders.values()), dtype=self.datatypeCrossings)
-		self.bitWidth = int(self.arrayArcCodes.max()).bit_length()
-		self.dictionaryMeanders = {}

mapFolding/reference/irvineJavaPort.py

@@ -1,5 +1,5 @@
-"""
-Ported from the Java version by Sean A. Irvine:
+"""Ported from the Java version by Sean A. Irvine.
+
 https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java
 
 This implementation is a Python version of a Java implementation of Lunnon's algorithm by Sean A. Irvine.
@@ -9,7 +9,7 @@ Key characteristics:
 - A procedural paradigm more similar to Lunnon and unlike Irvine's object-oriented implementation.
 - Only primitive Python data structures.
 
-Citation: https://github.com/hunterhogan/mapFolding/blob/134f2e6ecdf59fb6f6829c775475544a6aaaa800/citations/jOEIS.bibtex
+Citation: https://github.com/hunterhogan/mapFolding/blob/134f2e6ecdf59fb6f6829c775475544a6aaaa800/citations/jOEIS.bib
 """
 
 def foldings(p: list[int], res: int = 0, mod: int = 0) -> int:

mapFolding/reference/meandersDumpingGround/matrixMeandersNumPyV1finalForm.py

@@ -360,7 +360,7 @@ def doTheNeedful(n: int, dictionaryCurveLocations: dict[int, int]) -> int:
 	--------------
 
 	As first computed by Iwan Jensen in 2000, A000682(41) = 6664356253639465480.
-	Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bibtex
+	Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bib
 	See also https://oeis.org/A000682
 
 	I'm sure you instantly observed that A000682(41) = (6664356253639465480).bit_length() = 63 bits. And A005316(44) =

mapFolding/someAssemblyRequired/A007822/_asynchronousAnnex.py

@@ -34,7 +34,7 @@ def _threadDoesSomething() -> None:
 			break
 		state = _filterAsymmetricFolds(state)
 		with LOCKsymmetricFoldsTotal:
-			symmetricFoldsTotal += state.groupsOfFolds
+			symmetricFoldsTotal += state.symmetricFolds
 
 def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
 	"""Add real function during generation; the signature is here to preview its interactions with the module."""

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -1,10 +1,12 @@
 """addSymmetryCheckAsynchronous."""
-from astToolkit import Be, Grab, identifierDotAttribute, LedgerOfImports, Make, NodeChanger, NodeTourist, Then
+from astToolkit import Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then
+from astToolkit.containers import LedgerOfImports
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import defaultA007822, IfThis
 from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import ExprCallFilterAsymmetricFoldsState
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
@@ -85,7 +87,7 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, i
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -1,6 +1,8 @@
 """addSymmetryCheck."""
 from astToolkit import (
-	Be, Grab, identifierDotAttribute, LedgerOfImports, NodeChanger, NodeTourist, parsePathFilename2astModule, Then)
+	Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then)
+from astToolkit.containers import LedgerOfImports
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import default, defaultA007822, IfThis
@@ -8,7 +10,7 @@ from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
 	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds)
 from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
 from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
@@ -43,7 +45,21 @@ def addSymmetryCheck(astModule: ast.Module, identifierModule: str, identifierCal
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
+
+	return pathFilename
+
+def _numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	pathFilename: PurePath = numbaOnTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
+	astModule = parsePathFilename2astModule(pathFilename)
+
+	NodeChanger(Be.AnnAssign.valueIs(IfThis.isAttributeNamespaceIdentifier(defaultA007822['variable']['stateInstance'], 'indices'))
+			, lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(Make.Name('List'), [raiseIfNone(node.value)])))(node)
+		).visit(astModule)
+
+	astModule.body.insert(0, Make.ImportFrom('numba.typed', [Make.alias('List')]))
+
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
@@ -55,18 +71,18 @@ def makeA007822Modules() -> None:
 
 	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
 	makeInitializeState(astModule, defaultA007822['module']['initializeState']
-		, defaultA007822['function']['initializeState'], defaultA007822['logicalPath']['synthetic'], None)
+		, defaultA007822['function']['initializeState'], defaultA007822['logicalPath']['synthetic'], None, identifiers=defaultA007822)
 
 	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
 	pathFilename = makeTheorem2(astModule, 'theorem2', defaultA007822['function']['counting']
-		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'], identifiers=defaultA007822)
 
 	astModule = parsePathFilename2astModule(pathFilename)
 	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', defaultA007822['function']['counting']
 		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', defaultA007822['function']['counting']
+	pathFilename = _numbaOnTheorem2(astModule, 'theorem2Numba', defaultA007822['function']['counting']
 		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 if __name__ == '__main__':