docs: def reindex_similar(self, other, n_sphere=4):
          """Reindex ``other`` to be similarly indexed as ``self``.
  
          Returns a reindexed copy of ``other`` that minimizes the
          distance for each atom to itself in the same chemical environemt
          from ``self`` to ``other``.
          Read more about the definition of the chemical environment in
          :func:`Cartesian.partition_chem_env`
  
          .. note:: It is necessary to align ``self`` and other before
              applying this method.
              This can be done via :meth:`~Cartesian.align`.
  
          .. note:: It is probably necessary to improve the result using
              :meth:`~Cartesian.change_numbering()`.
  
          Args:
              other (Cartesian):
              n_sphere (int): Wrapper around the argument for
                  :meth:`~Cartesian.partition_chem_env`.
  
          Returns:
              Cartesian: Reindexed version of other
          """
          def make_subset_similar(m1, subset1, m2, subset2, index_dct):
              """Changes index_dct INPLACE"""
              coords = ['x', 'y', 'z']
              index1 = list(subset1)
              for m1_i in index1:
                  dist_m2_to_m1_i = m2.get_distance_to(m1.loc[m1_i, coords],
                                                       subset2, sort=True)
  
                  m2_i = dist_m2_to_m1_i.index[0]
                  dist_new = dist_m2_to_m1_i.loc[m2_i, 'distance']
                  m2_pos_i = dist_m2_to_m1_i.loc[m2_i, coords]
  
                  counter = itertools.count()
                  found = False
                  while not found:
                      if m2_i in index_dct.keys():
                          old_m1_pos = m1.loc[index_dct[m2_i], coords]
                          if dist_new < np.linalg.norm(m2_pos_i - old_m1_pos):
                              index1.append(index_dct[m2_i])
                              index_dct[m2_i] = m1_i
                              found = True
                          else:
                              m2_i = dist_m2_to_m1_i.index[next(counter)]
                              dist_new = dist_m2_to_m1_i.loc[m2_i, 'distance']
                              m2_pos_i = dist_m2_to_m1_i.loc[m2_i, coords]
                      else:
                          index_dct[m2_i] = m1_i
                          found = True
              return index_dct
  
          molecule1 = self.copy()
          molecule2 = other.copy()
  
          partition1 = molecule1.partition_chem_env(n_sphere)
          partition2 = molecule2.partition_chem_env(n_sphere)
  
          index_dct = {}
          for key in partition1:
              message = ('You have chemically different molecules, regarding '
                         'the topology of their connectivity.')
              assert len(partition1[key]) == len(partition2[key]), message
              index_dct = make_subset_similar(molecule1, partition1[key],
                                              molecule2, partition2[key],
                                              index_dct)
          molecule2.index = [index_dct[i] for i in molecule2.index]
          return molecule2.loc[molecule1.index]