mapFolding 0.3.12__py3-none-any.whl → 0.4.0__py3-none-any.whl

mapFolding/__init__.py

@@ -1,66 +1,68 @@
 # fundamentals
 from mapFolding.theSSOT import (
-    computationState,
-    EnumIndices,
-    getDispatcherCallable,
-    getPathPackage,
-    indexMy,
-    indexTrack,
-    myPackageNameIs,
+	computationState,
+	EnumIndices,
+	getDispatcherCallable,
+	getPathPackage,
+	indexMy,
+	indexTrack,
+	myPackageNameIs,
 )
 
 # Datatype management
 from mapFolding.theSSOT import (
-    hackSSOTdatatype,
-    hackSSOTdtype,
-    setDatatypeElephino,
-    setDatatypeFoldsTotal,
-    setDatatypeLeavesTotal,
-    setDatatypeModule,
+	hackSSOTdatatype,
+	hackSSOTdtype,
+	setDatatypeElephino,
+	setDatatypeFoldsTotal,
+	setDatatypeLeavesTotal,
+	setDatatypeModule,
 )
 
 # Synthesize modules
 from mapFolding.theSSOT import (
-    getAlgorithmCallable,
-    getAlgorithmSource,
-    getPathJobRootDEFAULT,
-    getPathSyntheticModules,
-    moduleOfSyntheticModules,
-    Z0Z_getDatatypeModuleScalar,
-    Z0Z_getDecoratorCallable,
-    Z0Z_setDatatypeModuleScalar,
-    Z0Z_setDecoratorCallable,
-    Z0Z_identifierCountFolds,
+	formatModuleNameDEFAULT,
+	getAlgorithmCallable,
+	getAlgorithmSource,
+	getPathJobRootDEFAULT,
+	getPathSyntheticModules,
+	moduleOfSyntheticModules,
+	Z0Z_getDatatypeModuleScalar,
+	Z0Z_getDecoratorCallable,
+	Z0Z_setDatatypeModuleScalar,
+	Z0Z_setDecoratorCallable,
+	Z0Z_identifierCountFolds,
 )
 
 # Parameters for the prima donna
 from mapFolding.theSSOT import (
-    ParametersNumba,
-    parametersNumbaDEFAULT,
-    parametersNumbaFailEarly,
-    parametersNumbaParallelDEFAULT,
-    parametersNumbaSuperJit,
-    parametersNumbaSuperJitParallel,
+	ParametersNumba,
+	parametersNumbaDEFAULT,
+	parametersNumbaFailEarly,
+	parametersNumbaMinimum,
+	parametersNumbaParallelDEFAULT,
+	parametersNumbaSuperJit,
+	parametersNumbaSuperJitParallel,
 )
 
 # Coping
 from mapFolding.theSSOT import (
-    FREAKOUT,
+	FREAKOUT,
 )
 
 from mapFolding.beDRY import (
-    getFilenameFoldsTotal,
-    getPathFilenameFoldsTotal,
-    outfitCountFolds,
-    saveFoldsTotal,
+	getFilenameFoldsTotal,
+	getPathFilenameFoldsTotal,
+	outfitCountFolds,
+	saveFoldsTotal,
 )
 
 from mapFolding.basecamp import countFolds
 from mapFolding.oeis import clearOEIScache, getOEISids, oeisIDfor_n
 
 __all__ = [
-    'clearOEIScache',
-    'countFolds',
-    'getOEISids',
-    'oeisIDfor_n',
+	'clearOEIScache',
+	'countFolds',
+	'getOEISids',
+	'oeisIDfor_n',
 ]

mapFolding/basecamp.py

@@ -3,53 +3,53 @@ from typing import Optional, Sequence, Union
 import os
 
 def countFolds(listDimensions: Sequence[int]
-                , pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None
-                , computationDivisions: Optional[Union[int, str]] = None
-                , CPUlimit: Optional[Union[int, float, bool]] = None
-                , **keywordArguments: Optional[Union[str, bool]]
-                ) -> int:
-    """Count the total number of possible foldings for a given map dimensions.
-
-    Parameters:
-        listDimensions: List of integers representing the dimensions of the map to be folded.
-        pathLikeWriteFoldsTotal (None): Path, filename, or pathFilename to write the total fold count to.
-            If a directory is provided, creates a file with a default name based on map dimensions.
-        computationDivisions (None):
-            Whether and how to divide the computational work. See notes for details.
-        CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
-        **keywordArguments: Datatype management.
-    Returns:
-        foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
-
-    Computation divisions:
-        - None: no division of the computation into tasks; sets task divisions to 0
-        - int: direct set the number of task divisions; cannot exceed the map's total leaves
-        - "maximum": divides into `leavesTotal`-many `taskDivisions`
-        - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
-
-    Limits on CPU usage `CPUlimit`:
-        - `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
-        - `True`: Yes, limit the CPU usage; limits to 1 CPU.
-        - Integer `>= 1`: Limits usage to the specified number of CPUs.
-        - Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
-        - Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
-        - Integer `<= -1`: Subtract the absolute value from total CPUs.
-
-    N.B.: You probably don't want to divide the computation into tasks.
-        If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time, it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the computation time. If logicalCores >= leavesTotal, it will probably be faster. If logicalCores <= 2 * leavesTotal, it will almost certainly be slower for all map dimensions.
-    """
-    stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
-
-    pathFilenameFoldsTotal = None
-    if pathLikeWriteFoldsTotal is not None:
-        pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
-
-    dispatcher = getDispatcherCallable()
-    dispatcher(**stateUniversal)
-
-    foldsTotal = int(stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1])
-
-    if pathFilenameFoldsTotal is not None:
-        saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
-
-    return foldsTotal
+				, pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None
+				, computationDivisions: Optional[Union[int, str]] = None
+				, CPUlimit: Optional[Union[int, float, bool]] = None
+				, **keywordArguments: Optional[Union[str, bool]]
+				) -> int:
+	"""Count the total number of possible foldings for a given map dimensions.
+
+	Parameters:
+		listDimensions: List of integers representing the dimensions of the map to be folded.
+		pathLikeWriteFoldsTotal (None): Path, filename, or pathFilename to write the total fold count to.
+			If a directory is provided, creates a file with a default name based on map dimensions.
+		computationDivisions (None):
+			Whether and how to divide the computational work. See notes for details.
+		CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
+		**keywordArguments: Datatype management.
+	Returns:
+		foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
+
+	Computation divisions:
+		- None: no division of the computation into tasks; sets task divisions to 0
+		- int: direct set the number of task divisions; cannot exceed the map's total leaves
+		- "maximum": divides into `leavesTotal`-many `taskDivisions`
+		- "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
+
+	Limits on CPU usage `CPUlimit`:
+		- `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
+		- `True`: Yes, limit the CPU usage; limits to 1 CPU.
+		- Integer `>= 1`: Limits usage to the specified number of CPUs.
+		- Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
+		- Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
+		- Integer `<= -1`: Subtract the absolute value from total CPUs.
+
+	N.B.: You probably don't want to divide the computation into tasks.
+		If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time, it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the computation time. If logicalCores >= leavesTotal, it will probably be faster. If logicalCores <= 2 * leavesTotal, it will almost certainly be slower for all map dimensions.
+	"""
+	stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
+
+	pathFilenameFoldsTotal = None
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
+
+	dispatcher = getDispatcherCallable()
+	dispatcher(**stateUniversal)
+
+	foldsTotal = int(stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1])
+
+	if pathFilenameFoldsTotal is not None:
+		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
+
+	return foldsTotal