mapFolding 0.15.2__tar.gz → 0.15.3__tar.gz

{mapfolding-0.15.2 → mapfolding-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.15.2
+Version: 0.15.3
 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
@@ -39,6 +39,7 @@ Requires-Dist: hunterMakesPy
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Provides-Extra: development
+Requires-Dist: memray; sys_platform == "linux" and extra == "development"
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"
 Requires-Dist: py-spy; extra == "development"

mapfolding-0.15.3/mapFolding/_oeisFormulas/A000682.py

@@ -0,0 +1,85 @@
+"""Semi-meanders.
+
+n = 3   `startingCurveLocations` keys = 3
+n = 4   `startingCurveLocations` keys = 4
+n = 5   `startingCurveLocations` keys = 4
+n = 6   `startingCurveLocations` keys = 5
+n = 7   `startingCurveLocations` keys = 5
+n = 8   `startingCurveLocations` keys = 6
+n = 9   `startingCurveLocations` keys = 6
+n = 10  `startingCurveLocations` keys = 7
+n = 11  `startingCurveLocations` keys = 7
+n = 12  `startingCurveLocations` keys = 8
+n = 13  `startingCurveLocations` keys = 8
+n = 14  `startingCurveLocations` keys = 9
+n = 15  `startingCurveLocations` keys = 9
+n = 16  `startingCurveLocations` keys = 10
+n = 17  `startingCurveLocations` keys = 10
+n = 18  `startingCurveLocations` keys = 11
+n = 19  `startingCurveLocations` keys = 11
+n = 20  `startingCurveLocations` keys = 12
+n = 21  `startingCurveLocations` keys = 12
+n = 22  `startingCurveLocations` keys = 13
+n = 23  `startingCurveLocations` keys = 13
+n = 24  `startingCurveLocations` keys = 14
+n = 25  `startingCurveLocations` keys = 14
+n = 26  `startingCurveLocations` keys = 15
+n = 27  `startingCurveLocations` keys = 15
+n = 28  `startingCurveLocations` keys = 16
+n = 29  `startingCurveLocations` keys = 16
+n = 30  `startingCurveLocations` keys = 17
+n = 31  `startingCurveLocations` keys = 17
+n = 32  `startingCurveLocations` keys = 18
+n = 33  `startingCurveLocations` keys = 18
+n = 34  `startingCurveLocations` keys = 19
+n = 35  `startingCurveLocations` keys = 19
+n = 36  `startingCurveLocations` keys = 20
+n = 37  `startingCurveLocations` keys = 20
+n = 38  `startingCurveLocations` keys = 21
+n = 39  `startingCurveLocations` keys = 21
+n = 40  `startingCurveLocations` keys = 22
+n = 41  `startingCurveLocations` keys = 22
+n = 42  `startingCurveLocations` keys = 23
+n = 43  `startingCurveLocations` keys = 23
+n = 44  `startingCurveLocations` keys = 24
+n = 45  `startingCurveLocations` keys = 24
+n = 46  `startingCurveLocations` keys = 25
+n = 47  `startingCurveLocations` keys = 25
+n = 48  `startingCurveLocations` keys = 26
+n = 49  `startingCurveLocations` keys = 26
+n = 50  `startingCurveLocations` keys = 27
+n = 51  `startingCurveLocations` keys = 27
+n = 52  `startingCurveLocations` keys = 28
+n = 53  `startingCurveLocations` keys = 28
+n = 54  `startingCurveLocations` keys = 29
+n = 55  `startingCurveLocations` keys = 29
+n = 56  `startingCurveLocations` keys = 30
+n = 57  `startingCurveLocations` keys = 30
+n = 58  `startingCurveLocations` keys = 31
+n = 59  `startingCurveLocations` keys = 31
+n = 60  `startingCurveLocations` keys = 32
+n = 61  `startingCurveLocations` keys = 32
+"""
+
+# TODO figure out how to call the correct module
+# In other situations, I use a so-called dispatcher amd that has helped make code transformation easier, too.
+from mapFolding._oeisFormulas.matrixMeanders import count  # noqa: ERA001
+from mapFolding._oeisFormulas.matrixMeanders64 import count as count64
+
+def initializeA000682(n: int) -> dict[int, int]:
+	curveLocationsMAXIMUM = 1 << (2 * n + 4)
+
+	curveSeed: int = 5 - (n & 0b1) * 4
+	listCurveLocations = [(curveSeed << 1) | curveSeed]
+
+	while listCurveLocations[-1] < curveLocationsMAXIMUM:
+		curveSeed = (curveSeed << 4) | 0b101
+		listCurveLocations.append((curveSeed << 1) | curveSeed)
+
+	return dict.fromkeys(listCurveLocations, 1)
+
+def A000682(n: int) -> int:
+	# count64(n - 1, initializeA000682(n - 1))
+	# print()
+	return count(n - 1, initializeA000682(n - 1))
+	# return count64(n - 1, initializeA000682(n - 1))

{mapfolding-0.15.2 → mapfolding-0.15.3}/mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -1,3 +1,4 @@
+# pyright: reportUnusedImport=false
 from mapFolding._oeisFormulas.A000136 import A000136
 from mapFolding._oeisFormulas.A000682 import A000682
 from mapFolding._oeisFormulas.A001010 import A001010
@@ -11,23 +12,23 @@ import time
 if __name__ == '__main__':
 	def _write() -> None:
 		sys.stdout.write(
-			f"{(match:=foldsTotal == dictionaryOEISMeanders[oeisID]['valuesKnown'][n])}\t"
-			f"\033[{(not match)*91}m"
+			f"{(booleanColor:=(foldsTotal == dictionaryOEISMeanders[oeisID]['valuesKnown'][n]))}\t" # pyright: ignore[reportIndexIssue, reportUnknownVariableType]
+			f"\033[{(not booleanColor)*91}m"
 			f"{n}\t"
-			f"{foldsTotal=}\t"
-			f"{dictionaryOEISMeanders[oeisID]['valuesKnown'][n]=}\t"
+			f"{foldsTotal}\t"
+			# f"{dictionaryOEISMeanders[oeisID]['valuesKnown'][n]=}\t"
 			f"{time.perf_counter() - timeStart:.2f}\t"
 			# f"{description}\t"
 			"\033[0m\n"
 		)
+	oeisID = 'A001010'
 	oeisID = 'A000136'
 	oeisID = 'A000682'
-	oeisID = 'A001010'
-	for n in range(2, 13):
+	for n in range(3,17):
 
 		# sys.stdout.write(f"{n = }\n")
 
 		timeStart = time.perf_counter()
-		foldsTotal = eval(oeisID)(n)
+		foldsTotal = eval(oeisID)(n)  # noqa: S307
 		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
 		_write()

mapfolding-0.15.3/mapFolding/_oeisFormulas/Z0Z_notes.py

@@ -0,0 +1,16 @@
+"""Half-formed thoughts.
+
+I have unintentionally made `bridges -= 1` almost meaningless.
+
+Unlike multidimensional map folding, the computation of curveLocations_sub_i for bridges=p does not need to happen during the
+series of computation for bridges=p. Each curveLocations_sub_i produces between no curveLocations, curveLocations_sub_q,
+curveLocations_sub_r, curveLocations_sub_s, and curveLocations_sub_t, which are recorded as keys in dictionaryCurveLocations.
+
+`while bridges > 0: bridges -= 1` tacitly attaches metadata to each key in dictionaryCurveLocations: specifically the value of
+`bridges`. The computation is not complete until the `bridges` value of each key reaches 0.
+
+Therefore, it is hypothetically possible to use one dictionary and to explicitly track the `bridges` value for each key. In
+that scenario, the dictionary is effectively a list of jobs. And instead of being at the mercy of the amount of resources
+needed by each decrement, bridges -= 1, we can use well-researched techniques to manage resources and the order of
+execution.
+"""

{mapfolding-0.15.2 → mapfolding-0.15.3}/mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -8,6 +8,7 @@ from mapFolding._oeisFormulas.A223094 import A223094
 from mapFolding._oeisFormulas.A259702 import A259702
 from mapFolding._oeisFormulas.A301620 import A301620
 from mapFolding.oeis import getOEISidInformation, getOEISidValues
+from typing import TypedDict
 import sys
 
 oeisIDsMeanders: list[str] = [
@@ -22,11 +23,32 @@ oeisIDsMeanders: list[str] = [
 	'A301620',
 ]
 
-dictionaryOEISMeanders: dict[str, dict[str, dict[int, int] | str | int]] = {
+# ruff: noqa: ERA001
+class MetadataOEISidMeanders(TypedDict):
+	"""Settings for an implemented OEIS sequence."""
+
+	description: str
+	"""The OEIS.org description of the integer sequence."""
+	# getMapShape: Callable[[int], tuple[int, ...]]
+	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
+	offset: int
+	"""The starting index, 'n', of the sequence, typically 0 or 1."""
+	# valuesBenchmark: list[int]
+	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
+	valuesKnown: dict[int, int]
+	"""Dictionary of sequence indices, 'n', to their known values, `foldsTotal`."""
+	# valuesTestParallelization: list[int]
+	"""List of index values, 'n', to use when testing parallelization performance."""
+	# valuesTestValidation: list[int]
+	"""List of index values, 'n', to use when testing validation performance."""
+	# valueUnknown: int
+	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
+
+dictionaryOEISMeanders: dict[str, MetadataOEISidMeanders] = {
 	oeisID: {
-		'valuesKnown': getOEISidValues(oeisID),
 		'description': getOEISidInformation(oeisID)[0],
 		'offset': getOEISidInformation(oeisID)[1],
+		'valuesKnown': getOEISidValues(oeisID),
 	}
 	for oeisID in oeisIDsMeanders
 }

mapfolding-0.15.3/mapFolding/_oeisFormulas/Z0Z_symmetry.py

@@ -0,0 +1,131 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+
+"""
+
+How to A000682:
+- Start A000682 for n.
+- Find A000560(n-1) in dictionaryCurveLocationsKnown or dictionaryCurveLocationsDiscovered.
+- STOP computing.
+- Double the total.
+That is A000682.
+
+
+How to A259703:
+- Start A000682 for n.
+- Find n-1 keys in dictionaryCurveLocationsKnown or dictionaryCurveLocationsDiscovered.
+- Descending sort.
+That is a A259703 row.
+
+https://oeis.org/A259703
+
+SYMMETRY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+     1;
+     1,    1;
+     2,    1,    1;
+     5,    2,    2,   1;
+    12,    5,    4,   2,   1;
+    33,   13,   12,   4,   3,   1;
+    87,   35,   30,  12,   6,   3,  1;
+   252,   98,   90,  32,  21,   6,  4,  1;
+   703,  278,  243,  94,  54,  21,  8,  4,  1;
+  2105,  812,  745, 270, 175,  57, 32,  8,  5, 1;
+  6099, 2385, 2108, 808, 485, 181, 84, 32, 10, 5, 1;
+
+
+n+1
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+
+     n/a;
+     1=    1;
+     2=    1+    1;
+     5=    2+    2+   1;
+    12=    5+    4+   2+   1;
+    33=   13+   12+   4+   3+   1;
+    87=   35+   30+  12+   6+   3+  1;
+   252=   98+   90+  32+  21+   6+  4+  1;
+   703=  278+  243+  94+  54+  21+  8+  4+  1;
+  2105=  812+  745+ 270+ 175+  57+ 32+  8+  5+ 1;
+  6099= 2385+ 2108+ 808+ 485+ 181+ 84+ 32+ 10+ 5+ 1;
+
+print(1==    1)
+print(2==    1+    1)
+print(5==    2+    2+   1)
+print(12==    5+    4+   2+   1)
+print(33==   13+   12+   4+   3+   1)
+print(87==   35+   30+  12+   6+   3+  1)
+print(252==   98+   90+  32+  21+   6+  4+  1)
+print(703==  278+  243+  94+  54+  21+  8+  4+  1)
+print(2105==  812+  745+ 270+ 175+  57+ 32+  8+  5+ 1)
+print(6099== 2385+ 2108+ 808+ 485+ 181+ 84+ 32+ 10+ 5+ 1)
+
+
+"""
+
+listA259703rowTerms = [1, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [2, 1, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [5, 2, 2, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [12, 5, 4, 2, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [33, 13, 12, 4, 3, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [87, 35, 30, 12, 6, 3, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [252, 98, 90, 32, 21, 6, 4, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [703, 278, 243, 94, 54, 21, 8, 4, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [2105, 812, 745, 270, 175, 57, 32, 8, 5, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [6099, 2385, 2108, 808, 485, 181, 84, 32, 10, 5, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+

mapfolding-0.15.3/mapFolding/_oeisFormulas/matrixMeanders.py

@@ -0,0 +1,134 @@
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	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), # `bridges = 13`, 0xaaaaaaaa.bit_length() = 32
+(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), # 0x5000000000000000.bit_length() = 63; 0xaaaaaaaaaaaaaaaa.bit_length() = 64; 0x5555555555555555.bit_length() = 63
+(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),
+]
+	"""`bridges = 29`
+	0x5000000000000000.bit_length() = 63;
+	0xaaaaaaaaaaaaaaaa.bit_length() = 64;
+	0x5555555555555555.bit_length() = 63"""
+
+	listCurveMaximums = listCurveMaximums[0:bridges]
+
+	dictionaryCurveLocations: dict[int, int] = {}
+	while bridges > 0:
+		bridges -= 1
+
+		bifurcationAlphaLocator, bifurcationZuluLocator, curveLocationsMAXIMUM = listCurveMaximums[bridges]
+
+		for curveLocations, distinctCrossings in startingCurveLocations.items():
+			bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+
+			# Z0Z_simpleBridges
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# bifurcationAlphaCurves
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | ((bifurcationAlphaIsEven := 1 - (bifurcationAlpha & 0b1)) << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# bifurcationZuluCurves
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | (bifurcationZuluIsEven := 1 - (bifurcationZulu & 1))
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# Z0Z_alignedBridges
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves:
+				# One Truth-check to select a code path
+				bifurcationsCanBePairedTogether = (bifurcationZuluIsEven << 1) | bifurcationAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
+
+				if bifurcationsCanBePairedTogether != 0:  # Case 0 (False, False)
+					XOrHere2makePair = 0b1
+					findUnpaired_0b1 = 0
+
+					if bifurcationsCanBePairedTogether == 1:  # Case 1: (False, True)
+						while findUnpaired_0b1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpaired_0b1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+						bifurcationAlpha ^= XOrHere2makePair
+					elif bifurcationsCanBePairedTogether == 2:  # Case 2: (True, False)
+						while findUnpaired_0b1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpaired_0b1 += 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) | (bifurcationAlpha >> 2)
+					if curveLocationAnalysis < curveLocationsMAXIMUM:
+						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+		startingCurveLocations.clear()
+		startingCurveLocations, dictionaryCurveLocations = dictionaryCurveLocations, startingCurveLocations
+
+		# print(sum(startingCurveLocations.values()))
+	return sum(startingCurveLocations.values())
+

mapfolding-0.15.3/mapFolding/_oeisFormulas/matrixMeanders64.py

@@ -0,0 +1,152 @@
+# ruff: noqa
+import numpy
+
+indexDistinctCrossings = int(0)  # noqa: RUF046, UP018
+indexBifurcationAlpha = int(1)  # noqa: RUF046, UP018
+indexBifurcationZulu = int(2)  # noqa: RUF046, UP018
+indexCurveLocations = int(3)  # noqa: RUF046, UP018
+
+def make1array(listArrays: list[numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]]) -> numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]:
+	arrayCurveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.fromiter({element for stupidSystem in listArrays for element in stupidSystem[:, 1]}, dtype=numpy.uint64)
+
+	arrayOut = numpy.column_stack((
+		numpy.zeros(len(arrayCurveLocations), dtype=numpy.uint64)
+		, arrayCurveLocations & numpy.uint64(0x5555555555555555)
+		, (arrayCurveLocations & numpy.uint64(0xaaaaaaaaaaaaaaaa)) >> numpy.uint64(1)
+		, arrayCurveLocations
+	))
+
+	for arrayCurveLocations in listArrays:
+		arrayOut[:, indexDistinctCrossings] += numpy.sum(arrayCurveLocations[:, 0] * (arrayCurveLocations[:, -1][:, numpy.newaxis] == arrayOut[:, indexCurveLocations]).T, axis=1)
+
+	return arrayOut  # The next `arrayBifurcations`
+
+def convertDictionaryToNumPy(dictionaryIn: dict[int, int]) -> numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]:
+	arrayKeys: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.fromiter(dictionaryIn.keys(), dtype=numpy.uint64)
+
+	return numpy.column_stack((
+		numpy.fromiter(dictionaryIn.values(), dtype=numpy.uint64)
+		, arrayKeys & numpy.uint64(0x5555555555555555)
+		, (arrayKeys & numpy.uint64(0xaaaaaaaaaaaaaaaa)) >> numpy.uint64(1)
+		, arrayKeys
+	))
+
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	arrayBifurcations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = convertDictionaryToNumPy(startingCurveLocations)
+
+	while bridges > 0:
+		bridges -= 1
+
+		listArrayCurveLocationsAnalyzed: list[numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]] = []
+
+		# Selector-adjacent
+		curveLocationsMAXIMUM: numpy.uint64 = numpy.uint64(1) << numpy.uint64(2 * bridges + 4)
+		# Selectors, general
+		selectBifurcationAlphaCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationAlpha] > numpy.uint64(1)
+		selectBifurcationAlphaEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & numpy.uint64(1)) == numpy.uint64(0)
+		selectBifurcationZuluCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationZulu] > numpy.uint64(1)
+		selectBifurcationZuluEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & numpy.uint64(1)) == numpy.uint64(0)
+
+		# BridgesSimple
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexDistinctCrossings] >= numpy.uint64(0) # This had better always be `True`.
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (((arrayBifurcations[selector, indexBifurcationAlpha] | (arrayBifurcations[selector, indexBifurcationZulu] << numpy.uint64(1))) << numpy.uint64(2)) | numpy.uint64(3))
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# BifurcationAlphaCurves
+		selector = selectBifurcationAlphaCurves
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.bitwise_or.reduce((
+			arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2)
+			, arrayBifurcations[selector, indexBifurcationZulu] << numpy.uint64(3)
+			, (numpy.uint64(1) - (arrayBifurcations[selector, indexBifurcationAlpha] & numpy.uint64(1))) << numpy.uint64(1)
+		))
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# BifurcationZuluCurves
+		selector = selectBifurcationZuluCurves
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.bitwise_or.reduce((
+			arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(1)
+			, arrayBifurcations[selector, indexBifurcationAlpha] << numpy.uint64(2)
+			, (1 - (arrayBifurcations[selector, indexBifurcationZulu] & numpy.uint64(1)))
+		))
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# Z0Z_bridgesBifurcationAlphaToRepair
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, ~selectBifurcationZuluEven
+		))
+
+			# Initialize
+		Z0Z_selectBridgesBifurcationAlphaToModify = selector.copy()
+		XOrHere2makePair = numpy.uint64(1)
+		selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
+		selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
+
+		while Z0Z_selectBridgesBifurcationAlphaToModify.any():
+			XOrHere2makePair <<= numpy.uint64(2)
+
+			selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & XOrHere2makePair) == numpy.uint64(0)
+			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationAlphaToModify, selectToModifyByXOR))
+
+			# Modify in place
+			arrayBifurcations[selectorUnified, indexBifurcationAlpha] ^= XOrHere2makePair
+
+			# Remove the modified elements
+			Z0Z_selectBridgesBifurcationAlphaToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationAlphaToModify, ~selectorUnified))
+
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
+			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
+			| (arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2))
+		)
+
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# Z0Z_bridgesBifurcationZuluToRepair
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, ~selectBifurcationAlphaEven, selectBifurcationZuluEven
+		))
+
+			# Initialize
+		Z0Z_selectBridgesBifurcationZuluToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = selector.copy()
+		XOrHere2makePair: numpy.uint64 = numpy.uint64(1)
+		selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
+		selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
+
+		while Z0Z_selectBridgesBifurcationZuluToModify.any():
+			XOrHere2makePair <<= numpy.uint64(2)
+
+			# New condition
+			selectUnpaired_0b1: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & XOrHere2makePair) == numpy.uint64(0)
+			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationZuluToModify, selectUnpaired_0b1))
+
+			# Modify in place
+			arrayBifurcations[selectorUnified, indexBifurcationZulu] ^= XOrHere2makePair
+
+			# Remove the modified elements from the selector
+			Z0Z_selectBridgesBifurcationZuluToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationZuluToModify, ~selectorUnified))
+
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
+			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
+			| (arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2))
+		)
+
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# Z0Z_bridgesAligned
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, selectBifurcationZuluEven
+		))
+
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
+			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
+			| (arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2))
+		)
+
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		arrayBifurcations = make1array(listArrayCurveLocationsAnalyzed)
+
+		listArrayCurveLocationsAnalyzed.clear()
+
+		print(int(sum(arrayBifurcations[:, 0])))
+	return int(sum(arrayBifurcations[:, 0]))
+

{mapfolding-0.15.2 → mapfolding-0.15.3}/mapFolding/_oeisFormulas/matrixMeandersAnnex.py

@@ -35,7 +35,7 @@ curveMaximum: dict[int, limitLocators] = {
 25: limitLocators(0x55555555555555, 0xaaaaaaaaaaaaaa, 0x40000000000000),
 26: limitLocators(0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
 27: limitLocators(0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
-28: limitLocators(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+28: limitLocators(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000),
 29: limitLocators(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000),
 30: limitLocators(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
 31: limitLocators(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),

{mapfolding-0.15.2 → mapfolding-0.15.3}/mapFolding/_theSSOT.py

@@ -115,7 +115,7 @@ settingsOEISManuallySelected: dict[str, MetadataOEISidManuallySet] = {
 		'getMapShape': lambda n: (1, 2 * n),
 		'valuesBenchmark': [7],
 		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
+		'valuesTestValidation': [random.randint(2, 8)],  # noqa: S311
 	},
 }
 

{mapfolding-0.15.2 → mapfolding-0.15.3}/mapFolding/_theTypes.py

@@ -36,7 +36,7 @@ NumPyFoldsTotal: TypeAlias = numpy_uint64  # noqa: UP040 The TypeAlias may be us
 
 Note well
 ---------
-If your elements might exceed 1.8 x 10^19, then you should take extra steps to ensure the integrity of the data in NumPy or use a
+If your element values might exceed 1.8 x 10^19, then you should take extra steps to ensure the integrity of the data in NumPy or use a
 different data structure."""
 
 Array3DLeavesTotal: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.