BinomialTreeOptions         package:fOptions         R Documentation

_B_i_n_o_m_i_a_l _T_r_e_e _O_p_t_i_o_n _M_o_d_e_l

_D_e_s_c_r_i_p_t_i_o_n:

     A collection and description of functions to valuate  options in
     the framework of the Binomial tree option  approach. 

     The functions are:

       'CRRBinomialTreeOption'   CRR Binomial Tree Option,
       'JRBinomialTreeOption'    JR Binomial Tree Option,
       'TIANBinomialTreeOption'  TIAN Binomial Tree Option,
       'BinomialTreeOption'      Binomial Tree Option,
       'BinomialTreePlot'        Binomial Tree Plot.

_U_s_a_g_e:

     CRRBinomialTreeOption(TypeFlag, S, X, Time, r, b, sigma, n)
     JRBinomialTreeOption(TypeFlag, S, X, Time, r, b, sigma, n)
     TIANBinomialTreeOption(TypeFlag, S, X, Time, r, b, sigma, n)

     BinomialTreeOption(TypeFlag, S, X, Time, r, b, sigma, n)
     BinomialTreePlot(BinomialTreeValues, dx = -0.025, dy = 0.4, 
         cex = 1, digits = 2, ...)

_A_r_g_u_m_e_n_t_s:

       b: the annualized cost-of-carry rate, a numeric value;  e.g. 0.1
          means 10% pa. 

BinomialTreeValues: the return value from the 'BinomialTreeOption'
          function. 

     cex: a numerical value giving the amount by which the plotting
          text and symbols should be scaled relative to the default. 

  digits: an integer value, how many digits should be displayed in the
          option tree? 

  dx, dy: numerical values, an offset fine tuning for the placement of
          the option values in the option tree. 

       n: number of time steps; an integer value. 

       r: the annualized rate of interest, a numeric value;  e.g. 0.25
          means 25% pa. 

       S: the asset price, a numeric value. 

   sigma: the annualized volatility of the underlying security,  a
          numeric value; e.g. 0.3 means 30% volatility pa. 

    Time: the time to maturity measured in years, a numeric  value;
          e.g. 0.5 means 6 months. 

TypeFlag: a character string either '"ce"', '"ca"' for an  European or
          American call option or a '"pe"', '"pa"'  for a put option,
          respectively. 

       X: the exercise price, a numeric value. 

     ...: arguments to be passed. 

_D_e_t_a_i_l_s:

     *CRR Binomial Tree Model:* 

      Binomial models were first suggested by Cox, Ross and Rubinstein
     (1979), CRR, and then became widely used because of its intuition
     and easy  implementation. Binomial trees are constructed on a
     discrete-time  lattice. With the time between two trading events
     shrinking to zero,  the evolution of the price converges weakly to
     a lognormal diffusion.  Within this mode the European options
     value converges to the value  given by the Black-Scholes formula.  

     *JR Binomial Tree Model:* 

      There exist many extensions of the CRR model. Jarrow and Rudd
     (1983),  JR, adjusted the CRR model to account for the local drift
     term. They  constructed a binomial model where the first two
     moments of the  discrete and continuous time return processes
     match. As a consequence  a probability measure equal to one half
     results. Therefore the CRR and JR models are sometimes atrributed
     as equal jumps binomial trees and equal probabilities binomial
     trees. 

     *TIAN Binomial Tree Model:* 

     Tian (1993) suggested to match discrete and continuous local 
     moments up to third order.  
      Leisen and Reimer (1996) proved that the order of convergence in 
     pricing European options for all three methods is equal to one,
     and thus the three models are equivalent.

_V_a_l_u_e:

     The option price, a numeric value.

_N_o_t_e:

     Note, the 'BinomialTree' and 'BinomialTreePlot' are preliminary 
     implementations.

_A_u_t_h_o_r(_s):

     Diethelm Wuertz for this R-Port.

_R_e_f_e_r_e_n_c_e_s:

     Broadie M., Detemple J. (1994); _American Option Evaluation: New
     Bounds, Approximations,  and a Comparison of Existing Methods_, 
     Working Paper, Columbia University, New York. 

     Cox J., Ross S.A., Rubinstein M. (1979); _Option Pricing: A
     Simplified Approach_,  Journal of Financial Economics 7, 229-263. 

     Haug E.G. (1997);  _The complete Guide to Option Pricing
     Formulas_,  McGraw-Hill, New York.

     Hull J.C. (1998); _Introduction to Futures and Options Markets_,
     Prentice Hall, London.

     Jarrow R., Rudd A. (1983);  _Option Pricing_,  Homewood, Illinois,
     183-188. 

     Leisen D.P., Reimer M., (1996);  _Binomial Models for Option
     Valuation - Examining and  Improving Convergence_,  Applied
     Mathematical Finanace 3, 319-346.

     Tian Y. (1993); _A Modified Lattice Approach to Option Pricing_, 
     Journal of Futures Markets 13, 563-577.

_E_x_a_m_p_l_e_s:

     ## Cox-Ross-Rubinstein Binomial Tree Option Model:
      
        # Example 14.1 from Hull's Book:
        xmpOptions("\nStart: CRR Binomial Tree > ")
        CRRBinomialTreeOption(TypeFlag = "pa", S = 50, X = 50, 
          Time = 5/12, r = 0.1, b = 0.1, sigma = 0.4, n = 5)
        # Example 3.1.1 from Haug's Book:
         CRRBinomialTreeOption(TypeFlag = "pa", S = 100, X = 95, 
             Time = 0.5, r = 0.08, b = 0.08, sigma = 0.3, n = 5)
        # A European Call - Compare with Black Scholes: 
        CRRBinomialTreeOption(TypeFlag = "ce", S = 100, X = 100, 
          Time = 1, r = 0.1, b = 0.1, sigma = 0.25, n = 50)
        GBSOption(TypeFlag = "c", S = 100, X = 100, 
          Time = 1, r = 0.1, b = 0.1, sigma = 0.25)$price
          
     ## CRR - JR - TIAN Model Comparison
          
        # Hull's Example as Function of "n":
        xmpOptions("\nNext: Convergence Behavior > ")
        par(mfrow = c(2, 1), cex = 0.7)
        steps = 50
        CRROptionValue =  JROptionValue = TIANOptionValue = 
          rep(NA, times = steps)
        for (n in 3:steps) { 
          CRROptionValue[n] = CRRBinomialTreeOption(TypeFlag = "pa", S = 50, 
            X = 50, Time = 0.4167, r = 0.1, b = 0.1, sigma = 0.4, n = n)
          JROptionValue[n] = JRBinomialTreeOption(TypeFlag = "pa", S = 50, 
            X = 50, Time = 0.4167, r = 0.1, b = 0.1, sigma = 0.4, n = n) 
          TIANOptionValue[n] = TIANBinomialTreeOption(TypeFlag = "pa", S = 50, 
            X = 50, Time = 0.4167, r = 0.1, b = 0.1, sigma = 0.4, n = n) }           
        plot(CRROptionValue[3:steps], type = "l", col = "red", 
          ylab = "Option Value")
        lines(JROptionValue[3:steps], col = "green")
        lines(TIANOptionValue[3:steps], col = "blue")
        # Add Result from BAW Approximation:
        BAWValue =  BAWAmericanApproxOption(TypeFlag = "p", S = 50, X = 50, 
          Time = 0.4167, r = 0.1, b = 0.1, sigma = 0.4)
        abline(h = BAWValue, lty = 3)
        title(main = "Convergence")
        data.frame(CRROptionValue, JROptionValue, TIANOptionValue)
        
     ## Plot CRR Option Tree:

        # Again Hull's Example:
        xmpOptions("\nNext: Plot CRR Option Tree > ")
        CRRTree = BinomialTreeOption(TypeFlag = "pa", S = 50, X = 50, 
          Time = 0.4167, r = 0.1, b = 0.1, sigma = 0.4, n = 5)
        BinomialTreePlot(CRRTree, dy = 1, cex = 0.8, ylim = c(-6, 7),
          xlab = "n", ylab = "Option Value")
        title(main = "Option Tree")

