mapFolding 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

mapFolding/theDao.py

@@ -1,243 +0,0 @@
-"""
-Core computational algorithm for map folding counting and enumeration.
-
-This module implements the core algorithms for enumerating and counting the various ways a rectangular map can be
-folded. It uses a functional state-transformation approach, where each function performs a specific state mutation and
-returns the updated state. The module provides three main counting algorithms:
-
-1. `countInitialize`: Sets up the initial state for computation.
-2. `countSequential`: Processes the folding computation sequentially.
-3. `countParallel`: Distributes the computation across multiple processes.
-
-All algorithms operate on a `ComputationState` object that tracks the folding process, including:
-- A "leaf" is a unit square in the map.
-- A "gap" is a potential position where a new leaf can be folded.
-- Connections track how leaves can connect above/below each other.
-- Leaves are enumerated starting from 1, not 0; hence, `leaf1ndex` not `leafIndex`.
-
-The `doTheNeedful` function is the main entry point that orchestrates the computation strategy based on task divisions and
-concurrency parameters.
-"""
-from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
-from copy import deepcopy
-from mapFolding.theSSOT import ComputationState
-from multiprocessing import set_start_method as multiprocessing_set_start_method
-
-# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
-if __name__ == '__main__':
-	multiprocessing_set_start_method('spawn')
-
-def activeLeafConnectedToItself(state: ComputationState) -> bool:
-	return state.leafConnectee == state.leaf1ndex
-
-def activeLeafGreaterThan0(state: ComputationState) -> bool:
-	return state.leaf1ndex > 0
-
-def activeLeafGreaterThanLeavesTotal(state: ComputationState) -> bool:
-	return state.leaf1ndex > state.leavesTotal
-
-def activeLeafIsTheFirstLeaf(state: ComputationState) -> bool:
-	return state.leaf1ndex <= 1
-
-def allDimensionsAreUnconstrained(state: ComputationState) -> bool:
-	return not state.dimensionsUnconstrained
-
-def countGaps(state: ComputationState) -> ComputationState:
-	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
-	if state.countDimensionsGapped[state.leafConnectee] == 0:
-		state = incrementGap1ndexCeiling(state)
-	state.countDimensionsGapped[state.leafConnectee] += 1
-	return state
-
-def decrementDimensionsUnconstrained(state: ComputationState) -> ComputationState:
-	state.dimensionsUnconstrained -= 1
-	return state
-
-def dimensionsUnconstrainedCondition(state: ComputationState) -> bool:
-	return state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex] == state.leaf1ndex
-
-def filterCommonGaps(state: ComputationState) -> ComputationState:
-	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 incrementActiveGap(state: ComputationState) -> ComputationState:
-	state.gap1ndex += 1
-	return state
-
-def incrementGap1ndexCeiling(state: ComputationState) -> ComputationState:
-	state.gap1ndexCeiling += 1
-	return state
-
-def incrementIndexDimension(state: ComputationState) -> ComputationState:
-	state.indexDimension += 1
-	return state
-
-def incrementIndexMiniGap(state: ComputationState) -> ComputationState:
-	state.indexMiniGap += 1
-	return state
-
-def initializeIndexMiniGap(state: ComputationState) -> ComputationState:
-	state.indexMiniGap = state.gap1ndex
-	return state
-
-def initializeLeafConnectee(state: ComputationState) -> ComputationState:
-	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
-	return state
-
-def initializeVariablesToFindGaps(state: ComputationState) -> ComputationState:
-	state.dimensionsUnconstrained = state.dimensionsTotal
-	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
-	state.indexDimension = 0
-	return state
-
-def insertLeafAtGap(state: ComputationState) -> ComputationState:
-	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
-	return state
-
-def insertUnconstrainedLeaf(state: ComputationState) -> ComputationState:
-	state.indexLeaf = 0
-	while state.indexLeaf < state.leaf1ndex:
-		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
-		state.gap1ndexCeiling += 1
-		state.indexLeaf += 1
-	return state
-
-def leafBelowSentinelIs1(state: ComputationState) -> bool:
-	return state.leafBelow[0] == 1
-
-def loopingLeavesConnectedToActiveLeaf(state: ComputationState) -> bool:
-	return state.leafConnectee != state.leaf1ndex
-
-def loopingToActiveGapCeiling(state: ComputationState) -> bool:
-	return state.indexMiniGap < state.gap1ndexCeiling
-
-def loopUpToDimensionsTotal(state: ComputationState) -> bool:
-	return state.indexDimension < state.dimensionsTotal
-
-def noGapsHere(state: ComputationState) -> bool:
-	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
-
-def thereIsAnActiveLeaf(state: ComputationState) -> bool:
-	return state.leaf1ndex > 0
-
-def thisIsMyTaskIndex(state: ComputationState) -> bool:
-	return (state.leaf1ndex != state.taskDivisions) or (state.leafConnectee % state.taskDivisions == state.taskIndex)
-
-def undoLastLeafPlacement(state: ComputationState) -> ComputationState:
-	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 updateLeafConnectee(state: ComputationState) -> ComputationState:
-	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
-	return state
-
-def countInitialize(state: ComputationState) -> ComputationState:
-	while state.gap1ndex == 0:
-		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
-				state = initializeVariablesToFindGaps(state)
-				while loopUpToDimensionsTotal(state):
-					state = initializeLeafConnectee(state)
-					if activeLeafConnectedToItself(state):
-						state = decrementDimensionsUnconstrained(state)
-					else:
-						while loopingLeavesConnectedToActiveLeaf(state):
-							state = countGaps(state)
-							state = updateLeafConnectee(state)
-					state = incrementIndexDimension(state)
-				if allDimensionsAreUnconstrained(state):
-					state = insertUnconstrainedLeaf(state)
-				state = initializeIndexMiniGap(state)
-				while loopingToActiveGapCeiling(state):
-					state = filterCommonGaps(state)
-					state = incrementIndexMiniGap(state)
-		if thereIsAnActiveLeaf(state):
-			state = insertLeafAtGap(state)
-	return state
-
-def countParallel(state: ComputationState) -> ComputationState:
-	while activeLeafGreaterThan0(state):
-		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
-			if activeLeafGreaterThanLeavesTotal(state):
-				state.groupsOfFolds += 1
-			else:
-				state = initializeVariablesToFindGaps(state)
-				while loopUpToDimensionsTotal(state):
-					if dimensionsUnconstrainedCondition(state):
-						state = decrementDimensionsUnconstrained(state)
-					else:
-						state = initializeLeafConnectee(state)
-						while loopingLeavesConnectedToActiveLeaf(state):
-							if thisIsMyTaskIndex(state):
-								state = countGaps(state)
-							state = updateLeafConnectee(state)
-					state = incrementIndexDimension(state)
-				state = initializeIndexMiniGap(state)
-				while loopingToActiveGapCeiling(state):
-					state = filterCommonGaps(state)
-					state = incrementIndexMiniGap(state)
-		while noGapsHere(state):
-			state = undoLastLeafPlacement(state)
-		if thereIsAnActiveLeaf(state):
-			state = insertLeafAtGap(state)
-	state.foldGroups[state.taskIndex] = state.groupsOfFolds
-	return state
-
-def countSequential(state: ComputationState) -> ComputationState:
-	while activeLeafGreaterThan0(state):
-		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
-			if activeLeafGreaterThanLeavesTotal(state):
-				state.groupsOfFolds += 1
-			else:
-				state = initializeVariablesToFindGaps(state)
-				while loopUpToDimensionsTotal(state):
-					state = initializeLeafConnectee(state)
-					if activeLeafConnectedToItself(state):
-						state = decrementDimensionsUnconstrained(state)
-					else:
-						while loopingLeavesConnectedToActiveLeaf(state):
-							state = countGaps(state)
-							state = updateLeafConnectee(state)
-					state = incrementIndexDimension(state)
-				state = initializeIndexMiniGap(state)
-				while loopingToActiveGapCeiling(state):
-					state = filterCommonGaps(state)
-					state = incrementIndexMiniGap(state)
-		while noGapsHere(state):
-			state = undoLastLeafPlacement(state)
-		if state.leaf1ndex == 3 and state.groupsOfFolds:
-			state.groupsOfFolds *= 2
-			# print('break')
-			break
-		if thereIsAnActiveLeaf(state):
-			state = insertLeafAtGap(state)
-	state.foldGroups[state.taskIndex] = state.groupsOfFolds
-	return state
-
-def doTheNeedful(state: ComputationState) -> ComputationState:
-	state = countInitialize(state)
-	if state.taskDivisions > 0:
-		dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
-		stateParallel = deepcopy(state)
-		with ProcessPoolExecutor(stateParallel.concurrencyLimit) as concurrencyManager:
-			for indexSherpa in range(stateParallel.taskDivisions):
-				state = deepcopy(stateParallel)
-				state.taskIndex = indexSherpa
-				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, state)
-			for indexSherpa in range(stateParallel.taskDivisions):
-				stateParallel.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
-		state = stateParallel
-	else:
-		state = countSequential(state)
-
-	return state

mapfolding-0.11.1.dist-info/RECORD

@@ -1,54 +0,0 @@
-mapFolding/__init__.py,sha256=P2guQYFN19PSAl8yd9NQjIapMvZnZlasPOvKJ1KUGvA,4883
-mapFolding/basecamp.py,sha256=hs7hlTmbX7KTjI_eIRVU4xn7HR4l448SIpHk1cKDwRk,8071
-mapFolding/beDRY.py,sha256=JQ7T9v4aKzweGjvpzyghyq4N9l3Wf9HZco_K_DWoiW0,15368
-mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
-mapFolding/dataBaskets.py,sha256=80ALoRqaOfNEgz8QTdDJPsyVBnm8MkWLtRHD3DPPoRw,5073
-mapFolding/datatypes.py,sha256=-TdXqAlEWEwUP_VUb9-X5pvaBBedbZOQbBuu5j1ZoTA,962
-mapFolding/oeis.py,sha256=zHk5Mygd7qpDj1NYXsvY_l3e8jg3tHDQ1Cpt6NrWiuc,17019
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=kc3rzTX3yts0PxgPCXFbgWvaqsBexsiU5ib2pzpvID0,10019
-mapFolding/theSSOT.py,sha256=rbv8esQeBG6uLWpFZu_ncMA4zIuQG3lj4FZNzC_6JGI,16138
-mapFolding/toolboxFilesystem.py,sha256=kVZoU-NBvfYSvI4R8mEpMXRUZee-1JV0fjtMFWPhk8Y,9818
-mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,2206
-mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
-mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
-mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
-mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
-mapFolding/reference/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
-mapFolding/reference/lunnonWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
-mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
-mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
-mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
-mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
-mapFolding/someAssemblyRequired/RecipeJob.py,sha256=6RD4F4Yde7K-Rz0F4IokQ62BVzRSx4vCCYY4H-Dfug4,10190
-mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py,sha256=Ss9YlFAAodsydiYWz9TrcTneeYn_IUR2iQfEPjFf3IY,15805
-mapFolding/someAssemblyRequired/__init__.py,sha256=p2mbSsdEefBu0Hnwuis91cnSr0i49ZV9_bhfncGLxls,3571
-mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=Ey6byfbpzRmgrnuOVIA9M068Lo7S1Jk6wzNgBMPci3A,3140
-mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=DZDFfCcRsCY0wFlkoZ9l8Ozw7bsT5OA3qMcG2KnABGI,16003
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
-mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=zZFfHhNG0VWaCigeHID-eAWQBRbYmo_59JycdstxJTc,13784
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=4ZwOQA4FWrILYe5eiawTZgeTiJ7RRUUCpI0Th5Mezso,15668
-mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=LZdosArlkNzFUwy8BMhswivW5xfhREAPyx2ApNOuse8,8961
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=o4gORDvDuTnTPofeDLwfZItW5MFJljNcHagVprJeBU4,18966
-mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
-mapFolding/syntheticModules/daoOfMapFolding.py,sha256=cfWPABtXyCxJ0BwPI7rhfLh_2UYV_XKAL8lJ4GLNXaQ,5896
-mapFolding/syntheticModules/dataPacking.py,sha256=J4WLJzQTOAm2d8itzWWSixTUcCGQl4KuEfqrzkb2tJQ,2294
-mapFolding/syntheticModules/initializeCount.py,sha256=nWSlJMMfIM3DvZxMn6ISQusUJqRYAjKQyLF5hwLEdBQ,3119
-mapFolding/syntheticModules/numbaCount.py,sha256=zM-bp07c9tEDdvidwzZ_bJTd0JC0VUkYEEiHG--P1tQ,15525
-mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
-mapFolding/syntheticModules/theorem2Numba.py,sha256=-cKjNyxgUMFhEyFVs0VJ7hw4LfrV0WSNK5tPYbQ1oNU,3369
-mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
-mapfolding-0.11.1.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=5VhHf0JJ2_DSh58zJ0rR5UkpoCon-0IkdljspTCzZ04,1950
-tests/conftest.py,sha256=x8zMZQyTss3sn0GwHm_TSRwD9_LVlR8l_qF8r43Vxl4,14178
-tests/test_computations.py,sha256=5sg1PpSp6aeOrXZeO5NwWK5ipPAe49wVKC2J7yT5MFg,6524
-tests/test_filesystem.py,sha256=T2DkjBoI3lW6tCxd5BilPmUFrVukNKLjOOZVZxLM560,3004
-tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
-tests/test_other.py,sha256=UMlK4JPInalpOZuPvTnUrgXWCJOxAw-OsPs6CxMR254,3753
-tests/test_tasks.py,sha256=tOQc4uomKXGwWnENfbcThaVa1XofwXNCkGZbg4yS6VI,2833
-mapfolding-0.11.1.dist-info/METADATA,sha256=z1Z2MfDiXFSxbortwiHbjCex9X3zD9RvC7qWYs4l50g,7560
-mapfolding-0.11.1.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-mapfolding-0.11.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.11.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.11.1.dist-info/RECORD,,