mapFolding 0.15.3__py3-none-any.whl → 0.16.0__py3-none-any.whl

mapFolding/_oeisFormulas/A000682.py

@@ -1,85 +0,0 @@
-"""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/_oeisFormulas/A001010.py

@@ -1,19 +0,0 @@
-from mapFolding import countFolds
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A001010(n: int) -> int:
-	"""Complicated.
-
-	a(2n-1) = 2*A007822(n)
-	OddQ[n], 2*A007822[[(n - 1)/2 + 1]]]
-
-	a(2n) = 2*A000682(n+1)
-	EvenQ[n], 2*A000682[[n/2 + 1]]
-	"""
-	if n & 0b1:
-		foldsTotal = 2 * countFolds(oeisID='A007822', oeis_n=(n - 1)//2 + 1, flow='theorem2Numba')
-	else:
-		foldsTotal = 2 * A000682(n // 2 + 1)
-
-	return foldsTotal
-

mapFolding/_oeisFormulas/A001011.py

@@ -1,5 +0,0 @@
-from mapFolding._oeisFormulas.A000136 import A000136
-from mapFolding._oeisFormulas.A001010 import A001010
-
-def A001011(n: int) -> int:
-    return (A001010(n) + A000136(n)) // 4

mapFolding/_oeisFormulas/A005315.py

@@ -1,4 +0,0 @@
-from mapFolding._oeisFormulas.A005316 import A005316
-
-def A005315(n: int) -> int:
-	return A005316(2 * n - 1)

mapFolding/_oeisFormulas/A005316.py

@@ -1,10 +0,0 @@
-from mapFolding._oeisFormulas.matrixMeanders import count
-
-def initializeA005316(n: int) -> dict[int, int]:
-	if n & 0b1:
-		return {22: 1}
-	else:
-		return {15: 1}
-
-def A005316(n: int) -> int:
-	return count(n-1, initializeA005316(n-1))

mapFolding/_oeisFormulas/A223094.py

@@ -1,7 +0,0 @@
-from mapFolding._oeisFormulas.A000136 import A000136
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A223094(n: int) -> int:
-    return A000136(n) - A000682(n + 1)
-
-# %F A223094 For n >= 3: a(n) = n! - Sum_{k=3..n-1} (a(k)*n!/k!) - A000682(n+1). - _Roger Ford_, Aug 24 2024

mapFolding/_oeisFormulas/A259702.py

@@ -1,4 +0,0 @@
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A259702(n: int) -> int:
-	return A000682(n) // 2 - A000682(n - 1)

mapFolding/_oeisFormulas/A301620.py

@@ -1,6 +0,0 @@
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A301620(n: int) -> int:
-	return A000682(n + 2) - 2 * A000682(n + 1)
-
-# %F A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018

mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -1,34 +0,0 @@
-# pyright: reportUnusedImport=false
-from mapFolding._oeisFormulas.A000136 import A000136
-from mapFolding._oeisFormulas.A000682 import A000682
-from mapFolding._oeisFormulas.A001010 import A001010
-from mapFolding._oeisFormulas.Z0Z_oeisMeanders import dictionaryOEISMeanders
-from mapFolding.oeis import dictionaryOEIS
-import sys
-import time
-
-# ruff: noqa: ERA001
-
-if __name__ == '__main__':
-	def _write() -> None:
-		sys.stdout.write(
-			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"{time.perf_counter() - timeStart:.2f}\t"
-			# f"{description}\t"
-			"\033[0m\n"
-		)
-	oeisID = 'A001010'
-	oeisID = 'A000136'
-	oeisID = 'A000682'
-	for n in range(3,17):
-
-		# sys.stdout.write(f"{n = }\n")
-
-		timeStart = time.perf_counter()
-		foldsTotal = eval(oeisID)(n)  # noqa: S307
-		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
-		_write()

mapFolding/_oeisFormulas/Z0Z_notes.py

@@ -1,16 +0,0 @@
-"""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/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -1,74 +0,0 @@
-from mapFolding._oeisFormulas.A000560 import A000560
-from mapFolding._oeisFormulas.A000682 import A000682
-from mapFolding._oeisFormulas.A001010 import A001010
-from mapFolding._oeisFormulas.A001011 import A001011
-from mapFolding._oeisFormulas.A005315 import A005315
-from mapFolding._oeisFormulas.A005316 import A005316
-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] = [
-	'A000560',
-	'A000682',
-	'A001010',
-	'A001011',
-	'A005315',
-	'A005316',
-	'A223094',
-	'A259702',
-	'A301620',
-]
-
-# 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: {
-		'description': getOEISidInformation(oeisID)[0],
-		'offset': getOEISidInformation(oeisID)[1],
-		'valuesKnown': getOEISidValues(oeisID),
-	}
-	for oeisID in oeisIDsMeanders
-}
-
-# ruff: noqa: S101
-# pyright: reportIndexIssue=false
-
-rangeTest = range(5, 13)
-
-if __name__ == '__main__':
-	for n in rangeTest:
-
-		assert A000560(n) == dictionaryOEISMeanders['A000560']['valuesKnown'][n]
-		assert A000682(n) == dictionaryOEISMeanders['A000682']['valuesKnown'][n]
-		assert A001010(n) == dictionaryOEISMeanders['A001010']['valuesKnown'][n]
-		assert A001011(n) == dictionaryOEISMeanders['A001011']['valuesKnown'][n]
-		assert A005315(n) == dictionaryOEISMeanders['A005315']['valuesKnown'][n]
-		assert A005316(n) == dictionaryOEISMeanders['A005316']['valuesKnown'][n]
-		assert A223094(n) == dictionaryOEISMeanders['A223094']['valuesKnown'][n]
-		assert A259702(n) == dictionaryOEISMeanders['A259702']['valuesKnown'][n]
-		assert A301620(n) == dictionaryOEISMeanders['A301620']['valuesKnown'][n]
-
-	sys.stdout.write(f"\nTrue for {str(rangeTest)}\n")

mapFolding/_oeisFormulas/Z0Z_symmetry.py

@@ -1,131 +0,0 @@
-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/_oeisFormulas/__init__.py

@@ -1 +0,0 @@
-"""OEIS formula collection and analysis."""

mapFolding/_oeisFormulas/matrixMeanders.py

@@ -1,134 +0,0 @@
-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/_oeisFormulas/matrixMeandersAnnex.py

@@ -1,84 +0,0 @@
-from typing import NamedTuple
-import sys
-
-class limitLocators(NamedTuple):
-	bifurcationAlphaLocator: int
-	bifurcationZuluLocator: int
-	curveLocationsMAXIMUM: int
-
-curveMaximum: dict[int, limitLocators] = {
-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),
-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)
-		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__':
-	makeCurveMaximum()
-