ivolt0.cpp

Go to the documentation of this file.

#include "ivolt0.hpp"

#include <ql/timeseries.hpp>

#include <ql/termstructures/yield/zerocurve.hpp>
#include <ql/math/interpolations/cubicinterpolation.hpp>
#include <ql/math/interpolations/bicubicsplineinterpolation.hpp>
#include <ql/termstructures/yield/zerocurve.hpp>
#include <ql/experimental/inflation/yoycapfloortermpricesurface.hpp>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits.hpp>
#include <boost/date_time/gregorian/formatters.hpp>

#include "eleve/src/typing0.hpp"

namespace eepgwde { namespace detail {

  namespace i0 {

    using boost::enable_if;
    
    // An old date
    template <typename U>
    typename enable_if<boost::is_base_of<QuantLib::Date, U>, U>::type 
    null1(dummy<2> = 2) {
      return QuantLib::Date(1, static_cast<QuantLib::Month>(1), 1901);
    }

    template <typename U>
    std::string
    ys(typename enable_if< boost::is_base_of<QuantLib::Date, U>, U>::type,
       const boost::any &o, dummy<2> = 2)
      throw (std::domain_error &) {
      U r(boost::any_cast<U>(o));
      boost::gregorian::date dt(r.year(), r.month(), r.dayOfMonth());
      return boost::gregorian::to_simple_string(dt);
    }

    template <typename U>
    U xs(typename enable_if<boost::is_same<QuantLib::Date, U>, U>::type,
     const std::string & s, dummy<2> = 2)
      throw (std::domain_error &) {
      posixdate bdt = boost::gregorian::from_simple_string(s);
      QuantLib::Date qdt0(bdt.day(), static_cast<QuantLib::Month>(static_cast<int>(bdt.month())), bdt.year());
      return qdt0;
    }

  }

}}

#include "eleve/src/typing3.hpp"
#include "eleve/src/typing1.hpp"

#include "eleve/src0/csv1.hpp"
#include "eleve/src0/csv2.hpp"
#include "eleve/src0/csv4.hpp"

#include "src1/acsvt0.hpp"

#include "src1/pivot0.hpp"

#include "types0.cpp"

namespace null0_types {
  X_NULL0_PTR1(QuantLib::Date);
}

#include "render1.cpp"



BOOST_GLOBAL_FIXTURE ( csv0 )

namespace {
  using namespace QuantLib;

  Handle<YieldTermStructure> nominalEUR;
  Handle<YieldTermStructure> nominalGBP;

};

BOOST_AUTO_TEST_SUITE (frame0)


BOOST_AUTO_TEST_CASE(csv1)
{
  using namespace eepgwde::detail;

  BOOST_TEST_MESSAGE("price::frame0::csv1");

  BOOST_TEST_MESSAGE("QuantLib::price::frame0::csv1: " <<  frame.shape()[0] );
  BOOST_TEST_MESSAGE("QuantLib::price::frame0::csv1: " <<  frame.shape()[1] );

  for (DataFrame::ma_any_t::size_type a = 0; a < frame.shape()[0]; ++a) {
    for (DataFrame::ma_any_t::size_type b = 0; b < frame.shape()[1]; ++b) {
      std::cerr << (frame[a][b]).type().name() << " "
        << boost::any_cast<std::string>(frame[a][b]) << " ";
    }
    std::cerr << endl;
  }
}

BOOST_AUTO_TEST_SUITE_END()

namespace eepgwde { namespace detail {

  struct TimeSeries0 {
    DataFrame &df;
    Typing::mappings_t & mappings0;

    TimeSeries0(DataFrame & df,
        Typing::mappings_t & mappings0)
      : df(df), mappings0(mappings0) {}

    operator QuantLib::TimeSeries<QuantLib::Rate>() {

      // Create a new header for the frame from the mappings and use it.
      DataFrame::headar h0(&df, mappings0);
      DataFrame::attr_pos_t h1 = h0;

      df.header = h1;

      DataFrame::column_t c0 = df.column(std::string("date"));
      std::vector<QuantLib::Date> qdates = DataFrame::columnar(c0);

      DataFrame::column_t c1 = df.column(std::string("value"));
      std::vector<QuantLib::Rate> qvalues = DataFrame::columnar(c1);

      // TimeSeries are sorted.
      QuantLib::TimeSeries<QuantLib::Rate> ts0(qdates.begin(), qdates.end(), qvalues.begin());

      std::vector<QuantLib::Date> d0(ts0.dates());
      std::vector<QuantLib::Rate> r0(ts0.values());

      return ts0;
    }
  };

}}

BOOST_AUTO_TEST_SUITE(misc)

// QuantLib dates start from 1901.
  BOOST_AUTO_TEST_CASE(null0)
{
  using namespace eepgwde::detail;
  using eepgwde::detail::null0;

  BOOST_TEST_MESSAGE("QuantLib::misc::null0");

  std::string date_type0 = boost::any((null0<posixdate>())()).type().name();
  std::string date_type1 = boost::any((null0<QuantLib::Date>())()).type().name();

  BOOST_TEST_MESSAGE( date_type0 << " " << date_type1 );

  QuantLib::Date dt = (null0<QuantLib::Date>())();
}

// Read in the first on the command line - UK yield curve
BOOST_AUTO_TEST_CASE(qldt)
{
  using namespace eepgwde::detail;

  BOOST_TEST_MESSAGE("QuantLib::misc::qldt");
  
  std::string fname1;
  fname1 = fnames.front();
  fnames.pop();
  std::string service1(fname1);
  service1 = service1.erase(service1.find("."));

  BOOST_TEST_MESSAGE(fname1 << " " << service1);

  DataFrame::ma_any_t frame1;
  csv0::load0(fname1, frame1);

  DataFrame df(frame1, service1);
  df.render();

  df.render<QuantLib::Date>(std::string("date"));

  std::cerr << df.frame << std::endl;
}

BOOST_AUTO_TEST_SUITE_END() 

BOOST_AUTO_TEST_SUITE(curves)

// Read in the first on the command line - UK yield curve
// Read in by hand.

  BOOST_AUTO_TEST_CASE(ycuk)
{
  using namespace eepgwde::detail;
  using namespace QuantLib;

  BOOST_TEST_MESSAGE("QuantLib::curves::ycuk");
  
  std::string fname1;
  fname1 = fnames.front();
  fnames.pop();
  std::string service1(fname1);
  service1 = service1.erase(service1.find("."));

  BOOST_TEST_MESSAGE(fname1 << " " << service1);

  DataFrame::ma_any_t frame1;
  csv0::load0(fname1, frame1);

  DataFrame df(frame1, service1);
  df.render();

  DataFrame::column_t c0 = df.column(std::string("date"));
  std::vector<QuantLib::Date> qdates = DataFrame::columnar(c0);

  DataFrame::column_t c1 = df.column(1);
  std::vector<QuantLib::Rate> qvalues = DataFrame::columnar(c1);

  // TimeSeries are sorted.
  QuantLib::TimeSeries<QuantLib::Rate> ts0(qdates.begin(), qdates.end(), qvalues.begin());

  std::vector<QuantLib::Date> d0(ts0.dates());
  std::vector<QuantLib::Rate> r0(ts0.values());

  shared_ptr<InterpolatedZeroCurve<Cubic> >
    iborTS(new InterpolatedZeroCurve<Cubic>(d0, r0, Actual365Fixed()));
  Handle<YieldTermStructure> nominalH(iborTS, false);
  nominalGBP = nominalH;
}

// Read in the first on the command line - EUR yield curve
// Using the TimeSeries0 class.

BOOST_AUTO_TEST_CASE(yceur)
{
  using namespace eepgwde::detail;
  using namespace QuantLib;

  BOOST_TEST_MESSAGE("QuantLib::curves::yceur");
  
  std::string fname1;
  fname1 = fnames.front();
  fnames.pop();
  std::string service1(fname1);
  service1 = service1.erase(service1.find("."));

  BOOST_TEST_MESSAGE(fname1 << " " << service1);

  DataFrame::ma_any_t frame1;
  csv0::load0(fname1, frame1);

  DataFrame df(frame1, service1);
  df.render();

  std::cerr << df.header.left << std::endl;

  Typing t0;
  Typing::mappings_t mappings0 = t0.mappings();
  // By position - find the string
  std::string vs = df.header.left.find(1)->second;
  // By name - check it exists.
  BOOST_CHECK( df.header.right.find("eur_yc_rate")
           != df.header.right.end() );
  mappings0[ "eur_yc_rate" ] = std::string("value");

  QuantLib::TimeSeries<QuantLib::Rate> ts1 = TimeSeries0(df, mappings0);

  std::vector<QuantLib::Date> d0(ts1.dates());
  std::vector<QuantLib::Rate> r0(ts1.values());

  copy(r0.begin(), r0.end(), ostream_iterator<double>(std::cerr, ","));
  std::cerr << std::endl;

  shared_ptr<InterpolatedZeroCurve<Cubic> >
    iborTS(new InterpolatedZeroCurve<Cubic>(d0, r0, Actual365Fixed()));
  Handle<YieldTermStructure> nominalH(iborTS, false);  
  nominalEUR = nominalH;
}

BOOST_AUTO_TEST_SUITE_END ()

BOOST_AUTO_TEST_SUITE (yoyeu)


BOOST_AUTO_TEST_CASE(yoyeur)
{
  using namespace eepgwde::detail;
  using namespace QuantLib;

  BOOST_TEST_MESSAGE("QuantLib::price::frame0::yoyeur");

  // Call this one by hand to set nominalGBP
  curves::ycuk().test_method();
  
  std::string fname1;
  fname1 = fnames.front();
  fnames.pop();
  std::string service1(fname1);
  service1 = service1.erase(service1.find("."));

  BOOST_TEST_MESSAGE(fname1 << " " << service1);

  DataFrame::ma_any_t frame1;
  csv0::load0(fname1, frame1);

  DataFrame df(frame1, service1);
  df.render();

  std::cerr << df.frame << std::endl;

}

BOOST_AUTO_TEST_SUITE_END ()



BOOST_AUTO_TEST_SUITE(caps0)

BOOST_AUTO_TEST_CASE(caps0)
{
  using namespace eepgwde::detail;

  BOOST_TEST_MESSAGE("QuantLib::curves::caps0");

  return;
  
  std::string fname1;
  fname1 = fnames.front();
  fnames.pop();
  std::string service1(fname1);
  service1 = service1.erase(service1.find("."));

  BOOST_TEST_MESSAGE(fname1 << " " << service1);

  DataFrame::ma_any_t frame1;
  csv0::load0(fname1, frame1);

  DataFrame df(frame1, service1);
  df.render();
  std::cerr << df.frame << std::endl;
}

BOOST_AUTO_TEST_SUITE_END()

---