c# pdf library mit license : Rename pdf files from metadata Library control component asp.net azure html mvc Wiley%20Advanced%20Modelling%20in%20Finance%20using%20Excel%20and%20VBA9-part604

84
Advanced Modelling in Finance
4.7 FUNCTIONS WITH ARRAY OUTPUT
All the functions described so far return values to individual cells (i.e. scalar output).
Sometimes, we want functions to return arrays of values, similar to the LINEST function
which returns a 5 by (k C 1) array of regression results for a data set with k explanatory
variables. Generally, functions with array output are a little more difficult to code in
VBA because of the need to correctly configure and construct arrays. In addition, the
user needs clues as to the appropriate range to be selected for formula entry using the
function. The function name can be used to suggest vector or matrix output, and the
function description in the function dictionary can include the dimensions of the output.
In the code, the variable names and variable type declarations can indicate whether vectors
are manipulated element-by-element or as a whole.
The approach is illustrated with an example from descriptive statistics: summarising
the distribution of a data set with percentiles. The objective is to obtain from a function
the vector or matrix of computed values.
Suppose the data comprises a large set of price data, such as that shown in the first
column of the sheet Data in Figure 4.5 and named dvec. Note that only 12 prices out of
the 120 values in the data set are displayed in the figure.
The prices below which 10% of the values lie, 20% lie, 30% lie, etc. are called the
‘deciles’ of the distribution. They are simply special cases of the percentiles of the cumu-
lative distribution. Just as the average of the data array called dvec can be evaluated with
an Excel function, the PERCENTILE function produces the various percentiles. When
the 0% value or minimum price is included, there are 11 deciles. These are displayed
in Figure 4.5 together with the relevant percentages. When plotted, the 11 by 2 array of
values displays the shape of the cumulative distribution of the data. Hence the objective
is to code a function that returns an 11 by 2 matrix of values.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
A
B
C
D
VBFns.xls
Data for Summary
count
120
mean
250.10
stdev.
1.04
dvec
deciles
percent
249.1
247.40
0%
250.8
248.69
10%
250.1
249.18
20%
252.1
249.60
30%
247.9
249.90
40%
250.7
250.10
50%
251.2
250.44
60%
249.8
250.73
70%
251.9
251.00
80%
251.8
251.40
90%
250.0
252.60
100%
248.8
Figure 4.5 Data with summarising deciles from the DecilesMat function
Rename pdf files from metadata - add, remove, update PDF metadata in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Allow C# Developers to Read, Add, Edit, Update and Delete PDF Metadata
pdf metadata reader; modify pdf metadata
Rename pdf files from metadata - VB.NET PDF metadata library: add, remove, update PDF metadata in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Enable VB.NET Users to Read, Write, Edit, Delete and Update PDF Document Metadata
pdf metadata extract; clean pdf metadata
Writing VBA User-defined Functions
85
The code for this function, DecilesMat(dvec), is set out below. Since the dimensions
of the array are known, the array variable can be declared from the start with these
dimensions(Dimdecmat(11,2)). The first column holds the decile values, obtained from
the Excel PERCENTILE function; the second column holds the relevant percentages, 0%,
10%, 20%, etc.
OptionBase 1
Function DecilesMat(dvec)
’returns 11by 2array of deciles ready for X-Y plot
Dim i As Integer
Dim decmat(11, 2) As Variant
’output array
For i = 0 To10
decmat( i + 1, 1) = Application.Percentile(dvec, 0.1
Ł
i)
decmat( i + 1, 2) = 0.1
Ł
i
Next i
DecilesMat = decmat
End Function
To apply the function, an 11 by 2 cell range is selected, the array formula is typed or
entered via the function dictionary specifying the relevant data set, then the keystroke
combination CtrlCShiftCEnter to enter the matrix of values.
4.8 USING EXCEL AND VBA FUNCTIONS IN USER-DEFINED
FUNCTIONS
As we have already seen, standard Excel functions such as COUNT and SUMPRODUCT
can be used in VBA code when prefaced with Application. or WorksheetFunction.
Until recently, a useful ‘List of Worksheet Functions available to Visual Basic’ could be
accessed via the Excel Visual Basic Help. However, it has proved illusive to locate in
recent upgrades of Excel. When last viewed, although most could be used in VBA code,
not all the standard functions were listed. Incorporating Excel functions where possible
both capitalises on the user’s knowledge of Excel and reduces the task of coding functions
reliably.
In addition, VBA provides a range of built-in functions as does the Analysis ToolPak,
and their usage is briefly outlined in the following paragraphs.
4.8.1 Using VBA Functions in User-Defined Functions
VBA functions such as MsgBox, InputBox, etc. are used without any prefix. There are
ahandful of Excel functions that are duplicated by standard VBA functions, such as the
Excel SQRT function duplicated by the Sqr function in VBA. In writing functions, the
VBA function must be used in preference to its Excel double.
VBA has a tiny number of maths functions as follows: Abs, Atn, Cos, Exp, Log,
Randomize, Rnd, Sgn, Sin, Sqr and Tan. You can confirm this by browsing the VBA
library in the Object Browser from within the VB Editor, then choosing the Math func-
tions. All except Randomize have Excel equivalents–the corresponding Excel functions,
in those cases where the names are different, are ATAN, LN, RAND, SIGN and SQRT.
There are also several ‘conversion’ functions available in VBA: useful ones are Fix,
Hex, Int and Oct. If you enter the function in lower case letters you should see the function
name capitalised automatically if VBA recognises the function.
C#: How to Add HTML5 Document Viewer Control to Your Web Page
You can rename this folder, but at _tabDemoFiles = new ToolbarTab("Sample Files"); //Scenario 1 _userCmdDemoPdf = new UserCommand("pdf"); _userCmdDemoPdf.addCSS
pdf xmp metadata; edit multiple pdf metadata
C# HTML5 Viewer: Deployment on ASP.NET MVC
Right-click Home and select "Add New Item", pop-up box as follows, select MVC 3 View Page (ASPX) and rename it. RasterEdge.XDoc.PDF.dll.
pdf xmp metadata viewer; pdf keywords metadata
86
Advanced Modelling in Finance
To summarise, VBA functions must be used in preference to their Excel equivalents.
They are used in VBA code without the Application. prefix.
4.8.2 Add-Ins
The Analysis ToolPak (ATP) containing additional functions such as COUPDAYS, LCM
and MULTINOMIAL is an add-in to Excel. If the Tools menu in Excel does not contain
the Data Analysis option then (as described in section 2.9) the Analysis ToolPak must be
installed. Following installation you should be able to see the ATP functions written in
upper case in the function dictionary.
To use ATP functions in VBA module sheets you must do two things:
1. In Excel, use the Tools then Add-Ins command to install the Analysis ToolPak–VBA.
The VBA equivalent functions will then appear as duplicates in the function diction-
ary, though in mixed case.
2. From within the VB environment, use the Tools then References command to link
to the ATPVBAEN.xla file. (This file was added in during step 1.) ATP functions
can now be used in VBA code just like standard VBA functions (i.e. without the
Application. prefix). Without the reference, VBA will not recognise the functions.
4.9 PROS AND CONS OF DEVELOPING VBA FUNCTIONS
In reflecting on the advantages and disadvantages of developing functions for spreadsheet
calculations, the following points are worth making.
Pros
When compared to spreadsheet calculations and complex cell formulas, functions have the
advantage of compressing extensive calculations into one cell. Provided it is programmed
accurately and intelligibly named, the user-defined function can pack considerable power
into a single cell. Entering functions into cells is less error prone than entering complex
cell formulas. If the functions and arguments are clearly and sensibly named, they are
easier for semi-expert users to deal with than complex formulas. To ensure user confi-
dence in functions, it is most important that the VBA code is clearly annotated and
documented.
Functions also have the advantage of portability, since they can be used in any work-
book, provided their VBA code can be accessed. The best way to make function code (in
ModuleA1, book A say) available to another workbook (book B) is to copy the required
code to a Module sheet in B (ModuleB1 say). Note that activating the Code window
for ModuleA1 then copying and pasting to ModuleB1 in the usual manner achieves this.
Do not attempt to ‘export’ the Module sheet from the Project Explorer window. With
portability in mind, it is sensible to group the code for related functions into the same
module sheet, for example, ModuleB1 in VBFNS contains code for all the Black–Scholes
related functions.
Functions are also extendable (e.g. a function written for a portfolio of three assets
holds for any number of assets). With a little ingenuity, they can be generalised (e.g. the
addition of the iopt argument in the BSOptValue Function means the function can be used
for puts as well as calls).
Writing VBA User-defined Functions
87
Sometimes, the existence of a function means that complicated structures do not need to
be constructed in the spreadsheet. For example, there is no need to replicate the binomial
tree structure for different numbers of steps if the number of binomial steps is an argu-
ment in the function. (See Appendix 4B where the development of a function for option
valuation via a binomial tree is described.)
Cons
Some people mention the need to grapple with VBA as a disadvantage of user-defined
functions. However, it should be emphasised that familiarity with only a small subset
of VBA is needed for coding functions. The syntax and control structure required for
function writing are essentially Basic programming. This is the traditional programming
not the object-oriented part of the VBA language.
Impossible Tasks for Functions
Some operations cannot be programmed into functions. Short of rewriting the linear
programming code in VBA, or inserting temporary dummy sheets, optimisations using
Solver cannot be written as functions. Similarly, operations that require actions like
constructing a chart or formatting the colour of a cell depending on its numerical value
are not easily achievable with functions.
Following the Summary section, Appendix 4A illustrates several aspects of using
Excel’s matrix functions to manipulate arrays. Then in Appendix 4B functions for bino-
mial tree valuation of options are described. Some simple exercises on function writing
follow, together with brief solution notes.
SUMMARY
Developing VBA functions capitalises on the user’s knowledge of spreadsheets and of
Excel’s functions. Programming is involved, but at a straightforward and intuitively
obvious level.
In contrast to subroutines that perform actions with objects, VBA functions are proced-
ures which return values, any calculations involved being carried out ‘off-sheet’. A key
distinction is that Function procedures are ‘passive’, that is, the code within the function
cannot manipulate ranges.
Most of Excel’s extensive range of built-in functions can also be included in user-
defined functions: in the VBA code, they are referenced by name with the prefixAppli-
cation.or WorksheetFunction.VBAalsoprovidesarangeofitsownfunctions,which
need no prefix, and can be referenced in the Object Browser.
User-defined functions take arguments, which can be numericalvalues, single cell inputs
and array inputs. Function arguments are implicitly declared in the Function statement,
and therefore need not be explicitly declared. All other variables used in the function
code should be declared and data-typed where appropriate.
Functions can return single values or arrays of values. Generally, functions that handle
array input and return arrays of values are more difficult to code.
User-defined functions are used in the spreadsheet either by typing in their names and
arguments or via the Paste Function button. They are listed in the function dictionary in
the User-Defined category. It is possible to briefly document what the function does and
88
Advanced Modelling in Finance
what inputs are required, so that some helpful text appears in the Function Dictionary
dialog box when the function is entered.
In the case of complex functions, it is sensible to adopt a modular approach, building
aseries of intermediate functions, which individually can be tested out.
APPENDIX 4A FUNCTIONS ILLUSTRATING ARRAY
HANDLING
The first example, Function ArrayDemo1, illustrates the use of Excel’s matrix multipli-
cation and inversion functions. For the function to work, both Amat1 and Amat2 must
be square matrices and of the same dimensions. Because all processing of the individual
elements of the matrices is taken care of by Excel functions, the code is particularly
straightforward. The product of the matrix multiplication, named Amat12 to indicate that
it is a matrix, is declared as a variant to reinforce the fact that it is non-scalar in type and
dimension:
Function ArrayDemo1(Amat1, Amat2)
’uses the MMultand MInverse array functions
Dim Amat12 As Variant
Amat12 = Application.MMult(Amat1, Amat2)
ArrayDemo1 = Application.MInverse(Amat12)
EndFunction
If a matrix and vector are to be multiplied together, it is important that the dimensions
conform. If Amat1 is a 3 by 3 matrix and avec a 3 by 1 column vector, if the matrix is
‘post’multiplied by the vector, the result is a 3 by 1 column vector. Function ArrayDemo2,
with inputs avec and Amat1, produces a column vector:
Function ArrayDemo2(avec, Amat1)
’multiplying matrix (Amat1) and col vector (avec)
ArrayDemo2 = Application.MMult(Amat1, avec)
EndFunction
Alternatively, if the vector is transposed into a row vector, it could ‘pre’multiply the
matrix, Amat1, but the result would be different, in fact a 1 by 3 row vector. The third
line of code would need to be modified to read as:
ArrayDemo2 = Application.MMult(Application.Transpose(avec), Amat1)
In general we code functions such that they behave in a comparable manner to Excel
functions. That is, we require functions with array input to accept either row or column
arrays. Where the function returns an output vector, the output is a row vector. Function
ArrayDemo3 returns a row vector, whatever the form of the input avec (i.e. whether avec
is a row or column vector). If avec is a column vector, its rows will exceed its columns
in number, and this condition will cause the vector to be transposed into a row vector.
Otherwise it is already in the correct format. Function ArrayDemo3 returns a row vector,
whatever the input vector:
Function ArrayDemo3(avec)
’returninga row vector, whatever the input
Dim nr As Integer, nc As Integer
nr = avec.Rows.Count
nc = avec.Columns.Count
If nr >= nc Then avec = Application.Transpose(avec)
Writing VBA User-defined Functions
89
ArrayDemo3= avec
End Function
The next function, ArrayDemo4, illustrates how arrays can be set up element-by-
element within VBA code. The important point to note is that these constructed arrays
are row vectors by default. For this reason, the matrix multiplication operation should
work as coded and a row vector will be returned:
OptionBase 1
Function ArrayDemo4(Amat1)
’VBA sets up array avec as row array
Dim avec(3) As Variant
avec(1) = 3
avec(2) = 4
avec(3) = 5
ArrayDemo4= Application.MMult(avec, Amat1)
End Function
Alternatively, if the penultimate line of code is:
ArrayDemo4 = Application.MMult(Amat1, Application.Transpose(avec))
a different matrix multiplication operation will return a column vector with different
values.
The Option Base 1 statement at the top of the module sheet ensures that the array
elements number from 1 as is usual in Excel operations. If the Option Base declara-
tion is omitted, the elements number from 0 (the default) (and the subsequent matrix
multiplication will fail because of non-conformity). Here, the Option Base statement
ensures that elements in array avec are simplyavec(1),avec(2)andavec(3), and that
there is noavec(0).
Where no suitable Excel array functions exist for the required manipulation of arrays,
element-by-element processing in a loop may be unavoidable. If so, the number of
elements in the array must be counted and this is easily achieved with code such as
Application.Count(avec). (For an array created within a user-defined function, the number
of elements can also be evaluated using the UBound (and LBound) properties of an
array.)
APPENDIX 4B BINOMIAL TREE OPTION VALUATION
FUNCTIONS
The Black–Scholes formula gives values for straightforward European calls and puts. An
alternative numerical approach to option valuation, which can be applied to a wide range
of options, is the binomial tree method. This approach approximates the development
of share prices over the option life by a series of linked probabilistically-determined
binomial steps (at which incremental share movements are restricted to up and down
movements of known size). This binomial tree structure produces a share price tree with
aspread of ending prices and a cluster of paths through the tree of differing frequency.
For each ending node in the tree, the option on the share can be valued and, using the
probabilistic structure of the tree, the option payoff can be discounted back to get its
present value.
90
Advanced Modelling in Finance
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
A
B
C
D
E
F
G
H
I
CRR Option Valuation
Share price (S)
100.00
Cox, Ross & Rubinstein
Exercise price (X)
95.00
Int rate-cont (r)
8.00%
dt
0.0556
erdt
1.0045
Dividend yield (q)
3.00%
ermqdt
1.0028
u
1.0483
Time now (0, years)
0.0000
d
0.9540
Time maturity (T, years)
0.5000
p
0.5177
Option life (T, years)
0.5000
p*
0.4823
Volatility (s)
20.0%
European
American
Steps in tree (n)
9
via CRRtree
9.63
iopt
1
via fn
9.63
9.63
option type
Call
BS value
9.73
Figure 4.6 Option valuation via CRR binomial tree method
The spreadsheet in Figure 4.6 shows details of the call option evaluated previously (with
the Black–Scholes function BSOptValue in cell G17) together with the components of
anine-step binomial tree. The life of the option (T D 0.5 years) is split into nine time
steps each of length υt (here 0.0556 years). The objective is to develop a second option
valuation function, this time based on the tree valuation method. To understand the VBA
code, it is important to understand how valuation occurs in the binomial tree and hence a
short digression into the mechanics of the approach is in order. However, in the function
to be developed, computation of the binomial tree and the option payoffs at maturity are
all contained in the code of the function itself.
The values of the share price up and down multipliers (u and d) and the associated
probabilities p and p
Ł
used at each step are due to Cox, Ross and Rubinstein (CRR).
Their formulas ensure that the resulting share price tree is consistent with the geometric
diffusion process considered by practitioners to be realistic for share price processes. The
detailed formulas for u, d, p and p
Ł
need not concern us here, but when applied to the
starting price and repeated for all nine steps, these give rise to the share price tree shown
in Figure 4.7 below.
17
18
19
20
21
22
23
24
25
26
27
28
29
30
A
B
C
D
E
F
G
H
I
J
K
Binomial Tree Valuation
Share
0
1
2
3
4
5
6
7
8
9
9
152.85
8
145.81
139.09
7
139.09
132.69
126.58
6
132.69
126.58
120.75
115.19
5
126.58
120.75
115.19
109.89
104.83
4
120.75
115.19
109.89
104.83
100.00
95.40
3
115.19
109.89
104.83
100.00
95.40
91.00
86.81
2
109.89
104.83
100.00
95.40
91.00
86.81
82.81
79.00
1
104.83
100.00
95.40
91.00
86.81
82.81
79.00
75.36
71.89
0
100.00
95.40
91.00
86.81
82.81
79.00
75.36
71.89
68.58
65.43
Figure 4.7 Nine-step share price tree using CRR parameters
Writing VBA User-defined Functions
91
Starting at value 100, one step later the two possible prices are 104.83 (100u) and 95.40
(100d). After nine steps, a share that has i up moves (and (9  i) down moves) will have
value 100u
i
d
9i
,or more generally for an n-step tree:
S
in
DSu
i
d
ni
It follows that the 10 payoffs of the associated option at expiry, as shown in cells K49:K58
of Figure 4.8, are given by the formulas:
max[S
i
X, 0] for i D 0, 1, ...,9 and S D 100, X D 95
For example, for nine up movements the option value is:
max[1001.048
9
95, 0] D 57.85
The last operation is to value this vector of cells, K49:K58, weighting each by its
probability of occurrence and discounting back to time 0. This involves ‘rolling back’ the
terminal option payoffs, using the up and down probabilities, p and p
Ł
,and discounting
to get values at step 8 in time, and so on back to their present value. For example at
step 8, the option value in cell J50 is [57.85p C 44.09p
Ł
]/1.0045 D 50.99. The steps are
displayed numerically in Figure 4.8, so that the final option value via binomial valuation
is shown in cell B58 (9.63 as compared with the Black–Scholes value of 9.73).
47
48
49
50
51
52
53
54
55
56
57
58
A
B
C
D
E
F
G
H
I
J
K
Option Value
0
1
2
3
4
5
6
7
8
9
9
57.85
8
50.99
44.09
7
44.47
37.89
31.58
6
38.29
32.00
25.97
20.19
5
32.41
26.41
20.65
15.13
9.83
4
26.84
21.10
15.60
10.32
5.25
0.40
3
21.65
16.27
11.24
6.67
2.81
0.20
0.00
2
16.98
12.13
7.79
4.15
1.50
0.11
0.00
0.00
1
12.96
8.76
5.23
2.52
0.80
0.05
0.00
0.00
0.00
0
9.63
6.15
3.42
1.50
0.42
0.03
0.00
0.00
0.00
0.00
Figure 4.8 Rolling back and discounting option values
The VBA code for the BinOptVal function, based on the CRR tree, is shown below. The
statementOptionBase0at the top of the Module sheet is strictly speaking unnecessary.
It merely confirms that for this function, all arrays number from 0, which is the default
numbering anyway. The function has eight inputs, includingnstep, the number of steps in
the tree. For the moment, the function returns the value of a European option (withiopt=1
for a call,iopt=–1 for a put). At the end of the section, we note how straightforward it
is to extend the function code to cover American options as well as the simpler European
versions:
Option Base 0
’arraysnumber from 0
Function BinOptVal(iopt, S, X, r, q, tyr, sigma, nstep)
‘codefor European Options
92
Advanced Modelling in Finance
’returns binomial option value, European only, where iopt = 1 for call, -1 for put
Dim delt, erdt, ermqdt, u, d, p, pstar
Dim i As Integer, j As Integer
Dim vvec As Variant
ReDim vvec(nstep) ‘known size ofvector
’calculate parameters
delt = tyr / nstep
’length of time step
erdt= Exp(r
Ł
delt)
’compounding factor
ermqdt = Exp((r-q)
Ł
delt)
’drift term
u= Exp(sigmaŁ Sqr(delt))
’up multiplier
d= 1 / u
’down multiplier
p= (ermqdt - d) / (u - d)
’up prob
pstar = 1 - p
’down prob
’calculating vector of option values after n steps
For i = 0To nstep
vvec(i) = Application.Max(iopt(S(uOi)(dO(nstep-i))-X), 0)
Next i
’calculating conditional payoffs & discounting backstep-by-step
For j = nstep - 1 To 0 Step -1
For i = 0 To j
vvec(i) = (p
vvec(i + 1) + pstar
vvec(i))/erdt
Next i
Next j
BinOptVal = vvec(0)
EndFunction
The valuation process centres on vector array vvec(), declared as a variant type. For
nstep =9, vvec() has10 values,vvec(0) to vvec(9), asensured by the dimensioning
statementReDimvvec(9), in generalvvec(nstep).
After declaring variables, the CRR tree parameters for the up and down price
movements are assigned. For the call option shown in Figure 4.6, the initial values
of vvec() are vvec(0) D 57.85, vvec1 D 44.09, ...vvec(9) D 0, i.e. the option payoffs
shown in K49:K58 of Figure 4.8. In the VBA code, these values are derived from formulas
of the form:
max[Su
i
d
nstepi
 X,0] i D 0,1, 2,. ..,nstep
The statements producing the initial vvec() array are:
For i = 0 To nstep
vvec(i)=Application.Max(ioptŁ(SŁ(uOi)Ł(dO(nstep-i))-X), 0)
Next i
The subsequent five lines of code drive the process of working backwards through the
tree, valuing and discounting:
For j = nstep - 1 To 0Step -1
For i = 0 To j
vvec(i) = (p
Ł
vvec(i+1)+pstar
Ł
vvec(i))/erdt
Next i
Next j
Examining the code, at each backwards step (j value), the vvec() array is recalculated,
replacing redundant values with new values as the option is valued. This has the advantage
Writing VBA User-defined Functions
93
of limiting storage requirements to a single vector with only (n C 1) elements. Thus for the
nine-step tree, when j D 8, vvec() is re-evaluated, the entries changing to vvec(0) D 50.99,
vvec(1) D 37.89, etc. and when finally j D 0, vvec(0) becomes 9.63. (In the spreadsheet
in contrast, working backwards through the tree from step 9 to step 0 requires us to
display 10 vectors of values, see Figure 4.8). Thus, the present value of the option is
contained in vvec(0) when j D 0.
Using this function to evaluate the call via a nine-step tree as in cell G15, we have:
BinOptVal(1, 100, 95, 8%, 3%, 0.5, 20%, 9)
which returns the value 9.63. In general the closeness of the binomial tree option valuation
to the Black–Scholes value should improve as the number of steps increases. For example,
BinOptVal(1, 100, 95, 8%, 3%, 0.5, 20%, 50) evaluates as 9.74. The proximity of binomial
valuation to the Black–Scholes value can be checked out by constructing a Data Table
on the function, varying the number of steps, nstep.
Figures 4.6, 4.7 and 4.8 show the binomial tree valuation of a call. If the option is a
put, input parameter iopt D 1, and the VBA function statements producing the initial
vvec() array:
For i = 0To nstep
vvec(i)=Application.Max(-1*(S*(uOi)
Ł
(dO(nstep-i))-X), 0)
Next i
give terminal outcomes for the put. Check that for a put:
DBinOptVal(1, 100, 95, 8%, 3%, 0.5, 20%, 9)
evaluates as 2.40 as compared with 2.49 for the Black–Scholes value.
American options in contrast to European ones allow the possibility of early exercise,
that is, exercise before the option matures. It has been shown that early exercise is never
preferable for American calls (in the absence of dividends), so their valuation is exactly
the same as European calls. However, for American puts, early exercise is frequently more
valuable than waiting until maturity. To adjust the VBA code in the valuation function,
BinOptVal, one additional input parameter (iea D 1 for European, iea D 2 for American)
is introduced and just one additional line of code is required:
’for Amer options, allowing for early exercise at eachstep
If iea=2 Thenvvec(i)=Application.Max(vvec(i), iopt
Ł
(S
Ł
(uOi)
Ł
(dO(j-i))-X))
The full code for this generalised binomial valuation function, which works for both
European and American calls and puts, is set out below:
Function BinOptVal(iopt, iea, S, X, r, q, tyr, sigma, nstep)
’returns binomial option value (iopt = 1 for call, -1 for put;
’iea=1for euro, 2 for amer)
Dim delt, erdt, ermqdt, u, d,p, pstar
Dim i As Integer, j As Integer
Dim vvec As Variant
ReDim vvec(nstep)
’known size of vector
’calculate parameters
delt = tyr / nstep
’length oftimestep
erdt = Exp(r
Ł
delt)
’compoundingfactor
Documents you may be interested
Documents you may be interested