docs: def fast_ordering(self, structure, num_remove_dict, num_to_return=1):
          """
          This method uses the matrix form of ewaldsum to calculate the ewald
          sums of the potential structures. This is on the order of 4 orders of
          magnitude faster when there are large numbers of permutations to
          consider. There are further optimizations possible (doing a smarter
          search of permutations for example), but this wont make a difference
          until the number of permutations is on the order of 30,000.
          """
          self.logger.debug("Performing fast ordering")
          starttime = time.time()
          self.logger.debug("Performing initial ewald sum...")
  
          ewaldmatrix = EwaldSummation(structure).total_energy_matrix
          self.logger.debug("Ewald sum took {} seconds."
                            .format(time.time() - starttime))
          starttime = time.time()
          m_list = []
          for indices, num in num_remove_dict.items():
              m_list.append([0, num, list(indices), None])
  
          self.logger.debug("Calling EwaldMinimizer...")
          minimizer = EwaldMinimizer(ewaldmatrix, m_list, num_to_return,
                                     PartialRemoveSitesTransformation.ALGO_FAST)
          self.logger.debug("Minimizing Ewald took {} seconds."
                            .format(time.time() - starttime))
  
          all_structures = []
  
          lowest_energy = minimizer.output_lists[0][0]
          num_atoms = sum(structure.composition.values())
  
          for output in minimizer.output_lists:
              s = structure.copy()
              del_indices = []
  
              for manipulation in output[1]:
                  if manipulation[1] is None:
                      del_indices.append(manipulation[0])
                  else:
                      s.replace(manipulation[0], manipulation[1])
              s.remove_sites(del_indices)
              struct = s.get_sorted_structure()
              all_structures.append(
                  {"energy": output[0],
                   "energy_above_minimum": (output[0] - lowest_energy)
                      / num_atoms,
                   "structure": struct})
  
          return all_structures