docs: def epsilon_lexicase(self, F, sizes, num_selections=None, survival = False):
          """conducts epsilon lexicase selection for de-aggregated fitness vectors"""
          # pdb.set_trace()
          if num_selections is None:
                  num_selections = F.shape[0]
  
          if self.c: # use c library
              # define c types
              locs = np.empty(num_selections,dtype='int32',order='F')
              # self.lib.epsilon_lexicase(F,F.shape[0],F.shape[1],num_selections,locs)
              if self.lex_size:
                  ep_lex(F,F.shape[0],F.shape[1],num_selections,locs,self.lex_size,np.array(sizes))
              else:
                  ep_lex(F,F.shape[0],F.shape[1],num_selections,locs,self.lex_size,np.array([]))
              return locs
          else: # use python version
              
              locs = []
              individual_locs = np.arange(F.shape[0])
              # calculate epsilon thresholds based on median absolute deviation (MAD)
              mad_for_case = np.array([self.mad(f) for f in F.transpose()])
              for i in np.arange(num_selections):
  
                  can_locs = individual_locs
                  cases = list(np.arange(F.shape[1]))
                  self.random_state.shuffle(cases)
                  # pdb.set_trace()
                  while len(cases) > 0 and len(can_locs) > 1:
                      # get best fitness for case among candidates
                      best_val_for_case = np.min(F[can_locs,cases[0]])
                      # filter individuals without an elite fitness on this case
                      can_locs = [l for l in can_locs if F[l,cases[0]] <= best_val_for_case + mad_for_case[cases[0]]]
                      cases.pop(0)
  
                  choice = self.random_state.randint(len(can_locs))
                  locs.append(can_locs[choice])
                  if survival: # filter out winners from remaining selection pool
                      individual_locs = [i for i in individual_locs if i != can_locs[choice]]
  
              while len(locs) < num_selections:
                  locs.append(individual_locs[0])
  
              return locs