docs: def apply_transformation(self, structure, return_ranked_list=False):
          """
          Apply the transformation.
  
          Args:
              structure: input structure
              return_ranked_list (bool): Whether or not multiple structures are
                  returned. If return_ranked_list is a number, that number of
                  structures is returned.
  
          Returns:
              Depending on returned_ranked list, either a transformed structure
              or a list of dictionaries, where each dictionary is of the form
              {"structure" = .... , "other_arguments"}
              the key "transformation" is reserved for the transformation that
              was actually applied to the structure.
              This transformation is parsed by the alchemy classes for generating
              a more specific transformation history. Any other information will
              be stored in the transformation_parameters dictionary in the
              transmuted structure class.
          """
          num_remove_dict = {}
          total_combis = 0
          for indices, frac in zip(self.indices, self.fractions):
              num_to_remove = len(indices) * frac
              if abs(num_to_remove - int(round(num_to_remove))) > 1e-3:
                  raise ValueError("Fraction to remove must be consistent with "
                                   "integer amounts in structure.")
              else:
                  num_to_remove = int(round(num_to_remove))
              num_remove_dict[tuple(indices)] = num_to_remove
              n = len(indices)
              total_combis += int(round(math.factorial(n) /
                                        math.factorial(num_to_remove) /
                                        math.factorial(n - num_to_remove)))
  
          self.logger.debug("Total combinations = {}".format(total_combis))
  
          try:
              num_to_return = int(return_ranked_list)
          except ValueError:
              num_to_return = 1
  
          num_to_return = max(1, num_to_return)
          self.logger.debug("Will return {} best structures."
                            .format(num_to_return))
  
          if self.algo == PartialRemoveSitesTransformation.ALGO_FAST:
              all_structures = self.fast_ordering(structure, num_remove_dict,
                                                  num_to_return)
          elif self.algo == PartialRemoveSitesTransformation.ALGO_COMPLETE:
              all_structures = self.complete_ordering(structure, num_remove_dict)
          elif self.algo == PartialRemoveSitesTransformation.ALGO_BEST_FIRST:
              all_structures = self.best_first_ordering(structure,
                                                        num_remove_dict)
          elif self.algo == PartialRemoveSitesTransformation.ALGO_ENUMERATE:
              all_structures = self.enumerate_ordering(structure)
          else:
              raise ValueError("Invalid algo.")
  
          opt_s = all_structures[0]["structure"]
          return opt_s if not return_ranked_list \
              else all_structures[0:num_to_return]