pivot1.hpp

Go to the documentation of this file.

#ifndef CSV3_
#define CSV3_

#include <string>
#include <map>
#include <list>
#include <string>
#include <stdexcept>

#include <boost/any.hpp>
#include <boost/multi_array.hpp>

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/composite_key.hpp>

#include "eleve/src/typing0.hpp"

namespace eepgwde { namespace detail { 

  using namespace boost::multi_index;

  struct StrikeMaturity : public DataFrame::Record {
    int maturity_;
    double strike_;
    double price_;

    static const std::string strike0;
    static const std::string maturity0;
    static const std::string price0;

    StrikeMaturity(DataFrame *df,
           DataFrame::iterator0 itr,
           eepgwde::detail::record_t r) :
      DataFrame::Record(df, itr, r),
      maturity_(maturity()), strike_(strike()), price_(price()) {
    }

    template<typename T>
    T as_(const std::string & key) const throw(std::exception) {
      boost::any o = *(r_)[key];
      T r0;
      if (!eepgwde::detail::as<T>(&r0, o))
    throw (std::domain_error("cast fail: " + key));
      return r0;
    }

    // If you don't want to pass arguments, define your own.
    int maturity() const throw(std::exception) {
      return as_<int>(maturity0);
    }

    // If you don't want to pass arguments, define your own.
    double strike() const throw(std::exception) {
      return as_<double>(strike0);
    }

    // If you don't want to pass arguments, define your own.
    double price() const throw(std::exception) {
      return as_<double>(price0);
    }
  };

  typedef multi_index_container<
    StrikeMaturity,
    indexed_by<
      // non-unique: there may be a number of sources
      ordered_non_unique<
      composite_key<
      StrikeMaturity,
      member<StrikeMaturity,double,&StrikeMaturity::strike_>,
      member<StrikeMaturity,int,&StrikeMaturity::maturity_>
    >
    >
    >
    > Prices;

  struct Pivotter {
    const Prices & px;
    const std::vector<double> & rs;
    const std::vector<double> & cs;

    // Errors in the cast operator.
    //
    // Used as an early indicator of an error.
    mutable int failures;

    Pivotter(const Prices & px,
         const std::vector<double> &rows,
         const std::vector<double> &cols) :
      px(px), rs(rows), cs(cols), failures(0) {}

    // This converts to a data frame of boost::any.
    //
    // If a value is not present it is replaced with a boost::any null.
    operator DataFrame::ma_any_t () const;

  };

}}

#endif

---