mapFolding 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

mapFolding/reference/hunterNumba.py

@@ -0,0 +1,132 @@
+from typing import List
+import numba
+import numpy
+
+@numba.jit(cache=True, nopython=True, fastmath=True)
+def countFolds(listDimensions: List[int]) -> int:
+	"""
+	Count the number of distinct ways to fold a map with at least two positive dimensions.
+
+	Parameters:
+		listDimensions: A list of integers representing the dimensions of the map. Error checking and DRY code are impermissible in the numba and jax universes. Validate the list yourself before passing here. There might be some tools for that in this package unless I have become a pyL33t coder.
+
+	Returns:
+		foldsTotal: The total number of distinct folds for the given map dimensions.
+	"""
+	def integerSmall(value) -> numpy.uint8:
+		return numpy.uint8(value)
+
+	def integerLarge(value) -> numpy.uint64:
+		return numpy.uint64(value)
+
+	dtypeMedium = numpy.uint8
+	dtypeMaximum = numpy.uint16
+
+	leavesTotal = integerSmall(1)
+	for 个 in listDimensions:
+		leavesTotal = leavesTotal * integerSmall(个)
+	dimensionsTotal = integerSmall(len(listDimensions))
+
+	"""How to build a leaf connection graph, also called a "Cartesian Product Decomposition"
+	or a "Dimensional Product Mapping", with sentinels:
+	Step 1: find the cumulative product of the map's dimensions"""
+	cumulativeProduct = numpy.ones(dimensionsTotal + 1, dtype=dtypeMedium)
+	for dimension1ndex in range(1, dimensionsTotal + 1):
+		cumulativeProduct[dimension1ndex] = cumulativeProduct[dimension1ndex - 1] * listDimensions[dimension1ndex - 1]
+
+	"""Step 2: for each dimension, create a coordinate system """
+	"""coordinateSystem[dimension1ndex, leaf1ndex] holds the dimension1ndex-th coordinate of leaf leaf1ndex"""
+	coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeMedium)
+	for dimension1ndex in range(1, dimensionsTotal + 1):
+		for leaf1ndex in range(1, leavesTotal + 1):
+			coordinateSystem[dimension1ndex, leaf1ndex] = ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) % listDimensions[dimension1ndex - 1] + 1
+
+	"""Step 3: create a huge empty connection graph"""
+	connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeMedium)
+
+	"""Step for... for... for...: fill the connection graph"""
+	for dimension1ndex in range(1, dimensionsTotal + 1):
+		for leaf1ndex in range(1, leavesTotal + 1):
+			for leafConnectee in range(1, leaf1ndex + 1):
+				connectionGraph[dimension1ndex, leaf1ndex, leafConnectee] = (0 if leafConnectee == 0
+								else ((leafConnectee if coordinateSystem[dimension1ndex, leafConnectee] == 1
+											else leafConnectee - cumulativeProduct[dimension1ndex - 1])
+									if (coordinateSystem[dimension1ndex, leaf1ndex] & 1) == (coordinateSystem[dimension1ndex, leafConnectee] & 1)
+									else (leafConnectee if coordinateSystem[dimension1ndex, leafConnectee] == listDimensions[dimension1ndex-1]
+											or leafConnectee + cumulativeProduct[dimension1ndex - 1] > leaf1ndex
+											else leafConnectee + cumulativeProduct[dimension1ndex - 1])))
+
+	"""Indices of array `track` (to "track" the execution state), which is a collection of one-dimensional arrays each of length `leavesTotal + 1`."""
+	leafAbove = numba.literally(0)
+	leafBelow = numba.literally(1)
+	countDimensionsGapped = numba.literally(2)
+	gapRangeStart = numba.literally(3)
+	track = numpy.zeros((4, leavesTotal + 1), dtype=dtypeMedium)
+
+	gapsWhere = numpy.zeros(integerLarge(integerLarge(leavesTotal) * integerLarge(leavesTotal) + 1), dtype=dtypeMaximum)
+
+	foldsTotal = integerLarge(0)
+	leaf1ndex = integerSmall(1)
+	gap1ndex = integerSmall(0)
+
+	while leaf1ndex > 0:
+		if leaf1ndex <= 1 or track[leafBelow, 0] == 1:
+			if leaf1ndex > leavesTotal:
+				foldsTotal += leavesTotal
+			else:
+				dimensionsUnconstrained = integerSmall(0)
+				"""Track possible gaps for leaf1ndex in each section"""
+				gap1ndexCeiling = track[gapRangeStart, leaf1ndex - 1]
+
+				"""Count possible gaps for leaf1ndex in each section"""
+				dimension1ndex = integerSmall(1)
+				while dimension1ndex <= dimensionsTotal:
+					if connectionGraph[dimension1ndex, leaf1ndex, leaf1ndex] == leaf1ndex:
+						dimensionsUnconstrained += 1
+					else:
+						leafConnectee = connectionGraph[dimension1ndex, leaf1ndex, leaf1ndex]
+						while leafConnectee != leaf1ndex:
+							gapsWhere[gap1ndexCeiling] = leafConnectee
+							if track[countDimensionsGapped, leafConnectee] == 0:
+								gap1ndexCeiling += 1
+							track[countDimensionsGapped, leafConnectee] += 1
+							leafConnectee = connectionGraph[dimension1ndex, leaf1ndex, track[leafBelow, leafConnectee]]
+					dimension1ndex += 1
+
+				"""If leaf1ndex is unconstrained in all sections, it can be inserted anywhere"""
+				if dimensionsUnconstrained == dimensionsTotal:
+					indexLeaf = integerSmall(0)
+					while indexLeaf < leaf1ndex:
+						gapsWhere[gap1ndexCeiling] = indexLeaf
+						gap1ndexCeiling += 1
+						indexLeaf += 1
+
+				"""Filter gaps that are common to all sections"""
+				indexMiniGap = gap1ndex
+				while indexMiniGap < gap1ndexCeiling:
+					gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+					if track[countDimensionsGapped, gapsWhere[indexMiniGap]] == dimensionsTotal - dimensionsUnconstrained:
+						gap1ndex += 1
+					"""Reset track[countDimensionsGapped] for next iteration"""
+					track[countDimensionsGapped, gapsWhere[indexMiniGap]] = 0
+					indexMiniGap += 1
+
+		"""Recursive backtracking steps"""
+		while leaf1ndex > 0 and gap1ndex == track[gapRangeStart, leaf1ndex - 1]:
+			leaf1ndex -= 1
+			track[leafBelow, track[leafAbove, leaf1ndex]] = track[leafBelow, leaf1ndex]
+			track[leafAbove, track[leafBelow, leaf1ndex]] = track[leafAbove, leaf1ndex]
+
+		"""Place leaf in valid position"""
+		if leaf1ndex > 0:
+			gap1ndex -= 1
+			track[leafAbove, leaf1ndex] = gapsWhere[gap1ndex]
+			track[leafBelow, leaf1ndex] = track[leafBelow, track[leafAbove, leaf1ndex]]
+			track[leafBelow, track[leafAbove, leaf1ndex]] = leaf1ndex
+			track[leafAbove, track[leafBelow, leaf1ndex]] = leaf1ndex
+			"""Save current gap index"""
+			track[gapRangeStart, leaf1ndex] = gap1ndex
+			"""Move to next leaf"""
+			leaf1ndex += 1
+
+	return int(foldsTotal)

mapFolding/reference/irvineJavaPort.py

@@ -0,0 +1,120 @@
+"""
+Ported from the Java version by Sean A. Irvine:
+https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java
+
+Citation: mapFolding/citations/jOEIS.bibtex
+"""
+def foldings(p: list[int], res: int = 0, mod: int = 0) -> int:
+	"""
+	Compute the total number of foldings for a map with dimensions specified in p.
+
+	Parameters:
+		p: List of integers representing the dimensions of the map.
+		res: Residue for modulo operation (integer).
+		mod: Modulus for modulo operation (integer).
+
+	Returns:
+		total_count: The total number of foldings (integer).
+	"""
+	n = 1  # Total number of leaves
+	d = len(p)  # Number of dimensions
+	for dimension in p:
+		n *= dimension
+
+	# Initialize arrays/lists
+	A = [0] * (n + 1)	   # Leaf above leaf m
+	B = [0] * (n + 1)	   # Leaf below leaf m
+	count = [0] * (n + 1)   # Counts for potential gaps
+	gapter = [0] * (n + 1)  # Indices for gap stack per leaf
+	gap = [0] * (n * n + 1) # Stack of potential gaps
+
+	# Compute arrays P, C, D as per the algorithm
+	P = [1] * (d + 1)
+	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 = [[0] * (n + 1) for _ in range(d + 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
+
+	# D[i][l][m] computes the leaf connected to m in section i when inserting l
+	D = [[[0] * (n + 1) for _ in range(n + 1)] for _ in range(d + 1)]
+	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 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 mod == 0 or l != mod or m % mod == res:
+							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]:
+			# No more gaps to try, backtrack to previous leaf
+			l -= 1
+			B[A[l]] = B[l]
+			A[B[l]] = A[l]
+
+		if l > 0:
+			# Try next gap for leaf l
+			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/reference/jax.py

@@ -0,0 +1,208 @@
+"""I was able to implement the algorithm with JAX, but I didn't see an advantage and it's a pain in the ass.
+I don't maintain this module."""
+from mapFolding import validateListDimensions, getLeavesTotal, makeConnectionGraph
+from typing import List, Tuple
+import jax
+import jaxtyping
+
+dtypeMedium = jax.numpy.uint32
+dtypeMaximum = jax.numpy.uint32
+
+def countFolds(listDimensions: List[int]) -> int:
+	listDimensionsPositive: List[int] = validateListDimensions(listDimensions)
+
+	n: int = getLeavesTotal(listDimensionsPositive)
+	d: int = len(listDimensions)
+	import numpy
+	D: numpy.ndarray = makeConnectionGraph(listDimensionsPositive)
+	connectionGraph = jax.numpy.asarray(D, dtype=dtypeMedium)
+	del listDimensionsPositive
+
+	return foldingsJAX(n, d, connectionGraph)
+
+def foldingsJAX(leavesTotal: jaxtyping.UInt32, dimensionsTotal: jaxtyping.UInt32, connectionGraph: jaxtyping.Array) -> jaxtyping.UInt32:
+
+	def doNothing(argument):
+		return argument
+
+	def while_activeLeaf1ndex_greaterThan_0(comparisonValues: Tuple):
+		comparand = comparisonValues[6]
+		return comparand > 0
+
+	def countFoldings(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
+		_0, leafBelow, _2, _3, _4, _5, activeLeaf1ndex, _7 = allValues
+
+		sentinel = leafBelow.at[0].get().astype(jax.numpy.uint32)
+
+		allValues = jax.lax.cond(findGapsCondition(sentinel, activeLeaf1ndex),
+							lambda argumentX: dao(findGapsDo(argumentX)),
+							lambda argumentY: jax.lax.cond(incrementCondition(sentinel, activeLeaf1ndex), lambda argumentZ: dao(incrementDo(argumentZ)), dao, argumentY),
+							allValues)
+
+		return allValues
+
+	def findGapsCondition(leafBelowSentinel, activeLeafNumber):
+		return jax.numpy.logical_or(jax.numpy.logical_and(leafBelowSentinel == 1, activeLeafNumber <= leavesTotal), activeLeafNumber <= 1)
+
+	def findGapsDo(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
+		def for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1(comparisonValues: Tuple):
+			return comparisonValues[-1] <= dimensionsTotal
+
+		def for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1_do(for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
+			def ifLeafIsUnconstrainedCondition(comparand):
+				return jax.numpy.equal(connectionGraph[comparand, activeLeaf1ndex, activeLeaf1ndex], activeLeaf1ndex)
+
+			def ifLeafIsUnconstrainedDo(unconstrainedValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+				unconstrained_unconstrainedLeaf = unconstrainedValues[3]
+				unconstrained_unconstrainedLeaf = 1 + unconstrained_unconstrainedLeaf
+				return (unconstrainedValues[0], unconstrainedValues[1], unconstrainedValues[2], unconstrained_unconstrainedLeaf)
+
+			def ifLeafIsUnconstrainedElse(unconstrainedValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+				def while_leaf1ndexConnectee_notEquals_activeLeaf1ndex(comparisonValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+					return comparisonValues[-1] != activeLeaf1ndex
+
+				def countGaps(countGapsDoValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+					countGapsCountDimensionsGapped, countGapsPotentialGaps, countGapsGap1ndexLowerBound, countGapsLeaf1ndexConnectee = countGapsDoValues
+
+					countGapsPotentialGaps = countGapsPotentialGaps.at[countGapsGap1ndexLowerBound].set(countGapsLeaf1ndexConnectee)
+					countGapsGap1ndexLowerBound = jax.numpy.where(jax.numpy.equal(countGapsCountDimensionsGapped[countGapsLeaf1ndexConnectee], 0), countGapsGap1ndexLowerBound + 1, countGapsGap1ndexLowerBound)
+					countGapsCountDimensionsGapped = countGapsCountDimensionsGapped.at[countGapsLeaf1ndexConnectee].add(1)
+					countGapsLeaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, leafBelow.at[countGapsLeaf1ndexConnectee].get()].get().astype(jax.numpy.uint32)
+
+					return (countGapsCountDimensionsGapped, countGapsPotentialGaps, countGapsGap1ndexLowerBound, countGapsLeaf1ndexConnectee)
+
+				unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf = unconstrainedValues
+
+				leaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, activeLeaf1ndex].get().astype(jax.numpy.uint32)
+
+				countGapsValues = (unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, leaf1ndexConnectee)
+				countGapsValues = jax.lax.while_loop(while_leaf1ndexConnectee_notEquals_activeLeaf1ndex, countGaps, countGapsValues)
+				unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, leaf1ndexConnectee = countGapsValues
+
+				return (unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf)
+
+			dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf, dimensionNumber = for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values
+
+			ifLeafIsUnconstrainedValues = (dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf)
+			ifLeafIsUnconstrainedValues = jax.lax.cond(ifLeafIsUnconstrainedCondition(dimensionNumber), ifLeafIsUnconstrainedDo, ifLeafIsUnconstrainedElse, ifLeafIsUnconstrainedValues)
+			dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf = ifLeafIsUnconstrainedValues
+
+			dimensionNumber = 1 + dimensionNumber
+			return (dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf, dimensionNumber)
+
+		def almostUselessCondition(comparand):
+			return comparand == dimensionsTotal
+
+		def almostUselessConditionDo(for_leaf1ndex_in_range_activeLeaf1ndexValues: Tuple[jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+			def for_leaf1ndex_in_range_activeLeaf1ndex(comparisonValues):
+				return comparisonValues[-1] < activeLeaf1ndex
+
+			def for_leaf1ndex_in_range_activeLeaf1ndex_do(for_leaf1ndex_in_range_activeLeaf1ndexValues: Tuple[jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+				leafInRangePotentialGaps, gapNumberLowerBound, leafNumber = for_leaf1ndex_in_range_activeLeaf1ndexValues
+				leafInRangePotentialGaps = leafInRangePotentialGaps.at[gapNumberLowerBound].set(leafNumber)
+				gapNumberLowerBound = 1 + gapNumberLowerBound
+				leafNumber = 1 + leafNumber
+				return (leafInRangePotentialGaps, gapNumberLowerBound, leafNumber)
+			return jax.lax.while_loop(for_leaf1ndex_in_range_activeLeaf1ndex, for_leaf1ndex_in_range_activeLeaf1ndex_do, for_leaf1ndex_in_range_activeLeaf1ndexValues)
+
+		def for_range_from_activeGap1ndex_to_gap1ndexCeiling(comparisonValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+			return comparisonValues[-1] < gap1ndexCeiling
+
+		def miniGapDo(gapToGapValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+			gapToGapCountDimensionsGapped, gapToGapPotentialGaps, activeGapNumber, index = gapToGapValues
+			gapToGapPotentialGaps = gapToGapPotentialGaps.at[activeGapNumber].set(gapToGapPotentialGaps.at[index].get())
+			activeGapNumber = jax.numpy.where(jax.numpy.equal(gapToGapCountDimensionsGapped.at[gapToGapPotentialGaps.at[index].get()].get(), dimensionsTotal - unconstrainedLeaf), activeGapNumber + 1, activeGapNumber).astype(jax.numpy.uint32)
+			gapToGapCountDimensionsGapped = gapToGapCountDimensionsGapped.at[gapToGapPotentialGaps.at[index].get()].set(0)
+			index = 1 + index
+			return (gapToGapCountDimensionsGapped, gapToGapPotentialGaps, activeGapNumber, index)
+
+		_0, leafBelow, countDimensionsGapped, gapRangeStart, gapsWhere, _5, activeLeaf1ndex, activeGap1ndex = allValues
+
+		unconstrainedLeaf = jax.numpy.uint32(0)
+		dimension1ndex = jax.numpy.uint32(1)
+		gap1ndexCeiling = gapRangeStart.at[activeLeaf1ndex - 1].get().astype(jax.numpy.uint32)
+		activeGap1ndex = gap1ndexCeiling
+		for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values = (countDimensionsGapped, gapsWhere, gap1ndexCeiling, unconstrainedLeaf, dimension1ndex)
+		for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values = jax.lax.while_loop(for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1, for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1_do, for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values)
+		countDimensionsGapped, gapsWhere, gap1ndexCeiling, unconstrainedLeaf, dimension1ndex = for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values
+		del dimension1ndex
+
+		leaf1ndex = jax.numpy.uint32(0)
+		for_leaf1ndex_in_range_activeLeaf1ndexValues = (gapsWhere, gap1ndexCeiling, leaf1ndex)
+		for_leaf1ndex_in_range_activeLeaf1ndexValues = jax.lax.cond(almostUselessCondition(unconstrainedLeaf), almostUselessConditionDo, doNothing, for_leaf1ndex_in_range_activeLeaf1ndexValues)
+		gapsWhere, gap1ndexCeiling, leaf1ndex = for_leaf1ndex_in_range_activeLeaf1ndexValues
+		del leaf1ndex
+
+		indexMiniGap = activeGap1ndex
+		miniGapValues = (countDimensionsGapped, gapsWhere, activeGap1ndex, indexMiniGap)
+		miniGapValues = jax.lax.while_loop(for_range_from_activeGap1ndex_to_gap1ndexCeiling, miniGapDo, miniGapValues)
+		countDimensionsGapped, gapsWhere, activeGap1ndex, indexMiniGap = miniGapValues
+		del indexMiniGap
+
+		return (allValues[0], leafBelow, countDimensionsGapped, gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
+
+	def incrementCondition(leafBelowSentinel, activeLeafNumber):
+		return jax.numpy.logical_and(activeLeafNumber > leavesTotal, leafBelowSentinel == 1)
+
+	def incrementDo(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
+		foldingsSubTotal = allValues[5]
+		foldingsSubTotal = leavesTotal + foldingsSubTotal
+		return (allValues[0], allValues[1], allValues[2], allValues[3], allValues[4], foldingsSubTotal, allValues[6], allValues[7])
+
+	def dao(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
+		def whileBacktrackingCondition(backtrackingValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
+			comparand = backtrackingValues[2]
+			return jax.numpy.logical_and(comparand > 0, jax.numpy.equal(activeGap1ndex, gapRangeStart.at[comparand - 1].get()))
+
+		def whileBacktrackingDo(backtrackingValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
+			backtrackAbove, backtrackBelow, activeLeafNumber = backtrackingValues
+
+			activeLeafNumber = activeLeafNumber - 1
+			backtrackBelow = backtrackBelow.at[backtrackAbove.at[activeLeafNumber].get()].set(backtrackBelow.at[activeLeafNumber].get())
+			backtrackAbove = backtrackAbove.at[backtrackBelow.at[activeLeafNumber].get()].set(backtrackAbove.at[activeLeafNumber].get())
+
+			return (backtrackAbove, backtrackBelow, activeLeafNumber)
+
+		def if_activeLeaf1ndex_greaterThan_0(activeLeafNumber):
+			return activeLeafNumber > 0
+
+		def if_activeLeaf1ndex_greaterThan_0_do(leafPlacementValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
+			placeLeafAbove, placeLeafBelow, placeGapRangeStart, activeLeafNumber, activeGapNumber = leafPlacementValues
+			activeGapNumber = activeGapNumber - 1
+			placeLeafAbove = placeLeafAbove.at[activeLeafNumber].set(gapsWhere.at[activeGapNumber].get())
+			placeLeafBelow = placeLeafBelow.at[activeLeafNumber].set(placeLeafBelow.at[placeLeafAbove.at[activeLeafNumber].get()].get())
+			placeLeafBelow = placeLeafBelow.at[placeLeafAbove.at[activeLeafNumber].get()].set(activeLeafNumber)
+			placeLeafAbove = placeLeafAbove.at[placeLeafBelow.at[activeLeafNumber].get()].set(activeLeafNumber)
+			placeGapRangeStart = placeGapRangeStart.at[activeLeafNumber].set(activeGapNumber)
+
+			activeLeafNumber = 1 + activeLeafNumber
+			return (placeLeafAbove, placeLeafBelow, placeGapRangeStart, activeLeafNumber, activeGapNumber)
+
+		leafAbove, leafBelow, _2, gapRangeStart, gapsWhere, _5, activeLeaf1ndex, activeGap1ndex = allValues
+
+		whileBacktrackingValues = (leafAbove, leafBelow, activeLeaf1ndex)
+		whileBacktrackingValues = jax.lax.while_loop(whileBacktrackingCondition, whileBacktrackingDo, whileBacktrackingValues)
+		leafAbove, leafBelow, activeLeaf1ndex = whileBacktrackingValues
+
+		if_activeLeaf1ndex_greaterThan_0_values = (leafAbove, leafBelow, gapRangeStart, activeLeaf1ndex, activeGap1ndex)
+		if_activeLeaf1ndex_greaterThan_0_values = jax.lax.cond(if_activeLeaf1ndex_greaterThan_0(activeLeaf1ndex), if_activeLeaf1ndex_greaterThan_0_do, doNothing, if_activeLeaf1ndex_greaterThan_0_values)
+		leafAbove, leafBelow, gapRangeStart, activeLeaf1ndex, activeGap1ndex = if_activeLeaf1ndex_greaterThan_0_values
+
+		return (leafAbove, leafBelow, allValues[2], gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
+
+	# Dynamic values
+	A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+	B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+	count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+	gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+	gap = jax.numpy.zeros(leavesTotal * leavesTotal + 1, dtype=dtypeMaximum)
+
+	foldingsTotal = jax.numpy.uint32(0)
+	l = jax.numpy.uint32(1)
+	g = jax.numpy.uint32(0)
+
+	foldingsValues = (A, B, count, gapter, gap, foldingsTotal, l, g)
+	foldingsValues = jax.lax.while_loop(while_activeLeaf1ndex_greaterThan_0, countFoldings, foldingsValues)
+	return foldingsValues[5]
+
+foldingsJAX = jax.jit(foldingsJAX, static_argnums=(0, 1))

mapFolding/reference/lunnan.py

@@ -0,0 +1,153 @@
+"""
+An unnecessarily literal translation of the original Atlas Autocode code by W. F. Lunnon to Python.
+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
+"""# NOTE not functional yet
+def foldings(p, job=None):
+	"""An unnecessarily literal translation of the original Atlas Autocode code."""
+	p = list(p)
+	p.append(None)  # NOTE mimics Atlas `array` type
+	p.insert(0, None)  # NOTE mimics Atlas `array` type
+
+	if job is None:
+		global G
+		G = 0
+		def job(A, B):
+			global G
+			G = G + 1
+		return foldings(p, job)
+	# perform job (A, B) on each folding of a p[1] x ... x p[d] map,
+	# where A and B are the above and below vectors. p[d + 1] < 0 terminates p;
+
+	d: int
+	n: int
+	j: int
+	i: int
+	m: int
+	l: int
+	g: int
+	gg: int
+	dd: int
+
+	n = 1
+	i, d = 0, 0
+
+	while (i := i + 1) and p[i] is not None:
+		d = i
+		n = n * p[i]
+
+	# d dimensions and n leaves;
+
+	# A: list[int] = [None] * (n + 1) # type: ignore
+	# B: list[int] = [None] * (n + 1) # type: ignore
+	# count: list[int] = [None] * (n + 1) # type: ignore
+	# gapter: list[int] = [None] * (n + 1) # type: ignore
+	# gap: list[int] = [None] * (n * n + 1) # type: ignore
+	A: list[int] = [0] * (n + 1) # type: ignore
+	B: list[int] = [0] * (n + 1) # type: ignore
+	count: list[int] = [0] * (n + 1) # type: ignore
+	gapter: list[int] = [0] * (n + 1) # type: ignore
+	gap: list[int] = [0] * (n * n + 1) # type: ignore
+
+	# 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: list[int] = [0] * (d + 1) # type: ignore
+	C: list[list[int]] = [[0] * (n + 1) for dimension1 in range(d + 1)] # type: ignore
+	# D: list[list[list[int]]] = [[[None] * (n + 1) for dimension2 in range(n + 1)] for dimension1 in range(d + 1)] # type: ignore
+	D: list[list[list[int]]] = [[[0] * (n + 1) for dimension2 in range(n + 1)] for dimension1 in range(d + 1)]
+
+	P[0] = 1
+	for i in range(1, d + 1):
+		P[i] = P[i - 1] * p[i]
+
+	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
+
+	for i in range(1, d + 1):
+		for l in range(1, n + 1):
+			for m in range(1, l + 1):
+				D[i][l][m] = (0 if m == 0
+								else
+										((m if C[i][m] == 1
+											else m - P[i - 1])
+									if C[i][l] - C[i][m] == (C[i][l] - C[i][m]) // 2 * 2
+									else
+										(m if C[i][m] == p[i] or m + P[i - 1] > l
+											else 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;
+
+	for m in range(n + 1):
+		count[m] = 0
+
+	A[0], B[0], g, l = 0, 0, 0, 0
+
+	state = 'entry'
+	while True:
+		if state == 'entry':
+			gapter[l] = g
+			l = l + 1
+			if l <= n:
+				state = 'down'
+				continue
+			else:
+				job(A, B)
+				state = 'up'
+				continue
+
+		elif state == 'down':
+			dd = 0
+			gg = gapter[l - 1]
+			g = gg
+			for i in range(1, d + 1):
+				if D[i][l][l] == l:
+					dd = dd + 1
+				else:
+					m = D[i][l][l]
+					while m != l:
+						gap[gg] = m
+						if count[m] == 0:
+							gg = gg + 1
+						count[m] = 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
+			state = 'along'
+			continue
+
+		elif state == 'along':
+			if g == gapter[l - 1]:
+				state = 'up'
+				continue
+			g = g - 1
+			A[l] = gap[g]
+			B[l] = B[A[l]]
+			B[A[l]] = l
+			A[B[l]] = l
+			state = 'entry'
+			continue
+
+		elif state == 'up':
+			l = l - 1
+			B[A[l]] = B[l]
+			A[B[l]] = A[l]
+			if l > 0:
+				state = 'along'
+				continue
+			else:
+				break
+
+	return G #if job.__closure__ else None