remove joint calculation of dot product and norms

Author: h-mayorquin

src/spikeinterface/comparison/comparisontools.py

@@ -108,90 +108,6 @@ def do_count_event(sorting):
     return event_counts
 
 
-def get_optimized_compute_dot_product_all():
-    """
-    This function wraps around the compute_dot_product function,
-    which uses numba for JIT compilation. It caches the compiled function
-    for improved performance on subsequent calls.
-    """
-
-    if hasattr(get_optimized_compute_dot_product_all, "_cached_function"):
-        return get_optimized_compute_dot_product_all._cached_function
-
-    import numba
-
-    @numba.jit(nopython=True, nogil=True)
-    def compute_dot_product(sample_frames, unit_indices, num_units_sorting1, num_units_sorting2, delta_frames):
-        """
-        Compute the dot product matrix for two spike trains.
-
-        Note that the sample frames and unit indices must be sorted by sample frames.
-        Also note that the unit_indices corresponding to the second spike train must be
-        shifted by num_units_sorting1.
-
-        This creates a matrix that can be divided in four quadrants. Clokwise from top left:
-        1. The dot product of spikes in the first spike train with themselves.
-        2. The dot product of spikes in the first spike train with spikes in the second spike train.
-        3. The dot product of spikes in the second spike train with spikes in the first spike train.
-        4. The dot product of spikes in the second spike train with themselves.
-
-        Note that the norms of of the spike trains are the diagonals of the 1 and 4 quadrants.
-        That is the only part of those quadrants that we need to calculate.
-
-        Parameters
-        ----------
-        sample_frames : ndarray
-            An array of integer frame numbers corresponding to spike times.
-        unit_indices : ndarray
-            An array of integers where unit_indices[i] gives the unit index associated with
-            the spike at sample_frames[i]. Note that the unit_indices of the second spike train
-            need to be shifted by num_units_sorting1.
-        num_units_sorting1 : int
-            The total count of unique units in the first spike train.
-        num_units_sorting2 : int
-            The total count of unique units in the second spike train.
-        delta_frames : int
-            The inclusive upper limit on the frame difference for which two spikes are considered in proximity.
-
-        Returns
-        -------
-        dot_product_matrix : ndarray
-            A 2D numpy array of shape (num_units_sorting1 + num_units_sorting2, num_units_sorting1 + num_units_sorting2).
-            Each element [i, j] represents the accumulated proximity score between unit i and unit j.
-        """
-
-        dot_product_matrix = np.zeros(
-            (num_units_sorting1 + num_units_sorting2, num_units_sorting1 + num_units_sorting2),
-            dtype=np.uint32,
-        )
-
-        minimal_search = 0
-        num_samples = len(sample_frames)
-        for index1 in range(num_samples):
-            frame1 = sample_frames[index1]
-
-            for index2 in range(minimal_search, num_samples):
-                frame2 = sample_frames[index2]
-
-                frame2 - frame1
-                if frame2 < frame1 - delta_frames:
-                    minimal_search += 1
-                    continue
-                elif frame2 > frame1 + delta_frames:
-                    break
-                else:
-                    unit_index1 = unit_indices[index1]
-                    unit_index2 = unit_indices[index2]
-                    dot_product_matrix[unit_index1, unit_index2] += delta_frames - abs(frame1 - frame2)
-
-        return dot_product_matrix
-
-    # Cache the compiled function
-    get_optimized_compute_dot_product_all._cached_function = compute_dot_product
-
-    return compute_dot_product
-
-
 def get_optimized_dot_product_function():
     """
     This function is to avoid the bare try-except pattern when importing the compute_dot_product function