code: def _sim_prediction(self, lmda, Y, scores, h, t_params, simulations):
               
  
          sim_vector = np.zeros([simulations,h])
  
          for n in range(0,simulations):
              # Create arrays to iteratre over        
              lmda_exp = lmda.copy()
              scores_exp = scores.copy()
              Y_exp = Y.copy()
  
              # Loop over h time periods          
              for t in range(0,h):
                  new_value = t_params[0]
  
                  if self.p != 0:
                      for j in range(1,self.p+1):
                          new_value += t_params[j]*lmda_exp[-j]
  
                  if self.q != 0:
                      for k in range(1,self.q+1):
                          new_value += t_params[k+self.p]*scores_exp[-k]
  
                  if self.leverage is True:
                      new_value += t_params[1+self.p+self.q]*np.sign(-(Y_exp[-1]-t_params[-2]-t_params[-1]*np.exp(lmda_exp[-1]/2.0)))*(scores_exp[-1]+1)
  
                  lmda_exp = np.append(lmda_exp,[new_value]) # For indexing consistency
                  scores_exp = np.append(scores_exp,scores[np.random.randint(scores.shape[0])]) # expectation of score is zero
                  Y_exp = np.append(Y_exp,Y[np.random.randint(Y.shape[0])]) # bootstrap returns
  
              sim_vector[n] = lmda_exp[-h:]
  
          return np.transpose(sim_vector)
docs: Simulates a h-step ahead mean prediction
  
          Parameters
          ----------
          lmda : np.array
              The past predicted values
  
          Y : np.array
              The past data
  
          scores : np.array
              The past scores
  
          h : int
              How many steps ahead for the prediction
  
          t_params : np.array
              A vector of (transformed) latent variables
  
          simulations : int
              How many simulations to perform
  
          Returns
          ----------
          Matrix of simulations