Module szyfrow.support.norms
+Various norms, for calcuating the distances between two frequency +profiles.
+
+
++Expand source code +
+"""Various norms, for calcuating the distances between two frequency
+profiles.
+"""
+
+import collections
+from math import log10
+
+def lp(v1, v2=None, p=2):
+ """Find the L_p norm. If passed one vector, find the length of that vector.
+ If passed two vectors, find the length of the difference between them.
+ """
+ if v2:
+ vec = {k: abs(v1[k] - v2[k]) for k in (v1.keys() | v2.keys())}
+ else:
+ vec = v1
+ return sum(v ** p for v in vec.values()) ** (1.0 / p)
+
+def l1(v1, v2=None):
+ """Finds the distances between two frequency profiles, expressed as
+ dictionaries. Assumes every key in frequencies1 is also in frequencies2
+
+ >>> l1({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1})
+ 0.0
+ >>> l1({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1})
+ 3.0
+ >>> l1(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1}))
+ 0.0
+ >>> l1({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1})
+ 3.0
+ >>> l1({'a':0, 'b':1}, {'a':1, 'b':1})
+ 1.0
+ """
+ return lp(v1, v2, 1)
+
+def l2(v1, v2=None):
+ """Finds the distances between two frequency profiles, expressed as dictionaries.
+ Assumes every key in frequencies1 is also in frequencies2
+
+ >>> l2({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1})
+ 0.0
+ >>> l2({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 1.73205080...
+ >>> l2(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1}))
+ 0.0
+ >>> l2({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 1.732050807...
+ >>> l2(normalise({'a':0, 'b':2, 'c':0}), \
+ normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS
+ 0.81649658...
+ >>> l2({'a':0, 'b':1}, {'a':1, 'b':1})
+ 1.0
+ """
+ return lp(v1, v2, 2)
+
+def l3(v1, v2=None):
+ """Finds the distances between two frequency profiles, expressed as
+ dictionaries. Assumes every key in frequencies1 is also in frequencies2
+
+ >>> l3({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1})
+ 0.0
+ >>> l3({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 1.44224957...
+ >>> l3({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 1.4422495703...
+ >>> l3(normalise({'a':0, 'b':2, 'c':0}), \
+ normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS
+ 0.718144896...
+ >>> l3({'a':0, 'b':1}, {'a':1, 'b':1})
+ 1.0
+ >>> l3(normalise({'a':0, 'b':1}), normalise({'a':1, 'b':1})) # doctest: +ELLIPSIS
+ 0.6299605249...
+ """
+ return lp(v1, v2, 3)
+
+def linf(v1, v2=None):
+ """Finds the distances between two frequency profiles, expressed as
+ dictionaries. Assumes every key in frequencies1 is also in frequencies2"""
+ if v2:
+ vec = {k: abs(v1[k] - v2[k]) for k in (v1.keys() | v2.keys())}
+ else:
+ vec = v1
+ return max(v for v in vec.values())
+
+
+def scale(frequencies, norm=l2):
+ length = norm(frequencies)
+ return collections.defaultdict(int,
+ {k: v / length for k, v in frequencies.items()})
+
+def l2_scale(f):
+ """Scale a set of frequencies so they have a unit euclidean length
+
+ >>> sorted(euclidean_scale({1: 1, 2: 0}).items())
+ [(1, 1.0), (2, 0.0)]
+ >>> sorted(euclidean_scale({1: 1, 2: 1}).items()) # doctest: +ELLIPSIS
+ [(1, 0.7071067...), (2, 0.7071067...)]
+ >>> sorted(euclidean_scale({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS
+ [(1, 0.577350...), (2, 0.577350...), (3, 0.577350...)]
+ >>> sorted(euclidean_scale({1: 1, 2: 2, 3: 1}).items()) # doctest: +ELLIPSIS
+ [(1, 0.408248...), (2, 0.81649658...), (3, 0.408248...)]
+ """
+ return scale(f, l2)
+
+def l1_scale(f):
+ """Scale a set of frequencies so they sum to one
+
+ >>> sorted(normalise({1: 1, 2: 0}).items())
+ [(1, 1.0), (2, 0.0)]
+ >>> sorted(normalise({1: 1, 2: 1}).items())
+ [(1, 0.5), (2, 0.5)]
+ >>> sorted(normalise({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS
+ [(1, 0.333...), (2, 0.333...), (3, 0.333...)]
+ >>> sorted(normalise({1: 1, 2: 2, 3: 1}).items())
+ [(1, 0.25), (2, 0.5), (3, 0.25)]
+ """
+ return scale(f, l1)
+
+normalise = l1_scale
+euclidean_distance = l2
+euclidean_scale = l2_scale
+
+
+def geometric_mean(frequencies1, frequencies2):
+ """Finds the geometric mean of the absolute differences between two frequency profiles,
+ expressed as dictionaries.
+ Assumes every key in frequencies1 is also in frequencies2
+
+ >>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1})
+ 1.0
+ >>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1})
+ 1.0
+ >>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':5, 'c':1})
+ 3.0
+ >>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), \
+ normalise({'a':1, 'b':5, 'c':1})) # doctest: +ELLIPSIS
+ 0.01382140...
+ >>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), \
+ normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS
+ 0.0
+ >>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), \
+ normalise({'a':1, 'b':1, 'c':0})) # doctest: +ELLIPSIS
+ 0.009259259...
+ """
+ total = 1.0
+ for k in frequencies1:
+ total *= abs(frequencies1[k] - frequencies2[k])
+ return total
+
+def harmonic_mean(frequencies1, frequencies2):
+ """Finds the harmonic mean of the absolute differences between two frequency profiles,
+ expressed as dictionaries.
+ Assumes every key in frequencies1 is also in frequencies2
+
+ >>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1})
+ 1.0
+ >>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1})
+ 1.0
+ >>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':5, 'c':1}) # doctest: +ELLIPSIS
+ 1.285714285...
+ >>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), \
+ normalise({'a':1, 'b':5, 'c':1})) # doctest: +ELLIPSIS
+ 0.228571428571...
+ >>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), \
+ normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS
+ 0.0
+ >>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), \
+ normalise({'a':1, 'b':1, 'c':0})) # doctest: +ELLIPSIS
+ 0.2
+ """
+ total = 0.0
+ for k in frequencies1:
+ if abs(frequencies1[k] - frequencies2[k]) == 0:
+ return 0.0
+ total += 1.0 / abs(frequencies1[k] - frequencies2[k])
+ return len(frequencies1) / total
+
+
+def cosine_similarity(frequencies1, frequencies2):
+ """Finds the distances between two frequency profiles, expressed as dictionaries.
+ Assumes every key in frequencies1 is also in frequencies2
+
+ >>> cosine_similarity({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 1.0000000000...
+ >>> cosine_similarity({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 1.0000000000...
+ >>> cosine_similarity({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS
+ 0.5773502691...
+ >>> cosine_similarity({'a':0, 'b':1}, {'a':1, 'b':1}) # doctest: +ELLIPSIS
+ 0.7071067811...
+ """
+ numerator = 0
+ length1 = 0
+ length2 = 0
+ for k in frequencies1:
+ numerator += frequencies1[k] * frequencies2[k]
+ length1 += frequencies1[k]**2
+ for k in frequencies2:
+ length2 += frequencies2[k]**2
+ return numerator / (length1 ** 0.5 * length2 ** 0.5)
+
+
+
+if __name__ == "__main__":
+ import doctest
+ doctest.testmod()Functions
+-
+
+def cosine_similarity(frequencies1, frequencies2) +
+-
++
Finds the distances between two frequency profiles, expressed as dictionaries. +Assumes every key in frequencies1 is also in frequencies2
+>>> cosine_similarity({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.0000000000... +>>> cosine_similarity({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.0000000000... +>>> cosine_similarity({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +0.5773502691... +>>> cosine_similarity({'a':0, 'b':1}, {'a':1, 'b':1}) # doctest: +ELLIPSIS +0.7071067811... ++++Expand source code +
+
+def cosine_similarity(frequencies1, frequencies2): + """Finds the distances between two frequency profiles, expressed as dictionaries. + Assumes every key in frequencies1 is also in frequencies2 + + >>> cosine_similarity({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.0000000000... + >>> cosine_similarity({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.0000000000... + >>> cosine_similarity({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 0.5773502691... + >>> cosine_similarity({'a':0, 'b':1}, {'a':1, 'b':1}) # doctest: +ELLIPSIS + 0.7071067811... + """ + numerator = 0 + length1 = 0 + length2 = 0 + for k in frequencies1: + numerator += frequencies1[k] * frequencies2[k] + length1 += frequencies1[k]**2 + for k in frequencies2: + length2 += frequencies2[k]**2 + return numerator / (length1 ** 0.5 * length2 ** 0.5)
+ +def euclidean_distance(v1, v2=None) +
+-
++
Finds the distances between two frequency profiles, expressed as dictionaries. +Assumes every key in frequencies1 is also in frequencies2
+>>> l2({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) +0.0 +>>> l2({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.73205080... +>>> l2(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) +0.0 +>>> l2({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.732050807... +>>> l2(normalise({'a':0, 'b':2, 'c':0}), normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS +0.81649658... +>>> l2({'a':0, 'b':1}, {'a':1, 'b':1}) +1.0 ++++Expand source code +
+
+def l2(v1, v2=None): + """Finds the distances between two frequency profiles, expressed as dictionaries. + Assumes every key in frequencies1 is also in frequencies2 + + >>> l2({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) + 0.0 + >>> l2({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.73205080... + >>> l2(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) + 0.0 + >>> l2({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.732050807... + >>> l2(normalise({'a':0, 'b':2, 'c':0}), \ + normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS + 0.81649658... + >>> l2({'a':0, 'b':1}, {'a':1, 'b':1}) + 1.0 + """ + return lp(v1, v2, 2)
+ +def euclidean_scale(f) +
+-
++
Scale a set of frequencies so they have a unit euclidean length
+>>> sorted(euclidean_scale({1: 1, 2: 0}).items()) +[(1, 1.0), (2, 0.0)] +>>> sorted(euclidean_scale({1: 1, 2: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.7071067...), (2, 0.7071067...)] +>>> sorted(euclidean_scale({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.577350...), (2, 0.577350...), (3, 0.577350...)] +>>> sorted(euclidean_scale({1: 1, 2: 2, 3: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.408248...), (2, 0.81649658...), (3, 0.408248...)] ++++Expand source code +
+
+def l2_scale(f): + """Scale a set of frequencies so they have a unit euclidean length + + >>> sorted(euclidean_scale({1: 1, 2: 0}).items()) + [(1, 1.0), (2, 0.0)] + >>> sorted(euclidean_scale({1: 1, 2: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.7071067...), (2, 0.7071067...)] + >>> sorted(euclidean_scale({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.577350...), (2, 0.577350...), (3, 0.577350...)] + >>> sorted(euclidean_scale({1: 1, 2: 2, 3: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.408248...), (2, 0.81649658...), (3, 0.408248...)] + """ + return scale(f, l2)
+ +def geometric_mean(frequencies1, frequencies2) +
+-
++
Finds the geometric mean of the absolute differences between two frequency profiles, +expressed as dictionaries. +Assumes every key in frequencies1 is also in frequencies2
+>>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) +1.0 +>>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) +1.0 +>>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':5, 'c':1}) +3.0 +>>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':5, 'c':1})) # doctest: +ELLIPSIS +0.01382140... +>>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS +0.0 +>>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':0})) # doctest: +ELLIPSIS +0.009259259... ++++Expand source code +
+
+def geometric_mean(frequencies1, frequencies2): + """Finds the geometric mean of the absolute differences between two frequency profiles, + expressed as dictionaries. + Assumes every key in frequencies1 is also in frequencies2 + + >>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) + 1.0 + >>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) + 1.0 + >>> geometric_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':5, 'c':1}) + 3.0 + >>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), \ + normalise({'a':1, 'b':5, 'c':1})) # doctest: +ELLIPSIS + 0.01382140... + >>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), \ + normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS + 0.0 + >>> geometric_mean(normalise({'a':2, 'b':2, 'c':2}), \ + normalise({'a':1, 'b':1, 'c':0})) # doctest: +ELLIPSIS + 0.009259259... + """ + total = 1.0 + for k in frequencies1: + total *= abs(frequencies1[k] - frequencies2[k]) + return total
+ +def harmonic_mean(frequencies1, frequencies2) +
+-
++
Finds the harmonic mean of the absolute differences between two frequency profiles, +expressed as dictionaries. +Assumes every key in frequencies1 is also in frequencies2
+>>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) +1.0 +>>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) +1.0 +>>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':5, 'c':1}) # doctest: +ELLIPSIS +1.285714285... +>>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':5, 'c':1})) # doctest: +ELLIPSIS +0.228571428571... +>>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS +0.0 +>>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':0})) # doctest: +ELLIPSIS +0.2 ++++Expand source code +
+
+def harmonic_mean(frequencies1, frequencies2): + """Finds the harmonic mean of the absolute differences between two frequency profiles, + expressed as dictionaries. + Assumes every key in frequencies1 is also in frequencies2 + + >>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) + 1.0 + >>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) + 1.0 + >>> harmonic_mean({'a':2, 'b':2, 'c':2}, {'a':1, 'b':5, 'c':1}) # doctest: +ELLIPSIS + 1.285714285... + >>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), \ + normalise({'a':1, 'b':5, 'c':1})) # doctest: +ELLIPSIS + 0.228571428571... + >>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), \ + normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS + 0.0 + >>> harmonic_mean(normalise({'a':2, 'b':2, 'c':2}), \ + normalise({'a':1, 'b':1, 'c':0})) # doctest: +ELLIPSIS + 0.2 + """ + total = 0.0 + for k in frequencies1: + if abs(frequencies1[k] - frequencies2[k]) == 0: + return 0.0 + total += 1.0 / abs(frequencies1[k] - frequencies2[k]) + return len(frequencies1) / total
+ +def l1(v1, v2=None) +
+-
++
Finds the distances between two frequency profiles, expressed as +dictionaries. Assumes every key in frequencies1 is also in frequencies2
+>>> l1({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) +0.0 +>>> l1({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) +3.0 +>>> l1(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) +0.0 +>>> l1({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) +3.0 +>>> l1({'a':0, 'b':1}, {'a':1, 'b':1}) +1.0 ++++Expand source code +
+
+def l1(v1, v2=None): + """Finds the distances between two frequency profiles, expressed as + dictionaries. Assumes every key in frequencies1 is also in frequencies2 + + >>> l1({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) + 0.0 + >>> l1({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) + 3.0 + >>> l1(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) + 0.0 + >>> l1({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) + 3.0 + >>> l1({'a':0, 'b':1}, {'a':1, 'b':1}) + 1.0 + """ + return lp(v1, v2, 1)
+ +def l1_scale(f) +
+-
++
Scale a set of frequencies so they sum to one
+>>> sorted(normalise({1: 1, 2: 0}).items()) +[(1, 1.0), (2, 0.0)] +>>> sorted(normalise({1: 1, 2: 1}).items()) +[(1, 0.5), (2, 0.5)] +>>> sorted(normalise({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.333...), (2, 0.333...), (3, 0.333...)] +>>> sorted(normalise({1: 1, 2: 2, 3: 1}).items()) +[(1, 0.25), (2, 0.5), (3, 0.25)] ++++Expand source code +
+
+def l1_scale(f): + """Scale a set of frequencies so they sum to one + + >>> sorted(normalise({1: 1, 2: 0}).items()) + [(1, 1.0), (2, 0.0)] + >>> sorted(normalise({1: 1, 2: 1}).items()) + [(1, 0.5), (2, 0.5)] + >>> sorted(normalise({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.333...), (2, 0.333...), (3, 0.333...)] + >>> sorted(normalise({1: 1, 2: 2, 3: 1}).items()) + [(1, 0.25), (2, 0.5), (3, 0.25)] + """ + return scale(f, l1)
+ +def l2(v1, v2=None) +
+-
++
Finds the distances between two frequency profiles, expressed as dictionaries. +Assumes every key in frequencies1 is also in frequencies2
+>>> l2({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) +0.0 +>>> l2({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.73205080... +>>> l2(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) +0.0 +>>> l2({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.732050807... +>>> l2(normalise({'a':0, 'b':2, 'c':0}), normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS +0.81649658... +>>> l2({'a':0, 'b':1}, {'a':1, 'b':1}) +1.0 ++++Expand source code +
+
+def l2(v1, v2=None): + """Finds the distances between two frequency profiles, expressed as dictionaries. + Assumes every key in frequencies1 is also in frequencies2 + + >>> l2({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) + 0.0 + >>> l2({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.73205080... + >>> l2(normalise({'a':2, 'b':2, 'c':2}), normalise({'a':1, 'b':1, 'c':1})) + 0.0 + >>> l2({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.732050807... + >>> l2(normalise({'a':0, 'b':2, 'c':0}), \ + normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS + 0.81649658... + >>> l2({'a':0, 'b':1}, {'a':1, 'b':1}) + 1.0 + """ + return lp(v1, v2, 2)
+ +def l2_scale(f) +
+-
++
Scale a set of frequencies so they have a unit euclidean length
+>>> sorted(euclidean_scale({1: 1, 2: 0}).items()) +[(1, 1.0), (2, 0.0)] +>>> sorted(euclidean_scale({1: 1, 2: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.7071067...), (2, 0.7071067...)] +>>> sorted(euclidean_scale({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.577350...), (2, 0.577350...), (3, 0.577350...)] +>>> sorted(euclidean_scale({1: 1, 2: 2, 3: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.408248...), (2, 0.81649658...), (3, 0.408248...)] ++++Expand source code +
+
+def l2_scale(f): + """Scale a set of frequencies so they have a unit euclidean length + + >>> sorted(euclidean_scale({1: 1, 2: 0}).items()) + [(1, 1.0), (2, 0.0)] + >>> sorted(euclidean_scale({1: 1, 2: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.7071067...), (2, 0.7071067...)] + >>> sorted(euclidean_scale({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.577350...), (2, 0.577350...), (3, 0.577350...)] + >>> sorted(euclidean_scale({1: 1, 2: 2, 3: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.408248...), (2, 0.81649658...), (3, 0.408248...)] + """ + return scale(f, l2)
+ +def l3(v1, v2=None) +
+-
++
Finds the distances between two frequency profiles, expressed as +dictionaries. Assumes every key in frequencies1 is also in frequencies2
+>>> l3({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) +0.0 +>>> l3({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.44224957... +>>> l3({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS +1.4422495703... +>>> l3(normalise({'a':0, 'b':2, 'c':0}), normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS +0.718144896... +>>> l3({'a':0, 'b':1}, {'a':1, 'b':1}) +1.0 +>>> l3(normalise({'a':0, 'b':1}), normalise({'a':1, 'b':1})) # doctest: +ELLIPSIS +0.6299605249... ++++Expand source code +
+
+def l3(v1, v2=None): + """Finds the distances between two frequency profiles, expressed as + dictionaries. Assumes every key in frequencies1 is also in frequencies2 + + >>> l3({'a':1, 'b':1, 'c':1}, {'a':1, 'b':1, 'c':1}) + 0.0 + >>> l3({'a':2, 'b':2, 'c':2}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.44224957... + >>> l3({'a':0, 'b':2, 'c':0}, {'a':1, 'b':1, 'c':1}) # doctest: +ELLIPSIS + 1.4422495703... + >>> l3(normalise({'a':0, 'b':2, 'c':0}), \ + normalise({'a':1, 'b':1, 'c':1})) # doctest: +ELLIPSIS + 0.718144896... + >>> l3({'a':0, 'b':1}, {'a':1, 'b':1}) + 1.0 + >>> l3(normalise({'a':0, 'b':1}), normalise({'a':1, 'b':1})) # doctest: +ELLIPSIS + 0.6299605249... + """ + return lp(v1, v2, 3)
+ +def linf(v1, v2=None) +
+-
++
Finds the distances between two frequency profiles, expressed as +dictionaries. Assumes every key in frequencies1 is also in frequencies2
+++Expand source code +
+
+def linf(v1, v2=None): + """Finds the distances between two frequency profiles, expressed as + dictionaries. Assumes every key in frequencies1 is also in frequencies2""" + if v2: + vec = {k: abs(v1[k] - v2[k]) for k in (v1.keys() | v2.keys())} + else: + vec = v1 + return max(v for v in vec.values())
+ +def lp(v1, v2=None, p=2) +
+-
++
Find the L_p norm. If passed one vector, find the length of that vector. +If passed two vectors, find the length of the difference between them.
+++Expand source code +
+
+def lp(v1, v2=None, p=2): + """Find the L_p norm. If passed one vector, find the length of that vector. + If passed two vectors, find the length of the difference between them. + """ + if v2: + vec = {k: abs(v1[k] - v2[k]) for k in (v1.keys() | v2.keys())} + else: + vec = v1 + return sum(v ** p for v in vec.values()) ** (1.0 / p)
+ +def normalise(f) +
+-
++
Scale a set of frequencies so they sum to one
+>>> sorted(normalise({1: 1, 2: 0}).items()) +[(1, 1.0), (2, 0.0)] +>>> sorted(normalise({1: 1, 2: 1}).items()) +[(1, 0.5), (2, 0.5)] +>>> sorted(normalise({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS +[(1, 0.333...), (2, 0.333...), (3, 0.333...)] +>>> sorted(normalise({1: 1, 2: 2, 3: 1}).items()) +[(1, 0.25), (2, 0.5), (3, 0.25)] ++++Expand source code +
+
+def l1_scale(f): + """Scale a set of frequencies so they sum to one + + >>> sorted(normalise({1: 1, 2: 0}).items()) + [(1, 1.0), (2, 0.0)] + >>> sorted(normalise({1: 1, 2: 1}).items()) + [(1, 0.5), (2, 0.5)] + >>> sorted(normalise({1: 1, 2: 1, 3: 1}).items()) # doctest: +ELLIPSIS + [(1, 0.333...), (2, 0.333...), (3, 0.333...)] + >>> sorted(normalise({1: 1, 2: 2, 3: 1}).items()) + [(1, 0.25), (2, 0.5), (3, 0.25)] + """ + return scale(f, l1)
+ +def scale(frequencies, norm=<function l2>) +
+-
+
+++
+Expand source code +
+
+def scale(frequencies, norm=l2): + length = norm(frequencies) + return collections.defaultdict(int, + {k: v / length for k, v in frequencies.items()})
+