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

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
 """

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
 
 """

easyRun/NOTcountingFolds.py

@@ -22,13 +22,13 @@ if __name__ == '__main__':
 
 	oeisID = 'A007822'
 
-	flow = 'asynchronousTrimmed'
 	flow = 'asynchronous'
-	flow = 'asynchronousNumba'
 	flow = 'algorithm'
+	flow = 'asynchronousNumba'
 	flow = 'theorem2Numba'
+	flow = 'asynchronousTrimmed'
 
-	for n in range(5,11):
+	for n in range(3,9):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)

easyRun/meanders.py

@@ -24,38 +24,36 @@ 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 [
-			'A005316',
+			# 'A005316',
 			'A000682',
 				]:
 		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/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/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
+