acsvt3.cpp

Go to the documentation of this file.

#include <iostream>
#include <stack>
#include <algorithm>
#include <vector>

#include <algorithm>
#include <typeinfo>

#include <boost/bind.hpp>
#include <boost/foreach.hpp>
#include <boost/multi_array.hpp>

#include <boost/regex.hpp>

#include <ql/utilities/tracing.hpp>

#include "eleve/src/scal0.hpp"
#include "eleve/src/typing0.hpp"

#include <boost/algorithm/string/trim.hpp>
#include <boost/tokenizer.hpp>

#include "eleve/src/loader0.hpp"

#define BOOST_TEST_NO_MAIN
#include <boost/test/unit_test.hpp>

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

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

#include "acsvt0.hpp"

namespace {

  using namespace eepgwde::detail;

  // This class is now implemented Filter0.
  struct csv2 {

    static const std::string strike;
    static const std::string maturity;

    std::string service0;

    // Make our own copy of the frame
    DataFrame::ma_any_t frame_;

    DataFrame df;
    DataFrame::ma_any_t sorted0;

    static std::string init1(std::string fn0) {
      return fn0.erase(fn0.find("."));
    };

    // Same as csv1, but with some regex column-splitting.
    //
    // This is hard-coded to split out the caps - it's the regex.
    csv2() : service0(csv2::init1(fname0)),
         frame_(frame),
         df(frame_, service0) {

      DataFrame::payloader payload0(df);
      std::vector<Attr0> attr0 = payload0;

      // Split the column to get new attributes.
      std::string key("X0");
      for_each(attr0.begin(), attr0.end(),
           boost::bind(&Attr0::attributes,_1,key) );

      // Get a vector of pointers to the existing records.
      std::vector<DataFrame::Record *> s =
    pointerize<std::vector<DataFrame::Record *>, std::vector<Attr0> >(attr0);

      // Create records to hold the new attributes
      std::list<record_t *> attrs;
      back_insert_iterator< std::list<record_t *> > ii(attrs);
      transform(s.begin(), s.end(),
        ii,
        boost::bind(&DataFrame::Record::attrs,_1));

      // Create a new frame using the records with the new attributes.
      DataFrame::ma_any_t xframe1;
      df.add(&xframe1, s);
      DataFrame df0(xframe1, service0);
      df = df0;

      // We can trap unnamed columns - no rendering type given in
      // the .csv0.csd. This is not a fatal error for the tests.
      // The bbg_mappings will change the names.
      try {
    df.render();
      } catch (std::domain_error & e) {
    BOOST_TEST_MESSAGE("render: error");
      }

      Typing t0;
      t0.mappings(bbg_mappings);
      Typing::mappings_t mappings0 = t0.mappings();

      // 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::payloader payload1(df);
      std::vector<DataFrame::Record> sort0 = payload1;

      boost::regex e("[A-Z]+ISC[^ ]+ Cu.+");
      QPXisc comparor(e);

      // Only the mark
      std::vector<DataFrame::Record>::iterator mark =
    partition(sort0.begin(), sort0.end(),
          boost::bind(&DataFrame::Comparor::compare,
                  boost::ref(comparor),_1) );

      std::vector<DataFrame::Record>::iterator mark0 = sort0.begin();
      if (mark != sort0.end() && mark != sort0.begin() ) {
    mark0 = mark;
      }

      BOOST_ASSERT(distance(sort0.begin(), mark0) > 1);

      // Mark 

      // second key
      sort(sort0.begin(), mark0,
       boost::bind(std::less<int>(),
               boost::bind(&DataFrame::Record::as<int>,_1, maturity),
               boost::bind(&DataFrame::Record::as<int>,_2, maturity) ));

      // first key
      stable_sort(sort0.begin(), mark0,
          boost::bind(std::less<double>(),
                  boost::bind(&DataFrame::Record::as<double>,_1, strike),
                  boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

      int headings = 1; //< replace header names with ours.
      DataFrame::ma_any_t sorted00 = payload0.as(sort0.begin(), mark0, headings);

      // Because sorted0 was default-constructed, the shape won't match
      // its assignee.
      boost::array<DataFrame::ma_any_t::index, 2> shape =
    {{ sorted00.shape()[0], sorted00.shape()[1] }};
      sorted0.resize(shape);
      sorted0 = sorted00;
    }

    ~csv2() {}

  };

  const std::string csv2::strike("strike");
  const std::string csv2::maturity("maturity");

}

BOOST_FIXTURE_TEST_SUITE (multi_index2,csv2) 

BOOST_AUTO_TEST_CASE(e0) 
{
  // Shows replaced header.
  std::cerr << df.frame << std::endl;
  std::cerr << df.header.left << std::endl;
  std::cerr << sorted0 << std::endl;
}

// Unique strikes and maturities.

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

  BOOST_TEST_MESSAGE("QuantLib::price::sort0::e1");

  BOOST_CHECK(sorted0.size() > 1);

  std::cerr << sorted0.shape()[0] << " " << sorted0.shape()[1] << std::endl;
  std::cerr << sorted0 << std::endl;

  DataFrame df0(sorted0);

  DataFrame::payloader payload0(df0);
  std::vector<DataFrame::Record> sort0 = payload0;

  mties0_ = DataFrame::columnar1(df0.column(maturity));
  strikes0_ = DataFrame::columnar1(df0.column(strike));

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

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

// Using multi-indexed container to pivot the table into a Matrix.
//
// Pivot by hand, first.
              
BOOST_AUTO_TEST_CASE(e2) 
{
  using namespace eepgwde::detail;

  BOOST_TEST_MESSAGE("QuantLib::price::sort0::e2");

  BOOST_CHECK(sorted0.size() > 1);

  std::cerr << sorted0.shape()[0] << " " << sorted0.shape()[1] << std::endl;
  std::cerr << sorted0 << std::endl;

  // This has been rendered, sorted and the new header names put in place.
  DataFrame df2(sorted0);

  std::cerr << df2.header.left << std::endl;
  std::cerr << df2.frame << std::endl;

  DataFrame::payloader payload2(df2);
  std::vector<StrikeMaturity> sort2 = payload2;

  BOOST_CHECK(sort2.size() > 0);

  Prices px(sort2.begin(), sort2.end());

  BOOST_CHECK(px.size() > 0);
  BOOST_CHECK(mties0_.size() > 0);
  BOOST_CHECK(strikes0_.size() > 0);

  DataFrame::ma_any_t mark0;
  boost::array<DataFrame::ma_any_t::index, 2>
    shape ={{ strikes0_.size(), mties0_.size() }};
  mark0.resize(shape);

  std::list<boost::any> data;
  int failures = 0;

  for(std::vector<double>::iterator it0=strikes0_.begin();
      it0 != strikes0_.end(); ++it0) {
    for(std::vector<double>::iterator it1=mties0_.begin();
    it1 != mties0_.end(); ++it1) {
    
      std::pair<Prices::iterator, Prices::iterator> p =
    px.equal_range(boost::make_tuple(*it0, *it1));

      Prices::iterator p0 = p.first;

      if (p0->strike_ == *it0 && p0->maturity_ == *it1) {
    double number = p0->price_;
    
    std::cerr << "(" << *it0 << " " << *it1 << " " << number
          << ")" << std::endl;
    data.push_back(boost::any(number));
    continue;
      }
      std::cerr << "(" << *it0 << " " << *it1 << " " << "null"
        << ")" << std::endl;
      failures++;
      data.push_back(boost::any());
    }
  }

  mark0.assign(data.begin(), data.end());
  std::cerr << mark0 << std::endl;
}

// Using multi-indexed container to pivot the table into a Matrix.
//
// This demonstrates the pivot using the Pivotter class.
              
BOOST_AUTO_TEST_CASE(e3) 
{
  using namespace eepgwde::detail;

  BOOST_TEST_MESSAGE("QuantLib::price::sort0::e3");

  BOOST_CHECK(sorted0.size() > 0);

  // This has been rendered, sorted and the new header names put in place.
  DataFrame df2(sorted0);
  DataFrame::payloader payload2(df2);
  std::vector<StrikeMaturity> sort2 = payload2;

  BOOST_CHECK(sort2.size() > 0);

  Prices px(sort2.begin(), sort2.end());

  BOOST_CHECK(px.size() > 0);
  BOOST_CHECK(mties0_.size() > 0);
  BOOST_CHECK(strikes0_.size() > 0);

  Pivotter r0(px, strikes0_, mties0_);
  // Don't get mixed up with
  // Pivotter r0(px, mties0_, strikes0_); 
  DataFrame::ma_any_t marked0 = r0;
  std::cerr << marked0 << std::endl;
  BOOST_CHECK(marked0.size() > 0);

  try {
    QuantLib::Matrix ceurisc = Matrix0(marked0);
    std::cerr << ceurisc << std::endl;
  } catch (std::exception & e) {
    std::cerr << "exception: " << e.what() << std::endl;
  }

}

BOOST_AUTO_TEST_SUITE_END()

// --log_level=all --run_test=*/csv0,cds0 eurisc.csv0

---