mapFolding 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

mapFolding/reference/lunnanNumpy.py

@@ -1,123 +0,0 @@
-"""
-A generally faithful translation of the original Atlas Autocode code by W. F. Lunnon to Python using NumPy.
-W. F. Lunnon, Multi-dimensional map-folding, The Computer Journal, Volume 14, Issue 1, 1971, Pages 75-80, https://doi.org/10.1093/comjnl/14.1.75
-"""
-from typing import List
-import numpy
-
-def foldings(p: List[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: A list 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 = numpy.zeros(n + 1, dtype=int)
-	B = numpy.zeros(n + 1, dtype=int)
-	count = numpy.zeros(n + 1, dtype=int)
-	gapter = numpy.zeros(n + 1, dtype=int)
-	gap = numpy.zeros(n * n + 1, dtype=int)
-
-	# 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 = numpy.ones(d + 1, dtype=int)
-	C = numpy.zeros((d + 1, n + 1), dtype=int)
-	D = numpy.zeros((d + 1, n + 1, n + 1), dtype=int)
-
-	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]) % p[i - 1] + 1 # NOTE Because modulo is available, this statement is simpler.
-
-	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 <= 1 or B[0] == 1: # NOTE This statement is part of a significant divergence from the 1971 paper. As a result, this version is greater than one order of magnitude faster.
-			if l > n:
-				G = G + n # NOTE Due to `B[0] == 1`, this implementation increments the counted foldings in batches of `n`-many foldings, rather than immediately incrementing when a folding is found, i.e. `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/lunnanWhile.py

@@ -1,121 +0,0 @@
-"""
-A largely faithful translation of the original Atlas Autocode code by W. F. Lunnon to Python using `while`.
-W. F. Lunnon, Multi-dimensional map-folding, The Computer Journal, Volume 14, Issue 1, 1971, Pages 75-80, https://doi.org/10.1093/comjnl/14.1.75
-"""
-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

mapFolding/reference/rotatedEntryPoint.py

@@ -1,240 +0,0 @@
-from mapFolding import outfitFoldings
-from numba import njit
-from typing import List
-import numpy
-from numpy.typing import NDArray
-
-"""
-It is possible to enter the main `while` loop from an arbitrary point. This version is "rotated" to effectively enter at the modulo operator.
-"""
-
-# Indices of array `track`, which is a collection of one-dimensional arrays each of length `the[leavesTotal] + 1`.
-# The values in the array cells are dynamic, small, unsigned integers.
-A = leafAbove = 0
-"""Leaf above leaf m"""
-B = leafBelow = 1
-"""Leaf below leaf m"""
-count = countDimensionsGapped = 2
-"""Number of gaps available for leaf l"""
-gapter = gapRangeStart = 3
-"""Index of gap stack for leaf l"""
-
-# Indices of array `my`, which holds dynamic, small, unsigned, integer values.
-tricky = [
-(leaf1ndex := 0),
-(gap1ndex := 1),
-(unconstrainedLeaf := 2),
-(gap1ndexCeiling := 3),
-(leafConnectee := 4),
-(taskIndex := 5),
-(dimension1ndex := 6),
-(foldingsSubtotal := 7),
-]
-
-COUNTindicesDynamic = len(tricky)
-
-# Indices of array `the`, which holds unchanging, small, unsigned, integer values.
-tricky = [
-(dimensionsPlus1 := 0),
-(dimensionsTotal := 1),
-(leavesTotal := 2),
-]
-
-COUNTindicesStatic = len(tricky)
-
-def countFolds(listDimensions: List[int]):
-	static = numpy.zeros(COUNTindicesStatic, dtype=numpy.int64)
-
-	listDimensions, static[leavesTotal], D, track,gapsWhere = outfitFoldings(listDimensions)
-
-	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
-
-# @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
-
-@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
-
-@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]

mapFolding/reference/total_countPlus1vsPlusN.py

@@ -1,211 +0,0 @@
-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/someAssemblyRequired/__init__.py

@@ -1,5 +0,0 @@
-from mapFolding.someAssemblyRequired.getLLVMforNoReason import writeModuleLLVM
-from mapFolding.someAssemblyRequired.makeJob import makeStateJob
-from mapFolding.someAssemblyRequired.synthesizeNumbaGeneralized import youOughtaKnow
-from mapFolding.someAssemblyRequired.synthesizeNumbaJob import writeJobNumba
-from mapFolding.someAssemblyRequired.synthesizeNumbaModules import makeFlowNumbaOptimized