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

mapFolding/syntheticModules/A007822/asynchronousTheorem2.py

@@ -0,0 +1,53 @@
+from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.A007822.asynchronousAnnex import filterAsymmetricFolds, getAsymmetricFoldsTotal
+
+def count(state: MapFoldingState) -> MapFoldingState:
+    while state.leaf1ndex > 4:
+        if state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                filterAsymmetricFolds(state.leafBelow)
+            else:
+                state.dimensionsUnconstrained = state.dimensionsTotal
+                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+                state.indexDimension = 0
+                while state.indexDimension < state.dimensionsTotal:
+                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                    if state.leafConnectee == state.leaf1ndex:
+                        state.dimensionsUnconstrained -= 1
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                            if state.countDimensionsGapped[state.leafConnectee] == 0:
+                                state.gap1ndexCeiling += 1
+                            state.countDimensionsGapped[state.leafConnectee] += 1
+                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                    state.indexDimension += 1
+                if not state.dimensionsUnconstrained:
+                    state.indexLeaf = 0
+                    while state.indexLeaf < state.leaf1ndex:
+                        state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+                        state.gap1ndexCeiling += 1
+                        state.indexLeaf += 1
+                state.indexMiniGap = state.gap1ndex
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                        state.gap1ndex += 1
+                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                    state.indexMiniGap += 1
+        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state.leaf1ndex -= 1
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+        state.gap1ndex -= 1
+        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+        state.leaf1ndex += 1
+    else:
+        state.groupsOfFolds = getAsymmetricFoldsTotal()
+        state.groupsOfFolds *= 2
+    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    return state

mapFolding/syntheticModules/A007822/asynchronousTrimmed.py

@@ -0,0 +1,47 @@
+from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.A007822.asynchronousAnnex import filterAsymmetricFolds, getAsymmetricFoldsTotal
+
+def count(state: MapFoldingState) -> MapFoldingState:
+    while state.leaf1ndex > 4:
+        if state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                filterAsymmetricFolds(state.leafBelow)
+            else:
+                state.dimensionsUnconstrained = state.dimensionsTotal
+                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+                state.indexDimension = 0
+                while state.indexDimension < state.dimensionsTotal:
+                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                    if state.leafConnectee == state.leaf1ndex:
+                        state.dimensionsUnconstrained -= 1
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                            if state.countDimensionsGapped[state.leafConnectee] == 0:
+                                state.gap1ndexCeiling += 1
+                            state.countDimensionsGapped[state.leafConnectee] += 1
+                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                    state.indexDimension += 1
+                state.indexMiniGap = state.gap1ndex
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                        state.gap1ndex += 1
+                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                    state.indexMiniGap += 1
+        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state.leaf1ndex -= 1
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+        state.gap1ndex -= 1
+        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+        state.leaf1ndex += 1
+    else:
+        state.groupsOfFolds = getAsymmetricFoldsTotal()
+        state.groupsOfFolds *= 2
+    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    return state

mapFolding/syntheticModules/{initializeStateA007822.py → A007822/initializeState.py}

@@ -21,8 +21,7 @@ def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
-                    if ImaSymmetricFold:
-                        state.groupsOfFolds += 1
+                    state.groupsOfFolds += ImaSymmetricFold
                     state.indexMiniGap += 1
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal

mapFolding/syntheticModules/{theorem2A007822.py → A007822/theorem2.py}

@@ -21,8 +21,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
-                    if ImaSymmetricFold:
-                        state.groupsOfFolds += 1
+                    state.groupsOfFolds += ImaSymmetricFold
                     state.indexMiniGap += 1
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal

mapFolding/syntheticModules/{theorem2A007822Numba.py → A007822/theorem2Numba.py}

@@ -1,6 +1,9 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
+from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclassA007822
 from numba import jit
 
+@unRePackDataclassA007822
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
 def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 4:
@@ -23,8 +26,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
-                    if ImaSymmetricFold:
-                        groupsOfFolds += 1
+                    groupsOfFolds += ImaSymmetricFold
                     indexMiniGap += 1
             else:
                 dimensionsUnconstrained = dimensionsTotal
@@ -63,4 +65,4 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
     else:
         groupsOfFolds *= 2
     groupsOfFolds = (groupsOfFolds + 1) // 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)

mapFolding/syntheticModules/{theorem2A007822Trimmed.py → A007822/theorem2Trimmed.py}

@@ -21,8 +21,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
-                    if ImaSymmetricFold:
-                        state.groupsOfFolds += 1
+                    state.groupsOfFolds += ImaSymmetricFold
                     state.indexMiniGap += 1
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal

mapFolding/syntheticModules/countParallelNumba.py

@@ -1,8 +1,11 @@
 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')
 
@@ -96,4 +99,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,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -72,4 +74,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     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
+    return state

mapFolding/syntheticModules/dataPacking.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from mapFolding.syntheticModules.theorem2Numba import count
 
 def sequential(state: MapFoldingState) -> MapFoldingState:
@@ -23,4 +25,4 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     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, leafComparison=leafComparison)
-    return state
+    return state

mapFolding/syntheticModules/dataPackingA007822.py

@@ -1,26 +1,92 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
-from mapFolding.syntheticModules.theorem2A007822Numba import count
-
-def sequential(state: MapFoldingState) -> MapFoldingState:
-    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
-    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, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
-    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+from collections.abc import Callable
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
+
+def unRePackDataclassA007822(callableTarget: Callable[[
+	DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino,
+	DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal,
+	Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal
+], tuple[
+	DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino,
+	DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal,
+	Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal
+]]) -> Callable[[MapFoldingState], MapFoldingState]:
+	def workhorse(state: MapFoldingState) -> MapFoldingState:
+		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
+		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, leafComparison, connectionGraph, dimensionsTotal, leavesTotal
+		) = callableTarget(
+			groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained,
+			countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
+
+		state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling,
+			indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee,
+			dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart,
+			gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
+		return state
+
+	return workhorse
+
+def unRePackDataclassAsynchronous(callableTarget: Callable[[
+	DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino,
+	DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal,
+	Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal
+], tuple[
+	DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino,
+	DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal,
+	Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal
+]]) -> Callable[[MapFoldingState], MapFoldingState]:
+	def workhorse(state: MapFoldingState) -> MapFoldingState:
+		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
+		leafComparison: Array1DLeavesTotal = state.leafComparison
+		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
+		) = callableTarget(
+			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, leafComparison=leafComparison)
+		return state
+
+	return workhorse

mapFolding/syntheticModules/meanders/__init__.py

@@ -0,0 +1 @@
+"""Everything in this directory is synthesized by other modules in the package."""

mapFolding/syntheticModules/meanders/bigInt.py

@@ -0,0 +1,62 @@
+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).
+
+    Parameters
+    ----------
+    state : MatrixMeandersState
+        The algorithm state.
+
+    Notes
+    -----
+    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)
+        state.dictionaryMeanders = {}
+        for (bitsAlpha, bitsZulu), crossings in dictionaryBitGroups.items():
+            bitsAlphaHasArcs: bool = bitsAlpha > 1
+            bitsZuluHasArcs: bool = bitsZulu > 1
+            bitsAlphaIsEven = bitsZuluIsEven = 0
+            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
+                if arcCodeAnalysis < state.MAXIMUMarcCode:
+                    state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
+            if bitsZuluHasArcs:
+                arcCodeAnalysis = bitsZulu >> 1 | bitsAlpha << 2 | (bitsZuluIsEven := (1 - (bitsZulu & 1)))
+                if arcCodeAnalysis < state.MAXIMUMarcCode:
+                    state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
+            if bitsAlphaHasArcs and bitsZuluHasArcs and (bitsAlphaIsEven or bitsZuluIsEven):
+                if bitsAlphaIsEven and (not bitsZuluIsEven):
+                    bitsAlpha ^= walkDyckPath(bitsAlpha)
+                elif bitsZuluIsEven and (not bitsAlphaIsEven):
+                    bitsZulu ^= walkDyckPath(bitsZulu)
+                arcCodeAnalysis: int = bitsZulu >> 2 << 1 | bitsAlpha >> 2
+                if arcCodeAnalysis < state.MAXIMUMarcCode:
+                    state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
+        dictionaryBitGroups = {}
+    return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -1,4 +1,5 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -43,4 +44,4 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
         leaf1ndex += 1
     else:
         groupsOfFolds *= 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)

mapFolding/tests/conftest.py

@@ -25,7 +25,7 @@ research domain.
 
 from collections.abc import Callable, Generator, Sequence
 from mapFolding import _theSSOT, getLeavesTotal, makeDataContainer, packageSettings, validateListDimensions
-from mapFolding.oeis import dictionaryOEISMapFolding, dictionaryOEISMeanders, oeisIDsImplemented
+from mapFolding.oeis import dictionaryOEIS, dictionaryOEISMapFolding, oeisIDsImplemented
 from pathlib import Path
 from typing import Any
 import numpy
@@ -223,7 +223,7 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 			pass
 
 @pytest.fixture
-def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
+def mapShapeTestCountFolds(oeisIDmapFolding: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if
 	`validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
 
@@ -239,10 +239,10 @@ def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -278,7 +278,7 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 			pass
 
 @pytest.fixture
-def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
+def mapShapeTestParallelization(oeisIDmapFolding: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`.
 
 	Parameters
@@ -292,8 +292,8 @@ def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
 		Map dimensions suitable for testing parallelization features.
 
 	"""
-	n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestParallelization'])
-	return dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
+	n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestParallelization'])
+	return dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
@@ -332,7 +332,7 @@ def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 	return make_mock
 
 @pytest.fixture(params=oeisIDsImplemented)
-def oeisID(request: pytest.FixtureRequest) -> Any:
+def oeisIDmapFolding(request: pytest.FixtureRequest) -> Any:
 	"""Parametrized fixture providing all implemented OEIS sequence identifiers.
 
 	(AI generated docstring)
@@ -350,11 +350,26 @@ def oeisID(request: pytest.FixtureRequest) -> Any:
 	"""
 	return request.param
 
-@pytest.fixture(params=tuple(dictionaryOEISMeanders.keys()))
-def oeisIDMeanders(request: pytest.FixtureRequest) -> Any:
-	"""Parametrized fixture providing all implemented Meanders OEIS sequence identifiers.
+@pytest.fixture(params=('A000682', 'A005316'))
+def oeisIDmeanders(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all Meanders OEIS sequence identifiers.
 
-	(AI generated docstring)
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object containing the current parameter value.
+
+	Returns
+	-------
+	sequenceIdentifier : Any
+		OEIS sequence identifier for testing across all Meanders sequences.
+
+	"""
+	return request.param
+
+@pytest.fixture(params=tuple(dictionaryOEIS.keys()))
+def oeisIDother(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all other OEIS sequence identifiers.
 
 	Parameters
 	----------
@@ -364,7 +379,7 @@ def oeisIDMeanders(request: pytest.FixtureRequest) -> Any:
 	Returns
 	-------
 	sequenceIdentifier : Any
-		OEIS sequence identifier for testing across all implemented Meanders sequences.
+		OEIS sequence identifier for testing across all other sequences.
 
 	"""
 	return request.param