mapFolding 0.7.1__py3-none-any.whl → 0.8.1__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/numbaCountExample.py

@@ -1,158 +0,0 @@
-from mapFolding.theSSOT import indexMy, indexTrack
-from numba import uint16, prange, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], uint16[::1], uint16[::1], uint16[:, ::1]), _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(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    while my[indexMy.leaf1ndex] > 0:
-        if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
-            my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
-            my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-            my[indexMy.indexDimension] = 0
-            while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
-                if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
-                    my[indexMy.dimensionsUnconstrained] -= 1
-                else:
-                    my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-                    while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-                        if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-                            my[indexMy.gap1ndexCeiling] += 1
-                        track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-                        my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-                my[indexMy.indexDimension] += 1
-            if not my[indexMy.dimensionsUnconstrained]:
-                my[indexMy.indexLeaf] = 0
-                while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
-                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
-                    my[indexMy.gap1ndexCeiling] += 1
-                    my[indexMy.indexLeaf] += 1
-            my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-            while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
-                gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-                if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
-                    my[indexMy.gap1ndex] += 1
-                track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-                my[indexMy.indexMiniGap] += 1
-        if my[indexMy.leaf1ndex] > 0:
-            my[indexMy.gap1ndex] -= 1
-            track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-            track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-            track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-            track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-            track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-            my[indexMy.leaf1ndex] += 1
-        if my[indexMy.gap1ndex] > 0:
-            return
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _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(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    gapsWherePARALLEL = gapsWhere.copy()
-    myPARALLEL = my.copy()
-    trackPARALLEL = track.copy()
-    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions]
-    for indexSherpa in prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex] = indexSherpa
-        while my[indexMy.leaf1ndex] > 0:
-            if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
-                if my[indexMy.leaf1ndex] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
-                    my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-                    my[indexMy.indexDimension] = 0
-                    while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
-                        if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
-                            my[indexMy.dimensionsUnconstrained] -= 1
-                        else:
-                            my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-                            while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
-                                if my[indexMy.leaf1ndex] != my[indexMy.taskDivisions] or my[indexMy.leafConnectee] % my[indexMy.taskDivisions] == my[indexMy.taskIndex]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-                                    if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-                                        my[indexMy.gap1ndexCeiling] += 1
-                                    track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-                                my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-                        my[indexMy.indexDimension] += 1
-                    my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-                    while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
-                        gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-                        if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
-                            my[indexMy.gap1ndex] += 1
-                        track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-                        my[indexMy.indexMiniGap] += 1
-            while my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]:
-                my[indexMy.leaf1ndex] -= 1
-                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
-                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
-            if my[indexMy.leaf1ndex] > 0:
-                my[indexMy.gap1ndex] -= 1
-                track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-                track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-                track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-                my[indexMy.leaf1ndex] += 1
-        foldGroups[my[indexMy.taskIndex]] = groupsOfFolds
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _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(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    leafBelow = track[indexTrack.leafBelow.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
-    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
-    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
-    indexDimension = my[indexMy.indexDimension.value]
-    leafConnectee = my[indexMy.leafConnectee.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
-    taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > foldGroups[-1]:
-                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
-    foldGroups[taskIndex] = groupsOfFolds

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/syntheticModules/numba_doTheNeedfulExample.py

@@ -1,13 +0,0 @@
-from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countInitialize, countSequential, countParallel
-from numba import uint16, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _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(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], mapShape: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    countInitialize(connectionGraph, gapsWhere, my, track)
-    if my[indexMy.taskDivisions] > 0:
-        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
-    else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)

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,,