Changeset 824

Timestamp:

09/04/15 08:00:51 (9 months ago)

Author:

mmckerns

Message:

reconcile Lnorm and minkowski, add hamming distance;
fix Lnorm and minkowski behavior at large p; allow default xp of zeros

File:

• mystic/_math/distance.py (modified) (9 diffs)

mystic/_math/distance.py

@@ -20 +20 @@
   # weights is a numpy array
   # p is an int
+  from numpy import asarray, seterr, inf
+  weights = asarray(weights).flatten()
   if not p:
     w = float(len(weights[weights != 0.0])) # total number of nonzero elements
+  elif p == inf:
+    w = float(max(abs(weights)))
   else:
-    w = float(sum(abs(weights**p)))**(1./p)
+    orig = seterr(over='raise', invalid='raise')
+    try:
+      w = float(sum(abs(weights**p)))**(1./p)
+    except FloatingPointError: # use the infinity norm
+      w = float(max(abs(weights)))
+    seterr(**orig)
   return w
 
-def absolute_distance(x, xp, up=False, dmin=0):
+def absolute_distance(x, xp=None, up=False, dmin=0):
   """distance = |x - x'|;  (see euclidean_distance for notes)"""
-  from numpy import abs, asarray, newaxis as nwxs
+  from numpy import abs, asarray, newaxis as nwxs, zeros_like
   from __builtin__ import max
   # cast as arrays of the same dimension
-  x = asarray(x); xp = asarray(xp)
+  x = asarray(x)
+  xp = zeros_like(x) if xp is None else asarray(xp)
   xsize = max(len(x.shape), len(xp.shape), dmin)
   while len(x.shape) < xsize: x = x[nwxs]
@@ -39 +49 @@
   return abs(x - xp)
 
-def euclidean_distance(x, xp, up=True, dmin=0):
+def euclidean_distance(x, xp=None, up=True, dmin=0):
   """1-D euclidean distance between points
 
@@ -54 +64 @@
   return absolute_distance(x,xp,up=up,dmin=dmin).swapaxes(0,1).T
 
-def manhattan_distance(x, xp, **kwds):
+def manhattan_distance(x, xp=None, **kwds):
   """1-D manhattan distance between points
 
@@ -65 +75 @@
   # dmin: force upconvert to x,x' to dimension >= dmin
   dmin = kwds['dmin'] if 'dmin' in kwds else 0 # default dimension
-  from numpy import abs, asarray, newaxis as nwxs
+  from numpy import abs, asarray, newaxis as nwxs, zeros_like
   from __builtin__ import max
   # cast as arrays of the same dimension
-  x = asarray(x); xp = asarray(xp)
+  x = asarray(x)
+  xp = zeros_like(x) if xp is None else asarray(xp)
   xsize = max(len(x.shape), len(xp.shape), dmin)
   while len(x.shape) < xsize: x = x[nwxs]
@@ -86 +97 @@
 ###############################################################################
 
-def lipschitz_metric(L, x, xp):
+def lipschitz_metric(L, x, xp=None):
   """sum of lipschitz-weighted distance between points
 
@@ -119 +130 @@
 ###########################################################################
 
-def chebyshev(x,xp, up=True, dmin=0, axis=None):
+def chebyshev(x,xp=None, up=True, dmin=0, axis=None):
   """infinity norm distance between points in euclidean space
 
@@ -138 +149 @@
 """
   d = euclidean_distance(x,xp,up=up,dmin=dmin)
-  from numpy import max
-  return max(d, axis=axis)
-
-
-def minkowski(x,xp, up=True, dmin=0, p=3, axis=None):
+  return d.max(axis=axis).astype(float)
+
+
+def hamming(x,xp=None, up=True, dmin=0, axis=None):
+  """zero 'norm' distance between points in euclidean space
+
+  d(0) =  sum( x[0] != x[0]', x[1] != x[1]', ..., x[n] != x[n]' ) 
+
+Input:
+  x    = array of points, x
+  xp   = array pf points, x'
+
+Additional Input:
+  up   = True if upconvert x with x[:,newaxis]
+  dmin = upconvert to x,x' to dimension >= dmin
+  axis = if not None, reduce across the selected axis
+
+Notes:
+  for standard array behavior, use up=False
+  for element-wise across all elements, use up=True
+"""
+  d = euclidean_distance(x,xp,up=up,dmin=dmin)
+  return d.astype(bool).sum(axis=axis).astype(float)
+
+
+def minkowski(x,xp=None, up=True, dmin=0, p=3, axis=None):
   """p-norm distance between points in euclidean space
 
@@ -161 +193 @@
   for element-wise across all elements, use up=True
 """
+  from numpy import seterr, inf
+  if p == inf: return chebyshev(x,xp,up=up,dmin=dmin,axis=axis)
   d = euclidean_distance(x,xp,up=up,dmin=dmin)
-  from numpy import sum
-  return sum(d**p, axis=axis)**(1./p)
-
-
-def euclidean(x,xp, up=True, dmin=0, axis=None):
+  orig = seterr(over='raise', invalid='raise')
+  try:
+      d = (d**p).sum(axis=axis)**(1./p)
+  except FloatingPointError: # use the infinity norm
+      d = d.max(axis=axis).astype(float)
+  seterr(**orig)
+  return d
+
+
+def euclidean(x,xp=None, up=True, dmin=0, axis=None):
   """L-2 norm distance between points in euclidean space
 
@@ -187 +226 @@
 
 
-def manhattan(x,xp, up=True, dmin=0, axis=None):
+def manhattan(x,xp=None, up=True, dmin=0, axis=None):
   """L-1 norm distance between points in euclidean space