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

mapFolding/syntheticModules/A007822/algorithm.py

@@ -1,5 +1,6 @@
 from mapFolding.dataBaskets import MapFoldingState
 
+
 def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
     state.indexLeaf = 0
     leafConnectee = 0
@@ -18,8 +19,7 @@ def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
                 ImaSymmetricFold = False
                 break
             leafConnectee += 1
-        if ImaSymmetricFold:
-            state.groupsOfFolds += 1
+        state.groupsOfFolds += ImaSymmetricFold
         state.indexMiniGap += 1
     return state
 
@@ -163,4 +163,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/A007822/algorithmNumba.py

@@ -23,8 +23,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
-                    if ImaSymmetricFold:
-                        groupsOfFolds += 1
+                    groupsOfFolds += ImaSymmetricFold
                     indexMiniGap += 1
             else:
                 dimensionsUnconstrained = dimensionsTotal

mapFolding/syntheticModules/A007822/asynchronous.py

@@ -1,6 +1,8 @@
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.syntheticModules.A007822.asynchronousAnnex import (
-	filterAsymmetricFolds, getAsymmetricFoldsTotal, initializeConcurrencyManager)
+    filterAsymmetricFolds, getSymmetricFoldsTotal,
+    initializeConcurrencyManager)
+
 
 def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
     return state.leaf1ndex > 0
@@ -138,11 +140,11 @@ def count(state: MapFoldingState) -> MapFoldingState:
         if gapAvailable(state):
             state = insertActiveLeafAtGap(state)
     else:
-        state.groupsOfFolds = getAsymmetricFoldsTotal()
+        state.groupsOfFolds = getSymmetricFoldsTotal()
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
-    initializeConcurrencyManager()
+def doTheNeedful(state: MapFoldingState, maxWorkers: int | None=None) -> MapFoldingState:
+    initializeConcurrencyManager(maxWorkers)
     state = count(state)
     return state

mapFolding/syntheticModules/A007822/asynchronousAnnex.py

@@ -1,11 +1,10 @@
-from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from concurrent.futures import Future as ConcurrentFuture, ThreadPoolExecutor
 from hunterMakesPy import raiseIfNone
 from mapFolding import Array1DLeavesTotal
 from queue import Empty, Queue
 from threading import Thread
 import numpy
 
-
 concurrencyManager = None
 groupsOfFoldsTotal: int = 0
 processingThread = None
@@ -13,7 +12,7 @@ queueFutures: Queue[ConcurrentFuture[int]] = Queue()
 
 def initializeConcurrencyManager(maxWorkers: int | None=None, groupsOfFolds: int=0) -> None:
     global concurrencyManager, queueFutures, groupsOfFoldsTotal, processingThread
-    concurrencyManager = ProcessPoolExecutor(max_workers=maxWorkers)
+    concurrencyManager = ThreadPoolExecutor(max_workers=maxWorkers)
     queueFutures = Queue()
     groupsOfFoldsTotal = groupsOfFolds
     processingThread = Thread(target=_processCompletedFutures)
@@ -51,16 +50,15 @@ def _filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> int:
                 ImaSymmetricFold = False
                 break
             leafConnectee += 1
-        if ImaSymmetricFold:
-            groupsOfFolds += 1
+        groupsOfFolds += ImaSymmetricFold
         indexDistance += 1
     return groupsOfFolds
 
 def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> None:
     global concurrencyManager, queueFutures
-    queueFutures.put(raiseIfNone(concurrencyManager).submit(_filterAsymmetricFolds, leafBelow.copy()))
+    queueFutures.put_nowait(raiseIfNone(concurrencyManager).submit(_filterAsymmetricFolds, leafBelow.copy()))
 
-def getAsymmetricFoldsTotal() -> int:
+def getSymmetricFoldsTotal() -> int:
     global concurrencyManager, queueFutures, processingThread
     raiseIfNone(concurrencyManager).shutdown(wait=True)
     queueFutures.put(None)

mapFolding/syntheticModules/A007822/asynchronousAnnexNumba.py

@@ -0,0 +1,70 @@
+from mapFolding import Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from queue import Queue
+from threading import Lock, Thread
+import numba
+import numpy
+
+listThreads: list[Thread] = []
+queueFutures: Queue[Array1DLeavesTotal] = Queue()
+groupsOfFoldsTotal: int = 0
+groupsOfFoldsTotalLock = Lock()
+sentinelStop = object()
+
+def initializeConcurrencyManager(maxWorkers: int, groupsOfFolds: int=0) -> None:
+	global listThreads, groupsOfFoldsTotal, queueFutures  # noqa: PLW0603
+	listThreads = []
+	queueFutures = Queue()
+	groupsOfFoldsTotal = groupsOfFolds
+	indexThread = 0
+	while indexThread < maxWorkers:
+		thread = Thread(target=_threadDoesSomething, name=f"thread{indexThread}", daemon=True)
+		thread.start()
+		listThreads.append(thread)
+		indexThread += 1
+
+def _threadDoesSomething() -> None:
+	global groupsOfFoldsTotal  # noqa: PLW0603
+	while True:
+		leafBelow = queueFutures.get()
+		if leafBelow is sentinelStop:  # pyright: ignore[reportUnnecessaryComparison]
+			break
+		symmetricFolds = _filterAsymmetricFolds(leafBelow)
+		with groupsOfFoldsTotalLock:
+			groupsOfFoldsTotal += symmetricFolds
+
+@numba.jit(cache=True, error_model='numpy', fastmath=True)
+def _filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> int:
+	groupsOfFolds = 0
+	leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
+	leavesTotal = leafBelow.size - 1
+	indexLeaf = 0
+	leafConnectee = 0
+	while leafConnectee < leavesTotal + 1:
+		leafNumber = int(leafBelow[indexLeaf])
+		leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
+		indexLeaf = leafNumber
+		leafConnectee += 1
+	indexInMiddle = leavesTotal // 2
+	indexDistance = 0
+	while indexDistance < leavesTotal + 1:
+		ImaSymmetricFold = True
+		leafConnectee = 0
+		while leafConnectee < indexInMiddle:
+			if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
+				ImaSymmetricFold = False
+				break
+			leafConnectee += 1
+		groupsOfFolds += ImaSymmetricFold
+		indexDistance += 1
+	return groupsOfFolds
+
+def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> None:
+	queueFutures.put_nowait(leafBelow.copy())
+
+def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
+	global listThreads  # noqa: PLW0602
+	for _thread in listThreads:
+		queueFutures.put(sentinelStop)  # pyright: ignore[reportArgumentType]
+	for thread in listThreads:
+		thread.join()
+	return groupsOfFoldsTotal

mapFolding/syntheticModules/A007822/asynchronousNumba.py

@@ -0,0 +1,79 @@
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
+from mapFolding.syntheticModules.A007822.asynchronousAnnex import (
+	filterAsymmetricFolds, getSymmetricFoldsTotal, initializeConcurrencyManager)
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+from numba import jit
+
+@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+    while leaf1ndex > 4:
+        if leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                filterAsymmetricFolds(leafBelow)
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if countDimensionsGapped[leafConnectee] == 0:
+                                gap1ndexCeiling += 1
+                            countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
+        while gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        gap1ndex -= 1
+        leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+        leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+        leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+        leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+        gapRangeStart[leaf1ndex] = gap1ndex
+        leaf1ndex += 1
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+
+def doTheNeedful(state: MapFoldingState, maxWorkers: int | None=None) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    initializeConcurrencyManager(maxWorkers, state.groupsOfFolds)
+    state.groupsOfFolds = 0
+    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 = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    groupsOfFolds = getSymmetricFoldsTotal()
+    groupsOfFolds *= 2
+    groupsOfFolds = (groupsOfFolds + 1) // 2
+    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

mapFolding/syntheticModules/A007822/asynchronousTheorem2.py

@@ -1,5 +1,10 @@
 from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.syntheticModules.A007822.asynchronousAnnex import filterAsymmetricFolds, getAsymmetricFoldsTotal
+from mapFolding.syntheticModules.A007822.asynchronousAnnexNumba import (
+    filterAsymmetricFolds, getSymmetricFoldsTotal,
+    initializeConcurrencyManager)
+from mapFolding.syntheticModules.A007822.initializeState import \
+    transitionOnGroupsOfFolds
+
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -47,7 +52,14 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
     else:
-        state.groupsOfFolds = getAsymmetricFoldsTotal()
+        state.groupsOfFolds = getSymmetricFoldsTotal()
         state.groupsOfFolds *= 2
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    return state
+    return state
+
+def doTheNeedful(state: MapFoldingState, maxWorkers: int | None=None) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    initializeConcurrencyManager(maxWorkers, state.groupsOfFolds)
+    state.groupsOfFolds = 0
+    state = count(state)
+    return state

mapFolding/syntheticModules/A007822/asynchronousTrimmed.py

@@ -1,5 +1,7 @@
 from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.syntheticModules.A007822.asynchronousAnnex import filterAsymmetricFolds, getAsymmetricFoldsTotal
+from mapFolding.syntheticModules.A007822.asynchronousAnnexNumba import (
+	filterAsymmetricFolds, getSymmetricFoldsTotal, initializeConcurrencyManager)
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -41,7 +43,14 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
     else:
-        state.groupsOfFolds = getAsymmetricFoldsTotal()
+        state.groupsOfFolds = getSymmetricFoldsTotal()
         state.groupsOfFolds *= 2
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    return state
+    return state
+
+def doTheNeedful(state: MapFoldingState, maxWorkers: int | None=None) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    initializeConcurrencyManager(maxWorkers, state.groupsOfFolds)
+    state.groupsOfFolds = 0
+    state = count(state)
+    return state

mapFolding/syntheticModules/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/A007822/theorem2.py

@@ -1,4 +1,5 @@
 from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -21,8 +22,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
@@ -67,4 +67,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
     else:
         state.groupsOfFolds *= 2
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
     return state

mapFolding/syntheticModules/A007822/theorem2Numba.py

@@ -1,4 +1,7 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -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,29 @@ 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)
+
+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
+    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

mapFolding/syntheticModules/A007822/theorem2Trimmed.py

@@ -1,4 +1,5 @@
 from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -21,8 +22,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
@@ -61,4 +61,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
     else:
         state.groupsOfFolds *= 2
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    return state
+    return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
+    return state

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/dataPacking.py

@@ -21,6 +21,6 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     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)
+    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

mapFolding/syntheticModules/dataPackingA007822.py

@@ -1,26 +1,92 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
-from mapFolding.syntheticModules.A007822.theorem2Numba 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,52 @@
+from mapFolding.algorithms.matrixMeandersBeDry import (areIntegersWide,
+                                                       walkDyckPath)
+from mapFolding.dataBaskets import MatrixMeandersNumPyState
+
+
+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.
+	"""
+    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 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: 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
+                if arcCodeAnalysis < state.MAXIMUMarcCode:
+                    state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
+            if bitsZuluHasArcs:
+                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):
+                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
+        dictionaryArcCodeToCrossings = {}
+    return state