mapFolding 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

mapFolding/syntheticModules/multiprocessingCount_doTheNeedful.py

@@ -1,216 +0,0 @@
-from concurrent.futures import ProcessPoolExecutor
-from mapFolding.theSSOT import ComputationState
-import concurrent.futures
-import copy
-import multiprocessing
-
-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 backtrack(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 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 insertUnconstrainedLeaf(state: ComputationState) -> ComputationState:
-	indexLeaf = 0
-	while indexLeaf < state.leaf1ndex:
-		state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
-		state.gap1ndexCeiling += 1
-		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 placeLeaf(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 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 updateLeafConnectee(state: ComputationState) -> ComputationState:
-	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
-	return state
-
-def countInitialize(state: ComputationState) -> ComputationState:
-	while activeLeafGreaterThan0(state):
-		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 = placeLeaf(state)
-		if state.gap1ndex > 0:
-			break
-	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 = backtrack(state)
-		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(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 = backtrack(state)
-		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
-	state.foldGroups[state.taskIndex] = state.groupsOfFolds
-	return state
-
-def doTheNeedful(state: ComputationState) -> ComputationState:
-	state = countInitialize(state)
-	if state.taskDivisions > 0:
-		multiprocessing.set_start_method('spawn')
-		dictionaryConcurrency: dict[int, concurrent.futures.Future[ComputationState]] = {}
-		with ProcessPoolExecutor() as concurrencyManager:
-			for indexSherpa in range(state.taskDivisions):
-				stateParallel = copy.deepcopy(state)
-				stateParallel.taskIndex = indexSherpa
-				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, stateParallel)
-			for indexSherpa in range(state.taskDivisions):
-				state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
-		return state
-	else:
-		return countSequential(state)

mapFolding/syntheticModules/numbaCount.py

@@ -1,90 +0,0 @@
-from  import , , 
-from mapFolding.theSSOT import ComputationState, ComputationState, ComputationState
-import copy
-
-@(ComputationState(ComputationState), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(statePARALLEL: ComputationState) -> ComputationState:
-    stateComplete = copy.deepcopy(statePARALLEL)
-    for indexSherpa in range(statePARALLEL.taskDivisions):
-        state = copy.deepcopy(statePARALLEL)
-        state.taskIndex = indexSherpa
-        while state.leaf1ndex > 0:
-            if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
-                if state.leaf1ndex > state.leavesTotal:
-                    state.groupsOfFolds += 1
-                else:
-                    state = state
-                    while state.indexDimension < state.dimensionsTotal:
-                        if state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex] == state.leaf1ndex:
-                            state = state
-                        else:
-                            state = state
-                            while state.leafConnectee != state.leaf1ndex:
-                                if state.leaf1ndex != state.taskDivisions or state.leafConnectee % state.taskDivisions == state.taskIndex:
-                                    state = state
-                                state = state
-                        state = state
-                    state = state
-                    while state.indexMiniGap < state.gap1ndexCeiling:
-                        state = state
-                        state = state
-            while state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
-                state = state
-            if state.leaf1ndex > 0:
-                state = state
-        stateComplete.foldGroups[state.taskIndex] = state.groupsOfFolds
-    return stateComplete
-
-@(ComputationState(ComputationState), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(state: ComputationState) -> ComputationState:
-    while state.leaf1ndex > 0:
-        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
-            if state.leaf1ndex > state.leavesTotal:
-                state.groupsOfFolds += 1
-            else:
-                state = state
-                while state.indexDimension < state.dimensionsTotal:
-                    state = state
-                    if state.leafConnectee == state.leaf1ndex:
-                        state = state
-                    else:
-                        while state.leafConnectee != state.leaf1ndex:
-                            state = state
-                            state = state
-                    state = state
-                state = state
-                while state.indexMiniGap < state.gap1ndexCeiling:
-                    state = state
-                    state = state
-        while state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
-            state = state
-        if state.leaf1ndex > 0:
-            state = state
-    state.foldGroups[state.taskIndex] = state.groupsOfFolds
-    return state
-
-@(ComputationState(ComputationState), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def countInitialize(state: ComputationState) -> ComputationState:
-    while state.leaf1ndex > 0:
-        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
-            state = state
-            while state.indexDimension < state.dimensionsTotal:
-                state = state
-                if state.leafConnectee == state.leaf1ndex:
-                    state = state
-                else:
-                    while state.leafConnectee != state.leaf1ndex:
-                        state = state
-                        state = state
-                state = state
-            if not state.dimensionsUnconstrained:
-                state = state
-            state = state
-            while state.indexMiniGap < state.gap1ndexCeiling:
-                state = state
-                state = state
-        if state.leaf1ndex > 0:
-            state = state
-        if state.gap1ndex > 0:
-            break
-    return state

mapFolding/syntheticModules/numbaCountSequential.py

@@ -1,111 +0,0 @@
-from mapFolding.theDao import countInitialize, doTheNeedful
-from mapFolding.theSSOT import Array1DElephino, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
-from numba import jit
-
-@jit(_nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, nopython=True, parallel=False)
-def countSequential(
-	connectionGraph: Array3D,
-	countDimensionsGapped: Array1DLeavesTotal,
-	dimensionsTotal: DatatypeLeavesTotal,
-	dimensionsUnconstrained: DatatypeLeavesTotal,
-	gap1ndex: DatatypeLeavesTotal,
-	gap1ndexCeiling: DatatypeElephino,
-	gapRangeStart: Array1DElephino,
-	gapsWhere: Array1DLeavesTotal,
-	groupsOfFolds: DatatypeFoldsTotal,
-	indexDimension: DatatypeLeavesTotal,
-	indexMiniGap: DatatypeElephino,
-	leaf1ndex: DatatypeElephino,
-	leafAbove: Array1DLeavesTotal,
-	leafBelow: Array1DLeavesTotal,
-	leafConnectee: DatatypeElephino,
-	leavesTotal: DatatypeLeavesTotal,
-	) -> DatatypeFoldsTotal:
-
-	while leaf1ndex > 0:
-		if leaf1ndex <= 1 or leafBelow[0] == 1:
-			if leaf1ndex > leavesTotal:
-				groupsOfFolds += 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
-				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
-	return groupsOfFolds
-
-def flattenData(state: ComputationState) -> ComputationState:
-
-	if state.taskDivisions > 0:
-		return doTheNeedful(state)
-
-	state = countInitialize(state)
-
-	connectionGraph: Array3D = state.connectionGraph
-	countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
-	dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
-	dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
-	gap1ndex: DatatypeLeavesTotal = state.gap1ndex
-	gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
-	gapRangeStart: Array1DElephino = state.gapRangeStart
-	gapsWhere: Array1DLeavesTotal = state.gapsWhere
-	groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
-	indexDimension: DatatypeLeavesTotal = state.indexDimension
-	indexMiniGap: DatatypeElephino = state.indexMiniGap
-	leaf1ndex: DatatypeElephino = state.leaf1ndex
-	leafAbove: Array1DLeavesTotal = state.leafAbove
-	leafBelow: Array1DLeavesTotal = state.leafBelow
-	leafConnectee: DatatypeElephino = state.leafConnectee
-	leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-
-	groupsOfFolds = countSequential(
-		connectionGraph = connectionGraph,
-		countDimensionsGapped = countDimensionsGapped,
-		dimensionsTotal = dimensionsTotal,
-		dimensionsUnconstrained = dimensionsUnconstrained,
-		gap1ndex = gap1ndex,
-		gap1ndexCeiling = gap1ndexCeiling,
-		gapRangeStart = gapRangeStart,
-		gapsWhere = gapsWhere,
-		groupsOfFolds = groupsOfFolds,
-		indexDimension = indexDimension,
-		indexMiniGap = indexMiniGap,
-		leaf1ndex = leaf1ndex,
-		leafAbove = leafAbove,
-		leafBelow = leafBelow,
-		leafConnectee = leafConnectee,
-		leavesTotal = leavesTotal,
-		)
-
-	state.groupsOfFolds = state.foldGroups[state.taskIndex] = groupsOfFolds
-
-	return state

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,12 +0,0 @@
-from  import 
-from mapFolding.syntheticModules.numbaCount import countInitialize, countParallel, countSequential
-from mapFolding.theSSOT import ComputationState
-import copy
-
-@(ComputationState(ComputationState), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def doTheNeedful(computationStateInitialized: ComputationState) -> ComputationState:
-    computationStateInitialized = countInitialize(computationStateInitialized)
-    if computationStateInitialized.taskDivisions > 0:
-        return countParallel(computationStateInitialized)
-    else:
-        return countSequential(computationStateInitialized)

mapfolding-0.7.1.dist-info/RECORD

@@ -1,51 +0,0 @@
-mapFolding/__init__.py,sha256=hONqdWnBN1ebgrKZuMIZfI8m-1krSR66L4GTVRwBmw4,203
-mapFolding/basecamp.py,sha256=Ik_oH-MpH8f6k-yBzwm99lfkv3pMDgFFEnSSDyiJjsQ,3861
-mapFolding/beDRY.py,sha256=Icgj8s6Rgd_oIBdvzwr6dovywdvG3sIVELO-n74W-So,9011
-mapFolding/filesystem.py,sha256=KqgsO-jaSWAlYib_9ovoXQY76PcQri09_73u0OqMWC8,4094
-mapFolding/noHomeYet.py,sha256=HjxLP-7BGVkKL66T50q4BWnC0Cg2gHUeCKMFuwR2mEQ,785
-mapFolding/oeis.py,sha256=xqnL_VyhwRBET-Kdpnf59K5W5metGbW0JiufTlVw7g0,11853
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=eQvR6lDMW_dI6qhZmkTqv-Eog79ekfQjap9rg8cavE8,8629
-mapFolding/theSSOT.py,sha256=fWEkYyCoioi_jJzu2Qwi11GBIyXBbjcFfKAf3tlL9Aw,13270
-mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
-mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
-mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
-mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
-mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
-mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
-mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
-mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
-mapFolding/someAssemblyRequired/Z0Z_workbench.py,sha256=XibNQRbX5gGfrkWVfRsW66kHlqphcqVCPz7TyJFcs90,1505
-mapFolding/someAssemblyRequired/__init__.py,sha256=pYkG-1LM8emzTeQbGtOfiZsAiklm5DU92-WE63qB-9s,602
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=sGDzg5HG21Q42M0upRD1NWzOUsd7mZ_9wUKJIQHI13o,1000
-mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=HnWgo1KwIoevUrE5A1WZh4AVFXKQllt8L6RL46JTXEg,2787
-mapFolding/someAssemblyRequired/synthesizeCountingFunctions.py,sha256=77iNPPsN8BmwHaYKdXcDKCwoZKS1g41CJNenQB0W-eg,252
-mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=czo6Y0ABlwye01ShumObAFtkTn7PBx4Qsh9Jna5BMUw,6187
-mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=cKXvp0BxmYayUBMQ2RJLkVoJUSvzPI1S4Wy_APRM5cI,4788
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=w7zLUzLrLXf2N6O75jKvXDoyTJemWB8GOdK4ryqSWbs,22700
-mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=zUclYPmAr6X5qFO3nQK1_HHqdiRq6j3EIBXjeax_b8c,4388
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=QAheMJgYWI09PBetyhnJqNhJk_hl6Zlu1TBbDjBwFSs,21001
-mapFolding/someAssemblyRequired/whatWillBe.py,sha256=G_r1VD106gTZISyiwhuJosREfRzQd73JLAMpYg8F6O8,14641
-mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/syntheticModules/dataNamespaceFlattened.py,sha256=vsU4PDEMoEcZ424AzsXOJoXoVlX_bSk-pXSTlDsSN9k,2939
-mapFolding/syntheticModules/multiprocessingCount_doTheNeedful.py,sha256=JwZzvF79mvuo2E0Lfs0NeY1QR6JP8FRuwUaRmENwDs8,8482
-mapFolding/syntheticModules/numbaCount.py,sha256=znFV9RhZ0WqPA-r-DT92WDgZXUyhdQlrsKmnsGySuKc,4561
-mapFolding/syntheticModules/numbaCountExample.py,sha256=Oo0Xeex89sLD15iRt3N76OKRFScKl9qwO84-d5sv6lM,11871
-mapFolding/syntheticModules/numbaCountSequential.py,sha256=CtSA3UX2JzoN_uSo0SH7E3coKuHBWaTloQZwbExIPBw,4325
-mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=8kgV2GGjy_nxVi9o_aAtrZzRSxsYr8HVNsVXesf4Kec,767
-mapFolding/syntheticModules/numba_doTheNeedfulExample.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=oPc1IS4RXhLQIBskhuawi4GEWhy6kXbM6D2MdX9kDhw,10833
-tests/test_computations.py,sha256=YhadlskBh_r5RiefHRy0FlrYQ0FelYbqcSNNSkSJMIY,3368
-tests/test_filesystem.py,sha256=7Ova6f4R6lI9rwnnu8SkZgficTYlKEhSzLp-nBRWESM,3183
-tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
-tests/test_other.py,sha256=CS64h5NACYmXhG3owBpPDcXv3BpYlXNeLqPcqT4quwg,4303
-tests/test_tasks.py,sha256=K5WdCtsM8ghFHX_BMmATsNUTvCICoTHtU-K73QBA4gY,3048
-mapfolding-0.7.1.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapfolding-0.7.1.dist-info/METADATA,sha256=czJ_D8mDCOZg1ug6kaIvrwMTKJKh2zfk7Q3FWLJcs6U,7696
-mapfolding-0.7.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-mapfolding-0.7.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.7.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.7.1.dist-info/RECORD,,