3 ¾ hØ–ã@spddlZddlmZmZddlZdddddgZdd d„Zdd d„Z Gd d„de ƒZ Gd d„de ƒZ ddd„Z dS)éN)ÚheappushÚheappopÚminkowski_distance_pÚminkowski_distanceÚdistance_matrixÚ RectangleÚKDTreeécCs¢tj|ƒ}tj|ƒ}tjtj|j|jƒdƒ}|j|ƒ}|j|ƒ}|tjkrbtjtj||ƒddS|dkr‚tjtj||ƒddStjtj||ƒ|ddSdS)a[ Compute the pth power of the L**p distance between two arrays. For efficiency, this function computes the L**p distance but does not extract the pth root. If `p` is 1 or infinity, this is equal to the actual L**p distance. Parameters ---------- x : (M, K) array_like Input array. y : (N, K) array_like Input array. p : float, 1 <= p <= infinity Which Minkowski p-norm to use. Examples -------- >>> from scipy.spatial import minkowski_distance_p >>> minkowski_distance_p([[0,0],[0,0]], [[1,1],[0,1]]) array([2, 1]) Zfloat64é)ÚaxisNéÿÿÿÿr r ) ÚnpÚasarrayZ promote_typesÚdtypeÚastypeÚinfÚamaxÚabsÚsum)ÚxÚyÚpZcommon_datatype©rú5/tmp/pip-build-riy7u7_k/scipy/scipy/spatial/kdtree.pyr s     cCsJtj|ƒ}tj|ƒ}|tjks&|dkr2t|||ƒSt|||ƒd|SdS)a­ Compute the L**p distance between two arrays. Parameters ---------- x : (M, K) array_like Input array. y : (N, K) array_like Input array. p : float, 1 <= p <= infinity Which Minkowski p-norm to use. Examples -------- >>> from scipy.spatial import minkowski_distance >>> minkowski_distance([[0,0],[0,0]], [[1,1],[0,1]]) array([ 1.41421356, 1. ]) r gð?N)r rrr)rrrrrrr7s    c@sXeZdZdZdd„Zdd„Zdd„Zdd „Zdd d „Zdd d„Z ddd„Z ddd„Z dS)rzLHyperrectangle class. Represents a Cartesian product of intervals. cCs8tj||ƒjtƒ|_tj||ƒjtƒ|_|jj\|_dS)zConstruct a hyperrectangle.N) r ÚmaximumrÚfloatÚmaxesZminimumÚminsÚshapeÚm)ÚselfrrrrrÚ__init__XszRectangle.__init__cCsdtt|j|jƒƒS)Nz)ÚlistÚziprr)r rrrÚ__repr__^szRectangle.__repr__cCstj|j|jƒS)z Total volume.)r Úprodrr)r rrrÚvolumeaszRectangle.volumecCsHtj|jƒ}|||<t|j|ƒ}tj|jƒ}|||<t||jƒ}||fS)a² Produce two hyperrectangles by splitting. In general, if you need to compute maximum and minimum distances to the children, it can be done more efficiently by updating the maximum and minimum distances to the parent. Parameters ---------- d : int Axis to split hyperrectangle along. split : float Position along axis `d` to split at. )r Úcopyrrr)r ÚdÚsplitZmidÚlessÚgreaterrrrr)es    zRectangle.splitç@cCs(tdtjdtj|j|||jƒƒ|ƒS)zÞ Return the minimum distance between input and points in the hyperrectangle. Parameters ---------- x : array_like Input. p : float, optional Input. r)rr rrr)r rrrrrÚmin_distance_point}s zRectangle.min_distance_pointcCs tdtj|j|||jƒ|ƒS)zä Return the maximum distance between input and points in the hyperrectangle. Parameters ---------- x : array_like Input array. p : float, optional Input. r)rr rrr)r rrrrrÚmax_distance_point‹s zRectangle.max_distance_pointcCs,tdtjdtj|j|j|j|jƒƒ|ƒS)zØ Compute the minimum distance between points in the two hyperrectangles. Parameters ---------- other : hyperrectangle Input. p : float Input. r)rr rrr)r ÚotherrrrrÚmin_distance_rectangle™s z Rectangle.min_distance_rectanglecCs$tdtj|j|j|j|jƒ|ƒS)zâ Compute the maximum distance between points in the two hyperrectangles. Parameters ---------- other : hyperrectangle Input. p : float, optional Input. r)rr rrr)r r/rrrrÚmax_distance_rectangle§s z Rectangle.max_distance_rectangleN)r,)r,)r,)r,) Ú__name__Ú __module__Ú __qualname__Ú__doc__r!r$r&r)r-r.r0r1rrrrrSs   c@s¶eZdZdZd"dd„ZGdd„deƒZGdd„deƒZGd d „d eƒZd d „Z d dde j fdd„Z d dde j fdd„Z d#dd„Zd$dd„Zd%dd„Zd&dd„Zd'dd„Zd(dd „Zd!S))ra kd-tree for quick nearest-neighbor lookup This class provides an index into a set of k-D points which can be used to rapidly look up the nearest neighbors of any point. Parameters ---------- data : (N,K) array_like The data points to be indexed. This array is not copied, and so modifying this data will result in bogus results. leafsize : int, optional The number of points at which the algorithm switches over to brute-force. Has to be positive. Raises ------ RuntimeError The maximum recursion limit can be exceeded for large data sets. If this happens, either increase the value for the `leafsize` parameter or increase the recursion limit by:: >>> import sys >>> sys.setrecursionlimit(10000) See Also -------- cKDTree : Implementation of `KDTree` in Cython Notes ----- The algorithm used is described in Maneewongvatana and Mount 1999. The general idea is that the kd-tree is a binary tree, each of whose nodes represents an axis-aligned hyperrectangle. Each node specifies an axis and splits the set of points based on whether their coordinate along that axis is greater than or less than a particular value. During construction, the axis and splitting point are chosen by the "sliding midpoint" rule, which ensures that the cells do not all become long and thin. The tree can be queried for the r closest neighbors of any given point (optionally returning only those within some maximum distance of the point). It can also be queried, with a substantial gain in efficiency, for the r approximate closest neighbors. For large dimensions (20 is already large) do not expect this to run significantly faster than brute force. High-dimensional nearest-neighbor queries are a substantial open problem in computer science. The tree also supports all-neighbors queries, both with arrays of points and with other kd-trees. These do use a reasonably efficient algorithm, but the kd-tree is not necessarily the best data structure for this sort of calculation. é cCs–tj|ƒ|_|jjjdkr"tdƒ‚tj|jƒ\|_|_t |ƒ|_ |j dkrRt dƒ‚tj |jdd|_ tj|jdd|_|jtj|jƒ|j |jƒ|_dS)NÚcz&KDTree does not work with complex datar zleafsize must be at least 1r)r )r rÚdatarÚkindÚ TypeErrorrÚnrÚintÚleafsizeÚ ValueErrorrrÚaminrÚ_KDTree__buildÚarangeÚtree)r r8r=rrrr!ïs   zKDTree.__init__c@s4eZdZdd„Zdd„Zdd„Zdd„Zd d „Zd S) z KDTree.nodecCst|ƒt|ƒkS)N)Úid)r r/rrrÚ__lt__þszKDTree.node.__lt__cCst|ƒt|ƒkS)N)rC)r r/rrrÚ__gt__szKDTree.node.__gt__cCst|ƒt|ƒkS)N)rC)r r/rrrÚ__le__szKDTree.node.__le__cCst|ƒt|ƒkS)N)rC)r r/rrrÚ__ge__szKDTree.node.__ge__cCst|ƒt|ƒkS)N)rC)r r/rrrÚ__eq__ szKDTree.node.__eq__N)r2r3r4rDrErFrGrHrrrrÚnodeýs rIc@seZdZdd„ZdS)zKDTree.leafnodecCs||_t|ƒ|_dS)N)ÚidxÚlenÚchildren)r rJrrrr!szKDTree.leafnode.__init__N)r2r3r4r!rrrrÚleafnode srMc@seZdZdd„ZdS)zKDTree.innernodecCs*||_||_||_||_|j|j|_dS)N)Ú split_dimr)r*r+rL)r rNr)r*r+rrrr!s zKDTree.innernode.__init__N)r2r3r4r!rrrrÚ innernodesrOc Cs¸t|ƒ|jkrtj|ƒS|j|}tj||ƒ}||}||}||krRtj|ƒS|dd…|f}||d}tj||kƒd} tj||kƒd} t| ƒdkrÌtj|ƒ}tj||kƒd} tj||kƒd} t| ƒdkrtj |ƒ}tj||kƒd} tj||kƒd} t| ƒdkrdtj ||dkƒs6t d|ƒ‚|d}tj t|ƒdƒ} tj t|ƒdgƒ} tj|ƒ} || |<tj|ƒ} || |<tj|||j|| | |ƒ|j|| || ƒƒSdS)Nr rzTroublesome data array: %sr )rKr=rrMr8r ZargmaxZnonzeror?rÚallr>rAÚarrayr'rOr@) r rJrrr8r(ÚmaxvalÚminvalr)Zless_idxZ greater_idxZ lessmaxesZ greaterminsrrrZ__buildsB          zKDTree.__buildr rr csÄtjdtj||j|j|ƒƒ}ˆtjkr>|ˆC}tj|ƒ}n tj|ƒ}|t|ƒ|jfg}g} |dkrld} n(ˆtjkr„dd|} ndd|ˆ} ˆtjkr°|tjkr°|ˆ}xØ|rŠt |ƒ\}}} t | t j ƒrp|j | j} t| |tjdd…fˆƒ} xptt| ƒƒD]`}| ||kr t| ƒ|kr2t | ƒt| | | | j|fƒt| ƒ|kr | dd }q Wq´||| kr€P|| j| jkr¢| j| j}}n| j| j}}t||||fƒt|ƒ}ˆtjkrðt|t| j|| jƒƒ}nxˆdkr0tj| j|| jƒ|| j<||| j|| j}n8tj| j|| jƒˆ|| j<||| j|| j}||| kr´t||t|ƒ|fƒq´Wˆtjkrªtdd„| DƒƒSt‡fdd„| DƒƒSdS)Nrr cSsg|]\}}| |f‘qSrr)Ú.0r(Úirrrú ”sz"KDTree.__query..cs"g|]\}}| dˆ|f‘qS)gð?r)rTr(rU)rrrrV–s)r rrrrrrÚtuplerBrÚ isinstancerrMr8rJrÚnewaxisÚrangerKrrNr)r*r+r"ÚmaxrÚsorted)r rÚkÚepsrÚdistance_upper_boundZside_distancesZ min_distanceÚqZ neighborsZepsfacrIr8ÚdsrUZnearZfarÚsdr)rrZ__queryFs^             zKDTree.__queryc Cstj|ƒ}|jjdkrtdƒ‚tj|ƒd|jkrJtd|jtj|ƒfƒ‚|dkrZtdƒ‚tj|ƒdd…}|fkr|dkrœtj|t d}tj|t d}n’|dkrætj||ft d}|j tj ƒtj||ft d}|j |jƒnH|dkr&tj|t d}|j tj ƒtj|t d}|j |jƒntdƒ‚xâtj|ƒD]Ô} |j|| ||||d } |dkr†d d „| Dƒ|| <d d „| Dƒ|| <n†|dkrÊxztt| ƒƒD]&} | | \|| | f<|| | f<qžWnB|dkr:t| ƒd krø| d \|| <|| <ntj || <|j|| <q:W||fS|j|||||d } |dkrTdd „| Dƒdd „| DƒfS|dkr‚t| ƒd krt| d Stj |jfSnz|dkrôtj|t d}|j tj ƒtj|t d}|j |jƒx*tt| ƒƒD]} | | \|| <|| <qÎW||fStdƒ‚dS)aC Query the kd-tree for nearest neighbors Parameters ---------- x : array_like, last dimension self.m An array of points to query. k : int, optional The number of nearest neighbors to return. eps : nonnegative float, optional Return approximate nearest neighbors; the kth returned value is guaranteed to be no further than (1+eps) times the distance to the real kth nearest neighbor. p : float, 1<=p<=infinity, optional Which Minkowski p-norm to use. 1 is the sum-of-absolute-values "Manhattan" distance 2 is the usual Euclidean distance infinity is the maximum-coordinate-difference distance distance_upper_bound : nonnegative float, optional Return only neighbors within this distance. This is used to prune tree searches, so if you are doing a series of nearest-neighbor queries, it may help to supply the distance to the nearest neighbor of the most recent point. Returns ------- d : float or array of floats The distances to the nearest neighbors. If x has shape tuple+(self.m,), then d has shape tuple if k is one, or tuple+(k,) if k is larger than one. Missing neighbors (e.g. when k > n or distance_upper_bound is given) are indicated with infinite distances. If k is None, then d is an object array of shape tuple, containing lists of distances. In either case the hits are sorted by distance (nearest first). i : integer or array of integers The locations of the neighbors in self.data. i is the same shape as d. Examples -------- >>> from scipy import spatial >>> x, y = np.mgrid[0:5, 2:8] >>> tree = spatial.KDTree(list(zip(x.ravel(), y.ravel()))) >>> tree.data array([[0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7]]) >>> pts = np.array([[0, 0], [2.1, 2.9]]) >>> tree.query(pts) (array([ 2. , 0.14142136]), array([ 0, 13])) >>> tree.query(pts[0]) (2.0, 0) r7z&KDTree does not work with complex datar z7x must consist of vectors of length %d but has shape %sz*Only p-norms with 1<=p<=infinity permittedN)rzeRequested %s nearest neighbors; acceptable numbers are integers greater than or equal to one, or None)r]r^rr_cSsg|] \}}|‘qSrr)rTr(rUrrrrVsz KDTree.query..cSsg|] \}}|‘qSrr)rTr(rUrrrrVsrcSsg|] \}}|‘qSrr)rTr(rUrrrrVscSsg|] \}}|‘qSrr)rTr(rUrrrrVsr r )r rrr9r:rrr>ÚemptyÚobjectrÚfillrr<r;ÚndindexÚ_KDTree__queryrZrK) r rr]r^rr_ÚretshapeÚddÚiir7ÚhitsÚjrrrÚquery˜sjS        (       z KDTree.queryç@cs>tˆjˆjƒ}‡‡‡‡‡‡‡fdd„‰‡fdd„‰ˆˆj|ƒS)Ncsž|jˆˆƒˆdˆkrgS|jˆˆƒˆdˆkr<ˆ|ƒSt|tjƒrnˆj|j}|jt|ˆˆƒˆkjƒS|j |j |j ƒ\}}ˆ|j |ƒˆ|j |ƒSdS)Ngð?) r-r.rXrrMr8rJrÚtolistr)rNr*r+)rIZrectr(r*r+)r^rÚrr Útraverse_checkingÚtraverse_no_checkingrrrrq)s   z4KDTree.__query_ball_point..traverse_checkingcs.t|tjƒr|jjƒSˆ|jƒˆ|jƒSdS)N)rXrrMrJror*r+)rI)rrrrrr6s  z7KDTree.__query_ball_point..traverse_no_checking)rrrrB)r rrprr^ÚRr)r^rrpr rqrrrrZ__query_ball_point&s zKDTree.__query_ball_pointcCs¶tj|ƒ}|jjdkrtdƒ‚|jd|jkrFtd|jd |jfƒ‚t|jƒdkrd|j ||||ƒS|jdd …}tj |t d}x,tj |ƒD]}|j |||||d||<qŒW|SdS) a]Find all points within distance r of point(s) x. Parameters ---------- x : array_like, shape tuple + (self.m,) The point or points to search for neighbors of. r : positive float The radius of points to return. p : float, optional Which Minkowski p-norm to use. Should be in the range [1, inf]. eps : nonnegative float, optional Approximate search. Branches of the tree are not explored if their nearest points are further than ``r / (1 + eps)``, and branches are added in bulk if their furthest points are nearer than ``r * (1 + eps)``. Returns ------- results : list or array of lists If `x` is a single point, returns a list of the indices of the neighbors of `x`. If `x` is an array of points, returns an object array of shape tuple containing lists of neighbors. Notes ----- If you have many points whose neighbors you want to find, you may save substantial amounts of time by putting them in a KDTree and using query_ball_tree. Examples -------- >>> from scipy import spatial >>> x, y = np.mgrid[0:5, 0:5] >>> points = np.c_[x.ravel(), y.ravel()] >>> tree = spatial.KDTree(points) >>> tree.query_ball_point([2, 0], 1) [5, 10, 11, 15] Query multiple points and plot the results: >>> import matplotlib.pyplot as plt >>> points = np.asarray(points) >>> plt.plot(points[:,0], points[:,1], '.') >>> for results in tree.query_ball_point(([2, 0], [3, 3]), 1): ... nearby_points = points[results] ... plt.plot(nearby_points[:,0], nearby_points[:,1], 'o') >>> plt.margins(0.1, 0.1) >>> plt.show() r7z&KDTree does not work with complex datar z?Searching for a %d-dimensional point in a %d-dimensional KDTreeN)r)rr^r r r ) r rrr9r:rrr>rKÚ_KDTree__query_ball_pointrcrdrf)r rrprr^rhÚresultr7rrrÚquery_ball_point?s3  zKDTree.query_ball_pointcsfdd„tˆjƒDƒ‰‡‡‡‡‡‡‡‡fdd„‰‡‡fdd„‰ˆˆjtˆjˆjƒˆjtˆjˆjƒƒˆS)aFind all pairs of points whose distance is at most r Parameters ---------- other : KDTree instance The tree containing points to search against. r : float The maximum distance, has to be positive. p : float, optional Which Minkowski norm to use. `p` has to meet the condition ``1 <= p <= infinity``. eps : float, optional Approximate search. Branches of the tree are not explored if their nearest points are further than ``r/(1+eps)``, and branches are added in bulk if their furthest points are nearer than ``r * (1+eps)``. `eps` has to be non-negative. Returns ------- results : list of lists For each element ``self.data[i]`` of this tree, ``results[i]`` is a list of the indices of its neighbors in ``other.data``. cSsg|]}g‘qSrr)rTrUrrrrVšsz*KDTree.query_ball_tree..c s’|j|ˆƒˆdˆkrdS|j|ˆƒˆdˆkrBˆ||ƒnLt|tjƒrÚt|tjƒr¤ˆj|j}xp|jD]0}ˆ||jt|ˆj|ˆƒˆkjƒ7<qnWn4|j |j |j ƒ\}}ˆ|||j |ƒˆ|||j |ƒn´t|tjƒr|j |j |j ƒ\}}ˆ|j |||ƒˆ|j |||ƒnp|j |j |j ƒ\}} |j |j |j ƒ\} } ˆ|j ||j | ƒˆ|j ||j | ƒˆ|j | |j | ƒˆ|j | |j | ƒdS)Ngð?) r0r1rXrrMr8rJrror)rNr*r+) Únode1Úrect1Únode2Úrect2r(rUr*r+Úless1Úgreater1Úless2Úgreater2)r^r/rrpÚresultsr rqrrrrrqœs,    2z1KDTree.query_ball_tree..traverse_checkingcsvt|tjƒrZt|tjƒr@x>|jD]}ˆ||jjƒ7<q Wqrˆ||jƒˆ||jƒnˆ|j|ƒˆ|j|ƒdS)N)rXrrMrJror*r+)rwryrU)rrrrrrr¶s     z4KDTree.query_ball_tree..traverse_no_checking)rZr;rBrrr)r r/rprr^r)r^r/rrprr rqrrrÚquery_ball_trees  zKDTree.query_ball_treecsVtƒ‰‡‡‡‡‡‡‡fdd„‰‡‡fdd„‰ˆˆjtˆjˆjƒˆjtˆjˆjƒƒˆS)a  Find all pairs of points within a distance. Parameters ---------- r : positive float The maximum distance. p : float, optional Which Minkowski norm to use. `p` has to meet the condition ``1 <= p <= infinity``. eps : float, optional Approximate search. Branches of the tree are not explored if their nearest points are further than ``r/(1+eps)``, and branches are added in bulk if their furthest points are nearer than ``r * (1+eps)``. `eps` has to be non-negative. Returns ------- results : set Set of pairs ``(i,j)``, with ``i < j``, for which the corresponding positions are close. c s@|j|ˆƒˆdˆkrdS|j|ˆƒˆdˆkrBˆ||ƒnút|tjƒrvt|tjƒr@t|ƒt|ƒkrȈj|j}xÂ|jD]@}x:|jt|ˆj|ˆƒˆkD]}||kr¤ˆj ||fƒq¤Wq‚Wnvˆj|j}xž|jD]^}xX|jt|ˆj|ˆƒˆkD]8}||krˆj ||fƒn||krþˆj ||fƒqþWqÜWn4|j |j |j ƒ\}}ˆ|||j |ƒˆ|||j |ƒnÆt|tjƒrº|j |j |j ƒ\}}ˆ|j |||ƒˆ|j |||ƒn‚|j |j |j ƒ\} } |j |j |j ƒ\} } ˆ|j | |j | ƒˆ|j | |j | ƒt|ƒt|ƒkr*ˆ|j | |j | ƒˆ|j | |j | ƒdS)Ngð?)r0r1rXrrMrCr8rJrÚaddr)rNr*r+) rwrxryrzr(rUrlr*r+r{r|r}r~)r^rrprr rqrrrrrqàsB  "  "  z-KDTree.query_pairs..traverse_checkingcs$t|tjƒrÊt|tjƒr°t|ƒt|ƒkr`x„|jD]*}x$|jD]}||kr<ˆj||fƒq.traverse_no_checking)ÚsetrBrrr)r rprr^r)r^rrprr rqrrrÚ query_pairsÆs - zKDTree.query_pairscs؇‡‡‡‡‡fdd„‰tˆjˆjƒ}tˆjˆjƒ}tjˆƒfkr|tjˆgƒ‰tjdtd‰ˆˆj|ˆj|tj dƒƒˆdSt tjˆƒƒdkrÌtj ˆƒ‰ˆj\}tj|td‰ˆˆj|ˆj|tj |ƒƒˆSt dƒ‚dS)aè Count how many nearby pairs can be formed. Count the number of pairs (x1,x2) can be formed, with x1 drawn from self and x2 drawn from ``other``, and where ``distance(x1, x2, p) <= r``. This is the "two-point correlation" described in Gray and Moore 2000, "N-body problems in statistical learning", and the code here is based on their algorithm. Parameters ---------- other : KDTree instance The other tree to draw points from. r : float or one-dimensional array of floats The radius to produce a count for. Multiple radii are searched with a single tree traversal. p : float, 1<=p<=infinity, optional Which Minkowski p-norm to use Returns ------- result : int or 1-D array of ints The number of pairs. Note that this is internally stored in a numpy int, and so may overflow if very large (2e9). csö|j|ˆƒ}|j|ˆƒ}ˆ||k}ˆ|||j|j7<||ˆ|kˆ||k@}t|ƒdkrldSt|tjƒr2t|tjƒrøtˆj|j dd…t j dd…fˆj|j t j dd…dd…fˆƒj ƒ}|j ƒˆ|t j|ˆ|dd7<n8|j|j|jƒ\} } ˆ|||j| |ƒˆ|||j| |ƒnÀt|tjƒrz|j|j|jƒ\} } ˆ|j| |||ƒˆ|j| |||ƒnx|j|j|jƒ\} } |j|j|jƒ\} }ˆ|j| |j| |ƒˆ|j| |j||ƒˆ|j| |j| |ƒˆ|j| |j||ƒdS)NrÚright)Zside)r0r1rLrKrXrrMrr8rJr rYZravelÚsortZ searchsortedr)rNr*r+)rwrxryrzrJZmin_rZmax_rZ c_greaterrar*r+r{r|r}r~)r/rrprur Útraverserrr†Ms6       "z(KDTree.count_neighbors..traverser )rrzDr must be either a single value or a one-dimensional array of valuesN) rrrr rrQÚzerosr<rBrArKrr>)r r/rprZR1ZR2r;r)r/rrprur r†rÚcount_neighbors1s!  zKDTree.count_neighborscsTtjjˆjˆjfƒ‰‡‡‡‡‡‡fdd„‰ˆˆjtˆjˆjƒˆjtˆjˆjƒƒˆS)a¾ Compute a sparse distance matrix Computes a distance matrix between two KDTrees, leaving as zero any distance greater than max_distance. Parameters ---------- other : KDTree max_distance : positive float p : float, optional Returns ------- result : dok_matrix Sparse matrix representing the results in "dictionary of keys" format. c sf|j|ˆƒˆkrdSt|tjƒr°t|tjƒrzx€|jD]@}x:|jD]0}tˆj|ˆj|ˆƒ}|ˆkr@|ˆ||f<q@Wq4Wn4|j|j|jƒ\}}ˆ|||j |ƒˆ|||j |ƒn²t|tjƒrò|j|j|jƒ\}}ˆ|j |||ƒˆ|j |||ƒnp|j|j|jƒ\} } |j|j|jƒ\} } ˆ|j | |j | ƒˆ|j | |j | ƒˆ|j | |j | ƒˆ|j | |j | ƒdS)N) r0rXrrMrJrr8r)rNr*r+) rwrxryrzrUrlr(r*r+r{r|r}r~)Ú max_distancer/rrur r†rrr†•s,     z/KDTree.sparse_distance_matrix..traverse)ÚscipyÚsparseZ dok_matrixr;rBrrr)r r/r‰rr)r‰r/rrur r†rÚsparse_distance_matrix~s zKDTree.sparse_distance_matrixN)r6)rnr)rnr)rnr)rnr)rn)rn)r2r3r4r5r!rdrIrMrOr@r rrgrmrtrvr€rƒrˆrŒrrrrr¶s8 ,R  B E k Mé@Bc Cstj|ƒ}|j\}}tj|ƒ}|j\}}||kr@td||fƒ‚||||kr„t|dd…tjdd…f|tjdd…dd…f|ƒStj||ftd}||krÎx\t|ƒD] } t|| ||ƒ|| dd…f<q¨Wn.x,t|ƒD] } t||| |ƒ|dd…| f<qØW|SdS)aE Compute the distance matrix. Returns the matrix of all pair-wise distances. Parameters ---------- x : (M, K) array_like Matrix of M vectors in K dimensions. y : (N, K) array_like Matrix of N vectors in K dimensions. p : float, 1 <= p <= infinity Which Minkowski p-norm to use. threshold : positive int If ``M * N * K`` > `threshold`, algorithm uses a Python loop instead of large temporary arrays. Returns ------- result : (M, N) ndarray Matrix containing the distance from every vector in `x` to every vector in `y`. Examples -------- >>> from scipy.spatial import distance_matrix >>> distance_matrix([[0,0],[0,1]], [[1,0],[1,1]]) array([[ 1. , 1.41421356], [ 1.41421356, 1. ]]) zGx contains %d-dimensional vectors but y contains %d-dimensional vectorsN)r) r rrr>rrYrcrrZ) rrrÚ thresholdrr]r;ÚkkrurUrlrrrr´s!    4" )r )r )r r)Znumpyr ÚheapqrrZ scipy.sparserŠÚ__all__rrrdrrrrrrrÚs  + c