change argument names

Author: Cedric Qi

pkg/R/bachelier_impvol.R

@@ -5,25 +5,25 @@
 #' @param spot current stock price
 #' @param forward forward stock price
 #' @param strike strike price
-#' @param t.exp time to expiry
-#' @param r interest rate
-#' @param div dividend rate
+#' @param texp time to expiry
+#' @param intr interest rate
+#' @param divr dividend rate
 #' @return implied vol
 #' @examples
 #' spot <- 100
 #' strike <- 100
-#' t.exp <- 1.2
+#' texp <- 1.2
 #' sigma <- 0.2
-#' r <- 0.05
+#' intr <- 0.05
 #' price <- 20
-#' vol <- FER::BachelierImpvol(price=price, spot=spot, strike=strike, t.exp=t.exp, r=r)
+#' vol <- FER::BachelierImpvol(price=price, spot=spot, strike=strike, texp=texp, intr=intr)
 #' @export
 BachelierImpvol <- function(
-  type = "call", price, spot, forward = spot*exp((r-div)*t.exp),
-  strike = forward, t.exp = 1, r = 0, div = 0
+  type = "call", price, spot, forward = spot*exp((intr-divr)*texp),
+  strike = forward, texp = 1, intr = 0, divr = 0
 ){
 
-  price.forward = price * exp(r*t.exp)
+  price.forward = price * exp(intr*texp)
 
   if( type == "call" ) {
     price.straddle <- 2*price.forward - (forward - strike)
@@ -33,7 +33,7 @@ BachelierImpvol <- function(
     price.straddle <- price.forward
   }
 
-  #vectors a and b used for rational Chebyshev approximation
+  # vectors a and b used for rational Chebyshev approximation
   a <- c(3.994961687345134e-1,
        2.100960795068497e1,
        4.980340217855084e1,
@@ -71,7 +71,7 @@ BachelierImpvol <- function(
 
   #approximation of h(n)
   #implied volatility
-  vol <- sqrt(pi*nu/(2*t.exp)) * price.straddle * (poly.a/poly.b)
+  vol <- sqrt(pi*nu/(2*texp)) * price.straddle * (poly.a/poly.b)
 
   return(vol)
 }

pkg/R/bachelier_price.R

@@ -4,22 +4,22 @@
 #' @param price Price
 #' @param spot current stock price
 #' @param forward forward stock price
-#' @param t.exp time to expiry
-#' @param r interest rate
-#' @param div dividend rate
+#' @param texp time to expiry
+#' @param intr interest rate
+#' @param divr dividend rate
 #' @param sigma volatility
 #' @return option price
 #' @examples
 #' spot <- 100
 #' strike <- seq(80,125,5)
-#' t.exp <- 1.2
+#' texp <- 1.2
 #' sigma <- 0.2
-#' r <- 0.05
-#' price <- FER::BachelierPrice(spot=spot, t.exp = t.exp, sigma=sigma, strike=strike, r=r)
+#' intr <- 0.05
+#' price <- FER::BachelierPrice(spot=spot, texp = texp, sigma=sigma, strike=strike, intr=intr)
 #' @export
 BachelierPrice <- function(
-  type = "call", spot, forward = spot*exp((r-div)*t.exp),
-  strike = forward, t.exp = 1, r = 0, div = 0, sigma
+  type = "call", spot, forward = spot*exp((intr-divr)*texp),
+  strike = forward, texp = 1, intr = 0, divr = 0, sigma
 ){
 
   #------------------------------------------------
@@ -39,48 +39,48 @@ BachelierPrice <- function(
   #------------------------------------------------
   #------------------------------------------------
 
-  stdev <- sigma*sqrt(t.exp)
+  stdev <- sigma*sqrt(texp)
   d1 <- (forward-strike) / stdev
   pnorm.d1 <- pnorm(d1) # normal CDF
   dnorm.d1 <- dnorm(d1) # normal PDF =exp(-d1*d1/2)/sqrt(2*pi)
-  disc.factor <- exp(-r*t.exp)
+  disc.factor <- exp(-intr*texp)
 
   if(type=="call"){
     #Option Price
     price <- (forward-strike)*pnorm.d1 + stdev*dnorm.d1
     #Greeks
     delta <- pnorm.d1 #Delta
-    gamma <- 1 / (sigma*t.exp)/sqrt(2*pi)*exp(-d1^2/2)#Gamma
-    vega <- sqrt(t.exp)/sqrt(2*pi)*exp(-d1^2/2)#Vega
+    gamma <- 1 / (sigma*texp)/sqrt(2*pi)*exp(-d1^2/2)#Gamma
+    vega <- sqrt(texp)/sqrt(2*pi)*exp(-d1^2/2)#Vega
 
   }else if (type=="put"){
     #Option Price
     price <- (strike-forward)*(1-pnorm.d1) + stdev*dnorm.d1
     #Greeks
     delta <- pnorm.d1 - 1 #Delta
-    gamma <- 1 / (sigma*t.exp)/sqrt(2*pi)*exp(-d1^2/2)#Gamma
-    vega <- sqrt(t.exp)/sqrt(2*pi)*exp(-d1^2/2)#Vega
+    gamma <- 1 / (sigma*texp)/sqrt(2*pi)*exp(-d1^2/2)#Gamma
+    vega <- sqrt(texp)/sqrt(2*pi)*exp(-d1^2/2)#Vega
 
   } else if (type=="straddle"){
     #Straddle price
     price <- (forward-strike)*(2*pnorm.d1-1) + 2*stdev*dnorm.d1
     delta <- 2*pnorm.d1 - 1
-    gamma <- 2 / (sigma*t.exp)/sqrt(2*pi)*exp(-d1^2/2)
-    vega <- 2 * sqrt(t.exp)/sqrt(2*pi)*exp(-d1^2/2)#Vega
+    gamma <- 2 / (sigma*texp)/sqrt(2*pi)*exp(-d1^2/2)
+    vega <- 2 * sqrt(texp)/sqrt(2*pi)*exp(-d1^2/2)#Vega
 
   } else if (type== "digital call"){
     #Digital call price
     price <- pnorm(d1)
-    delta <- 1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma*sqrt(t))
-    gamma <- 1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma^2*t)
-    vega <- -1 / sqrt(2*pi)*exp(-d1^2/2)*(spot-strike)/(sigma^2*sqrt(t))
+    delta <- 1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma*sqrt(texp))
+    gamma <- 1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma^2*texp)
+    vega <- -1 / sqrt(2*pi)*exp(-d1^2/2)*(spot-strike)/(sigma^2*sqrt(texp))
 
   } else if (type== "digital put"){
     #Digital put price
     price <- pnorm(-d1)
-    delta <- -1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma*sqrt(t))
-    gamma <- 1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma^2*t)
-    vega <- -1 / sqrt(2*pi)*exp(-d1^2/2)*(spot-strike)/(sigma^2*sqrt(t))
+    delta <- -1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma*sqrt(texp))
+    gamma <- 1 / sqrt(2*pi)*exp(-d1^2/2)/(sigma^2*texp)
+    vega <- -1 / sqrt(2*pi)*exp(-d1^2/2)*(spot-strike)/(sigma^2*sqrt(texp))
   } else {
     cat("Error! Please input: call/put/straddle/digital call/digital put")
   }

pkg/R/blackscholes_impvol.R

@@ -5,24 +5,24 @@
 #' @param spot current stock price
 #' @param forward forward stock price
 #' @param strike strike price
-#' @param t.exp time to expiry
-#' @param r interest rate
-#' @param div dividend rate
+#' @param texp time to expiry
+#' @param intr interest rate
+#' @param divr dividend rate
 #' @return Implied vol
 #' @examples
 #' spot <- 100
 #' strike <- 100
-#' t.exp <- 1.2
+#' texp <- 1.2
 #' sigma <- 0.2
-#' r <- 0.05
+#' intr <- 0.05
 #' price <- 20
-#' vol <- FER::BlackScholesImpvol(price=price, spot=spot, strike=strike, t.exp=t.exp, r=r)
+#' vol <- FER::BlackScholesImpvol(price=price, spot=spot, strike=strike, texp=texp, intr=intr)
 #' @export
 BlackScholesImpvol <- function(
-  type = "call", price, spot, forward = spot*exp((r-div)*t.exp),
-  strike = forward, t.exp = 1, r = 0, div = 0
+  type = "call", price, spot, forward = spot*exp((intr-div)*texp),
+  strike = forward, texp = 1, intr = 0, divr = 0
 ){
-    price.forward = price * exp( r*t.exp)
+    price.forward = price * exp( r*texp)
 
     n.price = length(price.forward)
     n.strike = length(strike)
@@ -40,7 +40,7 @@ BlackScholesImpvol <- function(
       # Be careful here.... Chekc how functional works in R.
       sub <- function(sigma){
         f <- CalcBsmPrice(
-          type = type, forward = forward, strike = strike.vec[k], t.exp = t.exp, sigma = sigma
+          type = type, forward = forward, strike = strike.vec[k], texp = texp, sigma = sigma
         )[1] - price.forward[k]
         return(f)
       }

pkg/R/blackscholes_price.R

@@ -4,32 +4,32 @@
 #' @param spot current stock price
 #' @param forward forward stock price
 #' @param strike strike price
-#' @param t.exp time to expiry
-#' @param r interest rate
-#' @param div dividend rate
+#' @param texp time to expiry
+#' @param intr interest rate
+#' @param divr dividend rate
 #' @param sigma volatility
 #' @return option price
 #' @examples
 #' spot <- 100
 #' strike <- seq(80,125,5)
-#' t.exp <- 1.2
+#' texp <- 1.2
 #' sigma <- 0.2
-#' r <- 0.05
-#' price <- FER::BlackScholesPrice(spot=spot, t.exp = t.exp, sigma=sigma, strike=strike, r=r)
+#' intr <- 0.05
+#' price <- FER::BlackScholesPrice(spot=spot, texp = texp, sigma=sigma, strike=strike, intr=intr)
 #' @export
 BlackScholesPrice <- function(
-  type = "call", spot, forward = spot*exp((r-div)*t.exp),
-  strike = forward, t.exp = 1, r = 0, div = 0, sigma
+  type = "call", spot, forward = spot*exp((intr-divr)*texp),
+  strike = forward, texp = 1, intr = 0, divr = 0, sigma
 ){
-    stdev <- sigma*sqrt(t.exp)
+    stdev <- sigma*sqrt(texp)
 
     # a trick to get the intrinsic value for negative or zero vol
     # also avoid NAN in case forward = strike
     stdev[stdev < 1e-32] <- 1e-32
 
     d1 <- log(forward/strike)/stdev + 0.5*stdev
     d2 <- d1 - stdev
-    disc.factor <- exp(-r*t.exp)
+    disc.factor <- exp(-intr*texp)
 
     pnorm.d1 <- pnorm(d1)
     pnorm.d2 <- pnorm(d2)

pkg/R/cev.R

@@ -1,26 +1,26 @@
 #' Constant Elasticity Of Variance (CEV) model option price
 #'
-#' @param strike
-#' @param spot
-#' @param forward
-#' @param t.exp
-#' @param sigma
+#' @param strike strike price
+#' @param spot current stock price
+#' @param forward forward stock price
+#' @param texp time to expiry
+#' @param sigma volatility
 #' @param beta
-#' @param r
-#' @param div
-#' @param type
+#' @param intr interest rate
+#' @param divr dividend rate
+#' @param type option type either 'call' or 'put'
 #'
-#' @return
+#' @return option price
 #' @export
 #'
 #' @examples
 CEV <- function(
-  strike, spot, forward = spot*exp((r-div)*t.exp),
-  t.exp=1, sigma=0.01, beta=0.5,
-  r = 0, div = 0, type="call"
+  strike, spot, forward = spot*exp((intr-divr)*texp),
+  texp=1, sigma=0.01, beta=0.5,
+  intr = 0, divr = 0, type="call"
 ){
   betac <- 1 - beta
-  scale <- (betac*sigma)^2*t.exp
+  scale <- (betac*sigma)^2*texp
   strike_cov = strike^(2*betac) / scale # strike change of variable
   forward_cov = forward^(2*betac) / scale # forward change of variable
   df <- 1/betac
@@ -30,7 +30,7 @@ CEV <- function(
   term1 <- stats::pchisq(strike_cov, df=df+2, ncp=forward_cov, lower.tail=!iscall)
   term2 <- stats::pchisq(forward_cov, df=df, ncp=strike_cov, lower.tail=iscall)
 
-  price <- ifelse(iscall, 1, -1)*exp(-r*t.exp)*(forward*term1 - strike*term2)
+  price <- ifelse(iscall, 1, -1)*exp(-intr*texp)*(forward*term1 - strike*term2)
 
   return(price)
 }

pkg/R/sabr_hagan2002.R

@@ -1,25 +1,25 @@
 #' Hagan approximation for the SABR model
 #'
-#' @param strike
-#' @param spot
-#' @param forward
-#' @param t.exp
-#' @param sigma
+#' @param strike strike price
+#' @param spot current stock price
+#' @param forward forward stock price
+#' @param texp time to expiry
+#' @param sigma volatility
 #' @param vov
 #' @param rho
 #' @param beta
-#' @param r
-#' @param div
+#' @param intr interest rate
+#' @param divr dividend rate
 #' @param type 'BlackScholes', 'call', 'put'
 #'
 #' @return Black-Scholes volatility (type="BlackScholes") or option price ("call" or "put")
 #' @export
 #'
 #' @examples
 SabrHagan2002 <- function(
-  strike, spot, forward = spot*exp((r-div)*t.exp),
-  t.exp=1, sigma=0.01, vov=0, rho=0, beta=1,
-  r = 0, div = 0, type="BlackScholes"
+  strike, spot, forward = spot*exp((intr-divr)*texp),
+  texp=1, sigma=0.01, vov=0, rho=0, beta=1,
+  intr = 0, divr = 0, type="BlackScholes"
 ){
   betac <- 1 - beta
   powFwdStrk <- (forward*strike)^(betac/2)
@@ -32,7 +32,7 @@ SabrHagan2002 <- function(
   pre2alp1 <- vov*rho*beta/4/powFwdStrk
   pre2alp2 <- betac^2/24/powFwdStrk^2
 
-  pre2 <- 1 + t.exp*( pre2alp0 + sigma*(pre2alp1 + pre2alp2*sigma) )
+  pre2 <- 1 + texp*( pre2alp0 + sigma*(pre2alp1 + pre2alp2*sigma) )
 
   zz <- powFwdStrk*logFwdStrk*vov/sigma  # need to make sure sig > 0
   yy <- sqrt(1 + zz*(zz-2*rho))
@@ -51,8 +51,8 @@ SabrHagan2002 <- function(
     return(volBlks)
   } else if(type=="call" | type=="put") {
     p <- BlackScholesPrice(
-      type=type, spot=spot, strike=strike, t.exp=t.exp, sigma=volBlks,
-      r=r, div=div
+      type=type, spot=spot, strike=strike, texp=texp, sigma=volBlks,
+      intr=intr, divr=divr
     )
     return(p)
   }