mapFolding 0.16.1__py3-none-any.whl → 0.16.4__py3-none-any.whl

mapFolding/syntheticModules/A007822/theorem2Trimmed.py

@@ -1,28 +1,23 @@
-from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.dataBaskets import SymmetricFoldsState
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+import numpy
 
-def count(state: MapFoldingState) -> MapFoldingState:
+def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
         if state.leafBelow[0] == 1:
             if state.leaf1ndex > state.leavesTotal:
-                state.indexLeaf = 0
-                leafConnectee = 0
-                while leafConnectee < state.leavesTotal + 1:
-                    leafNumber = int(state.leafBelow[state.indexLeaf])
-                    state.leafComparison[leafConnectee] = (leafNumber - state.indexLeaf + state.leavesTotal) % state.leavesTotal
-                    state.indexLeaf = leafNumber
-                    leafConnectee += 1
-                indexInMiddle = state.leavesTotal // 2
-                state.indexMiniGap = 0
-                while state.indexMiniGap < state.leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
-                            ImaSymmetricFold = False
-                            break
-                        leafConnectee += 1
-                    state.groupsOfFolds += ImaSymmetricFold
-                    state.indexMiniGap += 1
+                state.indexLeaf = 1
+                state.leafComparison[0] = 1
+                state.leafConnectee = 1
+                while state.leafConnectee < state.leavesTotal + 1:
+                    state.indexMiniGap = state.leafBelow[state.indexLeaf]
+                    state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+                    state.indexLeaf = state.indexMiniGap
+                    state.leafConnectee += 1
+                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
+                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
+                for indexRow in range(len(compared)):
+                    state.groupsOfFolds += compared[indexRow].all()
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -60,4 +55,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
     else:
         state.groupsOfFolds *= 2
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    return state
+
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
     return state

mapFolding/syntheticModules/countParallelNumba.py

@@ -1,11 +1,8 @@
 from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	ParallelMapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, ParallelMapFoldingState
 from multiprocessing import set_start_method as multiprocessing_set_start_method
 from numba import jit
-
 if __name__ == '__main__':
     multiprocessing_set_start_method('spawn')
 
@@ -75,14 +72,13 @@ def unRepackParallelMapFoldingState(state: ParallelMapFoldingState) -> ParallelM
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    leafComparison: Array1DLeavesTotal = state.leafComparison
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     taskDivisions: DatatypeLeavesTotal = state.taskDivisions
     taskIndex: DatatypeLeavesTotal = state.taskIndex
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex)
-    state = ParallelMapFoldingState(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, taskDivisions=taskDivisions, taskIndex=taskIndex)
+    state = ParallelMapFoldingState(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, taskDivisions=taskDivisions, taskIndex=taskIndex)
     return state
 
 def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple[int, list[ParallelMapFoldingState]]:
@@ -99,4 +95,4 @@ def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple
             listStatesParallel[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
             groupsOfFoldsTotal += listStatesParallel[indexSherpa].groupsOfFolds
     foldsTotal: int = groupsOfFoldsTotal * stateParallel.leavesTotal
-    return (foldsTotal, listStatesParallel)
+    return (foldsTotal, listStatesParallel)

mapFolding/syntheticModules/daoOfMapFoldingNumba.py

@@ -1,6 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -68,10 +66,9 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    leafComparison: Array1DLeavesTotal = state.leafComparison
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
-    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    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)
+    return state

mapFolding/syntheticModules/meanders/bigInt.py

@@ -1,21 +1,7 @@
-from mapFolding.algorithms.matrixMeandersBeDry import areIntegersWide, walkDyckPath
+from mapFolding.algorithms.matrixMeandersBeDry import (areIntegersWide,
+                                                       walkDyckPath)
 from mapFolding.dataBaskets import MatrixMeandersNumPyState
 
-def outfitDictionaryBitGroups(state: MatrixMeandersNumPyState) -> dict[tuple[int, int], int]:
-    """Outfit `dictionaryBitGroups` so it may manage the computations for one iteration of the transfer matrix.
-
-    Parameters
-    ----------
-    state : MatrixMeandersState
-        The current state of the computation, including `dictionaryMeanders`.
-
-    Returns
-    -------
-    dictionaryBitGroups : dict[tuple[int, int], int]
-        A dictionary of `(bitsAlpha, bitsZulu)` to `crossings`.
-    """
-    state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
-    return {(arcCode & state.locatorBits, arcCode >> 1 & state.locatorBits): crossings for arcCode, crossings in state.dictionaryMeanders.items()}
 
 def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
     """Count meanders with matrix transfer algorithm using Python `int` (*int*eger) contained in a Python `dict` (*dict*ionary).
@@ -30,24 +16,28 @@ def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
     The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each index one at a time,
     compute each `arcCode` one at a time, and compute each type of analysis one at a time.
     """
-    dictionaryBitGroups: dict[tuple[int, int], int] = {}
-    while state.kOfMatrix > 0 and areIntegersWide(state):
-        state.kOfMatrix -= 1
-        dictionaryBitGroups = outfitDictionaryBitGroups(state)
+    dictionaryArcCodeToCrossings: dict[int, int] = {}
+    while state.boundary > 0 and areIntegersWide(state):
+        state.boundary -= 1
+        state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
+        dictionaryArcCodeToCrossings = state.dictionaryMeanders.copy()
         state.dictionaryMeanders = {}
-        for (bitsAlpha, bitsZulu), crossings in dictionaryBitGroups.items():
+        for arcCode, crossings in dictionaryArcCodeToCrossings.items():
+            bitsAlpha: int = arcCode & state.locatorBits
+            bitsZulu: int = arcCode >> 1 & state.locatorBits
             bitsAlphaHasArcs: bool = bitsAlpha > 1
             bitsZuluHasArcs: bool = bitsZulu > 1
-            bitsAlphaIsEven = bitsZuluIsEven = 0
+            bitsAlphaIsEven: int = bitsAlpha & 1 ^ 1
+            bitsZuluIsEven: int = bitsZulu & 1 ^ 1
             arcCodeAnalysis = (bitsAlpha | bitsZulu << 1) << 2 | 3
             if arcCodeAnalysis < state.MAXIMUMarcCode:
                 state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsAlphaHasArcs:
-                arcCodeAnalysis = bitsAlpha >> 2 | bitsZulu << 3 | (bitsAlphaIsEven := (1 - (bitsAlpha & 1))) << 1
+                arcCodeAnalysis = bitsAlpha >> 2 | bitsZulu << 3 | bitsAlphaIsEven << 1
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsZuluHasArcs:
-                arcCodeAnalysis = bitsZulu >> 1 | bitsAlpha << 2 | (bitsZuluIsEven := (1 - (bitsZulu & 1)))
+                arcCodeAnalysis = bitsZulu >> 1 | bitsAlpha << 2 | bitsZuluIsEven
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsAlphaHasArcs and bitsZuluHasArcs and (bitsAlphaIsEven or bitsZuluIsEven):
@@ -58,5 +48,5 @@ def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
                 arcCodeAnalysis: int = bitsZulu >> 2 << 1 | bitsAlpha >> 2
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
-        dictionaryBitGroups = {}
+        dictionaryArcCodeToCrossings = {}
     return state

mapFolding/syntheticModules/theorem2.py

@@ -1,4 +1,5 @@
 from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -47,4 +48,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.leaf1ndex += 1
     else:
         state.groupsOfFolds *= 2
+    return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
     return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -1,5 +1,5 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -45,3 +45,27 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
     else:
         groupsOfFolds *= 2
     return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    gap1ndex: DatatypeElephino = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    connectionGraph: Array3DLeavesTotal = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
+    return state

mapFolding/syntheticModules/theorem2Trimmed.py

@@ -1,4 +1,5 @@
 from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -41,4 +42,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.leaf1ndex += 1
     else:
         state.groupsOfFolds *= 2
+    return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
     return state

mapFolding/tests/test_computations.py

@@ -40,7 +40,7 @@ import pytest
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-@pytest.mark.parametrize('flow', ['algorithm', 'asynchronous', 'asynchronousTrimmed', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
+@pytest.mark.parametrize('flow', ['algorithm', 'asynchronous',  'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
 def test_A007822(flow: str) -> None:
 	"""Test A007822 flow options.
 

mapFolding/zCuzDocStoopid/makeDocstrings.py

@@ -21,6 +21,8 @@ def transformOEISidByFormula(pathFilenameSource: Path) -> None:
     functionOf: str = 'Error during transformation' # The value of `functionOf` is in the docstring of function `oeisID` in `pathFilenameSource`.
 
     for oeisID, FunctionDef in dictionaryFunctionDef.items():
+        if not oeisID.startswith('A') or not oeisID[1:7].isdigit():
+            continue
         dictionary = dictionaryOEISMapFolding if oeisID in dictionaryOEISMapFolding else dictionaryOEIS
         functionOf = raiseIfNone(ast.get_docstring(FunctionDef))
 

{mapfolding-0.16.1.dist-info → mapfolding-0.16.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.16.1
+Version: 0.16.4
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -40,7 +40,10 @@ Requires-Dist: hunterMakesPy
 Requires-Dist: isort
 Requires-Dist: numpy
 Requires-Dist: platformdirs
+Requires-Dist: sympy
 Provides-Extra: development
+Requires-Dist: ipykernel; extra == "development"
+Requires-Dist: ipywidgets; extra == "development"
 Requires-Dist: memray; sys_platform == "linux" and extra == "development"
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

mapfolding-0.16.4.dist-info/RECORD

@@ -0,0 +1,106 @@
+easyRun/A000682.py,sha256=nJJrmVycQUe1H7ms11QGz1ZyYUVdZsjEGtuJk97yxQ0,713
+easyRun/A005316.py,sha256=WCIqsNSevjgUSnTe24d6zWKLZnJSoy14piSt6G26WuE,434
+easyRun/NOTcountingFolds.py,sha256=3wlVLr_KVZwniu-F4KCsBUhsErpu9BZCBGuvlz6-668,807
+easyRun/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+easyRun/countFolds.py,sha256=_7bdg31cN-Dtq4CATECRI1_dxhcrLwoTU9z8d9RWBjk,1181
+easyRun/generateAllModules.py,sha256=xsXFs0BwQ_O5m5rqMjhgMOZ3lj9ssmc3Qdxazp7_uAI,622
+easyRun/meanders.py,sha256=PeilOcWDZwTH60NHgkkMGeqIIAAfRMgL4f7qrVUN4gs,1824
+mapFolding/__init__.py,sha256=ZVkNS11uN04EWDBazqkY4AeVZC9UOXV_W-1V9QZgnl0,1913
+mapFolding/_theSSOT.py,sha256=QuyDsMCbqv3Au4RUgdYPcyR89JrT9WkzcauzybpgKzU,5384
+mapFolding/_theTypes.py,sha256=0uf4x31ilFxIO6sbiSd39H5_7VWBKxColVmfy3oIafk,7376
+mapFolding/basecamp.py,sha256=WXrtT5SeYdHovlTdTjkMh6ua_EU7yApBcMyPVMJfpvs,15088
+mapFolding/beDRY.py,sha256=0vJwnsvz6_jR8gfuU38vW9KoMTnRqyaYaAwbJcKLhFI,12674
+mapFolding/dataBaskets.py,sha256=2_auINZy4O3FreQIAK3DX0QafWoPO-WGop8QWOzKxIg,29058
+mapFolding/filesystemToolkit.py,sha256=ic69Y043xrdoFjKqiB0YJ6Zp8oosBWwdXi_hmg79PVs,10134
+mapFolding/oeis.py,sha256=2sqdFgYguB4sDpcYGYB_mJL57k9sHs7FUXF05pvIEak,17300
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/algorithms/A086345.py,sha256=te3Zy76eJLE3dSFsK7hXTHJapewM1u43GBUV78fL2z8,2492
+mapFolding/algorithms/__init__.py,sha256=gARPqfySaeSWMfApQ5wSxzy7ZdgLdKYsLqsRSEYWwWI,28
+mapFolding/algorithms/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
+mapFolding/algorithms/matrixMeanders.py,sha256=swU6xSo0QhhmA_FxmZhmqvGLJ0h_rS_75jO-SHETWLA,3489
+mapFolding/algorithms/matrixMeandersBeDry.py,sha256=92qk8dSXn2YxtUYhzSFpJpKDRUx6vbfMaRCbJt9baw0,7539
+mapFolding/algorithms/matrixMeandersNumPy.py,sha256=DsMUnB-tsttBm4ib385BaYS2Dnr-KCokKWfK7RjQ780,17147
+mapFolding/algorithms/matrixMeandersPandas.py,sha256=9Pm49HdK0g2MJ15CuZoXOFbdn8JcE0GHzz2p9NB3xvA,13167
+mapFolding/algorithms/oeisIDbyFormula.py,sha256=jinaLXJb3annODlyidtNZkKIKUuFKp_yzjEZMHSMhQ0,11782
+mapFolding/algorithms/symmetricFolds.py,sha256=ji6GitOuVqd_g0X3_mcKuXB6RhjVS0EpOQanlAc5fPI,1457
+mapFolding/algorithms/zCuzDocStoopidoeisIDbyFormula.py,sha256=eGf_gvHUuHAPFFQZd3NIaozY2sQUGse_njtZ8_AyZ-U,2438
+mapFolding/reference/A000682facts.py,sha256=wRg5uy72M-o-cYEF3waCa7NjTUZ3XOoD9dmkTaUiH0o,23510
+mapFolding/reference/A005316facts.py,sha256=Cg2Pqtv3Dnk8IZOqer8Wu3Ie2uwJV_M0Kmr6_QXjKuQ,11768
+mapFolding/reference/A086345Wu.py,sha256=3FJlvcVkrQL2hz4IN2NdzmdMW0weWfYh9l1pnXBTQnc,1110
+mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,2206
+mapFolding/reference/flattened.py,sha256=0eHgLFIeIeVUsI5zF5oSy5iWYrjOMzxr7KjDxiTe01k,16078
+mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
+mapFolding/reference/irvineJavaPort.py,sha256=XnsL4g33LRrYwAhcrAVt-ujsP6QD6fbyCsGYzcm9g_k,3724
+mapFolding/reference/jaxCount.py,sha256=t8ons45zyWNJQ-nmn1qbhNsTkTnRzf7ATauaYvIlkRI,14853
+mapFolding/reference/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnonWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=3IJU7Hc2PDSE71wmSkDs4Z3t0Px9NBSzmCsVrgQuQyU,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
+mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
+mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
+mapFolding/reference/matrixMeandersAnalysis/__init__.py,sha256=FQbR63_z3_zd3HMrpUxx3_YIcn9znzA0RIggcMntSC8,35
+mapFolding/reference/matrixMeandersAnalysis/prefixNotationNotes.py,sha256=R9MUdS0vLEyaVdCio2AAfxEpBz6FDp7cZotEE47nFdU,1001
+mapFolding/reference/matrixMeandersAnalysis/signatures.py,sha256=6yHwW22032ysBgoG9LXxUyvWlKjQgxpB-f8lI213YZ0,20677
+mapFolding/reference/meandersDumpingGround/A005316JavaPort.py,sha256=syMHicfioP-0GrOq7GnEpuAFSNvRwnbGim0mqV862sA,4885
+mapFolding/reference/meandersDumpingGround/A005316imperative.py,sha256=UEbXPkORngVo0UrwS81SY2gwz1XWAaMZ0rgA7HMiVYk,3793
+mapFolding/reference/meandersDumpingGround/A005316primitiveOptimized.py,sha256=iFig6Edv1E774xrlVUFLyscC40DqDhV-oh4hOnG2DLI,4116
+mapFolding/reference/meandersDumpingGround/A005316redis.py,sha256=MPeiobrs3VsNZOOKYBg52oVp0OjVDzLEdsRKfrZ9LrU,4328
+mapFolding/reference/meandersDumpingGround/A005316write2disk.py,sha256=NMVrdhe5KhnXQfaQ5Xr7Pwl5oXYEOM1DrMISDDOCVVw,5633
+mapFolding/reference/meandersDumpingGround/matrixMeanders64retired.py,sha256=oRVgf6zkWRjk7dWR-Px41M_5spdvKy_Pich0qd7oxVA,9270
+mapFolding/reference/meandersDumpingGround/matrixMeandersBaselineV2.py,sha256=VpRiIGhnk-DbxwsHwCeCwXqcKLSNyHl-iRGLDH9ZGMY,7674
+mapFolding/reference/meandersDumpingGround/matrixMeandersNumPyV1finalForm.py,sha256=G4358jHFr7hdOa709c8nYdR3eMMZjUqcxbS-L2aAOqw,24428
+mapFolding/reference/meandersDumpingGround/matrixMeandersSlicePop.py,sha256=XyiesSQAH1dRplYx_CdR1FzcXvgmmxzj27V4aIqPp7o,5353
+mapFolding/someAssemblyRequired/RecipeJob.py,sha256=Dpu33Wu6OziJ8Sqx6TCHA10TBmNQT8yiCl2FtaM3jl0,13723
+mapFolding/someAssemblyRequired/__init__.py,sha256=PIdLYHFSfYsQSP55PoQSusi1dsOGhiY986kgosGO3vI,5811
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=QC2cmCea18BZ_WpoWoErYCWhROvmd40_i_nBO7YFRaE,6378
+mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=rp1w-y5wXctcwSPkHG1JQSCY3ro5lc0AoAF_PkBJfQQ,14798
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=tY0-2K0BFkwLAAjSrFJLPoG8CevDHOFc3OH3TxXANzg,2806
+mapFolding/someAssemblyRequired/infoBooth.py,sha256=lwz8Zp8FRlTrBFqBHnch6JC_AukQ3o9O4lbBJ-wQVrY,2417
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=C29oQyDFE0St85opv37hqvIncpZ5IzCHavprex4HNIU,14221
+mapFolding/someAssemblyRequired/makeJobTheorem2codon.py,sha256=2wNA3iztFDN3jzxIneckgiR5UyRfApdjHbdXA4CRCWY,10118
+mapFolding/someAssemblyRequired/makingModules_count.py,sha256=E1WwaM_w1xiBusX7ah61e2AdMiWIBqNM5v0r5pjsd_k,15053
+mapFolding/someAssemblyRequired/makingModules_doTheNeedful.py,sha256=1lo_30R7__bkrOlA7t-iwb1vnw6kCN5eZbCsiZg29cw,3119
+mapFolding/someAssemblyRequired/toolkitMakeModules.py,sha256=wROp5yTJWts-_adcOwLKXr1e2P5vElKk4NCYkscXMZo,7915
+mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=Zi3JeJDio177T4P3om5XK_2wZzplZvkNy4PzY0NFiyM,14914
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=FzAraqdgxB7XOcxfKxeUI_zUNYiRKRn8eVAt6LcO4Ck,11553
+mapFolding/someAssemblyRequired/A007822/A007822rawMaterials.py,sha256=HbnYk4th5p_jCJI-WzIED8a35JZSLVpecZyTaSIfKXM,1609
+mapFolding/someAssemblyRequired/A007822/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/someAssemblyRequired/A007822/_asynchronousAnnex.py,sha256=mT4IEFTF2lVT8GeNJ2e18eWleBjwJGbOFZow0CjXx4Q,1726
+mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py,sha256=QMH0ihfkLHr_j3UY3-vTRU3_YbyowTV9c-rP-rr5Ml0,5528
+mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py,sha256=o80ac_b8KjogJ0jw0lUl36Qlw0XSw1QLQfzEU8UtjDE,4157
+mapFolding/someAssemblyRequired/mapFoldingModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/someAssemblyRequired/mapFoldingModules/makeMapFoldingModules.py,sha256=mZS1OQ4ttnStKO0PZkb6dKjPU-DsbFUrrc2eG7Bw61I,16341
+mapFolding/someAssemblyRequired/meanders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/someAssemblyRequired/meanders/makeMeandersModules.py,sha256=fvuZhOzL4LcUrDQq5gFtGF2U7xwlosTlbs_mLkeSr9E,3305
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/countParallelNumba.py,sha256=IarQHgZmxCt3I1WkRHRrqPwpeBSNzcV6ZEX2X0HrC8c,7777
+mapFolding/syntheticModules/daoOfMapFoldingNumba.py,sha256=6V2DwXtmO6EeQXf6oxDp3myp-vbsVq6G0ZjnLRF9rCw,5940
+mapFolding/syntheticModules/initializeState.py,sha256=OTiVi1Ywnlwk8tbwSIFjPJa_yBCINoapaCzGXDAJq_k,3121
+mapFolding/syntheticModules/theorem2.py,sha256=sqo8AA7CqvejAEuNqo5KIx7shjCQsuh8l8ThJot5RPA,3262
+mapFolding/syntheticModules/theorem2Numba.py,sha256=h4ToUvB5Ubesi3mGVrIHErxfEnzeqlvSI7otnJLAo4o,5650
+mapFolding/syntheticModules/theorem2Trimmed.py,sha256=JjWz71sBHdlzw1bDhy0rtEVvf6RNR9LVYLUvCdPYJ3g,2930
+mapFolding/syntheticModules/A007822/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/A007822/algorithm.py,sha256=K8H9cyJRhSeQ6ZPYK8ygH7luYh6Z0dpoav-hcWzb5C4,7041
+mapFolding/syntheticModules/A007822/asynchronous.py,sha256=mr4_Y6VT7AXrT1Yh6A5kn77c2N-mAjV1zh-8oRvOWd8,8653
+mapFolding/syntheticModules/A007822/initializeState.py,sha256=qDl156iCf9qmlHw6O9oJG_9f706dixp21qX7jFW2Qos,4040
+mapFolding/syntheticModules/A007822/theorem2.py,sha256=4N4AFuxpJdv9f-7RsH9-yEKYg_66nPbiTi6DFDBymSs,4197
+mapFolding/syntheticModules/A007822/theorem2Numba.py,sha256=z9hSU8tPoScQVklipmA1DjAKj5cJduwA5f_ZpNtew54,7138
+mapFolding/syntheticModules/A007822/theorem2Trimmed.py,sha256=8QU83qJO0Sxxh8xMOD2sdksOWdYR02qir_qpmzJKcMY,3865
+mapFolding/syntheticModules/meanders/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/meanders/bigInt.py,sha256=G6iZbPaEz2gHInMAZ0ZBUgoPbSjS7YYI2QjsxWg-PQE,2962
+mapFolding/tests/__init__.py,sha256=QVCHSMFVvTxV3mAyYOLkMFAFyBJ514zdoVnDmpBJnTo,1336
+mapFolding/tests/conftest.py,sha256=5vV_Vy5ZrV3uoP9bQ8B-Kqc0zMrL7KAhsPJwchMDb6w,15700
+mapFolding/tests/test_computations.py,sha256=72b_6rxaJsaIuTVwAF2qkc2rIFJE-bM3hHcFhT756MQ,8600
+mapFolding/tests/test_filesystem.py,sha256=0rYQ62f4e3HOoymXrxDWbqNEBJQ7DGN8RUOMI84tE2Q,3892
+mapFolding/tests/test_oeis.py,sha256=M4Fb0e4_h9QTX9Oy6l5-M1UQfNqeonoGVOn0DJI9huE,4854
+mapFolding/tests/test_other.py,sha256=ScBiJ78LnyAaW-RhxcouX6Xw10wgpSdqfvT4LO3WjnQ,4766
+mapFolding/tests/test_tasks.py,sha256=_pr9JRWjjNKA7sww70XvkJJdGPruBVzubM63RmD_Du0,4013
+mapFolding/zCuzDocStoopid/__init__.py,sha256=uKcGXsaYKH9kQUGHjaY0EtWtU6qybb9Fs09ZYKEFMNs,236
+mapFolding/zCuzDocStoopid/makeDocstrings.py,sha256=cQl-B-RlAkFijATUTWfKCael46foH-ZsOp1EHoYxoGs,3212
+mapfolding-0.16.4.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.16.4.dist-info/METADATA,sha256=78ArH8-l_3SsbbH2A4IDuT6P9l7tetRaEvfjHVVO7m0,7690
+mapfolding-0.16.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mapfolding-0.16.4.dist-info/entry_points.txt,sha256=-mH9DjW9tDRMPaeoSWKKywG35cR28m12H_jtmrB4eY8,98
+mapfolding-0.16.4.dist-info/top_level.txt,sha256=jNj7ccwEy_9uqs0hsQCO_rPXgaGn8-IMqXePQN6nZTY,19
+mapfolding-0.16.4.dist-info/RECORD,,

mapFolding/_dataPacking.py

@@ -1,68 +0,0 @@
-from collections.abc import Callable
-from mapFolding.dataBaskets import MapFoldingState
-from typing import Any
-import astToolkit
-import dataclasses
-import functools
-import inspect
-
-r"""Notes
-Goal: create a decorator, `unRePackMapFoldingState`, that will unpack `MapFoldingState`, pass only the parameters in the decorated function, receive the
-values returned by the function, and repack `MapFoldingState`.
-
-You must use dynamic programming. If the datatype or the field name changes, for example, that should not affect the decorator.
-
-To use in, for example, C:\apps\mapFolding\mapFolding\syntheticModules\A007822\theorem2Numba.py. Analogous to
-`Z0Z_tools.waveformSpectrogramWaveform`, see
-https://github.com/hunterhogan/Z0Z_tools/blob/2c393c2831382dfe6f3e742cf56db39e71126cbc/Z0Z_tools/ioAudio.py
-
-For examples of manipulating `dataclasses`, see also:
-C:\apps\mapFolding\mapFolding\someAssemblyRequired\_toolkitContainers.py and
-C:\apps\mapFolding\mapFolding\someAssemblyRequired\transformationTools.py
-
-- `TypeVar` may be useful.
-
-- `dataclasses` has inspection tools.
-
-- `return MapFoldingState(...` Check if the field is init=True
-
-Prototype. Eventual home will probably be "beDry.py".
-"""
-
-def unRePackMapFoldingState[CallableTargetType: Callable[..., Any]](callableTarget: CallableTargetType) -> Callable[[MapFoldingState], MapFoldingState]:
-	signatureTargetFunction: inspect.Signature = inspect.signature(callableTarget)
-	parametersTargetFunction: list[str] = list(signatureTargetFunction.parameters.keys())
-
-	fieldsMapFoldingState: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(MapFoldingState)
-
-	fieldsInitializable: dict[str, dataclasses.Field[Any]] = {field.name: field for field in fieldsMapFoldingState if field.init}
-
-	@functools.wraps(callableTarget)
-	def decoratedFunction(mapFoldingStateInstance: MapFoldingState, **additionalKeywordArguments: Any) -> MapFoldingState:
-		dataclassAsDict: dict[str, Any] = dataclasses.asdict(mapFoldingStateInstance)
-
-		argumentsForTargetFunction: list[Any] = []
-		for parameterName in parametersTargetFunction:
-			if parameterName in dataclassAsDict:
-				argumentsForTargetFunction.append(dataclassAsDict[parameterName])
-			elif parameterName in additionalKeywordArguments:
-				argumentsForTargetFunction.append(additionalKeywordArguments[parameterName])
-			else:
-				errorMessage = f"Parameter '{parameterName}' not found in MapFoldingState or additional arguments"
-				raise ValueError(errorMessage)
-
-		returnedFromTargetFunction: Any = callableTarget(*argumentsForTargetFunction)
-
-		argumentsForMapFoldingStateConstructor: dict[str, Any] = {fieldName: dataclassAsDict[fieldName] for fieldName in fieldsInitializable}
-
-		if len(parametersTargetFunction) == 1:
-			singleParameterName: str = parametersTargetFunction[0]
-			if singleParameterName in fieldsInitializable:
-				argumentsForMapFoldingStateConstructor[singleParameterName] = returnedFromTargetFunction
-		elif isinstance(returnedFromTargetFunction, tuple) and len(returnedFromTargetFunction) == len(parametersTargetFunction):
-			updatedFieldsFromReturn: dict[str, Any] = {parameterName: returnedValue for parameterName, returnedValue in zip(parametersTargetFunction, returnedFromTargetFunction, strict=True) if parameterName in fieldsInitializable}
-			argumentsForMapFoldingStateConstructor.update(updatedFieldsFromReturn)
-
-		return MapFoldingState(**argumentsForMapFoldingStateConstructor)
-
-	return decoratedFunction

mapFolding/reference/meandersDumpingGround/A005316intOptimized.py

@@ -1,122 +0,0 @@
-from collections.abc import Iterable
-from hunterMakesPy import raiseIfNone
-
-class BasicMeanderProblem:
-
-	def __init__(self, remainingBridges: int) -> None:
-		self.remainingBridges = remainingBridges
-		self.archStateLimit = 1 << (2 + (2 * (remainingBridges + 1)))
-		self.bridgesTotalIsOdd = (remainingBridges & 1) == 1
-
-	def initializeA005316(self) -> list[int]:
-		if self.bridgesTotalIsOdd:
-			bitPattern = (1 << 2) | 1
-			bitPattern <<= 2
-			return [bitPattern | 1 << 1]
-		else:
-			bitPattern = (1 << 2) | 1
-			return [bitPattern | bitPattern << 1]
-
-	def initializeA000682(self) -> list[int]:
-		initialStatesList: list[int] = []
-		bitPattern = 1 if self.bridgesTotalIsOdd else ((1 << 2) | 1)
-
-		packedState = bitPattern | bitPattern << 1
-		while packedState < self.archStateLimit:
-			initialStatesList.append(packedState)
-			bitPattern = ((bitPattern << 2) | 1) << 2 | 1
-			packedState = bitPattern | bitPattern << 1
-
-		return initialStatesList
-
-	def enumerate(self, packedState: int) -> list[int]:  # noqa: C901
-		bitMask = 0x5555555555555555
-		bitWidth = 64
-		while bitMask < packedState:
-			bitMask |= bitMask << bitWidth
-			bitWidth += bitWidth
-		lower: int = packedState & bitMask
-		upper: int = (packedState - lower) >> 1
-		nextStatesList: list[int] = []
-
-		if lower != 1:
-			nextState: int = (lower >> 2 | (((upper << 2) ^ (1 if (lower & 1) == 0 else 0)) << 1))
-			if nextState < self.archStateLimit:
-				nextStatesList.append(nextState)
-
-		if upper != 1:
-			nextState = (((lower << 2) ^ (1 if (upper & 1) == 0 else 0)) | (upper >> 2) << 1)
-			if nextState < self.archStateLimit:
-				nextStatesList.append(nextState)
-
-		nextState = ((lower << 2) | 1 | ((upper << 2) | 1) << 1)
-		if nextState < self.archStateLimit:
-			nextStatesList.append(nextState)
-
-		if lower != 1 and upper != 1 and ((lower & 1) == 0 or (upper & 1) == 0):
-			if (lower & 1) == 0 and (upper & 1) == 1:
-				archBalance = 0
-				bitPosition = 1
-				while archBalance >= 0:
-					bitPosition <<= 2
-					archBalance += 1 if (lower & bitPosition) == 0 else -1
-				lower ^= bitPosition
-			if (upper & 1) == 0 and (lower & 1) == 1:
-				archBalance = 0
-				bitPosition = 1
-				while archBalance >= 0:
-					bitPosition <<= 2
-					archBalance += 1 if (upper & bitPosition) == 0 else -1
-				upper ^= bitPosition
-			nextState = (lower >> 2 | (upper >> 2) << 1)
-			if nextState < self.archStateLimit:
-				nextStatesList.append(nextState)
-
-		return nextStatesList
-
-class SimpleProcessor:
-
-	def __init__(self) -> None:
-		self.createStateMachine: type | None = None
-		self.totalTransitions = 0
-
-	def setCreateStateMachine(self, stateMachineCreator: type) -> None:
-		self.createStateMachine = stateMachineCreator
-
-	def process(self, bridgesCount: int, initialStates: Iterable[int]) -> int:
-		stateCounts: list[tuple[int, int]] = [(state, 1) for state in initialStates]
-
-		self.createStateMachine = raiseIfNone(self.createStateMachine, "State machine creator must be set before processing.")
-		bridgesRemaining: int = bridgesCount
-		while bridgesRemaining > 0:
-			bridgesRemaining -= 1
-			stateCounts = self._accumulate(self.createStateMachine(bridgesRemaining), stateCounts)
-
-		return sum(count for state, count in stateCounts)
-
-	def _accumulate(self, layer: BasicMeanderProblem, previousCounts: list[tuple[int, int]]) -> list[tuple[int, int]]:
-		stateCountsDict: dict[int, int] = {}
-		transitions: int = 0
-
-		for state, count in previousCounts:
-			for nextState in layer.enumerate(state):
-				if nextState in stateCountsDict:
-					stateCountsDict[nextState] += count
-				else:
-					stateCountsDict[nextState] = count
-				transitions += 1
-
-		self.totalTransitions += transitions
-		return list(stateCountsDict.items())
-
-def A005316(n: int) -> int:
-	processor = SimpleProcessor()
-	processor.setCreateStateMachine(BasicMeanderProblem)
-	meanderProblem = BasicMeanderProblem(n)
-	return processor.process(n, meanderProblem.initializeA005316())
-
-def A000682(n: int) -> int:
-	processor = SimpleProcessor()
-	processor.setCreateStateMachine(BasicMeanderProblem)
-	meanderProblem = BasicMeanderProblem(n-1)
-	return processor.process(n-1, meanderProblem.initializeA000682())