XLL_DEC OPER *qlLMMDriftCalculatorCompute(
char *ObjectId,
char *CurveState,
OPER *Trigger) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlLMMDriftCalculatorCompute"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to Object references
OH_GET_OBJECT(ObjectIdObjPtr, ObjectId, QuantLibAddin::LMMDriftCalculator)
// convert object IDs into library objects
OH_GET_UNDERLYING(CurveStateLibObj, CurveState,
QuantLibAddin::LMMCurveState, QuantLib::LMMCurveState)
// invoke the member function
std::vector<double> returnValue = ObjectIdObjPtr->compute(
CurveStateLibObj);
// convert and return the return value
static OPER xRet;
ObjectHandler::vectorToOper(returnValue, xRet);
return &xRet;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
XLL_DEC OPER *qlVariates(
char *ObjectId,
long *Samples,
OPER *Trigger) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlVariates"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to Object references
OH_GET_OBJECT(ObjectIdObjPtr, ObjectId, QuantLibAddin::RandomSequenceGenerator)
// invoke the member function
std::vector<std::vector<double> > returnValue = ObjectIdObjPtr->variates(
*Samples);
// convert and return the return value
static OPER xRet;
ObjectHandler::matrixToOper(returnValue, xRet);
return &xRet;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
XLL_DEC OPER *qlPiecewiseYieldCurveJumpDates(
char *ObjectId,
OPER *Trigger) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlPiecewiseYieldCurveJumpDates"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to Object references
OH_GET_OBJECT(ObjectIdObjPtr, ObjectId, QuantLibAddin::PiecewiseYieldCurve)
// invoke the member function
std::vector<QuantLib::Date> returnValue = ObjectIdObjPtr->jumpDates();
// convert and return the return value
std::vector<long> returnValVec = QuantLibAddin::libraryToVector(returnValue);
static OPER xRet;
ObjectHandler::vectorToOper(returnValVec, xRet);
return &xRet;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
XLL_DEC char *qlHandleCurrentLink(
char *ObjectId,
OPER *Trigger) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlHandleCurrentLink"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to Object references
OH_GET_OBJECT(ObjectIdObjPtr, ObjectId, QuantLibAddin::Handle)
// invoke the member function
std::string returnValue = ObjectIdObjPtr->currentLink();
// convert and return the return value
static char ret[XL_MAX_STR_LEN];
ObjectHandler::stringToChar(returnValue, ret);
return ret;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
DLLEXPORT OPER *getSpotPathDetail(char *portfolioEvolverId,
OPER *spotPath,
OPER *Trigger)
{
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
static XLOPER returnValue;
try
{
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("getSpotPathDetail"));
ObjectHandler::validateRange(Trigger, "Trigger");
OH_GET_OBJECT(portfolioEvolverIdPtr, portfolioEvolverId, sjdObjects::PortfolioEvolver)
std::vector<double> spotPathCpp =
ObjectHandler::operToVector<double>(*spotPath, "Spot Path");
size_t numSims = portfolioEvolverIdPtr->getSimulationDates().size();
if (spotPathCpp.size() != numSims)
{
ObjectHandler::scalarToOper("spot path does not have the correct size", returnValue);
return &returnValue;
}
std::vector<string> columnHeadings;
std::vector<std::vector<double> > data;
std::vector<Date> simulationDates;
portfolioEvolverIdPtr->getSpotPathDetail(spotPathCpp, simulationDates, columnHeadings, data);
std::vector<string> rowHeadings = std::vector<string>(0);
for (size_t i = 0; i < simulationDates.size(); ++i)
{
stringstream errorDescription;
errorDescription << QuantLib::io::iso_date(simulationDates[i]);
rowHeadings.push_back(errorDescription.str());
}
sjd::tableToOper(columnHeadings, rowHeadings, data, returnValue);
return &returnValue;
}
SJD_XLL_CATCH_OPER()
}
DLLEXPORT OPER *getSimulationDatesForEvolver(char *portfolioEvolverId,
OPER *Trigger)
{
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
static XLOPER returnValue;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("getSimulationDatesForEvolver"));
ObjectHandler::validateRange(Trigger, "Trigger");
OH_GET_OBJECT(portfolioEvolverIdPtr, portfolioEvolverId, sjdObjects::PortfolioEvolver)
std::vector<Date> simDates = portfolioEvolverIdPtr->getSimulationDates();
ObjectHandler::vectorToOper(simDates, returnValue);
return &returnValue;
}
SJD_XLL_CATCH_OPER()
}
/* Fonction de calcul de la NPV d'un swap ou d'une jambe */
DLLEXPORT xloper * xlSwapNPV (const char * instrumentId_,
const char * discountCurveId_,
xloper * forwardCurveId_,
xloper * trigger_) {
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall(
new ObjectHandler::FunctionCall("xlSwapNPV")) ;
try {
QL_ENSURE(! functionCall->calledByFunctionWizard(), "") ;
// validation
ObjectHandler::validateRange(trigger_, "trigger") ;
ObjectHandler::validateRange(forwardCurveId_, "forward Curve") ;
// conversion des xloper
ObjectHandler::ConvertOper myOper(* forwardCurveId_) ;
// on récupère la courbe de discounting
OH_GET_OBJECT(discountCurvePtr,
discountCurveId_,
ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> discountCurveHandler =
QuantLibAddin::CoerceHandle<QuantLibAddin::YieldTermStructure, QuantLib::YieldTermStructure>()(discountCurvePtr) ;
// on récupère l'instrument
OH_GET_REFERENCE(mySwap,
instrumentId_,
QuantLibAddin::interestRateSwapObject,
QuantLib::vanillaSwap2)
boost::shared_ptr<QuantLib::PricingEngine> myPricingEngine ;
// ligature du pricing engine
if (myOper.missing()) {
myPricingEngine = boost::shared_ptr<QuantLib::PricingEngine>(
new QuantLib::DiscountingSwapEngine(discountCurveHandler/*, discountCurveHandler*/)) ;
//mySwap->setFixingIndex(* discountCurveHandler) ;
} else {
// on récupère la courbe forward
OH_GET_OBJECT(forwardCurvePtr,
static_cast<std::string>(myOper),
ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> forwardCurveHandler =
QuantLibAddin::CoerceHandle<QuantLibAddin::YieldTermStructure, QuantLib::YieldTermStructure>()(forwardCurvePtr) ;
myPricingEngine = boost::shared_ptr<QuantLib::PricingEngine>(
new QuantLib::DiscountingSwapEngine(discountCurveHandler/*, forwardCurveHandler*/)) ;
//mySwap->setFixingIndex(* forwardCurveHandler) ;
}
mySwap->setPricingEngine(myPricingEngine) ;
static XLOPER returnOper ;
ObjectHandler::scalarToOper(mySwap->NPV(), returnOper) ;
return & returnOper ;
} catch (std::exception & e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall) ;
static XLOPER returnOper ;
ObjectHandler::scalarToOper(e.what(), returnOper) ;
return & returnOper ;
}
} ;
XLL_DEC char *qlFRA(
char *ObjectId,
OPER *ValueDate,
OPER *MaturityDate,
char *Position,
double *Strike,
double *Notional,
char *IborIndex,
char *YieldCurve,
OPER *Permanent,
OPER *Trigger,
bool *Overwrite) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlFRA"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
ObjectHandler::property_t ValueDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*ValueDate));
ObjectHandler::property_t MaturityDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*MaturityDate));
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date ValueDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*ValueDate), "ValueDate");
QuantLib::Date MaturityDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*MaturityDate), "MaturityDate");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Position::Type PositionEnum =
ObjectHandler::Create<QuantLib::Position::Type>()(Position);
// convert object IDs into library objects
OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,
QuantLibAddin::IborIndex, QuantLib::IborIndex)
OH_GET_OBJECT(YieldCurveCoerce, YieldCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce);
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string IborIndexStrip = ObjectHandler::CallingRange::getStub(IborIndex);
std::string YieldCurveStrip = ObjectHandler::CallingRange::getStub(YieldCurve);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlFRA(
ObjectIdStrip,
ValueDateCpp,
MaturityDateCpp,
Position,
*Strike,
*Notional,
IborIndexStrip,
YieldCurveStrip,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::ForwardRateAgreement(
valueObject,
ValueDateLib,
MaturityDateLib,
PositionEnum,
*Strike,
*Notional,
IborIndexLibObjPtr,
YieldCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);
// Convert and return the return value
static char ret[XL_MAX_STR_LEN];
ObjectHandler::stringToChar(returnValue, ret);
return ret;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
DLLEXPORT char *createForwardCurveFX(char *objectID,
OPER *anchorDate,
double spot,
OPER *spotDate,
char *domesticDRSID,
char *foreignDRSID,
bool *stochastic,
char *vrsID,
bool *permanent)
{
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
static char ret[XL_MAX_STR_LEN];
try
{
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>
(new ObjectHandler::FunctionCall("createForwardCurveFX"));
QuantLib::Date AnchorDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*anchorDate), "AnchorDate");
QuantLib::Date SpotDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*anchorDate), "SpotDate");
if (SpotDateLib < AnchorDateLib)
{
ObjectHandler::stringToChar("Spot Date cannot preceed Anchor Date", ret);
return ret;
}
OH_GET_OBJECT(DomesticDRSIdLibObjPtr, domesticDRSID, sjdObjects::DiscountRateSource)
OH_GET_OBJECT(ForeignDRSIdLibObjPtr, foreignDRSID, sjdObjects::DiscountRateSource)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(objectID);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new sjdObjects::ValueObjects::GenericUnimplementedValueObject(ObjectIdStrip,false));
std::string returnValue;
if (!(*stochastic))
{
sjdObjects::ForwardRateSourceDeterministic *sfc;
sfc = new sjdObjects::ForwardCurveDeterministicFX(valueObject,
AnchorDateLib,
spot,
SpotDateLib,
DomesticDRSIdLibObjPtr,
ForeignDRSIdLibObjPtr,
*permanent);
boost::shared_ptr<ObjectHandler::Object> object(sfc);
if (!sfc->isOK())
{
returnValue = sfc->getErrorMessages();
}
else
{
returnValue =
ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, true);
}
}
else
{
sjdObjects::ForwardRateSourceStochastic *sfc;
OH_GET_OBJECT(VolIdLibObjPtr, vrsID, sjdObjects::VolatilityRateSource)
sfc = new sjdObjects::ForwardCurveStochasticFX(valueObject,
AnchorDateLib,
spot,
SpotDateLib,
DomesticDRSIdLibObjPtr,
ForeignDRSIdLibObjPtr,
VolIdLibObjPtr,
*permanent);
boost::shared_ptr<ObjectHandler::Object> object(sfc);
if (!sfc->isOK())
{
returnValue = sfc->getErrorMessages();
}
else
{
returnValue =
ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, true);
}
}
// Convert and return the return value
ObjectHandler::stringToChar(returnValue, ret);
return ret;
}
SJD_XLL_CATCH_STRING()
}
std::string qlRiskyFixedBond(
const std::string &ObjectId,
const std::string &Bondname,
const std::string &Currency,
const double &Recovery,
const std::string &DefaultCurve,
const std::string &Schedule,
const double &Rate,
const std::string &DayCounter,
const ObjectHandler::property_t &PaymentConvention,
const double &Notional,
const std::string &DiscountingCurve,
const ObjectHandler::property_t &PricingDate,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
std::string PaymentConventionCpp = ObjectHandler::convert2<std::string>(
PaymentConvention, "PaymentConvention", "Following");
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date PricingDateLib = ObjectHandler::convert2<QuantLib::Date>(
PricingDate, "PricingDate");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Currency CurrencyEnum =
ObjectHandler::Create<QuantLib::Currency>()(Currency);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounter);
QuantLib::BusinessDayConvention PaymentConventionEnum =
ObjectHandler::Create<QuantLib::BusinessDayConvention>()(PaymentConventionCpp);
// convert object IDs into library objects
OH_GET_OBJECT(DefaultCurveCoerce, DefaultCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::DefaultProbabilityTermStructure> DefaultCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::DefaultProbabilityTermStructure,
QuantLib::DefaultProbabilityTermStructure>()(
DefaultCurveCoerce);
OH_GET_REFERENCE(ScheduleLibObjPtr, Schedule,
QuantLibAddin::Schedule, QuantLib::Schedule)
OH_GET_OBJECT(DiscountingCurveCoerce, DiscountingCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> DiscountingCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
DiscountingCurveCoerce);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlRiskyFixedBond(
ObjectId,
Bondname,
Currency,
Recovery,
DefaultCurve,
Schedule,
Rate,
DayCounter,
PaymentConventionCpp,
Notional,
DiscountingCurve,
PricingDate,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::RiskyFixedBond(
valueObject,
Bondname,
CurrencyEnum,
Recovery,
DefaultCurveLibObj,
ScheduleLibObjPtr,
Rate,
DayCounterEnum,
PaymentConventionEnum,
Notional,
DiscountingCurveLibObj,
PricingDateLib,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite, valueObject);
// Convert and return the return value
return returnValue;
} catch (const std::exception &e) {
OH_FAIL("Error in function qlRiskyFixedBond : " << e.what());
}
}
XLL_DEC double *qlSwaptionImpliedVolatility(
char *ObjectId,
double *Price,
char *YieldCurve,
OPER *Guess,
OPER *Accuracy,
OPER *MaxIter,
OPER *MinVol,
OPER *MaxVol,
OPER *Displacement,
OPER *Trigger) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlSwaptionImpliedVolatility"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
double GuessCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Guess), "Guess", 0.10);
double AccuracyCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Accuracy), "Accuracy", 1.0e-6);
long MaxIterCpp = ObjectHandler::convert2<long>(
ObjectHandler::ConvertOper(*MaxIter), "MaxIter", 100);
double MinVolCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*MinVol), "MinVol", 1.0e-7);
double MaxVolCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*MaxVol), "MaxVol", 4.0);
double DisplacementCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Displacement), "Displacement", 0.0);
// convert input datatypes to QuantLib datatypes
QuantLib::Real AccuracyLib = ObjectHandler::convert2<QuantLib::Real>(
ObjectHandler::ConvertOper(*Accuracy), "Accuracy", 1.0e-6);
QuantLib::Natural MaxIterLib = ObjectHandler::convert2<QuantLib::Natural>(
ObjectHandler::ConvertOper(*MaxIter), "MaxIter", 100);
QuantLib::Real DisplacementLib = ObjectHandler::convert2<QuantLib::Real>(
ObjectHandler::ConvertOper(*Displacement), "Displacement", 0.0);
// convert object IDs into library objects
OH_GET_REFERENCE(ObjectIdLibObjPtr, ObjectId,
QuantLibAddin::Swaption, QuantLib::Swaption)
OH_GET_OBJECT(YieldCurveCoerce, YieldCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce);
// invoke the member function
static double returnValue;
returnValue = ObjectIdLibObjPtr->impliedVolatility(
*Price,
YieldCurveLibObj,
GuessCpp,
AccuracyLib,
MaxIterLib,
MinVolCpp,
MaxVolCpp,
DisplacementLib);
// convert and return the return value
return &returnValue;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
XLL_DEC char *qlSmileSectionFromSabrVolSurface(
char *ObjectId,
char *SabrVolSurface,
double *OptionTime,
OPER *Permanent,
OPER *Trigger,
bool *Overwrite) {
// declare a shared pointer to the Function Call object
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
try {
// instantiate the Function Call object
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(
new ObjectHandler::FunctionCall("qlSmileSectionFromSabrVolSurface"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert object IDs into library objects
OH_GET_OBJECT(SabrVolSurfaceCoerce, SabrVolSurface, ObjectHandler::Object)
QuantLib::Handle<QuantLib::SabrVolSurface> SabrVolSurfaceLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::SabrVolSurface,
QuantLib::SabrVolSurface>()(
SabrVolSurfaceCoerce);
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string SabrVolSurfaceStrip = ObjectHandler::CallingRange::getStub(SabrVolSurface);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlSmileSectionFromSabrVolSurface(
ObjectIdStrip,
SabrVolSurfaceStrip,
*OptionTime,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::SmileSectionFromSabrVolSurface(
valueObject,
SabrVolSurfaceLibObj,
*OptionTime,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);
// Convert and return the return value
static char ret[XL_MAX_STR_LEN];
ObjectHandler::stringToChar(returnValue, ret);
return ret;
} catch (const std::exception &e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
return 0;
} catch (...) {
ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);
return 0;
}
}
/* Fonction de calcul d'un taux fixe de swap */
DLLEXPORT xloper * xlSwapFairFixedRate (const char * swapId_,
const char * legId_,
const char * curveId_,
xloper * trigger_) {
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall(
new ObjectHandler::FunctionCall("xlSwapFairFixedRate")) ;
try {
QL_REQUIRE(! functionCall->calledByFunctionWizard(), "") ;
// trigger pour provoquer le recalcul
ObjectHandler::validateRange(trigger_, "trigger") ;
// on récupère la courbe des taux
OH_GET_OBJECT(curvePtr, curveId_, QuantLibAddin::YieldTermStructure)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<QuantLibAddin::YieldTermStructure, QuantLib::YieldTermStructure>()(curvePtr) ;
// setup de la date de pricing (reference date de la courbe)
//QuantLib::Settings::instance().evaluationDate() = YieldCurveLibObj->referenceDate() ;
// on récupère le swap
OH_GET_OBJECT(objPtr, swapId_, ObjectHandler::Object)
// calcul de la NPV totale des autres jambes
QuantLib::Real fairRate = 0.0 ;
// objet pour contrôle
OH_GET_OBJECT(swapObj, swapId_, QuantLibAddin::interestRateSwapObject)
// on spécialise le ptr
OH_GET_REFERENCE(swapPtr,
swapId_,
QuantLibAddin::interestRateSwapObject,
QuantLib::vanillaSwap2)
// vérification que la jambe fait partie du swap
QL_REQUIRE(swapObj->getLegType(std::string(legId_)) == "fixedLegUnitedStatesValueObject" ||
swapObj->getLegType(std::string(legId_)) == "fixedLegUnitedAustraliaValueObject", "unappropriate leg type") ;
swapPtr->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(
new QuantLib::DiscountingSwapEngine(YieldCurveLibObj))) ;
// calcul de la NPV totale des autres jambes
QuantLib::Size legRank = swapObj->getLegRank(std::string(legId_)) ;
// on suppose que le taux est fixe (pas de step-up cpn)
boost::shared_ptr<QuantLib::FixedRateCoupon> myCastedCashFlow
= boost::dynamic_pointer_cast<QuantLib::FixedRateCoupon>(swapPtr->leg(legRank)[0]) ;
fairRate = myCastedCashFlow->rate() - swapPtr->NPV()/(swapPtr->legBPS(legRank)/1.0e-4) ;
static XLOPER returnOper ;
ObjectHandler::scalarToOper(fairRate, returnOper) ;
return & returnOper ;
} catch (std::exception & e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall) ;
static XLOPER returnOper ;
ObjectHandler::scalarToOper(e.what(), returnOper) ;
return & returnOper ;
}
} ;
std::string CALCmsMarket(
const std::string &ObjectId,
const std::vector<ObjectHandler::property_t>& SwapLengths,
const std::vector<std::string>& SwapIndexes,
const std::string &IborIndex,
const std::vector<std::vector <ObjectHandler::property_t> >& BidAskSpreads,
const std::vector<std::string>& CmsCouponPricers,
const std::string &YieldCurve,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
std::vector<QuantLib::Period> SwapLengthsLib =
ObjectHandler::vector::convert2<QuantLib::Period>(SwapLengths, "SwapLengths");
// convert object IDs into library objects
std::vector<boost::shared_ptr<QuantLib::SwapIndex> > SwapIndexesLibObjPtr =
ObjectHandler::getLibraryObjectVector<QuantLibAddin::SwapIndex, QuantLib::SwapIndex>(SwapIndexes);
OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,
QuantLibAddin::IborIndex, QuantLib::IborIndex)
std::vector<std::vector<QuantLib::Handle<QuantLib::Quote> > > BidAskSpreadsLibObj =
ObjectHandler::matrix::convert2<QuantLib::Handle<QuantLib::Quote> >(BidAskSpreads, "BidAskSpreads");
std::vector<boost::shared_ptr<QuantLib::CmsCouponPricer> > CmsCouponPricersLibObjPtr =
ObjectHandler::getLibraryObjectVector<QuantLibAddin::CmsCouponPricer, QuantLib::CmsCouponPricer>(CmsCouponPricers);
OH_GET_OBJECT(YieldCurveCoerce, YieldCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::CALCmsMarket(
ObjectId,
SwapLengths,
SwapIndexes,
IborIndex,
BidAskSpreads,
CmsCouponPricers,
YieldCurve,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::CmsMarket(
valueObject,
SwapLengthsLib,
SwapIndexesLibObjPtr,
IborIndexLibObjPtr,
BidAskSpreadsLibObj,
CmsCouponPricersLibObjPtr,
YieldCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite);
// Convert and return the return value
return returnValue;
} catch (const std::exception &e) {
OH_FAIL("Error in function CALCmsMarket : " << e.what());
}
}
STRING SAL_CALL CalcAddins_impl::qlOvernightIndex(
const STRING &ObjectId,
const STRING &FamilyName,
sal_Int32 FixingDays,
const STRING &Currency,
const STRING &Calendar,
const STRING &DayCounter,
const ANY &YieldCurve,
const ANY &Permanent,
const ANY &Trigger,
sal_Int32 Overwrite) throw(RuntimeException) {
try {
// convert input datatypes to C++ datatypes
std::string ObjectIdCpp = ouStringToStlString(ObjectId);
std::string FamilyNameCpp = ouStringToStlString(FamilyName);
std::string CurrencyCpp = ouStringToStlString(Currency);
std::string CalendarCpp = ouStringToStlString(Calendar);
std::string DayCounterCpp = ouStringToStlString(DayCounter);
std::string YieldCurveCpp;
calcToScalar(YieldCurveCpp, YieldCurve);
bool PermanentCpp;
calcToScalar(PermanentCpp, Permanent);
// convert object IDs into library objects
OH_GET_OBJECT(YieldCurveCoerce, YieldCurveCpp, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce);
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Currency CurrencyEnum =
ObjectHandler::Create<QuantLib::Currency>()(CurrencyCpp);
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(CalendarCpp);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlOvernightIndex(
ObjectIdCpp,
FamilyNameCpp,
FixingDays,
CurrencyCpp,
CalendarCpp,
DayCounterCpp,
YieldCurveCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::OvernightIndex(
valueObject,
FamilyNameCpp,
FixingDays,
CurrencyEnum,
CalendarEnum,
DayCounterEnum,
YieldCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite);
// Convert and return the return value
STRING returnValueCalc;
scalarToCalc(returnValueCalc, returnValue);
return returnValueCalc;
} catch (const std::exception &e) {
OH_LOG_MESSAGE("ERROR: qlOvernightIndex: " << e.what());
THROW_RTE;
}
}
STRING SAL_CALL CalcAddins_impl::qlBMAIndex(
const STRING &ObjectId,
const ANY &YieldCurve,
const ANY &Permanent,
const ANY &Trigger,
sal_Int32 Overwrite) throw(RuntimeException) {
try {
// convert input datatypes to C++ datatypes
std::string ObjectIdCpp = ouStringToStlString(ObjectId);
std::string YieldCurveCpp;
calcToScalar(YieldCurveCpp, YieldCurve);
bool PermanentCpp;
calcToScalar(PermanentCpp, Permanent);
// convert object IDs into library objects
OH_GET_OBJECT(YieldCurveCoerce, YieldCurveCpp, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlBMAIndex(
ObjectIdCpp,
YieldCurveCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::BMAIndex(
valueObject,
YieldCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite);
// Convert and return the return value
STRING returnValueCalc;
scalarToCalc(returnValueCalc, returnValue);
return returnValueCalc;
} catch (const std::exception &e) {
OH_LOG_MESSAGE("ERROR: qlBMAIndex: " << e.what());
THROW_RTE;
}
}
/* Fonction de calcul de l'accrued des instruments */
DLLEXPORT xloper * xlSwapDV01 (const char * instrumentId_,
const char * curveId_,
const char * conventionId_,
xloper * trigger_) {
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall(
new ObjectHandler::FunctionCall("xlSwapDV01")) ;
try {
QL_ENSURE(! functionCall->calledByFunctionWizard(), "") ;
// trigger pour provoquer le recalcul
ObjectHandler::validateRange(trigger_, "trigger") ;
QuantLib::Real returnValue ;
// on récupère la courbe
OH_GET_OBJECT(curvePtr, curveId_, ObjectHandler::Object)
// on récupère la convention de taux
OH_GET_OBJECT(conventionPtr, conventionId_, QuantLibAddin::interestRateConventionObject)
QuantLib::Handle<QuantLib::YieldTermStructure> curveLibPtr =
QuantLibAddin::CoerceHandle<QuantLibAddin::YieldTermStructure, QuantLib::YieldTermStructure>()(curvePtr) ;
QuantLib::Handle<QuantLib::Quote> mySpread(
new QuantLib::SimpleQuote(1.0 / 100)) ; // 1 bp
QuantLib::Handle<QuantLib::YieldTermStructure> myShiftedCurve(
new QuantLib::ZeroSpreadedTermStructure(curveLibPtr,
mySpread,
conventionPtr->compounding(),
conventionPtr->frequency(),
conventionPtr->daycounter())) ;
// on récupère l'instrument
OH_GET_OBJECT(instrumentPtr, instrumentId_, ObjectHandler::Object)
/* IRS */
if (instrumentPtr->properties()->className() == "interestRateSwapValueObject") {
QuantLib::Handle<QuantLib::vanillaSwap2> swapPtr
= QuantLibAddin::CoerceHandle<QuantLibAddin::interestRateSwapObject,
QuantLib::vanillaSwap2>()(instrumentPtr) ;
returnValue = QuantLib::CashFlows::npv(swapPtr->leg(0),
** curveLibPtr,
QuantLib::Unadjusted, QuantLib::Calendar(),
false) * swapPtr->receivingLeg(0) ;
returnValue += QuantLib::CashFlows::npv(swapPtr->leg(1),
** curveLibPtr,
QuantLib::Unadjusted, QuantLib::Calendar(),
false) * swapPtr->receivingLeg(1) ;
returnValue -= QuantLib::CashFlows::npv(swapPtr->leg(0),
** myShiftedCurve,
QuantLib::Unadjusted, QuantLib::Calendar(),
false) * swapPtr->receivingLeg(0) ;
returnValue -= QuantLib::CashFlows::npv(swapPtr->leg(1),
** myShiftedCurve,
QuantLib::Unadjusted, QuantLib::Calendar(),
false) * swapPtr->receivingLeg(1) ;
}
/* jambe fixe */
else if (instrumentPtr->properties()->className() == "fixedLegAustraliaValueObject" ||
instrumentPtr->properties()->className() == "fixedLegUnitedStatesValueObject"||
instrumentPtr->properties()->className() == "floatLegAustraliaValueObject" ||
instrumentPtr->properties()->className() == "floatLegUnitedStatesValueObject") {
OH_GET_REFERENCE(instrumentLibObj,
instrumentId_,
QuantLibAddin::Leg,
QuantLib::Leg)
returnValue = QuantLib::CashFlows::npv(* instrumentLibObj,
** curveLibPtr,
QuantLib::Unadjusted, QuantLib::Calendar(),
false) ;
returnValue -= QuantLib::CashFlows::npv(* instrumentLibObj,
** myShiftedCurve,
QuantLib::Unadjusted, QuantLib::Calendar(),
false) ;
}
else { // ici pour les autres instruments
QL_FAIL("unknown instrument type") ;
}
static XLOPER returnOper ;
ObjectHandler::scalarToOper(returnValue, returnOper) ;
return & returnOper ;
} catch (std::exception & e) {
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall) ;
static XLOPER returnOper ;
returnOper.xltype = xltypeErr ;
returnOper.val.err = xlerrValue ;
return & returnOper ;
}
} ;
std::string qlMidPointCdsEngine(
const std::string &ObjectId,
const std::string &DefaultCurve,
const double &RecoveryRate,
const std::string &YieldCurve,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert object IDs into library objects
OH_GET_OBJECT(DefaultCurveCoerce, DefaultCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::DefaultProbabilityTermStructure> DefaultCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::DefaultProbabilityTermStructure,
QuantLib::DefaultProbabilityTermStructure>()(
DefaultCurveCoerce);
OH_GET_OBJECT(YieldCurveCoerce, YieldCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlMidPointCdsEngine(
ObjectId,
DefaultCurve,
RecoveryRate,
YieldCurve,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::MidPointCdsEngine(
valueObject,
DefaultCurveLibObj,
RecoveryRate,
YieldCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite, valueObject);
// Convert and return the return value
return returnValue;
} catch (const std::exception &e) {
OH_FAIL("Error in function qlMidPointCdsEngine : " << e.what());
}
}
DLLEXPORT char *createPortfolioEvolver(char *objectID, char *portfolioID, char *pathGeneratorID, OPER* dates, int holdingPeriodInDays, bool *permanent)
{
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;
static char ret[XL_MAX_STR_LEN];
try
{
functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>
(new ObjectHandler::FunctionCall("createPortfolioEvolver"));
OH_GET_OBJECT(portfolioIDLibObjPtr, portfolioID, sjdObjects::Portfolio);
OH_GET_OBJECT(pathGeneratorIDLibObjPtr, pathGeneratorID, sjdObjects::SingleFactorEconomicScenarioGenerator);
std::vector<QuantLib::Date> DatesLib =
ObjectHandler::operToVector<QuantLib::Date>(*dates, "Dates");
if (!sjd::isStrictlyIncreasing<QuantLib::Date>(DatesLib))
{
ObjectHandler::stringToChar("Input dates vector not increasing", ret);
return ret;
}
set<Date> dateSet = set<Date>(DatesLib.begin(), DatesLib.end());
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(objectID);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new sjdObjects::ValueObjects::GenericUnimplementedValueObject(ObjectIdStrip,*permanent));
sjdObjects::PortfolioEvolver *pe;
if (holdingPeriodInDays <= 0)
{
pe = new sjdObjects::PortfolioEvolver(valueObject,
portfolioIDLibObjPtr,
pathGeneratorIDLibObjPtr,
dateSet,
*permanent);
}
else
{
pe = new sjdObjects::PortfolioEvolver(valueObject,
portfolioIDLibObjPtr,
pathGeneratorIDLibObjPtr,
dateSet,
holdingPeriodInDays,
*permanent);
}
if (!pe->isOK())
{
ObjectHandler::stringToChar(pe->getErrorMessages(), ret);
return ret;
}
boost::shared_ptr<ObjectHandler::Object> object = boost::shared_ptr<ObjectHandler::Object>(pe);
std::string returnValue =
ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, true);
ObjectHandler::stringToChar(returnValue, ret);
return ret;
}
SJD_XLL_CATCH_STRING()
}
std::string qlSpreadCdsHelper(
const std::string &ObjectId,
const ObjectHandler::property_t &RunningSpread,
const std::string &Tenor,
const ObjectHandler::property_t &SettlementDays,
const std::string &Calendar,
const std::string &Frequency,
const std::string &PaymentConvention,
const std::string &GenRule,
const std::string &DayCounter,
const double &RecoveryRate,
const std::string &DiscountingCurve,
const ObjectHandler::property_t &SettleAccrual,
const ObjectHandler::property_t &PayAtDefault,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
long SettlementDaysCpp = ObjectHandler::convert2<long>(
SettlementDays, "SettlementDays", 0);
bool SettleAccrualCpp = ObjectHandler::convert2<bool>(
SettleAccrual, "SettleAccrual", true);
bool PayAtDefaultCpp = ObjectHandler::convert2<bool>(
PayAtDefault, "PayAtDefault", true);
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Period TenorLib;
QuantLibAddin::cppToLibrary(Tenor, TenorLib);
QuantLib::Natural SettlementDaysLib = ObjectHandler::convert2<long>(
SettlementDays, "SettlementDays", 0);
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(Calendar);
QuantLib::Frequency FrequencyEnum =
ObjectHandler::Create<QuantLib::Frequency>()(Frequency);
QuantLib::BusinessDayConvention PaymentConventionEnum =
ObjectHandler::Create<QuantLib::BusinessDayConvention>()(PaymentConvention);
QuantLib::DateGeneration::Rule GenRuleEnum =
ObjectHandler::Create<QuantLib::DateGeneration::Rule>()(GenRule);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounter);
// convert object IDs into library objects
QuantLib::Handle<QuantLib::Quote> RunningSpreadLibObj =
ObjectHandler::convert2<QuantLib::Handle<QuantLib::Quote> >(
RunningSpread, "RunningSpread");
OH_GET_OBJECT(DiscountingCurveCoerce, DiscountingCurve, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> DiscountingCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
DiscountingCurveCoerce);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlSpreadCdsHelper(
ObjectId,
RunningSpread,
Tenor,
SettlementDaysCpp,
Calendar,
Frequency,
PaymentConvention,
GenRule,
DayCounter,
RecoveryRate,
DiscountingCurve,
SettleAccrualCpp,
PayAtDefaultCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::SpreadCdsHelper(
valueObject,
RunningSpreadLibObj,
TenorLib,
SettlementDaysLib,
CalendarEnum,
FrequencyEnum,
PaymentConventionEnum,
GenRuleEnum,
DayCounterEnum,
RecoveryRate,
DiscountingCurveLibObj,
SettleAccrualCpp,
PayAtDefaultCpp,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite, valueObject);
// Convert and return the return value
return returnValue;
} catch (const std::exception &e) {
OH_FAIL("Error in function qlSpreadCdsHelper : " << e.what());
}
}
// parametric fitted curve
DLLEXPORT char * xlInitiateFittedBondDiscountCurve (const char * objectID_ ,
const xloper * evaluationDate_ ,
const xloper * settlementDate_ ,
const xloper * instruments_ ,
const xloper * quote_ ,
const char * calendarID_ ,
const char * fittingMethodID_ ,
const xloper * bondSelectionRule_,
const xloper * trigger_) {
boost::shared_ptr<ObjectHandler::FunctionCall> functionCall(
new ObjectHandler::FunctionCall("xlInitiateFittedBondDiscountCurve"));
try {
QL_ENSURE(! functionCall->calledByFunctionWizard(), ""); // called by wizard ?
ObjectHandler::validateRange(trigger_, "trigger" ); // validate range
ObjectHandler::validateRange(settlementDate_, "settlement Date" );
ObjectHandler::validateRange(instruments_, "instruments" );
ObjectHandler::validateRange(quote_, "quotes" );
ObjectHandler::validateRange(bondSelectionRule_, "bond selection rule");
ObjectHandler::ConvertOper myOper1(* bondSelectionRule_); // bond selection rule oper
QuantLib::bondSelectionRule myRule = // the rule
(myOper1.missing() ?
QuantLib::activeRule() :
ObjectHandler::bondSelectionRuleFactory()(
static_cast<std::string>(myOper1)));
QuantLib::Calendar curveCalendar // calendar
= ObjectHandler::calendarFactory()(calendarID_);
ObjectHandler::ConvertOper oper1(* evaluationDate_); // evaluation date
QuantLib::Date evaluationDate(oper1.missing() ?
QuantLib::Date() :
static_cast<QuantLib::Date>(oper1));
std::vector<std::string> instruments = // instrument ids
ObjectHandler::operToVector<std::string>(
* instruments_, "instruments");
std::vector<QuantLib::Real> quote = // quotes
ObjectHandler::operToVector<double>(
* quote_, "quote");
std::vector<boost::shared_ptr<QuantLib::BondHelper> > instrumentsObject; // helpers
for (unsigned int i = 0 ; i < instruments.size() ; i++) { // capture individual bonds
try {
OH_GET_REFERENCE(instrumentPtr, // get a reference
instruments[i],
QuantLibAddin::Bond,
QuantLib::Bond)
if (quote[i] != 0.0 && instrumentPtr->isTradable()) { // valid quote ?
QuantLib::RelinkableHandle<QuantLib::Quote> quoteHandle; // the handler
quoteHandle.linkTo(boost::shared_ptr<QuantLib::Quote>( // link to the quote
new QuantLib::SimpleQuote(quote[i])));
boost::shared_ptr<QuantLib::BondHelper> noteHelper( // the helper
new QuantLib::BondHelper(quoteHandle, instrumentPtr));
instrumentsObject.push_back(noteHelper); // helper storage
}
} catch (...) {} // nothing on exception
}
ObjectHandler::ConvertOper oper2(* settlementDate_); // settlement date
QuantLib::Date settlementDate(oper2.missing() ?
instrumentsObject[0]->bond()->settlementDate(evaluationDate) :
static_cast<QuantLib::Date>(oper2));
OH_GET_OBJECT(fittingMethodTemp, // fitting method selection
fittingMethodID_,
ObjectHandler::Object)
std::string returnValue;
if (fittingMethodTemp->properties()->className() // svensson ?
== "stochasticFittingValueObject") {
OH_GET_REFERENCE(fittingMethodPtr,
fittingMethodID_,
QuantLibAddin::stochasticFittingObject,
QuantLib::stochasticFittingHelper)
// build the value object
boost::shared_ptr<QuantLibAddin::ValueObjects::fittedBondDiscountCurveValueObject> curveValueObject(
new QuantLibAddin::ValueObjects::fittedBondDiscountCurveValueObject(
objectID_,
settlementDate.serialNumber(),
true));
boost::shared_ptr<ObjectHandler::Object> myCurve( // instanciating the curve
new QuantLibAddin::fittedBondDiscountCurveObject(
curveValueObject,
settlementDate,
myRule.select(instrumentsObject, settlementDate),
* fittingMethodPtr->fittingMethod(),
fittingMethodPtr->initialVector(),
fittingMethodPtr->randomMatrix(),
fittingMethodPtr->accuracy(),
fittingMethodPtr->maxEvaluationPercycle(),
fittingMethodPtr->cyclesPerThread(),
fittingMethodPtr->cycles(),
1.000, // simplex lambda
true)) ;
returnValue = // the value to return
ObjectHandler::RepositoryXL::instance().storeObject(objectID_,
myCurve ,
true );
}
static char ret[XL_MAX_STR_LEN];
ObjectHandler::stringToChar(returnValue, ret);
return ret;
} catch (std::exception & e) {
static char ret[XL_MAX_STR_LEN];
ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);
ObjectHandler::stringToChar(std::string(e.what()), ret);
return ret;
}
};
