mapFolding 0.2.5__tar.gz → 0.2.6__tar.gz

{mapfolding-0.2.5 → mapfolding-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.5
+Version: 0.2.6
 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

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding/babbage.py

@@ -1,5 +1,5 @@
 from mapFolding.importSelector import countSequential, countParallel, countInitialize
-from mapFolding import indexThe
+from mapFolding import indexMy
 from numpy import integer
 from numpy.typing import NDArray
 from typing import Any, Tuple
@@ -7,7 +7,7 @@ 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]]):
+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?
 
@@ -27,9 +27,9 @@ def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[
 
     """
     # print("babbage")
-    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=track)
+    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, track=track)
 
-    if the[indexThe.taskDivisions.value] > 0:
-        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, the=the, trackPARALLEL=track)
+    if my[indexMy.taskDivisions.value] > 0:
+        countParallel(connectionGraph=connectionGraph, foldGroups=foldGroups, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, trackPARALLEL=track)
     else:
-        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)
+        countSequential(connectionGraph=connectionGraph, foldGroups=foldGroups, gapsWhere=gapsWhere, my=my, track=track)

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding/beDRY.py

@@ -1,6 +1,6 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import dtypeDefault, dtypeLarge, pathJobDEFAULT
-from mapFolding import indexMy, indexThe, indexTrack, computationState
+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
@@ -12,7 +12,7 @@ import pathlib
 import sys
 
 def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
-    return str(sorted(listDimensions)).replace(', ', 'x') + '.foldsTotal'
+    return str(sorted(listDimensions)).replace(', ', 'x').replace('[', 'p').replace(']', '') + '.foldsTotal'
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -101,10 +101,11 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
     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:
+    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).
+
+    Returns
+        connectionGraph: A 3D numpy array with shape of (dimensionsTotal, leavesTotal + 1, leavesTotal + 1).
     """
     datatype = keywordArguments.get('datatype', dtypeDefault)
     mapShape = validateListDimensions(listDimensions)
@@ -116,39 +117,37 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
     cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
 
     # Step 2: create a coordinate system
-    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=datatype)
+    coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=datatype)
 
-    for dimension1ndex in range(1, dimensionsTotal + 1):
+    for indexDimension in range(dimensionsTotal):
         for leaf1ndex in range(1, leavesTotal + 1):
-            coordinateSystem[dimension1ndex, leaf1ndex] = (
-                ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) %
-                arrayDimensions[dimension1ndex - 1] + 1
+            coordinateSystem[indexDimension, leaf1ndex] = (
+                ((leaf1ndex - 1) // cumulativeProduct[indexDimension]) %
+                arrayDimensions[indexDimension] + 1
             )
 
     # Step 3: create and fill the connection graph
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
+    connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
 
-    for dimension1ndex in range(1, dimensionsTotal + 1):
+    for indexDimension in range(dimensionsTotal):
         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
+                isFirstCoord = coordinateSystem[indexDimension, connectee1ndex] == 1
+                isLastCoord = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
+                exceedsActive = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
 
                 # Parity check
-                isEvenParity = (coordinateSystem[dimension1ndex, activeLeaf1ndex] & 1) == \
-                                (coordinateSystem[dimension1ndex, connectee1ndex] & 1)
+                isEvenParity = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == \
+                                (coordinateSystem[indexDimension, connectee1ndex] & 1)
 
                 # Determine connection value
                 if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex
                 elif isEvenParity and not isFirstCoord:
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[dimension1ndex - 1]
+                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[indexDimension]
                 elif not isEvenParity and not (isLastCoord or exceedsActive):
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[dimension1ndex - 1]
-                else:
-                    connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+                    connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[indexDimension]
 
     return connectionGraph
 
@@ -197,36 +196,38 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
     """
     datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
     datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
+    datatypeSmall = keywordArguments.get('datatypeSmall', dtypeSmall)
 
-    the = makeDataContainer(len(indexThe), datatypeDefault)
+    my = makeDataContainer(len(indexMy), 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)
+    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=datatypeDefault),
-        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
+        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeSmall),
+        foldGroups = foldGroups,
         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)
+        my = my,
+        gapsWhere = makeDataContainer(int(leavesTotal) * int(leavesTotal) + 1, datatypeSmall),
+        track = makeDataContainer((len(indexTrack), leavesTotal + 1), datatypeDefault)
         )
 
-    stateInitialized['my'][indexMy.leaf1ndex.value] = 1
 
     return stateInitialized
 
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
+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 ('unnamed parameter'): Name of the parameter for error messages. Defaults to 'unnamed parameter'
+        parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'
     Returns:
         listNonNegative: List of validated non-negative integers
     Raises:
@@ -242,10 +243,6 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
 
     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.
@@ -254,10 +251,6 @@ def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int)
         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)
@@ -269,9 +262,10 @@ def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int)
             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))
+            writeStreamFallback = open(pathFilenamePlanB, 'w')
+            writeStreamFallback.write(str(foldsTotal))
+            writeStreamFallback.close()
             print(str(pathFilenamePlanB))
         except:
             print(foldsTotal)

mapfolding-0.2.6/mapFolding/importSelector.py

@@ -0,0 +1,7 @@
+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

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding/lovelace.py

@@ -1,4 +1,4 @@
-from mapFolding import indexMy, indexThe, indexTrack
+from mapFolding import indexMy, indexTrack
 import numba
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
@@ -10,16 +10,16 @@ def activeLeafGreaterThan0Condition(my):
     return my[indexMy.leaf1ndex.value] > 0
 
 @numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def activeLeafGreaterThanLeavesTotalCondition(my, the):
-    return my[indexMy.leaf1ndex.value] > the[indexThe.leavesTotal.value]
+def activeLeafGreaterThanLeavesTotalCondition(foldGroups, my):
+    return my[indexMy.leaf1ndex.value] > foldGroups[-1] # leavesTotal
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def activeLeafIsTheFirstLeafCondition(my):
     return my[indexMy.leaf1ndex.value] <= 1
 
 @numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def allDimensionsAreUnconstrained(my, the):
-    return my[indexMy.dimensionsUnconstrained.value] == the[indexThe.dimensionsTotal.value]
+def allDimensionsAreUnconstrained(my):
+    return my[indexMy.dimensionsUnconstrained.value] == my[indexMy.dimensionsTotal.value]
 
 @numba.jit((numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def backtrack(my, track):
@@ -44,20 +44,20 @@ def countGaps(gapsWhere, my, track):
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def dimension1ndexIncrement(my):
-    my[indexMy.dimension1ndex.value] += 1
+    my[indexMy.indexDimension.value] += 1
 
 @numba.jit((numba.int64[:,:,::1], numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def dimensionsUnconstrainedCondition(connectionGraph, my):
-    return connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
+    return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def dimensionsUnconstrainedIncrement(my):
     my[indexMy.dimensionsUnconstrained.value] += 1
 
 @numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def filterCommonGaps(gapsWhere, my, the, track):
+def filterCommonGaps(gapsWhere, my, track):
     gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-    if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == the[indexThe.dimensionsTotal.value] - my[indexMy.dimensionsUnconstrained.value]:
+    if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsTotal.value] - my[indexMy.dimensionsUnconstrained.value]:
         activeGapIncrement(my=my)
     track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
 
@@ -65,11 +65,11 @@ def filterCommonGaps(gapsWhere, my, the, track):
 def findGapsInitializeVariables(my, track):
     my[indexMy.dimensionsUnconstrained.value] = 0
     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-    my[indexMy.dimension1ndex.value] = 1
+    my[indexMy.indexDimension.value] = 0
 
 @numba.jit((numba.int64[::1],numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def foldsSubTotalIncrement(foldsSubTotals, my, the):
-    foldsSubTotals[my[indexMy.taskIndex.value]] += the[indexThe.leavesTotal.value]
+def foldsSubTotalIncrement(foldGroups, my):
+    foldGroups[my[indexMy.taskIndex.value]] += 1
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def indexMiniGapIncrement(my):
@@ -93,19 +93,19 @@ def leafBelowSentinelIs1Condition(track):
 
 @numba.jit((numba.int64[:,:,::1], numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def leafConnecteeInitialization(connectionGraph, my):
-    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
 
 @numba.jit((numba.int64[:,:,::1], numba.int64[::1],numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def leafConnecteeUpdate(connectionGraph, my, track):
-    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.dimension1ndex.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def loopingLeavesConnectedToActiveLeaf(my):
     return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
 @numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def loopingTheDimensions(my, the):
-    return my[indexMy.dimension1ndex.value] <= the[indexThe.dimensionsTotal.value]
+def loopingTheDimensions(my):
+    return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
 @numba.jit((numba.int64[::1],), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
 def loopingToActiveGapCeiling(my):
@@ -126,15 +126,15 @@ def placeLeafCondition(my):
     return my[indexMy.leaf1ndex.value] > 0
 
 @numba.jit((numba.int64[::1],numba.int64[::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def thereAreComputationDivisionsYouMightSkip(my, the):
-    return my[indexMy.leaf1ndex.value] != the[indexThe.taskDivisions.value] or my[indexMy.leafConnectee.value] % the[indexThe.taskDivisions.value] == my[indexMy.taskIndex.value]
+def thereAreComputationDivisionsYouMightSkip(my):
+    return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
 
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countInitialize(connectionGraph, gapsWhere, my, the, track):
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countInitialize(connectionGraph, gapsWhere, my, track):
     while activeLeafGreaterThan0Condition(my=my):
         if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
             findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my, the=the):
+            while loopingTheDimensions(my=my):
                 if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                     dimensionsUnconstrainedIncrement(my=my)
                 else:
@@ -143,26 +143,26 @@ def countInitialize(connectionGraph, gapsWhere, my, the, track):
                         countGaps(gapsWhere=gapsWhere, my=my, track=track)
                         leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
                 dimension1ndexIncrement(my=my)
-            if allDimensionsAreUnconstrained(my=my, the=the):
+            if allDimensionsAreUnconstrained(my=my):
                 insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
             indexMiniGapInitialization(my=my)
             while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, the=the, track=track)
+                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
                 indexMiniGapIncrement(my=my)
         if placeLeafCondition(my=my):
             placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
         if my[indexMy.gap1ndex.value] > 0:
             return
 
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track):
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countSequential(connectionGraph, foldGroups, gapsWhere, my, track):
     while activeLeafGreaterThan0Condition(my=my):
         if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-            if activeLeafGreaterThanLeavesTotalCondition(my=my, the=the):
-                foldsSubTotalIncrement(foldsSubTotals=foldsSubTotals, my=my, the=the)
+            if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                foldsSubTotalIncrement(foldGroups=foldGroups, my=my)
             else:
                 findGapsInitializeVariables(my=my, track=track)
-                while loopingTheDimensions(my=my, the=the):
+                while loopingTheDimensions(my=my):
                     if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                         dimensionsUnconstrainedIncrement(my=my)
                     else:
@@ -173,39 +173,39 @@ def countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track):
                     dimension1ndexIncrement(my=my)
                 indexMiniGapInitialization(my=my)
                 while loopingToActiveGapCeiling(my=my):
-                    filterCommonGaps(gapsWhere=gapsWhere, my=my, the=the, track=track)
+                    filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
                     indexMiniGapIncrement(my=my)
         while backtrackCondition(my=my, track=track):
             backtrack(my=my, track=track)
         if placeLeafCondition(my=my):
             placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 
-@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1],numba.int64[::1],numba.int64[::1],numba.int64[:,::1]), parallel=True, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
-def countParallel(connectionGraph, foldsSubTotals, gapsWherePARALLEL, myPARALLEL, the, trackPARALLEL):
-    for indexSherpa in numba.prange(the[indexThe.taskDivisions.value]):
+@numba.jit((numba.int64[:,:,::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:,::1]), parallel=True, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countParallel(connectionGraph, foldGroups, gapsWherePARALLEL, myPARALLEL, trackPARALLEL):
+    for indexSherpa in numba.prange(myPARALLEL[indexMy.taskDivisions.value]):
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
         my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
         while activeLeafGreaterThan0Condition(my=my):
             if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
-                if activeLeafGreaterThanLeavesTotalCondition(my=my, the=the):
-                    foldsSubTotalIncrement(foldsSubTotals=foldsSubTotals, my=my, the=the)
+                if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                    foldsSubTotalIncrement(foldGroups=foldGroups, my=my)
                 else:
                     findGapsInitializeVariables(my=my, track=track)
-                    while loopingTheDimensions(my=my, the=the):
+                    while loopingTheDimensions(my=my):
                         if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                             dimensionsUnconstrainedIncrement(my=my)
                         else:
                             leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
                             while loopingLeavesConnectedToActiveLeaf(my=my):
-                                if thereAreComputationDivisionsYouMightSkip(my=my, the=the):
+                                if thereAreComputationDivisionsYouMightSkip(my=my):
                                     countGaps(gapsWhere=gapsWhere, my=my, track=track)
                                 leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
                         dimension1ndexIncrement(my=my)
                     indexMiniGapInitialization(my=my)
                     while loopingToActiveGapCeiling(my=my):
-                        filterCommonGaps(gapsWhere=gapsWhere, my=my, the=the, track=track)
+                        filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
                         indexMiniGapIncrement(my=my)
             while backtrackCondition(my=my, track=track):
                 backtrack(my=my, track=track)

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding/someAssemblyRequired/inlineAfunction.py

@@ -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-0.2.5 → mapfolding-0.2.6}/mapFolding/someAssemblyRequired/jobsAndTasks.py

@@ -3,7 +3,7 @@ from typing import Any, Optional, Sequence, Type, Union
 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
+    from mapFolding.someAssemblyRequired.countInitializeNoNumba import countInitialize
     countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['the'], stateUniversal['track'])
     from mapFolding import getPathFilenameFoldsTotal
     pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
@@ -38,7 +38,7 @@ def runJob(pathFilename):
     the: Final[numpy.ndarray] = stateJob['the']
     track: numpy.ndarray = stateJob['track']
 
-    from mapFolding.countSequentialNoNumba import countSequential
+    from mapFolding.someAssemblyRequired.countSequentialNoNumba import countSequential
     countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track)
 
     print(foldsSubTotals.sum().item())

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding/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,50 @@ import llvmlite.binding
 import numpy
 import pathlib
 import pickle
+import python_minifier
 
-listDimensions = [3,7]
+listDimensions = [6,6]
 
 # 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
+
+    parametersNumba = f"numba.types.{datatypeLarge}(), \
+cache=True, \
+"
+# 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)
+
+    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 +72,17 @@ 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['foldsSubTotals'], 'foldsSubTotals')
+            , 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['the'], 'the')
+            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
             ])
 
     pathFilenameFoldsTotal: pathlib.Path = stateJob['pathFilenameFoldsTotal']
@@ -79,26 +103,25 @@ def writeModuleWithNumba(listDimensions):
                             , lineSource
                             ])
 
-    lineReturn = f"{ImaIndent}return foldsSubTotals.sum().item()"
-
     linesLaunch = """"""
     linesLaunch = linesLaunch + f"""
 if __name__ == '__main__':
-    foldsTotal = {identifierCallableLaunch}()"""
+    {identifierCallableLaunch}()"""
 
     linesWriteFoldsTotal = """"""
     linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
+                                    , "    foldsTotal = foldsSubTotals.sum().item()"
                                     , "    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-0.2.5 → mapfolding-0.2.6}/mapFolding/startHere.py

@@ -42,7 +42,7 @@ def countFolds(listDimensions: Sequence[int], pathishWriteFoldsTotal: Optional[U
     from mapFolding.babbage import _countFolds
     _countFolds(**stateUniversal)
 
-    foldsTotal = stateUniversal['foldsSubTotals'].sum().item()
+    foldsTotal = stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1]
 
     if pathFilenameFoldsTotal is not None:
         saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding/theSSOT.py

@@ -42,21 +42,22 @@ class EnumIndices(enum.IntEnum):
 
 class indexMy(EnumIndices):
     """Indices for dynamic values."""
-    dimension1ndex = enum.auto()
+    dimensionsTotal = enum.auto() # connectionGraph.shape[0]
     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 indexThe(EnumIndices):
-    """Indices for static values."""
-    dimensionsTotal = enum.auto()
-    leavesTotal = enum.auto()
-    taskDivisions = enum.auto()
+# class indexThe(EnumIndices):
+#     """Indices for static values."""
+#     dimensionsTotal = enum.auto() # connectionGraph.shape[0]
+#     taskDivisions = enum.auto()
 
 class indexTrack(EnumIndices):
     """Indices for state tracking array."""
@@ -67,9 +68,9 @@ class indexTrack(EnumIndices):
 
 class computationState(TypedDict):
     connectionGraph: numpy.typing.NDArray[numpy.integer[Any]]
-    foldsSubTotals: numpy.typing.NDArray[numpy.integer[Any]]
+    foldGroups: numpy.typing.NDArray[numpy.integer[Any]]
     gapsWhere: numpy.typing.NDArray[numpy.integer[Any]]
     mapShape: Tuple[int, ...]
     my: numpy.typing.NDArray[numpy.integer[Any]]
-    the: numpy.typing.NDArray[numpy.integer[Any]]
+    # the: numpy.typing.NDArray[numpy.integer[Any]]
     track: numpy.typing.NDArray[numpy.integer[Any]]

{mapfolding-0.2.5 → mapfolding-0.2.6}/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.5
+Version: 0.2.6
 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

{mapfolding-0.2.5 → mapfolding-0.2.6}/pyproject.toml

@@ -7,7 +7,7 @@ name = "mapFolding"
 description = "Count distinct ways to fold a map (or a strip of stamps)"
 readme = "README.md"
 authors = [{ name = "Hunter Hogan", email = "HunterHogan@pm.me" }]
-version = "0.2.5"
+version = "0.2.6"
 requires-python = ">=3.10,<3.13"
 dependencies = ["numba", "numpy", "Z0Z-tools"]
 urls = { homepage = "https://github.com/hunterhogan/mapFolding" }
@@ -42,5 +42,5 @@ output = "tests/coverage/coverage.xml"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = ["--color=yes", "-n 2"]
-# env = ["NUMBA_DISABLE_JIT=1"]
+addopts = ["--color=yes", "-n 4"]
+env = ["NUMBA_DISABLE_JIT=1"]

{mapfolding-0.2.5 → mapfolding-0.2.6}/tests/conftest.py

@@ -1,5 +1,4 @@
-"""SSOT for Pytest.
-Other test modules must not import directly from the package being tested."""
+"""SSOT for Pytest"""
 
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
@@ -13,7 +12,7 @@ import uuid
 from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
 from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
 from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie
-from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexThe, indexTrack
+from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexTrack, saveFoldsTotal
 from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie, outfitCountFolds
 from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache, getFilenameFoldsTotal
 from mapFolding.beDRY import getLeavesTotal, parseDimensions, validateListDimensions
@@ -41,7 +40,6 @@ __all__ = [
     'getLeavesTotal',
     'getOEISids',
     'getTaskDivisions',
-    'indexThe',
     'intInnit',
     'makeConnectionGraph',
     'makeDataContainer',
@@ -53,6 +51,7 @@ __all__ = [
     'oopsieKwargsie',
     'outfitCountFolds',
     'parseDimensions',
+    'saveFoldsTotal',
     'setCPUlimit',
     'settingsOEIS',
     'standardCacheTest',
@@ -240,13 +239,12 @@ def oeisID_1random() -> str:
 def mockFoldingFunction():
     """Creates a mock function that simulates _countFolds behavior."""
     def make_mock(foldsValue: int, listDimensions: List[int]):
-        arraySize = getLeavesTotal(listDimensions)
-        # The array needs to sum to our target value
-        mock_array = makeDataContainer(arraySize)
-        mock_array[arraySize - 1] = foldsValue  # Put entire value in last position
+        mock_array = makeDataContainer(2)
+        mock_array[0] = foldsValue
+        mock_array[-1] = getLeavesTotal(listDimensions)
 
         def mock_countfolds(**keywordArguments):
-            keywordArguments['foldsSubTotals'][:] = mock_array
+            keywordArguments['foldGroups'][:] = mock_array
             return None
 
         return mock_countfolds

{mapfolding-0.2.5 → mapfolding-0.2.6}/tests/test_other.py

@@ -1,7 +1,7 @@
 import pathlib
 from tests.conftest import *
 from tests.pythons_idiotic_namespace import *
-from typing import List, Optional
+from typing import List, Optional, Any
 import itertools
 import numba
 import numpy
@@ -9,6 +9,8 @@ import pytest
 import random
 import sys
 import unittest.mock
+import io
+from contextlib import redirect_stdout
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -81,13 +83,14 @@ def test_countFolds_writeFoldsTotal(
         pathWriteTarget = pathTempTesting / writeFoldsTarget
         filenameFoldsTotalExpected = writeFoldsTarget
 
+    foldsTotalExpected = foldsValue * getLeavesTotal(listDimensionsTestFunctionality)
     mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
 
     with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
         returned = countFolds(listDimensionsTestFunctionality, pathishWriteFoldsTotal=pathWriteTarget)
 
-    standardComparison(foldsValue, lambda: returned)  # Check return value
-    standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
+    # standardComparison(foldsValue, lambda: returned)  # Check return value
+    standardComparison(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
 
 def test_intInnit() -> None:
     """Test integer parsing using the test suite generator."""
@@ -266,3 +269,14 @@ def test_pathJobDEFAULT_colab():
 
     # Reload one more time to restore original state
     importlib.reload(mapFolding.theSSOT)
+
+def test_saveFoldsTotal_fallback(pathTempTesting: pathlib.Path) -> None:
+    foldsTotal = 123
+    pathFilename = pathTempTesting / "unwritable" / "foldsTotal.txt"
+    with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
+        with unittest.mock.patch("os.getcwd", return_value=str(pathTempTesting)):
+            capturedOutput = io.StringIO()
+            with redirect_stdout(capturedOutput):
+                saveFoldsTotal(pathFilename, foldsTotal)
+    fallbackFiles = list(pathTempTesting.glob("foldsTotalYO_*.txt"))
+    assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."

mapfolding-0.2.5/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