scipy.spatial.distance:pdist

Notes

See squareform for information on how to calculate the index of this entry or to convert the condensed distance matrix to a redundant square matrix.

The following are common calling conventions.

• Y = pdist(X, 'euclidean')

  Computes the distance between m points using Euclidean distance (2-norm) as the distance metric between the points. The points are arranged as m n-dimensional row vectors in the matrix X.

• Y = pdist(X, 'minkowski', p=2.)

  Computes the distances using the Minkowski distance $\Vert u-v{\Vert }_p$ ($p$-norm) where $p>0$ (note that this is only a quasi-metric if $0<p<1$).

• Y = pdist(X, 'cityblock')

  Computes the city block or Manhattan distance between the points.

• Y = pdist(X, 'seuclidean', V=None)

  Computes the standardized Euclidean distance. The standardized Euclidean distance between two n-vectors u and v is

  $$\sqrt{\sum (u_i-v_i{)}^2/V[x_i]}$$

  V is the variance vector; V[i] is the variance computed over all the i'th components of the points. If not passed, it is automatically computed.

• Y = pdist(X, 'sqeuclidean')

  Computes the squared Euclidean distance $\Vert u-v{\Vert }_2^2$ between the vectors.

• Y = pdist(X, 'cosine')

  Computes the cosine distance between vectors u and v,

  $$1-\frac{u\cdot v}{{\Vert u\Vert }_2{\Vert v\Vert }_2}$$

  where $\Vert \ast {\Vert }_2$ is the 2-norm of its argument *, and $u\cdot v$ is the dot product of u and v.

• Y = pdist(X, 'correlation')

  Computes the correlation distance between vectors u and v. This is

  $$1-\frac{(u-\bar{u})\cdot (v-\bar{v})}{{\Vert (u-\bar{u})\Vert }_2{\Vert (v-\bar{v})\Vert }_2}$$

  where $\bar{v}$ is the mean of the elements of vector v, and $x\cdot y$ is the dot product of $x$ and $y$.

• Y = pdist(X, 'hamming')

  Computes the normalized Hamming distance, or the proportion of those vector elements between two n-vectors u and v which disagree. To save memory, the matrix X can be of type boolean.

• Y = pdist(X, 'jaccard')

  Computes the Jaccard distance between the points. Given two vectors, u and v, the Jaccard distance is the proportion of those elements u[i] and v[i] that disagree.

• Y = pdist(X, 'jensenshannon')

  Computes the Jensen-Shannon distance between two probability arrays. Given two probability vectors, $p$ and $q$, the Jensen-Shannon distance is

  $$\sqrt{\frac{D(p\parallel m)+D(q\parallel m)}{2}}$$

  where $m$ is the pointwise mean of $p$ and $q$ and $D$ is the Kullback-Leibler divergence.

• Y = pdist(X, 'chebyshev')

  Computes the Chebyshev distance between the points. The Chebyshev distance between two n-vectors u and v is the maximum norm-1 distance between their respective elements. More precisely, the distance is given by

  $$d(u,v)=\underset{i}{\max }|u_i-v_i|$$

• Y = pdist(X, 'canberra')

  Computes the Canberra distance between the points. The Canberra distance between two points u and v is

  $$d(u,v)=\sum _i\frac{|u_i-v_i|}{|u_i|+|v_i|}$$

• Y = pdist(X, 'braycurtis')

  Computes the Bray-Curtis distance between the points. The Bray-Curtis distance between two points u and v is

  $$d(u,v)=\frac{{\sum }_i|u_i-v_i|}{{\sum }_i|u_i+v_i|}$$

• Y = pdist(X, 'mahalanobis', VI=None)

  Computes the Mahalanobis distance between the points. The Mahalanobis distance between two points u and v is $\sqrt{(u-v)(1/V)(u-v{)}^T}$ where $(1/V)$ (the VI variable) is the inverse covariance. If VI is not None, VI will be used as the inverse covariance matrix.

• Y = pdist(X, 'yule')

  Computes the Yule distance between each pair of boolean vectors. (see yule function documentation)

• Y = pdist(X, 'matching')

  Synonym for 'hamming'.

• Y = pdist(X, 'dice')

  Computes the Dice distance between each pair of boolean vectors. (see dice function documentation)

• Y = pdist(X, 'rogerstanimoto')

  Computes the Rogers-Tanimoto distance between each pair of boolean vectors. (see rogerstanimoto function documentation)

• Y = pdist(X, 'russellrao')

  Computes the Russell-Rao distance between each pair of boolean vectors. (see russellrao function documentation)

• Y = pdist(X, 'sokalsneath')

  Computes the Sokal-Sneath distance between each pair of boolean vectors. (see sokalsneath function documentation)

• Y = pdist(X, f)

  Computes the distance between all pairs of vectors in X using the user supplied 2-arity function f. For example, Euclidean distance between the vectors could be computed as follows

  dm = pdist(X, lambda u, v: np.sqrt(((u-v)**2).sum()))

  Note that you should avoid passing a reference to one of the distance functions defined in this library. For example,

  dm = pdist(X, sokalsneath)

  would calculate the pair-wise distances between the vectors in X using the Python function sokalsneath. This would result in sokalsneath being called $\left(\genfrac{}{}{0ex}{}{n}{2}\right)$ times, which is inefficient. Instead, the optimized C version is more efficient, and we call it using the following syntax.

  dm = pdist(X, 'sokalsneath')