[DOC] Fix inconsistent double backticks in similarity_search module (aeon-toolkit#809)

Author: adityagh006

aeon/similarity_search/base.py

@@ -21,35 +21,35 @@ class BaseSimilaritySearch(BaseCollectionEstimator):
     Parameters
     ----------
     distance : str, default="euclidean"
-        Name of the distance function to use. A list of valid strings can be found in
-        the documentation for :func:`aeon.distances.get_distance_function`.
-        If a callable is passed it must either be a python function or numba function
-        with nopython=True, that takes two 1d numpy arrays as input and returns a float.
+        The name of the distance function to use. A list of valid strings can be found in
+        the documentation for ``aeon.distances.get_distance_function``.
+        If a callable is passed, it must be either a Python function or a Numba function
+        with ``nopython=True`` that takes two 1D numpy arrays as input and returns a float.
     distance_args : dict, default=None
         Optional keyword arguments for the distance function.
     inverse_distance : bool, default=False
-        If True, the matching will be made on the inverse of the distance, and thus, the
-        worst matches to the query will be returned instead of the best ones.
+        If ``True``, the matching will be based on the inverse of the distance,
+        returning the worst matches instead of the best ones.
     normalise : bool, default=False
-        Whether the distance function should be z-normalised.
-    speed_up : str, default='fastest'
-        Which speed up technique to use with for the selected distance
-        function. By default, the fastest algorithm is used. A list of available
-        algorithm for each distance can be obtained by calling the
-        `get_speedup_function_names` function of the child classes.
+        Whether the distance function should be z-normalized.
+    speed_up : str, default="fastest"
+        Which speed-up technique to use for the selected distance function.
+        By default, the fastest algorithm is used. A list of available algorithms
+        for each distance can be obtained by calling the
+        ``get_speedup_function_names`` method of the child classes.
     n_jobs : int, default=1
-        Number of parallel jobs to use.
+        The number of parallel jobs to use.
 
     Attributes
     ----------
-    X_ : np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints)
-        The input time series stored during the fit method.
+    X_ : np.ndarray
+        A 3D array of shape ``(n_cases, n_channels, n_timepoints)`` storing the
+        input time series during the fit method.
 
     Notes
     -----
-    For now, the multivariate case is only treated as independent.
-    Distances are computed for each channel independently and then
-    summed together.
+    Currently, the multivariate case is treated independently.
+    Distances are computed for each channel separately and then summed together.
     """
 
     _tags = {

aeon/similarity_search/distance_profiles/euclidean_distance_profile.py

@@ -18,29 +18,30 @@ def euclidean_distance_profile(
     X: Union[np.ndarray, List], q: np.ndarray, mask: np.ndarray
 ) -> np.ndarray:
     """
-    Compute a distance profile using the squared Euclidean distance.
-
-    It computes the distance profiles between the input time series and the query using
-    the squared Euclidean distance. The distance between the query and a candidate is
-    comptued using a dot product and a rolling sum to avoid recomputing parts of the
-    operation.
-
-    Parameters
-    ----------
-    X: np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints)
-        The input samples. If X is an unquel length collection, expect a numba TypedList
-        of 2D arrays of shape (n_channels, n_timepoints)
-    q : np.ndarray, 2D array of shape (n_channels, query_length)
-        The query used for similarity search.
-    mask : np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints - query_length + 1)  # noqa: E501
-        Boolean mask of the shape of the distance profile indicating for which part
-        of it the distance should be computed.
-
-    Returns
-    -------
-    distance_profiles : np.ndarray
-        3D array of shape (n_cases, n_timepoints - query_length + 1)
-        The distance profile between q and the input time series X.
+     Compute the distance profile using the squared Euclidean distance.  
+
+    This method calculates the distance profiles between the input time series and the query  
+    using the squared Euclidean distance. To optimize computation, it utilizes a dot product  
+    and a rolling sum, reducing redundant calculations.  
+
+    Parameters  
+    ----------  
+    X : np.ndarray or numba.typed.List  
+        - If X is a NumPy array, it should have the shape ``(n_cases, n_channels, n_timepoints)``.  
+        - If X contains sequences of unequal lengths, it should be a numba ``TypedList``  
+          of 2D arrays, each with the shape ``(n_channels, n_timepoints)``.  
+    q : np.ndarray  
+        - A 2D array of shape ``(n_channels, query_length)`` representing the query used  
+          for similarity search.  
+    mask : np.ndarray  
+        - A 3D boolean array of shape ``(n_cases, n_channels, n_timepoints - query_length + 1)``  
+          that specifies which parts of the distance profile should be computed.  
+
+    Returns  
+    -------  
+    distance_profiles : np.ndarray  
+        - A 3D array of shape ``(n_cases, n_timepoints - query_length + 1)`` representing  
+          the distance profiles between the query ``q`` and the input time series ``X``.  
 
     """
     distance_profiles = squared_distance_profile(X, q, mask)
@@ -60,37 +61,37 @@ def normalised_euclidean_distance_profile(
     q_stds: np.ndarray,
 ) -> np.ndarray:
     """
-    Compute a distance profile in a brute force way.
+    Compute a distance profile using brute force.
 
     It computes the distance profiles between the input time series and the query using
-    the specified distance. The search is made in a brute force way without any
+    the specified distance. The search is performed in a brute-force manner without any
     optimizations and can thus be slow.
 
     Parameters
     ----------
-    X: np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints)
-        The input samples. If X is an unquel length collection, expect a numba TypedList
-        of 2D arrays of shape (n_channels, n_timepoints)
-    q : np.ndarray, 2D array of shape (n_channels, query_length)
+    X : np.ndarray, 3D array of shape ``(n_cases, n_channels, n_timepoints)``
+        The input samples. If `X` is an **unequal** length collection, expect a numba 
+        ``TypedList`` of 2D arrays of shape ``(n_channels, n_timepoints)``.
+    q : np.ndarray, 2D array of shape ``(n_channels, query_length)``
         The query used for similarity search.
-    mask : np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints - query_length + 1)  # noqa: E501
-        Boolean mask of the shape of the distance profile indicating for which part
-        of it the distance should be computed.
-    X_means : np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints - query_length + 1)  # noqa: E501
-        Means of each subsequences of X of size query_length. Should be a numba
-        TypedList if X is unequal length.
-    X_stds : np.ndarray, 3D array of shape (n_cases, n_channels, n_timepoints - query_length + 1)  # noqa: E501
-        Stds of each subsequences of X of size query_length. Should be a numba
-        TypedList if X is unequal length.
-    q_means : np.ndarray, 1D array of shape (n_channels)
-        Means of the query q
-    q_stds : np.ndarray, 1D array of shape (n_channels)
+    mask : np.ndarray, 3D array of shape ``(n_cases, n_channels, n_timepoints - query_length + 1)``
+        Boolean mask indicating for which part of the distance profile the computation 
+        should be performed.
+    X_means : np.ndarray, 3D array of shape ``(n_cases, n_channels, n_timepoints - query_length + 1)``
+        Means of each subsequence of ``X`` of size ``query_length``. Should be a numba
+        ``TypedList`` if ``X`` is of unequal length.
+    X_stds : np.ndarray, 3D array of shape ``(n_cases, n_channels, n_timepoints - query_length + 1)``
+        Standard deviations of each subsequence of ``X`` of size ``query_length``. Should be 
+        a numba ``TypedList`` if ``X`` is of unequal length.
+    q_means : np.ndarray, 1D array of shape ``(n_channels,)``
+        Means of the query ``q``.
+    q_stds : np.ndarray, 1D array of shape ``(n_channels,)``
+        Standard deviations of the query ``q``.
 
     Returns
     -------
-    distance_profiles : np.ndarray
-        3D array of shape (n_cases, n_timepoints - query_length + 1)
-        The distance profile between q and the input time series X.
+    distance_profiles : np.ndarray, 3D array of shape ``(n_cases, n_timepoints - query_length + 1)``
+        The computed distance profile between ``q`` and the input time series ``X``.
 
     """
     distance_profiles = normalised_squared_distance_profile(