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

mapFolding/reference/A005316write2disk.py

@@ -86,41 +86,41 @@ def recordAnalysis(bridges: int, curveLocationAnalysis: int, distinctCrossings:
 	bookkeeper.start()
 
 def analyzeCurves(bridges: int, curveLocations: int, distinctCrossings: int) -> None:
-	bifurcationOdd = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
-	bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+	bifurcationAlpha = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
+	bifurcationZulu = (curveLocations ^ bifurcationAlpha) >> 1
 
-	bifurcationOddHasCurves = bifurcationOdd != 1
-	bifurcationEvenHasCurves = bifurcationEven != 1
-	bifurcationOddFinalZero = not bifurcationOdd & 1
-	bifurcationEvenFinalZero = not bifurcationEven & 1
+	bifurcationAlphaHasCurves = bifurcationAlpha != 1
+	bifurcationZuluHasCurves = bifurcationZulu != 1
+	bifurcationAlphaFinalZero = not bifurcationAlpha & 1
+	bifurcationZuluFinalZero = not bifurcationZulu & 1
 
-	if bifurcationOddHasCurves:
-		curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+	if bifurcationAlphaHasCurves:
+		curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
 		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
-	if bifurcationEvenHasCurves:
-		curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+	if bifurcationZuluHasCurves:
+		curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
 		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
-	curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+	curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 	recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
-	if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+	if bifurcationAlphaHasCurves and bifurcationZuluHasCurves and (bifurcationAlphaFinalZero or bifurcationZuluFinalZero):
 		XOrHere2makePair = 0b1
 		findUnpairedBinary1 = 0
-		if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+		if bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
 			while findUnpairedBinary1 >= 0:
 				XOrHere2makePair <<= 2
-				findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
-			bifurcationOdd ^= XOrHere2makePair
+				findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+			bifurcationAlpha ^= XOrHere2makePair
 
-		elif bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+		elif bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
 			while findUnpairedBinary1 >= 0:
 				XOrHere2makePair <<= 2
-				findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
-			bifurcationEven ^= XOrHere2makePair
+				findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+			bifurcationZulu ^= XOrHere2makePair
 
-		curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 2) << 1)
+		curveLocationAnalysis = (bifurcationAlpha >> 2) | ((bifurcationZulu >> 2) << 1)
 		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
 def count(bridges: int, dictionaryCurveLocations: dict[int, int]) -> int:

mapFolding/reference/matrixMeandersBaseline.py

@@ -21,45 +21,45 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 
 	while bridges > 0:
 		bridges -= 1
-		curveLocationsMAXIMUM, bifurcationEvenLocator, bifurcationOddLocator = curveMaximum[bridges]
+		curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = curveMaximum[bridges]
 
 		for curveLocations, distinctCrossings in getCurveLocations().items():
-			bifurcationEven = (curveLocations & bifurcationEvenLocator) >> 1
-			bifurcationOdd = curveLocations & bifurcationOddLocator
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+			bifurcationAlpha = curveLocations & bifurcationAlphaLocator
 
-			bifurcationEvenFinalZero = (bifurcationEven & 0b1) == 0
-			bifurcationEvenHasCurves = bifurcationEven != 1
-			bifurcationOddFinalZero = (bifurcationOdd & 0b1) == 0
-			bifurcationOddHasCurves = bifurcationOdd != 1
+			bifurcationZuluFinalZero = (bifurcationZulu & 0b1) == 0
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+			bifurcationAlphaFinalZero = (bifurcationAlpha & 0b1) == 0
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
 
-			if bifurcationEvenHasCurves:
-				curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
 				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
-			if bifurcationOddHasCurves:
-				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
 				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
-			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 			recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
-			if bifurcationEvenHasCurves and bifurcationOddHasCurves and (bifurcationEvenFinalZero or bifurcationOddFinalZero):
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves and (bifurcationZuluFinalZero or bifurcationAlphaFinalZero):
 				XOrHere2makePair = 0b1
 				findUnpairedBinary1 = 0
 
-				if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+				if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
 					while findUnpairedBinary1 >= 0:
 						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
-					bifurcationEven ^= XOrHere2makePair
+						findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+					bifurcationZulu ^= XOrHere2makePair
 
-				elif bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+				elif bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
 					while findUnpairedBinary1 >= 0:
 						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
-					bifurcationOdd ^= XOrHere2makePair
+						findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+					bifurcationAlpha ^= XOrHere2makePair
 
-				curveLocationAnalysis = ((bifurcationEven >> 2) << 1) | (bifurcationOdd >> 2)
+				curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
 				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
 	return sum(getCurveLocations().values())

mapFolding/reference/matrixMeandersBaselineAnnex.py

@@ -3,8 +3,8 @@ import sys
 
 class limitLocators(NamedTuple):
 	curveLocationsMAXIMUM: int
-	bifurcationEvenLocator: int
-	bifurcationOddLocator: int
+	bifurcationZuluLocator: int
+	bifurcationAlphaLocator: int
 
 curveMaximum: dict[int, limitLocators] = {
 0: limitLocators(16, 0x2a, 0x15),
@@ -75,8 +75,8 @@ 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({curveLocationsMAXIMUM}, {hex(bifurcationAlphaLocator << 1)}, {hex(bifurcationAlphaLocator)}),\n")
 	sys.stdout.write("}\n")
 
 if __name__ == '__main__':

mapFolding/reference/matrixMeandersSimpleQueue.py

@@ -0,0 +1,90 @@
+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/reference/matrixMeandersSlicePop.py

@@ -0,0 +1,104 @@
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	listCurveMaximums: list[tuple[int, int, int]] = [
+	(16, 0x2a, 0x15),
+	(64, 0xaa, 0x55),
+	(256, 0x2aa, 0x155),
+	(1024, 0xaaa, 0x555),
+	(4096, 0x2aaa, 0x1555),
+	(16384, 0xaaaa, 0x5555),
+	(65536, 0x2aaaa, 0x15555),
+	(262144, 0xaaaaa, 0x55555),
+	(1048576, 0x2aaaaa, 0x155555),
+	(4194304, 0xaaaaaa, 0x555555),
+	(16777216, 0x2aaaaaa, 0x1555555),
+	(67108864, 0xaaaaaaa, 0x5555555),
+	(268435456, 0x2aaaaaaa, 0x15555555),
+	(1073741824, 0xaaaaaaaa, 0x55555555),
+	(4294967296, 0x2aaaaaaaa, 0x155555555),
+	(17179869184, 0xaaaaaaaaa, 0x555555555),
+	(68719476736, 0x2aaaaaaaaa, 0x1555555555),
+	(274877906944, 0xaaaaaaaaaa, 0x5555555555),
+	(1099511627776, 0x2aaaaaaaaaa, 0x15555555555),
+	(4398046511104, 0xaaaaaaaaaaa, 0x55555555555),
+	(17592186044416, 0x2aaaaaaaaaaa, 0x155555555555),
+	(70368744177664, 0xaaaaaaaaaaaa, 0x555555555555),
+	(281474976710656, 0x2aaaaaaaaaaaa, 0x1555555555555),
+	(1125899906842624, 0xaaaaaaaaaaaaa, 0x5555555555555),
+	(4503599627370496, 0x2aaaaaaaaaaaaa, 0x15555555555555),
+	(18014398509481984, 0xaaaaaaaaaaaaaa, 0x55555555555555),
+	(72057594037927936, 0x2aaaaaaaaaaaaaa, 0x155555555555555),
+	(288230376151711744, 0xaaaaaaaaaaaaaaa, 0x555555555555555),
+	(1152921504606846976, 0x2aaaaaaaaaaaaaaa, 0x1555555555555555), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+	(4611686018427387904, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555),
+	(18446744073709551616, 0x2aaaaaaaaaaaaaaaa, 0x15555555555555555),
+	(73786976294838206464, 0xaaaaaaaaaaaaaaaaa, 0x55555555555555555),
+	(295147905179352825856, 0x2aaaaaaaaaaaaaaaaa, 0x155555555555555555),
+	(1180591620717411303424, 0xaaaaaaaaaaaaaaaaaa, 0x555555555555555555),
+	(4722366482869645213696, 0x2aaaaaaaaaaaaaaaaaa, 0x1555555555555555555),
+	(18889465931478580854784, 0xaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555),
+	(75557863725914323419136, 0x2aaaaaaaaaaaaaaaaaaa, 0x15555555555555555555),
+	(302231454903657293676544, 0xaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555),
+	(1208925819614629174706176, 0x2aaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555),
+	(4835703278458516698824704, 0xaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555),
+	(19342813113834066795298816, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555),
+	(77371252455336267181195264, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555),
+	(309485009821345068724781056, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555),
+	(1237940039285380274899124224, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555),
+	(4951760157141521099596496896, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555),
+	(19807040628566084398385987584, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555),
+	]
+
+	listCurveMaximums = listCurveMaximums[0:bridges]
+	dictionaryCurveLocations: dict[int, int] = {}
+
+	while bridges > 0:
+		bridges -= 1
+
+		curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = listCurveMaximums.pop()
+
+		for curveLocations, distinctCrossings in startingCurveLocations.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
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + 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)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+		startingCurveLocations = dictionaryCurveLocations.copy()
+		dictionaryCurveLocations = {}
+
+	return sum(startingCurveLocations.values())

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -232,7 +232,7 @@ class DeReConstructField2ast:
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, 'dtype')
 			axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Name('uint8'))
 			dtype_asnameName: ast.Name = self.astAnnotation
-			if dtype_asnameName.id == 'Array3D':
+			if dtype_asnameName.id == 'Array3DLeavesTotal':
 				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8'), Make.Name('uint8')]))
 			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))
 			constructor = 'array'

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -292,7 +292,7 @@ if __name__ == '__main__':
 	listNumPyTypeConfigs = [
 		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
 		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
-		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3D'),
+		DatatypeConfig(fml='Array3DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3DLeavesTotal'),
 	]
 
 	for typeConfig in listNumPyTypeConfigs:

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -58,7 +58,7 @@ listDatatypeConfigurations: list[DatatypeConfiguration] = [
 listNumPy_dtype: list[DatatypeConfiguration] = [
 	DatatypeConfiguration(datatypeIdentifier='Array1DLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='Array1DLeavesTotal'),
 	DatatypeConfiguration(datatypeIdentifier='Array1DElephino', typeModule='numpy', typeIdentifier='uint8', type_asname='Array1DElephino'),
-	DatatypeConfiguration(datatypeIdentifier='Array3D', typeModule='numpy', typeIdentifier='uint8', type_asname='Array3D'),
+	DatatypeConfiguration(datatypeIdentifier='Array3DLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='Array3DLeavesTotal'),
 ]
 
 def _addWriteFoldsTotal(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:

mapFolding/syntheticModules/countParallel.py

@@ -1,13 +1,16 @@
 from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, ParallelMapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	ParallelMapFoldingState)
 from multiprocessing import set_start_method as multiprocessing_set_start_method
 from numba import jit
+
 if __name__ == '__main__':
     multiprocessing_set_start_method('spawn')
 
 @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, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+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, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 0:
         if leaf1ndex <= 1 or leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -72,7 +75,7 @@ def unRepackParallelMapFoldingState(state: ParallelMapFoldingState) -> ParallelM
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    connectionGraph: Array3D = state.connectionGraph
+    connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     taskDivisions: DatatypeLeavesTotal = state.taskDivisions
@@ -95,4 +98,4 @@ def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple
             listStatesParallel[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
             groupsOfFoldsTotal += listStatesParallel[indexSherpa].groupsOfFolds
     foldsTotal: int = groupsOfFoldsTotal * stateParallel.leavesTotal
-    return (foldsTotal, listStatesParallel)
+    return (foldsTotal, listStatesParallel)

mapFolding/syntheticModules/daoOfMapFolding.py

@@ -1,8 +1,10 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+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, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+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, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 0:
         if leaf1ndex <= 1 or leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -66,9 +68,9 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    connectionGraph: Array3D = state.connectionGraph
+    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, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, 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)
-    return state
+    return state

mapFolding/syntheticModules/dataPacking.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from mapFolding.syntheticModules.theorem2Numba import count
 
 def sequential(state: MapFoldingState) -> MapFoldingState:
@@ -17,9 +19,9 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    connectionGraph: Array3D = state.connectionGraph
+    connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, 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)
-    return state
+    return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -1,8 +1,9 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
-def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 4:
         if leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -42,4 +43,4 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
         gapRangeStart[leaf1ndex] = gap1ndex
         leaf1ndex += 1
     groupsOfFolds *= 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)

{mapfolding-0.14.0.dist-info → mapfolding-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.14.0
+Version: 0.15.0
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
-Keywords: A000136,A000560,A000682,A001415,A001416,A001417,A001418,A005315,A005316,A195646,A223094,A259702,A301620,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,AST manipulation,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,GPU acceleration,high-performance computing,integer sequences,JIT compilation,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,Numba optimization,numerical algorithms,numerical computation,OEIS,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,Python optimization,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,topological combinatorics,topological patterns,typed Python
+Keywords: A000136,A000560,A000682,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A195646,A223094,A259702,A301620,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,AST manipulation,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,GPU acceleration,high-performance computing,integer sequences,JIT compilation,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,Numba optimization,numerical algorithms,numerical computation,OEIS,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,Python optimization,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -34,15 +34,14 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: astToolkit>=0.7.1
-Requires-Dist: cytoolz
+Requires-Dist: astToolkit
 Requires-Dist: hunterMakesPy
-Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"
+Requires-Dist: py-spy; extra == "development"
 Requires-Dist: setuptools-scm; extra == "development"
 Provides-Extra: numba
 Requires-Dist: numba; extra == "numba"