Formula to gauge success probability?

A

afx111

Hi guys, is there a formula to determine the probability that an option trade's success?

For instance, whats the probability that an option would expire worthless in say 2 weeks? if its 10% away from strike price?

Should i perform like a simple probability distribution of returns on the underlying?

Or can i just look at the delta as a reasonable of success probability?

-- thanks!
 
Quote from afx111:

Hi guys, is there a formula to determine the probability that an option trade's success?
More...
Probability of success is not the same as probablility of
finishing in the money. "Success" for a long OTM call held
to expiration, for example, might be defined as the call
expiring ITM by an amount greater than you paid for it.

Assuming BSM log-normality, probability of a call finishing
ITM is N(d2). Probability of success is N(d2) computed with
your strike (K) increased by the amount you paid for the option.



Quote from afx111:
i just look at the delta as a reasonable of success probability?
[/B]
More...
For the example of a 10d call, delta is not a bad approximation.
Delta is N(d1), which will always be slightly less than N(d2),
just as probability of success is always less (for a long option)
than probability of finishing ITM.
 
The ThinkOrSwim platform has very nice built-in calculators for probability of expiring in the money and probability of touching a strike price.

You can add these as columns in a custom view of any option chain and display them in real time.
 
I translated these C# function from some excel vba code someone posted on EliteTrade several years ago. You could probably find the original VBA functions for excel with a search:

Code: 
using System;

namespace Trader.OptionPricing
{
	/// <summary>
	///  m drift
	/// s standard deviation
	/// t time
	/// H up barrier
	/// L down barrier
	/// K1,K2 barriers
	/// ST starting price

	/// ProbPTBB probability at time t the price is below the barrier
	/// ProbPTUB probability at time t the price is above the barrier
	/// ProbMaxPTUB probability at any time until t max price is crossing above the up barrier
	/// ProbMaxPTBB probability at any time until t max price is below the barrier
	/// ProbMinPTBB probability at any time until t min price is crossing bellow the down barrier
	/// ProbMinPTUB probability at any time until t min price is above the down barrier
	/// ProbFPBBMaxPTUB probability final price is below K1 and max price is crossing above the up barrier
	/// ProbFPUBMinPTBB probability final price is above K2 and min price is crossing below the down barrier
	/// </summary>
	/// 
	public class PriceProb
	{
		/// <summary>
		///  ProbPTBB probability at time t the price is below the barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="H">up barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbPTBB(double m, double s, double t, double H, double ST)
		{
			double MM = m - s*s/2;

			double ptbb = snorm( ( Math.Log(H/ST) - MM*t ) / ( s*Math.Sqrt(t) ) );
			
			return ptbb;
		}

		/// <summary>
		/// ProbPTUB probability at time t the price is above the barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="L">lower barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbPTUB(double m, double s, double t, double L, double ST)
		{
			double MM = m - s*s/2;

			double ptub = 1 - snorm( (Math.Log(L/ST) - MM*t) / (s*Math.Sqrt(t) ) );

			return ptub;
		}

		/// <summary>
		/// ProbMaxPTUB probability at any time until t max price is crossing above the up barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="H">up barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbMaxPTUB(double m, double s, double t, double H, double ST)
		{
			double MM = m - s*s/2;

			// ((H/ST)^(2*MM/s^2)) = Math.Pow( (H/ST), (2*MM/(s*s)) )
			double maxptub  =snorm(  ( -Math.Log(H/ST) + MM*t) / ( s*Math.Sqrt(t) ) )+Math.Pow( (H/ST), (2*MM/(s*s)) ) * snorm( ( -Math.Log(H/ST) - MM*t ) / ( s*Math.Sqrt(t) ) );
			
			return maxptub;
		}

		/// <summary>
		/// ProbMaxPTBB probability at any time until t max price is below the barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="H">up barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbMaxPTBB(double m, double s, double t, double H, double ST)
		{
			double MM = m - s*s/2;

			double maxptbb = 1 - ( snorm( ( -Math.Log(H/ST) + MM*t) / ( s*Math.Sqrt(t) ) ) + Math.Pow( (H/ST), (2*MM/(s*s)) ) * snorm( (- Math.Log(H/ST) - MM*t) / (s*Math.Sqrt(t) ) ) );

			return maxptbb;
		}

		/// <summary>
		/// ProbMinPTBB probability at any time until t min price is crossing bellow the down barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="L">down barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbMinPTBB(double m, double s, double t, double L, double ST)
		{
			double MM = m - s*s/2;

			// ((L/ST)^(2*MM/s^2)) = Math.Pow( (L/ST), (2*MM/(s*s)) )
			double minptbb = snorm( (Math.Log(L/ST) - MM*t) / (s*Math.Sqrt(t) ) ) + Math.Pow( (L/ST), (2*MM/(s*s)) ) * snorm( ( Math.Log(L/ST) + MM*t ) / (s*Math.Sqrt(t) ) );

			return minptbb;
		}

		/// <summary>
		/// ProbMinPTUB probability at any time until t min price is above the down barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="L">down barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbMinPTUB(double m, double s, double t, double L, double ST)
		{
			double MM = m - s*s/2;

			// ((L/ST)^(2*MM/s^2)) = Math.Pow( (L/ST), (2*MM/(s*s)) )
			double minptub = 1 - ( snorm( ( Math.Log(L/ST) - MM*t ) / ( s*Math.Sqrt(t) ) ) + Math.Pow( (L/ST), (2*MM/(s*s)) ) * snorm( (Math.Log(L/ST)+MM*t) / (s*Math.Sqrt(t) ) ) );

			return minptub;
		}


		/// <summary>
		/// ProbFPBBMaxPTUB probability final price is below K1 and max price is crossing above the up barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="H">up barrier</param>
		/// <param name="K1">barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbFPBBMaxPTUB(double m, double s, double t, double H, double K1, double ST)
		{
			double MM = m - s*s/2;

			// ((H/ST)^(2*MM/s^2)) = Math.Pow( (H/ST), (2*MM/(s*s)) )
			double fppbmaxptub = Math.Pow( (H/ST), (2*MM/(s*s)) ) * snorm( (Math.Log(K1/ST) - 2*Math.Log(H/ST) - MM*t) / (s*Math.Sqrt(t) ) );
			
			return fppbmaxptub;
		}
		
		/// <summary>
		/// ProbFPUBMinPTBB probability final price is above K2 and min price is crossing below the down barrier
		/// </summary>
		/// <param name="m">drift</param>
		/// <param name="m">drift</param>
		/// <param name="s">standard deviation</param>
		/// <param name="t">time</param>
		/// <param name="L">down barrier</param>
		/// <param name="K2">barrier</param>
		/// <param name="ST">starting price</param>
		/// <returns>the probability</returns>
		public static double ProbFPUBMinPTBB(double m, double s, double t, double L, double K2, double ST)
		{
			double MM = m - s*s/2;

			// ((L/ST)^(2*MM/s^2)) = Math.Pow( (L/ST), (2*MM/(s*s)) )
			double fpubminptbb = Math.Pow( (L/ST), (2*MM/(s*s)) )*snorm((-Math.Log(K2/ST)+2*Math.Log(L/ST)+MM*t)/(s*Math.Sqrt(t)));

			return fpubminptbb;
		}
		
		static double snorm(double sigma)
		{
			double z = 0.3989423*Math.Exp(-sigma*sigma*0.5);
			double y = 1.0 / (1.0 + 0.2316419*Math.Abs(sigma));
			double ysquared = y*y;
			double ycubed = ysquared*y;
			double yfourth = ycubed*y;
			double yfifth = yfourth*y;
			double x = 1.0 - z*(1.330274*yfifth - 1.821256*yfourth + 1.781478*ycubed - 0.356538*ysquared + 0.3193815*y);

			if (sigma >= 0.0)
			{
				return x;
			}

			if (sigma < 0.0)
			{
				return 1.0 - x;
			}

			throw new Exception("Sigma was NaN!");
		}

//		static double snorm(double z)
//		{
//			double a1 = 0.31938153;
//			double a2 = -0.356563782;
//			double a3 = 1.781477937;
//			double a4 = -1.821255978;
//			double a5 = 1.330274429;
//
//			double w;
//			if (0 > z)
//			{
//				w = -1;
//			}
//			else
//			{
//				w = 1;
//			}
//
//			double k = 1 / (1 + 0.2316419 * w * z);
//
//			double sn = 0.5 + w * (0.5 - 1 / Math.Sqrt(2 * Math.PI) * Exp(-z ^ 2 / 2) * (a1 * k + a2 * k ^ 2 + a3 * k ^ 3 + a4 * k ^ 4 + a5 * k ^ 5));
//
//			return sn;
//		}
	}
}
 
You must log in or register to reply here.
Back
Top