code: def geometric(
      random_state, p, size=None, chunk_size=None, gpu=None, dtype=None
  ):
      """
      Draw samples from the geometric distribution.
  
      Bernoulli trials are experiments with one of two outcomes:
      success or failure (an example of such an experiment is flipping
      a coin).  The geometric distribution models the number of trials
      that must be run in order to achieve success.  It is therefore
      supported on the positive integers, ``k = 1, 2, ...``.
  
      The probability mass function of the geometric distribution is
  
      .. math:: f(k) = (1 - p)^{k - 1} p
  
      where `p` is the probability of success of an individual trial.
  
      Parameters
      ----------
      p : float or array_like of floats
          The probability of success of an individual trial.
      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 ``p`` is a scalar.  Otherwise,
          ``mt.array(p).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 geometric distribution.
  
      Examples
      --------
      Draw ten thousand values from the geometric distribution,
      with the probability of an individual success equal to 0.35:
  
      >>> import mars.tensor as mt
  
      >>> z = mt.random.geometric(p=0.35, size=10000)
  
      How many trials succeeded after a single run?
  
      >>> ((z == 1).sum() / 10000.).execute()
      0.34889999999999999 #random
      """
      if dtype is None:
          dtype = (
              np.random.RandomState()
              .geometric(handle_array(p), size=(0,))
              .dtype
          )
      size = random_state._handle_size(size)
      seed = gen_random_seeds(1, random_state.to_numpy())[0]
      op = TensorGeometric(seed=seed, size=size, gpu=gpu, dtype=dtype)
      return op(p, chunk_size=chunk_size)
  
file_path: mars/mars/tensor/random/geometric.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: geometric(random_state, p, size, chunk_size, gpu, dtype) and returns: op