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

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

@@ -1,18 +1,32 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.5
+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
@@ -125,7 +125,7 @@ def Z0Z_inlineMapFolding():
 
     listPathFilenamesDestination: list[pathlib.Path] = []
     for callableTarget in listCallables:
-        pathFilenameDestination = pathFilenameSource.with_stem(callableTarget)
+        pathFilenameDestination = pathFilenameSource.parent / "someAssemblyRequired" / pathFilenameSource.with_stem(callableTarget).name
         codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues)
         pathFilenameDestination.write_text(codeInlined)
         listPathFilenamesDestination.append(pathFilenameDestination)

{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.countInitialize import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['the'], stateUniversal['track'])
+    from mapFolding.someAssemblyRequired.countInitializeNoNumba import countInitialize
+    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.countSequentialNoNumba import countSequential
-    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track)
+    from mapFolding.someAssemblyRequired.countSequentialNoNumba import countSequential
+    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, track)
 
     print(foldsSubTotals.sum().item())
     Path(pathFilenameFoldsTotal).parent.mkdir(parents=True, exist_ok=True)

{mapFolding/someAssemblyRequired → someAssemblyRequired}/makeNumbaJob.py

@@ -1,9 +1,12 @@
 """Create a python module hardcoded to compute a map's foldsTotal.
-NumPy ndarray.
-Numba optimized.
-Absolutely no other imports.
+- NumPy ndarray.
+- Numba optimized.
+- Absolutely no other imports.
+
+Can create LLVM IR from the module: of unknown utility.
 """
-from mapFolding import datatypeLarge, dtypeLarge, dtypeDefault
+# from mapFolding import dtypeDefault, dtypeSmall
+from mapFolding import make_dtype, datatypeLarge, dtypeLarge
 from mapFolding.someAssemblyRequired.inlineAfunction import Z0Z_inlineMapFolding
 from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
 import importlib
@@ -11,30 +14,51 @@ import llvmlite.binding
 import numpy
 import pathlib
 import pickle
+import python_minifier
 
-listDimensions = [3,7]
+listDimensions = [5,5]
 
 # NOTE this overwrites files
 Z0Z_inlineMapFolding()
 
 identifierCallableLaunch = "goGoGadgetAbsurdity"
 
-def archivistFormatsArrayToCode(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    """Format numpy array into a code string that recreates the array."""
-    arrayAsTypeStr = numpy.array2string(arrayTarget, threshold=10000, max_line_width=200, separator=',')
-    return f"{identifierName} = numpy.array({arrayAsTypeStr}, dtype=numpy.{arrayTarget.dtype})"
+def convertNDArrayToStr(arrayTarget: numpy.ndarray, identifierName: str) -> str:
+    arrayAsTypeStr = numpy.array2string(arrayTarget, threshold=100000, max_line_width=200, separator=',')
+    stringMinimized = python_minifier.minify(arrayAsTypeStr)
+    commaZeroMaximum = arrayTarget.shape[-1] - 1
+    stringMinimized = stringMinimized.replace('[0' + ',0'*commaZeroMaximum + ']', '[0]*'+str(commaZeroMaximum+1))
+    for countZeros in range(commaZeroMaximum, 2, -1):
+        stringMinimized = stringMinimized.replace(',0'*countZeros + ']', ']+[0]*'+str(countZeros))
+    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
 
 def writeModuleWithNumba(listDimensions):
     numpy_dtypeLarge = dtypeLarge
-    numpy_dtypeDefault = dtypeDefault
-
-    parametersNumba = f"numba.types.{datatypeLarge}(), cache=True, parallel=False, boundscheck=False, \
-        error_model='numpy', fastmath=True, nogil=True, nopython=True, _nrt=True, forceinline=True, \
-            inline=True, looplift=True, no_cfunc_wrapper=False, no_cpython_wrapper=False"
-
-    pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge)
-
-    pathFilenameAlgorithm = pathlib.Path('/apps/mapFolding/mapFolding/countSequentialNoNumba.py')
+    # numpy_dtypeDefault = dtypeDefault
+    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, \
+
+    pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge, datatypeSmall=numpy_dtypeSmall)
+
+    pathFilenameAlgorithm = pathlib.Path('/apps/mapFolding/mapFolding/someAssemblyRequired/countSequentialNoNumba.py')
     pathFilenameDestination = pathFilenameData.with_stem(pathFilenameData.parent.name).with_suffix(".py")
 
     lineNumba = f"@numba.jit({parametersNumba})"
@@ -49,16 +73,16 @@ def writeModuleWithNumba(listDimensions):
     ImaIndent = '    '
     linesDataDynamic = """"""
     linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['my'], 'my')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['foldsSubTotals'], 'foldsSubTotals')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['gapsWhere'], 'gapsWhere')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['track'], 'track')
+            , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
+            , ImaIndent + convertNDArrayToStr(stateJob['my'], 'my')
+            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
+            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
+            , ImaIndent + convertNDArrayToStr(stateJob['track'], 'track')
             ])
 
     linesDataStatic = """"""
     linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['the'], 'the')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['connectionGraph'], 'connectionGraph')
+            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
             ])
 
     pathFilenameFoldsTotal: pathlib.Path = stateJob['pathFilenameFoldsTotal']
@@ -79,26 +103,28 @@ def writeModuleWithNumba(listDimensions):
                             , lineSource
                             ])
 
-    lineReturn = f"{ImaIndent}return foldsSubTotals.sum().item()"
-
     linesLaunch = """"""
     linesLaunch = linesLaunch + f"""
 if __name__ == '__main__':
-    foldsTotal = {identifierCallableLaunch}()"""
+    import time
+    timeStart = time.perf_counter()
+    {identifierCallableLaunch}()
+    print(time.perf_counter() - timeStart)"""
 
     linesWriteFoldsTotal = """"""
     linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
+                                    , "    foldsTotal = foldGroups[0:-1].sum() * foldGroups[-1]"
                                     , "    print(foldsTotal)"
-                                    , f"    open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    , "    with numba.objmode():"
+                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    , "    return foldsTotal"
                                     ])
 
     linesAll = "\n".join([
                         linesImport
                         , linesAlgorithm
-                        , f"{ImaIndent}print(foldsSubTotals.sum().item())"
-                        , lineReturn
-                        , linesLaunch
                         , linesWriteFoldsTotal
+                        , linesLaunch
                         ])
 
     pathFilenameDestination.write_text(linesAll)

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 indexThe
-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]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], the: 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, the=the, track=track)
-
-    if the[indexThe.taskDivisions.value] > 0:
-        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, the=the, trackPARALLEL=track)
-    else:
-        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)

mapFolding/beDRY.py

@@ -1,325 +0,0 @@
-"""A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge, pathJobDEFAULT
-from mapFolding import indexMy, indexThe, 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') + '.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 + 1, 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 + 1, leavesTotal + 1), dtype=datatype)
-
-    for dimension1ndex in range(1, dimensionsTotal + 1):
-        for leaf1ndex in range(1, leavesTotal + 1):
-            coordinateSystem[dimension1ndex, leaf1ndex] = (
-                ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) %
-                arrayDimensions[dimension1ndex - 1] + 1
-            )
-
-    # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
-
-    for dimension1ndex in range(1, dimensionsTotal + 1):
-        for activeLeaf1ndex in range(1, leavesTotal + 1):
-            for connectee1ndex in range(1, activeLeaf1ndex + 1):
-                # Base coordinate conditions
-                isFirstCoord = coordinateSystem[dimension1ndex, connectee1ndex] == 1
-                isLastCoord = coordinateSystem[dimension1ndex, connectee1ndex] == arrayDimensions[dimension1ndex - 1]
-                exceedsActive = connectee1ndex + cumulativeProduct[dimension1ndex - 1] > activeLeaf1ndex
-
-                # Parity check
-                isEvenParity = (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == \
-                                (coordinateSystem[dimension1ndex, connectee1ndex] & 1)
-
-                # Determine connection value
-                if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
-                elif isEvenParity and not isFirstCoord:
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[dimension1ndex - 1]
-                elif not isEvenParity and not (isLastCoord or exceedsActive):
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[dimension1ndex - 1]
-                else:
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
-
-    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)
-
-    the = makeDataContainer(len(indexThe), datatypeDefault)
-
-    mapShape = tuple(sorted(validateListDimensions(listDimensions)))
-    the[indexThe.leavesTotal] = getLeavesTotal(mapShape)
-    the[indexThe.dimensionsTotal] = len(mapShape)
-    concurrencyLimit = setCPUlimit(CPUlimit)
-    the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
-
-    stateInitialized = computationState(
-        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
-        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
-        mapShape = mapShape,
-        my = makeDataContainer(len(indexMy), datatypeLarge),
-        gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeDefault),
-        the = the,
-        track = makeDataContainer((len(indexTrack), the[indexThe.leavesTotal] + 1), datatypeLarge)
-        )
-
-    stateInitialized['my'][indexMy.leaf1ndex.value] = 1
-
-    return stateInitialized
-
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
-    """
-    Parse and validate dimensions are non-negative integers.
-
-    Parameters:
-        dimensions: Sequence of integers representing dimensions
-        parameterName ('unnamed parameter'): Name of the parameter for error messages. Defaults to 'unnamed parameter'
-    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
-
-import tempfile
-import shutil
-import logging
-import os
-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
-    """
-    """Thoughts
-    Everything in a try block
-    Save it multiple times with multiple packages
-    no need for context managers, especially because they can cause errors"""
-    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)
-            import os
-            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
-            open(pathFilenamePlanB, 'w').write(str(foldsTotal))
-            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.countSequential import countSequential
-# from mapFolding.countParallel import countParallel
-# from mapFolding.countInitialize import countInitialize