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

mapFolding/algorithms/oeisIDbyFormula.py

@@ -0,0 +1,113 @@
+from functools import cache
+from mapFolding import countFolds
+from mapFolding.algorithms.matrixMeanders import doTheNeedful
+
+@cache
+def A000136(n: int) -> int:
+	return n * A000682(n)
+
+def A000560(n: int) -> int:
+	return A000682(n + 1) // 2
+
+def A000682getCurveLocations(n: int) -> dict[int, int]:
+	curveLocationsMAXIMUM: int = 1 << (2 * n + 4)
+
+	curveStart: int = 5 - (n & 0b1) * 4
+	listCurveLocations: list[int] = [(curveStart << 1) | curveStart]
+
+	while listCurveLocations[-1] < curveLocationsMAXIMUM:
+		curveStart = (curveStart << 4) | 0b101
+		listCurveLocations.append((curveStart << 1) | curveStart)
+
+	return dict.fromkeys(listCurveLocations, 1)
+
+@cache
+def A000682(n: int) -> int:
+	return doTheNeedful(n - 1, A000682getCurveLocations(n - 1))
+
+def A001010(n: int) -> int:
+	"""Formulas.
+
+	a(2n-1) = 2*A007822(n)
+	OddQ[n], 2*A007822[[(n - 1)/2 + 1]]]
+
+	a(2n) = 2*A000682(n+1)
+	EvenQ[n], 2*A000682[[n/2 + 1]]
+	"""
+	if n == 1:
+		foldsTotal = 1
+	elif n & 0b1:
+		foldsTotal = 2 * countFolds(oeisID='A007822', oeis_n=(n - 1)//2 + 1, flow='theorem2Numba')
+	else:
+		foldsTotal = 2 * A000682(n // 2 + 1)
+	return foldsTotal
+
+def A001011(n: int) -> int:
+	if n == 0:
+		foldsTotal = 1
+	else:
+		foldsTotal = (A001010(n) + A000136(n)) // 4
+	return foldsTotal
+
+def A005316getCurveLocations(n: int) -> dict[int, int]:
+	if n & 0b1:
+		return {22: 1}
+	else:
+		return {15: 1}
+
+@cache
+def A005316(n: int) -> int:
+	return doTheNeedful(n-1, A005316getCurveLocations(n-1))
+
+@cache
+def A005315(n: int) -> int:
+	if n == 1:
+		foldsTotal = 1
+	else:
+		foldsTotal = A005316(2 * n - 1)
+	return foldsTotal
+
+def A060206(n: int) -> int:
+	return A000682(2 * n + 1)
+
+def A077460(n: int) -> int:
+	"""Formulas.
+
+	a[0] = a[1] = 1;
+	a[n_] := If[OddQ[n], (A005316[[n + 1]] + A005316[[2n]] + A000682[[n]])/4
+	a(2n+1) = (A005315(2n+1) + A005316(2n+1) + A060206(n)) / 4.
+
+	a(2n) = (A005315(2n) + 2 * A005316(2n)) / 4.
+	(A005316[[2n]] + 2 A005316[[n + 1]])/4];
+
+	"""
+	if n in {0, 1}:
+		foldsTotal = 1
+	elif n & 0b1:
+		foldsTotal = (A005315(n) + A005316(n) + A060206((n - 1) // 2)) // 4
+	else:
+		foldsTotal = (A005315(n) + 2 * A005316(n)) // 4
+
+	return foldsTotal
+
+def A078591(n: int) -> int:
+	return A005315(n) // 2
+
+def A178961(n: int) -> int:
+	from mapFolding.oeis import dictionaryOEISMeanders  # noqa: PLC0415
+	A001010valuesKnown: dict[int, int] = dictionaryOEISMeanders['A001010']['valuesKnown']
+	foldsTotal: int = 0
+	for n下i in range(1, n+1):
+		foldsTotal += A001010valuesKnown[n下i]
+	return foldsTotal
+
+def A223094(n: int) -> int:
+	return A000136(n) - A000682(n + 1)
+# TODO A223094 For n >= 3: a(n) = n! - Sum_{k=3..n-1} (a(k)*n!/k!) - A000682(n+1). - _Roger Ford_, Aug 24 2024
+
+def A259702(n: int) -> int:
+	return A000682(n) // 2 - A000682(n - 1)
+
+def A301620(n: int) -> int:
+	return A000682(n + 2) - 2 * A000682(n + 1)
+# TODO A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018

mapFolding/basecamp.py

@@ -8,6 +8,58 @@ from os import PathLike
 from pathlib import PurePath
 import contextlib
 
+"""TODO new flow paradigm, incomplete
+
+algorithms directory
+	manually coded algorithms or formulas
+	countFolds will be a stable interface for multidimensional map folding, including synthetic modules
+		This has special treatment because people may want to call mapShape not defined in OEIS
+	countMeanders will be a stable interface for meanders
+		This has special treatment because people may want to call meanders not defined in OEIS
+	an enhanced version of oeisIDfor_n will be a stable interface for calling by ID and n
+
+General flow structure
+	doTheNeedful
+		specific to that version of that algorithm
+		abstracts the API for that algorithm, so that algorithm (such as multidimensional map folding) has a stable interface
+		The last place to do defensive programming
+
+- Incomplete: how to count
+	- currently in parameters computationDivisions, CPUlimit, and flow
+
+- Flow in count______
+	- DEFENSIVE PROGRAMMING
+	- FAIL EARLY
+	- Implement "common foundational logic".
+		- IDK what the correct technical term is, but I'm sure other people have researched excellent ways to do this.
+		- Example: in `countFolds`, every possible flow path needs `mapShape`. Therefore, `mapShape` is foundational logic that
+			all flow paths have in common: "common foundational logic".
+		- Example: in `countFolds`, some flow paths have more than one "task division" (i.e., the computation is divided into
+			multiple tasks), while other flow paths only have one task division. One reasonable perspective is that computing task
+			divisions is NOT "common foundational logic". My perspective for this example: to compute whether or not there are
+			task divisions and if so, how many task divisions is identical for all flow paths. Therefore, I handle computing task
+			divisions as "common foundational logic".
+		- Incomplete
+	- Initialize memorialization instructions, if asked
+	- MORE DEFENSIVE PROGRAMMING
+	- FAIL EARLIER THAN EARLY
+	- Incomplete
+	- DEFENSIVE PROGRAMMING ON BEHALF of downstream modules and functions
+	- FAIL SO EARLY IT IS BEFORE THE USER INSTALLS THE APP
+	- Incomplete
+	- REPEAT MANY OR ALL OF THE DEFENSIVE PROGRAMMING YOU HAVE ALREADY DONE
+
+	- Incomplete
+	- Pass control to the correct `doTheNeedful`
+	- I don't know how to "elegantly" pass control without putting `doTheNeedful` over `count______` in the stack, therefore,
+		control will come back here.
+	- DO NOT, for the love of puppies and cookies, DO NOT use defensive programming here. Defensive programming AFTER a
+		four-week-long computation is a tacit admission of incompetent programming.
+	- Follow memorialization instructions: which means pass control to a function will tenaciously follow the instructions.
+	- return "a(n)" (as OEIS calls it), such as foldsTotal
+
+"""
+
 def countFolds(listDimensions: Sequence[int] | None = None
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
@@ -93,9 +145,9 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		pass
 	else:
 		if oeisID and oeis_n:
-			from mapFolding.oeis import dictionaryOEIS  # noqa: PLC0415
+			from mapFolding.oeis import dictionaryOEISMapFolding  # noqa: PLC0415
 			with contextlib.suppress(KeyError):
-				mapShape = dictionaryOEIS[oeisID]['getMapShape'](oeis_n)
+				mapShape = dictionaryOEISMapFolding[oeisID]['getMapShape'](oeis_n)
 		if not mapShape and listDimensions:
 			mapShape = validateListDimensions(listDimensions)
 
@@ -196,7 +248,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
+		from mapFolding.algorithms.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 

mapFolding/oeis.py

@@ -24,41 +24,20 @@ redundant computation, or extending mathematical knowledge, this integration
 completes the journey from configuration foundation to mathematical discovery.
 """
 
-from collections.abc import Callable
 from datetime import datetime, timedelta, UTC
 from hunterMakesPy import writeStringToHere
 from itertools import chain
-from mapFolding import countFolds
-from mapFolding._theSSOT import cacheDays, pathCache, settingsOEISManuallySelected
+from mapFolding import countFolds, MetadataOEISidMapFolding, MetadataOEISidMeanders, packageSettings
+from mapFolding._theSSOT import pathCache
 from pathlib import Path
-from typing import Final, TypedDict
+from typing import Final
 from urllib.request import urlopen
 import argparse
 import sys
 import time
 import warnings
 
-class MetadataOEISid(TypedDict):
-	"""Settings for an implemented OEIS sequence."""
-
-	description: str
-	"""The OEIS.org description of the integer sequence."""
-	getMapShape: Callable[[int], tuple[int, ...]]
-	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
-	offset: int
-	"""The starting index, 'n', of the sequence, typically 0 or 1."""
-	valuesBenchmark: list[int]
-	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
-	valuesKnown: dict[int, int]
-	"""Dictionary of sequence indices, 'n', to their known values, `foldsTotal`."""
-	valuesTestParallelization: list[int]
-	"""List of index values, 'n', to use when testing parallelization performance."""
-	valuesTestValidation: list[int]
-	"""List of index values, 'n', to use when testing validation performance."""
-	valueUnknown: int
-	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
-
-oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEISManuallySelected])
+oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in packageSettings.OEISidMapFoldingManuallySet])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
 def _standardizeOEISid(oeisID: str) -> str:
@@ -134,13 +113,7 @@ def _parseBFileOEIS(OEISbFile: str) -> dict[int, int]:
 	return OEISsequence
 
 def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
-	"""Retrieve OEIS sequence data from cache or online source with intelligent caching.
-
-	(AI generated docstring)
-
-	This function implements a caching strategy that prioritizes local cached data when it exists and
-	has not expired. Fresh data is retrieved from the OEIS website when the cache is stale or missing,
-	and the cache is updated for future use.
+	"""Retrieve OEIS ID data from oeis.org or local cache.
 
 	Parameters
 	----------
@@ -154,16 +127,11 @@ def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 	oeisInformation : str | None
 		The retrieved OEIS sequence information as a string, or `None` if retrieval failed.
 
-	Notes
-	-----
-	Cache expiration is controlled by the module-level `cacheDays` variable. The function validates
-	URL schemes and issues warnings for failed retrievals.
-
 	"""
 	tryCache: bool = False
 	if pathFilenameCache.exists():
 		fileAge: timedelta = datetime.now(tz=UTC) - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime, tz=UTC)
-		tryCache = fileAge < timedelta(days=cacheDays)
+		tryCache = fileAge < timedelta(days=packageSettings.cacheDays)
 
 	oeisInformation: str | None = None
 	if tryCache:
@@ -176,7 +144,8 @@ def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 		if not url.startswith(("http:", "https:")):
 			message = "URL must start with 'http:' or 'https:'"
 			raise ValueError(message)
-		with urlopen(url) as response:
+
+		with urlopen(url) as response:  # noqa: S310
 			oeisInformationRaw = response.read().decode('utf-8')
 		oeisInformation = str(oeisInformationRaw)
 		writeStringToHere(oeisInformation, pathFilenameCache)
@@ -279,7 +248,7 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	description: str = ' '.join(listDescriptionDeconstructed)
 	return description, offset
 
-def _makeDictionaryOEIS() -> dict[str, MetadataOEISid]:
+def _makeDictionaryOEIS() -> dict[str, MetadataOEISidMapFolding]:
 	"""Construct the comprehensive settings dictionary for all implemented OEIS sequences.
 
 	(AI generated docstring)
@@ -302,23 +271,23 @@ def _makeDictionaryOEIS() -> dict[str, MetadataOEISid]:
 		objects, containing all metadata and known values needed for computation and validation.
 
 	"""
-	dictionaryOEIS: dict[str, MetadataOEISid] = {}
+	dictionaryOEIS: dict[str, MetadataOEISidMapFolding] = {}
 	for oeisID in oeisIDsImplemented:
 		valuesKnownSherpa: dict[int, int] = getOEISidValues(oeisID)
 		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
-		dictionaryOEIS[oeisID] = MetadataOEISid(
+		dictionaryOEIS[oeisID] = MetadataOEISidMapFolding(
 			description=descriptionSherpa,
 			offset=offsetSherpa,
-			getMapShape=settingsOEISManuallySelected[oeisID]['getMapShape'],
-			valuesBenchmark=settingsOEISManuallySelected[oeisID]['valuesBenchmark'],
-			valuesTestParallelization=settingsOEISManuallySelected[oeisID]['valuesTestParallelization'],
-			valuesTestValidation=settingsOEISManuallySelected[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
+			getMapShape=packageSettings.OEISidMapFoldingManuallySet[oeisID]['getMapShape'],
+			valuesBenchmark=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesBenchmark'],
+			valuesTestParallelization=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesTestParallelization'],
+			valuesTestValidation=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
 			valuesKnown=valuesKnownSherpa,
 			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1
 		)
 	return dictionaryOEIS
 
-dictionaryOEIS: dict[str, MetadataOEISid] = _makeDictionaryOEIS()
+dictionaryOEISMapFolding: dict[str, MetadataOEISidMapFolding] = _makeDictionaryOEIS()
 """Metadata for each OEIS sequence ID."""
 
 def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
@@ -332,7 +301,7 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 
 	"""
 	return dict(chain.from_iterable(zip(map(oeisIDmetadata['getMapShape'], oeisIDmetadata['valuesKnown'].keys())
-	, oeisIDmetadata['valuesKnown'].values(), strict=True) for oeisID, oeisIDmetadata in dictionaryOEIS.items() if oeisID != 'A007822'))
+	, oeisIDmetadata['valuesKnown'].values(), strict=True) for oeisID, oeisIDmetadata in dictionaryOEISMapFolding.items() if oeisID != 'A007822'))
 
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""Retrieve the known total number of distinct folding patterns for a given map shape.
@@ -378,7 +347,7 @@ def _formatHelpText() -> str:
 
 	"""
 	exampleOEISid: str = oeisIDsImplemented[0]
-	exampleN: int = dictionaryOEIS[exampleOEISid]['valuesTestValidation'][-1]
+	exampleN: int = dictionaryOEISMapFolding[exampleOEISid]['valuesTestValidation'][-1]
 
 	return (
 		"\nAvailable OEIS sequences:\n"
@@ -406,7 +375,7 @@ def _formatOEISsequenceInfo() -> str:
 
 	"""
 	return "\n".join(
-		f"  {oeisID}: {dictionaryOEIS[oeisID]['description']}"
+		f"  {oeisID}: {dictionaryOEISMapFolding[oeisID]['description']}"
 		for oeisID in oeisIDsImplemented
 	)
 
@@ -441,14 +410,14 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 		message = f"I received `{n = }` in the form of `{type(n) = }`, but it must be non-negative integer in the form of `{int}`."
 		raise ValueError(message)
 
-	mapShape = dictionaryOEIS[oeisID]['getMapShape'](n)
+	mapShape = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 	if n <= 1 or len(mapShape) < 2:
-		offset: int = dictionaryOEIS[oeisID]['offset']
+		offset: int = dictionaryOEISMapFolding[oeisID]['offset']
 		if n < offset:
 			message = f"OEIS sequence {oeisID} is not defined at {n = }."
 			raise ArithmeticError(message)
-		foldsTotal: int = dictionaryOEIS[oeisID]['valuesKnown'][n]
+		foldsTotal: int = dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]
 		return foldsTotal
 
 	return countFolds(mapShape, oeisID=oeisID)
@@ -513,7 +482,7 @@ def clearOEIScache() -> None:
 	if not pathCache.exists():
 		print(f"Cache directory, {pathCache}, not found - nothing to clear.")  # noqa: T201
 		return
-	for oeisID in dictionaryOEIS:
+	for oeisID in dictionaryOEISMapFolding:
 		( pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
 		( pathCache / _getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
 	print(f"Cache cleared from {pathCache}")  # noqa: T201
@@ -534,5 +503,22 @@ def getOEISids() -> None:
 	"""
 	print(_formatHelpText())  # noqa: T201
 
+def _makeDictionaryOEISMeanders() -> dict[str, MetadataOEISidMeanders]:
+	dictionary: dict[str, MetadataOEISidMeanders] = {}
+	for oeisID in packageSettings.OEISidMeandersManuallySet:
+		valuesKnownSherpa: dict[int, int] = getOEISidValues(oeisID)
+		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
+		dictionary[oeisID] = MetadataOEISidMeanders(
+			description=descriptionSherpa,
+			offset=offsetSherpa,
+			valuesKnown=valuesKnownSherpa,
+			valuesTestValidation=packageSettings.OEISidMeandersManuallySet[oeisID]['valuesTestValidation'],
+			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1,
+		)
+	return dictionary
+
+dictionaryOEISMeanders: dict[str, MetadataOEISidMeanders] = _makeDictionaryOEISMeanders()
+
 if __name__ == "__main__":
 	getOEISids()
+

mapFolding/{_oeisFormulas/matrixMeanders64.py → reference/meandersDumpingGround/matrixMeanders64retired.py}

@@ -15,7 +15,6 @@ def make1array(listArrays: list[numpy.ndarray[tuple[int, ...], numpy.dtype[numpy
 		, (arrayCurveLocations & numpy.uint64(0xaaaaaaaaaaaaaaaa)) >> numpy.uint64(1)
 		, arrayCurveLocations
 	))
-
 	for arrayCurveLocations in listArrays:
 		arrayOut[:, indexDistinctCrossings] += numpy.sum(arrayCurveLocations[:, 0] * (arrayCurveLocations[:, -1][:, numpy.newaxis] == arrayOut[:, indexCurveLocations]).T, axis=1)
 
@@ -42,31 +41,39 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 		# Selector-adjacent
 		curveLocationsMAXIMUM: numpy.uint64 = numpy.uint64(1) << numpy.uint64(2 * bridges + 4)
 		# Selectors, general
-		selectBifurcationAlphaCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationAlpha] > numpy.uint64(1)
+		selectBifurcationAlphaCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1)
 		selectBifurcationAlphaEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & numpy.uint64(1)) == numpy.uint64(0)
-		selectBifurcationZuluCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationZulu] > numpy.uint64(1)
+		selectBifurcationZuluCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationZulu] != numpy.uint64(1)
 		selectBifurcationZuluEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & numpy.uint64(1)) == numpy.uint64(0)
 
-		# BridgesSimple
+		# bridgesSimple
 		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexDistinctCrossings] >= numpy.uint64(0) # This had better always be `True`.
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (((arrayBifurcations[selector, indexBifurcationAlpha] | (arrayBifurcations[selector, indexBifurcationZulu] << numpy.uint64(1))) << numpy.uint64(2)) | numpy.uint64(3))
 		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
 
-		# BifurcationAlphaCurves
-		selector = selectBifurcationAlphaCurves
-		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.bitwise_or.reduce((
-			arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2)
-			, arrayBifurcations[selector, indexBifurcationZulu] << numpy.uint64(3)
-			, (numpy.uint64(1) - (arrayBifurcations[selector, indexBifurcationAlpha] & numpy.uint64(1))) << numpy.uint64(1)
+		# bifurcationAlphaCurves
+		this = numpy.bitwise_or.reduce((
+			arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexBifurcationAlpha] >> numpy.uint64(2)
+			, arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexBifurcationZulu] << numpy.uint64(3)
+			, (numpy.uint64(1) - (arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexBifurcationAlpha] & numpy.uint64(1))) << numpy.uint64(1)
 		))
-		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.where(this < curveLocationsMAXIMUM, this, numpy.uint64(0))
+		# print(curveLocations.astype(numpy.bool_))
+		print(curveLocations)
+		distinctCrossings = arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexDistinctCrossings]
+		print(distinctCrossings)
+		listArrayCurveLocationsAnalyzed.append(
+			numpy.column_stack((distinctCrossings, curveLocations))
+		)
+		# print(arrayBifurcations)
+		# print(listArrayCurveLocationsAnalyzed[-1])
 
-		# BifurcationZuluCurves
+		# bifurcationZuluCurves
 		selector = selectBifurcationZuluCurves
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.bitwise_or.reduce((
 			arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(1)
 			, arrayBifurcations[selector, indexBifurcationAlpha] << numpy.uint64(2)
-			, (1 - (arrayBifurcations[selector, indexBifurcationZulu] & numpy.uint64(1)))
+			, (numpy.uint64(1) - (arrayBifurcations[selector, indexBifurcationZulu] & numpy.uint64(1)))
 		))
 		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
 
@@ -75,24 +82,24 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, ~selectBifurcationZuluEven
 		))
 
-			# Initialize
-		Z0Z_selectBridgesBifurcationAlphaToModify = selector.copy()
+		# Initialize
 		XOrHere2makePair = numpy.uint64(1)
-		selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
-		selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
 
-		while Z0Z_selectBridgesBifurcationAlphaToModify.any():
+		while selector.any():
 			XOrHere2makePair <<= numpy.uint64(2)
 
-			selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & XOrHere2makePair) == numpy.uint64(0)
-			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationAlphaToModify, selectToModifyByXOR))
+			selectUnpaired_0b1: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & XOrHere2makePair) == numpy.uint64(0)
+			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, selectUnpaired_0b1))
 
 			# Modify in place
 			arrayBifurcations[selectorUnified, indexBifurcationAlpha] ^= XOrHere2makePair
 
 			# Remove the modified elements
-			Z0Z_selectBridgesBifurcationAlphaToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationAlphaToModify, ~selectorUnified))
+			selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, ~selectorUnified))
 
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, ~selectBifurcationZuluEven
+		))
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
 			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
 			| (arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2))
@@ -105,24 +112,25 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, ~selectBifurcationAlphaEven, selectBifurcationZuluEven
 		))
 
-			# Initialize
-		Z0Z_selectBridgesBifurcationZuluToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = selector.copy()
+		# Initialize
 		XOrHere2makePair: numpy.uint64 = numpy.uint64(1)
-		selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
-		selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
 
-		while Z0Z_selectBridgesBifurcationZuluToModify.any():
+		while selector.any():
 			XOrHere2makePair <<= numpy.uint64(2)
 
 			# New condition
 			selectUnpaired_0b1: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & XOrHere2makePair) == numpy.uint64(0)
-			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationZuluToModify, selectUnpaired_0b1))
+			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, selectUnpaired_0b1))
 
 			# Modify in place
 			arrayBifurcations[selectorUnified, indexBifurcationZulu] ^= XOrHere2makePair
 
 			# Remove the modified elements from the selector
-			Z0Z_selectBridgesBifurcationZuluToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationZuluToModify, ~selectorUnified))
+			selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, ~selectorUnified))
+
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, ~selectBifurcationAlphaEven, selectBifurcationZuluEven
+		))
 
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
 			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
@@ -147,6 +155,6 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 
 		listArrayCurveLocationsAnalyzed.clear()
 
-		print(int(sum(arrayBifurcations[:, 0])))
+		# print(int(sum(arrayBifurcations[:, 0])))
 	return int(sum(arrayBifurcations[:, 0]))
 

mapFolding/someAssemblyRequired/makeAllModules.py

@@ -711,16 +711,16 @@ def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 	return pathFilename
 
 if __name__ == '__main__':
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
 
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
 
-	astModule: ast.Module = _getModule(logicalPathInfix=None)
+	astModule: ast.Module = _getModule(logicalPathInfix='algorithms')
 	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
 
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, None)
 
 	astModule = parsePathFilename2astModule(pathFilename)
@@ -733,7 +733,7 @@ if __name__ == '__main__':
 	makeUnRePackDataclass(astImportFrom)
 
 # A007822 -----------------------------------------------------------
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename = addSymmetryCheck(astModule, 'algorithmA007822', None, logicalPathInfixDEFAULT, None)
 
 	astModule = _getModule(moduleIdentifier='algorithmA007822')

mapFolding/syntheticModules/algorithmA007822Numba.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -92,4 +94,4 @@ def doTheNeedful(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/tests/conftest.py

@@ -25,7 +25,7 @@ research domain.
 
 from collections.abc import Callable, Generator, Sequence
 from mapFolding import _theSSOT, getLeavesTotal, makeDataContainer, packageSettings, validateListDimensions
-from mapFolding.oeis import dictionaryOEIS, oeisIDsImplemented
+from mapFolding.oeis import dictionaryOEISMapFolding, dictionaryOEISMeanders, oeisIDsImplemented
 from pathlib import Path
 from typing import Any
 import numpy
@@ -212,10 +212,10 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEIS[oeisID_1random]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEIS[oeisID_1random]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID_1random]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -239,10 +239,10 @@ def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEIS[oeisID]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEIS[oeisID]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -267,10 +267,10 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEIS[oeisID_1random]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEIS[oeisID_1random]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID_1random]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -292,8 +292,8 @@ def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
 		Map dimensions suitable for testing parallelization features.
 
 	"""
-	n = random.choice(dictionaryOEIS[oeisID]['valuesTestParallelization'])
-	return dictionaryOEIS[oeisID]['getMapShape'](n)
+	n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestParallelization'])
+	return dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
@@ -350,6 +350,25 @@ def oeisID(request: pytest.FixtureRequest) -> Any:
 	"""
 	return request.param
 
+@pytest.fixture(params=tuple(dictionaryOEISMeanders.keys()))
+def oeisIDMeanders(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all implemented Meanders OEIS sequence identifiers.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object containing the current parameter value.
+
+	Returns
+	-------
+	sequenceIdentifier : Any
+		OEIS sequence identifier for testing across all implemented Meanders sequences.
+
+	"""
+	return request.param
+
 @pytest.fixture
 def oeisID_1random() -> str:
 	"""Return one random valid OEIS ID.