o {i@srddlZddlZddlmZmZmZmZmZm Z m Z m Z ddlm Z ddl mZddlmZddlmZejdejdZejdejdZejd ejdZeejjZeejjZ ed d Z!ej"d d ddZ#ej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej j%ej j&ddddZ'ej"d d efddZ(ej"d d ddZ)ej"d d ddZ*ej"d d dddZ+ej"d d edfd d!Z,ej"d d efd"d#Z-ej"d d d$d%Z.ej"d d d&d'Z/ej"d d d(d)Z0ej"d d d*d+Z1ej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej j2ej j2ej j%ej j&d,dd-d.Z3ej4d d d/d0Z5ej"d d d1d2Z6ej"d d d3d4Z7ej"d d d5d6Z8ej"d d d7d8Z9ej"d d d9d:Z:ej"d d d;d<Z;ej"d d d=d>Zej"d d dCdDZ?ej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej j%ej j&dEddFdGZ@ej"dd ej jej j%ej j&dHddIdJZAej"dej ej j$ej jddd dej j$ej jddd dgd ej jej j%ej j&dHddKdLZBej4d d dMdNZCej"dd ej jej j%ej j&dHddOdPZDej"dej ej j$ej jddd dej j$ej jddd dgd ej jej j%ej j&dHddQdRZEej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej jej j%ej j&dSddTdUZFej4d d dVdWZGej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej jej jej j%ej j&dXddYdZZHej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej jej jej jej jej j%ej j&d[ dd\d]ZIej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej jej jej jej j%ej j&d^dd_d`ZJej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej j%ej j&daddbdcZKej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej jej jej jej jej j%ej j&dd ddedfZLej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej jej jej jej jej j%ej j&d[ ddgdhZMej"d d didjZNej"d d dkdlZOej4d d dmdnZPej"d d dodpZQej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej j%ej j&dqddrdsZRej"dej ej j$ej jddd dej j$ej jddd dgd ej jej jej jej j%ej j&dqddtduZSej4d d dvdwZTe"ddydzZUej"d d d{d|ZVej"d d}ed~fddZWej"d d edfddZXe"ddZYe"dddZZe"dddZ[e"ddZ\ej"dej ej j$ej j2ddd dej j$ej j2ddd dgd d dej j]ej j2ej j%ej j&ddddZ^ej"dej ej j$ej j2ddd dej j$ej j2ddd dgd d dej j]ej j]ej j2ej j2ej j%ej j&ddddZ_ej"dej ej j$ej jddd dej j$ej j2ddd dej j$ej jddd dgd d dej jej j%ej j&ej jddddZ`ej"dej ej j$ej jddd dej j$ej j2ddd dej j$ej jddd dgd d dej jej jej jej j%ej j&dEdddZaej"dej ej j$ej jddd dej j$ej j2ddd dej j$ej jddd dgd ej jej j%ej j&dHdddZbej"dej ej j$ej jddd dej j$ej j2ddd dej j$ej jddd dgd ej j2ej jej j%ej j&ddddZcej"dej ej j$ej jddd dej j$ej j2ddd dej j$ej jddd dgd ej j2ej jej j%ej j&ddddZdej"dej ej j$ej jddd dej j$ej j2ddd dej j$ej jddd dgd ej j2ej jej j%ej j&ddddZeide#de#de'de)de)de)de*de*de*de*de+de(de(de,d!e,d#e-d'e/idDe?dJeAdPeDdpeQd@e=de0d|eVdjeNdleOdseRdeWdeWdeZdeZdeZdeZde[ide[deXdeYdeYde\de\de\d%e.d+e1d4e7d2e6d6e8de9d:e:de<de;dBe>e^e_dZfe'ejgde'ejgde@eCdeBeCdeEeGde@ePdeSeTde3e5ddZheFeDdeHeZdeHeZdeIeWdeIeWdeJe[deJe[deKeYdeKeYdeLe\deLe\deMeXdd Zie^e^e_e_e^e_de`e`eaebdececedeeddœZjdS)N)allocate_graph_structuresinitialize_graph_structuresinitialize_supplyinitialize_costnetwork_simplex_core total_cost ProblemStatussinkhorn_transport_plan)types) intrinsic)cgutils)irdtype)rrcCsttj}dd}||fS)z1Hardware popcount for uint8 using LLVM intrinsic.c Ss<|\}|j}t||g}t|j|d}|||g}|S)Nz llvm.ctpop.i8)typellvm_ir FunctionTyper get_or_insert_functionmodulecall) contextbuildersigargsvalllvm_i8fnty llvm_ctpopresultr I/home/ubuntu/.local/lib/python3.10/site-packages/pynndescent/distances.pypopcnt_u8_impl$sz!popcnt_u8..popcnt_u8_impl)r uint8) typingctxrrr"r r r! popcnt_u8s  r%T)fastmathcCs:d}t|jdD]}|||||d7}q t|S)z_Standard euclidean distance. .. math:: D(x, y) = \\sqrt{\sum_i (x_i - y_i)^2} rrrangeshapenpsqrtxyrir r r! euclidean2s r1zf4(f4[::1],f4[::1])C)readonly)rdiffdimr0)r&localscCs<d}|jd}t|D]}||||}|||7}q |S)zVSquared euclidean distance. .. math:: D(x, y) = \sum_i (x_i - y_i)^2 r'rr*r))r.r/rr6r0r5r r r!squared_euclidean?s   r9cCsBd}t|jdD]}|||||d||7}q t|S)zEuclidean distance standardised against a vector of standard deviations per coordinate. .. math:: D(x, y) = \sqrt{\sum_i \frac{(x_i - y_i)**2}{v_i}} r'rrr()r.r/sigmarr0r r r!standardised_euclidean^s" r;cCs6d}t|jdD]}|t||||7}q |S)z\Manhattan, taxicab, or l1 distance. .. math:: D(x, y) = \sum_i |x_i - y_i| r'rr)r*r+absr-r r r! manhattanmsr>cCs8d}t|jdD]}t|t||||}q |S)zZChebyshev or l-infinity distance. .. math:: D(x, y) = \max_i |x_i - y_i| r'r)r)r*maxr+r=r-r r r! chebyshev{sr@cCsBd}t|jdD]}|t|||||7}q |d|S)ahMinkowski distance. .. math:: D(x, y) = \left(\sum_i |x_i - y_i|^p\right)^{\frac{1}{p}} This is a general distance. For p=1 it is equivalent to manhattan distance, for p=2 it is Euclidean distance, and for p=infinity it is Chebyshev distance. In general it is better to use the more specialised functions for those distances. r'r?r<)r.r/prr0r r r! minkowskis   rCcCsJd}t|jdD]}|||t|||||7}q |d|S)aWA weighted version of Minkowski distance. .. math:: D(x, y) = \left(\sum_i w_i |x_i - y_i|^p\right)^{\frac{1}{p}} If weights w_i are inverse standard deviations of graph_data in each dimension then this represented a standardised Minkowski distance (and is equivalent to standardised Euclidean distance for p=1). r'rrAr<)r.r/wrBrr0r r r!weighted_minkowskis ( rEcCsd}tj|jdtjd}t|jdD] }||||||<qt|jdD]"}d}t|jdD]}||||f||7}q3||||7}q(t|S)zMahalanobis distance. .. math:: D(x, y) = \sqrt{(x - y)^T V^{-1} (x - y)} where V is the covariance matrix. This is equivalent to Euclidean distance after transforming the space by the inverse square root of the covariance. r'rr)r+emptyr*float32r)r,)r.r/vinvrr5r0tmpjr r r! mahalanobiss  rKcCsBd}t|jdD]}||||kr|d7}q t||jdS)zHamming distance. The proportion of elements that differ between two vectors. .. math:: D(x, y) = \frac{1}{n} \sum_i \mathbf{1}_{x_i \neq y_i} r'rrAr)r*floatr-r r r!hammings  rNcCs^d}t|jdD]#}t||t||}|dkr,|t|||||7}q |S)zCanberra distance. A weighted version of Manhattan distance where each term is divided by the sum of absolute values. .. math:: D(x, y) = \sum_i \frac{|x_i - y_i|}{|x_i| + |y_i|} r'rr<)r.r/rr0 denominatorr r r!canberras rPcCshd}d}t|jdD]}|t||||7}|t||||7}q |dkr2t||SdS)zBray-Curtis distance. A distance measure commonly used in ecology to quantify the compositional dissimilarity between two samples. .. math:: D(x, y) = \frac{\sum_i |x_i - y_i|}{\sum_i |x_i + y_i|} r'r)r)r*r+r=rM)r.r/ numeratorrOr0r r r! bray_curtiss  rRcCshd}d}t|jdD]}||dk}||dk}||p|7}||o#|7}q |dkr,dSt|||S)a>Jaccard distance. One minus the Jaccard similarity coefficient. For binary vectors this is the size of the symmetric difference divided by the size of the union. .. math:: D(x, y) = 1 - \frac{|x \cap y|}{|x \cup y|} For continuous vectors, non-zero values are treated as set membership. r'rrL)r.r/ num_non_zero num_equalr0x_truey_truer r r!jaccard    rW)rrSrTrUrVr6r0cCsld}d}|jd}t|D]}||dk}||dk}||p|7}||o%|7}q |dkr.dSt|| S)aAlternative Jaccard distance using log transform. A transformed version of Jaccard distance suitable for the bounded-radius search algorithm. Uses negative log of the Jaccard similarity coefficient. .. math:: D_{alt}(x, y) = -\log_2\left(\frac{|x \cap y|}{|x \cup y|}\right) Use `correct_alternative_jaccard` to convert back to standard Jaccard distance. r'r)r*r)r+log2)r.r/rSrTr6r0rUrVr r r!alternative_jaccards     rZcCdtd| S)zConvert alternative Jaccard distance back to standard Jaccard distance. .. math:: D(x, y) = 1 - 2^{-D_{alt}(x, y)} rA@pow)vr r r!correct_alternative_jaccardIr`cCsNd}t|jdD]}||dk}||dk}|||k7}q t||jdS)a5Matching distance (simple matching dissimilarity). The proportion of elements that differ in their boolean state. For binary vectors, counts positions where one is non-zero and the other is zero. .. math:: D(x, y) = \frac{1}{n} \sum_i \mathbf{1}_{(x_i \neq 0) \neq (y_i \neq 0)} r'rrLr.r/ num_not_equalr0rUrVr r r!matchingSs    rdcChd}d}t|jdD]}||dk}||dk}||o|7}|||k7}q |dkr,dS|d||S)uEDice distance (Sørensen-Dice dissimilarity). One minus twice the intersection divided by the sum of cardinalities. Commonly used for comparing the similarity of two samples. .. math:: D(x, y) = \frac{|x \oplus y|}{2|x \cap y| + |x \oplus y|} where :math:`\oplus` denotes symmetric difference. r'rr\r)r*r.r/ num_true_truercr0rUrVr r r!dicegrXricCs|d}d}t|jdD]}||dk}||dk}||o|7}|||k7}q |dkr,dSt|||jd||jdS)a4Kulsinski distance. A variant of Jaccard distance that includes a count of all dimensions. For binary vectors, gives more weight to dimensions where both are false. .. math:: D(x, y) = \frac{|x \oplus y| - |x \cap y| + n}{|x \oplus y| + n} where n is the number of dimensions. r'rrLrgr r r! kulsinskis     rjcCRd}t|jdD]}||dk}||dk}|||k7}q d||jd|S)zRogers-Tanimoto distance. A distance measure for binary vectors that gives double weight to disagreements. .. math:: D(x, y) = \frac{2|x \oplus y|}{n + |x \oplus y|} where n is the number of dimensions. r'rr\rfrbr r r!rogers_tanimoto    rlcCsd}t|jdD]}||dk}||dk}||o|7}q |t|dkkr2|t|dkkr2dSt|jd||jdS)zRussell-Rao distance. The proportion of dimensions where at least one vector has a false value. .. math:: D(x, y) = \frac{n - |x \cap y|}{n} where n is the number of dimensions. r'r)r)r*r+sumrM)r.r/rhr0rUrVr r r! russellraos   $rocCrk)aSokal-Michener distance. Equivalent to Rogers-Tanimoto distance. A distance measure for binary vectors that gives double weight to disagreements. .. math:: D(x, y) = \frac{2|x \oplus y|}{n + |x \oplus y|} where n is the number of dimensions. r'rr\rfrbr r r!sokal_michenerrmrpcCre)zSokal-Sneath distance. A binary distance that gives double weight to agreements (both true). .. math:: D(x, y) = \frac{|x \oplus y|}{0.5|x \cap y| + |x \oplus y|} where :math:`\oplus` denotes symmetric difference. r'r?rfrgr r r! sokal_sneaths    rrcCs|jddkr tdtd|d|d}td|d|d}t|dt|dt|d|d}dt|S)aHaversine (great circle) distance. The angular distance between two points on a sphere, given their latitudes and longitudes in radians. Only valid for 2D data where x[0], y[0] are latitudes and x[1], y[1] are longitudes. .. math:: D(x, y) = 2 \arcsin\left(\sqrt{\sin^2\left(\frac{\phi_1 - \phi_2}{2}\right) + \cos(\phi_1)\cos(\phi_2)\sin^2\left(\frac{\lambda_1 - \lambda_2}{2}\right)}\right) where :math:`\phi` is latitude and :math:`\lambda` is longitude. rrz6haversine is only defined for 2 dimensional graph_datarqr2r\)r* ValueErrorr+sinr,cosarcsin)r.r/sin_latsin_longrr r r! haversines  2ryc Csd}d}d}t|jdD]"}||dk}||dk}||o|7}||o&| 7}|| o-|7}q |jd|||}|dksC|dkrEdSd||||||S)a"Yule distance. A binary distance based on the Yule Q coefficient of association. .. math:: D(x, y) = \frac{2 \cdot n_{TF} \cdot n_{FT}}{n_{TT} \cdot n_{FF} + n_{TF} \cdot n_{FT}} where :math:`n_{TF}` is the count of positions where x is true and y is false, etc. r'rr\rf) r.r/rhnum_true_falsenum_false_truer0rUrVnum_false_falser r r!yule s     r}cCsd}d}d}t|jdD]}|||||7}|||d7}|||d7}q |dkr4|dkr4dS|dks<|dkr>dSd|t||S)a0Cosine distance. One minus the cosine of the angle between two vectors. Measures the angular difference between vectors, independent of their magnitudes. .. math:: D(x, y) = 1 - \frac{\langle x, y \rangle}{\|x\| \|y\|} Returns 0 if both vectors are zero, 1 if one is zero. r'rrrAr()r.r/rnorm_xnorm_yr0r r r!cosine+s r)rr~rr6r0cCsd}d}d}|jd}t|D] }|||||7}|||||7}|||||7}q|dkr:|dkr:dS|dksB|dkrDtS|dkrJtSt|||}t|S)aAlternative cosine distance using log transform. A transformed version of cosine distance suitable for the bounded-radius search algorithm. Uses negative log of the cosine similarity. .. math:: D_{alt}(x, y) = \log_2\left(\frac{\|x\| \|y\|}{\langle x, y \rangle}\right) Returns FLOAT32_MAX for non-positive cosine similarities (treating them as infinitely far). Use `correct_alternative_cosine` to convert back to standard cosine distance. r'rr*r) FLOAT32_MAXr+r,rYr.r/rr~rr6r0r r r!alternative_cosineGs    r)rr6r0cCsDd}|jd}t|D] }|||||7}q |dkrdSd|S)aUDot product distance for normalized vectors. One minus the dot product. This is equivalent to cosine distance when vectors are normalized to unit length. For unnormalized vectors, use `inner_product` distance instead. .. math:: D(x, y) = 1 - \langle x, y \rangle Returns 1.0 for non-positive dot products. r'rrAr8r.r/rr6r0r r r!dotys  rcCsHd}|jd}t|D] }|||||7}q |dkrtSt| S)aAlternative dot product distance using log transform. A transformed version of dot product distance suitable for the bounded-radius search algorithm. Uses negative log of the dot product. .. math:: D_{alt}(x, y) = -\log_2(\langle x, y \rangle) Returns FLOAT32_MAX for non-positive dot products (treating them as infinitely far). Use `correct_alternative_cosine` to convert back to standard dot distance. r'r)r*r)rr+rYrr r r!alternative_dots   rcCr[)z{Convert alternative cosine/dot distance back to standard form. .. math:: D(x, y) = 1 - 2^{-D_{alt}(x, y)} rAr\r]dr r r!correct_alternative_cosinerarcCs6d}|jd}t|D] }|||||7}q | S)aInner product distance (negative inner product). This is useful for retrieval tasks where the inner product represents similarity (higher = more similar). The distance is simply the negation of the inner product, so that higher similarity becomes lower distance. Note: Unlike dot product distance, this does NOT assume normalized vectors. For normalized vectors, use the `dot` distance instead which is bounded [0, 1]. .. math:: D(x, y) = -\sum_i x_i y_i r'rr8rr r r! inner_products   rcCsDd}|jd}t|D] }|||||7}q |dkrtSd|S)uAlternative inner product distance using reciprocal transform. This transforms the inner product into a positive distance suitable for the bounded-radius search algorithm. The transform is: .. math:: D_{alt}(x, y) = \frac{1}{\langle x, y \rangle} This maps positive inner products to positive distances: - High inner product → small positive distance - Low positive inner product → large positive distance - Non-positive inner product → FLOAT32_MAX (treated as infinitely far) In high-dimensional nearest neighbor search, we expect true neighbors to have positive inner products. Pairs with non-positive inner products are treated as maximally distant, similar to how alternative_cosine handles negative cosine similarities. The correction function `correct_alternative_inner_product` converts back to the negative inner product. r'rrAr*r)rrr r r!alternative_inner_products%  r)r ip_resultr~rr6r0cCsd}d}d}|jd}t|D] }|||||7}|||||7}|||||7}q|dks8|dkr:tSt|t|| }|dkrT|dt|StS)aA proxy for inner product distance (negative inner product). Inner product distance has undesirable properties for nearest neighbor graph based search, and NNDescent in general. This is a proxy function that behaves similarly to inner product distance for ranking neighbors, but avoids some of the pitfalls. This is to be used internally, and results should use reranking with true inner product distance. r'rrAr*r)rr+rYr,)r.r/rr~rr6r0 cosine_resultr r r!proxy_inner_products  rcCs|tkrdSd|S)a8Convert alternative inner product distance back to negative inner product. .. math:: D(x, y) = -\langle x, y \rangle = -\frac{1}{D_{alt}(x, y)} For d = FLOAT32_MAX (non-positive inner products), returns 0.0 as the negative inner product (representing orthogonal or dissimilar vectors). r'g)rrr r r!!correct_alternative_inner_productIs r)r l1_norm_x l1_norm_ycdf_xcdf_yr6r0c Csd}d}|jd}t|D]}|||7}|||7}q |dks$|dkr&tSd}d}d}t|D]}||||7}||||7}|t||7}q0|S)aAA proxy for 1D Wasserstein distance. Uses L1 distance on the cumulative distribution functions, which is exactly equal to Wasserstein-1 distance for 1D distributions. This avoids the more expensive Minkowski computation with allocation. For Wasserstein-p with p > 1, this is a lower bound and correlates well for nearest neighbor search. .. math:: D_{proxy}(x, y) = \sum_i |F_x(i) - F_y(i)| where :math:`F_x, F_y` are the cumulative distribution functions. Results should be reranked with true wasserstein_1d distance if p > 1. r'rr*r)rr+r=) r.r/rrr6r0rrrr r r!proxy_wasserstein_1dXs $    r) rrr tv_resulthellinger_resultpxpyr6r0c Cd}d}|jd}t|D]}|||7}|||7}q |dks$|dkr&tSd}d}t|D] }|||}|||} |t|| 7}|t|| 7}q.d|d|S)aA proxy for Kantorovich (Earth Mover's) distance. The full Kantorovich distance requires solving an optimal transport problem via network simplex, which is expensive. This proxy uses a combination of: 1. Total variation distance (L1 on normalized distributions) 2. Hellinger-like term for better correlation This is much cheaper to compute and correlates reasonably well with true optimal transport distance for nearest neighbor search. Results should be reranked with true kantorovich distance. r'rrqrAr*r)rr+r=r, r.r/rrr6r0rrrrr r r!proxy_kantorovichs #      r)rrrrrmur6r0c Csd}d}|jd}t|D]}|||7}|||7}q |dks$|dkr&tSd}d}d}t|D]}||||7}||||7}|||7}q0||}d}d}d} t|D]}||||7}||||7}| t|||7} qW| S)aeA proxy for circular Kantorovich distance. Uses mean-shifted CDF L1 distance instead of the more expensive median-shifted Minkowski distance. The mean is a reasonable approximation to the median for most distributions and avoids the expensive median computation. Results should be reranked with true circular_kantorovich distance. r'rr) r.r/rrr6r0rrrrr r r!proxy_circular_kantorovichs0     r)bcrrr6r0cCsd}d}|jd}t|D]}|||7}|||7}q |dks$|dkr&tSd}t|D]}|t||||||7}q,d||S)aA proxy for Jensen-Shannon divergence. Jensen-Shannon requires computing logs and the mixture distribution, which is expensive. This proxy uses squared Hellinger distance, which is also a proper divergence on probability distributions and much cheaper to compute (no logs required). .. math:: D_{proxy}(x, y) = 1 - \left(\sum_i \sqrt{p_i q_i}\right)^2 where p, q are the normalized distributions. Results should be reranked with true jensen_shannon_divergence. r'rrA)r*r)rr+r,)r.r/rrr6r0rr r r!proxy_jensen_shannons     $ r) rrrrrdenomr5r6r0c Csd}d}|jd}t|D]}|||7}|||7}q |dks$|dkr&tSd}t|D]"}|||}|||}||} | dkrN||} || | | 7}q,|S)aA proxy for symmetric KL divergence. Symmetric KL requires computing logs which is expensive. This proxy uses triangular discrimination (symmetric chi-squared divergence), which is a second-order approximation to KL divergence and much cheaper. .. math:: D_{proxy}(x, y) = \sum_i \frac{(p_i - q_i)^2}{p_i + q_i} Results should be reranked with true symmetric_kl_divergence. r'rr) r.r/rrr6r0rrrrr5r r r!proxy_symmetric_klHs$!      rc Cr)a@A proxy for Sinkhorn (entropy-regularized optimal transport) distance. Sinkhorn distance requires iterative matrix scaling which is expensive. This proxy uses the same combination as proxy_kantorovich since Sinkhorn approximates Kantorovich. Results should be reranked with true sinkhorn distance. r'rrqrArrr r r!proxy_sinkhorns       rc Csd}d}d}d}|jd}t|D].}||||}|||7}|||||7}|||||7}|||||7}qt|}t|}t||} |||}t|td} t|| d| } ||t| d} | | S)akTriangle Area Similarity - Sector Area Similarity (TS-SS) distance. A distance metric that combines both magnitude and angular information. It multiplies a triangle area (capturing angular difference) by a sector area (capturing both angular and magnitude differences). Useful when both the direction and magnitude of vectors are important. r'r rr\)r*r)r+r,r=arccosradiansrt) r.r/ d_euc_squaredd_cosr~rr6r0r5magnitude_differencethetasectortriangler r r!tssss&       rcCsd}d}d}|jd}t|D] }|||||7}|||||7}|||||7}q|dkr:|dkr:dS|dksB|dkrDtS|dkrJtS|t||}dt|tjS)udTrue angular distance. The actual angle between two vectors, normalized to [0, 1]. Unlike cosine distance which uses 1 - cos(θ), this returns 1 - θ/π. .. math:: D(x, y) = 1 - \frac{\arccos\left(\frac{\langle x, y \rangle}{\|x\| \|y\|}\right)}{\pi} Returns 0 for identical directions, approaches 1 for opposite directions. r'rrA)r*r)rr+r,rpirr r r! true_angulars    rcCsdttd| tjS)zConvert alternative cosine distance to true angular distance. .. math:: D_{angular}(x, y) = 1 - \frac{\arccos(2^{-D_{alt}})}{\pi} rAr\)r+rr^rrr r r!true_angular_from_alt_cosinesrc Csd}d}d}d}d}t|jdD]}|||7}|||7}q||jd}||jd}t|jdD] }|||}|||} ||d7}|| d7}||| 7}q5|dkr`|dkr`dS|dkrfdSd|t||S)a[Correlation distance. One minus the Pearson correlation coefficient. Measures how linearly related two vectors are after centering (subtracting their means). .. math:: D(x, y) = 1 - \frac{\langle x - \bar{x}, y - \bar{y} \rangle}{\|x - \bar{x}\| \|y - \bar{y}\|} Equivalent to cosine distance on mean-centered data. r'rrrAr() r.r/mu_xmu_yr~r dot_productr0 shifted_x shifted_yr r r! correlations*      r)rrrr6r0cCsd}d}d}|jd}t|D]}|t||||7}|||7}|||7}q|dkr5|dkr5dS|dks=|dkr?dStd|t||S)aJHellinger distance. A distance for probability distributions, based on the Bhattacharyya coefficient. Input vectors are treated as (unnormalized) probability distributions. .. math:: D(x, y) = \sqrt{1 - \frac{\sum_i \sqrt{x_i y_i}}{\sqrt{\sum_i x_i \cdot \sum_i y_i}}} Returns values in [0, 1]. r'rrAr2)r*r)r+r,r.r/rrrr6r0r r r! hellinger+s   rcCsd}d}d}|jd}t|D]}|t||||7}|||7}|||7}q|dkr5|dkr5dS|dks=|dkr?tS|dkrEtSt|||}t|S)asAlternative Hellinger distance using log transform. A transformed version of Hellinger distance suitable for the bounded-radius search algorithm. .. math:: D_{alt}(x, y) = \log_2\left(\frac{\sqrt{\sum_i x_i \cdot \sum_i y_i}}{\sum_i \sqrt{x_i y_i}}\right) Use `correct_alternative_hellinger` to convert back to standard Hellinger distance. r'r)r*r)r+r,rrYrr r r!alternative_hellingerZs     rcCstdtd| S)zConvert alternative Hellinger distance back to standard Hellinger distance. .. math:: D(x, y) = \sqrt{1 - 2^{-D_{alt}(x, y)}} rAr\)r+r,r^rr r r!correct_alternative_hellingersraveragec CsDtt|}|dkr|jdd}n|jdd}tj|jtjd}t|j||<|dkr6|dtj S||}t |jtj }|dd|ddk|dd<| |}|dkrb|tj St |d }t|tt|g|jf}|d kr||tj S|d kr||ddtj Sd ||||ddS) Nordinal mergesort)kind quicksortrr2denserr?minrq)r+ravelasarrayargsortrFsizeintparangeastypefloat64onesbool_cumsumnonzero concatenatearraylenr) amethodarrsorterinvobsrrcountr r r!rankdatas*    rcCst|}t|}t||S)aASpearman rank correlation distance. One minus the Spearman rank correlation coefficient. Measures the monotonic relationship between two vectors by computing correlation on their ranks. .. math:: D(x, y) = 1 - \rho(\text{rank}(x), \text{rank}(y)) where :math:`\rho` is Pearson correlation. )rr)r.r/x_ranky_rankr r r! spearmanrs  r)nogilicCs |dk}|dk}||tj}||tj}|}|} ||}|| }||ddfdd|f} t|jd|jdd\} } } t|| | | jt| | | j t | | | }|dkrct dt | | | |}|t jkrst d|t jkr|t dt| j| j }|S)aKantorovich distance (Earth Mover's Distance / Wasserstein distance). The optimal transport distance between two probability distributions. Computes the minimum cost to transform one distribution into another, given a cost matrix. Parameters ---------- x, y : array-like Input vectors treated as probability distributions (will be normalized). cost : array-like Cost matrix where cost[i,j] is the cost of moving mass from bin i to bin j. max_iter : int Maximum number of iterations for the network simplex algorithm. Returns ------- float The optimal transport distance. rNFzDKantorovich distance inputs must be valid probability distributions.z>Optimal transport problem was INFEASIBLE. Please check inputs.z=Optimal transport problem was UNBOUNDED. Please check inputs.)rr+rrnrr*rsupplyrcostrrsrr INFEASIBLE UNBOUNDEDrflow)r.r/rmax_iterrow_maskcol_maskrba_sumb_sumsub_cost node_arc_data spanning_treegraph init_status solve_statusrr r r! kantorovichs<    rrAcCs|dk}|dk}||tj}||tj}|}|} ||}|| }||ddfdd|f} t||| |d} | jd} | jd} d}t| D]}t| D]}|| ||f|||f7}qTqN|S)aSinkhorn distance (entropy-regularized optimal transport). An approximation to the Kantorovich distance using entropy regularization. Faster to compute than exact optimal transport for large distributions. Parameters ---------- x, y : array-like Input vectors treated as probability distributions (will be normalized). cost : array-like Cost matrix where cost[i,j] is the cost of moving mass from bin i to bin j. regularization : float Entropy regularization parameter. Smaller values give results closer to exact Kantorovich distance but may be less stable. Returns ------- float The entropy-regularized optimal transport distance. rN)rregularizationr2r')rr+rrnr r*r))r.r/rrrrrrrrrtransport_plandim_idim_jrr0rJr r r!sinkhorns(    rc Csd}d}d}|jd}t|D]}|||7}|||7}q|t|7}|t|7}|t|}|t|}d||} t|D]$}|d||t||| |||t||| |7}q@|S)aJensen-Shannon divergence. A symmetrized and smoothed version of KL divergence. Measures the similarity between two probability distributions. .. math:: D(x, y) = \frac{1}{2} \left( D_{KL}(x \| m) + D_{KL}(y \| m) \right) where :math:`m = \frac{1}{2}(x + y)` and :math:`D_{KL}` is KL divergence. Input vectors are normalized to probability distributions. r'rrqr*r) FLOAT32_EPSr+log) r.r/rrrr6r0pdf_xpdf_ymr r r!jensen_shannon_divergenceAs"          :rcCsd}d}t|jdD]}|||7}|||7}q ||}||}td|jdD]}||||d7<||||d7<q*t|||S)a&1-dimensional Wasserstein distance. The p-Wasserstein distance for 1D distributions, computed efficiently via the CDF. Input vectors are treated as histograms over ordered bins. .. math:: W_p(x, y) = \left( \sum_i |F_x(i) - F_y(i)|^p \right)^{1/p} where :math:`F_x, F_y` are the cumulative distribution functions. Parameters ---------- x, y : array-like Input vectors treated as probability distributions (will be normalized). p : int The order of the Wasserstein distance (default 1). r'rr2)r)r*rC)r.r/rBx_sumy_sumr0x_cdfy_cdfr r r!wasserstein_1dfs  rc Csvd}d}t|jdD]}|||7}|||7}q ||}||}td|jdD]}||||d7<||||d7<q*t|||}d} |dkrut|jdD]}| t||||||7} q[| d|S|dkrt|jdD]}|||||} | | | 7} qt| S|dkrt|jdD]}| t|||||7} q| Std)aCircular Kantorovich distance. The Wasserstein distance for distributions on a circle (periodic domain). Useful for cyclic data like angles, time of day, or periodic histograms. Parameters ---------- x, y : array-like Input vectors treated as probability distributions (will be normalized). p : int The order of the Wasserstein distance (default 1). r'rr2rrAz)Invalid p supplied to Kantorvich distance)r)r*r+medianr=r,rs) r.r/rBrrr0rrrrrr r r!circular_kantorovichs4 $   rc Csd}d}d}|jd}t|D]}|||7}|||7}q|t|7}|t|7}|t|}|t|}t|D]"}|||t||||||t||||7}q:|S)a3Symmetric Kullback-Leibler divergence. The sum of KL divergences in both directions, making it symmetric. .. math:: D(x, y) = D_{KL}(x \| y) + D_{KL}(y \| x) where :math:`D_{KL}(p \| q) = \sum_i p_i \log(p_i / q_i)`. Input vectors are normalized to probability distributions. r'rr) r.r/rrrr6r0rrr r r!symmetric_kl_divergences          ( rzf4(u1[::1],u1[::1])F)r intersectionr6r0)r&r boundscheckr7cCsBd}|jd}t|D]}||||A}|t|7}q t|S)aqHamming distance for bit-packed binary vectors. Counts the number of differing bits between two uint8 arrays, where each byte contains 8 packed binary features. More efficient than standard Hamming for binary data. .. math:: D(x, y) = \sum_i \text{popcount}(x_i \oplus y_i) Returns the total count of differing bits (not normalized). r)r*r)r%r+rG)r.r/rr6r0rr r r! bit_hammings    r )rrand_or_r6r0cCsd}d}|jd}t|D]}||||@}||||B}|t|7}|t|7}q |dkr2dStt|t| S)aJaccard distance for bit-packed binary vectors. Computes Jaccard distance for uint8 arrays where each byte contains 8 packed binary features. Uses negative log transform for compatibility with the bounded-radius search algorithm. .. math:: D(x, y) = -\log\left(\frac{\text{popcount}(x \land y)}{\text{popcount}(x \lor y)}\right) More efficient than standard Jaccard for binary data. rr')r*r)r%r+rrG)r.r/rrr6r0r r r r r! bit_jaccard s    r zf4(f4[::1],u1[::1],f4[::1]))rr6r0y_icCsDd}|jd}t|D]}|||}|||}|||7}q |S)zSquared Euclidean distance between a float vector ``x`` and a quantized uint8 vector ``y``. The uint8 values in ``y`` are mapped back to floats using the provided ``quantized_values`` array. r'rr8)r.r/quantized_valuesrr6r0rr5r r r!quantized_uint8_sq_euclidean:s    rc Csd}d}d}|jd}t|D] }|||}||||7}|||||7}|||7}q|dkr:|dkr:dS|dksB|dkrDtS|dkrJtS|t||}t|dd S)zAlternative cosine distance between a float vector ``x`` and a quantized uint8 vector ``y``. The uint8 values in ``y`` are mapped back to floats using the provided ``quantized_values`` array. r'rrAr\r) r.r/rrr~rr6r0qyr r r!"quantized_uint8_alternative_cosine]s"   rcCsjd}|jd}d}t|D]}|||}||||7}|||7}q |dkr*tSt|t| S)zAlternative dot product distance between a float vector ``x`` and a quantized uint8 vector ``y``. The uint8 values in ``y`` are mapped back to floats using the provided ``quantized_values`` array. x and y are assumed to be normalized. r'rr)r.r/rrr6rr0rr r r!quantized_uint8_alternative_dots   r)quantized_indexrr6r0c Csjd}|jd}t|D]'}||d}|ddkr|d@}n|d?d@}||||}|||7}q |S)zSquared Euclidean distance between a float vector ``x`` and a quantized uint8 vector ``y``. The uint8 values in ``y`` are mapped back to floats using upper and lower nibbles and via the provided ``quantized_values`` array. r'rrr8) r.r/rrr6r0byterr5r r r!quantized_uint4_sq_euclideans      rc Csd}d}d}|jd}t|D]5}||d}|ddkr"|d@} n|d?d@} || } |||| 7}|||||7}|| | 7}q|dkrO|dkrOdS|dksW|dkrYtS|dkr_tS|t||}t|dd S)zAlternative cosine distance between a float vector ``x`` and a quantized uint8 vector ``y``. The uint8 values in ``y`` are mapped back to floats using upper and lower nibbles and via the provided ``quantized_values`` array. r'rrrrrAr\r) r.r/rrr~rr6r0rrrr r r!"quantized_uint4_alternative_cosines*      rc Csd}|jd}d}t|D]+}||d}|ddkr |d@}n|d?d@}||} |||| 7}|| | 7}q |dkr?tSt|t| S)aAlternative dot product distance between a float vector ``x`` and a quantized uint8 vector ``y``. The uint8 values in ``y`` are mapped back to floats using upper and lower nibbles and via the provided ``quantized_values`` array. x and y are assumed to be normalized. r'rrrrr) r.r/rrr6rr0rrrr r r!quantized_uint4_alternative_dot s      rl2 sqeuclideantaxicabl1 linfinitylinftylinf seuclidean wminkowski braycurtis wassersteinzwasserstein-1dzkantorovich-1dkantorovich_1dcircular_wassersteinzjensen-shannonjensen_shannonz symmetric-kl symmetric_klsymmetric_kullback_lieblerrogerstanimoto sokalsneath sokalmichener)r r )dist correction)r1rrrrrrrW) proxy_dist true_dist) rrzproxy_wasserstein-1drproxy_wassersteinrproxy_circular_wassersteinrzproxy_jensen-shannonrzproxy_symmetric-klr)r1rrrrNrW)r1rrr)binaryr#uint4)r)r)r2)knumpyr+numbapynndescent.optimal_transportrrrrrrrr r numba.extendingr numba.corer llvmliter reyerG_mock_identityr _mock_oneszerosr _dummy_costfinfoepsrr?rr%njitr1Arrayruint16r9r;r>r@rCrErKrNrPrRrWr#rZ vectorizer`rdrirjrlrorprrryr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrint32r r rrrrrrnamed_distancesr,fast_distance_alternativesproxy_distancesquantized_distancesr r r r!s"(                                              !       !    ) ' . % $  !  !    '     #   D0 $ " 5 "       "      !"#$%&'()*+,-/0123456789 D 5