Black Scholes differential equation

\[\frac{\partial f}{\partial t} + rS\cdot \frac{\partial f}{\partial S}+\frac{1}{2}\sigma^2 S^2\cdot\frac{\partial^2 f}{\partial S^2} = rf\]

where

  • \[S = \text{stock price}\]
  • \[f = \text{option price}\]
  • \[r = \text{interest}\]

Pricing call and put with a given strike price X and maturity T

According the Black-Scholes formula, the values of call and put with the strike price \(X\) maturing at time \(T\) are given by:

\[c(S,t)=SN(d_1)-Xe^{r(T-t)}N(d_2)\\\\ p(S,t)=Xe^{-r(T-t)}N(-d_2)-SN(-d_1)\\\]

Where \(N\) is the distribution function of \(\phi(0,1)\),

and:

\[d_1=\frac{\ln{\left(\frac{S}{X}\right)}+(r + \frac{\sigma^2}{2})(T-t)}{\sigma\sqrt{T-t}}\\ d_2=\frac{\ln{\left(\frac{S}{X}\right)}+(r - \frac{\sigma^2}{2})(T-t)}{\sigma\sqrt{T-t}} = d_1-\sigma\sqrt{T-t}\\\]

Java

BlackScholes.java

public class BlackScholes implements PricingType

PricingType, is an interface that defines two abstract methods getCall() and getPut(). In BlackScholes, we implement these methods.

Our input variables are stored in a collection HashMap<String, Double>. At the constructor we initialize a number of instance variables.

stock          = hashMap.get("stock");
strike         = hashMap.get("strike");
volatility     = hashMap.get("volatility");
interest       = hashMap.get("interest");
timehorizon    = hashMap.get("timehorizon");

d1 & d2

Also at the constructor, we calculate \(d_1\) and \(d_2\).

d1 	= (Math.log(stock / strike) 
	+ (interest + (Math.pow(volatility, 2) / 2)) 
	* timehorizon)
	/ (volatility * Math.sqrt(timehorizon));

d2 	= d1 - (volatility * Math.sqrt(timehorizon));

getCall()

public double getCall() {
    return      (stock * distribution.cumulativeProbability(d1))
            -   (strike * Math.exp(-interest * timehorizon)
            *   distribution.cumulativeProbability(d2));
    }

getPut()

public double getPut() {
    return  strike * Math.exp(-interest * timehorizon)
    * distribution.cumulativeProbability(-d2)
    - stock * distribution.cumulativeProbability(-d1);
    }

BlackScholes.txt

In the Java implementation, we simply assume \(t=0\). So the timehorizon \(T-t\) is the maturity \(T\).

Let’s suppose the following:

\[S = 115\\ X = 80\\ \sigma = 0.48\\ r = 0.07\\ T-t = 0.5\\\]

So in BlackScholes.txt, we have

stock,115
strike,80
volatility,0.48
interest,0.07
timehorizon,0.5

Output

Black Scholes
	Call:39.63234093141300
	Put:1.88077423201832

The Black Scholes Formulas

Nearing Maturity

As we approach maturity, \(t \rightarrow T\), the following terms tend to 0.

\[\left(T-t\right) \rightarrow 0\\ \left(r\pm \frac{\sigma^2}{2} \right) \rightarrow 0\]

Therefore \(\ln{\frac{S}{X}}\) becomes important to the behaviour of \(d_1\) and \(d_2\).

If \(S \rightarrow +\infty\) then \(\ln{\frac{S}{X}}\) is positive.

When positive,

\[d_1,d_2 \rightarrow +\infty\\ N(d_1),N(d,2)\rightarrow 1\\ N(-d_1),N(-d_2) \rightarrow 0\\\]

So at maturity, the value of the options is:

\[c\rightarrow S-X\\ p\rightarrow 0\\\]

If \(S\) is big, the call will be executed with high probability and becomes similar to a forward! Likewise, the Put will not likely be executed.

If \(S \rightarrow -\infty\) then \(\ln{\frac{S}{X}}\) is negative.

When negative,

\[d_1,d_2 \rightarrow -\infty\\ N(d_1),N(d,2)\rightarrow 0\\ N(-d_1),N(-d_2) \rightarrow 1\\\]

So at maturity, the value of the options is:

\[c\rightarrow 0\\ p\rightarrow X-S\\\]

Updated: