mapFolding 0.16.1__tar.gz → 0.16.4__tar.gz

{mapfolding-0.16.1/mapFolding.egg-info → mapfolding-0.16.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.16.1
+Version: 0.16.4
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -40,7 +40,10 @@ Requires-Dist: hunterMakesPy
 Requires-Dist: isort
 Requires-Dist: numpy
 Requires-Dist: platformdirs
+Requires-Dist: sympy
 Provides-Extra: development
+Requires-Dist: ipykernel; extra == "development"
+Requires-Dist: ipywidgets; extra == "development"
 Requires-Dist: memray; sys_platform == "linux" and extra == "development"
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

{mapfolding-0.16.1 → mapfolding-0.16.4}/easyRun/A000682.py

@@ -21,5 +21,5 @@ if __name__ == "__main__":
 
 r"""
 deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
-title running && py Z0Z_A000682.py && title I'm done || title Error
+title running && start "running" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\A000682.py && title I'm done || title Error
 """

{mapfolding-0.16.1 → mapfolding-0.16.4}/easyRun/A005316.py

@@ -1,12 +1,12 @@
 # ruff: noqa
 # pyright: basic
-from mapFolding.basecamp import A005316
+from mapFolding.basecamp import NOTcountingFolds
 import warnings
 
 warnings.filterwarnings("ignore", category=FutureWarning)
 
 n=25
-print(A005316(n))
+print(NOTcountingFolds('A005316', n))
 
 from mapFolding import dictionaryOEIS
 
@@ -16,6 +16,5 @@ if n < dictionaryOEIS['A005316']['valueUnknown']:
 
 r"""
 deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
-title running && py Z0Z_A005316.py && title I'm done || title Error
 
 """

{mapfolding-0.16.1 → mapfolding-0.16.4}/easyRun/NOTcountingFolds.py

@@ -15,20 +15,21 @@ if __name__ == '__main__':
 			"\033[0m\n"
 		)
 
-	CPUlimit: bool | float | int | None = -2
+	CPUlimit: bool | float | int | None = 3
 	# oeisID: str | None = None
 	oeis_n: int | None = None
 	flow: str | None = None
 
+	oeisID = 'A001010'
 	oeisID = 'A007822'
 
-	flow = 'asynchronousTrimmed'
-	flow = 'asynchronous'
-	flow = 'asynchronousNumba'
 	flow = 'algorithm'
+	flow = 'asynchronous'
 	flow = 'theorem2Numba'
+	flow = 'theorem2Trimmed'
 
-	for n in range(5,11):
+	# for n in range(7,10):
+	for n in range(3,8):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)

{mapfolding-0.16.1 → mapfolding-0.16.4}/easyRun/countFolds.py

@@ -25,7 +25,7 @@ if __name__ == '__main__':
 	# mapShape: tuple[int, ...] | None = None
 	flow: str | None = 'theorem2Numba'
 
-	oeisID: str = 'A001415'
+	oeisID: str = 'A001416'
 	for n in range(3,8):
 
 		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)

mapfolding-0.16.4/easyRun/generateAllModules.py

@@ -0,0 +1,14 @@
+"""Generate all modules that require some assembly."""
+from mapFolding.someAssemblyRequired.A007822.makeA007822AsynchronousModules import makeA007822AsynchronousModules
+from mapFolding.someAssemblyRequired.A007822.makeA007822Modules import makeA007822Modules
+from mapFolding.someAssemblyRequired.mapFoldingModules.makeMapFoldingModules import makeMapFoldingModules
+from mapFolding.someAssemblyRequired.meanders.makeMeandersModules import makeMeandersModules
+
+# TODO from mapFolding.zCuzDocStoopid import makeDocstrings
+
+makeMapFoldingModules()
+
+makeA007822Modules()
+makeA007822AsynchronousModules()
+
+makeMeandersModules()

{mapfolding-0.16.1 → mapfolding-0.16.4}/easyRun/meanders.py

@@ -24,8 +24,8 @@ if __name__ == '__main__':
 	if sys.version_info >= (3, 14):
 		warnings.filterwarnings("ignore", category=FutureWarning)
 
-	flow = 'matrixPandas'
 	flow = 'matrixMeanders'
+	flow = 'matrixPandas'
 	flow = 'matrixNumPy'
 
 	for oeisID in [
@@ -35,27 +35,25 @@ if __name__ == '__main__':
 		sys.stdout.write(f"\n{oeisID}\n")
 
 		"""TODO Identifiers. improve
-		kOfMatrix: I don't think the paper uses 'k'. step?
+		"generate up to four targets."
+		1. Adding a new loop.
+		2. Dragging up a loop end.
+		3. Dragging down a loop end.
+		4. Connect ends across the line.
 
-		ReidemeisterMove?
 		flipTheExtra_0b1AsUfunc: what is extra?
-
-		"strand" is an interesting word.
 		"""
 
-		# for n in range(44,45):
-
-		# for n in range(43,56):
-		# for n in range(46,47):
-		# for n in range(43,47):
-		# for n in range(38,43):
-		# for n in range(28,38):
-		# for n in [*range(2, 10), *range(28,33)]:
-		# for n in range(28,33):
-		# for n in range(2, 28):
-		# for n in range(2, 10):
-		for n in range(1, 6):
+		nList: list[int] = []
+		nList.extend(range(2, 10))
+		# nList.extend(range(2, 28))
+		nList.extend(range(28,33))
+		# nList.extend(range(33,38))
+		# nList.extend(range(38,43))
+		# nList.extend(range(43,45))
+		# nList.extend(range(47,57))
 
+		for n in nList:
 			gc.collect()
 			timeStart = time.perf_counter()
 			countTotal = NOTcountingFolds(oeisID, n, flow)
@@ -66,6 +64,6 @@ if __name__ == '__main__':
 
 r"""
 deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
-title running && py Z0Z_aOFn.py && title I'm done || title Error
+title running && start "meanders" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\meanders.py && title I'm done || title Error
 
 """

{mapfolding-0.16.1 → mapfolding-0.16.4}/mapFolding/__init__.py

@@ -4,6 +4,7 @@ from mapFolding._theTypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
+    Array2DLeavesTotal as Array2DLeavesTotal,
 	Array3DLeavesTotal as Array3DLeavesTotal,
     axisOfLength as axisOfLength,
 	DatatypeElephino as DatatypeElephino,

{mapfolding-0.16.1 → mapfolding-0.16.4}/mapFolding/_theSSOT.py

@@ -43,7 +43,7 @@ class mapFoldingPackageSettings(PackageSettings):
 	concurrencyPackage: str = 'multiprocessing'
 	"""Package identifier for concurrent execution operations."""
 # ruff: noqa: S311
-# TODO I made a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
+# TODO I made this a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
 OEISidMapFoldingManuallySet: dict[str, MetadataOEISidMapFoldingManuallySet] = {
 	'A000136': {
 		'getMapShape': lambda n: (1, n),
@@ -89,7 +89,6 @@ identifierPackageFALLBACK = "mapFolding"
 packageSettings = mapFoldingPackageSettings(identifierPackageFALLBACK=identifierPackageFALLBACK, OEISidMapFoldingManuallySet=OEISidMapFoldingManuallySet)
 """Global package settings."""
 
-"""Local directory path for storing cached OEIS sequence data and metadata."""
 OEISidManuallySet: dict[str, MetadataOEISidManuallySet] = {
 	'A000560': {'valuesTestValidation': [random.randint(3, 12)]},
 	'A000682': {'valuesTestValidation': [random.randint(3, 12), 32]},
@@ -101,6 +100,7 @@ OEISidManuallySet: dict[str, MetadataOEISidManuallySet] = {
 	'A060206': {'valuesTestValidation': [random.randint(3, 9)]},
 	'A077460': {'valuesTestValidation': [3, 4, random.randint(5, 8)]},
 	'A078591': {'valuesTestValidation': [random.randint(3, 10)]},
+	'A086345': {'valuesTestValidation': [random.randint(3, 10), random.randint(11, 20), random.randint(21, 30), random.randint(31, 40)]},
 	'A178961': {'valuesTestValidation': [random.randint(3, 11)]},
 	'A223094': {'valuesTestValidation': [random.randint(3, 11)]},
 	'A259702': {'valuesTestValidation': [random.randint(3, 13)]},
@@ -117,3 +117,4 @@ packageSettings = mapFoldingPackageSettings(
 
 # TODO integrate into packageSettings
 pathCache: Path = packageSettings.pathPackage / ".cache"
+"""Local directory path for storing cached OEIS sequence data and metadata."""

{mapfolding-0.16.1 → mapfolding-0.16.4}/mapFolding/_theTypes.py

@@ -44,6 +44,9 @@ different data structure."""
 Array3DLeavesTotal: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """A `numpy.ndarray` with three axes and elements of type `NumPyLeavesTotal`."""
 
+Array2DLeavesTotal: TypeAlias = ndarray[tuple[int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""A `numpy.ndarray` with two axes and elements of type `NumPyLeavesTotal`."""
+
 Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """A `numpy.ndarray` with one axis and elements of type `NumPyLeavesTotal`."""
 

mapfolding-0.16.4/mapFolding/algorithms/A086345.py

@@ -0,0 +1,75 @@
+"""Directly based on code Chai Wah Wu, https://oeis.org/wiki/User:Chai_Wah_Wu, posted on OEIS."""
+from fractions import Fraction
+from functools import cache
+from itertools import combinations
+from math import factorial, gcd
+from sympy import divisors
+from sympy.functions.combinatorial.numbers import mobius
+from sympy.utilities.iterables import partitions
+
+@cache
+def _GoCountryDancing(romeo: int, copiesRomeo: int, sierra: int, copiesSierra: int) -> int:
+	return copiesRomeo * copiesSierra * gcd(romeo, sierra)
+
+@cache
+def _goRight(integer: int, copies: int) -> int:
+	return ((integer - 1) >> 1) * copies + (integer * copies * (copies - 1) >> 1)
+
+@cache
+def _deFactorial(integer: int, copies: int) -> int:
+	return integer ** copies * factorial(copies)
+
+@cache
+def _blender(n: int) -> int:
+	sumReBletionary: int = 0
+	for partitionary in partitions(n):
+		numbinations: int = 0
+		nummaNumma: int = 0
+		denominator: int = 1
+		for (romeo, copiesRomeo), (sierra, copiesSierra) in combinations(partitionary.items(), 2):
+			numbinations += _GoCountryDancing(romeo, copiesRomeo, sierra, copiesSierra)
+		for integer, copies in partitionary.items():
+			nummaNumma += _goRight(integer, copies)
+			denominator *= _deFactorial(integer, copies)
+		numerator: int = 3 ** (numbinations + nummaNumma)
+		sumReBletionary += Fraction(numerator, denominator)
+	return sumReBletionary
+
+@cache
+def _recurser(n: int) -> int:
+	sumReBlender: int = 0
+	for k in range(1, n):
+		sumReBlender += _recurser(k) * _blender(n - k)
+	return n * _blender(n) - sumReBlender
+
+def A086345(n: int) -> int:
+	"""Compute 'Number of connected oriented graphs (i.e., connected directed graphs with no bidirected edges) on n nodes'.
+
+	Parameters
+	----------
+	n : int
+		Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+	Returns
+	-------
+	a(n) : int
+		Number of connected oriented graphs (i.e., connected directed graphs with no bidirected edges) on n nodes.
+
+	Notes
+	-----
+	- The largest performance gains are from caching the recursion and `sympy.utilities.iterables.partitions` functions.
+	- Interestingly, there is a small but noticeable penalty for choosing comprehension instead of `for`.
+
+	Would You Like to Know More?
+	----------------------------
+	OEIS : webpage
+		https://oeis.org/A086345
+	"""
+	if n == 0:
+		aOFn: int = 1
+	else:
+		aOFn: int = 0
+		for aDivisor in divisors(n, generator=True):
+			aOFn += mobius(aDivisor) * _recurser(n//aDivisor)
+		aOFn //= n
+	return aOFn

{mapfolding-0.16.1 → mapfolding-0.16.4}/mapFolding/algorithms/matrixMeanders.py

@@ -1,23 +1,6 @@
 from mapFolding.algorithms.matrixMeandersBeDry import walkDyckPath
 from mapFolding.dataBaskets import MatrixMeandersState
 
-def outfitDictionaryBitGroups(state: MatrixMeandersState) -> dict[tuple[int, int], int]:
-    """Outfit `dictionaryBitGroups` so it may manage the computations for one iteration of the transfer matrix.
-
-    Parameters
-    ----------
-    state : MatrixMeandersState
-        The current state of the computation, including `dictionaryMeanders`.
-
-    Returns
-    -------
-    dictionaryBitGroups : dict[tuple[int, int], int]
-        A dictionary of `(bitsAlpha, bitsZulu)` to `crossings`.
-    """
-    state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
-    return {(arcCode & state.locatorBits, (arcCode >> 1) & state.locatorBits): crossings
-        for arcCode, crossings in state.dictionaryMeanders.items()}
-
 def count(state: MatrixMeandersState) -> MatrixMeandersState:
     """Count meanders with matrix transfer algorithm using Python `int` (*int*eger) contained in a Python `dict` (*dict*ionary).
 
@@ -31,18 +14,22 @@ def count(state: MatrixMeandersState) -> MatrixMeandersState:
     The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each index one at a time,
     compute each `arcCode` one at a time, and compute each type of analysis one at a time.
     """
-    dictionaryBitGroups: dict[tuple[int, int], int] = {}
+    dictionaryArcCodeToCrossings: dict[int, int] = {}
 
-    while state.kOfMatrix > 0:
-        state.kOfMatrix -= 1
+    while state.boundary > 0:
+        state.boundary -= 1
+        state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
 
-        dictionaryBitGroups = outfitDictionaryBitGroups(state)
+        dictionaryArcCodeToCrossings = state.dictionaryMeanders.copy()
         state.dictionaryMeanders = {}
 
-        for (bitsAlpha, bitsZulu), crossings in dictionaryBitGroups.items():
+        for arcCode, crossings in dictionaryArcCodeToCrossings.items():
+            bitsAlpha: int = arcCode & state.locatorBits
+            bitsZulu: int = (arcCode >> 1) & state.locatorBits
             bitsAlphaHasArcs: bool = bitsAlpha > 1
             bitsZuluHasArcs: bool = bitsZulu > 1
-            bitsAlphaIsEven = bitsZuluIsEven = 0
+            bitsAlphaIsEven: int = bitsAlpha & 1 ^ 1
+            bitsZuluIsEven: int = bitsZulu & 1 ^ 1
 
             arcCodeAnalysis = ((bitsAlpha | (bitsZulu << 1)) << 2) | 3
             # simple
@@ -50,27 +37,27 @@ def count(state: MatrixMeandersState) -> MatrixMeandersState:
                 state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
             if bitsAlphaHasArcs:
-                arcCodeAnalysis = (bitsAlpha >> 2) | (bitsZulu << 3) | ((bitsAlphaIsEven := 1 - (bitsAlpha & 1)) << 1)
+                arcCodeAnalysis = (bitsAlpha >> 2) | (bitsZulu << 3) | (bitsAlphaIsEven << 1)
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
             if bitsZuluHasArcs:
-                arcCodeAnalysis = (bitsZulu >> 1) | (bitsAlpha << 2) | (bitsZuluIsEven := 1 - (bitsZulu & 1))
+                arcCodeAnalysis = (bitsZulu >> 1) | (bitsAlpha << 2) | bitsZuluIsEven
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
             if bitsAlphaHasArcs and bitsZuluHasArcs and (bitsAlphaIsEven or bitsZuluIsEven):
                 # aligned
                 if bitsAlphaIsEven and not bitsZuluIsEven:
-                    bitsAlpha ^= walkDyckPath(bitsAlpha)  # noqa: PLW2901
+                    bitsAlpha ^= walkDyckPath(bitsAlpha)
                 elif bitsZuluIsEven and not bitsAlphaIsEven:
-                    bitsZulu ^= walkDyckPath(bitsZulu)  # noqa: PLW2901
+                    bitsZulu ^= walkDyckPath(bitsZulu)
 
                 arcCodeAnalysis: int = ((bitsZulu >> 2) << 1) | (bitsAlpha >> 2)
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
-        dictionaryBitGroups = {}
+        dictionaryArcCodeToCrossings = {}
 
     return state
 

{mapfolding-0.16.1 → mapfolding-0.16.4}/mapFolding/algorithms/matrixMeandersBeDry.py

@@ -2,12 +2,8 @@
 from functools import cache
 from hunterMakesPy import raiseIfNone
 from mapFolding.dataBaskets import MatrixMeandersNumPyState
-from mapFolding.reference.A000682facts import A000682_n_k_buckets
-from mapFolding.reference.A005316facts import (
-	A005316_n_k_buckets, bucketsIf_k_EVEN_by_nLess_k, bucketsIf_k_ODD_by_nLess_k)
-from math import exp, log
-from typing import Any, NamedTuple
-import math
+from mapFolding.reference.A000682facts import A000682_n_boundary_buckets
+from mapFolding.reference.A005316facts import A005316_n_boundary_buckets
 import numpy
 import pandas
 
@@ -22,14 +18,7 @@ import pandas
 - Convert duplicate code to procedures.
 """
 
-class ImaKey(NamedTuple):
-	"""keys for dictionaries."""
-
-	oeisID: str
-	kIsOdd: bool
-	nLess_kIsOdd: bool
-
-def areIntegersWide(state: MatrixMeandersNumPyState, *, dataframe: pandas.DataFrame | None = None, array: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]] | None = None, fixedSizeMAXIMUMarcCode: bool = False) -> bool:
+def areIntegersWide(state: MatrixMeandersNumPyState, *, dataframe: pandas.DataFrame | None = None, fixedSizeMAXIMUMarcCode: bool = False) -> bool:
 	"""Check if the largest values are wider than the maximum limits.
 
 	Parameters
@@ -58,19 +47,16 @@ def areIntegersWide(state: MatrixMeandersNumPyState, *, dataframe: pandas.DataFr
 
 	If you start with small values in `dictionaryMeanders`, however, then the flow goes to the function with fixed size
 	integers and usually stays there until `crossings` is huge, which is near the end of the computation. If you cast
-	`MAXIMUMarcCode` into a 64-bit unsigned integer, however, then around `state.kOfMatrix == 28`, the bit width of
+	`MAXIMUMarcCode` into a 64-bit unsigned integer, however, then around `state.boundary == 28`, the bit width of
 	`MAXIMUMarcCode` might exceed the limit. That will cause the flow to go to the function that does not have fixed size
 	integers for a few iterations before returning to the function with fixed size integers.
 	"""
 	if dataframe is not None:
 		arcCodeWidest = int(dataframe['analyzed'].max()).bit_length()
 		crossingsWidest = int(dataframe['crossings'].max()).bit_length()
-	elif array is not None:
-		arcCodeWidest = int(array[state.slicerArcCode].max()).bit_length()
-		crossingsWidest = int(array[state.slicerCrossings].max()).bit_length()
 	elif not state.dictionaryMeanders:
-		arcCodeWidest = int(state.arrayMeanders[state.slicerArcCode].max()).bit_length()
-		crossingsWidest = int(state.arrayMeanders[state.slicerCrossings].max()).bit_length()
+		arcCodeWidest = int(state.arrayArcCodes.max()).bit_length()
+		crossingsWidest = int(state.arrayCrossings.max()).bit_length()
 	else:
 		arcCodeWidest: int = max(state.dictionaryMeanders.keys()).bit_length()
 		crossingsWidest: int = max(state.dictionaryMeanders.values()).bit_length()
@@ -106,8 +92,14 @@ arrayFlipped : numpy.ndarray[tuple[int], numpy.dtype[numpy.unsignedinteger[Any]]
 	An array with the same shape as `arrayTarget` but with one bit flipped in each element.
 """
 
-def getBucketsTotal(state: MatrixMeandersNumPyState, safetyMultiplicand: float = 1.2) -> int:
-	"""Estimate the total number of non-unique arcCode that will be computed from the existing arcCode.
+def getBucketsTotal(state: MatrixMeandersNumPyState, safetyMultiplicand: float = 1.2) -> int:  # noqa: ARG001
+	"""Under renovation: Estimate the total number of non-unique arcCode that will be computed from the existing arcCode.
+
+	Warning
+	-------
+	Because `matrixMeandersPandas` does not store anything in `state.arrayArcCodes`, if `matrixMeandersPandas` requests
+	bucketsTotal for a value not in the dictionary, the returned value will be 0. But `matrixMeandersPandas` should have a safety
+	check that will allocate more space.
 
 	Notes
 	-----
@@ -117,7 +109,7 @@ def getBucketsTotal(state: MatrixMeandersNumPyState, safetyMultiplicand: float =
 		- The starting quantity of `arcCode`.
 		- The value(s) of the starting `arcCode`.
 		- n
-		- k
+		- boundary
 		- Whether this bucketsTotal is increasing, as compared to all of the prior bucketsTotal.
 		- If increasing, is it exponential or logarithmic?
 		- The maximum value.
@@ -126,104 +118,29 @@ def getBucketsTotal(state: MatrixMeandersNumPyState, safetyMultiplicand: float =
 
 	Figure out an intelligent flow for so many factors.
 	"""
-	theDictionary: dict[str, dict[int, dict[int, int]]] = {'A005316': A005316_n_k_buckets, 'A000682': A000682_n_k_buckets}
-	bucketsTotal: int = theDictionary.get(state.oeisID, {}).get(state.n, {}).get(state.kOfMatrix, -8)
-	if bucketsTotal > 0:
-		return bucketsTotal
-
-	dictionaryExponentialCoefficients: dict[ImaKey, float] = {
-		(ImaKey(oeisID='', kIsOdd=False, nLess_kIsOdd=True)): 0.834,
-		(ImaKey(oeisID='', kIsOdd=False, nLess_kIsOdd=False)): 1.5803,
-		(ImaKey(oeisID='', kIsOdd=True, nLess_kIsOdd=True)): 1.556,
-		(ImaKey(oeisID='', kIsOdd=True, nLess_kIsOdd=False)): 1.8047,
-	}
-
-	logarithmicOffsets: dict[ImaKey, float] ={
-		(ImaKey('A000682', kIsOdd=False, nLess_kIsOdd=False)): 0.0,
-
-		(ImaKey('A000682', kIsOdd=False, nLess_kIsOdd=True)): -0.07302547148212568,
-		(ImaKey('A000682', kIsOdd=True, nLess_kIsOdd=False)): -0.00595307513938792,
-		(ImaKey('A000682', kIsOdd=True, nLess_kIsOdd=True)): -0.012201222865243722,
-		(ImaKey('A005316', kIsOdd=False, nLess_kIsOdd=False)): -0.6392728422078733,
-		(ImaKey('A005316', kIsOdd=False, nLess_kIsOdd=True)): -0.6904925299923548,
-		(ImaKey('A005316', kIsOdd=True, nLess_kIsOdd=False)): 0.0,
-		(ImaKey('A005316', kIsOdd=True, nLess_kIsOdd=True)): 0.0,
-	}
+	theDictionary: dict[str, dict[int, dict[int, int]]] = {'A005316': A005316_n_boundary_buckets, 'A000682': A000682_n_boundary_buckets}
+	bucketsTotal: int = theDictionary.get(state.oeisID, {}).get(state.n, {}).get(state.boundary, 0)
+	if bucketsTotal <= 0:
+		bucketsTotal = int(3.55 * len(state.arrayArcCodes))
 
-	logarithmicParameters: dict[str, float] = {
-		'intercept': -166.1750299793178,
-		'log(n)': 1259.0051001675547,
-		'log(k)': -396.4306071056408,
-		'log(nLess_k)': -854.3309503739766,
-		'k/n': 716.530410654819,
-		'(k/n)^2': -2527.035113444166,
-		'normalized k': -882.7054406339189,
-	}
-
-	bucketsTotalMaximumBy_kOfMatrix: 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}
-
-	xCommon = 1.57
-
-	nLess_k: int = state.n - state.kOfMatrix
-	kIsOdd: bool = bool(state.kOfMatrix & 1)
-	nLess_kIsOdd: bool = bool(nLess_k & 1)
-	kIsEven: bool = not kIsOdd
-
-	bucketsTotalAtMaximum: bool = state.kOfMatrix <= ((state.n - 1 - (state.kOfMatrix % 2)) // 3)
-	bucketsTotalGrowsExponentially: bool = state.kOfMatrix > nLess_k
-	bucketsTotalGrowsLogarithmically: bool = state.kOfMatrix > ((state.n - (state.n % 3)) // 3)
-
-	if bucketsTotalAtMaximum:
-		if state.kOfMatrix in bucketsTotalMaximumBy_kOfMatrix:
-			bucketsTotal = bucketsTotalMaximumBy_kOfMatrix[state.kOfMatrix]
-		else:
-			c = 0.95037
-			r = 3.3591258254
-			if kIsOdd:
-				c = 0.92444
-				r = 3.35776
-			bucketsTotal = int(c * r**state.kOfMatrix * safetyMultiplicand)
-
-	elif state.kOfMatrix <= max(bucketsTotalMaximumBy_kOfMatrix.keys()):
-		# If `kOfMatrix` is low, use maximum bucketsTotal. 1. Can't underestimate. 2. Skip computation that can underestimate.
-		# 3. The potential difference in memory use is relatively small.
-		bucketsTotal = bucketsTotalMaximumBy_kOfMatrix[state.kOfMatrix]
+	return bucketsTotal
 
-	elif bucketsTotalGrowsExponentially:
-		if (state.oeisID == 'A005316') and kIsOdd and (nLess_k in bucketsIf_k_ODD_by_nLess_k):
-			# If I already know bucketsTotal.
-			bucketsTotal = bucketsIf_k_ODD_by_nLess_k[nLess_k]
-		elif (state.oeisID == 'A005316') and kIsEven and (nLess_k in bucketsIf_k_EVEN_by_nLess_k):
-			# If I already know bucketsTotal.
-			bucketsTotal = bucketsIf_k_EVEN_by_nLess_k[nLess_k]
-		else: # I estimate bucketsTotal during exponential growth.
-			xInstant: int = math.ceil(nLess_k / 2)
-			A000682adjustStartingArcCode: float = 0.25
-			startingConditionsCoefficient: float = dictionaryExponentialCoefficients[ImaKey('', kIsOdd, nLess_kIsOdd)]
-			if kIsOdd and nLess_kIsOdd:
-				A000682adjustStartingArcCode = 0.0
-			if state.oeisID == 'A000682': # NOTE Net effect is between `*= n` and `*= n * 2.2` if n=46.
-				startingConditionsCoefficient *= state.n * (((state.n // 2) + 2) ** A000682adjustStartingArcCode)
-			bucketsTotal = int(startingConditionsCoefficient * math.exp(xCommon * xInstant))
+def getSignaturesTotal(state: MatrixMeandersNumPyState) -> int:
+	"""Get the total number of signatures for the current `n` and `boundary`.
 
-	elif bucketsTotalGrowsLogarithmically:
-		xPower: float = (0
-			+ logarithmicParameters['intercept']
-			+ logarithmicParameters['log(n)'] * log(state.n)
-			+ logarithmicParameters['log(k)'] * log(state.kOfMatrix)
-			+ logarithmicParameters['log(nLess_k)'] * log(nLess_k)
-			+ logarithmicParameters['k/n'] * (state.kOfMatrix / state.n)
-			+ logarithmicParameters['(k/n)^2'] * (state.kOfMatrix / state.n)**2
-			+ logarithmicParameters['normalized k'] * nLess_k / state.n
-			+ logarithmicOffsets[ImaKey(state.oeisID, kIsOdd, nLess_kIsOdd)]
-		)
+	Parameters
+	----------
+	state : MatrixMeandersState
+		The current state of the computation.
 
-		bucketsTotal = int(exp(xPower * safetyMultiplicand))
+	Returns
+	-------
+	signaturesTotal : int
+		The total number of signatures for the current `n` and `boundary`.
 
-	else:
-		message = "I shouldn't be here."
-		raise SystemError(message)
-	return bucketsTotal
+	"""
+	from mapFolding.reference.matrixMeandersAnalysis.signatures import signatures  # noqa: PLC0415
+	return signatures[state.oeisID].get(state.n, {}).get(state.boundary, int(3.55 * len(state.arrayArcCodes)))
 
 @cache
 def walkDyckPath(intWithExtra_0b1: int) -> int:
@@ -262,3 +179,4 @@ def walkDyckPath(intWithExtra_0b1: int) -> int:
 		if findTheExtra_0b1 < 0:
 			break
 	return flipExtra_0b1_Here
+