Add kw arg to normalize kernel in distance weights.

libpysal/_kernels.py

@@ -0,0 +1,77 @@
+import numpy
+
+
+def _triangular(distances, bandwidth):
+    u = distances/bandwidth
+    u = 1-numpy.clip(u, 0,1)
+    return u/bandwidth
+
+def _parabolic(distances, bandwidth):
+    u = numpy.clip(distances / bandwidth, 0, 1)
+    return 0.75 * (1 - u**2)
+
+
+def _gaussian(distances, bandwidth):
+    u = distances / bandwidth
+    exponent_term = -0.5 * (u**2)
+    c = 1 / (bandwidth * numpy.sqrt(2 * numpy.pi))
+    return c * numpy.exp(exponent_term)
+
+
+def _bisquare(distances, bandwidth):
+    u = numpy.clip(distances / bandwidth, 0, 1)
+    return (15 / 16) * (1 - u**2) ** 2
+
+
+def _cosine(distances, bandwidth):
+    u = numpy.clip(distances / bandwidth, 0, 1)
+    return (numpy.pi / 4) * numpy.cos(numpy.pi / 2 * u)
+
+
+def _exponential(distances, bandwidth):
+    u = distances / bandwidth
+    return numpy.exp(-u)
+
+
+def _boxcar(distances, bandwidth):
+    r = (distances < bandwidth).astype(int)
+    return r
+
+
+def _identity(distances, _):
+    return distances
+
+
+_kernel_functions = {
+    "triangular": _triangular,
+    "parabolic": _parabolic,
+    "gaussian": _gaussian,
+    "bisquare": _bisquare,
+    "cosine": _cosine,
+    "boxcar": _boxcar,
+    "discrete": _boxcar,
+    "exponential": _exponential,
+    "identity": _identity,
+    None: _identity,
+}
+
+
+def _kernel(
+    distances,
+    bandwidth,
+    kernel="gaussian",
+):
+    """
+    distances: array-like
+    bandwidth  float
+    kernel: string or callable
+
+    """
+
+    if callable(kernel):
+        k = kernel(distances, bandwidth)
+    else:
+        kernel = kernel.lower()
+        k = _kernel_functions[kernel](distances, bandwidth)
+
+    return k

libpysal/weights/distance.py

@@ -372,8 +372,8 @@ class Kernel(W):
     bandwidth   : float
                   or array-like (optional)
                   the bandwidth :math:`h_i` for the kernel.
-    fixed       : binary
-                  If true then :math:`h_i=h \\forall i`. If false then
+    fixed       : bool
+                  If True then :math:`h_i=h \\forall i`. If False then
                   bandwidth is adaptive across observations.
     k           : int
                   the number of nearest neighbors to use for determining
@@ -424,6 +424,10 @@ class Kernel(W):
     eps         : float
                   adjustment to ensure knn distance range is closed on the
                   knnth observations
+    normalize   : bool
+                  If True (default) Gaussian kernel is normalized to integrate to 1.
+                  If False K(0)=1.
+
 
     Attributes
     ----------
@@ -530,8 +534,10 @@ def __init__(
         diagonal=False,
         distance_metric="euclidean",
         radius=None,
+        normalize=True,
         **kwargs,
     ):
+        self._normalize = normalize
         if radius is not None:
             distance_metric = "arc"
         if isKDTree(data):
@@ -685,7 +691,9 @@ def _eval_kernel(self):
             )
             z.append(zi)
         zs = z
-        # functions follow Anselin and Rey (2010) table 5.4
+
+        # functions follow Anselin and Rey (2014) Modern Spatial Econometircs in Practice. Pg 78
+
         if self.function == "triangular":
             self.kernel = [1 - zi for zi in zs]
         elif self.function == "uniform":
@@ -697,6 +705,8 @@ def _eval_kernel(self):
         elif self.function == "gaussian":
             c = np.pi * 2
             c = c ** (-0.5)
+            if self._normalize is False:
+                c = 1
             self.kernel = [c * np.exp(-(zi**2) / 2.0) for zi in zs]
         else:
             print(("Unsupported kernel function", self.function))

libpysal/weights/tests/test_distance.py

@@ -351,6 +351,14 @@ def test_from_geodataframe(self):
         for k, v in list(w[self.known_wi5 - 1].items()):
             np.testing.assert_allclose(v, self.known_w5[k + 1], rtol=RTOL)
 
+    def test_w_normalize(self):
+        wg = d.Kernel.from_array(self.points, function='gaussian')
+        np.testing.assert_allclose(wg.weights[0], [0.3989422804014327, 0.35206533556593145, 0.3412334260702758], rtol=RTOL)
+        wgun = d.Kernel.from_array(self.points, function='gaussian', normalize=False)
+        np.testing.assert_allclose(wgun.weights[0], [1.0, 0.8824969246470149, 0.8553453540369604], rtol=RTOL)
+
+
+
     ##########################
     # Function/User tests    #
     ##########################