Payoffs

The diagrams below illustrate the payoff for various derivatives at maturity. For options, the Profit/Loss (P/L), which accounts for the option premium, is also displayed. The diagrams do not account for any other trading costs.

\(S_T\) is the underlying asset value at maturity \(T\), \(F_0\) is the futures price at time zero, and \(X\) is the option exercise price.

Underlying asset

Change the value of the asset at maturity \(S_T\) using the slider below, the payoff is represented with a dot:

viewof s = Inputs.range([0, 150], {step: 1, label: "S_T", value:100})

longAssetSeries = d3.range(0, 151).map(x => ({x, y: x}))
shortAssetSeries = d3.range(0, 151).map(x => ({x, y: -x}))

longAssetPayoff = Plot.plot({
  caption: "Payoffs on a Long position on an asset",
  x: {
    domain: [0, 150],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.line([[0, 0], [150, 150]], {stroke: "#2196F3"}),
    Plot.dot(
      [[s, s]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${s}
Payoff: ${s}`,
        tip: true
      }),
    // Tooltip + crosshair (data-bound)
    Plot.tip(Plot.pointerX(longAssetSeries), {x: "x", y: "y", title: d => `S: ${d.x}\nPayoff: ${d.y}`}),
    Plot.crosshair(longAssetSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Long position payoff"
})

shortAssetPayoff = Plot.plot({
  caption: "Payoffs on a Short position on an asset",
  x: {
    domain: [0, 150],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.line([[0, 0], [150, -150]], {stroke: "#2196F3"}),
    Plot.dot(
      [[s, -s]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${s}
Payoff: ${-s}`,
        tip: true
      }),
    // Tooltip + crosshair (data-bound)
    Plot.tip(Plot.pointerX(shortAssetSeries), {x: "x", y: "y", title: d => `S: ${d.x}\nPayoff: ${d.y}`}),
    Plot.crosshair(shortAssetSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Short position payoff"
})

When you purchase an asset (long position), the payoff is simply the value of the asset at maturity \(S_T\). The payoff function is represented by the straight line passing through the origin with a slope of 1.

When you sell an asset (short position), the payoff is the negative of the value of the asset at maturity, \(-S_T\). The payoff function is represented by the straight line passing through the origin with a slope of -1.

Futures contract

Assuming no dividends, a maturity of 1 year, and a continuously compounded risk‑free rate of 4%, the fair futures price is \[F_0 = S_0\,e^{rT} = S_0\,e^{0.04\times1}.\]

Use the sliders to set the current spot price \(S_0\) and the maturity price \(S_T\). The corresponding \(F_0\) is computed automatically from \(S_0\) and displayed below.

viewof s0f = Inputs.range([50, 150], {step: 1, label: "S_0", value: 100})
viewof stf = Inputs.range([50, 150], {step: 1, label: "S_T", value: 100})

// Compute F0 from S0 (no dividends), r = 4% (cc), T = 1 year
f0 = s0f * Math.exp(0.04)

md`F_0 (no dividends, r = 4% cc, T = 1): **${f0.toFixed(2)}**`

domainMaxF = Math.max(150, Math.ceil(f0/10)*10 + 10)
futuresLongSeries = d3.range(0, domainMaxF + 1).map(x => ({x, y: x - f0}))
futuresShortSeries = d3.range(0, domainMaxF + 1).map(x => ({x, y: f0 - x}))

longFuturePayoff = Plot.plot({
  caption: "Payoffs on a Long position on a futures contract",
  x: {
    domain: [0, domainMaxF],
    label: "S_T"
  },
  y: {
    domain: [-domainMaxF, domainMaxF],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([f0], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line([[0, -f0], [domainMaxF, domainMaxF - f0]], {stroke: "#2196F3"}),
    Plot.dot(
      [[stf, stf - f0]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${stf.toFixed(2)}
F_0: ${f0.toFixed(2)}
Payoff: ${(stf - f0).toFixed(2)}`,
        tip: true
      }),
    // Pointer tooltip and crosshair bound to series
    Plot.tip(Plot.pointerX(futuresLongSeries), {x: "x", y: "y", title: d => `S: ${d.x.toFixed(2)}\nPayoff: ${(d.x - f0).toFixed(2)}`}),
    Plot.crosshair(futuresLongSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Long futures position payoff"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>F0 <span class="badge">${f0.toFixed(2)}</span></span>
  <span><span class="swatch" style="background: #2196F3"></span> Payoff</span>
  <span><span class="swatch" style="background: red"></span> Current point</span>
</div>`

shortFuturePayoff = Plot.plot({
  caption: "Payoffs on a Short position on a futures contract",
  x: {
    domain: [0, domainMaxF],
    label: "S_T"
  },
  y: {
    domain: [-domainMaxF, domainMaxF],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([f0], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line([[0, f0], [domainMaxF, f0 - domainMaxF]], {stroke: "#2196F3"}),
    Plot.dot(
      [[stf, f0 - stf]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${stf.toFixed(2)}
F_0: ${f0.toFixed(2)}
Payoff: ${(f0 - stf).toFixed(2)}`,
        tip: true
      }),
    // Pointer tooltip and crosshair bound to series
    Plot.tip(Plot.pointerX(futuresShortSeries), {x: "x", y: "y", title: d => `S: ${d.x.toFixed(2)}\nPayoff: ${(f0 - d.x).toFixed(2)}`}),
    Plot.crosshair(futuresShortSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Short futures position payoff"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>F0 <span class="badge">${f0.toFixed(2)}</span></span>
  <span><span class="swatch" style="background: #2196F3"></span> Payoff</span>
  <span><span class="swatch" style="background: red"></span> Current point</span>
</div>`

The payoff of a futures contract at maturity is the difference between the spot price of the underlying asset at maturity (\(S_T\)) and the futures price agreed upon at the initiation of the contract (\(F_0\)):

md`- For a long position (buyer of the futures contract), the payoff is ${tex`S_T - F_0`} = **${(stf - f0).toFixed(2)}**`

md`- For a short position (seller of the futures contract), the payoff is ${tex`F_0 - S_T`} = **${(f0 - stf).toFixed(2)}**`

Note that unlike other derivatives, futures contracts have no upfront premium cost as they are obligations to buy/sell at a predetermined price.

Option Contracts

Options give the holder the right, but not the obligation, to buy (call option) or sell (put option) the underlying asset at a predetermined price (exercise price or strike price). You can adjust the parameters below to see how they affect option payoffs.

viewof s0o = Inputs.range([50, 150], {step: 1, label: "S_0", value:100})
viewof x = Inputs.range([50, 150], {step: 1, label: "X (Exercise Price)", value:100})
viewof sto = Inputs.range([0, 150], {step: 1, label: "S_T", value:100})

erf = x => {
  const sign = Math.sign(x);
  const ax = Math.abs(x);
  const t = 1 / (1 + 0.3275911 * ax);
  const y = 1 - (((((1.061405429*t - 1.453152027)*t) + 1.421413741)*t - 0.284496736)*t + 0.254829592)*t*Math.exp(-ax*ax);
  return sign * y;
}

// Standard normal CDF
N = z => 0.5 * (1 + erf(z / Math.SQRT2));

// Black-Scholes pricing function
blackScholes = (S, K, T, r, sigma, q) => {
  // S: Current stock price
  // K: Strike price
  // T: Time to expiration (in years)
  // r: Risk-free rate (annualized)
  // sigma: Volatility (annualized)
  // q: Dividend yield (annualized)
  if (T <= 0) return {call: Math.max(0, S - K), put: Math.max(0, K - S)};
  const d1 = (Math.log(S / K) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const call = S * Math.exp(-q * T) * N(d1) - K * Math.exp(-r * T) * N(d2);
  const put = K * Math.exp(-r * T) * N(-d2) - S * Math.exp(-q * T) * N(-d1);
  return {call, put, d1, d2};
}

r = 0.04; T = 1; sigma = 0.20; q = 0;

// d1, d2 and option premiums
d1 = (Math.log(s0o / x) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * Math.sqrt(T));
d2 = d1 - sigma * Math.sqrt(T);
c0 = s0o * Math.exp(-q*T) * N(d1) - x * Math.exp(-r*T) * N(d2);
p0 = x * Math.exp(-r*T) * N(-d2) - s0o * Math.exp(-q*T) * N(-d1);

// Profit/Loss series at maturity across S_T
seriesLongCallPL  = Array.from({length: 201}, (_,i) => ({x: i, y: Math.max(0, i - x) - c0}));
seriesShortCallPL = Array.from({length: 201}, (_,i) => ({x: i, y: -Math.max(0, i - x) + c0}));
seriesLongPutPL   = Array.from({length: 201}, (_,i) => ({x: i, y: Math.max(0, x - i) - p0}));
seriesShortPutPL  = Array.from({length: 201}, (_,i) => ({x: i, y: -Math.max(0, x - i) + p0}));

Call Options

A call option gives the holder the right to buy the underlying asset at the exercise price.

md`Call premium (Black–Scholes, r = 4% cc, σ = 20%, T = 1): **${c0.toFixed(2)}**`

longCallPayoff = Plot.plot({
  caption: "Payoffs on a Long position on a Call option at the option maturity",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line([[0, 0], [x, 0], [200, 200 - x]], {stroke: "#2196F3"}),
    // Profit/Loss including premium
    Plot.line(seriesLongCallPL, {x: "x", y: "y", stroke: "#E91E63", strokeWidth: 2}),
    Plot.dot(
      [[sto, Math.max(0, sto - x)]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${sto}
X: ${x}
Premium C0: ${c0.toFixed(2)}
Payoff: ${Math.max(0, sto - x)}
P/L: ${ (Math.max(0, sto - x) - c0).toFixed(2) }`,
        tip: true
      }),
    Plot.tip(Plot.pointerX(seriesLongCallPL), {x: "x", y: "y", title: d => `S: ${d.x}\nPayoff: ${Math.max(0, d.x - x)}\nP/L: ${(Math.max(0, d.x - x) - c0).toFixed(2)}`}),
    Plot.crosshair(seriesLongCallPL, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Long Call position payoff"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>X <span class="badge">${x}</span></span>
  <span>Call premium C0 <span class="badge">${c0.toFixed(2)}</span></span>
  <span><span class="swatch" style="background: #2196F3"></span> Payoff</span>
  <span><span class="swatch" style="background: #E91E63"></span> P/L (incl. premium)</span>
  <span><span class="swatch" style="background: red"></span> Current point</span>
</div>`

shortCallPayoff = Plot.plot({
  caption: "Payoffs on a Short position on a Call option at the option maturity",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line([[0, 0], [x, 0], [200, x - 200]], {stroke: "#2196F3"}),
    // Profit/Loss including premium
    Plot.line(seriesShortCallPL, {x: "x", y: "y", stroke: "#E91E63", strokeWidth: 2}),
    Plot.dot(
      [[sto, -Math.max(0, sto - x)]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${sto}
X: ${x}
Premium C0: ${c0.toFixed(2)}
Payoff: ${-Math.max(0, sto - x)}
P/L: ${ (-Math.max(0, sto - x) + c0).toFixed(2) }`,
        tip: true
      }),
    Plot.tip(Plot.pointerX(seriesShortCallPL), {x: "x", y: "y", title: d => `S: ${d.x}\nPayoff: ${-Math.max(0, d.x - x)}\nP/L: ${(-Math.max(0, d.x - x) + c0).toFixed(2)}`}),
    Plot.crosshair(seriesShortCallPL, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Short Call position payoff"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>X <span class="badge">${x}</span></span>
  <span>Call premium C0 <span class="badge">${c0.toFixed(2)}</span></span>
  <span><span class="swatch" style="background: #2196F3"></span> Payoff</span>
  <span><span class="swatch" style="background: #E91E63"></span> P/L (incl. premium)</span>
  <span><span class="swatch" style="background: red"></span> Current point</span>
</div>`

Put Options

A put option gives the holder the right to sell the underlying asset at the exercise price.

md`Put premium (Black–Scholes, r = 4% cc, σ = 20%, T = 1): **${p0.toFixed(2)}**`

longPutPayoff = Plot.plot({
  caption: "Payoffs on a Long position on a Put option at the option maturity",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line([[0, x], [x, 0], [200, 0]], {stroke: "#2196F3"}),
    // Profit/Loss including premium
    Plot.line(seriesLongPutPL, {x: "x", y: "y", stroke: "#E91E63", strokeWidth: 2}),
    Plot.dot(
      [[sto, Math.max(0, x - sto)]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${sto}
X: ${x}
Premium P0: ${p0.toFixed(2)}
Payoff: ${Math.max(0, x - sto)}
P/L: ${ (Math.max(0, x - sto) - p0).toFixed(2) }`,
        tip: true
      }),
    Plot.tip(Plot.pointerX(seriesLongPutPL), {x: "x", y: "y", title: d => `S: ${d.x}\nPayoff: ${Math.max(0, x - d.x)}\nP/L: ${(Math.max(0, x - d.x) - p0).toFixed(2)}`}),
    Plot.crosshair(seriesLongPutPL, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Long Put position payoff"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>X <span class="badge">${x}</span></span>
  <span>Put premium P0 <span class="badge">${p0.toFixed(2)}</span></span>
  <span><span class="swatch" style="background: #2196F3"></span> Payoff</span>
  <span><span class="swatch" style="background: #E91E63"></span> P/L (incl. premium)</span>
  <span><span class="swatch" style="background: red"></span> Current point</span>
</div>`

shortPutPayoff = Plot.plot({
  caption: "Payoffs on a Short position on a Put option at the option maturity",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  pointer: "plot",
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line([[0, -x], [x, 0], [200, 0]], {stroke: "#2196F3"}),
    // Profit/Loss including premium
    Plot.line(seriesShortPutPL, {x: "x", y: "y", stroke: "#E91E63", strokeWidth: 2}),
    Plot.dot(
      [[sto, -Math.max(0, x - sto)]], 
      {
        fill: "red", 
        r: 5,
        title: d => `S_T: ${sto}
X: ${x}
Premium P0: ${p0.toFixed(2)}
Payoff: ${-Math.max(0, x - sto)}
P/L: ${ (-Math.max(0, x - sto) + p0).toFixed(2) }`,
        tip: true
      }),
    Plot.tip(Plot.pointerX(seriesShortPutPL), {x: "x", y: "y", title: d => `S: ${d.x}\nPayoff: ${-Math.max(0, x - d.x)}\nP/L: ${(-Math.max(0, x - d.x) + p0).toFixed(2)}`}),
    Plot.crosshair(seriesShortPutPL, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Short Put position payoff"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>X <span class="badge">${x}</span></span>
  <span>Put premium P0 <span class="badge">${p0.toFixed(2)}</span></span>
  <span><span class="swatch" style="background: #2196F3"></span> Payoff</span>
  <span><span class="swatch" style="background: #E91E63"></span> P/L (incl. premium)</span>
  <span><span class="swatch" style="background: red"></span> Current point</span>
</div>`

Option payoffs at maturity:

• Long Call: \(\max(0, S_T - X)\)
  
• Short Call: \(-\max(0, S_T - X)\)
  
• Long Put: \(\max(0, X - S_T)\)
  
• Short Put: \(-\max(0, X - S_T)\)

The blue lines in the diagrams represent the payoff at maturity. The pink lines also account for the premium paid or received, showing the final profit or loss.

NoteReference

This page accompanies Chapter 1 of Hull (2022).

References

Hull, John. 2022. Options, Futures, and Other Derivatives. 11th ed. Pearson.