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

mapFolding/basecamp.py

@@ -1,9 +1,11 @@
 """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
@@ -12,11 +14,11 @@ import contextlib
 
 algorithms directory
 	manually coded algorithms or formulas
-	countFolds will be a stable interface for multidimensional map folding, including synthetic modules
+	`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
+	`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
+	an enhanced version of `oeisIDfor_n` will be a stable interface for calling by ID and n
 
 General flow structure
 	doTheNeedful
@@ -60,6 +62,14 @@ General flow structure
 
 """
 
+# 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
@@ -198,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
@@ -229,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
@@ -302,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
@@ -319,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)

mapFolding/dataBaskets.py

@@ -24,6 +24,7 @@ from mapFolding import (
 	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
 	getConnectionGraph, getLeavesTotal, makeDataContainer)
 import dataclasses
+import numpy
 
 @dataclasses.dataclass
 class MapFoldingState:
@@ -268,3 +269,76 @@ class LeafSequenceState(MapFoldingState):
 		if self.leafSequence is None: # pyright: ignore[reportUnnecessaryComparison]
 			self.leafSequence = makeDataContainer(groupsOfFoldsKnown, self.__dataclass_fields__['leafSequence'].metadata['dtype'])
 			self.leafSequence[self.groupsOfFolds] = self.leaf1ndex
+
+
+@dataclasses.dataclass
+class MatrixMeandersState:
+	"""State."""
+
+	n: int
+	oeisID: str
+	kOfMatrix: int
+	dictionaryCurveLocations: dict[int, int]
+
+	datatypeCurveLocations: type = numpy.uint64
+	datatypeDistinctCrossings: type = numpy.uint64
+
+	bitWidthCurveLocationsMaximum: int | None = None
+	bitWidthDistinctCrossingsMaximum: int | None = None
+
+	bitWidth: int = 0
+	indexStartAnalyzed: int = 0
+
+	def __post_init__(self) -> None:
+		"""Post init."""
+		if self.bitWidthCurveLocationsMaximum is None:
+			_bitWidthOfFixedSizeInteger: int = numpy.dtype(self.datatypeCurveLocations).itemsize * 8 # bits
+
+			_offsetNecessary: int = 3 # For example, `groupZulu << 3`.
+			_offsetSafety: int = 1 # I don't have mathematical proof of how many extra bits I need.
+			_offset: int = _offsetNecessary + _offsetSafety
+
+			self.bitWidthCurveLocationsMaximum = _bitWidthOfFixedSizeInteger - _offset
+
+			del _bitWidthOfFixedSizeInteger, _offsetNecessary, _offsetSafety, _offset
+
+		if self.bitWidthDistinctCrossingsMaximum is None:
+			_bitWidthOfFixedSizeInteger: int = numpy.dtype(self.datatypeDistinctCrossings).itemsize * 8 # bits
+
+			_offsetNecessary: int = 0 # I don't know of any.
+			_offsetEstimation: int = 3 # See reference directory.
+			_offsetSafety: int = 1
+			_offset: int = _offsetNecessary + _offsetEstimation + _offsetSafety
+
+			self.bitWidthDistinctCrossingsMaximum = _bitWidthOfFixedSizeInteger - _offset
+
+			del _bitWidthOfFixedSizeInteger, _offsetNecessary, _offsetEstimation, _offsetSafety, _offset
+
+	@property
+	def MAXIMUMcurveLocations(self) -> int:
+		"""Compute the maximum value of `curveLocations` for the current iteration of the transfer matrix."""
+		return 1 << (2 * self.kOfMatrix + 4)
+
+	@property
+	def locatorGroupAlpha(self) -> int:
+		"""Compute an odd-parity bit-mask with `bitWidth` bits.
+
+		Notes
+		-----
+		In binary, `locatorGroupAlpha` has alternating 0s and 1s and ends with a 1, such as '101', '0101', and '10101'. The last
+		digit is in the 1's column, but programmers usually call it the "least significant bit" (LSB). If we count the columns
+		from the right, the 1's column is column 1, the 2's column is column 2, the 4's column is column 3, and so on. When
+		counting this way, `locatorGroupAlpha` has 1s in the columns with odd index numbers. Mathematicians and programmers,
+		therefore, tend to call `locatorGroupAlpha` something like the "odd bit-mask", the "odd-parity numbers", or simply "odd
+		mask" or "odd numbers". In addition to "odd" being inherently ambiguous in this context, this algorithm also segregates
+		odd numbers from even numbers, so I avoid using "odd" and "even" in the names of these bit-masks.
+
+		"""
+		return sum(1 << one for one in range(0, self.bitWidth, 2))
+
+	@property
+	def locatorGroupZulu(self) -> int:
+		"""Compute an even-parity bit-mask with `bitWidth` bits."""
+		return sum(1 << one for one in range(1, self.bitWidth, 2))
+
+

mapFolding/oeis.py

@@ -418,9 +418,10 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 			message = f"OEIS sequence {oeisID} is not defined at {n = }."
 			raise ArithmeticError(message)
 		foldsTotal: int = dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]
-		return foldsTotal
+	else:
+		foldsTotal = countFolds(oeisID=oeisID, oeis_n=n)
 
-	return countFolds(mapShape, oeisID=oeisID)
+	return foldsTotal
 
 def OEIS_for_n() -> None:
 	"""Command-line interface for calculating OEIS sequence values.