cooptools 1.75__tar.gz → 1.76__tar.gz

{cooptools-1.75 → cooptools-1.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cooptools
-Version: 1.75
+Version: 1.76
 Summary: Generic Tooling
 Home-page: https://github.com/tylertjburns/cooptools
 Author: tburns

{cooptools-1.75 → cooptools-1.76}/cooptools/common.py

@@ -1,6 +1,6 @@
 import math
 import uuid
-from typing import List, Union, Tuple, Iterable, Callable, Sequence, TypeVar, Dict
+from typing import List, Union, Tuple, Iterable, Callable, Sequence, TypeVar, Dict, Optional
 import itertools
 import numpy as np
 import bisect
@@ -145,12 +145,12 @@ def verify_unique(lst: Iterable, error_msg: str = None):
 def verify_len_match(iterable1,
                      iterable2,
                      error_msg: str = None,
-                     block:bool = True):
+                     block:bool = True) -> Optional[int]:
     # Length is compared before the message is built. This sits under
     # rect_contains_point on the sector-tree insert path, where formatting a
     # message for a check that passes costs more than the check itself.
-    if len(iterable1) == len(iterable2):
-        return
+    if (l1:=len(iterable1)) == len(iterable2):
+        return l1
 
     msg = f"{iterable1} and {iterable2} do not have the same length ({len(iterable1)} vs {len(iterable2)})"
     verify(lambda: False, msg, error_msg, block=block)

{cooptools-1.75 → cooptools-1.76}/cooptools/geometry_utils/vector_utils.py

@@ -108,12 +108,30 @@ def vector_between(start: FloatVec,
                    allow_diff_lengths: bool = False
                    ) -> FloatVec:
     if not allow_diff_lengths:
-        verify_len_match(start, end)
+        l_start = verify_len_match(start, end)
+        l_end = l_start
+    else:
+        l_start, l_end = len(start), len(end)
+
+    # 2- and 3-D vectors are most of the traffic here, and for them the loop
+    # below costs far more than the subtractions it performs: a range, two
+    # bounds-checked conditionals per axis, a list append per axis, and a
+    # tuple() at the end. Naming the axes skips all of it.
+    #
+    # Equal lengths are part of the condition because that is the only case in
+    # which the loop's padding cannot apply; an unequal pair falls through and
+    # is padded or truncated exactly as before.
+    if l_start == l_end == 2:
+        return (end[0] - start[0], end[1] - start[1])
+
+    if l_start == l_end == 3:
+        return (end[0] - start[0], end[1] - start[1], end[2] - start[2])
 
     ret = []
-    for idx in range(len(start)):
-        e = end[idx] if idx < len(end) else 0
-        s = start[idx] if idx < len(start) else 0
+
+    for idx in range(l_start):
+        e = end[idx] if idx < l_end else 0
+        s = start[idx] if idx < l_start else 0
 
         ret.append((e - s))
 
@@ -175,7 +193,23 @@ def scale_vector_length(a: FloatVec, scale: float) -> FloatVec:
 
 
 def vector_len(a: FloatVec, squared: bool = False) -> float:
-    sum_sq = sum(ii ** 2 for ii in a)
+    # 2- and 3-D vectors are most of the traffic here, and for them the general
+    # branch spends more on interpreter overhead than on arithmetic: a generator
+    # object plus one resumption of it per axis, driven by sum(). Naming the
+    # axes skips both.
+    #
+    # sum() applies compensated (Neumaier) summation to floats, so for three
+    # terms it can land a ULP away from the plain addition used here. That
+    # difference is accepted: a ULP sits far below the precision a caller of a
+    # vector length can meaningfully rely on.
+    len_a = len(a)
+    if len_a == 2:
+        sum_sq = a[0] * a[0] + a[1] * a[1]
+    elif len_a == 3:
+        sum_sq = a[0] * a[0] + a[1] * a[1] + a[2] * a[2]
+    else:
+        sum_sq = sum(ii * ii for ii in a)
+
     return sum_sq if squared else math.sqrt(sum_sq)
 
 

{cooptools-1.75 → cooptools-1.76}/cooptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cooptools
-Version: 1.75
+Version: 1.76
 Summary: Generic Tooling
 Home-page: https://github.com/tylertjburns/cooptools
 Author: tburns

{cooptools-1.75 → cooptools-1.76}/setup.py

@@ -7,7 +7,7 @@ with open('requirements.txt') as f:
     requirements = f.read().splitlines()
 
 setuptools.setup(name='cooptools',
-      version='1.75',
+      version='1.76',
       description='Generic Tooling',
       url='https://github.com/tylertjburns/cooptools',
       author='tburns',

{cooptools-1.75 → cooptools-1.76}/tests/test_graph_node_classification.py

@@ -115,11 +115,16 @@ class TestAStarIgnoredDisablers(unittest.TestCase):
 
 class TestVerifyLenMatch(unittest.TestCase):
 
-    def test_matching_lengths_pass_silently(self):
-        self.assertIsNone(verify_len_match((1, 2), (3, 4)))
+    def test_matching_lengths_return_the_shared_length(self):
+        # The length is handed back so callers that need it -- vector_between
+        # being the reason -- do not have to measure the operands again.
+        self.assertEqual(2, verify_len_match((1, 2), (3, 4)))
 
-    def test_two_empties_match(self):
-        self.assertIsNone(verify_len_match((), ()))
+    def test_two_empties_match_and_report_zero(self):
+        self.assertEqual(0, verify_len_match((), ()))
+
+    def test_mismatch_returns_nothing_when_not_blocking(self):
+        self.assertIsNone(verify_len_match((1, 2, 3), (4, 5), block=False))
 
     def test_mismatched_lengths_raise(self):
         with self.assertRaises(ValueError):
@@ -131,8 +136,6 @@ class TestVerifyLenMatch(unittest.TestCase):
         self.assertIn('3', str(ctx.exception))
         self.assertIn('2', str(ctx.exception))
 
-    def test_mismatch_does_not_raise_when_not_blocking(self):
-        self.assertIsNone(verify_len_match((1, 2, 3), (4, 5), block=False))
 
 
 if __name__ == '__main__':