mapFolding 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

mapFolding/reference/A005316intOptimized.py

@@ -0,0 +1,122 @@
+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/A005316optimized128bit.py

@@ -0,0 +1,79 @@
+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():
+			bifurcationOdd = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
+			bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+
+			bifurcationOddHasCurves = bifurcationOdd != 1
+			bifurcationEvenHasCurves = bifurcationEven != 1
+			bifurcationOddFinalZero = not bifurcationOdd & 1
+			bifurcationEvenFinalZero = not bifurcationEven & 1
+
+			if bifurcationOddHasCurves:
+				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationEvenHasCurves:
+				curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+				XOrHere2makePair = 0b1
+				findUnpairedBinary1 = 0
+				if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
+					bifurcationOdd ^= XOrHere2makePair
+
+				elif bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
+					bifurcationEven ^= XOrHere2makePair
+
+				curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 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/A005316primitiveOptimized.py

@@ -0,0 +1,97 @@
+bifurcationOddLocator = 0x55555555555555555555555555555555
+bitWidth = 1 << (bifurcationOddLocator.bit_length() - 1).bit_length()
+
+def count(bridges: int, dictionaryCurveLocationsKnown: dict[int, int]) -> int:
+	while bridges > 0:
+		bridges -= 1
+		curveLocationsMAXIMUM = 1 << (2 + (2 * (bridges + 1)))
+
+		dictionaryCurveLocationsDiscovered: dict[int, int] = {}
+
+		for curveLocations, distinctCrossings in dictionaryCurveLocationsKnown.items():
+			global bifurcationOddLocator, bitWidth  # noqa: PLW0603
+
+			if curveLocations > bifurcationOddLocator:
+				while curveLocations > bifurcationOddLocator:
+					bifurcationOddLocator |= bifurcationOddLocator << bitWidth
+					bitWidth <<= 1
+
+			bifurcationOdd = curveLocations & bifurcationOddLocator
+			bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+
+			bifurcationOddHasCurves = bifurcationOdd != 1
+			bifurcationEvenHasCurves = bifurcationEven != 1
+			bifurcationOddFinalZero = (bifurcationOdd & 1) == 0
+			bifurcationEvenFinalZero = (bifurcationEven & 1) == 0
+
+			if bifurcationOddHasCurves:
+				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationEvenHasCurves:
+				curveLocationAnalysis = (bifurcationEven >> 1) | ((bifurcationOdd << 2) | bifurcationEvenFinalZero)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+				if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+					Z0Z_idk = 0
+					Z0Z_indexIDK = 1
+					while Z0Z_idk >= 0:
+						Z0Z_indexIDK <<= 2
+						Z0Z_idk += 1 if (bifurcationOdd & Z0Z_indexIDK) == 0 else -1
+					bifurcationOdd ^= Z0Z_indexIDK
+
+				if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+					Z0Z_idk = 0
+					Z0Z_indexIDK = 1
+					while Z0Z_idk >= 0:
+						Z0Z_indexIDK <<= 2
+						Z0Z_idk += 1 if (bifurcationEven & Z0Z_indexIDK) == 0 else -1
+					bifurcationEven ^= Z0Z_indexIDK
+
+				curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 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]:
+	bridgesTotalIsOdd = (n & 1) == 1
+	if bridgesTotalIsOdd:
+		arrayBitPattern = (1 << 2) | 1
+		arrayBitPattern <<= 2
+		initialState = arrayBitPattern | 1 << 1
+		return {initialState: 1}
+	else:
+		arrayBitPattern = (1 << 2) | 1
+		initialState = arrayBitPattern | arrayBitPattern << 1
+		return {initialState: 1}
+
+def initializeA000682(n: int) -> dict[int, int]:
+	bridgesTotalIsOdd = (n & 1) == 1
+	archStateLimit = 1 << (2 + (2 * (n + 1)))
+
+	dictionaryStateToTotal: dict[int, int] = {}
+	arrayBitPattern = 1 if bridgesTotalIsOdd else ((1 << 2) | 1)
+
+	arrayPackedState = arrayBitPattern | arrayBitPattern << 1
+	while arrayPackedState < archStateLimit:
+		dictionaryStateToTotal[arrayPackedState] = 1
+		arrayBitPattern = ((arrayBitPattern << 2) | 1) << 2 | 1
+		arrayPackedState = arrayBitPattern | arrayBitPattern << 1
+
+	return dictionaryStateToTotal
+
+def A005316(n: int) -> int:
+	return count(n, initializeA005316(n))
+
+def A000682(n: int) -> int:
+	return count(n - 1, initializeA000682(n - 1))

mapFolding/reference/A005316redis.py

@@ -0,0 +1,118 @@
+import redis
+
+def count(bridges: int, curveLocationsKnown: dict[int, int]) -> int:
+	# Initialize Redis connection
+	redisClient = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
+
+	# Load initial data into Redis
+	redisClient.flushdb()
+	for key, value in curveLocationsKnown.items():
+		redisClient.set(f"known:{key}", str(value))
+
+	while bridges > 0:
+		bridges -= 1
+		curveLocationsMAXIMUM = 1 << (2 * bridges + 4)
+
+		# Clear discovered data in Redis
+		for key in redisClient.scan_iter(match="discovered:*"):
+			redisClient.delete(key)
+
+		def storeCurveLocations(curveLocationAnalysis: int, distinctCrossings: int,
+								curveLocationsMAXIMUM: int = curveLocationsMAXIMUM,
+								redisClient: redis.Redis = redisClient) -> None:
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				keyName = f"discovered:{curveLocationAnalysis}"
+				existingValue = redisClient.get(keyName)
+				if existingValue is not None:
+					newValue = int(existingValue) + distinctCrossings
+				else:
+					newValue = distinctCrossings
+				redisClient.set(keyName, str(newValue))
+
+		# Process all known curve locations from Redis
+		for keyName in redisClient.scan_iter(match="known:*"):
+			curveLocations = int(str(keyName).split(":")[1])
+			distinctCrossings = int(str(redisClient.get(keyName)))
+
+			bifurcationOdd = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
+			bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+
+			bifurcationOddHasCurves = bifurcationOdd != 1
+			bifurcationEvenHasCurves = bifurcationEven != 1
+			bifurcationOddFinalZero = not bifurcationOdd & 1
+			bifurcationEvenFinalZero = not bifurcationEven & 1
+
+			if bifurcationOddHasCurves:
+				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+				storeCurveLocations(curveLocationAnalysis, distinctCrossings)
+
+			if bifurcationEvenHasCurves:
+				curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+				storeCurveLocations(curveLocationAnalysis, distinctCrossings)
+
+			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			storeCurveLocations(curveLocationAnalysis, distinctCrossings)
+
+			if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+				XOrHere2makePair = 0b1
+				findUnpairedBinary1 = 0
+				if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
+					bifurcationOdd ^= XOrHere2makePair
+
+				elif bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
+					bifurcationEven ^= XOrHere2makePair
+
+				curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 2) << 1)
+				storeCurveLocations(curveLocationAnalysis, distinctCrossings)
+
+		# Move discovered data to known for next iteration
+		for keyName in redisClient.scan_iter(match="known:*"):
+			redisClient.delete(str(keyName))
+
+		for keyName in redisClient.scan_iter(match="discovered:*"):
+			newKeyName = str(keyName).replace("discovered:", "known:")
+			value = redisClient.get(str(keyName))
+			redisClient.set(newKeyName, str(value))
+			redisClient.delete(str(keyName))
+
+	# Calculate final sum from Redis
+	totalResult = 0
+	for keyName in redisClient.scan_iter(match="known:*"):
+		value = int(str(redisClient.get(str(keyName))))
+		totalResult += value
+
+	return totalResult
+
+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/A005316write2disk.py

@@ -0,0 +1,169 @@
+from pathlib import Path
+import shutil
+import threading
+
+pathRoot = Path.cwd() / 'curves'
+
+curveMaximum: dict[int, int] = {0: 16,
+1: 64,
+2: 256,
+3: 1024,
+4: 4096,
+5: 16384,
+6: 65536,
+7: 262144,
+8: 1048576,
+9: 4194304,
+10: 16777216,
+11: 67108864,
+12: 268435456,
+13: 1073741824,
+14: 4294967296,
+15: 17179869184,
+16: 68719476736,
+17: 274877906944,
+18: 1099511627776,
+19: 4398046511104,
+20: 17592186044416,
+21: 70368744177664,
+22: 281474976710656,
+23: 1125899906842624,
+24: 4503599627370496,
+25: 18014398509481984,
+26: 72057594037927936,
+27: 288230376151711744,
+28: 1152921504606846976,
+29: 4611686018427387904,
+30: 18446744073709551616,
+31: 73786976294838206464,
+32: 295147905179352825856,
+33: 1180591620717411303424,
+34: 4722366482869645213696,
+35: 18889465931478580854784,
+36: 75557863725914323419136,
+37: 302231454903657293676544,
+38: 1208925819614629174706176,
+39: 4835703278458516698824704,
+40: 19342813113834066795298816,
+41: 77371252455336267181195264,
+42: 309485009821345068724781056,
+43: 1237940039285380274899124224,
+44: 4951760157141521099596496896,
+45: 19807040628566084398385987584,
+46: 79228162514264337593543950336,
+47: 316912650057057350374175801344,
+48: 1267650600228229401496703205376,
+49: 5070602400912917605986812821504,
+50: 20282409603651670423947251286016,
+51: 81129638414606681695789005144064,
+52: 324518553658426726783156020576256,
+53: 1298074214633706907132624082305024,
+54: 5192296858534827628530496329220096,
+55: 20769187434139310514121985316880384,
+56: 83076749736557242056487941267521536,
+57: 332306998946228968225951765070086144,
+58: 1329227995784915872903807060280344576,
+59: 5316911983139663491615228241121378304,
+60: 21267647932558653966460912964485513216,
+61: 85070591730234615865843651857942052864}
+
+def buildDictionaryCurveLocations(bridges: int) -> dict[int, int]:
+	"""Wait for the writing to finish."""
+	dictionaryCurveLocations: dict[int, int] = {}
+	for curveLocation in Path(pathRoot, str(bridges)).glob('*'):
+		dictionaryCurveLocations[int(curveLocation.stem)] = eval(curveLocation.read_text().strip().rstrip('+'))  # noqa: S307
+	return dictionaryCurveLocations
+
+def recordAnalysis(bridges: int, curveLocationAnalysis: int, distinctCrossings: int) -> None:
+	"""Record and building system should be fluid: it will write to disk when needed."""
+	def _record() -> None:
+		if curveLocationAnalysis < curveMaximum[bridges]:
+			with Path(pathRoot, str(bridges), str(curveLocationAnalysis)).open('a') as appendStream:
+				appendStream.write(f"{distinctCrossings}+")
+
+	bookkeeper = threading.Thread(target=_record)
+	bookkeeper.daemon = True
+	bookkeeper.start()
+
+def analyzeCurves(bridges: int, curveLocations: int, distinctCrossings: int) -> None:
+	bifurcationOdd = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
+	bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+
+	bifurcationOddHasCurves = bifurcationOdd != 1
+	bifurcationEvenHasCurves = bifurcationEven != 1
+	bifurcationOddFinalZero = not bifurcationOdd & 1
+	bifurcationEvenFinalZero = not bifurcationEven & 1
+
+	if bifurcationOddHasCurves:
+		curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
+
+	if bifurcationEvenHasCurves:
+		curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
+
+	curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+	recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
+
+	if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+		XOrHere2makePair = 0b1
+		findUnpairedBinary1 = 0
+		if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
+			bifurcationOdd ^= XOrHere2makePair
+
+		elif bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
+			bifurcationEven ^= XOrHere2makePair
+
+		curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 2) << 1)
+		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
+
+def count(bridges: int, dictionaryCurveLocations: dict[int, int]) -> int:
+	shutil.rmtree(pathRoot, ignore_errors=True)
+	pathRoot.mkdir(exist_ok=True)
+	for n in range(bridges):
+		Path(pathRoot, str(n)).mkdir(exist_ok=True)
+
+	while bridges > 0:
+		bridges -= 1
+
+		for curveLocations, distinctCrossings in dictionaryCurveLocations.items():
+			"""This is now ready for concurrency."""
+			analyzeCurves(bridges, curveLocations, distinctCrossings)
+
+		dictionaryCurveLocations = buildDictionaryCurveLocations(bridges)
+
+	return sum(dictionaryCurveLocations.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/irvineJavaPort.py

@@ -2,16 +2,12 @@
 Ported from the Java version by Sean A. Irvine:
 https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java
 
-This implementation is a conversion from a well-known Java implementation of Lunnon's algorithm
-by Sean A. Irvine, a contributor to the OEIS project. It provides a clean, procedural implementation
-with straightforward variable naming and control flow that may be more approachable for
-programmers familiar with modern languages.
+This implementation is a Python version of a Java implementation of Lunnon's algorithm by Sean A. Irvine.
 
 Key characteristics:
-- Clear variable naming following modern programming conventions
-- Procedural implementation style similar to Java but adapted for Python
-- Follows the same algorithmic structure as Lunnon's original but with cleaner organization
-- Uses primitive Python data structures (lists) without NumPy dependencies
+- Identifiers tend to match Irvine.
+- A procedural paradigm more similar to Lunnon and unlike Irvine's object-oriented implementation.
+- Only primitive Python data structures.
 
 Citation: https://github.com/hunterhogan/mapFolding/blob/134f2e6ecdf59fb6f6829c775475544a6aaaa800/citations/jOEIS.bibtex
 """

mapFolding/reference/matrixMeandersBaseline.py

@@ -0,0 +1,65 @@
+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, bifurcationEvenLocator, bifurcationOddLocator = curveMaximum[bridges]
+
+		for curveLocations, distinctCrossings in getCurveLocations().items():
+			bifurcationEven = (curveLocations & bifurcationEvenLocator) >> 1
+			bifurcationOdd = curveLocations & bifurcationOddLocator
+
+			bifurcationEvenFinalZero = (bifurcationEven & 0b1) == 0
+			bifurcationEvenHasCurves = bifurcationEven != 1
+			bifurcationOddFinalZero = (bifurcationOdd & 0b1) == 0
+			bifurcationOddHasCurves = bifurcationOdd != 1
+
+			if bifurcationEvenHasCurves:
+				curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+			if bifurcationOddHasCurves:
+				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+			if bifurcationEvenHasCurves and bifurcationOddHasCurves and (bifurcationEvenFinalZero or bifurcationOddFinalZero):
+				XOrHere2makePair = 0b1
+				findUnpairedBinary1 = 0
+
+				if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
+					bifurcationEven ^= XOrHere2makePair
+
+				elif bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
+					bifurcationOdd ^= XOrHere2makePair
+
+				curveLocationAnalysis = ((bifurcationEven >> 2) << 1) | (bifurcationOdd >> 2)
+				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	return sum(getCurveLocations().values())