code: def aamped(client, T_A, m, T_B=None, ignore_trivial=True, p=2.0, k=1):
      """
      Compute the non-normalized (i.e., without z-normalization) matrix profile
  
      This is a highly distributed implementation around the Numba JIT-compiled
      parallelized `_aamp` function which computes the non-normalized matrix profile
      according to AAMP.
  
      Parameters
      ----------
      client : client
          A Dask or Ray Distributed client. Setting up a distributed cluster is beyond
          the scope of this library. Please refer to the Dask or Ray Distributed
          documentation.
  
      T_A : numpy.ndarray
          The time series or sequence for which to compute the matrix profile
  
      m : int
          Window size
  
      T_B : numpy.ndarray, default None
          The time series or sequence that will be used to annotate T_A. For every
          subsequence in T_A, its nearest neighbor in T_B will be recorded. Default is
          `None` which corresponds to a self-join.
  
      ignore_trivial : bool, default True
          Set to `True` if this is a self-join. Otherwise, for AB-join, set this
          to `False`. Default is `True`.
  
      p : float, default 2.0
          The p-norm to apply for computing the Minkowski distance. Minkowski distance is
          typically used with `p` being 1 or 2, which correspond to the Manhattan distance
          and the Euclidean distance, respectively.
  
      k : int, default 1
          The number of top `k` smallest distances used to construct the matrix profile.
          Note that this will increase the total computational time and memory usage
          when k > 1.
  
      Returns
      -------
      out : numpy.ndarray
          When k = 1 (default), the first column consists of the matrix profile,
          the second column consists of the matrix profile indices, the third column
          consists of the left matrix profile indices, and the fourth column consists
          of the right matrix profile indices. However, when k > 1, the output array
          will contain exactly 2 * k + 2 columns. The first k columns (i.e., out[:, :k])
          consists of the top-k matrix profile, the next set of k columns
          (i.e., out[:, k:2k]) consists of the corresponding top-k matrix profile
          indices, and the last two columns (i.e., out[:, 2k] and out[:, 2k+1] or,
          equivalently, out[:, -2] and out[:, -1]) correspond to the top-1 left
          matrix profile indices and the top-1 right matrix profile indices, respectively.
  
      Notes
      -----
      `arXiv:1901.05708 \
      <https://arxiv.org/pdf/1901.05708.pdf>`__
  
      See Algorithm 1
  
      Note that we have extended this algorithm for AB-joins as well.
      """
      if T_B is None:
          T_B = T_A.copy()
          ignore_trivial = True
  
      T_A, T_A_subseq_isfinite = core.preprocess_non_normalized(T_A, m)
      T_B, T_B_subseq_isfinite = core.preprocess_non_normalized(T_B, m)
  
      if T_A.ndim != 1:  # pragma: no cover
          raise ValueError(
              f"T_A is {T_A.ndim}-dimensional and must be 1-dimensional. "
          )
  
      if T_B.ndim != 1:  # pragma: no cover
          raise ValueError(
              f"T_B is {T_B.ndim}-dimensional and must be 1-dimensional. "
          )
  
      core.check_window_size(
          m, max_size=min(T_A.shape[0], T_B.shape[0])
      )
      ignore_trivial = core.check_ignore_trivial(
          T_A, T_B, ignore_trivial
      )
  
      n_A = T_A.shape[0]
      n_B = T_B.shape[0]
  
      excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
  
      if ignore_trivial:
          diags = np.arange(excl_zone + 1, n_A - m + 1, dtype=np.int64)
      else:
          diags = np.arange(
              -(n_A - m + 1) + 1, n_B - m + 1, dtype=np.int64
          )
  
      _aamped = core._client_to_func(client)
  
      out = _aamped(
          client,
          T_A,
          T_B,
          m,
          T_A_subseq_isfinite,
          T_B_subseq_isfinite,
          p,
          diags,
          ignore_trivial,
          k,
      )
  
      core._check_P(out[:, 0])
  
      return out
  
imports: import numpy
  from .None import config, core
  from .aamp import _aamp
label_desc: Use image node_id 2 for calling a global function with example usage: aamped(client, T_A, m, T_B, ignore_trivial, p, k) and returns: out