mapFolding 0.13.1__tar.gz → 0.14.1__tar.gz

mapfolding-0.14.1/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: mapFolding
+Version: 0.14.1
+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
+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
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Pre-processors
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astToolkit
+Requires-Dist: hunterMakesPy
+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"
+Requires-Dist: numba_progress; extra == "numba"
+Provides-Extra: testing
+Requires-Dist: numba; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-env; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Dynamic: license-file
+
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+
+Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
+
+Command line:
+
+- getOEISids
+- OEIS_for_n
+
+The package is focused on mapFolding and stamp folding. But "mapFolding/_oeisFormulas" has some infrastructure for meanders and semi-meanders.
+
+There are innovations and insights in the mapFolding stuff.
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.14.1/README.md

@@ -0,0 +1,21 @@
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+
+Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
+
+Command line:
+
+- getOEISids
+- OEIS_for_n
+
+The package is focused on mapFolding and stamp folding. But "mapFolding/_oeisFormulas" has some infrastructure for meanders and semi-meanders.
+
+There are innovations and insights in the mapFolding stuff.
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.14.1/mapFolding/_oeisFormulas/A000136.py

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

mapfolding-0.14.1/mapFolding/_oeisFormulas/A000560.py

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

mapfolding-0.14.1/mapFolding/_oeisFormulas/A000682.py

@@ -0,0 +1,17 @@
+from mapFolding._oeisFormulas.matrixMeanders import count, curveMaximum
+
+def initializeA000682(n: int) -> dict[int, int]:
+	curveLocationsMAXIMUM = curveMaximum[n].curveLocationsMAXIMUM
+
+	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:
+	return count(n - 1, initializeA000682(n - 1))
+

mapfolding-0.14.1/mapFolding/_oeisFormulas/A005315.py

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

mapfolding-0.14.1/mapFolding/_oeisFormulas/A005316.py

@@ -0,0 +1,10 @@
+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-0.14.1/mapFolding/_oeisFormulas/A223094.py

@@ -0,0 +1,7 @@
+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-0.14.1/mapFolding/_oeisFormulas/A259702.py

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

mapfolding-0.14.1/mapFolding/_oeisFormulas/A301620.py

@@ -0,0 +1,6 @@
+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-0.14.1/mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -0,0 +1,18 @@
+from mapFolding._oeisFormulas.A000136 import A000136
+from mapFolding.oeis import dictionaryOEIS
+import sys
+import time
+
+# ruff: noqa: ERA001
+
+if __name__ == '__main__':
+	oeisID = 'A000136'
+	for n in range(3,30):
+
+		# print(n)
+
+		timeStart = time.perf_counter()
+		foldsTotal = A000136(n)
+		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
+		sys.stdout.write(f"{foldsTotal == dictionaryOEIS[oeisID]['valuesKnown'][n]} {n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
+

mapfolding-0.14.1/mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

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

mapfolding-0.14.1/mapFolding/_oeisFormulas/__init__.py

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

mapfolding-0.14.1/mapFolding/_oeisFormulas/matrixMeanders.py

@@ -0,0 +1,79 @@
+from mapFolding._oeisFormulas.matrixMeandersAnnex import curveMaximum as curveMaximum
+from typing import NamedTuple
+
+class BifurcatedCurves(NamedTuple):
+    bifurcationEven: int
+    bifurcationOdd: int
+    distinctCrossings: int
+    curveLocationsMAXIMUM: int
+
+dictionaryCurveLocations: dict[int, list[int]] = {}
+
+def getCurveLocations(bridges: int) -> list[BifurcatedCurves]:
+	global dictionaryCurveLocations  # noqa: PLW0603
+	curveLocationsMAXIMUM, bifurcationEvenLocator, bifurcationOddLocator = curveMaximum[bridges]
+	listBifurcatedCurves: list[BifurcatedCurves] = []
+	# TODO This is ready for concurrency and/or vectorization.
+	for curveLocations, listDistinctCrossings in dictionaryCurveLocations.items():
+		bifurcationEven = (curveLocations & bifurcationEvenLocator) >> 1
+		bifurcationOdd = (curveLocations & bifurcationOddLocator)
+		distinctCrossings = sum(listDistinctCrossings)
+		listBifurcatedCurves.append(BifurcatedCurves(bifurcationEven, bifurcationOdd, distinctCrossings, curveLocationsMAXIMUM))
+	dictionaryCurveLocations = {}
+	return listBifurcatedCurves
+
+def recordAnalysis(curveLocationAnalysis: int, curveLocationsMAXIMUM: int, distinctCrossings: int) -> None:
+	if curveLocationAnalysis < curveLocationsMAXIMUM:
+		dictionaryCurveLocations.setdefault(curveLocationAnalysis, []).append(distinctCrossings)
+
+def analyzeCurve(bifurcationEven: int, bifurcationOdd: int, distinctCrossings: int, curveLocationsMAXIMUM: int) -> None:
+	bifurcationEvenFinalZero = (bifurcationEven & 0b1) == 0
+	bifurcationEvenHasCurves = bifurcationEven != 1
+	bifurcationOddFinalZero = (bifurcationOdd & 0b1) == 0
+	bifurcationOddHasCurves = bifurcationOdd != 1
+
+	if bifurcationEvenHasCurves:
+		curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	if bifurcationOddHasCurves:
+		curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+	recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	if bifurcationEvenHasCurves and bifurcationOddHasCurves and (bifurcationEvenFinalZero or bifurcationOddFinalZero):
+		XOrHere2makePair = 0b1
+		findUnpairedBinary1 = 0
+
+		if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
+			bifurcationEven ^= XOrHere2makePair
+
+		elif bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
+			bifurcationOdd ^= XOrHere2makePair
+
+		curveLocationAnalysis = ((bifurcationEven >> 2) << 1) | (bifurcationOdd >> 2)
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+def initializeCurveLocations(startingCurveLocations: dict[int, int]) -> None:
+	global dictionaryCurveLocations  # noqa: PLW0603
+	dictionaryCurveLocations = {curve: [distinctCrossings] for curve, distinctCrossings in startingCurveLocations.items()}
+
+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-0.14.1/mapFolding/_oeisFormulas/matrixMeandersAnnex.py

@@ -0,0 +1,84 @@
+from typing import NamedTuple
+import sys
+
+class limitLocators(NamedTuple):
+	curveLocationsMAXIMUM: int
+	bifurcationEvenLocator: int
+	bifurcationOddLocator: int
+
+curveMaximum: dict[int, limitLocators] = {
+0: limitLocators(16, 0x2a, 0x15),
+1: limitLocators(64, 0xaa, 0x55),
+2: limitLocators(256, 0x2aa, 0x155),
+3: limitLocators(1024, 0xaaa, 0x555),
+4: limitLocators(4096, 0x2aaa, 0x1555),
+5: limitLocators(16384, 0xaaaa, 0x5555),
+6: limitLocators(65536, 0x2aaaa, 0x15555),
+7: limitLocators(262144, 0xaaaaa, 0x55555),
+8: limitLocators(1048576, 0x2aaaaa, 0x155555),
+9: limitLocators(4194304, 0xaaaaaa, 0x555555),
+10: limitLocators(16777216, 0x2aaaaaa, 0x1555555),
+11: limitLocators(67108864, 0xaaaaaaa, 0x5555555),
+12: limitLocators(268435456, 0x2aaaaaaa, 0x15555555),
+13: limitLocators(1073741824, 0xaaaaaaaa, 0x55555555),
+14: limitLocators(4294967296, 0x2aaaaaaaa, 0x155555555),
+15: limitLocators(17179869184, 0xaaaaaaaaa, 0x555555555),
+16: limitLocators(68719476736, 0x2aaaaaaaaa, 0x1555555555),
+17: limitLocators(274877906944, 0xaaaaaaaaaa, 0x5555555555),
+18: limitLocators(1099511627776, 0x2aaaaaaaaaa, 0x15555555555),
+19: limitLocators(4398046511104, 0xaaaaaaaaaaa, 0x55555555555),
+20: limitLocators(17592186044416, 0x2aaaaaaaaaaa, 0x155555555555),
+21: limitLocators(70368744177664, 0xaaaaaaaaaaaa, 0x555555555555),
+22: limitLocators(281474976710656, 0x2aaaaaaaaaaaa, 0x1555555555555),
+23: limitLocators(1125899906842624, 0xaaaaaaaaaaaaa, 0x5555555555555),
+24: limitLocators(4503599627370496, 0x2aaaaaaaaaaaaa, 0x15555555555555),
+25: limitLocators(18014398509481984, 0xaaaaaaaaaaaaaa, 0x55555555555555),
+26: limitLocators(72057594037927936, 0x2aaaaaaaaaaaaaa, 0x155555555555555),
+27: limitLocators(288230376151711744, 0xaaaaaaaaaaaaaaa, 0x555555555555555),
+28: limitLocators(1152921504606846976, 0x2aaaaaaaaaaaaaaa, 0x1555555555555555), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+29: limitLocators(4611686018427387904, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555),
+30: limitLocators(18446744073709551616, 0x2aaaaaaaaaaaaaaaa, 0x15555555555555555),
+31: limitLocators(73786976294838206464, 0xaaaaaaaaaaaaaaaaa, 0x55555555555555555),
+32: limitLocators(295147905179352825856, 0x2aaaaaaaaaaaaaaaaa, 0x155555555555555555),
+33: limitLocators(1180591620717411303424, 0xaaaaaaaaaaaaaaaaaa, 0x555555555555555555),
+34: limitLocators(4722366482869645213696, 0x2aaaaaaaaaaaaaaaaaa, 0x1555555555555555555),
+35: limitLocators(18889465931478580854784, 0xaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555),
+36: limitLocators(75557863725914323419136, 0x2aaaaaaaaaaaaaaaaaaa, 0x15555555555555555555),
+37: limitLocators(302231454903657293676544, 0xaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555),
+38: limitLocators(1208925819614629174706176, 0x2aaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555),
+39: limitLocators(4835703278458516698824704, 0xaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555),
+40: limitLocators(19342813113834066795298816, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555),
+41: limitLocators(77371252455336267181195264, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555),
+42: limitLocators(309485009821345068724781056, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555),
+43: limitLocators(1237940039285380274899124224, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555),
+44: limitLocators(4951760157141521099596496896, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555),
+45: limitLocators(19807040628566084398385987584, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555),
+46: limitLocators(79228162514264337593543950336, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555),
+47: limitLocators(316912650057057350374175801344, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555),
+48: limitLocators(1267650600228229401496703205376, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555),
+49: limitLocators(5070602400912917605986812821504, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555),
+50: limitLocators(20282409603651670423947251286016, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555),
+51: limitLocators(81129638414606681695789005144064, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555),
+52: limitLocators(324518553658426726783156020576256, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555),
+53: limitLocators(1298074214633706907132624082305024, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555),
+54: limitLocators(5192296858534827628530496329220096, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555),
+55: limitLocators(20769187434139310514121985316880384, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555),
+56: limitLocators(83076749736557242056487941267521536, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555555),
+57: limitLocators(332306998946228968225951765070086144, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555555),
+58: limitLocators(1329227995784915872903807060280344576, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555555),
+59: limitLocators(5316911983139663491615228241121378304, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555555),
+60: limitLocators(21267647932558653966460912964485513216, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555555),
+61: limitLocators(85070591730234615865843651857942052864, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555555),
+}
+
+def makeCurveMaximum() -> None:
+	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
+	for n in range(62):
+		curveLocationsMAXIMUM = 1 << (2 * n + 4)
+		bifurcationOddLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
+		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationOddLocator << 1)}, {hex(bifurcationOddLocator)}),\n")
+	sys.stdout.write("}\n")
+
+if __name__ == '__main__':
+	makeCurveMaximum()
+

mapfolding-0.14.1/mapFolding/_theSSOT.py

@@ -0,0 +1,123 @@
+"""Primary goal: access and configure package settings and metadata.
+
+Secondary goal: store hardcoded values until I implement a dynamic solution.
+"""
+
+from collections.abc import Callable
+from hunterMakesPy import PackageSettings
+from pathlib import Path
+from typing import TypedDict
+import dataclasses
+import random
+
+# TODO eliminate hardcoding
+concurrencyPackageHARDCODED = 'multiprocessing'
+"""Default package identifier for concurrent execution operations."""
+
+class MetadataOEISidManuallySet(TypedDict):
+	"""Settings that are best selected by a human instead of algorithmically."""
+
+	getMapShape: Callable[[int], tuple[int, ...]]
+	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
+	valuesBenchmark: list[int]
+	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
+	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."""
+
+@dataclasses.dataclass
+class mapFoldingPackageSettings(PackageSettings):
+	"""Centralized configuration container for all package-wide settings.
+
+	(AI generated docstring)
+
+	This dataclass serves as the single source of truth for package configuration,
+	providing both static and dynamically-resolved values needed throughout the
+	package lifecycle. The metadata on each field indicates when that value is
+	determined - either during packaging or at installation/runtime.
+
+	The design supports different evaluation phases to optimize performance and
+	reliability. Packaging-time values can be determined during package creation,
+	while installing-time values require filesystem access or module introspection.
+
+	Attributes
+	----------
+	fileExtension : str = '.py'
+		Standard file extension for Python modules in this package.
+	packageName : str
+		Canonical name of the package as defined in project configuration.
+	pathPackage : Path
+		Absolute filesystem path to the installed package directory.
+	concurrencyPackage : str | None = None
+		Package identifier for concurrent execution operations.
+
+	"""
+
+	concurrencyPackage: str | None = None
+	"""
+	Package identifier for concurrent execution operations.
+
+	(AI generated docstring)
+
+	Specifies which Python package should be used for parallel processing
+	in computationally intensive operations. When None, the default concurrency
+	package specified in the module constants is used. Accepted values include
+	'multiprocessing' for standard parallel processing and 'numba' for
+	specialized numerical computations.
+	"""
+
+identifierPackageFALLBACK = "mapFolding"
+"""Hardcoded package name used as fallback when dynamic resolution fails."""
+
+concurrencyPackage = concurrencyPackageHARDCODED
+"""Active concurrency package configuration for the current session."""
+
+# TODO I made a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
+settingsOEISManuallySelected: dict[str, MetadataOEISidManuallySet] = {
+	'A000136': {
+		'getMapShape': lambda n: tuple(sorted([1, n])),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
+	},
+	'A001415': {
+		'getMapShape': lambda n: tuple(sorted([2, n])),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
+	},
+	'A001416': {
+		'getMapShape': lambda n: tuple(sorted([3, n])),
+		'valuesBenchmark': [9],
+		'valuesTestParallelization': [*range(3, 5)],
+		'valuesTestValidation': [random.randint(2, 6)],  # noqa: S311
+	},
+	'A001417': {
+		'getMapShape': lambda n: tuple(2 for _dimension in range(n)),
+		'valuesBenchmark': [6],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
+	},
+	'A195646': {
+		'getMapShape': lambda n: tuple(3 for _dimension in range(n)),
+		'valuesBenchmark': [3],
+		'valuesTestParallelization': [*range(2, 3)],
+		'valuesTestValidation': [2],
+	},
+	'A001418': {
+		'getMapShape': lambda n: (n, n),
+		'valuesBenchmark': [5],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
+	},
+}
+
+packageSettings = mapFoldingPackageSettings(
+	identifierPackageFALLBACK=identifierPackageFALLBACK
+	, concurrencyPackage=concurrencyPackage)
+"""Global package settings."""
+cacheDays = 30
+"""Number of days to retain cached OEIS data before refreshing from the online source."""
+pathCache: Path = packageSettings.pathPackage / ".cache"
+"""Local directory path for storing cached OEIS sequence data and metadata."""

{mapfolding-0.13.1 → mapfolding-0.14.1}/mapFolding/basecamp.py

@@ -96,9 +96,9 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		pass
 	else:
 		if oeisID and oeis_n:
-			from mapFolding.oeis import settingsOEIS  # noqa: PLC0415
+			from mapFolding.oeis import dictionaryOEIS  # noqa: PLC0415
 			with contextlib.suppress(KeyError):
-				mapShape = settingsOEIS[oeisID]['getMapShape'](oeis_n)
+				mapShape = dictionaryOEIS[oeisID]['getMapShape'](oeis_n)
 		if not mapShape and listDimensions:
 			mapShape = validateListDimensions(listDimensions)
 

{mapfolding-0.13.1 → mapfolding-0.14.1}/mapFolding/beDRY.py

@@ -319,7 +319,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
 			message = f"I received `{dimension = }` in `{listDimensions = }`, but all dimensions must be a non-negative integer."
 			raise ValueError(message)
 		mapDimensions.append(dimension)
-	if len(mapDimensions) < 2:  # noqa: PLR2004
+	if len(mapDimensions) < 2:
 		message = f"This function requires `{listDimensions = }` to have at least two dimensions greater than 0. You may want to look at https://oeis.org/."
 		raise NotImplementedError(message)