mapFolding 0.3.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

mapFolding/reference/lunnanWhile.py

@@ -5,117 +5,117 @@ W. F. Lunnon, Multi-dimensional map-folding, The Computer Journal, Volume 14, Is
 from typing import Sequence
 
 def foldings(p: Sequence[int]) -> int:
-    """
-    Run loop with (A, B) on each folding of a p[1] x ... x p[d] map, where A and B are the above and below vectors.
-
-    Parameters:
-        p: An array of integers representing the dimensions of the map.
-
-    Returns:
-        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.
-    """
-
-    g: int = 0
-    d: int = len(p)
-    n: int = 1
-    for i in range(d):
-        n = n * p[i]
-
-    # d dimensions and n leaves
-
-    A = [0] * (n + 1)
-    B = [0] * (n + 1)
-    count = [0] * (n + 1)
-    gapter = [0] * (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
-    # there is a gap for the new leaf l below leaf m,
-    # gap[gapter[l - 1] + j] is the j-th (possible or actual) gap for leaf l,
-    # and later gap[gapter[l]] is the gap where leaf l is currently inserted
-
-    P = [1] * (d + 1)
-    C = [[0] * (n + 1) for dimension1 in range(d + 1)]
-    D = [[[0] * (n + 1) for dimension2 in range(n + 1)] for dimension1 in range(d + 1)]
-
-    for i in range(1, d + 1):
-        P[i] = P[i - 1] * p[i - 1]
-
-    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
-
-    for i in range(1, d + 1):
-        for l in range(1, n + 1):
-            for m in range(1, l + 1):
-                if C[i][l] - C[i][m] == (C[i][l] - C[i][m]) // 2 * 2: # !
-                    if C[i][m] == 1:
-                        D[i][l][m] = m
-                    else:
-                        D[i][l][m] = m - P[i - 1]
-                else:
-                    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]
-    # 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;
-
-    G: int = 0
-    l: int = 1
-
-    # kick off with null folding
-    while l > 0:
-        if l > n:
-            G = G + 1
-        else:
-            dd: int = 0
-            gg: int = gapter[l - 1]
-            g = gg
-            # dd is the no. of sections in which l is unconstrained,
-            # gg the no. of possible and g the no. of actual gaps for l, + gapter[l - 1]
-
-            # find the possible gaps for leaf l in each section,
-            # then discard those not common to all. All possible if dd = d
-            for i in range(1, d + 1):
-                if D[i][l][l] == l:
-                    dd = dd + 1
-                else:
-                    m: int = D[i][l][l]
-                    while m != l:
-                        gap[gg] = m
-                        if count[m] == 0:
-                            gg = gg + 1
-                        count[m] += 1
-                        m = D[i][l][B[m]]
-
-            if dd == d:
-                for m in range(l):
-                    gap[gg] = m
-                    gg = gg + 1
-
-            for j in range(g, gg):
-                gap[g] = gap[j]
-                if count[gap[j]] == d - dd:
-                    g = g + 1
-                count[gap[j]] = 0
-
-        # for each gap insert leaf l, [the main while loop shall progress],
-        # remove leaf l
-        while l > 0 and g == gapter[l - 1]:
-            l = l - 1
-            B[A[l]] = B[l]
-            A[B[l]] = A[l]
-
-        if l > 0:
-            g = g - 1
-            A[l] = gap[g]
-            B[l] = B[A[l]]
-            B[A[l]] = l
-            A[B[l]] = l
-            gapter[l] = g
-            l = l + 1
-    return G
+	"""
+	Run loop with (A, B) on each folding of a p[1] x ... x p[d] map, where A and B are the above and below vectors.
+
+	Parameters:
+		p: An array of integers representing the dimensions of the map.
+
+	Returns:
+		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.
+	"""
+
+	g: int = 0
+	d: int = len(p)
+	n: int = 1
+	for i in range(d):
+		n = n * p[i]
+
+	# d dimensions and n leaves
+
+	A = [0] * (n + 1)
+	B = [0] * (n + 1)
+	count = [0] * (n + 1)
+	gapter = [0] * (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
+	# there is a gap for the new leaf l below leaf m,
+	# gap[gapter[l - 1] + j] is the j-th (possible or actual) gap for leaf l,
+	# and later gap[gapter[l]] is the gap where leaf l is currently inserted
+
+	P = [1] * (d + 1)
+	C = [[0] * (n + 1) for dimension1 in range(d + 1)]
+	D = [[[0] * (n + 1) for dimension2 in range(n + 1)] for dimension1 in range(d + 1)]
+
+	for i in range(1, d + 1):
+		P[i] = P[i - 1] * p[i - 1]
+
+	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
+
+	for i in range(1, d + 1):
+		for l in range(1, n + 1):
+			for m in range(1, l + 1):
+				if C[i][l] - C[i][m] == (C[i][l] - C[i][m]) // 2 * 2: # !
+					if C[i][m] == 1:
+						D[i][l][m] = m
+					else:
+						D[i][l][m] = m - P[i - 1]
+				else:
+					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]
+	# 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;
+
+	G: int = 0
+	l: int = 1
+
+	# kick off with null folding
+	while l > 0:
+		if l > n:
+			G = G + 1
+		else:
+			dd: int = 0
+			gg: int = gapter[l - 1]
+			g = gg
+			# dd is the no. of sections in which l is unconstrained,
+			# gg the no. of possible and g the no. of actual gaps for l, + gapter[l - 1]
+
+			# find the possible gaps for leaf l in each section,
+			# then discard those not common to all. All possible if dd = d
+			for i in range(1, d + 1):
+				if D[i][l][l] == l:
+					dd = dd + 1
+				else:
+					m: int = D[i][l][l]
+					while m != l:
+						gap[gg] = m
+						if count[m] == 0:
+							gg = gg + 1
+						count[m] += 1
+						m = D[i][l][B[m]]
+
+			if dd == d:
+				for m in range(l):
+					gap[gg] = m
+					gg = gg + 1
+
+			for j in range(g, gg):
+				gap[g] = gap[j]
+				if count[gap[j]] == d - dd:
+					g = g + 1
+				count[gap[j]] = 0
+
+		# for each gap insert leaf l, [the main while loop shall progress],
+		# remove leaf l
+		while l > 0 and g == gapter[l - 1]:
+			l = l - 1
+			B[A[l]] = B[l]
+			A[B[l]] = A[l]
+
+		if l > 0:
+			g = g - 1
+			A[l] = gap[g]
+			B[l] = B[A[l]]
+			B[A[l]] = l
+			A[B[l]] = l
+			gapter[l] = g
+			l = l + 1
+	return G

mapFolding/reference/rotatedEntryPoint.py

@@ -43,198 +43,198 @@ tricky = [
 COUNTindicesStatic = len(tricky)
 
 def countFolds(listDimensions: List[int]):
-    static = numpy.zeros(COUNTindicesStatic, dtype=numpy.int64)
+	static = numpy.zeros(COUNTindicesStatic, dtype=numpy.int64)
 
-    listDimensions, static[leavesTotal], D, track,gapsWhere = outfitFoldings(listDimensions)
+	listDimensions, static[leavesTotal], D, track,gapsWhere = outfitFoldings(listDimensions)
 
-    static[dimensionsTotal] = len(listDimensions)
-    static[dimensionsPlus1] = static[dimensionsTotal] + 1
+	static[dimensionsTotal] = len(listDimensions)
+	static[dimensionsPlus1] = static[dimensionsTotal] + 1
 
-    # Pass listDimensions and taskDivisions to _sherpa for benchmarking
-    foldingsTotal = _sherpa(track, gapsWhere, static, D, listDimensions)
-    return foldingsTotal
+	# Pass listDimensions and taskDivisions to _sherpa for benchmarking
+	foldingsTotal = _sherpa(track, gapsWhere, static, D, listDimensions)
+	return foldingsTotal
 
 # @recordBenchmarks()
 def _sherpa(track: NDArray, gap: NDArray, static: NDArray, D: NDArray, p: List[int]):
-    """Performance critical section that counts foldings.
-
-    Parameters:
-        track: Array tracking folding state
-        gap: Array for potential gaps
-        static: Array containing static configuration values
-        D: Array of leaf connections
-        p: List of dimensions for benchmarking
-    """
-    foldingsTotal = countFoldings(track, gap, static, D)
-    return foldingsTotal
+	"""Performance critical section that counts foldings.
+
+	Parameters:
+		track: Array tracking folding state
+		gap: Array for potential gaps
+		static: Array containing static configuration values
+		D: Array of leaf connections
+		p: List of dimensions for benchmarking
+	"""
+	foldingsTotal = countFoldings(track, gap, static, D)
+	return foldingsTotal
 
 @njit(cache=True, parallel=False, fastmath=False)
 def countFoldings(TEMPLATEtrack: NDArray,
-                    TEMPLATEgapsWhere: NDArray,
-                    the: NDArray,
-                    connectionGraph: NDArray
-                    ):
-
-    TEMPLATEmy = numpy.zeros(COUNTindicesDynamic, dtype=numpy.int64)
-    TEMPLATEmy[leaf1ndex] = 1
-
-    taskDivisions = 0
-    # taskDivisions = the[leavesTotal]
-    TEMPLATEmy[taskIndex] = taskDivisions - 1 # the first modulo is leavesTotal - 1
-
-    def prepareWork(track: NDArray,
-                    gapsWhere: NDArray,
-                    my: NDArray) -> tuple[NDArray, NDArray, NDArray]:
-        foldingsTotal = 0
-        while True:
-            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[leaf1ndex] - 1]
-                    my[gap1ndex] = my[gap1ndexCeiling]
-
-                    for PREPAREdimension1ndex in range(1, the[dimensionsPlus1]):
-                        if connectionGraph[PREPAREdimension1ndex][my[leaf1ndex]][my[leaf1ndex]] == my[leaf1ndex]:
-                            my[unconstrainedLeaf] += 1
-                        else:
-                            my[leafConnectee] = connectionGraph[PREPAREdimension1ndex][my[leaf1ndex]][my[leaf1ndex]]
-                            while my[leafConnectee] != my[leaf1ndex]:
-
-                                if my[leafConnectee] != my[leaf1ndex]:
-                                    my[dimension1ndex] = PREPAREdimension1ndex
-                                    return track, gapsWhere, my
-
-                                if my[leaf1ndex] != the[leavesTotal]:
-                                    gapsWhere[my[gap1ndexCeiling]] = my[leafConnectee]
-                                    if track[countDimensionsGapped][my[leafConnectee]] == 0:
-                                        my[gap1ndexCeiling] += 1
-                                    track[countDimensionsGapped][my[leafConnectee]] += 1
-                                else:
-                                    print("else")
-                                    my[dimension1ndex] = PREPAREdimension1ndex
-                                    return track, gapsWhere, my
-                                    # PREPAREmy[leafConnectee] % the[leavesTotal] == PREPAREmy[taskIndex]
-                                my[leafConnectee] = connectionGraph[dimension1ndex][my[leaf1ndex]][track[leafBelow][my[leafConnectee]]]
-
-                    if my[unconstrainedLeaf] == the[dimensionsTotal]:
-                        for indexLeaf in range(my[leaf1ndex]):
-                            gapsWhere[my[gap1ndexCeiling]] = indexLeaf
-                            my[gap1ndexCeiling] += 1
-
-                    for indexMiniGap in range(my[gap1ndex], my[gap1ndexCeiling]):
-                        gapsWhere[my[gap1ndex]] = gapsWhere[indexMiniGap]
-                        if track[countDimensionsGapped][gapsWhere[indexMiniGap]] == the[dimensionsTotal] - my[unconstrainedLeaf]:
-                            my[gap1ndex] += 1
-                        track[countDimensionsGapped][gapsWhere[indexMiniGap]] = 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
-
-    RETURNtrack, RETURNgapsWhere, RETURNmy = prepareWork(TEMPLATEtrack.copy(), TEMPLATEgapsWhere.copy(), TEMPLATEmy.copy())
-
-    foldingsTotal = doWork(RETURNtrack.copy(), RETURNgapsWhere.copy(), RETURNmy.copy(), the, connectionGraph, taskDivisions)
-
-    return foldingsTotal
+					TEMPLATEgapsWhere: NDArray,
+					the: NDArray,
+					connectionGraph: NDArray
+					):
+
+	TEMPLATEmy = numpy.zeros(COUNTindicesDynamic, dtype=numpy.int64)
+	TEMPLATEmy[leaf1ndex] = 1
+
+	taskDivisions = 0
+	# taskDivisions = the[leavesTotal]
+	TEMPLATEmy[taskIndex] = taskDivisions - 1 # the first modulo is leavesTotal - 1
+
+	def prepareWork(track: NDArray,
+					gapsWhere: NDArray,
+					my: NDArray) -> tuple[NDArray, NDArray, NDArray]:
+		foldingsTotal = 0
+		while True:
+			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[leaf1ndex] - 1]
+					my[gap1ndex] = my[gap1ndexCeiling]
+
+					for PREPAREdimension1ndex in range(1, the[dimensionsPlus1]):
+						if connectionGraph[PREPAREdimension1ndex][my[leaf1ndex]][my[leaf1ndex]] == my[leaf1ndex]:
+							my[unconstrainedLeaf] += 1
+						else:
+							my[leafConnectee] = connectionGraph[PREPAREdimension1ndex][my[leaf1ndex]][my[leaf1ndex]]
+							while my[leafConnectee] != my[leaf1ndex]:
+
+								if my[leafConnectee] != my[leaf1ndex]:
+									my[dimension1ndex] = PREPAREdimension1ndex
+									return track, gapsWhere, my
+
+								if my[leaf1ndex] != the[leavesTotal]:
+									gapsWhere[my[gap1ndexCeiling]] = my[leafConnectee]
+									if track[countDimensionsGapped][my[leafConnectee]] == 0:
+										my[gap1ndexCeiling] += 1
+									track[countDimensionsGapped][my[leafConnectee]] += 1
+								else:
+									print("else")
+									my[dimension1ndex] = PREPAREdimension1ndex
+									return track, gapsWhere, my
+									# PREPAREmy[leafConnectee] % the[leavesTotal] == PREPAREmy[taskIndex]
+								my[leafConnectee] = connectionGraph[dimension1ndex][my[leaf1ndex]][track[leafBelow][my[leafConnectee]]]
+
+					if my[unconstrainedLeaf] == the[dimensionsTotal]:
+						for indexLeaf in range(my[leaf1ndex]):
+							gapsWhere[my[gap1ndexCeiling]] = indexLeaf
+							my[gap1ndexCeiling] += 1
+
+					for indexMiniGap in range(my[gap1ndex], my[gap1ndexCeiling]):
+						gapsWhere[my[gap1ndex]] = gapsWhere[indexMiniGap]
+						if track[countDimensionsGapped][gapsWhere[indexMiniGap]] == the[dimensionsTotal] - my[unconstrainedLeaf]:
+							my[gap1ndex] += 1
+						track[countDimensionsGapped][gapsWhere[indexMiniGap]] = 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
+
+	RETURNtrack, RETURNgapsWhere, RETURNmy = prepareWork(TEMPLATEtrack.copy(), TEMPLATEgapsWhere.copy(), TEMPLATEmy.copy())
+
+	foldingsTotal = doWork(RETURNtrack.copy(), RETURNgapsWhere.copy(), RETURNmy.copy(), the, connectionGraph, taskDivisions)
+
+	return foldingsTotal
 
 @njit(cache=True, parallel=False, fastmath=False)
 def doWork(track: NDArray,
-                gapsWhere: NDArray,
-                my: NDArray,
-                the: NDArray,
-                connectionGraph: NDArray,
-                taskDivisions: int = 0
-                ):
-
-    papasGotABrandNewBag = True
-    if_activeLeaf1ndex_LTE_1_or_leafBelow_index_0_equals_1 = True
-    for_dimension1ndex_in_range_1_to_dimensionsPlus1 = True
-    while_leaf1ndexConnectee_notEquals_activeLeaf1ndex = True
-
-    thisIsNotTheFirstPass = False
-
-    while papasGotABrandNewBag:
-        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[leaf1ndex] > the[leavesTotal] and thisIsNotTheFirstPass:
-                my[foldingsSubtotal] += the[leavesTotal]
-            else:
-                if thisIsNotTheFirstPass:
-                    my[unconstrainedLeaf] = 0
-                    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[leaf1ndex]][my[leaf1ndex]] == my[leaf1ndex] and thisIsNotTheFirstPass:
-                        my[unconstrainedLeaf] += 1
-                    else:
-                        if thisIsNotTheFirstPass:
-                            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[leaf1ndex] != taskDivisions:
-                                myTask = True
-                            else:
-                                modulo = my[leafConnectee] % the[leavesTotal]
-                                if modulo == my[taskIndex]: myTask = True
-                                else:
-                                    myTask = False
-                            if myTask:
-                                gapsWhere[my[gap1ndexCeiling]] = my[leafConnectee]
-                                if track[countDimensionsGapped][my[leafConnectee]] == 0:
-                                    my[gap1ndexCeiling] += 1
-                                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]:
-                        for_dimension1ndex_in_range_1_to_dimensionsPlus1 = True
-                    else:
-                        my[dimension1ndex] = 1
-
-                if my[unconstrainedLeaf] == the[dimensionsTotal]:
-                    for leaf1ndex in range(my[leaf1ndex]):
-                        gapsWhere[my[gap1ndexCeiling]] = leaf1ndex
-                        my[gap1ndexCeiling] += 1
-
-                for indexMiniGap in range(my[gap1ndex], my[gap1ndexCeiling]):
-                    gapsWhere[my[gap1ndex]] = gapsWhere[indexMiniGap]
-                    if track[countDimensionsGapped][gapsWhere[indexMiniGap]] == the[dimensionsTotal] - my[unconstrainedLeaf]:
-                        my[gap1ndex] += 1
-                    track[countDimensionsGapped][gapsWhere[indexMiniGap]] = 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]
+				gapsWhere: NDArray,
+				my: NDArray,
+				the: NDArray,
+				connectionGraph: NDArray,
+				taskDivisions: int = 0
+				):
+
+	papasGotABrandNewBag = True
+	if_activeLeaf1ndex_LTE_1_or_leafBelow_index_0_equals_1 = True
+	for_dimension1ndex_in_range_1_to_dimensionsPlus1 = True
+	while_leaf1ndexConnectee_notEquals_activeLeaf1ndex = True
+
+	thisIsNotTheFirstPass = False
+
+	while papasGotABrandNewBag:
+		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[leaf1ndex] > the[leavesTotal] and thisIsNotTheFirstPass:
+				my[foldingsSubtotal] += the[leavesTotal]
+			else:
+				if thisIsNotTheFirstPass:
+					my[unconstrainedLeaf] = 0
+					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[leaf1ndex]][my[leaf1ndex]] == my[leaf1ndex] and thisIsNotTheFirstPass:
+						my[unconstrainedLeaf] += 1
+					else:
+						if thisIsNotTheFirstPass:
+							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[leaf1ndex] != taskDivisions:
+								myTask = True
+							else:
+								modulo = my[leafConnectee] % the[leavesTotal]
+								if modulo == my[taskIndex]: myTask = True
+								else:
+									myTask = False
+							if myTask:
+								gapsWhere[my[gap1ndexCeiling]] = my[leafConnectee]
+								if track[countDimensionsGapped][my[leafConnectee]] == 0:
+									my[gap1ndexCeiling] += 1
+								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]:
+						for_dimension1ndex_in_range_1_to_dimensionsPlus1 = True
+					else:
+						my[dimension1ndex] = 1
+
+				if my[unconstrainedLeaf] == the[dimensionsTotal]:
+					for leaf1ndex in range(my[leaf1ndex]):
+						gapsWhere[my[gap1ndexCeiling]] = leaf1ndex
+						my[gap1ndexCeiling] += 1
+
+				for indexMiniGap in range(my[gap1ndex], my[gap1ndexCeiling]):
+					gapsWhere[my[gap1ndex]] = gapsWhere[indexMiniGap]
+					if track[countDimensionsGapped][gapsWhere[indexMiniGap]] == the[dimensionsTotal] - my[unconstrainedLeaf]:
+						my[gap1ndex] += 1
+					track[countDimensionsGapped][gapsWhere[indexMiniGap]] = 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]