# Pricing American Call Options in R

In this article, we’re going to look at a way to price American call options using another package in R, known as “AmericanCallOpt.”

(American options are differentiated from European options in that with the former you can exercise before expiry. With the latter, there is no early-exercise option.)

With this package, we can do the following:

1. Price an American call using standard binomial approximation

2. Hedge parameters (delta, gamma, theta, vega, rho) via a standard binomial tree

3. Price an American call based on continuous payout from the underlying asset

4. Price an American call paying proportional dividends at specific times

5. Price a perpetual American call

6. Use binomial approximation to price an American call on a standard futures contract

7. Use binomial approximation to price an American call on a forex futures contracts

As with any financial model, there will be input parameters that need to be used in order to compute results.

For American call option financial modeling, we need to know the following:

**S**: spot price**K**: exercise price**r**: domestic risk-free interest rate**r_f**: foreign risk-free interest rate**sigma**: volatility**y**: dividend yield**t**: time to maturity**dividend_times**: periods when the dividend is paid out**dividend_yields**: dividend yield when each dividend is paid**steps**: number of steps in binomial tree

## Examples

### #1: Pricing an American Call Using a Standard Binomial Approximation

Here we have an American call option representing a stock with an underlying price of 50, an exercise price of 50, a risk-free interest rate of 5% (0.05), and volatility of 20% (0.20) on a monthly expiry (1/12 – to denote that one month is 1/12 of one year).

```
# Price of American call option using a binomial approximation
S<-50
K<-50
r<-0.05
sigma<-0.20
t<-1/12
steps<-100
call_price1 <- am_call_bin(S, K, r, sigma, t, steps)
call_price1
```

By writing the object name alone at the end of our code (“call_price1”), we will be able to obtain the result(s) from our model. We will do this for each model.

### #2: Hedge Parameters via a Standard Binomial Tree

The hedge parameters, commonly called “the Greeks”, are inherently associated with an option – delta, gamma, theta, vega, rho – based on the underlying components of price, the rate at which price changes, time, volatility, and underlying interest rate, respectively.

` # Hedge parameters for an American Call`

S<-50 K<-50 r<-0.02 sigma<-0.30 t<-1/4 steps<-100 hedge<-am_call_partials(S, K, r, sigma, t, steps) hedge

If just one Greek letter value is of interest, it can be pulled out of the calculation individually by stating the object name, followed by a $ sign, then the Greek letter of interest.

For example, if we wanted to know the vega for the above code we would write:

`hedge$vega`

### #3: Price based on continuous payout from an underlying asset

The call_price_bin_contpay command will calculate the price of a call option based on a continuous dividend payout structure.

The code below calculates for a two-year expiry (t<-2).

Note that a dividend is paid only to the owner of the stock, not the individual who purchased the option.

`#American option price with continous payout`

S<-30 K<-30 r<-0.0 y<-0.02 sigma<-0.15 t<-2 steps<-100 price_continous<-am_call_bin_contpay(S, K, r, y, sigma, t, steps) price_continuous

### #4: Price on an American call paying proportional dividends on the underlying asset at specific times

For stocks that pay proportional dividends, or payouts at discrete intervals, the call_price_bin_propdiv command can be used.

A matrix must be set up in order to inform the model of when these dividend payments are dispensed and the percentage of the stock’s price that is paid out at that time.

For payments made on April 1 and October 1, we would type in 0.25 and 0.75 into the “dividend_times” matrix to denote that they are being made 25% and 75% into the year.

If each payment is 1.5% of the stock’s price, then we would type in .015 and 0.15 into the “dividend_yields” matix.

`#American option for stock with proportional dividends`

S<-100 K<-100 r<-0.10 sigma<-0.25 t<-1 steps<-100 dividend_times<-matrix( c(0.25, 0.75) ) dividend_yields<-matrix( c(0.015, 0.015) ) price_propdiv<-am_call_bin_propdiv(S, K, r, sigma, t, steps, dividend_times, dividend_yields) price_propdiv

### #5: Price of a perpetual American call

A perpetual option has no defined maturity date and is exclusive to the American options structure. In this case, obviously, time is not a factor.

`#Price for American perpetual call option`

S<-50.0 K<-45.0 r<-0.05 y<-0.02 sigma<-0.05 price_perpetual<-am_call_perpetual(S, K, r, y, sigma) price_perpetual

### #6: Price a standard futures contract

In the case of American call pricing on futures contracts of all kinds, a binomial approximation is used.

In this case, F (instead of S) must be used to denote the price of the underlying.

This was a simple change made to denote that we are now working with futures contracts instead of stock prices.

`#Pricing an American call option on futures using a binomial approximation`

F<-100
K<-95
r<-0.05
sigma<-0.17
t<-0.25
steps<-100
price_fut<-am_call_bin_futures(F, K, r, sigma, t, steps)
price_fut

### #7: Price a standard forex futures contract

And finally, the price of an American call option with respect to forex futures can be determined via the am_call_bin_currency command.

```
# Pricing a futures currency option using a binomial approximation
S<-80
K<-82
```

r<-0.10
r_f<-0.04
sigma<-0.135
t<-1/12
steps<-100
price_forex<-am_call_bin_currency(S, K, r, r_f, sigma, t, steps)
price_forex