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

mapFolding/syntheticModules/theorem2A007822Trimmed.py

@@ -0,0 +1,64 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def count(state: MapFoldingState) -> MapFoldingState:
+    while state.leaf1ndex > 4:
+        if state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                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
+            else:
+                state.dimensionsUnconstrained = state.dimensionsTotal
+                state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+                state.indexDimension = 0
+                while state.indexDimension < state.dimensionsTotal:
+                    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                    if state.leafConnectee == state.leaf1ndex:
+                        state.dimensionsUnconstrained -= 1
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                            if state.countDimensionsGapped[state.leafConnectee] == 0:
+                                state.gap1ndexCeiling += 1
+                            state.countDimensionsGapped[state.leafConnectee] += 1
+                            state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                    state.indexDimension += 1
+                state.indexMiniGap = state.gap1ndex
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                        state.gap1ndex += 1
+                    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                    state.indexMiniGap += 1
+        while state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state.leaf1ndex -= 1
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+        state.gap1ndex -= 1
+        state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+        state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+        state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+        state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+        state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+        state.leaf1ndex += 1
+    else:
+        state.groupsOfFolds *= 2
+    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -1,5 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -42,5 +41,6 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
         leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
         gapRangeStart[leaf1ndex] = gap1ndex
         leaf1ndex += 1
-    groupsOfFolds *= 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    else:
+        groupsOfFolds *= 2
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)

mapFolding/syntheticModules/theorem2Trimmed.py

@@ -39,5 +39,6 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
-    state.groupsOfFolds *= 2
+    else:
+        state.groupsOfFolds *= 2
     return state

mapFolding/tests/test_computations.py

@@ -30,7 +30,7 @@ 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.initializeCount import initializeGroupsOfFolds
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
 from pathlib import Path, PurePosixPath
 from typing import Literal
@@ -41,8 +41,8 @@ import pytest
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'theorem2', 'theorem2Trimmed', 'theorem2numba'])
-def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: Literal['daoOfMapFolding', 'theorem2', 'theorem2numba']) -> None:
+@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)
@@ -86,6 +86,31 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 	for n in dictionaryOEIS[oeisID]['valuesTestValidation']:
 		standardizedEqualToCallableReturn(dictionaryOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
+@pytest.mark.parametrize('flow', ['numba', 'theorem2', 'theorem2numba', 'theorem2Trimmed'])
+def test_flowControlByOEISid(flow: str) -> None:
+	"""Crappy.
+
+	I'm making this while pushing through pain, so it's not great but it's a step in the right direction.
+
+	Notes for future me:
+
+	`oeisID` is a fixture: don't use it here.
+
+	`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:`
+
+	But that's wrong.
+
+	So, I'm changing the local identifier `OEISid` back to `oeisID` because I use `oeisID` everywhere else.
+	"""
+
+	oeisID = 'A007822'
+
+	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)
+
 @pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None:
 	"""Test dynamic code generation and execution for computational modules.
@@ -111,7 +136,7 @@ def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFil
 	from mapFolding.someAssemblyRequired.makeJobTheorem2Numba import makeJobNumba  # noqa: PLC0415
 	from mapFolding.someAssemblyRequired.toolkitNumba import SpicesJobNumba  # noqa: PLC0415
 	mapShape = oneTestCuzTestsOverwritingTests
-	state = initializeGroupsOfFolds(MapFoldingState(mapShape))
+	state = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
 
 	pathFilenameModule = pathFilename_tmpTesting.absolute()
 	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.15.0
+Version: 0.15.2
 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
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
-Keywords: A000136,A000560,A000682,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A195646,A223094,A259702,A301620,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,AST manipulation,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,GPU acceleration,high-performance computing,integer sequences,JIT compilation,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,Numba optimization,numerical algorithms,numerical computation,OEIS,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,Python optimization,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
+Keywords: A000136,A000560,A000682,A001010,A001011,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A195646,A223094,A259702,A301620,AST manipulation,GPU acceleration,JIT compilation,Numba optimization,OEIS,Python optimization,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,high-performance computing,integer sequences,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,numerical algorithms,numerical computation,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{mapfolding-0.15.0.dist-info → mapfolding-0.15.2.dist-info}/RECORD

@@ -1,24 +1,25 @@
-mapFolding/_A007822.py,sha256=Ge2PsiLvnz6jOjEGCV95cuQNRFQQT7hdHhdlePaEzyQ,6939
-mapFolding/__init__.py,sha256=mtABkOaPaJSdabbrGrVOzYV330UrSU6ObgOqKtd4p3M,3665
+mapFolding/__init__.py,sha256=UqUsMLADRoBiWI7YTwQqdP7gnoQ2HrerquHXPRTPeFM,3703
 mapFolding/_theSSOT.py,sha256=s2yx72OMJIQEFM_x-UpPuS8uzGEyt9hS4aCKU2GWERA,4832
-mapFolding/_theTypes.py,sha256=Y51kXvBExzjOABGKr8gP6qCsP-wHnJ7eGajoPmWa09c,3678
-mapFolding/basecamp.py,sha256=Uzy9GmU3o0vCKieVr2d_R2Mmx4gNsso8tXjkO0rXIlQ,9426
+mapFolding/_theTypes.py,sha256=wzr05TeV6gp7OlMNKvmP2yR5LI94BrBUWHe_7zXJRyM,3677
+mapFolding/basecamp.py,sha256=GtuP4WXG2s345RYLiRibt3d-MbH9qyJ7j-uWRR3UyfQ,12976
 mapFolding/beDRY.py,sha256=iYATcrYrAWkKaAecjA_awELBtZP5Q3snU4053dIsEwU,13941
-mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
+mapFolding/daoOfMapFolding.py,sha256=yLqaAqMwHIVFAtig3T46aZZQLAjCtQzYoAi0iMs_2CY,5482
 mapFolding/dataBaskets.py,sha256=04tVULSbWbPkKkLjTofWfVOr6gWcs38XILvU0-ftHIU,15191
 mapFolding/filesystemToolkit.py,sha256=Ex5tyugRQurXIgUNVtkQYfWMq8fM4e-izX01MBXU5_8,11006
-mapFolding/oeis.py,sha256=8dEqY2yJ2H3dZ8Gj1oTgYoNGmxviXwQRewMxyUNrCV0,19214
+mapFolding/oeis.py,sha256=nP_-cSNMkEsC0VWD93AqTO4lA7VFfkVsG-c3DnkwsaU,19093
 mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mapFolding/_oeisFormulas/A000136.py,sha256=G_vqOdb6s_YBbrCkHKjQDnlYfOZ4suXRtie6bRI7hhE,105
 mapFolding/_oeisFormulas/A000560.py,sha256=sN5-BAjL0oDk7YXZ2kx7ffBDX-gC28mmOj4CxHkM36c,113
 mapFolding/_oeisFormulas/A000682.py,sha256=w1u9ECjqw32IA_crWkdcFt_iojfmA7Js1ps8AEYb6es,516
+mapFolding/_oeisFormulas/A001010.py,sha256=-QjtVNo34EqOeQjOufuI32b7e6gn1aj5I5j_I_aAlyo,431
+mapFolding/_oeisFormulas/A001011.py,sha256=IlPvOdz0tSGSKTxKXTFYD41fO1N0TtUwwgvewbbteQs,177
 mapFolding/_oeisFormulas/A005315.py,sha256=g1P52zUuWCLFbTb_i6U75sVzXfUGaCM3rJonXNRgVr4,109
 mapFolding/_oeisFormulas/A005316.py,sha256=3B4_2TT_ip3CcYngEaFS-rTNDx-x2TZ0r_J0f8IMJbQ,234
 mapFolding/_oeisFormulas/A223094.py,sha256=z7t6RcRQlhXdbYImIER15KwG1_W7iV4MNIRDx9Q_Efs,284
 mapFolding/_oeisFormulas/A259702.py,sha256=9hUs8jzwOnJGmBsueS1yGsLjau4YVa0Yd9lYMG8UFso,123
 mapFolding/_oeisFormulas/A301620.py,sha256=pY0OJsCLhIEDHQUKpeSMTZ2SUFvcqt83uCOPE_lZCsw,225
-mapFolding/_oeisFormulas/Z0Z_aOFn.py,sha256=HadJifbcq8s5KrdhlPCP9r3gsh6AZHyN_M4_JTNoXiY,728
-mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py,sha256=yww1A9MCyCEdomzD1lqgf0aYdbY3ztspSRPoJD0t7uE,1766
+mapFolding/_oeisFormulas/Z0Z_aOFn.py,sha256=bx2C5hkQH9BK20ARLWpqgAzARFU8aNI3N1s9FoQX4eU,967
+mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py,sha256=c2PdVz2UdrHl3cnOVqrxr1VcquIb1jijuj4bZlIOYHk,1816
 mapFolding/_oeisFormulas/__init__.py,sha256=n83beVb7HHplXYAM5HveaIAuR7KrJG99OaNHJGMb_uc,44
 mapFolding/_oeisFormulas/matrixMeanders.py,sha256=Qk7S2dTpfZp-5bg--Qsspb2voOTBeLLQd7J_iQH3OpE,7356
 mapFolding/_oeisFormulas/matrixMeandersAnnex.py,sha256=UdSZCI9PtiuPCFTT6kLQZY7uoalaOkYzcR5VXUN8v1U,5793
@@ -33,47 +34,55 @@ mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInW
 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=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+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/matrixMeandersBaseline.py,sha256=8Z98MMfhTCdoa75HWZz4DO166EiHZCu5eHeFzhgK42s,3003
 mapFolding/reference/matrixMeandersBaselineAnnex.py,sha256=d2Oh4JZxz53ox_ArhIxpMTOuA7rtE9wnEPojpFcnlfc,5817
 mapFolding/reference/matrixMeandersSimpleQueue.py,sha256=pOfaS315OKIBG9GSqSJwUDcEhfnV2XduM9IPqHrBvJg,4083
 mapFolding/reference/matrixMeandersSlicePop.py,sha256=XyiesSQAH1dRplYx_CdR1FzcXvgmmxzj27V4aIqPp7o,5353
-mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
+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/someAssemblyRequired/A007822rawMaterials.py,sha256=I1lZyQ_4H7Ey07diN-0Ai7c-NUaV4ffFsZCUWdELXjc,1701
 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=o22qQ35N9M3N3kra16IayOpXMI1bkwVNQ5c04_rxMGw,44295
-mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=jh2tEqIWEVf015BkaMp5qx5IfGeECyJJzUZkUUw4J_E,17192
-mapFolding/someAssemblyRequired/makeJobTheorem2codon.py,sha256=q35Fsu1J3Alc9HLs4XvQ6r_caZJ4M69PHXFI0-NXaHY,11322
+mapFolding/someAssemblyRequired/makeAllModules.py,sha256=mNIT-qUJt75qJLTCVElbZPIZNH36qOG3akAJ57JerTo,44490
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=wflkPttFID9vao4C4CohoUCYgbMWD7GhZ7TO9h5mwtE,17196
+mapFolding/someAssemblyRequired/makeJobTheorem2codon.py,sha256=EPcrnHrK_TBqVB5uLvHz-XLcjaNYUhfQZCNaROCS1Oo,11326
 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/countParallel.py,sha256=_-OoZ07-5oC3WeB603tXUGT9c9-kmsDVtcluMTM8y1U,7784
-mapFolding/syntheticModules/daoOfMapFolding.py,sha256=OYaMwdyFzlll0OYlUwxQSvyLHgI4QzkDGkCPen1TFJ4,5946
-mapFolding/syntheticModules/dataPacking.py,sha256=vAi4vsGCwU_q8r3XpqW6LyuTba17ProT941pKbiWjCk,2320
-mapFolding/syntheticModules/initializeCount.py,sha256=nWSlJMMfIM3DvZxMn6ISQusUJqRYAjKQyLF5hwLEdBQ,3119
-mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
-mapFolding/syntheticModules/theorem2Numba.py,sha256=qfHlyiOxP1lLNvYg4zsrcLfKnynWAdu5dYGyrGPDtlM,3407
-mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
+mapFolding/syntheticModules/algorithmA007822.py,sha256=0Nsi-l9it4Wd9TACEecvOh02as_6gZJ9IsLcbVhZLFE,7078
+mapFolding/syntheticModules/algorithmA007822Numba.py,sha256=Tiychj5ST0Mxsw7KVp9Movdor5-deRb0tnfTbXA_RTc,7226
+mapFolding/syntheticModules/countParallelNumba.py,sha256=6sHWzGc6ch3HjKVB8krvaBec_KoHv3gpfN_F5Vl1SP8,7870
+mapFolding/syntheticModules/daoOfMapFoldingNumba.py,sha256=5oMb8pttNKslN6wss9JIQXSnmjgE2q_2-3fIrh1pEW0,6033
+mapFolding/syntheticModules/dataPacking.py,sha256=ZsEtbT3UCH2gscpK_N5ypGGUAyFA9_SrQaAnhr3BqjI,2413
+mapFolding/syntheticModules/dataPackingA007822.py,sha256=6XxYMaZ0_WNm1IJ2HbjZBD14ouLCvrMFApW5u3paJBs,2474
+mapFolding/syntheticModules/initializeState.py,sha256=OTiVi1Ywnlwk8tbwSIFjPJa_yBCINoapaCzGXDAJq_k,3121
+mapFolding/syntheticModules/initializeStateA007822.py,sha256=7Qd-ggF5RcSKXyCnw7PehEVuAlfED6rnqlJokqmSuJ4,4348
+mapFolding/syntheticModules/theorem2.py,sha256=QeXkBScihDatBk4iEMOMSntvhyJISb0G8zwZMQe7JFc,3031
+mapFolding/syntheticModules/theorem2A007822.py,sha256=SaJpHt0juljfHYR1XZMYHkYmLCHu-bpGhf3fky39RUc,4258
+mapFolding/syntheticModules/theorem2A007822Numba.py,sha256=E8U5_AF0uns-pDzJFMwfW44iCPDfUd5MsQM4jLCM1Os,4641
+mapFolding/syntheticModules/theorem2A007822Trimmed.py,sha256=gaTWsTJoDgCf-cW3gyheU9j2cj_R8CNvrnAp7lzv_8s,3926
+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=VZ9l0Vd2d-hdp6cVBmsTkYA7FZIH0cEgdeJx844oe3A,14624
-mapFolding/tests/test_computations.py,sha256=OjX7zECx2Hr6RsIi0hZZSzaiQJa7GBRLUpiASofNp-A,6541
+mapFolding/tests/test_computations.py,sha256=I1FJ5YRat16TCn_YfgiQQgej1bfE986WhV6k0YRXKhA,7461
 mapFolding/tests/test_filesystem.py,sha256=0rYQ62f4e3HOoymXrxDWbqNEBJQ7DGN8RUOMI84tE2Q,3892
 mapFolding/tests/test_oeis.py,sha256=ejqaOMB61c1oUEBblPPBG9hFFXffpKuIS0CJMe7Rd1o,5497
 mapFolding/tests/test_other.py,sha256=ScBiJ78LnyAaW-RhxcouX6Xw10wgpSdqfvT4LO3WjnQ,4766
 mapFolding/tests/test_tasks.py,sha256=_pr9JRWjjNKA7sww70XvkJJdGPruBVzubM63RmD_Du0,4013
-mapfolding-0.15.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapfolding-0.15.0.dist-info/METADATA,sha256=WqiwVl5WhvaaFlYtmq-toz5XCfcZYSSef1jY1awHxZk,5144
-mapfolding-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mapfolding-0.15.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.15.0.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
-mapfolding-0.15.0.dist-info/RECORD,,
+mapfolding-0.15.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.15.2.dist-info/METADATA,sha256=zT2XInHtZfx3eI_QvuO3YWp-Pm8TtJzHGuN8gBqJkTc,5160
+mapfolding-0.15.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mapfolding-0.15.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.15.2.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
+mapfolding-0.15.2.dist-info/RECORD,,

mapFolding/_A007822.py

@@ -1,181 +0,0 @@
-from mapFolding import Array1DLeavesTotal, makeDataContainer, NumPyLeavesTotal
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.oeis import dictionaryOEIS
-import numpy
-import sys
-import time
-
-def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
-	return state.leaf1ndex > 0
-
-def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
-	return state.leaf1ndex > state.leavesTotal
-
-def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
-	return state.leaf1ndex <= 1
-
-def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
-	return not state.dimensionsUnconstrained
-
-def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
-	state.dimensionsUnconstrained -= 1
-	return state
-
-def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
-	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
-	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
-		state = incrementActiveGap(state)
-	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
-	return state
-
-def gapAvailable(state: MapFoldingState) -> bool:
-	return state.leaf1ndex > 0
-
-def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
-	state.gap1ndex += 1
-	return state
-
-def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
-	state.gap1ndexCeiling += 1
-	return state
-
-def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
-	state.indexMiniGap += 1
-	return state
-
-def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
-	state.indexMiniGap = state.gap1ndex
-	return state
-
-def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
-	state.dimensionsUnconstrained = state.dimensionsTotal
-	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
-	state.indexDimension = 0
-	return state
-
-def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
-	state.indexLeaf = 0
-	while state.indexLeaf < state.leaf1ndex:
-		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
-		state.gap1ndexCeiling += 1
-		state.indexLeaf += 1
-	return state
-
-def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
-	state.gap1ndex -= 1
-	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
-	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
-	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
-	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
-	state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
-	state.leaf1ndex += 1
-	return state
-
-def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
-	return state.leafBelow[0] == 1
-
-def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
-	return state.leafConnectee == state.leaf1ndex
-
-def lookForGaps(state: MapFoldingState) -> MapFoldingState:
-	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
-	if state.countDimensionsGapped[state.leafConnectee] == 0:
-		state = incrementGap1ndexCeiling(state)
-	state.countDimensionsGapped[state.leafConnectee] += 1
-	return state
-
-def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
-	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
-	return state
-
-def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
-	return state.leafConnectee != state.leaf1ndex
-
-def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
-	return state.indexDimension < state.dimensionsTotal
-
-def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
-	return state.indexMiniGap < state.gap1ndexCeiling
-
-def noGapsHere(state: MapFoldingState) -> bool:
-	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
-
-def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
-	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
-	return state
-
-def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
-	state.indexDimension += 1
-	return state
-
-def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
-	state.leaf1ndex -= 1
-	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
-	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
-	return state
-
-def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
-	lengthLeafBelow = len(state.leafBelow)
-
-	indexLeaf: int = 0
-	for leafConnectee in range(lengthLeafBelow):
-		leafNumber = int(state.leafBelow[indexLeaf])
-		state.leafComparison[leafConnectee] = (leafNumber - indexLeaf + lengthLeafBelow - 1) % (lengthLeafBelow - 1)
-		indexLeaf = leafNumber
-
-	indexInMiddle = (lengthLeafBelow - 1) // 2
-	for delta in range(lengthLeafBelow):
-		ImaSymmetricFold = True
-		for leafConnectee in range(indexInMiddle):
-			if state.leafComparison[(delta + leafConnectee) % lengthLeafBelow] != state.leafComparison[(delta + lengthLeafBelow - 2 - leafConnectee) % lengthLeafBelow]:
-				ImaSymmetricFold = False
-				break
-		if ImaSymmetricFold:
-			state.groupsOfFolds += 1
-
-	return state
-
-def count(state: MapFoldingState) -> MapFoldingState:
-	while activeLeafGreaterThan0(state):
-		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
-			if activeLeafGreaterThanLeavesTotal(state):
-				state = filterAsymmetricFolds(state)
-			else:
-				state = initializeVariablesToFindGaps(state)
-				while loopingThroughTheDimensions(state):
-					state = lookupLeafConnecteeInConnectionGraph(state)
-					if leafConnecteeIsActiveLeaf(state):
-						state = activeLeafUnconstrainedInThisDimension(state)
-					else:
-						while loopingLeavesConnectedToActiveLeaf(state):
-							state = lookForGaps(state)
-							state = tryAnotherLeafConnectee(state)
-					state = tryNextDimension(state)
-				if activeLeafIsUnconstrainedInAllDimensions(state):
-					state = insertActiveLeaf(state)
-				state = initializeIndexMiniGap(state)
-				while loopingToActiveGapCeiling(state):
-					state = filterCommonGaps(state)
-					state = incrementIndexMiniGap(state)
-		while noGapsHere(state):
-			state = undoLastLeafPlacement(state)
-		if gapAvailable(state):
-			state = insertActiveLeafAtGap(state)
-	return state
-
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
-	state = count(state)
-	state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-	return state
-
-def Z0Z_flowNeedsFixing(mapShape: tuple[int, ...]) -> int:
-	return doTheNeedful(MapFoldingState(mapShape)).groupsOfFolds
-
-if __name__ == '__main__':
-	for n in range(3, 7):
-		mapShape = dictionaryOEIS['A007822']['getMapShape'](n)
-
-		state = MapFoldingState(mapShape)
-		timeStart = time.perf_counter()
-		foldsTotal = doTheNeedful(state).groupsOfFolds
-		sys.stdout.write(f"{foldsTotal == dictionaryOEIS['A007822']['valuesKnown'][n]} {n} {foldsTotal = } {time.perf_counter() - timeStart:.2f}\n")