自学教程：C++ Excel函数代码示例

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

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