code: def _stomp_self(ts, m):
      """STOMP implementation for self-similarity join.
  
      Parameters
      ----------
          ts: numpy.array
              Time series.
          m: int
              Length of the subsequences.
  
      Output
      ------
          mp: numpy.array
              Array with the distance between every subsequence from ts1
              to the nearest subsequence with same length from ts2.
          ip: numpy.array
              Array with the index of the nearest neighbor of ts1 in ts2.
      """
      ts = ts.flatten()
  
      ts_len = ts.shape[0]
  
      # Number of subsequences
      n_subs = ts_len - m + 1
  
      # Compute the mean and standard deviation
      ts_mean = [np.mean(ts[i : i + m]) for i in range(0, n_subs)]
      ts_std = [np.std(ts[i : i + m]) for i in range(0, n_subs)]
  
      # Compute the dot products between the first subsequence and every other
      # subsequence
      dot_prod = _sliding_dot_products(ts[0:m], ts, m, ts_len)
      first_dot_prod = np.copy(dot_prod)
  
      # Initialization
      mp = np.full(n_subs, float("inf"))  # matrix profile
      ip = np.zeros(n_subs)  # index profile
  
      # Compute the distance profile for the first subsequence
      dp = _calculate_distance_profile(
          dot_prod, ts_mean[0], ts_std[0], ts_mean, ts_std, m, n_subs
      )
  
      # Updates the matrix profile
      mp, ip = _minimum_distance(mp, ip, dp, 0, m, n_subs)
  
      for i in range(1, n_subs):
          for j in range(n_subs - 1, 0, -1):
              dot_prod[j] = (
                  dot_prod[j - 1]
                  - ts[j - 1] * ts[i - 1]
                  + ts[j - 1 + m] * ts[i - 1 + m]
              )  # compute the next dot products
              # using the previous ones
          dot_prod[0] = first_dot_prod[i]
          dp = _calculate_distance_profile(
              dot_prod,
              ts_mean[i],
              ts_std[i],
              ts_mean,
              ts_std,
              m,
              n_subs,
          )
          mp, ip = _minimum_distance(mp, ip, dp, i, m, n_subs)
  
      return mp
  
file_path: sktime/sktime/transformations/panel/matrix_profile.py
imports: import numpy
  import pandas
  from sktime.transformations.base import BaseTransformer
label_desc: Use image node_id 4 for calling a global function with example usage: _stomp_self(ts, m) and returns: mp