code: def tile(cls, op):
      inp = op.inputs[0]
      out = op.outputs[0]
      if len(inp.chunks) == 1:
          chunk_op = op.copy().reset_key()
          chunk_param = out.params
          chunk_param["index"] = (0, 0)
          chunk = chunk_op.new_chunk(inp.chunks, kws=[chunk_param])
          new_op = op.copy().reset_key()
          param = out.params
          param["chunks"] = [chunk]
          param["nsplits"] = ((np.nan,), (np.nan,))
          return new_op.new_dataframe(op.inputs, kws=[param])
      elif isinstance(inp, SERIES_TYPE):
          unique_inp = yield from recursive_tile(unique(inp))
          chunks = []
          for c in inp.chunks:
              chunk_op = op.copy().reset_key()
              chunk_param = out.params
              chunk_param["index_value"] = gen_unknown_index_value(
                  c.index_value
              )
              chunk_param["index"] = (c.index[0], 0)
              chunk = chunk_op.new_chunk(
                  [c] + unique_inp.chunks, kws=[chunk_param]
              )
              chunks.append(chunk)
  
          new_op = op.copy().reset_key()
          param = out.params
          param["chunks"] = chunks
          param["nsplits"] = (
              tuple([np.nan] * inp.chunk_shape[0]),
              (np.nan,),
          )
          return new_op.new_dataframe(op.inputs, kws=[param])
      else:
          if op.columns:
              encoding_columns = op.columns
          else:
              encoding_columns = []
              for idx, dtype in enumerate(inp.dtypes.values):
                  if dtype.kind in _encoding_dtype_kind:
                      column = inp.dtypes.index[idx]
                      encoding_columns.append(column)
          # reindex, make encoding columns in the end of dataframe, to keep pace with pandas.get_dummies
          total_columns = list(inp.columns.to_pandas().array)
          for col in encoding_columns:
              total_columns.remove(col)
          total_columns.extend(encoding_columns)
          inp = yield from recursive_tile(inp[total_columns])
  
          unique_chunks = dict()
          for col in encoding_columns:
              unique_chunks[col] = yield from recursive_tile(
                  unique(inp[col])
              )
  
          chunks = []
          prefix = op.prefix
          column_to_prefix = dict()
          for c in inp.chunks:
              chunk_op = op.copy().reset_key()
              chunk_op.columns = []
              if isinstance(chunk_op.prefix, list):
                  chunk_op.prefix = []
              chunk_param = c.params
              chunk_param["shape"] = (np.nan, np.nan)
              chunk_columns = c.dtypes.index
              inp_chunk = [c]
              for chunk_column in chunk_columns:
                  if chunk_column in encoding_columns:
                      chunk_op.columns.append(chunk_column)
                      inp_chunk.extend(
                          unique_chunks[chunk_column].chunks
                      )
                      if isinstance(prefix, list):
                          if chunk_column in column_to_prefix.keys():
                              chunk_op.prefix.append(
                                  column_to_prefix[chunk_column]
                              )
                          else:
                              column_to_prefix[chunk_column] = prefix[0]
                              chunk_op.prefix.append(prefix[0])
                              prefix = prefix[1:]
              chunk = chunk_op.new_chunk(inp_chunk, kws=[chunk_param])
              chunks.append(chunk)
  
          new_op = op.copy()
          kw = out.params.copy()
          kw["chunks"] = chunks
          kw["nsplits"] = (
              tuple([np.nan] * inp.chunk_shape[0]),
              tuple([np.nan] * inp.chunk_shape[1]),
          )
          return new_op.new_dataframe(op.inputs, kws=[kw])
  
file_path: mars/mars/dataframe/base/get_dummies.py
imports: import numpy
  import pandas
  from ...core import OutputType, recursive_tile
  from ...serialization.serializables import StringField, BoolField, AnyField, ListField
  from ..core import SERIES_TYPE
  from ..datasource.dataframe import from_pandas
  from ..datasource.series import from_pandas
  from ..initializer import Series
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..reduction.unique import unique
  from ..utils import gen_unknown_index_value
label_desc: Use image node_id 2 for calling the DataFrameGetDummies obj's underlying member method code with example usage: obj.tile(cls, op) and returns: new_op, new_op, new_op