QuantlibPlugin.hpp

/*
 * \file    QuantlibPlugin.hpp
 * \brief   Interface functions for the QuantlibPlugin
 *
 * \copyright
 * Copyright (c) 2016-2017 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors. 
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG 
 */
 
#ifndef _QUANTLIBPLUGIN_H_
#define _QUANTLIBPLUGIN_H_
 
// the only header you need to use QuantLib
#include <ql/quantlib.hpp>
#include <ql/math/statistics/generalstatistics.hpp>
 
#ifdef BOOST_MSVC
/* Uncomment the following lines to unmask floating-point
   exceptions. Warning: unpredictable results can arise...
 
   See http://www.wilmott.com/messageview.cfm?catid=10&threadid=9481
   Is there anyone with a definitive word about this?
   */
// #include <float.h>
// namespace { unsigned int u = _controlfp(_EM_INEXACT, _MCW_EM); }
#endif
 
#include <epl_plugin.hpp>
#include <boost/timer/timer.hpp>
#include <boost/unordered_map.hpp>
#include <iostream>
#include <string>
using namespace com::apama::epl;
using namespace QuantLib;
 
#if defined(QL_ENABLE_SESSIONS)
namespace QuantLib {
 
    Integer sessionId() { return 0; }
 
}
#endif
 
 
#define BOND_COMPARE_EQUAL          0
#define BOND_MATURITYDATE_ERROR     1
#define BOND_ISSUEDATE_ERROR        2
#define BOND_SETTLEMENTDATE_ERROR   4
#define BOND_RATE_ERROR             8
#define BOND_FREQUENCY_ERROR        16
#define BOND_CREATED_NEW            255
 
#define NO_UPDATE_BOND              false
#define UPDATE_BOND                 true
 
// local typedefs
typedef boost::shared_ptr<FixedRateBond> bond_ptr;
 
class BondKey {
public:
    BondKey(
        const char* issueDate, const char* maturityDate, const char* settlementDate,
        const Rate rate, const Frequency frequency, bool takeCopies = true);
    BondKey(const BondKey& that);
    BondKey& operator=(const BondKey& that);
    ~BondKey();
    const char *toString();
    const char *getIssueDate() { return issueDate; }
    const char *getMaturityDate() { return maturityDate; }
    const char *getSettlementDate() { return settlementDate; }
    Rate getRate() { return rate; }
    Frequency getFrequency() { return frequency; }
 
private:
 
    void cleanup();
 
    char* issueDate;
    char* maturityDate;
    char* settlementDate;
    Rate rate;
    Frequency frequency;
    std::size_t hash;
    bool ownStrings;
 
    friend bool operator<(const BondKey& lhs, const BondKey& rhs);
    friend bool operator==(const BondKey& lhs, const BondKey& rhs);
    friend int compare(BondKey& lhs, BondKey& rhs);
    friend std::size_t hash_value(const BondKey& x) {
        return x.hash;
    }
};
 
class YieldKey {
public:
    YieldKey(bond_ptr& bond, Real price, const char* settlementDate, bool takeCopies = true);
    YieldKey(const YieldKey& that);
    YieldKey& operator=(const YieldKey& that);
    ~YieldKey();
 
private:
    void cleanup();
 
    bond_ptr bond;
    Real price;
    char* settlementDate;
    std::size_t hash;
    bool ownStrings;
 
    friend bool operator<(const YieldKey& lhs, const YieldKey& rhs);
    friend bool operator==(const YieldKey& lhs, const YieldKey& rhs);
    friend std::size_t hash_value(const YieldKey& x) {
        return x.hash;
    }
};
 
bool operator<(const BondKey& lhs, const BondKey& rhs);
bool operator==(const BondKey& lhs, const BondKey& rhs);
 
// more local typedefs
typedef std::map< std::string, bond_ptr> stringbond_map;
//typedef boost::unordered_map< BondKey, bond_ptr > bond_map;
typedef boost::unordered_map< const char *, bond_ptr > bond_map;
typedef boost::unordered_map< const char *, BondKey > bondspec_map;
typedef boost::unordered_map< YieldKey, Real > yield_map;
 
class OptionResultsChunk
{
public:
    OptionResultsChunk(int32_t errorNum, double npv, double implVol, double delta, double gamma, double theta, double vega, double rho, char* error);
    ~OptionResultsChunk();
    void print() const;
    int32_t errNum;
    double npv;
    double implVol;
    double delta; 
    double gamma;
    double theta;
    double vega;
    double rho;
    char* error;
};
 
class myIncrementalStatistics : public QuantLib::IncrementalStatistics
{
public:
    void remove(Real value, Real weight);
};
 
class QuantlibPlugin : public EPLPlugin<QuantlibPlugin>
{
public:
    QuantlibPlugin() :base_plugin_t("QuantlibPlugin"){}
    ~QuantlibPlugin(){}
    static void initialize(base_plugin_t::method_data_t &md);
    custom_t<OptionResultsChunk>
    modelPrice(double _underlying, double _strike, const char* _currentBussinessDate,
               const char* _maturity, double _riskFreeRate, double _volatility,
               double _dividendYield, const char* _t, const char* _modelName);
    custom_t<OptionResultsChunk> 
    modelImplVol(double _price, double _underlying, double _strike,
                 const char* _currentBussinessDate, const char* _maturityDate,
                 double _riskFreeRate, double _dividendYield, const char* _t, 
                 const char* _modelName);
    custom_t<OptionResultsChunk> 
    modelGreeks(double _underlying, double _strike, const char* _currentBussinessDate,
                const char* _maturity, double _riskFreeRate, double _volatility,
                double _dividendYield, const char* _t, const char* _modelName);
    custom_t<OptionResultsChunk>
    btcoxrossrubinsteinGreeks(double _underlying, double _strike, const char* _currentBussinessDate,
                              const char* _maturity, double _riskFreeRate, double _volatility,
                              double _dividendYield, int64_t _timeSteps, const char* _t);
    custom_t<OptionResultsChunk>
    btcoxrossrubinsteinPrice(double _underlying, double _strike, const char* _currentBussinessDate,
                             const char* _maturity, double _riskFreeRate, double _volatility,
                             double _dividendYield, int64_t _timeSteps, const char* _t);
    custom_t<OptionResultsChunk>
    btcoxrossrubinsteinImplVol(double _price, double _underlying, double _strike,
                               const char* _currentBussinessDate, const char* _maturity,
                               double _riskFreeRate, double _dividendYield, int64_t _timeSteps,
                               const char* _t);
    const char* error(const custom_t<OptionResultsChunk> &results);
    double npv(const custom_t<OptionResultsChunk> &results);
    double delta(const custom_t<OptionResultsChunk> &results);
    double gamma(const custom_t<OptionResultsChunk> &results);
    double theta(const custom_t<OptionResultsChunk> &results);
    double vega(const custom_t<OptionResultsChunk> &results);
    double rho(const custom_t<OptionResultsChunk> &results);
    double implVol(const custom_t<OptionResultsChunk> &results);
    double yield(const char* _symbol, double _price, const char* _issueDate,
                 const char* _maturityDate, const char* _settlementDate, double _rate,
                 int64_t _freq);
    double dv01(const char* _symbol, double _yield, const char* _issueDate,
                const char* _maturityDate, const char* _settlementDate, double _rate,
                int64_t _freq);
    double price(const char* _symbol, double _yield, const char* _issueDate,
                 const char* _maturityDate, const char* _settlementDate, double _rate,
                 int64_t _freq);
    int64_t createBond(const char* _symbol, const char* _issueDate,
                       const char* _maturityDate, const char* _settlementDate,
                       double _rate, int64_t _frequency, bool _updateFlag);
    void addToDataset(double _value, double _weight);
    void removeFromDataset(double _value, double _weight);
    void resetDataset();
    double mean();
    double stddev();
    double weightSum();
    double variance();
    double kurtosis();
    double skew();
    double min();
    double max();
    int64_t numSamples();
 
    static Logger* _logger; 
    static bond_ptr _getBond(
        const char* symbol, const char* issueDate,
        const char* maturityDate, const char* settlementDate,
        Rate rate, Frequency frequency, bool updateFlag, int &ouputValue, std::string &discrepancyMessage);
    static Rate _yield(
        bond_ptr bond, const Real& price, const char* settlementDate);
    static Real _dv01(
        bond_ptr bond, const Rate& yield, const char* settlementDate);
    static Real _price(
        bond_ptr bond, const Rate& yield, const char* settlementDate);
    static std::string getDiscrepancyErrorMessage(int outputValue, BondKey cachedBondKey, BondKey inputBondKey);
    static void dumpCaches();
 
private:
    static bond_ptr _createBond(
        const char* issueDate, const char* maturityDate, const char* settlementDate,
        const Rate& rate, const Frequency& frequency);
};
 
APAMA_DECLARE_EPL_PLUGIN(QuantlibPlugin)
#endif /*_QUANTLIBPLUGIN_H_ */