mapFolding 0.15.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

mapFolding/__init__.py

@@ -85,4 +85,5 @@ from mapFolding.oeis import (
 	getOEISids as getOEISids,
 	OEIS_for_n as OEIS_for_n,
 	oeisIDfor_n as oeisIDfor_n,
+    dictionaryOEIS as dictionaryOEIS,
 )

mapFolding/_oeisFormulas/A001010.py

@@ -0,0 +1,19 @@
+from mapFolding import countFolds
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A001010(n: int) -> int:
+	"""Complicated.
+
+	a(2n-1) = 2*A007822(n)
+	OddQ[n], 2*A007822[[(n - 1)/2 + 1]]]
+
+	a(2n) = 2*A000682(n+1)
+	EvenQ[n], 2*A000682[[n/2 + 1]]
+	"""
+	if n & 0b1:
+		foldsTotal = 2 * countFolds(oeisID='A007822', oeis_n=(n - 1)//2 + 1, flow='theorem2Numba')
+	else:
+		foldsTotal = 2 * A000682(n // 2 + 1)
+
+	return foldsTotal
+

mapFolding/_oeisFormulas/A001011.py

@@ -0,0 +1,5 @@
+from mapFolding._oeisFormulas.A000136 import A000136
+from mapFolding._oeisFormulas.A001010 import A001010
+
+def A001011(n: int) -> int:
+    return (A001010(n) + A000136(n)) // 4

mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -1,5 +1,6 @@
 from mapFolding._oeisFormulas.A000136 import A000136
 from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.A001010 import A001010
 from mapFolding._oeisFormulas.Z0Z_oeisMeanders import dictionaryOEISMeanders
 from mapFolding.oeis import dictionaryOEIS
 import sys
@@ -8,14 +9,25 @@ import time
 # ruff: noqa: ERA001
 
 if __name__ == '__main__':
+	def _write() -> None:
+		sys.stdout.write(
+			f"{(match:=foldsTotal == dictionaryOEISMeanders[oeisID]['valuesKnown'][n])}\t"
+			f"\033[{(not match)*91}m"
+			f"{n}\t"
+			f"{foldsTotal=}\t"
+			f"{dictionaryOEISMeanders[oeisID]['valuesKnown'][n]=}\t"
+			f"{time.perf_counter() - timeStart:.2f}\t"
+			# f"{description}\t"
+			"\033[0m\n"
+		)
 	oeisID = 'A000136'
 	oeisID = 'A000682'
-	for n in range(3, 13):
+	oeisID = 'A001010'
+	for n in range(2, 13):
 
 		# sys.stdout.write(f"{n = }\n")
 
 		timeStart = time.perf_counter()
 		foldsTotal = eval(oeisID)(n)
 		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
-		sys.stdout.write(f"{foldsTotal == dictionaryOEISMeanders[oeisID]['valuesKnown'][n]} {n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n") # pyright: ignore[reportIndexIssue]
-
+		_write()

mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -1,5 +1,7 @@
 from mapFolding._oeisFormulas.A000560 import A000560
 from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.A001010 import A001010
+from mapFolding._oeisFormulas.A001011 import A001011
 from mapFolding._oeisFormulas.A005315 import A005315
 from mapFolding._oeisFormulas.A005316 import A005316
 from mapFolding._oeisFormulas.A223094 import A223094
@@ -8,11 +10,11 @@ from mapFolding._oeisFormulas.A301620 import A301620
 from mapFolding.oeis import getOEISidInformation, getOEISidValues
 import sys
 
-'A001010'
-'A001011'
 oeisIDsMeanders: list[str] = [
 	'A000560',
 	'A000682',
+	'A001010',
+	'A001011',
 	'A005315',
 	'A005316',
 	'A223094',
@@ -37,19 +39,14 @@ rangeTest = range(5, 13)
 if __name__ == '__main__':
 	for n in rangeTest:
 
-		A000560for_n = A000560(n)
-		assert A000560for_n == dictionaryOEISMeanders['A000560']['valuesKnown'][n]
-		A000682for_n = A000682(n)
-		assert A000682for_n == dictionaryOEISMeanders['A000682']['valuesKnown'][n]
-		A005315for_n = A005315(n)
-		assert A005315for_n == dictionaryOEISMeanders['A005315']['valuesKnown'][n]
-		A005316for_n = A005316(n)
-		assert A005316for_n == dictionaryOEISMeanders['A005316']['valuesKnown'][n]
-		A223094for_n = A223094(n)
-		assert A223094for_n == dictionaryOEISMeanders['A223094']['valuesKnown'][n]
-		A259702for_n = A259702(n)
-		assert A259702for_n == dictionaryOEISMeanders['A259702']['valuesKnown'][n]
-		A301620for_n = A301620(n)
-		assert A301620for_n == dictionaryOEISMeanders['A301620']['valuesKnown'][n]
+		assert A000560(n) == dictionaryOEISMeanders['A000560']['valuesKnown'][n]
+		assert A000682(n) == dictionaryOEISMeanders['A000682']['valuesKnown'][n]
+		assert A001010(n) == dictionaryOEISMeanders['A001010']['valuesKnown'][n]
+		assert A001011(n) == dictionaryOEISMeanders['A001011']['valuesKnown'][n]
+		assert A005315(n) == dictionaryOEISMeanders['A005315']['valuesKnown'][n]
+		assert A005316(n) == dictionaryOEISMeanders['A005316']['valuesKnown'][n]
+		assert A223094(n) == dictionaryOEISMeanders['A223094']['valuesKnown'][n]
+		assert A259702(n) == dictionaryOEISMeanders['A259702']['valuesKnown'][n]
+		assert A301620(n) == dictionaryOEISMeanders['A301620']['valuesKnown'][n]
 
 	sys.stdout.write(f"\nTrue for {str(rangeTest)}\n")

mapFolding/_theTypes.py

@@ -36,7 +36,7 @@ NumPyFoldsTotal: TypeAlias = numpy_uint64  # noqa: UP040 The TypeAlias may be us
 
 Note well
 ---------
-If your elements might exceed 1.8 × 10^19, then you should take extra steps to ensure the integrity of the data in NumPy or use a
+If your elements might exceed 1.8 x 10^19, then you should take extra steps to ensure the integrity of the data in NumPy or use a
 different data structure."""
 
 Array3DLeavesTotal: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.

mapFolding/basecamp.py

@@ -134,7 +134,79 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	# Flow control until I can figure out a good way ---------------------------------
 
-	if flow == 'daoOfMapFolding':
+	# A007822 flow control until I can figure out a good way ---------------------------------
+	if oeisID == 'A007822':
+		"""Temporary notes.
+
+		The REAL motivation for integrating into basecamp is to integrate into the test modules. No, wait: to stop having to work
+		around the test modules.
+
+		I put `if oeisID == 'A007822'` in the `elif flow ==` cascade, before the `flow` checks because I want to remove A007822
+		from those flow paths. It is fundamentally incompatible and it will cause `Exception` or incorrect computations.
+
+		To use A007822, oeisID is mandatory.
+
+		Parameters:
+			listDimensions should work. mapShape should work. oeis_n should work. `pathLikeWriteFoldsTotal` should work!!! I
+			didn't think about that, and I like it.
+
+		Parallel version:
+			idk. The computation division logic will try to execute. As of 2025 Aug 6 at 7 PM, I haven't tried or thought about a
+			parallel version. TODO Watch out for errors.
+
+		`flow`:
+			It looks like I will need to make decisions tree just for A007822. That's probably not a big deal since all of the
+			possible routes are predictable.
+
+		"""
+		match flow:
+			case 'numba':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.algorithmA007822Numba import doTheNeedful  # noqa: PLC0415
+				mapFoldingState = doTheNeedful(mapFoldingState)
+
+			case 'theorem2':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.theorem2A007822 import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
+			case 'theorem2Numba':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.dataPackingA007822 import sequential  # noqa: PLC0415
+				mapFoldingState = sequential(mapFoldingState)
+
+			case 'theorem2Trimmed':
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
+				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+				from mapFolding.syntheticModules.theorem2A007822Trimmed import count  # noqa: PLC0415
+				mapFoldingState = count(mapFoldingState)
+
+			case _:
+				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				from mapFolding.syntheticModules.algorithmA007822 import doTheNeedful  # noqa: PLC0415
+				mapFoldingState = doTheNeedful(mapFoldingState)
+
+		foldsTotal = mapFoldingState.groupsOfFolds
+
+	elif flow == 'daoOfMapFolding':
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
@@ -142,12 +214,20 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
+	elif flow == 'numba':
+		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
+
 	elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 		from mapFolding.syntheticModules.theorem2 import count  # noqa: PLC0415
 		mapFoldingState = count(mapFoldingState)
@@ -158,8 +238,8 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 		from mapFolding.syntheticModules.theorem2Trimmed import count  # noqa: PLC0415
 		mapFoldingState = count(mapFoldingState)
@@ -170,8 +250,8 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
 		from mapFolding.syntheticModules.dataPacking import sequential  # noqa: PLC0415
 		mapFoldingState = sequential(mapFoldingState)
@@ -182,7 +262,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.dataBaskets import ParallelMapFoldingState  # noqa: PLC0415
 		parallelMapFoldingState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
 
-		from mapFolding.syntheticModules.countParallel import doTheNeedful  # noqa: PLC0415
+		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful  # noqa: PLC0415
 
 		# `listStatesParallel` exists in case you want to research the parallel computation.
 		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]
@@ -191,7 +271,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
+		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 

mapFolding/daoOfMapFolding.py

@@ -1,3 +1,4 @@
+# ruff: noqa: D100 D103
 from mapFolding.dataBaskets import MapFoldingState
 
 def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
@@ -139,4 +140,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
 	state = count(state)
-	return state
+	return state  # noqa: RET504

mapFolding/oeis.py

@@ -451,11 +451,7 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 		foldsTotal: int = dictionaryOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
 
-	if oeisID == 'A007822':
-		from mapFolding._A007822 import Z0Z_flowNeedsFixing  # noqa: PLC0415
-		return Z0Z_flowNeedsFixing(mapShape)
-
-	return countFolds(mapShape)
+	return countFolds(mapShape, oeisID=oeisID)
 
 def OEIS_for_n() -> None:
 	"""Command-line interface for calculating OEIS sequence values.

mapFolding/reference/jaxCount.py

@@ -18,7 +18,7 @@ over other approaches and presented additional complexity. It serves as a valuab
 for exploring alternative acceleration strategies and understanding the limitations of
 different computational frameworks for this specific algorithm.
 """
-from flattened import validateListDimensions, getLeavesTotal, makeConnectionGraph
+from flattened import getLeavesTotal, makeConnectionGraph, validateListDimensions
 from numpy.typing import NDArray
 from typing import Any
 import jax

mapFolding/reference/rotatedEntryPoint.py

@@ -18,8 +18,8 @@ structure can be creatively redesigned while maintaining the core computational
 
 from mapFolding import outfitFoldings
 from numba import njit
-import numpy
 from numpy.typing import NDArray
+import numpy
 
 """
 It is possible to enter the main `while` loop from an arbitrary point. This version is "rotated" to effectively enter at the modulo operator.

mapFolding/someAssemblyRequired/A007822rawMaterials.py

@@ -0,0 +1,46 @@
+from astToolkit import extractFunctionDef  # noqa: D100
+from hunterMakesPy import raiseIfNone
+from mapFolding.someAssemblyRequired.infoBooth import (
+	dataclassInstanceIdentifierDEFAULT, sourceCallableIdentifierDEFAULT, theCountingIdentifierDEFAULT)
+import ast
+
+Z0Z_identifier = 'filterAsymmetricFolds'
+ImaString = f"""
+def {Z0Z_identifier}(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	leafConnectee = 0
+	while leafConnectee < state.leavesTotal + 1:
+		leafNumber = int(state.leafBelow[state.indexLeaf])
+		state.leafComparison[leafConnectee] = (leafNumber - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+		state.indexLeaf = leafNumber
+		leafConnectee += 1
+
+	indexInMiddle = state.leavesTotal // 2
+	state.indexMiniGap = 0
+	while state.indexMiniGap < state.leavesTotal + 1:
+		ImaSymmetricFold = True
+		leafConnectee = 0
+		while leafConnectee < indexInMiddle:
+			if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+				ImaSymmetricFold = False
+				break
+			leafConnectee += 1
+		if ImaSymmetricFold:
+			state.groupsOfFolds += 1
+		state.indexMiniGap += 1
+
+	return state
+"""
+
+FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(ast.parse(ImaString), Z0Z_identifier))
+del ImaString
+
+ImaString = f"{dataclassInstanceIdentifierDEFAULT} = {Z0Z_identifier}({dataclassInstanceIdentifierDEFAULT})"
+Z0Z_incrementCount = ast.parse(ImaString).body[0]
+del ImaString
+
+
+ImaString = 'state.groupsOfFolds = (state.groupsOfFolds + 1) // 2'
+Z0Z_adjustFoldsTotal = ast.parse(ImaString).body[0]
+del ImaString
+