docs: def calc_endpoint_from_percentile_abc(model_obj,
                                        init_vals,
                                        percentile,
                                        bias_correction,
                                        acceleration,
                                        std_error,
                                        empirical_influence,
                                        **fit_kwargs):
      """
      Calculates the endpoint of the 1-tailed, (percentile)% confidence interval.
      Note this interval spans from negative infinity to the calculated endpoint.
  
      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.
      init_vals : 1D ndarray.
          The initial values used to estimate the desired choice model.
      percentile : scalar in (0.0, 100.0).
          Denotes the percentile of the standard normal distribution at which
          we'd like to evaluate the inverse cumulative distribution function and
          then convert this standardized value back to our approximate bootstrap
          distribution.
      bias_correction : 1D ndarray of scalars.
          Contains the computed bias correction for the MLE estimates that the
          ABC interval is being computed for.
      acceleration : 1D ndarray of scalars.
          Should contain the ABC intervals' estimated acceleration constants.
      std_error : 1D ndarray.
          Contains the standard error of the MLE estimates for use in the ABC
          confidence intervals.
      empirical_influence : 2D ndarray.
          Should have one row for each observation. Should have one column for
          each parameter in the parameter vector being estimated. Elements should
          denote the empirical influence of the associated observation on the
          associated parameter.
      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
      -------
      endpoint : 1D ndarray.
          Contains the endpoint from our approximate bootstrap distribution's
          1-tailed, upper `percentile` confidence interval.
  
      References
      ----------
      Efron, Bradley, and Robert J. Tibshirani. An Introduction to the Bootstrap.
          CRC press, 1994. Section 22.6, Equation 22.33.
      """
      # Get the bias corrected standard normal value for the relevant percentile.
      # We multiply percentile by 0.01 because the ppf function requires decimals
      # in [0.0, 1.0].
      bias_corrected_z = bias_correction + norm.ppf(percentile * 0.01)
      # Calculate the multiplier for the least favorable direction
      # (i.e. the empirical influence function).
      lam = bias_corrected_z / (1 - acceleration * bias_corrected_z)**2
      multiplier = lam / std_error
      # Calculate the initial weights
      num_obs = empirical_influence.shape[0]
      init_weights_wide = np.ones(num_obs, dtype=float)[:, None] / num_obs
      # Get the necessary weight adjustment term for calculating the endpoint.
      weight_adjustment_wide = (multiplier[None, :] * empirical_influence)
      wide_weights_all_params = init_weights_wide + weight_adjustment_wide
      # Extract the initial weights from the fit kwargs
      new_fit_kwargs = deepcopy(fit_kwargs)
      if fit_kwargs is not None and 'weights' in fit_kwargs:
          orig_weights = fit_kwargs['weights']
          del new_fit_kwargs['weights']
      else:
          orig_weights = np.ones(model_obj.data.shape[0], dtype=float)
      # Make sure we're just getting the point estimate
      new_fit_kwargs['just_point'] = True
      # Get a long format version of the weights needed to compute the endpoints
      long_weights_all_params =\
          (create_long_form_weights(model_obj, wide_weights_all_params) *
           orig_weights[:, None])
      # Initialize the array to store the desired enpoints
      num_params = init_vals.shape[0]
      endpoint = np.empty(num_params, dtype=float)
      # Populate the endpoint array
      for param_id in xrange(num_params):
          current_weights = long_weights_all_params[:, param_id]
          current_estimate = model_obj.fit_mle(init_vals,
                                               weights=current_weights,
                                               **new_fit_kwargs)['x']
          endpoint[param_id] = current_estimate[param_id]
      return endpoint