docs: def store_fit_results(self, results_dict):
          """
          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:
             `["final_gradient", "final_hessian", "fisher_info",
               "final_log_likelihood", "chosen_probs", "long_probs", "residuals",
               "ind_chi_squareds"]`.
              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.
  
          Returns
          -------
          None. Will calculate and store a variety of estimation results and
          inferential statistics as attributes of the model instance.
          """
          # Check to make sure the results_dict has all the needed keys.
          self._check_result_dict_for_needed_keys(results_dict)
  
          # Store the basic estimation results that simply need to be transferred
          # from the results_dict to the model instance.
          self._store_basic_estimation_results(results_dict)
  
          # Account for attributes from the mixed logit model.
          if not hasattr(self, "design_3d"):
              self.design_3d = None
  
          # Initialize the lists of all parameter names and all parameter values
          # Note we add the new mixing variables to the list of index
          # coefficients after estimation so that we can correctly create the
          # design matrix during the estimation proces. The create_design_3d
          # function relies on the original list of independent variable names.
          self._add_mixing_variable_names_to_individual_vars()
          all_names = deepcopy(self.ind_var_names)
          all_params = [deepcopy(results_dict["utility_coefs"])]
  
          ##########
          # Figure out whether this model had nest, shape, or intercept
          # parameters and store each of these appropriately
          ##########
          if results_dict["intercept_params"] is not None:
              storage_args = [results_dict["intercept_params"],
                              "intercept_names",
                              "Outside_ASC_{}",
                              all_names,
                              all_params,
                              "intercepts",
                              "intercept_parameters"]
              storage_results = self._store_optional_parameters(*storage_args)
              all_names, all_params = storage_results
          else:
              self.intercepts = None
  
          if results_dict["shape_params"] is not None:
              storage_args = [results_dict["shape_params"],
                              "shape_names",
                              "Shape_{}",
                              all_names,
                              all_params,
                              "shapes",
                              "shape_parameters"]
              storage_results = self._store_optional_parameters(*storage_args)
              all_names, all_params = storage_results
          else:
              self.shapes = None
  
          if results_dict["nest_params"] is not None:
              storage_args = [results_dict["nest_params"],
                              "nest_names",
                              "Nest_Param_{}",
                              all_names,
                              all_params,
                              "nests",
                              "nest_parameters"]
              storage_results = self._store_optional_parameters(*storage_args)
              all_names, all_params = storage_results
          else:
              self.nests = None
  
          # Store the model results and values needed for model inference
          self._store_generic_inference_results(results_dict,
                                                all_params,
                                                all_names)
  
          # Adjust the inferential results to account for parameters that were
          # not actually estimated, i.e. parameters that were constrained.
          constraints = results_dict["constrained_pos"]
          self._adjust_inferential_results_for_parameter_constraints(constraints)
  
          # Store a summary dataframe of the estimation results
          self._create_results_summary()
  
          # Record values for the fit_summary and statsmodels table
          self._record_values_for_fit_summary_and_statsmodels()
  
          # Store a "Fit Summary"
          self._create_fit_summary()
  
          return None