code: def comb(N, k, exact=False, repetition=False):
      """The number of combinations of N things taken k at a time.
  
      This is often expressed as "N choose k".
  
      Parameters
      ----------
      N : int, ndarray
          Number of things.
      k : int, ndarray
          Number of elements taken.
      exact : bool, optional
          If `exact` is False, then floating point precision is used, otherwise
          exact long integer is computed.
      repetition : bool, optional
          If `repetition` is True, then the number of combinations with
          repetition is computed.
  
      Returns
      -------
      val : int, float, ndarray
          The total number of combinations.
  
      See Also
      --------
      binom : Binomial coefficient ufunc
  
      Notes
      -----
      - Array arguments accepted only for exact=False case.
      - If N < 0, or k < 0, then 0 is returned.
      - If k > N and repetition=False, then 0 is returned.
  
      Examples
      --------
      >>> from scipy.special import comb
      >>> k = np.array([3, 4])
      >>> n = np.array([10, 10])
      >>> comb(n, k, exact=False)
      array([ 120.,  210.])
      >>> comb(10, 3, exact=True)
      120
      >>> comb(10, 3, exact=True, repetition=True)
      220
  
      """
      if repetition:
          return comb(N + k - 1, k, exact)
      if exact:
          return _comb_int(N, k)
      else:
          k, N = asarray(k), asarray(N)
          cond = (k <= N) & (N >= 0) & (k >= 0)
          vals = binom(N, k)
          if isinstance(vals, np.ndarray):
              vals[~cond] = 0
          elif not cond:
              vals = np.float64(0)
          return vals
  
imports: import operator
  import numpy
  import math
  from numpy import pi, asarray, floor, isscalar, iscomplex, real, imag, sqrt, where, mgrid, sin, place, issubdtype, extract, inexact, nan, zeros, sinc
  from .None import _ufuncs
  from ._ufuncs import mathieu_a, mathieu_b, iv, jv, gamma, psi, hankel1, hankel2, yv, kv, ndtri, poch, binom, hyp0f1
  from .None import specfun
  from .None import orthogonal
  from ._comb import _comb_int
label_desc: Use image node_id 53 for calling a global function with example usage: comb(N, k, exact, repetition) and returns: comb, _comb_int, vals