class_docstr: Distribution, critical values and p-values from tables
  
  currently only 1 extra parameter, e.g. sample size
  
  Parameters
  ----------
  alpha : array_like, 1d
      probabiliy in the table, could be either sf (right tail) or cdf (left
      tail)
  size : array_like, 1d
      The sample sizes for the table
  crit_table : array_like, 2d
      The sample sizes in the table
      array with critical values for sample size in rows and probability in
      columns
  asymptotic : callable, optional
      Callable function with the form fn(nobs) that returns len(alpha)
      critical values where the critical value in position i corresponds to
      alpha[i]
  min_nobs : int, optional
      Minimum number of observations to use the asymptotic distribution. If
      not provided, uses max(size).
  max_nobs : int, optional
      Maximum number of observations to use the tabular distribution. If not
      provided, uses max(size)
  
  Notes
  -----
  size and alpha must be sorted and increasing.
  
  If both min_nobs and max_nobs are provided, then
  the critical values from the tabular distribution and the asymptotic
  distribution are linearly blended using the formula
  :math:`w cv_a + (1-w) cv_t` where the weight is
  :math:`w = (n - a_{min}) / (a_{max} - a_{min})`. This ensures the
  transition between the tabular and the asymptotic critical values is
  continuous. If these are not provided, then the asymptotic critical value
  is used for nobs > max(size).
code: def __init__(
      self,
      alpha,
      size,
      crit_table,
      asymptotic=None,
      min_nobs=None,
      max_nobs=None,
  ):
      self.alpha = np.asarray(alpha)
      if self.alpha.ndim != 1:
          raise ValueError("alpha is not 1d")
      elif (np.diff(self.alpha) <= 0).any():
          raise ValueError("alpha is not sorted")
      self.size = np.asarray(size)
      if self.size.ndim != 1:
          raise ValueError("size is not 1d")
      elif (np.diff(self.size) <= 0).any():
          raise ValueError("size is not sorted")
      if self.size.ndim == 1:
          if (np.diff(alpha) <= 0).any():
              raise ValueError("alpha is not sorted")
      self.crit_table = np.asarray(crit_table)
      if self.crit_table.shape != (
          self.size.shape[0],
          self.alpha.shape[0],
      ):
          raise ValueError(
              "crit_table must have shape" "(len(size), len(alpha))"
          )
  
      self.n_alpha = len(alpha)
      self.signcrit = np.sign(np.diff(self.crit_table, 1).mean())
      if self.signcrit > 0:  # increasing
          self.critv_bounds = self.crit_table[:, [0, 1]]
      else:
          self.critv_bounds = self.crit_table[:, [1, 0]]
      self.asymptotic = None
      max_size = self.max_size = max(size)
  
      if asymptotic is not None:
          try:
              cv = asymptotic(self.max_size + 1)
          except Exception as exc:
              raise type(exc)(
                  "Calling asymptotic(self.size+1) failed. The "
                  "error message was:"
                  "\n\n{err_msg}".format(err_msg=exc.args[0])
              )
          if len(cv) != len(alpha):
              raise ValueError(
                  "asymptotic does not return len(alpha) " "values"
              )
          self.asymptotic = asymptotic
  
      self.min_nobs = max_size if min_nobs is None else min_nobs
      self.max_nobs = max_size if max_nobs is None else max_nobs
      if self.min_nobs > max_size:
          raise ValueError("min_nobs > max(size)")
      if self.max_nobs > max_size:
          raise ValueError("max_nobs > max(size)")
  
file_path: statsmodels/statsmodels/stats/tabledist.py
imports: import numpy
  from scipy.interpolate import interp1d, interp2d, Rbf
  from statsmodels.tools.decorators import cache_readonly
label_desc: Use image node_id 1 to create a new TableDist object  with example: obj = TableDist(alpha, size, crit_table, asymptotic, min_nobs, max_nobs)