docs: def generate_jackknife_replicates(self,
                                        mnl_obj=None,
                                        mnl_init_vals=None,
                                        mnl_fit_kwargs=None,
                                        extract_init_vals=None,
                                        print_res=False,
                                        method="BFGS",
                                        loss_tol=1e-06,
                                        gradient_tol=1e-06,
                                        maxiter=1000,
                                        ridge=None,
                                        constrained_pos=None):
          """
          Generates the jackknife replicates for one's given model and dataset.
  
          Parameters
          ----------
          mnl_obj : an instance of pylogit.MNL or None, optional.
              Should be the MNL model object that is used to provide starting
              values for the final model being estimated. If None, then one's
              final model should be an MNL model. Default == None.
          mnl_init_vals : 1D ndarray or None, optional.
              If the model that is being estimated is not an MNL, then
              `mnl_init_val` should be passed. Should contain the values used to
              begin the estimation process for the MNL model that is used to
              provide starting values for our desired model. Default == None.
          mnl_fit_kwargs : dict or None.
              If the model that is being estimated is not an MNL, then
              `mnl_fit_kwargs` should be passed.
          extract_init_vals : callable or None, optional.
              Should accept 3 arguments, in the following order. First, it should
              accept `orig_model_obj`. Second, it should accept a pandas Series
              of estimated parameters from the MNL model. The Series' index will
              be the names of the coefficients from `mnl_names`. Thirdly, it
              should accept an int denoting the number of parameters in the final
              choice model. The callable should return a 1D ndarray of starting
              values for the final choice model. Default == None.
          print_res : bool, optional.
              Determines whether the timing and initial and final log likelihood
              results will be printed as they they are determined.
              Default `== True`.
          method : str, optional.
              Should be a valid string for scipy.optimize.minimize. Determines
              the optimization algorithm that is used for this problem.
              Default `== 'bfgs'`.
          loss_tol : float, optional.
              Determines the tolerance on the difference in objective function
              values from one iteration to the next that is needed to determine
              convergence. Default `== 1e-06`.
          gradient_tol : float, optional.
              Determines the tolerance on the difference in gradient values from
              one iteration to the next which is needed to determine convergence.
              Default `== 1e-06`.
          maxiter : int, optional.
              Determines the maximum number of iterations used by the optimizer.
              Default `== 1000`.
          ridge : int, float, long, or None, optional.
              Determines whether or not ridge regression is performed. If a
              scalar is passed, then that scalar determines the ridge penalty for
              the optimization. The scalar should be greater than or equal to
              zero. Default `== None`.
          constrained_pos : list or None, optional.
              Denotes the positions of the array of estimated parameters that are
              not to change from their initial values. If a list is passed, the
              elements are to be integers where no such integer is greater than
              `init_vals.size.` Default == None.
  
          Returns
          -------
          None. Will store the bootstrap replicates on the
          `self.bootstrap_replicates` attribute.
          """
          print("Generating Jackknife Replicates")
          print(time.strftime("%a %m-%d-%Y %I:%M%p"))
          sys.stdout.flush()
          # Take note of the observation id column that is to be used
          obs_id_col = self.model_obj.obs_id_col
  
          # Get the array of original observation ids
          orig_obs_id_array =\
              self.model_obj.data[obs_id_col].values
  
          # Get an array of the unique observation ids.
          unique_obs_ids = np.sort(np.unique(orig_obs_id_array))
  
          # Determine how many observations are in one's dataset.
          num_obs = unique_obs_ids.size
          # Determine how many parameters are being estimated.
          num_params = self.mle_params.size
  
          # Get keyword arguments for final model estimation with new data.
          fit_kwargs = {"print_res": print_res,
                        "method": method,
                        "loss_tol": loss_tol,
                        "gradient_tol": gradient_tol,
                        "maxiter": maxiter,
                        "ridge": ridge,
                        "constrained_pos": constrained_pos,
                        "just_point": True}
  
          # Get the specification and name dictionary of the MNL model.
          mnl_spec = None if mnl_obj is None else mnl_obj.specification
          mnl_names = None if mnl_obj is None else mnl_obj.name_spec
  
          # Initialize the array of jackknife replicates
          point_replicates = np.empty((num_obs, num_params), dtype=float)
  
          # Create an iterable for iteration
          iterable_for_iteration = PROGRESS(enumerate(unique_obs_ids),
                                            desc="Creating Jackknife Replicates",
                                            total=unique_obs_ids.size)
  
          # Populate the array of jackknife replicates
          for pos, obs_id in iterable_for_iteration:
              # Create the dataframe without the current observation
              new_df = self.model_obj.data.loc[orig_obs_id_array != obs_id]
              # Get the point estimate for this new dataset
              current_results =\
                  retrieve_point_est(self.model_obj,
                                     new_df,
                                     obs_id_col,
                                     num_params,
                                     mnl_spec,
                                     mnl_names,
                                     mnl_init_vals,
                                     mnl_fit_kwargs,
                                     extract_init_vals=extract_init_vals,
                                     **fit_kwargs)
              # Store the estimated parameters
              point_replicates[pos] = current_results['x']
  
          # Store the jackknife replicates as a pandas dataframe
          self.jackknife_replicates =\
              pd.DataFrame(point_replicates, columns=self.mle_params.index)
          # Print a 'finished' message for users
          print("Finished Generating Jackknife Replicates")
          print(time.strftime("%a %m-%d-%Y %I:%M%p"))
          return None