code: def wddtw_alignment_path(
      x: np.ndarray,
      y: np.ndarray,
      return_cost_matrix: bool = False,
      window: Union[float, None] = None,
      itakura_max_slope: Union[float, None] = None,
      bounding_matrix: Union[np.ndarray, None] = None,
      compute_derivative=None,
      g: float = 0.0,
      **kwargs: Any,
  ) -> AlignmentPathReturn:
      r"""Compute the weighted derivative dynamic time warping (WDDTW) alignment path.
  
      WDDTW was first proposed in [1]_ as an extension of DDTW. By adding a weight
      to the derivative it means the alignment isn't only considering the shape of the
      time series, but also the phase.
  
      Formally the derivative is calculated as:
  
      .. math::
          D_{x}[q] = \frac{{}(q_{i} - q_{i-1} + ((q_{i+1} - q_{i-1}/2)}{2}
  
      Therefore a weighted derivative can be calculated using D (the derivative) as:
  
      .. math::
          d_{w}(x_{i}, y_{j}) = ||w_{|i-j|}(D_{x_{i}} - D_{y_{j}})||
  
      Parameters
      ----------
      x: np.ndarray (1d or 2d array)
          First time series.
      y: np.ndarray (1d or 2d array)
          Second time series.
      return_cost_matrix: bool, defaults = False
          Boolean that when true will also return the cost matrix.
      window: float, defaults = None
          Float that is the radius of the sakoe chiba window (if using Sakoe-Chiba
          lower bounding). Value must be between 0. and 1.
      itakura_max_slope: float, defaults = None
          Gradient of the slope for itakura parallelogram (if using Itakura
          Parallelogram lower bounding). Value must be between 0. and 1.
      bounding_matrix: np.ndarray (2d of size mxn where m is len(x) and n is len(y)),
                                      defaults = None
          Custom bounding matrix to use. If defined then other lower_bounding params
          are ignored. The matrix should be structure so that indexes considered in
          bound should be the value 0. and indexes outside the bounding matrix should be
          infinity.
      compute_derivative: Callable[[np.ndarray], np.ndarray],
                              defaults = average slope difference
          Callable that computes the derivative. If none is provided the average of the
          slope between two points used.
      g: float, defaults = 0.
          Constant that controls the curvature (slope) of the function; that is, g
          controls the level of penalisation for the points with larger phase
          difference.
      kwargs: Any
          Extra kwargs.
  
      Returns
      -------
      list[tuple]
          List of tuples containing the wddtw alignment path.
      float
          Wddtw distance between x and y.
      np.ndarray (of shape (len(x), len(y)).
          Optional return only given if return_cost_matrix = True.
          Cost matrix used to compute the distance.
  
      Raises
      ------
      ValueError
          If the sakoe_chiba_window_radius is not float.
          If the itakura_max_slope is not a float.
          If the value of x or y provided is not a numpy array.
          If the value of x or y has more than 2 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 the metric type cannot be determined
          If the compute derivative callable is not no_python compiled.
          If the value of g is not a float
          If both window and itakura_max_slope are set
  
      References
      ----------
      .. [1] Young-Seon Jeong, Myong K. Jeong, Olufemi A. Omitaomu, Weighted dynamic time
      warping for time series classification, Pattern Recognition, Volume 44, Issue 9,
      2011, Pages 2231-2240, ISSN 0031-3203, https://doi.org/10.1016/j.patcog.2010.09.022.
      """
      if compute_derivative is None:
          from sktime.distances._ddtw_numba import average_of_slope
  
          compute_derivative = average_of_slope
  
      format_kwargs = {
          "window": window,
          "itakura_max_slope": itakura_max_slope,
          "bounding_matrix": bounding_matrix,
          "compute_derivative": compute_derivative,
          "g": g,
      }
      format_kwargs = {**format_kwargs, **kwargs}
  
      return distance_alignment_path(
          x,
          y,
          metric="wddtw",
          return_cost_matrix=return_cost_matrix,
          **format_kwargs,
      )
  
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 15 for calling a global function with example usage: wddtw_alignment_path(x, y, return_cost_matrix, window, itakura_max_slope, bounding_matrix, compute_derivative, g) and returns: distance_alignment_path