docs: def bootstrap_counts(dtrajs, lagtime, corrlength=None):
      """
      Generates a randomly resampled count matrix given the input coordinates.
  
      See API function for full documentation.
      """
      from scipy.stats import rv_discrete
      # if we have just one trajectory, put it into a one-element list:
      if (isinstance(dtrajs[0], six.integer_types)):
          dtrajs = [dtrajs]
      ntraj = len(dtrajs)
  
      # can we do the estimate?
      lengths = determine_lengths(dtrajs)
      Lmax = np.max(lengths)
      Ltot = np.sum(lengths)
      if (lagtime >= Lmax):
          raise ValueError('Cannot estimate count matrix: lag time '
                           + str(lagtime) + ' is longer than the longest trajectory length ' + str(Lmax))
  
      # how many counts can we sample?
      if corrlength is None:
          corrlength = lagtime
      nsample = int(Ltot / corrlength)
  
      # determine number of states n
      n = number_of_states(dtrajs)
  
      # assigning trajectory sampling weights
      w_trajs = np.maximum(0.0, lengths - lagtime)
      w_trajs /= np.sum(w_trajs)  # normalize to sum 1.0
      distrib_trajs = rv_discrete(values=(list(range(ntraj)), w_trajs))
      # sample number of counts from each trajectory
      n_from_traj = np.bincount(distrib_trajs.rvs(size=nsample), minlength=ntraj)
  
      # for each trajectory, sample counts and stack them
      rows = np.zeros((nsample))
      cols = np.zeros((nsample))
      ones = np.ones((nsample))
      ncur = 0
      for i in range(len(n_from_traj)):
          if n_from_traj[i] > 0:
              (r, c) = bootstrap_counts_singletraj(dtrajs[i], lagtime, n_from_traj[i])
              rows[ncur:ncur + n_from_traj[i]] = r
              cols[ncur:ncur + n_from_traj[i]] = c
              ncur += n_from_traj[i]
      # sum over counts
      Csparse = scipy.sparse.coo_matrix((ones, (rows, cols)), shape=(n, n))
  
      return Csparse.tocsr()