source: branches/decorate/wrapper.py @ 855

#!/usr/bin/env python
#
# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
# Copyright (c) 2012-2016 California Institute of Technology.
# License: 3-clause BSD.  The full license text is available at:
#  - http://mmckerns.github.io/project/mystic/browser/mystic/LICENSE

#XXX: be mindful if the decorators restrict to functions that expect arrays
#     compare against the originals for restrictions

#XXX: when_decorated registers methods to 'populate up' when is decorated ?

from mystic.tools import Null
def monitored(monitor=Null):
    """bind a monitor to a function object"""
    def dec(f):
        def func(x, *args, **kwds):
            fval =  f(x, *args, **kwds)
            monitor(x, fval)
            return fval
        return func
    return dec


def counted(f):
    """bind a counter to a function object"""
    ncalls = [0]
    def func(x, *args, **kwds):
        ncalls[0] += 1
        fval =  f(x, *args, **kwds)
        return ncalls, fval
    return func


def monitoredcounted(monitor=Null):
    """bind a counter and a monitor to a function object"""
    def dec(f):
        ncalls = [0]
        def func(x, *args, **kwds):
            ncalls[0] += 1
            fval =  f(x, *args, **kwds)
            monitor(x, fval)
            return ncalls, fval
        return func
    return dec


from numpy import asarray, any, inf, vectorize
def bounded(min=None, max=None):
    """impose an infinite barrier box constraint on a function

If any of the bounds are violated, the function will evaluate to 'inf'

Example:
>>> @bounded(1,10)
... def squared(x):
...   return x**2

>>> squared(0)
inf
>>> squared(10)
100
>>> squared(11)
inf
    """
    bounds = True
    if min is not None and max is not None: #has upper & lower bound
        min = asarray(min)
        max = asarray(max)
    elif min is not None: #has lower bound
        min = asarray(min)
        max = asarray([inf for i in min])
    elif max is not None: #has upper bound
        max = asarray(max)
        min = asarray([-inf for i in max])
    else: #not bounded
        bounds = False
    def dec(f):
        if bounds:
            def func(x, *args, **kwds):
                if any((x<min)|(x>max)): #if violate bounds, evaluate as inf
                    return inf #XXX: better, return x with xi=inf where violate?
                return f(x, *args, **kwds)
        else:
            def func(x, *args, **kwds):
                return f(x, *args, **kwds)
        return func
    return dec


def isbounded(func, x, min=None, max=None):
    """return False if func(x) evaluates outside the bounds, True otherwise.

Inputs:
    func -- a function of x.
    x -- a list of parameters.

Additional Inputs:
    min -- list of lower bounds on parameters.
    max -- list of upper bounds on parameters.
"""
    #from numpy import clip, array   #XXX: numpy.clip doesn't need/use func
    #return all(clip(x,min,max) == array(x))
    bound = bounded(min,max)
    wrapped = bound(func)
    if wrapped(x) == inf:
        return False    
    return True


def mixedin(scale=1.0, shift=0.0, mixin=lambda x:x, normalized=False):
  """build a function from the weighted sum of two functions

The resulting function is: f'(x) = scale * f(x) + shift * mixin(x).
If normalized, then f' = f' / (scale + shift)"""
  def dec(f):
    def func(*args, **kwds):
      norm = 1.0
      if normalized: norm = scale + shift
      return (scale * f(*args, **kwds) + shift * mixin(*args, **kwds)) / norm
    return func
  return dec


#FIXME: the following should preserve the input type
def __clip_bound(x, amin, amax):
  return max(min(x, amax), amin)
clip_bound = vectorize(__clip_bound)

def __bounce_bound(x, amin, amax):
  if not x <= amax:
    x = amax-(amax-amin)*((x-amax)/(x+amax))
  if not x >= amin:
    x = amin+(amax-amin)*((amin-x)/(amin+x))
  return x
bounce_bound = vectorize(__bounce_bound)

def __target_bound(x, amin, amax, target):
  if not x <= amax:
    x = min(target, amax)
  if not x >= amin:
    x = max(target, amin)
  return x
target_bound = vectorize(__target_bound)

"""
def _clip_bound(x, amin, amax):
  return [__clip_bound(xi,li,ui) for xi,li,ui in zip(x,amin,amax)]

def _bounce_bound(x, amin, amax):
  return [__bounce_bound(xi,li,ui) for xi,li,ui in zip(x,amin,amax)]

def _target_bound(x, amin, amax, target):
  return [__target_bound(xi,li,ui,target) for xi,li,ui in zip(x,amin,amax)]
"""

def clip_bounded(min, max):
    def dec(f):
        def func(x, *args, **kwds):
            return f(clip_bound(x, min, max), *args, **kwds)
        return func
    return dec

def bounce_bounded(min, max):
    def dec(f):
        def func(x, *args, **kwds):
            return f(bounce_bound(x, min, max), *args, **kwds)
        return func
    return dec

def target_bounded(min, max, target):
    def dec(f):
        def func(x, *args, **kwds):
            return f(target_bound(x, min, max, target), *args, **kwds)
        return func
    return dec


# EOF