Revise function to pass test

Author: NimaSarajpoor

stumpy/core.py

@@ -554,7 +554,7 @@ def get_max_window_size(n):
     return max_m
 
 
-def check_window_size(m, max_size=None, excl_zone=None, last_start_index=None):
+def check_window_size(m, max_size=None, n=None):
     """
     Check the window size and ensure that it is greater than or equal to 3 and, if
     `max_size` is provided, ensure that the window size is less than or equal to the
@@ -569,12 +569,8 @@ def check_window_size(m, max_size=None, excl_zone=None, last_start_index=None):
     max_size : int, default None
         The maximum window size allowed
 
-    excl_zone : int, default None
-        Size of the exclusion zone. If provided, then the `last_start_index`
-        must also be provided.
-
-    last_start_index : int, default None
-        Start index of the last subsequence
+    n : int, default None
+        The length of the time series.
 
     Returns
     -------
@@ -597,31 +593,31 @@ def check_window_size(m, max_size=None, excl_zone=None, last_start_index=None):
     if max_size is not None and m > max_size:
         raise ValueError(f"The window size must be less than or equal to {max_size}")
 
-    if excl_zone is not None:
-        if last_start_index is None:  # pragma: no cover
-            raise ValueError(
-                "last_start_index must be provided when excl_zone is not None"
-            )
-
-        # Check if subsequneces have non-trivial neighbours
-
-        # Case 1:
-        # There is at least one subsequence with non-trivial neighbour
-        # i.e. For AN `i`, there exists at least one `j` such that |i - j| > excl_zone
-        # In this case, we just need to consider the two subsequences that are furthest
-        # apart from each other.
-        # In other words: |last_start_index - 0| > excl_zone
-        cond_1 = (last_start_index - 0) > excl_zone
-
-        # Case 2:
-        # Check if each single subsequence has at least one non-trivial neighbor
-        # i. e. For ANY `i`, there exists at least one `j` such that |i - j| > excl_zone
-        # In this case, we need to consider the subseuqence whose furthest neighbour is
-        # the shortest compared to other subsequences.
-        # In other words: |ceil(last_start_index / 2) - 0| > excl_zone
-        cond_2 = (math.ceil(last_start_index / 2) - 0) > excl_zone
-
-        if not cond_1 or not cond_2:
+    if n is not None:
+        # The following code raises warning if there is at least one subsequence
+        # with no non-trivial neighbor. The following logic does not check if
+        # a subsequence has a non-finite value.
+
+        # Logic: For each subsequnece `S_i = T[i : i + m]`, its neighbor `S_j`
+        # is non-trivial if |i - j| > excl_zone. Let's denote `S_jmax` as
+        # the neighbor that is furthest away from `S_i` (index-wise). So:
+        # |i - jmax| >= |i - j|
+        # Therefore, if `S_i` has at least one non-trivial neighbor, then `S_jmax` is
+        # definitely a non-trivial neighbor. Because:
+        # |i - jmax| >= |i - j| > excl_zone
+        # To ensure ALL subsequences have at least one non-trivial neighbor, we can just
+        # check the subsequence `S_i` that has the minimum |i - jmax|. Let's denote `d`
+        # as that minimum value. So, if d > excl_zone, then:
+        # For any `i` and its corresponding `jmax`, we have:
+        # |i - jmax| >= d > excl_zone
+
+        # The minimum |i - jmax| is achieved when `S_i` is the middle ubsequence,
+        # i.e. i == int(ceil((n - m) / 2)), and its corresponding jmax is 0. Hence,
+        # we just need to make sure the following inequity is satisfied:
+        # |int(ceil((n - m) / 2)) - 0| > excl_zone`
+
+        excl_zone = int(math.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
+        if (int(math.ceil((n - m) / 2)) - 0) <= excl_zone:
             msg = (
                 f"The window size, 'm = {m}', may be too large and could lead to "
                 + "meaningless results. Consider reducing 'm' where necessary"

stumpy/stump.py

@@ -716,20 +716,14 @@ def stump(
     l = n_A - m + 1
 
     ignore_trivial = core.check_ignore_trivial(T_A, T_B, ignore_trivial)
-    if ignore_trivial:
-        excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
+    excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
+    if ignore_trivial:  # self-join
+        core.check_window_size(m, max_size=n_A, n=n_A)
         diags = np.arange(excl_zone + 1, n_A - m + 1, dtype=np.int64)
-    else:
-        excl_zone = None
+    else:  # AB-join
+        core.check_window_size(m, max_size=min(n_A, n_B))
         diags = np.arange(-(n_A - m + 1) + 1, n_B - m + 1, dtype=np.int64)
 
-    core.check_window_size(
-        m,
-        max_size=min(T_A.shape[0], T_B.shape[0]),
-        excl_zone=excl_zone,
-        last_start_index=l - 1,
-    )
-
     P, PL, PR, I, IL, IR = _stump(
         T_A,
         T_B,