mapFolding 0.14.1__tar.gz → 0.15.1__tar.gz

{mapfolding-0.14.1 → mapfolding-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.14.1
+Version: 0.15.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
@@ -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

{mapfolding-0.14.1 → mapfolding-0.15.1}/mapFolding/__init__.py

@@ -46,7 +46,7 @@ from mapFolding._theTypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
-	Array3D as Array3D,
+	Array3DLeavesTotal as Array3DLeavesTotal,
 	DatatypeElephino as DatatypeElephino,
 	DatatypeFoldsTotal as DatatypeFoldsTotal,
 	DatatypeLeavesTotal as DatatypeLeavesTotal,
@@ -85,4 +85,5 @@ from mapFolding.oeis import (
 	getOEISids as getOEISids,
 	OEIS_for_n as OEIS_for_n,
 	oeisIDfor_n as oeisIDfor_n,
+    dictionaryOEIS as dictionaryOEIS,
 )

{mapfolding-0.14.1 → mapfolding-0.15.1}/mapFolding/_oeisFormulas/A000682.py

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

mapfolding-0.15.1/mapFolding/_oeisFormulas/A001010.py

@@ -0,0 +1,18 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding.oeis import oeisIDfor_n
+
+def A001010(Z0Z_n: int) -> tuple[int, int]:
+	"""Complicated.
+
+	a(2n+1) = 2*A007822(n)
+	a(2n) = 2*A000682(n+2)
+	"""
+	if Z0Z_n & 0b1:
+		foldsTotal = 2 * oeisIDfor_n('A007822', Z0Z_n)
+		A001010n = 2 * Z0Z_n + 1
+	else:
+		foldsTotal = 2 * A000682(Z0Z_n + 2)
+		A001010n = 2 * Z0Z_n
+
+	return (A001010n, foldsTotal)
+

mapfolding-0.15.1/mapFolding/_oeisFormulas/Z0Z_aOFn.py

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

{mapfolding-0.14.1 → mapfolding-0.15.1}/mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -1,5 +1,6 @@
 from mapFolding._oeisFormulas.A000560 import A000560
 from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.A001010 import A001010
 from mapFolding._oeisFormulas.A005315 import A005315
 from mapFolding._oeisFormulas.A005316 import A005316
 from mapFolding._oeisFormulas.A223094 import A223094
@@ -8,9 +9,13 @@ from mapFolding._oeisFormulas.A301620 import A301620
 from mapFolding.oeis import getOEISidInformation, getOEISidValues
 import sys
 
+'A001011'
+# a(n) = (A001010(n) + A000136(n)) / 4
+
 oeisIDsMeanders: list[str] = [
 	'A000560',
 	'A000682',
+	'A001010',
 	'A005315',
 	'A005316',
 	'A223094',
@@ -39,6 +44,8 @@ if __name__ == '__main__':
 		assert A000560for_n == dictionaryOEISMeanders['A000560']['valuesKnown'][n]
 		A000682for_n = A000682(n)
 		assert A000682for_n == dictionaryOEISMeanders['A000682']['valuesKnown'][n]
+		nComputed, foldsTotal = A001010(n)
+		assert foldsTotal == dictionaryOEISMeanders['A001010']['valuesKnown'][nComputed]
 		A005315for_n = A005315(n)
 		assert A005315for_n == dictionaryOEISMeanders['A005315']['valuesKnown'][n]
 		A005316for_n = A005316(n)

mapfolding-0.15.1/mapFolding/_oeisFormulas/matrixMeanders.py

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

mapfolding-0.15.1/mapFolding/_oeisFormulas/matrixMeandersAnnex.py

@@ -0,0 +1,84 @@
+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), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+29: limitLocators(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000),
+30: limitLocators(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
+31: limitLocators(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
+32: limitLocators(0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
+33: limitLocators(0x555555555555555555, 0xaaaaaaaaaaaaaaaaaa, 0x400000000000000000),
+34: limitLocators(0x1555555555555555555, 0x2aaaaaaaaaaaaaaaaaa, 0x1000000000000000000),
+35: limitLocators(0x5555555555555555555, 0xaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000),
+36: limitLocators(0x15555555555555555555, 0x2aaaaaaaaaaaaaaaaaaa, 0x10000000000000000000),
+37: limitLocators(0x55555555555555555555, 0xaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000),
+38: limitLocators(0x155555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000),
+39: limitLocators(0x555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000),
+40: limitLocators(0x1555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000),
+41: limitLocators(0x5555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000),
+42: limitLocators(0x15555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000),
+43: limitLocators(0x55555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000),
+44: limitLocators(0x155555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000),
+45: limitLocators(0x555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000),
+46: limitLocators(0x1555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000),
+47: limitLocators(0x5555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000),
+48: limitLocators(0x15555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000),
+49: limitLocators(0x55555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000),
+50: limitLocators(0x155555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000),
+51: limitLocators(0x555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000),
+52: limitLocators(0x1555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000),
+53: limitLocators(0x5555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000),
+54: limitLocators(0x15555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000),
+55: limitLocators(0x55555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000),
+56: limitLocators(0x155555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000000),
+57: limitLocators(0x555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000000),
+58: limitLocators(0x1555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000000),
+59: limitLocators(0x5555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000000),
+60: limitLocators(0x15555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000000),
+61: limitLocators(0x55555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000000),
+}
+
+def makeCurveMaximum() -> None:
+	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
+	for n in range(62):
+		curveLocationsMAXIMUM = 1 << (2 * n + 4)
+		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()
+

{mapfolding-0.14.1 → mapfolding-0.15.1}/mapFolding/_theSSOT.py

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

mapfolding-0.15.1/mapFolding/_theTypes.py

@@ -0,0 +1,52 @@
+"""Types for defensive coding and for computation optimization."""
+
+from numpy import dtype, int_ as numpy_int, integer, ndarray, uint64 as numpy_uint64
+from typing import Any, TypeAlias, TypeVar
+
+NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
+"""Any NumPy integer type, which is usually between 8-bit signed and 64-bit unsigned."""
+
+DatatypeLeavesTotal: TypeAlias = int  # 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.
+"""Use on unsigned integers that will never exceed the magnitude of `leavesTotal`."""
+
+NumPyLeavesTotal: TypeAlias = numpy_int  # 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.
+"""Use in NumPy data structures whose elements are unsigned integers that will never exceed the magnitude of `leavesTotal`."""
+
+DatatypeElephino: TypeAlias = int  # 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.
+"""Use on unsigned integers that will exceed the magnitude of `leavesTotal` but that are not "colossal."
+
+Note well
+---------
+Colossal values are found with the cross humpy inequality:
+
+    ⎡ el  ⎤   ⎡     ⎤
+    ⎢ eph ⎥ X ⎢ rhi ⎥ <= elephino
+    ⎣ ant ⎦   ⎣ no  ⎦
+
+"""
+
+NumPyElephino: TypeAlias = numpy_int  # 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.
+"""Use in NumPy data structures whose elements are unsigned integers that might exceed the magnitude of `leavesTotal` but that are not 'colossal.'"""
+
+DatatypeFoldsTotal: TypeAlias = int  # 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.
+"""Use on unsigned integers that might have colossal magnitudes similar to `foldsTotal`."""
+
+NumPyFoldsTotal: TypeAlias = numpy_uint64  # 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.
+"""Use in NumPy data structures whose elements are unsigned integers that might have colossal magnitudes similar to `foldsTotal`.
+
+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
+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.
+"""A `numpy.ndarray` with three axes and elements of type `NumPyLeavesTotal`."""
+
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[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.
+"""A `numpy.ndarray` with one axis and elements of type `NumPyLeavesTotal`."""
+
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]  # 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.
+"""A `numpy.ndarray` with one axis and elements of type `NumPyElephino`."""
+
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]  # 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.
+"""A `numpy.ndarray` with one axis and elements of type `NumPyFoldsTotal`."""

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

@@ -31,7 +31,7 @@ from os import PathLike
 from pathlib import PurePath
 import contextlib
 
-def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR0912, PLR0915
+def countFolds(listDimensions: Sequence[int] | None = None
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
 				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
@@ -134,7 +134,79 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 
 	# Flow control until I can figure out a good way ---------------------------------
 
-	if flow == 'daoOfMapFolding':
+	# A007822 flow control until I can figure out a good way ---------------------------------
+	if oeisID == 'A007822':
+		"""Temporary notes.
+
+		The REAL motivation for integrating into basecamp is to integrate into the test modules. No, wait: to stop having to work
+		around the test modules.
+
+		I put `if oeisID == 'A007822'` in the `elif flow ==` cascade, before the `flow` checks because I want to remove A007822
+		from those flow paths. It is fundamentally incompatible and it will cause `Exception` or incorrect computations.
+
+		To use A007822, oeisID is mandatory.
+
+		Parameters:
+			listDimensions should work. mapShape should work. oeis_n should work. `pathLikeWriteFoldsTotal` should work!!! I
+			didn't think about that, and I like it.
+
+		Parallel version:
+			idk. The computation division logic will try to execute. As of 2025 Aug 6 at 7 PM, I haven't tried or thought about a
+			parallel version. TODO Watch out for errors.
+
+		`flow`:
+			It looks like I will need to make decisions tree just for A007822. That's probably not a big deal since all of the
+			possible routes are predictable.
+
+		"""
+		match flow:
+			case 'numba':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.algorithmA007822Numba import doTheNeedful  # noqa: PLC0415
+				mapFoldingState = doTheNeedful(mapFoldingState)
+
+			case 'theorem2':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.theorem2A007822 import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
+			case 'theorem2Numba':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.theorem2A007822Numba import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
+			case 'theorem2Trimmed':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.theorem2A007822Trimmed import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
+			case _:
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.algorithmA007822 import doTheNeedful  # noqa: PLC0415
+				mapFoldingState = doTheNeedful(mapFoldingState)
+
+		foldsTotal = mapFoldingState.groupsOfFolds
+
+	elif flow == 'daoOfMapFolding':
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
@@ -142,12 +214,20 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
+	elif flow == 'numba':
+		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
+
 	elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 		from mapFolding.syntheticModules.theorem2 import count  # noqa: PLC0415
 		mapFoldingState = count(mapFoldingState)
@@ -158,8 +238,8 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 		from mapFolding.syntheticModules.theorem2Trimmed import count  # noqa: PLC0415
 		mapFoldingState = count(mapFoldingState)
@@ -170,8 +250,8 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 		from mapFolding.syntheticModules.dataPacking import sequential  # noqa: PLC0415
 		mapFoldingState = sequential(mapFoldingState)
@@ -182,7 +262,7 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		from mapFolding.dataBaskets import ParallelMapFoldingState  # noqa: PLC0415
 		parallelMapFoldingState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
 
-		from mapFolding.syntheticModules.countParallel import doTheNeedful  # noqa: PLC0415
+		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful  # noqa: PLC0415
 
 		# `listStatesParallel` exists in case you want to research the parallel computation.
 		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]
@@ -191,7 +271,7 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
+		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 

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

@@ -121,12 +121,6 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 def _makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int) -> ndarray[tuple[int, int, int], numpy_dtype[numpy_int64]]:
 	"""Implement connection graph generation for map folding.
 
-	(AI generated docstring)
-
-	This is the internal implementation that calculates all possible connections between leaves in a map folding problem
-	based on Lunnon's algorithm. The function constructs a three-dimensional array representing which leaves can be
-	connected to each other for each dimension of the map.
-
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
@@ -177,12 +171,6 @@ def _makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int) -> ndarray
 def getConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: type[NumPyIntegerType]) -> ndarray[tuple[int, int, int], numpy_dtype[NumPyIntegerType]]:
 	"""Create a properly typed connection graph for the map folding algorithm.
 
-	(AI generated docstring)
-
-	This function serves as a typed wrapper around the internal implementation that generates connection graphs. It
-	provides the correct type information for the returned array, ensuring consistency throughout the computation
-	assembly-line.
-
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
@@ -204,25 +192,21 @@ def getConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: ty
 	return connectionGraph.astype(datatype)
 
 def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerType]) -> ndarray[Any, numpy_dtype[NumPyIntegerType]]:
-	"""Create a typed NumPy array container with initialized values.
-
-	(AI generated docstring)
+	"""Create any data container as long as it is a `numpy.ndarray` full of zeroes of type `numpy.integer`.
 
-	This function centralizes the creation of data containers used throughout the computation assembly-line, enabling
-	easy switching between different container types or implementation strategies if needed in the future.
+	By centralizing data container creation, you can more easily make global changes.
 
 	Parameters
 	----------
 	shape : int | tuple[int, ...]
-		Either an integer (for 1D arrays) or a tuple of integers (for multi-dimensional arrays) specifying the
-		dimensions of the array.
+		The array shape, either as a single axis length or a tuple of axes lengths.
 	datatype : type[NumPyIntegerType]
-		The NumPy integer type to use for the array elements, ensuring proper type consistency and memory efficiency.
+		The `numpy.integer` type for the array elements.
 
 	Returns
 	-------
 	container : ndarray[Any, numpy_dtype[NumPyIntegerType]]
-		A NumPy array of zeros with the specified shape and `datatype`.
+		A zero-filled `ndarray` with the specified `shape` and `datatype`.
 
 	"""
 	return numpy.zeros(shape, dtype=datatype)

{mapfolding-0.14.1 → mapfolding-0.15.1}/mapFolding/daoOfMapFolding.py

@@ -1,3 +1,4 @@
+# ruff: noqa: D100 D103
 from mapFolding.dataBaskets import MapFoldingState
 
 def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
@@ -139,4 +140,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
 	state = count(state)
-	return state
+	return state  # noqa: RET504