std::string qlZeroCouponBond(
const std::string &ObjectId,
const ObjectHandler::property_t &Description,
const std::string &Currency,
const long &SettlementDays,
const std::string &Calendar,
const ObjectHandler::property_t &FaceAmount,
const ObjectHandler::property_t &Maturity,
const ObjectHandler::property_t &PaymentBDC,
const ObjectHandler::property_t &Redemption,
const ObjectHandler::property_t &IssueDate,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
std::string DescriptionCpp = ObjectHandler::convert2<std::string>(
Description, "Description", std::string());
double FaceAmountCpp = ObjectHandler::convert2<double>(
FaceAmount, "FaceAmount", 100.0);
std::string PaymentBDCCpp = ObjectHandler::convert2<std::string>(
PaymentBDC, "PaymentBDC", "Following");
double RedemptionCpp = ObjectHandler::convert2<double>(
Redemption, "Redemption", 100);
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Size SettlementDaysLib;
QuantLibAddin::cppToLibrary(SettlementDays, SettlementDaysLib);
QuantLib::Real FaceAmountLib = ObjectHandler::convert2<QuantLib::Real>(
FaceAmount, "FaceAmount", 100.0);
QuantLib::Date MaturityLib = ObjectHandler::convert2<QuantLib::Date>(
Maturity, "Maturity");
QuantLib::Real RedemptionLib = ObjectHandler::convert2<QuantLib::Real>(
Redemption, "Redemption", 100);
QuantLib::Date IssueDateLib = ObjectHandler::convert2<QuantLib::Date>(
IssueDate, "IssueDate", QuantLib::Date());
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Currency CurrencyEnum =
ObjectHandler::Create<QuantLib::Currency>()(Currency);
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(Calendar);
QuantLib::BusinessDayConvention PaymentBDCEnum =
ObjectHandler::Create<QuantLib::BusinessDayConvention>()(PaymentBDCCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlZeroCouponBond(
ObjectId,
DescriptionCpp,
Currency,
SettlementDays,
Calendar,
FaceAmountCpp,
Maturity,
PaymentBDCCpp,
RedemptionCpp,
IssueDate,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::ZeroCouponBond(
valueObject,
DescriptionCpp,
CurrencyEnum,
SettlementDaysLib,
CalendarEnum,
FaceAmountLib,
MaturityLib,
PaymentBDCEnum,
RedemptionLib,
IssueDateLib,
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 qlZeroCouponBond : " << e.what());
}
}
XLL_DEC char *qlPiecewiseConstantAbcdVariance(
char *ObjectId,
OPER *A,
OPER *B,
OPER *C,
OPER *D,
long *ResetIndex,
OPER *RateTimes,
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("qlPiecewiseConstantAbcdVariance"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
double ACpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*A), "A", -0.06);
double BCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*B), "B", 0.17);
double CCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*C), "C", 0.54);
double DCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*D), "D", 0.17);
std::vector<double> RateTimesCpp =
ObjectHandler::operToVector<double>(*RateTimes, "RateTimes");
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// 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 QuantLibAddin::ValueObjects::qlPiecewiseConstantAbcdVariance(
ObjectIdStrip,
ACpp,
BCpp,
CCpp,
DCpp,
*ResetIndex,
RateTimesCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::PiecewiseConstantAbcdVariance(
valueObject,
ACpp,
BCpp,
CCpp,
DCpp,
*ResetIndex,
RateTimesCpp,
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;
}
}
std::string qlFlatHazardRate(
const std::string &ObjectId,
const ObjectHandler::property_t &NDays,
const ObjectHandler::property_t &Calendar,
const ObjectHandler::property_t &Rate,
const ObjectHandler::property_t &DayCounter,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
long NDaysCpp = ObjectHandler::convert2<long>(
NDays, "NDays", 0);
std::string CalendarCpp = ObjectHandler::convert2<std::string>(
Calendar, "Calendar", "NullCalendar");
std::string DayCounterCpp = ObjectHandler::convert2<std::string>(
DayCounter, "DayCounter", "Actual/365 (Fixed)");
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Size NDaysLib = ObjectHandler::convert2<QuantLib::Size>(
NDays, "NDays", 0);
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(CalendarCpp);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// convert object IDs into library objects
QuantLib::Handle<QuantLib::Quote> RateLibObj =
ObjectHandler::convert2<QuantLib::Handle<QuantLib::Quote> >(
Rate, "Rate");
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlFlatHazardRate(
ObjectId,
NDaysCpp,
CalendarCpp,
Rate,
DayCounterCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::FlatHazardRate(
valueObject,
NDaysLib,
CalendarEnum,
RateLibObj,
DayCounterEnum,
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 qlFlatHazardRate : " << e.what());
}
}
SEQSEQ(ANY) SAL_CALL CalcAddins_impl::qlMakeCapFloor(
const ANY &ObjectId,
const ANY &OptionType,
const ANY &Length,
const ANY &IborIndex,
const ANY &Strike,
const ANY &ForwardStart,
const ANY &PricingEngineID,
const sal_Int32 Permanent,
const ANY &Trigger,
const sal_Int32 Overwrite) throw(RuntimeException) {
try {
// convert input datatypes to C++ datatypes
std::string ObjectIdCpp;
calcToScalar(ObjectIdCpp, ObjectId);
std::string OptionTypeCpp;
calcToScalar(OptionTypeCpp, OptionType);
std::string LengthCpp;
calcToScalar(LengthCpp, Length);
std::string IborIndexCpp;
calcToScalar(IborIndexCpp, IborIndex);
double StrikeCpp;
if(Strike.hasValue())
calcToScalar(StrikeCpp, Strike);
else
StrikeCpp = QuantLib::Null<QuantLib::Rate>();
std::string ForwardStartCpp;
calcToScalar(ForwardStartCpp, ForwardStart);
std::string PricingEngineIDCpp;
calcToScalar(PricingEngineIDCpp, PricingEngineID);
bool PermanentCpp;
calcToScalar(PermanentCpp, Permanent);
// convert input datatypes to QuantLib datatypes
QuantLib::Period LengthLib;
calcToScalar(LengthLib, Length);
QuantLib::Period ForwardStartLib;
calcToScalar(ForwardStartLib, ForwardStart);
// convert object IDs into library objects
OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndexCpp,
QuantLibAddin::IborIndex, QuantLib::IborIndex)
OH_GET_REFERENCE(PricingEngineIDLibObjPtr, PricingEngineIDCpp,
QuantLibAddin::PricingEngine, QuantLib::PricingEngine)
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::CapFloor::Type OptionTypeEnum =
ObjectHandler::Create<QuantLib::CapFloor::Type>()(OptionTypeCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlMakeCapFloor(
ObjectIdCpp,
OptionTypeCpp,
LengthCpp,
IborIndexCpp,
StrikeCpp,
ForwardStartCpp,
PricingEngineIDCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::CapFloor(
valueObject,
OptionTypeEnum,
LengthLib,
IborIndexLibObjPtr,
StrikeCpp,
ForwardStartLib,
PricingEngineIDLibObjPtr,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite, valueObject);
// Convert and return the return value
ANY returnValueCalc;
scalarToCalc(returnValueCalc, returnValue);
SEQSEQ(ANY) retAnyArray;
retAnyArray.realloc(1);
SEQ(ANY) retAnyVector(1);
retAnyVector[0] = returnValueCalc;
retAnyArray[0] = retAnyVector;
return retAnyArray;
} catch (const std::exception &e) {
do {
std::ostringstream errorMsg;
errorMsg << "ERROR: qlMakeCapFloor: " << e.what();
OH_LOG_MESSAGE(errorMsg.str());
SEQSEQ(ANY) retAnyArray;
retAnyArray.realloc(1);
SEQ(ANY) retAnyVector(1);
STRING s = STRFROMASCII( errorMsg.str().c_str() );
retAnyVector[0] = CSS::uno::makeAny( s );
retAnyArray[0] = retAnyVector;
return retAnyArray;
} while (false);
}
}
SEQSEQ(ANY) SAL_CALL CalcAddins_impl::qlIborIndex(
const ANY &ObjectId,
const ANY &FamilyName,
const ANY &Tenor,
const ANY &FixingDays,
const ANY &Currency,
const ANY &Calendar,
const ANY &BDayConvention,
const sal_Int32 EndOfMonth,
const ANY &DayCounter,
const ANY &FwdCurve,
const sal_Int32 Permanent,
const ANY &Trigger,
const sal_Int32 Overwrite) throw(RuntimeException) {
try {
// convert input datatypes to C++ datatypes
std::string ObjectIdCpp;
calcToScalar(ObjectIdCpp, ObjectId);
std::string FamilyNameCpp;
calcToScalar(FamilyNameCpp, FamilyName);
std::string TenorCpp;
calcToScalar(TenorCpp, Tenor);
long FixingDaysCpp;
calcToScalar(FixingDaysCpp, FixingDays);
std::string CurrencyCpp;
calcToScalar(CurrencyCpp, Currency);
std::string CalendarCpp;
calcToScalar(CalendarCpp, Calendar);
std::string BDayConventionCpp;
calcToScalar(BDayConventionCpp, BDayConvention);
bool EndOfMonthCpp;
calcToScalar(EndOfMonthCpp, EndOfMonth);
std::string DayCounterCpp;
calcToScalar(DayCounterCpp, DayCounter);
std::string FwdCurveCpp;
if(FwdCurve.hasValue())
calcToScalar(FwdCurveCpp, FwdCurve);
else
FwdCurveCpp = "";
bool PermanentCpp;
calcToScalar(PermanentCpp, Permanent);
// convert input datatypes to QuantLib datatypes
QuantLib::Period TenorLib;
calcToScalar(TenorLib, Tenor);
QuantLib::Natural FixingDaysLib;
calcToScalar(FixingDaysLib, FixingDays);
// convert object IDs into library objects
OH_GET_OBJECT_DEFAULT(FwdCurveCoerce, FwdCurveCpp, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> FwdCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
FwdCurveCoerce, QuantLib::Handle<QuantLib::YieldTermStructure>());
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Currency CurrencyEnum =
ObjectHandler::Create<QuantLib::Currency>()(CurrencyCpp);
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(CalendarCpp);
QuantLib::BusinessDayConvention BDayConventionEnum =
ObjectHandler::Create<QuantLib::BusinessDayConvention>()(BDayConventionCpp);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlIborIndex(
ObjectIdCpp,
FamilyNameCpp,
TenorCpp,
FixingDaysCpp,
CurrencyCpp,
CalendarCpp,
BDayConventionCpp,
EndOfMonthCpp,
DayCounterCpp,
FwdCurveCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::IborIndex(
valueObject,
FamilyNameCpp,
TenorLib,
FixingDaysLib,
CurrencyEnum,
CalendarEnum,
BDayConventionEnum,
EndOfMonthCpp,
DayCounterEnum,
FwdCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite, valueObject);
// Convert and return the return value
ANY returnValueCalc;
scalarToCalc(returnValueCalc, returnValue);
SEQSEQ(ANY) retAnyArray;
retAnyArray.realloc(1);
SEQ(ANY) retAnyVector(1);
retAnyVector[0] = returnValueCalc;
retAnyArray[0] = retAnyVector;
return retAnyArray;
} catch (const std::exception &e) {
do {
std::ostringstream errorMsg;
errorMsg << "ERROR: qlIborIndex: " << e.what();
OH_LOG_MESSAGE(errorMsg.str());
SEQSEQ(ANY) retAnyArray;
retAnyArray.realloc(1);
SEQ(ANY) retAnyVector(1);
STRING s = STRFROMASCII( errorMsg.str().c_str() );
retAnyVector[0] = CSS::uno::makeAny( s );
retAnyArray[0] = retAnyVector;
return retAnyArray;
} while (false);
}
}
std::string CALForwardRateIpc(
const std::string &ObjectId,
const std::string &MarketModel,
const std::string &BrownianGeneratorFactory,
const std::vector<long>& Numeraires,
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::Size> NumerairesLib =
QuantLibAddin::convertVector<long, QuantLib::Size>(Numeraires);
// convert object IDs into library objects
OH_GET_REFERENCE(MarketModelLibObjPtr, MarketModel,
QuantLibAddin::MarketModel, QuantLib::MarketModel)
OH_GET_UNDERLYING(BrownianGeneratorFactoryLibObj, BrownianGeneratorFactory,
QuantLibAddin::BrownianGeneratorFactory, QuantLib::BrownianGeneratorFactory)
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::CALForwardRateIpc(
ObjectId,
MarketModel,
BrownianGeneratorFactory,
Numeraires,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::LogNormalFwdRateIpc(
valueObject,
MarketModelLibObjPtr,
BrownianGeneratorFactoryLibObj,
NumerairesLib,
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 CALForwardRateIpc : " << e.what());
}
}
XLL_DEC char *qlMakeDatedOIS(
char *ObjectId,
OPER *StartDate,
OPER *EndDate,
char *OvernightIndex,
OPER *FixedRate,
OPER *FixDayCounter,
OPER *Spread,
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("qlMakeDatedOIS"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
ObjectHandler::property_t StartDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*StartDate));
ObjectHandler::property_t EndDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*EndDate));
double FixedRateCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*FixedRate), "FixedRate", QuantLib::Null<QuantLib::Rate>());
std::string FixDayCounterCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*FixDayCounter), "FixDayCounter", "Actual/360");
double SpreadCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Spread), "Spread", 0.0);
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date StartDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*StartDate), "StartDate", QuantLib::Date());
QuantLib::Date EndDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*EndDate), "EndDate", QuantLib::Date());
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::DayCounter FixDayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(FixDayCounterCpp);
// convert object IDs into library objects
OH_GET_REFERENCE(OvernightIndexLibObjPtr, OvernightIndex,
QuantLibAddin::OvernightIndex, QuantLib::OvernightIndex)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string OvernightIndexStrip = ObjectHandler::CallingRange::getStub(OvernightIndex);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlMakeDatedOIS(
ObjectIdStrip,
StartDateCpp,
EndDateCpp,
OvernightIndexStrip,
FixedRateCpp,
FixDayCounterCpp,
SpreadCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::OvernightIndexedSwap(
valueObject,
StartDateLib,
EndDateLib,
OvernightIndexLibObjPtr,
FixedRateCpp,
FixDayCounterEnum,
SpreadCpp,
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;
}
}
XLL_DEC char *qlRangeAccrualPricerByBgm(
char *ObjectId,
double *Correlation,
char *SmileOnStartDateID,
char *SmileOnEndDateID,
bool *WithSmile,
bool *ByCallSpread,
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("qlRangeAccrualPricerByBgm"));
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_REFERENCE(SmileOnStartDateIDLibObjPtr, SmileOnStartDateID,
QuantLibAddin::SmileSection, QuantLib::SmileSection)
OH_GET_REFERENCE(SmileOnEndDateIDLibObjPtr, SmileOnEndDateID,
QuantLibAddin::SmileSection, QuantLib::SmileSection)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string SmileOnStartDateIDStrip = ObjectHandler::CallingRange::getStub(SmileOnStartDateID);
std::string SmileOnEndDateIDStrip = ObjectHandler::CallingRange::getStub(SmileOnEndDateID);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlRangeAccrualPricerByBgm(
ObjectIdStrip,
*Correlation,
SmileOnStartDateIDStrip,
SmileOnEndDateIDStrip,
*WithSmile,
*ByCallSpread,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::RangeAccrualPricerByBgm(
valueObject,
*Correlation,
SmileOnStartDateIDLibObjPtr,
SmileOnEndDateIDLibObjPtr,
*WithSmile,
*ByCallSpread,
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;
}
}
XLL_DEC char *qlSMMDriftCalculator(
char *ObjectId,
FP *Pseudo_square_root,
OPER *Displacements,
OPER *Taus,
long *Numeraire,
long *Alive,
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("qlSMMDriftCalculator"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
std::vector<std::vector<double> > Pseudo_square_rootCpp =
ObjectHandler::fpToMatrix<double>(*Pseudo_square_root);
std::vector<double> DisplacementsCpp =
ObjectHandler::operToVector<double>(*Displacements, "Displacements");
std::vector<double> TausCpp =
ObjectHandler::operToVector<double>(*Taus, "Taus");
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Matrix Pseudo_square_rootLib =
QuantLibXL::operToQlMatrix(*Pseudo_square_root);
QuantLib::Size NumeraireLib;
QuantLibAddin::cppToLibrary(*Numeraire, NumeraireLib);
QuantLib::Size AliveLib;
QuantLibAddin::cppToLibrary(*Alive, AliveLib);
// 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 QuantLibAddin::ValueObjects::qlSMMDriftCalculator(
ObjectIdStrip,
Pseudo_square_rootCpp,
DisplacementsCpp,
TausCpp,
*Numeraire,
*Alive,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::SMMDriftCalculator(
valueObject,
Pseudo_square_rootLib,
DisplacementsCpp,
TausCpp,
NumeraireLib,
AliveLib,
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;
}
}
XLL_DEC char *qlRangeAccrualFloatersCouponFromLeg(
char *ObjectId,
char *RangeAccrualLeg,
long *Position,
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("qlRangeAccrualFloatersCouponFromLeg"));
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 input datatypes to QuantLib datatypes
QuantLib::Size PositionLib;
QuantLibAddin::cppToLibrary(*Position, PositionLib);
// convert object IDs into library objects
OH_GET_UNDERLYING(RangeAccrualLegLibObj, RangeAccrualLeg,
QuantLibAddin::Leg, QuantLib::Leg)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string RangeAccrualLegStrip = ObjectHandler::CallingRange::getStub(RangeAccrualLeg);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlRangeAccrualFloatersCouponFromLeg(
ObjectIdStrip,
RangeAccrualLegStrip,
*Position,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::RangeAccrualFloatersCoupon(
valueObject,
RangeAccrualLegLibObj,
PositionLib,
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;
}
}
XLL_DEC char *qlRangeAccrualFloatersCoupon(
char *ObjectId,
double *Nominal,
OPER *PaymentDate,
char *IborIndex,
OPER *StartDate,
OPER *EndDate,
long *FixingDays,
char *DayCountID,
double *Gearings,
double *Spreads,
OPER *RefPeriodStart,
OPER *RefPeriodEnd,
char *ObserSchedID,
double *LowerTrigger,
double *UpperTrigger,
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("qlRangeAccrualFloatersCoupon"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
ObjectHandler::property_t PaymentDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*PaymentDate));
ObjectHandler::property_t StartDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*StartDate));
ObjectHandler::property_t EndDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*EndDate));
ObjectHandler::property_t RefPeriodStartCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*RefPeriodStart));
ObjectHandler::property_t RefPeriodEndCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*RefPeriodEnd));
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date PaymentDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*PaymentDate), "PaymentDate");
QuantLib::Date StartDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*StartDate), "StartDate");
QuantLib::Date EndDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*EndDate), "EndDate");
QuantLib::Date RefPeriodStartLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*RefPeriodStart), "RefPeriodStart");
QuantLib::Date RefPeriodEndLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*RefPeriodEnd), "RefPeriodEnd");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::DayCounter DayCountIDEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCountID);
// convert object IDs into library objects
OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,
QuantLibAddin::IborIndex, QuantLib::IborIndex)
OH_GET_REFERENCE(ObserSchedIDLibObjPtr, ObserSchedID,
QuantLibAddin::Schedule, QuantLib::Schedule)
// 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 ObserSchedIDStrip = ObjectHandler::CallingRange::getStub(ObserSchedID);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlRangeAccrualFloatersCoupon(
ObjectIdStrip,
*Nominal,
PaymentDateCpp,
IborIndexStrip,
StartDateCpp,
EndDateCpp,
*FixingDays,
DayCountID,
*Gearings,
*Spreads,
RefPeriodStartCpp,
RefPeriodEndCpp,
ObserSchedIDStrip,
*LowerTrigger,
*UpperTrigger,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::RangeAccrualFloatersCoupon(
valueObject,
*Nominal,
PaymentDateLib,
IborIndexLibObjPtr,
StartDateLib,
EndDateLib,
*FixingDays,
DayCountIDEnum,
*Gearings,
*Spreads,
RefPeriodStartLib,
RefPeriodEndLib,
ObserSchedIDLibObjPtr,
*LowerTrigger,
*UpperTrigger,
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;
}
}
XLL_DEC char *qlSabrSmileSection(
char *ObjectId,
double *OptionTime,
OPER *Strikes,
OPER *StdDevs,
OPER *Forward,
OPER *Alpha,
OPER *Beta,
OPER *Nu,
OPER *Rho,
OPER *AlphaIsFixed,
OPER *BetaIsFixed,
OPER *NuIsFixed,
OPER *RhoIsFixed,
OPER *VegaWeighted,
OPER *EndCriteria,
OPER *Method,
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("qlSabrSmileSection"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
std::vector<double> StrikesCpp =
ObjectHandler::operToVector<double>(*Strikes, "Strikes");
std::vector<ObjectHandler::property_t> StdDevsCpp =
ObjectHandler::operToVector<ObjectHandler::property_t>(*StdDevs, "StdDevs");
ObjectHandler::property_t ForwardCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*Forward));
double AlphaCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Alpha), "Alpha", QuantLib::Null<QuantLib::Real>());
double BetaCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Beta), "Beta", QuantLib::Null<QuantLib::Real>());
double NuCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Nu), "Nu", QuantLib::Null<QuantLib::Real>());
double RhoCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Rho), "Rho", QuantLib::Null<QuantLib::Real>());
bool AlphaIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*AlphaIsFixed), "AlphaIsFixed", false);
bool BetaIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*BetaIsFixed), "BetaIsFixed", false);
bool NuIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*NuIsFixed), "NuIsFixed", false);
bool RhoIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*RhoIsFixed), "RhoIsFixed", false);
bool VegaWeightedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*VegaWeighted), "VegaWeighted", false);
std::string EndCriteriaCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*EndCriteria), "EndCriteria", "");
std::string MethodCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*Method), "Method", "");
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert object IDs into library objects
std::vector<QuantLib::Handle<QuantLib::Quote> > StdDevsLibObj =
ObjectHandler::operToVector<QuantLib::Handle<QuantLib::Quote> >(*StdDevs, "StdDevs");
QuantLib::Handle<QuantLib::Quote> ForwardLibObj =
ObjectHandler::convert2<QuantLib::Handle<QuantLib::Quote> >(
ObjectHandler::ConvertOper(*Forward), "Forward");
OH_GET_REFERENCE_DEFAULT(EndCriteriaLibObjPtr, EndCriteriaCpp,
QuantLibAddin::EndCriteria, QuantLib::EndCriteria)
OH_GET_REFERENCE_DEFAULT(MethodLibObjPtr, MethodCpp,
QuantLibAddin::OptimizationMethod, QuantLib::OptimizationMethod)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string EndCriteriaStrip = ObjectHandler::CallingRange::getStub(EndCriteriaCpp);
std::string MethodStrip = ObjectHandler::CallingRange::getStub(MethodCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlSabrSmileSection(
ObjectIdStrip,
*OptionTime,
StrikesCpp,
StdDevsCpp,
ForwardCpp,
AlphaCpp,
BetaCpp,
NuCpp,
RhoCpp,
AlphaIsFixedCpp,
BetaIsFixedCpp,
NuIsFixedCpp,
RhoIsFixedCpp,
VegaWeightedCpp,
EndCriteriaCpp,
MethodCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::SabrSmileSection(
valueObject,
*OptionTime,
StrikesCpp,
StdDevsLibObj,
ForwardLibObj,
AlphaCpp,
BetaCpp,
NuCpp,
RhoCpp,
AlphaIsFixedCpp,
BetaIsFixedCpp,
NuIsFixedCpp,
RhoIsFixedCpp,
VegaWeightedCpp,
EndCriteriaLibObjPtr,
MethodLibObjPtr,
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;
}
}
XLL_DEC char *qlFlatSmileSection(
char *ObjectId,
OPER *OptionDate,
double *Volatility,
OPER *DayCounter,
OPER *RefDate,
double *AtmValue,
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("qlFlatSmileSection"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
ObjectHandler::property_t OptionDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*OptionDate));
std::string DayCounterCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*DayCounter), "DayCounter", "Actual/365 (Fixed)");
ObjectHandler::property_t RefDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*RefDate));
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date OptionDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*OptionDate), "OptionDate");
QuantLib::Date RefDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*RefDate), "RefDate");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// 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 QuantLibAddin::ValueObjects::qlFlatSmileSection(
ObjectIdStrip,
OptionDateCpp,
*Volatility,
DayCounterCpp,
RefDateCpp,
*AtmValue,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::FlatSmileSection(
valueObject,
OptionDateLib,
*Volatility,
DayCounterEnum,
RefDateLib,
*AtmValue,
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;
}
}
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;
}
}
std::string CALBarrierOption(
const std::string &ObjectId,
const std::string &BarrierType,
const double &Barrier,
const double &Rebate,
const std::string &Payoff,
const std::string &Exercise,
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 enumerated datatypes
QuantLib::Barrier::Type BarrierTypeEnum =
ObjectHandler::Create<QuantLib::Barrier::Type>()(BarrierType);
// convert object IDs into library objects
OH_GET_REFERENCE(PayoffLibObjPtr, Payoff,
QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)
OH_GET_REFERENCE(ExerciseLibObjPtr, Exercise,
QuantLibAddin::Exercise, QuantLib::Exercise)
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::CALBarrierOption(
ObjectId,
BarrierType,
Barrier,
Rebate,
Payoff,
Exercise,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::BarrierOption(
valueObject,
BarrierTypeEnum,
Barrier,
Rebate,
PayoffLibObjPtr,
ExerciseLibObjPtr,
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 CALBarrierOption : " << e.what());
}
}
XLL_DEC char *qlGeneralizedBlackScholesProcess(
char *ObjectId,
char *BlackVolID,
double *Underlying,
OPER *DayCounter,
OPER *SettlementDate,
double *RiskFreeRate,
double *DividendYield,
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("qlGeneralizedBlackScholesProcess"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
std::string DayCounterCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*DayCounter), "DayCounter", "Actual/365 (Fixed)");
ObjectHandler::property_t SettlementDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*SettlementDate));
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date SettlementDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*SettlementDate), "SettlementDate");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// convert object IDs into library objects
OH_GET_REFERENCE(BlackVolIDLibObjPtr, BlackVolID,
QuantLibAddin::BlackVolTermStructure, QuantLib::BlackVolTermStructure)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string BlackVolIDStrip = ObjectHandler::CallingRange::getStub(BlackVolID);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlGeneralizedBlackScholesProcess(
ObjectIdStrip,
BlackVolIDStrip,
*Underlying,
DayCounterCpp,
SettlementDateCpp,
*RiskFreeRate,
*DividendYield,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::GeneralizedBlackScholesProcess(
valueObject,
BlackVolIDLibObjPtr,
*Underlying,
DayCounterEnum,
SettlementDateLib,
*RiskFreeRate,
*DividendYield,
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;
}
}
std::string CALQuantoForwardVanillaOption(
const std::string &ObjectId,
const double &Moneyness,
const ObjectHandler::property_t &ResetDate,
const std::string &Payoff,
const std::string &Exercise,
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
QuantLib::Date ResetDateLib = ObjectHandler::convert2<QuantLib::Date>(
ResetDate, "ResetDate");
// convert object IDs into library objects
OH_GET_REFERENCE(PayoffLibObjPtr, Payoff,
QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)
OH_GET_REFERENCE(ExerciseLibObjPtr, Exercise,
QuantLibAddin::Exercise, QuantLib::Exercise)
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::CALQuantoForwardVanillaOption(
ObjectId,
Moneyness,
ResetDate,
Payoff,
Exercise,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::QuantoForwardVanillaOption(
valueObject,
Moneyness,
ResetDateLib,
PayoffLibObjPtr,
ExerciseLibObjPtr,
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 CALQuantoForwardVanillaOption : " << e.what());
}
}
XLL_DEC char *qlAbcdCalibration(
char *ObjectId,
OPER *Times,
OPER *BlackVols,
OPER *A,
OPER *B,
OPER *C,
OPER *D,
OPER *AIsFixed,
OPER *BIsFixed,
OPER *CIsFixed,
OPER *DIsFixed,
OPER *VegaWeighted,
OPER *EndCriteria,
OPER *Method,
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("qlAbcdCalibration"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
std::vector<double> TimesCpp =
ObjectHandler::operToVector<double>(*Times, "Times");
std::vector<double> BlackVolsCpp =
ObjectHandler::operToVector<double>(*BlackVols, "BlackVols");
double ACpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*A), "A", -0.06);
double BCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*B), "B", 0.17);
double CCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*C), "C", 0.54);
double DCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*D), "D", 0.17);
bool AIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*AIsFixed), "AIsFixed", false);
bool BIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*BIsFixed), "BIsFixed", false);
bool CIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*CIsFixed), "CIsFixed", false);
bool DIsFixedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*DIsFixed), "DIsFixed", false);
bool VegaWeightedCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*VegaWeighted), "VegaWeighted", false);
std::string EndCriteriaCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*EndCriteria), "EndCriteria", "");
std::string MethodCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*Method), "Method", "");
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert object IDs into library objects
OH_GET_REFERENCE_DEFAULT(EndCriteriaLibObjPtr, EndCriteriaCpp,
QuantLibAddin::EndCriteria, QuantLib::EndCriteria)
OH_GET_REFERENCE_DEFAULT(MethodLibObjPtr, MethodCpp,
QuantLibAddin::OptimizationMethod, QuantLib::OptimizationMethod)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string EndCriteriaStrip = ObjectHandler::CallingRange::getStub(EndCriteriaCpp);
std::string MethodStrip = ObjectHandler::CallingRange::getStub(MethodCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlAbcdCalibration(
ObjectIdStrip,
TimesCpp,
BlackVolsCpp,
ACpp,
BCpp,
CCpp,
DCpp,
AIsFixedCpp,
BIsFixedCpp,
CIsFixedCpp,
DIsFixedCpp,
VegaWeightedCpp,
EndCriteriaCpp,
MethodCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::AbcdCalibration(
valueObject,
TimesCpp,
BlackVolsCpp,
ACpp,
BCpp,
CCpp,
DCpp,
AIsFixedCpp,
BIsFixedCpp,
CIsFixedCpp,
DIsFixedCpp,
VegaWeightedCpp,
EndCriteriaLibObjPtr,
MethodLibObjPtr,
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;
}
}
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;
}
}
std::string CALMakeCapFloor(
const std::string &ObjectId,
const std::string &OptionType,
const std::string &Length,
const std::string &IborIndex,
const ObjectHandler::property_t &Strike,
const std::string &ForwardStart,
const std::string &PricingEngineID,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
double StrikeCpp = ObjectHandler::convert2<double>(
Strike, "Strike", QuantLib::Null<QuantLib::Rate>());
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Period LengthLib;
QuantLibAddin::cppToLibrary(Length, LengthLib);
QuantLib::Period ForwardStartLib;
QuantLibAddin::cppToLibrary(ForwardStart, ForwardStartLib);
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::CapFloor::Type OptionTypeEnum =
ObjectHandler::Create<QuantLib::CapFloor::Type>()(OptionType);
// convert object IDs into library objects
OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,
QuantLibAddin::IborIndex, QuantLib::IborIndex)
OH_GET_REFERENCE(PricingEngineIDLibObjPtr, PricingEngineID,
QuantLibAddin::PricingEngine, QuantLib::PricingEngine)
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::CALMakeCapFloor(
ObjectId,
OptionType,
Length,
IborIndex,
StrikeCpp,
ForwardStart,
PricingEngineID,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::CapFloor(
valueObject,
OptionTypeEnum,
LengthLib,
IborIndexLibObjPtr,
StrikeCpp,
ForwardStartLib,
PricingEngineIDLibObjPtr,
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 CALMakeCapFloor : " << e.what());
}
}
XLL_DEC char *qlOvernightIndexedSwapFromOISRateHelper(
char *ObjectId,
char *OISRateHelper,
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("qlOvernightIndexedSwapFromOISRateHelper"));
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_REFERENCE(OISRateHelperLibObjPtr, OISRateHelper,
QuantLibAddin::OISRateHelper, QuantLib::OISRateHelper)
// Strip the Excel cell update counter suffix from Object IDs
std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);
std::string OISRateHelperStrip = ObjectHandler::CallingRange::getStub(OISRateHelper);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlOvernightIndexedSwapFromOISRateHelper(
ObjectIdStrip,
OISRateHelperStrip,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::OvernightIndexedSwap(
valueObject,
OISRateHelperLibObjPtr,
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 *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()
}
XLL_DEC char *qlAmericanExercise(
char *ObjectId,
OPER *EarliestDate,
OPER *LatestDate,
OPER *PayoffAtExpiry,
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("qlAmericanExercise"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
ObjectHandler::property_t EarliestDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*EarliestDate));
ObjectHandler::property_t LatestDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(
ObjectHandler::ConvertOper(*LatestDate));
bool PayoffAtExpiryCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*PayoffAtExpiry), "PayoffAtExpiry", false);
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date EarliestDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*EarliestDate), "EarliestDate");
QuantLib::Date LatestDateLib = ObjectHandler::convert2<QuantLib::Date>(
ObjectHandler::ConvertOper(*LatestDate), "LatestDate");
// 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 QuantLibAddin::ValueObjects::qlAmericanExercise(
ObjectIdStrip,
EarliestDateCpp,
LatestDateCpp,
PayoffAtExpiryCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::AmericanExercise(
valueObject,
EarliestDateLib,
LatestDateLib,
PayoffAtExpiryCpp,
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;
}
}
std::string qlBlackConstantVol(
const std::string &ObjectId,
const ObjectHandler::property_t &SettlementDate,
const std::string &Calendar,
const double &Volatility,
const ObjectHandler::property_t &DayCounter,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
std::string DayCounterCpp = ObjectHandler::convert2<std::string>(
DayCounter, "DayCounter", "Actual/365 (Fixed)");
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Date SettlementDateLib = ObjectHandler::convert2<QuantLib::Date>(
SettlementDate, "SettlementDate");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(Calendar);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlBlackConstantVol(
ObjectId,
SettlementDate,
Calendar,
Volatility,
DayCounterCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::BlackConstantVol(
valueObject,
SettlementDateLib,
CalendarEnum,
Volatility,
DayCounterEnum,
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 qlBlackConstantVol : " << e.what());
}
}
SEQSEQ(ANY) SAL_CALL CalcAddins_impl::qlLibor(
const ANY &ObjectId,
const ANY &Currency,
const ANY &Tenor,
const ANY &YieldCurve,
const sal_Int32 Permanent,
const ANY &Trigger,
const sal_Int32 Overwrite) throw(RuntimeException) {
try {
// convert input datatypes to C++ datatypes
std::string ObjectIdCpp;
calcToScalar(ObjectIdCpp, ObjectId);
std::string CurrencyCpp;
calcToScalar(CurrencyCpp, Currency);
std::string TenorCpp;
calcToScalar(TenorCpp, Tenor);
std::string YieldCurveCpp;
if(YieldCurve.hasValue())
calcToScalar(YieldCurveCpp, YieldCurve);
else
YieldCurveCpp = "";
bool PermanentCpp;
calcToScalar(PermanentCpp, Permanent);
// convert object IDs into library objects
OH_GET_OBJECT_DEFAULT(YieldCurveCoerce, YieldCurveCpp, ObjectHandler::Object)
QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =
QuantLibAddin::CoerceHandle<
QuantLibAddin::YieldTermStructure,
QuantLib::YieldTermStructure>()(
YieldCurveCoerce, QuantLib::Handle<QuantLib::YieldTermStructure>());
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Currency CurrencyEnum =
ObjectHandler::Create<QuantLib::Currency>()(CurrencyCpp);
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlLibor(
ObjectIdCpp,
CurrencyCpp,
TenorCpp,
YieldCurveCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::Libor(
valueObject,
CurrencyEnum,
TenorCpp,
YieldCurveLibObj,
PermanentCpp));
// Store the Object in the Repository
std::string returnValue =
ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite, valueObject);
// Convert and return the return value
ANY returnValueCalc;
scalarToCalc(returnValueCalc, returnValue);
SEQSEQ(ANY) retAnyArray;
retAnyArray.realloc(1);
SEQ(ANY) retAnyVector(1);
retAnyVector[0] = returnValueCalc;
retAnyArray[0] = retAnyVector;
return retAnyArray;
} catch (const std::exception &e) {
do {
std::ostringstream errorMsg;
errorMsg << "ERROR: qlLibor: " << e.what();
OH_LOG_MESSAGE(errorMsg.str());
SEQSEQ(ANY) retAnyArray;
retAnyArray.realloc(1);
SEQ(ANY) retAnyVector(1);
STRING s = STRFROMASCII( errorMsg.str().c_str() );
retAnyVector[0] = CSS::uno::makeAny( s );
retAnyArray[0] = retAnyVector;
return retAnyArray;
} while (false);
}
}
XLL_DEC char *qlPiecewiseYieldCurve(
char *ObjectId,
OPER *NDays,
char *Calendar,
OPER *RateHelpers,
OPER *DayCounter,
OPER *Jumps,
OPER *JumpDates,
OPER *Accuracy,
OPER *TraitsID,
OPER *InterpolatorID,
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("qlPiecewiseYieldCurve"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
long NDaysCpp = ObjectHandler::convert2<long>(
ObjectHandler::ConvertOper(*NDays), "NDays", 0);
std::vector<std::string> RateHelpersCpp =
ObjectHandler::operToVector<std::string>(*RateHelpers, "RateHelpers");
std::string DayCounterCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*DayCounter), "DayCounter", "Actual/365 (Fixed)");
std::vector<ObjectHandler::property_t> JumpsCpp =
ObjectHandler::operToVector<ObjectHandler::property_t>(*Jumps, "Jumps");
std::vector<ObjectHandler::property_t> JumpDatesCpp =
ObjectHandler::operToVector<ObjectHandler::property_t>(*JumpDates, "JumpDates");
double AccuracyCpp = ObjectHandler::convert2<double>(
ObjectHandler::ConvertOper(*Accuracy), "Accuracy", 1.0e-12);
std::string TraitsIDCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*TraitsID), "TraitsID", "Discount");
std::string InterpolatorIDCpp = ObjectHandler::convert2<std::string>(
ObjectHandler::ConvertOper(*InterpolatorID), "InterpolatorID", "LogLinear");
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Natural NDaysLib = ObjectHandler::convert2<QuantLib::Natural>(
ObjectHandler::ConvertOper(*NDays), "NDays", 0);
std::vector<QuantLib::Date> JumpDatesLib =
ObjectHandler::operToVector<QuantLib::Date>(*JumpDates, "JumpDates");
QuantLib::Real AccuracyLib = ObjectHandler::convert2<QuantLib::Real>(
ObjectHandler::ConvertOper(*Accuracy), "Accuracy", 1.0e-12);
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Calendar CalendarEnum =
ObjectHandler::Create<QuantLib::Calendar>()(Calendar);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);
// convert object IDs into library objects
std::vector<boost::shared_ptr<QuantLib::RateHelper> > RateHelpersLibObjPtr =
ObjectHandler::getLibraryObjectVector<QuantLibAddin::RateHelper, QuantLib::RateHelper>(RateHelpersCpp);
std::vector<QuantLib::Handle<QuantLib::Quote> > JumpsLibObj =
ObjectHandler::operToVector<QuantLib::Handle<QuantLib::Quote> >(*Jumps, "Jumps");
// 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 QuantLibAddin::ValueObjects::qlPiecewiseYieldCurve(
ObjectIdStrip,
NDaysCpp,
Calendar,
RateHelpersCpp,
DayCounterCpp,
JumpsCpp,
JumpDatesCpp,
AccuracyCpp,
TraitsIDCpp,
InterpolatorIDCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::PiecewiseYieldCurve(
valueObject,
NDaysLib,
CalendarEnum,
RateHelpersLibObjPtr,
DayCounterEnum,
JumpsLibObj,
JumpDatesLib,
AccuracyLib,
TraitsIDCpp,
InterpolatorIDCpp,
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;
}
}
XLL_DEC char *qlMarketModelLmExtLinearExponentialVolModel(
char *ObjectId,
OPER *FixingTimes,
double *A,
double *B,
double *C,
double *D,
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("qlMarketModelLmExtLinearExponentialVolModel"));
ObjectHandler::validateRange(Trigger, "Trigger");
// initialize the session ID (if enabled)
SET_SESSION_ID
// convert input datatypes to C++ datatypes
std::vector<double> FixingTimesCpp =
ObjectHandler::operToVector<double>(*FixingTimes, "FixingTimes");
bool PermanentCpp = ObjectHandler::convert2<bool>(
ObjectHandler::ConvertOper(*Permanent), "Permanent", false);
// 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 QuantLibAddin::ValueObjects::qlMarketModelLmExtLinearExponentialVolModel(
ObjectIdStrip,
FixingTimesCpp,
*A,
*B,
*C,
*D,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::LmExtLinearExponentialVolModel(
valueObject,
FixingTimesCpp,
*A,
*B,
*C,
*D,
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;
}
}
std::string CALDaAsianOption(
const std::string &ObjectId,
const std::string &AverageType,
const double &RunningAccumulator,
const long &PastFixings,
const std::vector<ObjectHandler::property_t>& FixingDates,
const std::string &Payoff,
const std::string &Exercise,
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
QuantLib::Size PastFixingsLib;
QuantLibAddin::cppToLibrary(PastFixings, PastFixingsLib);
std::vector<QuantLib::Date> FixingDatesLib =
ObjectHandler::vector::convert2<QuantLib::Date>(FixingDates, "FixingDates");
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Average::Type AverageTypeEnum =
ObjectHandler::Create<QuantLib::Average::Type>()(AverageType);
// convert object IDs into library objects
OH_GET_REFERENCE(PayoffLibObjPtr, Payoff,
QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)
OH_GET_REFERENCE(ExerciseLibObjPtr, Exercise,
QuantLibAddin::Exercise, QuantLib::Exercise)
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::CALDaAsianOption(
ObjectId,
AverageType,
RunningAccumulator,
PastFixings,
FixingDates,
Payoff,
Exercise,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::DiscreteAveragingAsianOption(
valueObject,
AverageTypeEnum,
RunningAccumulator,
PastFixingsLib,
FixingDatesLib,
PayoffLibObjPtr,
ExerciseLibObjPtr,
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 CALDaAsianOption : " << e.what());
}
}
STRING SAL_CALL CalcAddins_impl::qlEuribor(
const STRING &ObjectId,
const STRING &Tenor,
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 TenorCpp = ouStringToStlString(Tenor);
std::string YieldCurveCpp;
calcToScalar(YieldCurveCpp, YieldCurve);
bool PermanentCpp;
calcToScalar(PermanentCpp, Permanent);
// convert object IDs into library objects
// RL: Use OH_GET_OBJECT_DEFAULT instead of OH_GET_OBJECT
OH_GET_OBJECT_DEFAULT(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::qlEuribor(
ObjectIdCpp,
TenorCpp,
YieldCurveCpp,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::Euribor(
valueObject,
TenorCpp,
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: qlEuribor: " << e.what());
THROW_RTE;
}
}
std::string qlFloatingRateBond(
const std::string &ObjectId,
const ObjectHandler::property_t &Description,
const std::string &Currency,
const long &SettlementDays,
const ObjectHandler::property_t &PaymentBDC,
const ObjectHandler::property_t &FaceAmount,
const std::string &ScheduleID,
const ObjectHandler::property_t &FixingDays,
const ObjectHandler::property_t &IsInArrears,
const std::string &DayCounter,
const std::vector<double>& Floors,
const std::vector<double>& Gearings,
const std::string &IborIndex,
const std::vector<double>& Spreads,
const std::vector<double>& Caps,
const ObjectHandler::property_t &Redemption,
const ObjectHandler::property_t &IssueDate,
const ObjectHandler::property_t &Permanent,
const ObjectHandler::property_t &Trigger,
const bool &Overwrite) {
try {
// convert input datatypes to C++ datatypes
std::string DescriptionCpp = ObjectHandler::convert2<std::string>(
Description, "Description", std::string());
std::string PaymentBDCCpp = ObjectHandler::convert2<std::string>(
PaymentBDC, "PaymentBDC", "Following");
double FaceAmountCpp = ObjectHandler::convert2<double>(
FaceAmount, "FaceAmount", 100.0);
long FixingDaysCpp = ObjectHandler::convert2<long>(
FixingDays, "FixingDays", QuantLib::Null<QuantLib::Natural>());
bool IsInArrearsCpp = ObjectHandler::convert2<bool>(
IsInArrears, "IsInArrears", false);
double RedemptionCpp = ObjectHandler::convert2<double>(
Redemption, "Redemption", 100);
bool PermanentCpp = ObjectHandler::convert2<bool>(
Permanent, "Permanent", false);
// convert input datatypes to QuantLib datatypes
QuantLib::Size SettlementDaysLib;
QuantLibAddin::cppToLibrary(SettlementDays, SettlementDaysLib);
QuantLib::Real FaceAmountLib = ObjectHandler::convert2<QuantLib::Real>(
FaceAmount, "FaceAmount", 100.0);
QuantLib::Natural FixingDaysLib = ObjectHandler::convert2<long>(
FixingDays, "FixingDays", QuantLib::Null<QuantLib::Natural>());
QuantLib::Real RedemptionLib = ObjectHandler::convert2<QuantLib::Real>(
Redemption, "Redemption", 100);
QuantLib::Date IssueDateLib = ObjectHandler::convert2<QuantLib::Date>(
IssueDate, "IssueDate", QuantLib::Date());
// convert input datatypes to QuantLib enumerated datatypes
QuantLib::Currency CurrencyEnum =
ObjectHandler::Create<QuantLib::Currency>()(Currency);
QuantLib::BusinessDayConvention PaymentBDCEnum =
ObjectHandler::Create<QuantLib::BusinessDayConvention>()(PaymentBDCCpp);
QuantLib::DayCounter DayCounterEnum =
ObjectHandler::Create<QuantLib::DayCounter>()(DayCounter);
// convert object IDs into library objects
OH_GET_REFERENCE(ScheduleIDLibObjPtr, ScheduleID,
QuantLibAddin::Schedule, QuantLib::Schedule)
OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,
QuantLibAddin::IborIndex, QuantLib::IborIndex)
// Construct the Value Object
boost::shared_ptr<ObjectHandler::ValueObject> valueObject(
new QuantLibAddin::ValueObjects::qlFloatingRateBond(
ObjectId,
DescriptionCpp,
Currency,
SettlementDays,
PaymentBDCCpp,
FaceAmountCpp,
ScheduleID,
FixingDaysCpp,
IsInArrearsCpp,
DayCounter,
Floors,
Gearings,
IborIndex,
Spreads,
Caps,
RedemptionCpp,
IssueDate,
PermanentCpp));
// Construct the Object
boost::shared_ptr<ObjectHandler::Object> object(
new QuantLibAddin::FloatingRateBond(
valueObject,
DescriptionCpp,
CurrencyEnum,
SettlementDaysLib,
PaymentBDCEnum,
FaceAmountLib,
ScheduleIDLibObjPtr,
FixingDaysLib,
IsInArrearsCpp,
DayCounterEnum,
Floors,
Gearings,
IborIndexLibObjPtr,
Spreads,
Caps,
RedemptionLib,
IssueDateLib,
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 qlFloatingRateBond : " << e.what());
}
}
