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

mapFolding/reference/lunnanWhile.py

@@ -12,7 +12,7 @@ def foldings(p: Sequence[int]) -> int:
         p: An array of integers representing the dimensions of the map.
 
     Returns:
-        f: The number of distinct foldings for the given map dimensions.
+        G: The number of distinct foldings for the given map dimensions.
 
     NOTE If there are fewer than two dimensions, any dimensions are not positive, or any dimensions are not integers, the output will be unreliable.
     """
@@ -29,7 +29,7 @@ def foldings(p: Sequence[int]) -> int:
     B = [0] * (n + 1)
     count = [0] * (n + 1)
     gapter = [0] * (n + 1)
-    gap = [0] * (n * n + 1)    
+    gap = [0] * (n * n + 1)
 
     # B[m] is the leaf below leaf m in the current folding,
     # A[m] the leaf above. count[m] is the no. of sections in which
@@ -64,13 +64,13 @@ def foldings(p: Sequence[int]) -> int:
     # P[i] = p[1] x ... x p[i], C[i][m] = i-th co-ordinate of leaf m,
     # D[i][l][m] = leaf connected to m in section i when inserting l;
 
-    f: int = 0
+    G: int = 0
     l: int = 1
 
     # kick off with null folding
     while l > 0:
         if l > n:
-            f = f + 1
+            G = G + 1
         else:
             dd: int = 0
             gg: int = gapter[l - 1]
@@ -118,4 +118,4 @@ def foldings(p: Sequence[int]) -> int:
             A[B[l]] = l
             gapter[l] = g
             l = l + 1
-    return f
+    return G

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

@@ -1,4 +1,4 @@
-from mapFolding import outfitFoldings
+from mapFolding import outfitCountFolds, getFilenameFoldsTotal
 from typing import Optional, Sequence, Type, Union
 import os
 import pathlib
@@ -13,9 +13,9 @@ 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.
+        foldsSubTotals: Total number of distinct ways to fold a map of the given dimensions.
 
     Computation divisions:
         - None: no division of the computation into tasks; sets task divisions to 0
@@ -34,29 +34,29 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
     N.B.: You probably don't want to divide the computation into tasks.
         If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time, it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the computation time. If logicalCores >= leavesTotal, it will probably be faster. If logicalCores <= 2 * leavesTotal, it will almost certainly be slower for all map dimensions.
     """
-    stateUniversal = outfitFoldings(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
+    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
 
     pathFilenameFoldsTotal = None
     if writeFoldsTotal is not None:
         pathFilenameFoldsTotal = pathlib.Path(writeFoldsTotal)
         if pathFilenameFoldsTotal.is_dir():
-            filenameFoldsTotalDEFAULT = str(sorted(stateUniversal['mapShape'])).replace(' ', '') + '.foldsTotal'
+            filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(stateUniversal['mapShape'])
             pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
         pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 
     # NOTE Don't import a module with a numba.jit function until you want the function to compile and to freeze all settings for that function.
     from mapFolding.babbage import _countFolds
-    foldsTotal = _countFolds(**stateUniversal)
-    # foldsTotal = benchmarkSherpa(**stateUniversal)
+    _countFolds(**stateUniversal)
+    # foldsSubTotals = benchmarkSherpa(**stateUniversal)
+
+    foldsTotal = stateUniversal['foldsSubTotals'].sum().item()
 
     if pathFilenameFoldsTotal is not None:
         try:
             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
 
@@ -65,6 +65,6 @@ def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[st
 # from typing import Any, Tuple
 # from mapFolding.benchmarks.benchmarking import recordBenchmarks
 # @recordBenchmarks()
-# def benchmarkSherpa(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
+# def benchmarkSherpa(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]]):
 #     from mapFolding.babbage import _countFolds
-#     return _countFolds(connectionGraph, foldsTotal, mapShape, my, gapsWhere, the, track)
+#     return _countFolds(connectionGraph, foldsSubTotals, gapsWhere, mapShape, my, the, track)

mapFolding/theSSOT.py

@@ -5,13 +5,17 @@ import numpy.typing
 import pathlib
 import sys
 
+dtypeLarge = numpy.int64
+dtypeDefault = dtypeLarge
+dtypeSmall = dtypeDefault
+
 try:
     _pathModule = pathlib.Path(__file__).parent
 except NameError:
     _pathModule = pathlib.Path.cwd()
 
 pathJobDEFAULT = _pathModule / "jobs"
-"""filenameFoldsTotal = str(sorted(mapShape)).replace(' ', '') + '.foldsTotal'"""
+
 if 'google.colab' in sys.modules:
     pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
 
@@ -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):
@@ -54,7 +59,7 @@ class indexTrack(EnumIndices):
 
 class computationState(TypedDict):
     connectionGraph: numpy.typing.NDArray[numpy.integer[Any]]
-    foldsTotal: numpy.ndarray[numpy.int64, numpy.dtype[numpy.int64]]
+    foldsSubTotals: numpy.ndarray[numpy.int64, numpy.dtype[numpy.int64]]
     mapShape: Tuple[int, ...]
     my: numpy.typing.NDArray[numpy.integer[Any]]
     gapsWhere: numpy.typing.NDArray[numpy.integer[Any]]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.1
+Version: 0.2.3
 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
@@ -25,7 +25,7 @@ Requires-Dist: pytest-xdist; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
-`mapFolding.countFolds()` will accept arbitrary values for the map's dimensions.
+The function `mapFolding.countFolds()` counts distinct ways to fold maps and strips of stamps. The function accepts two or more dimensions:
 
 ```python
 from mapFolding import countFolds
@@ -34,12 +34,12 @@ foldsTotal = countFolds( [2,10] )
 
 The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference) has
 
-- a verbatim transcription of the "procedure" published in _The Computer Journal_,
+- a verbatim transcription of Lunnon's "procedure" published in 1971 by _The Computer Journal_,
 - multiple referential versions of the procedure with explanatory comments including
 - [hunterNumba.py](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference), a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
 - miscellaneous notes.
 
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) ![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ## Simple, easy usage based on OEIS IDs
 

mapFolding-0.2.3.dist-info/RECORD

@@ -0,0 +1,30 @@
+mapFolding/__init__.py,sha256=wnf2EzHR2unVha6-Y0gRoSPaE4PDdT4VngINa_dfT2E,337
+mapFolding/babbage.py,sha256=LCtyapF8SKsECqBifqbLm7bR_i4n8VJ647w_TQxnQvE,1930
+mapFolding/beDRY.py,sha256=UE4IRrb5lXN4nTuUghHfieNm2FBHgz7oBj_EqUgkadI,13800
+mapFolding/lovelace.py,sha256=r4dkTGh_AgaVsWOsdPRdpPWVx3TjVjbWfPCVu3UTm6U,13495
+mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
+mapFolding/startHere.py,sha256=glGxmefrWpxyuqrzXrbCvIo84yvPnv8l8l7Rmff2sAo,5105
+mapFolding/theSSOT.py,sha256=rAyx034y33QC7IiRKaW89CMGGvqe2p-QBc3_fO-zEGM,2101
+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/flattened.py,sha256=X9nvRzg7YDcpCtSDTL4YiidjshlX9rg2e6JVCY6i2u0,16547
+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=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=WE3DETPaQ4zuUiw8pweTry4rp1PxvUPgeb8CN8eh5JI,13574
+tests/pythons_idiotic_namespace.py,sha256=oOLDBergQqqhGuRpsXUnFD-R_6AlJipNKYHw-kk_OKw,33
+tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
+tests/test_other.py,sha256=5DwOZsjezBHZzr4-9qEnybBYJEGsozBm2n9p0KYvs9E,10664
+tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
+mapFolding-0.2.3.dist-info/METADATA,sha256=nEQXgDmmuu2NJko4R4gPUdjIrm1upUGwMIOn0s0JOOc,6442
+mapFolding-0.2.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.3.dist-info/RECORD,,

tests/__init__.py

@@ -1 +1 @@
-from .conftest import makeDictionaryFoldsTotalKnown
+from tests.conftest import makeDictionaryFoldsTotalKnown