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

mapFolding/algorithms/matrixMeandersPandas.py

@@ -5,37 +5,33 @@ from mapFolding.syntheticModules.meanders.bigInt import countBigInt
 from warnings import warn
 import pandas
 
-# TODO investigate adding another condition to `areIntegersWide`: while dict is faster than pandas, stay in bigInt.
-
-# ruff: noqa: B023
-
 def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 	"""Count meanders with matrix transfer algorithm using pandas DataFrame.
 
 	Parameters
 	----------
 	state : MatrixMeandersState
-		The algorithm state containing current `kOfMatrix`, `dictionaryMeanders`, and thresholds.
+		The algorithm state containing current `boundary`, `dictionaryMeanders`, and thresholds.
 
 	Returns
 	-------
 	state : MatrixMeandersState
-		Updated state with new `kOfMatrix` and `dictionaryMeanders`.
+		Updated state with new `boundary` and `dictionaryMeanders`.
 	"""
 	dataframeAnalyzed = pandas.DataFrame({
 		'analyzed': pandas.Series(name='analyzed', data=state.dictionaryMeanders.keys(), copy=False, dtype=state.datatypeArcCode)
 		, 'crossings': pandas.Series(name='crossings', data=state.dictionaryMeanders.values(), copy=False, dtype=state.datatypeCrossings)
-		}, dtype=state.datatypeArcCode
+		}
 	)
 	state.dictionaryMeanders.clear()
 
-	while (state.kOfMatrix > 0 and not areIntegersWide(state, dataframe=dataframeAnalyzed)):
+	while (state.boundary > 0 and not areIntegersWide(state, dataframe=dataframeAnalyzed)):
 
 		def aggregateArcCodes()  -> None:
 			nonlocal dataframeAnalyzed
 			dataframeAnalyzed = dataframeAnalyzed.iloc[0:state.indexTarget].groupby('analyzed', sort=False)['crossings'].aggregate('sum').reset_index()
 
-		def analyzeArcCodesAligned() -> None:
+		def analyzeArcCodesAligned(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
 			"""Compute `arcCode` from `bitsAlpha` and `bitsZulu` if at least one is an even number.
 
 			Before computing `arcCode`, some values of `bitsAlpha` and `bitsZulu` are modified.
@@ -51,84 +47,105 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 				arcCode = (bitsAlpha >> 2) | ((bitsZulu >> 2) << 1)
 			```
 			"""
-			nonlocal dataframeMeanders
-
 			# NOTE Step 1 drop unqualified rows
+# ======= > * > bitsAlpha 1 bitsZulu 1 ====================
+			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode'].copy()			# `bitsAlpha`
+			dataframeMeanders['analyzed'] &= state.locatorBits							# `bitsAlpha`
 
-			bitsTarget: pandas.Series = dataframeMeanders['arcCode'].copy() # `bitsAlpha`
-			bitsTarget &= state.locatorBits # `bitsAlpha`
+			dataframeMeanders['analyzed'] = dataframeMeanders['analyzed'].gt(1)			# if bitsAlphaHasArcs
 
-			dataframeMeanders = dataframeMeanders.loc[(bitsTarget > 1)] # if bitsAlphaHasCurves
+			bitsTarget: pandas.Series = dataframeMeanders['arcCode'].copy()				# `bitsZulu`
+			bitsTarget //= 2**1 														# `bitsZulu` (bitsZulu >> 1)
+			bitsTarget &= state.locatorBits 											# `bitsZulu`
 
+			dataframeMeanders['analyzed'] *= bitsTarget
 			del bitsTarget
+			dataframeMeanders = dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 1)] 	# if (bitsAlphaHasArcs and bitsZuluHasArcs)
 
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsZulu`
-			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			bitsTarget &= state.locatorBits # `bitsZulu`
+# ======= ^ & & bitsAlpha 1 bitsZulu 1 ====================
+			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'].copy()	# `bitsAlpha`
+			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits					# `bitsAlpha`
+
+			dataframeMeanders.loc[:, 'analyzed'] &= 1									# `bitsAlpha`
 
-			dataframeMeanders = dataframeMeanders.loc[(bitsTarget > 1)] # if bitsZuluHasCurves
+			bitsTarget: pandas.Series = dataframeMeanders['arcCode'].copy()				# `bitsZulu`
+			bitsTarget //= 2**1															# `bitsZulu` (bitsZulu >> 1)
+			bitsTarget &= state.locatorBits 											# `bitsZulu`
 
+			dataframeMeanders.loc[:, 'analyzed'] &= bitsTarget
 			del bitsTarget
+			dataframeMeanders.loc[:, 'analyzed'] ^= 1
 
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsZulu`
-			bitsTarget &= 0b10 # `bitsZulu`
-			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			bitsTarget &= 1 # (bitsZulu & 1)
-			bitsTarget ^= 1 # (1 - (bitsZulu ...))
-			dataframeMeanders.loc[:, 'analyzed'] = bitsTarget # selectorBitsZuluAtEven
+			dataframeMeanders = dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 0)] 	# if (bitsAlphaIsEven or bitsZuluIsEven)
 
-			del bitsTarget
+			# NOTE Step 2 modify rows
+			# Make a selector for bitsZuluAtOdd, so you can modify bitsAlpha
+			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'].copy()	# `bitsZulu`
+			dataframeMeanders.loc[:, 'analyzed'] //= 2**1								# `bitsZulu` (bitsZulu >> 1)
+			dataframeMeanders.loc[:, 'analyzed'] &= 1									# selectorBitsZuluAtOdd
 
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsAlpha`
-			bitsTarget &= 1 # (bitsAlpha & 1)
-			bitsTarget ^= 1 # (1 - (bitsAlpha ...))
-			bitsTarget = bitsTarget.astype(bool) # selectorBitsAlphaAtODD
+			bitsTarget = dataframeMeanders['arcCode'].copy()							# `bitsAlpha`
+			bitsTarget &= state.locatorBits												# `bitsAlpha`
 
-			dataframeMeanders = dataframeMeanders.loc[(bitsTarget) | (dataframeMeanders.loc[:, 'analyzed'])] # if (bitsAlphaIsEven or bitsZuluIsEven)
+			# if bitsAlphaAtEven and not bitsZuluAtEven, modify bitsAlphaPairedToOdd
+			bitsTarget.loc[(dataframeMeanders['analyzed'] > 0)] = state.datatypeArcCode(
+				flipTheExtra_0b1AsUfunc(bitsTarget.loc[(dataframeMeanders['analyzed'] > 0)]))
 
-			del bitsTarget
+			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'].copy()	# `bitsZulu`
+			dataframeMeanders.loc[:, 'analyzed'] //= 2**1								# `bitsZulu` (bitsZulu >> 1)
+			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits					# `bitsZulu`
 
-			# NOTE Step 2 modify rows
+			# if bitsZuluAtEven and not bitsAlphaAtEven, modify bitsZuluPairedToOdd
+			dataframeMeanders.loc[((dataframeMeanders.loc[:, 'arcCode'] & 1) > 0), 'analyzed'] = state.datatypeArcCode(
+				flipTheExtra_0b1AsUfunc(dataframeMeanders.loc[((dataframeMeanders.loc[:, 'arcCode'] & 1) > 0), 'analyzed']))
 
-			# Make a selector for bitsZuluAtEven, so you can modify bitsAlpha
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsZulu`
-			bitsTarget &= 0b10 # `bitsZulu`
-			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			bitsTarget &= 1 # (bitsZulu & 1)
-			bitsTarget ^= 1 # (1 - (bitsZulu ...))
-			bitsTarget = bitsTarget.astype(bool) # selectorBitsZuluAtEven
+			# NOTE Step 3 compute arcCode
+# ======= >> | << >> bitsZulu 2 3 bitsAlpha 2 =============
+			dataframeMeanders.loc[:, 'analyzed'] //= 2**2 # (bitsZulu >> 2)
+			dataframeMeanders.loc[:, 'analyzed'] *= 2**3 # (bitsZulu << 3)
+			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget
+			del bitsTarget
+			dataframeMeanders.loc[:, 'analyzed'] //= 2**2 # (... >> 2)
 
-			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'] # `bitsAlpha`
-			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits # `bitsAlpha`
+			dataframeMeanders.loc[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
 
-			# if bitsAlphaIsEven and not bitsZuluIsEven, modify bitsAlphaPairedToOdd
-			dataframeMeanders.loc[(~bitsTarget), 'analyzed'] = state.datatypeArcCode( # pyright: ignore[reportCallIssue, reportArgumentType]
-				flipTheExtra_0b1AsUfunc(dataframeMeanders.loc[(~bitsTarget), 'analyzed']))
+			return dataframeMeanders
 
-			del bitsTarget
+		def analyzeArcCodesSimple(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
+			"""Compute arcCode with the 'simple' formula.
 
-			# if bitsZuluIsEven and not bitsAlphaIsEven, modify bitsZuluPairedToOdd
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsZulu`
-			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			bitsTarget &= state.locatorBits # `bitsZulu`
+			Formula
+			-------
+			```python
+			arcCode = ((bitsAlpha | (bitsZulu << 1)) << 2) | 3
+			```
 
-			bitsTarget.loc[(dataframeMeanders.loc[:, 'arcCode'] & 1).astype(bool)] = state.datatypeArcCode( # pyright: ignore[reportArgumentType, reportCallIssue]
-				flipTheExtra_0b1AsUfunc(bitsTarget.loc[(dataframeMeanders.loc[:, 'arcCode'] & 1).astype(bool)])) # pyright: ignore[reportCallIssue, reportUnknownArgumentType, reportArgumentType]
+			Notes
+			-----
+			Using `+= 3` instead of `|= 3` is valid in this specific case. Left shift by two means the last bits are '0b00'. '0 + 3'
+			is '0b11', and '0b00 | 0b11' is also '0b11'.
 
-			# NOTE Step 3 compute arcCode
+			"""
+			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode']
+			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits
 
-			dataframeMeanders.loc[:, 'analyzed'] //= 2**2 # (bitsAlpha >> 2)
+			bitsZulu: pandas.Series = dataframeMeanders['arcCode'].copy()
+			bitsZulu //= 2**1 # (bitsZulu >> 1)
+			bitsZulu &= state.locatorBits # `bitsZulu`
 
-			bitsTarget //= 2**2 # (bitsZulu >> 2)
-			bitsTarget *= 2**1 # ((bitsZulu ...) << 1)
+			bitsZulu *= 2**1 # (bitsZulu << 1)
 
-			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsZulu ...)
+			dataframeMeanders.loc[:, 'analyzed'] |= bitsZulu # ((bitsAlpha | (bitsZulu ...))
 
-			del bitsTarget
+			del bitsZulu
 
+			dataframeMeanders.loc[:, 'analyzed'] *= 2**2 # (... << 2)
+			dataframeMeanders.loc[:, 'analyzed'] += 3 # (...) | 3
 			dataframeMeanders.loc[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
 
-		def analyzeBitsAlpha() -> None:
+			return dataframeMeanders
+
+		def analyzeBitsAlpha(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
 			"""Compute `arcCode` from `bitsAlpha`.
 
 			Formula
@@ -139,7 +156,6 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 			# `(1 - (bitsAlpha & 1)` is an evenness test.
 			```
 			"""
-			nonlocal dataframeMeanders
 			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode']
 			dataframeMeanders.loc[:, 'analyzed'] &= 1 # (bitsAlpha & 1)
 			dataframeMeanders.loc[:, 'analyzed'] ^= 1 # (1 - (bitsAlpha ...))
@@ -177,39 +193,9 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 			dataframeMeanders.loc[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
 
-		def analyzeArcCodesSimple() -> None:
-			"""Compute arcCode with the 'simple' formula.
-
-			Formula
-			-------
-			```python
-			arcCode = ((bitsAlpha | (bitsZulu << 1)) << 2) | 3
-			```
-
-			Notes
-			-----
-			Using `+= 3` instead of `|= 3` is valid in this specific case. Left shift by two means the last bits are '0b00'. '0 + 3'
-			is '0b11', and '0b00 | 0b11' is also '0b11'.
+			return dataframeMeanders
 
-			"""
-			nonlocal dataframeMeanders
-			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode']
-			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits
-
-			bitsZulu: pandas.Series = dataframeMeanders['arcCode'].copy()
-			bitsZulu //= 2**1 # (bitsZulu >> 1)
-			bitsZulu &= state.locatorBits # `bitsZulu`
-			bitsZulu *= 2**1 # (bitsZulu << 1)
-
-			dataframeMeanders.loc[:, 'analyzed'] |= bitsZulu # ((bitsAlpha | (bitsZulu ...))
-
-			del bitsZulu
-
-			dataframeMeanders.loc[:, 'analyzed'] *= 2**2 # (... << 2)
-			dataframeMeanders.loc[:, 'analyzed'] += 3 # (...) | 3
-			dataframeMeanders.loc[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
-
-		def analyzeBitsZulu() -> None:
+		def analyzeBitsZulu(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
 			"""Compute `arcCode` from `bitsZulu`.
 
 			Formula
@@ -219,10 +205,10 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 				arcCode = (1 - (bitsZulu & 1)) | (bitsAlpha << 2) | (bitsZulu >> 1)
 			```
 			"""
-			nonlocal dataframeMeanders
+# NOTE `(1 - (bitsZulu & 1))` is an evenness test: we want a single bit as the answer.
 			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'] # `bitsZulu`
-			dataframeMeanders.loc[:, 'analyzed'] &= 0b10 # `bitsZulu`
 			dataframeMeanders.loc[:, 'analyzed'] //= 2**1 # `bitsZulu` (bitsZulu >> 1)
+			dataframeMeanders.loc[:, 'analyzed'] &= 1 # `bitsZulu`
 			dataframeMeanders.loc[:, 'analyzed'] &= 1 # (bitsZulu & 1)
 			dataframeMeanders.loc[:, 'analyzed'] ^= 1 # (1 - (bitsZulu ...))
 
@@ -231,54 +217,56 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 			bitsTarget *= 2**2 # (bitsAlpha << 2)
 			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsAlpha ...)
-
 			del bitsTarget
 
-			# NOTE No, IDK why I didn't use the same trick as in `analyzeBitsAlpha`. I _think_ I wrote this code before I figured out that trick.
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsZulu`
-			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			bitsTarget &= state.locatorBits # `bitsZulu`
-
-			bitsTarget //= 2**1 # (bitsZulu >> 1)
-
-			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsZulu ...)
-
-			del bitsTarget
+			# NOTE Same trick as in `analyzeBitsAlpha`.
+			dataframeMeanders.loc[:, 'analyzed'] *= 2**1 # (... << 1)
 
 			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsZulu`
 			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
 			bitsTarget &= state.locatorBits # `bitsZulu`
 
-			dataframeMeanders.loc[bitsTarget <= 1, 'analyzed'] = 0 # if bitsZulu > 1
+			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsZulu)
+			dataframeMeanders.loc[:, 'analyzed'] //= 2**1 # (... >> 1)
 
+			dataframeMeanders.loc[bitsTarget <= 1, 'analyzed'] = 0 # if bitsZulu > 1
 			del bitsTarget
 
 			dataframeMeanders.loc[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
 
-		def recordArcCodes() -> None:
+			return dataframeMeanders
+
+		def recordArcCodes(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
 			nonlocal dataframeAnalyzed
 
-			indexStopAnalyzed: int = state.indexTarget + int((dataframeMeanders['analyzed'] > 0).sum()) # pyright: ignore[reportUnknownArgumentType, reportUnknownMemberType]
+			indexStopAnalyzed: int = state.indexTarget + int((dataframeMeanders['analyzed'] > 0).sum())
 
 			if indexStopAnalyzed > state.indexTarget:
 				if len(dataframeAnalyzed.index) < indexStopAnalyzed:
-					warn(f"Lengthened `dataframeAnalyzed` from {len(dataframeAnalyzed.index)} to {indexStopAnalyzed=}; n={state.n}, {state.kOfMatrix=}.", stacklevel=2)
+					warn(f"Lengthened `dataframeAnalyzed` from {len(dataframeAnalyzed.index)} to {indexStopAnalyzed=}; n={state.n}, {state.boundary=}.", stacklevel=2)
 					dataframeAnalyzed = dataframeAnalyzed.reindex(index=pandas.RangeIndex(indexStopAnalyzed), fill_value=0)
 
-				dataframeAnalyzed.loc[state.indexTarget:indexStopAnalyzed - 1, ['analyzed', 'crossings']] = (
-					dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 0), ['analyzed', 'crossings']
+				dataframeAnalyzed.loc[state.indexTarget:indexStopAnalyzed - 1, ['analyzed']] = (
+					dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 0), ['analyzed']
 								].to_numpy(dtype=state.datatypeArcCode, copy=False)
 				)
 
+				dataframeAnalyzed.loc[state.indexTarget:indexStopAnalyzed - 1, ['crossings']] = (
+					dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 0), ['crossings']
+								].to_numpy(dtype=state.datatypeCrossings, copy=False)
+				)
+
 				state.indexTarget = indexStopAnalyzed
 
 			del indexStopAnalyzed
 
+			return dataframeMeanders
+
 		dataframeMeanders = pandas.DataFrame({
 			'arcCode': pandas.Series(name='arcCode', data=dataframeAnalyzed['analyzed'], copy=False, dtype=state.datatypeArcCode)
 			, 'analyzed': pandas.Series(name='analyzed', data=0, dtype=state.datatypeArcCode)
 			, 'crossings': pandas.Series(name='crossings', data=dataframeAnalyzed['crossings'], copy=False, dtype=state.datatypeCrossings)
-			} # pyright: ignore[reportUnknownArgumentType]
+			}
 		)
 
 		del dataframeAnalyzed
@@ -287,35 +275,33 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		state.bitWidth = int(dataframeMeanders['arcCode'].max()).bit_length()
 		length: int = getBucketsTotal(state)
 		dataframeAnalyzed = pandas.DataFrame({
-			'analyzed': pandas.Series(0, pandas.RangeIndex(length), dtype=state.datatypeArcCode, name='analyzed')
-			, 'crossings': pandas.Series(0, pandas.RangeIndex(length), dtype=state.datatypeCrossings, name='crossings')
-			}, index=pandas.RangeIndex(length), columns=['analyzed', 'crossings'], dtype=state.datatypeArcCode # pyright: ignore[reportUnknownArgumentType]
+			'analyzed': pandas.Series(name='analyzed', data=0, index=pandas.RangeIndex(length), dtype=state.datatypeArcCode)
+			, 'crossings': pandas.Series(name='crossings', data=0, index=pandas.RangeIndex(length), dtype=state.datatypeCrossings)
+			}, index=pandas.RangeIndex(length)
 		)
 
-		state.kOfMatrix -= 1
+		state.boundary -= 1
 
 		state.indexTarget = 0
 
-		analyzeArcCodesSimple()
-		recordArcCodes()
+		dataframeMeanders: pandas.DataFrame = analyzeArcCodesSimple(dataframeMeanders)
+		dataframeMeanders = recordArcCodes(dataframeMeanders)
 
-		analyzeBitsAlpha()
-		recordArcCodes()
+		dataframeMeanders = analyzeBitsAlpha(dataframeMeanders)
+		dataframeMeanders = recordArcCodes(dataframeMeanders)
 
-		analyzeBitsZulu()
-		recordArcCodes()
+		dataframeMeanders = analyzeBitsZulu(dataframeMeanders)
+		dataframeMeanders = recordArcCodes(dataframeMeanders)
 
-		analyzeArcCodesAligned()
-		recordArcCodes()
+		dataframeMeanders = analyzeArcCodesAligned(dataframeMeanders)
+		dataframeMeanders = recordArcCodes(dataframeMeanders)
 		del dataframeMeanders
 		goByeBye()
 
 		aggregateArcCodes()
 
-		if state.n >= 45:  # for data collection
-			print(state.n, state.kOfMatrix+1, state.indexTarget, sep=',')  # noqa: T201
-
 	state.dictionaryMeanders = dataframeAnalyzed.set_index('analyzed')['crossings'].to_dict()
+	del dataframeAnalyzed
 	return state
 
 def doTheNeedful(state: MatrixMeandersNumPyState) -> int:
@@ -340,12 +326,9 @@ def doTheNeedful(state: MatrixMeandersNumPyState) -> int:
 	https://oeis.org/A000682
 	https://oeis.org/A005316
 	"""
-	while state.kOfMatrix > 0:
+	while state.boundary > 0:
 		if areIntegersWide(state):
 			state = countBigInt(state)
 		else:
 			state = countPandas(state)
-
-		goByeBye()
-
 	return sum(state.dictionaryMeanders.values())

mapFolding/algorithms/oeisIDbyFormula.py

@@ -8,7 +8,7 @@ NOTE: This is a generated file; edit the source file.
 """
 from functools import cache
 from mapFolding import dictionaryOEIS
-from mapFolding.basecamp import A000682, A005316, NOTcountingFolds
+from mapFolding.basecamp import NOTcountingFolds
 
 @cache
 def A000136(n: int) -> int:
@@ -35,13 +35,13 @@ def A000136(n: int) -> int:
     OEIS : webpage
         https://oeis.org/A000136
     """
-    return n * A000682(n)
+    return n * _A000682(n)
 
 def A000560(n: int) -> int:
     """
     Compute A000560(n) as a function of A000682.
 
-    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A000560 is: "Number of ways of folding a strip of n labeled stamps."
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A000560 is: "Number of symmetric ways of folding a strip of n labeled stamps."
 
     The domain of A000560 starts at 2, therefore for values of `n` < 2, a(n) is undefined. The smallest value of n for which a(n)
     has not yet been computed is 45.
@@ -54,14 +54,14 @@ def A000560(n: int) -> int:
     Returns
     -------
     a(n) : int
-        Number of ways of folding a strip of n labeled stamps.
+        Number of symmetric ways of folding a strip of n labeled stamps.
 
     Would You Like to Know More?
     ----------------------------
     OEIS : webpage
         https://oeis.org/A000560
     """
-    return A000682(n + 1) // 2
+    return _A000682(n + 1) // 2
 
 def A001010(n: int) -> int:
     """
@@ -90,9 +90,9 @@ def A001010(n: int) -> int:
     if n == 1:
         countTotal = 1
     elif n & 1:
-        countTotal = 2 * NOTcountingFolds(oeisID='A007822', oeis_n=(n - 1) // 2 + 1, flow='theorem2Numba')
+        countTotal = 2 * _A007822((n - 1) // 2 + 1)
     else:
-        countTotal = 2 * A000682(n // 2 + 1)
+        countTotal = 2 * _A000682(n // 2 + 1)
     return countTotal
 
 def A001011(n: int) -> int:
@@ -153,7 +153,7 @@ def A005315(n: int) -> int:
     if n in {0, 1}:
         countTotal = 1
     else:
-        countTotal = A005316(2 * n - 1)
+        countTotal = _A005316(2 * n - 1)
     return countTotal
 
 def A060206(n: int) -> int:
@@ -180,7 +180,7 @@ def A060206(n: int) -> int:
     OEIS : webpage
         https://oeis.org/A060206
     """
-    return A000682(2 * n + 1)
+    return _A000682(2 * n + 1)
 
 def A077460(n: int) -> int:
     """
@@ -209,9 +209,9 @@ def A077460(n: int) -> int:
     if n in {0, 1}:
         countTotal = 1
     elif n & 1:
-        countTotal = (A005315(n) + A005316(n) + A060206((n - 1) // 2)) // 4
+        countTotal = (A005315(n) + _A005316(n) + A060206((n - 1) // 2)) // 4
     else:
-        countTotal = (A005315(n) + 2 * A005316(n)) // 4
+        countTotal = (A005315(n) + 2 * _A005316(n)) // 4
     return countTotal
 
 def A078591(n: int) -> int:
@@ -298,7 +298,7 @@ def A223094(n: int) -> int:
     OEIS : webpage
         https://oeis.org/A223094
     """
-    return A000136(n) - A000682(n + 1)
+    return A000136(n) - _A000682(n + 1)
 
 def A259702(n: int) -> int:
     """
@@ -327,7 +327,7 @@ def A259702(n: int) -> int:
     if n == 2:
         countTotal = 0
     else:
-        countTotal = A000682(n) // 2 - A000682(n - 1)
+        countTotal = _A000682(n) // 2 - _A000682(n - 1)
     return countTotal
 
 def A301620(n: int) -> int:
@@ -354,4 +354,15 @@ def A301620(n: int) -> int:
     OEIS : webpage
         https://oeis.org/A301620
     """
-    return A000682(n + 2) - 2 * A000682(n + 1)
+    return _A000682(n + 2) - 2 * _A000682(n + 1)
+
+@cache
+def _A000682(n: int) -> int:
+    return NOTcountingFolds('A000682', n)
+
+def _A007822(n: int) -> int:
+    return NOTcountingFolds('A007822', n)
+
+@cache
+def _A005316(n: int) -> int:
+    return NOTcountingFolds('A005316', n)

mapFolding/algorithms/symmetricFolds.py

@@ -0,0 +1,36 @@
+"""Count the number of symmetric folds in the group of folds defined by `leafBelow`.
+
+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.
+- Some implementation details are based on Numba compatibility. Incompatible:
+    - `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
+

mapFolding/algorithms/zCuzDocStoopidoeisIDbyFormula.py

@@ -6,25 +6,26 @@ TODO A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger F
 """
 from functools import cache
 from mapFolding import dictionaryOEIS
-from mapFolding.basecamp import A000682, A005316, NOTcountingFolds
+from mapFolding.basecamp import NOTcountingFolds
 
+# ruff: noqa: D400
 @cache
 def A000136(n: int) -> int:
 	"""A000682"""
-	return n * A000682(n)
+	return n * _A000682(n)
 
 def A000560(n: int) -> int:
 	"""A000682"""
-	return A000682(n + 1) // 2
+	return _A000682(n + 1) // 2
 
 def A001010(n: int) -> int:
 	"""A000682 or A007822"""
 	if n == 1:
 		countTotal = 1
 	elif n & 0b1:
-		countTotal = 2 * NOTcountingFolds(oeisID='A007822', oeis_n=(n - 1)//2 + 1, flow='theorem2Numba')
+		countTotal = 2 * _A007822((n - 1)//2 + 1)
 	else:
-		countTotal = 2 * A000682(n // 2 + 1)
+		countTotal = 2 * _A000682(n // 2 + 1)
 	return countTotal
 
 def A001011(n: int) -> int:
@@ -41,21 +42,21 @@ def A005315(n: int) -> int:
 	if n in {0, 1}:
 		countTotal = 1
 	else:
-		countTotal = A005316(2 * n - 1)
+		countTotal = _A005316(2 * n - 1)
 	return countTotal
 
 def A060206(n: int) -> int:
 	"""A000682"""
-	return A000682(2 * n + 1)
+	return _A000682(2 * n + 1)
 
 def A077460(n: int) -> int:
 	"""A005315, A005316, and A060206"""
 	if n in {0, 1}:
 		countTotal = 1
 	elif n & 0b1:
-		countTotal = (A005315(n) + A005316(n) + A060206((n - 1) // 2)) // 4
+		countTotal = (A005315(n) + _A005316(n) + A060206((n - 1) // 2)) // 4
 	else:
-		countTotal = (A005315(n) + 2 * A005316(n)) // 4
+		countTotal = (A005315(n) + 2 * _A005316(n)) // 4
 
 	return countTotal
 
@@ -77,16 +78,29 @@ def A178961(n: int) -> int:
 
 def A223094(n: int) -> int:
 	"""A000136 and A000682"""
-	return A000136(n) - A000682(n + 1)
+	return A000136(n) - _A000682(n + 1)
 
 def A259702(n: int) -> int:
 	"""A000682"""
 	if n == 2:
 		countTotal = 0
 	else:
-		countTotal = A000682(n) // 2 - A000682(n - 1)
+		countTotal = _A000682(n) // 2 - _A000682(n - 1)
 	return countTotal
 
 def A301620(n: int) -> int:
 	"""A000682"""
-	return A000682(n + 2) - 2 * A000682(n + 1)
+	return _A000682(n + 2) - 2 * _A000682(n + 1)
+
+# ================= Not formulas ==========================
+
+@cache
+def _A000682(n: int) -> int:
+	return NOTcountingFolds('A000682', n)
+
+def _A007822(n: int) -> int:
+	return NOTcountingFolds('A007822', n)
+
+@cache
+def _A005316(n: int) -> int:
+	return NOTcountingFolds('A005316', n)