Matt Owen

source code for "files/robot birds and robot bees/select.py"

return to portfolio
  1.  # Matt
  2.  # select.py
  3.  
  4.  import math
  5.  
  6.  
  7.  # error # # # # # #
  8.  # # # # # # #
  9.  
  10.  class size_mismatch: pass
  11.  
  12.  
  13.  # math # # # # # #
  14.  # # # # # # #
  15.  
  16.  def dot(l, r):
  17.   if len(l) != len(r): raise size_mismatch
  18.   s = 0
  19.   for k in range(len(l)): s += l[k] * r[k]
  20.   return s
  21.  
  22.  def scale(v, a):
  23.   for k in range(len(v)): v[k] *= a
  24.   return v
  25.  
  26.  def mapto01(a, b): return lambda x: (b-a)*x+a
  27.  
  28.  def splitrange(a, b, n):
  29.   dx = float(b-a)/n
  30.   for k in range(n):
  31.   yield (a, a+dx)
  32.   a += dx
  33.   pass
  34.  
  35.  def nintegrate(f, a, b):
  36.   if b == a: return 0
  37.   if (b-a) < 0: -return nintegrate(f, b, a)
  38.   if (b-a) > .25: return sum([nintegrate(f, l, r) for l, r in splitrange(a, b, 2*(b-a))])
  39.  
  40.   x = [-math.sqrt(1/3.), 0, math.sqrt(1/3.)]
  41.   w = [5/9., 8/9., 5/9.]
  42.   F = map(lambda x: f((b-a)/2.*x+(a+b)/2.)*(b-a)/2., x)
  43.  
  44.   return dot(w,F)
  45.  
  46.  
  47.  # population # # # # # #
  48.  # # # # # # #
  49.  
  50.  class populationvector:
  51.   """
  52.  
  53.   """
  54.   def __init__(s, p, size=0):
  55.   r = len(p)
  56.   s._size = size
  57.   s._hash = {}
  58.   for k in p: s[k] += 1./r
  59.   def __getitem__(s, k):
  60.   if k in s._hash: return s._hash[k]
  61.   else: return 0
  62.   def __setitem__(s, k, v):
  63.   if k < 0 or k >= s._size: raise IndexError
  64.   if v == 0:
  65.   if k in s._hash: del s._hash[k]
  66.   else: s._hash[k] = v
  67.   def __repr__(s): return str([s[k] for k in range(s._size)])
  68.   def __len__(s): return s._size
  69.   def __iter__(s):
  70.   for k in range(s._size): yield s[k]
  71.  
  72.  
  73.  # proportional selection # # # # # #
  74.  # # # # # # #
  75.  
  76.  def proportional(p, i, f=lambda x: 1): return f(i) / sum([ f(x) for x in p ]) * len(filter(lambda k: k == i, p))
  77.  def dproportional(p, f=lambda x: 1, size=False):
  78.   if size == False: l = max(p)+1
  79.   else: l = size
  80.   v = [0]*l
  81.   for x in p: v[x] += f(x)
  82.   v = scale(v, 1./sum([ f(x) for x in p ]))
  83.   return v
  84.  
  85.  
  86.  # ranking selection # # # # # #
  87.  # # # # # # #
  88.  
  89.  def ranked(p, i, f=lambda x: x, q=lambda x: 1):
  90.   p = sorted(p)
  91.   r, j = len(p), 0
  92.  
  93.   for k in range(len(p)):
  94.   if i == p[k]:
  95.   j = float(k)
  96.   break
  97.  
  98.   return len(filter(lambda x: x == i, p)) * nintegrate(q, j/r, (j+1)/r)
  99.  
  100.  def dranked(p, size, f=lambda x: x, q=lambda x: 1):
  101.   return [ranked(p, i=k, f=f, q=q) for k in range(size)]