code: def beta(a, b, size=None, dtype=None, device=None):
      r"""Draw samples from a Beta distribution.
  
      The Beta distribution is a special case of the Dirichlet distribution,
      and is related to the Gamma distribution.  It has the probability
      distribution function
  
      .. math:: f(x; a,b) = \frac{1}{B(\alpha, \beta)} x^{\alpha - 1}
                                                       (1 - x)^{\beta - 1},
  
      where the normalisation, B, is the beta function,
  
      .. math:: B(\alpha, \beta) = \int_0^1 t^{\alpha - 1}
                                   (1 - t)^{\beta - 1} dt.
  
      It is often seen in Bayesian inference and order statistics.
  
      Parameters
      ----------
      a : float or array_like of floats
          Alpha, positive (>0).
      b : float or array_like of floats
          Beta, positive (>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 ``a`` and ``b`` are both scalars.
          Otherwise, ``np.broadcast(a, b).size`` samples are drawn.
      dtype : {'float16', 'float32', 'float64'}, optional
          Data type of output samples.
          When npx.is_np_default_dtype() returns False, default dtype is float32;
          When npx.is_np_default_dtype() returns True, default dtype is float64.
      device : Device, optional
          Device context of output. Default is current device.
  
      Notes
      -------
      To use this  operator with scalars as input, please run ``npx.set_np()`` first.
  
      Returns
      -------
      out : ndarray or scalar
          Drawn samples from the parameterized beta distribution.
      """
      if dtype is None:
          dtype = np.float64 if is_np_default_dtype() else np.float32
      if device is None:
          device = current_device()
      if size == ():
          size = None
      # use fp64 to prevent precision loss
      X = gamma(a, 1, size=size, dtype="float64", device=device)
      Y = gamma(b, 1, size=size, dtype="float64", device=device)
      out = X / (X + Y)
      return out.astype(dtype)
  
imports: import numpy
  from ...util import is_np_default_dtype
  from ...device import current_device
  from .None import _internal
  from .None import _api_internal
  from ...util import wrap_ctx_to_device_func
  from ..ndarray import get_dtype_name
label_desc: Use image node_id 16 for calling a global function with example usage: beta(a, b, size, dtype, device) and returns: out