mapFolding 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

mapFolding/theDao.py

@@ -1,96 +1,93 @@
 from mapFolding import indexMy, indexTrack
 from numba import prange
 from numpy import dtype, integer, ndarray
-from typing import Any, Tuple
+from typing import Any
 
-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 ndarray index without `.value`.
-	my[indexMy.gap1ndex.value] += 1
+# `.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 ndarray index without `.value`.
+def activeLeafConnectedToItself(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
 
-def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value]
+def activeLeafGreaterThan0(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leaf1ndex.value] > 0
 
-def activeLeafGreaterThanLeavesTotalCondition(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThanLeavesTotal(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: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafIsTheFirstLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] <= 1
 
-def allDimensionsAreUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def allDimensionsAreUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return not my[indexMy.dimensionsUnconstrained.value]
 
-def backtrack(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], 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: 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: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-	my[indexMy.gap1ndexCeiling.value] += 1
-
-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:
+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)
+		incrementGap1ndexCeiling(my=my)
 	track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
 
-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: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def decrementDimensionsUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.dimensionsUnconstrained.value] -= 1
 
-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:
+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 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)
+		incrementActiveGap(my=my)
 	track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
 
-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 incrementActiveGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
+	my[indexMy.gap1ndex.value] += 1
+
+def incrementGap1ndexCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
+	my[indexMy.gap1ndexCeiling.value] += 1
 
-def indexDimensionIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexDimension(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexDimension.value] += 1
 
-def indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] += 1
 
-def indexMiniGapInitialization(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def initializeIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
 
-def insertUnconstrainedLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def initializeLeafConnectee(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 initializeVariablesToFindGaps(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 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: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+def leafBelowSentinelIs1(track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
 	return track[indexTrack.leafBelow.value, 0] == 1
 
-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: 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 activeLeafConnectedToItself(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
-
-def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopingLeavesConnectedToActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopUpToDimensionsTotal(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopingToActiveGapCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+
+def loopUpToDimensionsTotal(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
-def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+def noGapsHere(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 
-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:
+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]]]
@@ -99,46 +96,49 @@ def placeLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[T
 	track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
 	my[indexMy.leaf1ndex.value] += 1
 
-def placeLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
-	return my[indexMy.leaf1ndex.value]
+def thereIsAnActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leaf1ndex.value] > 0
 
-def thereAreComputationDivisionsYouMightSkip(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def thisIsMyTaskIndex(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: 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]]]
+def updateLeafConnectee(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 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)
+	while activeLeafGreaterThan0(my=my):
+		if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
+			initializeVariablesToFindGaps(my=my, track=track)
 			while loopUpToDimensionsTotal(my=my):
 				if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-					dimensionsUnconstrainedDecrement(my=my)
+					decrementDimensionsUnconstrained(my=my)
 				else:
-					leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+					initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
 					while loopingLeavesConnectedToActiveLeaf(my=my):
 						countGaps(gapsWhere=gapsWhere, my=my, track=track)
-						leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-				indexDimensionIncrement(my=my)
+						updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
+				incrementIndexDimension(my=my)
 			if allDimensionsAreUnconstrained(my=my):
 				insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
-			indexMiniGapInitialization(my=my)
+			initializeIndexMiniGap(my=my)
 			while loopingToActiveGapCeiling(my=my):
 				filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-				indexMiniGapIncrement(my=my)
-		if placeLeafCondition(my=my):
+				incrementIndexMiniGap(my=my)
+		if thereIsAnActiveLeaf(my=my):
 			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 		if my[indexMy.gap1ndex.value] > 0:
 			return
 
-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]]]
+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()
@@ -156,72 +156,72 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
 
 		my[indexMy.taskIndex.value] = indexSherpa
 
-		while activeLeafGreaterThan0Condition(my=my):
-			if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-				if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+		while activeLeafGreaterThan0(my=my):
+			if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
+				if activeLeafGreaterThanLeavesTotal(foldGroups=foldGroups, my=my):
 					groupsOfFolds += 1
 				else:
-					findGapsInitializeVariables(my=my, track=track)
+					initializeVariablesToFindGaps(my=my, track=track)
 					while loopUpToDimensionsTotal(my=my):
 						if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-							dimensionsUnconstrainedDecrement(my=my)
+							decrementDimensionsUnconstrained(my=my)
 						else:
-							leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+							initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
 							while loopingLeavesConnectedToActiveLeaf(my=my):
-								if thereAreComputationDivisionsYouMightSkip(my=my):
+								if thisIsMyTaskIndex(my=my):
 									countGaps(gapsWhere=gapsWhere, my=my, track=track)
-								leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-						indexDimensionIncrement(my=my)
-					indexMiniGapInitialization(my=my)
+								updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
+						incrementIndexDimension(my=my)
+					initializeIndexMiniGap(my=my)
 					while loopingToActiveGapCeiling(my=my):
 						filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-						indexMiniGapIncrement(my=my)
-			while backtrackCondition(my=my, track=track):
+						incrementIndexMiniGap(my=my)
+			while noGapsHere(my=my, track=track):
 				backtrack(my=my, track=track)
-			if placeLeafCondition(my=my):
+			if thereIsAnActiveLeaf(my=my):
 				placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 		foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-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]]]
+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
 
-	while activeLeafGreaterThan0Condition(my=my):
-		if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-			if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+	while activeLeafGreaterThan0(my=my):
+		if activeLeafIsTheFirstLeaf(my=my) or leafBelowSentinelIs1(track=track):
+			if activeLeafGreaterThanLeavesTotal(foldGroups=foldGroups, my=my):
 				groupsOfFolds += 1
 			else:
-				findGapsInitializeVariables(my=my, track=track)
+				initializeVariablesToFindGaps(my=my, track=track)
 				while loopUpToDimensionsTotal(my=my):
-					leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+					initializeLeafConnectee(connectionGraph=connectionGraph, my=my)
 					if activeLeafConnectedToItself(my=my):
-						dimensionsUnconstrainedDecrement(my=my)
+						decrementDimensionsUnconstrained(my=my)
 					else:
 						while loopingLeavesConnectedToActiveLeaf(my=my):
 							countGaps(gapsWhere=gapsWhere, my=my, track=track)
-							leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-					indexDimensionIncrement(my=my)
-				indexMiniGapInitialization(my=my)
+							updateLeafConnectee(connectionGraph=connectionGraph, my=my, track=track)
+					incrementIndexDimension(my=my)
+				initializeIndexMiniGap(my=my)
 				while loopingToActiveGapCeiling(my=my):
 					filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-					indexMiniGapIncrement(my=my)
-		while backtrackCondition(my=my, track=track):
+					incrementIndexMiniGap(my=my)
+		while noGapsHere(my=my, track=track):
 			backtrack(my=my, track=track)
-		if placeLeafCondition(my=my):
+		if thereIsAnActiveLeaf(my=my):
 			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 	foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-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]]]
+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)

mapFolding/theSSOT.py

@@ -1,80 +1,67 @@
-from collections import defaultdict
-from mapFolding.theSSOTnumba import *
+from collections.abc import Callable
+from mapFolding.theSSOTdatatypes import (
+	EnumIndices,
+	indexMy,
+	indexTrack,
+	reportDatatypeLimit,
+	setDatatypeModule,
+	setDatatypeElephino,
+	setDatatypeFoldsTotal,
+	setDatatypeLeavesTotal,
+	getDatatypeModule,
+	setInStone,
+	hackSSOTdtype,
+	hackSSOTdatatype,
+)
+from numba.core.compiler import CompilerBase as numbaCompilerBase
 from numpy import dtype, integer, ndarray
+from pathlib import Path
+from sys import modules as sysModules
 from types import ModuleType
-from typing import Any, Callable, cast, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING
-import enum
-import numba
-import numpy
-import numpy.typing
-import pathlib
-import sys
+from typing import Any, Final, TYPE_CHECKING, cast
 
 try:
 	from typing import NotRequired
-except ImportError:
-	from typing_extensions import NotRequired
+except Exception:
+	from typing_extensions import NotRequired # type: ignore
 
 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."""
-
 """Technical concepts I am likely using and likely want to use more effectively:
 - Configuration Registry
 - Write-Once, Read-Many (WORM) / Immutable Initialization
 - Lazy Initialization
-- Separation of Concerns: in the sense that configuration is separated from business logic
-
-Furthermore, I want to more clearly divorce the concept of a single _source_ of (a) truth from
-the _authority_ of that truth. The analogy to a registry of ownership is still apt: the registry
-is, at most, a single (or centralized) source of truth, but it is merely the place to register/record
-the truth determined by some other authority.
+- Separation of configuration from business logic
 
-And, I almost certainly want to change the semiotics from "authority" (of truth) to "power" (to create a truth).
-Here, "power" is a direct analogy to https://hunterthinks.com/opinion/a-hohfeldian-primer.
+delay realization/instantiation until a concrete value is desired
+moment of truth: when the value is needed, not when the value is defined
 """
 
-"delay realization/instantiation until a concrete value is desired"
-
-"moment of truth: when the value is needed, not when the value is defined"
-
-"""What is a (not too complicated, integer) datatype?
-	- ecosystem/module
-		- must apathy|value|list of values
-		- mustn't apathy|value|list of values
-	- bit width
-		- bits maximum apathy|value
-		- bits minimum apathy|value
-		- magnitude maximum apathy|value
-		- ?magnitude minimum apathy|value
-	- signedness apathy|non-negative|non-positive|both
-	"""
-
 myPackageNameIs = "mapFolding"
 
 moduleOfSyntheticModules = "syntheticModules"
-formatModuleNameDEFAULT = "numba_{callableTarget}"
+# TODO I'm not sure if this is the right tool for the job.
+formatFilenameModuleDEFAULT = "numba_{callableTarget}.py"
+dispatcherCallableNameDEFAULT = "doTheNeedful"
 
-def getPathPackage() -> pathlib.Path:
+def getPathPackage() -> Path:
 	import importlib, inspect
-	pathPackage = pathlib.Path(inspect.getfile(importlib.import_module(myPackageNameIs)))
+	pathPackage = Path(inspect.getfile(importlib.import_module(myPackageNameIs)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-def getPathJobRootDEFAULT() -> pathlib.Path:
-	if 'google.colab' in sys.modules:
-		pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
+def getPathJobRootDEFAULT() -> Path:
+	if 'google.colab' in sysModules:
+		pathJobDEFAULT = Path("/content/drive/MyDrive") / "jobs"
 	else:
 		pathJobDEFAULT = getPathPackage() / "jobs"
 	return pathJobDEFAULT
 
-def getPathSyntheticModules() -> pathlib.Path:
+def getPathSyntheticModules() -> Path:
 	pathSyntheticModules = getPathPackage() / moduleOfSyntheticModules
 	return pathSyntheticModules
 
@@ -92,165 +79,12 @@ def getDispatcherCallable() -> Callable[..., None]:
 
 # 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:	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):
-	"""Base class for index enums."""
-	@staticmethod
-	def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> int:
-		"""0-indexed."""
-		return count
-
-	def __index__(self) -> int:
-		"""Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
-		same as `array.array`. See NumPy.org; I think it will be very popular someday."""
-		return self.value
-
-class indexMy(EnumIndices):
-	"""Indices for scalar values."""
-	dimensionsTotal 		= enum.auto()
-	dimensionsUnconstrained = enum.auto()
-	gap1ndex				= enum.auto()
-	gap1ndexCeiling 		= enum.auto()
-	indexDimension 			= enum.auto()
-	indexLeaf 				= enum.auto()
-	indexMiniGap 			= enum.auto()
-	leaf1ndex 				= enum.auto()
-	leafConnectee 			= enum.auto()
-	taskDivisions 			= enum.auto()
-	taskIndex 				= enum.auto()
-
-class indexTrack(EnumIndices):
-	"""Indices for state tracking array."""
-	leafAbove				= enum.auto()
-	leafBelow				= enum.auto()
-	countDimensionsGapped	= enum.auto()
-	gapRangeStart			= enum.auto()
-
-_datatypeDefault: Final[Dict[str, str]] = {
-	'elephino': 'uint8',
-	'foldsTotal': 'int64',
-	'leavesTotal': 'uint8',
-}
-_datatypeModule = ''
-_datatypeModuleDEFAULT: Final[str] = 'numpy'
-
-_datatype: Dict[str, str] = defaultdict(str)
-
-def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[bool] = False) -> str:
-	global _datatype
-	if not _datatype[identifier]:
-		_datatype[identifier] = datatype
-	elif _datatype[identifier] == datatype:
-		pass
-	elif sourGrapes:
-		raise Exception(f"Datatype is '{_datatype[identifier]}' not '{datatype}', so you can take your ball and go home.")
-	return _datatype[identifier]
-
-def setDatatypeModule(datatypeModule: str, sourGrapes: Optional[bool] = False) -> str:
-	global _datatypeModule
-	if not _datatypeModule:
-		_datatypeModule = datatypeModule
-	elif _datatypeModule == datatypeModule:
-		pass
-	elif sourGrapes:
-		raise Exception(f"Datatype module is '{_datatypeModule}' not '{datatypeModule}', so you can take your ball and go home.")
-	return _datatypeModule
-
-def setDatatypeElephino(datatype: str, sourGrapes: Optional[bool] = False) -> str:
-	return reportDatatypeLimit('elephino', datatype, sourGrapes)
-
-def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
-	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
-
-def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
-	return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
-
-def _get_datatype(identifier: str) -> str:
-	global _datatype
-	if not _datatype[identifier]:
-		if identifier in indexMy._member_names_:
-			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
-		elif identifier in indexTrack._member_names_:
-			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
-		else:
-			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('foldsTotal')
-	return _datatype[identifier]
-
-def _getDatatypeModule() -> str:
-	global _datatypeModule
-	if not _datatypeModule:
-		_datatypeModule = _datatypeModuleDEFAULT
-	return _datatypeModule
-
-def setInStone(identifier: str) -> Type[Any]:
-	datatypeModule = _getDatatypeModule()
-	datatypeStr = _get_datatype(identifier)
-	return cast(Type[Any], getattr(eval(datatypeModule), datatypeStr))
-
-def hackSSOTdtype(identifier: str) -> Type[Any]:
-	_hackSSOTdtype={
-	'connectionGraph': 	'dtypeLeavesTotal',
-	'dtypeElephino': 	'dtypeElephino',
-	'dtypeFoldsTotal': 	'dtypeFoldsTotal',
-	'dtypeLeavesTotal': 'dtypeLeavesTotal',
-	'foldGroups': 		'dtypeFoldsTotal',
-	'gapsWhere': 		'dtypeLeavesTotal',
-	'mapShape': 		'dtypeLeavesTotal',
-	'my': 				'dtypeElephino',
-	'track': 			'dtypeElephino',
-	}
-	RubeGoldBerg = _hackSSOTdtype[identifier]
-	if RubeGoldBerg == 'dtypeElephino':
-		return setInStone('elephino')
-	elif RubeGoldBerg == 'dtypeFoldsTotal':
-		return setInStone('foldsTotal')
-	elif RubeGoldBerg == 'dtypeLeavesTotal':
-		return setInStone('leavesTotal')
-	raise Exception("Dude, you forgot to set a value in `hackSSOTdtype`.")
-
-def hackSSOTdatatype(identifier: str) -> str:
-	_hackSSOTdatatype={
-	'connectionGraph':	 		'datatypeLeavesTotal',
-	'countDimensionsGapped': 	'datatypeLeavesTotal',
-	'datatypeElephino': 		'datatypeElephino',
-	'datatypeFoldsTotal': 		'datatypeFoldsTotal',
-	'datatypeLeavesTotal': 		'datatypeLeavesTotal',
-	'dimensionsTotal': 			'datatypeLeavesTotal',
-	'dimensionsUnconstrained':	'datatypeLeavesTotal',
-	'foldGroups': 				'datatypeFoldsTotal',
-	'gap1ndex': 				'datatypeLeavesTotal',
-	'gap1ndexCeiling': 			'datatypeElephino',
-	'gapRangeStart': 			'datatypeElephino',
-	'gapsWhere': 				'datatypeLeavesTotal',
-	'groupsOfFolds': 			'datatypeFoldsTotal',
-	'indexDimension': 			'datatypeLeavesTotal',
-	'indexLeaf': 				'datatypeLeavesTotal',
-	'indexMiniGap': 			'datatypeElephino',
-	'leaf1ndex': 				'datatypeLeavesTotal',
-	'leafAbove': 				'datatypeLeavesTotal',
-	'leafBelow': 				'datatypeLeavesTotal',
-	'leafConnectee': 			'datatypeLeavesTotal',
-	'mapShape': 				'datatypeLeavesTotal',
-	'my':	 					'datatypeElephino',
-	'taskDivisions': 			'datatypeLeavesTotal',
-	'taskIndex': 				'datatypeLeavesTotal',
-	'track':	 				'datatypeElephino',
-	}
-	RubeGoldBerg = _hackSSOTdatatype[identifier]
-	if RubeGoldBerg == 'datatypeElephino':
-		return _get_datatype('elephino')
-	elif RubeGoldBerg == 'datatypeFoldsTotal':
-		return _get_datatype('foldsTotal')
-	elif RubeGoldBerg == 'datatypeLeavesTotal':
-		return _get_datatype('leavesTotal')
-	raise Exception("Dude, you forgot to set a value in `hackSSOTdatatype`.")
+	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]]]
 
 _datatypeModuleScalar = 'numba'
 _decoratorCallable = 'jit'
@@ -277,3 +111,44 @@ class FREAKOUT(Exception):
 # TODO Learn how to assign theDao.py the power to set this truth
 # while using theSSOT.py as the SSOT.
 Z0Z_identifierCountFolds = 'groupsOfFolds'
+
+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[type[numbaCompilerBase]]
+	signature_or_function: NotRequired[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."""
+
+parametersNumbaMinimum: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': False, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': False, 'forceobj': True, 'parallel': False, }