Rename function: 'segments_overlap_or_cross' -> 'segments_cross_or_ov…

…erlap'

bentley_ottmann/planar.py

@@ -133,7 +133,7 @@ def segments_intersect(segments: Sequence[Segment],
     return any(_planar.sweep(segments, accurate, validate))
 
 
-def segments_overlap_or_cross(segments: Sequence[Segment],
+def segments_cross_or_overlap(segments: Sequence[Segment],
                               *,
                               accurate: bool = True,
                               validate: bool = True) -> bool:
@@ -160,15 +160,15 @@ def segments_overlap_or_cross(segments: Sequence[Segment],
         if ``validate`` flag is set and degenerate segment found.
     :returns: true if segments overlap or cross found, false otherwise.
 
-    >>> segments_overlap_or_cross([])
+    >>> segments_cross_or_overlap([])
     False
-    >>> segments_overlap_or_cross([((0., 0.), (2., 2.))])
+    >>> segments_cross_or_overlap([((0., 0.), (2., 2.))])
     False
-    >>> segments_overlap_or_cross([((0., 0.), (2., 0.)), ((0., 2.), (2., 2.))])
+    >>> segments_cross_or_overlap([((0., 0.), (2., 0.)), ((0., 2.), (2., 2.))])
     False
-    >>> segments_overlap_or_cross([((0., 0.), (2., 2.)), ((0., 0.), (2., 2.))])
+    >>> segments_cross_or_overlap([((0., 0.), (2., 2.)), ((0., 0.), (2., 2.))])
     True
-    >>> segments_overlap_or_cross([((0., 0.), (2., 2.)), ((2., 0.), (0., 2.))])
+    >>> segments_cross_or_overlap([((0., 0.), (2., 2.)), ((2., 0.), (0., 2.))])
     True
     """
     relationships = _SegmentsRelationship.CROSS, _SegmentsRelationship.OVERLAP

tests/planar_tests/test_segments_overlap_or_cross.py → tests/planar_tests/test_segments_cross_or_overlap.py

@@ -6,22 +6,22 @@
 from bentley_ottmann.core.linear import (SegmentsRelationship,
                                          segments_relationship)
 from bentley_ottmann.hints import Segment
-from bentley_ottmann.planar import segments_overlap_or_cross
+from bentley_ottmann.planar import segments_cross_or_overlap
 from tests.utils import (reverse_segment,
                          reverse_segment_coordinates)
 from . import strategies
 
 
 @given(strategies.segments_lists)
 def test_basic(segments: List[Segment]) -> None:
-    result = segments_overlap_or_cross(segments)
+    result = segments_cross_or_overlap(segments)
 
     assert isinstance(result, bool)
 
 
 @given(strategies.empty_segments_lists)
 def test_base_case(segments: List[Segment]) -> None:
-    result = segments_overlap_or_cross(segments)
+    result = segments_cross_or_overlap(segments)
 
     assert not result
 
@@ -30,8 +30,8 @@ def test_base_case(segments: List[Segment]) -> None:
 def test_step(segments: List[Segment]) -> None:
     first_segment, *rest_segments = segments
 
-    result = segments_overlap_or_cross(rest_segments)
-    next_result = segments_overlap_or_cross(segments)
+    result = segments_cross_or_overlap(rest_segments)
+    next_result = segments_cross_or_overlap(segments)
 
     assert (next_result
             is (result
@@ -43,29 +43,29 @@ def test_step(segments: List[Segment]) -> None:
 
 @given(strategies.segments_lists)
 def test_reversed(segments: List[Segment]) -> None:
-    result = segments_overlap_or_cross(segments)
+    result = segments_cross_or_overlap(segments)
 
-    assert result is segments_overlap_or_cross(segments[::-1])
+    assert result is segments_cross_or_overlap(segments[::-1])
 
 
 @given(strategies.segments_lists)
 def test_reversed_endpoints(segments: List[Segment]) -> None:
-    result = segments_overlap_or_cross(segments)
+    result = segments_cross_or_overlap(segments)
 
-    assert result is segments_overlap_or_cross([reverse_segment(segment)
+    assert result is segments_cross_or_overlap([reverse_segment(segment)
                                                 for segment in segments])
 
 
 @given(strategies.segments_lists)
 def test_reversed_coordinates(segments: List[Segment]) -> None:
-    result = segments_overlap_or_cross(segments)
+    result = segments_cross_or_overlap(segments)
 
     assert (result
-            is segments_overlap_or_cross([reverse_segment_coordinates(segment)
+            is segments_cross_or_overlap([reverse_segment_coordinates(segment)
                                           for segment in segments]))
 
 
 @given(strategies.degenerate_segments_lists)
 def test_degenerate_segments(segments: List[Segment]) -> None:
     with pytest.raises(ValueError):
-        segments_overlap_or_cross(segments)
+        segments_cross_or_overlap(segments)