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

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -281,7 +281,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 	return ingredientsFunction
 
 @dataclasses.dataclass
-class SpicesJobNumba:
+class SpicesJobNumba: # slots?
 	"""Configuration container for Numba-specific job processing options.
 
 	(AI generated docstring)

mapFolding/someAssemblyRequired/transformationTools.py

@@ -79,10 +79,10 @@ def shatter_dataclassesDOTdataclass(logicalPathDataclass: identifierDotAttribute
 
 	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(logicalPathDataclass), identifierDataclass)
 	if not dataclassClassDef:
-		message = f"I could not find `{identifierDataclass = }` in `{logicalPathDataclass = }`."
+		message: str = f"I could not find `{identifierDataclass = }` in `{logicalPathDataclass = }`."
 		raise ValueError(message)
 
-	countingVariable = None
+	countingVariable: str | None = None
 	for aField in dataclasses.fields(importLogicalPath2Identifier(logicalPathDataclass, identifierDataclass)): # pyright: ignore [reportArgumentType]
 		Official_fieldOrder.append(aField.name)
 		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathDataclass, dataclassClassDef, identifierDataclassInstance, aField)
@@ -99,6 +99,7 @@ def shatter_dataclassesDOTdataclass(logicalPathDataclass: identifierDotAttribute
 		Z0Z_field2AnnAssign={dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder},
 		list_argAnnotated4ArgumentsSpecification=[dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
 		list_keyword_field__field4init=[dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
+		listIdentifiersStaticScalars=[dictionaryDeReConstruction[field].name for field in Official_fieldOrder if (dictionaryDeReConstruction[field].Z0Z_hack[1] == 'scalar' and not dictionaryDeReConstruction[field].init)],
 		listAnnotations=[dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
 		listName4Parameters=[dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
 		listUnpack=[Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
@@ -145,12 +146,11 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 	"""
 	ingredientsTarget.astFunctionDef.args = Make.arguments(list_arg=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
-	changeReturnCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
-	changeReturnCallable.visit(ingredientsTarget.astFunctionDef)
+	NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters))).visit(ingredientsTarget.astFunctionDef)
 	ingredientsTarget.astFunctionDef = unparseFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 	return ingredientsTarget
 
-def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: str, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
+def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, identifierCallee: str, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	"""Transform a caller function to interface with a dataclass-free target function.
 
 	(AI generated docstring)
@@ -184,12 +184,10 @@ def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFun
 		The modified caller function with appropriate unpacking and repacking around the target call.
 
 	"""
-	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
-	replaceAssignTargetCallable = NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
-	unpack4targetCallable = NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-	repack4targetCallable = NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
-	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
-	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
-	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
+	AssignAndCall: ast.Assign = Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=Make.Call(Make.Name(identifierCallee), shatteredDataclass.listName4Parameters))
+	NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallee)), Then.replaceWith(AssignAndCall)).visit(ingredientsCaller.astFunctionDef)
+	NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallee)), Then.insertThisAbove(shatteredDataclass.listUnpack)).visit(ingredientsCaller.astFunctionDef)
+	NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallee)), Then.insertThisBelow([shatteredDataclass.repack])).visit(ingredientsCaller.astFunctionDef)
 	return ingredientsCaller
 
+

mapFolding/syntheticModules/A007822/algorithm.py

@@ -1,77 +1,72 @@
-from mapFolding.dataBaskets import MapFoldingState
+import numpy
 
+from mapFolding.dataBaskets import SymmetricFoldsState
 
-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:
+
+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
@@ -79,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]]
@@ -89,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):
@@ -161,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,58 +1,115 @@
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.syntheticModules.A007822.asynchronousAnnex import (
-    filterAsymmetricFolds, getSymmetricFoldsTotal,
-    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
@@ -60,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]]
@@ -70,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):
@@ -144,7 +201,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState, maxWorkers: int | None=None) -> MapFoldingState:
+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,29 +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]
@@ -69,7 +63,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
     state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
     return state