mapFolding 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

{mapFolding-0.2.6.dist-info → mapFolding-0.2.7.dist-info}/METADATA

@@ -1,18 +1,32 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.6
+Version: 0.2.7
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
-Project-URL: homepage, https://github.com/hunterhogan/mapFolding
-Requires-Python: <3.13,>=3.10
+License: CC-BY-NC-4.0
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Donate, https://www.patreon.com/integrated
+Keywords: A001415,A001416,A001417,A001418,A195646,folding,map folding,OEIS,stamp folding
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Other Audience
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: numba
 Requires-Dist: numpy
-Requires-Dist: Z0Z-tools
+Requires-Dist: Z0Z_tools
 Provides-Extra: benchmark
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: jupyter; 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: pytest; extra == "testing"
@@ -40,7 +54,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_ ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/oeis.bibtex) citation).
 
 ### Usage: command line
 

mapFolding-0.2.7.dist-info/RECORD

@@ -0,0 +1,19 @@
+benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
+reference/flattened.py,sha256=X9nvRzg7YDcpCtSDTL4YiidjshlX9rg2e6JVCY6i2u0,16547
+reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
+reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
+reference/jax.py,sha256=bB34dGdi3VSz4cRFbmCPn_erAmQ3FyrSED8uJ7CsES0,14961
+reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
+reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
+reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
+reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
+reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+someAssemblyRequired/inlineAfunction.py,sha256=_hGAxVSVUAKCsNT92p0--Y636HkudpxHDEClXKrmmNE,6181
+someAssemblyRequired/jobsAndTasks.py,sha256=zHgqvY4GHiCmH1fQrOHxsyDFUWoOcNtLAKPLwL6NVvU,2155
+someAssemblyRequired/makeNuitkaSource.py,sha256=jTK34OWzm6OsgFPd2mHwETxFo2X83io0M4YiEHRgk3U,3262
+someAssemblyRequired/makeNumbaJob.py,sha256=L1JORHfVKjBve7GjlE4-JMnzT7wJGJISGzLbWyRCyxU,5899
+mapFolding-0.2.7.dist-info/METADATA,sha256=i3nAtGhadvid_ODpCN9uXk9e4L3zQhXJfuElSQUmY50,7425
+mapFolding-0.2.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.7.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.7.dist-info/top_level.txt,sha256=yHhQq-bIJhB4pZcof5hXDTIjan0nxcFuOEWb7gy1DuU,42
+mapFolding-0.2.7.dist-info/RECORD,,

mapFolding-0.2.7.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+benchmarks
+reference
+someAssemblyRequired

{mapFolding/someAssemblyRequired → someAssemblyRequired}/inlineAfunction.py

@@ -1,11 +1,11 @@
-from mapFolding import indexMy, indexThe, indexTrack
+from mapFolding import indexMy, indexTrack
 import ast
 import copy
 import pathlib
 
 def getDictionaryEnumValues():
     dictionaryEnumValues = {}
-    for enumIndex in [indexMy, indexThe, indexTrack]:
+    for enumIndex in [indexMy, indexTrack]:
         for memberName, memberValue in enumIndex._member_map_.items():
             dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
     return dictionaryEnumValues

{mapFolding/someAssemblyRequired → someAssemblyRequired}/jobsAndTasks.py

@@ -1,10 +1,10 @@
-from typing import Any, Optional, Sequence, Type, Union
+from typing import Any, Optional, Sequence, Type
 
 def Z0Z_makeJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
     from mapFolding import outfitCountFolds
     stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
     from mapFolding.someAssemblyRequired.countInitializeNoNumba import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['the'], stateUniversal['track'])
+    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
     from mapFolding import getPathFilenameFoldsTotal
     pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
     import pathlib
@@ -35,11 +35,10 @@ def runJob(pathFilename):
     gapsWhere: numpy.ndarray = stateJob['gapsWhere']
     my: numpy.ndarray = stateJob['my']
     pathFilenameFoldsTotal: Final[Path] = stateJob['pathFilenameFoldsTotal']
-    the: Final[numpy.ndarray] = stateJob['the']
     track: numpy.ndarray = stateJob['track']
 
     from mapFolding.someAssemblyRequired.countSequentialNoNumba import countSequential
-    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track)
+    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, track)
 
     print(foldsSubTotals.sum().item())
     Path(pathFilenameFoldsTotal).parent.mkdir(parents=True, exist_ok=True)

{mapFolding/someAssemblyRequired → someAssemblyRequired}/makeNumbaJob.py

@@ -16,7 +16,7 @@ import pathlib
 import pickle
 import python_minifier
 
-listDimensions = [6,6]
+listDimensions = [5,5]
 
 # NOTE this overwrites files
 Z0Z_inlineMapFolding()
@@ -38,22 +38,23 @@ def writeModuleWithNumba(listDimensions):
     datatypeDefault = 'uint8'
     numpy_dtypeDefault = make_dtype(datatypeDefault)
     numpy_dtypeSmall = numpy_dtypeDefault
-
+    # forceinline=True might actually be useful
     parametersNumba = f"numba.types.{datatypeLarge}(), \
 cache=True, \
+nopython=True, \
+fastmath=True, \
+forceinline=True, \
+inline='always', \
+looplift=False, \
+_nrt=True, \
+error_model='numpy', \
+parallel=False, \
+boundscheck=False, \
+no_cfunc_wrapper=False, \
+no_cpython_wrapper=False, \
 "
 # no_cfunc_wrapper=True, \
 # no_cpython_wrapper=True, \
-# _nrt=True, \
-# nopython=True, \
-# parallel=False, \
-# boundscheck=False, \
-# error_model='numpy', \
-# fastmath=True, \
-# no_cfunc_wrapper=False, \
-# no_cpython_wrapper=False, \
-# looplift=True, \
-# forceinline=True, \
 
     pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge, datatypeSmall=numpy_dtypeSmall)
 
@@ -74,14 +75,13 @@ cache=True, \
     linesDataDynamic = "\n".join([linesDataDynamic
             , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
             , ImaIndent + convertNDArrayToStr(stateJob['my'], 'my')
-            , ImaIndent + convertNDArrayToStr(stateJob['foldsSubTotals'], 'foldsSubTotals')
+            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
             , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
             , ImaIndent + convertNDArrayToStr(stateJob['track'], 'track')
             ])
 
     linesDataStatic = """"""
     linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + convertNDArrayToStr(stateJob['the'], 'the')
             , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
             ])
 
@@ -106,11 +106,14 @@ cache=True, \
     linesLaunch = """"""
     linesLaunch = linesLaunch + f"""
 if __name__ == '__main__':
-    {identifierCallableLaunch}()"""
+    import time
+    timeStart = time.perf_counter()
+    {identifierCallableLaunch}()
+    print(time.perf_counter() - timeStart)"""
 
     linesWriteFoldsTotal = """"""
     linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
-                                    , "    foldsTotal = foldsSubTotals.sum().item()"
+                                    , "    foldsTotal = foldGroups[0:-1].sum() * foldGroups[-1]"
                                     , "    print(foldsTotal)"
                                     , "    with numba.objmode():"
                                     , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"

mapFolding/__init__.py

@@ -1,12 +0,0 @@
-from .theSSOT import *
-from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getFilenameFoldsTotal, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
-from .startHere import countFolds
-from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
-
-__all__ = [
-    'clearOEIScache',
-    'countFolds',
-    'getOEISids',
-    'oeisIDfor_n',
-]

mapFolding/babbage.py

@@ -1,35 +0,0 @@
-from mapFolding.importSelector import countSequential, countParallel, countInitialize
-from mapFolding import indexMy
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, Tuple
-import numba
-import numpy
-
-@numba.jit(cache=True)
-def _countFolds(connectionGraph: NDArray[integer[Any]], foldGroups: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], track: NDArray[integer[Any]]):
-    """
-    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 `countFoldsCompiled`, which is the function that does the hard, so that we can delay `numba.jit` compilation of `countFoldsCompiled`.
-    - `countFoldsCompiled` is not merely "jitted", it is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
-    - The function in this module is jitted, so it can talk to `countFoldsCompiled`, and because it isn't so arrogant, it will talk to the low-class `countFolds` with only a few restrictions, such as:
-        - No `TypedDict`
-        - No Python v 3.13
-        - The plebs must clean up their own memory problems
-        - No oversized integers
-        - No global variables, only global constants
-        - They don't except pleb nonlocal variables either
-        - Python "class": they are all inferior to a jit
-        - No `**kwargs`
-        - and just a few dozen-jillion other things.
-
-    """
-    # print("babbage")
-    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, track=track)
-
-    if my[indexMy.taskDivisions.value] > 0:
-        countParallel(connectionGraph=connectionGraph, foldGroups=foldGroups, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, trackPARALLEL=track)
-    else:
-        countSequential(connectionGraph=connectionGraph, foldGroups=foldGroups, gapsWhere=gapsWhere, my=my, track=track)

mapFolding/beDRY.py

@@ -1,319 +0,0 @@
-"""A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge, dtypeSmall, pathJobDEFAULT
-from mapFolding import indexMy, indexTrack, computationState
-from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, List, Optional, Sequence, Type, Union
-import numba
-import numpy
-import os
-import pathlib
-import sys
-
-def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
-    return str(sorted(listDimensions)).replace(', ', 'x').replace('[', 'p').replace(']', '') + '.foldsTotal'
-
-def getLeavesTotal(listDimensions: Sequence[int]) -> int:
-    """
-    How many leaves are in the map.
-
-    Parameters:
-        listDimensions: A list of integers representing dimensions.
-
-    Returns:
-        productDimensions: The product of all positive integer dimensions.
-    """
-    listNonNegative = parseDimensions(listDimensions, 'listDimensions')
-    listPositive = [dimension for dimension in listNonNegative if dimension > 0]
-
-    if not listPositive:
-        return 0
-    else:
-        productDimensions = 1
-        for dimension in listPositive:
-            if dimension > sys.maxsize // productDimensions:
-                raise OverflowError(f"I received {dimension=} in {listDimensions=}, but the product of the dimensions exceeds the maximum size of an integer on this system.")
-            productDimensions *= dimension
-
-        return productDimensions
-
-def getPathFilenameFoldsTotal(listDimensions: Sequence[int], pathishWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
-    pathFilenameFoldsTotal = pathlib.Path(pathishWriteFoldsTotal) if pathishWriteFoldsTotal is not None else pathJobDEFAULT
-    if pathFilenameFoldsTotal.is_dir():
-        filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(listDimensions)
-        pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
-    pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-    return pathFilenameFoldsTotal
-
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
-    """
-    Determines whether or how to divide the computation into tasks.
-
-    Parameters
-    ----------
-    computationDivisions (None):
-        Specifies how to divide computations:
-        - 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`
-    concurrencyLimit:
-        Maximum number of concurrent tasks allowed
-    listDimensions: for error reporting
-    CPUlimit: for error reporting
-
-    Returns
-    -------
-    taskDivisions:
-
-    Raises
-    ------
-    ValueError
-        If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves
-
-    Notes
-    -----
-    Task divisions cannot exceed total leaves to prevent duplicate counting of folds.
-    """
-    if not computationDivisions:
-        return 0
-    else:
-        leavesTotal = getLeavesTotal(listDimensions)
-    if isinstance(computationDivisions, int):
-        taskDivisions = computationDivisions
-    elif isinstance(computationDivisions, str):
-        computationDivisions = computationDivisions.lower()
-        if computationDivisions == "maximum":
-            taskDivisions = leavesTotal
-        elif computationDivisions == "cpu":
-            taskDivisions = min(concurrencyLimit, leavesTotal)
-    else:
-        raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
-
-    if taskDivisions > leavesTotal:
-        raise ValueError(f"Problem: `taskDivisions`, ({taskDivisions}), is greater than `leavesTotal`, ({leavesTotal}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.\n\nFor those parameters, I received {computationDivisions=}, {CPUlimit=}, and {listDimensions=}.\n\nPotential solutions: get a different hobby or set `computationDivisions` to a different value.")
-
-    return taskDivisions
-
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
-    """
-    Constructs a multi-dimensional connection graph representing the connections between the leaves of a map with the given dimensions.
-    Also called a Cartesian product decomposition or dimensional product mapping.
-
-    Parameters
-        listDimensions: A sequence of integers representing the dimensions of the map.
-
-    Returns
-        connectionGraph: A 3D numpy array with shape of (dimensionsTotal, leavesTotal + 1, leavesTotal + 1).
-    """
-    datatype = keywordArguments.get('datatype', dtypeDefault)
-    mapShape = validateListDimensions(listDimensions)
-    leavesTotal = getLeavesTotal(mapShape)
-    arrayDimensions = numpy.array(mapShape, dtype=datatype)
-    dimensionsTotal = len(arrayDimensions)
-
-    # Step 1: find the cumulative product of the map's dimensions
-    cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
-
-    # Step 2: create a coordinate system
-    coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=datatype)
-
-    for indexDimension in range(dimensionsTotal):
-        for leaf1ndex in range(1, leavesTotal + 1):
-            coordinateSystem[indexDimension, leaf1ndex] = (
-                ((leaf1ndex - 1) // cumulativeProduct[indexDimension]) %
-                arrayDimensions[indexDimension] + 1
-            )
-
-    # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
-
-    for indexDimension in range(dimensionsTotal):
-        for activeLeaf1ndex in range(1, leavesTotal + 1):
-            for connectee1ndex in range(1, activeLeaf1ndex + 1):
-                # Base coordinate conditions
-                isFirstCoord = coordinateSystem[indexDimension, connectee1ndex] == 1
-                isLastCoord = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
-                exceedsActive = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
-
-                # Parity check
-                isEvenParity = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == \
-                                (coordinateSystem[indexDimension, connectee1ndex] & 1)
-
-                # Determine connection value
-                if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
-                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex
-                elif isEvenParity and not isFirstCoord:
-                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[indexDimension]
-                elif not isEvenParity and not (isLastCoord or exceedsActive):
-                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[indexDimension]
-
-    return connectionGraph
-
-def makeDataContainer(shape, datatype: Optional[Type] = None):
-    """Create a container, probably numpy.ndarray, with the given shape and datatype."""
-    if datatype is None:
-        datatype = dtypeDefault
-    return numpy.zeros(shape, dtype=datatype)
-
-def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type[Any]]) -> computationState:
-    """
-    Initializes and configures the computation state for map folding computations.
-
-    Parameters
-    ----------
-    listDimensions:
-        The dimensions of the map to be folded
-    computationDivisions (None):
-        Specifies how to divide computations:
-        - 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`
-    CPUlimit (None):
-        Whether and how to limit the CPU usage. See notes for details.
-
-    Returns
-    -------
-    computationState
-        An initialized computation state containing:
-        - connectionGraph: Graph representing connections in the map
-        - foldsSubTotals: Array tracking total folds
-        - mapShape: Validated and sorted dimensions of the map
-        - my: Array for internal state tracking
-        - gapsWhere: Array tracking gap positions
-        - the: Static settings and metadata
-        - track: Array for tracking computation progress
-
-    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.
-    """
-    datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
-    datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
-    datatypeSmall = keywordArguments.get('datatypeSmall', dtypeSmall)
-
-    my = makeDataContainer(len(indexMy), datatypeDefault)
-
-    mapShape = tuple(sorted(validateListDimensions(listDimensions)))
-    concurrencyLimit = setCPUlimit(CPUlimit)
-    my[indexMy.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, mapShape)
-
-    foldGroups = makeDataContainer(max(my[indexMy.taskDivisions] + 1, 2), datatypeLarge)
-    foldGroups[-1] = leavesTotal = getLeavesTotal(mapShape)
-
-    my[indexMy.dimensionsTotal] = len(mapShape)
-    my[indexMy.leaf1ndex] = 1
-    stateInitialized = computationState(
-        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeSmall),
-        foldGroups = foldGroups,
-        mapShape = mapShape,
-        my = my,
-        gapsWhere = makeDataContainer(int(leavesTotal) * int(leavesTotal) + 1, datatypeSmall),
-        track = makeDataContainer((len(indexTrack), leavesTotal + 1), datatypeDefault)
-        )
-
-
-    return stateInitialized
-
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> List[int]:
-    """
-    Parse and validate dimensions are non-negative integers.
-
-    Parameters:
-        dimensions: Sequence of integers representing dimensions
-        parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'
-    Returns:
-        listNonNegative: List of validated non-negative integers
-    Raises:
-        ValueError: If any dimension is negative or if the list is empty
-        TypeError: If any element cannot be converted to integer (raised by intInnit)
-    """
-    listValidated = intInnit(dimensions, parameterName)
-    listNonNegative = []
-    for dimension in listValidated:
-        if dimension < 0:
-            raise ValueError(f"Dimension {dimension} must be non-negative")
-        listNonNegative.append(dimension)
-
-    return listNonNegative
-
-def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int) -> None:
-    """
-    Save foldsTotal with multiple fallback mechanisms.
-
-    Parameters:
-        pathFilename: Target save location
-        foldsTotal: Critical computed value to save
-    """
-    try:
-        pathFilenameFoldsTotal = pathlib.Path(pathFilename)
-        pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-        pathFilenameFoldsTotal.write_text(str(foldsTotal))
-    except Exception as ERRORmessage:
-        try:
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-            print(ERRORmessage)
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-            randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
-            filenameInfixUnique = ''.join(randomnessPlanB)
-            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
-            writeStreamFallback = open(pathFilenamePlanB, 'w')
-            writeStreamFallback.write(str(foldsTotal))
-            writeStreamFallback.close()
-            print(str(pathFilenamePlanB))
-        except:
-            print(foldsTotal)
-
-def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
-    """Sets CPU limit for Numba concurrent operations. Note that it can only affect Numba-jitted functions that have not yet been imported.
-
-    Parameters:
-        CPUlimit: whether and how to limit the CPU usage. See notes for details.
-    Returns:
-        concurrencyLimit: The actual concurrency limit that was set
-    Raises:
-        TypeError: If CPUlimit is not of the expected types
-
-    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.
-    """
-    if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
-        CPUlimit = oopsieKwargsie(CPUlimit)
-
-    concurrencyLimit = defineConcurrencyLimit(CPUlimit)
-    numba.set_num_threads(concurrencyLimit)
-
-    return concurrencyLimit
-
-def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
-    """
-    Validates and sorts a sequence of at least two positive dimensions.
-
-    Parameters:
-        listDimensions: A sequence of integer dimensions to be validated.
-
-    Returns:
-        dimensionsValidSorted: A list, with at least two elements, of only positive integers.
-
-    Raises:
-        ValueError: If the input listDimensions is None.
-        NotImplementedError: If the resulting list of positive dimensions has fewer than two elements.
-    """
-    if not listDimensions:
-        raise ValueError(f"listDimensions is a required parameter.")
-    listNonNegative = parseDimensions(listDimensions, 'listDimensions')
-    dimensionsValid = [dimension for dimension in listNonNegative if dimension > 0]
-    if len(dimensionsValid) < 2:
-        raise NotImplementedError(f"This function requires listDimensions, {listDimensions}, to have at least two dimensions greater than 0. You may want to look at https://oeis.org/.")
-    return sorted(dimensionsValid)

mapFolding/importSelector.py

@@ -1,7 +0,0 @@
-from mapFolding.lovelace import countSequential
-from mapFolding.lovelace import countParallel
-from mapFolding.lovelace import countInitialize
-
-# from mapFolding.someAssemblyRequired.countSequential import countSequential
-# from mapFolding.someAssemblyRequired.countParallel import countParallel
-# from mapFolding.someAssemblyRequired.countInitialize import countInitialize