mapFolding 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

mapFolding/reference/rotatedEntryPoint.py

@@ -21,11 +21,11 @@ gapter = gapRangeStart = 3
 
 # Indices of array `my`, which holds dynamic, small, unsigned, integer values.
 tricky = [
-(activeLeaf1ndex := 0),
-(activeGap1ndex := 1),
+(leaf1ndex := 0),
+(gap1ndex := 1),
 (unconstrainedLeaf := 2),
 (gap1ndexCeiling := 3),
-(leaf1ndexConnectee := 4),
+(leafConnectee := 4),
 (taskIndex := 5),
 (dimension1ndex := 6),
 (foldingsSubtotal := 7),
@@ -76,7 +76,7 @@ def countFoldings(TEMPLATEtrack: NDArray,
                     ):
 
     TEMPLATEmy = numpy.zeros(COUNTindicesDynamic, dtype=numpy.int64)
-    TEMPLATEmy[activeLeaf1ndex] = 1
+    TEMPLATEmy[leaf1ndex] = 1
 
     taskDivisions = 0
     # taskDivisions = the[leavesTotal]
@@ -87,61 +87,61 @@ def countFoldings(TEMPLATEtrack: NDArray,
                     my: NDArray) -> tuple[NDArray, NDArray, NDArray]:
         foldingsTotal = 0
         while True:
-            if my[activeLeaf1ndex] <= 1 or track[leafBelow][0] == 1:
-                if my[activeLeaf1ndex] > the[leavesTotal]:
+            if my[leaf1ndex] <= 1 or track[leafBelow][0] == 1:
+                if my[leaf1ndex] > the[leavesTotal]:
                     foldingsTotal += the[leavesTotal]
                 else:
                     my[unconstrainedLeaf] = 0
-                    my[gap1ndexCeiling] = track[gapRangeStart][my[activeLeaf1ndex] - 1]
-                    my[activeGap1ndex] = my[gap1ndexCeiling]
+                    my[gap1ndexCeiling] = track[gapRangeStart][my[leaf1ndex] - 1]
+                    my[gap1ndex] = my[gap1ndexCeiling]
 
                     for PREPAREdimension1ndex in range(1, the[dimensionsPlus1]):
-                        if connectionGraph[PREPAREdimension1ndex][my[activeLeaf1ndex]][my[activeLeaf1ndex]] == my[activeLeaf1ndex]:
+                        if connectionGraph[PREPAREdimension1ndex][my[leaf1ndex]][my[leaf1ndex]] == my[leaf1ndex]:
                             my[unconstrainedLeaf] += 1
                         else:
-                            my[leaf1ndexConnectee] = connectionGraph[PREPAREdimension1ndex][my[activeLeaf1ndex]][my[activeLeaf1ndex]]
-                            while my[leaf1ndexConnectee] != my[activeLeaf1ndex]:
+                            my[leafConnectee] = connectionGraph[PREPAREdimension1ndex][my[leaf1ndex]][my[leaf1ndex]]
+                            while my[leafConnectee] != my[leaf1ndex]:
 
-                                if my[leaf1ndexConnectee] != my[activeLeaf1ndex]:
+                                if my[leafConnectee] != my[leaf1ndex]:
                                     my[dimension1ndex] = PREPAREdimension1ndex
                                     return track, gapsWhere, my
 
-                                if my[activeLeaf1ndex] != the[leavesTotal]:
-                                    gapsWhere[my[gap1ndexCeiling]] = my[leaf1ndexConnectee]
-                                    if track[countDimensionsGapped][my[leaf1ndexConnectee]] == 0:
+                                if my[leaf1ndex] != the[leavesTotal]:
+                                    gapsWhere[my[gap1ndexCeiling]] = my[leafConnectee]
+                                    if track[countDimensionsGapped][my[leafConnectee]] == 0:
                                         my[gap1ndexCeiling] += 1
-                                    track[countDimensionsGapped][my[leaf1ndexConnectee]] += 1
+                                    track[countDimensionsGapped][my[leafConnectee]] += 1
                                 else:
                                     print("else")
                                     my[dimension1ndex] = PREPAREdimension1ndex
                                     return track, gapsWhere, my
-                                    # PREPAREmy[leaf1ndexConnectee] % the[leavesTotal] == PREPAREmy[taskIndex]
-                                my[leaf1ndexConnectee] = connectionGraph[dimension1ndex][my[activeLeaf1ndex]][track[leafBelow][my[leaf1ndexConnectee]]]
+                                    # PREPAREmy[leafConnectee] % the[leavesTotal] == PREPAREmy[taskIndex]
+                                my[leafConnectee] = connectionGraph[dimension1ndex][my[leaf1ndex]][track[leafBelow][my[leafConnectee]]]
 
                     if my[unconstrainedLeaf] == the[dimensionsTotal]:
-                        for leaf1ndex in range(my[activeLeaf1ndex]):
-                            gapsWhere[my[gap1ndexCeiling]] = leaf1ndex
+                        for indexLeaf in range(my[leaf1ndex]):
+                            gapsWhere[my[gap1ndexCeiling]] = indexLeaf
                             my[gap1ndexCeiling] += 1
 
-                    for indexMiniGap in range(my[activeGap1ndex], my[gap1ndexCeiling]):
-                        gapsWhere[my[activeGap1ndex]] = gapsWhere[indexMiniGap]
+                    for indexMiniGap in range(my[gap1ndex], my[gap1ndexCeiling]):
+                        gapsWhere[my[gap1ndex]] = gapsWhere[indexMiniGap]
                         if track[countDimensionsGapped][gapsWhere[indexMiniGap]] == the[dimensionsTotal] - my[unconstrainedLeaf]:
-                            my[activeGap1ndex] += 1
+                            my[gap1ndex] += 1
                         track[countDimensionsGapped][gapsWhere[indexMiniGap]] = 0
 
-            while my[activeLeaf1ndex] > 0 and my[activeGap1ndex] == track[gapRangeStart][my[activeLeaf1ndex] - 1]:
-                my[activeLeaf1ndex] -= 1
-                track[leafBelow][track[leafAbove][my[activeLeaf1ndex]]] = track[leafBelow][my[activeLeaf1ndex]]
-                track[leafAbove][track[leafBelow][my[activeLeaf1ndex]]] = track[leafAbove][my[activeLeaf1ndex]]
+            while my[leaf1ndex] > 0 and my[gap1ndex] == track[gapRangeStart][my[leaf1ndex] - 1]:
+                my[leaf1ndex] -= 1
+                track[leafBelow][track[leafAbove][my[leaf1ndex]]] = track[leafBelow][my[leaf1ndex]]
+                track[leafAbove][track[leafBelow][my[leaf1ndex]]] = track[leafAbove][my[leaf1ndex]]
 
-            if my[activeLeaf1ndex] > 0:
-                my[activeGap1ndex] -= 1
-                track[leafAbove][my[activeLeaf1ndex]] = gapsWhere[my[activeGap1ndex]]
-                track[leafBelow][my[activeLeaf1ndex]] = track[leafBelow][track[leafAbove][my[activeLeaf1ndex]]]
-                track[leafBelow][track[leafAbove][my[activeLeaf1ndex]]] = my[activeLeaf1ndex]
-                track[leafAbove][track[leafBelow][my[activeLeaf1ndex]]] = my[activeLeaf1ndex]
-                track[gapRangeStart][my[activeLeaf1ndex]] = my[activeGap1ndex]
-                my[activeLeaf1ndex] += 1
+            if my[leaf1ndex] > 0:
+                my[gap1ndex] -= 1
+                track[leafAbove][my[leaf1ndex]] = gapsWhere[my[gap1ndex]]
+                track[leafBelow][my[leaf1ndex]] = track[leafBelow][track[leafAbove][my[leaf1ndex]]]
+                track[leafBelow][track[leafAbove][my[leaf1ndex]]] = my[leaf1ndex]
+                track[leafAbove][track[leafBelow][my[leaf1ndex]]] = my[leaf1ndex]
+                track[gapRangeStart][my[leaf1ndex]] = my[gap1ndex]
+                my[leaf1ndex] += 1
 
     RETURNtrack, RETURNgapsWhere, RETURNmy = prepareWork(TEMPLATEtrack.copy(), TEMPLATEgapsWhere.copy(), TEMPLATEmy.copy())
 
@@ -166,44 +166,44 @@ def doWork(track: NDArray,
     thisIsNotTheFirstPass = False
 
     while papasGotABrandNewBag:
-        if my[activeLeaf1ndex] <= 1 or track[leafBelow][0] == 1 or if_activeLeaf1ndex_LTE_1_or_leafBelow_index_0_equals_1 == True:
+        if my[leaf1ndex] <= 1 or track[leafBelow][0] == 1 or if_activeLeaf1ndex_LTE_1_or_leafBelow_index_0_equals_1 == True:
             if_activeLeaf1ndex_LTE_1_or_leafBelow_index_0_equals_1 = False
-            if my[activeLeaf1ndex] > the[leavesTotal] and thisIsNotTheFirstPass:
+            if my[leaf1ndex] > the[leavesTotal] and thisIsNotTheFirstPass:
                 my[foldingsSubtotal] += the[leavesTotal]
             else:
                 if thisIsNotTheFirstPass:
                     my[unconstrainedLeaf] = 0
-                    my[gap1ndexCeiling] = track[gapRangeStart][my[activeLeaf1ndex] - 1]
-                    my[activeGap1ndex] = my[gap1ndexCeiling]
+                    my[gap1ndexCeiling] = track[gapRangeStart][my[leaf1ndex] - 1]
+                    my[gap1ndex] = my[gap1ndexCeiling]
 
                 for_dimension1ndex_in_range_1_to_dimensionsPlus1 = True
                 while for_dimension1ndex_in_range_1_to_dimensionsPlus1 == True:
                     for_dimension1ndex_in_range_1_to_dimensionsPlus1 = False
-                    if connectionGraph[my[dimension1ndex]][my[activeLeaf1ndex]][my[activeLeaf1ndex]] == my[activeLeaf1ndex] and thisIsNotTheFirstPass:
+                    if connectionGraph[my[dimension1ndex]][my[leaf1ndex]][my[leaf1ndex]] == my[leaf1ndex] and thisIsNotTheFirstPass:
                         my[unconstrainedLeaf] += 1
                     else:
                         if thisIsNotTheFirstPass:
-                            my[leaf1ndexConnectee] = connectionGraph[my[dimension1ndex]][my[activeLeaf1ndex]][my[activeLeaf1ndex]]
-                        if my[leaf1ndexConnectee] != my[activeLeaf1ndex]:
+                            my[leafConnectee] = connectionGraph[my[dimension1ndex]][my[leaf1ndex]][my[leaf1ndex]]
+                        if my[leafConnectee] != my[leaf1ndex]:
                             while_leaf1ndexConnectee_notEquals_activeLeaf1ndex = True
 
                         while while_leaf1ndexConnectee_notEquals_activeLeaf1ndex == True:
                             while_leaf1ndexConnectee_notEquals_activeLeaf1ndex = False
                             thisIsNotTheFirstPass = True
-                            if taskDivisions==0 or my[activeLeaf1ndex] != taskDivisions:
+                            if taskDivisions==0 or my[leaf1ndex] != taskDivisions:
                                 myTask = True
                             else:
-                                modulo = my[leaf1ndexConnectee] % the[leavesTotal]
+                                modulo = my[leafConnectee] % the[leavesTotal]
                                 if modulo == my[taskIndex]: myTask = True
                                 else:
                                     myTask = False
                             if myTask:
-                                gapsWhere[my[gap1ndexCeiling]] = my[leaf1ndexConnectee]
-                                if track[countDimensionsGapped][my[leaf1ndexConnectee]] == 0:
+                                gapsWhere[my[gap1ndexCeiling]] = my[leafConnectee]
+                                if track[countDimensionsGapped][my[leafConnectee]] == 0:
                                     my[gap1ndexCeiling] += 1
-                                track[countDimensionsGapped][my[leaf1ndexConnectee]] += 1
-                            my[leaf1ndexConnectee] = connectionGraph[my[dimension1ndex]][my[activeLeaf1ndex]][track[leafBelow][my[leaf1ndexConnectee]]]
-                            if my[leaf1ndexConnectee] != my[activeLeaf1ndex]:
+                                track[countDimensionsGapped][my[leafConnectee]] += 1
+                            my[leafConnectee] = connectionGraph[my[dimension1ndex]][my[leaf1ndex]][track[leafBelow][my[leafConnectee]]]
+                            if my[leafConnectee] != my[leaf1ndex]:
                                 while_leaf1ndexConnectee_notEquals_activeLeaf1ndex = True
                     my[dimension1ndex] += 1
                     if my[dimension1ndex] < the[dimensionsPlus1]:
@@ -212,29 +212,29 @@ def doWork(track: NDArray,
                         my[dimension1ndex] = 1
 
                 if my[unconstrainedLeaf] == the[dimensionsTotal]:
-                    for leaf1ndex in range(my[activeLeaf1ndex]):
+                    for leaf1ndex in range(my[leaf1ndex]):
                         gapsWhere[my[gap1ndexCeiling]] = leaf1ndex
                         my[gap1ndexCeiling] += 1
 
-                for indexMiniGap in range(my[activeGap1ndex], my[gap1ndexCeiling]):
-                    gapsWhere[my[activeGap1ndex]] = gapsWhere[indexMiniGap]
+                for indexMiniGap in range(my[gap1ndex], my[gap1ndexCeiling]):
+                    gapsWhere[my[gap1ndex]] = gapsWhere[indexMiniGap]
                     if track[countDimensionsGapped][gapsWhere[indexMiniGap]] == the[dimensionsTotal] - my[unconstrainedLeaf]:
-                        my[activeGap1ndex] += 1
+                        my[gap1ndex] += 1
                     track[countDimensionsGapped][gapsWhere[indexMiniGap]] = 0
 
-        while my[activeLeaf1ndex] > 0 and my[activeGap1ndex] == track[gapRangeStart][my[activeLeaf1ndex] - 1]:
-            my[activeLeaf1ndex] -= 1
-            track[leafBelow][track[leafAbove][my[activeLeaf1ndex]]] = track[leafBelow][my[activeLeaf1ndex]]
-            track[leafAbove][track[leafBelow][my[activeLeaf1ndex]]] = track[leafAbove][my[activeLeaf1ndex]]
-
-        if my[activeLeaf1ndex] > 0:
-            my[activeGap1ndex] -= 1
-            track[leafAbove][my[activeLeaf1ndex]] = gapsWhere[my[activeGap1ndex]]
-            track[leafBelow][my[activeLeaf1ndex]] = track[leafBelow][track[leafAbove][my[activeLeaf1ndex]]]
-            track[leafBelow][track[leafAbove][my[activeLeaf1ndex]]] = my[activeLeaf1ndex]
-            track[leafAbove][track[leafBelow][my[activeLeaf1ndex]]] = my[activeLeaf1ndex]
-            track[gapRangeStart][my[activeLeaf1ndex]] = my[activeGap1ndex]
-            my[activeLeaf1ndex] += 1
-
-        if my[activeLeaf1ndex] <= 0:
+        while my[leaf1ndex] > 0 and my[gap1ndex] == track[gapRangeStart][my[leaf1ndex] - 1]:
+            my[leaf1ndex] -= 1
+            track[leafBelow][track[leafAbove][my[leaf1ndex]]] = track[leafBelow][my[leaf1ndex]]
+            track[leafAbove][track[leafBelow][my[leaf1ndex]]] = track[leafAbove][my[leaf1ndex]]
+
+        if my[leaf1ndex] > 0:
+            my[gap1ndex] -= 1
+            track[leafAbove][my[leaf1ndex]] = gapsWhere[my[gap1ndex]]
+            track[leafBelow][my[leaf1ndex]] = track[leafBelow][track[leafAbove][my[leaf1ndex]]]
+            track[leafBelow][track[leafAbove][my[leaf1ndex]]] = my[leaf1ndex]
+            track[leafAbove][track[leafBelow][my[leaf1ndex]]] = my[leaf1ndex]
+            track[gapRangeStart][my[leaf1ndex]] = my[gap1ndex]
+            my[leaf1ndex] += 1
+
+        if my[leaf1ndex] <= 0:
             return my[foldingsSubtotal]

mapFolding/reference/total_countPlus1vsPlusN.py

@@ -0,0 +1,211 @@
+from numba import njit
+import numpy
+
+@njit(cache=True)
+def foldings_plus_1(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
+    n: int = 1  # Total number of leaves
+    for dimension in p:
+        n *= dimension
+
+    d = len(p)  # Number of dimensions
+    # Compute arrays P, C, D as per the algorithm
+    P = numpy.ones(d + 1, dtype=numpy.int64)
+    for i in range(1, d + 1):
+        P[i] = P[i - 1] * p[i - 1]
+
+    # C[i][m] holds the i-th coordinate of leaf m
+    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for m in range(1, n + 1):
+            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+
+    # D[i][l][m] computes the leaf connected to m in section i when inserting l
+    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for l in range(1, n + 1):
+            for m in range(1, l + 1):
+                delta = C[i][l] - C[i][m]
+                if delta % 2 == 0:
+                    # If delta is even
+                    if C[i][m] == 1:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m - P[i - 1]
+                else:
+                    # If delta is odd
+                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m + P[i - 1]
+    # Initialize arrays/lists
+    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
+    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
+    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+    # Initialize variables for backtracking
+    total_count = 0  # Total number of foldings
+    g = 0            # Gap index
+    l = 1            # Current leaf
+
+    # Start backtracking loop
+    while l > 0:
+        # If we have processed all leaves, increment total count
+        if l > n:
+            total_count += 1
+        else:
+            dd = 0     # Number of sections where leaf l is unconstrained
+            gg = g     # Temporary gap index
+            g = gapter[l - 1]  # Reset gap index for current leaf
+
+            # Count possible gaps for leaf l in each section
+            for i in range(1, d + 1):
+                if D[i][l][l] == l:
+                    dd += 1
+                else:
+                    m = D[i][l][l]
+                    while m != l:
+                        if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+                            gap[gg] = m
+                            if count[m] == 0:
+                                gg += 1
+                            count[m] += 1
+                        m = D[i][l][B[m]]
+
+            # If leaf l is unconstrained in all sections, it can be inserted anywhere
+            if dd == d:
+                for m in range(l):
+                    gap[gg] = m
+                    gg += 1
+
+            # Filter gaps that are common to all sections
+            for j in range(g, gg):
+                gap[g] = gap[j]
+                if count[gap[j]] == d - dd:
+                    g += 1
+                count[gap[j]] = 0  # Reset count for next iteration
+
+        # Recursive backtracking steps
+        while l > 0 and g == gapter[l - 1]:
+            l -= 1
+            B[A[l]] = B[l]
+            A[B[l]] = A[l]
+
+        if l > 0:
+            g -= 1
+            A[l] = gap[g]
+            B[l] = B[A[l]]
+            B[A[l]] = l
+            A[B[l]] = l
+            gapter[l] = g  # Save current gap index
+            l += 1         # Move to next leaf
+
+    return total_count
+
+@njit(cache=True)
+def foldings(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
+    n: int = 1  # Total number of leaves
+    for dimension in p:
+        n *= dimension
+
+    d = len(p)  # Number of dimensions
+    # Compute arrays P, C, D as per the algorithm
+    P = numpy.ones(d + 1, dtype=numpy.int64)
+    for i in range(1, d + 1):
+        P[i] = P[i - 1] * p[i - 1]
+
+    # C[i][m] holds the i-th coordinate of leaf m
+    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for m in range(1, n + 1):
+            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+            # C[i][m] = ((m - 1) // P[i - 1]) % p[i - 1] + 1 # NOTE different, but either one works
+
+    # D[i][l][m] computes the leaf connected to m in section i when inserting l
+    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for l in range(1, n + 1):
+            for m in range(1, l + 1):
+                delta = C[i][l] - C[i][m]
+                if delta % 2 == 0:
+                    # If delta is even
+                    if C[i][m] == 1:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m - P[i - 1]
+                else:
+                    # If delta is odd
+                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m + P[i - 1]
+    # Initialize arrays/lists
+    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
+    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
+    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+    # Initialize variables for backtracking
+    total_count = 0  # Total number of foldings
+    g = 0            # Gap index
+    l = 1            # Current leaf
+
+    # Start backtracking loop
+    while l > 0:
+        if l <= 1 or B[0] == 1: # NOTE different
+            # NOTE the above `if` statement encloses the the if/else block below
+            # NOTE these changes increase the throughput by more than an order of magnitude
+            if l > n:
+                total_count += n
+            else:
+                dd = 0     # Number of sections where leaf l is unconstrained
+                gg = gapter[l - 1]  # Track possible gaps # NOTE different, but not important
+                g = gg # NOTE different, but not important
+
+                # Count possible gaps for leaf l in each section
+                for i in range(1, d + 1):
+                    if D[i][l][l] == l:
+                        dd += 1
+                    else:
+                        m = D[i][l][l]
+                        while m != l:
+                            if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+                                gap[gg] = m
+                                if count[m] == 0:
+                                    gg += 1
+                                count[m] += 1
+                            m = D[i][l][B[m]]
+
+                # If leaf l is unconstrained in all sections, it can be inserted anywhere
+                if dd == d:
+                    for m in range(l):
+                        gap[gg] = m
+                        gg += 1
+
+                # Filter gaps that are common to all sections
+                for j in range(g, gg):
+                    gap[g] = gap[j]
+                    if count[gap[j]] == d - dd:
+                        g += 1
+                    count[gap[j]] = 0  # Reset count for next iteration
+
+        # Recursive backtracking steps
+        while l > 0 and g == gapter[l - 1]:
+            l -= 1
+            B[A[l]] = B[l]
+            A[B[l]] = A[l]
+
+        if l > 0:
+            g -= 1
+            A[l] = gap[g]
+            B[l] = B[A[l]]
+            B[A[l]] = l
+            A[B[l]] = l
+            gapter[l] = g  # Save current gap index
+            l += 1         # Move to next leaf
+
+    return total_count

mapFolding/startHere.py

@@ -13,7 +13,7 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
         computationDivisions (None):
             Whether and how to divide the computational work. See notes for details.
         CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
-        **keywordArguments: Additional arguments including dtypeDefault and dtypeLarge for data type specifications.
+        **keywordArguments: Additional arguments including `dtypeDefault` and `dtypeLarge` for data type specifications.
     Returns:
         foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
 
@@ -54,9 +54,7 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
             pathFilenameFoldsTotal.write_text(str(foldsTotal))
         except Exception as ERRORmessage:
             print(ERRORmessage)
-            print("\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
-            print(f"{foldsTotal=}")
-            print("\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
+            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
 
     return foldsTotal
 

mapFolding/theSSOT.py

@@ -5,6 +5,10 @@ import numpy.typing
 import pathlib
 import sys
 
+dtypeLarge = numpy.int64
+dtypeDefault = dtypeLarge
+dtypeSmall = dtypeDefault
+
 try:
     _pathModule = pathlib.Path(__file__).parent
 except NameError:
@@ -24,7 +28,8 @@ class EnumIndices(enum.IntEnum):
         return count
 
     def __index__(self) -> int:
-        """Make the enum work with array indexing."""
+        """Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
+        same as `array.array`. See NumPy.org; I think it will be very popular someday."""
         return self.value
 
 class indexMy(EnumIndices):

{mapFolding-0.2.1.dist-info → mapFolding-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.1
+Version: 0.2.2
 Summary: Algorithm(s) for counting 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.2.dist-info/RECORD

@@ -0,0 +1,28 @@
+mapFolding/__init__.py,sha256=POxXTSE6Qu1G8k-YlSXHzbe-_JGuHk-L9p5SLRng4vA,439
+mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
+mapFolding/beDRY.py,sha256=ZrUXCNqnumTQ1XX8RT5gGdRr-a-o8QxEiGrerUxKtYg,12784
+mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
+mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
+mapFolding/startHere.py,sha256=RGdFoJJdrJ_0tmLIKZn1WnHP0NCZwvQG7C2p4EUHOe4,5034
+mapFolding/theSSOT.py,sha256=yRW6aHyJxheL-Znk537LQA6xUPHz6FfoXY-0Ayh3Lsg,2178
+mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
+mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
+mapFolding/benchmarks/benchmarking.py,sha256=kv85F6V9pGhZvTOImArOuxyg5rywA_T6JLH_qFXM8BM,3018
+mapFolding/benchmarks/test_benchmarks.py,sha256=c4ANeR3jgqpKXFoxDeZkmAHxSuenMwsjmrhKJ1_XPqY,3659
+mapFolding/reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
+mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
+mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
+mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
+mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
+mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
+tests/conftest.py,sha256=VFYSd7-tHWd-LUKnTY24PIJhq9quP9S3sK2SYusNNog,12875
+tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
+tests/test_other.py,sha256=cf8DbkZxm_DHNq9lkMe7auXye_XspruU9qiNZATkxr4,6930
+tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
+mapFolding-0.2.2.dist-info/METADATA,sha256=BSCXcKZDhAtOWr8A5pZMG8bZnm5YBLf-6uMN9qs8JDk,5914
+mapFolding-0.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.2.dist-info/RECORD,,