Source code for transfer

'''
Transfer Functions

by Patrick Ruoff in 2012
'''

from common import find_next

import math


class CTransfer(object):
    """ Base class for data transfers between a control value and a data item,
    i.e. a two way function,
    implements right shift operator for function concatenation
    >> hereby symbolizes the flow of the data from the control value to the data item
    """
    
    parent = None;
    
    def __init__(self):
        pass
        
    def FromWindow(self, data, key, val):
        """ Transfer data from window value *val* to data item *data*[*key*]
        never set impossible value!
        if there is an error, try to perform closest possible change 
        and return False
        otherwise return True
        """
        if self.parent:
            return self.parent.FromWindow(data, key, val);
        else:
            data[key] = val;
            return True;
            
    def ToWindow(self, data, key):
        if self.parent:
            return self.parent.ToWindow(data, key);
        else:
            return data[key];

    def __rshift__(self, other):
        self.parent = other;
        return self;
    

class CMinMaxTrans(CTransfer):
    """ Transfer that implements minimum and maximum limits for the data item """
    
    def __init__(self, v_min, v_max):
        CTransfer.__init__(self);
        self.v_min = v_min;
        self.v_max = v_max;
    
    def FromWindow(self, data, key, val):
        limited = False;
        if val < self.v_min:
            limited = True; 
            val = self.v_min;
        if val > self.v_max:
            limited = True;
            val = self.v_max;
        return CTransfer.FromWindow(self, data, key, val) and (not limited);
        
        
class CAffineTrans(CTransfer):
    """ Affine transfer function """
    
    def __init__(self, a, b):
        """ Construct affine transfer function with factor *a* and offset *b* 
        or from range *a* = (a_from, a_to) to range *b* = (b_from, b_to) given by tuples
        """
        CTransfer.__init__(self);
        if type(a) == tuple:
            self.a = (b[1]-b[0])/(a[1]-a[0]);
            self.b = b[0] - self.a * a[0];
        else:
            self.a = a;
            self.b = b;
        
    def FromWindow(self, data, key, val):
        return CTransfer.FromWindow(self, data, key, self.a*val + self.b);
    
    def ToWindow(self, data, key):
        return (CTransfer.ToWindow(self, data, key) - self.b) / self.a;
    
    
class CExpTrans(CTransfer):
    """ Exponential / Logarithmic transfer function """
    
    def __init__(self, c = 1, e = 10):
        """ Construct exponential transfer function with factor *c* and exponent *e* """
        CTransfer.__init__(self); 
        self.c = c;
        self.e = e;
        
    def FromWindow(self, data, key, val):
        return CTransfer.FromWindow(self, data, key, self.c * self.e**val);
    
    def ToWindow(self, data, key):
        return math.log(CTransfer.ToWindow(self, data, key) / self.c, self.e)
    

class CListIndexTrans(CTransfer):
    """ Maps number to index of closest number in sorted list """
    
    def __init__(self, sorted_list):
        self.sorted_list = sorted_list;
        
    def FromWindow(self, data, key, val):
        return CTransfer.FromWindow(self, data, key, find_next(self.sorted_list, val) )
    
    def ToWindow(self, data, key):
        return self.sorted_list[CTransfer.ToWindow(self, data, key)];