code: def idst(
      x,
      type=2,
      n=None,
      axis=-1,
      norm=None,
      overwrite_x=False,
      workers=None,
  ):
      """
      Return the Inverse Discrete Sine Transform of an arbitrary type sequence.
  
      Parameters
      ----------
      x : array_like
          The input array.
      type : {1, 2, 3, 4}, optional
          Type of the DST (see Notes). Default type is 2.
      n : int, optional
          Length of the transform. If ``n < x.shape[axis]``, `x` is
          truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
          default results in ``n = x.shape[axis]``.
      axis : int, optional
          Axis along which the idst is computed; the default is over the
          last axis (i.e., ``axis=-1``).
      norm : {"backward", "ortho", "forward"}, optional
          Normalization mode (see Notes). Default is "backward".
      overwrite_x : bool, optional
          If True, the contents of `x` can be destroyed; the default is False.
      workers : int, optional
          Maximum number of workers to use for parallel computation. If negative,
          the value wraps around from ``os.cpu_count()``.
          See :func:`~scipy.fft.fft` for more details.
  
      Returns
      -------
      idst : ndarray of real
          The transformed input array.
  
      See Also
      --------
      dst : Forward DST
  
      Notes
      -----
  
      'The' IDST is the IDST-II, which is the same as the normalized DST-III.
  
      The IDST is equivalent to a normal DST except for the normalization and
      type. DST type 1 and 4 are their own inverse and DSTs 2 and 3 are each
      other's inverses.
  
      """
      return (Dispatchable(x, np.ndarray),)
  
file_path: catboost/contrib/python/scipy/py3/scipy/fft/_realtransforms.py
imports: from ._basic import _dispatch
  from scipy._lib.uarray import Dispatchable
  import numpy
label_desc: Use image node_id 8 for calling a global function with example usage: idst(x, type, n, axis, norm, overwrite_x, workers) and returns: Dispatchable