code: def prune_tour(self, tour, cpus):
          
          while True:
              tour_score, = self.evaluate_tour_M(tour)
              logging.debug("Starting score: {}".format(tour_score))
              active_sizes = self.active_sizes
              M = self.M
              args = []
              for i, t in enumerate(tour):
                  stour = tour[:i] + tour[i + 1:]
                  args.append((t, stour, tour_score, active_sizes, M))
  
              # Parallel run
              p = Pool(processes=cpus)
              results = list(p.imap(prune_tour_worker, args))
              assert len(tour) == len(results), \
                  "Array size mismatch, tour({}) != results({})"\
                  .format(len(tour), len(results))
  
              # Identify outliers
              active_contigs = self.active_contigs
              idx, log10deltas = zip(*results)
              lb, ub = outlier_cutoff(log10deltas)
              logging.debug("Log10(delta_score) ~ [{}, {}]".format(lb, ub))
  
              remove = set(active_contigs[x] for (x, d) in results if d < lb)
              self.active -= remove
              self.report_active()
  
              tig_to_idx = self.tig_to_idx
              tour = [active_contigs[x] for x in tour]
              tour = array.array('i', [tig_to_idx[x] for x in tour
                                       if x not in remove])
              if not remove:
                  break
  
          self.tour = tour
          self.flip_all(tour)
  
          return tour
docs: Test deleting each contig and check the delta_score; tour here must
          be an array of ints.