docs: def cov_params(self, r_matrix=None, column=None, scale=None, cov_p=None,
                     other=None):
          """
          Returns the variance/covariance matrix.
          The variance/covariance matrix can be of a linear contrast
          of the estimates of params or all params multiplied by scale which
          will usually be an estimate of sigma^2.  Scale is assumed to be
          a scalar.
          Parameters
          ----------
          r_matrix : array-like
              Can be 1d, or 2d.  Can be used alone or with other.
          column :  array-like, optional
              Must be used on its own.  Can be 0d or 1d see below.
          scale : float, optional
              Can be specified or not.  Default is None, which means that
              the scale argument is taken from the model.
          other : array-like, optional
              Can be used when r_matrix is specified.
          Returns
          -------
          cov : ndarray
              covariance matrix of the parameter estimates or of linear
              combination of parameter estimates. See Notes.
          Notes
          -----
          (The below are assumed to be in matrix notation.)
          If no argument is specified returns the covariance matrix of a model
          ``(scale)*(X.T X)^(-1)``
          If contrast is specified it pre and post-multiplies as follows
          ``(scale) * r_matrix (X.T X)^(-1) r_matrix.T``
          If contrast and other are specified returns
          ``(scale) * r_matrix (X.T X)^(-1) other.T``
          If column is specified returns
          ``(scale) * (X.T X)^(-1)[column,column]`` if column is 0d
          OR
          ``(scale) * (X.T X)^(-1)[column][:,column]`` if column is 1d
          """
          if (hasattr(self, 'mle_settings') and
                  self.mle_settings['optimizer'] in ['l1', 'l1_cvxopt_cp']):
              dot_fun = nan_dot
          else:
              dot_fun = np.dot
  
          if (cov_p is None and self.normalized_cov_params is None and
                  not hasattr(self, 'cov_params_default')):
              raise ValueError('need covariance of parameters for computing '
                               '(unnormalized) covariances')
          if column is not None and (r_matrix is not None or other is not None):
              raise ValueError('Column should be specified without other '
                               'arguments.')
          if other is not None and r_matrix is None:
              raise ValueError('other can only be specified with r_matrix')
  
          if cov_p is None:
              if hasattr(self, 'cov_params_default'):
                  cov_p = self.cov_params_default
              else:
                  if scale is None:
                      scale = self.scale
                  cov_p = self.normalized_cov_params * scale
  
          if column is not None:
              column = np.asarray(column)
              if column.shape == ():
                  return cov_p[column, column]
              else:
                  # return cov_p[column][:, column]
                  return cov_p[column[:, None], column]
          elif r_matrix is not None:
              r_matrix = np.asarray(r_matrix)
              if r_matrix.shape == ():
                  raise ValueError("r_matrix should be 1d or 2d")
              if other is None:
                  other = r_matrix
              else:
                  other = np.asarray(other)
              tmp = dot_fun(r_matrix, dot_fun(cov_p, np.transpose(other)))
              return tmp
          else:  # if r_matrix is None and column is None:
              return cov_p