docs: def _store_generic_inference_results(self,
                                           results_dict,
                                           all_params,
                                           all_names):
          """
          Store the model inference values that are common to all choice models.
          This includes things like index coefficients, gradients, hessians,
          asymptotic covariance matrices, t-values, p-values, and robust versions
          of these values.
  
          Parameters
          ----------
          results_dict : dict.
              The estimation result dictionary that is output from
              scipy.optimize.minimize. In addition to the standard keys which are
              included, it should also contain the following keys:
             `["utility_coefs", "final_gradient", "final_hessian",
               "fisher_info"]`.
              The "final_gradient", "final_hessian", and "fisher_info" values
              should be the gradient, hessian, and Fisher-Information Matrix of
              the log likelihood, evaluated at the final parameter vector.
          all_params : list of 1D ndarrays.
              Should contain the various types of parameters that were actually
              estimated.
          all_names : list of strings.
              Should contain names of each estimated parameter.
  
          Returns
          -------
          None. Stores all results on the model instance.
          """
          # Store the utility coefficients
          self._store_inferential_results(results_dict["utility_coefs"],
                                          index_names=self.ind_var_names,
                                          attribute_name="coefs",
                                          series_name="coefficients")
  
          # Store the gradient
          self._store_inferential_results(results_dict["final_gradient"],
                                          index_names=all_names,
                                          attribute_name="gradient",
                                          series_name="gradient")
  
          # Store the hessian
          self._store_inferential_results(results_dict["final_hessian"],
                                          index_names=all_names,
                                          attribute_name="hessian",
                                          column_names=all_names)
  
          # Store the variance-covariance matrix
          self._store_inferential_results(-1 * scipy.linalg.inv(self.hessian),
                                          index_names=all_names,
                                          attribute_name="cov",
                                          column_names=all_names)
  
          # Store ALL of the estimated parameters
          self._store_inferential_results(np.concatenate(all_params, axis=0),
                                          index_names=all_names,
                                          attribute_name="params",
                                          series_name="parameters")
  
          # Store the standard errors
          self._store_inferential_results(np.sqrt(np.diag(self.cov)),
                                          index_names=all_names,
                                          attribute_name="standard_errors",
                                          series_name="std_err")
  
          # Store the t-stats of the estimated parameters
          self.tvalues = self.params / self.standard_errors
          self.tvalues.name = "t_stats"
  
          # Store the p-values
          p_vals = 2 * scipy.stats.norm.sf(np.abs(self.tvalues))
          self._store_inferential_results(p_vals,
                                          index_names=all_names,
                                          attribute_name="pvalues",
                                          series_name="p_values")
  
          # Store the fischer information matrix of estimated coefficients
          self._store_inferential_results(results_dict["fisher_info"],
                                          index_names=all_names,
                                          attribute_name="fisher_information",
                                          column_names=all_names)
  
          # Store the 'robust' variance-covariance matrix
          robust_covariance = calc_asymptotic_covariance(self.hessian,
                                                         self.fisher_information)
          self._store_inferential_results(robust_covariance,
                                          index_names=all_names,
                                          attribute_name="robust_cov",
                                          column_names=all_names)
  
          # Store the 'robust' standard errors
          self._store_inferential_results(np.sqrt(np.diag(self.robust_cov)),
                                          index_names=all_names,
                                          attribute_name="robust_std_errs",
                                          series_name="robust_std_err")
  
          # Store the 'robust' t-stats of the estimated coefficients
          self.robust_t_stats = self.params / self.robust_std_errs
          self.robust_t_stats.name = "robust_t_stats"
  
          # Store the 'robust' p-values
          one_sided_p_vals = scipy.stats.norm.sf(np.abs(self.robust_t_stats))
          self._store_inferential_results(2 * one_sided_p_vals,
                                          index_names=all_names,
                                          attribute_name="robust_p_vals",
                                          series_name="robust_p_values")
  
          return None