mapFolding 0.17.1__py3-none-any.whl → 0.18.0__py3-none-any.whl

mapFolding/_theTypes.py

@@ -5,15 +5,52 @@ from numpy import dtype, int_ as numpy_int, integer, ndarray, uint64 as numpy_ui
 from types import EllipsisType
 from typing import Any, Final, NamedTuple, TypeAlias, TypedDict, TypeVar
 
+#======== Metadata management for OEIS sequences =======
+
+class MetadataOEISidMapFoldingManuallySet(TypedDict):
+	"""Settings that are best selected by a human instead of algorithmically."""
+
+	getMapShape: Callable[[int], tuple[int, ...]]
+	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
+
+class MetadataOEISidMapFolding(TypedDict):
+	"""Settings for an OEIS ID that may be computed by a multidimensional map folding algorithm."""
+
+	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."""
+	valuesKnown: dict[int, int]
+	"""Dictionary of sequence indices, 'n', to their known values, `foldsTotal`."""
+	valueUnknown: int
+	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
+
+class MetadataOEISidManuallySet(TypedDict, total=False):
+	"""Placeholder for future manually curated OEIS metadata."""
+
+class MetadataOEISid(TypedDict):
+	"""Settings for an implemented OEIS sequence."""
+
+	description: str
+	"""The OEIS.org description of the integer sequence."""
+	offset: int
+	"""The starting index, 'n', of the sequence, typically 0 or 1."""
+	valuesKnown: dict[int, int]
+	"""Dictionary of sequence indices, 'n', to their known values, `foldsTotal`."""
+	valueUnknown: int
+	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
+
+#======== `TypeVar` indicates when a NumPy integer type is mandatory =======
+
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 """Any NumPy integer type, which is usually between 8-bit signed and 64-bit unsigned."""
 
+#======== Flexible `TypeAlias` for granular control over fixed-width integers =======
 DatatypeLeavesTotal: TypeAlias = int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """Use on unsigned integers that will never exceed the magnitude of `leavesTotal`."""
 
-NumPyLeavesTotal: TypeAlias = numpy_int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
-"""Use in NumPy data structures whose elements are unsigned integers that will never exceed the magnitude of `leavesTotal`."""
-
 DatatypeElephino: TypeAlias = int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """Use on unsigned integers that will exceed the magnitude of `leavesTotal` but that are not "colossal."
 
@@ -27,12 +64,17 @@ Colossal values are found with the cross humpy inequality:
 
 """
 
-NumPyElephino: TypeAlias = numpy_int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
-"""Use in NumPy data structures whose elements are unsigned integers that might exceed the magnitude of `leavesTotal` but that are not 'colossal.'"""
-
 DatatypeFoldsTotal: TypeAlias = int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """Use on unsigned integers that might have colossal magnitudes similar to `foldsTotal`."""
 
+#-------- Additional `TypeAlias` with NumPy types as their default ----------
+
+NumPyLeavesTotal: TypeAlias = numpy_int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use in NumPy data structures whose elements are unsigned integers that will never exceed the magnitude of `leavesTotal`."""
+
+NumPyElephino: TypeAlias = numpy_int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use in NumPy data structures whose elements are unsigned integers that might exceed the magnitude of `leavesTotal` but that are not 'colossal.'"""
+
 NumPyFoldsTotal: TypeAlias = numpy_uint64  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """Use in NumPy data structures whose elements are unsigned integers that might have colossal magnitudes similar to `foldsTotal`.
 
@@ -41,6 +83,9 @@ Note well
 If your element values might exceed 1.8 x 10^19, then you should take extra steps to ensure the integrity of the data in NumPy or use a
 different data structure."""
 
+#-------- Yet more `TypeAlias` with NumPy `ndarray` types ----------
+# Reminder: you can override the types with anything you want, not just `ndarray`. See, e.g., `makeJobTheorem2Numba`.
+
 Array3DLeavesTotal: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """A `numpy.ndarray` with three axes and elements of type `NumPyLeavesTotal`."""
 
@@ -56,67 +101,7 @@ Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]  # noqa:
 Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """A `numpy.ndarray` with one axis and elements of type `NumPyFoldsTotal`."""
 
-class MetadataOEISidMapFoldingManuallySet(TypedDict):
-	"""Settings that are best selected by a human instead of algorithmically."""
-
-	getMapShape: Callable[[int], tuple[int, ...]]
-	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
-	valuesBenchmark: list[int]
-	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
-	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."""
-
-class MetadataOEISidMapFolding(TypedDict):
-	"""Settings for an OEIS ID that may be computed by a multidimensional map folding algorithm."""
-
-	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."""
-
-# ruff: noqa: ERA001
-class MetadataOEISidManuallySet(TypedDict):
-	"""Settings that are best selected by a human instead of algorithmically."""
-
-	# valuesBenchmark: list[int]
-	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
-	# 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."""
-
-class MetadataOEISid(TypedDict):
-	"""Settings for an implemented OEIS sequence."""
-
-	description: str
-	"""The OEIS.org description of the integer sequence."""
-	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."""
-
+#======== Managing data structures in `matrixMeandersNumPyndas` algorithm =======
 # TODO Figure out how to have a SSOT for the axis order.
 axisOfLength: Final[int] = 0
 

mapFolding/algorithms/matrixMeandersNumPyndas.py

@@ -327,10 +327,10 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		state.boundary -= 1
 		state.setMAXIMUMarcCode()
 
-# =============== analyze aligned ===== if bitsAlpha > 1 and bitsZulu > 1 =============================================
+#================ analyze aligned ===== if bitsAlpha > 1 and bitsZulu > 1 =============================================
 # NOTE In other versions, this analysis step is last because I modify the data. In this version, I don't modify the data.
 		arrayBitsAlpha: NDArray[numpy.uint64] = bitwise_and(state.arrayArcCodes, state.bitsLocator)	# NOTE extra array
-# ======= > * > bitsAlpha 1 bitsZulu 1 ====================
+#======== > * > bitsAlpha 1 bitsZulu 1 ====================
 		greater(arrayBitsAlpha, 1, out=prepArea)
 		bitsZuluStack: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexCrossings)
 		bitwise_right_shift(bitsZuluStack, 1, out=bitsZuluStack)					# O indexArcCode X indexCrossings
@@ -339,7 +339,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		greater(prepArea, 1, out=prepArea)
 		selectorGreaterThan1: NDArray[numpy.uint64] = makeStorage(prepArea, state, arrayAnalyzed, indexArcCode)
 																					# X indexArcCode X indexCrossings
-# ======= if bitsAlphaAtEven and not bitsZuluAtEven ======= # ======= ^ & | ^ & bitsZulu 1 1 bitsAlpha 1 1 ============
+#======== if bitsAlphaAtEven and not bitsZuluAtEven ======= #======== ^ & | ^ & bitsZulu 1 1 bitsAlpha 1 1 ============
 		bitwise_and(bitsZuluStack, 1, out=prepArea)
 		del bitsZuluStack 															# X indexArcCode O indexCrossings
 		bitwise_xor(prepArea, 1, out=prepArea)
@@ -353,7 +353,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		arrayBitsAlpha[selectorAlignAlpha] = flipTheExtra_0b1AsUfunc(arrayBitsAlpha[selectorAlignAlpha])
 		del selectorAlignAlpha 														# X indexArcCode O indexCrossings
 
-# ======= if bitsZuluAtEven and not bitsAlphaAtEven ======= # ======= ^ & | ^ & bitsAlpha 1 1 bitsZulu 1 1 ============
+#======== if bitsZuluAtEven and not bitsAlphaAtEven ======= #======== ^ & | ^ & bitsAlpha 1 1 bitsZulu 1 1 ============
 		bitsAlphaStack: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexCrossings)
 		bitwise_and(bitsAlphaStack, state.bitsLocator, out=bitsAlphaStack)
 		bitwise_and(bitsAlphaStack, 1, out=prepArea)
@@ -370,7 +370,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		bitwise_and(selectorGreaterThan1, prepArea, out=prepArea)
 		selectorAlignZulu: NDArray[numpy.intp] = makeStorage(numpy.flatnonzero(prepArea), state, arrayAnalyzed, indexCrossings)
 																					# X indexArcCode X indexCrossings
-# ======= bitsAlphaAtEven or bitsZuluAtEven =============== # ======= ^ & & bitsAlpha 1 bitsZulu 1 ====================
+#======== bitsAlphaAtEven or bitsZuluAtEven =============== #======== ^ & & bitsAlpha 1 bitsZulu 1 ====================
 		bitwise_and(state.arrayArcCodes, state.bitsLocator, out=prepArea)
 		bitwise_and(prepArea, 1, out=prepArea)
 		sherpaBitsZulu: NDArray[numpy.uint64] = bitwise_right_shift(state.arrayArcCodes, 1) # NOTE 2° extra array
@@ -392,7 +392,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 		bitsZuluStack: NDArray[numpy.uint64] = makeStorage(prepArea, state, arrayAnalyzed, indexCrossings)
 
-# ======= (bitsZulu >> 2 << 3 | bitsAlpha) >> 2 =========== # ======= >> | << >> bitsZulu 2 3 bitsAlpha 2 =============
+#======== (bitsZulu >> 2 << 3 | bitsAlpha) >> 2 =========== #======== >> | << >> bitsZulu 2 3 bitsAlpha 2 =============
 		bitwise_right_shift(bitsZuluStack, 2, out=prepArea)
 		del bitsZuluStack 															# X indexArcCode O indexCrossings
 		bitwise_left_shift(prepArea, 3, out=prepArea)
@@ -405,10 +405,10 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 		state = recordAnalysis(arrayAnalyzed, state, prepArea)
 
-# ----------------- analyze bitsAlpha ------- (1 - (bitsAlpha & 1)) << 1 | bitsAlpha >> 2 | bitsZulu << 3 ---------
+#------------------ analyze bitsAlpha ------- (1 - (bitsAlpha & 1)) << 1 | bitsAlpha >> 2 | bitsZulu << 3 ---------
 		bitsAlphaStack: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexArcCode)
 		bitwise_and(bitsAlphaStack, state.bitsLocator, out=bitsAlphaStack)			# X indexArcCode O indexCrossings
-# ------- >> | << | (<< - 1 & bitsAlpha 1 1) << bitsZulu 3 2 bitsAlpha 2 ----------
+#-------- >> | << | (<< - 1 & bitsAlpha 1 1) << bitsZulu 3 2 bitsAlpha 2 ----------
 		bitwise_and(bitsAlphaStack, 1, out=bitsAlphaStack)
 		subtract(1, bitsAlphaStack, out=bitsAlphaStack)
 		bitwise_left_shift(bitsAlphaStack, 1, out=bitsAlphaStack)
@@ -425,7 +425,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		bitwise_or(bitsAlphaStack, prepArea, out=prepArea)
 		bitwise_right_shift(prepArea, 2, out=prepArea)
 
-# ------- if bitsAlpha > 1 ------------ > bitsAlpha 1 -----
+#-------- if bitsAlpha > 1 ------------ > bitsAlpha 1 -----
 		less_equal(bitsAlphaStack, 1, out=bitsAlphaStack)
 		selectorUnderLimit: NDArray[numpy.intp] = makeStorage(numpy.flatnonzero(bitsAlphaStack), state, arrayAnalyzed, indexArcCode)
 		del bitsAlphaStack 															# X indexArcCode O indexCrossings
@@ -434,11 +434,11 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 		state = recordAnalysis(arrayAnalyzed, state, prepArea)
 
-# ----------------- analyze bitsZulu ---------- (1 - (bitsZulu & 1)) | bitsAlpha << 2 | bitsZulu >> 1 -------------
+#------------------ analyze bitsZulu ---------- (1 - (bitsZulu & 1)) | bitsAlpha << 2 | bitsZulu >> 1 -------------
 		arrayBitsZulu: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexCrossings)
 		arrayBitsZulu = bitwise_right_shift(arrayBitsZulu, 1)						# O indexArcCode X indexCrossings
 		arrayBitsZulu = bitwise_and(arrayBitsZulu, state.bitsLocator)
-# ------- >> | << | (- 1 & bitsZulu 1) << bitsAlpha 2 1 bitsZulu 1 ----------
+#-------- >> | << | (- 1 & bitsZulu 1) << bitsAlpha 2 1 bitsZulu 1 ----------
 		bitwise_and(arrayBitsZulu, 1, out=arrayBitsZulu)
 		subtract(1, arrayBitsZulu, out=arrayBitsZulu)
 		bitsAlphaStack: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexArcCode)
@@ -454,7 +454,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		bitwise_or(bitsZuluStack, prepArea, out=prepArea)
 		bitwise_right_shift(prepArea, 1, out=prepArea)
 
-# ------- if bitsZulu > 1 ------------- > bitsZulu 1 ------
+#-------- if bitsZulu > 1 ------------- > bitsZulu 1 ------
 		less_equal(bitsZuluStack, 1, out=bitsZuluStack)
 		selectorUnderLimit = makeStorage(numpy.flatnonzero(bitsZuluStack), state, arrayAnalyzed, indexArcCode)
 		del bitsZuluStack 															# X indexArcCode O indexCrossings
@@ -463,11 +463,11 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 		state = recordAnalysis(arrayAnalyzed, state, prepArea)
 
-# ----------------- analyze simple ------------------------ (bitsZulu << 1 | bitsAlpha) << 2 | 3 ------------------
+#------------------ analyze simple ------------------------ (bitsZulu << 1 | bitsAlpha) << 2 | 3 ------------------
 		bitsZuluStack: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexCrossings)
 		bitwise_right_shift(bitsZuluStack, 1, out=bitsZuluStack)					# O indexArcCode X indexCrossings
 		bitwise_and(bitsZuluStack, state.bitsLocator, out=bitsZuluStack)
-# ------- | << | bitsAlpha << bitsZulu 1 2 3 --------------
+#-------- | << | bitsAlpha << bitsZulu 1 2 3 --------------
 		bitwise_left_shift(bitsZuluStack, 1, out=prepArea)
 		del bitsZuluStack 															# O indexArcCode O indexCrossings
 		bitsAlphaStack: NDArray[numpy.uint64] = makeStorage(state.arrayArcCodes, state, arrayAnalyzed, indexArcCode)
@@ -480,7 +480,7 @@ def countNumPy(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 		state = recordAnalysis(arrayAnalyzed, state, prepArea)
 
 		del prepArea, arrayPrepArea
-# ----------------------------------------------- aggregation ---------------------------------------------------------
+#------------------------------------------------ aggregation ---------------------------------------------------------
 		state.arrayArcCodes = numpy.zeros((0,), dtype=state.datatypeArcCode)
 		arrayAnalyzed.resize((state.indexTarget, indicesAnalyzed))
 
@@ -536,7 +536,7 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 				arcCode = (bitsAlpha >> 2) | ((bitsZulu >> 2) << 1)
 			```
 			"""
-			# -------- Step 1 drop unqualified rows ---------------------------
+			#--------- Step 1 drop unqualified rows ---------------------------
 			dataframeMeanders['analyzed'] = dataframeMeanders['arcCode'].copy()
 			dataframeMeanders['analyzed'] &= state.bitsLocator       				# `bitsAlpha`
 
@@ -565,7 +565,7 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
 			dataframeMeanders = dataframeMeanders.loc[(dataframeMeanders['analyzed'] > 0)]  # `if (bitsAlphaIsEven or bitsZuluIsEven)`
 
-			# ------- Step 2 modify rows --------------------------------------
+			#-------- Step 2 modify rows --------------------------------------
 			# Make a selector for bitsZuluAtOdd, so you can modify bitsAlpha
 			dataframeMeanders.loc[:, 'analyzed'] = dataframeMeanders['arcCode'].copy()
 			dataframeMeanders.loc[:, 'analyzed'] //= 2**1        					# Truncated conversion to `bitsZulu`
@@ -586,7 +586,7 @@ def countPandas(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 			dataframeMeanders.loc[((dataframeMeanders.loc[:, 'arcCode'] & 1) > 0), 'analyzed'] = state.datatypeArcCode(
 				flipTheExtra_0b1AsUfunc(dataframeMeanders.loc[((dataframeMeanders.loc[:, 'arcCode'] & 1) > 0), 'analyzed']))
 
-			# -------- Step 3 compute `arcCode` -------------------------------
+			#--------- Step 3 compute `arcCode` -------------------------------
 			dataframeMeanders.loc[:, 'analyzed'] //= 2**2 							# (bitsZulu >> 2)
 			dataframeMeanders.loc[:, 'analyzed'] *= 2**3 							# (... << 3)
 			dataframeMeanders.loc[:, 'analyzed'] |= bitsTarget						# (... | bitsAlpha)

mapFolding/algorithms/oeisIDbyFormula.py

@@ -7,7 +7,7 @@ TODO A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger F
 NOTE: This is a generated file; edit the source file.
 """
 from functools import cache
-from mapFolding import dictionaryOEIS
+from mapFolding import dictionaryOEIS, inclusive
 from mapFolding.basecamp import NOTcountingFolds
 
 @cache
@@ -67,7 +67,7 @@ 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 On-Line Encyclopedia of Integer Sequences* (OEIS) description of A001010 is: "Number of symmetric foldings of a strip of n blank 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.
@@ -80,7 +80,7 @@ def A001010(n: int) -> int:
     Returns
     -------
     a(n) : int
-        Number of symmetric foldings of a strip of n stamps.
+        Number of symmetric foldings of a strip of n blank stamps.
 
     Would You Like to Know More?
     ----------------------------
@@ -270,7 +270,7 @@ def A178961(n: int) -> int:
     """
     A001010valuesKnown: dict[int, int] = dictionaryOEIS['A001010']['valuesKnown']
     countTotal: int = 0
-    for n下i in range(1, n + 1):
+    for n下i in range(1, n + inclusive):
         countTotal += A001010valuesKnown[n下i]
     return countTotal
 

mapFolding/algorithms/zCuzDocStoopidoeisIDbyFormula.py

@@ -5,7 +5,7 @@ TODO A223094 For n >= 3: a(n) = n! - Sum_{k=3..n-1} (a(k)*n!/k!) - 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
 """
 from functools import cache
-from mapFolding import dictionaryOEIS
+from mapFolding import dictionaryOEIS, inclusive
 from mapFolding.basecamp import NOTcountingFolds
 
 # ruff: noqa: D400
@@ -72,7 +72,7 @@ def A178961(n: int) -> int:
 	"""A001010"""
 	A001010valuesKnown: dict[int, int] = dictionaryOEIS['A001010']['valuesKnown']
 	countTotal: int = 0
-	for n下i in range(1, n+1):
+	for n下i in range(1, n + inclusive):
 		countTotal += A001010valuesKnown[n下i]
 	return countTotal
 
@@ -92,7 +92,7 @@ def A301620(n: int) -> int:
 	"""A000682"""
 	return _A000682(n + 2) - 2 * _A000682(n + 1)
 
-# ================= Not formulas ==========================
+#================== Not formulas ==========================
 
 @cache
 def _A000682(n: int) -> int:

mapFolding/basecamp.py

@@ -8,7 +8,7 @@ from pathlib import Path, PurePath
 from typing import Literal
 
 # ruff: noqa: PLC0415
-"""TODO new flow paradigm, incomplete
+"""# TODO new flow paradigm, incomplete
 
 - I don't want to FORCE people to use the meaningless OEIS ids without providing the definition of the ID at the same time.
 - On the other hand, I don't have any evidence that anyone is using this package except me.
@@ -128,7 +128,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	computation time. If logicalCores >= `leavesTotal`, it will probably be faster. If logicalCores <= 2 * `leavesTotal`, it
 	will almost certainly be slower for all map dimensions.
 	"""
-# ------- mapShape ---------------------------------------------------------------------
+#-------- mapShape ---------------------------------------------------------------------
 
 	if mapShape:
 		pass
@@ -142,11 +142,11 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		)
 		raise ValueError(message)
 
-# ------- task division instructions -----------------------------------------------------
+#-------- task division instructions -----------------------------------------------------
 
 	if computationDivisions:
-		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions, setProcessorLimit
-		concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
+		from mapFolding.beDRY import defineProcessorLimit, getLeavesTotal, getTaskDivisions
+		concurrencyLimit: int = defineProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
 		leavesTotal: int = getLeavesTotal(mapShape)
 		taskDivisions: int = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
 		del leavesTotal
@@ -154,7 +154,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		concurrencyLimit = 1
 		taskDivisions = 0
 
-# ------- memorialization instructions ---------------------------------------------
+#-------- memorialization instructions ---------------------------------------------
 
 	if pathLikeWriteFoldsTotal is not None:
 		pathFilenameFoldsTotal: Path | None = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
@@ -162,7 +162,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	else:
 		pathFilenameFoldsTotal = None
 
-# ------- Algorithm version -----------------------------------------------------
+#-------- Algorithm version -----------------------------------------------------
 	if taskDivisions > 1:
 		from mapFolding.dataBaskets import ParallelMapFoldingState
 		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful
@@ -174,7 +174,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 # ruff: noqa: E701
 	else:
-		if all(dimension < 2 for dimension in mapShape):
+		if all(dimension <= 2 for dimension in mapShape):
 			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
 		else:
 			match flow:
@@ -189,76 +189,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
-# ------- Follow memorialization instructions ---------------------------------------------
-
-	if pathFilenameFoldsTotal is not None:
-		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
-
-	return foldsTotal
-
-def eliminateFolds(mapShape: tuple[int, ...]
-				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
-				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
-				, CPUlimit: bool | float | int | None = None  # noqa: FBT001
-				, flow: str | None = None
-				) -> int:
-	"""
-	Compute foldsTotal by elimination.
-
-	Parameters
-	----------
-	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.
-	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.
-	CPUlimit : bool | float | int | None = None
-		If relevant, whether and how to limit the number of processors `countFolds` will use.
-		- `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.
-		- `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`.
-	flow : str | None = None
-		My stupid way of selecting the version of the algorithm to use in the computation.
-
-	Returns
-	-------
-	foldsTotal : int
-		Number of distinct ways to fold a map of the given dimensions.
-	"""
-	from mapFolding.beDRY import setProcessorLimit
-	concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
-
-# ------- memorialization instructions ---------------------------------------------
-
-	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal: Path | None = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
-		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
-	else:
-		pathFilenameFoldsTotal = None
-
-# ------- Algorithm version -----------------------------------------------------
-# ruff: noqa: E701
-	match flow:
-		case 'constraintPropagation': from mapFolding.algorithms.constraintPropagation import doTheNeedful
-		case 'pinned': from mapFolding.algorithms.eliminationPinned import doTheNeedful
-		case 'elimination' | _: from mapFolding.algorithms.elimination import doTheNeedful
-
-	from mapFolding.dataBaskets import EliminationState
-	eliminationState: EliminationState = EliminationState(mapShape)
-	eliminationState = doTheNeedful(eliminationState, concurrencyLimit)
-	foldsTotal = eliminationState.foldsTotal
-
-# ------- Follow memorialization instructions ---------------------------------------------
+#-------- Follow memorialization instructions ---------------------------------------------
 
 	if pathFilenameFoldsTotal is not None:
 		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
@@ -338,8 +269,8 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 				countTotal = doTheNeedful(state) # pyright: ignore[reportArgumentType]
 			case 'A007822':
 				mapShape: tuple[Literal[1], int] = (1, 2 * oeis_n)
-				from mapFolding import setProcessorLimit
-				concurrencyLimit: int = setProcessorLimit(CPUlimit)
+				from mapFolding import defineProcessorLimit
+				concurrencyLimit: int = defineProcessorLimit(CPUlimit)
 
 				from mapFolding.dataBaskets import SymmetricFoldsState
 				symmetricState: SymmetricFoldsState = SymmetricFoldsState(mapShape)