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

mapFolding/algorithms/oeisIDbyFormula.py

@@ -0,0 +1,347 @@
+"""Compute a(n) for an OEIS ID by computing other OEIS IDs.
+
+TODO Implement A178961 for unknown values of A001010
+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
+TODO A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018
+"""
+from functools import cache
+from mapFolding import countFolds, dictionaryOEISMeanders
+from mapFolding.basecamp import A000682, A005316
+
+@cache
+def A000136(n: int) -> int:
+    """
+    Compute A000136(n) as a function of A000682.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A000136 is: "Number of ways of folding a strip of n labeled stamps."
+
+    The domain of A000136 starts at 1, therefore for values of `n` < 1, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 46.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of ways of folding a strip of n labeled stamps.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A000136
+    """
+    return n * A000682(n)
+
+def A000560(n: int) -> int:
+    """
+    Compute A000560(n) as a function of A000682.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A000560 is: "Number of ways of folding a strip of n labeled stamps."
+
+    The domain of A000560 starts at 2, therefore for values of `n` < 2, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 45.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of ways of folding a strip of n labeled stamps.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A000560
+    """
+    return A000682(n + 1) // 2
+
+def A001010(n: int) -> int:
+    """
+    Compute A001010(n) as a function of A000682 or A007822.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A001010 is: "Number of symmetric foldings of a strip of n stamps."
+
+    The domain of A001010 starts at 1, therefore for values of `n` < 1, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 53.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of symmetric foldings of a strip of n stamps.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A001010
+    """
+    if n == 1:
+        foldsTotal = 1
+    elif n & 1:
+        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:
+    """
+    Compute A001011(n) as a function of A000136 and A001010.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A001011 is: "Number of ways to fold a strip of n blank stamps."
+
+    The domain of A001011 starts at 1, therefore for values of `n` < 1, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 46.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of ways to fold a strip of n blank stamps.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A001011
+    """
+    if n == 0:
+        foldsTotal = 1
+    else:
+        foldsTotal = (A001010(n) + A000136(n)) // 4
+    return foldsTotal
+
+@cache
+def A005315(n: int) -> int:
+    """
+    Compute A005315(n) as a function of A005316.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A005315 is: "Closed meandric numbers (or meanders): number of ways a loop can cross a road 2n times."
+
+    The domain of A005315 starts at 0, therefore for values of `n` < 0, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 29.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Closed meandric numbers (or meanders): number of ways a loop can cross a road 2n times.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A005315
+    """
+    if n == 1:
+        foldsTotal = 1
+    else:
+        foldsTotal = A005316(2 * n - 1)
+    return foldsTotal
+
+def A060206(n: int) -> int:
+    """
+    Compute A060206(n) as a function of A000682.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A060206 is: "Number of rotationally symmetric closed meanders of length 4n+2."
+
+    The domain of A060206 starts at 0, therefore for values of `n` < 0, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 21.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of rotationally symmetric closed meanders of length 4n+2.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A060206
+    """
+    return A000682(2 * n + 1)
+
+def A077460(n: int) -> int:
+    """
+    Compute A077460(n) as a function of A005315, A005316, and A060206.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A077460 is: "Number of nonisomorphic ways a loop can cross a road (running East-West) 2n times."
+
+    The domain of A077460 starts at 0, therefore for values of `n` < 0, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 21.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of nonisomorphic ways a loop can cross a road (running East-West) 2n times.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A077460
+    """
+    if n in {0, 1}:
+        foldsTotal = 1
+    elif n & 1:
+        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:
+    """
+    Compute A078591(n) as a function of A005315.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A078591 is: "Number of nonisomorphic ways a loop can cross a road (running East-West) 2n times."
+
+    The domain of A078591 starts at 0, therefore for values of `n` < 0, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 29.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of nonisomorphic ways a loop can cross a road (running East-West) 2n times.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A078591
+    """
+    return A005315(n) // 2
+
+def A178961(n: int) -> int:
+    """
+    Compute A178961(n) as a function of A001010.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A178961 is: "Partial sums of A001010."
+
+    The domain of A178961 starts at 1, therefore for values of `n` < 1, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 53.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Partial sums of A001010.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A178961
+    """
+    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:
+    """
+    Compute A223094(n) as a function of A000136 and A000682.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A223094 is: "Number of foldings of n labeled stamps in which leaf n is inwards."
+
+    The domain of A223094 starts at 1, therefore for values of `n` < 1, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 44.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Number of foldings of n labeled stamps in which leaf n is inwards.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A223094
+    """
+    return A000136(n) - A000682(n + 1)
+
+def A259702(n: int) -> int:
+    """
+    Compute A259702(n) as a function of A000682.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A259702 is: "Row sums of A259701 except first column."
+
+    The domain of A259702 starts at 2, therefore for values of `n` < 2, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 33.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        Row sums of A259701 except first column.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A259702
+    """
+    return A000682(n) // 2 - A000682(n - 1)
+
+def A301620(n: int) -> int:
+    """
+    Compute A301620(n) as a function of A000682.
+
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A301620 is: "a(n) is the total number of top arches with exactly one covering arch for semi-meanders with n top arches."
+
+    The domain of A301620 starts at 1, therefore for values of `n` < 1, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is 44.
+
+    Parameters
+    ----------
+    n : int
+        Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+    Returns
+    -------
+    a(n) : int
+        a(n) is the total number of top arches with exactly one covering arch for semi-meanders with n top arches.
+
+    Would You Like to Know More?
+    ----------------------------
+    OEIS : webpage
+        https://oeis.org/A301620
+    """
+    return A000682(n + 2) - 2 * A000682(n + 1)

mapFolding/algorithms/zCuzDocStoopidoeisIDbyFormula.py

@@ -0,0 +1,84 @@
+"""Compute a(n) for an OEIS ID by computing other OEIS IDs.
+
+TODO Implement A178961 for unknown values of A001010
+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
+TODO A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018
+"""
+from functools import cache
+from mapFolding import countFolds, dictionaryOEISMeanders
+from mapFolding.basecamp import A000682, A005316
+
+@cache
+def A000136(n: int) -> int:
+	"""A000682"""
+	return n * A000682(n)
+
+def A000560(n: int) -> int:
+	"""A000682"""
+	return A000682(n + 1) // 2
+
+def A001010(n: int) -> int:
+	"""A000682 or A007822"""
+	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:
+	"""A000136 and A001010"""
+	if n == 0:
+		foldsTotal = 1
+	else:
+		foldsTotal = (A001010(n) + A000136(n)) // 4
+	return foldsTotal
+
+@cache
+def A005315(n: int) -> int:
+	"""A005316"""
+	if n == 1:
+		foldsTotal = 1
+	else:
+		foldsTotal = A005316(2 * n - 1)
+	return foldsTotal
+
+def A060206(n: int) -> int:
+	"""A000682"""
+	return A000682(2 * n + 1)
+
+def A077460(n: int) -> int:
+	"""A005315, A005316, and A060206"""
+	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:
+	"""A005315"""
+	return A005315(n) // 2
+
+def A178961(n: int) -> int:
+	"""A001010"""
+	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:
+	"""A000136 and A000682"""
+	return A000136(n) - A000682(n + 1)
+
+def A259702(n: int) -> int:
+	"""A000682"""
+	return A000682(n) // 2 - A000682(n - 1)
+
+def A301620(n: int) -> int:
+	"""A000682"""
+	return A000682(n + 2) - 2 * A000682(n + 1)

mapFolding/basecamp.py

@@ -1,13 +1,75 @@
 """Unified interface for map folding computation."""
 
 from collections.abc import Sequence
+from functools import cache
 from mapFolding import (
-	getPathFilenameFoldsTotal, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly, setProcessorLimit,
-	validateListDimensions)
+	getPathFilenameFoldsTotal, MatrixMeandersState, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly,
+	setProcessorLimit, validateListDimensions)
+from mapFolding.algorithms.matrixMeanders import doTheNeedful
 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
+
+"""
+
+# Parameters
+	# What you want to compute
+	# Memorialization
+	# Concurrency
+	# How you want to compute it
+# Interpretation of parameters
+	# Input data
+
 def countFolds(listDimensions: Sequence[int] | None = None
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
@@ -93,9 +155,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)
 
@@ -146,28 +208,63 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 		"""
 		match flow:
+			case 'asynchronous':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.A007822.asynchronous import doTheNeedful  # noqa: PLC0415
+				mapFoldingState = doTheNeedful(mapFoldingState)
+
+			case 'asynchronousTheorem2':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.A007822.asynchronousAnnex import initializeConcurrencyManager  # noqa: PLC0415
+				initializeConcurrencyManager(groupsOfFolds=mapFoldingState.groupsOfFolds)
+				mapFoldingState.groupsOfFolds = 0
+
+				from mapFolding.syntheticModules.A007822.asynchronousTheorem2 import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
+			case 'asynchronousTrimmed':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.A007822.asynchronousAnnex import initializeConcurrencyManager  # noqa: PLC0415
+				initializeConcurrencyManager(groupsOfFolds=mapFoldingState.groupsOfFolds)
+				mapFoldingState.groupsOfFolds = 0
+
+				from mapFolding.syntheticModules.A007822.asynchronousTrimmed import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
 			case 'numba':
 				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-				from mapFolding.syntheticModules.algorithmA007822Numba import doTheNeedful  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.algorithmNumba import doTheNeedful  # noqa: PLC0415
 				mapFoldingState = doTheNeedful(mapFoldingState)
 
 			case 'theorem2':
 				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
 				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
-				from mapFolding.syntheticModules.theorem2A007822 import count  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.theorem2 import count  # noqa: PLC0415
 				mapFoldingState = count(mapFoldingState)
 
 			case 'theorem2Numba':
 				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
 				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 				from mapFolding.syntheticModules.dataPackingA007822 import sequential  # noqa: PLC0415
@@ -177,17 +274,17 @@ def countFolds(listDimensions: Sequence[int] | None = None
 				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
 				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
-				from mapFolding.syntheticModules.theorem2A007822Trimmed import count  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.theorem2Trimmed import count  # noqa: PLC0415
 				mapFoldingState = count(mapFoldingState)
 
 			case _:
 				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-				from mapFolding.syntheticModules.algorithmA007822 import doTheNeedful  # noqa: PLC0415
+				from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful  # noqa: PLC0415
 				mapFoldingState = doTheNeedful(mapFoldingState)
 
 		foldsTotal = mapFoldingState.groupsOfFolds
@@ -196,7 +293,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
 
@@ -250,8 +347,8 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful  # noqa: PLC0415
 
-		# `listStatesParallel` exists in case you want to research the parallel computation.
-		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]
+		# `listStatesParallel` exists so you can research the parallel computation.
+		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]  # noqa: RUF059
 
 	else:
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
@@ -267,3 +364,43 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
 
 	return foldsTotal
+
+@cache
+def A000682(n: int) -> int:
+	"""Compute A000682(n)."""
+	oeisID = 'A000682'
+
+	kOfMatrix: int = n - 1
+
+	if n & 0b1:
+		curveLocations: int = 5
+	else:
+		curveLocations = 1
+	listCurveLocations: list[int] = [(curveLocations << 1) | curveLocations]
+
+	MAXIMUMcurveLocations: int = 1 << (2 * kOfMatrix + 4)
+	while listCurveLocations[-1] < MAXIMUMcurveLocations:
+		curveLocations = (curveLocations << 4) | 0b101 # == curveLocations * 2**4 + 5
+		listCurveLocations.append((curveLocations << 1) | curveLocations)
+
+	dictionaryCurveLocations=dict.fromkeys(listCurveLocations, 1)
+
+	state = MatrixMeandersState(n, oeisID, kOfMatrix, dictionaryCurveLocations)
+
+	return doTheNeedful(state)
+
+@cache
+def A005316(n: int) -> int:
+	"""Compute A005316(n)."""
+	oeisID = 'A005316'
+
+	kOfMatrix: int = n - 1
+
+	if n & 0b1:
+		dictionaryCurveLocations: dict[int, int] = {15: 1}
+	else:
+		dictionaryCurveLocations = {22: 1}
+
+	state = MatrixMeandersState(n, oeisID, kOfMatrix, dictionaryCurveLocations)
+
+	return doTheNeedful(state)