DLLEXPORT int xlAutoClose() {
static XLOPER xDll;
try {
// empty the ObjectHandler repository
//Excel(xlUDF, 0, 1, TempStrNoSize("\x1c""ohRepositoryDeleteAllObjects"));
// unregister the addin functions
Excel(xlGetName, &xDll, 0);
unregisterOhFunctions(xDll);
Excel(xlFree, 0, 1, &xDll);
return 1;
} catch (const std::exception &e) {
Excel(xlFree, 0, 1, &xDll);
std::ostringstream err;
err << "Error unloading ObjectHandler: " << e.what();
Excel(xlcAlert, 0, 1, TempStrStl(err.str()));
return 0;
} catch (...) {
Excel(xlFree, 0, 1, &xDll);
return 0;
}
}
DLLEXPORT int xlAutoOpen() {
static XLOPER xDll;
try {
Excel(xlGetName, &xDll, 0);
ObjectHandler::Configuration::instance().init();
registerOhFunctions(xDll);
Excel(xlFree, 0, 1, &xDll);
return 1;
} catch (const std::exception &e) {
std::ostringstream err;
err << "Error loading ObjectHandler: " << e.what();
Excel(xlcAlert, 0, 1, TempStrStl(err.str()));
Excel(xlFree, 0, 1, &xDll);
return 0;
} catch (...) {
Excel(xlFree, 0, 1, &xDll);
return 0;
}
}
DLLEXPORT int xlAutoClose() {
static XLOPER xDll;
try {
Excel(xlGetName, &xDll, 0);
unregisterOhFunctions(xDll);
Excel(xlFree, 0, 1, &xDll);
return 1;
} catch (const std::exception &e) {
std::ostringstream err;
err << "Error unloading AddinXlHw: " << e.what();
Excel(xlcAlert, 0, 1, TempStrStl(err.str()));
Excel(xlFree, 0, 1, &xDll);
return 0;
} catch (...) {
Excel(xlFree, 0, 1, &xDll);
return 0;
}
}
/*
***************************************************************************
** Standard Excel function to provide the library name to Excel.
***************************************************************************
*/
XLFUNC(LPXLOPER) xlAddInManagerInfo(LPXLOPER xAction)
{
static XLOPER xInfo, xIntAction;
static char xLibName[JPMCDS_MAX_LIB_NAME];
LPXLOPER pxInfo;
/*
** This code coerces the passed-in value to an integer. This is how the
** code determines what is being requested. If it receives a 1,
** it returns a string representing the long name. If it receives
** anything else, it returns a #VALUE! error.
*/
Excel(xlCoerce, &xIntAction, 2, xAction, TempInt(xltypeInt));
if(xIntAction.val.w == 1)
{
xInfo.xltype = xltypeStr;
xLibName[0] = strlen(gtoLibName);
strncpy (xLibName+1, gtoLibName, xLibName[0]);
xInfo.val.str = xLibName;
}
else
{
xInfo.xltype = xltypeErr;
xInfo.val.err = xlerrValue;
}
Excel(xlFree, 0, 1, (LPXLOPER) &xIntAction ,0);
pxInfo = &xInfo;
return pxInfo;
}
DLLEXPORT int xlAutoClose() {
static XLOPER xDll;
try {
Excel(xlGetName, &xDll, 0);
#ifdef XLL_STATIC
// Unregister ObjectHandler functions
unregisterOhFunctions(xDll);
#endif
// Unregister QuantLib functions
unregisterSBSAFunctions(xDll);
// Deallocate the Enumeration Registry
QuantLibAddin::unregisterEnumerations();
Excel(xlFree, 0, 1, &xDll);
return 1;
} catch (const std::exception &e) {
std::ostringstream err;
err << "Error unloading sbsa xll objects: " << e.what();
Excel(xlcAlert, 0, 1, TempStrStl(err.str()));
Excel(xlFree, 0, 1, &xDll);
return 0;
} catch (...) {
Excel(xlFree, 0, 1, &xDll);
return 0;
}
}
void registerPrices(const XLOPER &xDll) {
Excel(xlfRegister, 0, 15, &xDll,
// function code name
TempStrNoSize("\x0F""qlMidEquivalent"),
// parameter codes
TempStrNoSize("\x07""EPPPPP#"),
// function display name
TempStrNoSize("\x0F""qlMidEquivalent"),
// comma-delimited list of parameter names
TempStrNoSize("\x1A""Bid,Ask,Last,Close,Trigger"),
// function type (0 = hidden, 1 = worksheet)
TempStrNoSize("\x01""1"),
// function category
TempStrNoSize("\x14""QuantLib - Financial"),
// shortcut text (command macros only)
TempStrNoSize("\x00"""),
// path to help file
TempStrNoSize("\x00"""),
// function description
TempStrNoSize("\x47""returns the mid price if available, or a suitable substitute otherwise."),
// parameter descriptions
TempStrNoSize("\x1D""bid price. Default value = 0."),
TempStrNoSize("\x1D""ask price. Default value = 0."),
TempStrNoSize("\x1E""last price. Default value = 0."),
TempStrNoSize("\x1F""close price. Default value = 0."),
TempStrNoSize("\x1D""dependency tracking trigger "));
Excel(xlfRegister, 0, 13, &xDll,
// function code name
TempStrNoSize("\x09""qlMidSafe"),
// parameter codes
TempStrNoSize("\x05""EPPP#"),
// function display name
TempStrNoSize("\x09""qlMidSafe"),
// comma-delimited list of parameter names
TempStrNoSize("\x0F""Bid,Ask,Trigger"),
// function type (0 = hidden, 1 = worksheet)
TempStrNoSize("\x01""1"),
// function category
TempStrNoSize("\x14""QuantLib - Financial"),
// shortcut text (command macros only)
TempStrNoSize("\x00"""),
// path to help file
TempStrNoSize("\x00"""),
// function description
TempStrNoSize("\x3D""returns the mid price only if both bid and ask are available."),
// parameter descriptions
TempStrNoSize("\x1D""bid price. Default value = 0."),
TempStrNoSize("\x1D""ask price. Default value = 0."),
TempStrNoSize("\x1D""dependency tracking trigger "));
}
XLL_DEC XLOPER *ohRangeRetrieveError(XLOPER *xRange) {
try {
XLOPER xTemp;
Excel(xlCoerce, &xTemp, 1, xRange);
static XLOPER xRet;
if (xTemp.xltype & xltypeErr)
Excel(xlUDF, &xRet, 2, TempStrNoSize("\x13""ohRetrieveErrorImpl"), xRange);
else
ObjectHandler::scalarToOper(std::string(), xRet);
return &xRet;
} catch (...) {
return 0;
}
}
bool CallingRange::valid() const {
if (callerType_ == CallerType::Cell) {
Xloper xDef, xRef;
Excel(xlfGetName, &xDef, 1, TempStrStl(key_));
std::string address = ConvertOper(xDef());
Excel(xlfTextref, &xRef, 1, TempStrStl(address.substr(1)));
bool ret = (xRef->xltype & (xltypeRef | xltypeSRef)) != 0;
return ret;
} else {
return true;
}
}
inline void unregisterxlInstrumentYield(const XLOPER & xDll) {
XLOPER xlRegID ;
// Libère la fonction xlInstrumentTheoreticalYield
Excel(xlfRegister, 0, 15, & xDll,
TempStrNoSize("\x11""xlInstrumentYield"),
TempStrNoSize("\x07""PCEPCP#"),
TempStrNoSize("\x13""INSTRUMENT.TAUX.NEW"),
TempStrNoSize("\x49""Identifiant de l'instrument,prix,date de règlement,convention,déclencheur"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Bond"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x56""Cette fonction calcule le taux de l'instument selectionné selon la convention désignée"),
TempStrNoSize("\x18""L'instrument à valoriser"),
TempStrNoSize("\x17""Le prix de l'instrument"),
TempStrNoSize("\x14""La date de règlement"),
TempStrNoSize("\x28""L'identifiant de la convention de calcul"),
TempStrNoSize("\x1C""Le déclencheur du recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x11""xlInstrumentYield")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateFixedLegUnitedStates(const XLOPER & xDll) {
XLOPER xlRegID ;
// Enregistre la fonction xlInitiateFixedLeg
Excel(xlfRegister, 0, 20, & xDll,
TempStrNoSize("\x1E""xlInitiateFixedLegUnitedStates"),
TempStrNoSize("\x0C""PCEPPEPEPPP#"),
TempStrNoSize("\x21""INSTANCE.JAMBE.FIXE.UNITED.STATES"),
TempStrNoSize("\xA1""Identifiant de l'instrument,date effective,date de premier coupon,date de dernier coupon,date de maturité,notionel,taux de coupon,fréquence,base annuelle,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x17""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x3A""Cette fonction instancie une jambe fixe de swap en dollar."),
TempStrNoSize("\x19""L'identifiant de la jambe"),
TempStrNoSize("\x2B""La date de début de cumul du premier coupon"),
TempStrNoSize("\x19""La date du premier coupon"),
TempStrNoSize("\x19""La date de dernier coupon"),
TempStrNoSize("\x1F""La date de maturité de la jambe"),
TempStrNoSize("\x16""Le notionel du contrat"),
TempStrNoSize("\x11""Le taux de coupon"),
TempStrNoSize("\x16""La fréquence de coupon"),
TempStrNoSize("\x1C""La base annuelle de la jambe"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x1E""xlInitiateFixedLegUnitedStates")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateTreasuryNote (const XLOPER & xDll) {
XLOPER xlRegID ;
// Enregistre la fonction xlInitiateMatrix
Excel(xlfRegister, 0, 18, & xDll,
TempStrNoSize("\x16""xlInitiateTreasuryNote"),
TempStrNoSize("\x0A""PCEEEEEEP#"),
TempStrNoSize("\x0F""INSTANCE.TNOTE"),
TempStrNoSize("\x83""identifiant de l'instrument,date d'emission,date effective,premier coupon,penultième coupon,date de maturité,taux de coupon,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x17""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x34""Cette fonction instancie une obligation du trésor US"),
TempStrNoSize("\x1D""L'identifiant de l'instrument"),
TempStrNoSize("\x1B""La date d'émission du titre"),
TempStrNoSize("\x2B""La date de début de cumul de premier coupon"),
TempStrNoSize("\x25""La date de paiement du premier coupon"),
TempStrNoSize("\x1C""La date du penultième coupon"),
TempStrNoSize("\x1C""La date de maturité du titre"),
TempStrNoSize("\x21""Le taux de coupon de l'obligation"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x0F""xlInitiateTNote")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInstrumentRollDown(const XLOPER & xDll) {
XLOPER xlRegID ;
Excel(xlfRegister, 0, 16, & xDll,
TempStrNoSize("\x14""xlInstrumentRollDown"),
TempStrNoSize("\x08""PCCEPPP#"),
TempStrNoSize("\x14""INSTRUMENT.ROLL.DOWN"),
TempStrNoSize("\x6E""Identifiant de l'instrument,identifiant de la courbe,date de fin,spread initial,convention de taux,déclencheur"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Bond"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x79""Cette fonction calcule le prix à terme d'un instrument pour un spread et une courbe spot et à un horizon de portage donné"),
TempStrNoSize("\x1D""L'identifiant de l'instrument"),
TempStrNoSize("\x1A""L'identifiant de la courbe"),
TempStrNoSize("\x19""La date de fin de portage"),
TempStrNoSize("\x2B""Le spread de l'instrument en points de base"),
TempStrNoSize("\x27""L'identifiant de la convention employée"),
TempStrNoSize("\x1C""Le déclencheur du recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x14""xlInstrumentRollDown")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInstrumentPrice(const XLOPER & xDll) {
XLOPER xlRegID ;
// release the function registerxlInstrumentPrice
Excel( xlfRegister, 0, 15, &xDll,
TempStrNoSize("\x11""xlInstrumentPrice"),
TempStrNoSize("\x07""PCPEPP#"),
TempStrNoSize("\x0A""BOND.PRICE"),
TempStrNoSize("\x33""identifier,settlement date,yield,convention,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Bond"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x4D""This function computes the bond price from its yield for the given convention"),
TempStrNoSize("\x15""Instrument identifier"),
TempStrNoSize("\x25""instrument settlement date (optional)"),
TempStrNoSize("\x10""instrument yield"),
TempStrNoSize("\x24""rate convention identifer (optional)"),
TempStrNoSize("\x25""Triggers the computation (optional) "));
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x11""xlInstrumentPrice")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateOvernightIndexedBootstrapHelper(const XLOPER & xDll) {
XLOPER xlRegID ;
// unregister the xlInitiateDepositBootstrapHelper function
Excel(xlfRegister, 0, 15, &xDll,
TempStrNoSize("\x29""xlInitiateOvernightIndexedBootstrapHelper"),
TempStrNoSize("\x07""PCCEEP#"),
TempStrNoSize("\x22""OBJECT.CURVE.HELPER.OVERNIGHT.SWAP"),
TempStrNoSize("\x39""object indentifier,index identifier,maturity,rate,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x16""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x40""This function creates an OIS swap helper for curve bootstrapping"),
TempStrNoSize("\x11""Object Identifier"),
TempStrNoSize("\x11""Index indentifier"),
TempStrNoSize("\x19""Maturity date of the swap"),
TempStrNoSize("\x16""Fixed rate of the swap"),
TempStrNoSize("\x19""Trigger for recalculation"));
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x29""xlInitiateOvernightIndexedBootstrapHelper")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateCurveShift(const XLOPER & xDll) {
XLOPER xlRegID ;
// Enregistre la fonction xlInitiateCurveShift
Excel(xlfRegister, 0, 15, & xDll,
TempStrNoSize("\x14""xlInitiateCurveShift"),
TempStrNoSize("\x07""PCPPCP#"),
TempStrNoSize("\x0E""INSTANCE.SHIFT"),
TempStrNoSize("\x4D""identifiant de l'objet,vecteur des gaps,vecteur des shifts,convention,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x1C""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x2B""Cette fonction instancie un shift de courbe"),
TempStrNoSize("\x16""L'identifiant du shift"),
TempStrNoSize("\x1E""Les maturités exprimés en gaps"),
TempStrNoSize("\x1B""Les valeurs de perturbation"),
TempStrNoSize("\x1E""La convention de taux employée"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x26""xlInitiateCurveShift")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateSwaptionHelper(const XLOPER & xDll) {
XLOPER xlRegID ;
// unregister the function xlInitiateSwaptionHelper
Excel(xlfRegister, 0, 22, &xDll,
TempStrNoSize("\x18""xlInitiateSwaptionHelper"),
TempStrNoSize("\x0F""PCEEECCCCCPPPP#"),
TempStrNoSize("\x29""OBJECT.VOLATILITY.SURFACE.SWAPTION.HELPER"),
TempStrNoSize("\x8F""identifier,exercice,maturity,volatility,index,fixed leg tenor,fixed leg daycounter,float leg daycounter,curve,error type,strike,nominal,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x16""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x57""This function instanciates a swaption helper for volatility surface calibration purpose"),
TempStrNoSize("\x1A""The name of the instrument"),
TempStrNoSize("\x11""The exercice date"),
TempStrNoSize("\x0C""The end date"),
TempStrNoSize("\x15""The quoted volatility"),
TempStrNoSize("\x10""The fixing index"),
TempStrNoSize("\x13""The fixed leg tenor"),
TempStrNoSize("\x18""The fixed leg daycounter"),
TempStrNoSize("\x1B""The floating leg daycounter"),
TempStrNoSize("\x0F""The yield curve"),
TempStrNoSize("\x3D""The calibration Error type (defaults to relative price error)"),
TempStrNoSize("\x1A""The strike rate (optional)"),
TempStrNoSize("\x16""The nominal (optional)"));
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x1D""xlInitiateSwaptionHelper")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateTimeSeries(const XLOPER & xDll) {
XLOPER xlRegID ;
// freed the function xlInitiateTimeSeries
Excel(xlfRegister, 0, 14, &xDll,
TempStrNoSize("\x14""xlInitiateTimeSeries"),
TempStrNoSize("\x06""CCPPP#"),
TempStrNoSize("\x12""OBJECT.TIME.SERIES"),
TempStrNoSize("\x27""object indentifier,dates,values,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x16""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x2A""This function creates a time series object"),
TempStrNoSize("\x11""Object Identifier"),
TempStrNoSize("\x09""The dates"),
TempStrNoSize("\x16""The corresponding data"),
TempStrNoSize("\x1C""Trigger for recalculation "));
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x10""xlInitiateTimeSeries")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
XLL_DEC XLOPER *ohRangeRetrieveError(XLOPER *xRange) {
try {
reposit::Xloper xTemp;
Excel(xlCoerce, &xTemp, 1, xRange);
static XLOPER xRet;
if (xTemp->xltype & xltypeErr) {
Excel(xlUDF, &xRet, 2, TempStrNoSize("\x13""ohRetrieveErrorImpl"), xRange);
xRet.xltype |= xlbitXLFree;
} else {
reposit::scalarToOper(std::string(), xRet);
}
return &xRet;
} catch (...) {
return 0;
}
}
void unregisterContractsForwardAsian(const XLOPER &xDll)
{
XLOPER xlRegID;
// Unregister each function. Due to a bug in Excel's C API this is a
// two-step process. Thanks to Laurent Longre for discovering the
// workaround implemented here.
Excel(xlfRegister, 0, 18, &xDll,
TempStrNoSize("\x1A""createContractForwardAsian"),
TempStrNoSize("\xA""CCPPPBBCL#"),
TempStrNoSize("\x1A""createContractForwardAsian"),
TempStrNoSize("\x3D""ObjectID,AveStart,AveEnd,SettDate,Strike,Volume,B/S,Permanent"),
TempStrNoSize("\x01""1"), // function type (0 = hidden function, 1 = worksheet function, 2 = command macro)
TempStrNoSize("\x9""prObjects"), // function category
TempStrNoSize("\x00"""), // shortcut text (command macros only)
TempStrNoSize("\x00"""), // path to help file
TempStrNoSize("\x26""Constructs an Oil Average Rate Forward"),
TempStrNoSize("\x1A""id of object to be created"), // parameter descriptions
TempStrNoSize("\x19""Start of averaging period"),
TempStrNoSize("\x17""End of averaging period"),
TempStrNoSize("\xF""Settlement date"),
TempStrNoSize("\x6""Strike"),
TempStrNoSize("\x6""Volume"),
TempStrNoSize("\x1D""Buy or Sell at the fixed rate"),
TempStrNoSize("\x1D""object permanent/nonpermanent"));
Excel4(xlfRegisterId, &xlRegID, 2, &xDll,
TempStrNoSize("\x1A""createContractForwardAsian"));
Excel4(xlfUnregister, 0, 1, &xlRegID);
}
inline void unregisterxlCurveForwardRate(const XLOPER & xDll) {
XLOPER xlRegID ;
// Unregister the function xlCurveForwardRate
Excel(xlfRegister, 0, 15, &xDll,
TempStrNoSize("\x12""xlCurveForwardRate"),
TempStrNoSize("\x07""BCEECP#"),
TempStrNoSize("\x12""CURVE.FORWARD.RATE"),
TempStrNoSize("\x31""curve identifier,time 1,time 2,convention,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x1B""xlObjectTools - Yield Curve"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x43""This function computes the forward rate for the corresponding dates"),
TempStrNoSize("\x10""Curve identifier"),
TempStrNoSize("\x10""The forward date"),
TempStrNoSize("\x11""The maturity date"),
TempStrNoSize("\x20""The identifier of the convention"),
TempStrNoSize("\x1B""Trigger for recalculation "));
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x12""xlCurveForwardRate")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInitiateAussieBill (const XLOPER & xDll) {
XLOPER xlRegID ;
// décharge la fonction xlInitiateAussieBill
Excel(xlfRegister, 0, 15, & xDll,
TempStrNoSize("\x14""xlInitiateAussieBill"),
TempStrNoSize("\x07""PCEEPP#"),
TempStrNoSize("\x14""INSTANCE.AUSSIE.BILL"),
TempStrNoSize("\x57""identifiant de l'instrument,date d'emission,date de maturité,jours de règlement,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x17""xlObjectTools - Object"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x3E""Cette fonction instancie un bill émis par le trésor australien"),
TempStrNoSize("\x1D""L'identifiant de l'instrument"),
TempStrNoSize("\x1B""La date d'émission du titre"),
TempStrNoSize("\x1C""La date de maturité du titre"),
TempStrNoSize("\x1F""Le nombre de jours de règlement"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x14""xlInitiateAussieBill")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
void registerRange(const XLOPER &xDll) {
Excel(xlfRegister, 0, 15, &xDll,
// function code name
TempStrNoSize("\x07""ohRange"),
// parameter codes
TempStrNoSize("\x07""CCKPPL#"),
// function display name
TempStrNoSize("\x07""ohRange"),
// comma-delimited list of parameter names
TempStrNoSize("\x2B""ObjectId,Values,Permanent,Trigger,Overwrite"),
// function type (0 = hidden, 1 = worksheet)
TempStrNoSize("\x01""1"),
// function category
TempStrNoSize("\x0D""ObjectHandler"),
// shortcut text (command macros only)
TempStrNoSize("\x00"""),
// path to help file
TempStrNoSize("\x00"""),
// function description
TempStrNoSize("\x34""Construct an object of class Range and return its id"),
// parameter descriptions
TempStrNoSize("\x1A""id of object to be created"),
TempStrNoSize("\x12""a range of values."),
TempStrNoSize("\x1D""object permanent/nonpermanent"),
TempStrNoSize("\x1B""dependency tracking trigger"),
TempStrNoSize("\x10""overwrite flag "));
}
inline void unregisterxlInstrumentDuration(const XLOPER & xDll) {
XLOPER xlRegID ;
Excel(xlfRegister, 0, 17, & xDll,
TempStrNoSize("\x14""xlInstrumentDuration"),
TempStrNoSize("\x09""PCPPEPCP#"),
TempStrNoSize("\x13""INSTRUMENT.DURATION"),
TempStrNoSize("\x6C""Identifiant de l'instrument,date d'évaluation,date de règlement,prix,type de duration,convention,déclencheur"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Bond"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x52""Cette fonction calcule la duration de l'instrument pour un prix et une date donnée"),
TempStrNoSize("\x16""Le nom de l'instrument"),
TempStrNoSize("\x17""Le prix de l'instrument"),
TempStrNoSize("\x23""La date d'évaluation de la duration"),
TempStrNoSize("\x1D""La date de règlement du titre"),
TempStrNoSize("\x1E""Le type de duration à calculer"),
TempStrNoSize("\x20""La convention de taux à utiliser"),
TempStrNoSize("\x1C""Le déclencheur du recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x14""xlInstrumentDuration")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlInstrumentPreviousCashFlowAmount(const XLOPER & xDll) {
XLOPER xlRegID ;
// libère la fonction registerxlInstrumentPreviousCashFlowAmount
Excel(xlfRegister, 0, 13, & xDll,
TempStrNoSize("\x22""xlInstrumentPreviousCashFlowAmount"),
TempStrNoSize("\x05""PCPP#"),
TempStrNoSize("\x25""INSTRUMENT.MONTANT.CASHFLOW.PRECEDENT"),
TempStrNoSize("\x39""Identifiant de l'instrument,date de règlement,déclencheur"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Bond"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x34""Cette fonction calcule la valeur du cashflow précédent"),
TempStrNoSize("\x1D""L'identifiant de l'instrument"),
TempStrNoSize("\x14""La date de règlement"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x22""xlInstrumentPreviousCashFlowAmount")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
/*
***************************************************************************
** Standard Excel addin cleanup function.
***************************************************************************
*/
XLFUNC(short) xlAutoClose(void)
{
static char funcName[257]; /* Function name */
OPER xFuncName;
size_t i;
for (i = 0; i < gtoFuncDefCount; i++)
{
/* Define the function name as a pascal string. */
funcName[0] = strlen(FNPREFIX) + strlen(gtoFuncDefList[i]->name) + 1;
strcpy (funcName+1, FNPREFIX);
strcat (funcName, "_");
strcat (funcName, gtoFuncDefList[i]->name);
/* Create a string oper from the function name pascal string */
xFuncName.type = xltypeStr;
xFuncName.val.str = funcName;
/* Call Excel using xlfSetName to "unregister" the function */
Excel(xlfSetName, 0, 1, &xFuncName);
}
FreeObjects();
return 1;
}
inline void unregisterxlSwapCurrentFixing(const XLOPER & xDll) {
XLOPER xlRegID ;
// libère la fonction xlSwapAccruedAmount
Excel(xlfRegister, 0, 14, & xDll,
TempStrNoSize("\x13""xlSwapCurrentFixing"),
TempStrNoSize("\x06""PCEPP#"),
TempStrNoSize("\x19""SWAP.FIXING"),
TempStrNoSize("\x4C""Identifiant de l'instrument,date de règlement,index de référence,déclencheur"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Swap"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x64""Cette fonction détermine le taux de fixing d'une jambe variable pour une date de règlement donnée"),
TempStrNoSize("\x16""Le nom de l'instrument"),
TempStrNoSize("\x24""La date de règlement de l'instrument"),
TempStrNoSize("\x2E""L'index des fixings de la jambe flottante"),
TempStrNoSize("\x1C""Le déclencheur du recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x19""xlSwapCurrentFixing")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlCurveZeroRate(const XLOPER & xDll) {
XLOPER xlRegID ;
// release the function xlCurveZeroRate
Excel(xlfRegister, 0, 14, &xDll,
TempStrNoSize("\x0F""xlCurveZeroRate"),
TempStrNoSize("\x06""PCECP#"),
TempStrNoSize("\x0F""CURVE.ZERO.RATE"),
TempStrNoSize("\x1F""curve,effective date,convention"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x1C""xlObjectTools - Yield Curve"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x64""This function gives yield curve's zero rate corresponding to the passed maturity date and convention"),
TempStrNoSize("\x10""Curve Identifier"),
TempStrNoSize("\x11""The maturity date"),
TempStrNoSize("\x1F""The yield convention identifier"),
TempStrNoSize("\x1B""Trigger for recalculation "));
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x0F""xlCurveZeroRate")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlZScoreEWMA(const XLOPER & xDll) {
XLOPER xlRegID ;
// Enregistre la fonction xlZScoreEWMA
Excel(xlfRegister, 0, 14, & xDll,
TempStrNoSize("\x0C""xlZScoreEWMA"),
TempStrNoSize("\x06""PCEEP#"),
TempStrNoSize("\x0C""Z.SCORE.EWMA"),
TempStrNoSize("\x40""série à estimer,facteur d'obsolescence,date d'évaluation,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Math"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x5E""Cette fonction calcule le z-score d'une série pour une valeur du facteur d'obsolescence donnée"),
TempStrNoSize("\x21""Identifiant de la série à estimer"),
TempStrNoSize("\x25""La valeur du paramètre d'obsolescence"),
TempStrNoSize("\x1F""La date d'évaluation du z-score"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x0C""xlZScoreEWMA")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
inline void unregisterxlCovarianceMatrixEWMA(const XLOPER & xDll) {
XLOPER xlRegID ;
// Enregistre la fonction xlCovarianceMatrixEWMA
Excel(xlfRegister, 0, 14, & xDll,
TempStrNoSize("\x16""xlCovarianceMatrixEWMA"),
TempStrNoSize("\x07""PPEELP#"),
TempStrNoSize("\x17""MATRICE.COVARIANCE.EWMA"),
TempStrNoSize("\x56""plage des séries,facteur d'obsolescence, date d'évaluation,indicateur de norme,trigger"),
TempStrNoSize("\x01""1"),
TempStrNoSize("\x15""xlObjectTools - Math"),
TempStrNoSize("\x00"""),
TempStrNoSize("\x00"""),
TempStrNoSize("\x9D""Cette fonction calcule la matrice des variances-covariances d'un ensemble de séries pour une valeur du facteur d'obsolescence et une date d'évaluation donnée"),
TempStrNoSize("\x2E""La plage des identifiants des séries à estimer"),
TempStrNoSize("\x25""La valeur du paramètre d'obsolescence"),
TempStrNoSize("\x29""Indique si la volatilité doit être normée"),
TempStrNoSize("\x17""Déclenche le recalcul ")) ;
Excel4(xlfRegisterId, & xlRegID, 2, & xDll,
TempStrNoSize("\x16""xlCovarianceMatrixEWMA")) ;
Excel4(xlfUnregister, 0, 1, & xlRegID) ;
}
QuantLib::Array operToQlArray(const OPER &xVector,
const std::string paramName) {
OPER xTemp;
bool excelToFree = false;
bool xllToFree = false;
try {
RP_REQUIRE(!(xVector.xltype & xltypeErr),
"input value '" << paramName << "' has type=error");
if (xVector.xltype & (xltypeMissing | xltypeNil))
return QuantLib::Array();
const OPER *xMulti;
if (xVector.xltype == xltypeMulti) {
xMulti = &xVector;
} else if (xVector.xltype == xltypeStr) {
splitOper(&xVector, &xTemp);
xMulti = &xTemp;
xllToFree = true;
} else {
Excel(xlCoerce, &xTemp, 2, &xVector, TempInt(xltypeMulti));
xMulti = &xTemp;
excelToFree = true;
}
int size = xMulti->val.array.rows * xMulti->val.array.columns;
QuantLib::Array a(size);
for (int i=0; i<size; ++i) {
a[i] = reposit::convert2<double>(reposit::ConvertOper(xMulti->val.array.lparray[i]));
}
if (excelToFree) {
Excel(xlFree, 0, 1, &xTemp);
} else if (xllToFree) {
freeOper(&xTemp);
}
return a;
} catch (const std::exception &e) {
if (excelToFree) {
Excel(xlFree, 0, 1, &xTemp);
} else if (xllToFree) {
freeOper(&xTemp);
}
RP_FAIL("operToVector: error converting parameter '" << paramName << "' : " << e.what());
}
}
