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

mapFolding/syntheticModules/A007822/algorithm.py

@@ -1,76 +1,72 @@
-from mapFolding.dataBaskets import MapFoldingState
+import numpy
 
-def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
-    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
-    return state
-
-def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+from mapFolding.dataBaskets import SymmetricFoldsState
+
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    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()
+    return state
+
+def activeLeafGreaterThan0(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0
 
-def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+def activeLeafGreaterThanLeavesTotal(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > state.leavesTotal
 
-def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+def activeLeafIsTheFirstLeaf(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex <= 1
 
-def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+def activeLeafIsUnconstrainedInAllDimensions(state: SymmetricFoldsState) -> bool:
     return not state.dimensionsUnconstrained
 
-def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+def activeLeafUnconstrainedInThisDimension(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.dimensionsUnconstrained -= 1
     return state
 
-def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+def filterCommonGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
     if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
         state = incrementActiveGap(state)
     state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
     return state
 
-def gapAvailable(state: MapFoldingState) -> bool:
+def gapAvailable(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0
 
-def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+def incrementActiveGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndex += 1
     return state
 
-def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+def incrementGap1ndexCeiling(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndexCeiling += 1
     return state
 
-def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+def incrementIndexMiniGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexMiniGap += 1
     return state
 
-def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+def initializeIndexMiniGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexMiniGap = state.gap1ndex
     return state
 
-def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+def initializeVariablesToFindGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.dimensionsUnconstrained = state.dimensionsTotal
     state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
     state.indexDimension = 0
     return state
 
-def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+def insertActiveLeaf(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexLeaf = 0
     while state.indexLeaf < state.leaf1ndex:
         state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
@@ -78,7 +74,7 @@ def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
         state.indexLeaf += 1
     return state
 
-def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+def insertActiveLeafAtGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndex -= 1
     state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
     state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
@@ -88,50 +84,50 @@ def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
     state.leaf1ndex += 1
     return state
 
-def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+def leafBelowSentinelIs1(state: SymmetricFoldsState) -> bool:
     return state.leafBelow[0] == 1
 
-def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+def leafConnecteeIsActiveLeaf(state: SymmetricFoldsState) -> bool:
     return state.leafConnectee == state.leaf1ndex
 
-def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+def lookForGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
     if state.countDimensionsGapped[state.leafConnectee] == 0:
         state = incrementGap1ndexCeiling(state)
     state.countDimensionsGapped[state.leafConnectee] += 1
     return state
 
-def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+def lookupLeafConnecteeInConnectionGraph(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
     return state
 
-def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+def loopingLeavesConnectedToActiveLeaf(state: SymmetricFoldsState) -> bool:
     return state.leafConnectee != state.leaf1ndex
 
-def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+def loopingThroughTheDimensions(state: SymmetricFoldsState) -> bool:
     return state.indexDimension < state.dimensionsTotal
 
-def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+def loopingToActiveGapCeiling(state: SymmetricFoldsState) -> bool:
     return state.indexMiniGap < state.gap1ndexCeiling
 
-def noGapsHere(state: MapFoldingState) -> bool:
+def noGapsHere(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]
 
-def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+def tryAnotherLeafConnectee(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
     return state
 
-def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+def tryNextDimension(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexDimension += 1
     return state
 
-def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+def undoLastLeafPlacement(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leaf1ndex -= 1
     state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
     state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
     return state
 
-def count(state: MapFoldingState) -> MapFoldingState:
+def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while activeLeafGreaterThan0(state):
         if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
             if activeLeafGreaterThanLeavesTotal(state):
@@ -160,6 +156,6 @@ def count(state: MapFoldingState) -> MapFoldingState:
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = count(state)
     return state

mapFolding/syntheticModules/A007822/asynchronous.py

@@ -1,56 +1,115 @@
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.syntheticModules.A007822.asynchronousAnnex import (
-	filterAsymmetricFolds, getAsymmetricFoldsTotal, initializeConcurrencyManager)
-
-def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+from copy import deepcopy
+from queue import Queue
+from threading import Lock, Thread
+
+import numpy
+
+from mapFolding import DatatypeFoldsTotal
+from mapFolding.dataBaskets import SymmetricFoldsState
+
+listThreads: list[Thread] = []
+queueFutures: Queue[SymmetricFoldsState] = Queue()
+symmetricFoldsTotal: int = 0
+LOCKsymmetricFoldsTotal = Lock()
+STOPsignal = object()
+
+def initializeConcurrencyManager(maxWorkers: int, symmetricFolds: int=0) -> None:
+    global listThreads, symmetricFoldsTotal, queueFutures
+    listThreads = []
+    queueFutures = Queue()
+    symmetricFoldsTotal = symmetricFolds
+    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 symmetricFoldsTotal
+    while True:
+        state = queueFutures.get()
+        if state is STOPsignal:
+            break
+        state = _filterAsymmetricFolds(state)
+        with LOCKsymmetricFoldsTotal:
+            symmetricFoldsTotal += state.groupsOfFolds
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
+    queueFutures.put_nowait(deepcopy(state))
+
+def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
+    for _thread in listThreads:
+        queueFutures.put(STOPsignal)
+    for thread in listThreads:
+        thread.join()
+    return symmetricFoldsTotal
+
+def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    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)
+    state.indexMiniGap = 0
+    while state.indexMiniGap < len(state.arrayGroupOfFolds):
+        state.groupsOfFolds += int(numpy.all(numpy.equal(state.arrayGroupOfFolds[state.indexMiniGap, slice(0, state.leavesTotal // 2)], state.arrayGroupOfFolds[state.indexMiniGap, slice(state.leavesTotal // 2, None)])))
+        state.indexMiniGap += 1
+    return state
+
+def activeLeafGreaterThan0(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0
 
-def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+def activeLeafGreaterThanLeavesTotal(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > state.leavesTotal
 
-def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+def activeLeafIsTheFirstLeaf(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex <= 1
 
-def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+def activeLeafIsUnconstrainedInAllDimensions(state: SymmetricFoldsState) -> bool:
     return not state.dimensionsUnconstrained
 
-def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+def activeLeafUnconstrainedInThisDimension(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.dimensionsUnconstrained -= 1
     return state
 
-def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+def filterCommonGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
     if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
         state = incrementActiveGap(state)
     state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
     return state
 
-def gapAvailable(state: MapFoldingState) -> bool:
+def gapAvailable(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0
 
-def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+def incrementActiveGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndex += 1
     return state
 
-def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+def incrementGap1ndexCeiling(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndexCeiling += 1
     return state
 
-def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+def incrementIndexMiniGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexMiniGap += 1
     return state
 
-def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+def initializeIndexMiniGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexMiniGap = state.gap1ndex
     return state
 
-def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+def initializeVariablesToFindGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.dimensionsUnconstrained = state.dimensionsTotal
     state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
     state.indexDimension = 0
     return state
 
-def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+def insertActiveLeaf(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexLeaf = 0
     while state.indexLeaf < state.leaf1ndex:
         state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
@@ -58,7 +117,7 @@ def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
         state.indexLeaf += 1
     return state
 
-def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+def insertActiveLeafAtGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndex -= 1
     state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
     state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
@@ -68,54 +127,54 @@ def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
     state.leaf1ndex += 1
     return state
 
-def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+def leafBelowSentinelIs1(state: SymmetricFoldsState) -> bool:
     return state.leafBelow[0] == 1
 
-def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+def leafConnecteeIsActiveLeaf(state: SymmetricFoldsState) -> bool:
     return state.leafConnectee == state.leaf1ndex
 
-def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+def lookForGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
     if state.countDimensionsGapped[state.leafConnectee] == 0:
         state = incrementGap1ndexCeiling(state)
     state.countDimensionsGapped[state.leafConnectee] += 1
     return state
 
-def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+def lookupLeafConnecteeInConnectionGraph(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
     return state
 
-def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+def loopingLeavesConnectedToActiveLeaf(state: SymmetricFoldsState) -> bool:
     return state.leafConnectee != state.leaf1ndex
 
-def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+def loopingThroughTheDimensions(state: SymmetricFoldsState) -> bool:
     return state.indexDimension < state.dimensionsTotal
 
-def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+def loopingToActiveGapCeiling(state: SymmetricFoldsState) -> bool:
     return state.indexMiniGap < state.gap1ndexCeiling
 
-def noGapsHere(state: MapFoldingState) -> bool:
+def noGapsHere(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]
 
-def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+def tryAnotherLeafConnectee(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
     return state
 
-def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+def tryNextDimension(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexDimension += 1
     return state
 
-def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+def undoLastLeafPlacement(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leaf1ndex -= 1
     state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
     state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
     return state
 
-def count(state: MapFoldingState) -> MapFoldingState:
+def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while activeLeafGreaterThan0(state):
         if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
             if activeLeafGreaterThanLeavesTotal(state):
-                filterAsymmetricFolds(state.leafBelow)
+                filterAsymmetricFolds(state)
             else:
                 state = initializeVariablesToFindGaps(state)
                 while loopingThroughTheDimensions(state):
@@ -138,11 +197,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: SymmetricFoldsState, maxWorkers: int) -> SymmetricFoldsState:
+    initializeConcurrencyManager(maxWorkers)
     state = count(state)
     return state

mapFolding/syntheticModules/A007822/initializeState.py

@@ -1,28 +1,22 @@
-from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.dataBaskets import SymmetricFoldsState
+import numpy
 
-def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
+def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.groupsOfFolds == 0:
         if state.leaf1ndex <= 1 or 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]

mapFolding/syntheticModules/A007822/theorem2.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]
@@ -66,4 +61,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/A007822/theorem2Numba.py

@@ -1,33 +1,25 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
-from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclassA007822
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, SymmetricFoldsState
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 from numba import jit
+import numpy
 
-@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]:
+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, arrayGroupOfFolds: Array2DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, indicesArrayGroupOfFolds: Array2DLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, Array2DLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 4:
         if leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
-                indexLeaf = 0
-                leafConnectee = 0
+                indexLeaf = 1
+                leafComparison[0] = 1
+                leafConnectee = 1
                 while leafConnectee < leavesTotal + 1:
-                    leafNumber = int(leafBelow[indexLeaf])
-                    leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
-                    indexLeaf = leafNumber
+                    indexMiniGap = leafBelow[indexLeaf]
+                    leafComparison[leafConnectee] = (indexMiniGap - indexLeaf + leavesTotal) % leavesTotal
+                    indexLeaf = indexMiniGap
                     leafConnectee += 1
-                indexInMiddle = leavesTotal // 2
-                indexMiniGap = 0
-                while indexMiniGap < leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
-                            ImaSymmetricFold = False
-                            break
-                        leafConnectee += 1
-                    groupsOfFolds += ImaSymmetricFold
-                    indexMiniGap += 1
+                arrayGroupOfFolds = numpy.take(leafComparison, indicesArrayGroupOfFolds)
+                compared = arrayGroupOfFolds[..., 0:leavesTotal // 2] == arrayGroupOfFolds[..., leavesTotal // 2:None]
+                for indexRow in range(len(compared)):
+                    groupsOfFolds += compared[indexRow].all()
             else:
                 dimensionsUnconstrained = dimensionsTotal
                 gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
@@ -65,4 +57,31 @@ 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, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal)
+
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    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
+    arrayGroupOfFolds: Array2DLeavesTotal = state.arrayGroupOfFolds
+    connectionGraph: Array3DLeavesTotal = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    indicesArrayGroupOfFolds: Array2DLeavesTotal = state.indicesArrayGroupOfFolds
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal)
+    state = SymmetricFoldsState(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