docs: def effective_count_matrix(dtrajs, lag, average='row', 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-iterables
          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).
      mact : float, default=1.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 inefficiencies of sliding window transition counts
  
      References
      ----------
      .. [1] Noe, F. and H. Wu: in preparation (2015)
  
      """
  
      dtrajs = _ensure_dtraj_list(dtrajs)
      import os
      # enforce one job on windows.
      if os.name == 'nt':
          n_jobs = 1
      return sparse.effective_counts.effective_count_matrix(dtrajs, lag, average=average, mact=mact, n_jobs=n_jobs, callback=callback)