docs: def calc_abc_interval(model_obj,
                        mle_params,
                        init_vals,
                        conf_percentage,
                        epsilon=0.001,
                        **fit_kwargs):
      """
      Calculate 'approximate bootstrap confidence' intervals.
  
      Parameters
      ----------
      model_obj : an instance or sublcass of the MNDC class.
          Should be the model object that corresponds to the model we are
          constructing the bootstrap confidence intervals for.
      mle_params : 1D ndarray.
          Should contain the desired model's maximum likelihood point estimate.
      init_vals : 1D ndarray.
          The initial values used to estimate the desired choice model.
      conf_percentage : scalar in the interval (0.0, 100.0).
          Denotes the confidence-level of the returned confidence interval. For
          instance, to calculate a 95% confidence interval, pass `95`.
      epsilon : positive float, optional.
          Should denote the 'very small' value being used to calculate the
          desired finite difference approximations to the various influence
          functions. Should be close to zero. Default == sys.float_info.epsilon.
      fit_kwargs : additional keyword arguments, optional.
          Should contain any additional kwargs used to alter the default behavior
          of `model_obj.fit_mle` and thereby enforce conformity with how the MLE
          was obtained. Will be passed directly to `model_obj.fit_mle`.
  
      Returns
      -------
      conf_intervals : 2D ndarray.
          The shape of the returned array will be `(2, samples.shape[1])`. The
          first row will correspond to the lower value in the confidence
          interval. The second row will correspond to the upper value in the
          confidence interval. There will be one column for each element of the
          parameter vector being estimated.
  
      References
      ----------
      Efron, Bradley, and Robert J. Tibshirani. An Introduction to the Bootstrap.
          CRC press, 1994. Section 22.6.
      DiCiccio, Thomas J., and Bradley Efron. "Bootstrap confidence intervals."
          Statistical science (1996): 189-212.
      """
      # Check validity of arguments
      check_conf_percentage_validity(conf_percentage)
      # Calculate the empirical influence component and second order empirical
      # influence component for each observation
      empirical_influence, second_order_influence =\
          calc_influence_arrays_for_abc(model_obj,
                                        mle_params,
                                        init_vals,
                                        epsilon,
                                        **fit_kwargs)
      # Calculate the acceleration constant for the ABC interval.
      acceleration = calc_acceleration_abc(empirical_influence)
      # Use the delta method to calculate the standard error of the MLE parameter
      # estimate of the model using the original data.
      std_error = calc_std_error_abc(empirical_influence)
      # Approximate the bias of the MLE parameter estimates.
      bias = calc_bias_abc(second_order_influence)
  
      # Calculate the quadratic coefficient. Note we are using the 'efron'
      # version of the desired function because the direct implementation of the
      # formulas in the textbook don't return the correct results. The 'efron'
      # versions re-implement the calculations from 'abcnon.R' in Efron's
      # 'bootstrap' library in R.
  
      # quadratic_coef = calc_quadratic_coef_abc(model_obj,
      #                                          mle_params,
      #                                          init_vals,
      #                                          empirical_influence,
      #                                          std_error,
      #                                          epsilon,
      #                                          **fit_kwargs)
      quadratic_coef = efron_quadratic_coef_abc(model_obj,
                                                mle_params,
                                                init_vals,
                                                empirical_influence,
                                                std_error,
                                                epsilon,
                                                **fit_kwargs)
  
      # Calculate the total curvature of the level surface of the weight vector,
      # where the set of weights in the surface are those where the weighted MLE
      # equals the original (i.e. the equal-weighted) MLE.
      total_curvature = calc_total_curvature_abc(bias, std_error, quadratic_coef)
      # Calculate the bias correction constant.
      bias_correction = calc_bias_correction_abc(acceleration, total_curvature)
  
      # Calculate the lower limit of the conf_percentage confidence intervals
      # Note we are using the 'efron' version of the desired function because the
      # direct implementation of the formulas in the textbook don't return the
      # correct results. The 'efron' versions re-implement the calculations from
      # 'abcnon.R' in Efron's 'bootstrap' library in R.
  
      # lower_endpoint, upper_endpoint =\
      #     calc_endpoints_for_abc_confidence_interval(conf_percentage,
      #                                                model_obj,
      #                                                init_vals,
      #                                                bias_correction,
      #                                                acceleration,
      #                                                std_error,
      #                                                empirical_influence,
      #                                                **fit_kwargs)
      lower_endpoint, upper_endpoint =\
          efron_endpoints_for_abc_confidence_interval(conf_percentage,
                                                      model_obj,
                                                      init_vals,
                                                      bias_correction,
                                                      acceleration,
                                                      std_error,
                                                      empirical_influence,
                                                      **fit_kwargs)
      # Combine the enpoints into a single ndarray.
      conf_intervals = combine_conf_endpoints(lower_endpoint, upper_endpoint)
      return conf_intervals