code: def euclidean_distances(
      X, Y=None, Y_norm_squared=None, squared=False, X_norm_squared=None
  ):
      """
      Considering the rows of X (and Y=X) as vectors, compute the
      distance matrix between each pair of vectors.
  
      For efficiency reasons, the euclidean distance between a pair of row
      vector x and y is computed as::
  
          dist(x, y) = sqrt(dot(x, x) - 2 * dot(x, y) + dot(y, y))
  
      This formulation has two advantages over other ways of computing distances.
      First, it is computationally efficient when dealing with sparse data.
      Second, if one argument varies but the other remains unchanged, then
      `dot(x, x)` and/or `dot(y, y)` can be pre-computed.
  
      However, this is not the most precise way of doing this computation, and
      the distance matrix returned by this function may not be exactly
      symmetric as required by, e.g., ``scipy.spatial.distance`` functions.
  
      Read more in the :ref:`User Guide <metrics>`.
  
      Parameters
      ----------
      X : {array-like, sparse matrix}, shape (n_samples_1, n_features)
  
      Y : {array-like, sparse matrix}, shape (n_samples_2, n_features)
  
      Y_norm_squared : array-like, shape (n_samples_2, ), optional
          Pre-computed dot-products of vectors in Y (e.g.,
          ``(Y**2).sum(axis=1)``)
  
      squared : boolean, optional
          Return squared Euclidean distances.
  
      X_norm_squared : array-like, shape = [n_samples_1], optional
          Pre-computed dot-products of vectors in X (e.g.,
          ``(X**2).sum(axis=1)``)
  
      Returns
      -------
      distances : {array, sparse matrix}, shape (n_samples_1, n_samples_2)
  
      Examples
      --------
      >>> from sklearn.metrics.pairwise import euclidean_distances
      >>> X = [[0, 1], [1, 1]]
      >>> # distance between rows of X
      >>> euclidean_distances(X, X)
      array([[ 0.,  1.],
             [ 1.,  0.]])
      >>> # get distance to origin
      >>> euclidean_distances(X, [[0, 0]])
      array([[ 1.        ],
             [ 1.41421356]])
  
      See also
      --------
      paired_distances : distances betweens pairs of elements of X and Y.
      """
      X, Y = check_pairwise_arrays(X, Y)
  
      if X_norm_squared is not None:
          XX = check_array(X_norm_squared)
          if XX.shape == (1, X.shape[0]):
              XX = XX.T
          elif XX.shape != (X.shape[0], 1):
              raise ValueError(
                  "Incompatible dimensions for X and X_norm_squared"
              )
      else:
          XX = row_norms(X, squared=True)[:, np.newaxis]
  
      if (
          X is Y
      ):  # shortcut in the common case euclidean_distances(X, X)
          YY = XX.T
      elif Y_norm_squared is not None:
          YY = np.atleast_2d(Y_norm_squared)
  
          if YY.shape != (1, Y.shape[0]):
              raise ValueError(
                  "Incompatible dimensions for Y and Y_norm_squared"
              )
      else:
          YY = row_norms(Y, squared=True)[np.newaxis, :]
  
      distances = safe_sparse_dot(X, Y.T, dense_output=True)
      distances *= -2
      distances += XX
      distances += YY
      np.maximum(distances, 0, out=distances)
  
      if X is Y:
          # Ensure that distances between vectors and themselves are set to 0.0.
          # This may not be the case due to floating point rounding errors.
          distances.flat[:: distances.shape[0] + 1] = 0.0
  
      return distances if squared else np.sqrt(distances, out=distances)
  
imports: import itertools
  import numpy
  from scipy.spatial import distance
  from scipy.sparse import csr_matrix
  from scipy.sparse import issparse
  from ..utils import check_array
  from ..utils import gen_even_slices
  from ..utils import gen_batches
  from ..utils.fixes import partial
  from ..utils.extmath import row_norms, safe_sparse_dot
  from ..preprocessing import normalize
  from ..externals.joblib import Parallel
  from ..externals.joblib import delayed
  from ..externals.joblib import cpu_count
  from .pairwise_fast import _chi2_kernel_fast, _sparse_manhattan
label_desc: Use image node_id 4 for calling a global function with example usage: euclidean_distances(X, Y, Y_norm_squared, squared, X_norm_squared) and returns: unknown