`weights.Distance` — Distance based Spatial Weights¶

The weights.Distance module provides for spatial weights defined on distance relationships.

New in version 1.0.

Distance based spatial weights

class pysal.weights.Distance.DistanceBand(data, threshold, p=2, alpha=-1.0, binary=True, ids=None)¶

Spatial weights based on distance band

Parameters:

data : array (n,m)

attribute data, n observations on m attributes

threshold : float

distance band

p : float

Minkowski p-norm distance metric parameter: 1<=p<=infinity 2: Euclidean distance 1: Manhattan distance

binary : binary

If true w_{ij}=1 if d_{i,j}<=threshold, otherwise w_{i,j}=0 If false wij=dij^{alpha}

alpha : float

distance decay parameter for weight (default -1.0) if alpha is positive the weights will not decline with distance. If binary is True, alpha is ignored

Notes

this was initially implemented running scipy 0.8.0dev (in epd 6.1). earlier versions of scipy (0.7.0) have a logic bug in scipy/sparse/dok.py so serge changed line 221 of that file on sal-dev to fix the logic bug

Examples

>>> points=[(10, 10), (20, 10), (40, 10), (15, 20), (30, 20), (30, 30)]
>>> w=DistanceBand(points,threshold=11.2)
>>> w.weights
{0: [1, 1], 1: [1, 1], 2: [], 3: [1, 1], 4: [1], 5: [1]}
>>> w.neighbors
{0: [1, 3], 1: [0, 3], 2: [], 3: [0, 1], 4: [5], 5: [4]}

inverse distance weights

>>> w=DistanceBand(points,threshold=11.2,binary=False)
>>> w.weights[0]
[0.10000000000000001, 0.089442719099991588]
>>> w.neighbors[0]
[1, 3]
>>> 

gravity weights

>>> w=DistanceBand(points,threshold=11.2,binary=False,alpha=-2.)
>>> w.weights[0]
[0.01, 0.0079999999999999984]

Methods

`asymmetry`
`full`
`get_transform`
`higher_order`
`order`
`set_transform`
`shimbel`

class pysal.weights.Distance.Kernel(data, bandwidth=None, fixed=True, k=2, function='triangular', eps=1.0000001000000001, ids=None)¶

Spatial weights based on kernel functions

Parameters:

data : array (n,k)

n observations on k characteristics used to measure distances between the n objects

bandwidth : float or array-like (optional)

the bandwidth $h_i$ for the kernel.

fixed : binary

If true then $h_i=h \forall i$ . If false then bandwidth is adaptive across observations.

k : int

the number of nearest neighbors to use for determining bandwidth. For fixed bandwidth, $h_i=max(dknn) \forall i$ where $dknn$ is a vector of k-nearest neighbor distances (the distance to the kth nearest neighbor for each observation). For adaptive bandwidths, $h_i=dknn_i$

function : string {‘triangular’,’uniform’,’quadratic’,’quartic’,’gaussian’}

kernel function defined as follows with

$z_{i,j} = d_{i,j}/h_i$

triangular

$K(z) = (1 - |z|) \ if |z| \le 1$

uniform

$K(z) = |z| \ if |z| \le 1$

quadratic

$K(z) = (3/4)(1-z^2) \ if |z| \le 1$

quartic

$K(z) = (15/16)(1-z^2)^2 \ if |z| \le 1$

gaussian

$K(z) = (2\pi)^{(-1/2)} exp(-z^2 / 2)$

eps : float

adjustment to ensure knn distance range is closed on the knnth observations

Examples

>>> points=[(10, 10), (20, 10), (40, 10), (15, 20), (30, 20), (30, 30)]
>>> kw=Kernel(points)
>>> kw.weights[0]
[1.0, 0.50000004999999503, 0.44098306152674649]
>>> kw.neighbors[0]
[0, 1, 3]
>>> kw.bandwidth
array([[ 20.000002],
       [ 20.000002],
       [ 20.000002],
       [ 20.000002],
       [ 20.000002],
       [ 20.000002]])
>>> kw15=Kernel(points,bandwidth=15.0)
>>> kw15[0]
{0: 1.0, 1: 0.33333333333333337, 3: 0.2546440075000701}
>>> kw15.neighbors[0]
[0, 1, 3]
>>> kw15.bandwidth
array([[ 15.],
       [ 15.],
       [ 15.],
       [ 15.],
       [ 15.],
       [ 15.]])

Adaptive bandwidths user specified

>>> bw=[25.0,15.0,25.0,16.0,14.5,25.0]
>>> kwa=Kernel(points,bandwidth=bw)
>>> kwa.weights[0]
[1.0, 0.59999999999999998, 0.55278640450004202, 0.10557280900008403]
>>> kwa.neighbors[0]
[0, 1, 3, 4]
>>> kwa.bandwidth
array([[ 25. ],
       [ 15. ],
       [ 25. ],
       [ 16. ],
       [ 14.5],
       [ 25. ]])

Endogenous adaptive bandwidths

>>> kwea=Kernel(points,fixed=False)
>>> kwea.weights[0]
[1.0, 0.10557289844279438, 9.9999990066379496e-08]
>>> kwea.neighbors[0]
[0, 1, 3]
>>> kwea.bandwidth
array([[ 11.18034101],
       [ 11.18034101],
       [ 20.000002  ],
       [ 11.18034101],
       [ 14.14213704],
       [ 18.02775818]])

Endogenous adaptive bandwidths with Gaussian kernel

>>> kweag=Kernel(points,fixed=False,function='gaussian')
>>> kweag.weights[0]
[0.3989422804014327, 0.26741902915776961, 0.24197074871621341]
>>> kweag.bandwidth
array([[ 11.18034101],
       [ 11.18034101],
       [ 20.000002  ],
       [ 11.18034101],
       [ 14.14213704],
       [ 18.02775818]])

Methods

`asymmetry`
`full`
`get_transform`
`higher_order`
`order`
`set_transform`
`shimbel`

pysal.weights.Distance.knnW(point_array, k=2, p=2, ids=None)¶

Creates contiguity matrix based on k nearest neighbors

Parameters:

point_array : multitype

np.array n observations on m attributes

k : int

number of nearest neighbors

p : float

Minkowski p-norm distance metric parameter: 1<=p<=infinity 2: Euclidean distance 1: Manhattan distance

ids : list

identifiers to attach to each observation

Returns :

——- :

w : W instance

Weights object with binary weights

Previous topic

This Page

`weights.Distance` — Distance based Spatial Weights¶

Navigation

Previous topic

This Page

Quick search

weights.Distance — Distance based Spatial Weights¶

Navigation

`weights.Distance` — Distance based Spatial Weights¶