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

mapFolding/tests/test_computations.py

@@ -25,50 +25,28 @@ The `test_writeJobNumba` function shows how to test dynamically generated code,
 which is useful if you're working with the code synthesis features of the package.
 """
 
-from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding import countFolds, dictionaryOEISMapFolding, dictionaryOEISMeanders, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding.algorithms import oeisIDbyFormula
 from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.oeis import dictionaryOEIS
 from mapFolding.someAssemblyRequired.makeAllModules import parametersNumbaLight
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
 from pathlib import Path, PurePosixPath
-from typing import Literal
+from typing import Literal, TYPE_CHECKING
 import importlib.util
 import multiprocessing
 import pytest
 
+if TYPE_CHECKING:
+	from collections.abc import Callable
+
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2numba', 'theorem2Trimmed'])
-def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
-	"""Validate that different computational flows produce identical results.
-
-	(AI generated docstring)
-
-	This is the primary test for ensuring mathematical consistency across different
-	algorithmic implementations. When adding a new computational approach, include
-	it in the parametrized flow list to verify it produces correct results.
-
-	The test compares the output of each flow against known correct values from
-	OEIS sequences, ensuring that optimization techniques don't compromise accuracy.
-
-	Parameters
-	----------
-	mapShapeTestCountFolds : tuple[int, ...]
-		The map shape dimensions to test fold counting for.
-	flow : Literal['daoOfMapFolding', 'theorem2', 'theorem2numba']
-		The computational flow algorithm to validate.
-
-	"""
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
-
-def test_aOFn_calculate_value(oeisID: str) -> None:
+def test_aOFn_calculate_value_mapFolding(oeisID: str) -> None:
 	"""Verify OEIS sequence value calculations against known reference values.
 
-	(AI generated docstring)
-
 	Tests the `oeisIDfor_n` function by comparing its calculated output against
 	known correct values from the OEIS database. This ensures that sequence
 	value computations remain mathematically accurate across code changes.
@@ -83,33 +61,84 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 		The OEIS sequence identifier to test calculations for.
 
 	"""
-	for n in dictionaryOEIS[oeisID]['valuesTestValidation']:
-		standardizedEqualToCallableReturn(dictionaryOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+	for n in dictionaryOEISMapFolding[oeisID]['valuesTestValidation']:
+		standardizedEqualToCallableReturn(dictionaryOEISMapFolding[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
-@pytest.mark.parametrize('flow', ['numba', 'theorem2', 'theorem2numba', 'theorem2Trimmed'])
-def test_flowControlByOEISid(flow: str) -> None:
-	"""Crappy.
+def test_aOFn_calculate_value_meanders(oeisIDMeanders: str) -> None:
+	"""Verify Meanders OEIS sequence value calculations against known reference values.
 
-	I'm making this while pushing through pain, so it's not great but it's a step in the right direction.
+	Tests the functions in `mapFolding.algorithms.oeisIDbyFormula` by comparing their
+	calculated output against known correct values from the OEIS database for Meanders IDs.
 
-	Notes for future me:
+	Parameters
+	----------
+	oeisIDMeanders : str
+		The Meanders OEIS sequence identifier to test calculations for.
+
+	"""
+	oeisIDcallable: Callable[[int], int] = getattr(oeisIDbyFormula, oeisIDMeanders)
+	for n in dictionaryOEISMeanders[oeisIDMeanders]['valuesTestValidation']:
+		standardizedEqualToCallableReturn(
+			dictionaryOEISMeanders[oeisIDMeanders]['valuesKnown'][n],
+			oeisIDcallable,
+			n,
+		)
+
+@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
+def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
+	"""Validate that different computational flows produce valid results.
 
-	`oeisID` is a fixture: don't use it here.
+	(AI generated docstring)
 
-	`OEISid` matches `test_flowControlByOEISid`. It's pseudo-hardcoded to A007822 because that's currently the only OEISid that needs this test.
-	I tried:
-	`def test_flowControlByOEISid(OEISid: str | None, flow: str) -> None:`
+	This is the primary test for ensuring mathematical consistency across different
+	algorithmic implementations. When adding a new computational approach, include
+	it in the parametrized flow list to verify it produces correct results.
 
-	But that's wrong.
+	The test compares the output of each flow against known correct values from
+	OEIS sequences, ensuring that optimization techniques don't compromise accuracy.
+
+	Parameters
+	----------
+	mapShapeTestCountFolds : tuple[int, ...]
+		The map shape dimensions to test fold counting for.
+	flow : str
+		The computational flow algorithm to validate.
 
-	So, I'm changing the local identifier `OEISid` back to `oeisID` because I use `oeisID` everywhere else.
 	"""
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
 
-	oeisID = 'A007822'
+@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
+def test_flowControlByOEISid(oeisID: str, flow: str) -> None:
+	"""Validate that different flow paths using oeisID produce valid results.
 
-	for n in dictionaryOEIS[oeisID]['valuesTestValidation']:
-		mapShape = dictionaryOEIS[oeisID]['getMapShape'](n)
-		standardizedEqualToCallableReturn(dictionaryOEIS[oeisID]['valuesKnown'][n], countFolds, None, None, None, None, mapShape, oeisID, None, flow)
+	Parameters
+	----------
+	oeisID : str
+		The OEIS sequence identifier to test.
+	flow : str
+		The computational flow algorithm to validate.
+
+	"""
+	listDimensions = None
+	pathLikeWriteFoldsTotal = None
+	computationDivisions = None
+	CPUlimit = None
+	mapShape = None
+
+	oeis_n = 2
+	for oeis_n in dictionaryOEISMapFolding[oeisID]['valuesTestValidation']:
+		if oeis_n < 2:
+			continue
+
+		if oeisID in dictionaryOEISMeanders:
+			expected = dictionaryOEISMeanders[oeisID]['valuesKnown'][oeis_n]
+		else:
+			expected = dictionaryOEISMapFolding[oeisID]['valuesKnown'][oeis_n]
+
+		standardizedEqualToCallableReturn(
+			expected
+			, countFolds, listDimensions, pathLikeWriteFoldsTotal, computationDivisions, CPUlimit, mapShape
+			, oeisID, oeis_n, flow)
 
 @pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None:

mapFolding/tests/test_oeis.py

@@ -26,7 +26,7 @@ which is crucial for maintaining package reliability in production environments.
 
 from contextlib import redirect_stdout
 from mapFolding.oeis import (
-	_standardizeOEISid, clearOEIScache, dictionaryOEIS, getOEISids, OEIS_for_n, oeisIDfor_n, oeisIDsImplemented)
+	_standardizeOEISid, dictionaryOEISMapFolding, getOEISids, OEIS_for_n, oeisIDfor_n, oeisIDsImplemented)
 from mapFolding.tests.conftest import standardizedEqualToCallableReturn, standardizedSystemExit
 from typing import Any
 import io
@@ -57,24 +57,6 @@ def test_aOFn_invalid_n(oeisID_1random: str, badN: Any) -> None:
 def test_aOFn_zeroDim_A001418() -> None:
 	standardizedEqualToCallableReturn(ArithmeticError, oeisIDfor_n, 'A001418', 0)
 
-# ===== OEIS Cache Tests =====
-@pytest.mark.parametrize("cacheExists", [True, False])
-@unittest.mock.patch('pathlib.Path.exists')
-@unittest.mock.patch('pathlib.Path.unlink')
-def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unittest.mock.MagicMock, cacheExists: bool) -> None:
-	"""Test OEIS cache clearing with both existing and non-existing cache."""
-	mock_exists.return_value = cacheExists
-	clearOEIScache()
-
-	if cacheExists:
-		# Each OEIS ID has two cache files
-		expected_calls = len(dictionaryOEIS) * 2
-		assert mock_unlink.call_count == expected_calls
-		mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * expected_calls)
-	else:
-		mock_exists.assert_called_once()
-		mock_unlink.assert_not_called()
-
 # ===== Command Line Interface Tests =====
 def testHelpText() -> None:
 	"""Test that help text is complete and examples are valid."""
@@ -87,7 +69,7 @@ def testHelpText() -> None:
 	# Verify content
 	for oeisID in oeisIDsImplemented:
 		assert oeisID in helpText
-		assert dictionaryOEIS[oeisID]['description'] in helpText
+		assert dictionaryOEISMapFolding[oeisID]['description'] in helpText
 
 	# Extract and verify examples
 

{mapfolding-0.15.2.dist-info → mapfolding-0.15.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.15.2
+Version: 0.15.4
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -39,6 +39,7 @@ Requires-Dist: hunterMakesPy
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Provides-Extra: development
+Requires-Dist: memray; sys_platform == "linux" and extra == "development"
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"
 Requires-Dist: py-spy; extra == "development"

mapfolding-0.15.4.dist-info/RECORD

@@ -0,0 +1,78 @@
+mapFolding/__init__.py,sha256=6iou-H1W0rZdGmo7WjLwdYbR44fP_hVxeT2vjLh9e_A,3965
+mapFolding/_theSSOT.py,sha256=SoG6tKzhjpc7gnG1b3qLfpXiT2_GR3yYTWMpble6If4,5224
+mapFolding/_theTypes.py,sha256=F2pCHexrlbHTgMpQn58jDhkwAMFUSBp28gQp21n86o0,6559
+mapFolding/basecamp.py,sha256=TITldxLm889eqBPXmlAilbC6Bmi_QNafzaLWYe1jptg,15755
+mapFolding/beDRY.py,sha256=iYATcrYrAWkKaAecjA_awELBtZP5Q3snU4053dIsEwU,13941
+mapFolding/dataBaskets.py,sha256=04tVULSbWbPkKkLjTofWfVOr6gWcs38XILvU0-ftHIU,15191
+mapFolding/filesystemToolkit.py,sha256=Ex5tyugRQurXIgUNVtkQYfWMq8fM4e-izX01MBXU5_8,11006
+mapFolding/oeis.py,sha256=f9yywOQzvdG8ofqmRL1_-1BlO8rgo4TdEo6VyXHiJNw,18639
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/algorithms/__init__.py,sha256=gARPqfySaeSWMfApQ5wSxzy7ZdgLdKYsLqsRSEYWwWI,28
+mapFolding/algorithms/daoOfMapFolding.py,sha256=yLqaAqMwHIVFAtig3T46aZZQLAjCtQzYoAi0iMs_2CY,5482
+mapFolding/algorithms/matrixMeanders.py,sha256=XLcaiUH66PlIzEQb4bD7oZpWjFGxysnj_w-KiXxIj5E,20740
+mapFolding/algorithms/oeisIDbyFormula.py,sha256=Ke1SOVGzE3uDq0tAS2kHzo8AtT_tntmXpgcizNx6DVs,2889
+mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,2206
+mapFolding/reference/flattened.py,sha256=0eHgLFIeIeVUsI5zF5oSy5iWYrjOMzxr7KjDxiTe01k,16078
+mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
+mapFolding/reference/irvineJavaPort.py,sha256=XnsL4g33LRrYwAhcrAVt-ujsP6QD6fbyCsGYzcm9g_k,3724
+mapFolding/reference/jaxCount.py,sha256=t8ons45zyWNJQ-nmn1qbhNsTkTnRzf7ATauaYvIlkRI,14853
+mapFolding/reference/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnonWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=3IJU7Hc2PDSE71wmSkDs4Z3t0Px9NBSzmCsVrgQuQyU,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
+mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
+mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
+mapFolding/reference/meandersDumpingGround/A005316JavaPort.py,sha256=6qqTzbD3PTwYGtqaywEURGXtNFx1lp8ofEwpQeEvAHc,4899
+mapFolding/reference/meandersDumpingGround/A005316imperative.py,sha256=hhjUxELOktNBmHrwIoxVA-mcFsOWgg01p780OBeqL04,3816
+mapFolding/reference/meandersDumpingGround/A005316intOptimized.py,sha256=oO9ktdYeFwtosVp5KliwH8JmCSxfjapjBM1iMECuDAc,4121
+mapFolding/reference/meandersDumpingGround/A005316optimized128bit.py,sha256=6JxmVBIQnN0rH0MQIZtu_wgY1Wbms8hZCWarMe5NLLU,3416
+mapFolding/reference/meandersDumpingGround/A005316primitiveOptimized.py,sha256=iFig6Edv1E774xrlVUFLyscC40DqDhV-oh4hOnG2DLI,4116
+mapFolding/reference/meandersDumpingGround/A005316redis.py,sha256=MPeiobrs3VsNZOOKYBg52oVp0OjVDzLEdsRKfrZ9LrU,4328
+mapFolding/reference/meandersDumpingGround/A005316write2disk.py,sha256=NMVrdhe5KhnXQfaQ5Xr7Pwl5oXYEOM1DrMISDDOCVVw,5633
+mapFolding/reference/meandersDumpingGround/matrixMeanders64retired.py,sha256=oRVgf6zkWRjk7dWR-Px41M_5spdvKy_Pich0qd7oxVA,9270
+mapFolding/reference/meandersDumpingGround/matrixMeandersBaseline.py,sha256=8Z98MMfhTCdoa75HWZz4DO166EiHZCu5eHeFzhgK42s,3003
+mapFolding/reference/meandersDumpingGround/matrixMeandersBaselineAnnex.py,sha256=d2Oh4JZxz53ox_ArhIxpMTOuA7rtE9wnEPojpFcnlfc,5817
+mapFolding/reference/meandersDumpingGround/matrixMeandersBaselineV2.py,sha256=VpRiIGhnk-DbxwsHwCeCwXqcKLSNyHl-iRGLDH9ZGMY,7674
+mapFolding/reference/meandersDumpingGround/matrixMeandersSimpleQueue.py,sha256=pOfaS315OKIBG9GSqSJwUDcEhfnV2XduM9IPqHrBvJg,4083
+mapFolding/reference/meandersDumpingGround/matrixMeandersSlicePop.py,sha256=XyiesSQAH1dRplYx_CdR1FzcXvgmmxzj27V4aIqPp7o,5353
+mapFolding/someAssemblyRequired/A007822rawMaterials.py,sha256=_IeOaxuA3IoHzsrm7qRPO_M1ZT09ATLJl7xpTXiqg8E,1697
+mapFolding/someAssemblyRequired/RecipeJob.py,sha256=yGGPHq9JX-Gf7QlJz50EPpkO7sADwGvSZNA1aC_F_PQ,9866
+mapFolding/someAssemblyRequired/__init__.py,sha256=UNDh6O86jT5ywlw9LgeWsUHwOfNvoMJRDAzYXbwCbeM,5779
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=VDZC10Xo3E1Y5n6FmaBBbOBR-rinV9DFkpgw8zrDyzg,6339
+mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=Xbo1QJT8KtrWcAvQ-eLzOEzR8N78WfF43fJKGRIebA4,13625
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=tY0-2K0BFkwLAAjSrFJLPoG8CevDHOFc3OH3TxXANzg,2806
+mapFolding/someAssemblyRequired/infoBooth.py,sha256=GWiqnHbqk7te_pvVuk4G_gbFa_W2aeSx19w4pakvqfM,2300
+mapFolding/someAssemblyRequired/makeAllModules.py,sha256=V-vjzHQsD4O2SP--zCik7y7eblKZNPgU9CrUKZ7wAwY,44530
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=wflkPttFID9vao4C4CohoUCYgbMWD7GhZ7TO9h5mwtE,17196
+mapFolding/someAssemblyRequired/makeJobTheorem2codon.py,sha256=JasXcDMBVO1t0m84z1Q3T30dIZCteLsxVUK0QL3jYdA,11495
+mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=nCCVsGidAlcKRVAvA__hu4bXtat3B-cO9YloKtqOAc4,14919
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=nPGZsvb5GquaCCxdDh_XzNIZYSiVJpWKd7wfhfRvxnk,11512
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/algorithmA007822.py,sha256=rJHwImwcFGAysYoNME79qmNhoa3ebRgXb7ktKZLtSZ8,7074
+mapFolding/syntheticModules/algorithmA007822Numba.py,sha256=Ae_UZ2My56GJZ8ZA6WSeLWb7Rml3tcgxpY7r6-lTP6Y,7228
+mapFolding/syntheticModules/countParallelNumba.py,sha256=6sHWzGc6ch3HjKVB8krvaBec_KoHv3gpfN_F5Vl1SP8,7870
+mapFolding/syntheticModules/daoOfMapFoldingNumba.py,sha256=5oMb8pttNKslN6wss9JIQXSnmjgE2q_2-3fIrh1pEW0,6033
+mapFolding/syntheticModules/dataPacking.py,sha256=SzRmDNr2OZP6Xk4krLqxTuWAUtUJxBDXmHEqlBHzNPI,2407
+mapFolding/syntheticModules/dataPackingA007822.py,sha256=NeE6ohIx2yRIA25L58NbX3sd5OLPB9LkTqfeFjvUs3Y,2468
+mapFolding/syntheticModules/initializeState.py,sha256=OTiVi1Ywnlwk8tbwSIFjPJa_yBCINoapaCzGXDAJq_k,3121
+mapFolding/syntheticModules/initializeStateA007822.py,sha256=qizwxyNqKSgnF4MyBWU8Nca9IRbTnp-rrUAirF-ZL-E,4344
+mapFolding/syntheticModules/theorem2.py,sha256=QeXkBScihDatBk4iEMOMSntvhyJISb0G8zwZMQe7JFc,3031
+mapFolding/syntheticModules/theorem2A007822.py,sha256=HflJuuOj6b_cF6zEKmLy74Nzv_7jFrqLmjsN05XM4KQ,4254
+mapFolding/syntheticModules/theorem2A007822Numba.py,sha256=GppP_WntOrcFSIpIk6jP7PlAb4PlskzEBqfKOJaisSA,4637
+mapFolding/syntheticModules/theorem2A007822Trimmed.py,sha256=ekbKQ_FIZgaQ9m7NrxDimx5dM2PBDIReGBtpv23jpNc,3922
+mapFolding/syntheticModules/theorem2Numba.py,sha256=AFe-KI97ilPgPFA22ASAhfUetaTA249K7By_vqu1Crs,3416
+mapFolding/syntheticModules/theorem2Trimmed.py,sha256=geKX3So1SqhENlKeEO2dV6S3rGsxBp-AItB4hRbwbBI,2699
+mapFolding/tests/__init__.py,sha256=QVCHSMFVvTxV3mAyYOLkMFAFyBJ514zdoVnDmpBJnTo,1336
+mapFolding/tests/conftest.py,sha256=fLBZFStVJEIfbt6PQNVyAEdMVyck_lwhEB0eZYgQSwU,15255
+mapFolding/tests/test_computations.py,sha256=OTKnDqNOrTLhkfkoq0NX5veEsGQPlz140SROBWHI8U0,8297
+mapFolding/tests/test_filesystem.py,sha256=0rYQ62f4e3HOoymXrxDWbqNEBJQ7DGN8RUOMI84tE2Q,3892
+mapFolding/tests/test_oeis.py,sha256=qwi9z_BnpeGO4QwTHj_WOiP21gf2rUgDdxhc90zWsl8,4754
+mapFolding/tests/test_other.py,sha256=ScBiJ78LnyAaW-RhxcouX6Xw10wgpSdqfvT4LO3WjnQ,4766
+mapFolding/tests/test_tasks.py,sha256=_pr9JRWjjNKA7sww70XvkJJdGPruBVzubM63RmD_Du0,4013
+mapfolding-0.15.4.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.15.4.dist-info/METADATA,sha256=BXwMx_DXwPRzBfAXUWNsBUVp71OvXFIXkpOuToAOYqs,5234
+mapfolding-0.15.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mapfolding-0.15.4.dist-info/entry_points.txt,sha256=-mH9DjW9tDRMPaeoSWKKywG35cR28m12H_jtmrB4eY8,98
+mapfolding-0.15.4.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
+mapfolding-0.15.4.dist-info/RECORD,,

{mapfolding-0.15.2.dist-info → mapfolding-0.15.4.dist-info}/entry_points.txt

@@ -1,4 +1,3 @@
 [console_scripts]
 OEIS_for_n = mapFolding.oeis:OEIS_for_n
-clearOEIScache = mapFolding.oeis:clearOEIScache
 getOEISids = mapFolding.oeis:getOEISids

mapFolding/_oeisFormulas/A000136.py

@@ -1,4 +0,0 @@
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A000136(n: int) -> int:
-	return n * A000682(n)

mapFolding/_oeisFormulas/A000560.py

@@ -1,4 +0,0 @@
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A000560(n: int) -> int:
-    return A000682(n + 1) // 2

mapFolding/_oeisFormulas/A000682.py

@@ -1,17 +0,0 @@
-from mapFolding._oeisFormulas.matrixMeanders import count
-
-def initializeA000682(n: int) -> dict[int, int]:
-	curveLocationsMAXIMUM = 1 << (2 * n + 4)
-
-	curveSeed: int = 5 - (n & 0b1) * 4
-	listCurveLocations = [(curveSeed << 1) | curveSeed]
-
-	while listCurveLocations[-1] < curveLocationsMAXIMUM:
-		curveSeed = (curveSeed << 4) | 0b101
-		listCurveLocations.append((curveSeed << 1) | curveSeed)
-
-	return dict.fromkeys(listCurveLocations, 1)
-
-def A000682(n: int) -> int:
-	return count(n - 1, initializeA000682(n - 1))
-

mapFolding/_oeisFormulas/A001010.py

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

@@ -1,5 +0,0 @@
-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/A005315.py

@@ -1,4 +0,0 @@
-from mapFolding._oeisFormulas.A005316 import A005316
-
-def A005315(n: int) -> int:
-	return A005316(2 * n - 1)

mapFolding/_oeisFormulas/A005316.py

@@ -1,10 +0,0 @@
-from mapFolding._oeisFormulas.matrixMeanders import count
-
-def initializeA005316(n: int) -> dict[int, int]:
-	if n & 0b1:
-		return {22: 1}
-	else:
-		return {15: 1}
-
-def A005316(n: int) -> int:
-	return count(n-1, initializeA005316(n-1))

mapFolding/_oeisFormulas/A223094.py

@@ -1,7 +0,0 @@
-from mapFolding._oeisFormulas.A000136 import A000136
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A223094(n: int) -> int:
-    return A000136(n) - A000682(n + 1)
-
-# %F A223094 For n >= 3: a(n) = n! - Sum_{k=3..n-1} (a(k)*n!/k!) - A000682(n+1). - _Roger Ford_, Aug 24 2024

mapFolding/_oeisFormulas/A259702.py

@@ -1,4 +0,0 @@
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A259702(n: int) -> int:
-	return A000682(n) // 2 - A000682(n - 1)

mapFolding/_oeisFormulas/A301620.py

@@ -1,6 +0,0 @@
-from mapFolding._oeisFormulas.A000682 import A000682
-
-def A301620(n: int) -> int:
-	return A000682(n + 2) - 2 * A000682(n + 1)
-
-# %F A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018

mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -1,33 +0,0 @@
-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
-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'
-	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")
-		_write()

mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -1,52 +0,0 @@
-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
-from mapFolding._oeisFormulas.A259702 import A259702
-from mapFolding._oeisFormulas.A301620 import A301620
-from mapFolding.oeis import getOEISidInformation, getOEISidValues
-import sys
-
-oeisIDsMeanders: list[str] = [
-	'A000560',
-	'A000682',
-	'A001010',
-	'A001011',
-	'A005315',
-	'A005316',
-	'A223094',
-	'A259702',
-	'A301620',
-]
-
-dictionaryOEISMeanders: dict[str, dict[str, dict[int, int] | str | int]] = {
-	oeisID: {
-		'valuesKnown': getOEISidValues(oeisID),
-		'description': getOEISidInformation(oeisID)[0],
-		'offset': getOEISidInformation(oeisID)[1],
-	}
-	for oeisID in oeisIDsMeanders
-}
-
-# ruff: noqa: S101
-# pyright: reportIndexIssue=false
-
-rangeTest = range(5, 13)
-
-if __name__ == '__main__':
-	for n in rangeTest:
-
-		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/_oeisFormulas/__init__.py

@@ -1 +0,0 @@
-"""OEIS formula collection and analysis."""

mapFolding/_oeisFormulas/matrixMeandersAnnex.py

@@ -1,84 +0,0 @@
-from typing import NamedTuple
-import sys
-
-class limitLocators(NamedTuple):
-	bifurcationAlphaLocator: int
-	bifurcationZuluLocator: int
-	curveLocationsMAXIMUM: int
-
-curveMaximum: dict[int, limitLocators] = {
-0: limitLocators(0x15, 0x2a, 0x10),
-1: limitLocators(0x55, 0xaa, 0x40),
-2: limitLocators(0x155, 0x2aa, 0x100),
-3: limitLocators(0x555, 0xaaa, 0x400),
-4: limitLocators(0x1555, 0x2aaa, 0x1000),
-5: limitLocators(0x5555, 0xaaaa, 0x4000),
-6: limitLocators(0x15555, 0x2aaaa, 0x10000),
-7: limitLocators(0x55555, 0xaaaaa, 0x40000),
-8: limitLocators(0x155555, 0x2aaaaa, 0x100000),
-9: limitLocators(0x555555, 0xaaaaaa, 0x400000),
-10: limitLocators(0x1555555, 0x2aaaaaa, 0x1000000),
-11: limitLocators(0x5555555, 0xaaaaaaa, 0x4000000),
-12: limitLocators(0x15555555, 0x2aaaaaaa, 0x10000000),
-13: limitLocators(0x55555555, 0xaaaaaaaa, 0x40000000),
-14: limitLocators(0x155555555, 0x2aaaaaaaa, 0x100000000),
-15: limitLocators(0x555555555, 0xaaaaaaaaa, 0x400000000),
-16: limitLocators(0x1555555555, 0x2aaaaaaaaa, 0x1000000000),
-17: limitLocators(0x5555555555, 0xaaaaaaaaaa, 0x4000000000),
-18: limitLocators(0x15555555555, 0x2aaaaaaaaaa, 0x10000000000),
-19: limitLocators(0x55555555555, 0xaaaaaaaaaaa, 0x40000000000),
-20: limitLocators(0x155555555555, 0x2aaaaaaaaaaa, 0x100000000000),
-21: limitLocators(0x555555555555, 0xaaaaaaaaaaaa, 0x400000000000),
-22: limitLocators(0x1555555555555, 0x2aaaaaaaaaaaa, 0x1000000000000),
-23: limitLocators(0x5555555555555, 0xaaaaaaaaaaaaa, 0x4000000000000),
-24: limitLocators(0x15555555555555, 0x2aaaaaaaaaaaaa, 0x10000000000000),
-25: limitLocators(0x55555555555555, 0xaaaaaaaaaaaaaa, 0x40000000000000),
-26: limitLocators(0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
-27: limitLocators(0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
-28: limitLocators(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
-29: limitLocators(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000),
-30: limitLocators(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
-31: limitLocators(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
-32: limitLocators(0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
-33: limitLocators(0x555555555555555555, 0xaaaaaaaaaaaaaaaaaa, 0x400000000000000000),
-34: limitLocators(0x1555555555555555555, 0x2aaaaaaaaaaaaaaaaaa, 0x1000000000000000000),
-35: limitLocators(0x5555555555555555555, 0xaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000),
-36: limitLocators(0x15555555555555555555, 0x2aaaaaaaaaaaaaaaaaaa, 0x10000000000000000000),
-37: limitLocators(0x55555555555555555555, 0xaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000),
-38: limitLocators(0x155555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000),
-39: limitLocators(0x555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000),
-40: limitLocators(0x1555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000),
-41: limitLocators(0x5555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000),
-42: limitLocators(0x15555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000),
-43: limitLocators(0x55555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000),
-44: limitLocators(0x155555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000),
-45: limitLocators(0x555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000),
-46: limitLocators(0x1555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000),
-47: limitLocators(0x5555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000),
-48: limitLocators(0x15555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000),
-49: limitLocators(0x55555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000),
-50: limitLocators(0x155555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000),
-51: limitLocators(0x555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000),
-52: limitLocators(0x1555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000),
-53: limitLocators(0x5555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000),
-54: limitLocators(0x15555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000),
-55: limitLocators(0x55555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000),
-56: limitLocators(0x155555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000000),
-57: limitLocators(0x555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000000),
-58: limitLocators(0x1555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000000),
-59: limitLocators(0x5555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000000),
-60: limitLocators(0x15555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000000),
-61: limitLocators(0x55555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000000),
-}
-
-def makeCurveMaximum() -> None:
-	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
-	for n in range(62):
-		curveLocationsMAXIMUM = 1 << (2 * n + 4)
-		bifurcationAlphaLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
-		sys.stdout.write(f"{n}: limitLocators({hex(bifurcationAlphaLocator)}, {hex(bifurcationAlphaLocator << 1)}, {hex(curveLocationsMAXIMUM)}),\n")
-	sys.stdout.write("}\n")
-
-if __name__ == '__main__':
-	makeCurveMaximum()
-