root/projects/AsynCluster/trunk/svpmc/weave.py

# svpmc: Stochastic Volatility Inference via Population Monte Carlo
#
# Copyright (C) 2008 by Edwin A. Suominen, http://www.eepatents.com
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
# 
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the file COPYING for more details.
# 
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

"""
Convenience class for doing inline C with SciPy.weave.

You can import from this module instead of scipy.weave. Then you get the
convenience class L{Weaver} in addition to the good stuff in scipy.weave.
"""

import inspect, re
from pkg_resources import resource_string
from scipy.weave import *
from scipy.weave.base_info import custom_info


class my_info(custom_info):
    _extra_compile_args = ['-w', '-O3', '-march=native']
    __macros = [
        # Access an element i of a 1-D array whose pointer is pa
        'PA1(pa,i)',
        "*(pa + i)",

        # Access an element i of a 1-D array whose pointer is pa in a structure
        # whose pointer is s
        'SPA1(s,pa,i)',
        "*(s->pa + i)",

        # Access an element i, j of a 2-D Numpy array object whose pointer is
        # ppa
        'PP2(ppa,i,j)',
        "(*((double*)(ppa->data + (i)*ppa->strides[0] + (j)*ppa->strides[1])))",

        # Access an element i of a 1-D Numpy array object whose pointer is ppa
        # in a structure whose pointer is s
        'SPP1(s,ppa,i)',
        "(*((double*)(s->ppa->data + (i)*s->ppa->strides[0])))",
        
        # Access an element i, j of a 2-D Numpy array object whose pointer is
        # ppa in a structure whose pointer is s
        'SPP2(s,ppa,i,j)',
        "(*((double*)(s->ppa->data + "+\
        "(i)*s->ppa->strides[0] + (j)*s->ppa->strides[1])))",
        ]

    def __init__(self):
        k = 0
        macros = ["'%s'" % (x,) for x in self.__macros]
        while(k < len(macros)):
            name, value = macros[k:k+2]
            self.add_define_macro((name, value))
            self.add_undefine_macro(name)
            k += 2


class Weaver(object):
    """
    Subclass from me to conveniently use a separate C code file for inline
    operations.

    The code file is for the entire module in which my sublcass resides, and
    must be present in that module's directory under the name C{<module>.c}. It
    is parsed into sections with headings as inline C comments in the following
    format::

        // <subclass>.<method in which 'c' base class method is called>

    The subclass name must start with a capital letter and the method name with
    a lowercase letter (possibly followed by one or two underscores), as is
    conventional. There must not be anything else but whitespace on the comment
    line.
    """
    infoObj = my_info()
    
    def _parseCode(self, text):
        re_delimiter = re.compile(
            "//\s+([A-Z][A-Za-z0-9_]+)\.(_{0,2}[a-z][A-Za-z0-9_]+)\s*$")
        cName = self.__class__.__name__
        key = None
        lines = []
        result = {'support':None}
        for line in text.split("\n"):
            m = re_delimiter.match(line)
            if m is None:
                if key:
                    lines.append(line)
                continue
            if lines:
                result[key] = "\n".join(lines)
                lines = []
            if m.group(1) == cName:
                key = m.group(2)
            else:
                key = None
        if lines:
            result[key] = "\n".join(lines)
        return result
    
    def _get_code(self):
        if not hasattr(self, '_code'):
            moduleName = self.__class__.__module__.split(".")[-1]
            self._code = self._parseCode(
                resource_string(__name__, "%s.c" % moduleName))
        return self._code
    code = property(_get_code)

    def inline(self, *args, **kw):
        """
        Call this method to run the inline code for the calling method of the
        subclass.

        Supply the names of variables to use as arguments in order as
        arguments. The variables can have their values set via keywords;
        otherwise they will be retrieved from the caller's namespace or,
        failing that, from my instance's namespace as C{self.<varname>}.

        A reference to the result of the inline call, set inside the C code via
        the variable I{return_val}, is returned.
        """
        local_dict = kw
        frame = inspect.currentframe()
        methodName = frame.f_back.f_code.co_name
        callerVarNames = frame.f_back.f_locals.keys()
        try:
            for varName in args:
                if varName in kw:
                    continue
                if varName in callerVarNames:
                    local_dict[varName] = frame.f_back.f_locals[varName]
                elif hasattr(self, varName):
                    local_dict[varName] = getattr(self, varName)
                else:
                    raise AttributeError(
                        "Variable '%s' not defined " % varName +\
                        "in keyword, caller, or instance namespace")
        finally:
            # Avoid cycle problems, per Python Library Reference 3.11.4
            del frame
        return inline(
            self.code[methodName], args, local_dict,
            customize=self.infoObj, support_code=self.code['support'])

    def inlineDirect(self, code, **kw):
        """
        Call this method with a string of C I{code} and keywords defining the
        names and values of variables to be passed to the code function.

        Using this method entails less CPU overhead (but also less convenience
        and flexibility) than using L{inline}.
        """
        return inline(
            code, kw.keys(), kw,
            customize=self.infoObj, support_code=self.code['support'])