docs: def effective_count_matrix(dtrajs, lag, average='row', truncate_acf=True, mact=1.0, n_jobs=1, callback=None):
      r""" Computes the statistically effective transition count matrix
  
      Given a list of discrete trajectories, compute the effective number of statistically uncorrelated transition
      counts at the given lag time. First computes the full sliding-window counts :math:`c_{ij}(tau)`. Then uses
      :func:`statistical_inefficiencies` to compute statistical inefficiencies :math:`I_{ij}(tau)`. The number of
      effective counts in a row is then computed as
  
      .. math:
          c_i^{\mathrm{eff}}(tau) = \sum_j I_{ij}(tau) c_{ij}(tau)
  
      and the effective transition counts are obtained by scaling the rows accordingly:
  
      .. math:
          c_{ij}^{\mathrm{eff}}(tau) = \frac{c_i^{\mathrm{eff}}(tau)}{c_i(tau)} c_{ij}(tau)
  
      This procedure is not yet published, but a manuscript is in preparation [1]_.
  
      Parameters
      ----------
      dtrajs : list of int-ndarrays
          discrete trajectories
      lag : int
          lag time
      average : str, default='row'
          Use either of 'row', 'all', 'none', with the following consequences:
          'none': the statistical inefficiency is applied separately to each
              transition count (not recommended)
          'row': the statistical inefficiency is averaged (weighted) by row
              (recommended).
          'all': the statistical inefficiency is averaged (weighted) over all
              transition counts (not recommended).
      truncate_acf : bool, optional, default=True
          Mode of estimating the autocorrelation time of transition counts.
          True: When the normalized autocorrelation function passes through 0,
          it is truncated in order to avoid integrating random noise. This
          tends to lead to a slight underestimate of the autocorrelation time
      mact : float, default=2.0
          multiplier for the autocorrelation time. We tend to underestimate the
          autocorrelation time (and thus overestimate effective counts)
          because the autocorrelation function is truncated when it passes
          through 0 in order to avoid numerical instabilities.
          This is a purely heuristic factor trying to compensate this effect.
          This parameter might be removed in the future when a more robust
          estimation method of the autocorrelation time is used.
  
      n_jobs: int, default=1
          If greater one, the function will be evaluated with multiple processes.
  
      callback: callable, default=None
          will be called for every statistical inefficiency computed (number of nonzero elements in count matrix).
          If n_jobs is greater one, the callback will be invoked per finished batch.
  
      See also
      --------
      statistical_inefficiencies
          is used for computing the statistical inefficiences of sliding window
          transition counts
  
      References
      ----------
      .. [1] Noe, F. and H. Wu: in preparation (2015)
  
      """
      # observed C
      C = count_matrix_coo2_mult(dtrajs, lag, sliding=True, sparse=True)
      # statistical inefficiencies
      si = statistical_inefficiencies(dtrajs, lag, C=C, truncate_acf=truncate_acf, mact=mact,
                                      n_jobs=n_jobs, callback=callback)
      # effective element-wise counts
      Ceff = C.multiply(si)
      # averaging
      if average.lower() == 'row':
          # reduction factor by row
          factor = np.array(Ceff.sum(axis=1) / np.maximum(1.0, C.sum(axis=1)))
          # row-based effective counts
          Ceff = scipy.sparse.csr_matrix(C.multiply(factor))
      elif average.lower() == 'all':
          # reduction factor by all
          factor = Ceff.sum() / C.sum()
          Ceff = scipy.sparse.csr_matrix(C.multiply(factor))
      # else: by element, we're done.
  
      return Ceff