code: def _inter_manager_operations(self, other, how_to_join, func):
          
          reindexed_self, reindexed_other_list, joined_index = self.copartition(
              0, other, how_to_join, False
          )
          # unwrap list returned by `copartition`.
          reindexed_other = reindexed_other_list[0]
          new_columns = self._join_index_objects(
              0, other.columns, how_to_join, sort=False
          )
          # THere is an interesting serialization anomaly that happens if we do
          # not use the columns in `inter_data_op_builder` from here (e.g. if we
          # pass them in). Passing them in can cause problems, so we will just
          # use them from here.
          self_cols = self.columns
          other_cols = other.columns
  
          def inter_data_op_builder(left, right, func):
              left.columns = self_cols
              right.columns = other_cols
              # We reset here to make sure that the internal indexes match. We aligned
              # them in the previous step, so this step is to prevent mismatches.
              left.index = pandas.RangeIndex(len(left.index))
              right.index = pandas.RangeIndex(len(right.index))
              result = func(left, right)
              result.columns = pandas.RangeIndex(len(result.columns))
              return result
  
          new_data = reindexed_self.inter_data_operation(
              1, lambda l, r: inter_data_op_builder(l, r, func), reindexed_other
          )
          return self.__constructor__(new_data, joined_index, new_columns)
docs: Inter-data operations (e.g. add, sub).
  
          Args:
              other: The other Manager for the operation.
              how_to_join: The type of join to join to make (e.g. right, outer).
  
          Returns:
              New DataManager with new data and index.