time_series.hpp

#ifndef HAVE_TOM__TIMESERIES_HPP
#define HAVE_TOM__TIMESERIES_HPP
 
#include <tom-util/defines.hpp>
#include <tom-util/calendar.hpp>
#include <tom-util/scalar.hpp>
 
#include <vector>
#include <algorithm>
#include <iostream>
 
namespace tom {
 
namespace collections {
    
    using namespace tom::calendars;
    
class time_series;
class time_series_iterator;
class standard_time_series_iterator;
 
// garbage collected time_series class
// that wraps up basic time_series functionality
class TOM_UTIL_API time_series 
{
public:
    // empty ts w/ calendar
    time_series(  ) : m_start_date_int( 0 ), m_end_date_int(0) {  };
    virtual ~time_series() {  }
 
    virtual time_series_iterator &begin() const = 0;
    virtual time_series_iterator &end() const = 0;
    
    virtual const observation &get_observation( date_int_type d ) const = 0;
    virtual const observation &get_observation( date d ) const = 0;
    
    // provide specific handlers for dates since they will need to 
    // be properly converted if time-series hold date_interval_observation
    // values...which most(ALL!) date series will!
    virtual void set_observation( date_int_type d, const Date & ) = 0;
    virtual void set_observation( date d, const Date & ) = 0;
    
    virtual void set_observation( date_int_type d, const observation & val ) = 0;
    virtual void set_observation( date d, const observation & val ) = 0;
    virtual void set_observation( const Date &d, const observation &val )
    {
        if ( d.is_normal() )
            set_observation( date( d.value() ), val );
    }
    
    // useful helpers for native formats
    
    // native float setters
    void set_observation( date_int_type d, float f )
        { set_observation(d, Float(f) ); }
    void set_observation( date d, float f )
        { set_observation(d, Float(f) ); }
    void set_observation( const Date &d, float f )
        { set_observation(d, Float(f) ); }
    
    // native double setters
    void set_observation( date_int_type d, double f )
        { set_observation(d, Double(f) ); }
    void set_observation( date d, double f )
        { set_observation(d, Double(f) ); }
    void set_observation( const Date &d, double f )
        { set_observation(d, Double(f) ); }
 
    // native std::string setters
    virtual
    void set_observation( date_int_type d, const std::string &f )
        { set_observation(d, String(f) ); }
    virtual
    void set_observation( date d, const std::string &f )
        { set_observation(d, String(f) ); }
    virtual
    void set_observation( const Date &d, const std::string &f )
        { set_observation(d, String(f) ); }
 
    // native const char * setters
    virtual
    void set_observation( date_int_type d, const char *f )
        { set_observation(d, String(f) ); }
    virtual
    void set_observation( date d, const char *f )
        { set_observation(d, String(f) ); }
    virtual
    void set_observation( const Date &d, const char *f )
        { set_observation(d, String(f) ); }
 
    // native int setters
    void set_observation( date_int_type d, int f )
        { set_observation(d, Int(f) ); }
    void set_observation( date d, int f )
        { set_observation(d, Int(f) ); }
    void set_observation( const Date &d, int f )
        { set_observation(d, Int(f) ); }
 
    // native bool setters
    void set_observation( date_int_type d, bool f )
        { set_observation(d, Bool(f) ); }
    void set_observation( date d, bool f )
        { set_observation(d, Bool(f) ); }
    void set_observation( const Date &d, bool f )
        { set_observation(d, Bool(f) ); }
 
    // native category_type setters
    void set_observation(   date_int_type d, 
                            tom::value_type f )
        { set_observation(d, Int(f) ); }
    void set_observation( date d, tom::value_type f )
        { set_observation(d, Int(f) ); }
    void set_observation( const Date &d, tom::value_type f )
        { set_observation(d, Int(f) ); }
 
    
    virtual const observation & operator[ ](  date_int_type d ) const = 0;
    virtual observation & operator[ ](  date_int_type d ) = 0;
    virtual const observation & operator[ ] ( date d ) const = 0;
    virtual observation & operator[ ] ( date d ) = 0;
 
    virtual std::ostream &print( std::ostream & ) const = 0;
    virtual tom::calendars::calendar & get_calendar( )  const = 0;
    
    virtual inline date_int_type get_first_date_int() const { return m_start_date_int; }
    virtual inline date_int_type get_last_date_int() const { return m_end_date_int; }
    inline date get_first_date() const { return get_calendar()( get_first_date_int() ); }
    inline date get_last_date() const { return get_calendar()( get_last_date_int()); }
 
    // allow optional exposing of void * to data space
    // this will likely not remain, so don't use this unless you are tom mccubbin!
    // DEFAULT impl returns NULL ptr.  classes wishing to hand out ptrs
    // to memory may do so by overriding this method
    virtual const void *data() const { return NULL; }
    
protected:
    // these can be safely called w/out regard
    // for 'd' being the actual start or end
    date_int_type set_last_date_int( const date_int_type d );
    date_int_type set_first_date_int( const date_int_type d );
 
    date_int_type   m_start_date_int;   // first date inclusive
    date_int_type   m_end_date_int;     // last date inclusive (not end())
 
private:
};
 
// ostream << function
inline
std::ostream &
operator<<( std::ostream &os, const time_series &ts )
{
    return ts.print(os);
}
 
class TOM_UTIL_API time_series_iterator 
{
public:
    virtual 
    ~time_series_iterator() { }
 
    virtual
    time_series_iterator &
    operator++() = 0;
 
    virtual
    time_series_iterator &
    operator++(int) = 0;
 
    virtual
    time_series_iterator &
    operator--() = 0;
 
    virtual
    time_series_iterator &
    operator--(int) = 0;
 
    virtual
    bool
    operator==( const tom::collections::time_series_iterator& rhs) const = 0;
    
    virtual
    bool
    operator!=( const tom::collections::time_series_iterator& rhs) const = 0;
    
    virtual
    const observation &
    operator*() const = 0;
 
    virtual
    const observation &
    operator->() const = 0;
 
    virtual
    date
    get_date() const = 0;
 
    virtual
    date_int_type
    get_date_int() const = 0;
 
    // dummy implementation
    virtual
    timespec
    get_timespec() const { struct timespec spec {0,0}; return spec; }
 
    virtual
    calendar &
    get_calendar() const = 0;
    
};
class TOM_UTIL_API standard_time_series_iterator : public time_series_iterator
{
public:
    standard_time_series_iterator ( time_series &ts, date_int_type d ) :
        m_ts( ts ), m_cal( ts.get_calendar() ), m_date_int(d)
        { }
 
    standard_time_series_iterator ( time_series &ts, date d ) :
        m_ts( ts ), m_cal( ts.get_calendar() ), m_date_int( m_cal(d) )
        { }
 
    virtual 
    ~standard_time_series_iterator() { }
 
    virtual
    time_series_iterator &
    operator++() { m_date_int++; return *this; }
 
    virtual
    time_series_iterator &
    operator++(int) { m_date_int++; return *this; }
 
    virtual
    time_series_iterator &
    operator--() { m_date_int--; return *this; }
 
    virtual
    time_series_iterator &
    operator--(int) { m_date_int--; return *this; }
 
    virtual
    bool
    operator==( const tom::collections::time_series_iterator& rhs) const
    { 
        return rhs.get_calendar() == m_cal &&
            rhs.get_date_int() == m_date_int; 
    }
 
    virtual
    bool
    operator!=( const tom::collections::time_series_iterator& rhs) const 
    { 
        return ! ( *this == rhs ); 
    }
 
    virtual
    const observation &
    operator*() const
    {
        return m_ts.get_observation( m_date_int );  
    }
 
    virtual
    const observation &
    operator->() const
    {
        return m_ts.get_observation( m_date_int );          
    }
 
    virtual
    date
    get_date() const { return m_cal( m_date_int ); }
 
    virtual
    date_int_type
    get_date_int() const { return m_date_int; }
 
    virtual
    timespec
    get_timespec() const
    {
        date d = get_date();
        struct tm tm;
        tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
        tm.tm_year = d.year() - 1900;
        tm.tm_mon = d.month();
        tm.tm_mday = d.day();
        struct timespec spec {0,0};
        spec.tv_sec = mktime( &tm );
        spec.tv_nsec = 0;
        return spec;
    }
 
    virtual
    calendar &
    get_calendar() const { return m_cal; }
 
protected:
    time_series &   m_ts;
    calendar &      m_cal;
    date_int_type   m_date_int;
 
};
 
template <typename T>
class TOM_UTIL_API time_series_impl : 
    public time_series, public std::vector<typename T::value_type>
{
public:
  typedef T                                                 value_type;
  typedef typename std::vector<typename T::value_type >     vector_type;
  typedef tom::value_types::scalar<typename T::value_type>  scalar_type;
  typedef typename vector_type::pointer                     pointer;
  typedef typename vector_type::reference                   reference;
  typedef typename vector_type::difference_type             difference_type;
  typedef std::random_access_iterator_tag                   iterator_category;
 
  typedef typename vector_type::iterator                    iterator;
  typedef typename vector_type::const_iterator              const_iterator;
 
  time_series_impl( calendar &cal ) : 
    vector_type(), m_align( OFFSET ), m_calendar( cal ), 
    m_first_date( 0 ), m_last_date( 0 ), m_min_first_date(0)
  {
    m_calendar_offset = cal( cal.get_first_date() );
  }
 
  template <typename Iter>
  time_series_impl( calendar &cal, date_int_type start, Iter begin, Iter end ) :
    vector_type( begin, end ), m_align( OFFSET ), m_calendar(cal), 
    m_first_date( start ), m_last_date( start + ( end - begin ) - 1 ), 
    m_min_first_date(start)
  {
    m_calendar_offset = cal( cal.get_first_date() );
  }
  template <typename IteratorT>
  time_series_impl( calendar &cal, date start, IteratorT begin, IteratorT end ) :
    vector_type( begin, end ), m_align( OFFSET ), m_calendar(cal), 
    m_first_date( cal( start ) ), m_last_date( cal( start ) + ( end - begin ) - 1 ),
    m_min_first_date( m_first_date )
  {
    m_calendar_offset = cal( cal.get_first_date() );
  }
  virtual ~time_series_impl() { }
 
  virtual time_series_iterator& begin() const
  {
    return * new standard_time_series_iterator( const_cast<time_series_impl &>(*this), get_first_date_int() );
  }
  virtual time_series_iterator &end() const
  {
    return *new standard_time_series_iterator( const_cast<time_series_impl &>(*this), get_last_date_int() + 1 );    
  }
 
  virtual
  const observation &
  get_observation( date_int_type d ) const
  {
    if ( in_range(d) )
      return m_return_value = *( real_begin() + index_of(d) );
    else
      // no need to refer to T, as ND is ND, right?
      // and because i don't yet have a fix for the 
      // String static init problem / SEGV!!
      return Int::HAS_NO_DATA;  // ND in real life
  }
  virtual const observation &get_observation( const date d ) const ;
 
  // hidden (by name only) method that does the work
  // all methods should redirect to this one !!!
  void
  set_observation_( date_int_type d, const T &v )
  {
    // convert to native type first!
    //value_type v( val );
    
    // first handle ND values which may shrink the series,
    // or make it empty
    if ( v.flag() == tom::value_type::no_data() )
    {
      // setting empty series point to ND - no effect
      if ( is_empty() )
    return;
 
      // set series w/ single point to ND - become empty ts
      else if ( get_first_date_int() == get_last_date_int() && d == get_first_date_int() )
      {
    set_first_date(0);
    set_last_date(0);
    return;
      }
 
      // ND outside or at edge of range
      else if ( ! (     d > get_first_date_int() && d < get_last_date_int() ) )
      {
    // ND at last point, shrink range
    if ( d == get_last_date_int() )
      unwind_end( d );
 
    // ND at first point, shrink range
    else if ( d == get_first_date_int() )
      unwind_start( d );
 
    // d outside range, no effect
    return;
      }
    }
        // empty series?  set dates and allocate
        if ( is_empty() )
        {
            set_first_date(d);
            set_last_date(d);
            extend(d);
        }
        // add past end?  extend, init(ND), and adjust last_date
        else if ( d > get_last_date_int() )
        {
            extend( d );
            assign_nd( get_last_date_int() +1, d );
            set_last_date(d);
        }
        // add before start?
        else if ( d < get_first_date_int() )
        {
            // if aligned w/ offset
            if ( get_alignment() == OFFSET )
            {
                // mark ourselved naturally aligned
                set_alignment( NATURAL );
                // extend for new expanded range
                extend( get_last_date_int() );
                // move data to proper offset
                realign();
            }
            // init(ND)'s and set first_date
            assign_nd( d, get_first_date_int() -1 );
            set_first_date(d);
        }
        // for all, assign value...finally!
        *(real_begin() + index_of( d )) = v.value();
    }
    virtual 
    void
    set_observation( date_int_type d, const observation &val )
    {
        set_observation_( d, T(val) );  
    }
    // date handlers - this should apply to Date, date_interval_observation,
    //                  and date_interval_scalar<> classes
    virtual void set_observation( date_int_type d, const Date &v )
    {
        set_observation_( d, T(v) );    
    }
    virtual void set_observation( date d, const Date &v )
    {
        set_observation_( get_calendar()(d), T(v) );
    }
    
    virtual void set_observation( const date d, const observation & val );
    void set_observation( const date_int_type d, const typename T::value_type & val );
    void set_observation( const date d, const typename T::value_type & val );
    void set_observation( const date_int_type d, tom::value_type val );
    void set_observation( const date d, tom::value_type val );
    
    virtual const observation & operator[ ](  const date_int_type d ) const ;
    virtual observation & operator[ ](  const date_int_type d );
    virtual const observation & operator[ ] ( const date d ) const ;
    virtual observation & operator[ ] ( const date d ) ;
 
    virtual std::ostream &print( std::ostream & ) const;
 
    virtual
    tom::calendars::calendar &
    get_calendar() const { return m_calendar; }
 
    date_int_type
    get_first_date_int() const { return m_first_date; }
 
    date_int_type
    get_last_date_int() const { return m_last_date; }
 
    
    bool
    is_empty() const
    {
        if ( get_last_date_int() == 0 )
            return true;
        return false;
    }
    bool
    in_range( date_int_type d ) const 
    {
        if ( get_first_date_int() == 0 )
            return false;
        if ( d >= get_first_date_int() && d <= get_last_date_int() )
            return true;
        return false;
    }
    virtual const void *data() const
    {
        // ugly hack for now :(
        return reinterpret_cast<const void *>( (&this->vector_type::front()) + index_of( get_first_date_int() ) );  
    }
 
protected:
    enum Alignment { OFFSET, NATURAL };
 
    Alignment           m_align;
    calendar &          m_calendar;
    date_int_type       m_calendar_offset;
    date_int_type       m_first_date;
    date_int_type       m_last_date;
    date_int_type       m_min_first_date;
    // This acts as a observation to be returned where one is needed
    mutable value_type          m_return_value;
    iterator real_begin() { return this->vector_type::begin(); }
    iterator real_end() { return this->vector_type::end(); }
    const_iterator real_begin() const { return this->vector_type::begin(); }
    const_iterator real_end() const { return this->vector_type::end(); }
 
    void 
    set_first_date( date_int_type d ) 
    {
        m_min_first_date = (d < m_min_first_date || m_min_first_date == 0 ) ? 
                            d : m_min_first_date;
        m_first_date = d; 
    }
 
    void
    set_last_date( date_int_type d ) { m_last_date = d; }
 
    Alignment 
    get_alignment() const { return m_align; }
    void
    set_alignment( Alignment a ) { m_align = a; }
 
    // how much shift is evident in vector alignment
    // 1 is natural, otherwise it is offset by start date
    int
    get_offset() const
    {
        if ( get_alignment() == OFFSET )
            //return get_first_date_int();
            return m_min_first_date;
        else
            return m_calendar_offset;
    }
    // real index for date d in vector
    size_t
    index_of( date_int_type d ) const
    {
        return d - get_offset();
    }
    // extends vector to date d, filling w/ ND's
    void
    extend( date_int_type d )
    {
        if ( index_of(d) + 1 > this->size() )
            this->resize( index_of( d ) + 1 );
    }
    // sets vector to ND in range of start - end, including end
    void
    assign_nd( date_int_type start, date_int_type end )
    {
        iterator b = real_begin() + index_of( start );
        iterator e = real_begin() + index_of( end ) + 1;
        // not reliable as T::no_data::value may not be initialized yet 
        // and will default to 0 if not! 
        // but lets give it a try as this runtime
        std::fill( b, e, T::no_data::value );
        // instead get the value based on function call guaranteed to work
        //typename T::value_type tmp = tom::value_types::resolve_nd<typename T::value_type>::get_value_of_nd();
        //std::fill( b, e, tmp );
    }
    void
    unwind_end( date_int_type d )
    {
        while ( (--d) >= get_first_date_int() )
        {
            scalar_type tmp( *(real_begin() + index_of(d) ) );
            if ( tmp.category() != tom::value_types::TOM_VALUE_NO_DATA )
            {
                set_last_date( d );
                return;
            }
        }
        set_last_date( get_first_date_int() );
    }
    void
    unwind_start( date_int_type d )
    {
        // change the use of index_of so it and only it uses min-first-date
        // then this should work!
        while ( (++d) <= get_last_date_int() )
        {           
            if ( scalar_type( *(real_begin() + index_of(d) ) ).category() != tom::value_types::TOM_VALUE_NO_DATA )
            {
                set_first_date( d );
                return;
            }
        }
        set_first_date( get_last_date_int() );
    }
    // after extending, move data forward in the vector
    // by the difference of first_date and cal_offset
    void
    realign(  )
    {
        size_t diff = get_last_date_int() - get_first_date_int() + 1;
        std::copy_backward( real_begin(), real_begin() + diff,
                   real_begin() + this->vector_type::size() );
    }
    
};
 
template <typename T>
inline
const observation &
time_series_impl<T>::get_observation( const date d ) const 
{
    date_int_type di = get_calendar()(d);
    return this->get_observation( di ); 
}
template <typename T>
inline
void 
time_series_impl<T>::set_observation( const date d, const observation & val )
{
    date_int_type di = get_calendar()(d);
    this->set_observation_( di, T(val) );
}
template <typename T>
inline
void 
time_series_impl<T>::set_observation( const date_int_type d, const typename T::value_type & val )
{
    set_observation_( d, T(val) );
};
template <typename T>
inline
void 
time_series_impl<T>::set_observation( const date d, const typename T::value_type & val )
{
    set_observation_( get_calendar()(d), T(val) );
}
template <typename T>
inline
void 
time_series_impl<T>::set_observation( const date_int_type d, tom::value_type val )
{
    set_observation_( d, T(val) );
}
template <typename T>
inline
void 
time_series_impl<T>::set_observation( const date d, tom::value_type val )
{
    set_observation_( get_calendar()(d), T(val) );
}
 
template <typename T>
const observation & 
time_series_impl<T>::operator[ ](  const date_int_type d ) const 
{
    if ( in_range(d) )
        return m_return_value = *( real_begin() + index_of(d) );
    else
        return Int::HAS_NO_DATA;    // ND in real life
}
template <typename T>
observation & 
time_series_impl<T>::operator[ ](  const date_int_type d )
{
    if ( in_range(d) )
        return m_return_value = *( real_begin() + index_of(d) );
    else
        return m_return_value = tom::value_type::no_data(); // ND in real life
}
template <typename T>
const observation & 
time_series_impl<T>::operator[ ] ( const date d ) const 
{
    date_int_type di = get_calendar()(d);
    return (*this)[di];
}
template <typename T>
observation & 
time_series_impl<T>::operator[ ] ( const date d ) 
{
    date_int_type di = get_calendar()(d);
    return (*this)[di];
}
template <typename T>
inline
std::ostream &
time_series_impl<T>::print( std::ostream & os) const
{
    calendar &cal = get_calendar();
    if ( cal != ordinal_calendar::Instance() )
        //for( time_series_iterator &it = begin(); it != end(); ++it )
        //os << it.get_date() << ": " << *it << std::endl;
        for( date_int_type di = get_first_date_int(); di <= get_last_date_int(); ++di )
            os << cal(di) << ": " << get_observation(di) << std::endl;
    else
        //for( time_series_iterator &it = begin(); it != end(); ++it )
        // os << it.get_date_int() << ": " << *it << std::endl;
        for( date_int_type di = get_first_date_int(); di <= get_last_date_int(); ++di )
            os << di << ": " << get_observation(di) << std::endl;
    
    return os;
}
 
 
 
// Factory template to save some typeing for the 
// code-monkeys using the util libs...
// It is safe to just use 'new time_series_impl<...>(...)'
// yourself, this is just easier i think :)
// eg. : 
//
// time_series &ts = 
//              float_time_series_factory::create<monthly_calendar>();
//
// creates a float time series with a monthly calendar
// This is the same as just doing...
//
// time_series &ts = 
//          *new time_series_impl<tom::Float,monthly_calendar>();
//
// NOTE: this may look like a memory leak in the waiting,
//          but the class is garbage collected, so pass it around
//          and forget about memory management.  When it is no longer
//          referenced, it will be freed.
 
template <typename T>
struct TOM_UTIL_API time_series_impl_factory
{
    template <typename CalendarT>
    static
    time_series &
    create()
    {
        return *new time_series_impl<T>( CalendarT::Instance() );
    }
    template <typename CalendarT, typename IteratorT>
    static
    time_series &
    create(date start, IteratorT begin, IteratorT end)
    {
        return *new time_series_impl<T>( CalendarT::Instance(), start, begin, end);
    }
    template <typename CalendarT, typename IteratorT>
    static
    time_series &
    create(date_int_type start, IteratorT begin, IteratorT end)
    {
        return *new time_series_impl<T>( CalendarT::Instance(), start, begin, end);
    }
};
 
typedef time_series_impl_factory<tom::Float>                                    float_time_series_factory;
typedef time_series_impl_factory<tom::Double>                                   double_time_series_factory;
typedef time_series_impl_factory<tom::Int>                                      int_time_series_factory;
typedef time_series_impl_factory<tom::String>                                   string_time_series_factory;
typedef time_series_impl_factory<tom::Bool>                                     bool_time_series_factory;
typedef time_series_impl_factory<tom::Date>                                     date_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalDaily>                        daily_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalBusiness>                     business_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklyMonday>                 weekly_monday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklyTuesday>                weekly_tuesday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklyWednesday>              weekly_wednesday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklyThursday>               weekly_thursday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklyFriday>                 weekly_friday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklySaturday>               weekly_saturday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalWeeklySunday>                 weekly_sunday_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalMonthly>                      monthly_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalQuarterlyOctober>             quarterly_october_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalQuarterlyNovember>            quarterly_november_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalQuarterlyDecember>            quarterly_december_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalSemiannualJuly>               semiannual_july_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalSemiannualAugust>             semiannual_august_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalSemiannualSeptember>          semiannual_september_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalSemiannualOctober>            semiannual_october_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalSemiannualNovember>           semiannual_november_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalSemiannualDecember>           semiannual_december_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualJanuary>                annual_january_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualFebruary>               annual_february_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualMarch>                  annual_march_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualApril>                  annual_april_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualMay>                    annual_may_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualJune>                   annual_june_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualJuly>                   annual_july_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualAugust>                 annual_august_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualSeptember>              annual_september_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualOctober>                annual_october_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualNovember>               annual_november_time_series_factory;
typedef time_series_impl_factory<tom::DateIntervalAnnualDecember>               annual_december_time_series_factory;
 
// alias for commonly used timeseries
typedef weekly_friday_time_series_factory                                       weekly_time_series_factory;
typedef quarterly_december_time_series_factory                                  quarterly_time_series_factory;
typedef semiannual_december_time_series_factory                                 semiannual_time_series_factory;
typedef annual_december_time_series_factory                                     annual_time_series_factory;
 
} // end collections namespace
} // end tom namespace
 
#endif