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

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()
-

mapFolding/reference/meandersDumpingGround/matrixMeandersSimpleQueue.py

@@ -1,90 +0,0 @@
-from mapFolding._oeisFormulas.matrixMeandersAnnex import curveMaximum as curveMaximum
-from queue import Empty, SimpleQueue
-from typing import NamedTuple
-import contextlib
-
-class BifurcatedCurves(NamedTuple):
-    bifurcationZulu: int
-    bifurcationAlpha: int
-    distinctCrossings: int
-    curveLocationsMAXIMUM: int
-
-dictionaryCurveLocations: dict[int, int] = {}
-simpleQueueCurveLocations: SimpleQueue[tuple[int, int]] = SimpleQueue()
-
-def unpackQueue() -> dict[int, int]:
-	with contextlib.suppress(Empty):
-		while True:
-			curveLocations, distinctCrossings = simpleQueueCurveLocations.get_nowait()
-			dictionaryCurveLocations[curveLocations] = dictionaryCurveLocations.get(curveLocations, 0) + distinctCrossings
-
-	return dictionaryCurveLocations
-
-def getCurveLocations(bridges: int) -> list[BifurcatedCurves]:
-	global dictionaryCurveLocations  # noqa: PLW0603
-	dictionaryCurveLocations = unpackQueue()
-	curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = curveMaximum[bridges]
-	listBifurcatedCurves: list[BifurcatedCurves] = []
-	# TODO This is ready for concurrency and/or vectorization.
-	for curveLocations, distinctCrossings in dictionaryCurveLocations.items():
-		bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
-		bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
-		listBifurcatedCurves.append(BifurcatedCurves(bifurcationZulu, bifurcationAlpha, distinctCrossings, curveLocationsMAXIMUM))
-	dictionaryCurveLocations = {}
-	return listBifurcatedCurves
-
-def recordAnalysis(curveLocationAnalysis: int, curveLocationsMAXIMUM: int, distinctCrossings: int) -> None:
-	if curveLocationAnalysis < curveLocationsMAXIMUM:
-		simpleQueueCurveLocations.put((curveLocationAnalysis, distinctCrossings))
-
-def analyzeCurve(bifurcationZulu: int, bifurcationAlpha: int, distinctCrossings: int, curveLocationsMAXIMUM: int) -> None:
-	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)
-
-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
-
-		# TODO This could be parallelized when `recordAnalysis` is thread-safe
-		for bifurcatedCurve in getCurveLocations(bridges):
-			analyzeCurve(*bifurcatedCurve)
-
-	return getCurveLocations(bridges)[0].distinctCrossings

mapFolding/syntheticModules/A007822/algorithmNumba.py

@@ -1,94 +0,0 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
-from numba import jit
-
-@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
-def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > leavesTotal:
-                indexLeaf = 0
-                leafConnectee = 0
-                while leafConnectee < leavesTotal + 1:
-                    leafNumber = int(leafBelow[indexLeaf])
-                    leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
-                    indexLeaf = leafNumber
-                    leafConnectee += 1
-                indexInMiddle = leavesTotal // 2
-                indexMiniGap = 0
-                while indexMiniGap < leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
-                            ImaSymmetricFold = False
-                            break
-                        leafConnectee += 1
-                    groupsOfFolds += ImaSymmetricFold
-                    indexMiniGap += 1
-            else:
-                dimensionsUnconstrained = dimensionsTotal
-                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-                indexDimension = 0
-                while indexDimension < dimensionsTotal:
-                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                    if leafConnectee == leaf1ndex:
-                        dimensionsUnconstrained -= 1
-                    else:
-                        while leafConnectee != leaf1ndex:
-                            gapsWhere[gap1ndexCeiling] = leafConnectee
-                            if countDimensionsGapped[leafConnectee] == 0:
-                                gap1ndexCeiling += 1
-                            countDimensionsGapped[leafConnectee] += 1
-                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                    indexDimension += 1
-                if not dimensionsUnconstrained:
-                    indexLeaf = 0
-                    while indexLeaf < leaf1ndex:
-                        gapsWhere[gap1ndexCeiling] = indexLeaf
-                        gap1ndexCeiling += 1
-                        indexLeaf += 1
-                indexMiniGap = gap1ndex
-                while indexMiniGap < gap1ndexCeiling:
-                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                        gap1ndex += 1
-                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                    indexMiniGap += 1
-        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex > 0:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    groupsOfFolds = (groupsOfFolds + 1) // 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
-
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
-    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
-    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
-    gap1ndex: DatatypeElephino = state.gap1ndex
-    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
-    indexDimension: DatatypeLeavesTotal = state.indexDimension
-    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
-    indexMiniGap: DatatypeElephino = state.indexMiniGap
-    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
-    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
-    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
-    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
-    gapRangeStart: Array1DElephino = state.gapRangeStart
-    gapsWhere: Array1DLeavesTotal = state.gapsWhere
-    leafAbove: Array1DLeavesTotal = state.leafAbove
-    leafBelow: Array1DLeavesTotal = state.leafBelow
-    leafComparison: Array1DLeavesTotal = state.leafComparison
-    connectionGraph: Array3DLeavesTotal = state.connectionGraph
-    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
-    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
-    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state

mapFolding/syntheticModules/A007822/asynchronousAnnex.py

@@ -1,66 +0,0 @@
-from concurrent.futures import Future as ConcurrentFuture, ThreadPoolExecutor
-from hunterMakesPy import raiseIfNone
-from mapFolding import Array1DLeavesTotal
-from queue import Empty, Queue
-from threading import Thread
-import numpy
-
-concurrencyManager = None
-groupsOfFoldsTotal: int = 0
-processingThread = None
-queueFutures: Queue[ConcurrentFuture[int]] = Queue()
-
-def initializeConcurrencyManager(maxWorkers: int | None=None, groupsOfFolds: int=0) -> None:
-    global concurrencyManager, queueFutures, groupsOfFoldsTotal, processingThread
-    concurrencyManager = ThreadPoolExecutor(max_workers=maxWorkers)
-    queueFutures = Queue()
-    groupsOfFoldsTotal = groupsOfFolds
-    processingThread = Thread(target=_processCompletedFutures)
-    processingThread.start()
-
-def _processCompletedFutures() -> None:
-    global queueFutures, groupsOfFoldsTotal
-    while True:
-        try:
-            claimTicket: ConcurrentFuture[int] = queueFutures.get(timeout=1)
-            if claimTicket is None:
-                break
-            groupsOfFoldsTotal += claimTicket.result()
-        except Empty:
-            continue
-
-def _filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> int:
-    groupsOfFolds = 0
-    leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
-    leavesTotal = leafBelow.size - 1
-    indexLeaf = 0
-    leafConnectee = 0
-    while leafConnectee < leavesTotal + 1:
-        leafNumber = int(leafBelow[indexLeaf])
-        leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
-        indexLeaf = leafNumber
-        leafConnectee += 1
-    indexInMiddle = leavesTotal // 2
-    indexDistance = 0
-    while indexDistance < leavesTotal + 1:
-        ImaSymmetricFold = True
-        leafConnectee = 0
-        while leafConnectee < indexInMiddle:
-            if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
-                ImaSymmetricFold = False
-                break
-            leafConnectee += 1
-        groupsOfFolds += ImaSymmetricFold
-        indexDistance += 1
-    return groupsOfFolds
-
-def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> None:
-    global concurrencyManager, queueFutures
-    queueFutures.put_nowait(raiseIfNone(concurrencyManager).submit(_filterAsymmetricFolds, leafBelow.copy()))
-
-def getSymmetricFoldsTotal() -> int:
-    global concurrencyManager, queueFutures, processingThread
-    raiseIfNone(concurrencyManager).shutdown(wait=True)
-    queueFutures.put(None)
-    raiseIfNone(processingThread).join()
-    return groupsOfFoldsTotal

mapFolding/syntheticModules/A007822/asynchronousAnnexNumba.py

@@ -1,70 +0,0 @@
-from mapFolding import Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
-from queue import Queue
-from threading import Lock, Thread
-import numba
-import numpy
-
-listThreads: list[Thread] = []
-queueFutures: Queue[Array1DLeavesTotal] = Queue()
-groupsOfFoldsTotal: int = 0
-groupsOfFoldsTotalLock = Lock()
-sentinelStop = object()
-
-def initializeConcurrencyManager(maxWorkers: int, groupsOfFolds: int=0) -> None:
-	global listThreads, groupsOfFoldsTotal, queueFutures  # noqa: PLW0603
-	listThreads = []
-	queueFutures = Queue()
-	groupsOfFoldsTotal = groupsOfFolds
-	indexThread = 0
-	while indexThread < maxWorkers:
-		thread = Thread(target=_threadDoesSomething, name=f"thread{indexThread}", daemon=True)
-		thread.start()
-		listThreads.append(thread)
-		indexThread += 1
-
-def _threadDoesSomething() -> None:
-	global groupsOfFoldsTotal  # noqa: PLW0603
-	while True:
-		leafBelow = queueFutures.get()
-		if leafBelow is sentinelStop:  # pyright: ignore[reportUnnecessaryComparison]
-			break
-		symmetricFolds = _filterAsymmetricFolds(leafBelow)
-		with groupsOfFoldsTotalLock:
-			groupsOfFoldsTotal += symmetricFolds
-
-@numba.jit(cache=True, error_model='numpy', fastmath=True)
-def _filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> int:
-	groupsOfFolds = 0
-	leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
-	leavesTotal = leafBelow.size - 1
-	indexLeaf = 0
-	leafConnectee = 0
-	while leafConnectee < leavesTotal + 1:
-		leafNumber = int(leafBelow[indexLeaf])
-		leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
-		indexLeaf = leafNumber
-		leafConnectee += 1
-	indexInMiddle = leavesTotal // 2
-	indexDistance = 0
-	while indexDistance < leavesTotal + 1:
-		ImaSymmetricFold = True
-		leafConnectee = 0
-		while leafConnectee < indexInMiddle:
-			if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
-				ImaSymmetricFold = False
-				break
-			leafConnectee += 1
-		groupsOfFolds += ImaSymmetricFold
-		indexDistance += 1
-	return groupsOfFolds
-
-def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> None:
-	queueFutures.put_nowait(leafBelow.copy())
-
-def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
-	global listThreads  # noqa: PLW0602
-	for _thread in listThreads:
-		queueFutures.put(sentinelStop)  # pyright: ignore[reportArgumentType]
-	for thread in listThreads:
-		thread.join()
-	return groupsOfFoldsTotal