Changeset 609 for branches

Timestamp:

12/11/12 08:23:06 (3 years ago)

Author:

mmckerns

Message:

rename and migrate wrap, nested, and proxify from wrapper to constraints
add outer_proxy, wrap_constraints, and wrap_penalty methods
proxify methods now take args and kwds

Location:

branches/decorate

Files:

• constraints.py (modified) (1 diff)
• penalty.py (modified) (3 diffs)
• test_constraints.py (modified) (4 diffs)
• test_penalty.py (modified) (2 diffs)
• test_wrapper.py (modified) (3 diffs)
• wrapper.py (modified) (1 diff)

branches/decorate/constraints.py

@@ -5 +5 @@
 from wrapper import *
 from mystic.math import almostEqual
+
+def with_constraint(ctype, *args, **kwds):
+    """convert a set transformation to a constraints solver of the chosen type
+
+transformation f(x) is a mapping between x and x', where x' = f(x).
+ctype is a mystic.constraints type [inner, outer, inner_proxy, outer_proxy].
+    """
+    def dec(condition):
+      @ctype(condition, *args, **kwds)
+      def constraint(x):
+          return x
+      return constraint
+    return dec
+
+
+def outer(outer=lambda x:x, args=None, kwds=None):
+    """wrap a function around another function: convert y = f(x) to y' = c(f(x))
+
+This is useful, for example, in nesting one constraint in another constraint.
+    """
+    if args is None: args=()
+    if kwds is None: kwds={}
+    def dec(f):
+        def func(x, *argz, **kwdz):
+            return outer(f(x, *argz, **kwdz), *args, **kwds)
+        return func
+    return dec
+
+
+def inner(inner=lambda x:x, args=None, kwds=None):
+    """nest a function within another function: convert y = f(x) to y' = f(c(x))
+
+This is useful, for example, in nesting constraints in a cost function;
+thus, the constraints will be enforced at every cost function evaluation.
+    """
+    if args is None: args=()
+    if kwds is None: kwds={}
+    def dec(f):
+        def func(x, *argz, **kwdz):
+            return f(inner(x, *args, **kwds), *argz, **kwdz)
+        return func
+    return dec
+
+
+def inner_proxy(inner=lambda x:x, args=None, kwds=None):
+    """nest a function within another function: convert y = f(x) to y' = f(c(x))
+
+This is useful, for example, in nesting constraints in a cost function;
+thus, the constraints will be enforced at every cost function evaluation.
+
+This function does not preserve decorated function signature, but passes args
+and kwds to the inner function.
+    """
+    if args is None: args=()
+    if kwds is None: kwds={}
+    def dec(f):
+        def func(*argz, **kwdz):
+            return f(inner(*argz, **kwdz), *args, **kwds)
+        return func
+    return dec
+
+
+def outer_proxy(outer=lambda x:x, args=None, kwds=None):
+    """wrap a function around another function: convert y = f(x) to y' = c(f(x))
+
+This is useful, for example, in nesting one constraint in another constraint.
+ 
+This function does not preserve decorated function signature, but passes args
+and kwds to the outer function.
+    """
+    if args is None: args=()
+    if kwds is None: kwds={}
+    def dec(f):
+        def func(x, *argz, **kwdz):
+            return outer(f(x, *args, **kwds), *argz, **kwdz)
+        return func
+    return dec
+
 
 '''

branches/decorate/penalty.py

@@ +1 @@
+
+def with_penalty(ptype, *args, **kwds):
+    """convert a condition to a penalty function of the chosen type
+
+condition f(x) is satisfied when f(x) == 0.0 for equality constraints
+and f(x) <= 0.0 for inequality constraints. ptype is a mystic.penalty type.
+    """
+    def dec(condition):
+      @ptype(condition, *args, **kwds)
+      def penalty(x):
+          return 0.0
+      return penalty
+    return dec
+
+
 from numpy import inf, log
 def quadratic_equality(condition=lambda x:0., args=None, kwds=None, k=100, h=5):
@@ -383 +398 @@
 
 ####################################################
-def proxify(penalty=lambda x:0.0):
+def proxify(penalty=lambda x:0.0, args=None, kwds=None):
     """penalize a function with another function: y = f(x) to y' = f(x) + p(x)
     
@@ -391 +406 @@
 
 This function does not preserve decorated function signature, but passes args
-and kwds to the inner function.  The decorated function should require a
-single parameter as input.
-    """
-    def dec(f):
-        def func(x, *args, **kwds):
-            return f(x) + penalty(x, *args, **kwds)
-        return func
-    return dec
-
-def penalize(penalty=lambda x:0.0, args=None, kwds=None): #XXX: *args, **kwds ?
+and kwds to the penalty function.
+    """
+    if args is None: args=()
+    if kwds is None: kwds={}
+    def dec(f):
+        def func(x, *argz, **kwdz):
+            return f(x, *args, **kwds) + penalty(x, *argz, **kwdz)
+        return func
+    return dec
+
+def penalize(penalty=lambda x:0.0, args=None, kwds=None):
     """penalize a function with another function: y = f(x) to y' = f(x) + p(x)
     

branches/decorate/test_constraints.py

@@ -2 +2 @@
 from mystic.math import almostEqual
 
-def test_with_constraint():
+def test_outer():
+
+  def squared(x):
+    return x**2
+
+  @outer(outer=squared) 
+  def plus_one_squared(x):
+    return x+1
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  assert all(plus_one_squared(x)) == all((x+1)**2)
+
+
+def test_inner():
+
+  def squared(x):
+    return x**2
+
+  @inner(inner=squared) 
+  def squared_plus_one(x):
+    return x+1
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  assert all(squared_plus_one(x)) == all(x**2 + 1)
+
+
+def test_outer_constraint():
+
+  from mystic.math.measures import impose_mean, mean
+
+  def impose_constraints(x, mean, weights=None):
+    return impose_mean(mean, x, weights)
+
+  @outer(outer=impose_constraints, kwds={'mean':5.0})
+  def mean_of_squared(x):
+    return [i**2 for i in x]
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  y = impose_mean(5, [i**2 for i in x])
+  assert mean(y) == 5.0
+  assert mean_of_squared(x) == y
+
+
+def test_inner_constraint():
+
+  from mystic.math.measures import impose_mean
+
+  def impose_constraints(x, mean, weights=None):
+    return impose_mean(mean, x, weights)
+
+  @inner(inner=impose_constraints, kwds={'mean':5.0})
+  def mean_then_squared(x):
+    return [i**2 for i in x]
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  assert mean_then_squared(x) == [i**2 for i in impose_mean(5,x)]
+
+
+def test_proxified_constraint():
+
+  from mystic.math.measures import impose_mean
+
+  @inner_proxy(inner=impose_mean)
+  def mean_then_squared(x): #XXX: proxy doesn't preserve function signature
+    return [i**2 for i in x]
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  assert mean_then_squared(5,x) == [i**2 for i in impose_mean(5,x)]
+
+
+def test_inner_constraints():
+
+  from mystic.math.measures import impose_mean, impose_spread
+
+  def impose_constraints(x, mean=0.0, spread=1.0):
+    x = impose_mean(mean, x)
+    x = impose_spread(spread, x)
+    return x
+
+  @inner(inner=impose_constraints, kwds={'mean':5.0, 'spread':50.0})
+  def constrained_squared(x):
+    return [i**2 for i in x]
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  y = impose_spread(50.0, impose_mean(5.0,x))
+  assert constrained_squared(x) == [i**2 for i in y]
+
+
+def test_proxified_constraints():
+
+  from mystic.math.measures import impose_mean, impose_spread
+
+  def impose_constraints(x, mean=0.0, spread=1.0):
+    x = impose_mean(mean, x)
+    x = impose_spread(spread, x)
+    return x
+
+  @inner_proxy(inner=impose_constraints)
+  def constrained_squared(x): #XXX: proxy doesn't preserve function signature
+    return [i**2 for i in x]
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  y = impose_spread(50.0, impose_mean(5.0,x))
+  assert constrained_squared(x, 5.0, 50.0) == [i**2 for i in y]
+
+
+def test_with_mean():
 
   from mystic.math.measures import impose_mean
@@ -17 +130 @@
 
 
-def test_with_constraints():
+def test_with_mean_spread():
 
   from mystic.math.measures import impose_mean, impose_spread
@@ -34 +147 @@
 
 
-def test_constrain():
+def test_constrained_solve():
 
   @with_spread(5.0)
@@ -54 +167 @@
 
 
+def test_constrain():
+
+  from mystic.math.measures import mean, spread
+  from mystic.math.measures import impose_mean, impose_spread
+  def mean_constraint(x, mean=0.0):
+    return impose_mean(mean, x)
+
+  def range_constraint(x, spread=1.0):
+    return impose_spread(spread, x)
+
+  @inner(inner=range_constraint, kwds={'spread':5.0})
+  @inner(inner=mean_constraint, kwds={'mean':5.0})
+  def constraints(x):
+    return x
+
+  def cost(x):
+    return abs(sum(x) - 5.0)
+
+  from mystic.solvers import fmin_powell
+  from numpy import array
+  x = array([1,2,3,4,5])
+  y = fmin_powell(cost, x, constraints=constraints, disp=False)
+
+  assert mean(y) == 5.0
+  assert spread(y) == 5.0
+  assert almostEqual(cost(y), 4*(5.0))
+
+
+def test_with_constraint():
+
+  from mystic.math.measures import impose_mean
+
+  @with_constraint(inner, kwds={'target':5.0})
+  def mean_of_squared(x, target):
+    return impose_mean(target, [i**2 for i in x])
+
+  from numpy import array
+  x = array([1,2,3,4,5])
+  y = impose_mean(5, [i**2 for i in x])
+  assert mean(y) == 5.0
+  assert mean_of_squared(x) == y
+
 
 if __name__ == '__main__':
+  test_outer()
+  test_inner()
+  test_outer_constraint()
+  test_inner_constraint()
+  test_proxified_constraint()
+  test_inner_constraints()
+  test_proxified_constraints()
+  test_with_mean()
+  test_with_mean_spread()
+  test_constrained_solve()
+  test_constrain()
   test_with_constraint()
-  test_with_constraints()
-  test_constrain()
 
 

branches/decorate/test_penalty.py

@@ -130 +130 @@
 
 
+def test_with_penalty():
+
+  from mystic.math.measures import mean, spread
+  @with_penalty(quadratic_equality, kwds={'target':5.0})
+  def penalty(x, target):
+    return mean(x) - target
+
+  def cost(x):
+    return abs(sum(x) - 5.0)
+
+  from mystic.solvers import fmin_powell
+  from numpy import array
+  x = array([1,2,3,4,5])
+  y = fmin_powell(cost, x, penalty=penalty, disp=False)
+
+  assert round(mean(y)) == 5.0
+  assert round(cost(y)) == 4*(5.0)
+
 
 if __name__ == '__main__':
@@ -137 +155 @@
   test_as_constraint()
   test_as_penalty()
+  test_with_penalty()
 
 

branches/decorate/test_wrapper.py

@@ -1 +1 @@
 from wrapper import *
 from mystic.math import almostEqual
-
-def test_wrap():
-
-  def squared(x):
-    return x**2
-
-  @wrap(outer=squared) 
-  def plus_one_squared(x):
-    return x+1
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  assert all(plus_one_squared(x)) == all((x+1)**2)
-
-
-def test_nested():
-
-  def squared(x):
-    return x**2
-
-  @nested(inner=squared) 
-  def squared_plus_one(x):
-    return x+1
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  assert all(squared_plus_one(x)) == all(x**2 + 1)
-
-
-def test_wrap_constraint():
-
-  from mystic.math.measures import impose_mean, mean
-
-  def impose_constraints(x, mean, weights=None):
-    return impose_mean(mean, x, weights)
-
-  @wrap(outer=impose_constraints, kwds={'mean':5.0})
-  def mean_of_squared(x):
-    return [i**2 for i in x]
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  y = impose_mean(5, [i**2 for i in x])
-  assert mean(y) == 5.0
-  assert mean_of_squared(x) == y
-
-
-def test_nested_constraint():
-
-  from mystic.math.measures import impose_mean
-
-  def impose_constraints(x, mean, weights=None):
-    return impose_mean(mean, x, weights)
-
-  @nested(inner=impose_constraints, kwds={'mean':5.0})
-  def mean_then_squared(x):
-    return [i**2 for i in x]
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  assert mean_then_squared(x) == [i**2 for i in impose_mean(5,x)]
-
-
-def test_proxified_constraint():
-
-  from mystic.math.measures import impose_mean
-
-  @proxify(inner=impose_mean)
-  def mean_then_squared(x): #XXX: proxy doesn't preserve function signature
-    return [i**2 for i in x]
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  assert mean_then_squared(5,x) == [i**2 for i in impose_mean(5,x)]
-
-
-def test_nested_constraints():
-
-  from mystic.math.measures import impose_mean, impose_spread
-
-  def impose_constraints(x, mean=0.0, spread=1.0):
-    x = impose_mean(mean, x)
-    x = impose_spread(spread, x)
-    return x
-
-  @nested(inner=impose_constraints, kwds={'mean':5.0, 'spread':50.0})
-  def constrained_squared(x):
-    return [i**2 for i in x]
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  y = impose_spread(50.0, impose_mean(5.0,x))
-  assert constrained_squared(x) == [i**2 for i in y]
-
-
-def test_proxified_constraints():
-
-  from mystic.math.measures import impose_mean, impose_spread
-
-  def impose_constraints(x, mean=0.0, spread=1.0):
-    x = impose_mean(mean, x)
-    x = impose_spread(spread, x)
-    return x
-
-  @proxify(inner=impose_constraints)
-  def constrained_squared(x): #XXX: proxy doesn't preserve function signature
-    return [i**2 for i in x]
-
-  from numpy import array
-  x = array([1,2,3,4,5])
-  y = impose_spread(50.0, impose_mean(5.0,x))
-  assert constrained_squared(x, 5.0, 50.0) == [i**2 for i in y]
-
 
 def test_monitored():
@@ -251 +138 @@
 
 
-def test_constrain():
-
-  from mystic.math.measures import mean, spread
-  from mystic.math.measures import impose_mean, impose_spread
-  def mean_constraint(x, mean=0.0):
-    return impose_mean(mean, x)
-
-  def range_constraint(x, spread=1.0):
-    return impose_spread(spread, x)
-
-  @nested(inner=range_constraint, kwds={'spread':5.0})
-  @nested(inner=mean_constraint, kwds={'mean':5.0})
-  def constraints(x):
-    return x
-
-  def cost(x):
-    return abs(sum(x) - 5.0)
-
-  from mystic.solvers import fmin_powell
-  from numpy import array
-  x = array([1,2,3,4,5])
-  y = fmin_powell(cost, x, constraints=constraints, disp=False)
-
-  assert mean(y) == 5.0
-  assert spread(y) == 5.0
-  assert almostEqual(cost(y), 4*(5.0))
-
-
-
 if __name__ == '__main__':
-  test_wrap()
-  test_nested()
-  test_wrap_constraint()
-  test_nested_constraint()
-  test_proxified_constraint()
-  test_nested_constraints()
-  test_proxified_constraints()
   test_monitored()
   test_counted()
@@ -297 +148 @@
   test_target_bounded()
   test_bounce_bounded()
-  test_constrain()
 
 

branches/decorate/wrapper.py

@@ -3 +3 @@
 
 #XXX: when_decorated registers methods to 'populate up' when is decorated ?
-
-
-def wrap(outer=lambda x:x, args=None, kwds=None): #XXX: *args, **kwds ?
-    """wrap a function around another function: convert y = f(x) to y' = c(f(x))
-
-This is useful, for example, in nesting one constraint in another constraint.
-    """
-    if args is None: args=()
-    if kwds is None: kwds={}
-    def dec(f):
-        def func(x, *argz, **kwdz):
-            return outer(f(x, *argz, **kwdz), *args, **kwds)
-        return func
-    return dec
-
-
-def nested(inner=lambda x:x, args=None, kwds=None): #XXX: *args, **kwds ?
-    """nest a function within another function: convert y = f(x) to y' = f(c(x))
-
-This is useful, for example, in nesting constraints in a cost function;
-thus, the constraints will be enforced at every cost function evaluation.
-    """
-    if args is None: args=()
-    if kwds is None: kwds={}
-    def dec(f):
-        def func(x, *argz, **kwdz):
-            return f(inner(x, *args, **kwds), *argz, **kwdz)
-        return func
-    return dec
-
-
-def proxify(inner=lambda x:x):
-    """nest a function within another function: convert y = f(x) to y' = f(c(x))
-
-This is useful, for example, in nesting constraints in a cost function;
-thus, the constraints will be enforced at every cost function evaluation.
-
-This function does not preserve decorated function signature, but passes args
-and kwds to the inner function.  The decorated function should require a
-single parameter as input.
-    """
-    def dec(f):
-        def func(*args, **kwds):
-            return f(inner(*args, **kwds))
-        return func
-    return dec