Abstract:
A system, method and computer program product are described for providing the execution probability of a limit order within a given time period based on historical and current information and for adaptively and dynamically adjusting to intra-day trade data. For a given financial interest, the frequency of trade execution, the time evolution of the price, the time evolution of the trade volume, and the current state of the market, among other parameters, are captured and/or calculated. A probability function is generated based on the parameters corresponding to various time spans, and the execution probability of a limit order within a given time period is provided. Embodiments of the invention can be employed to estimate the probability of a limit order being executed within a given time period in the future, e.g., the next two minutes, based on the parameter data of a given time period in the past, e.g., the previous five minutes.

Description:
COPYRIGHT NOTICE 
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyrights whatsoever. 
     BACKGROUND OF THE INVENTION 
     The present invention relates generally to the field of trade execution and more particularly to providing an execution probability of a limit order of a given financial asset (hereinafter a “security” or a “stock”) or a given real asset or commodity, including those represented by a yellow key on a Bloomberg Professional® Service keyboard. Systems and methods known in the prior art for providing the execution probability of a limit order are based on, for example, econometric modeling, which directly models or tests execution probabilities, or models which directly model limit order book data. Such systems and methods are static and non-adaptive. The inventors do not believe such models to have achieved practical success. 
     SUMMARY OF THE INVENTION 
     Embodiments of the present invention provide a system, method, and computer program product useful in providing an execution probability of a limit order of a given security during a given time period. 
     Embodiments of the invention calculate the execution probability based on past or historical trade data, including past dynamics which may be predictive in nature. According to the embodiments of the invention, past parameters may include one or more of: times of executions of trades in the security over a given past time period (e.g., based on time stamps); executed volumes of trades in the security over a given past time period, prices of executed trades in the security over a given past time period. An execution probability is provided based on one or more of such parameters and current market state data, e.g., best ask price (for a buy order) or the best bid price (for a sell order). 
     Embodiments of the invention provide an execution probability based on a dynamic and adaptive model which, conditional on current market data, infers execution probability from an evolution model of a price-volume pair representing a bargaining process and its corresponding output process. 
     According to embodiments of the invention, observations of trade data for a given security are captured, e.g., some or all of the parameters identified above. According to embodiments of the invention, calculations are made of one or more of the frequency of trade execution, the time evolution of the stock price, and the time evolution of the trade volume. According to embodiments of the invention, a probability function is generated based on the some or all of the above parameters corresponding to various time spans and the execution probability of a limit order within a given time period is provided. 
     Embodiments of the invention provide execution probability of a limit order for at least one financial interest implemented by a computer system comprising at least one computer and a database comprising financial trade data of at least one financial interest. The at least one computer calculates dynamics in past trading of the at least one interest based on one or more of prices of past executed trades of the at least one interest, volumes of past executed trades of the at least one interest, and frequency of execution of past trades of the at least one interest. The at least one computer provides an execution probability within a given future time period of a limit order of the at least one financial interest based on the calculated past trading dynamics and a current market state of the at least one financial interest. 
     In one embodiment, the present invention can be employed to estimate the probability of a limit order being executed within a given time period in the future, e.g., the next two minutes, based on the trade data of a given time period in the past, e.g., the previous five minutes. This set of parameters captures the market movement over a short time period resulting in an adaptive and dynamic system and method of providing an execution probability. Such a system and method are highly beneficial when considering high levels of intra-day volatility, e.g., the market reaction to a press release. 
     In an embodiment, the system and method for providing the execution probability of a limit order of at least one security comprises at least one computer, at least one database comprising financial trade data of the security, and programming stored on a computer readable medium or media. When executed, the programming causes the computer to calculate a frequency of trade execution of the security, calculate a price movement of the security, calculate a distribution of trade volumes of the security, and determine a current market state of the security. Further, the program calculates an execution probability of a limit order of the security within a given time period based on the calculated frequency of trade execution, the calculated price movement, the calculated distribution of trade volumes, and the determined current market state. In an embodiment, the trade data comprises one or more of trade price, trade volume, trade timestamp, last bid, and last ask data for the security. 
     Embodiments of the invention provide for: calculating the frequency of trade execution comprising calculating the intensity of inter-arrival trade times based on trade timestamp data for the security; calculating the price movement comprising applying a Brownian motion, a geometric Brownian motion, a Martingale model, a Semimartingale model, or a Monte Carlo model to trade price and trade timestamp data; and calculating the distribution of trade volumes comprising applying a Weibull distribution, a Semimartingale model, or a Monte Carlo model to the trade volume data. 
     In an embodiment, determining the market state comprises determining a price-volume pair of a best bid or best ask of the security based on trade price and trade volume data. 
     In an embodiment, calculating the execution probability comprises applying a mathematical transformation to the calculated frequency of trade execution, the calculated price movement, the calculated distribution of trade volumes, and the determined current market state. In an embodiment, calculating the execution probability also comprises applying an integration formula using the calculated frequency of trade execution, the calculated price movement, the calculated distribution of trade volumes, and the determined current market state. In an embodiment, calculating the execution probability comprises applying an adaptive numerical integration routine using the calculated frequency of trade execution, the calculated price movement, the calculated distribution of trade volumes, and the determined current market state. 
     In various embodiments of the present invention, a computer program product comprises a computer program embodied on at least one computer readable medium, the computer program when executed being operative in performing the functionality described herein. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The invention is illustrated in the figures of the accompanying drawings, which are meant to be exemplary and not limiting, and in which like references are intended to refer to like or corresponding parts. 
         FIG. 1  illustrates a high-level flowchart of calculating the probability of a limit order being executed within a given time period. 
         FIG. 2  illustrates a flow of block  116  of  FIG. 1  which receives input parameters from blocks  108 ,  110 ,  112 , and  114  of  FIG. 1  and calculates the execution probability of a limit order within a given time period. 
         FIG. 3  depicts a block diagram of a computer system according to an embodiment of the invention for calculating the probability of a limit order being executed within a given time period. 
     
    
    
     DETAILED DESCRIPTION 
     According to embodiments of the invention, a system, method, and computer program provide an execution probability of a limit order of a given security during a given time period. The system, method, and computer program capture and/or calculate the frequency of trade execution, the time evolution of the price, the time evolution of the trade volume, and the current state of the market, among other parameters, for the given security. The system, method, and computer program generate a probability function based on the parameters corresponding to various time spans, i.e., the execution probability of a limit order within a given time period is provided. 
       FIG. 1  depicts an embodiment of a high-level flow  100  for estimating the probability of a limit order being executed. As populated, database  102  represents a database of trade data for the concerned security. In an embodiment, the database contains the trade price, trade volume, and trade timestamps for completed trades. This data may be obtained in any suitable manner by a programmed computer that received a data stream of market data or tick data and/or accesses a database, and selects and stores relevant data in the database  102 . 
     As populated, database  104  represents a limit order book database. In an embodiment, the database contains ask and bid prices, volume data, and timestamp data. Limit order data may be obtained from one or more entities&#39; order management system (OMS). Firms maintain OMSs for orders of that firm in various securities, and services maintain OMSs for their clients. Limit order data for a given security may be obtained from one or more OMSs in any suitable manner by a programmed computer having access to the concerned OMS(s), which selects the limit order book data and populates database  104 . 
     In block  106 , the trade data is extracted from databases  102  and  104  for a given security during a given time period. For example, a programmed computer may download the trade price, trade volume, and trade timestamps for each trade during a five minute period of time as well as the last bid price (if the order is a buy order) or last ask price (if the order is a sell order) and volume data during the same five minute period. 
     In blocks  108 ,  110 , and  112  market characteristics related to the trading of the security are captured or calculated by a programmed computer using algorithms such as described herein. 
     In block  108  the frequency of trade execution, is calculated for the security. In an embodiment, interarrival trade times are independent and identically-distributed exponential random variables. In this embodiment, an intensity parameter is calibrated based on input parameters comprising an array of trade timestamps for the interarrival trade times. 
     In an embodiment, the following algorithm  108  calibrates the intensity parameter in block  108  based on the input parameters comprising an array of trade timestamps for the interarrival trade times, where t is trade timestamp data and n is the number of trades: 
     
       
         
           
             
               λ 
               ^ 
             
             = 
             
               
                 1 
                 
                   
                     
                       ( 
                       
                         
                           t 
                           2 
                         
                         - 
                         
                           t 
                           1 
                         
                       
                       ) 
                     
                     + 
                     … 
                     + 
                     
                       ( 
                       
                         
                           t 
                           n 
                         
                         - 
                         
                           t 
                           
                             n 
                             - 
                             1 
                           
                         
                       
                       ) 
                     
                   
                   
                     n 
                     - 
                     1 
                   
                 
               
               = 
               
                 
                   n 
                   - 
                   1 
                 
                 
                   
                     t 
                     n 
                   
                   - 
                   
                     t 
                     1 
                   
                 
               
             
           
         
       
     
     In an embodiment, the above algorithm is executed in block  108  by the following pseudocode: 
     
       
         
           
             return 
             ⁢ 
             
                 
             
             ⁢ 
             
               
                 
                   length 
                   ⁡ 
                   
                     [ 
                     T 
                     ] 
                   
                 
                 - 
                 1 
               
               
                 
                   T 
                   ⁡ 
                   
                     [ 
                     
                       length 
                       ⁡ 
                       
                         [ 
                         T 
                         ] 
                       
                     
                     ] 
                   
                 
                 - 
                 
                   T 
                   ⁡ 
                   
                     [ 
                     1 
                     ] 
                   
                 
               
             
           
         
       
     
     In block  110  the price movement of the security is calculated. Price movements may follow a certain model, e.g., a Brownian motion, a geometric Brownian motion, Martingale, a Semimartingale, or Monte Carlo. In an embodiment, the drift and volatility parameters are calibrated based on input parameters comprising an array of trade prices and trade timestamps for a given model, e.g., a Brownian motion with a drift. 
     In an embodiment, the following algorithm  110 A calibrates the drift coefficient in block  110  based on the input of an array of trade prices and an array of corresponding trade timestamps, where m is the estimate for the two moments of inter-arrival trade times, p is trade price, and t is trade timestamp data. 
     
       
         
           
             
               μ 
               ^ 
             
             = 
             
               
                 
                   M 
                   1 
                 
                 
                   m 
                   1 
                 
               
               = 
               
                 
                   
                     p 
                     n 
                   
                   - 
                   
                     p 
                     1 
                   
                 
                 
                   
                     t 
                     n 
                   
                   - 
                   
                     t 
                     1 
                   
                 
               
             
           
         
       
     
     In an embodiment, the following algorithm  110 B calibrates the volatility coefficient in block  110  based on the input of an array of trade prices and an array of corresponding trade timestamps, where m is the estimate for the two moments of inter-arrival trade times, p is trade price, and t is trade timestamp data. 
     
       
         
           
             
               γ 
               ^ 
             
             = 
             
               
                 
                   
                     
                       M 
                       2 
                     
                     - 
                     
                       
                         
                           μ 
                           ^ 
                         
                         2 
                       
                       ⁢ 
                       
                         m 
                         2 
                       
                     
                   
                   
                     m 
                     1 
                   
                 
               
               = 
               
                 
                   
                     
                       [ 
                       
                         
                           
                             ( 
                             
                               
                                 p 
                                 2 
                               
                               - 
                               
                                 p 
                                 1 
                               
                             
                             ) 
                           
                           2 
                         
                         + 
                         … 
                         + 
                         
                           
                             ( 
                             
                               
                                 p 
                                 n 
                               
                               - 
                               
                                 p 
                                 
                                   n 
                                   - 
                                   1 
                                 
                               
                             
                             ) 
                           
                           2 
                         
                       
                       ] 
                     
                     - 
                     
                       
                         
                           μ 
                           ^ 
                         
                         2 
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               ( 
                               
                                 
                                   t 
                                   2 
                                 
                                 - 
                                 
                                   t 
                                   1 
                                 
                               
                               ) 
                             
                             2 
                           
                           + 
                           … 
                           + 
                           
                             
                               ( 
                               
                                 
                                   t 
                                   n 
                                 
                                 - 
                                 
                                   t 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                               ) 
                             
                             2 
                           
                         
                         ] 
                       
                     
                   
                   
                     
                       t 
                       n 
                     
                     - 
                     
                       t 
                       1 
                     
                   
                 
               
             
           
         
       
     
     In an embodiment, the above algorithms for drift and volatility coefficients are executed in block  110  by the following pseudocode: 
     
       
         
               
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
               
             
             
               
                   
                 
                   
                     
                       
                         drift 
                         ← 
                         
                           
                             
                               P 
                               [ 
                               
                                 length 
                                 ⁡ 
                                 
                                   [ 
                                   P 
                                   ] 
                                 
                               
                               ] 
                             
                             - 
                             
                               P 
                               [ 
                               1 
                               ] 
                             
                           
                           
                             
                               T 
                               [ 
                               
                                 length 
                                 [ 
                                 T 
                                 ] 
                               
                               ] 
                             
                             - 
                             
                               T 
                               [ 
                               1 
                               ] 
                             
                           
                         
                       
                     
                   
                 
               
               
                   
               
               
                   
                 m ← 0 
               
               
                   
                 M ← 0 
               
               
                   
                 for i ← 2 to length[T] 
               
             
          
           
               
                   
                 do m ← m + (T[i] − T[i − 1]) 2   
               
             
          
           
               
                   
                 M ← M + (P[i] − P[i − 1]) 2   
               
             
          
           
               
                   
                 
                   
                     
                       
                         volatility 
                         ← 
                         
                           
                             
                               M 
                               - 
                               
                                 
                                   drift 
                                   2 
                                 
                                 * 
                                 m 
                               
                             
                             
                               
                                 T 
                                 [ 
                                 
                                   length 
                                   [ 
                                   T 
                                   ] 
                                 
                                 ] 
                               
                               - 
                               
                                 T 
                                 [ 
                                 1 
                                 ] 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                   
               
               
                   
                 return drift, volatility 
               
               
                   
               
             
          
         
       
     
     In block  112 , the distribution of trade volumes of the security is calculated. In an embodiment, trade volumes are independent and identically-distributed Weibull random variables. Accordingly, location, scale, and shape Weibull parameters are calibrated based on input parameters comprising an array of trade volumes. More specifically, block  112  takes as input an array of independent and identically-distributed observations of a three-parameter Weibull distribution and returns, as output, the estimates for the location, scale, and shape parameters. 
     In an embodiment, the following algorithm  112 A calibrates the shape parameter in block  112  where N is the number of sample data: 
     
       
         
           
             
               
                 log 
                 ⁡ 
                 
                   ( 
                   
                     
                       
                         Γ 
                         ⁡ 
                         
                           ( 
                           
                             1 
                             + 
                             
                               2 
                               shape 
                             
                           
                           ) 
                         
                       
                       
                         
                           Γ 
                           ⁡ 
                           
                             ( 
                             
                               1 
                               + 
                               
                                 1 
                                 shape 
                               
                             
                             ) 
                           
                         
                         2 
                       
                     
                     - 
                     1 
                   
                   ) 
                 
               
               - 
               
                 log 
                 ( 
                 
                   1 
                   - 
                   
                     N 
                     
                       - 
                       
                         1 
                         shape 
                       
                     
                   
                 
                 ) 
               
               - 
               
                 log 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 a 
               
             
             = 
             0 
           
         
       
     
     In an embodiment, the following algorithm  112 B calibrates the location parameter in block  112 , where N is the number of sample data and minimum is the minimum trade volume: 
     
       
         
           
             
               
                 
                   N 
                   
                     1 
                     shape 
                   
                 
                 × 
                 minimum 
               
               - 
               
                 m 
                 1 
               
             
             
               
                 N 
                 
                   1 
                   shape 
                 
               
               - 
               1 
             
           
         
       
     
     In an embodiment, the following algorithm  112 C calibrates the scale parameter in block  112 , where N is the number of sample data and minimum is the minimum trade volume: 
     
       
         
           
             
               
                 N 
                 
                   1 
                   shape 
                 
               
               ⁡ 
               
                 ( 
                 
                   
                     m 
                     1 
                   
                   - 
                   minimum 
                 
                 ) 
               
             
             
               
                 ( 
                 
                   
                     N 
                     
                       1 
                       shape 
                     
                   
                   - 
                   1 
                 
                 ) 
               
               ⁢ 
               
                 Γ 
                 ⁡ 
                 
                   ( 
                   
                     1 
                     + 
                     
                       1 
                       shape 
                     
                   
                   ) 
                 
               
             
           
         
       
     
     In an embodiment, the above algorithms for calibrating the shape, location, and scale coefficients are executed in block  112  by the following pseudocode: 
     
       
         
           
             m 
             ← 
             
               mean 
               ⁡ 
               
                 [ 
                 A 
                 ] 
               
             
           
         
       
       
         
           
             
               skewed 
               ⁢ 
               
                   
               
               ⁢ 
               Var 
             
             ← 
             
               
                 
                   var 
                   ⁡ 
                   
                     [ 
                     A 
                     ] 
                   
                 
                 * 
                 
                   length 
                   ⁡ 
                   
                     [ 
                     A 
                     ] 
                   
                 
               
               
                 
                   length 
                   ⁡ 
                   
                     [ 
                     A 
                     ] 
                   
                 
                 - 
                 1 
               
             
           
         
       
       
         
           
             s 
             ← 
             
               min 
               ⁡ 
               
                 [ 
                 A 
                 ] 
               
             
           
         
       
       
         
           
             a 
             ← 
             
               
                 skewed 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 Var 
               
               
                 
                   ( 
                   
                     m 
                     - 
                     s 
                   
                   ) 
                 
                 2 
               
             
           
         
       
       
         
           
             shape 
             ← 
             
               DEKKER 
               ⁢ 
               
                 - 
               
               ⁢ 
               
                 BRENT 
                 ⁡ 
                 
                   ( 
                   
                     
                       
                         W 
                         BLCALIB 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           , 
                           a 
                           , 
                           
                             length 
                             ⁡ 
                             
                               [ 
                               A 
                               ] 
                             
                           
                         
                         ) 
                       
                     
                     , 
                     1 
                   
                   ) 
                 
               
             
           
         
       
       
         
           
             location 
             ← 
             
               
                 
                   
                     
                       length 
                       ⁡ 
                       
                         [ 
                         A 
                         ] 
                       
                     
                     
                       1 
                       shape 
                     
                   
                   * 
                   s 
                 
                 - 
                 m 
               
               
                 
                   
                     length 
                     ⁡ 
                     
                       [ 
                       A 
                       ] 
                     
                   
                   
                     1 
                     shape 
                   
                 
                 - 
                 1 
               
             
           
         
       
       
         
           
             scale 
             ← 
             
               
                 
                   
                     length 
                     ⁡ 
                     
                       [ 
                       A 
                       ] 
                     
                   
                   
                     1 
                     shape 
                   
                 
                 * 
                 
                   ( 
                   
                     m 
                     - 
                     s 
                   
                   ) 
                 
               
               
                 
                   ( 
                   
                     
                       
                         length 
                         ⁡ 
                         
                           [ 
                           A 
                           ] 
                         
                       
                       
                         1 
                         shape 
                       
                     
                     - 
                     1 
                   
                   ) 
                 
                 * 
                 
                   Γ 
                   ⁡ 
                   
                     ( 
                     
                       1 
                       + 
                       
                         1 
                         shape 
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           
             
               return 
               ⁢ 
               
                   
               
               ⁢ 
               location 
             
             , 
             scale 
             , 
             shape 
           
         
       
     
     In block  114 , the current state of the market is calculated based on the price-volume pair of an order. In an embodiment, in a buy order, the current state is defined as algorithm  114 A comprising the price-volume pair of the latest ask price and the latest ask volume. In an embodiment, in a sell order, the current state is defined as algorithm  114 B comprising the price-volume pair of the latest bid price and the latest bid volume. 
     In an embodiment, the above algorithms for calibrating the price-volume pairs are executed in block  114  by the following pseudocode: 
     
       
         
               
             
           
               
                   
               
             
             
               
                 if orderType == “Buy” 
               
               
                  then return askPrice[length[askPrice]], askVolume[length[askVolume]] 
               
               
                  else if orderType == “Sell” 
               
               
                       then return bidPrice[length[bidPrice]], 
               
               
                       bidVolume[length[bidVolume]] 
               
               
                       else  error “order type not found” 
               
               
                   
               
             
          
         
       
     
     The parameters calculated in blocks  108 ,  110 ,  112 , and  114  are received in block  116  as input to the execution probability algorithms. The algorithms produce, as output, a probability function corresponding to various time spans, i.e., the execution probability of a limit order within a given time period, e.g., the next two minutes, based on the input parameters. 
       FIG. 2  illustrates a flow of block  116  of  FIG. 1  which receives input parameters from blocks  108 ,  110 ,  112 , and  114  of  FIG. 1  and calculates the execution probability of a limit order within a given time period. 
       FIG. 2  depicts an embodiment of a flow  200  for calculating the parameters discussed in connection with  FIG. 1  for a sell limit order, to which the following description applies. Parameters may be calculated for a buy limit order in a similar fashion. In block  202 , input parameters from blocks  108 ,  110 ,  112 , and  114  of  FIG. 1  are transformed into auxiliary parameters to simplify the algorithms prior to final computation of the execution probability and to allow the same set of algorithms to be used in both buy and sell orders, with only the definitions of the auxiliary parameters differing. The auxiliary parameters may be generated by suitable mathematical transformation as can be determined by any person reasonably skilled in the art. In an embodiment, the auxiliary parameters are generated differentials. 
     In an embodiment, the following algorithms  202 A,  202 B, and  202 C generate the auxiliary parameters in block  202 , where x is price, y is volume, t is trade timestamp data, μ is the drift coefficient, and γ is the volatility coefficient: 
     
       
         
           
             p 
             = 
             
               
                 
                   x 
                   b 
                 
                 - 
                 x 
               
               
                 
                   
                     2 
                     ⁢ 
                     t 
                   
                 
                 ⁢ 
                 γ 
               
             
           
         
       
       
         
           
             q 
             = 
             
               
                 μ 
                 ⁢ 
                 
                   t 
                 
               
               
                 
                   2 
                 
                 ⁢ 
                 γ 
               
             
           
         
       
       
         
           
             θ 
             = 
             
               λ 
               ⁡ 
               
                 [ 
                 
                   1 
                   - 
                   
                     H 
                     ⁡ 
                     
                       ( 
                       
                         
                           y 
                           b 
                         
                         - 
                       
                       ) 
                     
                   
                 
                 ] 
               
             
           
         
       
     
     Calculating the execution probability of a limit order within a given time period may be based on any of a series of algorithms to improve the accuracy of the probability result. In an embodiment, the algorithm used for calculating the execution probability of a given limit order is chosen based on price and volume parameters. 
     In an embodiment, three algorithms are employed for different orders. More specifically, a first algorithm is applied if the sell price of a given security is equal to or below the bid price, and if the sell volume is below or equal to the bid volume. A second algorithm is applied if the sell price of a given security is equal to or below the bid price, and if the sell volume is greater than the bid volume. A third algorithm is applied if the sell price of a given security is greater than the bid price. 
     To determine which of the three algorithms to apply, in an embodiment, block  204  ( FIG. 2 ) determines whether the sell price of a given security is equal to or below the bid price. If the sell price is indeed below the bid price, the flow progresses to block  206 . 
     In block  206 , to further determine which of the three algorithms to apply, in an embodiment, it is determined whether the sell volume of a given security is equal to or below the bid volume. If the sell volume of a given security is equal to or below the bid volume, the flow progresses to block  208 . 
     In an embodiment, the above algorithms for generating the auxiliary parameters and the decisions in blocks  204  and  206  for a sell order may be executed by the pseudocode below, corresponding to  FIG. 2 , where the orderType is equal to “sell.” In the pseudocode below, “op” corresponds to sell price in  FIG. 2 , and “sp” corresponds to “state price” or bid price in  FIG. 2 . The flow for an order type equal to “buy” is similar to the flow depicted in  FIG. 2 , with the inequality and relationships being reversed for buy and offer prices. 
     
       
         
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
               
             
             
               
                   
                 if orderType == “Buy” 
               
               
                   
               
             
          
           
               
                   
                 
                   
                     
                       
                         
                           
                             then 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             p 
                           
                           ← 
                           
                             
                               op 
                               - 
                               sp 
                             
                             
                               
                                 
                                   2 
                                   * 
                                   t 
                                 
                               
                               ≠ 
                               volatility 
                             
                           
                         
                         , 
                         
                           q 
                           ← 
                           
                             
                               drift 
                               * 
                               
                                 t 
                               
                             
                             
                               
                                 2 
                               
                               * 
                               volatility 
                             
                           
                         
                       
                     
                   
                 
               
               
                   
               
             
          
           
               
                   
                 if (op ≧ sp) and (ov ≦ sp) 
               
             
          
           
               
                   
                 then formula Type = 0 
               
               
                   
                 else if (op ≧ sp) and (ov &gt; sv) 
               
             
          
           
               
                   
                 then formulaType = 1 
               
               
                   
                 else formulaType = 2 
               
             
          
           
               
                   
                 else if orderType == “Sell” 
               
               
                   
               
             
          
           
               
                   
                 
                   
                     
                       
                         
                           
                             then 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             p 
                           
                           ← 
                           
                             - 
                             
                               
                                 op 
                                 - 
                                 sp 
                               
                               
                                 
                                   
                                     2 
                                     * 
                                     t 
                                   
                                 
                                 * 
                                 volatility 
                               
                             
                           
                         
                         , 
                         
                           q 
                           ← 
                           
                             
                               
                                 - 
                                 drift 
                               
                               * 
                               
                                 t 
                               
                             
                             
                               
                                 2 
                               
                               * 
                               volatility 
                             
                           
                         
                       
                     
                   
                 
               
               
                   
               
             
          
           
               
                   
                 if (op ≦ sp) and (ov ≦ sv) 
               
             
          
           
               
                   
                 then formulaType = 0 
               
               
                   
                 else if (op ≦ sp) and (ov &gt; sv) 
               
             
          
           
               
                   
                 then formulaType = 1 
               
               
                   
                 else formulaType = 2 
               
             
          
           
               
                   
                 else error “order type not found” 
               
             
          
           
               
                   
                 theta ← intensity *(1 − W BL 3 CDF (location,scale,shape,ov)) 
               
               
                   
                 return p, q, theta, intType 
               
               
                   
               
             
          
         
       
     
     In block  208 , where the sell price of a given security has been determined to be equal to or below the bid price and the sell volume has been determined to be equal to or below the bid volume, the execution probability of the order is assumed to be one hundred percent, which is set in block  210  without further calculation. 
     Returning to block  206 , if the sell volume of a given security is greater than the bid volume, the flow progresses to block  212 . In block  212 , where the sell price of a given security has been determined to be equal to or below the bid price and the sell volume has been determined to be greater than the bid volume, the execution probability of the order is assumed to be less than one hundred percent. More specifically, as the bid volume is below the sell volume, a situation is created where the seller may request that the bidder execute a larger order, thereby affecting the execution probability. 
     To calculate an execution probability where the sell price of a given security is equal to or below the bid price, but the sell volume is greater than the bid volume, the flow progresses to block  214 . In this block, an integration formula is applied using the auxiliary parameters generated in block  202  along with the amount of time by which the order is to be executed, thereby returning the appropriate integrand. The returned integrand will be used to numerically evaluate execution probability in block  216 . In an embodiment, the Er f c function, a complementary error function of the C math library, is employed. 
     In an embodiment, the following algorithm  214  returns the appropriate integrand in block  214 , where p, q and θ are as defined above in algorithms  202 A,  202 B, and  202 C, and t is trade timestamp data: 
     
       
         
           
             
               
                 ⅇ 
                 
                   
                     - 
                     θ 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   tx 
                 
               
               ⁡ 
               
                 ( 
                 
                   
                     
                       ⅇ 
                       
                         - 
                         
                           
                             q 
                             2 
                           
                           ⁡ 
                           
                             ( 
                             
                               1 
                               - 
                               x 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         π 
                         ⁡ 
                         
                           ( 
                           
                             1 
                             - 
                             x 
                           
                           ) 
                         
                       
                     
                   
                   + 
                   
                     q 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       Erfc 
                       ⁡ 
                       
                         ( 
                         
                           
                             - 
                             q 
                           
                           ⁢ 
                           
                             
                               1 
                               - 
                               x 
                             
                           
                         
                         ) 
                       
                     
                   
                 
                 ) 
               
             
             ⁢ 
             
               ( 
               
                 
                   
                     ⅇ 
                     
                       
                         - 
                         
                           
                             p 
                             2 
                           
                           x 
                         
                       
                       + 
                       
                         2 
                         ⁢ 
                         pq 
                       
                       - 
                       
                         
                           q 
                           2 
                         
                         ⁢ 
                         x 
                       
                     
                   
                   
                     
                       π 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       x 
                     
                   
                 
                 - 
                 
                   q 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     ⅇ 
                     
                       4 
                       ⁢ 
                       pq 
                     
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     Erfc 
                     ⁡ 
                     
                       ( 
                       
                         
                           p 
                           
                             x 
                           
                         
                         + 
                         
                           q 
                           ⁢ 
                           
                             x 
                           
                         
                       
                       ) 
                     
                   
                 
               
               ) 
             
           
         
       
     
     In block  216 , an adaptive numerical integration routine is applied using the auxiliary parameters generated in block  202  along with the amount of time by which the order is to be executed and along with the integrand calculated in block  214 . In an embodiment, the adaptive numerical integration routine comprises the adaptive Gauss-Kronrod quadrature routine. The output of the adaptive numerical integration routine is the execution probability of the limit order based on the given parameters. 
     In an embodiment, the following algorithm  216  returns the execution probability of the limit order based on the given parameters in block  216 , where p, q and θ are as defined above in algorithms  202 A,  202 B, and  202 C, and t is trade timestamp data: 
     
       
         
           
             1 
             - 
             
               QUAD 
               ⁡ 
               
                 ( 
                 
                   
                     INTEGRAND 
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         p 
                         , 
                         q 
                         , 
                         θ 
                         , 
                         t 
                         , 
                         formulaType 
                       
                       ) 
                     
                   
                   , 
                   0 
                   , 
                   1 
                 
                 ) 
               
             
             - 
             
               
                 ⅇ 
                 
                   θ 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   t 
                 
               
               ⁡ 
               
                 ( 
                 
                   1 
                   - 
                   
                     
                       1 
                       2 
                     
                     ⁢ 
                     
                       Erfc 
                       ⁡ 
                       
                         ( 
                         
                           p 
                           - 
                           q 
                         
                         ) 
                       
                     
                   
                   - 
                   
                     
                       1 
                       2 
                     
                     ⁢ 
                     
                       ⅇ 
                       
                         4 
                         ⁢ 
                         pq 
                       
                     
                     ⁢ 
                     
                       Erfc 
                       ⁡ 
                       
                         ( 
                         
                           p 
                           + 
                           q 
                         
                         ) 
                       
                     
                   
                 
                 ) 
               
             
           
         
       
     
     Returning to block  204  ( FIG. 2 ), if the sell price of a given security is greater than the bid price, the flow progresses to block  218 . In such a case, the execution probability of the order is below one hundred percent as the bid price is below the sell price. Accordingly, an execution probability formula computes the probability that the order gets executed within a pre-specified time window. 
     To calculate an execution probability where the sell price of a given security is greater than the bid price, the flow progresses to block  220 . This block applies an integration formula using the auxiliary parameters generated in block  202  along with the amount of time by which the order is to be executed, thereby returning the appropriate integrand. The returned integrand will be used to numerically evaluate execution probability in block  222 . In an embodiment, the Er f c function, a complementary error function of the C math library, is employed. 
     In an embodiment, the following algorithm  220  returns the appropriate integrand in block  220 , where p, q and θ are as defined above in algorithms  202 A,  202 B, and  202 C, and t is trade timestamp data: 
     
       
         
           
             
               
                 ⅇ 
                 
                   
                     - 
                     θ 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   tx 
                 
               
               ( 
               
                 
                   
                     ⅇ 
                     
                       
                         - 
                         
                           
                             p 
                             2 
                           
                           
                             1 
                             - 
                             x 
                           
                         
                       
                       + 
                       
                         2 
                         ⁢ 
                         pq 
                       
                       - 
                       
                         
                           q 
                           2 
                         
                         ⁡ 
                         
                           ( 
                           
                             1 
                             - 
                             x 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       π 
                       ⁡ 
                       
                         ( 
                         
                           1 
                           - 
                           x 
                         
                         ) 
                       
                     
                   
                 
                 + 
                 
                   q 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     ⅇ 
                     
                       4 
                       ⁢ 
                       pq 
                     
                   
                   ⁢ 
                   
                     Erfc 
                     ⁡ 
                     
                       ( 
                       
                         
                           - 
                           
                             p 
                             
                               
                                 1 
                                 - 
                                 x 
                               
                             
                           
                         
                         - 
                         
                           q 
                           ⁢ 
                           
                             
                               1 
                               - 
                               x 
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               ) 
             
             ⁢ 
             
               ( 
               
                 
                   
                     ⅇ 
                     
                       
                         - 
                         
                           q 
                           2 
                         
                       
                       ⁢ 
                       x 
                     
                   
                   
                     
                       π 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       x 
                     
                   
                 
                 - 
                 
                   q 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     Erfc 
                     ⁡ 
                     
                       ( 
                       
                         q 
                         ⁢ 
                         
                           x 
                         
                       
                       ) 
                     
                   
                 
               
               ) 
             
           
         
       
     
     In block  222 , an adaptive numerical integration routine is applied using the auxiliary parameters generated in block  202  along with the amount of time by which the order is to be executed and the integrand calculated in block  220 . In an embodiment, the adaptive numerical integration routine comprises the adaptive Gauss-Kronrod quadrature routine. The output of the adaptive numerical integration routine is the execution probability of the limit order based on the given parameters. 
     In an embodiment, the following algorithm  222  returns the execution probability of the limit order based on the given parameters in block  222 , where p, q and θ are as defined above in algorithms  202 A,  202 B, and  202 C, and t is trade timestamp data: 
     
       
         
           
             
               - 
               
                 QUAD 
                 ⁡ 
                 
                   ( 
                   
                     
                       INTEGRAND 
                       ⁡ 
                       
                         ( 
                         
                           x 
                           , 
                           p 
                           , 
                           q 
                           , 
                           θ 
                           , 
                           t 
                           , 
                           formulaType 
                         
                         ) 
                       
                     
                     , 
                     0 
                     , 
                     1 
                   
                   ) 
                 
               
             
             + 
             
               
                 1 
                 2 
               
               ⁢ 
               
                 Erfc 
                 ⁡ 
                 
                   ( 
                   
                     
                       - 
                       p 
                     
                     + 
                     q 
                   
                   ) 
                 
               
             
             + 
             
               
                 1 
                 2 
               
               ⁢ 
               
                 ⅇ 
                 
                   4 
                   ⁢ 
                   pq 
                 
               
               ⁢ 
               
                 Erfc 
                 ⁡ 
                 
                   ( 
                   
                     
                       - 
                       p 
                     
                     - 
                     q 
                   
                   ) 
                 
               
             
           
         
       
     
       FIG. 3  illustrates a computer system  300  for implementing the functionality described herein. Order management system database  312  feeds order management system  310 . Market data database  316  and ticker plant  318  feed market data system  314 . Execution probability system  308  receives data from order management system  310  comprising at least one computer and market data system  314  comprising at least one computer and stores the extracted data in limit order book database  304  and trade data database  306 . Execution probability system  308  generates execution probabilities and forwards the execution probability data to computer  320 , which may be a personal computer, a financial terminal, or a web server. Computer  320  may also be used to manage execution probability system  308 . Limit order book database  304 , trade data database  306 , order management system database  312 , market data database  316 , ticker plant  318 , order management system  310 , market data system  314 , execution probability system  308 , and computer  320  may be connected via network connection  302  which may be any type of network system such as a local network, wide area network, or the Internet. Other arrangements of computer hardware and computer architecture may be used to collect, calculate, and store data, generate visual representations, and provide reports. 
     In various embodiments of the present invention, a computer program product comprises a computer program embodied on at least one computer readable medium, the computer program when executed being operative in performing the functionality described herein. 
     While the invention has been described and illustrated in connection with embodiments, many variations and modifications as will be evident to those skilled in this art may be made without departing from the spirit and scope of the invention as defined by the claims, and the invention is thus not to be limited to the precise details of methodology or construction set forth above as such variations and modifications are intended to be included within the scope of the invention as defined by the claims.