Revert "added calc_utils"

This reverts commit 1428e4c, reversing
changes made to 094a269.

Author: jsalvatier

pymc/CommonDeterministics.py

@@ -15,13 +15,11 @@
 from Container import Container
 from InstantiationDecorators import deterministic, check_special_methods
 import numpy as np
-from numpy import sum, shape,size, ravel, sign, zeros, ones, broadcast, newaxis
-import inspect, types
-from utils import safe_len, stukel_logit, stukel_invlogit, logit, invlogit, value, find_element
+import inspect
+from utils import safe_len, stukel_logit, stukel_invlogit, logit, invlogit, value
 from types import UnboundMethodType
 from copy import copy
 import sys
-import operator, __builtin__
 
 __all__ = ['CompletedDirichlet', 'LinearCombination', 'Index', 'Lambda', 'lambda_deterministic', 'lam_dtrm',
             'logit', 'invlogit', 'stukel_logit', 'stukel_invlogit', 'Logit', 'InvLogit', 'StukelLogit', 'StukelInvLogit',
@@ -319,7 +317,7 @@ def eval_fun(x, y):
                 stochastic_elem = x[i]
                 self.sides[stochastic_elem].append('L')
                 this_coef = Lambda('%s_coef'%stochastic_elem, lambda c=y[i]: np.asarray(c))
-                self.coefs[stochastic_elem].append(this_coef) 
+                self.coefs[stochastic_elem].append(this_coef)
 
             if isinstance(y[i], pm.Stochastic):
 
@@ -486,36 +484,25 @@ def wrapper(**wkwds_in):
 # = Add special methods to variables to support FBC syntax =
 # ==========================================================
 
-def create_uni_method(op_name, klass, jacobians = None):
+def create_uni_method(op_name, klass):
     """
     Creates a new univariate special method, such as A.__neg__() <=> -A,
     for target class. The method is called __op_name__.
     """
     # This function will become the actual method.
-    op_modules = [operator, __builtin__]
-    op_names = [ op_name, op_name + '_']
-
-    op_function_base = find_element( op_names,op_modules, error_on_fail = True)
-    #many such functions do not take keyword arguments, so we need to wrap them 
-    def op_function(self):
-        return op_function_base(self)
-    
     def new_method(self):
         # This code creates a Deterministic object.
-        if not check_special_methods():
-            raise NotImplementedError, 'Special method %s called on %s, but special methods have been disabled. Set pymc.special_methods_available to True to enable them.'%(op_name, str(self))
-            
-        jacobian_formats = {'self' : 'transformation_operation'}
-        return pm.Deterministic(op_function,
+        def eval_fun(self,op=op):
+            if not check_special_methods():
+                raise NotImplementedError, 'Special method %s called on %s, but special methods have been disabled. Set pymc.special_methods_available to True to enable them.'%(op_name, str(self))
+            return getattr(self, op)()
+        return pm.Deterministic(eval_fun,
                                 'A Deterministic returning the value of %s(%s)'%(op_name, self.__name__),
                                 '('+op_name+'_'+self.__name__+')',
-                                parents = {'self':self},
+                                {'self':self, 'op': '__'+op_name+'__'},
                                 trace=False,
-                                plot=False, 
-                                jacobians=jacobians,
-                                jacobian_formats = jacobian_formats)
-    # Make the function into a method for klass. 
-    
+                                plot=False)
+    # Make the function into a method for klass.
     new_method.__name__ = '__'+op_name+'__'
     setattr(klass, new_method.__name__, UnboundMethodType(new_method, None, klass))
 
@@ -533,11 +520,7 @@ def new_method(self, op=op):
     new_method.__name__ = '__'+op.__name__+'__'
     setattr(klass, new_method.__name__, UnboundMethodType(new_method, None, klass))
 
-
-        
-                
-
-def create_rl_bin_method(op_name, klass,  jacobians = {}):
+def create_rl_bin_method(op_name, klass):
     """
     Creates a new binary special method with left and right versions, such as
         A.__mul__(B) <=> A*B,
@@ -547,33 +530,34 @@ def create_rl_bin_method(op_name, klass,  jacobians = {}):
     # Make left and right versions.
     for prefix in ['r','']:
         # This function will became the methods.
-        op_modules = [operator, __builtin__]
-        op_names = [ op_name, op_name + '_']
-
-        op_function_base = find_element( op_names, op_modules, error_on_fail = True)
-        #many such functions do not take keyword arguments, so we need to wrap them 
-        def op_function(a, b):
-            return op_function_base(a, b)
-            
         def new_method(self, other, prefix=prefix):
             if not check_special_methods():
                 raise NotImplementedError, 'Special method %s called on %s, but special methods have been disabled. Set pymc.special_methods_available to True to enable them.'%(op_name, str(self))
             # This code will create one of two Deterministic objects.
             if prefix == 'r':
-                parents = {'a':other, 'b':self}
-                
+                # Right version: raises error on failure.
+                parents = {'self':self, 'other':other, 'op':'__r' + op_name + '__'}
+                def eval_fun(self,other,op):
+                    out = getattr(self, op)(other)
+                    if out is NotImplemented:
+                        # the rt version has failed, meainng the lft version has failed as well.
+                        raise TypeError, "unsupported operand type(s) for %s: '%s' and '%s'"%(op.replace('_',''), self.__class__.__name__, other.__class__.__name__)
+                    return out
             else:
-                parents = {'a':self, 'b':other}
-            jacobian_formats = {'a' : 'broadcast_operation',
-                               'b' : 'broadcast_operation'}
-            return pm.Deterministic(op_function,
+                # Left version: tries right version on failure.
+                parents = {'self':self, 'other':other, 'op':'__' + op_name + '__', 'rt_op': '__r'+op_name+'__'}
+                def eval_fun(self, other, op, rt_op):
+                    out = getattr(self, op)(other)
+                    if out is NotImplemented:
+                        # if try the rt version.
+                        out = getattr(other, rt_op)(self)
+                    return out
+            return pm.Deterministic(eval_fun,
                                     'A Deterministic returning the value of %s(%s,%s)'%(prefix+op_name,self.__name__, str(other)),
                                     '('+'_'.join([self.__name__,prefix+op_name,str(other)])+')',
                                     parents,
                                     trace=False,
-                                    plot=False,
-                                    jacobians = jacobians,
-                                    jacobian_formats = jacobian_formats)
+                                    plot=False)
         # Convert the functions into methods for klass.
         new_method.__name__ = '__'+prefix+op_name+'__'
         setattr(klass, new_method.__name__, UnboundMethodType(new_method, None, klass))
@@ -644,62 +628,20 @@ def new_method(self, *args):
     new_method.__name__ = '__'+op_name+'__'
     setattr(klass, new_method.__name__, UnboundMethodType(new_method, None, klass))
 
-def op_to_jacobians(op, module):
-    if type(module) is types.ModuleType:
-        module = copy(module.__dict__)
-    elif type(module) is dict:
-        module = copy(module)
-    else:
-        raise AttributeError
-
-    name = op + "_jacobians"
-    try:
-       jacobians = module[name]
-    except:
-        jacobians = {} 
-    
-    return jacobians
-
 # Left/right binary operators
-
-    
-truediv_jacobians = {'a' : lambda a, b: ones(shape(a))/b,
-                    'b' : lambda a, b: - a / b**2  }
-
-div_jacobians = truediv_jacobians        
-    
-pow_jacobians = {'a' : lambda a, b: b * a**(b - 1.0),
-                'b' : lambda a, b: np.log(a) * a**b}  
-
-
 for op in ['div', 'truediv', 'floordiv', 'mod', 'divmod', 'pow', 'lshift', 'rshift', 'and', 'xor', 'or']:
-    create_rl_bin_method(op, Variable, jacobians = op_to_jacobians(op, locals()))
-
-# Binary operators eq not part of this set because it messes up having stochastics in lists 
-for op in ['lt', 'le', 'ne', 'gt', 'ge']:
-     create_bin_method(op ,Variable)
-    
-def equal(s1, s2): #makes up for deficiency of __eq__
-    return pm.Deterministic(lambda x1, x2 : x1 == x2,
-                            'A Deterministic returning the value of x1 == x2',
-                            '('+'_'.join([s1.__name__,'=',str(s2)])+')',
-                            {'x1':s1, 'x2':s2},
-                            trace=False,
-                            plot=False)
+    create_rl_bin_method(op, Variable)
 
+# # Binary operators
+# for op in ['lt', 'le', 'eq', 'ne', 'gt', 'ge']:
+#     create_bin_method(op ,Variable)
 
 # Unary operators
-neg_jacobians = {'self' : lambda self: -ones(shape(self))}
-
-pos_jacobians = {'self' : lambda self: np.ones(shape(self))}
-
-abs_jacobians = {'self' : lambda self: np.sign(self)}
-
-for op in ['neg','abs','invert']: # no need for pos and __index__ seems to cause a lot of problems
-    create_uni_method(op, Variable, jacobians = op_to_jacobians(op, locals()))
+for op in ['neg','pos','abs','invert','index']:
+    create_uni_method(op, Variable)
 
 # Casting operators
-for op in [iter,complex,int,long,float,oct,hex]:
+for op in [iter,complex,int,long,float,oct,hex,len]:
     create_casting_method(op, Variable)
 
 # Addition, subtraction, multiplication
@@ -712,50 +654,31 @@ def equal(s1, s2): #makes up for deficiency of __eq__
 # create_rl_lin_comb_method('rmul', Variable, ['self'],['other'])
 
 #TODO: Comment once LinearCombination issues are ironed out.
-
-add_jacobians = {'a' : lambda a, b:  ones(broadcast(a,b).shape),
-                 'b' : lambda a, b:  ones(broadcast(a,b).shape)}
-
-mul_jacobians = {'a' : lambda a, b: ones(shape(a)) * b,
-                 'b' : lambda a, b: ones(shape(b)) * a}
-
-sub_jacobians = {'a' : lambda a, b:  ones(broadcast(a,b).shape),
-                 'b' : lambda a, b: -ones(broadcast(a,b).shape)}
-
 for op in ['add', 'mul', 'sub']:
-    create_rl_bin_method(op, Variable, jacobians = op_to_jacobians(op, locals()))
+    create_rl_bin_method(op, Variable)
 
 for op in ['iadd','isub','imul','idiv','itruediv','ifloordiv','imod','ipow','ilshift','irshift','iand','ixor','ior','unicode']:
     create_nonimplemented_method(op, Variable)
 
 
-def getitem_jacobian(self, index):
-    return index
-
-
 # Create __getitem__ method.
 def __getitem__(self, index):
     if not check_special_methods():
         raise NotImplementedError, 'Special method __index__ called on %s, but special methods have been disabled. Set pymc.special_methods_available to True to enable them.'%str(self)
     # If index is number or number-valued variable, make an Index object
     name = '%s[%s]'%(self.__name__, str(index))
-    if np.isscalar(value(index)) and len(np.shape(self.value)) < 2:
+    if np.isscalar(value(index)):
         if np.isreal(value(index)):
             return Index(name, self, index, trace=False, plot=False)
     # Otherwise make a standard Deterministic.
     def eval_fun(self, index):
         return self[index]
-    
-    jacobians = {'self' : getitem_jacobian}
-    jacobian_formats = {'self' : 'index_operation'}
     return pm.Deterministic(eval_fun,
                             'A Deterministic returning the value of %s[%s]'%(self.__name__, str(index)),
                             name,
                             {'self':self, 'index':index},
                             trace=False,
-                            plot=False,
-                            jacobians = jacobians,
-                            jacobian_formats = jacobian_formats)
+                            plot=False)
 Variable.__getitem__ = UnboundMethodType(__getitem__, None, Variable)
 
 # Create __call__ method for Variable.

pymc/Node.py

@@ -28,28 +28,7 @@ def logp_of_set(s):
     else:
         raise exc[0], exc[1], exc[2]
 
-def logp_gradient_of_set(variable_set, calculation_set = None):
-    """
-    Calculates the gradient of the joint log posterior with respect to all the variables in variable_set.
-    Calculation of the log posterior is restricted to the variables in calculation_set. 
-    
-    Returns a dictionary of the gradients.
-    """
-
-    logp_gradients = {}
-    for variable in variable_set:   
-        logp_gradients[variable] = logp_gradient(variable, calculation_set)
-                    
-    return logp_gradients
-    
-def logp_gradient(variable, calculation_set = None):
-    """
-    Calculates the gradient of the joint log posterior with respect to variable. 
-    Calculation of the log posterior is restricted to the variables in calculation_set. 
-    """
-    return variable.logp_partial_gradient(variable, calculation_set) + sum([child.logp_partial_gradient(variable, calculation_set) for child in variable.children] )
 
-    
 def batchsd(trace, batches=5):
     """
     Calculates the simulation standard error, accounting for non-independent