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

mapFolding/reference/meandersDumpingGround/matrixMeandersSimpleQueue.py

@@ -1,90 +0,0 @@
-from mapFolding._oeisFormulas.matrixMeandersAnnex import curveMaximum as curveMaximum
-from queue import Empty, SimpleQueue
-from typing import NamedTuple
-import contextlib
-
-class BifurcatedCurves(NamedTuple):
-    bifurcationZulu: int
-    bifurcationAlpha: int
-    distinctCrossings: int
-    curveLocationsMAXIMUM: int
-
-dictionaryCurveLocations: dict[int, int] = {}
-simpleQueueCurveLocations: SimpleQueue[tuple[int, int]] = SimpleQueue()
-
-def unpackQueue() -> dict[int, int]:
-	with contextlib.suppress(Empty):
-		while True:
-			curveLocations, distinctCrossings = simpleQueueCurveLocations.get_nowait()
-			dictionaryCurveLocations[curveLocations] = dictionaryCurveLocations.get(curveLocations, 0) + distinctCrossings
-
-	return dictionaryCurveLocations
-
-def getCurveLocations(bridges: int) -> list[BifurcatedCurves]:
-	global dictionaryCurveLocations  # noqa: PLW0603
-	dictionaryCurveLocations = unpackQueue()
-	curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = curveMaximum[bridges]
-	listBifurcatedCurves: list[BifurcatedCurves] = []
-	# TODO This is ready for concurrency and/or vectorization.
-	for curveLocations, distinctCrossings in dictionaryCurveLocations.items():
-		bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
-		bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
-		listBifurcatedCurves.append(BifurcatedCurves(bifurcationZulu, bifurcationAlpha, distinctCrossings, curveLocationsMAXIMUM))
-	dictionaryCurveLocations = {}
-	return listBifurcatedCurves
-
-def recordAnalysis(curveLocationAnalysis: int, curveLocationsMAXIMUM: int, distinctCrossings: int) -> None:
-	if curveLocationAnalysis < curveLocationsMAXIMUM:
-		simpleQueueCurveLocations.put((curveLocationAnalysis, distinctCrossings))
-
-def analyzeCurve(bifurcationZulu: int, bifurcationAlpha: int, distinctCrossings: int, curveLocationsMAXIMUM: int) -> None:
-	bifurcationZuluFinalZero = (bifurcationZulu & 0b1) == 0
-	bifurcationZuluHasCurves = bifurcationZulu != 1
-	bifurcationAlphaFinalZero = (bifurcationAlpha & 0b1) == 0
-	bifurcationAlphaHasCurves = bifurcationAlpha != 1
-
-	if bifurcationZuluHasCurves:
-		curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
-		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-	if bifurcationAlphaHasCurves:
-		curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
-		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-	curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
-	recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-	if bifurcationZuluHasCurves and bifurcationAlphaHasCurves and (bifurcationZuluFinalZero or bifurcationAlphaFinalZero):
-		XOrHere2makePair = 0b1
-		findUnpairedBinary1 = 0
-
-		if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
-			while findUnpairedBinary1 >= 0:
-				XOrHere2makePair <<= 2
-				findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
-			bifurcationZulu ^= XOrHere2makePair
-
-		elif bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
-			while findUnpairedBinary1 >= 0:
-				XOrHere2makePair <<= 2
-				findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
-			bifurcationAlpha ^= XOrHere2makePair
-
-		curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
-		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
-
-def initializeCurveLocations(startingCurveLocations: dict[int, int]) -> None:
-	global dictionaryCurveLocations  # noqa: PLW0603
-	dictionaryCurveLocations = startingCurveLocations.copy()
-
-def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
-	initializeCurveLocations(startingCurveLocations)
-
-	while bridges > 0:
-		bridges -= 1
-
-		# TODO This could be parallelized when `recordAnalysis` is thread-safe
-		for bifurcatedCurve in getCurveLocations(bridges):
-			analyzeCurve(*bifurcatedCurve)
-
-	return getCurveLocations(bridges)[0].distinctCrossings

mapFolding/syntheticModules/A007822/algorithmNumba.py

@@ -1,94 +0,0 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
-from numba import jit
-
-@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
-def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > leavesTotal:
-                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
-                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
-            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
-                if not dimensionsUnconstrained:
-                    indexLeaf = 0
-                    while indexLeaf < leaf1ndex:
-                        gapsWhere[gap1ndexCeiling] = indexLeaf
-                        gap1ndexCeiling += 1
-                        indexLeaf += 1
-                indexMiniGap = gap1ndex
-                while indexMiniGap < gap1ndexCeiling:
-                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                        gap1ndex += 1
-                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                    indexMiniGap += 1
-        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex > 0:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    groupsOfFolds = (groupsOfFolds + 1) // 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
-
-def doTheNeedful(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

mapFolding/syntheticModules/A007822/asynchronousAnnex.py

@@ -1,66 +0,0 @@
-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
-queueFutures: Queue[ConcurrentFuture[int]] = Queue()
-
-def initializeConcurrencyManager(maxWorkers: int | None=None, groupsOfFolds: int=0) -> None:
-    global concurrencyManager, queueFutures, groupsOfFoldsTotal, processingThread
-    concurrencyManager = ThreadPoolExecutor(max_workers=maxWorkers)
-    queueFutures = Queue()
-    groupsOfFoldsTotal = groupsOfFolds
-    processingThread = Thread(target=_processCompletedFutures)
-    processingThread.start()
-
-def _processCompletedFutures() -> None:
-    global queueFutures, groupsOfFoldsTotal
-    while True:
-        try:
-            claimTicket: ConcurrentFuture[int] = queueFutures.get(timeout=1)
-            if claimTicket is None:
-                break
-            groupsOfFoldsTotal += claimTicket.result()
-        except Empty:
-            continue
-
-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:
-    global concurrencyManager, queueFutures
-    queueFutures.put_nowait(raiseIfNone(concurrencyManager).submit(_filterAsymmetricFolds, leafBelow.copy()))
-
-def getSymmetricFoldsTotal() -> int:
-    global concurrencyManager, queueFutures, processingThread
-    raiseIfNone(concurrencyManager).shutdown(wait=True)
-    queueFutures.put(None)
-    raiseIfNone(processingThread).join()
-    return groupsOfFoldsTotal

mapFolding/syntheticModules/A007822/asynchronousAnnexNumba.py

@@ -1,70 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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,65 +0,0 @@
-from mapFolding.dataBaskets import MapFoldingState
-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:
-        if state.leafBelow[0] == 1:
-            if state.leaf1ndex > state.leavesTotal:
-                filterAsymmetricFolds(state.leafBelow)
-            else:
-                state.dimensionsUnconstrained = state.dimensionsTotal
-                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
-                state.indexDimension = 0
-                while state.indexDimension < state.dimensionsTotal:
-                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
-                    if state.leafConnectee == state.leaf1ndex:
-                        state.dimensionsUnconstrained -= 1
-                    else:
-                        while state.leafConnectee != state.leaf1ndex:
-                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
-                            if state.countDimensionsGapped[state.leafConnectee] == 0:
-                                state.gap1ndexCeiling += 1
-                            state.countDimensionsGapped[state.leafConnectee] += 1
-                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
-                    state.indexDimension += 1
-                if not state.dimensionsUnconstrained:
-                    state.indexLeaf = 0
-                    while state.indexLeaf < state.leaf1ndex:
-                        state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
-                        state.gap1ndexCeiling += 1
-                        state.indexLeaf += 1
-                state.indexMiniGap = state.gap1ndex
-                while state.indexMiniGap < state.gap1ndexCeiling:
-                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
-                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
-                        state.gap1ndex += 1
-                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
-                    state.indexMiniGap += 1
-        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
-            state.leaf1ndex -= 1
-            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
-            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
-        state.gap1ndex -= 1
-        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
-        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
-        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
-        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
-        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
-        state.leaf1ndex += 1
-    else:
-        state.groupsOfFolds = getSymmetricFoldsTotal()
-        state.groupsOfFolds *= 2
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    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,56 +0,0 @@
-from mapFolding.dataBaskets import MapFoldingState
-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:
-        if state.leafBelow[0] == 1:
-            if state.leaf1ndex > state.leavesTotal:
-                filterAsymmetricFolds(state.leafBelow)
-            else:
-                state.dimensionsUnconstrained = state.dimensionsTotal
-                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
-                state.indexDimension = 0
-                while state.indexDimension < state.dimensionsTotal:
-                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
-                    if state.leafConnectee == state.leaf1ndex:
-                        state.dimensionsUnconstrained -= 1
-                    else:
-                        while state.leafConnectee != state.leaf1ndex:
-                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
-                            if state.countDimensionsGapped[state.leafConnectee] == 0:
-                                state.gap1ndexCeiling += 1
-                            state.countDimensionsGapped[state.leafConnectee] += 1
-                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
-                    state.indexDimension += 1
-                state.indexMiniGap = state.gap1ndex
-                while state.indexMiniGap < state.gap1ndexCeiling:
-                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
-                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
-                        state.gap1ndex += 1
-                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
-                    state.indexMiniGap += 1
-        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
-            state.leaf1ndex -= 1
-            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
-            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
-        state.gap1ndex -= 1
-        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
-        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
-        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
-        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
-        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
-        state.leaf1ndex += 1
-    else:
-        state.groupsOfFolds = getSymmetricFoldsTotal()
-        state.groupsOfFolds *= 2
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    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/dataPacking.py

@@ -1,26 +0,0 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
-from mapFolding.syntheticModules.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, 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,92 +0,0 @@
-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