mapFolding 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,12 +1,15 @@
-from numpy.typing import NDArray
-import numpy
+from mapFolding import indexMy
+from mapFolding import indexTrack
+from numba import uint8
+from numba import jit
+from numpy import ndarray
+from numpy import dtype
 from numpy import integer
-import numba
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
+from typing import Any
+from typing import Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]))
-def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+@jit((uint8[:, :, ::1], uint8[::1], uint8[::1], uint8[:, ::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.value]:
         if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
             my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,22 +1,27 @@
-from numpy.typing import NDArray
-import numpy
+from mapFolding import indexMy
+from mapFolding import indexTrack
+from numba import uint8
+from numba import prange
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
 from numpy import integer
-import numba
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
+from typing import Any
+from typing import Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::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.value]
-    for indexSherpa in numba.prange(taskDivisionsPrange):
+    for indexSherpa in prange(taskDivisionsPrange):
         groupsOfFolds: int = 0
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
+        my[indexMy.taskIndex.value] = indexSherpa
         while my[indexMy.leaf1ndex.value]:
             if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
                 if my[indexMy.leaf1ndex.value] > foldGroups[-1]:

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,12 +1,16 @@
-from numpy.typing import NDArray
-import numpy
+from mapFolding import indexMy
+from mapFolding import indexTrack
+from numba import uint8
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
 from numpy import integer
-import numba
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
+from typing import Any
+from typing import Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::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]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,31 +1,18 @@
-from mapFolding import indexMy, indexTrack
+from mapFolding import indexMy
+from numba import uint8
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
 from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, Tuple
-import numba
-import numpy
+from typing import Any
+from typing import Tuple
 from mapFolding.syntheticModules.numba_countInitialize import countInitialize
 from mapFolding.syntheticModules.numba_countParallel import countParallel
 from mapFolding.syntheticModules.numba_countSequential import countSequential
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]))
-def doTheNeedful(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], mapShape: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
-    """
-        What in tarnation is this stupid module and function?
-
-        - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
-        - This function is not in the same module as the next function, which does the hard work, so that we can delay `numba.jit` compilation of the next function.
-        - This function is "jitted" but the next function is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
-        - So this module can talk to the next function, and because this module isn't as arrogant, it will talk to the low-class `countFolds` that called this function. Well, with a few restrictions, of course:
-            - No `TypedDict`
-            - The plebs must clean up their own memory problems
-            - No oversized integers
-            - No global variables, only global constants
-            - It won't accept pleb nonlocal variables either
-            - Python "class": they are all inferior to the jit class
-            - No `**kwargs`
-            - and just a few dozen-jillion other things.
-        """
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=True, cache=True, error_model='python', fastmath=False, 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.value] > 0:
         countParallel(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/theDao.py

@@ -1,94 +1,93 @@
 from mapFolding import indexMy, indexTrack
-from numpy import integer
-from numpy.typing import NDArray
+from numba import prange
+from numpy import dtype, integer, ndarray
 from typing import Any, Tuple
-import numba
-import numpy
 
-def activeGapIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def activeGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    # `.value` is not necessary for this module or most modules. But, this module is transformed into Numba "jitted" functions, and Numba won't use `Enum` for an index without `.value`.
     my[indexMy.gap1ndex.value] += 1
 
-def activeLeafGreaterThan0Condition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value]
 
-def activeLeafGreaterThanLeavesTotalCondition(foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThanLeavesTotalCondition(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value] > foldGroups[-1]
 
-def activeLeafIsTheFirstLeafCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def activeLeafIsTheFirstLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value] <= 1
 
-def allDimensionsAreUnconstrained(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def allDimensionsAreUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return not my[indexMy.dimensionsUnconstrained.value]
 
-def backtrack(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+def backtrack(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     my[indexMy.leaf1ndex.value] -= 1
     track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
     track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
 
-def backtrackCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+def backtrackCondition(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 
-def gap1ndexCeilingIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def gap1ndexCeilingIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.gap1ndexCeiling.value] += 1
 
-def countGaps(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+def countGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
     if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
         gap1ndexCeilingIncrement(my=my)
     track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
 
-def dimension1ndexIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def dimension1ndexIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexDimension.value] += 1
 
-def dimensionsUnconstrainedCondition(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def dimensionsUnconstrainedCondition(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
 
-def dimensionsUnconstrainedDecrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def dimensionsUnconstrainedDecrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.dimensionsUnconstrained.value] -= 1
 
-def filterCommonGaps(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+def filterCommonGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
     if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
         activeGapIncrement(my=my)
     track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
 
-def findGapsInitializeVariables(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+def findGapsInitializeVariables(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
     my[indexMy.indexDimension.value] = 0
 
-def indexMiniGapIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexMiniGap.value] += 1
 
-def indexMiniGapInitialization(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def indexMiniGapInitialization(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
 
-def insertUnconstrainedLeaf(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def insertUnconstrainedLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexLeaf.value] = 0
     while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
         gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
         my[indexMy.gap1ndexCeiling.value] += 1
         my[indexMy.indexLeaf.value] += 1
 
-def leafBelowSentinelIs1Condition(track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+def leafBelowSentinelIs1Condition(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
     return track[indexTrack.leafBelow.value, 0] == 1
 
-def leafConnecteeInitialization(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def leafConnecteeInitialization(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
 
-def leafConnecteeUpdate(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+def leafConnecteeUpdate(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
 
-def loopingLeavesConnectedToActiveLeaf(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopingTheDimensions(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def loopingTheDimensions(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
-def loopingToActiveGapCeiling(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
 
-def placeLeaf(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+def placeLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     my[indexMy.gap1ndex.value] -= 1
     track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
     track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
@@ -97,16 +96,18 @@ def placeLeaf(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], m
     track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
     my[indexMy.leaf1ndex.value] += 1
 
-def placeLeafCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def placeLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value]
 
-def thereAreComputationDivisionsYouMightSkip(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def thereAreComputationDivisionsYouMightSkip(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
 
-def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
-                    , gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                    , my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                    , track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+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 activeLeafGreaterThan0Condition(my=my):
         if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
             findGapsInitializeVariables(my=my, track=track)
@@ -130,21 +131,28 @@ def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
         if my[indexMy.gap1ndex.value] > 0:
             return
 
-def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
-                    , foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                    , gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                    , my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                    , track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+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.value]
-    for indexSherpa in numba.prange(taskDivisionsPrange):
+
+    for indexSherpa in prange(taskDivisionsPrange):
         groupsOfFolds: int = 0
+
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
+
+        my[indexMy.taskIndex.value] = indexSherpa
+
         while activeLeafGreaterThan0Condition(my=my):
             if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
                 if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
@@ -171,9 +179,16 @@ def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dty
                 placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
         foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+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:
+
     groupsOfFolds: int = 0
-    doFindGaps = True
+    doFindGaps = True # Frankly, I can't figure out if `doFindGaps` is or is not faster. Furthermore, I have a strong feeling there is an even better way.
+
     while activeLeafGreaterThan0Condition(my=my):
         if ((doFindGaps := activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track))
                 and activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my)):
@@ -199,13 +214,14 @@ def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
             placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
     foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-def doTheNeedful(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
-                , foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                , gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                , mapShape: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                , my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-                , track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]
-                ) -> None:
+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.value] > 0:

mapFolding/theSSOT.py

@@ -1,7 +1,8 @@
 from collections import defaultdict
-from numpy import integer
+from mapFolding.theSSOTnumba import *
+from numpy import dtype, integer, ndarray
 from types import ModuleType
-from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TypedDict, cast
+from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING, cast
 import enum
 import numba
 import numpy
@@ -9,6 +10,16 @@ import numpy.typing
 import pathlib
 import sys
 
+try:
+    from typing import NotRequired
+except ImportError:
+    from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    from typing import TypedDict
+else:
+    TypedDict = dict
+
 """I have hobbled together:
 TypedDict, Enum, defaultdict, and lookup dictionaries to make DIY immutability and delayed realization/instantiation.
 Nevertheless, I am both confident that all of these processes will be replaced and completely ignorant of what will replace them."""
@@ -39,7 +50,7 @@ def getPathPackage() -> pathlib.Path:
         pathPackage = pathPackage.parent
     return pathPackage
 
-def getPathJobDEFAULT() -> pathlib.Path:
+def getPathJobRootDEFAULT() -> pathlib.Path:
     if 'google.colab' in sys.modules:
         pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
     else:
@@ -62,14 +73,14 @@ def getDispatcherCallable() -> Callable[..., None]:
     from mapFolding.syntheticModules import numba_doTheNeedful
     return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
 
-# NOTE I want this _concept_ to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
+# NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
 class computationState(TypedDict):
-    connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
-    foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    mapShape: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]
+    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]]]
 
 @enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
 class EnumIndices(enum.IntEnum):
@@ -105,35 +116,6 @@ class indexTrack(EnumIndices):
     countDimensionsGapped = enum.auto()
     gapRangeStart = enum.auto()
 
-class ParametersNumba(TypedDict):
-    _nrt: bool
-    boundscheck: bool
-    cache: bool
-    error_model: str
-    fastmath: bool
-    forceinline: bool
-    inline: str
-    looplift: bool
-    no_cfunc_wrapper: bool
-    no_cpython_wrapper: bool
-    nopython: bool
-    parallel: bool
-
-parametersNumbaDEFAULT: Final[ParametersNumba] = {
-    '_nrt': True,
-    'boundscheck': False,
-    'cache': True,
-    'error_model': 'numpy',
-    'fastmath': True,
-    'forceinline': False,
-    'inline': 'never',
-    'looplift': False,
-    'no_cfunc_wrapper': True,
-    'no_cpython_wrapper': True,
-    'nopython': True,
-    'parallel': False,
-}
-
 "delay realization/instantiation until a concrete value is desired"
 "moment of truth: when the value is needed, not when the value is defined"
 

mapFolding/theSSOTnumba.py

@@ -0,0 +1,116 @@
+"""I have so much truth, I need two files to contain it all!"""
+"""TODO learn how to use this efficiently and effectively to solve problems, be DRY, and have SSOT."""
+from typing import Final, TYPE_CHECKING, Dict, Any, Union, Callable, Tuple, Any
+import numba
+import numba.core.compiler
+try:
+    from typing import NotRequired
+except ImportError:
+    from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    from typing import TypedDict
+else:
+    TypedDict = dict
+
+"""
+Old notes that are not entirely accurate.
+
+| **Option**              | **Description**                                     | **Why**               | **Size**        | **But**                  |
+| ----------------------- | --------------------------------------------------- | --------------------- | --------------- | ------------------------ |
+| `_dbg_extend_lifetimes` | Debug option to extend object lifetimes             | Debugging             |                 |                          |
+| `_dbg_optnone`          | Disable optimization for debugging                  | Debugging             |                 |                          |
+| `debug`                 | Enable debug mode with additional checks            | Debugging             |                 |                          |
+| `no_rewrites`           | Disable AST rewrites optimization                   | Debugging             |                 |                          |
+| `boundscheck`           | Enable array bounds checking (slows execution)      | Error checking        | Larger          | Slower                   |
+| `error_model`           | Divide by zero: kill or chill?                      | Error checking        | ?               |                          |
+| `_nrt`                  | Enable No Runtime type checking                     | Startup speed         | Smaller         | No type protection       |
+| `fastmath`              | Reduce float potential precision                    | Float speed           | Smaller         | Discriminatory, untested |
+| `forceinline`           | Force function inlining                             | Reduce function calls | Likely larger   |                          |
+| `forceobj`              | Force object mode compilation                       | Inclusiveness         | Larger          | Slower execution         |
+| `inline`                | Algorithmically choose inlining                     | Speed                 | Slightly larger |                          |
+| `looplift`              | Enable loop lifting optimization                    | Speed (if applicable) | Larger          | Exclusionary             |
+| `no_cfunc_wrapper`      | Disable C function wrapper generation               | Size                  | Smaller         | Exclusionary             |
+| `no_cpython_wrapper`    | Disable Python C-API wrapper generation             | Size                  | Smallest        | Exclusionary             |
+
+"""
+
+# TODO try to implement all possible parameters, but use `NotRequired` for the more esoteric ones
+class ParametersNumba(TypedDict):
+    _dbg_extend_lifetimes: NotRequired[bool]
+    _dbg_optnone: NotRequired[bool]
+    _nrt: NotRequired[bool]
+    boundscheck: NotRequired[bool]
+    cache: bool
+    debug: NotRequired[bool]
+    error_model: str
+    fastmath: bool
+    forceinline: bool
+    forceobj: NotRequired[bool]
+    inline: str
+    locals: NotRequired[Dict[str, Any]]
+    looplift: bool
+    no_cfunc_wrapper: bool
+    no_cpython_wrapper: bool
+    no_rewrites: NotRequired[bool]
+    nogil: NotRequired[bool]
+    nopython: bool
+    parallel: bool
+    pipeline_class: NotRequired[numba.core.compiler.CompilerBase]
+    signature_or_function: NotRequired[Union[Any, Callable, str, Tuple]]
+    target: NotRequired[str]
+
+parametersNumbaFailEarly: Final[ParametersNumba] = {
+    '_nrt': True,
+    'boundscheck': True,
+    'cache': True,
+    'error_model': 'python',
+    'fastmath': False,
+    'forceinline': True,
+    'inline': 'always',
+    'looplift': False,
+    'no_cfunc_wrapper': False,
+    'no_cpython_wrapper': False,
+    'nopython': True,
+    'parallel': False,
+}
+"""For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
+
+parametersNumbaDEFAULT: Final[ParametersNumba] = {
+    '_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,
+}
+"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
+
+parametersNumbaParallelDEFAULT: Final[ParametersNumba] = {
+    **parametersNumbaDEFAULT,
+    '_nrt': True,
+    'parallel': True,
+}
+"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
+
+parametersNumbaSuperJit: Final[ParametersNumba] = {
+    **parametersNumbaDEFAULT,
+    'no_cfunc_wrapper': True,
+    'no_cpython_wrapper': True,
+}
+"""Speed, no helmet, no talking to non-jitted functions."""
+
+parametersNumbaSuperJitParallel: Final[ParametersNumba] = {
+    **parametersNumbaSuperJit,
+    '_nrt': True,
+    'parallel': True,
+}
+"""Speed, no helmet, concurrency, no talking to non-jitted functions.
+Claude says, "The NRT is Numba's memory management system that handles memory allocation and deallocation for array operations. Because of array copying, you need to have NRT enabled." IDK which AI assistant autocompleted this, but, "The NRT is a bit slower than the default memory management system, but it's necessary for certain operations."
+"""

{mapFolding-0.3.9.dist-info → mapFolding-0.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.9
+Version: 0.3.11
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -25,12 +25,8 @@ License-File: LICENSE
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
-Provides-Extra: benchmark
-Requires-Dist: ipywidgets; extra == "benchmark"
-Requires-Dist: jupyter; extra == "benchmark"
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: autoflake; extra == "testing"
 Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
@@ -39,8 +35,8 @@ Requires-Dist: pytest-mypy; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
-Requires-Dist: tomli; extra == "testing"
 Requires-Dist: types-setuptools; extra == "testing"
+Requires-Dist: updateCitation; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)