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

mapFolding/syntheticModules/numbaCount.py

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

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

@@ -0,0 +1,111 @@
+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/numbaCount_doTheNeedful.py

@@ -0,0 +1,13 @@
+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/syntheticModules/numba_doTheNeedful.py

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

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