A stochastic mesh size simulation algorithm for pricing barrier options in a jump-diffusion model

Transcription

1 Journal of Applied Operational Research (2016) Vol. 8, No. 1, A stochastic mesh size simulation algorithm for pricing barrier options in a jump-diffusion model Snorre Lindset 1 and Svein-Arne Persson 2, 1 Norwegian University of Science and Technology, Trondheim, Norway 2 Norwegian School of Economics, Bergen, Norway ISSN (Print), ISSN (Online) Received 17 March 2016 Accepted 11 August 2016 Keywords: Barrier options Jump-diffusion Simulations Stochastic mesh size Abstract We present a heuristic simulation algorithm for pricing barrier options when the price process for the underlying asset is a jump-diffusion. Our algorithm uses the stochastic number and stochastic timing of jumps to determine the simulation mesh size so that the price of the underlying asset is estimated at each jump time. Compared to other approaches, it is more useful in situations with frequent jumps and where knowledge of the complete price path of the underlying asset is required. Published 01 December 2016 Copyright ORLab Analytics Inc. All rights reserved. Introduction A financial option is a specialized instrument whose final payoff and intermediate value depend on the price of a specific underlying asset. The major breakthrough in option pricing are the articles by Black and Scholes (1973) and Merton (1973) (see Duffie (1998) for a detailed and interesting explanation of each article s contribution). However, the standard option pricing formulas do not apply to all kinds of options nor can they be used in more general economic models. Various numerical methods have been developed to price options where no closed form solutions are available. This paper presents an algorithm applicable for a jump-diffusion model, i.e., a more general model than the so-called standard model (where the possibility of jumps is not included). A barrier option is one special type of option that is widely used in the financial market place. Barrier options contain conditions, which activate or deactivate a future potential positive payoff when barriers are crossed. For example, a barrier knock-out option has the feature that if the underlying asset price crosses a contractual barrier (H) before the expiration date, the option is knocked-out and becomes worthless. Due to the options path-dependency of the underlying asset price, numerical pricing of barrier options is computationally demanding, see, e.g., Gobet (2009). For traders and market makers it is important that price estimates are easy to obtain without resorting to lengthy computations. Having fast and efficient pricing algorithms is also important for risk managers who need to calculate price estimates for a wide range of different assets under different scenarios. One should strive for short computation times and unbiased estimates. It is common to assume that asset prices follow specific stochastic processes. The standard model for asset prices used in the literature is a geometric Brownian motion, i.e., a diffusion process. Merton (1976) extends the price process to also include jumps. There is a large literature in financial economics documenting the empirical importance of jumps in asset prices. Jorion (1989) finds statistical evidence that there are discontinuities in asset prices, particularly in foreign exchange rates. Clifford and Ball (1985) confirm that there are statistically significant jumps in the daily returns on common stocks listed on the New York Stock Exchange. Carr, Geman, Madan, and Yor (2002) find that the (risk adjusted) price process for stocks can be described by a pure jump process. Thus, the underlying asset can be a share of stock, an exchange rate, or some other asset. In corporate finance applications, it is often assumed that the underlying asset is a company s total asset portfolio, i.e., the asset side (left-hand) of the balance sheet. First passage time distributions are important when pricing barrier options in closed form. The probability distribution for the first-passage time for a Brownian motion is well known and is given by the Inverse Gaussian distribution. Only for special cases, see e.g., Kou and Wang (2003), do similar distribution functions exist for jump-diffusion processes. In simulation experiments, we can only monitor the underlying asset price at a finite number of grid points, so there is a positive probability that the barrier is crossed an even number of times between two grid points. With an even number Correspondence: Svein-Arne Persson, Dept. of Finance, Norwegian School of Economics, Helleveien 30, NO 5045 Bergen, Norway svein-arne.persson@nhh.no

2 16 Lindset and Persson (2016) of crossings, the barrier breach will not be detected in the simulation and the option will not be knocked out, as it should have been. This possibility leads to severely biased price estimates unless surprisingly many grid points are used. Using many grid points is costly in terms of computation time. The goal of this paper is to present a heuristic simulation algorithm for pricing barrier options in a jump-diffusion model. We seek precise price estimates without resorting to lengthy calculations. The algorithm is based on the method of simulating jump times (method JT), as opposed to the method of simulating underlying asset prices at fixed dates (method FD). Method FD uses an intuitive brute-force discretization of the time dimension, see, e.g., chapter 3.5 of Glasserman (2004). To illustrate, we use an up-and-out call option as an example, although our method is applicable to any kind of barrier option. Our approach, based on method JT, is as follows: First, we simulate the jump times of the underlying asset price. We specify a maximum mesh size, corresponding to the fixed time space between grid points in method FD. In our algorithm the mesh size depends on both the length between jump times and the number of jumps, and may vary within one simulated path, and is always less than or equal to. There are two reasons for why our approach for pricing barrier options reduces the underestimation of the probability of a barrier breach: 1. Compared to method FD, the average mesh size is smaller. 2. If two or more jumps occur between two grid points in method FD, effects of positive and negative jumps partially offset each other, severely underestimating the probability of a barrier breach. By simulating the value of the underlying asset at each jump time, our approach avoids this problem. As an example illustrating point 2 above, consider the period between the two grid points t 1 and t 2. Assume that the only changes in the underlying asset price come from two jumps in this time period. The time t 1 asset price is 100 and the knock-out barrier H = 120. If the first jump is 30 and the second is -20, the asset price at time t 2 is 110. However, the option should have been knocked out because the first jump moved the underlying asset price above the barrier. Our numerical results indicate that it is important to reduce this second effect in order to obtain less biased price estimates. Broadie, Glasserman, and Kou (1997) (BGK) analyze the case with no jumps. To reduce the computation time, they suggest a clever way to adjust the barrier that is based on the mesh size and the volatility parameter (σ) of the diffusion process. The effectiveness of the BGK-correction is illustrated in Figure 1 (calculations are performed using Ox, see Doornik (1999)). By not including the correction, we see that even with grid points, the price estimate is severely biased. When we include the BGK-correction in the simulations, most of the bias in the price estimates has disappeared already at 10 to 25 grid points Number of grid points Figure 1. Estimated option prices for different number of monitoring points when the stock price follows a diffusion process. The upper curve shows estimates without barrier correction, the straight line shows the theoretical price (calculated by closed form solution), and the lower curve shows estimates using the BGK-correction. The corrected barrier is given by. See Table 1 for parameter values. Number of simulation runs is

3 Journal of Applied Operational Research Vol. 8, No The BGK-correction is only theoretically justified in the case where the underlying asset price process is a diffusion. Our results indicate that it works well also when the underlying price process is a jump-diffusion. In particular, in cases with frequent jumps our price estimates have low bias also for a coarse grid, i.e., for large values of. No general closed form solution for the option price is known in the jump-diffusion case. We want our algorithm to produce price estimates that are close to the (unknown) theoretical prices. We use the approach of Metwally and Atiya (2002) to obtain proxies for benchmark prices that our estimates can be compared to. Their approach is fast and it gives price estimates with low bias. Hence, these estimates are natural candidates for benchmark prices. As opposed to their approach, our approach traces out the whole price path of the underlying asset. Price paths may be of interest in some situations, for instance when analyzing performance sensitive debt (see e.g., Manso, Strulovici, and Tchistyi (2010) and Mjøs, Myklebust, and Persson (2013)). In this case the price path of the underlying asset determines the interest payments of a company s debt. Price paths can also be of interest for risk managers. The price process and option contract We use the jump-diffusion model first used in financial economics by Merton (1976). Let S t t 0 be a stochastic process on a given filtered probability space. In particular, Q represents a fixed equivalent martingale measure (risk neutral probability). Here S t is interpretable as the time t market value of the underlying asset and is given as the solution to the stochastic differential equation ds t = (r λy)s t dt + σs t db t + dj t, where r, λ, σ, S 0 R ++. Here, r is the risk-free interest rate, σ is the volatility parameter, B t is a standard Brownian motion, and In the above expression, N t t 0 is a Poisson process and ln Y h N (a, b), a, b R. Also, y = E[Yh ] 1 and λ is the intensity of the Poisson process. The parameter λ represents the expected number of jumps in one year. Note that the discounted stock price is a martingale, so that, for u t, where is the Q-conditional expectation. If the stock price crosses the constant barrier H > S 0, the option is knocked out, i.e., becomes worthless. If the barrier is not crossed before the expiration date T, the time T payoff of the option is π T = max(s T X, 0), where the constant X 0 is the exercise price, i.e., the price that the option holder is entitled to buy the underlying asset for at the expiration date. The time 0 price of the option is given by where 1 is an indicator function. In the case where X H, we trivially have that π 0 = 0. (1) The Pricing Algorithm In order to estimate option values, we use Monte Carlo simulations and simulate several price paths. The novelty of our algorithm is that it uses the random number of jumps and the jump times for each price path to determine the number of grid points. The discretization is (partly) event driven, where the jumps are the relevant events. Consider the time interval 0 to T. In method FD this interval is divided into M subintervals, each with length, i.e.,. The total number of grid points is M + 1. The combination of a coarse grid (a low M) and a high jump intensity

4 18 Lindset and Persson (2016) (high λ) will for many paths result in more than one jump in a subinterval. Jumps may move prices significantly, possibly resulting in barrier breaches. Clearly, it is of interest to observe the underlying asset price just after a jump has occurred. Method FD simulates the number of jumps between two grid points, not the jump times, so the exact jump times are not available by this method. In addition, two or more jumps of opposite sign simulated at the same grid point partially offset each other. The probability of a barrier breach is therefore underestimated, and the estimated prices are biased by method FD. Let us use the coarsest grid possible, i.e., M = 1, to illustrate how our algorithm works. With M = 1, the two grid points are 0 and T, i.e., the initial- and final time. Assume that a given path contains two jumps (N T = 2) at the time points t 1 and t 2, 0 < t 1 < t 2 < T. We simulate the underlying asset price at three points in time, t 1, t 2, and T. Thus, we have effectively increased the number of subintervals to 3 with step size 1 = t 1, 2 = t 2 t 1, and 3 = T t 2 for this price path. More generally, the number of subintervals generated by our algorithm is random. The realized number of subintervals for a given path, denoted by m, is determined by the number of jumps N T, and the individual jump times, as well as the parameter. Consider a fixed price path and define t 0 = 0 and t N(T)+1 = T. Consider two adjacent jump times t h and t h+1, t h < t h+1, for h = 0,..., N T. Let denote the integer part of z + 1, z R +. The number of subintervals in the interval [t h, t h+1 ] is, with mesh size, for h = 0,,N T. Figure 2 shows how two jumps can result in both three and four subintervals. Thus, not only the number of jumps, but also the timing of the jumps determines the number of grid points. For case II, 1 = 2 = 0.4 and 3 = 0.2. Observe that i < = 0.5, i = 1, 2, 3. For case III, 1 = 0.2, 2 = 0.1, and 3 = 4 = Also here i < = 0.5, i = 1, 2, 3, 4. For case III the remaining time after the last jump is T t 2 = 0.7 > = 0.5. The algorithm therefore allocates an additional grid point at time Pseudo codes for our algorithm as well as method FD are presented in Appendix A. Figure 2. Examples of jumps and mesh sizes. Here, t 1 and t 2 denote the first and second jump time. Table 1. Benchmark parameters. Parameter Symbol Value Time 0 stock price S(0) 100 Exercise price X 100 Barrier H 120 Volatility σ 0.2 Mean jump size location a Jump size dispersion b 0.01 Expiration time T 1 Continuously compounded risk free interest rate r 0.05

5 Journal of Applied Operational Research Vol. 8, No Numerical Results In this section, we present numerical results to illustrate the merits of our algorithm. The benchmark parameters are given in Table 1. We use the algorithm of Metwally and Atiya (2002) to obtain proxies for benchmark prices. This algorithm is based on a Brownian-bridge construction and is, as such, independent of the number of subintervals M. Figure 3 contains four panels with different jump intensities (λ = 30, λ = 20, λ = 10, and λ = 0.1). Each panel shows the benchmark prices, prices from the FD method, and prices from our algorithm. We report price estimates both with and without the use of the BGK-correction. Figure 3. Estimated option prices as functions of the parameter M for different jump intensities λ. Here, MA represents the benchmark prices, FD represents prices from the algorithm with fixed dates, and JT represents prices from our algorithm. The stars (*) indicate use of the BGK-correction. Without the BGK-correction, both FD and our JT estimates are upward biased, i.e., they are higher than the benchmark prices. The reason for this bias is that both methods underestimate the probability of barrier breach. From the three panels with the higher value of λ, we see that our estimates JT are, as expected from the previous discussion of our algorithm, less biased than the FD estimates. In the panel with λ = 0.1, there are few jumps in the simulated price paths. Consequently, method JT produces similar estimates as method FD. For the cases with BGK-correction, there is no visual bias between the price estimates JT* from our algorithm and the benchmark MA for λ = 30 and λ = 20. In comparison, the FD* estimates are significantly biased for these values of λ. For λ = 10, both FD* and JT* have low bias. Again, for λ = 0.1 the estimates FD* and JT* are similar. Also note that for low values of M and λ = 30, the estimates from our algorithm JT, without BGK-correction, are less biased than the BGKcorrected FD* estimates. Tables 2 and 3 present price estimates for up-and-out call option prices. The FD* and JT* prices are estimated for different number of grid points (M + 1). The first panel of Table 2 contains estimates for the case = 30 and the second panel contains estimates for the case = 20. Table 3 contains the corresponding estimates for = 10 and = 0.1. The estimates are based on Monte Carlo simulations with million simulation runs. I.e., we estimate the expectation in equation (1) by averaging over the simulated (stochastic) option payoffs. The price estimates are therefore random variables. The tables report estimates of the standard errors of the price estimates (given in parentheses). The

6 20 Lindset and Persson (2016) computation times for method FD* and method JT* differ. The tables also report normalized computation times (reported in square brackets). The MA columns are the benchmark price estimates (found using the algorithm proposed by Metwally and Atiya (2002) with simulation runs). Table 1 reports the model parameter values we use when estimating the option values. Table 2. Comparison of algorithms for high values of for different number of subperiods M The standard errors of the price estimates are similar both across M and across the two estimation methods. For each panel of the two tables, we set the computation time for M = 1 for our proposed algorithm (column JT*) to 1 and report other computation times relative to this time. The relative computation times reported in Table 2 and in the first panel of Table 3 are higher for our proposed algorithm, compared to the computation times for FD. The explanation is that higher jump intensities result in more frequent jumps. Our algorithm then dictates a higher number of grid points, which is computationally demanding. The corresponding computation times, reported in the second panel of Table 3, are higher for JT for lower values of M and are lower for higher values of M. In the introduction we identify two reasons for why our algorithm works: It generates a finer grid than the FD method, and it eliminates the problem of netting, i.e., positive and negative jumps in the underlying asset price cancel. These two properties reduce the underestimation of the probability of a barrier breach, which again reduce the bias in the price estimates. If the reduction of the mesh size was the only effect from our algorithm, this could easily be compensated for in method FD by increasing the number of grid points. We use this insight to disentangle the effects from the two properties mentioned above. The number of grid points used in our algorithm is random. For any path, the number of grid points is never smaller than the number of grid points from the FD algorithm, but often larger. Thus, the average number of grid points from our algorithm is higher than the number of grid points from the FD approach. See Figure 4 for examples of frequency distributions of the number of grid points for the case where M = 10. To control for the increased number of grid points (property one), we increase the number of grid points in the FD approach to the average number from our algorithm, rounded upwards to the nearest integer. We label this approach FD 1 *. The results using approach FD 1 * are illustrated in Figure 5. These estimates are typically less biased than the estimates FD*, confirming our understanding that the number of grid points is important for the size of the discretization bias. However, for high the FD 1 * estimates are more biased than the corresponding JT* estimates. This observation indicates that it is not only the number of grid points that is important to reduce discretization bias, but also the timing of the jumps. Observing the underlying asset price after a jump increases the probability of detecting a barrier breach.

7 Journal of Applied Operational Research Vol. 8, No Table 3. Comparison of algorithms for low values of for different number of subperiods M. Figure 4. Frequency distributions of the realized number of subintervals m for different values of λ for the case of M = 10 and simulation runs. The average values are 32.26, 23.75, 16.36, and 10.09, for the four cases, respectively. The corresponding maximum values mmax are 58, 46, 32, and 13.

8 22 Lindset and Persson (2016) We use our algorithm to simulate one million price paths. Let m max be the maximum number of subperiods (= number of grid points 1) for these price paths. To measure the effect of property two, we increase the number of subperiods in the FD* method to m max. We label this approach FD 2 *. Any difference between the estimates from our approach and the estimates from the FD 2 * method can be attributed to the netting of positive and negative jumps. Actually, FD 2 * overcompensates for the grid size effect in the sense that it uses either a finer or identical grid size compared to our algorithm. The netting effect is thus underestimated. From Figure 5 we see that our algorithm produces the price estimates with smaller bias for λ = 20 and λ = 30, compared to the two adjusted methods FD 1 * and FD 2 *. We also see that the netting explains a substantial part of the bias for λ = 10, λ = 20, and λ = 30. From the panel for λ = 0.1 it is clear that our algorithm produces more biased estimates for small values of M. This case exhibits a low number of jumps and the average number of subperiods is typically such that M < < M + 1. The price estimates FD 1 * are therefore based on M + 1 subperiods (M + 2 grid points). From Figure 3 we know that, as a function of M, the JT estimates and the FD estimates are indistinguishable. Therefore, for any given M, the estimates FD 1 * are indistinguishable from the estimates JT* with M + 1 subperiods (this effect is easy to visualize in Figure 5 for low values of M). Figure 5. Estimated option prices as functions of the parameter M for different jump intensities λ. Here, MA represents the benchmark prices, FD and FD represent prices from the two adjusted fixed dates algorithms, and JT represents prices from our algorithm. The stars (*) indicate use of the BGK-correction. Conclusion We present an algorithm to price barrier options when the market value of the underlying asset is given by a jumpdiffusion. Our algorithm uses the stochastic number of jumps and the stochastic timing of these jumps to determine the simulation mesh size, which is decreased by inserting additional grid points. In particular, the price of the underlying asset is estimated at each jump time. Using this information about jump times reduces estimation bias compared to the standard approach of simulating prices at fixed dates. One drawback of the latter method is that the total effect of the jumps on the estimated option prices is too small. When the jumps in the underlying asset price in a subperiod have opposite signs, the

9 Journal of Applied Operational Research Vol. 8, No jumps will partially cancel and the effect from the jumps on the option price is underestimated. We present conservative tests showing that this drawback is significant, especially for high jump intensities. By estimating prices at each jump time, our approach is not subject to this drawback. Our numerical results show that our algorithm produces price estimates with low bias also for a course grid. Acknowledgments The authors acknowledge comments and suggestions from two anonymous referees. References Ball, C. A. and Torus, W. N. (1985). On jumps in common stock prices and their impact on call option pricing, Journal of Finance, 40 (1), Black, F. and Scholes, M. (1973). The pricing of options and corporate liabilities, Journal of Political Economy 81 (3), Broadie, M., Glasserman, P., and Kou, S. (1997). A continuity correction for discrete barrier options, Mathematical Finance, 2 (4), Carr, P, Geman, H., Madan, D. B., and Yor, M. (2002). The fine structure of asset returns: an empirical investigation, Journal of Business, 75 (2), Doornik, J. (1999). Object-oriented matrix programming using Ox. Timberlake Consultants Press and Oxford ( London. Duffie, D. (1998). Black, merton and scholes their central contributions to economics, Scandinavian Journal of Economics, 100 (2), Glasserman, P. (2004). Monte Carlo Methods in Financial Engineering (1 st edition). Springer-Verlag, New York. Gobet, E. (2009). Advanced Monte Carlo methods for barrier and related exotic options in Mathematical Modeling and Numerical Methods in Finance, eds. Bensoussan and Zhang. North-Holland, Oxford. Jorion, P. (1989). On jump processes in the foreign exchange and stock markets, Review of Financial Studies, 1 (4), Kou, S. G. and Wang, H. (2003). First passage times of a jump diffusion process, Advances in Applied Probability, 35 (2), Manso, G., Strulovici, B., and Tchistyi, A. (2010). Performance-sensitive debt, Review of Financial Studies, 71 (23), Merton, R. C. (1976). Option pricing when underlying stock returns are discontinuous, Journal of Financial Economics, 4 (3), Merton, R. C. (1973). Theory of rational option pricing, Bell Journal of Economics and Management Science, 4 (1), Metwally, S. A. K. and Atiya, A. F. (2002). Using Brownian bridge for fast simulation of jump-diffusion processes and barrier options, Journal of Derivatives, 10 (1), Mjøs, A., Myklebust, T. A., & Persson, S. A. (2013). On the pricing of performance sensitive debt. NHH Dept. of Finance & Management Science Discussion Paper, (2011/5). Appendix A: Pseudo-code Let n be the number of simulation runs. The simulation algorithm then goes as follows (the code is only meant as a pseudo code). Here U(0,1) (N(0,1)) returns a drawing from the scalar uniform (normal) distribution. sum = 0; mu = r-y*lambda-0.5*sigma^2; for(i=1;i<=n;i++) S = S_0; dummy = 1; while(t_h<t) dt = -1/lambda*log(U(0,1));

10 24 Lindset and Persson (2016) t_h <-- t_h+dt; if(t_h<t) M_h = integer(t_h*m+1); dt_h = t_h/m_h; H_hat = H*exp( *sigma*sqrt(dt_h)); for(j=1;j<=m_h;j++ && S<H_hat) S <-- S*exp(mu*dt_h+sigma*sqrt(dt_h)*N(0,1)); if(s>h_hat) dummy = 0; t_h = T; S <-- S*exp(a+b*N(0,1)); if(s_tau>h) else dummy=0; t_h = T;M_h = integer((t-t_h)/t*m+1); dt_h = t_h/m_h; H_hat = H*exp( *sigma*sqrt(dt_h)); for(j=1;j<=m_h;j++ && S<H_hat) S <-- S*exp(mu*dt_i+sigma*sqrt(dt_i)*N(0,1)); if(s_tau>h_i) dummy=0; sum <-- sum + dummy*max(s-x,0); return(exp(-r*t)*sum/n); Method 2: Fix M + 1 equally spaced grid points. The number of jumps between each grid point is Poisson distributed. For each time step we simulate the number of jumps between each grid point, and based on this number, the stock price is simulated at each grid point. The algorithm is illustrated by the following pseudo code: dt = T/M; EY_S = exp(a+0.5*b^2); y_s = EY_S - 1; dummy_s = exp(-lambda*dt); drift_s = ((r-lambda*y_s)-0.5*sigma^2)*dt; vol_s = sigma*sqrt(dt); sum = 0; for(i=1;i<=n;i++) S_new = S; dummy = 1; for(j=1;j<=m;j++)

11 Journal of Applied Operational Research Vol. 8, No product_of_uniform_s = U(0,1); N_jump = 0; while(product_of_uniform_s > dummy_s) M_jump=M_jump+1; product_of_uniform_s = product_of_uniform_s*u(0,1); jump_factor_s = 1; for(k=1;k<=m_jump;k++) jump_factor_s = jump_factor_s*exp(a+b*n(0,1)); S_new = S_new*exp(drift_S+vol_S*N(0,1))*jump_factor_S; if(s_new>h) dummy = 0; j = M; payoff = dummy*max(s_new-x,0); sum = sum + payoff; return(exp(-r*t)*sum/n