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

# svpmc: Stochastic Volatility Inference via Population Monte Carlo
#
# Copyright (C) 2007-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

"""
Time series data sources.
"""

import re, os.path
import scipy as s
from twisted.spread import pb

from twisted_goodies.pybywire import params


def transform(f):
    """
    Decorate a method of L{TimeSeries} with me to allow it optionally accept a vector
    of values to be transformed. If the vector is supplied, the method will
    transform that and return the result. Otherwise it will transform the
    instance's values in-place and, for convenience, return a reference to the
    instance.

    Keywords can be included and will not affect whether the method is
    transformative or not.
    """
    def wrapper(self, *Y, **kw):
        if Y:
            YY = Y[0]
        else:
            YY = self.data[:,1]
        N1 = len(YY)
        YY = f(self, YY, **kw)
        if Y:
            return YY
        self.Y(YY)
        return self

    wrapper.__name__ = f.__name__
    return wrapper
    

class Loader(object):
    """
    Base class for file and string loaders. You can call an instance of those
    classes to get a sorted 2-D array in which each row contains the year and
    value of one data point loaded from the file.
    """
    monthList = [
        'jan', 'feb', 'mar', 'apr', 'may', 'jun',
        'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
    reList = [
        (x, re.compile("^\s*%s\s+([0-9\.]+)\s*$" % y))
        for x, y in [
        ('ymd',
         "(\d{4})[\-\./](\d{1,2})[\-\./](\d{1,2})"),
        ('dMy',
         "(\d{1,2})[\-\ ]([jfmasondJFMASOND][a-z]{2})[\-\ ](\d{2})"),
        ('ym',
         "(\d{4})[\-\./](\d{1,2})")]]

    def __call__(self):
        rows = self.load()
        rows.sort(key=lambda x: x[0])
        return s.array(rows)
        
    def parseLine(self, line):
        """
        Attempts to parse one line of the data file, returning C{None} if the
        attempt failed. If it succeeded, returns the year (as a float, with
        months being fractional values) and the value.
        """
        if not line or line.strip().startswith('#'):
            return
        for dateCode, thisRe in self.reList:
            m = thisRe.match(line)
            if m is None:
                continue
            year = 1.0 / 365
            for k, char in enumerate(dateCode):
                if char == 'y':
                    rawYear = int(m.group(k+1))
                    if rawYear < 100:
                        # WARNING: Not Y2K compliant!!!!!
                        year += 1900+rawYear
                    else:
                        year += rawYear
                elif char == 'm':
                    year += (float(m.group(k+1)) - 1) / 12
                elif char == 'M':
                    month = self.monthList.index(m.group(k+1).lower())
                    year += float(month) / 12
                elif char == 'd':
                    year += ((float(m.group(k+1)) - 1) / 365)
            return year, float(m.group(k+2))


class FileLoader(Loader):
    """
    Instantiate me with the path (absolute or relative to current path) of a
    source data file. Then you can call my instance to get a sorted 2-D array
    in which each row contains the date and value of one data point loaded from
    the file.
    """

    def __init__(self, filePath):
        self.filePath = os.path.abspath(filePath)

    def load(self):
        rows = []
        fh = open(self.filePath)
        for line in fh:
            parsed = self.parseLine(line)
            if parsed:
                rows.append(parsed)
        fh.close()
        return rows


class TextLoader(Loader):
    """
    Instantiate me with a string of text and I'll load from it as L{FileLoader}
    would from a file containing that text.
    """
    def __init__(self, text):
        self.textLines = text.split("\n")
        
    def load(self):
        rows = []
        for line in self.textLines:
            parsed = self.parseLine(line)
            if parsed:
                rows.append(parsed)
        del self.textLines
        return rows


class TimeSeries(params.Parameterized):
    """
    I am a time series of stochastic source data, with methods especially
    suited to financial time series.
    """
    _X, _Y = None, None

    paramNames = ['data']
    
    def __init__(
        self, name, filePath=None, text=None, data=None, j=None, k=None):
        self.name = name
        if filePath:
            data = FileLoader(filePath)()
        elif text:
            data = TextLoader(text)()
        params.Parameterized.__init__(self, data=data[slice(j, k),:])

    def X(self):
        return self.data[:,0]

    def Y(self, value=None):
        if value is None:
            return self.data[:,1]
        if len(value) != s.shape(self.data)[0]:
            raise ValueError("Transforms can't change data length!")
        data = s.column_stack([self.data[:,0], value])
        self.data = data

    def __call__(self):
        """
        You can simply call me to get my full Y vector.
        """
        return self.Y()

    def __getitem__(self, key):
        """
        Returns a copy of me with data limited to a year or range of years.
        """
        X = self.X()
        N = len(X)
        if isinstance(key, slice):
            start, stop = key.start, key.stop
        else:
            start = stop = key
        if start is None:
            start = min(X)
        elif start < 0:
            start = max(X) + start
        if stop is None:
            stop = max(X)
        elif stop < 0:
            stop = max(X) + stop
        I = s.arange(N)[s.greater_equal(X, start) & s.less(X, stop+1)]
        if len(I):
            return self.copy(I[0], I[-1]+1)

    def __hash__(self):
        X = self.X()
        return hash((self.name, min(X), max(X), len(X)))

    def __len__(self):
        return len(self.Y())

    def __abs__(self):
        return s.absolute(self.Y())

    def transmogrifator(self, other):
        if isinstance(other, TimeSeries):
            newTimeSeriesObject = self.intersect(other)
            otherTimeSeries = other.intersect(self).Y()
        else:
            newTimeSeriesObject = self.copy()
            otherTimeSeries = other
        yield newTimeSeriesObject, otherTimeSeries

    def __mul__(self, other):
        for a, b in self.transmogrifator(other):
            a.Y(a.Y()*b)
        return a

    def __div__(self, other):
        for a, b in self.transmogrifator(other):
            a.Y(a.Y()/b)
        return a

    def __add__(self, other):
        for a, b in self.transmogrifator(other):
            a.Y(a.Y()+b)
        return a

    def __sub__(self, other):
        for a, b in self.transmogrifator(other):
            a.Y(a.Y()-b)
        return a

    def truncate(self, j=None, k=None):
        """
        """
        self.data = self.data[slice(j, k),:]

    def intersect(self, other):
        """
        Returns a copy of myself with elements restricted to those having time
        series X values that are also found in the I{other} data object.
        """
        X = s.intersect1d(self.X(), other.X())
        I = self.data[:,0].searchsorted(X)
        return self.copy(I[0], I[-1]+1)

    def copy(self, j=None, k=None):
        """
        Returns a copy of me with a copied underlying data array, extents of
        which may be limited to the slice I{j:k}.
        """
        return self.__class__(self.name, data=self.data.copy(), j=j, k=k)

    @transform
    def inv(self, Y):
        """
        Transforms values into their inverse (reciprocal) values.
        """
        return 1.0 / Y

    @transform
    def v2r(self, Y, earnings=None):
        """
        Transforms asset values into log returns relative to the previous
        value. The log return of the first value is set to 0.0.

        If I{earnings} is set to a vector, the log returns will be adjusted to
        account for increases in holdings proportional to each corresponding
        earnings amount, or decreases in the case of negative earnings. There
        must be an earnings value for every asset value except the last one.
        """
        N = len(Y)
        if earnings is None:
            E = s.zeros(N-1)
        elif len(earnings) < N-1:
            raise ValueError(
                "Must be an earnings value for every asset value except last")
        else:
            E = earnings[:N]
        R = s.ones(N)
        for k, earningsThisPeriod in enumerate(E):
            R[k+1] = (Y[k+1] + earningsThisPeriod) / Y[k]
        return s.log(R)

    @transform
    def r2p(self, Y):
        """
        Transforms asset log returns into percentage changes.
        """
        return 100*(s.exp(Y) - 1.0)

    @transform
    def p2v(self, Y):
        """
        Transforms percentage changes into asset values, with an initial value
        of 1.00 times the first percentage change.
        """
        def iterator():
            value = 1.0
            for fractionalChange in (0.01*Y + 1.0):
                value *= fractionalChange
                yield value

        return s.fromiter(iterator())