Skip to content
All library documents

Moneyness and Black–Scholes Call Prices Across Volatility

Article Quant Q&A · Author: Marine Galantin

Summary

The document clarifies that moneyness in the illustrated option pricing context is the ratio of the underlying stock price to the strike price. It addresses confusion about a paper’s graph by reproducing a related set of curves using European call prices from the Black–Scholes formula, with different moneyness values and volatility inputs. The plot has volatility on one axis and option price on the other, rather than showing implied volatility directly against moneyness.

The reproduced curves are described as broadly similar to the paper’s, aside from behavior at zero volatility, where the calculation encounters division by zero. This example helps distinguish an option price surface slice from the more familiar implied volatility smile or skew plot. It does not establish that one moneyness convention is universally preferred, and the code example uses particular parameter choices and a basic European call setup, so its curves are illustrative rather than a general market calibration.

Key ideas

  • Moneyness is represented here as the underlying price divided by the strike price.
  • The discussed graph plots European call price against volatility for several moneyness levels.
  • A price-versus-volatility curve is distinct from an implied volatility smile plotted across strikes.
  • The Black–Scholes reproduction is broadly similar to the paper’s figure except near zero volatility.
  • The example uses a basic call option and specific parameter choices, so it is illustrative.

Tags

Full text
# Pricing Options and Computing Implied Volatilities using Neural Networks, strange shape of a graph


# Pricing Options and Computing Implied Volatilities using Neural Networks, strange shape of a graph












I am sometimes confused by the expression moneyness. Can anyone tell me what is plot here ? Its from the paper called :Pricing Options and Computing Implied Volatilities using Neural Networks.

Usually, I see the volatility as a function of the shape like the negative of a sigmoid (inversed S). Here the shape is differnet. Is it the curve of the price against $\frac {X_0} {K} $ ?

Is it common to plot like that ? What about a plot against $\frac {K} {X_0} $

## Answer by Idonknow (score 1, accepted)

https://quant.stackexchange.com/a/54872

As mentioned, the moneyness refers to the ratio of stock price to strike price, that is, $\frac{S}{K}.$.

I reproduce the following plots using Python 3.

Comparing the plot above to the plot in the paper, they exhibit fairly similar behaviors except at zero volatility (I get divide by zero error).

The source codes are as follows and can be found at my github:

```
from Option import *
import numpy as np
import matplotlib.pyplot as plt

sigma_upper = 10
x = np.linspace(1, sigma_upper, sigma_upper)

d = 0
r = 0
T = 1
sigma = 0.1
K = 1

moneyness = np.arange(0.7, 1.4, 0.1)

for i in moneyness[::-1]:
  S = i * K
  y = [Option(S, K, r, d, sigma, T).european_call() for sigma in range(1, sigma_upper+1)]
  plt.plot(x,y, label = 'moneyness = ' + str(round(i,2)))
  plt.xlabel('Volatility')
  plt.ylabel('Option Price')
  plt.legend();
```

The `Option` script source is as follows and can be found at my github (I extracted only the necessary parts):

```
from scipy.stats import norm

class Option:
    def __init__(self, S, K, r, d, sigma, T):
        '''
        Parameters:
        ===========
        S: stock price 
        K: strike price
        r: risk-free interest rate
        d: dividend 
        sigma: volatility (implied)
        T: time to maturity

        Returns: 
        ===========
        Forward price, vanilla European call and put option' prices, cash-or-nothing call and put options' prices,
        zero coupon bond and forward contract.
        '''

        self.S = S
        self.K = K
        self.r = r
        self.d = d
        self.sigma = sigma
        self.T = T

        self.d1 = (np.log(self.S/self.K) + (self.r - self.d + self.sigma**2 / 2) * self.T) / (self.sigma * np.sqrt(self.T))
        self.d2 = self.d1 - self.sigma * np.sqrt(self.T)

    def european_call(self):
        '''
        output vanilla European call option's price using Black-Scholes formula 
        '''        
        return self.S * np.exp(-self.d * self.T) * norm.cdf(self.d1) - self.K * np.exp(-self.r * self.T)*norm.cdf(self.d2)
```

Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)

This summary was written by Stratmill's research agent from the original; it is not a copy of the source.