mapFolding 0.16.4__py3-none-any.whl → 0.17.0__py3-none-any.whl

mapFolding/syntheticModules/A007822/initializeState.py

@@ -1,8 +1,7 @@
 from mapFolding.dataBaskets import SymmetricFoldsState
-import numpy
 
 def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
-    while state.groupsOfFolds == 0:
+    while state.symmetricFolds == 0:
         if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
             if state.leaf1ndex > state.leavesTotal:
                 state.indexLeaf = 1
@@ -13,10 +12,13 @@ def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState
                     state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
                     state.indexLeaf = state.indexMiniGap
                     state.leafConnectee += 1
-                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    state.groupsOfFolds += compared[indexRow].all()
+                for listTuples in state.indices:
+                    state.leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                            state.leafConnectee = 0
+                            break
+                    state.symmetricFolds += state.leafConnectee
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -58,5 +60,5 @@ def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState
             state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
             state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
             state.leaf1ndex += 1
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    return state
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
+    return state

mapFolding/syntheticModules/A007822/theorem2.py

@@ -1,6 +1,5 @@
 from mapFolding.dataBaskets import SymmetricFoldsState
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
-import numpy
 
 def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
@@ -14,10 +13,13 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
                     state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
                     state.indexLeaf = state.indexMiniGap
                     state.leafConnectee += 1
-                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    state.groupsOfFolds += compared[indexRow].all()
+                for listTuples in state.indices:
+                    state.leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                            state.leafConnectee = 0
+                            break
+                    state.symmetricFolds += state.leafConnectee
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -59,11 +61,11 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
     else:
-        state.groupsOfFolds *= 2
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+        state.symmetricFolds *= 2
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
 def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/A007822/theorem2Numba.py

@@ -1,10 +1,12 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, SymmetricFoldsState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	SymmetricFoldsState)
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 from numba import jit
-import numpy
+from numba.typed import List
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
-def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, arrayGroupOfFolds: Array2DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, indicesArrayGroupOfFolds: Array2DLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, Array2DLeavesTotal, DatatypeLeavesTotal]:
+def count(symmetricFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, indices: list[list[tuple[int, int]]], leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, list[list[tuple[int, int]]], DatatypeLeavesTotal]:
     while leaf1ndex > 4:
         if leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -16,10 +18,13 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                     leafComparison[leafConnectee] = (indexMiniGap - indexLeaf + leavesTotal) % leavesTotal
                     indexLeaf = indexMiniGap
                     leafConnectee += 1
-                arrayGroupOfFolds = numpy.take(leafComparison, indicesArrayGroupOfFolds)
-                compared = arrayGroupOfFolds[..., 0:leavesTotal // 2] == arrayGroupOfFolds[..., leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    groupsOfFolds += compared[indexRow].all()
+                for listTuples in indices:
+                    leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if leafComparison[indexLeft] != leafComparison[indexRight]:
+                            leafConnectee = 0
+                            break
+                    symmetricFolds += leafConnectee
             else:
                 dimensionsUnconstrained = dimensionsTotal
                 gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
@@ -55,14 +60,14 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
         gapRangeStart[leaf1ndex] = gap1ndex
         leaf1ndex += 1
     else:
-        groupsOfFolds *= 2
-    groupsOfFolds = (groupsOfFolds + 1) // 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal)
+        symmetricFolds *= 2
+    symmetricFolds = (symmetricFolds + 1) // 2
+    return (symmetricFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, indices, leavesTotal)
 
 def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
-    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    symmetricFolds: DatatypeFoldsTotal = state.symmetricFolds
     gap1ndex: DatatypeElephino = state.gap1ndex
     gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
     indexDimension: DatatypeLeavesTotal = state.indexDimension
@@ -77,11 +82,10 @@ def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
     leafComparison: Array1DLeavesTotal = state.leafComparison
-    arrayGroupOfFolds: Array2DLeavesTotal = state.arrayGroupOfFolds
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
-    indicesArrayGroupOfFolds: Array2DLeavesTotal = state.indicesArrayGroupOfFolds
+    indices: list[list[tuple[int, int]]] = List(state.indices)
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal)
-    state = SymmetricFoldsState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    symmetricFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, indices, leavesTotal = count(symmetricFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, indices, leavesTotal)
+    state = SymmetricFoldsState(mapShape=mapShape, symmetricFolds=symmetricFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
+    return state

mapFolding/syntheticModules/A007822/theorem2Trimmed.py

@@ -1,6 +1,5 @@
 from mapFolding.dataBaskets import SymmetricFoldsState
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
-import numpy
 
 def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
@@ -14,10 +13,13 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
                     state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
                     state.indexLeaf = state.indexMiniGap
                     state.leafConnectee += 1
-                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    state.groupsOfFolds += compared[indexRow].all()
+                for listTuples in state.indices:
+                    state.leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                            state.leafConnectee = 0
+                            break
+                    state.symmetricFolds += state.leafConnectee
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -53,11 +55,11 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
     else:
-        state.groupsOfFolds *= 2
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+        state.symmetricFolds *= 2
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
 def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/countParallelNumba.py

@@ -1,8 +1,11 @@
 from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, ParallelMapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	ParallelMapFoldingState)
 from multiprocessing import set_start_method as multiprocessing_set_start_method
 from numba import jit
+
 if __name__ == '__main__':
     multiprocessing_set_start_method('spawn')
 
@@ -95,4 +98,4 @@ def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple
             listStatesParallel[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
             groupsOfFoldsTotal += listStatesParallel[indexSherpa].groupsOfFolds
     foldsTotal: int = groupsOfFoldsTotal * stateParallel.leavesTotal
-    return (foldsTotal, listStatesParallel)
+    return (foldsTotal, listStatesParallel)

mapFolding/syntheticModules/daoOfMapFoldingNumba.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -71,4 +73,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
-    return state
+    return state

mapFolding/syntheticModules/initializeState.py

@@ -46,4 +46,4 @@ def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
             state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
             state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
             state.leaf1ndex += 1
-    return state
+    return state

mapFolding/syntheticModules/meanders/bigInt.py

@@ -1,7 +1,43 @@
-from mapFolding.algorithms.matrixMeandersBeDry import (areIntegersWide,
-                                                       walkDyckPath)
-from mapFolding.dataBaskets import MatrixMeandersNumPyState
+from functools import cache
+from mapFolding.algorithms.matrixMeandersNumPyndas import areIntegersWide, MatrixMeandersNumPyState
 
+@cache
+def walkDyckPath(intWithExtra_0b1: int) -> int:
+    """Find the bit position for flipping paired curve endpoints in meander transfer matrices.
+
+    Parameters
+    ----------
+    intWithExtra_0b1 : int
+        Binary representation of curve locations with an extra bit encoding parity information.
+
+    Returns
+    -------
+    flipExtra_0b1_Here : int
+        Bit mask indicating the position where the balance condition fails, formatted as 2^(2k).
+
+    3L33T H@X0R
+    ------------
+    Binary search for first negative balance in shifted bit pairs. Returns 2^(2k) mask for
+    bit position k where cumulative balance counter transitions from non-negative to negative.
+
+    Mathematics
+    -----------
+    Implements the Dyck path balance verification algorithm from Jensen's transfer matrix
+    enumeration. Computes the position where ∑(i=0 to k) (-1)^b_i < 0 for the first time,
+    where b_i are the bits of the input at positions 2i.
+
+    """
+    findTheExtra_0b1: int = 0
+    flipExtra_0b1_Here: int = 1
+    while True:
+        flipExtra_0b1_Here <<= 2
+        if intWithExtra_0b1 & flipExtra_0b1_Here == 0:
+            findTheExtra_0b1 += 1
+        else:
+            findTheExtra_0b1 -= 1
+        if findTheExtra_0b1 < 0:
+            break
+    return flipExtra_0b1_Here
 
 def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
     """Count meanders with matrix transfer algorithm using Python `int` (*int*eger) contained in a Python `dict` (*dict*ionary).
@@ -13,31 +49,31 @@ def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
     Notes
     -----
-    The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each index one at a time,
-    compute each `arcCode` one at a time, and compute each type of analysis one at a time.
+    The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each `boundary` one at a
+    time, compute each `arcCode` one at a time, and compute each type of analysis one at a time.
     """
     dictionaryArcCodeToCrossings: dict[int, int] = {}
     while state.boundary > 0 and areIntegersWide(state):
-        state.boundary -= 1
-        state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
+        state.reduceBoundary()
         dictionaryArcCodeToCrossings = state.dictionaryMeanders.copy()
         state.dictionaryMeanders = {}
-        for arcCode, crossings in dictionaryArcCodeToCrossings.items():
-            bitsAlpha: int = arcCode & state.locatorBits
-            bitsZulu: int = arcCode >> 1 & state.locatorBits
+
+        def analyzeArcCode(arcCode: int, crossings: int) -> None:
+            bitsAlpha: int = arcCode & state.bitsLocator
             bitsAlphaHasArcs: bool = bitsAlpha > 1
-            bitsZuluHasArcs: bool = bitsZulu > 1
             bitsAlphaIsEven: int = bitsAlpha & 1 ^ 1
+            bitsZulu: int = arcCode >> 1 & state.bitsLocator
+            bitsZuluHasArcs: bool = bitsZulu > 1
             bitsZuluIsEven: int = bitsZulu & 1 ^ 1
-            arcCodeAnalysis = (bitsAlpha | bitsZulu << 1) << 2 | 3
+            arcCodeAnalysis: int = (bitsZulu << 1 | bitsAlpha) << 2 | 3
             if arcCodeAnalysis < state.MAXIMUMarcCode:
                 state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsAlphaHasArcs:
-                arcCodeAnalysis = bitsAlpha >> 2 | bitsZulu << 3 | bitsAlphaIsEven << 1
+                arcCodeAnalysis = bitsAlphaIsEven << 1 | bitsAlpha >> 2 | bitsZulu << 3
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsZuluHasArcs:
-                arcCodeAnalysis = bitsZulu >> 1 | bitsAlpha << 2 | bitsZuluIsEven
+                arcCodeAnalysis = bitsZuluIsEven | bitsAlpha << 2 | bitsZulu >> 1
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsAlphaHasArcs and bitsZuluHasArcs and (bitsAlphaIsEven or bitsZuluIsEven):
@@ -45,8 +81,9 @@ def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
                     bitsAlpha ^= walkDyckPath(bitsAlpha)
                 elif bitsZuluIsEven and (not bitsAlphaIsEven):
                     bitsZulu ^= walkDyckPath(bitsZulu)
-                arcCodeAnalysis: int = bitsZulu >> 2 << 1 | bitsAlpha >> 2
+                arcCodeAnalysis = (bitsZulu >> 2 << 3 | bitsAlpha) >> 2
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
+        set(map(analyzeArcCode, dictionaryArcCodeToCrossings.keys(), dictionaryArcCodeToCrossings.values()))
         dictionaryArcCodeToCrossings = {}
     return state

mapFolding/syntheticModules/theorem2.py

@@ -53,4 +53,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from numba import jit
 
@@ -68,4 +70,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
-    return state
+    return state

mapFolding/syntheticModules/theorem2Trimmed.py

@@ -47,4 +47,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/tests/test_computations.py

@@ -32,14 +32,40 @@ from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
+from numba.core.errors import NumbaPendingDeprecationWarning
 from pathlib import Path, PurePosixPath
 import importlib.util
 import multiprocessing
 import pytest
+import warnings
 
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
+@pytest.mark.parametrize('flow', ['elimination', 'eliminationParallel'])#,  'constraintPropagation']) # ortools requires pandas, which doesn't have Py 3.14 yet.
+def test_A000136(flow: str) -> None:
+	"""Test A000136 flow options.
+
+	Parameters
+	----------
+	flow : str
+		The computational flow algorithm to validate.
+
+	"""
+	oeisID = 'A000136'
+	CPUlimit = .5
+	oeis_n = 2
+	for oeis_n in dictionaryOEISMapFolding[oeisID]['valuesTestValidation']:
+		if oeis_n < 2:
+			continue
+
+		expected = dictionaryOEISMapFolding[oeisID]['valuesKnown'][oeis_n]
+
+		standardizedEqualToCallableReturn(
+			expected
+			, NOTcountingFolds, oeisID, oeis_n, flow, CPUlimit
+			)
+
 @pytest.mark.parametrize('flow', ['algorithm', 'asynchronous',  'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
 def test_A007822(flow: str) -> None:
 	"""Test A007822 flow options.
@@ -52,7 +78,7 @@ def test_A007822(flow: str) -> None:
 	"""
 	oeisID = 'A007822'
 	CPUlimit = .5
-
+	warnings.filterwarnings('ignore', category=NumbaPendingDeprecationWarning)
 	oeis_n = 2
 	for oeis_n in dictionaryOEIS[oeisID]['valuesTestValidation']:
 		if oeis_n < 2:
@@ -88,7 +114,7 @@ def test_countFolds(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
 	"""
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, flow)
 
-@pytest.mark.parametrize('flow', ['matrixNumPy', 'matrixPandas'])
+@pytest.mark.parametrize('flow', ['matrixMeanders', 'matrixNumPy', 'matrixPandas'])
 def test_meanders(oeisIDmeanders: str, flow: str) -> None:
 	"""Verify Meanders OEIS sequence value calculations against known reference values.
 

{mapfolding-0.16.4.dist-info → mapfolding-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.16.4
+Version: 0.17.0
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -31,39 +31,39 @@ Classifier: Topic :: Software Development :: Compilers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Pre-processors
 Classifier: Typing :: Typed
-Requires-Python: >=3.12
+Requires-Python: <3.14,>=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: astToolkit
-Requires-Dist: autoflake
-Requires-Dist: hunterMakesPy
-Requires-Dist: isort
+Requires-Dist: astToolkit>=0.9.0
+Requires-Dist: hunterMakesPy>=0.3.0
 Requires-Dist: numpy
 Requires-Dist: platformdirs
-Requires-Dist: sympy
 Provides-Extra: development
 Requires-Dist: ipykernel; extra == "development"
 Requires-Dist: ipywidgets; 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"
 Requires-Dist: setuptools-scm; extra == "development"
 Provides-Extra: numba
 Requires-Dist: numba; extra == "numba"
 Requires-Dist: numba_progress; extra == "numba"
 Provides-Extra: pandas
+Requires-Dist: ortools; extra == "pandas"
 Requires-Dist: pandas; extra == "pandas"
 Requires-Dist: pyarrow; extra == "pandas"
 Requires-Dist: pyarrow-stubs; extra == "pandas"
+Provides-Extra: sympy
+Requires-Dist: sympy; extra == "sympy"
 Provides-Extra: testing
 Requires-Dist: numba; extra == "testing"
+Requires-Dist: ortools; extra == "testing"
 Requires-Dist: pandas; extra == "testing"
 Requires-Dist: pyarrow; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
+Requires-Dist: sympy; extra == "testing"
 Dynamic: license-file
 
 # mapFolding