mapFolding 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeDataConverters.py

@@ -1,117 +0,0 @@
-from collections.abc import Sequence
-from importlib import import_module
-from inspect import getsource as inspect_getsource
-from mapFolding.beDRY import outfitCountFolds, validateListDimensions
-from mapFolding.filesystem import getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	extractClassDef,
-	ifThis,
-	LedgerOfImports,
-	Make,
-	NodeCollector,
-	strDotStrCuzPyStoopid,
-	Then,
-	Z0Z_executeActionUnlessDescendantMatches,
-)
-from mapFolding.theSSOT import ComputationState, getSourceAlgorithm
-from pathlib import Path
-from types import ModuleType
-from typing import Any, Literal, overload
-import ast
-import pickle
-
-# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
-
-def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier
-		)-> tuple[ast.Name, LedgerOfImports, list[ast.AnnAssign], ast.Tuple, list[ast.Name], list[ast.arg], ast.Subscript, ast.Assign, list[ast.keyword]]:
-	"""
-	Parameters:
-		logicalPathModule: gimme string cuz python is stoopid
-		dataclass_Identifier: The identifier of the dataclass to be dismantled.
-		instance_Identifier: In the synthesized module/function/scope, the identifier that will be used for the instance.
-	"""
-	module: ast.Module = ast.parse(inspect_getsource(import_module(logicalPathModule)))
-
-	dataclass = extractClassDef(dataclass_Identifier, module)
-
-	if not isinstance(dataclass, ast.ClassDef):
-		raise ValueError(f"I could not find {dataclass_Identifier=} in {logicalPathModule=}.")
-
-	ledgerDataclassANDFragments = LedgerOfImports()
-	list_ast_argAnnotated4ArgumentsSpecification: list[ast.arg] = []
-	list_keyword4DataclassInitialization: list[ast.keyword] = []
-	listAnnAssign4DataclassUnpack: list[ast.AnnAssign] = []
-	listAnnotations: list[ast.expr] = []
-	listNameDataclassFragments4Parameters: list[ast.Name] = []
-
-	addToLedgerPredicate = ifThis.isAnnAssignAndAnnotationIsName
-	addToLedgerAction = Then.Z0Z_ledger(logicalPathModule, ledgerDataclassANDFragments)
-	addToLedger = NodeCollector(addToLedgerPredicate, [addToLedgerAction])
-
-	exclusionPredicate = ifThis.is_keyword_IdentifierEqualsConstantValue('init', False)
-	appendKeywordAction = Then.Z0Z_appendKeywordMirroredTo(list_keyword4DataclassInitialization)
-	filteredAppendKeywordAction = Z0Z_executeActionUnlessDescendantMatches(exclusionPredicate, appendKeywordAction) # type: ignore
-
-	collector = NodeCollector(
-			ifThis.isAnnAssignAndTargetIsName,
-				[Then.Z0Z_appendAnnAssignOf_nameDOTnameTo(instance_Identifier, listAnnAssign4DataclassUnpack)
-				, Then.append_targetTo(listNameDataclassFragments4Parameters) # type: ignore
-				, lambda node: addToLedger.visit(node)
-				, filteredAppendKeywordAction
-				, lambda node: list_ast_argAnnotated4ArgumentsSpecification.append(Make.ast_arg(node.target.id, node.annotation)) # type: ignore
-				, lambda node: listAnnotations.append(node.annotation) # type: ignore
-				]
-			)
-
-	collector.visit(dataclass)
-
-	astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns = Make.astSubscript(Make.astName('tuple'), Make.astTuple(listAnnotations))
-
-	ledgerDataclassANDFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
-
-	astName_dataclassesDOTdataclass = Make.astName(dataclass_Identifier)
-	astTuple4AssignTargetsToFragments: ast.Tuple = Make.astTuple(listNameDataclassFragments4Parameters, ast.Store())
-	astAssignDataclassRepack = Make.astAssign(listTargets=[Make.astName(instance_Identifier)], value=Make.astCall(astName_dataclassesDOTdataclass, list_astKeywords=list_keyword4DataclassInitialization))
-	return (astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
-			astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
-			astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization)
-
-@overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True], **keywordArguments: Any) -> Path: ...
-@overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False], **keywordArguments: Any) -> ComputationState: ...
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Any) -> ComputationState | Path:
-	"""
-	Creates a computation state job for map folding calculations and optionally saves it to disk.
-
-	This function initializes a computation state for map folding calculations based on the given dimensions,
-	sets up the initial counting configuration, and can optionally save the state to a pickle file.
-
-	Parameters:
-		listDimensions: List of integers representing the dimensions of the map to be folded.
-		writeJob (True): Whether to save the state to disk.
-		**keywordArguments: Additional keyword arguments to pass to the computation state initialization.
-
-	Returns:
-		stateUniversal|pathFilenameJob: The computation state for the map folding calculations, or
-			the path to the saved state file if writeJob is True.
-	"""
-	mapShape = validateListDimensions(listDimensions)
-	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
-
-	moduleSource: ModuleType = getSourceAlgorithm()
-	# TODO `countInitialize` is hardcoded
-	stateUniversal = moduleSource.countInitialize(stateUniversal)
-
-	if not writeJob:
-		return stateUniversal
-
-	pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal.mapShape, None)
-	suffix = pathFilenameChopChop.suffix
-	pathJob = Path(str(pathFilenameChopChop)[0:-len(suffix)])
-	pathJob.mkdir(parents=True, exist_ok=True)
-	pathFilenameJob = pathJob / 'stateJob.pkl'
-
-	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-	return pathFilenameJob

mapFolding/syntheticModules/numbaCountHistoricalExample.py

@@ -1,158 +0,0 @@
-from mapFolding.theSSOT import indexMy, indexTrack
-from numba import uint16, prange, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], uint16[::1], uint16[::1], uint16[:, ::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] > 0:
-        if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
-            my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
-            my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-            my[indexMy.indexDimension] = 0
-            while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
-                if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
-                    my[indexMy.dimensionsUnconstrained] -= 1
-                else:
-                    my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-                    while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-                        if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-                            my[indexMy.gap1ndexCeiling] += 1
-                        track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-                        my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-                my[indexMy.indexDimension] += 1
-            if not my[indexMy.dimensionsUnconstrained]:
-                my[indexMy.indexLeaf] = 0
-                while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
-                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
-                    my[indexMy.gap1ndexCeiling] += 1
-                    my[indexMy.indexLeaf] += 1
-            my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-            while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
-                gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-                if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
-                    my[indexMy.gap1ndex] += 1
-                track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-                my[indexMy.indexMiniGap] += 1
-        if my[indexMy.leaf1ndex] > 0:
-            my[indexMy.gap1ndex] -= 1
-            track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-            track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-            track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-            track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-            track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-            my[indexMy.leaf1ndex] += 1
-        if my[indexMy.gap1ndex] > 0:
-            return
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::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]
-    for indexSherpa in prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex] = indexSherpa
-        while my[indexMy.leaf1ndex] > 0:
-            if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
-                if my[indexMy.leaf1ndex] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
-                    my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-                    my[indexMy.indexDimension] = 0
-                    while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
-                        if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
-                            my[indexMy.dimensionsUnconstrained] -= 1
-                        else:
-                            my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-                            while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
-                                if my[indexMy.leaf1ndex] != my[indexMy.taskDivisions] or my[indexMy.leafConnectee] % my[indexMy.taskDivisions] == my[indexMy.taskIndex]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-                                    if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-                                        my[indexMy.gap1ndexCeiling] += 1
-                                    track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-                                my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-                        my[indexMy.indexDimension] += 1
-                    my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-                    while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
-                        gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-                        if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
-                            my[indexMy.gap1ndex] += 1
-                        track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-                        my[indexMy.indexMiniGap] += 1
-            while my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]:
-                my[indexMy.leaf1ndex] -= 1
-                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
-                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
-            if my[indexMy.leaf1ndex] > 0:
-                my[indexMy.gap1ndex] -= 1
-                track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-                track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-                track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-                my[indexMy.leaf1ndex] += 1
-        foldGroups[my[indexMy.taskIndex]] = groupsOfFolds
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::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 > 0:
-        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:
-                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                    if leafConnectee == leaf1ndex:
-                        dimensionsUnconstrained -= 1
-                    else:
-                        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 > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex > 0:
-            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/syntheticModules/numba_doTheNeedfulHistoricalExample.py

@@ -1,13 +0,0 @@
-from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countInitialize, countSequential, countParallel
-from numba import uint16, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::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 doTheNeedful(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], mapShape: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    countInitialize(connectionGraph, gapsWhere, my, track)
-    if my[indexMy.taskDivisions] > 0:
-        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
-    else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)

mapfolding-0.8.0.dist-info/METADATA

@@ -1,157 +0,0 @@
-Metadata-Version: 2.2
-Name: mapFolding
-Version: 0.8.0
-Summary: Count distinct ways to fold a map (or a strip of stamps)
-Author-email: Hunter Hogan <HunterHogan@pm.me>
-License: CC-BY-NC-4.0
-Project-URL: Donate, https://www.patreon.com/integrated
-Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
-Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
-Keywords: A001415,A001416,A001417,A001418,A195646,combinatorics,folding,map folding,OEIS,optimization,stamp folding
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Other Audience
-Classifier: Intended Audience :: Science/Research
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: autoflake
-Requires-Dist: more_itertools
-Requires-Dist: numba_progress
-Requires-Dist: numba
-Requires-Dist: numpy
-Requires-Dist: python_minifier
-Requires-Dist: tomli
-Requires-Dist: Z0Z_tools
-Provides-Extra: testing
-Requires-Dist: mypy; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: pytest-env; extra == "testing"
-Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pyupgrade; extra == "testing"
-
-# mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
-
-[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
-[![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4)
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
-![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen)
-[![License: CC-BY-NC-4.0](https://img.shields.io/badge/License-CC_BY--NC_4.0-3b434b)](https://creativecommons.org/licenses/by-nc/4.0/)
-![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding)
-![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
-
----
-
-## Quick start
-
-```sh
-pip install mapFolding
-```
-
-`OEIS_for_n` will run a computation from the command line.
-
-```cmd
-(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
-186086600 distinct folding patterns.
-Time elapsed: 1.605 seconds
-```
-
-Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
-
-```python
-from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n( 'A001418', 4 )
-```
-
----
-
-## Features
-
-### 1. Simple, easy usage based on OEIS IDs
-
-`mapFolding` directly implements some IDs from [_The On-Line Encyclopedia of Integer Sequences_](https://oeis.org/) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/oeis.bibtex) citation).
-
-Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
-
-```cmd
-(mapFolding) C:\apps\mapFolding> getOEISids
-
-Available OEIS sequences:
-  A001415: Number of ways of folding a 2 X n strip of stamps.
-  A001416: Number of ways of folding a 3 X n strip of stamps.
-  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
-  A001418: Number of ways of folding an n X n sheet of stamps.
-  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
-```
-
-### 2. **Algorithm Zoo** 🦒
-
-- **Lunnon’s 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
-- The /reference directory.
-- **Numba-JIT Accelerated**: Up to 1000× faster than pure Python ([benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
-
-### 3. **For Researchers** 🔬
-
-- Change multiple minute settings, such as the bit width of the data types.
-- Transform the algorithm using AST
-- Create hyper-optimized modules to compute a specific map.
-
-### 4. **Customizing your algorithm**
-
-- Renovations in progress: ~~mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)~~
-  - Synthesize a Numba-optimized module for a specific mapShape
-  - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
-  - Use the existing transformation options
-  - Or create new ways of transforming the algorithm from its source to a specific job
-- Renovations in progress: ~~mapFolding\someAssemblyRequired\makeJob.py~~
-  - Initialize data for a specific mapShape
-- Renovations in progress: ~~mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)~~
-  - Synthesize one or more Numba-optimized modules for parallel or sequential computation
-  - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
-  - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
-  - Use the existing transformation options
-  - Or create new ways of transforming the algorithm from its source to a new module
-  - Use your new module in synthesizeNumbaJob.py, above, as the source to create a mapShape-specific job module
-- mapFolding\theDao.py
-  - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
-  - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
-  - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
-- mapFolding\theSSOT.py
-  - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
-  - Create new settings or groups of settings
-- mapFolding\beDRY.py
-  - Functions to handle common tasks, such as parsing parameters or creating the `connectionGraph` for a mapShape (a Cartesian product decomposition)
-- mapFolding\someAssemblyRequired
-  - Create new transformations to optimize the algorithm, such as for JAX, CuPy, or CUDA
-  - (mapFolding\reference\jax.py has a once-functional JAX implementation, and synthesizeModuleJAX.py might be a useful starting point)
-
-## Map-folding Video
-
-~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
-
-"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/Physics_for_the_Birds.bibtex) citation)
-
-[![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
-
----
-
-## My recovery
-
-[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
-[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
-
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.8.0.dist-info/RECORD

@@ -1,41 +0,0 @@
-mapFolding/__init__.py,sha256=hONqdWnBN1ebgrKZuMIZfI8m-1krSR66L4GTVRwBmw4,203
-mapFolding/basecamp.py,sha256=Ik_oH-MpH8f6k-yBzwm99lfkv3pMDgFFEnSSDyiJjsQ,3861
-mapFolding/beDRY.py,sha256=nn0AEGzrroM3wp91Fts7mmx1VQgG14s0EZsXR-Uy5x8,9049
-mapFolding/filesystem.py,sha256=KqgsO-jaSWAlYib_9ovoXQY76PcQri09_73u0OqMWC8,4094
-mapFolding/noHomeYet.py,sha256=DAppmTJG95Ip1qF1uVLU_vXGz4Lmonp8OYfGXtmOnTE,785
-mapFolding/oeis.py,sha256=ZNt3UBklmpfjdmgbA7pO-ezz2prafr2JvdkpIDapi1w,11853
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=E-hisOy_1_iQqS6w4c7S-C-sIgIcwnAPFqooeWuinVY,9008
-mapFolding/theSSOT.py,sha256=r7_9t0dOo_IfBMqmkm1WXOzMfZjyPNco0hl1g9uU_2Y,12710
-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/Z0Z_workbench.py,sha256=g4VkNKp2ts0koqcMSPNbE_ySR2-23Y-5CJBDpvbT6XU,16853
-mapFolding/someAssemblyRequired/__init__.py,sha256=G1uIo1RWcdBjeFPXFwa69kizsZFzkDR55B2uyyY5z7E,680
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=2kGRji3FGaALZwUZ6qlEjS7QxOkJK1Si-mAnsWePs_Q,983
-mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=u5621TzZW7Sp8BXedq0yooyYoFwDDsd9smoqObzRf8g,7359
-mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=J1qLKxqCMQd5JhcrTg9fvpPCfhb5TLz2wXY-J9z-TH8,5792
-mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py,sha256=3yRCEMIf9UCswu6wQvdUK9H3MW6Ossn-wg5eOq8LWz8,22362
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=u2ah47kOqvVGKifuk7rZe4bSm3Z681nJzp73IXavYw4,36297
-mapFolding/syntheticModules/numbaCountHistoricalExample.py,sha256=Oo0Xeex89sLD15iRt3N76OKRFScKl9qwO84-d5sv6lM,11871
-mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=52RuwJVH2fROvWU2dT8wYcQvLgRuvkNZPq01kujCC_U,15725
-mapFolding/syntheticModules/numba_doTheNeedfulHistoricalExample.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=rRlXOhihwheHyQ8ggjRBbmgPVERxWjupajguVBzBkVE,10783
-tests/test_computations.py,sha256=YhadlskBh_r5RiefHRy0FlrYQ0FelYbqcSNNSkSJMIY,3368
-tests/test_filesystem.py,sha256=Kou0gj5T72oISao6umYfU6L_W5Hi7QS9_IxTv2hU0Pw,3147
-tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
-tests/test_other.py,sha256=1uuApByNWPiTf0zaro2dETkvyWQFfMweU_ge4aJuVgM,4244
-tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
-mapfolding-0.8.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapfolding-0.8.0.dist-info/METADATA,sha256=AA0b9jY45EztgHbZQq8SbpBExcDpnmhotXZB4DDO_2A,7670
-mapfolding-0.8.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-mapfolding-0.8.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.8.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.8.0.dist-info/RECORD,,