mapFolding 0.3.0__tar.gz → 0.3.1__tar.gz

{mapfolding-0.3.0 → mapfolding-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.0
+Version: 0.3.1
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.3.0 → mapfolding-0.3.1}/mapFolding/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.0
+Version: 0.3.1
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.3.0 → mapfolding-0.3.1}/mapFolding/mapFolding.egg-info/SOURCES.txt

@@ -20,6 +20,8 @@ mapFolding/someAssemblyRequired/__init__.py
 mapFolding/someAssemblyRequired/countInitialize.py
 mapFolding/someAssemblyRequired/countParallel.py
 mapFolding/someAssemblyRequired/countSequential.py
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py
+mapFolding/someAssemblyRequired/synthesizeJob.py
 mapFolding/someAssemblyRequired/synthesizeModules.py
 tests/test_oeis.py
 tests/test_other.py

{mapfolding-0.3.0 → mapfolding-0.3.1}/mapFolding/reference/flattened.py

@@ -236,7 +236,7 @@ class computationState(TypedDict):
     track: NDArray[integer[Any]]
 
 dtypeLarge = numpy.int64
-dtypeDefault = dtypeLarge
+dtypeMedium = dtypeLarge
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -284,7 +284,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
     return taskDivisions
 
 def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
-    datatype = keywordArguments.get('datatype', dtypeDefault)
+    datatype = keywordArguments.get('datatype', dtypeMedium)
     mapShape = validateListDimensions(listDimensions)
     leavesTotal = getLeavesTotal(mapShape)
     arrayDimensions = numpy.array(mapShape, dtype=datatype)
@@ -317,14 +317,14 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 
 def makeDataContainer(shape, datatype: Optional[Type] = None):
     if datatype is None:
-        datatype = dtypeDefault
+        datatype = dtypeMedium
     return numpy.zeros(shape, dtype=datatype)
 
 def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
-    datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
+    datatypeMedium = keywordArguments.get('datatypeMedium', dtypeMedium)
     datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
 
-    the = makeDataContainer(len(indexThe), datatypeDefault)
+    the = makeDataContainer(len(indexThe), datatypeMedium)
 
     mapShape = tuple(sorted(validateListDimensions(listDimensions)))
     the[indexThe.leavesTotal] = getLeavesTotal(mapShape)
@@ -333,11 +333,11 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
 
     stateInitialized = computationState(
-        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
+        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeMedium),
         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),
+        gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeMedium),
         the = the,
         track = makeDataContainer((len(indexTrack), the[indexThe.leavesTotal] + 1), datatypeLarge)
         )

{mapfolding-0.3.0 → mapfolding-0.3.1}/mapFolding/reference/hunterNumba.py

@@ -19,7 +19,7 @@ def countFolds(listDimensions: List[int]) -> int:
     def integerLarge(value) -> numpy.uint64:
         return numpy.uint64(value)
 
-    dtypeDefault = numpy.uint8
+    dtypeMedium = numpy.uint8
     dtypeMaximum = numpy.uint16
 
     leavesTotal = integerSmall(1)
@@ -30,19 +30,19 @@ def countFolds(listDimensions: List[int]) -> int:
     """How to build a leaf connection graph, also called a "Cartesian Product Decomposition"
     or a "Dimensional Product Mapping", with sentinels:
     Step 1: find the cumulative product of the map's dimensions"""
-    cumulativeProduct = numpy.ones(dimensionsTotal + 1, dtype=dtypeDefault)
+    cumulativeProduct = numpy.ones(dimensionsTotal + 1, dtype=dtypeMedium)
     for dimension1ndex in range(1, dimensionsTotal + 1):
         cumulativeProduct[dimension1ndex] = cumulativeProduct[dimension1ndex - 1] * listDimensions[dimension1ndex - 1]
 
     """Step 2: for each dimension, create a coordinate system """
     """coordinateSystem[dimension1ndex, leaf1ndex] holds the dimension1ndex-th coordinate of leaf leaf1ndex"""
-    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
+    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeMedium)
     for dimension1ndex in range(1, dimensionsTotal + 1):
         for leaf1ndex in range(1, leavesTotal + 1):
             coordinateSystem[dimension1ndex, leaf1ndex] = ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) % listDimensions[dimension1ndex - 1] + 1
 
     """Step 3: create a huge empty connection graph"""
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
+    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeMedium)
 
     """Step for... for... for...: fill the connection graph"""
     for dimension1ndex in range(1, dimensionsTotal + 1):
@@ -61,7 +61,7 @@ def countFolds(listDimensions: List[int]) -> int:
     leafBelow = numba.literally(1)
     countDimensionsGapped = numba.literally(2)
     gapRangeStart = numba.literally(3)
-    track = numpy.zeros((4, leavesTotal + 1), dtype=dtypeDefault)
+    track = numpy.zeros((4, leavesTotal + 1), dtype=dtypeMedium)
 
     gapsWhere = numpy.zeros(integerLarge(integerLarge(leavesTotal) * integerLarge(leavesTotal) + 1), dtype=dtypeMaximum)
 

{mapfolding-0.3.0 → mapfolding-0.3.1}/mapFolding/reference/jax.py

@@ -5,7 +5,7 @@ from typing import List, Tuple
 import jax
 import jaxtyping
 
-dtypeDefault = jax.numpy.uint32
+dtypeMedium = jax.numpy.uint32
 dtypeMaximum = jax.numpy.uint32
 
 def countFolds(listDimensions: List[int]) -> int:
@@ -15,7 +15,7 @@ def countFolds(listDimensions: List[int]) -> int:
     d: int = len(listDimensions)
     import numpy
     D: numpy.ndarray = makeConnectionGraph(listDimensionsPositive)
-    connectionGraph = jax.numpy.asarray(D, dtype=dtypeDefault)
+    connectionGraph = jax.numpy.asarray(D, dtype=dtypeMedium)
     del listDimensionsPositive
 
     return foldingsJAX(n, d, connectionGraph)
@@ -191,10 +191,10 @@ def foldingsJAX(leavesTotal: jaxtyping.UInt32, dimensionsTotal: jaxtyping.UInt32
         return (leafAbove, leafBelow, allValues[2], gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
 
     # Dynamic values
-    A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
+    A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+    B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+    count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+    gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
     gap = jax.numpy.zeros(leavesTotal * leavesTotal + 1, dtype=dtypeMaximum)
 
     foldingsTotal = jax.numpy.uint32(0)

mapfolding-0.3.1/mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -0,0 +1,19 @@
+import importlib
+import importlib.util
+import llvmlite.binding
+import pathlib
+
+def writeModuleLLVM(pathFilename: pathlib.Path, identifierCallable: str) -> pathlib.Path:
+    """Import the generated module directly and get its LLVM IR."""
+    specTarget = importlib.util.spec_from_file_location("generatedModule", pathFilename)
+    if specTarget is None or specTarget.loader is None:
+        raise ImportError(f"Could not create module spec or loader for {pathFilename}")
+    moduleTarget = importlib.util.module_from_spec(specTarget)
+    specTarget.loader.exec_module(moduleTarget)
+
+    # Get LLVM IR and write to file
+    linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
+    moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
+    pathFilenameLLVM = pathFilename.with_suffix(".ll")
+    pathFilenameLLVM.write_text(str(moduleLLVM))
+    return pathFilenameLLVM

mapfolding-0.3.1/mapFolding/someAssemblyRequired/synthesizeJob.py

@@ -0,0 +1,170 @@
+from mapFolding import getPathFilenameFoldsTotal, dtypeNumpyDefaults, thisSeemsVeryComplicated
+from mapFolding import make_dtype, datatypeLarge, dtypeLarge, datatypeMedium, dtypeMedium, datatypeSmall, dtypeSmall
+from mapFolding import outfitCountFolds, computationState, indexMy, indexTrack
+from someAssemblyRequired import countInitialize, countSequential
+from typing import Any, Optional, Sequence, Type
+import more_itertools
+import inspect
+import numpy
+import pathlib
+import pickle
+import python_minifier
+
+identifierCallableLaunch = "goGoGadgetAbsurdity"
+
+def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
+    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
+
+    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
+    suffix = pathFilenameChopChop.suffix
+    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
+    pathJob.mkdir(parents=True, exist_ok=True)
+    pathFilenameJob = pathJob / 'stateJob.pkl'
+
+    pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
+    return pathFilenameJob
+
+def convertNDArrayToStr(arrayTarget: numpy.ndarray, identifierName: str) -> str:
+    def process_nested_array(arraySlice):
+        if isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim > 1:
+            return [process_nested_array(arraySlice[index]) for index in range(arraySlice.shape[0])]
+        elif isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim == 1:
+            listWithRanges = []
+            for group in more_itertools.consecutive_groups(arraySlice.tolist()):
+                ImaSerious = list(group)
+                if len(ImaSerious) <= 4:
+                    listWithRanges += ImaSerious
+                else:
+                    ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
+                    listWithRanges += ImaRange
+            return listWithRanges
+        return arraySlice
+
+    arrayAsNestedLists = process_nested_array(arrayTarget)
+
+    stringMinimized = python_minifier.minify(str(arrayAsNestedLists))
+    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))
+
+    stringMinimized = stringMinimized.replace('range', '*range')
+
+    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
+
+def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> pathlib.Path:
+    datatypeLargeAsStr = keywordArguments.get('datatypeLarge', thisSeemsVeryComplicated.datatypeLarge)
+    datatypeMediumAsStr = keywordArguments.get('datatypeMedium', thisSeemsVeryComplicated.datatypeMedium)
+    datatypeSmallAsStr = keywordArguments.get('datatypeSmall', thisSeemsVeryComplicated.datatypeSmall)
+
+    numpy_dtypeLarge = make_dtype(datatypeLargeAsStr) # type: ignore
+    numpy_dtypeMedium = make_dtype(datatypeMediumAsStr) # type: ignore
+    numpy_dtypeSmall = make_dtype(datatypeSmallAsStr) # type: ignore
+
+    pathFilenameJob = makeStateJob(listDimensions, dtypeLarge = numpy_dtypeLarge, dtypeMedium = numpy_dtypeMedium, dtypeSmall = numpy_dtypeSmall)
+    stateJob: computationState = pickle.loads(pathFilenameJob.read_bytes())
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'], pathFilenameJob.parent)
+
+    codeSource = inspect.getsource(countSequential)
+
+    # forceinline=True might actually be useful
+    parametersNumba = f"numba.types.{datatypeLargeAsStr}(), \
+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, \
+
+    lineNumba = f"@numba.jit({parametersNumba})"
+
+    linesImport = "\n".join([
+                        "import numpy"
+                        , "import numba"
+                        ])
+
+    ImaIndent = '    '
+    linesDataDynamic = """"""
+    linesDataDynamic = "\n".join([linesDataDynamic
+            , ImaIndent + f"foldsTotal = numba.types.{datatypeLargeAsStr}(0)"
+            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
+            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
+            ])
+
+    linesDataStatic = """"""
+    linesDataStatic = "\n".join([linesDataStatic
+            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
+            ])
+
+    my = stateJob['my']
+    track = stateJob['track']
+    linesAlgorithm = """"""
+    for lineSource in codeSource.splitlines():
+        if lineSource.startswith(('#', 'import', 'from', '@numba.jit')):
+            continue
+        elif not lineSource:
+            continue
+        elif lineSource.startswith('def '):
+            lineSource = "\n".join([lineNumba
+                                , f"def {identifierCallableLaunch}():"
+                                , linesDataDynamic
+                                , linesDataStatic
+                                ])
+        elif 'my[indexMy.' in lineSource:
+            # leaf1ndex = my[indexMy.leaf1ndex.value]
+            identifier, statement = lineSource.split('=')
+            lineSource = ImaIndent + identifier.strip() + '=' + str(eval(statement.strip()))
+        elif 'track[indexTrack.' in lineSource:
+            # leafAbove = track[indexTrack.leafAbove.value]
+            identifier, statement = lineSource.split('=')
+            lineSource = ImaIndent + convertNDArrayToStr(eval(statement.strip()), identifier.strip())
+
+        linesAlgorithm = "\n".join([linesAlgorithm
+                            , lineSource
+                            ])
+
+    linesLaunch = """"""
+    linesLaunch = linesLaunch + f"""
+if __name__ == '__main__':
+    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)"
+                                    , "    with numba.objmode():"
+                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    , "    return foldsTotal"
+                                    ])
+
+    linesAll = "\n".join([
+                        linesImport
+                        , linesAlgorithm
+                        , linesWriteFoldsTotal
+                        , linesLaunch
+                        ])
+
+    pathFilenameDestination = pathFilenameJob.with_stem(pathFilenameJob.parent.name).with_suffix(".py")
+    pathFilenameDestination.write_text(linesAll)
+
+    return pathFilenameDestination
+
+if __name__ == '__main__':
+    listDimensions = [3,15]
+    datatypeLarge = 'int64'
+    datatypeMedium = 'uint8'
+    datatypeSmall = datatypeMedium
+    writeModuleWithNumba(listDimensions, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)

{mapfolding-0.3.0 → mapfolding-0.3.1}/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -1,4 +1,4 @@
-from mapFolding import indexMy, indexTrack, theDao, datatypeDefault, datatypeLarge, datatypeSmall
+from mapFolding import indexMy, indexTrack, theDao, datatypeMedium, datatypeLarge, datatypeSmall
 import ast
 import pathlib
 import inspect
@@ -7,11 +7,11 @@ algorithmSource = theDao
 
 dictionaryDecorators={
     'countInitialize':
-    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeDefault}[::1], numba.{datatypeSmall}[::1], numba.{datatypeDefault}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
     'countParallel':
-    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeDefault}[::1], numba.{datatypeSmall}[::1], numba.{datatypeDefault}[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
     'countSequential':
-    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeDefault}[::1], numba.{datatypeSmall}[::1], numba.{datatypeDefault}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
     }
 
 def getDictionaryEnumValues():

{mapfolding-0.3.0 → mapfolding-0.3.1}/pyproject.toml

@@ -49,7 +49,7 @@ readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10,<3.14"
 scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
 urls = { Homepage = "https://github.com/hunterhogan/mapFolding", Donate = "https://www.patreon.com/integrated" }
-version = "0.3.0"
+version = "0.3.1"
 
 [tool.coverage]
 report = { exclude_lines = [

{mapfolding-0.3.0 → mapfolding-0.3.1}/tests/test_other.py

@@ -146,7 +146,7 @@ CPUlimit
     random: int, first included: 2, first excluded: (min(leavesTotal, 16) - 1)
     random: int, first included: -1 * (min(leavesTotal, 16) - 1), first excluded: -1
 
-datatypeDefault
+datatypeMedium
     None
     numpy.int64
     numpy.intc
@@ -172,7 +172,7 @@ def parameterIterator():
         'CPUlimit': [
             None, True, False, 0, 1, -1,
         ],
-        'datatypeDefault': [
+        'datatypeMedium': [
             None,
             numpy.int64,
             numpy.intc,