Financial Applications Using Excel Add-in Development in C/C++Second Edition phần 9 pot

446 Excel Add-in Development in C/C++xloper * __stdcall ExampleActiveOnlyxloper *pTrigger Op = ++count; // re-use Op for the return value else // return the last value Op.ConvertRefToVal

if(m_Vol <= 0.0)

return false;

double d1 = log(m_Fwd / m_Strike) / m_vRootT + m_vRootT / 2.0;

double N1 = ndist(d1); // ndist(x) = N(x)

double N2 = ndist(d1 - m_vRootT);

m_Call = m_Fwd * N1 - m_Strike * N2;

m_Put = m_Call + m_Intrinsic;

m_Straddle = m_Call + m_Put;

The following XLL-exportable function shows a simple example of its use It is also used

in the example implementation of CMS derivative pricing (see section 10.11 on page513)

xloper * stdcall BlackOpt(double t_exp, double fwd, double strike,

double vol) {

BlackOption Opt(t_exp, fwd, strike, vol);

Opt.Calc(true); // true: calc greeks

// Return a single row array

cpp_xloper RetVal((RW)1, (COL)NUM_BLACK_RTN_VALS, ret_vals);

A(int i) {m_iVal = i;}

void SetVal(int i) {m_iVal = i;}

440 Excel Add-in Development in C/C++

be passed and returned by reference (or by pointer) Passing or returning by value causesthe implicit creation, copying and destruction of temporary class instances

You should also avoid calling into Excel through the C API for functions that are alsoavailable in standard string or mathematics libraries, for example This is because theoverhead of calling into Excel is significant You can break this rule where you are notcalling back into Excel very often, or where you need compatible behaviour with theworksheet functions

There are many other ways in which code can leak performance, such as the inefficientuse of arrays, for example These are too numerous to go into in great detail, suffice to

say that there is still good reason to write nice code.

9.14.2 VBA code optimisation

Given that VBA is much slower than compiled C++, it is likely that at some point youwill find there is a performance bottleneck in your VBA code The highly-recommended

Professional Excel Development10contains a chapter specifically about the optimisation ofVBA The following list reproduces some of the optimisations they recommend, althoughthere is a great deal more said in their text

10 Bullen, Bovey and Green, 2005, Addisson Wesley.

• Use matching data types to avoid implicit conversions, and use Variants only wherenecessary.

• Perform explicit type conversions CStr(), CDbl(), etc., instead of VBA’s implicitconversions

• UseLen(string)= 0 instead ofstring= ""to detect zero length/empty strings

• Use string-typed string functions instead of Variant functions, e.g., useLeft()instead

ofLeft()

• Pass strings and arraysByRef instead ofByVal

• Use Option Compare Text to make string comparisons case-sensitive by default,using theCompareMethod ofStrComp()when case-insensitivity is needed

• Avoid late binding by declaring object variables as their explicit types instead of As Object

• Use integer division instead of floating point division (\ instead of /) where integerarguments are being evaluated to an integer

• Iterate collections usingFor Eachinstead ofFor Nextand indexing

• Iterate arrays usingFor Nextand indexing instead ofFor Each

• UseIf bVariable Then .instead of If bVariable = True Then .

• UseIf Then ElseIf Then .instead of IIF()orSelect Case

• UseWith End Withblocks wherever possible

There may be times when you feel the readability of your code is improved with one ofthe less-efficient ways of doing things.Select Casefor example leads to very readablemaintainable code, so you might justifiably prefer it

9.14.3 Excel calculation optimisation

Optimising the calculation time of an Excel spreadsheet is a far more complex topic thanthe code optimisations discussed briefly above There are many more factors that canaffect the perceived amount of time spent in recalculation:

• System resource availability and performance (memory, processor, disk and networkaccess time, multi-threading settings in Excel 2007, etc.)

• Workbook complexity (inter-workbook and inter-worksheet links, number of cells taining formulae, display complexity, etc.)

con-• Worksheet formula choices (use of volatile functions, use of inefficient functions)

• XLL add-in and user-defined function performance

• VBA user-defined function performance

• COM add-in function performance

Understanding the first point, resource availability, is key to knowing how much effort

to put into resolving the others A system that’s low on memory or that makes frequentaccess to a remote system via a slow network connection, or a remote system that isstruggling to keep up, will not be helped much by increasing the speed of execution of anadd-in function Equally, where a simple and cheap upgrade of hardware will restore therecalculation time expected by the user, relatively costly development hours are probablybetter not spent on optimisation With Excel 2007, the purchase of a second processor or

a dual-core machine could reduce calculation times by up to half

442 Excel Add-in Development in C/C++

Multi-threading in Excel 2007 can also improve performance on a single processormachine where a UDF makes a call to a remote calculation server (or server farm orcluster) where the server has many processors This enables the single processor machine

to send many requests off to the server roughly at the same time, fully loading the server,rather than having to wait for each calculation request to complete before sending the next.Even given the often better alternatives to re-coding, you would hope not to end up in

a situation where you have to perform emergency optimisation on your workbooks andprojects Following sound principles from the outset, performance should only deteriorateslowly as new features/code/cells are added However, there are times when things canget a little sluggish and the rest of this section aims to provide some practical advice onwhat to do

Many of the previous chapters and sections of this book refer to performance In fact,given that the use of XLLs is largely a performance-driven choice, you could say thatthis entire book is about improving performance So rather than restating all that has beensaid already, this section refers back to those sections and adds additional advice wherenecessary There is one important point that applies to all programming optimisation, andthat is to avoid, or at least be aware of, implicit type conversions When designing theinterfaces for your XLL worksheet function exports, and you need to get best possibleperformance, it is better to register all of your arguments as valuexloper/xloper12s(type P/Q) as this avoids the overhead of Excel conversion You do, of course, then need

to check that the types in your code are correct, and convert them or fail, depending onhow exacting you are with the caller

Before getting to that, there is some ancient Excel-lore that states that you shouldtry to arrange your calculations on the sheet such that dependencies run from top-left to bottom-right For example, B2 depending on A1 is good; vice versa is bad.Whilst this might have been good advice in some past version of Excel (or perhaps someother spreadsheet package) the author can find nothing to suggest this willimprove performance The two workbooks TopLeftDrivenCalcTest.xls andBottomRightDrivenCalcTest.xlscontain named ranges of 50,000 cells, contain-ing volatile formulae, that are recalculated 1,000 times under VBA macro control As youcan verify for yourself, the recalculation times are as good as identical

Section 2.12 Excel recalculation logic, page 33, covers the differences between the

way Excel 97 and 2000 differ from versions 2002+ with respect to the recalculation ofinter-worksheet (not inter-workbook) links If you or your users are or might be using

97 or 2000 you should be aware of the recalculation problems that careless use of suchlinks can cause and follow the advice in that section The section also covers the use andmis-use of volatile functions, another potential performance black hole, as well as datatables, where completion of recalculations may not always be obvious, as well as beingslow

Section 2.16 Good spreadsheet design and practice, page 49, covers some basic ideas

relating to the choice of worksheet function that you make In particular it discussesformula repetition and usingMATCH()and INDEX()instead of VLOOKUP() There aremyriad examples that could be thought up of two or more ways to use Excel’s ownfunctions to do the same thing, for example:

=IF(INT(A1)= 1,C1,IF(INT(A1)= 2,C2,IF(INT(A1)= 3,C3,# VALUE!)))

=CHOOSE(A1,C1,C2,C3)

=INDEX(C1:C3,A1)

These 3 expressions all do almost the same thing (The third will return a #REF!error ifA1¿3 and INDEX(C1:C3,1.999999761466)will round up to 2 and return C2, whereas1.999999761465 will round down) Clearly, without some good reason for choosing thefirst, the second and third are far more succinct, readable and efficient It is amazingthat people struggle with the limitation of the number of nested IF()s that Excel allows

([v11–]: 7, [v12+]: 64) and the ingenious work-arounds, such as splitting more nested

IF()s across more than one cell If you need more than 3 or 4 in a single expression youshould certainly be considering something likeCHOOSEorINDEX instead, for reasons ofreadability, if not performance

Much of the skill of knowing which combination of Excel’s own functions to best usecan only come with experience, although the general advice is that keeping things simpleand readable will automatically keep them efficient in most cases This is explained further

in section 2.12.8 on page 41, which covers argument evaluation in functions that tionally ignore some of their arguments, for example, the functionsIF(),OR(),AND() andCHOOSE(): All arguments are recalculated prior to Excel calling the function, regardless

condi-of whether or not the result will be ignored This clearly has an impact on recalculationtime and the section’s advice of using only simple arguments, even if that means refer-ences to cells containing complex expressions, should always be followed This is eventrue to the extent that an expression like =B5*IF(C6,1,±1) is slightly more efficient than

=IF(C6,B5,±B5), since in the first example B5is only dereferenced once

Once you are happy that any sluggishness cannot easily be removed by optimisingadd-in code (after all, you may only have Excel formulae in your workbook), and youhave scoured the workbook for inefficient formulae, you must turn to fine-tuning whatExcel does and does not calculate In a large workbook, you may have sheets that do notneed to be calculated when the sheet is not being viewed In other words you may want

to turn off a sheet’s calculation unless it is active This can make a huge difference to alarge workbook, and fortunately there are a couple of ways to achieve this An example

of such a sheet might be one that shows a detailed breakdown of something that youordinarily do not need to see, or that calculates and displays data graphically

TheExcel.Worksheetobject exposes a propertyEnableCalculationwhose defaultstate isTrueand can be switched off in a VBA macro or with a call via COM The moststraightforward approach is to place a couple of event traps in the worksheet’s VBA codemodule, as shown here:

Private Sub Worksheet_Activate()

is complete)

The following event will cause the sheet to be updated once only when it becomesactive, but then to be static There may not be many times when you can get away withthis or need to do it, however

444 Excel Add-in Development in C/C++

Private Sub Worksheet_Activate()

Config EnableCalculation: always true

Processes configuration data that is used when building curves, pricing

positions, etc Calculations are driven by changes to configuration data and a

master non-volatile trigger (could be today’s date).

Curves EnableCalculation: always true

Contains all links to external dynamic real-time data Processes data for use in pricing, and increments triggers for dependent calculations.

Portfolio EnableCalculation: true when active only, or always true (see note)

Calculates present value of position in the portfolio using configuration data from Config and market data from Curves.

Note: Provided other sheets that need real-time updates do not link to this sheet, this can be recalculated when active only.

Risk EnableCalculation: true when active only

Calculates portfolio risk and display graphs Depends on volatile curve data and non-volatile data from Portfolio sheet, i.e., does not depend on Portfolio being recalculated when curves change.

xCashflow EnableCalculation: true when active only

Calculate and display actual and anticipated cashflows.

Note thatxCashflowis so named to ensure that it is afterConfigandCurvesalphabetically,for the benefit of those running the workbook in versions 97 and 2000

You may need to go one step further, and be more selective in what you let be culated on a given sheet For example, you may have some cells that drive calculations

recal-in other sheets, but other related cells that take a long time to recalculate but do notdrive such things In this case you would ideally like to be able to tell a function torecalculate only when it is on the active sheet As such functions are likely to be either

VBA user-defined functions or XLL functions, the question is then how can a functiondetermine this.

In both these cases the trick is to find out where the function is being called from: is

it a worksheet cell or range of cells; are they on the active sheet; and so on In VBAthis is done usingApplication.Caller This example returns an incremented counter

if called from the active sheet and returns zero otherwise:

Option Explicit

Dim count As Integer

Function CallerIsActive() As Boolean

One limitation of doing this with VBA is that it cannot return the last value(s) of thecalling cell(s) The statement ExampleActiveOnly = Application.Caller.Value2,apart from its assumption thatCalleris a Range object, would lead Excel to complain

of a circular reference This is unfortunate, as this is precisely what you would like to beable to do: return the old value so that the dependent values do not change to somethinginvalid

Fortunately the C API permits XLL functions registered as macro-sheet equivalent toread the calling cell’s old value, as shown in the following code This does essentially thesame thing as the above VBA code but with the added benefit of returning the caller’slast value if not on the active sheet

446 Excel Add-in Development in C/C++

xloper * stdcall ExampleActiveOnly(xloper *pTrigger)

Op = ++count; // re-use Op for the return value

else // return the last value

Op.ConvertRefToValues(); // fails if not registered as type #

// Is the xloper a reference on the active sheet?

bool cpp_xloper::IsActiveRef(void) const

xloper12 as_ref = {0, xltypeNil};

xloper12 type = {0, xltypeInt};

xloper as_ref = {0, xltypeNil};

xloper type = {0, xltypeInt};

You may also like to create worksheet functions that are only recalculated, say, when

a button on the active sheet is pressed One way to achieve this is to create functionsthat take an argument, perhaps optional, where the functions only recalculate when thatargument isTRUE, and otherwise return the cell’s last value Again, using VBA this is notpossible Using the C API this is straightforward, as the following function demonstrates

xloper * stdcall ExampleRecalcSwitch(xloper *pArg, xloper *pDontRecalc) {

cpp_xloper Op, DontRecalc(pDontRecalc);

if(DontRecalc.IsTrue()) // then return the last value

448 Excel Add-in Development in C/C++

// Get the calling cell' s value

if(Excel4(xlCoerce, &m_Op, 1, &caller) != xlretSuccess)

// Get the calling cell' s value

if(Excel12(xlCoerce, &m_Op12, 1, &caller) != xlretSuccess)

Without using thecpp_xloperclass, the above code could be implemented as follows

in a function registered as type #

xloper * stdcall ExampleRecalcSwitch(xloper *pArg, xloper *pDontRecalc) {

// Not thread-safe, but this function must be registered as type #

// so cannot also be registered as thread-safe in Excel 12

static xloper ret_val;

if(pDontRecalc->xltype == xltypeBool && pDontRecalc->val.xbool == 1)

10 Example Add-ins and Financial Applications

Developers are always faced with the need to balance freedoms and constraints whendeciding the best way to implement a model Arguably the most important skill a developercan have is the ability to choose the most appropriate approach all things considered:Failure can result in code that is cumbersome, or slow, or difficult to maintain or extend,

or bug-ridden, or that fails completely to meet a completion time target

This chapter aims to do two things:

1 Present a few simple worksheet function examples that demonstrate some of the basicconsiderations, such as argument and return types For these examples source code isincluded on the CD ROM in the example project Sections 10.1 to 10.4 cover thesefunctions

2 Discuss the development choices available and constraints for a number of financialmarkets applications Some of these applications are not all fully worked through inthe book, and some source code is not provided on the CD ROM Sections 10.5 andbeyond cover these functions and applications

Some of the simple example functions could easily be coded in VBA or duplicated withperhaps only a small number of worksheet cells The point is not to say that these thingscan only be done in C/C++ or using the C API If you have decided that you want orneed to use C/C++, these examples aim to provide a template or guide

The most important thing that an add-in developer must get right is the function face The choices made as to the types of arguments a function takes, are they required oroptional; if optional what the default behaviour is; and so on, are often critical Much ofthe discussion in this chapter is on this and similar issues, rather than on one algorithmversus another The discussion of which algorithm to use, etc., is left to other texts and

inter-to the reader whose own experience may very well be more informed or advanced thanthe author’s

Important note: You should not rely on any of these examples, or the methods they

contain, in your own applications without having completely satisfied yourself thatthey are correct and appropriate for your needs They are intended only to illustratehow techniques discussed in earlier chapters can be applied

Excel has a number of very efficient basic string functions, but string operations canquickly become unnecessarily complex when just using these Consider, for example, thecase where you want to substitute commas for stops (periods) dynamically This is easilydone using Excel’s SUBSTITUTE() However, if you want to simultaneously substitutecommas for stops and stops for commas things are more complex (You could do this in

452 Excel Add-in Development in C/C++

three applications ofSUBSTITUTE(), but this is messy.) Writing a function in C that doesthis is straightforward (seereplace_mask()below)

The C and C++ libraries both contain a number of low-level string functions that caneasily be given Excel worksheet wrappers This section presents a number of examplefunctions, some of which just wrap standard library functions The code for all ofthese functions is listed in the Example project on the CD ROM in the source fileXllStrings.cpp When registered with Excel, they are added to theTextcategory.Excel 2007 gives the C API access to Unicode strings of much greater length than the

byte-strings of earlier versions Section 8.6.12 Registering functions with dual interfaces for Excel 2007 and earlier versions on page 263 explains how to register worksheet

functions that call a different underlying DLL export depending on the running version.This enables your functions to get the optimum behaviour The examples in this sectionare, therefore, given in both 2003− and 2007+ flavours

Notes Function does not need to be volatile and does not access any C

API functions that might require it to be registered as a macro sheetequivalent function 2007 version is thread-safe

// Excel 11- interface function Uses xlopers and byte-string

size_t stdcall count_char_xl4(char *text, xloper *p_ch)

{

cpp_xloper Ch(p_ch);

char ch;

// Excel 12+ interface function Uses xloper12s and Unicode string

size_t stdcall count_char_xl12(wchar_t *text, xloper12 *p_ch)

Description Replaces all occurrences of characters in a search string with

corresponding characters from a replacement string, or removes all

such occurrences if no replacement string is provided

Type string "1FCP"(2003),"1F%C%Q$"(2007)

Notes Declared as returning void Return value is the 1st argument

modified in place Third argument is optional and passed as a valuexloper/xloper12(see section 6.2.6) to avoid the need todereference a range reference

// Remove all occurrences of all characters in old_chars

for(p_old = old_chars; *p_old; p_old++)

454 Excel Add-in Development in C/C++

for(pt = text; *pt;)

{

if(*pt == *p_old) {

p = pt;

do {*p = p[1];} while (*(++p));

} else pt++;

void replace_mask(wchar_t *text, wchar_t *old_chars, wchar_t *new_chars);

// Excel 11- interface function Uses xlopers and byte-string

void stdcall replace_mask_xl4(char *text, char *old_chars, xloper

// Excel 12+ interface function Uses xloper12s and Unicode string

void stdcall replace_mask_xl12(wchar_t *text, wchar_t *old_chars, xloper12

replace_mask(text, old_chars, new_chars);

Description Reverses a string

Prototype void stdcall reverse_text(char *text);

Type string "1F"(2003),"1F%$"(2007)

Notes Declared as returning void Return value is the 1st argument

modified in place These functions simply wrap the C libraryfunctionsstrrev()andwcsrev(), and are useful in the creation

of Halton quasi-random number sequences, for example

// Excel 11- interface function Uses xlopers and byte-string

void stdcall reverse_text_xl4(char *text) {strrev(text);}

// Excel 12+ interface function Uses xloper12s and Unicode string

void stdcall reverse_text_xl12(wchar_t *text) {wcsrev(text);}

Function

name

find_first_xl4orfind_first_xl12(exported)FindFirst(registered with Excel)

Description Returns the position of the first occurrence of any character from a

search string, or zero if none found

Type string "HCC"(2003),"HC%C%$"(2007)

Notes Any error in input is reflected with a zero return value, rather than

an error type These functions simply wrap the C library functionsstrpbrk()andwcspbrk()

// Core functions

size_t find_first(char *text, char *search_text)

{

if(!text | | !search_text) return 0;

char *p = strpbrk(text, search_text);

return p ? 1 + p - text : 0;

}

size_t find_first(wchar_t *text, wchar_t *search_text)

456 Excel Add-in Development in C/C++

if(!text | | !search_text) return 0;

wchar_t *p = wcspbrk(text, search_text);

return p ? 1 + p - text : 0;

}

// Excel 11- interface function Uses xlopers and byte-string

size_t stdcall find_first_xl4(char *text, char *search_text)

{

return find_first(text, search_text);

}

// Excel 12+ interface function Uses xloper12s and Unicode string

size_t stdcall find_first_xl12(wchar_t *text, wchar_t *search_text) {

return find_first(text, search_text);

}

Function name find_first_excluded_xl4or

find_first_excluded_xl12(exported)FindFirstExcl(registered with Excel)

Description Returns the position of the first occurrence of any character that

is not in the search string, or zero if no such character is found.Type string "HCC"(2003),"HC%C%$"(2007)

Notes Any error in input is reflected with a zero return value, rather

than an error type

// Excel 11- interface function Uses xlopers and byte-string

size_t stdcall find_first_excluded_xl4(char *text, char *search_text) {

return find_first_excluded(text, search_text);

}

// Excel 12+ interface function Uses xloper12s and Unicode string

size_t stdcall find_first_excluded_xl12(wchar_t *text, wchar_t

Description Returns the position of the last occurrence of a given character, or

zero if not found

Type string "HCP"(2003),"HC%Q$"(2007)

Notes Any error in input is reflected with a zero return value, rather than

an error type These functions simply wrap the C library functionsstrrchr() and wcsrchr()

// Excel 11- interface function Uses xlopers and byte-string

size_t stdcall find_last_xl4(char *text, xloper *p_ch)

458 Excel Add-in Development in C/C++

// Excel 12+ interface function Uses xloper12s and Unicode string size_t stdcall find_last_xl12(wchar_t *text, xloper12 *p_ch)

Description Compare two strings for equality (return 0), A< B (return −1),

A> B (return 1), case sensitive or not (default).

Type string "RCCP"(2003),"UC%C%Q$"(2007)

Notes Any error in input is reflected with an Excel#VALUE! error

Excel’s comparison operators<, > and = are not case-sensitive

and Excel’sEXACT()function only performs a case-sensitivecheck for equality

// Core functions

int compare_text(char *a, char *b, bool case_sensitive)

{

if(!a | | !b)

return -2; // str*cmp functions return <0, 0, >0

return case_sensitive ? strcmp(a, b) : stricmp(a, b);

}

int compare_text(wchar_t *a, wchar_t *b, bool case_sensitive)

{

if(!a | | !b)

return -2; // str*cmp functions return <0, 0, >0

return case_sensitive ? wcscmp(a, b) : wcsicmp(a, b);

}

// Excel 11- interface function Uses xlopers and byte-string

xloper * stdcall compare_text_xl4(char *a_text, char *b_text, xloper

*is_case_sensitive)

{

cpp_xloper CaseSensitive(is_case_sensitive);

bool case_sensitive = !CaseSensitive.IsFalse();

int ret_val = compare_text(a_text, b_text, case_sensitive);

if(ret_val == -2) // compare_text error value

return p_xlErrValue;

cpp_xloper RetVal(ret_val);

return RetVal.ExtractXloper();

}

// Excel 12+ interface function Uses xloper12s and Unicode string

xloper12 * stdcall compare_text_xl12(wchar_t *a_text, wchar_t *b_text, xloper12 *is_case_sensitive)

{

cpp_xloper CaseSensitive(is_case_sensitive);

bool case_sensitive = !CaseSensitive.IsBool() | |

CaseSensitive.IsTrue();

int ret_val = compare_text(a_text, b_text, case_sensitive);

if(ret_val == -2) // compare_text error value

Description Compare the first n (1 to 255 in Excel 2003; 1 to 32,767 in Excel

2007) characters of two strings for equality (return 0), A< B

(return−1), A > B (return 1), case sensitive or not (default).

Type string "RCCHP"(2003)"UC%C%HQ$"(2007)

// Excel 11- interface function Uses xlopers and byte-string

xloper * stdcall compare_nchars_xl4(char *a_text, char *b_text,

size_t n_chars, xloper *case_sensitive)

{

if(!a_text | | !b_text | | !n_chars | | n_chars > MAX_XL4_STR_LEN)

return p_xlErrNum;

// Case-sensitive unless explicitly Boolean False

int ret_val = case_sensitive->xltype != xltypeBool

| | case_sensitive->val.xbool == 1 ?

strncmp(a_text, b_text, n_chars) :

strnicmp(a_text, b_text, n_chars);

cpp_xloper RetVal(ret_val);

return RetVal.ExtractXloper();

}

// Excel 12+ interface function Uses xloper12s and Unicode string

xloper12 * stdcall compare_nchars_xl12(wchar_t *a_text, wchar_t *b_text, size_t n_chars, xloper12 *case_sensitive)

460 Excel Add-in Development in C/C++

| | case_sensitive->val.xbool == 1 ?

wcsncmp(a_text, b_text, n_chars) :

wcsnicmp(a_text, b_text, n_chars);

Description Concatenate the contents of the given range (row-by-row) using the

given separator (or comma by default) Returned string length limit

is 255 characters (2003) or 32,767 (2007) by default, but can be setlower Caller can specify the number of decimal places to use whenconverting numbers

Type string "RPPPPP"(2003),"UQQQQQ$"(2007)

// Core code function written in terms of cpp_xlopers to make it

// version-independent cpp_xloper class is version-aware and

// uses either xlopers or xloper12s depending on the running

// version.

bool concat_xl(cpp_xloper &RetVal, const cpp_xloper &Inputs,

const cpp_xloper &Delim, const cpp_xloper &MaxLen,

const cpp_xloper &NumDecs, const cpp_xloper &NumScaling)

Inputs.GetArraySize(size);

bool scaling = NumScaling.IsNum();

double scale = scaling ? (double)NumScaling : 0.0;

if(num_decs >= 0 && Op.IsNum())

// Excel 11- interface function Uses xlopers

xloper * stdcall concat_xl4(xloper *inputs, xloper *p_delim,

xloper *p_max_len, xloper *p_num_decs, xloper *p_num_scaling)

// Excel 12+ interface function Uses xloper12s

xloper12 * stdcall concat_xl12(xloper12 *inputs, xloper12 *p_delim,

xloper12 *p_max_len, xloper12 *p_num_decs, xloper12 *p_num_scaling) {

cpp_xloper RetVal, Inputs(inputs), Delim(p_delim), MaxLen(p_max_len), NumDecs(p_num_decs), NumScaling(p_num_scaling);

concat_xl(RetVal, Inputs, Delim, MaxLen, NumDecs, NumScaling);

Description Parse the input string using the given separator (or comma by

default) and return an array Caller can request conversion of allfields to numbers, or to zero if no conversion possible Caller canspecify a value to be assigned to empty fields (zero by default).Type string "RCPP"(2003),"UC%QQ$"(2007)

Notes Registered name avoids conflict with the XLM PARSE()function

462 Excel Add-in Development in C/C++

// Core code function written in terms of cpp_xlopers to make it

// version-independent cpp_xloper class is version-aware and

// uses either xlopers or xloper12s depending on the running

// version.

bool parse_xl(cpp_xloper &RetVal, const cpp_xloper &Input,

const cpp_xloper &Delim, const cpp_xloper &Numeric,

const cpp_xloper &Empty, const cpp_xloper &NumScaling)

DWORD num_calling_cells = c_rows * c_cols;

wchar_t delimiter = Delim.IsStr() ? Delim.First() : L' ,' ;

wchar_t *input_copy = (wchar_t *)Input; // Work with Unicode strings wchar_t *p_last = input_copy, *p;

DWORD count = 1;

for(p = input_copy; *p;)

if(*p++ == delimiter)

++count;

RetVal.SetTypeMulti(c_rows, c_cols); // Same shape as caller

// CLIB strtok ignores empty fields, so must do our own tokenizing

DWORD i = 0;

bool numeric = Numeric.IsTrue();

bool have_empty_val = // single value types only

Empty.IsType(xltypeNum | xltypeStr | xltypeErr | xltypeBool);

bool scaling = NumScaling.IsNum();

double scale = scaling ? (double)NumScaling : 0.0;

// Fill the target range in row-by-row

if(count > num_calling_cells) // Need to avoid overwriting array bounds count = num_calling_cells;

// Need to convert p_last to a byte-string to convert to a double

// as there is no wchar equivalent of atof

// Excel 11- interface function Uses xlopers and byte-string

xloper * stdcall parse_xl4(char *input, xloper *p_delim,

xloper *p_numeric, xloper *p_empty, xloper *p_num_scaling)

// Excel 12+ interface function Uses xloper12s and Unicode string

xloper12 * stdcall parse_xl12(wchar_t *input, xloper12 *p_delim,

xloper12 *p_numeric, xloper12 *p_empty, xloper12 *p_num_scaling)

to provide a few examples of useful functions, or slight improvements on existing ones,that also demonstrate some of the interface issues discussed in earlier chapters

1 See Jackson and Staunton, 2001, John Wiley & Sons, Ltd, for numerous examples of applications of these functions to finance.

464 Excel Add-in Development in C/C++

10.2.1 Pseudo-random number generation

A random number generator with a repeat cycle that is small compared to the number

of samples required is something that can seriously distort or hide behaviours of systemsbeing simulated using Monte Carlo methods Versions of Excel prior to 2003 (version 11)used a generator that would repeat results after 1,000,000 or so calls This was improved

in Excel 2003 with an algorithm, developed by Wichman and Hill, that produces at least

1013 distinct iterations (see MSDN KB 828795) If you you need 2003-quality results in

an earlier version you should consider implementing your own equivalent ofRAND() Oneimportant thing to ensure is that your generator is thread-safe, as it is precisely this sort

of application, Monte-Carlo simulation, where you will want to take advantage of 2007’smulti-threading The following structure implements the algorithm used by Excel 2003,

in a thread-safe way when running 2007+, and is used in the examples on the CD ROM.Note that even when running Excel 2003+, it is significantly more efficient to call yourown implementation ofRAND()than Excel’s via the C API

// Algorithm used by Excel 2003, wrapped in a thread-safe structure.

// Wichman, B.A and I.D Hill, Algorithm AS 183:

// An Efficient and Portable Pseudo-Random Number Generator,

// Applied Statistics, 31, 188-190, 1982.

// Wichman, B.A and I.D Hill

// Building a Random-Number Generator, BYTE, pp 127-128, March 1987.

if(ix_seed < 1 | | ix_seed >= 30000) ix_seed = SEED_1_DFT;

if(iy_seed < 1 | | iy_seed >= 30000) iy_seed = SEED_2_DFT;

if(iz_seed < 1 | | iz_seed >= 30000) iz_seed = SEED_3_DFT;

CRITICAL_SECTION cs_rand; // Only used when version is 12+

int ix, iy, iz;

};

ts_rand rand_xl2003(SEED_1_DFT, SEED_2_DFT, SEED_3_DFT);

The following function provides a wrapper to an instance of the above structure.Function

name

xll_rand_xl4orxll_rand_xl12(exported)RandXll(registered with Excel)

Description Takes three optional seed arguments which if all between 1 and

30,000 reinitialises the algorithm

&& pSeed2->xltype == xltypeNum

&& pSeed3->xltype == xltypeNum)

&& pSeed2->xltype == xltypeNum

&& pSeed3->xltype == xltypeNum)

{

466 Excel Add-in Development in C/C++

If the function is called from a worksheet with three valid numeric values then thegenerator will be reinitialised with every recalculation, as the function is (needs to be)declared as volatile This makes it possible to fall into the trap of generating the same set

of numbers every time, clearly, not what is required However, it provides the ability togenerate the same sequence repeatedly, useful if you want to test what impact a change

of pricing method has independent of the pseudo-randomness of the sequence, or if youwant to start with your own ‘random’ seed

You may also want to implement a non-volatile version where the function is onlycalled as a result of a trigger value changing This trigger could be the return value ofanother call to this function or some other value that might, say, be changed under thecontrol of a macro or external data The advantage of this approach is, of course, betterrecalculation times as a result of only calling the function when you really need to

Function

name

xll_rand_non_vol_xl4orxll_rand_non_vol_xl12

(exported)

RandXllnv(registered with Excel)

Description Takes a numeric trigger and three optional seed arguments which if

all between 1 and 30,000 reinitialises the algorithm

Type string "BPPPP"(2003),"BQQQQ$"(2007)

Notes Function recalculation is driven by the trigger argument instead of

being volatile

double stdcall xll_rand_non_vol_xl4(double trigger, xloper *pSeed1,

xloper *pSeed2, xloper *pSeed3)

10.2.2 Generating random samples from the normal distribution

The next two functions return samples from the normal distribution based on the Muller transform of a standard random variable (See Clewlow and Strickland, 1998,modified to use half-tan formulae to minimise trigonometric function calls.)

Box-Function

name

nsample_BM_pair(exported)NsampleBoxMullerPair(registered with Excel)Description Takes an array of two uncorrelated uniform random numbers in the

range (0, 1] and returns two uncorrelated samples from the normaldistribution as a 1× 2 or 2 × 1 array, depending on the shape of theinput array

Type string "1K"(2003),"1K$"(2007)

Notes Makes use of the floating point array structure,xl4_array, for

input and output (See section 6.2.2 on page 129.) Does not need tomanage memory and is therefore fast Only drawback is the limitederror handling: any error in input is reflected with return values of 0

#define PI 3.14159265358979323846264

void generate_BM_pair(double &z1, double &z2)

{

// Use Excel 2003' s algorithm to generate std random numbers.

// More reliable than earlier Excel algorithms and calling

// this implementation of it is much faster than calling

// back into Excel with xlfRand.

double r1 = rand_xl2003.get();

double r2 = rand_xl2003.get();

// Use half-angle tan formulae to minimise trig fn calls

double t = tan(r2 * PI), tt = t * t;