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

mapFolding/reference/jax.py

@@ -1,208 +0,0 @@
-"""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

@@ -1,153 +0,0 @@
-"""
-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

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