code: def pairwise_distance(
      x: np.ndarray,
      y: np.ndarray = None,
      metric: Union[
          str,
          Callable[
              [np.ndarray, np.ndarray, dict],
              Callable[[np.ndarray, np.ndarray], float],
          ],
          Callable[[np.ndarray, np.ndarray], float],
          NumbaDistance,
      ] = "euclidean",
      **kwargs: Any,
  ) -> np.ndarray:
      """Compute the pairwise distance matrix between two time series.
  
      First the distance metric is 'resolved'. This means the metric that is passed
      is resolved to a callable. The callable is then called with x and y and the
      value is then returned. Then for each combination of x and y, the distance between
      the values are computed resulting in a 2d pairwise matrix.
  
      Parameters
      ----------
      x: np.ndarray (1d, 2d or 3d array)
          First time series.
      y: np.ndarray (1d, 2d or 3d array), defaults = None
          Second time series. If not specified then y is set to the value of x.
      metric: str or Callable, defaults = 'euclidean'
          The distance metric to use.
          If a string is given, the value must be one of the following strings:
              'euclidean', 'squared', 'dtw', 'ddtw', 'wdtw', 'wddtw',
              'lcss', 'edr', 'erp', 'msm'
          If callable then it has to be a distance factory or numba distance callable.
          If you want to pass custom kwargs to the distance at runtime, use a distance
          factory as it constructs the distance using the kwargs before distance
          computation.
          A distance callable takes the form (must be no_python compiled):
          Callable[[np.ndarray, np.ndarray], float]
  
          A distance factory takes the form (must return a no_python callable):
          Callable[[np.ndarray, np.ndarray, bool, dict], Callable[[np.ndarray,
          np.ndarray], float]].
      kwargs: Any
          Extra arguments for metric. Refer to each metric documentation for a list of
          possible arguments.
  
      Returns
      -------
      np.ndarray (2d of size mxn where m is len(x) and n is len(y)).
          Pairwise distance matrix between the two time series.
  
      Raises
      ------
      ValueError
          If the value of x or y provided is not a numpy array.
          If the value of x or y has more than 3 dimensions.
          If a metric string provided, and is not a defined valid string.
          If a metric object (instance of class) is provided and doesn't inherit from
          NumbaDistance.
          If a resolved metric is not no_python compiled.
          If the metric type cannot be determined.
  
      Examples
      --------
      >>> import numpy as np
      >>> from sktime.distances import pairwise_distance
      >>> x_1d = np.array([1, 2, 3, 4])  # 1d array
      >>> y_1d = np.array([5, 6, 7, 8])  # 1d array
      >>> pairwise_distance(x_1d, y_1d, metric='dtw')
      array([[16., 25., 36., 49.],
             [ 9., 16., 25., 36.],
             [ 4.,  9., 16., 25.],
             [ 1.,  4.,  9., 16.]])
  
      >>> x_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])  # 2d array
      >>> y_2d = np.array([[9, 10, 11, 12], [13, 14, 15, 16]])  # 2d array
      >>> pairwise_distance(x_2d, y_2d, metric='dtw')
      array([[256., 576.],
             [ 58., 256.]])
  
      >>> x_3d = np.array([[[1], [2], [3], [4]], [[5], [6], [7], [8]]])  # 3d array
      >>> y_3d = np.array([[[9], [10], [11], [12]], [[13], [14], [15], [16]]])  # 3d array
      >>> pairwise_distance(x_3d, y_3d, metric='dtw')
      array([[256., 576.],
             [ 64., 256.]])
  
      >>> x_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])  # 2d array
      >>> y_2d = np.array([[9, 10, 11, 12], [13, 14, 15, 16]])  # 2d array
      >>> pairwise_distance(x_2d, y_2d, metric='dtw', window=0.5)
      array([[256., 576.],
             [ 58., 256.]])
      """
      from sktime.distances._numba_utils import (
          _compute_pairwise_distance,
          _make_3d_series,
      )
  
      _x = _make_3d_series(x)
      if y is None:
          y = x
      _y = _make_3d_series(y)
      symmetric = np.array_equal(_x, _y)
      _metric_callable = _resolve_metric_to_factory(
          metric, _x[0], _y[0], _METRIC_INFOS, **kwargs
      )
      return _compute_pairwise_distance(
          _x, _y, symmetric, _metric_callable
      )
  
imports: from typing import Any, Callable, Union
  import numpy
  from sktime.distances._ddtw import _DdtwDistance
  from sktime.distances._dtw import _DtwDistance
  from sktime.distances._edr import _EdrDistance
  from sktime.distances._erp import _ErpDistance
  from sktime.distances._euclidean import _EuclideanDistance
  from sktime.distances._lcss import _LcssDistance
  from sktime.distances._msm import _MsmDistance
  from sktime.distances._resolve_metric import _resolve_dist_instance, _resolve_metric_to_factory
  from sktime.distances._squared import _SquaredDistance
  from sktime.distances._twe import _TweDistance
  from sktime.distances._wddtw import _WddtwDistance
  from sktime.distances._wdtw import _WdtwDistance
  from sktime.distances.base import AlignmentPathReturn, DistanceAlignmentPathCallable, DistanceCallable, MetricInfo, NumbaDistance
label_desc: Use image node_id 23 for calling a global function with example usage: pairwise_distance(x, y, metric) and returns: _compute_pairwise_distance