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

tests/test_computations.py

@@ -13,67 +13,31 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 	for n in settingsOEIS[oeisID]['valuesTestValidation']:
 		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
-# Python doesn't want me to test this
-# @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-# def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
-# 	from mapFolding.syntheticModules import numba_countSequential
-# 	algorithmSourceHARDCODED: ModuleType = numba_countSequential
-# 	algorithmSource = algorithmSourceHARDCODED
-# 	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
-
-# 	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
-# 	if Don_Lapre_Road_to_Self_Improvement is None:
-# 		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
-# 	if Don_Lapre_Road_to_Self_Improvement.loader is None:
-# 		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
-# 	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
-
-# 	module.__name__ = "__main__"
-# 	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
-
-# 	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
-# 	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
-
-# def test_makeFlowNumbaOptimized(pathTmpTesting: Path, useThisDispatcher):
-# def test_makeFlowNumbaOptimized(useThisDispatcher):
-# 	"""To get this to work:
-# 	walk_up=True doesn't work on 3.10, so that has to go
-# 	the _logical_ import must be in the logical path of the package
-# 	fuck python
-# 	"""
-# 	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
-# 	listCallablesInline = listCallablesInlineHARDCODED
-# 	callableDispatcher = True
-# 	algorithmSource = None
-# 	relativePathWrite = None
-# 	# relativePathWrite = pathTmpTesting.absolute().relative_to(getPathPackage(), walk_up=True)
-# 	formatFilenameWrite = "pytest_{callableTarget}"
-# 	listSynthesizedModules: List[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, formatFilenameWrite)
-# 	for stuff in listSynthesizedModules:
-# 		registrarRecordsTmpObject(stuff.pathFilenameForMe)
-# 		if stuff.callableSynthesized not in listCallablesInline:
-# 			dispatcherSynthetic: youOughtaKnow = stuff
-# 	if not dispatcherSynthetic: raise FREAKOUT
-# 		# dispatcherSynthetic: youOughtaKnow = next(filter(lambda x: x.callableSynthesized not in listCallablesInline, listSynthesizedModules))
-
-# 	# Import the synthetic dispatcher module to get the callable
-# 	dispatcherSpec = importlib.util.spec_from_file_location(
-# 		dispatcherSynthetic.callableSynthesized,
-# 		dispatcherSynthetic.pathFilenameForMe
-# 	)
-# 	if dispatcherSpec is None:
-# 		raise ImportError(f"Failed to create module specification from {dispatcherSynthetic.pathFilenameForMe}")
-# 	if dispatcherSpec.loader is None:
-# 		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
-
-# 	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
-# 	dispatcherSpec.loader.exec_module(dispatcherModule)
-# 	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
-
-# 	useThisDispatcher(callableDispatcherSynthetic)
-
-# 	def test_syntheticSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
-# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+@pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
+def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
+	from mapFolding.syntheticModules import numbaCount
+	algorithmSourceHARDCODED: ModuleType = numbaCount
+	algorithmSource = algorithmSourceHARDCODED
+	callableTargetHARDCODED = 'countSequential'
+	callableTarget = callableTargetHARDCODED
+	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, callableTarget, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
+
+	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+	if Don_Lapre_Road_to_Self_Improvement is None:
+		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
+	if Don_Lapre_Road_to_Self_Improvement.loader is None:
+		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
+	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+
+	module.__name__ = "__main__"
+	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
+
+	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
+	registrarRecordsTmpObject(pathFilenameFoldsTotal)
+	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
+
+def test_syntheticParallel(syntheticDispatcherFixture, listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
-# 	def test_syntheticParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
-# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+def test_syntheticSequential(syntheticDispatcherFixture, listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)

tests/test_oeis.py

@@ -1,10 +1,7 @@
 from contextlib import redirect_stdout
-from datetime import datetime, timedelta
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _parseBFileOEIS, _validateOEISid, _getOEISidInformation
 from tests.conftest import *
 from urllib.error import URLError
 import io
-import os
 import pathlib
 import pytest
 import random
@@ -16,18 +13,18 @@ import urllib.request
 
 @pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
 def test__validateOEISid_invalid_id(badID: str) -> None:
-	standardizedEqualTo(KeyError, _validateOEISid, badID)
+	standardizedEqualTo(KeyError, validateOEISid, badID)
 
 def test__validateOEISid_partially_valid(oeisID_1random: str) -> None:
-	standardizedEqualTo(KeyError, _validateOEISid, f"{oeisID_1random}extra")
+	standardizedEqualTo(KeyError, validateOEISid, f"{oeisID_1random}extra")
 
 def test__validateOEISid_valid_id(oeisID: str) -> None:
-	standardizedEqualTo(oeisID, _validateOEISid, oeisID)
+	standardizedEqualTo(oeisID, validateOEISid, oeisID)
 
 def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
-	standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.lower())
-	standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.upper())
-	standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.swapcase())
+	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.lower())
+	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.upper())
+	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.swapcase())
 
 parameters_test_aOFn_invalid_n = [
 	# (2, "ok"), # test the test template
@@ -68,7 +65,7 @@ def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.
 		raise URLError("Network error")
 
 	monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-	standardizedEqualTo(URLError, _getOEISidValues, next(iter(settingsOEIS)))
+	standardizedEqualTo(URLError, getOEISidValues, next(iter(settingsOEIS)))
 
 # ===== Command Line Interface Tests =====
 def testHelpText() -> None:

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,52 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import jit
-from numba import uint8
-from numpy import ndarray
-from numpy import integer
-from numpy import dtype
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    while my[indexMy.leaf1ndex.value]:
-        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-            my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-            my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-            my[indexMy.indexDimension.value] = 0
-            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                    my[indexMy.dimensionsUnconstrained.value] -= 1
-                else:
-                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                            my[indexMy.gap1ndexCeiling.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                my[indexMy.indexDimension.value] += 1
-            if not my[indexMy.dimensionsUnconstrained.value]:
-                my[indexMy.indexLeaf.value] = 0
-                while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
-                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
-                    my[indexMy.gap1ndexCeiling.value] += 1
-                    my[indexMy.indexLeaf.value] += 1
-            my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                    my[indexMy.gap1ndex.value] += 1
-                track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                my[indexMy.indexMiniGap.value] += 1
-        if my[indexMy.leaf1ndex.value]:
-            my[indexMy.gap1ndex.value] -= 1
-            track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-            track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-            track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-            track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-            track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-            my[indexMy.leaf1ndex.value] += 1
-        if my[indexMy.gap1ndex.value] > 0:
-            return

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,65 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import jit
-from numba import uint8
-from numba import int64
-from numba import prange
-from numpy import ndarray
-from numpy import integer
-from numpy import dtype
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    gapsWherePARALLEL = gapsWhere.copy()
-    myPARALLEL = my.copy()
-    trackPARALLEL = track.copy()
-    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
-        while my[indexMy.leaf1ndex.value]:
-            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-                if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-                    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-                    my[indexMy.indexDimension.value] = 0
-                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                            my[indexMy.dimensionsUnconstrained.value] -= 1
-                        else:
-                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                                        my[indexMy.gap1ndexCeiling.value] += 1
-                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                        my[indexMy.indexDimension.value] += 1
-                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                            my[indexMy.gap1ndex.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                        my[indexMy.indexMiniGap.value] += 1
-            while my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
-                my[indexMy.leaf1ndex.value] -= 1
-                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
-                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
-            if my[indexMy.leaf1ndex.value]:
-                my[indexMy.gap1ndex.value] -= 1
-                track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-                track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-                track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-                my[indexMy.leaf1ndex.value] += 1
-        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,67 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import jit
-from numba import uint8
-from numba import int64
-from numpy import ndarray
-from numpy import integer
-from numpy import dtype
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    leafBelow = track[indexTrack.leafBelow.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
-    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
-    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
-    indexDimension = my[indexMy.indexDimension.value]
-    leafConnectee = my[indexMy.leafConnectee.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
-    taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
-    while leaf1ndex:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > foldGroups[-1]:
-                groupsOfFolds += 1
-            else:
-                dimensionsUnconstrained = dimensionsTotal
-                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-                indexDimension = 0
-                while indexDimension < dimensionsTotal:
-                    if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
-                        dimensionsUnconstrained -= 1
-                    else:
-                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                        while leafConnectee != leaf1ndex:
-                            gapsWhere[gap1ndexCeiling] = leafConnectee
-                            if countDimensionsGapped[leafConnectee] == 0:
-                                gap1ndexCeiling += 1
-                            countDimensionsGapped[leafConnectee] += 1
-                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                    indexDimension += 1
-                indexMiniGap = gap1ndex
-                while indexMiniGap < gap1ndexCeiling:
-                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                        gap1ndex += 1
-                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                    indexMiniGap += 1
-        while leaf1ndex and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    foldGroups[taskIndex] = groupsOfFolds

mapFolding/theSSOTnumba.py

@@ -1,132 +0,0 @@
-"""I have so much truth, I need two files to contain it all!"""
-"""TODO learn how to use this efficiently and effectively to solve problems, be DRY, and have SSOT."""
-from typing import Final, TYPE_CHECKING, Dict, Any, Union, Callable, Tuple, Any
-import numba
-import numba.core.compiler
-try:
-	from typing import NotRequired
-except ImportError:
-	from typing_extensions import NotRequired
-
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict
-
-"""
-Old notes that are not entirely accurate.
-
-| **Option**			  | **Description**									 | **Why**			   | **Size**		| **But**				  |
-| ----------------------- | --------------------------------------------------- | --------------------- | --------------- | ------------------------ |
-| `_dbg_extend_lifetimes` | Debug option to extend object lifetimes			 | Debugging			 |				 |						  |
-| `_dbg_optnone`		  | Disable optimization for debugging				  | Debugging			 |				 |						  |
-| `debug`				 | Enable debug mode with additional checks			| Debugging			 |				 |						  |
-| `no_rewrites`		   | Disable AST rewrites optimization				   | Debugging			 |				 |						  |
-| `boundscheck`		   | Enable array bounds checking (slows execution)	  | Error checking		| Larger		  | Slower				   |
-| `error_model`		   | Divide by zero: kill or chill?					  | Error checking		| ?			   |						  |
-| `_nrt`				  | Enable No Runtime type checking					 | Startup speed		 | Smaller		 | No type protection	   |
-| `fastmath`			  | Reduce float potential precision					| Float speed		   | Smaller		 | Discriminatory, untested |
-| `forceinline`		   | Force function inlining							 | Reduce function calls | Likely larger   |						  |
-| `forceobj`			  | Force object mode compilation					   | Inclusiveness		 | Larger		  | Slower execution		 |
-| `inline`				| Algorithmically choose inlining					 | Speed				 | Slightly larger |						  |
-| `looplift`			  | Enable loop lifting optimization					| Speed (if applicable) | Larger		  | Exclusionary			 |
-| `no_cfunc_wrapper`	  | Disable C function wrapper generation			   | Size				  | Smaller		 | Exclusionary			 |
-| `no_cpython_wrapper`	| Disable Python C-API wrapper generation			 | Size				  | Smallest		| Exclusionary			 |
-
-"""
-# NOTE Deepseek removed forceinline=True, inline='always'
-# TODO try to implement all possible parameters, but use `NotRequired` for the more esoteric ones
-class ParametersNumba(TypedDict):
-	_dbg_extend_lifetimes: NotRequired[bool]
-	_dbg_optnone: NotRequired[bool]
-	_nrt: NotRequired[bool]
-	boundscheck: NotRequired[bool]
-	cache: bool
-	debug: NotRequired[bool]
-	error_model: str
-	fastmath: bool
-	forceinline: bool
-	forceobj: NotRequired[bool]
-	inline: str
-	locals: NotRequired[Dict[str, Any]]
-	looplift: bool
-	no_cfunc_wrapper: bool
-	no_cpython_wrapper: bool
-	no_rewrites: NotRequired[bool]
-	nogil: NotRequired[bool]
-	nopython: bool
-	parallel: bool
-	pipeline_class: NotRequired[numba.core.compiler.CompilerBase]
-	signature_or_function: NotRequired[Union[Any, Callable, str, Tuple]]
-	target: NotRequired[str]
-
-parametersNumbaFailEarly: Final[ParametersNumba] = {
-	'_nrt': True,
-	'boundscheck': True,
-	'cache': True,
-	'error_model': 'python',
-	'fastmath': False,
-	'forceinline': True,
-	'inline': 'always',
-	'looplift': False,
-	'no_cfunc_wrapper': False,
-	'no_cpython_wrapper': False,
-	'nopython': True,
-	'parallel': False,
-}
-"""For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
-
-parametersNumbaDEFAULT: Final[ParametersNumba] = {
-	'_nrt': True,
-	'boundscheck': False,
-	'cache': True,
-	'error_model': 'numpy',
-	'fastmath': True,
-	'forceinline': True,
-	'inline': 'always',
-	'looplift': False,
-	'no_cfunc_wrapper': False,
-	'no_cpython_wrapper': False,
-	'nopython': True,
-	'parallel': False,
-}
-"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
-
-parametersNumbaParallelDEFAULT: Final[ParametersNumba] = {
-	**parametersNumbaDEFAULT,
-	'_nrt': True,
-	'parallel': True,
-}
-"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
-
-parametersNumbaSuperJit: Final[ParametersNumba] = {
-	**parametersNumbaDEFAULT,
-	'no_cfunc_wrapper': True,
-	'no_cpython_wrapper': True,
-}
-"""Speed, no helmet, no talking to non-jitted functions."""
-
-parametersNumbaSuperJitParallel: Final[ParametersNumba] = {
-	**parametersNumbaSuperJit,
-	'_nrt': True,
-	'parallel': True,
-}
-"""Speed, no helmet, concurrency, no talking to non-jitted functions.
-Claude says, "The NRT is Numba's memory management system that handles memory allocation and deallocation for array operations. Because of array copying, you need to have NRT enabled." IDK which AI assistant autocompleted this, but, "The NRT is a bit slower than the default memory management system, but it's necessary for certain operations."
-"""
-
-parametersNumbaMinimum: Final[ParametersNumba] = {
-	'_nrt': True,
-	'boundscheck': True,
-	'cache': True,
-	'error_model': 'numpy',
-	'fastmath': True,
-	'forceinline': False,
-	'inline': 'always',
-	'looplift': False,
-	'no_cfunc_wrapper': False,
-	'no_cpython_wrapper': False,
-	'nopython': False,
-	'forceobj': True,
-	'parallel': False,
-}

mapFolding-0.4.1.dist-info/RECORD

@@ -1,42 +0,0 @@
-mapFolding/__init__.py,sha256=_YjoypHXmWLmEWwhFVgKO83Uf28ksesT9F73oJoAIPE,1323
-mapFolding/basecamp.py,sha256=v0VCF_Zgm_XBHcz4bqblsxfHwAxZKgenW6um77quWLk,3751
-mapFolding/beDRY.py,sha256=XVtLraG9VnC4yG2HkaFwZRh2td4ZHMjTQvnbcD_W130,17133
-mapFolding/oeis.py,sha256=3hv71o8bhckjY0nsSY5JTJ2LrpJcuhZ9j3mP6LWLIQc,11124
-mapFolding/theDao.py,sha256=SmyTbP1iwRAnpuq2ngdJKooXUA1_PR0VRHQ4fcJskMY,12713
-mapFolding/theSSOT.py,sha256=QrEMPREjEbt1H8HcrM2Nm_hv7JsFWRG3lHdUU0Jrv-w,10238
-mapFolding/theSSOTnumba.py,sha256=zGq2zlZZeuxiNSO2Fs_AqV6UhybJAJuDw-2lMVvDS2w,5133
-mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
-mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
-mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
-mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
-mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
-mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
-mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
-mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
-mapFolding/someAssemblyRequired/__init__.py,sha256=wtec_hIz-AKz0_hGdXsWnCKTcCxdMV9-WK6SiIriAeU,396
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=nX8tghZClYt7zJd6RpZBXhE_h-CGRHOS17biqiEdf-o,855
-mapFolding/someAssemblyRequired/makeJob.py,sha256=c9sTRUK90snTCcXCvs86VKBH6z_nt3OVFjNs_WgCoIg,2422
-mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=jatvtYhK5ZJK-YmCKATt7w3icFXXO79cZDAYVrU9bgA,1258
-mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=mPCjp4N-dOJRC4TvZGkqAqFKDWEPhWH9v0Cq5AWHlBA,17279
-mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=k8IaCT74ZPhHyra0MbCRdt_5k0Ov3vJgXlN5tbLVnf4,13998
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=2sKZgc5kyyz2KaoApcazj_37UgBqAkxORFeROWWU5tk,9038
-mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=_iRXjMASB_BnYJeH8Rt7FlC-GE7lkZ1Hy292XTaUCu4,3785
-mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/syntheticModules/numba_countInitialize.py,sha256=geHketfekZTgu5gbc8E3SShPmbW3gDybg5PCBpXdsa8,4274
-mapFolding/syntheticModules/numba_countParallel.py,sha256=kOI5PU90AExPvlWwU0BHVVFjlHlmUFp1KdtlmthQ71E,5517
-mapFolding/syntheticModules/numba_countSequential.py,sha256=zFFRv9oLtOih9TpbtARpVAPt-NfZxh0ygXuj-wfPjUg,3732
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=6WuXKDMVa_C56dLlmXNvFl04MlU8-WVasqbAaxsgI-o,1368
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=7Ims3QcOzqBXu_k0kX9bt6PieC-OoIpc7OGxzdT2ELc,11826
-tests/test_computations.py,sha256=qBha4IggMfr6ZH06W3M66enTA6PWsx8vkDp5eqYFM9M,4765
-tests/test_oeis.py,sha256=31kdO1vnu2Lon43vM-YJVS4g40Ic03DWNER-cJcpxX4,4916
-tests/test_other.py,sha256=u0vINT5EyVsXTNTR2DZIMpWCg4FH471jjHLRzC2JX7U,8351
-tests/test_tasks.py,sha256=iq6_dh43JQkC2vAWXua0Xe915BKFGbvRJAkmbco854A,2389
-tests/test_types.py,sha256=58tmPG9WOeGGAQbdQK_h_7t4SnENnZugH4WXlI8-L-M,171
-mapFolding-0.4.1.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.4.1.dist-info/METADATA,sha256=iJiWfEzXVheLtyLLWT2BNis5xsisnhllS17hnPwiRws,7633
-mapFolding-0.4.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.4.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.4.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.4.1.dist-info/RECORD,,