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

mapFolding/basecamp.py

@@ -1,27 +1,4 @@
-"""
-Unified interface for map folding computation orchestration.
-
-(AI generated docstring)
-
-This module represents the culmination of the computational ecosystem, providing
-the primary entry point where users interact with the complete map folding analysis
-system. It orchestrates all preceding layers: the configuration foundation,
-type system, core utilities, state management, and persistent storage to deliver
-a seamless computational experience.
-
-The interface handles multiple computation flows including sequential algorithms,
-experimental task division strategies, and various mathematical theorem implementations.
-It provides flexible parameter validation, computation method selection, task
-division management, processor utilization control, and automatic result persistence.
-Integration with OEIS sequences enables research validation and mathematical
-verification of computed results.
-
-Through this unified interface, researchers and practitioners can access the full
-power of Lunnon's algorithm implementation while the underlying computational
-complexity remains elegantly abstracted. The interface ensures that whether
-solving simple 2D problems or complex multi-dimensional challenges, users receive
-consistent, reliable, and efficiently computed folding pattern counts.
-"""
+"""Unified interface for map folding computation."""
 
 from collections.abc import Sequence
 from mapFolding import (
@@ -35,42 +12,62 @@ 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
-				, CPUlimit: int | float | bool | None = None  # noqa: FBT001
+				, CPUlimit: bool | float | int | None = None  # noqa: FBT001
 				, mapShape: tuple[int, ...] | None = None
 				, oeisID: str | None = None
 				, oeis_n: int | None = None
 				, flow: str | None = None
 				) -> int:
 	"""
-	Count the total number of possible foldings for a given map dimensions.
+	Count the total number of distinct ways to fold a map.
 
-	(AI generated docstring)
-
-	This function serves as the main public interface to the map folding algorithm, handling all parameter validation,
-	computation state management, and result persistence in a user-friendly way.
+	Mathematicians also describe this as folding a strip of stamps, and they usually call the total "number of distinct ways to
+	fold" a map the map's "foldings."
 
 	Parameters
 	----------
-	listDimensions
+	listDimensions : Sequence[int] | None = None
 		List of integers representing the dimensions of the map to be folded.
-	pathLikeWriteFoldsTotal: None
-		Path, filename, or pathFilename to write the total fold count to. If a directory is provided, creates a file
-		with a default name based on map dimensions.
-	computationDivisions: None
+	pathLikeWriteFoldsTotal : PathLike[str] | PurePath | None = None
+		A filename, a path of only directories, or a path with directories and a filename to which `countFolds` will write the
+		value of `foldsTotal`. If `pathLikeWriteFoldsTotal` is a path of only directories, `countFolds` creates a filename based
+		on the map dimensions.
+	computationDivisions : int | str | None = None
 		Whether and how to divide the computational work.
-		- `None`: no division of the computation into tasks; sets task divisions to 0.
-		- int: directly set the number of task divisions; cannot exceed the map's total leaves.
-		- `'maximum'`: divides into `leavesTotal`-many `taskDivisions`.
-		- `'cpu'`: limits the divisions to the number of available CPUs: i.e., `concurrencyLimit`.
-	CPUlimit: None
-		This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage.
+		- `None`: no division of the computation into tasks.
+		- `int`: into how many tasks `countFolds` will divide the computation. The values 0 or 1 are identical to `None`. It is
+		mathematically impossible to divide the computation into more tasks than the map's total leaves.
+		- 'maximum': divides the computation into `leavesTotal`-many tasks.
+		- 'cpu': divides the computation into the number of available CPUs.
+	CPUlimit : bool | float | int | None = None
+		If relevant, whether and how to limit the number of processors `countFolds` will use. `CPUlimit` is an irrelevant setting
+		unless the computation is divided into more than one task with the `computationDivisions` parameter.
 		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will
 		potentially limit processor usage.
 		- `True`: Yes, limit the processor usage; limits to 1 processor.
-		- Integer `>= 1`: Limits usage to the specified number of processors.
-		- Decimal value (`float`) between 0 and 1: Fraction of total processors to use.
-		- Decimal value (`float`) between -1 and 0: Fraction of processors to _not_ use.
-		- Integer `<= -1`: Subtract the absolute value from total processors.
+		- `int >= 1`: The maximum number of available processors to use.
+		- `0 < float < 1`: The maximum number of processors to use expressed as a fraction of available processors.
+		- `-1 < float < 0`: The number of processors to *not* use expressed as a fraction of available processors.
+		- `int <= -1`: The number of available processors to *not* use.
+		- If the value of `CPUlimit` is a `float` greater than 1 or less than -1, `countFolds` truncates the value to an `int`
+		with the same sign as the `float`.
+	mapShape : tuple[int, ...] | None = None
+		Tuple of integers representing the dimensions of the map to be folded. Mathematicians almost always use the term
+		"dimensions", such as in the seminal paper, "Multi-dimensional map-folding". Nevertheless, in contemporary Python
+		programming, in the context of these algorithms, the term "shape" makes it much easier to align the mathematics with the
+		syntax of the programming language.
+	oeisID : str | None = None
+		The On-Line Encyclopedia of Integer Sequences (OEIS) ID for which to compute a(n) for value of 'n' set in `oeis_n`.
+	oeis_n : int | None = None
+		The 'n' value for the `oeisID`.
+	flow : str | None = None
+		My stupid way of selecting the version of the algorithm to use in the computation. There are certainly better ways to do
+		this, but I have not yet solved this issue. As of 2025 Aug 14, these values will work:
+		- 'daoOfMapFolding'
+		- 'numba'
+		- 'theorem2'
+		- 'theorem2Numba'
+		- 'theorem2Trimmed'
 
 	Returns
 	-------
@@ -83,7 +80,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the
 	algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the
 	work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all
-	tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time,
+	tasks: at least 50% of the work done by every task must be done by each task. If you improve the computation time,
 	it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number
 	of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still
 	take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the
@@ -136,27 +133,16 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	# 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.
 
-		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.
+		`if oeisID == 'A007822'` precedes the `elif flow ==` cascade because A007822 is fundamentally incompatible with those flow
+		paths and it will cause `Exception` or incorrect computations.
 
 		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.
+			idk. The computation division logic will try to execute. As of 2025 Aug 13 at 11 PM, I haven't tried or thought about
+			a parallel version. And I don't really care. Potential parallelism is certainly present in `filterAsymmetricFolds`.
+			But, if I want to implement that, I should almost certainly replace `filterAsymmetricFolds` with a non-blocking
+			function to which `count` can pass the necessary values to. TODO Watch out for errors.
 
 		"""
 		match flow:

mapFolding/reference/matrixMeandersBaselineV2.py

@@ -0,0 +1,133 @@
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	listCurveMaximums: list[tuple[int, int, int]] = [
+(0x15, 0x2a, 0x10),
+(0x55, 0xaa, 0x40),
+(0x155, 0x2aa, 0x100),
+(0x555, 0xaaa, 0x400),
+(0x1555, 0x2aaa, 0x1000),
+(0x5555, 0xaaaa, 0x4000),
+(0x15555, 0x2aaaa, 0x10000),
+(0x55555, 0xaaaaa, 0x40000),
+(0x155555, 0x2aaaaa, 0x100000),
+(0x555555, 0xaaaaaa, 0x400000),
+(0x1555555, 0x2aaaaaa, 0x1000000),
+(0x5555555, 0xaaaaaaa, 0x4000000),
+(0x15555555, 0x2aaaaaaa, 0x10000000),
+(0x55555555, 0xaaaaaaaa, 0x40000000), # `bridges = 13`, 0xaaaaaaaa.bit_length() = 32
+(0x155555555, 0x2aaaaaaaa, 0x100000000),
+(0x555555555, 0xaaaaaaaaa, 0x400000000),
+(0x1555555555, 0x2aaaaaaaaa, 0x1000000000),
+(0x5555555555, 0xaaaaaaaaaa, 0x4000000000),
+(0x15555555555, 0x2aaaaaaaaaa, 0x10000000000),
+(0x55555555555, 0xaaaaaaaaaaa, 0x40000000000),
+(0x155555555555, 0x2aaaaaaaaaaa, 0x100000000000),
+(0x555555555555, 0xaaaaaaaaaaaa, 0x400000000000),
+(0x1555555555555, 0x2aaaaaaaaaaaa, 0x1000000000000),
+(0x5555555555555, 0xaaaaaaaaaaaaa, 0x4000000000000),
+(0x15555555555555, 0x2aaaaaaaaaaaaa, 0x10000000000000),
+(0x55555555555555, 0xaaaaaaaaaaaaaa, 0x40000000000000),
+(0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
+(0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
+(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000),
+(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000), # 0x5000000000000000.bit_length() = 63; 0xaaaaaaaaaaaaaaaa.bit_length() = 64; 0x5555555555555555.bit_length() = 63
+(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
+(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
+(0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
+(0x555555555555555555, 0xaaaaaaaaaaaaaaaaaa, 0x400000000000000000),
+(0x1555555555555555555, 0x2aaaaaaaaaaaaaaaaaa, 0x1000000000000000000),
+(0x5555555555555555555, 0xaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000),
+(0x15555555555555555555, 0x2aaaaaaaaaaaaaaaaaaa, 0x10000000000000000000),
+(0x55555555555555555555, 0xaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000),
+(0x155555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000),
+(0x555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000),
+(0x1555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000),
+(0x5555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000),
+(0x15555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000),
+(0x55555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000),
+(0x155555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000),
+(0x555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000),
+(0x1555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000),
+(0x5555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000),
+(0x15555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000),
+(0x55555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000),
+(0x155555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000),
+(0x555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000),
+(0x1555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000),
+(0x5555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000),
+(0x15555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000),
+(0x55555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000),
+(0x155555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000000),
+(0x555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000000),
+(0x1555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000000),
+(0x5555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000000),
+(0x15555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000000),
+(0x55555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000000),
+]
+	"""`bridges = 29`
+	0x5000000000000000.bit_length() = 63;
+	0xaaaaaaaaaaaaaaaa.bit_length() = 64;
+	0x5555555555555555.bit_length() = 63"""
+
+	listCurveMaximums = listCurveMaximums[0:bridges]
+
+	dictionaryCurveLocations: dict[int, int] = {}
+	while bridges > 0:
+		bridges -= 1
+
+		bifurcationAlphaLocator, bifurcationZuluLocator, curveLocationsMAXIMUM = listCurveMaximums[bridges]
+
+		for curveLocations, distinctCrossings in startingCurveLocations.items():
+			bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+
+			# Z0Z_simpleBridges
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# bifurcationAlphaCurves
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlphaShiftRight2 := bifurcationAlpha >> 2) | (bifurcationZulu << 3) | ((bifurcationAlphaIsEven := 1 - (bifurcationAlpha & 0b1)) << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# bifurcationZuluCurves
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | (bifurcationZuluIsEven := 1 - (bifurcationZulu & 1))
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# Z0Z_alignedBridges
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves:
+				# One Truth-check to select a code path
+				bifurcationsCanBePairedTogether = (bifurcationZuluIsEven << 1) | bifurcationAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
+
+				if bifurcationsCanBePairedTogether != 0:  # Case 0 (False, False)
+					XOrHere2makePair = 0b1
+					findUnpaired_0b1 = 0
+
+					if bifurcationsCanBePairedTogether == 1:  # Case 1: (False, True)
+						while findUnpaired_0b1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpaired_0b1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+						bifurcationAlphaShiftRight2 = (bifurcationAlpha ^ XOrHere2makePair) >> 2
+					elif bifurcationsCanBePairedTogether == 2:  # Case 2: (True, False)
+						while findUnpaired_0b1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpaired_0b1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+						bifurcationZulu ^= XOrHere2makePair
+
+					# Cases 1, 2, and 3 all compute curveLocationAnalysis
+# TODO https://github.com/hunterhogan/mapFolding/issues/19
+					curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | bifurcationAlphaShiftRight2 # pyright: ignore[reportPossiblyUnboundVariable]
+					if curveLocationAnalysis < curveLocationsMAXIMUM:
+						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+		startingCurveLocations.clear()
+		startingCurveLocations, dictionaryCurveLocations = dictionaryCurveLocations, startingCurveLocations
+
+	return sum(startingCurveLocations.values())
+

mapFolding/someAssemblyRequired/A007822rawMaterials.py

@@ -21,7 +21,7 @@ def {Z0Z_identifier}(state: MapFoldingState) -> MapFoldingState:
 		ImaSymmetricFold = True
 		leafConnectee = 0
 		while leafConnectee < indexInMiddle:
-			if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+			if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
 				ImaSymmetricFold = False
 				break
 			leafConnectee += 1

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -5,13 +5,13 @@ https://docs.exaloop.io/start/install/
 
 from astToolkit import (
 	Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
-	NodeTourist, Then)
+	NodeTourist, parseLogicalPath2astModule, Then)
 from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
 from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
-from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
+from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds
 from pathlib import Path, PurePosixPath
 from typing import cast, NamedTuple, TYPE_CHECKING
 import ast
@@ -214,11 +214,12 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 	"""
 	state = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
 	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
+	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2A007822Numba')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	aJob = RecipeJobTheorem2(state, source_astModule=source_astModule, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	makeJob(aJob)
 
 if __name__ == '__main__':
-	mapShape = (2, 21)
+	mapShape = (1, 15)
 	fromMapShape(mapShape)
 

mapFolding/syntheticModules/algorithmA007822.py

@@ -14,7 +14,7 @@ def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
         ImaSymmetricFold = True
         leafConnectee = 0
         while leafConnectee < indexInMiddle:
-            if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+            if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                 ImaSymmetricFold = False
                 break
             leafConnectee += 1

mapFolding/syntheticModules/algorithmA007822Numba.py

@@ -19,7 +19,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal + 1 - 2 - leafConnectee) % (leavesTotal + 1)]:
+                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/dataPacking.py

@@ -1,6 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from mapFolding.syntheticModules.theorem2Numba import count
 
 def sequential(state: MapFoldingState) -> MapFoldingState:
@@ -25,4 +23,4 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    return state

mapFolding/syntheticModules/dataPackingA007822.py

@@ -1,6 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from mapFolding.syntheticModules.theorem2A007822Numba import count
 
 def sequential(state: MapFoldingState) -> MapFoldingState:
@@ -25,4 +23,4 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    return state

mapFolding/syntheticModules/initializeStateA007822.py

@@ -17,7 +17,7 @@ def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/theorem2A007822.py

@@ -17,7 +17,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/theorem2A007822Numba.py

@@ -19,7 +19,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal + 1 - 2 - leafConnectee) % (leavesTotal + 1)]:
+                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/theorem2A007822Trimmed.py

@@ -17,7 +17,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/tests/conftest.py

@@ -224,7 +224,8 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 @pytest.fixture
 def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if
+	`validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
 
 	Parameters
 	----------

mapFolding/tests/test_computations.py

@@ -26,6 +26,7 @@ which is useful if you're working with the code synthesis features of the packag
 """
 
 from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding._oeisFormulas.Z0Z_oeisMeanders import dictionaryOEISMeanders
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.oeis import dictionaryOEIS
 from mapFolding.someAssemblyRequired.makeAllModules import parametersNumbaLight
@@ -41,34 +42,9 @@ import pytest
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2numba', 'theorem2Trimmed'])
-def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
-	"""Validate that different computational flows produce identical results.
-
-	(AI generated docstring)
-
-	This is the primary test for ensuring mathematical consistency across different
-	algorithmic implementations. When adding a new computational approach, include
-	it in the parametrized flow list to verify it produces correct results.
-
-	The test compares the output of each flow against known correct values from
-	OEIS sequences, ensuring that optimization techniques don't compromise accuracy.
-
-	Parameters
-	----------
-	mapShapeTestCountFolds : tuple[int, ...]
-		The map shape dimensions to test fold counting for.
-	flow : Literal['daoOfMapFolding', 'theorem2', 'theorem2numba']
-		The computational flow algorithm to validate.
-
-	"""
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
-
 def test_aOFn_calculate_value(oeisID: str) -> None:
 	"""Verify OEIS sequence value calculations against known reference values.
 
-	(AI generated docstring)
-
 	Tests the `oeisIDfor_n` function by comparing its calculated output against
 	known correct values from the OEIS database. This ensures that sequence
 	value computations remain mathematically accurate across code changes.
@@ -86,30 +62,61 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 	for n in dictionaryOEIS[oeisID]['valuesTestValidation']:
 		standardizedEqualToCallableReturn(dictionaryOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
-@pytest.mark.parametrize('flow', ['numba', 'theorem2', 'theorem2numba', 'theorem2Trimmed'])
-def test_flowControlByOEISid(flow: str) -> None:
-	"""Crappy.
-
-	I'm making this while pushing through pain, so it's not great but it's a step in the right direction.
+@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
+def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
+	"""Validate that different computational flows produce valid results.
 
-	Notes for future me:
+	(AI generated docstring)
 
-	`oeisID` is a fixture: don't use it here.
+	This is the primary test for ensuring mathematical consistency across different
+	algorithmic implementations. When adding a new computational approach, include
+	it in the parametrized flow list to verify it produces correct results.
 
-	`OEISid` matches `test_flowControlByOEISid`. It's pseudo-hardcoded to A007822 because that's currently the only OEISid that needs this test.
-	I tried:
-	`def test_flowControlByOEISid(OEISid: str | None, flow: str) -> None:`
+	The test compares the output of each flow against known correct values from
+	OEIS sequences, ensuring that optimization techniques don't compromise accuracy.
 
-	But that's wrong.
+	Parameters
+	----------
+	mapShapeTestCountFolds : tuple[int, ...]
+		The map shape dimensions to test fold counting for.
+	flow : str
+		The computational flow algorithm to validate.
 
-	So, I'm changing the local identifier `OEISid` back to `oeisID` because I use `oeisID` everywhere else.
 	"""
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
 
-	oeisID = 'A007822'
+@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
+def test_flowControlByOEISid(oeisID: str, flow: str) -> None:
+	"""Validate that different flow paths using oeisID produce valid results.
 
-	for n in dictionaryOEIS[oeisID]['valuesTestValidation']:
-		mapShape = dictionaryOEIS[oeisID]['getMapShape'](n)
-		standardizedEqualToCallableReturn(dictionaryOEIS[oeisID]['valuesKnown'][n], countFolds, None, None, None, None, mapShape, oeisID, None, flow)
+	Parameters
+	----------
+	oeisID : str
+		The OEIS sequence identifier to test.
+	flow : str
+		The computational flow algorithm to validate.
+
+	"""
+	listDimensions = None
+	pathLikeWriteFoldsTotal = None
+	computationDivisions = None
+	CPUlimit = None
+	mapShape = None
+
+	oeis_n = 2
+	for oeis_n in dictionaryOEIS[oeisID]['valuesTestValidation']:
+		if oeis_n < 2:
+			continue
+
+		if oeisID in dictionaryOEISMeanders:
+			expected = dictionaryOEISMeanders[oeisID]['valuesKnown'][oeis_n]
+		else:
+			expected = dictionaryOEIS[oeisID]['valuesKnown'][oeis_n]
+
+		standardizedEqualToCallableReturn(
+			expected
+			, countFolds, listDimensions, pathLikeWriteFoldsTotal, computationDivisions, CPUlimit, mapShape
+			, oeisID, oeis_n, flow)
 
 @pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None:

{mapfolding-0.15.2.dist-info → mapfolding-0.15.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.15.2
+Version: 0.15.3
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -39,6 +39,7 @@ Requires-Dist: hunterMakesPy
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Provides-Extra: development
+Requires-Dist: memray; sys_platform == "linux" and extra == "development"
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"
 Requires-Dist: py-spy; extra == "development"