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

mapFolding/_A007822.py

@@ -0,0 +1,181 @@
+from mapFolding import Array1DLeavesTotal, makeDataContainer, NumPyLeavesTotal
+from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.oeis import dictionaryOEIS
+import numpy
+import sys
+import time
+
+def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+	return state.leaf1ndex <= 1
+
+def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+		state = incrementActiveGap(state)
+	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+	return state
+
+def gapAvailable(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	while state.indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+		state.gap1ndexCeiling += 1
+		state.indexLeaf += 1
+	return state
+
+def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex -= 1
+	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+	state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+	state.leaf1ndex += 1
+	return state
+
+def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+	return state.leafBelow[0] == 1
+
+def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def noGapsHere(state: MapFoldingState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+	state.indexDimension += 1
+	return state
+
+def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+	state.leaf1ndex -= 1
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+	return state
+
+def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
+	lengthLeafBelow = len(state.leafBelow)
+
+	indexLeaf: int = 0
+	for leafConnectee in range(lengthLeafBelow):
+		leafNumber = int(state.leafBelow[indexLeaf])
+		state.leafComparison[leafConnectee] = (leafNumber - indexLeaf + lengthLeafBelow - 1) % (lengthLeafBelow - 1)
+		indexLeaf = leafNumber
+
+	indexInMiddle = (lengthLeafBelow - 1) // 2
+	for delta in range(lengthLeafBelow):
+		ImaSymmetricFold = True
+		for leafConnectee in range(indexInMiddle):
+			if state.leafComparison[(delta + leafConnectee) % lengthLeafBelow] != state.leafComparison[(delta + lengthLeafBelow - 2 - leafConnectee) % lengthLeafBelow]:
+				ImaSymmetricFold = False
+				break
+		if ImaSymmetricFold:
+			state.groupsOfFolds += 1
+
+	return state
+
+def count(state: MapFoldingState) -> MapFoldingState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state = filterAsymmetricFolds(state)
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopingThroughTheDimensions(state):
+					state = lookupLeafConnecteeInConnectionGraph(state)
+					if leafConnecteeIsActiveLeaf(state):
+						state = activeLeafUnconstrainedInThisDimension(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = lookForGaps(state)
+							state = tryAnotherLeafConnectee(state)
+					state = tryNextDimension(state)
+				if activeLeafIsUnconstrainedInAllDimensions(state):
+					state = insertActiveLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = undoLastLeafPlacement(state)
+		if gapAvailable(state):
+			state = insertActiveLeafAtGap(state)
+	return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+	state = count(state)
+	state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+	return state
+
+def Z0Z_flowNeedsFixing(mapShape: tuple[int, ...]) -> int:
+	return doTheNeedful(MapFoldingState(mapShape)).groupsOfFolds
+
+if __name__ == '__main__':
+	for n in range(3, 7):
+		mapShape = dictionaryOEIS['A007822']['getMapShape'](n)
+
+		state = MapFoldingState(mapShape)
+		timeStart = time.perf_counter()
+		foldsTotal = doTheNeedful(state).groupsOfFolds
+		sys.stdout.write(f"{foldsTotal == dictionaryOEIS['A007822']['valuesKnown'][n]} {n} {foldsTotal = } {time.perf_counter() - timeStart:.2f}\n")

mapFolding/__init__.py

@@ -46,7 +46,7 @@ from mapFolding._theTypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
-	Array3D as Array3D,
+	Array3DLeavesTotal as Array3DLeavesTotal,
 	DatatypeElephino as DatatypeElephino,
 	DatatypeFoldsTotal as DatatypeFoldsTotal,
 	DatatypeLeavesTotal as DatatypeLeavesTotal,

mapFolding/_oeisFormulas/A000682.py

@@ -1,7 +1,7 @@
-from mapFolding._oeisFormulas.matrixMeanders import count, curveMaximum
+from mapFolding._oeisFormulas.matrixMeanders import count
 
 def initializeA000682(n: int) -> dict[int, int]:
-	curveLocationsMAXIMUM = curveMaximum[n].curveLocationsMAXIMUM
+	curveLocationsMAXIMUM = 1 << (2 * n + 4)
 
 	curveSeed: int = 5 - (n & 0b1) * 4
 	listCurveLocations = [(curveSeed << 1) | curveSeed]

mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -1,5 +1,6 @@
 from mapFolding._oeisFormulas.A000136 import A000136
-from mapFolding._oeisFormulas.matrixMeanders import curveMaximum
+from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.Z0Z_oeisMeanders import dictionaryOEISMeanders
 from mapFolding.oeis import dictionaryOEIS
 import sys
 import time
@@ -8,12 +9,13 @@ import time
 
 if __name__ == '__main__':
 	oeisID = 'A000136'
-	for n in range(3,30):
+	oeisID = 'A000682'
+	for n in range(3, 13):
 
-		# print(n)
+		# sys.stdout.write(f"{n = }\n")
 
 		timeStart = time.perf_counter()
-		foldsTotal = A000136(n)
+		foldsTotal = eval(oeisID)(n)
 		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
-		sys.stdout.write(f"{foldsTotal == dictionaryOEIS[oeisID]['valuesKnown'][n]} {n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
+		sys.stdout.write(f"{foldsTotal == dictionaryOEISMeanders[oeisID]['valuesKnown'][n]} {n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n") # pyright: ignore[reportIndexIssue]
 

mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -8,6 +8,8 @@ from mapFolding._oeisFormulas.A301620 import A301620
 from mapFolding.oeis import getOEISidInformation, getOEISidValues
 import sys
 
+'A001010'
+'A001011'
 oeisIDsMeanders: list[str] = [
 	'A000560',
 	'A000682',

mapFolding/_oeisFormulas/matrixMeanders.py

@@ -1,65 +1,126 @@
-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)
-
+	listCurveMaximums: list[tuple[int, int, int]] = [
+(0x15, 0x2a, 0x10),
+(0x55, 0xaa, 0x40),
+(0x155, 0x2aa, 0x100),
+(0x555, 0xaaa, 0x400),
+(0x1555, 0x2aaa, 0x1000),
+(0x5555, 0xaaaa, 0x4000),
+(0x15555, 0x2aaaa, 0x10000),
+(0x55555, 0xaaaaa, 0x40000),
+(0x155555, 0x2aaaaa, 0x100000),
+(0x555555, 0xaaaaaa, 0x400000),
+(0x1555555, 0x2aaaaaa, 0x1000000),
+(0x5555555, 0xaaaaaaa, 0x4000000),
+(0x15555555, 0x2aaaaaaa, 0x10000000),
+(0x55555555, 0xaaaaaaaa, 0x40000000),
+(0x155555555, 0x2aaaaaaaa, 0x100000000),
+(0x555555555, 0xaaaaaaaaa, 0x400000000),
+(0x1555555555, 0x2aaaaaaaaa, 0x1000000000),
+(0x5555555555, 0xaaaaaaaaaa, 0x4000000000),
+(0x15555555555, 0x2aaaaaaaaaa, 0x10000000000),
+(0x55555555555, 0xaaaaaaaaaaa, 0x40000000000),
+(0x155555555555, 0x2aaaaaaaaaaa, 0x100000000000),
+(0x555555555555, 0xaaaaaaaaaaaa, 0x400000000000),
+(0x1555555555555, 0x2aaaaaaaaaaaa, 0x1000000000000),
+(0x5555555555555, 0xaaaaaaaaaaaaa, 0x4000000000000),
+(0x15555555555555, 0x2aaaaaaaaaaaaa, 0x10000000000000),
+(0x55555555555555, 0xaaaaaaaaaaaaaa, 0x40000000000000),
+(0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
+(0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
+(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000),
+(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000),
+(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
+(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
+(0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
+(0x555555555555555555, 0xaaaaaaaaaaaaaaaaaa, 0x400000000000000000),
+(0x1555555555555555555, 0x2aaaaaaaaaaaaaaaaaa, 0x1000000000000000000),
+(0x5555555555555555555, 0xaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000),
+(0x15555555555555555555, 0x2aaaaaaaaaaaaaaaaaaa, 0x10000000000000000000),
+(0x55555555555555555555, 0xaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000),
+(0x155555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000),
+(0x555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000),
+(0x1555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000),
+(0x5555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000),
+(0x15555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000),
+(0x55555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000),
+(0x155555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000),
+(0x555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000),
+(0x1555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000),
+(0x5555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000),
+(0x15555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000),
+(0x55555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000),
+(0x155555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000),
+(0x555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000),
+(0x1555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000),
+(0x5555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000),
+(0x15555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000),
+(0x55555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000),
+(0x155555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000000),
+(0x555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000000),
+(0x1555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000000),
+(0x5555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000000),
+(0x15555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000000),
+(0x55555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000000),
+]
+	listCurveMaximums = listCurveMaximums[0:bridges]
+
+	dictionaryCurveLocations: dict[int, int] = {}
 	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())
+		bifurcationAlphaLocator, bifurcationZuluLocator, curveLocationsMAXIMUM = listCurveMaximums[bridges]
+		for curveLocations, distinctCrossings in startingCurveLocations.items():
+			bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+
+			# Curve location analysis
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# Curve location analysis, conditional
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | (bifurcationZuluIsEven := not (bifurcationZulu & 1))
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# Curve location analysis, conditional
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlphaShiftRight2 := bifurcationAlpha >> 2) | (bifurcationZulu << 3) | ((bifurcationAlphaIsEven := 1 - (bifurcationAlpha & 0b1)) << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# Curve location analysis, uber-conditional
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves:
+				# One Truth-check to select a code path
+				finalZeroCombination = (bifurcationZuluIsEven << 1) | bifurcationAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
+
+				if finalZeroCombination != 0:  # Case 0 (False, False)
+					XOrHere2makePair = 0b1
+					findUnpairedBinary1 = 0
+
+					if finalZeroCombination == 1:  # Case 1: (False, True)
+						while findUnpairedBinary1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+						bifurcationAlphaShiftRight2 = (bifurcationAlpha ^ XOrHere2makePair) >> 2
+					elif finalZeroCombination == 2:  # Case 2: (True, False)
+						while findUnpairedBinary1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+						bifurcationZulu ^= XOrHere2makePair
+
+					# Cases 1, 2, and 3 all compute curveLocationAnalysis
+# TODO https://github.com/hunterhogan/mapFolding/issues/19
+					curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | bifurcationAlphaShiftRight2 # pyright: ignore[reportPossiblyUnboundVariable]
+					if curveLocationAnalysis < curveLocationsMAXIMUM:
+						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+		startingCurveLocations = dictionaryCurveLocations.copy()
+		dictionaryCurveLocations = {}
+
+	return sum(startingCurveLocations.values())

mapFolding/_oeisFormulas/matrixMeandersAnnex.py

@@ -2,81 +2,81 @@ from typing import NamedTuple
 import sys
 
 class limitLocators(NamedTuple):
+	bifurcationAlphaLocator: int
+	bifurcationZuluLocator: int
 	curveLocationsMAXIMUM: int
-	bifurcationEvenLocator: int
-	bifurcationOddLocator: 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),
+0: limitLocators(0x15, 0x2a, 0x10),
+1: limitLocators(0x55, 0xaa, 0x40),
+2: limitLocators(0x155, 0x2aa, 0x100),
+3: limitLocators(0x555, 0xaaa, 0x400),
+4: limitLocators(0x1555, 0x2aaa, 0x1000),
+5: limitLocators(0x5555, 0xaaaa, 0x4000),
+6: limitLocators(0x15555, 0x2aaaa, 0x10000),
+7: limitLocators(0x55555, 0xaaaaa, 0x40000),
+8: limitLocators(0x155555, 0x2aaaaa, 0x100000),
+9: limitLocators(0x555555, 0xaaaaaa, 0x400000),
+10: limitLocators(0x1555555, 0x2aaaaaa, 0x1000000),
+11: limitLocators(0x5555555, 0xaaaaaaa, 0x4000000),
+12: limitLocators(0x15555555, 0x2aaaaaaa, 0x10000000),
+13: limitLocators(0x55555555, 0xaaaaaaaa, 0x40000000),
+14: limitLocators(0x155555555, 0x2aaaaaaaa, 0x100000000),
+15: limitLocators(0x555555555, 0xaaaaaaaaa, 0x400000000),
+16: limitLocators(0x1555555555, 0x2aaaaaaaaa, 0x1000000000),
+17: limitLocators(0x5555555555, 0xaaaaaaaaaa, 0x4000000000),
+18: limitLocators(0x15555555555, 0x2aaaaaaaaaa, 0x10000000000),
+19: limitLocators(0x55555555555, 0xaaaaaaaaaaa, 0x40000000000),
+20: limitLocators(0x155555555555, 0x2aaaaaaaaaaa, 0x100000000000),
+21: limitLocators(0x555555555555, 0xaaaaaaaaaaaa, 0x400000000000),
+22: limitLocators(0x1555555555555, 0x2aaaaaaaaaaaa, 0x1000000000000),
+23: limitLocators(0x5555555555555, 0xaaaaaaaaaaaaa, 0x4000000000000),
+24: limitLocators(0x15555555555555, 0x2aaaaaaaaaaaaa, 0x10000000000000),
+25: limitLocators(0x55555555555555, 0xaaaaaaaaaaaaaa, 0x40000000000000),
+26: limitLocators(0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
+27: limitLocators(0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
+28: limitLocators(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+29: limitLocators(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000),
+30: limitLocators(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
+31: limitLocators(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
+32: limitLocators(0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
+33: limitLocators(0x555555555555555555, 0xaaaaaaaaaaaaaaaaaa, 0x400000000000000000),
+34: limitLocators(0x1555555555555555555, 0x2aaaaaaaaaaaaaaaaaa, 0x1000000000000000000),
+35: limitLocators(0x5555555555555555555, 0xaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000),
+36: limitLocators(0x15555555555555555555, 0x2aaaaaaaaaaaaaaaaaaa, 0x10000000000000000000),
+37: limitLocators(0x55555555555555555555, 0xaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000),
+38: limitLocators(0x155555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000),
+39: limitLocators(0x555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000),
+40: limitLocators(0x1555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000),
+41: limitLocators(0x5555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000),
+42: limitLocators(0x15555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000),
+43: limitLocators(0x55555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000),
+44: limitLocators(0x155555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000),
+45: limitLocators(0x555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000),
+46: limitLocators(0x1555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000),
+47: limitLocators(0x5555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000),
+48: limitLocators(0x15555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000),
+49: limitLocators(0x55555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000),
+50: limitLocators(0x155555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000),
+51: limitLocators(0x555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000),
+52: limitLocators(0x1555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000),
+53: limitLocators(0x5555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000),
+54: limitLocators(0x15555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000),
+55: limitLocators(0x55555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000),
+56: limitLocators(0x155555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000000),
+57: limitLocators(0x555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000000),
+58: limitLocators(0x1555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000000),
+59: limitLocators(0x5555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000000),
+60: limitLocators(0x15555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000000),
+61: limitLocators(0x55555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000000),
 }
 
 def makeCurveMaximum() -> None:
 	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
 	for n in range(62):
 		curveLocationsMAXIMUM = 1 << (2 * n + 4)
-		bifurcationOddLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
-		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationOddLocator << 1)}, {hex(bifurcationOddLocator)}),\n")
+		bifurcationAlphaLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
+		sys.stdout.write(f"{n}: limitLocators({hex(bifurcationAlphaLocator)}, {hex(bifurcationAlphaLocator << 1)}, {hex(curveLocationsMAXIMUM)}),\n")
 	sys.stdout.write("}\n")
 
 if __name__ == '__main__':

mapFolding/_theSSOT.py

@@ -76,19 +76,19 @@ concurrencyPackage = concurrencyPackageHARDCODED
 # TODO I made a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
 settingsOEISManuallySelected: dict[str, MetadataOEISidManuallySet] = {
 	'A000136': {
-		'getMapShape': lambda n: tuple(sorted([1, n])),
+		'getMapShape': lambda n: (1, n),
 		'valuesBenchmark': [14],
 		'valuesTestParallelization': [*range(3, 7)],
 		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
 	},
 	'A001415': {
-		'getMapShape': lambda n: tuple(sorted([2, n])),
+		'getMapShape': lambda n: (2, n),
 		'valuesBenchmark': [14],
 		'valuesTestParallelization': [*range(3, 7)],
 		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
 	},
 	'A001416': {
-		'getMapShape': lambda n: tuple(sorted([3, n])),
+		'getMapShape': lambda n: (3, n),
 		'valuesBenchmark': [9],
 		'valuesTestParallelization': [*range(3, 5)],
 		'valuesTestValidation': [random.randint(2, 6)],  # noqa: S311
@@ -111,6 +111,12 @@ settingsOEISManuallySelected: dict[str, MetadataOEISidManuallySet] = {
 		'valuesTestParallelization': [*range(2, 4)],
 		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
 	},
+	'A007822': {
+		'getMapShape': lambda n: (1, 2 * n),
+		'valuesBenchmark': [7],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
+	},
 }
 
 packageSettings = mapFoldingPackageSettings(