esets-lib 0.3.0__tar.gz → 0.3.2__tar.gz

{esets_lib-0.3.0 → esets_lib-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esets-lib
-Version: 0.3.0
+Version: 0.3.2
 Summary: Lazy, index-addressable enumerated sets, including a full combinatorics family (permutations, combinations, arrangements, subsets, partitions, derangements, and Cartesian products)
 Project-URL: Homepage, https://github.com/ffavela/esets
 Project-URL: Repository, https://github.com/ffavela/esets
@@ -73,6 +73,10 @@ the substance directly:
   benchmarking turned up.
 * [FLOAT64S.md](https://github.com/ffavela/esets/blob/main/FLOAT64S.md)
   -- an eset that enumerates all 64-bit floats.
+* [TEXTENCODE.md](https://github.com/ffavela/esets/blob/main/TEXTENCODE.md)
+  -- character and word alphabets built from a small text file, encoded
+  with `Arranger` and with `Combinator`+`Permutator` by hand, as a
+  first step toward larger-text, whole-language "compression."
 
 ## What is it? (An informal introduction)
 

{esets_lib-0.3.0 → esets_lib-0.3.2}/README.md

@@ -49,6 +49,10 @@ the substance directly:
   benchmarking turned up.
 * [FLOAT64S.md](https://github.com/ffavela/esets/blob/main/FLOAT64S.md)
   -- an eset that enumerates all 64-bit floats.
+* [TEXTENCODE.md](https://github.com/ffavela/esets/blob/main/TEXTENCODE.md)
+  -- character and word alphabets built from a small text file, encoded
+  with `Arranger` and with `Combinator`+`Permutator` by hand, as a
+  first step toward larger-text, whole-language "compression."
 
 ## What is it? (An informal introduction)
 

{esets_lib-0.3.0 → esets_lib-0.3.2}/esets/cesets.py

@@ -808,6 +808,29 @@ class Natural_Multiset_Arranger(Eset):
     arrangement #0 agree with Natural_Arranger's ordering when every
     capacity is 1, and with Natural_Multiset_Permutator's ordering
     when r equals the full multiset size.
+
+    That position-by-position shape is also why ranking's recursion
+    depth is O(classes * r) in the worst case, not O(classes) --
+    each of the r positions can try up to `classes` candidates before
+    landing on the right one. A prototype class-by-class ranking
+    (decide how many of the smallest remaining class, and which of
+    the still-open positions they occupy, via plain get_combination/
+    get_combination_number over positions, then recurse into the next
+    class for the remaining positions) was benchmarked and verified
+    as a correct bijection: it cuts depth to O(classes) and wins big
+    on many-classes/tight-capacity shapes (~470x faster before the
+    memo fix below existed, still much shallower after), but costs
+    more wall-clock time than the position-by-position approach on
+    few-classes/large-r shapes (get_combination_number's own O(r)
+    candidate search per class-step isn't free), and it ranks
+    arrangements in a different order than this class does today, so
+    switching isn't behavior-preserving the way the memo fix is.
+    Shipping it for real would mean dispatching between the two by
+    shape -- the same treatment multiset_combination_count already
+    gives inclusion-exclusion -- plus its own benchmark file, not a
+    blanket replacement. Not attempted here; left as a known, deferred
+    option for whoever next needs ranking to survive a much larger
+    number of classes than it currently does.
     """
 
     def __init__(self, *args, **kwargs):

{esets_lib-0.3.0 → esets_lib-0.3.2}/esets/ecombinatorics.py

@@ -188,8 +188,19 @@ def _inclusion_exclusion_combination_count(
     return total_answer
 
 
-def multiset_combination_count(multiplicities: tuple[int, ...], k: int) -> int:
-    memo: dict[tuple[tuple[int, ...], int], int] = {}
+def multiset_combination_count(
+    multiplicities: tuple[int, ...],
+    k: int,
+    _memo: dict[tuple[tuple[int, ...], int], int] | None = None,
+) -> int:
+    # get_multiset_combination/get_multiset_combination_number call this
+    # once per candidate tried at every class, and get_multiset_subset/
+    # get_multiset_subset_number call it once per size -- both pass their
+    # own long-lived _memo through every call instead of letting each one
+    # start over from empty, since overlapping subproblems (same
+    # sorted-suffix, same remaining_k) come up constantly across those
+    # calls.
+    memo: dict[tuple[tuple[int, ...], int], int] = {} if _memo is None else _memo
 
     def count(rem: tuple[int, ...], remaining_k: int) -> int:
         key = (rem, remaining_k)
@@ -254,7 +265,8 @@ def multiset_combination_count(multiplicities: tuple[int, ...], k: int) -> int:
 def get_multiset_combination(
     val: int, multiplicities: tuple[int, ...], k: int
 ) -> tuple[int] | None:
-    total = multiset_combination_count(multiplicities, k)
+    memo: dict[tuple[tuple[int, ...], int], int] = {}
+    total = multiset_combination_count(multiplicities, k, memo)
     if val >= total or val < 0:
         return None
 
@@ -284,7 +296,7 @@ def get_multiset_combination(
         retlist: list[int],
         t: int,
     ) -> list[int]:
-        block = multiset_combination_count(classes[1:], remaining_k - t)
+        block = multiset_combination_count(classes[1:], remaining_k - t, memo)
         if resval < block:
             return place(
                 resval,
@@ -310,6 +322,8 @@ def get_multiset_combination_number(
     ):
         return None
 
+    memo: dict[tuple[tuple[int, ...], int], int] = {}
+
     def rank(
         classes: tuple[int, ...], remaining_k: int, class_id: int, seq: list[int]
     ) -> int:
@@ -330,7 +344,7 @@ def get_multiset_combination_number(
         t: int,
         actual: int,
     ) -> int:
-        block = multiset_combination_count(classes[1:], remaining_k - t)
+        block = multiset_combination_count(classes[1:], remaining_k - t, memo)
         if t == actual:
             return rank(classes[1:], remaining_k - t, class_id + 1, seq[t:])
         return block + locate(classes, remaining_k, class_id, seq, t - 1, actual)
@@ -438,8 +452,18 @@ def get_arrangement_number(arrangement: tuple[int], n: int) -> int | None:
     return get_number(list(arrangement), r)
 
 
-def multiset_arrangement_count(multiplicities: tuple[int, ...], r: int) -> int:
-    memo: dict[tuple[tuple[int, ...], int], int] = {}
+def multiset_arrangement_count(
+    multiplicities: tuple[int, ...],
+    r: int,
+    _memo: dict[tuple[tuple[int, ...], int], int] | None = None,
+) -> int:
+    # get_multiset_arrangement/get_multiset_arrangement_number call this
+    # once per candidate tried at every position, so they pass their own
+    # long-lived _memo through every call instead of letting each call
+    # start over from an empty one -- the two share overlapping
+    # subproblems (same sorted-suffix, same remaining_r) constantly, and
+    # without a shared memo those get recomputed from scratch every time.
+    memo: dict[tuple[tuple[int, ...], int], int] = {} if _memo is None else _memo
 
     def g(rem: tuple[int, ...], remaining_r: int) -> int:
         key = (rem, remaining_r)
@@ -482,7 +506,8 @@ def multiset_arrangement_count(multiplicities: tuple[int, ...], r: int) -> int:
 def get_multiset_arrangement(
     val: int, multiplicities: tuple[int, ...], r: int
 ) -> tuple[int] | None:
-    total = multiset_arrangement_count(multiplicities, r)
+    memo: dict[tuple[tuple[int, ...], int], int] = {}
+    total = multiset_arrangement_count(multiplicities, r, memo)
     if val >= total or val < 0:
         return None
 
@@ -508,7 +533,7 @@ def get_multiset_arrangement(
         new_mult = list(remaining_mult)
         new_mult[label] -= 1
         rest_mult = tuple(new_mult)
-        block = multiset_arrangement_count(rest_mult, remaining_r - 1)
+        block = multiset_arrangement_count(rest_mult, remaining_r - 1, memo)
         if resval < block:
             return place(resval, rest_mult, remaining_r - 1, retlist + [label])
         return try_candidate(
@@ -529,6 +554,8 @@ def get_multiset_arrangement_number(
     ):
         return None
 
+    memo: dict[tuple[tuple[int, ...], int], int] = {}
+
     def rank(remaining_mult: tuple[int, ...], remaining_r: int, seq: list[int]) -> int:
         if not seq:
             return 0
@@ -545,7 +572,7 @@ def get_multiset_arrangement_number(
         new_mult = list(remaining_mult)
         new_mult[label] -= 1
         rest_mult = tuple(new_mult)
-        block = multiset_arrangement_count(rest_mult, remaining_r - 1)
+        block = multiset_arrangement_count(rest_mult, remaining_r - 1, memo)
         if label == seq[0]:
             return rank(rest_mult, remaining_r - 1, seq[1:])
         return block + locate(remaining_mult, remaining_r, seq, candidates[1:])
@@ -592,8 +619,10 @@ def get_multiset_subset(val: int, multiplicities: tuple[int, ...]) -> tuple[int]
     if val >= total or val < 0:
         return None
 
+    memo: dict[tuple[tuple[int, ...], int], int] = {}
+
     def try_size(resval: int, k: int) -> tuple[int]:
-        block = multiset_combination_count(multiplicities, k)
+        block = multiset_combination_count(multiplicities, k, memo)
         if resval < block:
             return get_multiset_combination(resval, multiplicities, k)
         return try_size(resval - block, k + 1)
@@ -608,10 +637,14 @@ def get_multiset_subset_number(
     if combo_rank is None:
         return None
 
+    memo: dict[tuple[tuple[int, ...], int], int] = {}
+
     def offset(size: int) -> int:
         if size == 0:
             return 0
-        return multiset_combination_count(multiplicities, size - 1) + offset(size - 1)
+        return multiset_combination_count(multiplicities, size - 1, memo) + offset(
+            size - 1
+        )
 
     return offset(len(subset)) + combo_rank
 

{esets_lib-0.3.0 → esets_lib-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "esets-lib"
-version = "0.3.0"
+version = "0.3.2"
 description = "Lazy, index-addressable enumerated sets, including a full combinatorics family (permutations, combinations, arrangements, subsets, partitions, derangements, and Cartesian products)"
 readme = "README.md"
 license = "BSD-3-Clause"