acsvt1.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>

// weaves
// Check CSV file loading.

#include "eleve/src/scal0.hpp"

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

#include "eleve/src/loader0.hpp"

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

#include "acsvt0.hpp"

// Define some Renderers. If you don't define this then you will get a failure in
// any test where X2 (an integer) has to be converted to a double.
#include "eleve/src/types0.cpp"

BOOST_AUTO_TEST_SUITE(header0)  

// These tests manipulate the header so that column names that
// were rendered are now changed to more generic names so that the 
// sort and filter algorithms can be re-used.

// Checking access to the header

BOOST_AUTO_TEST_CASE(ab0)  
{
  using namespace eepgwde::detail;
  using namespace std;

  BOOST_TEST_MESSAGE("QuantLib::price::header0::ab0");

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

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

  DataFrame::r_itr ti =
    df.header.right.find(std::string("PX"));

  BOOST_CHECK( ti != df.header.right.end() );

  BOOST_CHECK( df.header.left.size() > 0 );
  std::cerr << df.header.left << std::endl;

  std::string tag("PX");
  DataFrame::column_t col = df.column(tag);
  BOOST_CHECK( col.size() > 0 );

  std::vector<std::string> a = DataFrame::columnar(col);

  BOOST_CHECK(distance(a.begin(), a.end()) > 0);

  copy(a.begin(), a.end(), ostream_iterator<std::string>(std::cerr, " "));

}

// Overwriting a key in the header.
  
BOOST_AUTO_TEST_CASE(ab1)  
{
  using namespace eepgwde::detail;
  using namespace std;

  BOOST_TEST_MESSAGE("QuantLib::price::header0::ab1");

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

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

  std::string tag0("PX_LAST");

  DataFrame::attr_pos_t::right_map::iterator
    ri = df.header.right.find(tag0);
  std::cerr << (*ri).second << std::endl;

  std::string tag = std::string("price");
  bool is = df.header.right.replace_key( ri, tag);

  BOOST_CHECK( df.header.left.size() > 0 );
  std::cerr << df.header.left << std::endl;

  DataFrame::column_t col = df.column(tag);

  std::vector<double> a = DataFrame::columnar(col);

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

  DataFrame::iterator0 ii = df.payload->begin();
  record_t r0 = DataFrame::rowar(&df, ++ii);

  std::cerr << "tag: " << tag << " " << as(*r0[tag]) << std::endl;
  
}

BOOST_AUTO_TEST_CASE(ab2)  
{
  using namespace eepgwde::detail;
  using namespace std;

  BOOST_TEST_MESSAGE("QuantLib::price::header0::ab2");

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

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

  Typing t0;
  t0.mappings(bbg_mappings);

  Typing::mappings_t mappings0 = t0.mappings();
  for(Typing::mappings_t::const_iterator i = mappings0.begin();
      i != mappings0.end(); ++i) {
    std::cerr << i->first << " " << i->second << std::endl;
  }

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

  BOOST_CHECK( h1.size() > 0 );

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

  // Use the new name in the header 
  std::string tag = std::string("price");
  DataFrame::column_t col = df.column(tag);
  std::vector<double> a = DataFrame::columnar(col);

  // Copy out a column
  copy(a.begin(), a.end(), ostream_iterator<double>(std::cerr, " "));
  std::cerr << std::endl;

  // Demonstrate use as a key.
  DataFrame::iterator0 ii = df.payload->begin();
  record_t r0 = DataFrame::rowar(&df, ++ii);

  std::cerr << "tag: " << tag << " " << as(*r0[tag]) << std::endl;
  
}
  
BOOST_AUTO_TEST_SUITE_END()  

#include <boost/regex.hpp>

BOOST_AUTO_TEST_SUITE(attrs)  

using namespace eepgwde::detail;

// Use this to test regular expressions.
void print_captures(const std::string& regx, const std::string& text)
{
   boost::regex e(regx);
   boost::smatch what;
   std::cerr << "Expression:  \"" << regx << "\"\n";
   std::cerr << "Text:        \"" << text << "\"\n";
   if(boost::regex_match(text, what, e, boost::match_extra))
   {
      unsigned i, j;
      std::cerr << "** Match found **\n   Sub-Expressions:\n";
      for(i = 0; i < what.size(); ++i)
         std::cerr << "      $" << i << " = \"" << what[i] << "\"\n";
      std::cerr << "   Captures:\n";
      for(i = 0; i < what.size(); ++i)
      {
         std::cerr << "      $" << i << " = {";
         for(j = 0; j < what.captures(i).size(); ++j)
         {
            if(j)
               std::cerr << ", ";
            else
               std::cerr << " ";
            std::cerr << "\"" << what.captures(i)[j] << "\"";
         }
         std::cerr << " }\n";
      }
   }
   else
   {
      std::cout << "** No Match found **\n";
   }
}

struct Attr0 : public DataFrame::Record {
  Attr0(DataFrame *df,
    DataFrame::iterator0 itr,
    eepgwde::detail::record_t r) : DataFrame::Record(df, itr, r) {}

  void attributes(const std::string & key0) {
    boost::any o = *r_[key0];
    std::string text = eepgwde::detail::as(o);
    std::string regx(".+ ([0-9.-]+)%[ ]+([0-9]+)Y$");
    // print_captures(regx, text);
    boost::regex e(regx);
    boost::smatch what;
    if (boost::regex_match(text, what, e)) {
      attrs0_.push_back(boost::any(static_cast<std::string>(what[1])));
      attrs0_.push_back(boost::any(static_cast<std::string>(what[2])));
      std::list<boost::any>::iterator a = attrs0_.begin();
      attrs_["strike"] = & * a;
      attrs_["maturity"] = & * (++a);
    }
  }

  void show() {
    if (! attrs_.size() > 0)
      return;
    if (attrs_.find("strike") == attrs_.end())
      return;
    if (attrs_.find("maturity") == attrs_.end())
      return;
    
    boost::any o = * attrs_["strike"];
    boost::any o1 = * attrs_["maturity"];
    std::cerr
      << eepgwde::detail::as(o) << " " 
      << eepgwde::detail::as(o1)
      << std::endl;
  }

};

struct Collector {
  std::set<std::string> names;

  void collect(const record_t * r) {
    for(record_t::const_iterator i=r->begin();
    i != r->end(); ++i) {
      names.insert(i->first);
    }
  }
};

BOOST_AUTO_TEST_CASE(q0)  
{
  BOOST_TEST_MESSAGE("QuantLib::price::attrs::q0");

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

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

  BOOST_CHECK(attr0.size() > 0);

  std::string key("X0");
  for_each(attr0.begin(), attr0.end(),
       boost::bind(&Attr0::attributes,_1,key) );

  for_each(attr0.begin(), attr0.end(),
       boost::bind(&Attr0::show,_1) );

  std::list<record_t *> attrs;
  back_insert_iterator< std::list<record_t *> > ii(attrs);
  transform(attr0.begin(), attr0.end(),
        ii,
        boost::bind(&Attr0::attrs,_1));

  Collector c;
  for_each(attrs.begin(), attrs.end(),
       boost::bind(&Collector::collect,boost::ref(c),_1));

  copy(c.names.begin(), c.names.end(),
       ostream_iterator<std::string>(std::cerr, " "));
  std::cerr << std::endl ;

  std::vector<DataFrame::Record *> s =
    pointerize<std::vector<DataFrame::Record *>, std::vector<Attr0> >(attr0);

  DataFrame::ma_any_t xframe;
  df.add(&xframe, s, c.names);
  std::cerr << xframe << std::endl;

  DataFrame::ma_any_t xframe1;
  df.add(&xframe1, s);
  std::cerr << xframe1 << std::endl;

}

// Testing the assignment operator and the empty frame.

BOOST_AUTO_TEST_CASE(q1)  
{
  BOOST_TEST_MESSAGE("QuantLib::price::attrs::q1");

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df0(frame, service0);

  DataFrame::ma_any_t frame0;

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

  DataFrame::payload_t a =
    frame0[ boost::indices[DataFrame::range()][DataFrame::range()] ];

  // empty frame initialization - fails for payload construction os
  // init0 added.
  DataFrame df(frame0);
  BOOST_CHECK( df.frame.shape()[0] == 0 && df.frame.shape()[1] == 0 );

  // Assignment
  df = df0;
  BOOST_CHECK( df.frame.shape()[0] == df0.frame.shape()[0] &&
           df.frame.shape()[1] == df0.frame.shape()[1] );

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

BOOST_AUTO_TEST_SUITE_END()  

BOOST_AUTO_TEST_SUITE(sort0)  

namespace {
  using namespace eepgwde::detail;
  using namespace std;
  
  // Simple sorting class - extends DataFrame::Record.
  //
  // @note
  // No const reference here. Otherwise default assignment operator will
  // not work.
  //
  // The accessor methods must be const for sort, so
  // the other fields must be mutable.

  struct Sort0 : public DataFrame::Record {
    Sort0(DataFrame *df,
      DataFrame::iterator0 itr,
      eepgwde::detail::record_t r) : DataFrame::Record(df, itr, r) {}

#ifndef NDEBUG
    // If you don't want to pass arguments, define your own.
    int maturity3() const {
      std::string key("X2");
      boost::any o = *(r_)[key];
      int r0;
      std::cerr << * eepgwde::detail::as<int>(&r0, o) << std::endl;
      return 0;
    }
#endif

  };

  // Simple multi-key sort comparator.
  //
  // This doesn't work like stable sort.
  struct Sort1 {
    const std::string strike;
    const std::string maturity;

    bool t1(const std::string & k) {
      return false;
    }

    template <typename T>
    T r(const DataFrame::Record & z, const std::string & k0) const {
      T x = *eepgwde::detail::as(&x, *(z.r_[k0]) );
      return x;
    }

    Sort1() : strike("X1"), maturity("X2") {}
    
    bool less(const DataFrame::Record & a_,
          const DataFrame::Record & b_)
      const {
      return ( r<double>(a_, strike) < r<double>(b_, strike)
           &&
           r<int>(a_, maturity) < r<int>(b_, maturity) );
    }
  };

}

// Putting the iterators for the rows into a list for sorting.

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

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

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

  DataFrame::payloader payload0(df);
  std::vector<DataFrame::iterator0> a = payload0;

  for(std::vector<DataFrame::iterator0>::iterator
    i = a.begin(); i != a.end(); ++i) {
    // DataFrame::iterator1 ii = (*i);
  }

  std::cerr << frame << std::endl;

}

// Putting the iterators for the rows into a list for sorting.
// 
// Single-key sorting on one attribute uses a single fetch on the
// attribute on the key and the std::less().

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

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

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

  std::string key("X2");
    
  DataFrame::payloader payload0(df);
  std::vector<Sort0> sort0 = payload0;

  BOOST_CHECK(sort0.size() > 0);

  sort(sort0.begin(), sort0.end(),
       boost::bind(std::less<int>(),
           boost::bind(&Sort0::as<int>,_1, key),
           boost::bind(&Sort0::as<int>,_2, key) ));

  DataFrame::ma_any_t sorted0 = payload0.as(sort0);

  std::cerr << sorted0 << std::endl;

}

// Putting the iterators for the rows into a list for sorting.
// 
// Multi-key sorting. Uses stable_sort().
// We want a sorted list by strike and then by maturity.
// First we sort by maturity, then we stable_sort by strike.
//
// @note
// Not very efficient. We should sort within partitioned ranges.
// But this will do for small sorts.
// @note
// The eurisc.csv0 data doesn't make much sense. It has caps and floors.

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

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

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

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

  BOOST_CHECK(sort0.size() > 0);

  std::string strike("X1");
  std::string maturity("X2");

  // second key
  sort(sort0.begin(), sort0.end(),
       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(), sort0.end(),
          boost::bind(std::less<double>(),
              boost::bind(&DataFrame::Record::as<double>,_1, strike),
              boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

  DataFrame::ma_any_t sorted0 = payload0.as(sort0);

  std::cerr << sorted0 << std::endl;

}

// Using partition and sort.
//
// Partition returns [begin, middle), [middle, end]

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

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

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

  Typing t0;
  Typing::mappings_t mappings0 = t0.mappings();
  mappings0["PX"] = "name";

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

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

  BOOST_CHECK(sort0.size() > 0);

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

  // second key
  std::vector<DataFrame::Record>::iterator caps =
    partition(sort0.begin(), sort0.end(),
          boost::bind(&QPXisc::compare,boost::ref(comparor),_1) );

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

  std::string strike("X1");
  std::string maturity("X2");

  // Caps 

  // second key
  sort(sort0.begin(), caps0,
       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(), caps0,
          boost::bind(std::less<double>(),
              boost::bind(&DataFrame::Record::as<double>,_1, strike),
              boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

  {
    DataFrame::ma_any_t sorted0 = payload0.as(sort0.begin(), caps0);
    
    std::cerr << sorted0 << std::endl;
  }

  // Floors

  // second key
  sort(caps, sort0.end(),
       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(caps, sort0.end(),
          boost::bind(std::less<double>(),
              boost::bind(&DataFrame::Record::as<double>,_1, strike),
              boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

  {
    DataFrame::ma_any_t sorted0 = payload0.as(caps, sort0.end());
    
    std::cerr << sorted0 << std::endl;
  }

}

// Using partition and sort.
//
// Partition returns [begin, middle), [middle, end]

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

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

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

  Typing t0;
  Typing::mappings_t mappings0 = t0.mappings();
  mappings0["PX"] = "name";

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

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

  BOOST_CHECK(sort0.size() > 0);

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

  // second key
  std::vector<DataFrame::Record>::iterator caps =
    partition(sort0.begin(), sort0.end(),
          boost::bind(&QPXisc::compare,boost::ref(comparor),_1) );

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

  std::string strike("X1");
  std::string maturity("X2");

  // Caps 

  // second key
  sort(sort0.begin(), caps0,
       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(), caps0,
          boost::bind(std::less<double>(),
              boost::bind(&DataFrame::Record::as<double>,_1, strike),
              boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

  {
    DataFrame::ma_any_t sorted0 = payload0.as(sort0.begin(), caps0);
    
    std::cerr << sorted0 << std::endl;
  }

  // Floors

  // second key
  sort(caps, sort0.end(),
       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(caps, sort0.end(),
          boost::bind(std::less<double>(),
              boost::bind(&DataFrame::Record::as<double>,_1, strike),
              boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

  {
    DataFrame::ma_any_t sorted0 = payload0.as(caps, sort0.end());
    
    std::cerr << sorted0 << std::endl;
  }

}

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

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

  std::string service0(fname0);
  service0 = service0.erase(service0.find("."));

  DataFrame df(frame, service0);

  df.render();

  Typing t0;
  Typing::mappings_t mappings0 = t0.mappings();
  mappings0["PX"] = "name";

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

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

  BOOST_CHECK(sort0.size() > 0);

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

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

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

  std::string strike("X1");
  std::string maturity("X2");

  // Caps 

  // second key
  sort(sort0.begin(), caps0,
       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(), caps0,
          boost::bind(std::less<double>(),
              boost::bind(&DataFrame::Record::as<double>,_1, strike),
              boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

  DataFrame::ma_any_t sorted0 = payload0.as(sort0.begin(), caps0);
  std::cerr << sorted0 << std::endl;

  std::vector<std::vector<DataFrame::Record>::iterator > marks;
  std::vector<DataFrame::Record>::iterator marker = sort0.begin();
  
  while (1) {
    std::vector<DataFrame::Record>::iterator mark =
      adjacent_find(marker, caps0,
            boost::bind(std::greater<double>(),
                boost::bind(&DataFrame::Record::as<double>,_2, strike),
                boost::bind(&DataFrame::Record::as<double>,_1, strike) ));
    if (distance(mark,caps0) > 0) {
      std::cerr << "mark: "
        << mark->as<double>(strike) << " "
        << mark->as<double>(maturity) << std::endl;
      marks.push_back(mark);
      marker = mark + 1;
    }
    else
      break;
  }
  if (marks.size() > 0) {
    std::vector<DataFrame::Record>::iterator c = caps0;
    advance(c, -1);
    marks.push_back(c);
  }

  BOOST_TEST_MESSAGE(marks.size());

  for (std::vector<std::vector<DataFrame::Record>::iterator >::iterator
     i = marks.begin(); i != marks.end(); ++i) {
    std::vector<DataFrame::Record>::iterator r = *i;
    std::cerr << r->as<double>(strike) << " "
          << r->as<double>(maturity) << std::endl;
  }
  
}

BOOST_AUTO_TEST_SUITE_END()

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

---