mapFolding 0.16.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

mapFolding/dataBaskets.py

@@ -23,10 +23,7 @@ access patterns that enable efficient result persistence and retrieval.
 from mapFolding import (
 	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
 	getConnectionGraph, getLeavesTotal, makeDataContainer)
-from numpy.typing import NDArray
-from typing import TypeAlias
 import dataclasses
-import numpy
 
 @dataclasses.dataclass(slots=True)
 class MapFoldingState:
@@ -111,8 +108,6 @@ class MapFoldingState:
 	"""Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation."""
 	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
 	"""Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation."""
-	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."""
 
 	connectionGraph: Array3DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array3DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	"""Unchanging array representing connections between all leaves."""
@@ -126,7 +121,7 @@ class MapFoldingState:
 
 		Returns
 		-------
-		totalFoldings : DatatypeFoldsTotal
+		foldsTotal : DatatypeFoldsTotal
 			The complete count of distinct folding patterns achievable with the current map configuration.
 
 		"""
@@ -154,6 +149,123 @@ class MapFoldingState:
 		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+
+@dataclasses.dataclass(slots=True)
+class SymmetricFoldsState:
+	"""Core computational state for symmetric map folding algorithms.
+
+	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.
+	gap1ndex : DatatypeElephino = DatatypeElephino(0)
+		The current 1-indexed position of the 'gap' during computation: 1-indexed as opposed to 0-indexed.
+	gap1ndexCeiling : DatatypeElephino = DatatypeElephino(0)
+		The upper bound of `gap1ndex`.
+	indexDimension : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+		The current 0-indexed position of the dimension during computation.
+	indexLeaf : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+		The current 0-indexed position of a leaf in a loop during computation: not to be confused with `leaf1ndex`.
+	indexMiniGap : DatatypeElephino = DatatypeElephino(0)
+		The current 0-indexed position of a 'gap' in a loop during computation.
+	leaf1ndex : DatatypeLeavesTotal = DatatypeLeavesTotal(1)
+		The current 1-indexed position of the leaf during computation: 1-indexed as opposed to 0-indexed.
+	leafConnectee : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+		Target leaf for connection operations.
+	dimensionsUnconstrained : DatatypeLeavesTotal = None
+		Count of dimensions not subject to folding constraints.
+	countDimensionsGapped : Array1DLeavesTotal = None
+		Array tracking computed number of dimensions with gaps.
+	gapRangeStart : Array1DElephino = None
+		Array tracking computed starting positions of gap ranges.
+	gapsWhere : Array1DLeavesTotal = None
+		Array indicating locations of gaps in the folding pattern.
+	leafAbove : Array1DLeavesTotal = None
+		Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation.
+	leafBelow : Array1DLeavesTotal = None
+		Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation.
+	leafComparison : Array1DLeavesTotal = None
+		Array for finding symmetric folds.
+	connectionGraph : Array3DLeavesTotal
+		Unchanging array representing connections between all leaves.
+	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."""
+
+	symmetricFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	"""Current count of symmetric folds."""
+
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The current 1-indexed position of the 'gap' during computation: 1-indexed as opposed to 0-indexed."""
+	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The upper bound of `gap1ndex`."""
+	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""The current 0-indexed position of the dimension during computation."""
+	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""The current 0-indexed position of a leaf in a loop during computation: not to be confused with `leaf1ndex`."""
+	indexMiniGap: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The current 0-indexed position of a 'gap' in a loop during computation."""
+	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	"""The current 1-indexed position of the leaf during computation: 1-indexed as opposed to 0-indexed."""
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""Target leaf for connection operations."""
+
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Count of dimensions not subject to folding constraints."""
+
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking computed number of dimensions with gaps."""
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking computed starting positions of gap ranges."""
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array indicating locations of gaps in the folding pattern."""
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation."""
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation."""
+	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."""
+
+	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."""
+	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."""
+
+	def __post_init__(self) -> None:
+		"""Ensure all fields have a value.
+
+		Notes
+		-----
+		Arrays that are not explicitly provided (None) are automatically allocated with appropriate sizes based on the map
+		dimensions. `dimensionsTotal`, `leavesTotal`, and `connectionGraph` cannot be set: they are calculated.
+
+		"""
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+
+		leavesTotalAsInt = int(self.leavesTotal)
+		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
+
+		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
+		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafComparison is None: self.leafComparison = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafComparison'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 
 @dataclasses.dataclass
@@ -280,6 +392,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]
@@ -290,14 +403,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
@@ -311,60 +429,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/filesystemToolkit.py

@@ -56,12 +56,10 @@ def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
 
 def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None) -> Path:
-	"""Get a standardized path and filename for the computed `foldsTotal` value.
+	"""Get a standardized filename and create a configurable path to store the computed `foldsTotal` value.
 
-	(AI generated docstring)
-
-	This function resolves paths for storing computation results, handling different input types including directories,
-	absolute paths, or relative paths. It ensures that all parent directories exist in the resulting path.
+	To help reduce duplicate code and to increase predictability, this function creates a standardized filename, has a default but
+	configurable path, and creates the path.
 
 	Parameters
 	----------
@@ -78,10 +76,9 @@ def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal
 	Notes
 	-----
 	The function creates any necessary directories in the path if they don't exist.
-
 	"""
 	if pathLikeWriteFoldsTotal is None:
-		pathFilenameFoldsTotal = getPathRootJobDEFAULT() / getFilenameFoldsTotal(mapShape)
+		pathFilenameFoldsTotal: Path = getPathRootJobDEFAULT() / getFilenameFoldsTotal(mapShape)
 	else:
 		pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
 		if pathLikeSherpa.is_dir():
@@ -237,28 +234,3 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 	if foldsTotalRead != foldsTotal:
 		message = f"I wrote a test file to `{pathFilename = }` with contents of `{str(foldsTotal) = }`, but I read `{foldsTotalRead = }` from the file. Python says the values are not equal. Fix that now, so your computation doesn't get corrupted later. And be pro-social."
 		raise FileNotFoundError(message)
-
-def writeStringToHere(this: str, pathFilename: PathLike[str] | PurePath) -> None:
-	"""Write a string to a file, creating parent directories if needed.
-
-	(AI generated docstring)
-
-	This utility function provides a consistent interface for writing string content to files across the package. It
-	handles path creation and ensures proper string conversion.
-
-	Parameters
-	----------
-	this : str
-		The string content to write to the file.
-	pathFilename : PathLike[str] | PurePath
-		The target file path where the string should be written.
-
-	Notes
-	-----
-	This function creates all parent directories in the path if they don't exist, making it safe to use with newly
-	created directory structures.
-
-	"""
-	pathFilename = Path(pathFilename)
-	pathFilename.parent.mkdir(parents=True, exist_ok=True)
-	pathFilename.write_text(str(this))

mapFolding/oeis.py

@@ -306,12 +306,6 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""Retrieve the known total number of distinct folding patterns for a given map shape.
 
-	(AI generated docstring)
-
-	This function provides rapid access to precalculated folding totals from OEIS sequences without
-	requiring computation. It serves as a validation reference for algorithm results and enables
-	quick lookup of known values across all implemented sequences.
-
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
@@ -320,17 +314,16 @@ def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	Returns
 	-------
 	foldingsTotal : int
-		The known total number of distinct folding patterns for the given map shape,
-		or -1 if the map shape does not match any known values in the OEIS sequences.
+		The known total number of distinct folding patterns for the given map shape, or 0 if the map shape does not match any
+		known values in the OEIS sequences.
 
 	Notes
 	-----
-	The function uses a cached dictionary for efficient retrieval without repeatedly processing
-	OEIS data. Map shapes are matched exactly as provided without internal sorting or normalization.
+	Map shapes are matched exactly as provided without internal sorting or normalization.
 
 	"""
-	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
-	return lookupFoldsTotal.get(tuple(mapShape), -1)
+	lookupFoldsTotal: dict[tuple[int, ...], int] = makeDictionaryFoldsTotalKnown()
+	return lookupFoldsTotal.get(tuple(mapShape), 0)
 
 def _formatHelpText() -> str:
 	"""Format comprehensive help text for both command-line and interactive use.

mapFolding/reference/A086345Wu.py

@@ -0,0 +1,25 @@
+# ruff: noqa: ANN001, T201, D103, D100, ANN201, ANN202
+# pyright: standard
+from fractions import Fraction
+from functools import cache
+from itertools import combinations
+from math import factorial, gcd, prod
+from sympy import divisors
+from sympy.functions.combinatorial.numbers import mobius
+from sympy.utilities.iterables import partitions
+import time
+
+# NOTE Because `b` and `c` are inside `A086345` instead of peers, the run time is increased by a factor of 6.
+
+def A086345(n):
+	@cache
+	def b(n): return int(sum(Fraction(3**(sum(p[r]*p[s]*gcd(r, s) for r, s in combinations(p.keys(), 2))+sum((q-1>>1)*r+(q*r*(r-1)>>1) for q, r in p.items())), prod(q**r*factorial(r) for q, r in p.items())) for p in partitions(n))) # pyright: ignore[reportAttributeAccessIssue, reportOperatorIssue]
+	@cache
+	def c(n): return n*b(n)-sum(c(k)*b(n-k) for k in range(1, n))
+	return sum(mobius(d)*c(n//d) for d in divisors(n, generator=True))//n if n else 1 # Chai Wah Wu, Jul 15 2024
+
+if __name__ == "__main__":
+	timeStart = time.perf_counter()
+	for n in range(51):
+		print(n, A086345(n))
+	print(time.perf_counter() - timeStart)

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/matrixMeandersAnalysis/signatures.py

@@ -1,3 +1,6 @@
+"""buckets and signatures."""
+bucketsTotalMaximumBy_boundary: dict[int, int] = {1:3, 2:12, 3:40, 4:125, 5:392, 6:1254, 7:4087, 8:13623, 9:46181, 10:159137, 11:555469, 12:1961369, 13:6991893, 14:25134208}
+
 signatures: dict[str, dict[int, dict[int, int]]] = {'A000682': {2: {1: 1, 2: 3},
 3: {1: 1, 2: 3, 3: 3},
 4: {1: 1, 2: 3, 3: 4, 4: 4},

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/A007822rawMaterials.py

@@ -1,54 +1,19 @@
-from astToolkit import extractFunctionDef, identifierDotAttribute, Make  # noqa: D100
+from astToolkit import extractFunctionDef, Make  # noqa: D100
 from hunterMakesPy import raiseIfNone
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
-	identifierDataclassInstanceDEFAULT, logicalPathInfixDEFAULT)
+from mapFolding.someAssemblyRequired import defaultA007822
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule
 import ast
 
-identifierDataclass: str = identifierDataclassInstanceDEFAULT
-identifierCounting: str = identifierCountingDEFAULT
-logicalPathInfixA007822: identifierDotAttribute = logicalPathInfixDEFAULT + '.A007822'
-sourceCallableDispatcherA007822: str = identifierCallableSourceDispatcherDEFAULT
-sourceCallableIdentifierA007822: str = identifierCallableSourceDEFAULT
+FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(getModule(logicalPathInfix='algorithms', identifierModule='symmetricFolds'), defaultA007822['function']['filterAsymmetricFolds']))
 
-identifier_filterAsymmetricFolds = 'filterAsymmetricFolds'
-
-ImaString = f"""
-def {identifier_filterAsymmetricFolds}({identifierDataclass}: MapFoldingState) -> MapFoldingState:
-	{identifierDataclass}.indexLeaf = 0
-	leafConnectee = 0
-	while leafConnectee < {identifierDataclass}.leavesTotal + 1:
-		leafNumber = int({identifierDataclass}.leafBelow[{identifierDataclass}.indexLeaf])
-		{identifierDataclass}.leafComparison[leafConnectee] = (leafNumber - {identifierDataclass}.indexLeaf + {identifierDataclass}.leavesTotal) % {identifierDataclass}.leavesTotal
-		{identifierDataclass}.indexLeaf = leafNumber
-		leafConnectee += 1
-
-	indexInMiddle = {identifierDataclass}.leavesTotal // 2
-	{identifierDataclass}.indexMiniGap = 0
-	while {identifierDataclass}.indexMiniGap < {identifierDataclass}.leavesTotal + 1:
-		ImaSymmetricFold = True
-		leafConnectee = 0
-		while leafConnectee < indexInMiddle:
-			if {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + leafConnectee) % ({identifierDataclass}.leavesTotal + 1)] != {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + {identifierDataclass}.leavesTotal - 1 - leafConnectee) % ({identifierDataclass}.leavesTotal + 1)]:
-				ImaSymmetricFold = False
-				break
-			leafConnectee += 1
-		{identifierDataclass}.{identifierCounting} += ImaSymmetricFold
-		{identifierDataclass}.indexMiniGap += 1
-
-	return {identifierDataclass}
-"""  # noqa: E501
-
-FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds))
-del ImaString
-
-ImaString = f"{identifierDataclass} = {identifier_filterAsymmetricFolds}({identifierDataclass})"
+ImaString: str = f"{defaultA007822['variable']['stateInstance']} = {defaultA007822['function']['filterAsymmetricFolds']}({defaultA007822['variable']['stateInstance']})"
 A007822incrementCount = ast.parse(ImaString).body[0]
 del ImaString
 
-ImaString = f'{identifierDataclass}.{identifierCounting} = ({identifierDataclass}.{identifierCounting} + 1) // 2'
-A007822adjustFoldsTotal = ast.parse(ImaString).body[0]
+ImaString = f'{defaultA007822['variable']['stateInstance']}.{defaultA007822['variable']['counting']} = ({defaultA007822['variable']['stateInstance']}.{defaultA007822['variable']['counting']} + 1) // 2'
+A007822adjustFoldsTotal: ast.stmt = ast.parse(ImaString).body[0]
 del ImaString
 
-astExprCall_filterAsymmetricFoldsDataclass: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Attribute(Make.Name(identifierDataclass), 'leafBelow')]))
-astExprCall_filterAsymmetricFoldsLeafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Name('leafBelow')]))
+ExprCallFilterAsymmetricFolds_leafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Name('leafBelow')]))
+ExprCallFilterAsymmetricFoldsState: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Name(defaultA007822['variable']['stateInstance'])]))
+ExprCallFilterAsymmetricFoldsStateDot_leafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Attribute(Make.Name(defaultA007822['variable']['stateInstance']), 'leafBelow')]))

mapFolding/someAssemblyRequired/A007822/_asynchronousAnnex.py

@@ -0,0 +1,51 @@
+# NOTE The real module is generated from this incomplete module. Comments are not preserved.
+# ruff: noqa: PLW0603
+from copy import deepcopy
+from mapFolding import DatatypeFoldsTotal
+from mapFolding.dataBaskets import SymmetricFoldsState
+from queue import Queue
+from threading import Lock, Thread
+
+listThreads: list[Thread] = []
+queueFutures: Queue[SymmetricFoldsState] = Queue()
+symmetricFoldsTotal: int = 0
+LOCKsymmetricFoldsTotal = Lock()
+# TODO There isn't a better way to do this?
+STOPsignal = object()
+
+def initializeConcurrencyManager(maxWorkers: int, symmetricFolds: int=0) -> None:
+	global listThreads, symmetricFoldsTotal, queueFutures
+	listThreads = []
+	queueFutures = Queue()
+	symmetricFoldsTotal = symmetricFolds
+
+	indexThread = 0
+	while indexThread < maxWorkers:
+		thread = Thread(target=_threadDoesSomething, name=f"thread{indexThread}", daemon=True)
+		thread.start()
+		listThreads.append(thread)
+		indexThread += 1
+
+def _threadDoesSomething() -> None:
+	global symmetricFoldsTotal
+	while True:
+		state = queueFutures.get()
+		if state is STOPsignal:
+			break
+		state = _filterAsymmetricFolds(state)
+		with LOCKsymmetricFoldsTotal:
+			symmetricFoldsTotal += state.symmetricFolds
+
+def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+	"""Add real function during generation; the signature is here to preview its interactions with the module."""
+	return state
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
+	queueFutures.put_nowait(deepcopy(state))
+
+def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
+	for _thread in listThreads:
+		queueFutures.put(STOPsignal)  # pyright: ignore[reportArgumentType]
+	for thread in listThreads:
+		thread.join()
+	return symmetricFoldsTotal