code: def tile(cls, op):
      X, Y = op.x, op.y
      out = op.outputs[0]
  
      if X.dtype == np.float32:
          if has_unknown_shape(X, Y):
              yield
          # rechunk
          new_nsplit = max(max(X.nsplits[0]) // 2, 1)
          X = yield from recursive_tile(
              X.rechunk({0: new_nsplit}).astype(np.float64)
          )
          if Y is not X:
              new_nsplit = max(max(Y.nsplits[0]) // 2, 1)
              Y = yield from recursive_tile(
                  Y.rechunk({0: new_nsplit}).astype(np.float64)
              )
  
      XX = op.x_norm_squared
      if XX is None:
          XX = row_norms(X, squared=True)[:, np.newaxis]
      YY = op.y_norm_squared
      if YY is None:
          YY = row_norms(Y, squared=True)[np.newaxis, :]
  
      X, Y = yield from cls._adjust_chunk_sizes(op, X, Y, out)
  
      distances = -2 * X.dot(Y.T)
      if distances.issparse():
          distances = distances.todense()
      distances += XX
      distances += YY
      distances = mt.maximum(distances, 0)
  
      if X is Y or X.key == Y.key:
          mt.fill_diagonal(distances, 0)
  
      distances = distances if op.squared else mt.sqrt(distances)
      distances = distances.astype(out.dtype, copy=False)
      return [(yield from recursive_tile(distances))]
  
imports: import numpy
  from ....None import opcodes
  from ....None import tensor
  from ....config import options
  from ....core import recursive_tile
  from ....serialization.serializables import KeyField, BoolField
  from ....tensor.core import TensorOrder
  from ....utils import has_unknown_shape
  from ...utils import check_array
  from ...utils.extmath import row_norms
  from .core import PairwiseDistances
label_desc: Use image node_id 9 for calling the EuclideanDistances obj's underlying member method code with example usage: obj.tile(cls, op) and returns: list