mapFolding 0.14.1__tar.gz → 0.15.0__tar.gz

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

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

mapfolding-0.15.0/mapFolding/_A007822.py

@@ -0,0 +1,181 @@
+from mapFolding import Array1DLeavesTotal, makeDataContainer, NumPyLeavesTotal
+from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.oeis import dictionaryOEIS
+import numpy
+import sys
+import time
+
+def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+	return state.leaf1ndex <= 1
+
+def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+		state = incrementActiveGap(state)
+	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+	return state
+
+def gapAvailable(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	while state.indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+		state.gap1ndexCeiling += 1
+		state.indexLeaf += 1
+	return state
+
+def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex -= 1
+	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+	state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+	state.leaf1ndex += 1
+	return state
+
+def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+	return state.leafBelow[0] == 1
+
+def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def noGapsHere(state: MapFoldingState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+	state.indexDimension += 1
+	return state
+
+def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+	state.leaf1ndex -= 1
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+	return state
+
+def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
+	lengthLeafBelow = len(state.leafBelow)
+
+	indexLeaf: int = 0
+	for leafConnectee in range(lengthLeafBelow):
+		leafNumber = int(state.leafBelow[indexLeaf])
+		state.leafComparison[leafConnectee] = (leafNumber - indexLeaf + lengthLeafBelow - 1) % (lengthLeafBelow - 1)
+		indexLeaf = leafNumber
+
+	indexInMiddle = (lengthLeafBelow - 1) // 2
+	for delta in range(lengthLeafBelow):
+		ImaSymmetricFold = True
+		for leafConnectee in range(indexInMiddle):
+			if state.leafComparison[(delta + leafConnectee) % lengthLeafBelow] != state.leafComparison[(delta + lengthLeafBelow - 2 - leafConnectee) % lengthLeafBelow]:
+				ImaSymmetricFold = False
+				break
+		if ImaSymmetricFold:
+			state.groupsOfFolds += 1
+
+	return state
+
+def count(state: MapFoldingState) -> MapFoldingState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state = filterAsymmetricFolds(state)
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopingThroughTheDimensions(state):
+					state = lookupLeafConnecteeInConnectionGraph(state)
+					if leafConnecteeIsActiveLeaf(state):
+						state = activeLeafUnconstrainedInThisDimension(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = lookForGaps(state)
+							state = tryAnotherLeafConnectee(state)
+					state = tryNextDimension(state)
+				if activeLeafIsUnconstrainedInAllDimensions(state):
+					state = insertActiveLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = undoLastLeafPlacement(state)
+		if gapAvailable(state):
+			state = insertActiveLeafAtGap(state)
+	return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+	state = count(state)
+	state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+	return state
+
+def Z0Z_flowNeedsFixing(mapShape: tuple[int, ...]) -> int:
+	return doTheNeedful(MapFoldingState(mapShape)).groupsOfFolds
+
+if __name__ == '__main__':
+	for n in range(3, 7):
+		mapShape = dictionaryOEIS['A007822']['getMapShape'](n)
+
+		state = MapFoldingState(mapShape)
+		timeStart = time.perf_counter()
+		foldsTotal = doTheNeedful(state).groupsOfFolds
+		sys.stdout.write(f"{foldsTotal == dictionaryOEIS['A007822']['valuesKnown'][n]} {n} {foldsTotal = } {time.perf_counter() - timeStart:.2f}\n")

{mapfolding-0.14.1 → mapfolding-0.15.0}/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,

{mapfolding-0.14.1 → mapfolding-0.15.0}/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.0/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.0}/mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -8,6 +8,8 @@ from mapFolding._oeisFormulas.A301620 import A301620
 from mapFolding.oeis import getOEISidInformation, getOEISidValues
 import sys
 
+'A001010'
+'A001011'
 oeisIDsMeanders: list[str] = [
 	'A000560',
 	'A000682',

mapfolding-0.15.0/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.0/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.0}/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.0/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 × 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.0}/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

{mapfolding-0.14.1 → mapfolding-0.15.0}/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)