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

mapFolding/algorithms/matrixMeandersPandas.py

@@ -1,334 +0,0 @@
-from gc import collect as goByeBye
-from mapFolding.algorithms.matrixMeandersBeDry import areIntegersWide, flipTheExtra_0b1AsUfunc, getBucketsTotal
-from mapFolding.dataBaskets import MatrixMeandersNumPyState
-from mapFolding.syntheticModules.meanders.bigInt import countBigInt
-from warnings import warn
-import pandas
-
-def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
-	"""Count meanders with matrix transfer algorithm using pandas DataFrame.
-
-	Parameters
-	----------
-	state : MatrixMeandersState
-		The algorithm state containing current `boundary`, `dictionaryMeanders`, and thresholds.
-
-	Returns
-	-------
-	state : MatrixMeandersState
-		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)
-		}
-	)
-	state.dictionaryMeanders.clear()
-
-	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(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.
-
-			Warning
-			-------
-			This function deletes rows from `dataframeMeanders`. Always run this analysis last.
-
-			Formula
-			-------
-			```python
-			if bitsAlpha > 1 and bitsZulu > 1 and (bitsAlphaIsEven or bitsZuluIsEven):
-				arcCode = (bitsAlpha >> 2) | ((bitsZulu >> 2) << 1)
-			```
-			"""
-			# NOTE Step 1 drop unqualified rows
-# ======= > * > bitsAlpha 1 bitsZulu 1 ====================
-			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode'].copy()			# `bitsAlpha`
-			dataframeMeanders['analyzed'] &= state.locatorBits							# `bitsAlpha`
-
-			dataframeMeanders['analyzed'] = dataframeMeanders['analyzed'].gt(1)			# if bitsAlphaHasArcs
-
-			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)
-
-# ======= ^ & & bitsAlpha 1 bitsZulu 1 ====================
-			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'].copy()	# `bitsAlpha`
-			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits					# `bitsAlpha`
-
-			dataframeMeanders.loc[:, 'analyzed'] &= 1									# `bitsAlpha`
-
-			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
-
-			dataframeMeanders = dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 0)] 	# if (bitsAlphaIsEven or bitsZuluIsEven)
-
-			# 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 &= state.locatorBits												# `bitsAlpha`
-
-			# if bitsAlphaAtEven and not bitsZuluAtEven, modify bitsAlphaPairedToOdd
-			bitsTarget.loc[(dataframeMeanders['analyzed'] > 0)] = state.datatypeArcCode(
-				flipTheExtra_0b1AsUfunc(bitsTarget.loc[(dataframeMeanders['analyzed'] > 0)]))
-
-			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'].copy()	# `bitsZulu`
-			dataframeMeanders.loc[:, 'analyzed'] //= 2**1								# `bitsZulu` (bitsZulu >> 1)
-			dataframeMeanders.loc[:, 'analyzed'] &= state.locatorBits					# `bitsZulu`
-
-			# 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']))
-
-			# 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[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
-
-			return dataframeMeanders
-
-		def analyzeArcCodesSimple(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
-			"""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'.
-
-			"""
-			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
-
-			return dataframeMeanders
-
-		def analyzeBitsAlpha(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
-			"""Compute `arcCode` from `bitsAlpha`.
-
-			Formula
-			-------
-			```python
-			if bitsAlpha > 1:
-				arcCode = ((1 - (bitsAlpha & 1)) << 1) | (bitsZulu << 3) | (bitsAlpha >> 2)
-			# `(1 - (bitsAlpha & 1)` is an evenness test.
-			```
-			"""
-			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode']
-			dataframeMeanders.loc[:, 'analyzed'] &= 1 # (bitsAlpha & 1)
-			dataframeMeanders.loc[:, 'analyzed'] ^= 1 # (1 - (bitsAlpha ...))
-
-			dataframeMeanders.loc[:, 'analyzed'] *= 2**1 # ((bitsAlpha ...) << 1)
-
-			bitsTarget: pandas.Series = dataframeMeanders['arcCode'].copy() # `bitsZulu`
-			bitsTarget //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			bitsTarget &= state.locatorBits # `bitsZulu`
-
-			bitsTarget *= 2**3 # (bitsZulu << 3)
-			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsZulu ...)
-
-			del bitsTarget
-
-			"""NOTE In this code block, I rearranged the "formula" to use `bitsTarget` for two goals. 1. `(bitsAlpha >> 2)`.
-			2. `if bitsAlpha > 1`. The trick is in the equivalence of v1 and v2.
-				v1: BITScow | (BITSwalk >> 2)
-				v2: ((BITScow << 2) | BITSwalk) >> 2
-
-			The "formula" calls for v1, but by using v2, `bitsTarget` is not changed. Therefore, because `bitsTarget` is
-			`bitsAlpha`, I can use `bitsTarget` for goal 2, `if bitsAlpha > 1`.
-			"""
-			dataframeMeanders.loc[:, 'analyzed'] *= 2**2 # ... | (bitsAlpha >> 2)
-
-			bitsTarget = dataframeMeanders['arcCode'].copy() # `bitsAlpha`
-			bitsTarget &= state.locatorBits # `bitsAlpha`
-
-			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsAlpha)
-			dataframeMeanders.loc[:, 'analyzed'] //= 2**2 # (... >> 2)
-
-			dataframeMeanders.loc[(bitsTarget <= 1), 'analyzed'] = 0 # if bitsAlpha > 1
-
-			del bitsTarget
-
-			dataframeMeanders.loc[dataframeMeanders['analyzed'] >= state.MAXIMUMarcCode, 'analyzed'] = 0
-
-			return dataframeMeanders
-
-		def analyzeBitsZulu(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
-			"""Compute `arcCode` from `bitsZulu`.
-
-			Formula
-			-------
-			```python
-			if bitsZulu > 1:
-				arcCode = (1 - (bitsZulu & 1)) | (bitsAlpha << 2) | (bitsZulu >> 1)
-			```
-			"""
-# 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'] //= 2**1 # `bitsZulu` (bitsZulu >> 1)
-			dataframeMeanders.loc[:, 'analyzed'] &= 1 # `bitsZulu`
-			dataframeMeanders.loc[:, 'analyzed'] &= 1 # (bitsZulu & 1)
-			dataframeMeanders.loc[:, 'analyzed'] ^= 1 # (1 - (bitsZulu ...))
-
-			bitsTarget: pandas.Series = dataframeMeanders['arcCode'].copy() # `bitsAlpha`
-			bitsTarget &= state.locatorBits # `bitsAlpha`
-
-			bitsTarget *= 2**2 # (bitsAlpha << 2)
-			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget # ... | (bitsAlpha ...)
-			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[:, '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
-
-			return dataframeMeanders
-
-		def recordArcCodes(dataframeMeanders: pandas.DataFrame) -> pandas.DataFrame:
-			nonlocal dataframeAnalyzed
-
-			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.boundary=}.", stacklevel=2)
-					dataframeAnalyzed = dataframeAnalyzed.reindex(index=pandas.RangeIndex(indexStopAnalyzed), fill_value=0)
-
-				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)
-			}
-		)
-
-		del dataframeAnalyzed
-		goByeBye()
-
-		state.bitWidth = int(dataframeMeanders['arcCode'].max()).bit_length()
-		length: int = getBucketsTotal(state)
-		dataframeAnalyzed = pandas.DataFrame({
-			'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.boundary -= 1
-
-		state.indexTarget = 0
-
-		dataframeMeanders: pandas.DataFrame = analyzeArcCodesSimple(dataframeMeanders)
-		dataframeMeanders = recordArcCodes(dataframeMeanders)
-
-		dataframeMeanders = analyzeBitsAlpha(dataframeMeanders)
-		dataframeMeanders = recordArcCodes(dataframeMeanders)
-
-		dataframeMeanders = analyzeBitsZulu(dataframeMeanders)
-		dataframeMeanders = recordArcCodes(dataframeMeanders)
-
-		dataframeMeanders = analyzeArcCodesAligned(dataframeMeanders)
-		dataframeMeanders = recordArcCodes(dataframeMeanders)
-		del dataframeMeanders
-		goByeBye()
-
-		aggregateArcCodes()
-
-	state.dictionaryMeanders = dataframeAnalyzed.set_index('analyzed')['crossings'].to_dict()
-	del dataframeAnalyzed
-	return state
-
-def doTheNeedful(state: MatrixMeandersNumPyState) -> int:
-	"""Compute `crossings` with a transfer matrix algorithm implemented in pandas.
-
-	Parameters
-	----------
-	state : MatrixMeandersState
-		The algorithm state.
-
-	Returns
-	-------
-	crossings : int
-		The computed value of `crossings`.
-
-	Notes
-	-----
-	Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bibtex
-
-	See Also
-	--------
-	https://oeis.org/A000682
-	https://oeis.org/A005316
-	"""
-	while state.boundary > 0:
-		if areIntegersWide(state):
-			state = countBigInt(state)
-		else:
-			state = countPandas(state)
-	return sum(state.dictionaryMeanders.values())

mapFolding/reference/meandersDumpingGround/A005316intOptimized.py

@@ -1,122 +0,0 @@
-from collections.abc import Iterable
-from hunterMakesPy import raiseIfNone
-
-class BasicMeanderProblem:
-
-	def __init__(self, remainingBridges: int) -> None:
-		self.remainingBridges = remainingBridges
-		self.archStateLimit = 1 << (2 + (2 * (remainingBridges + 1)))
-		self.bridgesTotalIsOdd = (remainingBridges & 1) == 1
-
-	def initializeA005316(self) -> list[int]:
-		if self.bridgesTotalIsOdd:
-			bitPattern = (1 << 2) | 1
-			bitPattern <<= 2
-			return [bitPattern | 1 << 1]
-		else:
-			bitPattern = (1 << 2) | 1
-			return [bitPattern | bitPattern << 1]
-
-	def initializeA000682(self) -> list[int]:
-		initialStatesList: list[int] = []
-		bitPattern = 1 if self.bridgesTotalIsOdd else ((1 << 2) | 1)
-
-		packedState = bitPattern | bitPattern << 1
-		while packedState < self.archStateLimit:
-			initialStatesList.append(packedState)
-			bitPattern = ((bitPattern << 2) | 1) << 2 | 1
-			packedState = bitPattern | bitPattern << 1
-
-		return initialStatesList
-
-	def enumerate(self, packedState: int) -> list[int]:  # noqa: C901
-		bitMask = 0x5555555555555555
-		bitWidth = 64
-		while bitMask < packedState:
-			bitMask |= bitMask << bitWidth
-			bitWidth += bitWidth
-		lower: int = packedState & bitMask
-		upper: int = (packedState - lower) >> 1
-		nextStatesList: list[int] = []
-
-		if lower != 1:
-			nextState: int = (lower >> 2 | (((upper << 2) ^ (1 if (lower & 1) == 0 else 0)) << 1))
-			if nextState < self.archStateLimit:
-				nextStatesList.append(nextState)
-
-		if upper != 1:
-			nextState = (((lower << 2) ^ (1 if (upper & 1) == 0 else 0)) | (upper >> 2) << 1)
-			if nextState < self.archStateLimit:
-				nextStatesList.append(nextState)
-
-		nextState = ((lower << 2) | 1 | ((upper << 2) | 1) << 1)
-		if nextState < self.archStateLimit:
-			nextStatesList.append(nextState)
-
-		if lower != 1 and upper != 1 and ((lower & 1) == 0 or (upper & 1) == 0):
-			if (lower & 1) == 0 and (upper & 1) == 1:
-				archBalance = 0
-				bitPosition = 1
-				while archBalance >= 0:
-					bitPosition <<= 2
-					archBalance += 1 if (lower & bitPosition) == 0 else -1
-				lower ^= bitPosition
-			if (upper & 1) == 0 and (lower & 1) == 1:
-				archBalance = 0
-				bitPosition = 1
-				while archBalance >= 0:
-					bitPosition <<= 2
-					archBalance += 1 if (upper & bitPosition) == 0 else -1
-				upper ^= bitPosition
-			nextState = (lower >> 2 | (upper >> 2) << 1)
-			if nextState < self.archStateLimit:
-				nextStatesList.append(nextState)
-
-		return nextStatesList
-
-class SimpleProcessor:
-
-	def __init__(self) -> None:
-		self.createStateMachine: type | None = None
-		self.totalTransitions = 0
-
-	def setCreateStateMachine(self, stateMachineCreator: type) -> None:
-		self.createStateMachine = stateMachineCreator
-
-	def process(self, bridgesCount: int, initialStates: Iterable[int]) -> int:
-		stateCounts: list[tuple[int, int]] = [(state, 1) for state in initialStates]
-
-		self.createStateMachine = raiseIfNone(self.createStateMachine, "State machine creator must be set before processing.")
-		bridgesRemaining: int = bridgesCount
-		while bridgesRemaining > 0:
-			bridgesRemaining -= 1
-			stateCounts = self._accumulate(self.createStateMachine(bridgesRemaining), stateCounts)
-
-		return sum(count for state, count in stateCounts)
-
-	def _accumulate(self, layer: BasicMeanderProblem, previousCounts: list[tuple[int, int]]) -> list[tuple[int, int]]:
-		stateCountsDict: dict[int, int] = {}
-		transitions: int = 0
-
-		for state, count in previousCounts:
-			for nextState in layer.enumerate(state):
-				if nextState in stateCountsDict:
-					stateCountsDict[nextState] += count
-				else:
-					stateCountsDict[nextState] = count
-				transitions += 1
-
-		self.totalTransitions += transitions
-		return list(stateCountsDict.items())
-
-def A005316(n: int) -> int:
-	processor = SimpleProcessor()
-	processor.setCreateStateMachine(BasicMeanderProblem)
-	meanderProblem = BasicMeanderProblem(n)
-	return processor.process(n, meanderProblem.initializeA005316())
-
-def A000682(n: int) -> int:
-	processor = SimpleProcessor()
-	processor.setCreateStateMachine(BasicMeanderProblem)
-	meanderProblem = BasicMeanderProblem(n-1)
-	return processor.process(n-1, meanderProblem.initializeA000682())

mapFolding/reference/meandersDumpingGround/A005316optimized128bit.py

@@ -1,79 +0,0 @@
-def count(bridges: int, dictionaryCurveLocationsKnown: dict[int, int]) -> int:
-	while bridges > 0:
-		bridges -= 1
-		curveLocationsMAXIMUM = 1 << (2 * bridges + 4)
-		dictionaryCurveLocationsDiscovered: dict[int, int] = {}
-
-		for curveLocations, distinctCrossings in dictionaryCurveLocationsKnown.items():
-			bifurcationAlpha = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
-			bifurcationZulu = (curveLocations ^ bifurcationAlpha) >> 1
-
-			bifurcationAlphaHasCurves = bifurcationAlpha != 1
-			bifurcationZuluHasCurves = bifurcationZulu != 1
-			bifurcationAlphaFinalZero = not bifurcationAlpha & 1
-			bifurcationZuluFinalZero = not bifurcationZulu & 1
-
-			if bifurcationAlphaHasCurves:
-				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
-				if curveLocationAnalysis < curveLocationsMAXIMUM:
-					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
-
-			if bifurcationZuluHasCurves:
-				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
-				if curveLocationAnalysis < curveLocationsMAXIMUM:
-					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
-
-			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
-			if curveLocationAnalysis < curveLocationsMAXIMUM:
-				dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
-
-			if bifurcationAlphaHasCurves and bifurcationZuluHasCurves and (bifurcationAlphaFinalZero or bifurcationZuluFinalZero):
-				XOrHere2makePair = 0b1
-				findUnpairedBinary1 = 0
-				if bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
-					while findUnpairedBinary1 >= 0:
-						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
-					bifurcationAlpha ^= XOrHere2makePair
-
-				elif bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
-					while findUnpairedBinary1 >= 0:
-						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
-					bifurcationZulu ^= XOrHere2makePair
-
-				curveLocationAnalysis = (bifurcationAlpha >> 2) | ((bifurcationZulu >> 2) << 1)
-				if curveLocationAnalysis < curveLocationsMAXIMUM:
-					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
-
-		dictionaryCurveLocationsKnown = dictionaryCurveLocationsDiscovered
-
-	return sum(dictionaryCurveLocationsKnown.values())
-
-def initializeA005316(n: int) -> dict[int, int]:
-	if n & 1:
-		return {22: 1}
-	else:
-		return {15: 1}
-
-def initializeA000682(n: int) -> dict[int, int]:
-	stateToCount: dict[int, int] = {}
-
-	curveLocationsMAXIMUM = 1 << (2 * n + 4)
-
-	bitPattern = 5 - (n & 1) * 4
-
-	packedState = bitPattern | (bitPattern << 1)
-	while packedState < curveLocationsMAXIMUM:
-		stateToCount[packedState] = 1
-		bitPattern = ((bitPattern << 4) | 0b0101)
-		packedState = bitPattern | (bitPattern << 1)
-
-	return stateToCount
-
-def A005316(n: int) -> int:
-	return count(n, initializeA005316(n))
-
-def A000682(n: int) -> int:
-	return count(n - 1, initializeA000682(n - 1))
-

mapFolding/reference/meandersDumpingGround/matrixMeandersBaseline.py

@@ -1,65 +0,0 @@
-from mapFolding._oeisFormulas.matrixMeandersAnnex import curveMaximum as curveMaximum
-
-dictionaryCurveLocations: dict[int, int] = {}
-
-def getCurveLocations() -> dict[int, int]:
-	global dictionaryCurveLocations  # noqa: PLW0603
-	sherpa = dictionaryCurveLocations.copy()
-	dictionaryCurveLocations = {}
-	return sherpa
-
-def recordAnalysis(curveLocationAnalysis: int, curveLocationsMAXIMUM: int, distinctCrossings: int) -> None:
-	if curveLocationAnalysis < curveLocationsMAXIMUM:
-		dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
-
-def initializeCurveLocations(startingCurveLocations: dict[int, int]) -> None:
-	global dictionaryCurveLocations  # noqa: PLW0603
-	dictionaryCurveLocations = startingCurveLocations.copy()
-
-def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
-	initializeCurveLocations(startingCurveLocations)
-
-	while bridges > 0:
-		bridges -= 1
-		curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = curveMaximum[bridges]
-
-		for curveLocations, distinctCrossings in getCurveLocations().items():
-			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
-			bifurcationAlpha = curveLocations & bifurcationAlphaLocator
-
-			bifurcationZuluFinalZero = (bifurcationZulu & 0b1) == 0
-			bifurcationZuluHasCurves = bifurcationZulu != 1
-			bifurcationAlphaFinalZero = (bifurcationAlpha & 0b1) == 0
-			bifurcationAlphaHasCurves = bifurcationAlpha != 1
-
-			if bifurcationZuluHasCurves:
-				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
-				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-			if bifurcationAlphaHasCurves:
-				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
-				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
-			recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves and (bifurcationZuluFinalZero or bifurcationAlphaFinalZero):
-				XOrHere2makePair = 0b1
-				findUnpairedBinary1 = 0
-
-				if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
-					while findUnpairedBinary1 >= 0:
-						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
-					bifurcationZulu ^= XOrHere2makePair
-
-				elif bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
-					while findUnpairedBinary1 >= 0:
-						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
-					bifurcationAlpha ^= XOrHere2makePair
-
-				curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
-				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-	return sum(getCurveLocations().values())

mapFolding/reference/meandersDumpingGround/matrixMeandersBaselineAnnex.py

@@ -1,84 +0,0 @@
-from typing import NamedTuple
-import sys
-
-class limitLocators(NamedTuple):
-	curveLocationsMAXIMUM: int
-	bifurcationZuluLocator: int
-	bifurcationAlphaLocator: int
-
-curveMaximum: dict[int, limitLocators] = {
-0: limitLocators(16, 0x2a, 0x15),
-1: limitLocators(64, 0xaa, 0x55),
-2: limitLocators(256, 0x2aa, 0x155),
-3: limitLocators(1024, 0xaaa, 0x555),
-4: limitLocators(4096, 0x2aaa, 0x1555),
-5: limitLocators(16384, 0xaaaa, 0x5555),
-6: limitLocators(65536, 0x2aaaa, 0x15555),
-7: limitLocators(262144, 0xaaaaa, 0x55555),
-8: limitLocators(1048576, 0x2aaaaa, 0x155555),
-9: limitLocators(4194304, 0xaaaaaa, 0x555555),
-10: limitLocators(16777216, 0x2aaaaaa, 0x1555555),
-11: limitLocators(67108864, 0xaaaaaaa, 0x5555555),
-12: limitLocators(268435456, 0x2aaaaaaa, 0x15555555),
-13: limitLocators(1073741824, 0xaaaaaaaa, 0x55555555),
-14: limitLocators(4294967296, 0x2aaaaaaaa, 0x155555555),
-15: limitLocators(17179869184, 0xaaaaaaaaa, 0x555555555),
-16: limitLocators(68719476736, 0x2aaaaaaaaa, 0x1555555555),
-17: limitLocators(274877906944, 0xaaaaaaaaaa, 0x5555555555),
-18: limitLocators(1099511627776, 0x2aaaaaaaaaa, 0x15555555555),
-19: limitLocators(4398046511104, 0xaaaaaaaaaaa, 0x55555555555),
-20: limitLocators(17592186044416, 0x2aaaaaaaaaaa, 0x155555555555),
-21: limitLocators(70368744177664, 0xaaaaaaaaaaaa, 0x555555555555),
-22: limitLocators(281474976710656, 0x2aaaaaaaaaaaa, 0x1555555555555),
-23: limitLocators(1125899906842624, 0xaaaaaaaaaaaaa, 0x5555555555555),
-24: limitLocators(4503599627370496, 0x2aaaaaaaaaaaaa, 0x15555555555555),
-25: limitLocators(18014398509481984, 0xaaaaaaaaaaaaaa, 0x55555555555555),
-26: limitLocators(72057594037927936, 0x2aaaaaaaaaaaaaa, 0x155555555555555),
-27: limitLocators(288230376151711744, 0xaaaaaaaaaaaaaaa, 0x555555555555555),
-28: limitLocators(1152921504606846976, 0x2aaaaaaaaaaaaaaa, 0x1555555555555555),
-29: limitLocators(4611686018427387904, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555),
-30: limitLocators(18446744073709551616, 0x2aaaaaaaaaaaaaaaa, 0x15555555555555555),
-31: limitLocators(73786976294838206464, 0xaaaaaaaaaaaaaaaaa, 0x55555555555555555),
-32: limitLocators(295147905179352825856, 0x2aaaaaaaaaaaaaaaaa, 0x155555555555555555),
-33: limitLocators(1180591620717411303424, 0xaaaaaaaaaaaaaaaaaa, 0x555555555555555555),
-34: limitLocators(4722366482869645213696, 0x2aaaaaaaaaaaaaaaaaa, 0x1555555555555555555),
-35: limitLocators(18889465931478580854784, 0xaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555),
-36: limitLocators(75557863725914323419136, 0x2aaaaaaaaaaaaaaaaaaa, 0x15555555555555555555),
-37: limitLocators(302231454903657293676544, 0xaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555),
-38: limitLocators(1208925819614629174706176, 0x2aaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555),
-39: limitLocators(4835703278458516698824704, 0xaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555),
-40: limitLocators(19342813113834066795298816, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555),
-41: limitLocators(77371252455336267181195264, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555),
-42: limitLocators(309485009821345068724781056, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555),
-43: limitLocators(1237940039285380274899124224, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555),
-44: limitLocators(4951760157141521099596496896, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555),
-45: limitLocators(19807040628566084398385987584, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555),
-46: limitLocators(79228162514264337593543950336, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555),
-47: limitLocators(316912650057057350374175801344, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555),
-48: limitLocators(1267650600228229401496703205376, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555),
-49: limitLocators(5070602400912917605986812821504, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555),
-50: limitLocators(20282409603651670423947251286016, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555),
-51: limitLocators(81129638414606681695789005144064, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555),
-52: limitLocators(324518553658426726783156020576256, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555),
-53: limitLocators(1298074214633706907132624082305024, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555),
-54: limitLocators(5192296858534827628530496329220096, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555),
-55: limitLocators(20769187434139310514121985316880384, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555),
-56: limitLocators(83076749736557242056487941267521536, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555555),
-57: limitLocators(332306998946228968225951765070086144, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555555),
-58: limitLocators(1329227995784915872903807060280344576, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555555),
-59: limitLocators(5316911983139663491615228241121378304, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555555),
-60: limitLocators(21267647932558653966460912964485513216, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555555),
-61: limitLocators(85070591730234615865843651857942052864, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555555),
-}
-
-def makeCurveMaximum() -> None:
-	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
-	for n in range(62):
-		curveLocationsMAXIMUM = 1 << (2 * n + 4)
-		bifurcationAlphaLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
-		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationAlphaLocator << 1)}, {hex(bifurcationAlphaLocator)}),\n")
-	sys.stdout.write("}\n")
-
-if __name__ == '__main__':
-	makeCurveMaximum()
-