acsvt2.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/typing3.hpp"
#include "eleve/src/typing1.hpp"

#include "eleve/src0/csv1.hpp"

#include "pivot0.hpp"

// weaves
// Check CSV file loading.

#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"
#include "eleve/src0/csv1.hpp"

#include "acsvt0.hpp"

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

#include "eleve/src0/csv2.hpp"

namespace eepgwde { namespace detail {
  // Using a mapping_t array to set up mappings.
  //
  // The null entry is a string of length 0.
  eepgwde::detail::Typing::mapping_t bbg_mappings[] = {
    { std::string("PX"), std::string("name") },
    { std::string("PX_LAST"), std::string("price") },
    { std::string("X1"), std::string("strike") },
    { std::string("X2"), std::string("maturity") },
    { std::string(""), std::string("") }
  };

}}

namespace {
  using namespace eepgwde::detail;

struct csv1 {

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

  DataFrame df;
  DataFrame::ma_any_t sorted0;

  static DataFrame init0() {
    std::string service0(fname0);
    service0 = service0.erase(service0.find("."));

    DataFrame df(frame, service0);
    return df;
  };

  // This is hard-coded to split out the caps - it's the regex.
  csv1() : df(csv1::init0()) {
    df.render();

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

    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(&QPXisc::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;
  }

  ~csv1() {}

};

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

}

BOOST_FIXTURE_TEST_SUITE (multi_index1,csv1) 

BOOST_AUTO_TEST_CASE(c0) 
{
  // 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(c1) 
{
  using namespace eepgwde::detail;

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

  BOOST_CHECK(sorted0.size() > 1);

  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(c2) 
{
  using namespace eepgwde::detail;

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

  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);

  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(c3) 
{
  using namespace eepgwde::detail;

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

  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

---