code: def chisquare(
      random_state, df, size=None, chunk_size=None, gpu=None, dtype=None
  ):
      r"""
      Draw samples from a chi-square distribution.
  
      When `df` independent random variables, each with standard normal
      distributions (mean 0, variance 1), are squared and summed, the
      resulting distribution is chi-square (see Notes).  This distribution
      is often used in hypothesis testing.
  
      Parameters
      ----------
      df : float or array_like of floats
           Number of degrees of freedom, should be > 0.
      size : int or tuple of ints, optional
          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
          ``m * n * k`` samples are drawn.  If size is ``None`` (default),
          a single value is returned if ``df`` is a scalar.  Otherwise,
          ``mt.array(df).size`` samples are drawn.
      chunk_size : int or tuple of int or tuple of ints, optional
          Desired chunk size on each dimension
      gpu : bool, optional
          Allocate the tensor on GPU if True, False as default
      dtype : data-type, optional
        Data-type of the returned tensor.
  
      Returns
      -------
      out : Tensor or scalar
          Drawn samples from the parameterized chi-square distribution.
  
      Raises
      ------
      ValueError
          When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)
          is given.
  
      Notes
      -----
      The variable obtained by summing the squares of `df` independent,
      standard normally distributed random variables:
  
      .. math:: Q = \sum_{i=0}^{\mathtt{df}} X^2_i
  
      is chi-square distributed, denoted
  
      .. math:: Q \sim \chi^2_k.
  
      The probability density function of the chi-squared distribution is
  
      .. math:: p(x) = \frac{(1/2)^{k/2}}{\Gamma(k/2)}
                       x^{k/2 - 1} e^{-x/2},
  
      where :math:`\Gamma` is the gamma function,
  
      .. math:: \Gamma(x) = \int_0^{-\infty} t^{x - 1} e^{-t} dt.
  
      References
      ----------
      .. [1] NIST "Engineering Statistics Handbook"
             http://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> mt.random.chisquare(2,4).execute()
      array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272])
      """
      if dtype is None:
          dtype = (
              np.random.RandomState()
              .chisquare(handle_array(df), size=(0,))
              .dtype
          )
      size = random_state._handle_size(size)
      seed = gen_random_seeds(1, random_state.to_numpy())[0]
      op = TensorChisquareDist(
          seed=seed, size=size, gpu=gpu, dtype=dtype
      )
      return op(df, chunk_size=chunk_size)
  
file_path: mars/mars/tensor/random/chisquare.py
imports: import numpy
  from ...None import opcodes
  from ...serialization.serializables import AnyField
  from ..utils import gen_random_seeds
  from .core import TensorRandomOperandMixin, handle_array, TensorDistribution
label_desc: Use image node_id 1 for calling a global function with example usage: chisquare(random_state, df, size, chunk_size, gpu, dtype) and returns: op