(ph~ Sr/SQrSSKrSSKrSSKrSSKrSSKJr SSK J r SSK J r J r SSKJr SS KJr SS KJr S S KJr S S KJr SSKJr SrSrSrSrSwSjrSwSjrSrSrSr Sr!Sr"Sr#Sr$SwSjr%\RL4Sjr'\ "SS SS 9SxS!j5r(SyS"jr)SwS#jr*SwS$jr+SzS&jr,SwS'jr-SwS(jr.SwS)jr/\"S*5r0\0SS+.S,j5r1S-r2SwS.jr3S/r4SwS0jr5SwS1jr6SwS2jr7SwSSS3.S4jjr8SwS5jr9SwS6jr:SwS7jr;SwS8jr<\"S95r=\=SwS:j5r>SwS;jr?\ "\\RLS<9r@\ "\\AS<9rB\\lC\\lD\R"S%S=9"S>S?55rF\R"S%S=9"S@SA55rG\R"S%S=9"SBSC55rH\H"SDSD1\6\R\RSE9\H"SFSF1\7\R\RSE9\H"SG1SHk\5\R\RSE9\H"SI1SJk\3\R\RSE9\H"SKSKSL1\,\F"SK5\G"SK5SE9\H"SMSMSN1\-\F"SM5\G"SM5SE9\H"SOSO1SP/\:\R\RSQ9\H"SR1SSk\*\R\RSE9\H"ST1SUkSVSP/\ \.\R\RSW9\H"SX1SYkSVSP/\/\R\RSQ9\H"SZSZS[1\8\F"SZ5\G"SZ5SE9\H"S\S\1SP/\1\0"\R5\0"\R5SQ9\H"S]1S^k\!\4\F"S]5\G"S]5S_9\H"S`1Sak\"\)\R\RS_9\H"SbSb1SP/\;\R\RSQ9\H"ScSc1SP/\<\R\RSQ9\H"Sd1Sek\$\2\F"Sd5\G"Sd5S_9\H"SfSf1SP/\>\="\R5\="\R5SQ9\H"SgSg1SP/\?\R\RSQ9\H"Sh1Sik\+\R\RSE9\H"SjSj1SP/\9\R\RSQ9/ri\iVs0sHoRU_M snrk\iVVs0sHnURHnX_M M snnrm\n"\kR55rp\iVs0sHnSkUR-U_M snrqS{SSl.SmjjrrS|SnjrsS}SojrtS~SpjruSqrvSrrwSsrxStrySurzS{SSl.Svjjr{gs snfs snnfs snf)al Distance computations (:mod:`scipy.spatial.distance`) ===================================================== .. sectionauthor:: Damian Eads Function reference ------------------ Distance matrix computation from a collection of raw observation vectors stored in a rectangular array. .. autosummary:: :toctree: generated/ pdist -- pairwise distances between observation vectors. cdist -- distances between two collections of observation vectors squareform -- convert distance matrix to a condensed one and vice versa directed_hausdorff -- directed Hausdorff distance between arrays Predicates for checking the validity of distance matrices, both condensed and redundant. Also contained in this module are functions for computing the number of observations in a distance matrix. .. autosummary:: :toctree: generated/ is_valid_dm -- checks for a valid distance matrix is_valid_y -- checks for a valid condensed distance matrix num_obs_dm -- # of observations in a distance matrix num_obs_y -- # of observations in a condensed distance matrix Distance functions between two numeric vectors ``u`` and ``v``. Computing distances over a large collection of vectors is inefficient for these functions. Use ``pdist`` for this purpose. .. autosummary:: :toctree: generated/ braycurtis -- the Bray-Curtis distance. canberra -- the Canberra distance. chebyshev -- the Chebyshev distance. cityblock -- the Manhattan distance. correlation -- the Correlation distance. cosine -- the Cosine distance. euclidean -- the Euclidean distance. jensenshannon -- the Jensen-Shannon distance. mahalanobis -- the Mahalanobis distance. minkowski -- the Minkowski distance. seuclidean -- the normalized Euclidean distance. sqeuclidean -- the squared Euclidean distance. Distance functions between two boolean vectors (representing sets) ``u`` and ``v``. As in the case of numerical vectors, ``pdist`` is more efficient for computing the distances between all pairs. .. autosummary:: :toctree: generated/ dice -- the Dice dissimilarity. hamming -- the Hamming distance. jaccard -- the Jaccard distance. kulczynski1 -- the Kulczynski 1 distance. rogerstanimoto -- the Rogers-Tanimoto dissimilarity. russellrao -- the Russell-Rao dissimilarity. sokalmichener -- the Sokal-Michener dissimilarity. sokalsneath -- the Sokal-Sneath dissimilarity. yule -- the Yule dissimilarity. :func:`hamming` also operates over discrete numerical vectors. ) braycurtiscanberracdist chebyshev cityblock correlationcosinedicedirected_hausdorff euclideanhamming is_valid_dm is_valid_yjaccard jensenshannon kulczynski1 mahalanobis minkowski num_obs_dm num_obs_ypdistrogerstanimoto russellrao seuclidean sokalmichener sokalsneath sqeuclidean squareformyuleN)Callable)partial)_asarray_validated_transition_to_rng) _deprecated)_distance_wrap) _hausdorff)norm)rel_entr)_distance_pybindc@URbUR5$U$)z4Copy the array if its base points to a parent array.)basecopy)as I/var/www/html/venv/lib/python3.13/site-packages/scipy/spatial/distance.py_copy_array_if_base_presentr1~svvvvx Hc |XRSSS9- nXRSSS9- n[R"XU40UD6 gNr%Taxiskeepdims)meanr&cdist_cosine_double_wrap)XAXBdmkwargss r0_correlation_cdist_wrapr>sA gg1tg, ,B gg1tg, ,B++BBA&Ar2c VXRSSS9- n[R"X140UD6 gr4)r8r&pdist_cosine_double_wrap)Xr<r=X2s r0_correlation_pdist_wraprCs* VVTV * *B++B=f=r2c*[R"XS9$)Ndtype)npascontiguousarray)rAout_types r0_convert_to_typerJs   22r2c\URURs=:Xa [:XaUO ORUcOU)nU)nX4-R5nX1-R5nX-R5nX-R5nO[R"[ URUR5n UR U 5nUR U 5nSU- nSU- nUbX#-nX -nX4-R5nX1-R5nX-R5nX-R5nXVXx4$N?rFboolsumrG result_typeintastype) uvwnot_unot_vnffnftntfnttrFs r0_nbool_correspond_allr]sww!''!T!ai}!!#yooyooukkmsAGGQWW5 HHUO HHUOaa =IEA}!!#yooyooukkm c r2cURURs=:Xa [:Xa3O O0Uc-U)nU)nX1-R5nX-R5nXV4$[R"[ URUR5nUR U5nUR U5nSU- nSU- nUbX#-nX -nX1-R5nX-R5nXV4$rLrN)rTrUrVrWrXrZr[rFs r0_nbool_correspond_ft_tfr_sww!''!T!aiyooyoo :sAGGQWW5 HHUO HHUOaa =IEAyooyoo :r2c URnURU;aXwRUR5OUSn[XS9n[XS9nURn U (aU "X4X#-U40UD6nXX4$NrrItypesrFindexrJ validator) r:r;mAmBn metric_infor=rdtyp_validate_kwargss r0_validate_cdist_inputrmsz   E*,((e*;% BHH% &qC " +B " +B#,,!2(BGQA&A 3 r2c URSS5nUcU$URS:wdURSU:wa[SURSSU35e[ U5US'U$)NrVr%rz-Weights must have same size as input vector. z vs. )popndimshape ValueError_validate_weightsrAmrir=rVs r0_validate_weight_with_sizervsr 3Ay vv{aggajAoHGGAJ > a   ! A ]]266!((2::E("B"D"DE F YY]]2  % % '%b)F4L Mr2c b[XU40UD6nSU;aSUS'U$USS::a [S5eU$)Np@rp must be greater than 0)rvrr)rArurir=s r0_validate_minkowski_kwargsrsJ 'a :6 :F &s M #;! 78 8 Mr2c URnURU;aXURUR5OUSn[XS9nURnU(a U"XU40UD6nXU4$rarc)rArurirjr=rdrkrls r0_validate_pdist_inputrsi   E)*E)9% AGG$ %uQxC)A#,,!!4V4 6>r2c URSS5nUc^[U[5(a[R"U5n[R "UR [RSS9SSS9nOW[R"USS9n[UR5S:wa [S 5eURSU:wa [S 5e[U5US'U$) NVFr~rr%)r6ddofcorderz*Variance vector V must be one-dimensional.zcVariance vector V must be of the same dimension as the vectors on which the distances are computed.) rorrrGrvarrSrasarraylenrqrrr)rArurir=rs r0_validate_seuclidean_kwargsrs 3Ay a   ! A FF188BJJU83!! D JJq $ qww<1 34 4 771:?-. .%Q'F3K Mr2cf[R"XSS9nURS:XaU$[S5e)NrrFrr%zInput vector should be 1-D.)rGrrprr)rTrFs r0_validate_vectorr)s. 1-Avv{ 2 33r2cj[XS9n[R"US:5(a [S5eU$)NrErz(Input weights should be all non-negative)rrGanyrr)rVrFs r0rsrs1s.(A vva!e}}CDD Hr2seedF) position_num replace_docc[R"U[RSS9n[R"U[RSS9nURSURS:wa [ S5e[ R "XU5nU$)al Compute the directed Hausdorff distance between two 2-D arrays. Distances between pairs are calculated using a Euclidean metric. Parameters ---------- u : (M,N) array_like Input array with M points in N dimensions. v : (O,N) array_like Input array with O points in N dimensions. rng : int or `numpy.random.Generator` or None, optional Pseudorandom number generator state. Default is 0 so the shuffling of `u` and `v` is reproducible. If `rng` is passed by keyword, types other than `numpy.random.Generator` are passed to `numpy.random.default_rng` to instantiate a ``Generator``. If `rng` is already a ``Generator`` instance, then the provided instance is used. If this argument is passed by position or `seed` is passed by keyword, legacy behavior for the argument `seed` applies: - If `seed` is None, a new ``RandomState`` instance is used. The state is initialized using data from ``/dev/urandom`` (or the Windows analogue) if available or from the system clock otherwise. - If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. - If `seed` is already a ``Generator`` or ``RandomState`` instance, then that instance is used. .. versionchanged:: 1.15.0 As part of the `SPEC-007 `_ transition from use of `numpy.random.RandomState` to `numpy.random.Generator`, this keyword was changed from `seed` to `rng`. For an interim period, both keywords will continue to work, although only one may be specified at a time. After the interim period, function calls using the `seed` keyword will emit warnings. The behavior of both `seed` and `rng` are outlined above, but only the `rng` keyword should be used in new code. Returns ------- d : double The directed Hausdorff distance between arrays `u` and `v`, index_1 : int index of point contributing to Hausdorff pair in `u` index_2 : int index of point contributing to Hausdorff pair in `v` Raises ------ ValueError An exception is thrown if `u` and `v` do not have the same number of columns. See Also -------- scipy.spatial.procrustes : Another similarity test for two data sets Notes ----- Uses the early break technique and the random sampling approach described by [1]_. Although worst-case performance is ``O(m * o)`` (as with the brute force algorithm), this is unlikely in practice as the input data would have to require the algorithm to explore every single point interaction, and after the algorithm shuffles the input points at that. The best case performance is O(m), which is satisfied by selecting an inner loop distance that is less than cmax and leads to an early break as often as possible. The authors have formally shown that the average runtime is closer to O(m). .. versionadded:: 0.19.0 References ---------- .. [1] A. A. Taha and A. Hanbury, "An efficient algorithm for calculating the exact Hausdorff distance." IEEE Transactions On Pattern Analysis And Machine Intelligence, vol. 37 pp. 2153-63, 2015. Examples -------- Find the directed Hausdorff distance between two 2-D arrays of coordinates: >>> from scipy.spatial.distance import directed_hausdorff >>> import numpy as np >>> u = np.array([(1.0, 0.0), ... (0.0, 1.0), ... (-1.0, 0.0), ... (0.0, -1.0)]) >>> v = np.array([(2.0, 0.0), ... (0.0, 2.0), ... (-2.0, 0.0), ... (0.0, -4.0)]) >>> directed_hausdorff(u, v)[0] 2.23606797749979 >>> directed_hausdorff(v, u)[0] 3.0 Find the general (symmetric) Hausdorff distance between two 2-D arrays of coordinates: >>> max(directed_hausdorff(u, v)[0], directed_hausdorff(v, u)[0]) 3.0 Find the indices of the points that generate the Hausdorff distance (the Hausdorff pair): >>> directed_hausdorff(v, u)[1:] (3, 3) rrr%z/u and v need to have the same number of columns)rGrrrqrrr'r )rTrUrngresults r0r r 8srn 1BJJc2A 1BJJc2AwwqzQWWQZ-. .  * *1 5F Mr2cF[U5n[U5nUS::a [S5eX- nUbi[U5nUS:XaUnOQUS:Xa[R"U5nO4U[R :XaUS:gnO[R "USU- 5nXT-n[XBS9nU$)a Compute the Minkowski distance between two 1-D arrays. The Minkowski distance between 1-D arrays `u` and `v`, is defined as .. math:: {\|u-v\|}_p = (\sum{|u_i - v_i|^p})^{1/p}. \left(\sum{w_i(|(u_i - v_i)|^p)}\right)^{1/p}. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. p : scalar The order of the norm of the difference :math:`{\|u-v\|}_p`. Note that for :math:`0 < p < 1`, the triangle inequality only holds with an additional multiplicative factor, i.e. it is only a quasi-metric. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- minkowski : double The Minkowski distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.minkowski([1, 0, 0], [0, 1, 0], 1) 2.0 >>> distance.minkowski([1, 0, 0], [0, 1, 0], 2) 1.4142135623730951 >>> distance.minkowski([1, 0, 0], [0, 1, 0], 3) 1.2599210498948732 >>> distance.minkowski([1, 1, 0], [0, 1, 0], 1) 1.0 >>> distance.minkowski([1, 1, 0], [0, 1, 0], 2) 1.0 >>> distance.minkowski([1, 1, 0], [0, 1, 0], 3) 1.0 rrr%r()ord)rrrrsrGsqrtinfpowerr))rTrUrrVu_vroot_wdists r0rrsd AAAv344 %C} a  6F !VWWQZF "&&[1fFXXa1%Fl  D Kr2c[XSUS9$)a Computes the Euclidean distance between two 1-D arrays. The Euclidean distance between 1-D arrays `u` and `v`, is defined as .. math:: {\|u-v\|}_2 \left(\sum{(w_i |(u_i - v_i)|^2)}\right)^{1/2} Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- euclidean : double The Euclidean distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.euclidean([1, 0, 0], [0, 1, 0]) 1.4142135623730951 >>> distance.euclidean([1, 1, 0], [0, 1, 0]) 1.0 r()rrV)rrTrUrVs r0r r sH QQ! $$r2cSup4[US5(a4[R"UR[R5(d[R n[US5(a4[R"UR[R5(d[R n[ XS9n[ XS9nX- nUnUb[U5nX%-n[R"XV5$)a Compute the squared Euclidean distance between two 1-D arrays. The squared Euclidean distance between `u` and `v` is defined as .. math:: \sum_i{w_i |u_i - v_i|^2} Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- sqeuclidean : double The squared Euclidean distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.sqeuclidean([1, 0, 0], [0, 1, 0]) 2.0 >>> distance.sqeuclidean([1, 1, 0], [0, 1, 0]) 1.0 )NNrFrE) hasattrrG issubdtyperFinexactrrrsdot)rTrUrVutypevtyperu_v_ws r0rr&sHLE Aw  BMM!''2::$F$F  Aw  BMM!''2::$F$F (A(A %C E} a  66# r2Tc[U5n[U5n[R"U5(d[R"U5(aSn[R"U[ SS9 Ub[ U5nX"R5- nU(adUb-[R"X5n[R"X5nO,[R"U5n[R"U5nX- nX- nUb X-nX-nOXp[R"X5n [R"X5n [R"X5n SU [R"X-5- - n [R"U SS5$)a Compute the correlation distance between two 1-D arrays. The correlation distance between `u` and `v`, is defined as .. math:: 1 - \frac{(u - \bar{u}) \cdot (v - \bar{v})} {{\|(u - \bar{u})\|}_2 {\|(v - \bar{v})\|}_2} where :math:`\bar{u}` is the mean of the elements of `u` and :math:`x \cdot y` is the dot product of :math:`x` and :math:`y`. Parameters ---------- u : (N,) array_like of floats Input array. .. deprecated:: 1.15.0 Complex `u` is deprecated and will raise an error in SciPy 1.17.0 v : (N,) array_like of floats Input array. .. deprecated:: 1.15.0 Complex `v` is deprecated and will raise an error in SciPy 1.17.0 w : (N,) array_like of floats, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 centered : bool, optional If True, `u` and `v` will be centered. Default is True. Returns ------- correlation : double The correlation distance between 1-D array `u` and `v`. Examples -------- Find the correlation between two arrays. >>> from scipy.spatial.distance import correlation >>> correlation([1, 0, 1], [1, 1, 0]) 1.5 Using a weighting array, the correlation can be calculated as: >>> correlation([1, 0, 1], [1, 1, 0], w=[0.9, 0.1, 0.1]) 1.1 If centering is not needed, the correlation can be calculated as: >>> correlation([1, 0, 1], [1, 1, 0], centered=False) 0.5 zKComplex `u` and `v` are deprecated and will raise an error in SciPy 1.17.0.r( stacklevelrMr) rrG iscomplexobjwarningswarnDeprecationWarningrsrPrr8mathrclip) rTrUrVcenteredmessageumuvmuvwuwuvuuvvrs r0rrZs%p AA qR__Q//    g1a@} a  K =&&,C&&,C''!*C''!*C G G} U UB B B B dii(( (D 774c ""r2c[XUSS9$)a Compute the Cosine distance between 1-D arrays. The Cosine distance between `u` and `v`, is defined as .. math:: 1 - \frac{u \cdot v} {\|u\|_2 \|v\|_2}. where :math:`u \cdot v` is the dot product of :math:`u` and :math:`v`. Parameters ---------- u : (N,) array_like of floats Input array. .. deprecated:: 1.15.0 Complex `u` is deprecated and will raise an error in SciPy 1.17.0 v : (N,) array_like of floats Input array. .. deprecated:: 1.15.0 Complex `v` is deprecated and will raise an error in SciPy 1.17.0 w : (N,) array_like of floats, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- cosine : double The Cosine distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.cosine([1, 0, 0], [0, 1, 0]) 1.0 >>> distance.cosine([100, 0, 0], [0, 1, 0]) 1.0 >>> distance.cosine([1, 1, 0], [0, 1, 0]) 0.29289321881345254 F)rVr)rrs r0rrs` qq5 11r2cb[U5n[U5nURUR:wa [S5eX:gnUbX[U5nURUR:wa [S5eX"R 5- n[ R "X25$[ R"U5$)a Compute the Hamming distance between two 1-D arrays. The Hamming distance between 1-D arrays `u` and `v`, is simply the proportion of disagreeing components in `u` and `v`. If `u` and `v` are boolean vectors, the Hamming distance is .. math:: \frac{c_{01} + c_{10}}{n} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n`. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- hamming : double The Hamming distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.hamming([1, 0, 0], [0, 1, 0]) 0.66666666666666663 >>> distance.hamming([1, 0, 0], [1, 1, 0]) 0.33333333333333331 >>> distance.hamming([1, 0, 0], [2, 0, 0]) 0.33333333333333331 >>> distance.hamming([1, 0, 0], [3, 0, 0]) 0.33333333333333331 z&The 1d arrays must have equal lengths.z/'w' should have the same length as 'u' and 'v'.)rrqrrrsrPrGrr8)rTrUrVu_ne_vs r0r r sX AAww!''ABB VF} a  77agg NO O Kvvf  776?r2c[U5n[U5n[R"US:gUS:g5n[R"US:gUS:g5nUb[ U5nX#-nX$-n[R "UR 55n[R "UR 55nUS:waXV- $[R "S5$)a Compute the Jaccard dissimilarity between two boolean vectors. Given boolean vectors :math:`u \equiv (u_1, \cdots, u_n)` and :math:`v \equiv (v_1, \cdots, v_n)` that are not both zero, their *Jaccard dissimilarity* is defined as ([1]_, p. 26) .. math:: d_\textrm{jaccard}(u, v) := \frac{c_{10} + c_{01}} {c_{11} + c_{10} + c_{01}} where .. math:: c_{ij} := \sum_{1 \le k \le n, u_k=i, v_k=j} 1 for :math:`i, j \in \{ 0, 1\}`. If :math:`u` and :math:`v` are both zero, their Jaccard dissimilarity is defined to be zero. [2]_ If a (non-negative) weight vector :math:`w \equiv (w_1, \cdots, w_n)` is supplied, the *weighted Jaccard dissimilarity* is defined similarly but with :math:`c_{ij}` replaced by .. math:: \tilde{c}_{ij} := \sum_{1 \le k \le n, u_k=i, v_k=j} w_k Parameters ---------- u : (N,) array_like of bools Input vector. v : (N,) array_like of bools Input vector. w : (N,) array_like of floats, optional Weights for each pair of :math:`(u_k, v_k)`. Default is ``None``, which gives each pair a weight of ``1.0``. Returns ------- jaccard : float The Jaccard dissimilarity between vectors `u` and `v`, optionally weighted by `w` if supplied. Notes ----- The Jaccard dissimilarity satisfies the triangle inequality and is qualified as a metric. [2]_ The *Jaccard index*, or *Jaccard similarity coefficient*, is equal to one minus the Jaccard dissimilarity. [3]_ The dissimilarity between general (finite) sets may be computed by encoding them as boolean vectors and computing the dissimilarity between the encoded vectors. For example, subsets :math:`A,B` of :math:`\{ 1, 2, ..., n \}` may be encoded into boolean vectors :math:`u, v` by setting :math:`u_k := 1_{k \in A}`, :math:`v_k := 1_{k \in B}` for :math:`k = 1,2,\cdots,n`. .. versionchanged:: 1.2.0 Previously, if all (positively weighted) elements in `u` and `v` are zero, the function would return ``nan``. This was changed to return ``0`` instead. .. versionchanged:: 1.15.0 Non-0/1 numeric input used to produce an ad hoc result. Since 1.15.0, numeric input is converted to Boolean before computation. References ---------- .. [1] Kaufman, L. and Rousseeuw, P. J. (1990). "Finding Groups in Data: An Introduction to Cluster Analysis." John Wiley & Sons, Inc. .. [2] Kosub, S. (2019). "A note on the triangle inequality for the Jaccard distance." *Pattern Recognition Letters*, 120:36-38. .. [3] https://en.wikipedia.org/wiki/Jaccard_index Examples -------- >>> from scipy.spatial import distance Non-zero vectors with no matching 1s have dissimilarity of 1.0: >>> distance.jaccard([1, 0, 0], [0, 1, 0]) 1.0 Vectors with some matching 1s have dissimilarity less than 1.0: >>> distance.jaccard([1, 0, 0, 0], [1, 1, 1, 0]) 0.6666666666666666 Identical vectors, including zero vectors, have dissimilarity of 0.0: >>> distance.jaccard([1, 0, 0], [1, 0, 0]) 0.0 >>> distance.jaccard([0, 0, 0], [0, 0, 0]) 0.0 The following example computes the dissimilarity from a confusion matrix directly by setting the weight vector to the frequency of True Positive, False Negative, False Positive, and True Negative: >>> distance.jaccard([1, 1, 0, 0], [1, 0, 1, 0], [31, 41, 59, 26]) 0.7633587786259542 # (41+59)/(31+41+59) r)rrG bitwise_xor bitwise_orrsrrP)rTrUrVunequalnonzeror/bs r0rrsX AAnnQ!VQ!V,GmmAFAF+G} a ++ 7;;=!A 7;;=!A1fAE/"**Q-/r2zThe kulczynski1 metric is deprecated since SciPy 1.15.0 and will be removed in SciPy 1.17.0. Replace usage of 'kulczynski1(u, v)' with '1/jaccard(u, v) - 1'.rVcr[U5n[U5nUb [U5n[XUS9up4pVXeU-- $)a6 Compute the Kulczynski 1 dissimilarity between two boolean 1-D arrays. .. deprecated:: 1.15.0 This function is deprecated and will be removed in SciPy 1.17.0. Replace usage of ``kulczynski1(u, v)`` with ``1/jaccard(u, v) - 1``. The Kulczynski 1 dissimilarity between two boolean 1-D arrays `u` and `v` of length ``n``, is defined as .. math:: \frac{c_{11}} {c_{01} + c_{10}} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k \in {0, 1, ..., n-1}`. Parameters ---------- u : (N,) array_like, bool Input array. v : (N,) array_like, bool Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- kulczynski1 : float The Kulczynski 1 distance between vectors `u` and `v`. Notes ----- This measure has a minimum value of 0 and no upper limit. It is un-defined when there are no non-matches. .. versionadded:: 1.8.0 References ---------- .. [1] Kulczynski S. et al. Bulletin International de l'Academie Polonaise des Sciences et des Lettres, Classe des Sciences Mathematiques et Naturelles, Serie B (Sciences Naturelles). 1927; Supplement II: 57-203. Examples -------- >>> from scipy.spatial import distance >>> distance.kulczynski1([1, 0, 0], [0, 1, 0]) 0.0 >>> distance.kulczynski1([True, False, False], [True, True, False]) 1.0 >>> distance.kulczynski1([True, False, False], [True]) 0.5 >>> distance.kulczynski1([1, 0, 0], [3, 1, 0]) -3.0 r)rrsr])rTrUrV_rZr[r\s r0rrsF@ AA} a .qq9QS ) r2c[U5n[U5n[U[RS9nURSURS:wd URSURS:wa [ S5e[ XSU- S9$)a Return the standardized Euclidean distance between two 1-D arrays. The standardized Euclidean distance between two n-vectors `u` and `v` is .. math:: \sqrt{\sum\limits_i \frac{1}{V_i} \left(u_i-v_i \right)^2} ``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. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. V : (N,) array_like `V` is an 1-D array of component variances. It is usually computed among a larger collection of vectors. Returns ------- seuclidean : double The standardized Euclidean distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.seuclidean([1, 0, 0], [0, 1, 0], [0.1, 0.1, 0.1]) 4.4721359549995796 >>> distance.seuclidean([1, 0, 0], [0, 1, 0], [1, 0.1, 0.1]) 3.3166247903553998 >>> distance.seuclidean([1, 0, 0], [0, 1, 0], [10, 0.1, 0.1]) 3.1780497164141406 rErz7V must be a 1-D array of the same dimension as u and v.r%r)rrGrrq TypeErrorr )rTrUrs r0rrs{N AA"**-AwwqzQWWQZ1771:#;&' ' QQqS !!r2c[U5n[U5n[X- 5nUb[U5nX#-nUR5$)a Compute the City Block (Manhattan) distance. Computes the Manhattan distance between two 1-D arrays `u` and `v`, which is defined as .. math:: \sum_i {\left| u_i - v_i \right|}. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- cityblock : double The City Block (Manhattan) distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.cityblock([1, 0, 0], [0, 1, 0]) 2 >>> distance.cityblock([1, 0, 0], [0, 2, 0]) 3 >>> distance.cityblock([1, 0, 0], [1, 1, 0]) 1 )rabsrsrP)rTrUrVl1_diffs r0rrsFJ AA!%jG} a + ;;=r2c[U5n[U5n[R"U5nX- n[R"[R"X25U5n[R"U5$)a- Compute the Mahalanobis distance between two 1-D arrays. The Mahalanobis distance between 1-D arrays `u` and `v`, is defined as .. math:: \sqrt{ (u-v) V^{-1} (u-v)^T } where ``V`` is the covariance matrix. Note that the argument `VI` is the inverse of ``V``. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. VI : array_like The inverse of the covariance matrix. Returns ------- mahalanobis : double The Mahalanobis distance between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> iv = [[1, 0.5, 0.5], [0.5, 1, 0.5], [0.5, 0.5, 1]] >>> distance.mahalanobis([1, 0, 0], [0, 1, 0], iv) 1.0 >>> distance.mahalanobis([0, 2, 0], [0, 1, 0], iv) 1.0 >>> distance.mahalanobis([2, 0, 0], [0, 1, 0], iv) 1.7320508075688772 )rrGrrr)rTrUr}deltarus r0rrGsUN AA r B EE rvve %(A 771:r2c[U5n[U5nUb'[U5n[US:[X- 5-5$[[X- 55$)a Compute the Chebyshev distance. The *Chebyshev distance* between real vectors :math:`u \equiv (u_1, \cdots, u_n)` and :math:`v \equiv (v_1, \cdots, v_n)` is defined as [1]_ .. math:: d_\textrm{chebyshev}(u,v) := \max_{1 \le i \le n} |u_i-v_i| If a (non-negative) weight vector :math:`w \equiv (w_1, \cdots, w_n)` is supplied, the *weighted Chebyshev distance* is defined to be the weighted Minkowski distance of infinite order; that is, .. math:: \begin{align} d_\textrm{chebyshev}(u,v;w) &:= \lim_{p\rightarrow \infty} \left( \sum_{i=1}^n w_i | u_i-v_i |^p \right)^\frac{1}{p} \\ &= \max_{1 \le i \le n} 1_{w_i > 0} | u_i - v_i | \end{align} Parameters ---------- u : (N,) array_like of floats Input vector. v : (N,) array_like of floats Input vector. w : (N,) array_like of floats, optional Weight vector. Default is ``None``, which gives all pairs :math:`(u_i, v_i)` the same weight ``1.0``. Returns ------- chebyshev : float The Chebyshev distance between vectors `u` and `v`, optionally weighted by `w`. References ---------- .. [1] https://en.wikipedia.org/wiki/Chebyshev_distance Examples -------- >>> from scipy.spatial import distance >>> distance.chebyshev([1, 0, 0], [0, 1, 0]) 1 >>> distance.chebyshev([1, 1, 0], [0, 1, 0]) 1 r)rrsmaxrrs r0rrvsRj AA} a AESZ'(( s15z?r2c[U5n[U[RS9n[X- 5n[X-5nUb[ U5nX#-nX$-nUR 5UR 5- $)a Compute the Bray-Curtis distance between two 1-D arrays. Bray-Curtis distance is defined as .. math:: \sum{|u_i-v_i|} / \sum{|u_i+v_i|} The Bray-Curtis distance is in the range [0, 1] if all coordinates are positive, and is undefined if the inputs are of length zero. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- braycurtis : double The Bray-Curtis distance between 1-D arrays `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.braycurtis([1, 0, 0], [0, 1, 0]) 1.0 >>> distance.braycurtis([1, 1, 0], [0, 1, 0]) 0.33333333333333331 rE)rrGrrrsrP)rTrUrVrl1_sums r0rrsiJ A"**-A!%jG ZF} a + ;;=6::< ''r2cT[U5n[U[RS9nUb [U5n[R"SS9 [ X- 5n[ U5n[ U5nX4U-- nUbX&-n[R "U5nSSS5 U$!,(df  W$=f)a Compute the Canberra distance between two 1-D arrays. The Canberra distance is defined as .. math:: d(u,v) = \sum_i \frac{|u_i-v_i|} {|u_i|+|v_i|}. Parameters ---------- u : (N,) array_like Input array. v : (N,) array_like Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- canberra : double The Canberra distance between vectors `u` and `v`. Notes ----- When ``u[i]`` and ``v[i]`` are 0 for given i, then the fraction 0/0 = 0 is used in the calculation. Examples -------- >>> from scipy.spatial import distance >>> distance.canberra([1, 0, 0], [0, 1, 0]) 2.0 >>> distance.canberra([1, 1, 0], [0, 1, 0]) 1.0 rENignore)invalid)rrGrrserrstaternansum)rTrUrVabs_uvabs_uabs_vds r0rrsP A"**-A} a  X &QUAA em $ =A IIaL ' H ' & Hs AB B'r5c[R"U5n[R"U5nU[R"XSS9- nU[R"XSS9- nX-S- n[X5n[X5n[R"XcUS9n[R"XsUS9n X-n UbU [R"U5-n [R "U S- 5$)a Compute the Jensen-Shannon distance (metric) between two probability arrays. This is the square root of the Jensen-Shannon divergence. The Jensen-Shannon distance between two probability vectors `p` and `q` is defined as, .. math:: \sqrt{\frac{D(p \parallel m) + D(q \parallel m)}{2}} where :math:`m` is the pointwise mean of :math:`p` and :math:`q` and :math:`D` is the Kullback-Leibler divergence. This routine will normalize `p` and `q` if they don't sum to 1.0. Parameters ---------- p : (N,) array_like left probability vector q : (N,) array_like right probability vector base : double, optional the base of the logarithm used to compute the output if not given, then the routine uses the default base of scipy.stats.entropy. axis : int, optional Axis along which the Jensen-Shannon distances are computed. The default is 0. .. versionadded:: 1.7.0 keepdims : bool, optional If this is set to `True`, the reduced axes are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array. Default is False. .. versionadded:: 1.7.0 Returns ------- js : double or ndarray The Jensen-Shannon distances between `p` and `q` along the `axis`. Notes ----- .. versionadded:: 1.2.0 Examples -------- >>> from scipy.spatial import distance >>> import numpy as np >>> distance.jensenshannon([1.0, 0.0, 0.0], [0.0, 1.0, 0.0], 2.0) 1.0 >>> distance.jensenshannon([1.0, 0.0], [0.5, 0.5]) 0.46450140402245893 >>> distance.jensenshannon([1.0, 0.0, 0.0], [1.0, 0.0, 0.0]) 0.0 >>> a = np.array([[1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12]]) >>> b = np.array([[13, 14, 15, 16], ... [17, 18, 19, 20], ... [21, 22, 23, 24]]) >>> distance.jensenshannon(a, b, axis=0) array([0.1954288, 0.1447697, 0.1138377, 0.0927636]) >>> distance.jensenshannon(a, b, axis=1) array([0.1402339, 0.0399106, 0.0201815]) Tr5r)rGrrPr*logr) rqr-r6r7ruleftrightleft_sum right_sumjss r0rrsR 1 A 1 A BFF1$ //A BFF1$ //A # A A>D QNEvvd9Hu(;I  B  bffTl 7728 r2c[U5n[U5nUb [U5n[XUS9up4pVXT-nUS:Xag[SU-Xc-U-- 5$)a& Compute the Yule dissimilarity between two boolean 1-D arrays. The Yule dissimilarity is defined as .. math:: \frac{R}{c_{TT} * c_{FF} + \frac{R}{2}} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n` and :math:`R = 2.0 * c_{TF} * c_{FT}`. Parameters ---------- u : (N,) array_like, bool Input array. v : (N,) array_like, bool Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- yule : double The Yule dissimilarity between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.yule([1, 0, 0], [0, 1, 0]) 2.0 >>> distance.yule([1, 1, 0], [0, 1, 0]) 0.0 rrrrrrsr]float)rTrUrVrYrZr[r\half_Rs r0rrrseL AA} a 0;Ss YF {S6\SY%7899r2c2[U5n[U5nUb [U5nURURs=:Xa [:XaO OUcX-R 5nO}[ R "[URUR5nURU5nURU5nUcX-R 5nOX-U-R 5n[XUS9upV[Xe-[ R"SU-U-U-5- 5$)a Compute the Dice dissimilarity between two boolean 1-D arrays. The Dice dissimilarity between `u` and `v`, is .. math:: \frac{c_{TF} + c_{FT}} {2c_{TT} + c_{FT} + c_{TF}} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n`. Parameters ---------- u : (N,) array_like, bool Input 1-D array. v : (N,) array_like, bool Input 1-D array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- dice : double The Dice dissimilarity between 1-D arrays `u` and `v`. Notes ----- This function computes the Dice dissimilarity index. To compute the Dice similarity index, convert one to the other with similarity = 1 - dissimilarity. Examples -------- >>> from scipy.spatial import distance >>> distance.dice([1, 0, 0], [0, 1, 0]) 1.0 >>> distance.dice([1, 0, 0], [1, 1, 0]) 0.3333333333333333 >>> distance.dice([1, 0, 0], [2, 0, 0]) -0.3333333333333333 rr) rrsrFrOrPrGrQrRrSr_rarray)rTrUrVr\rFrZr[s r0r r s^ AA} a ww!''!T!aiukkmsAGGQWW5 HHUO HHUO 95++-C519//#C(3JS #)rxxc C#(=>> ??r2c[U5n[U5nUb [U5n[XUS9up4pV[SXT--5[Xc-SXT---5- $)a Compute the Rogers-Tanimoto dissimilarity between two boolean 1-D arrays. The Rogers-Tanimoto dissimilarity between two boolean 1-D arrays `u` and `v`, is defined as .. math:: \frac{R} {c_{TT} + c_{FF} + R} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n` and :math:`R = 2(c_{TF} + c_{FT})`. Parameters ---------- u : (N,) array_like, bool Input array. v : (N,) array_like, bool Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- rogerstanimoto : double The Rogers-Tanimoto dissimilarity between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.rogerstanimoto([1, 0, 0], [0, 1, 0]) 0.8 >>> distance.rogerstanimoto([1, 0, 0], [1, 1, 0]) 0.5 >>> distance.rogerstanimoto([1, 0, 0], [2, 0, 0]) -1.0 rrrrTrUrVrYrZr[r\s r0rrscT AA} a 0;Ss  " #eCI 9J,K&L LLr2c[U5n[U5nURURs=:Xa [:Xa-O O*Uc'X-R5n[ [ U55nOZUc'X-R5n[ [ U55nO0[ U5nX-U-R5nUR5n[ XC- 5U- $)a Compute the Russell-Rao dissimilarity between two boolean 1-D arrays. The Russell-Rao dissimilarity between two boolean 1-D arrays, `u` and `v`, is defined as .. math:: \frac{n - c_{TT}} {n} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n`. Parameters ---------- u : (N,) array_like, bool Input array. v : (N,) array_like, bool Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- russellrao : double The Russell-Rao dissimilarity between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.russellrao([1, 0, 0], [0, 1, 0]) 1.0 >>> distance.russellrao([1, 0, 0], [1, 1, 0]) 0.6666666666666666 >>> distance.russellrao([1, 0, 0], [2, 0, 0]) 0.3333333333333333 )rrFrOrPrrrs)rTrUrVr\ris r0rrsT AAww!''!T!aiukkm #a&M ukkm #a&M a uqyoo EEG >A r2zThe sokalmichener metric is deprecated since SciPy 1.15.0 and will be removed in SciPy 1.17.0. Replace usage of 'sokalmichener(u, v)' with 'rogerstanimoto(u, v)'.c[U5n[U5nUb [U5n[XUS9up4pV[SXT--5[Xc-SXT---5- $)ap Compute the Sokal-Michener dissimilarity between two boolean 1-D arrays. .. deprecated:: 1.15.0 This function is deprecated and will be removed in SciPy 1.17.0. Replace usage of ``sokalmichener(u, v)`` with ``rogerstanimoto(u, v)``. The Sokal-Michener dissimilarity between boolean 1-D arrays `u` and `v`, is defined as .. math:: \frac{R} {S + R} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n`, :math:`R = 2 * (c_{TF} + c_{FT})` and :math:`S = c_{FF} + c_{TT}`. Parameters ---------- u : (N,) array_like, bool Input array. v : (N,) array_like, bool Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- sokalmichener : double The Sokal-Michener dissimilarity between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.sokalmichener([1, 0, 0], [0, 1, 0]) 0.8 >>> distance.sokalmichener([1, 0, 0], [1, 1, 0]) 0.5 >>> distance.sokalmichener([1, 0, 0], [2, 0, 0]) -1.0 rrrrs r0rrWsc` AA} a .qq9Cc  " #eCIsy8I,I&J JJr2c[U5n[U5nURURs=:Xa [:XaO OUcX-R5nO6UcX-R5nO [ U5nX-U-R5n[ XUS9upE[ R"USXT---5nUR5(d [S5e[SXT--5U- $)a Compute the Sokal-Sneath dissimilarity between two boolean 1-D arrays. The Sokal-Sneath dissimilarity between `u` and `v`, .. math:: \frac{R} {c_{TT} + R} where :math:`c_{ij}` is the number of occurrences of :math:`\mathtt{u[k]} = i` and :math:`\mathtt{v[k]} = j` for :math:`k < n` and :math:`R = 2(c_{TF} + c_{FT})`. Parameters ---------- u : (N,) array_like, bool Input array. v : (N,) array_like, bool Input array. w : (N,) array_like, optional The weights for each value in `u` and `v`. Default is None, which gives each value a weight of 1.0 Returns ------- sokalsneath : double The Sokal-Sneath dissimilarity between vectors `u` and `v`. Examples -------- >>> from scipy.spatial import distance >>> distance.sokalsneath([1, 0, 0], [0, 1, 0]) 1.0 >>> distance.sokalsneath([1, 0, 0], [1, 1, 0]) 0.66666666666666663 >>> distance.sokalsneath([1, 0, 0], [2, 1, 0]) 0.0 >>> distance.sokalsneath([1, 0, 0], [3, 1, 0]) -2.0 rrzNSokal-Sneath dissimilarity is not defined for vectors that are entirely false.) rrFrOrPrsr_rGrrrrr)rTrUrVr\rZr[denoms r0rrsV AAww!''!T!aiukkm ukkm a uqyoo(3JS HHS3#),, -E 99;;<= =  " #e ++r2rb)frozenc.\rSrSr%\\S'SS.SjrSrg)CDistMetricWrapperi metric_nameNoutc [R"U5n[R"U5nURupVURupxURn [U n [ XXWXj40UD6uppUR SS5n U bU Rn [X4XU S.UD6$[U[RXW45n[[SU SU S35nU"XU40UD6 U$)NrVmetricrrVcdist_r_wrap) rGrHrqr_METRICSrmro dist_func_cdist_callable_prepare_out_argumentrgetattrr&)selfr:r;rr=rgrirhrrrjrkrVrr<cdist_fns r0__call__CDistMetricWrapper.__call__s  ! !" %  ! !" %&& {+ 3 BA6.46 JJsD ! = **F"?%!?7=? ?#3 RH =>VK=#e+LM&v& r2__name__ __module__ __qualname____firstlineno__str__annotations__r__static_attributes__rr2r0rrs&*r2rc.\rSrSr%\\S'SS.SjrSrg)PDistMetricWrapperirNrc [R"U5nURupEURn[Un[ XXW40UD6upnXDS- -S-n UR SS5n U bURn [U4XU S.UD6$[U[RU 45n [[SUSUS35n U "X40UD6 U $)Nr%r(rVrpdist_rr ) rGrHrqrr rror _pdist_callablerrrr&)rrArr=rurirrjrkout_sizerVrr<pdist_fns r0rPDistMetricWrapper.__call__s   #ww&& {+ . !,$*,QKA% JJsD ! = **F": Q:28: :#3 XK @>VK=#e+LM!&! r2rrrr2r0rrs!%r2rc\rSrSr%\\S'\\\S'\\S'\\S'\\S'Sr\S-\S'\ R"S S 9r \ \\S 'S r \\S 'Srg) MetricInfoicanonical_nameakar  cdist_func pdist_funcNrfcS/$)Nrxrrr2r0MetricInfo.s(r2)default_factoryrdTrequires_contiguous_outr)rrrrrrsetr rf dataclassesfieldrdlistr/rOrrr2r0r&r&s\ SM"&Ix$%#((9KLE49L$(T(r2r&r)r'r(r r)r*rr>chchebcheby chebychevrr>rcbcblockrrcorcosr rO)r'r(rdr r)r*r >eeueuclidr r >hhahammr matchingrx)r'r(rdrfr r)r*r>jjajaccrrrrr>mahmahalr)r'r(rfr r)r*r>rumipnormrrrr>sserrrr>sqesqeuclidrrtest_rc [USSSSS9nURn[U5S:wa [S5eUupV[ U5(aD[ USS5n[ RUS5nUb[XXh40UD6up n[U4XS .UD6$[U[5(aUR5n[ RUS5nUbURn U "U4S U0UD6$URS 5(aS[RUS5nUc[S US S35e[XXh40UD6up n[U4UR US .UD6$[SU35e[#S5e)a# Pairwise distances between observations in n-dimensional space. See Notes for common calling conventions. Parameters ---------- X : array_like An m by n array of m original observations in an n-dimensional space. metric : str or function, optional The distance metric to use. The distance function can be 'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'dice', 'euclidean', 'hamming', 'jaccard', 'jensenshannon', 'kulczynski1', 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'. out : ndarray, optional The output array. If not None, condensed distance matrix Y is stored in this array. **kwargs : dict, optional Extra arguments to `metric`: refer to each metric documentation for a list of all possible arguments. Some possible arguments: p : scalar The p-norm to apply for Minkowski, weighted and unweighted. Default: 2. w : ndarray The weight vector for metrics that support weights (e.g., Minkowski). V : ndarray The variance vector for standardized Euclidean. Default: var(X, axis=0, ddof=1) VI : ndarray The inverse of the covariance matrix for Mahalanobis. Default: inv(cov(X.T)).T Returns ------- Y : ndarray Returns a condensed distance matrix Y. For each :math:`i` and :math:`j` (where :math:`i 0` (note that this is only a quasi-metric if :math:`0 < p < 1`). 3. ``Y = pdist(X, 'cityblock')`` Computes the city block or Manhattan distance between the points. 4. ``Y = pdist(X, 'seuclidean', V=None)`` Computes the standardized Euclidean distance. The standardized Euclidean distance between two n-vectors ``u`` and ``v`` is .. math:: \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. 5. ``Y = pdist(X, 'sqeuclidean')`` Computes the squared Euclidean distance :math:`\|u-v\|_2^2` between the vectors. 6. ``Y = pdist(X, 'cosine')`` Computes the cosine distance between vectors u and v, .. math:: 1 - \frac{u \cdot v} {{\|u\|}_2 {\|v\|}_2} where :math:`\|*\|_2` is the 2-norm of its argument ``*``, and :math:`u \cdot v` is the dot product of ``u`` and ``v``. 7. ``Y = pdist(X, 'correlation')`` Computes the correlation distance between vectors u and v. This is .. math:: 1 - \frac{(u - \bar{u}) \cdot (v - \bar{v})} {{\|(u - \bar{u})\|}_2 {\|(v - \bar{v})\|}_2} where :math:`\bar{v}` is the mean of the elements of vector v, and :math:`x \cdot y` is the dot product of :math:`x` and :math:`y`. 8. ``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. 9. ``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. 10. ``Y = pdist(X, 'jensenshannon')`` Computes the Jensen-Shannon distance between two probability arrays. Given two probability vectors, :math:`p` and :math:`q`, the Jensen-Shannon distance is .. math:: \sqrt{\frac{D(p \parallel m) + D(q \parallel m)}{2}} where :math:`m` is the pointwise mean of :math:`p` and :math:`q` and :math:`D` is the Kullback-Leibler divergence. 11. ``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 .. math:: d(u,v) = \max_i {|u_i-v_i|} 12. ``Y = pdist(X, 'canberra')`` Computes the Canberra distance between the points. The Canberra distance between two points ``u`` and ``v`` is .. math:: d(u,v) = \sum_i \frac{|u_i-v_i|} {|u_i|+|v_i|} 13. ``Y = pdist(X, 'braycurtis')`` Computes the Bray-Curtis distance between the points. The Bray-Curtis distance between two points ``u`` and ``v`` is .. math:: d(u,v) = \frac{\sum_i {|u_i-v_i|}} {\sum_i {|u_i+v_i|}} 14. ``Y = pdist(X, 'mahalanobis', VI=None)`` Computes the Mahalanobis distance between the points. The Mahalanobis distance between two points ``u`` and ``v`` is :math:`\sqrt{(u-v)(1/V)(u-v)^T}` where :math:`(1/V)` (the ``VI`` variable) is the inverse covariance. If ``VI`` is not None, ``VI`` will be used as the inverse covariance matrix. 15. ``Y = pdist(X, 'yule')`` Computes the Yule distance between each pair of boolean vectors. (see yule function documentation) 16. ``Y = pdist(X, 'matching')`` Synonym for 'hamming'. 17. ``Y = pdist(X, 'dice')`` Computes the Dice distance between each pair of boolean vectors. (see dice function documentation) 18. ``Y = pdist(X, 'kulczynski1')`` Computes the kulczynski1 distance between each pair of boolean vectors. (see kulczynski1 function documentation) .. deprecated:: 1.15.0 This metric is deprecated and will be removed in SciPy 1.17.0. Replace usage of ``pdist(X, 'kulczynski1')`` with ``1 / pdist(X, 'jaccard') - 1``. 19. ``Y = pdist(X, 'rogerstanimoto')`` Computes the Rogers-Tanimoto distance between each pair of boolean vectors. (see rogerstanimoto function documentation) 20. ``Y = pdist(X, 'russellrao')`` Computes the Russell-Rao distance between each pair of boolean vectors. (see russellrao function documentation) 21. ``Y = pdist(X, 'sokalmichener')`` Computes the Sokal-Michener distance between each pair of boolean vectors. (see sokalmichener function documentation) .. deprecated:: 1.15.0 This metric is deprecated and will be removed in SciPy 1.17.0. Replace usage of ``pdist(X, 'sokalmichener')`` with ``pdist(X, 'rogerstanimoto')``. 22. ``Y = pdist(X, 'sokalsneath')`` Computes the Sokal-Sneath distance between each pair of boolean vectors. (see sokalsneath function documentation) 23. ``Y = pdist(X, 'kulczynski1')`` Computes the Kulczynski 1 distance between each pair of boolean vectors. (see kulczynski1 function documentation) 24. ``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 :math:`{n \choose 2}` times, which is inefficient. Instead, the optimized C version is more efficient, and we call it using the following syntax.:: dm = pdist(X, 'sokalsneath') Examples -------- >>> import numpy as np >>> from scipy.spatial.distance import pdist ``x`` is an array of five points in three-dimensional space. >>> x = np.array([[2, 0, 2], [2, 2, 3], [-2, 4, 5], [0, 1, 9], [2, 2, 4]]) ``pdist(x)`` with no additional arguments computes the 10 pairwise Euclidean distances: >>> pdist(x) array([2.23606798, 6.40312424, 7.34846923, 2.82842712, 4.89897949, 6.40312424, 1. , 5.38516481, 4.58257569, 5.47722558]) The following computes the pairwise Minkowski distances with ``p = 3.5``: >>> pdist(x, metric='minkowski', p=3.5) array([2.04898923, 5.1154929 , 7.02700737, 2.43802731, 4.19042714, 6.03956994, 1. , 4.45128103, 4.10636143, 5.0619695 ]) The pairwise city block or Manhattan distances: >>> pdist(x, metric='cityblock') array([ 3., 11., 10., 4., 8., 9., 1., 9., 7., 8.]) FT) sparse_ok objects_okmask_ok check_finiter(z%A 2-dimensional array must be passed.rUnknownCustomMetricNrrrrN Unknown "Test" Distance Metric: Unknown Distance Metric: >2nd argument metric must be a string identifier or a function.)r"rqrrrcallabler _METRIC_ALIASryrr!rrlowerr* startswith _TEST_METRICSr r) rArrr=rJrurimstrrjrkr#s r0rrs\ 1$(- /A A 1v{@AA DAvz+@A#''d3  "2a0(.0NAFqCCFCC FC ||~#''d3  ""--HA131&1 1 __W % %'++D$7K" #CDH:!NOO2a0(.0NAF"D%//SD= 1`` encoding distances as described, ``X = squareform(v)`` returns a n-by-n distance matrix ``X``. The ``X[i, j]`` and ``X[j, i]`` values are set to :math:`v[{n \choose 2} - {n-i \choose 2} + (j-i-1)]` and all diagonal elements are zero. In SciPy 0.19.0, ``squareform`` stopped casting all input types to float64, and started returning arrays of the same dtype as the input. Examples -------- >>> import numpy as np >>> from scipy.spatial.distance import pdist, squareform ``x`` is an array of five points in three-dimensional space. >>> x = np.array([[2, 0, 2], [2, 2, 3], [-2, 4, 5], [0, 1, 9], [2, 2, 4]]) ``pdist(x)`` computes the Euclidean distances between each pair of points in ``x``. The distances are returned in a one-dimensional array with length ``5*(5 - 1)/2 = 10``. >>> distvec = pdist(x) >>> distvec array([2.23606798, 6.40312424, 7.34846923, 2.82842712, 4.89897949, 6.40312424, 1. , 5.38516481, 4.58257569, 5.47722558]) ``squareform(distvec)`` returns the 5x5 distance matrix. >>> m = squareform(distvec) >>> m array([[0. , 2.23606798, 6.40312424, 7.34846923, 2.82842712], [2.23606798, 0. , 4.89897949, 6.40312424, 1. ], [6.40312424, 4.89897949, 0. , 5.38516481, 4.58257569], [7.34846923, 6.40312424, 5.38516481, 0. , 5.47722558], [2.82842712, 1. , 4.58257569, 5.47722558, 0. ]]) When given a square distance matrix ``m``, ``squareform(m)`` returns the one-dimensional condensed distance vector associated with the matrix. In this case, we recover ``distvec``. >>> squareform(m) array([2.23606798, 6.40312424, 7.34846923, 2.82842712, 4.89897949, 6.40312424, 1. , 5.38516481, 4.58257569, 5.47722558]) tomatrixr%z8Forcing 'tomatrix' but input X is not a distance vector.tovectorr(z8Forcing 'tovector' but input X is not a distance matrix.r)r%r%rEz_Incompatible vector size. It must be a binomial coefficient n choose 2 for some integer n >= 2.z#The matrix argument must be square.TrAthrownamez;The first argument must be one or two dimensional array. A z#-dimensional array is not permitted)rGrHrqr\rrrzerosrFrRceilrr1r&to_squareform_from_vector_wrapr rto_vector_from_squareform_wrap)rAforcechecksrJrMrUs r0rr" sl QA A {{} " q6Q;01 1  * $ q6Q;01 1 1v{ Q41988F!''2 2 !q)* + A;!A$( "OP P HHaV177 + ( * 55a; Q1 Q41Q4<BC C  C 0 aD 688Bagg. . HHaq5ka'qww 7 ( * 55a;%%(VH,OQR Rr2c[R"USS9nSnURn[UR5S:wa!U(a[ SUS35e[ S5eUS:XaXR :HR 5(d!U(a[ SUS 35e[ S 5eU[S US 5[S US 54S :HR 5(d!U(a[ SUS 35e[ S 5eU$XR - U:*R 5(d*U(a[ SUSUSS35e[ SUSS35eU[S US 5[S US 54U:*R 5(d2U(a[ SUSUSS35e[ SR"U65eU$![a:nU(aeU(a[R"[U5SS9 SnSnAU$SnAff=f)a Return True if input array is a valid distance matrix. Distance matrices must be 2-dimensional numpy arrays. They must have a zero-diagonal, and they must be symmetric. Parameters ---------- D : array_like The candidate object to test for validity. tol : float, optional The distance matrix should be symmetric. `tol` is the maximum difference between entries ``ij`` and ``ji`` for the distance metric to be considered symmetric. throw : bool, optional An exception is thrown if the distance matrix passed is not valid. name : str, optional The name of the variable to checked. This is useful if throw is set to True so the offending variable can be identified in the exception message when an exception is thrown. warning : bool, optional Instead of throwing an exception, a warning message is raised. Returns ------- valid : bool True if the variable `D` passed is a valid distance matrix. Notes ----- Small numerical differences in `D` and `D.T` and non-zeroness of the diagonal are ignored if they are within the tolerance specified by `tol`. Examples -------- >>> import numpy as np >>> from scipy.spatial.distance import is_valid_dm This matrix is a valid distance matrix. >>> d = np.array([[0.0, 1.1, 1.2, 1.3], ... [1.1, 0.0, 1.0, 1.4], ... [1.2, 1.0, 0.0, 1.5], ... [1.3, 1.4, 1.5, 0.0]]) >>> is_valid_dm(d) True In the following examples, the input is not a valid distance matrix. Not square: >>> is_valid_dm([[0, 2, 2], [2, 0, 2]]) False Nonzero diagonal element: >>> is_valid_dm([[0, 1, 1], [1, 2, 3], [1, 3, 0]]) False Not symmetric: >>> is_valid_dm([[0, 1, 3], [2, 0, 1], [3, 1, 0]]) False rrTr(zDistance matrix 'z.' must have shape=2 (i.e. be two-dimensional).z">??!"899 #:H>>##$'8>R%STT$%IJJeAqtneAqtn45:??AA$'8>V%WXX$%MNN B4 L)GsN''))$'9$@CCFt*A&OPP%&225d1&>??eAqtneAqtn45<AACC$'9$@GGJ4jPQ&STT%'JKQ6&RSV&XYY D L     MM#a&Q / L sC&F<B7F<< H/G;;Hc"[R"USS9nSn[UR5S:wa!U(a[ SUS35e[ S5eURSn[ [R "[R"US -555nXfS- -S - U:wa!U(a[ S US 35e[ S 5eU$![a:nU(aeU(a[R"[U5S S 9 SnSnAU$SnAff=f)a  Return True if the input array is a valid condensed distance matrix. Condensed distance matrices must be 1-dimensional numpy arrays. Their length must be a binomial coefficient :math:`{n \choose 2}` for some positive integer n. Parameters ---------- y : array_like The condensed distance matrix. warning : bool, optional Invokes a warning if the variable passed is not a valid condensed distance matrix. The warning message explains why the distance matrix is not valid. `name` is used when referencing the offending variable. throw : bool, optional Throws an exception if the variable passed is not a valid condensed distance matrix. name : bool, optional Used when referencing the offending variable in the warning or exception message. Returns ------- bool True if the input array is a valid condensed distance matrix, False otherwise. Examples -------- >>> from scipy.spatial.distance import is_valid_y This vector is a valid condensed distance matrix. The length is 6, which corresponds to ``n = 4``, since ``4*(4 - 1)/2`` is 6. >>> v = [1.0, 1.2, 1.0, 0.5, 1.3, 0.9] >>> is_valid_y(v) True An input vector with length, say, 7, is not a valid condensed distance matrix. >>> is_valid_y([1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7]) False rrTr%zCondensed distance matrix 'z.' must have shape=1 (i.e. be one-dimensional).zFCondensed distance matrix must have shape=1 (i.e. be one-dimensional).rr(z'Length n of condensed distance matrix 'zS' must be a binomial coefficient, i.e.there must be a k such that (k \choose 2)=n)!zxLength n of condensed distance matrix must be a binomial coefficient, i.e. there must be a k such that (k \choose 2)=n)!rFN) rGrrrqrrrRrgrrrrrr)yrurdrervrirr<s r0rr- s'` 1C A E qww<1  #>tfEK"KLL!">?? GGAJ A' ( QK!O ! #J4&QR"RSS!"GHH " L     MM#a&Q / L sB.C D/D  Dc~[R"USS9n[U[RSSS9 URS$)a Return the number of original observations that correspond to a square, redundant distance matrix. Parameters ---------- d : array_like The target distance matrix. Returns ------- num_obs_dm : int The number of observations in the redundant distance matrix. Examples -------- Find the number of original observations corresponding to a square redundant distance matrix d. >>> from scipy.spatial.distance import num_obs_dm >>> d = [[0, 100, 200], [100, 0, 150], [200, 150, 0]] >>> num_obs_dm(d) 3 rrTr)rtrdrer)rGrr rrq)rs r0rr{ s42 1C ArvvT4 771:r2c$[R"USS9n[USSS9 URSnUS:Xa [ S5e[ [R "[R"US-555nX"S - -S- U:wa [ S 5eU$) a Return the number of original observations that correspond to a condensed distance matrix. Parameters ---------- Y : array_like Condensed distance matrix. Returns ------- n : int The number of observations in the condensed distance matrix `Y`. Examples -------- Find the number of original observations corresponding to a condensed distance matrix Y. >>> from scipy.spatial.distance import num_obs_y >>> Y = [1, 2, 3.5, 7, 10, 4] >>> num_obs_y(Y) 4 rrTYrcrzLThe number of observations cannot be determined on an empty distance matrix.r(r%z^Invalid condensed distance matrix passed. Must be some k where k=(n choose 2) for some n >= 2.)rGrrrqrrrRrgr)r{krs r0rr s2 1C Aq3'  AAv56 6 BGGBGGAEN #$A U aAHI I Hr2cUc[R"X!S9$URU:wa [S5eURR (d [S5eUR [R:wa [S5eU$)NrEz!Output array has incorrect shape.z"Output array must be C-contiguous.z!Output array must be double type.)rGemptyrqrrflags c_contiguousrFr)rrFexpected_shapes r0rr sh {xx44 yyN"<== 99 ! !=>> yyBJJ<== Jr2c (URSnXDS- -S-n[U[RU45nSn[ URSS- 5H;n[ US-URS5Hn U"XX 40UD6Xg'US- nM M= U$)Nrr%r(rqrrGrrp) rArrr=rir"r<r|irCs r0r!r! s  AU !H sBJJ "q1uaggaj)A1400BE FA*# Ir2c URSnURSn[U[RXV45n[ U5H'n[ U5Hn U"XX40UD6XxU 4'M M) U$)Nrr) r:r;rrr=rgrhr<rrCs r0r r  sn !B !B sBJJ 9B 2YrAbeRU5f5B!tH Ir2c [R"U5n[R"U5nURnURn[U5S:wa [ S5e[U5S:wa [ S5eUSUS:wa [ S5eUSnUSnUSn [ U5(aE[ USS5n [RU S 5n U b[XXxX40UD6upp[X4X#S .UD6$[U[5(aUR5n [RU S 5n U bU Rn U "X4S U0UD6$U RS 5(aT[ RU S 5n U c[ S U SS 35e[XXxX40UD6upp[X4U R"US .UD6$[ SU 35e[%S5e)a$ Compute distance between each pair of the two collections of inputs. See Notes for common calling conventions. Parameters ---------- XA : array_like An :math:`m_A` by :math:`n` array of :math:`m_A` original observations in an :math:`n`-dimensional space. Inputs are converted to float type. XB : array_like An :math:`m_B` by :math:`n` array of :math:`m_B` original observations in an :math:`n`-dimensional space. Inputs are converted to float type. metric : str or callable, optional The distance metric to use. If a string, the distance function can be 'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'dice', 'euclidean', 'hamming', 'jaccard', 'jensenshannon', 'kulczynski1', 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'. **kwargs : dict, optional Extra arguments to `metric`: refer to each metric documentation for a list of all possible arguments. Some possible arguments: p : scalar The p-norm to apply for Minkowski, weighted and unweighted. Default: 2. w : array_like The weight vector for metrics that support weights (e.g., Minkowski). V : array_like The variance vector for standardized Euclidean. Default: var(vstack([XA, XB]), axis=0, ddof=1) VI : array_like The inverse of the covariance matrix for Mahalanobis. Default: inv(cov(vstack([XA, XB].T))).T out : ndarray The output array If not None, the distance matrix Y is stored in this array. Returns ------- Y : ndarray A :math:`m_A` by :math:`m_B` distance matrix is returned. For each :math:`i` and :math:`j`, the metric ``dist(u=XA[i], v=XB[j])`` is computed and stored in the :math:`ij` th entry. Raises ------ ValueError An exception is thrown if `XA` and `XB` do not have the same number of columns. Notes ----- The following are common calling conventions: 1. ``Y = cdist(XA, XB, 'euclidean')`` Computes the distance between :math:`m` points using Euclidean distance (2-norm) as the distance metric between the points. The points are arranged as :math:`m` :math:`n`-dimensional row vectors in the matrix X. 2. ``Y = cdist(XA, XB, 'minkowski', p=2.)`` Computes the distances using the Minkowski distance :math:`\|u-v\|_p` (:math:`p`-norm) where :math:`p > 0` (note that this is only a quasi-metric if :math:`0 < p < 1`). 3. ``Y = cdist(XA, XB, 'cityblock')`` Computes the city block or Manhattan distance between the points. 4. ``Y = cdist(XA, XB, 'seuclidean', V=None)`` Computes the standardized Euclidean distance. The standardized Euclidean distance between two n-vectors ``u`` and ``v`` is .. math:: \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. 5. ``Y = cdist(XA, XB, 'sqeuclidean')`` Computes the squared Euclidean distance :math:`\|u-v\|_2^2` between the vectors. 6. ``Y = cdist(XA, XB, 'cosine')`` Computes the cosine distance between vectors u and v, .. math:: 1 - \frac{u \cdot v} {{\|u\|}_2 {\|v\|}_2} where :math:`\|*\|_2` is the 2-norm of its argument ``*``, and :math:`u \cdot v` is the dot product of :math:`u` and :math:`v`. 7. ``Y = cdist(XA, XB, 'correlation')`` Computes the correlation distance between vectors u and v. This is .. math:: 1 - \frac{(u - \bar{u}) \cdot (v - \bar{v})} {{\|(u - \bar{u})\|}_2 {\|(v - \bar{v})\|}_2} where :math:`\bar{v}` is the mean of the elements of vector v, and :math:`x \cdot y` is the dot product of :math:`x` and :math:`y`. 8. ``Y = cdist(XA, XB, '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. 9. ``Y = cdist(XA, XB, '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 where at least one of them is non-zero. 10. ``Y = cdist(XA, XB, 'jensenshannon')`` Computes the Jensen-Shannon distance between two probability arrays. Given two probability vectors, :math:`p` and :math:`q`, the Jensen-Shannon distance is .. math:: \sqrt{\frac{D(p \parallel m) + D(q \parallel m)}{2}} where :math:`m` is the pointwise mean of :math:`p` and :math:`q` and :math:`D` is the Kullback-Leibler divergence. 11. ``Y = cdist(XA, XB, '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 .. math:: d(u,v) = \max_i {|u_i-v_i|}. 12. ``Y = cdist(XA, XB, 'canberra')`` Computes the Canberra distance between the points. The Canberra distance between two points ``u`` and ``v`` is .. math:: d(u,v) = \sum_i \frac{|u_i-v_i|} {|u_i|+|v_i|}. 13. ``Y = cdist(XA, XB, 'braycurtis')`` Computes the Bray-Curtis distance between the points. The Bray-Curtis distance between two points ``u`` and ``v`` is .. math:: d(u,v) = \frac{\sum_i (|u_i-v_i|)} {\sum_i (|u_i+v_i|)} 14. ``Y = cdist(XA, XB, 'mahalanobis', VI=None)`` Computes the Mahalanobis distance between the points. The Mahalanobis distance between two points ``u`` and ``v`` is :math:`\sqrt{(u-v)(1/V)(u-v)^T}` where :math:`(1/V)` (the ``VI`` variable) is the inverse covariance. If ``VI`` is not None, ``VI`` will be used as the inverse covariance matrix. 15. ``Y = cdist(XA, XB, 'yule')`` Computes the Yule distance between the boolean vectors. (see `yule` function documentation) 16. ``Y = cdist(XA, XB, 'matching')`` Synonym for 'hamming'. 17. ``Y = cdist(XA, XB, 'dice')`` Computes the Dice distance between the boolean vectors. (see `dice` function documentation) 18. ``Y = cdist(XA, XB, 'kulczynski1')`` Computes the kulczynski distance between the boolean vectors. (see `kulczynski1` function documentation) .. deprecated:: 1.15.0 This metric is deprecated and will be removed in SciPy 1.17.0. Replace usage of ``cdist(XA, XB, 'kulczynski1')`` with ``1 / cdist(XA, XB, 'jaccard') - 1``. 19. ``Y = cdist(XA, XB, 'rogerstanimoto')`` Computes the Rogers-Tanimoto distance between the boolean vectors. (see `rogerstanimoto` function documentation) 20. ``Y = cdist(XA, XB, 'russellrao')`` Computes the Russell-Rao distance between the boolean vectors. (see `russellrao` function documentation) 21. ``Y = cdist(XA, XB, 'sokalmichener')`` Computes the Sokal-Michener distance between the boolean vectors. (see `sokalmichener` function documentation) .. deprecated:: 1.15.0 This metric is deprecated and will be removed in SciPy 1.17.0. Replace usage of ``cdist(XA, XB, 'sokalmichener')`` with ``cdist(XA, XB, 'rogerstanimoto')``. 22. ``Y = cdist(XA, XB, 'sokalsneath')`` Computes the Sokal-Sneath distance between the vectors. (see `sokalsneath` function documentation) 23. ``Y = cdist(XA, XB, 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 = cdist(XA, XB, 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 = cdist(XA, XB, sokalsneath) would calculate the pair-wise distances between the vectors in X using the Python function `sokalsneath`. This would result in sokalsneath being called :math:`{n \choose 2}` times, which is inefficient. Instead, the optimized C version is more efficient, and we call it using the following syntax:: dm = cdist(XA, XB, 'sokalsneath') Examples -------- Find the Euclidean distances between four 2-D coordinates: >>> from scipy.spatial import distance >>> import numpy as np >>> coords = [(35.0456, -85.2672), ... (35.1174, -89.9711), ... (35.9728, -83.9422), ... (36.1667, -86.7833)] >>> distance.cdist(coords, coords, 'euclidean') array([[ 0. , 4.7044, 1.6172, 1.8856], [ 4.7044, 0. , 6.0893, 3.3561], [ 1.6172, 6.0893, 0. , 2.8477], [ 1.8856, 3.3561, 2.8477, 0. ]]) Find the Manhattan distance from a 3-D point to the corners of the unit cube: >>> a = np.array([[0, 0, 0], ... [0, 0, 1], ... [0, 1, 0], ... [0, 1, 1], ... [1, 0, 0], ... [1, 0, 1], ... [1, 1, 0], ... [1, 1, 1]]) >>> b = np.array([[ 0.1, 0.2, 0.4]]) >>> distance.cdist(a, b, 'cityblock') array([[ 0.7], [ 0.9], [ 1.3], [ 1.5], [ 1.5], [ 1.7], [ 2.1], [ 2.3]]) r(z!XA must be a 2-dimensional array.z!XB must be a 2-dimensional array.r%zHXA and XB must have the same number of columns (i.e. feature dimension.)rrUnknownNrUrrNrVrWrXrY)rGrrqrrrrZrr[ryrmr rrr\r)r]r^r r)r:r;rrr=rJsBrgrhrir_rjrkrs r0rr sn BB BB A B 1v{<== 2w!|<==tr!u}56 6 1B AB !Avz95#''d3  ""7#:28#: BCrHfHHH FC ||~#''d3  ""--HB66v6 6 __W % %'++D$7K" #CDH:!NOO"7#:28#: BC"I*44#IAGI I8?@ @)* *r2)N)r)r(N)NT)r )noT)rFrsF)FFN)|__doc____all__rrnumpyrGr1collections.abcr functoolsr!scipy._lib._utilr"r#scipy._lib.deprecationr$r&r'rr)specialr*r+r1r>rCrJr]r_rmrvr{rrrrrrrsr rr rrrr r_deprecated_kulczynski1rrrrrrrrrr rr_deprecated_sokalmichenerrrrrO_convert_to_boolpdist_correlation_double_wrapcdist_correlation_double_wrap dataclassrrr&cdist_braycurtispdist_braycurtiscdist_canberrapdist_canberracdist_chebyshevpdist_chebyshevcdist_cityblockpdist_cityblock cdist_dice pdist_dicecdist_euclideanpdist_euclidean cdist_hamming pdist_hamming cdist_jaccard pdist_jaccardcdist_kulczynski1pdist_kulczynski1cdist_minkowskipdist_minkowskicdist_rogerstanimotopdist_rogerstanimotocdist_russellraopdist_russellraocdist_sokalmichenerpdist_sokalmichenercdist_sokalsneathpdist_sokalsneathcdist_sqeuclideanpdist_sqeuclidean cdist_yule pdist_yule _METRIC_INFOSr'r r(r[r3keys_METRICS_NAMESr^rrr rrrrr!r r)infoaliass00r0rsFT B $C. B > 3 0(   & &4 "zz F>|?|~DN$%N1hU#p02f7tw0t&EEP-"`+\,^:z-(`4 nU1uUp/:d>@B/Md6r(4K4Kn9,x- C+d;0G,/F, d#$4 d#$0 d#))$)0# N#44#44 ! L#22#22 " =#33#33 " .#33#33 $ D !%m4%m4  u %h/%h/  Hh#..#.. " .#33#33  6 *#11#11 * #11#11 & d #%o6%o6 $ Oh*+;+M+MN*+;+M+MN $ +.%m4%m4 " -,#33#33 '  h #88#88 # Nh#44#44 # %-%l3%l3 &  h,-=-Q-QR,-=-Q-QR $ Oh#55#55 $ .#55#55  Hh#..#.. sa F3@ @-$   %- @!.,!."&(("*!., hmmo&ANO4...4O S*S*l VRrodK\<# L  b*Tb*A A, Ps2S S!S'