docs: def subsampleCorrelatedData(A_t, g=None, fast=False, conservative=False, verbose=False):
      """Determine the indices of an uncorrelated subsample of the data.
  
      Parameters
      ----------
      A_t : np.ndarray
          A_t[t] is the t-th value of timeseries A(t).  Length is deduced from vector.
      g : float, optional
          if provided, the statistical inefficiency g is used to subsample the timeseries -- otherwise it will be computed (default: None)
      fast : bool, optional, default=False
          fast can be set to True to give a less accurate but very quick estimate (default: False)
      conservative : bool, optional, default=False
          if set to True, uniformly-spaced indices are chosen with interval ceil(g), where
          g is the statistical inefficiency.  Otherwise, indices are chosen non-uniformly with interval of
          approximately g in order to end up with approximately T/g total indices
      verbose : bool, optional, default=False
          if True, some output is printed
  
      Returns
      -------
      indices : list of int
          the indices of an uncorrelated subsample of the data
  
      Notes
      -----
      The statistical inefficiency is computed with the function computeStatisticalInefficiency().
  
      ToDo
      ----
      Instead of using regular stride, use irregular stride so more data can be fit in when g is non-integral.
  
      Examples
      --------
  
      Subsample a correlated timeseries to extract an effectively uncorrelated dataset.
  
      >>> from pymbar import testsystems
      >>> A_t = testsystems.correlated_timeseries_example(N=10000, tau=5.0) # generate a test correlated timeseries
      >>> indices = subsampleCorrelatedData(A_t) # compute indices of uncorrelated timeseries
      >>> A_n = A_t[indices] # extract uncorrelated samples
  
      Extract uncorrelated samples from multiple timeseries data from the same process.
  
      >>> # Generate multiple correlated timeseries data of different lengths.
      >>> T_k = [1000, 2000, 3000, 4000, 5000]
      >>> K = len(T_k) # number of timeseries
      >>> tau = 5.0 # exponential relaxation time
      >>> A_kt = [ testsystems.correlated_timeseries_example(N=T, tau=tau) for T in T_k ] # A_kt[k] is correlated timeseries k
      >>> # Estimate statistical inefficiency from all timeseries data.
      >>> g = statisticalInefficiencyMultiple(A_kt)
      >>> # Count number of uncorrelated samples in each timeseries.
      >>> N_k = np.array([ len(subsampleCorrelatedData(A_t, g=g)) for A_t in A_kt ]) # N_k[k] is the number of uncorrelated samples in timeseries k
      >>> N = N_k.sum() # total number of uncorrelated samples
      >>> # Subsample all trajectories to produce uncorrelated samples
      >>> A_kn = [ A_t[subsampleCorrelatedData(A_t, g=g)] for A_t in A_kt ] # A_kn[k] is uncorrelated subset of trajectory A_kt[t]
      >>> # Concatenate data into one timeseries.
      >>> A_n = np.zeros([N], np.float32) # A_n[n] is nth sample in concatenated set of uncorrelated samples
      >>> A_n[0:N_k[0]] = A_kn[0]
      >>> for k in range(1,K): A_n[N_k[0:k].sum():N_k[0:k+1].sum()] = A_kn[k]
  
      """
  
      # Create np copy of arrays.
      A_t = np.array(A_t)
  
      # Get the length of the timeseries.
      T = A_t.size
  
      # Compute the statistical inefficiency for the timeseries.
      if not g:
          if verbose:
              print("Computing statistical inefficiency...")
          g = statisticalInefficiency(A_t, A_t, fast=fast)
          if verbose:
              print("g = %f" % g)
  
      if conservative:
          # Round g up to determine the stride we can use to pick out regularly-spaced uncorrelated samples.
          stride = int(math.ceil(g))
          if verbose:
              print("conservative subsampling: using stride of %d" % stride)
  
          # Assemble list of indices of uncorrelated snapshots.
          indices = range(0, T, stride)
      else:
          # Choose indices as floor(n*g), with n = 0,1,2,..., until we run out of data.
          indices = []
          n = 0
          while int(round(n * g)) < T:
              t = int(round(n * g))
              # ensure we don't sample the same point twice
              if (n == 0) or (t != indices[n - 1]):
                  indices.append(t)
              n += 1
          if verbose:
              print("standard subsampling: using average stride of %f" % g)
  
      # Number of samples in subsampled timeseries.
      N = len(indices)
  
      if verbose:
          print("The resulting subsampled set has %d samples (original timeseries had %d)." % (N, T))
  
      # Return the list of indices of uncorrelated snapshots.
      return indices