renamed IdxMap to ArrayOrdering, which seems more informative

Author: jsalvatier

pymc/blocking.py

@@ -6,12 +6,15 @@
 import numpy as np
 import collections
 
-__all__ = ['IdxMap', 'DictToArrayBijection', 'DictToVarBijection']
+__all__ = ['ArrayOrdering', 'DictToArrayBijection', 'DictToVarBijection']
 
 VarMap = collections.namedtuple('VarMap', 'var, slc, shp')
 
 # TODO Classes and methods need to be fully documented.
-class IdxMap(object):
+class ArrayOrdering(object):
+    """
+    An ordering for an array space
+    """
     def __init__(self, vars):
         self.vmap = []
         dim = 0
@@ -25,8 +28,11 @@ def __init__(self, vars):
 
 
 class DictToArrayBijection(object):
-    def __init__(self, idxmap, dpoint):
-        self.idxmap = idxmap
+    """
+    A mapping between a dict space and an array space
+    """
+    def __init__(self, ordering, dpoint):
+        self.ordering = ordering
         self.dpt = dpoint
 
     def map(self, dpt):
@@ -37,8 +43,8 @@ def map(self, dpt):
         ----------
         dpt : dict 
         """
-        apt = np.empty(self.idxmap.dimensions)
-        for var, slc, _ in self.idxmap.vmap:
+        apt = np.empty(self.ordering.dimensions)
+        for var, slc, _ in self.ordering.vmap:
                 apt[slc] = np.ravel(dpt[var])
         return apt
 
@@ -52,24 +58,31 @@ def rmap(self, apt):
         """
         dpt = self.dpt.copy()
 
-        for var, slc, shp in self.idxmap.vmap:
+        for var, slc, shp in self.ordering.vmap:
             dpt[var] = np.reshape(apt[slc], shp)
 
 
         return dpt
 
     def mapf(self, f):
         """
-        Maps function f : DictSpace -> T to ArraySpace -> T
+         function f : DictSpace -> T to ArraySpace -> T
         
         Parameters
-        ---------
+        ----------
 
         f : dict -> T 
+
+        Returns
+        -------
+        f : array -> T 
         """
-        return BijectionWrapFunc(self,f)
+        return Compose(self.rmap,f)
 
 class DictToVarBijection(object):
+    """
+    A mapping between a dict space and the array space for one element within the dict space
+    """
     def __init__(self, var, idx, dpoint):
         self.var = str(var)
         self.idx = idx
@@ -88,13 +101,16 @@ def rmap(self, apt):
 
         return dpt 
     def mapf(self, f):
-        return BijectionWrapFunc(self, f)
+        return Compose(self.rmap, f)
 
 
-class BijectionWrapFunc(object):
-    def __init__(self, bij, fn): 
-        self.bij = bij
-        self.fn = fn
+class Compose(object):
+    """
+    Compose two functions in a pickleable way
+    """
+    def __init__(self, fa, fb): 
+        self.fa = fa
+        self.fb = fb
 
-    def __call__(self, d):
-        return self.fn(self.bij.rmap(d))
+    def __call__(self, x):
+        return self.fa(self.fb(x))

pymc/step_methods/utils.py

@@ -7,12 +7,12 @@
 
 class array_step(object):
     def __init__(self, vars, fs, allvars = False):
-        self.idxmap = IdxMap(vars)
+        self.ordering = ArrayOrdering(vars)
         self.fs = fs
         self.allvars = allvars
 
     def step(self, state, point):
-        bij = DictToArrayBijection(self.idxmap, point)
+        bij = DictToArrayBijection(self.ordering, point)
 
         inputs = map(bij.mapf, self.fs) 
         if self.allvars:

pymc/tuning/scaling.py

@@ -24,7 +24,7 @@ def approx_hess(model, start, vars=None):
 
     start = clean_point(start)
 
-    bij = DictToArrayBijection(IdxMap(vars), start)
+    bij = DictToArrayBijection(ArrayOrdering(vars), start)
     dlogp = bij.mapf(model.dlogpc(vars))
 
 

pymc/tuning/starting.py

@@ -37,7 +37,7 @@ def find_MAP(model, start = None, vars=None, fmin = optimize.fmin_bfgs, return_r
         vars = model.cont_vars
 
     start = clean_point(start)
-    bij = DictToArrayBijection(IdxMap(vars), start)
+    bij = DictToArrayBijection(ArrayOrdering(vars), start)
 
     logp = bij.mapf(model.logpc)
     dlogp = bij.mapf(model.dlogpc(vars))

tests/test_distributions.py

@@ -86,7 +86,7 @@ def check_int_to_1(model, value, domains):
 def check_dlogp(model, value, domains): 
 
     domains = [d[1:-1] for d in domains]
-    bij = DictToArrayBijection(IdxMap(model.cont_vars), model.test_point)
+    bij = DictToArrayBijection(ArrayOrdering(model.cont_vars), model.test_point)
 
     dlp = model.dlogpc()
     dlogp = bij.mapf(model.dlogpc())