Formula to gauge success probability?

Discussion in 'Options' started by afx111, Feb 2, 2011.

  1. afx111

    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!
     
  2. 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.



    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.
     
  3. afx111

    afx111

    Thanks alot for the info guys! really useful stuff!
     
  4. 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.
     
  5. Which of those formulas is always best? :confused:
     
  6. GTG

    GTG

    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;
    //		}
    	}
    }
    
    
     
  7. Duuuude, every single one of them is golden and will make you a bazillionaire instantly.
     
  8. Probability of success trading options?

    Just multiply by 0.000000001... :p
     
    #10     Feb 4, 2011