Overall Statistics |
Total Trades 16 Average Win 0% Average Loss 0% Compounding Annual Return -1.591% Drawdown 0.200% Expectancy 0 Net Profit -0.141% Sharpe Ratio -2.391 Probabilistic Sharpe Ratio 9.841% Loss Rate 0% Win Rate 0% Profit-Loss Ratio 0 Alpha -0.014 Beta 0.016 Annual Standard Deviation 0.005 Annual Variance 0 Information Ratio -3.27 Tracking Error 0.053 Treynor Ratio -0.711 Total Fees $328.50 Estimated Strategy Capacity $0 Lowest Capacity Asset AES 30JRGLXA5XIBQ|AES R735QTJ8XC9X |
using QuantConnect.Securities.Option; namespace QuantConnect.Algorithm.CSharp { public partial class CollarAlgorithm : QCAlgorithm { public class PutSpread { public decimal stockPrice; // 2 public DateTime exDate; // 3 may not be necessary public DateTime tradeDate; // 4 public DateTime putExpiry; // 5 public Symbol oldPutSymb; // 6 public Symbol newPutSymb; // 7 public decimal oldPutBid; // 8 public decimal newPutAsk; // 9 public decimal oldPutStrike; // 10 public decimal newPutStrike; // 11 public decimal newPutOpenInterest; // 12 //public decimal newPutDelta; //public decimal newPutGamma; //public decimal newPutVega; //public decimal newPutRho; //public decimal newPutTheta; //public decimal newPutImpliedVol; public decimal divAmt; // 13 public decimal divCount; // 14 public decimal divDollars; // 15 public decimal stkIncr; // 16 appreciation in stock value public decimal intCost; // 17 public decimal downsideRisk; // 18 public decimal upsidePotential; // 19 public decimal netIncome; // 20 public decimal netOptions; // 21 public decimal haircut; // 22 committed capital in a portfolio margin account public string description1; // 23 //public string description2; //public string description3; public override string ToString() { return this.description1; } public bool IsEmpty() { return this.description1.IsNullOrEmpty(); } } public List<PutSpread> AssemblePutSpreads(Slice slc, Dictionary<int, DateTime> expiries, TradePerfRec tPRec, IEnumerable<Symbol> allUndrOptSymbs, decimal sPrice, decimal incrAmt){ // only roll puts up if the appreciation in stock price + the expected dividends is greater than the cost of the put spread + interest cost // appreciation = incrAmt // get the expected dividends int yearsInTrade = 0; // to calculate dividends decimal monthsInTrade = 0; // to calculate dividends int daysInTrade = 0; // to calculate interest int intCost = 0; // interest cost decimal dividends = 0.0M; int k = 1; // initialize iterator for AddOptionContracts below Symbol optSymbol; // initialize option symbol for building the list of contracts Option tempOption; // initialize option contract for building list of contracts and obtaining pricing data Option thisPutOpt; // initialize option contract for building list of contracts and obtaining pricing data var justDate = slc.Time.Date; // separate out the DATEVALUE from the DateTime variable bc fedFundsRates are so indexed LUD.thisFFRate = LUD.fedFundsRates[justDate]; // fedFundsRates is a Dictionary of all dates where DateTime index are all 12:00:00am decimal oldPutPrem = Securities[tPRec.pSymbol].BidPrice; // need the price at which we might sell the puts; List<Option> putOptionsList = new List<Option>(); DateTime oldPutExpiry = tPRec.expDate; // use old put expiry for selecting put options to examine var atmPut = allUndrOptSymbs.Where(s => s.ID.OptionRight == OptionRight.Put) // get the ATM put strike for selecting put options to examine .OrderBy(s => Math.Abs(s.ID.StrikePrice - sPrice)) .FirstOrDefault(); if (haltProcessing && doTracing) { Debug(" ********* ******* WE GOT AN ATM PUT " ); } var atmStrike = atmPut.ID.StrikePrice; // get the ATM strike var lowStrike = tPRec.pStrike; var highStrik = atmStrike; //var lowStrike = (1 - (maxPutOTM / (decimal)100)) * atmStrike; // ~~ for selecting put options to examine //var highStrike = (decimal)1.1 * atmStrike; // ~~ for selecting put options to examine List<PutSpread> pSpreads = new List<PutSpread>(); // ~~ List for assembling filterd put options var putSymbs = allUndrOptSymbs; // declare the variable before the conditional branching // can we get current Put Expiration date? if (doTracing) Debug("---------------------- PUTS ROLLUP EXPIRIES PASS 1 ----------------------------"); if (doTracing) Debug("--" + stockPrice.ToString() +", " + expiries[2].ToString("MM/dd/yy") + ", " + expiries[3].ToString("MM/dd/yy") + ", " + expiries[4].ToString("MM/dd/yy") + ", " + expiries[5].ToString("MM/dd/yy")); /*putSymbs = allUndrOptSymbs.Where( o=> (DateTime.Compare(o.ID.Date, expiries[1])==0 | DateTime.Compare(o.ID.Date, expiries[2])==0 | DateTime.Compare(o.ID.Date, expiries[3])==0 | DateTime.Compare(o.ID.Date, expiries[4])==0 ) && o.ID.OptionRight == OptionRight.Put && o.ID.StrikePrice >= lowStrike && o.ID.StrikePrice < atmStrike) .OrderByDescending(o => o.ID.StrikePrice); */ putSymbs = allUndrOptSymbs.Where( o=> o.ID.Date.Subtract(slc.Time).Days >= 10 & o.ID.OptionRight == OptionRight.Put & o.ID.StrikePrice >= lowStrike & o.ID.StrikePrice <= atmStrike) .OrderByDescending(o => o.ID.StrikePrice); if (haltProcessing) { if (doTracing) IterateChain(putSymbs, "putSymbols"); } if (putSymbs == null | putSymbs.Count()== 0) { if (doTracing) Debug(" AP AP AP AP putSymbs is null or empty "); return pSpreads; } // putSymbs !=null && putSymbs.Count() != 0 -- in other words continue var pEnumerator = putSymbs.GetEnumerator(); // convert the options contracts list to an enumerator while (pEnumerator.MoveNext()) // process the contracts enumerator to add the options { optSymbol = pEnumerator.Current; tempOption = AddOptionContract(optSymbol, Resolution.Minute, true); tempOption.PriceModel = OptionPriceModels.BinomialTian(); /// necessary for Greeks putOptionsList.Add(tempOption); } var putEnum = putOptionsList.GetEnumerator(); // get the enumerator to build the List<PutSpread> while (putEnum.MoveNext()) { thisPutOpt = putEnum.Current; //if ( thisPutOpt.Expiry.Subtract(slc.Time).Days >= 10 ) { PutSpread pSpread = new PutSpread(); pSpread.stockPrice = sPrice; pSpread.tradeDate = justDate; pSpread.stkIncr = incrAmt; pSpread.oldPutSymb = tPRec.pSymbol; pSpread.newPutSymb = thisPutOpt.Symbol; pSpread.oldPutBid = oldPutPrem; pSpread.newPutAsk = thisPutOpt.AskPrice; pSpread.oldPutStrike = tPRec.pSymbol.ID.StrikePrice; pSpread.newPutStrike = thisPutOpt.StrikePrice; pSpread.putExpiry = thisPutOpt.Expiry; daysInTrade = (thisPutOpt.Expiry - justDate).Days; // use the new put option expiration to calculate potential days in trade pSpread.intCost = (LUD.thisFFRate + LUD.ibkrRateAdj)/LUD.workingDays * (decimal) daysInTrade * stockPrice; monthsInTrade = ((thisPutOpt.Expiry.Year - justDate.Year) * 12) + (thisPutOpt.Expiry.Month - justDate.Month); pSpread.divCount = Math.Truncate(monthsInTrade/3.00M) + 1.00M; // add 1 for the next dividend and 1 for every 3 months thereafter pSpread.divAmt = stockDividendAmount; pSpread.divDollars = stockDividendAmount * pSpread.divCount; // pSpread.divDollars = stockDividendAmount * pSpread.divCount; pSpread.divDollars = stockDividendAmount * 1M; // for profit calc and filtering, omit more than one dividend. Many PTS's end before 1st dividend is paid pSpread.netOptions = oldPutPrem - tPRec.pStartPrice - thisPutOpt.AskPrice; // get the total net cost of the options trade (not the spread traded) pSpread.netIncome = incrAmt + pSpread.divDollars - pSpread.intCost; // net potential profit including unrealized gain in underlying since initial trade //pSpread.newPutOpenInterest; //pSpread.newPutDelta; //pSpread.newPutGamma; //pSpread.newPutVega; //pSpread.newPutRho; //pSpread.newPutTheta; //pSpread.newPutImpliedVol; //pSpread.haircut; // committed capital in a portfolio margin account //pSpread.description1; //pSpread.description2; pSpreads.Add(pSpread); //} } return pSpreads; // return filled pSpreads; } // ********************** GetBestPutSpread ************************************** // *** This sub routine takes in the assembled List of PutSpreads // *** available in the Slice.Data and calculates the best spread to use // *** to the roll up the puts // *********************************************************************************** public PutSpread GetBestPutSpread(List<PutSpread> pSpreads) { PutSpread pSprd = new PutSpread(); // get a null empty PutSpread pSprd = pSpreads.Where(s => s.netIncome + s.netOptions > 0 ).OrderByDescending( s => (s.netIncome + s.netOptions)/Math.Abs(s.stockPrice - s.newPutStrike)).FirstOrDefault(); if (haltProcessing) { if (doTracing) Debug(" HALTED IN GETBESTPUTSPREAD -- CHECKING PSPREADS"); var orderedPSpreads = pSpreads.Where(s => s.netIncome + s.netOptions > 0 ).OrderByDescending( s => (s.netIncome + s.netOptions)/Math.Abs(s.stockPrice - s.newPutStrike)); IterateOrderedPutSpreadList(orderedPSpreads); } // null pSpread can occur when sPrice>oldPStrike but (sPrice-oldPStrike)/oldPStrike < ~2%: Also, rolling forward would cost money. return pSprd; } } }
namespace QuantConnect { /// 2020-12-03: Arranged all trade pathways, usingDeltas and not, to utilze GetPotentialCollars() /////// /// ####-##-##: in order to IterateOrderedMatrices solely when executing a trade. /// 2020-12-04: Added [[bestSSQRColumn = new SSQRColumn();]] to prevent looping and Matrix Iteration after initial SSQRMatrix buiding /// ####-##-## This was found to occur and created multiple copies of the same SSQR in subsequent OnData() events. /// 2020-12-07: Corrected RollTheCollar to calculate callQty by putPrem/callPrem (as is done in ExecuteTheTrade()). /// ####-##-## Also added bool didTheTrade to IterateOrderedSSQRMatix solely when actually trading /// 2020-12-08 Found GetPotentialCollars for ABBV would only return 2 divs (not 3 or 4) in 2015-10. April Options missing. Has May '16 options /// ####-##-## conferred with John, and decided to look further (LEAPS) for more possible trades. Added fifthExpirationDate to GetOptionsExpiries() /// 2020-12-08 Prevented duplicate call/put contracts from being added to SSQRMatrix in AssembleSSQRMatrix (!SSQRMatrix.Any(o=>o.optSymbo == optSymbol) /// 2020-12-13 Re-configured assembleSSQRMatrix to put and call list enumarators with all the options for 2-5 dividends, and loop 1X /// ####-##-## Build SSQR only occurs for calls >= put strike and expiration. /// 2020-12-13 Evaluation of SSQR Matrix reveals the potential of using call time spreads (selling longer dated calls to pay for puts) /// 2020-12-15 Saw several instances of divide-by-zero error when evaluating vcc/pot. loss (stockprice - putstrike) /// ####-##-## decided to reformulate the algorithm to sort first by loss potential and then by VCC. /// 2020-12-16 SIGNIFICANT -- modified bestSSQRColumn to sort descending by Math.Abs(stockPrice-putStrike) then ascending by putPremium/callPremium to get lowest risk and least call coverage /// 2021-01-04 Captured DivideByZero errors when StockPrice = PutStrike in CCOR calculations /// 2021-01-06 Added LogTrace to turn Debug on/off /// 2021-01-06 Debug placing and filling of limit orders for Call and Put closure /// 2021-01-07 refined debug placing/filling of Call/Put closure -- include MKT orders to better trace /// 2021-01-19 debugged oldRollDate. Never set initially and not always set in various branches of code. /// 2021-01-19 Found that in longer expirations, may try to set AddedMonths to 24. Error where Months%12 =0 /// 2021-01-21 Added code to exercise puts when rolling is more expensive than exercising. /// 2021-01-24 Added code to conditionally roll up puts when stock appreciates /// 2021-01-31 Added code in OnOrder() to detect call assignment so that the primary TradeRec collar PUTs are sold uEndPrice is recorded and record is closed /// 2021-01-31 Modified OTM code because in VCC put and call expirations may be different. Old code didnt trap all OTM situations /// 2021-02-01 Implemented calling Divididend Check to move code bytes to a different .cs file /// 2021-02-05 Wrapped OnEndOfDay in try-catch as well as .GetOpenOrders() routines. /// 2021-02-05 Found that LimitOrderTicket.Update() was not executing -- replaced update with MarketOrder /// 2021-02-08 ERROR: Found System.InvalidOperationException: Collection was modified; enumeration operation may not execute. /// Remedied this by creating a list<int> of oLOs.Indices to remove in a second step /// 2021-02-10 Version 13 Found that slightly OTM 2nd TPRs will not roll at expiration because they are OTM but spread is very small ($1.00). Thus, /// had to force exercise /// 2021-02-10 Version 13 Found that the orderTicket.Quantity follows the option, not the stock. Have to multiply by 100M in order to find the TPR /// 2021-02-10 Version 14 wrote foreach(2ndTPR in SecondTPRs) to process additional 2nd TPRs /// 2021-02-12 Version 15 reduced minDivs on PutRoll to 1 and only look out to 4th Div, not 5th. Found appreciating stocks move up faster and longer durations unnecessary /// 2021-02-15 changed formatting codes in IterateOrderedPutSpreads to make visible the ExpirationDate and to limit the decimals to 2 places /// 2021-02-17 fixed RollPut where expireDateDelta2P<1 and OTM--call Close2TPR. If ITM, then Exercise PUT /// 2021-02-18 Verssion 16 Found the 2nd TPR loop was using "current2ndRec" (1st 2nd TPR) data, not the actual sTPR from the loop. In situations with more than 1 2nd TPR, was totally wrong /// 2021-02-20 Version 17 Modified GetExpiries to ensure expires[1] is more than 10 days after the trade date /// 2021-02-21 modified to allow various paths, CheckDiv, CheckCall, CheckPut, & CheckOTM to execute serially until a good threshold and non-losing roll can be found /// until the last day, when a Kill or Close is called and forced. Modified OnOrder to track LEAN-intitiated call assignment /// 2021-02-23 Add GrossPnL and SSQR.netIncome to TPRs for analysis of roll PnL /// 2021-02-28 Attempted evaluation of ITM based upon actual option premiums rather than an arbitrary 5% based solely upon strikes -- failed due to QC internal algo's /// 2021-03-03 Base 2ndTPR split based upon intitial short call premium. Rationale is that stock appreciation above that number results in nullification of inititial short term capital collar credit. /// 2021-03-03 Modified 2ndTPR roll up based upon incrAmount > cost-to-sell-original-puts /// 2021-03-03 fixed a nit in creating thetaTPR.isSecondary -- make it false to prevent null pointers in processing puts in 2nd TPR Rec /// 2021-03-05 /// 2021-03-10 Converted to Wing Trade -- added PerfRec columns for wing call performance tracking and removed 2ndTPR Put Rolling and thetaCall processing /// 2021-03-12 Amended oLO (open limit order) processing to accomondate shoring calls to open collars and wing calls. /// 2021-03-12 WING VERSION 3 ELIMINATED CONVERSION TRADES -- SET CALLSTRIKE >> PUTSTRIKE /// 2021-03-12 WING VERSION 4 FIXED WINGFACTOR ERROR IN ROLLS /// 2021-03-12 WING VERSION 4C implemented hasDividends check /// 2021-03-12 WING VERSION 4D replaced TPR iteration loop AtEndOfAlogrithm() with expanded line-by-line string concatenation.... could not get actual options symbols otherwise /// 2021-03-21 WING VERSION 5 adjusted DownsideRisk to use Collar.netBid. Check for ITM WingCall to sell ahead of ITM ShortCall (new code in OnData() after Dividend Approachment /// 2021-10-17 Moved all CheckRoll.cs code for evaluating and processing rolls based upon expirations and options-monieness into TradePerfRec class. /// Then, in Main.cs OnData() the list of 1st TPR's are iterated and processed by calling tpr.CheckRoll() method. /*var OpenOrders = Transactions.GetOpenOrders(); // Get the open orders to search for open limit orders if (OpenOrders.Count() > 0) { // process them only if there's any open foreach (var OrderTkt in OpenOrders){ // loop through and process open options limit orders (HasUnderlying) if (OrderTkt.Status == OrderStatus.Submitted && OrderTkt.Type == OrderType.Limit) { if (OrderTkt.Symbol.HasUnderlying) { if (OrderTkt.Symbol.ID.OptionRight == OptionRight.Call) { var orderUnderlyingPrice = Securities[OrderTkt.Symbol.ID.Underlying.Symbol].Price; var Ticket = Extensions.ToOrderTicket(OrderTkt,Securities.SecurityTransactionManager); var orderLimitPrice = Ticket.Get(OrderField.LimitPrice); var orderStrikePrice = Ticket.Symbol.ID.StrikePrice; if (orderLimitPrice < orderUnderlyingPrice - orderStrikePrice + 0.10M) { /// this is the criteria for placing a call buyback limit order. This contition will exist if the underlying price has moved up Ticket.Update(new UpdateOrderFields{LimitPrice = orderUnderlyingPrice - orderStrikePrice + 0.10M}); } } else if (OrderTkt.Symbol.ID.OptionRight == OptionRight.Put) { var orderUnderlyingPrice = Securities[OrderTkt.Symbol.ID.Underlying.Symbol].Price; var orderLimitPrice = OrderTkt.Get(OrderField.LimitPrice); var orderStrikePrice = OrderTkt.Symbol.ID.StrikePrice; if (orderLimitPrice > orderStrikePrice - orderUnderlyingPrice - 0.10M) { /// this is the criteria for placing a put sell-to-close limit order. This contition will exist if the underlying price has moved down. OrderTkt.Update(new UpdateOrderFields{LimitPrice = orderStrikePrice - orderUnderlyingPrice - 0.10M}); } } } } } }*/ /* var OpenTickets = Transactions.GetOrderTickets(); // Get all the orders to search for open limit orders if (OpenTickets.Count() > 0) { // process them only if there's any open Debug(" |||||||| We have " + OpenTickets.Count() + " tickets"); foreach (var Ticket in OpenTickets){ // loop through and process open options limit orders (HasUnderlying) if (Ticket.Status == OrderStatus.Submitted && Ticket.OrderType == OrderType.Limit) { if (Ticket.Symbol.HasUnderlying) { Debug(" |||||||| Ticket for " + Ticket.Symbol + " is " + Ticket.Status + " submitted at " + Ticket.Time + " for " + Ticket.Quantity + "."); if ((int)data.Time.Subtract(Ticket.Time).TotalMinutes > 15) { if (Ticket.Symbol.ID.OptionRight == OptionRight.Call) { var orderUnderlyingPrice = Securities[Ticket.Symbol.ID.Underlying.Symbol].Price; var orderLimitPrice = Ticket.Get(OrderField.LimitPrice); var orderStrikePrice = Ticket.Symbol.ID.StrikePrice; var lPrice = orderUnderlyingPrice - orderStrikePrice + 0.10M; if (orderLimitPrice < orderUnderlyingPrice - orderStrikePrice + 0.10M) { /// this is the criteria for placing a call buyback limit order. This contition will exist if the underlying price has moved up //Debug(" |||||||| with " + Ticket.Symbol.ID.Underlying.Symbol + " trading at " + orderUnderlyingPrice + ", updating " + Ticket.Symbol + "limit order to new limit price: " + lPrice ); //Ticket.Update(new UpdateOrderFields{LimitPrice = orderUnderlyingPrice - orderStrikePrice + 0.10M}); Ticket.Cancel(); Debug(" |||||||| With " + Ticket.Symbol.ID.Underlying.Symbol + " trading at " + orderUnderlyingPrice + ", updating " + Ticket.Quantity + " of " + Ticket.Symbol + "limit order to market order"); var buyCallTkt = MarketOrder(Ticket.Symbol, Ticket.Quantity); if (buyCallTkt.Status == OrderStatus.Filled ){ bool anyTPRs = tradeRecs.Any(tr => tr.cSymbol.Equals(Ticket.Symbol) && -tr.cQty == Ticket.Quantity); if (anyTPRs) { var callTradeRec = tradeRecs.Where(tr => tr.cSymbol.Equals(Ticket.Symbol) && -tr.cQty == Ticket.Quantity).FirstOrDefault(); callTradeRec.cEndPrice = buyCallTkt.AverageFillPrice; //foreach (TradePerfRec tpr in callTradeRecs) { //tpr.cEndPrice = buyCallTkt.AverageFillPrice; //} } } } } else if (Ticket.Symbol.ID.OptionRight == OptionRight.Put) { var orderUnderlyingPrice = Securities[Ticket.Symbol.ID.Underlying.Symbol].Price; var orderLimitPrice = Ticket.Get(OrderField.LimitPrice); var orderStrikePrice = Ticket.Symbol.ID.StrikePrice; var lPrice = orderStrikePrice - orderUnderlyingPrice - 0.10M; if (orderLimitPrice > orderStrikePrice - orderUnderlyingPrice - 0.10M) { /// this is the criteria for placing a put sell-to-close limit order. This contition will exist if the //Debug(" |||||||| with " + Ticket.Symbol.ID.Underlying.Symbol + " trading at " + orderUnderlyingPrice + ", updating " + Ticket.Symbol + "limit order to new limit price: " + lPrice ); //underlying price has moved down. //Ticket.Update(new UpdateOrderFields{LimitPrice = orderStrikePrice - orderUnderlyingPrice - 0.10M}); Ticket.Cancel(); Debug(" |||||||| With " + Ticket.Symbol.ID.Underlying.Symbol + " trading at " + orderUnderlyingPrice + ", updating " + Ticket.Quantity + " of " + Ticket.Symbol + "limit order to market order"); var sellPutTkt = MarketOrder(Ticket.Symbol, Ticket.Quantity); if (sellPutTkt.Status == OrderStatus.Filled ){ bool anyTPRs = tradeRecs.Any(tr => tr.pSymbol.Equals(Ticket.Symbol) && -tr.pQty == Ticket.Quantity); if (anyTPRs) { var putTradeRec = tradeRecs.Where(tr => tr.pSymbol.Equals(Ticket.Symbol) && -tr.pQty == Ticket.Quantity).FirstOrDefault(); putTradeRec.pEndPrice = sellPutTkt.AverageFillPrice; //foreach (TradePerfRec tpr in putTradeRecs) { //tpr.pEndPrice = sellPutTkt.AverageFillPrice; //} } // is there TPR } // if order filled } // limit price needs to be changed } /// < 15" after order submission } // PUT } // OPTION ORDER } // FOR LOOP } } } catch (Exception errMsg) { Debug(" ERROR " + errMsg ); if (errMsg.Data.Count > 0) { Debug(" Extra details:"); foreach (DictionaryEntry de in errMsg.Data) Debug(" Key: {0,-20} Value: {1}'" + de.Key.ToString() + "'" + de.Value); } } */ }
namespace QuantConnect.Algorithm.CSharp { public partial class CollarAlgorithm : QCAlgorithm { public class LookupData { // ********************** DividendRecord ************************************** // *** This structure contains the dividend information necessary to calculate trading // *** decision. It is used to build a List<DividendRecord> that can be searched to // *** produce the nextExDivDate and dividend amount0 // *** doTracing // *** haltProcessing // *** exDividendDates // *** fedFundsRates // *** ibkrHairCuts // *** workingDays // *** thisFFRate // *** ibkrRateAdj public struct DividendRecord { public string ticker; public DateTime exDate; public decimal divAmt; public string frequency; } public List<SSQRColumn> SSQRMatrix = new List<SSQRColumn>(); public Symbol uSymbol; // underlying symbol in current processing public bool doTracing = false; public bool haltProcessing = false; public decimal workingDays = 365M; public decimal thisFFRate = 0M; public decimal ibkrRateAdj = .006M; // IBKR adds 60bps to FFR (blended over $3,000,000) public decimal maxPutOTM = 0M; // maximum Put OTM depth public List<DividendRecord> exDividendDates = new List<DividendRecord>(); public Dictionary<DateTime, decimal> fedFundsRates = new Dictionary<DateTime, decimal>(); public Dictionary<decimal, decimal> ibkrHairCuts = new Dictionary<decimal, decimal>(); public Dictionary<int, string> tickers = new Dictionary<int, string> (); public decimal divdndAmt = 0; public string divdnFrequency = ""; public DateTime exDivdnDate; public DateTime dtTst; // used for current date time in methods public int daysRemainingC; // use vars for checking days before expiration public int daysRemainingP; public int daysRemaining2P; public int daysRemainingWC; public void InitializeData(QCAlgorithm algo) { this.exDividendDates = this.GetDividendDates(algo); if (exDividendDates == null) algo.Debug("|||||||||||||||||| MISSING DIV DATES |||||||||||||||"); this.fedFundsRates = this.GetFedFundsRates(algo); if (fedFundsRates == null) algo.Debug("|||||||||||||||||| MISSING FED FUNDS |||||||||||||||"); this.ibkrHairCuts = this.InitializeHaircuts(algo); this.tickers = this.GetTickers(algo); } public void GetSliceData(QCAlgorithm algo) { } // ********************** getNextExDate ************************************** // *** Use this to find and return the next ex-dividend date from // *** the list exDividendDates given a Slice.DateTime // *********************************************************************************** public DateTime getNxtExDt(string tickStr, DateTime sliceTime, List<DividendRecord> exDivRecs) { // // /// /// NOTE: Adjusted this to .Compare(sliceTime, d.exDate <=0) to accommondate BND ex-dates on 1st of month // // /// /// NOTE: This should work because most stocks will be traded before progressing through the month to their ex-div dates DividendRecord nextExDateRec = exDivRecs.Where(d => DateTime.Compare(sliceTime.Date, d.exDate.Date)<=0 && d.ticker == tickStr) .OrderBy(d => d.exDate) .FirstOrDefault(); DateTime nextExDate = nextExDateRec.exDate; return nextExDate; } // ********************** GetTickers() ************************************** // *** This function downloads the tickers.csv file from Dropbox and loads it into // *** a Dictionary<int, string> for randomly selecting stocks to put on // *** this dictionary is used when making a trading decision private Dictionary<int, string> GetTickers(QCAlgorithm algo) { // https://www.dropbox.com/s/hkpr3luefv3u141/StockTickers.csv?dl=1 // 2020-09-26 // https://www.dropbox.com/sh/05qjk3o3y53fp4i/AAA6fEJg8J50xMQWm5nlg7M4a?dl=1 // prior var tickerFile = algo.Download("https://www.dropbox.com/s/hkpr3luefv3u141/StockTickers.csv?dl=1"); Dictionary <int, string> tkrs = new Dictionary<int, string>(); if (tickerFile == null) { algo.Debug(" TTTTTTTTTTTTTTTTTTTTTTT EMPTY TICKER FILE TTTTTTTTTTTTTTTTTTTTTTTTTTTTTT"); return tkrs; } string[] tickerLines = tickerFile.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); int h = 0; foreach (string tickerLine in tickerLines) { if(h==0) // discard header row { h++; continue; } var vals = tickerLine.Split(','); tkrs.Add(h, vals[0]); h++; } // these next 2 lines are for debugging only -- return tkrs; } // ********************** GetFedFundsRates() ************************************** // *** This function downloads the DFF.csv file from Dropbox and loads it into // *** a Dictionary<DateTime, interest rate> for each day // *** this dictionary is used when making a trading decision to calculate the interest private Dictionary<DateTime, decimal> GetFedFundsRates(QCAlgorithm algo) { var ffFile = algo.Download("https://www.dropbox.com/s/s25jzi5ng47wv4k/DFF.csv?dl=1"); if (ffFile == null) return null; Dictionary<DateTime, decimal> ffDict = new Dictionary<DateTime, decimal>(); string[] ffLines = ffFile.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); int h = 0; foreach (string ffLine in ffLines) { if(h==0) // discard header row { h++; continue; } var vals = ffLine.Split(','); ffDict.Add(DateTime.Parse(vals[0]), Convert.ToDecimal(vals[1])/100M); // convert percentage to decimal h++; } // these next 2 lines are for debugging only -- //DateTime testFind = DateTime.Parse("02/02/2015 16:30:00"); //var justDate = testFind.Date; return ffDict; } // ********************** GetDividendDates() ************************************** // *** This function downloads the DividendDates.csv file from Dropbox and loads it into // *** a List<DividendRecord>. The List is used to lookup the next ex-dividend date // *** this list is used when making a trading decision to calculate the dividend payout private List<DividendRecord> GetDividendDates(QCAlgorithm algo) { // 2020-9-25 9:24 https://www.dropbox.com/s/ap8s120gksb858h/DividendData.csv?dl=1 // 2020-09-25 8:11 https://www.dropbox.com/s/ap8s120gksb858h/DividendData.csv?dl=1 // 2020-09-25 8:09 https://www.dropbox.com/sh/05qjk3o3y53fp4i/AAA6fEJg8J50xMQWm5nlg7M4a?dl=1 -- zip file // 2021-01-14 8:33 var csvFile = Download("https://www.dropbox.com/s/ap8s120gksb858h/DividendData.csv?dl=1"); var csvFile = algo.Download("https://www.dropbox.com/s/jv0aaajwsw8auwo/FiveYearDividends.csv?dl=1"); if (csvFile == null) return null; decimal lastDiv = 0; List<DividendRecord> dividendDates = new List<DividendRecord>(); // want to use Microsoft.VisualBasic.FileIO csv parser but is not available // use the system's /cr /lf to parse the file string into lines string[] csvLines = csvFile.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); int i = 0; foreach (string csvLine in csvLines) { if (i == 0) { i++; continue; //discard the header row } var values = csvLine.Split(','); // this file is comma delimited if (!values[3].Equals("annual") ) { DividendRecord divRec = new DividendRecord(); divRec.ticker = values[0]; if (values[1] == "") { divRec.divAmt = 0; } else { divRec.divAmt = Convert.ToDecimal(values[1]); } divRec.exDate = DateTime.Parse(values[2]); divRec.frequency = values[3]; dividendDates.Add(divRec); } } i++; return dividendDates; } private Dictionary<decimal, decimal> InitializeHaircuts(QCAlgorithm algo) { Dictionary<decimal, decimal> ibkrHC = new Dictionary<decimal, decimal>(); ibkrHC.Add(0M, .75M); ibkrHC.Add(0.5M, .75M); ibkrHC.Add(1M, .75M); ibkrHC.Add(1.5M, .75M); ibkrHC.Add(2M, .75M); ibkrHC.Add(2.5M, .85M); ibkrHC.Add(3M, 1M); ibkrHC.Add(3.5M, 1.15M); ibkrHC.Add(4M, 1.3M); ibkrHC.Add(4.5M, 1.65M); ibkrHC.Add(5M, 2M); ibkrHC.Add(5.5M, 2.2M); ibkrHC.Add(6M, 2.4M); ibkrHC.Add(6.5M, 2.6M); ibkrHC.Add(7M, 2.8M); ibkrHC.Add(7.5M, 3M); ibkrHC.Add(8M, 3.5M); ibkrHC.Add(8.5M, 3.8M); ibkrHC.Add(9M, 4M); ibkrHC.Add(9.5M, 4.3M); ibkrHC.Add(10M, 4.5M); ibkrHC.Add(10.5M, 4.8M); ibkrHC.Add(11M, 5M); ibkrHC.Add(11.5M, 5.3M); ibkrHC.Add(12M, 5.5M); ibkrHC.Add(12.5M, 5.7M); ibkrHC.Add(13M, 6M); ibkrHC.Add(13.5M, 6.2M); ibkrHC.Add(14M, 6.6M); ibkrHC.Add(14.5M, 6.8M); ibkrHC.Add(15M, 7M); ibkrHC.Add(15.5M, 7.2M); ibkrHC.Add(16M, 7.4M); ibkrHC.Add(16.5M, 7.6M); ibkrHC.Add(17M, 7.8M); ibkrHC.Add(17.5M, 8.1M); ibkrHC.Add(18M, 8.2M); ibkrHC.Add(18.5M, 8.4M); ibkrHC.Add(19M, 8.6M); ibkrHC.Add(19.5M, 8.8M); ibkrHC.Add(20M, 9M); ibkrHC.Add(20.5M, 9.2M); ibkrHC.Add(21M, 9.4M); ibkrHC.Add(21.5M, 9.6M); ibkrHC.Add(22M, 9.8M); ibkrHC.Add(22.5M, 10.1M); ibkrHC.Add(23M, 10.4M); ibkrHC.Add(23.5M, 10.7M); ibkrHC.Add(24M, 11M); ibkrHC.Add(24.5M, 11.4M); ibkrHC.Add(25M, 11.8M); ibkrHC.Add(25.5M, 12.3M); ibkrHC.Add(26M, 12.8M); ibkrHC.Add(26.5M, 13.2M); ibkrHC.Add(27M, 13.7M); ibkrHC.Add(27.5M, 14.2M); ibkrHC.Add(28M, 14.7M); ibkrHC.Add(28.5M, 15.2M); ibkrHC.Add(29M, 15.6M); ibkrHC.Add(29.5M, 16.1M); ibkrHC.Add(30M, 16.6M); ibkrHC.Add(30.5M, 17M); ibkrHC.Add(31M, 17.4M); ibkrHC.Add(31.5M, 17.8M); ibkrHC.Add(32M, 13.4M); ibkrHC.Add(32.5M, 18.2M); ibkrHC.Add(33M, 18.6M); ibkrHC.Add(33.5M, 19M); ibkrHC.Add(34M, 19.4M); ibkrHC.Add(34.5M, 19.8M); ibkrHC.Add(35M, 20.2M); return ibkrHC; } // end initializeIBKR // ********************** getNextExDate ************************************** // *** Use this to find and return the next ex-dividend date from // *** the list exDividendDates given a Slice.DateTime // *********************************************************************************** public void GetNextExDate(QCAlgorithm algo) { // // /// /// NOTE: Adjusted this to .Compare(sliceTime, d.exDate <=0) to accommondate BND ex-dates on 1st of month // // /// /// NOTE: This should work because most stocks will be traded before progressing through the month to their ex-div dates if (haltProcessing) { algo.Debug(" HALTED IN getNextExDate"); } DateTime sliceTime = algo.CurrentSlice.Time; string tickStr = this.uSymbol.Value; DividendRecord nextExDateRec = exDividendDates.Where(d => DateTime.Compare(sliceTime.Date, d.exDate.Date)<=0 && d.ticker == tickStr) .OrderBy(d => d.exDate) .FirstOrDefault(); this.exDivdnDate = nextExDateRec.exDate; this.divdndAmt = nextExDateRec.divAmt; this.divdnFrequency = nextExDateRec.frequency; return; } public void GetNextExDate(string tickStr, QCAlgorithm algo) { // // /// /// NOTE: Adjusted this to .Compare(sliceTime, d.exDate <=0) to accommondate BND ex-dates on 1st of month // // /// /// NOTE: This should work because most stocks will be traded before progressing through the month to their ex-div dates if (haltProcessing) { algo.Debug(" HALTED IN getNextExDate"); } DateTime sliceTime = algo.CurrentSlice.Time; DividendRecord nextExDateRec = exDividendDates.Where(d => DateTime.Compare(sliceTime.Date, d.exDate.Date)<=0 && d.ticker == tickStr) .OrderBy(d => d.exDate) .FirstOrDefault(); this.exDivdnDate = nextExDateRec.exDate; this.divdndAmt = nextExDateRec.divAmt; this.divdnFrequency = nextExDateRec.frequency; return; } } /// end class lookupData } }
using QuantConnect.Securities.Option; using static QuantConnect.StringExtensions; using System.Collections.Generic; using System.Drawing; using Newtonsoft.Json; namespace QuantConnect.Algorithm.CSharp { public partial class CollarAlgorithm : QCAlgorithm { // Initialize trade control variables used to intercept automated options exercise. //public var uniThis; public bool badDtParameter; // get this from the parameters for debugging public bool haltProcessing = false; // use this to trap ERROR public bool doTracing = false; // turn Debug() process tracing on/off public Symbol symbFilter = null; //bool didTheTrade = false; // Flag that permits InterateOrderedSSQRMatrix only if a trade was done OrderTicket closeCallTicket; // use this to track and manage collar rolling and killing trades OrderTicket closePutTicket; // use this to track and manage collar rolling and killing trades OrderTicket closeWCallTicket; // use this to track and manage collar rolling and killing trades List<OpenLimitOrder> oLOs = new List<OpenLimitOrder>(); // maintain a list of open limit orders to manage bool iteratePortfolio = false; // Switch to toggle Iterating and Logging portfolio decimal stockDollarValue; // get the dollar value for the position decimal sharesToBuy; // Get the number shares to achieve the value bool hasDividends = true; // Bool set (unset=false) to determine whether to add security to portfolio decimal optionsToTrade; // Get the initial Options to trade (1/10th the sharesToBuy) decimal callsToTrade; // Get the initial call options to trade in a variable call coverage strategy //decimal maxPutOTM = 0.5M; // Instantiate and set maximum depth of PUT OTM -- percentage int MinNmbrDivs = 1; // Instantiate and set minimum number of dividends acceptable in BestSSQRMatrix decimal wingFactor = 0; // wing factor to multiply optionsToTrade to trade the wings decimal vix; // used to track and log vix values bool doTheTrade = false; // Used to allow trades the algorithm initiates bool didTheTrade = false; // used to toggle iterating SSQRMatrix bool useDeltas = false; // used to turn use of deltas in trade determination on or off public decimal ROCThresh; // return on (risk/margin-committed) capital public decimal RORThresh; // return on risk (= net collar cost - put strike) public decimal CCORThresh; // call coverage ratio / risk for 0 cost collar (risk = stockPrice - putStrike) bool goodThresh = false; // used to determine go/no-go on trade public bool switchROC = true; LookupData LUD = new LookupData(); // repository of system-wide and common data List<TradePerfRec> tradeRecs = new List<TradePerfRec>(); // used to track P&L of trades List<TradePerfRec> tprsToClose = new List<TradePerfRec>(); // List of TPRs to Close. // use this in OnData TPR-driven position updating List<TradePerfRec> tprsToOpen = new List<TradePerfRec>(); // List of TPRs to Open. // use this in OnData TPR-driven position updating List<TradePerfRec> secTPRs = new List<TradePerfRec>(); List<TradePerfRec> thetaTPRs = new List<TradePerfRec>(); int tradeRecCount = 0; // track the trade count int secndRecCount = 0; // loop counter for processing 2nd Recs int collarIndex = 0; bool hasPrimaryRec = false; bool hasSecondaryRec = false; bool hasThetaRec = false; int curr2ndTPR = 0; // Used to store index int curr1stTPR = 0; // used to store index of 1st TPR // Use this to filter FineFilterSelection to 1 stock as specified by Algorithm Parameter. string strFilterTkr = ""; Symbol thisSymbol; // Initialize Symbol as class variable decimal incrPrice = 0; // check for underlying price appreciation decimal currSellPnL = 0; // for calculating potential roll P&L decimal currExrcsPutPnL = 0; // for calculating potential roll P&L decimal currExrcsCallPnL = 0; // for calculating potential roll P&L decimal callStrike; decimal putStrike; decimal sTPRPutStrike; // strike of 2nd TPR Put Strike decimal wcStrike; // strike of wing call for evaluating sale Symbol debugSymbol; // general purpose debugging variable OptionChain debugChain; // special purpose debugging variable decimal stockPrice = 0; decimal fTPRPutPrice = 0; // used when rolling up stop losses or deciding to exercise ITM positions decimal sTPRPutPrice = 0; // used when evaluating sTPRs for rolling or extinguishing decimal thisROC = 0; decimal thisROR = 0; decimal thisCCOR = 0; decimal heldValue = 0; // value of thisSymbol held bool buyMoreShares = false; // decision to buy more shares of thisSymbol or keep managing inventory SSQRColumn bestSSQRColumn = new SSQRColumn(); decimal stockDividendAmount = 0M; string divFrequency = "Quarterly"; decimal divPlotValue = 0M; DateTime fmrNextExDate; bool sellThePut = false; // ORDER MANAGEMENT CONTROL -- SET sellThePut whenever calls are exercised by LEAN bool buyTheCall = false; // ORDER MANAGEMENT CONTROL -- SET buyThePut whenever puts are exercised by LEAN // Added foundOption dictionary to store if we have pulled greek data for our securities Dictionary<Symbol, bool> foundOption = new Dictionary<Symbol, bool>(); // Holds multi ticker data Dictionary<Symbol, SymbolData> symbolDataBySymbol = new Dictionary<Symbol, SymbolData>(); int lastMonth = -1; // *** *** *** *** *** *** *** *** *** *** ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ *** *** *** *** *** *** *** *** *** *** *** *** *** *** // *** *** *** *** *** *** *** *** *** *** | PRICE AND DIVIDEND AND TRANSACTION PLOT |** *** *** *** *** *** *** *** *** *** *** *** *** *** *** // *** *** *** *** *** *** *** *** *** *** ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ *** *** *** *** *** *** *** *** *** *** *** *** *** *** // Instantiate and set plotting information //Stochastic sto; // Stochastic AccumulationDistribution ad; // Accumulation / Distribution AccumulationDistributionOscillator adOsc; // Accumulation / Distribution Oscillator AverageDirectionalIndex adx; // Average Directional Index AverageDirectionalMovementIndexRating adxr; // Average Directional Index Rating OnBalanceVolume obv; // On Balance Volumne indicator Variance variance; // Variance of this stock //decimal lastSto; // store values from night before decimal lastAd; decimal lastAdOsc; decimal lastAdx; decimal lastAdxr; decimal lastObv; decimal lastVariance; Chart stockPlot; // initialize Series Variables to reference during order processing and endofday plotting Series buyOrders; Series sellOrders; Series rollOrders; Series ptsOrders; Series assetPrice; Series varianceS; //Series stochastics; Series dividendsS; Series vixVals; // *** *** *** *** *** *** *** *** *** *** ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ *** *** *** *** *** *** *** *** *** *** *** *** *** *** // *** *** *** *** *** *** *** *** *** *** | END OF VARIABLE DECLARATION AND INSTANTIATION |** *** *** *** *** *** *** *** *** *** *** *** *** *** *** // *** *** *** *** *** *** *** *** *** *** ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ ‾‾‾ *** *** *** *** *** *** *** *** *** *** *** *** *** *** public override void Initialize() { DateTime startDate = DateTime.Parse(GetParameter("StartDate")); DateTime endDate = DateTime.Parse(GetParameter("EndDate")); SetStartDate(startDate.Year, startDate.Month, startDate.Day); //Set Start Date SetEndDate(endDate.Year, endDate.Month, endDate.Day); // Set End Date SetCash(10000000); //Set Strategy Cash SetWarmup(TimeSpan.FromDays(31), Resolution.Daily); //ABBV ADM BA BBY BMY CVS DOW GIS GM IBM IRM KO LVS M OHI OXY PM PG PSX QCOM SO T VZ WFC XOM // Get RunTime control parameters for Minimum # of Dividends and Maximum OTM Put Depth strFilterTkr = GetParameter("stockTicker"); if (!strFilterTkr.IsNullOrEmpty()) { symbFilter = QuantConnect.Symbol.Create(strFilterTkr, SecurityType.Equity, Market.USA); /// create a symbol to filter the Universe if one is in the parameters } badDtParameter = GetParameter("CheckBadDate") == "true" ? true : false; // get this from parameters stockDollarValue = Convert.ToDecimal(GetParameter("StockDollarValue")); MinNmbrDivs = Convert.ToInt16(GetParameter("MinNmbrDivs")); // get and set minimum number of dividends acceptable in BestSSQRMatrix useDeltas = GetParameter("UseDeltas") == "true" ? true : false; // get this from parameters wingFactor = Convert.ToDecimal(GetParameter("wingFactor")); // get wing factor for multiplying optionsToTrade when putting on wing LUD.InitializeData(this); LUD.maxPutOTM = Convert.ToDecimal(GetParameter("MaxOTMPutDepth")); // get and set the Maximum OTM Put Depth LUD.doTracing = GetParameter("LogTrace") == "true" ? true : false; // get this from paramters to turn Debug() tracing on/off // Chart - Master Container for the Chart: if (symbFilter !=null) { stockPlot = new Chart("Stock Chart"); // On the Trade Plotter Chart we want 3 series: trades and price: buyOrders = new Series("Buys", SeriesType.Scatter, "$", Color.Green, ScatterMarkerSymbol.Triangle); rollOrders = new Series("Rolls", SeriesType.Scatter, "$", Color.Blue, ScatterMarkerSymbol.Square); ptsOrders = new Series("PTSs", SeriesType.Scatter, "$", Color.Crimson, ScatterMarkerSymbol.Square); sellOrders = new Series("Sells", SeriesType.Scatter, "$", Color.Red, ScatterMarkerSymbol.TriangleDown); dividendsS = new Series("Divs", SeriesType.Scatter, "$", Color.Pink, ScatterMarkerSymbol.Diamond); assetPrice = new Series("EOD Price", SeriesType.Line, "$", Color.Purple); varianceS = new Series("Variance", SeriesType.Line, "$", Color.Magenta); assetPrice.Index = 0; buyOrders.Index = 0; rollOrders.Index = 0; ptsOrders.Index = 0; sellOrders.Index = 0; dividendsS.Index = 0; stockPlot.AddSeries(buyOrders); stockPlot.AddSeries(rollOrders); stockPlot.AddSeries(ptsOrders); stockPlot.AddSeries(sellOrders); stockPlot.AddSeries(dividendsS); stockPlot.AddSeries(assetPrice); AddChart(stockPlot); } //SetSecurityInitializer(HistoricalSecurityInitializer); var uniThis = AddUniverse(CoarseSelectionFilter, FineSelectionFunction); } // // // /// /// /// /// /// Initialize() public void OnData(TradeBars tbData) { // Does this update the indicators? } public void OnData(Dividends dData) ///// //////// check this for completeness and cohesion with previous versions { try{ if (Portfolio.Invested) { foreach(var pair in symbolDataBySymbol) { //// wonder if this will miss some .Distribution values? Symbol thisSymbol = pair.Key; SymbolData symbolData = pair.Value; if(dData.ContainsKey(thisSymbol)) { int k = 0; // counter for updates var paymentAmount = dData[thisSymbol].Distribution; if (doTracing) Debug(" DDDDDDDDDD DDDDDDDDDDD DIVIDENDS FOR " + thisSymbol + " ARE " + paymentAmount); if (tradeRecs.Any(tpr=> tpr!=null && tpr.isOpen && tpr.uSymbol.Equals(thisSymbol))) { foreach(var tprec in tradeRecs.Where(tpr=> tpr.isOpen && tpr.uSymbol.Equals(thisSymbol))) { tprec.numDividends = tprec.numDividends + 1; tprec.divIncome = tprec.divIncome + paymentAmount; k = k + 1; } } if (doTracing) Debug(" DDDDDDDDDD DDDDDDDDDDD UPDATED " + k.ToString() + " TRADE PERF RECORDS. "); if (doTracing) Debug("-"); if (symbFilter != null) Plot("Stock Chart", "Divs", divPlotValue); } } } } catch (Exception errMsg) { if (doTracing) Debug(" DIV ERROR DIV ERROR DIV ERROR " + errMsg); return; } } public override void OnData(Slice data) { if (data.Time.Hour != 9) return; if (data.Time.Minute % 15 != 0) return; // evaluate everything every 15 minutes foreach(var pair in symbolDataBySymbol) { Symbol thisSymbol = pair.Key; LUD.uSymbol = thisSymbol; SymbolData symbolData = pair.Value; if (!IsMarketOpen(thisSymbol)) return; //CheckGreeks(ref foundOption, data); ///// **** **** Jovad Jovad Jovad : where is foundOption set to something to be checked? if(!data.Bars.ContainsKey(thisSymbol)) ///// **** **** Jovad Jovad Jovad : Won't this exit the whole OnData() if solely 1 thisSymbol is not here return; goodThresh = false; // set the threshold switch to false; hasPrimaryRec = hasSecondaryRec = false; // reset processing branch flags if (CheckBadDate(data.Time)) { LUD.haltProcessing = true; Debug(" @@@@@@ BAD DATE @@@@@@@@@@ The price of " + thisSymbol + " is " + data[thisSymbol].Price); foreach(var kvp in Securities) { var security = kvp.Value; if (security.Invested) { Debug($" |-|-|-|- HOLDINGS: {security.Symbol} : {security.Holdings.Quantity} @ {security.BidPrice} by {security.AskPrice}"); } } } else LUD.haltProcessing = false; if (LUD.haltProcessing) { Debug(" Logging ONDATA()"); } if (didTheTrade) { Debug($" |||| |||| |||| DID A TRADE "); foreach(var kvp in Securities) /// make sure there's no leaking of abandoned stocks or options { var security = kvp.Value; if (security.Invested) { Debug($" |||| HOLDINGS: {security.Symbol} : {security.Holdings.Quantity} @ {security.BidPrice} by {security.AskPrice}"); } } didTheTrade = false; } //if (newRollDate.GetHashCode() == 0) newRollDate = data.Time.Date; //if (oldRollDate.GetHashCode() == 0) oldRollDate = data.Time.Date; string tickerString = thisSymbol.Value; LUD.GetNextExDate(tickerString, this); if (LUD.exDivdnDate.Equals(DateTime.MinValue)) { if (doTracing) Debug("----- NULL nextExDate ----- NULL nextExDate -----"); hasDividends = false; return; } else hasDividends = true; stockPrice = data[thisSymbol].Price; if (divPlotValue == 0) { divPlotValue = stockPrice - 5; } thisROC = 0; thisROR = 0; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // IF NOT INVESTED AT ALL OR IF LESS THAN // QUARTER'S ALLOCATION, CREATE AND TEST // POTENTIAL OPTIONS COLLARS AND IF // GOOD, ESTABLISH A POSITION ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// heldValue = Portfolio[thisSymbol].HoldingsValue; // get the if (heldValue < stockDollarValue) { sharesToBuy = Math.Round((stockDollarValue-heldValue)/stockPrice/100, 0) * 100; if ( sharesToBuy >= 1000M && symbolDataBySymbol[thisSymbol].isRollable == true) { buyMoreShares = true; } else buyMoreShares = false; } if (haltProcessing) { Debug(" --- "); } hasPrimaryRec = tradeRecs.Any(t => t!=null && t.isOpen && !t.isSecondary && t.uSymbol.Equals(thisSymbol)); hasSecondaryRec = false; secndRecCount = 0; // reset the 2ndTPR processing loop counter //hasSecondaryRec = tradeRecs.Any(t => t!=null && t.isOpen && t.isSecondary && t.uSymbol.Equals(thisSymbol)); hasThetaRec = tradeRecs.Any(t => t!=null && t.isOpen && t.isTheta && t.uSymbol.Equals(thisSymbol)); try { if (!hasPrimaryRec && buyMoreShares & hasDividends & symbolData.isRollable) { // get the underlying stock price in this Slice if (LUD.exDivdnDate.Month == data.Time.Month) { ///////////////////////////// ONLY TEST EVERY 15 QUARTER HOUR AND EACH SUBSEQUENT MINUTE //if (data.Time.Minute != 0 & data.Time.Minute != 1 & data.Time.Minute != 15 & data.Time.Minute != 16 & data.Time.Minute != 30 & data.Time.Minute != 31 & data.Time.Minute != 45) return; if (doTracing) Debug($" ----- PROCESSING COLLAR INITIAZATION: {thisSymbol}"); if (doTracing) Debug(" ----- "); bestSSQRColumn = GetBestCollar(this, ref LUD); if (bestSSQRColumn == null || bestSSQRColumn.IsEmpty()) // just in case somehow we got here with a null bestSSQRColumn { if (doTracing) Debug($" ************** null OR EMPTY bestSSQR in Trade Initializing {thisSymbol} *************"); return; } else { if (!bestSSQRColumn.IsEmpty()) { Debug($" ******************* EXECUTING BESTSSQRCOLUMN -- {thisSymbol} --- "); ExecuteTrade(data, bestSSQRColumn); if (didTheTrade) { //oldRollDate = data.Time.Date; var orderedSSQRMatrix = LUD.SSQRMatrix.OrderByDescending(p => p.CCOR); IterateOrderedSSQRMatrix(orderedSSQRMatrix); //didTheTrade = false; } else { Debug($" ******************* DIDN'T TRADE - {thisSymbol} --- "); } } return; } } // if data.Time.Month == nextExDividendDate.Month } // if !hasPrimaryRec && buyMoreShares & hasDividends } catch (Exception errMsg) { Debug(" ERROR " + errMsg ); if (errMsg.Data.Count > 0) { Debug(" Extra details:"); foreach (DictionaryEntry de in errMsg.Data) Debug(" Key: {0,-20} Value: {1}'" + de.Key.ToString() + "'" + de.Value); } return; } } // end ForEach(var pair in symbolDataBySymbol) int k = 0; if (tradeRecs.Any(tpr=> tpr!=null && tpr.isOpen && !tpr.isSecondary && !tpr.isTheta && data.Time.Subtract(tpr.startDate).Days >=10)) { foreach(var tprec in tradeRecs.Where(tpr=> tpr.isOpen && !tpr.isSecondary && !tpr.isTheta && data.Time.Subtract(tpr.startDate).Days >= 10)) { if (tprec.CheckRolling(this, ref LUD)) break; /// 2021-10-18 -- modified TradeDetermination.cs so never sets .isClose=true. & never add and new TPR there k = k + 1; } } if (tprsToClose.Any(tpr=> tpr!=null)) { /// 2021-10-18 -- close TPRs here //tprsToClose.ForEach(tpr=>tpr.isOpen = false); tprsToClose.ForEach(tpr=>tpr.CloseTPR()); } tprsToClose.Clear(); if(tprsToOpen.Any(tpr=>tpr!=null)) { /// 2021-10-18 -- open TPRs here foreach(var tprec in tprsToOpen) { tprec.OpenTPR(); tradeRecs.Add(tprec); } } tprsToOpen.Clear(); } // OnData() public IEnumerable<Symbol> CoarseSelectionFilter(IEnumerable<CoarseFundamental> coarse) { if(Time.Month == lastMonth) { return Universe.Unchanged; } lastMonth = Time.Month; //2. Save coarse as _coarse and return an Unchanged Universe var _coarse = coarse; /* List<Symbol> finalCoarse = new List<Symbol>(); foreach(var symbol in symbolDataBySymbol.Keys) { foreach(var optionSymbol in symbolDataBySymbol[symbol].currentOptions) { if(Portfolio[optionSymbol].Invested) { finalCoarse.Add(symbol); Debug("Adding Invested Option " + symbol.ToString() + " to Coarse Filter at " + Time.ToString() ); break; } } } var filteredByPrice = coarse.Where(x => x.HasFundamentalData & x.Market == Market.USA & x.Price > 5).Select(x => x.Symbol); foreach(var finalSymbol in filteredByPrice) { if(!finalCoarse.Contains(finalSymbol)) { finalCoarse.Add(finalSymbol); } } */ var filteredByPrice = coarse.Where(x => x.HasFundamentalData & x.Market == Market.USA & x.Price > 5).Select(x => x.Symbol); return filteredByPrice; } public IEnumerable<Symbol> FineSelectionFunction(IEnumerable<FineFundamental> fine) { var _fine = fine; int cntr = 0; // SELECT 2% Dividend Yield & $5B Market Cap var CDC_Criteria = fine.Where(x => x.ValuationRatios.TrailingDividendYield >= 0.02m & x.MarketCap > 5e9).Select(x => x.Symbol); if (strFilterTkr != "") /// If a stockTicker is not empty, then run the backtest for that tick only { CDC_Criteria = CDC_Criteria.Where(s=>s == QuantConnect.Symbol.Create(strFilterTkr, SecurityType.Equity, Market.USA )); } else { /// otherwise take the top 10 securities CDC_Criteria = CDC_Criteria.Take(10); } Debug( " ------------------ UNIVERSE FINE SELECTION -------------------------"); foreach(var fineSymb in CDC_Criteria) { cntr = cntr + 1; Debug(" " + cntr.ToString() + ": " + fineSymb); } return CDC_Criteria; } /// Rahul said this is beta and possibly inactive public void OnAssignmentOrderEvent(OrderEvent assignmentEvent) { //if (doTracing) Debug("ASSIGNMENT ==== " + assignmentEvent.Symbol.Value); Debug("AAAAAAAAAAAAAAA ASSIGNMENT ==== " + assignmentEvent.Symbol.Value); } // ********************** OnOrderEvent *********************************************** // *** Generalized function to iterate through and print members of an IEnumerable of Contracts // *** This is used for debugging only tricky part is passing an IOrderedEnumerable into this // **************************************************************************************************** public override void OnOrderEvent(OrderEvent orderEvent) { var order = Transactions.GetOrderById(orderEvent.OrderId); var oeSymb = orderEvent.Symbol; if (haltProcessing) { Debug(" Logging ONORDER()"); } Debug(" OO +++ " + order.Type + " order for " + oeSymb + ", Order Status: " + orderEvent.Status); try { if (orderEvent.Status == OrderStatus.Filled) { //var order = Transactions.GetOrderById(orderEvent.OrderId); //var oeSymb = orderEvent.Symbol; if (order.Type == OrderType.OptionExercise) { Debug(" OO OPTION EXERCISE ORDER EVENT AT:" + orderEvent.UtcTime + " OOOO"); if (orderEvent.IsAssignment) { // .IsAssignment seems only to occur when LEAN creates the ASSIGNMENT. -- use this to troubleshoot // Check for this now because DIVIDEND APPROACHMENT may Debug(" OO " + orderEvent.UtcTime + " LEAN LEAN LEAN ASSIGNMENT ORDER EVENT LEAN LEAN LEAN OOOOOO"); Debug(" OO ASSIGNMENT SYMBOL: " + oeSymb ); if (oeSymb.HasUnderlying && oeSymb.ID.OptionRight == OptionRight.Call) { sellThePut = true; } } Debug(" OO Quantity: " + orderEvent.FillQuantity + ", price: " + orderEvent.FillPrice); if (oeSymb.HasUnderlying) { didTheTrade = true; var thisOption = (Option)Securities[oeSymb]; var stkSymbol = thisOption.Underlying; Debug(" OO OPTIONS ORDER FOR : " + oeSymb + " IS A " + (oeSymb.ID.OptionRight == OptionRight.Put ? "PUT. " : "CALL.") + "for underlying: " + stkSymbol); // Get the open tradePerfRecord (if any still exists) ??? what is the order of exercise events ??? // tradePerfRec Call termination handled in code prior to PUT EXERCISE // Execute TradePerfRec Underlying termination in OnOrder() upon Stock Assignment if(oeSymb.ID.OptionRight == OptionRight.Put) { Debug(" oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo "); Debug(" oo PUT OPTION EXERCISE ORDER FOR : " + oeSymb); Debug(" oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo "); if (tradeRecs.Any(t => t!=null && t.pSymbol.Equals(oeSymb) & t.pQty == -order.Quantity)) { var pTPR = tradeRecs.Where(t => t!=null && t.pSymbol.Equals(oeSymb) & t.pQty == -order.Quantity).FirstOrDefault(); pTPR.pEndPrice = orderEvent.FillPrice; Debug(" OO UPDATED PUT END PRICE TO : " + orderEvent.FillPrice); if (pTPR.cSymbol != null) { var shrtCall = (Option)Securities[pTPR.cSymbol]; TimeSpan daysToCallExpiry = shrtCall.Expiry.Subtract(orderEvent.UtcTime); /*if (daysToCallExpiry.Days > 10 ) { Debug(" OO CALL " + shrtCall + " EXPIRES IN " + daysToCallExpiry.Days + ". CREATING THETA TPR."); // create a thetaTPR to move the call data and track it. Buy it back when theta decays. tradeRecs.Add(newThTPR); pTPR.cSymbol = null; // eliminate the call from the existint TPR pTPR.cStartPrice = 0; pTPR.cQty = 0; } else { */ Debug(" OO SELLING THE CALL IF IT EXISTS"); Debug("IN MAIN INVESTING"); var closeCTkt = MarketOrder(pTPR.cSymbol, -pTPR.cQty); if (closeCTkt.Status == OrderStatus.Filled) { pTPR.cEndPrice = closeCTkt.AverageFillPrice; } //} } Debug(" OO SELLING THE WING CALL IF IT EXISTS"); if (pTPR.wcSymbol != null) { //var wingCall = (Option)Securities[pTPR.wcSymbol]; var closeWingTkt = MarketOrder(pTPR.wcSymbol, -pTPR.wcQty); if (closeWingTkt.Status == OrderStatus.Filled) { pTPR.wcEndPrice = closeWingTkt.AverageFillPrice; } } } else { // 1st TPR in PUT EXERCISE Debug(" oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo "); Debug(" oo PUT OPTION ORDER FOR : " + oeSymb); Debug(" oo NOT SURE HOW THIS WAS ACCESSED - NO 1st TPR FOUND "); Debug(" oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo "); //string jsonString = ConvertTradePerfRec(tradeRecs); /* if (tradeRecs.Any(t => t!=null && t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity)) { var cTPR = tradeRecs.Where(t => t!=null && t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity).FirstOrDefault(); cTPR.cEndPrice = orderEvent.FillPrice; Debug(" OO UPDATED CALL END PRICE TO : " + orderEvent.FillPrice); Debug(" OO SELLING THE PUT IF IT EXISTS"); if (cTPR.cSymbol != null) { var closePTkt = MarketOrder(cTPR.pSymbol, -cTPR.pQty); if (closePTkt.Status == OrderStatus.Filled) { cTPR.pEndPrice = closePTkt.AverageFillPrice; } } } */ } } else if (oeSymb.ID.OptionRight == OptionRight.Call){ Debug(" oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo "); Debug(" oo CALL OPTION EXERCISE ORDER FOR : " + oeSymb); Debug(" oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo "); if (tradeRecs.Any(t => t!=null && t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity)) { Debug(" oo oo FOUND SHORT CALL 1ST TPR oo "); var cTPR = tradeRecs.Where(t => t!=null && t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity).FirstOrDefault(); cTPR.cEndPrice = orderEvent.FillPrice; Debug(" oo oo UPDATED 1ST TPR SHORT CALL END PRICE TO : " + orderEvent.FillPrice); if (cTPR.pSymbol != null) { var longPut = (Option)Securities[cTPR.pSymbol]; Debug(" oo SELLING THE PUT IF IT EXISTS"); var closePTkt = MarketOrder(cTPR.pSymbol, -cTPR.pQty); if (closePTkt.Status == OrderStatus.Filled) { cTPR.pEndPrice = closePTkt.AverageFillPrice; } } if (cTPR.wcSymbol != null) { var wCallSymbol = (Option)Securities[cTPR.wcSymbol]; Debug(" oo oo oo SELLING THE WING CALL IF IT EXISTS OR HASN'T BEEN BOUGHT"); if (cTPR.wcEndPrice != 0) { Debug(" oo oo oo oo SELLING THE WING CALL"); var closeWCTkt = MarketOrder(cTPR.wcSymbol, -cTPR.wcQty); if (closeWCTkt.Status == OrderStatus.Filled) { cTPR.wcEndPrice = closeWCTkt.AverageFillPrice; } } else Debug(" oo oo oo oo THE WING CALL WAS ALREADY SOLD"); } //// THE FOLLOWING WOULD EXECUTE IF ALGO EXERCISED THE WING CALL -- NOT CONTEMPLATED } else if (tradeRecs.Any(t => t!=null && t.wcSymbol.Equals(oeSymb) & t.wcQty == order.Quantity)) { var wcTPR = tradeRecs.Where(t => t!=null && t.wcSymbol.Equals(oeSymb) & t.wcQty == order.Quantity).FirstOrDefault(); Debug(" oo FOUND SHORT CALL 1ST TPR oo "); Debug(" oo UPDATED WING CALL END PRICE TO : " + orderEvent.FillPrice); wcTPR.wcEndPrice = orderEvent.FillPrice; } } } else { /// !.HasUnderlying -- this is stock being assigned Debug(" oo ASSIGNMENT OF UNDERLYING ORDER FOR : " + oeSymb); Debug(" oo STOCK EXERCISE ORDER EVENT FOR: " + order.Quantity + " shares." ); if (haltProcessing) { Debug(" oo oo oo oo => Logging OnOrder() "); } didTheTrade = true; if(tradeRecs.Any(t => t!=null && t.isOpen & t.uSymbol.Equals(oeSymb) & t.uQty == -order.Quantity * 100M)) { Debug(" oo UPDATING 2ND TRADE RECORD"); var uTPR = tradeRecs.Where(t => t!=null && t.isOpen & t.uSymbol.Equals(oeSymb) & t.uQty == -order.Quantity * 100M).FirstOrDefault(); if (symbFilter != null) Plot("Stock Chart", "Sells", orderEvent.FillPrice); tradeRecCount = 0; // reset tradeRec Counter ??? may be obviated //uTPR.isOpen = false; tprsToClose.Add(uTPR); uTPR.uEndPrice = orderEvent.FillPrice; uTPR.endDate = orderEvent.UtcTime; if (uTPR.reasonForClose !=null || uTPR.reasonForClose != "") { uTPR.reasonForClose = uTPR.reasonForClose + "OPTIONS ASSIGNMENT -- UNDERLYING CLOSED"; } else uTPR.reasonForClose = "OPTIONS ASSIGNMENT -- UNDERLYING CLOSED"; if (Portfolio[uTPR.pSymbol].Invested && uTPR.pSymbol != null) { var sellPutTicket = MarketOrder(uTPR.pSymbol, -uTPR.pQty); if (doTracing) Debug(" oo oo oo oo ooo Selling the PUT and setting the TPR.EndPrice"); if (sellPutTicket.Status == OrderStatus.Filled) { uTPR.pEndPrice = sellPutTicket.AverageFillPrice; } } if (Portfolio[uTPR.wcSymbol].Invested && uTPR.wcSymbol != null) { var sellWCallTicket = MarketOrder(uTPR.wcSymbol, -uTPR.wcQty); if (doTracing) Debug(" oo oo oo oo ooo Selling the Wing Call and setting the TPR.wcEndPrice"); if (sellWCallTicket.Status == OrderStatus.Filled) { uTPR.wcEndPrice = sellWCallTicket.AverageFillPrice; } } /// NOTE: OPTIONS WILL EXPIRE OR EXERCISE AT ENDPRICE = 0. THEREFORE THESE VALUES ARE NOT SET HERE /// BECAUSE THE END PRICES MAY BE SET OTHERWISE ELSEWHERE } else { Debug(" oo oo oo oo => FAILED TO LOCATE 2ND TPR"); } } Debug(" ---------------------------------------------------------------------------"); } // Order.Type = OrderType.OptionExercise else { Debug(" OO ** ** NON EXERCISE OPTION ORDER -- " + oeSymb); Debug(" OO ** " + order.Type + ": " + orderEvent.UtcTime + ": " + orderEvent.Direction + " ** OO "); Debug(" OO ** " + orderEvent.Status + ": " + orderEvent.Direction + " " + order.Quantity + " @ " + orderEvent.FillPrice ); if (oeSymb.HasUnderlying && order.Type == OrderType.Limit ) { /// Option if (oeSymb.ID.OptionRight == OptionRight.Put) { Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); Debug(" OO PUT OPTION LIMIT ORDER FOR : " + oeSymb); Debug(" OO PROCESSING TPR IN NEXT ON DATA oo oo oo oo "); // Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); /*if (tradeRecs.Any(t => t.pSymbol.Equals(oeSymb) & t.pQty == -order.Quantity)) { var transRec = tradeRecs.Where(t => t.pSymbol.Equals(oeSymb) & t.pQty == -order.Quantity).FirstOrDefault(); transRec.pEndPrice = orderEvent.FillPrice; Debug(" OO ** Setting pEndPrice."); } */ //Debug(" OO NOTE PUT EXPIRATION execute a market order to sell underlying"); } else if (oeSymb.ID.OptionRight == OptionRight.Call) { Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); Debug(" OO CALL OPTION LIMIT ORDER FOR : " + oeSymb); Debug(" OO PROCESSING TPR IN NEXT ON DATA oo oo oo oo "); // Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); /*if (tradeRecs.Any(t => t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity)) { var transRec = tradeRecs.Where(t => t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity).FirstOrDefault(); transRec.cEndPrice = orderEvent.FillPrice; Debug(" OO ** Setting cEndPrice."); }*/ //Debug(" OO NOTE CALL EXPIRATION execute a market order to sell underlying"); } } else if (oeSymb.HasUnderlying && order.Type == OrderType.Market) { if (oeSymb.ID.OptionRight == OptionRight.Put) { Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); Debug(" OO PUT OPTION MARKET ORDER FOR : " + oeSymb); Debug(" OO PROCESSING TPR SYNCHRONOUSLY IN LINE oo oo oo "); // Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); /*if (tradeRecs.Any(t => t.pSymbol.Equals(oeSymb) & t.pQty == -order.Quantity)) { var transRec = tradeRecs.Where(t => t.pSymbol.Equals(oeSymb) & t.pQty == -order.Quantity).FirstOrDefault(); transRec.pEndPrice = orderEvent.FillPrice; Debug(" OO ** Setting pEndPrice."); } */ //Debug(" OO NOTE ALGO-DRIVEN PUT market order"); } else if (oeSymb.ID.OptionRight == OptionRight.Call) { Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); Debug(" OO CALL OPTION MARKET ORDER FOR : " + oeSymb); Debug(" OO PROCESSING TPR SYNCHRONOUSLY IN LINE oo oo oo "); // Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); /*if (tradeRecs.Any(t => t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity)) { var transRec = tradeRecs.Where(t => t.cSymbol.Equals(oeSymb) & t.cQty == -order.Quantity).FirstOrDefault(); transRec.cEndPrice = orderEvent.FillPrice; Debug(" OO ** Setting cEndPrice."); }*/ //Debug(" OO NOTE ALGO-DRIVEN CALL MARKET ORDER"); } } else if (!oeSymb.HasUnderlying) { Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); Debug(" OO UNDERLYING ORDER FOR : " + oeSymb); // Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); } else { // NON EXERCISE ORDER HAS UNDERLYING Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); Debug(" OO UNKNOWN ALGO ORDER ORDER FOR : " + oeSymb); // Debug(" OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO "); /*if (tradeRecs.Any(tpr => tpr.uSymbol.Equals(oeSymb) & tpr.uQty == -order.Quantity)) { var transRec = tradeRecs.Where(tpr => tpr.uSymbol.Equals(oeSymb) & tpr.uQty == -order.Quantity).FirstOrDefault(); Debug (" OO ** THERE IS A TPR THAT IS " + (transRec.isOpen ? " OPEN" : " CLOSED")); transRec.isOpen = false; transRec.uEndPrice = orderEvent.FillPrice; transRec.endDate = orderEvent.UtcTime; transRec.reasonForClose = "Options Expiration"; Plot("Stock Chart", "Sells", orderEvent.FillPrice); }*/ } Debug(" ---------------------------------------------------------------------------"); } } // orderStatus = Filled } catch (Exception errMsg) { Debug(" ERROR " + errMsg ); if (errMsg.Data.Count > 0) { Debug(" Extra details:"); foreach (DictionaryEntry de in errMsg.Data) Debug(" Key: {0,-20} Value: {1}'" + de.Key.ToString() + "'" + de.Value); } return; } } //private void CheckExpiration() { // foreach(var callOption in callOptions) { // if(callOption.Symbol.ID.Date == Time.Date) { // Debug($"{callOption.Symbol}"); // } //} // } public override void OnEndOfDay(Symbol symbol) { if (symbol.SecurityType != SecurityType.Equity) return; int i = 0; if (symbFilter != null) { //lastSto = sto.Current.Value; // store values from night before //lastAd = ad.Current.Value; // lastAdOsc = adOsc.Current.Value; } return; } public override void OnEndOfAlgorithm() { string saveString = ""; bool hasStock = false; bool hasPuts = false; bool hasCalls = false; var tprEnum = tradeRecs.GetEnumerator(); while (tprEnum.MoveNext()) { TradePerfRec tpr = tprEnum.Current; if (tpr.isOpen) { if (tpr.uEndPrice == 0 && tpr.cSymbol != null) { tpr.uEndPrice = Securities[tpr.uSymbol].Price; } if (tpr.pEndPrice == 0 && tpr.pSymbol != null) { tpr.pEndPrice = Securities[tpr.pSymbol].Price; } if (tpr.cEndPrice == 0 && tpr.cSymbol != null) { tpr.cEndPrice = Securities[tpr.cSymbol].Price; } tpr.endDate = Time; } } string jsonString = ConvertTradePerfRec(tradeRecs); } public bool CheckOptionInvested(Symbol symbol, Dictionary<Symbol, SymbolData> symbolDataBySymbol) { if (symbol.SecurityType == SecurityType.Equity && symbolDataBySymbol.ContainsKey(symbol)) { ///if (Portfolio[symbol].Invested) { return true; } foreach(var optionSymbol in symbolDataBySymbol[symbol].currentOptions) { if(Portfolio[optionSymbol].Invested) { return true; } } } if (symbol.SecurityType == SecurityType.Option && Portfolio[symbol].Invested) { return true; } return false; } public void RemoveOptions(Symbol symbol) { if (symbolDataBySymbol.ContainsKey(symbol)) { foreach(var optionSymbol in symbolDataBySymbol[symbol].currentOptions) { RemoveSecurity(optionSymbol); Liquidate(optionSymbol); } symbolDataBySymbol.Remove(symbol); } } public override void OnSecuritiesChanged(SecurityChanges changes) { //foreach (var universe in UniverseManager.Values) { // // User defined universe has symbols from AddSecurity/AddEquity calls // if (universe is UserDefinedUniverse) continue; //} // Debug("Removing:"); foreach(var security in changes.RemovedSecurities) { var symbol = security.Symbol; // Debug(symbol); // if (CheckOptionInvested(symbol, symbolDataBySymbol)) { ///symbolDataBySymbol[symbol].currentPosition == true) { // if (symbol.SecurityType == SecurityType.Equity) { AddEquity(symbol, Resolution.Minute); symbolDataBySymbol[symbol].isRollable = false; } // else if (symbol.SecurityType == SecurityType.Option) { AddOptionContract(symbol, Resolution.Minute); symbolDataBySymbol[symbol.Underlying].isRollable = false; } // continue; // } //RemoveOptions(symbol); //Liquidate(symbol); //RemoveSecurity(symbol); } foreach(var security in changes.AddedSecurities) { Symbol thisSymbol = security.Symbol; if (thisSymbol.SecurityType == SecurityType.Equity) { if (symbolDataBySymbol.ContainsKey(thisSymbol)) { continue; } var sym = AddEquity(thisSymbol, Resolution.Minute); var opt = AddOption(thisSymbol, Resolution.Minute, Market.USA, true, 0m); //opt.SetFilter(universe => from symbol in universe.IncludeWeeklys() // .Expiration(TimeSpan.Zero, TimeSpan.FromDays(360)) // where Math.Abs(universe.Underlying.Price - symbol.ID.StrikePrice) < 60 select symbol); opt.SetFilter(-5, 1, TimeSpan.Zero, TimeSpan.FromDays(300)); opt.PriceModel = OptionPriceModels.CrankNicolsonFD(); /// necessary for Greeks symbolDataBySymbol.Add(thisSymbol, new SymbolData(thisSymbol, true, false, opt.Symbol)); //sto = STO(thisSymbol, 14, Resolution.Daily); // Stochastic if (symbFilter != null) { ad = AD(thisSymbol, Resolution.Daily); // Accumulation / Distribution adOsc = ADOSC(thisSymbol, 3, 14, Resolution.Daily); // Accumulation / Distribution Oscillator adx = ADX(thisSymbol, 7, Resolution.Daily); // Average Directional Index adxr = ADXR(thisSymbol, 7, Resolution.Daily); // Average Directional Index Rating obv = OBV(thisSymbol, Resolution.Daily); // On Balance Volume variance = VAR(thisSymbol, 14, Resolution.Daily); // Variance of this stock Securities[thisSymbol].SetDataNormalizationMode(DataNormalizationMode.Raw); Securities[thisSymbol].VolatilityModel = new StandardDeviationOfReturnsVolatilityModel(31); } } } //List<Symbol> keyList = new List<Symbol>(symbolDataBySymbol.Keys); //Debug("Universe Underlying Securities on " + DateTime.Now.ToShortDateString() + ": " + keyList.Count.ToString()); //Debug("-- UU -- UU -- Universe Underlying Securities on " + CurrentSlice.Time.ToShortDateString() + ": " + keyList.Count.ToString()); // foreach(var security in keyList) { // Debug(security.ToString()); // } } private void HistoricalSecurityInitializer(Security security) { var bar = GetLastKnownPrice(security); security.SetMarketPrice(bar); if(security.Type == SecurityType.Option){ var openInterest = History<OpenInterest>(security.Symbol, TimeSpan.FromDays(1)); var tradeBar = History<TradeBar>(security.Symbol, TimeSpan.FromDays(1)); } } private bool CheckBadDate(DateTime checkDate) { DateTime badDate1 = Convert.ToDateTime(GetParameter("BadDate")); DateTime badDate2 = badDate1.AddMinutes(1); //DateTime badDate1 = new DateTime(2020, 1, 6, 9, 45, 0); //DateTime badDate2 = new DateTime(2020, 11, 1, 13, 45, 0); if(checkDate.Equals(badDate1) | checkDate.Equals(badDate2)) { return badDtParameter; } else { return false; } } // ||||||||||||||||||||||||||||||||||||||||||||||| // Prints greeks for the corresponding symbol public void PrintGreeks(ref Dictionary<Symbol, bool> foundOption, Slice thisSlice, Symbol pairKey, bool pairValue) { decimal callDelta; if (pairValue == true) { return; } foreach(var chain in thisSlice.OptionChains) { foreach(var option in chain.Value) { if(pairKey.ToString() == option.ToString()) { callDelta = option.Greeks.Delta; foundOption[pairKey] = true; ///Debug(" || Succesfully added Greeks || " + pairKey + " Delta = " + callDelta.ToString()); //break; } } } } // ||||||||||||||||||||||||||||||||||||||||||||||| // Loops through dictionary of active contracts public void CheckGreeks(ref Dictionary<Symbol, bool> foundOption, Slice thisSlice) { OptionContract callContract; OptionChain callChain; Symbol optSymbol; Dictionary<Symbol, bool> tempDict = foundOption; foreach(var pair in tempDict) { Symbol pairKey = pair.Key; bool pairValue = pair.Value; PrintGreeks(ref foundOption, thisSlice, pairKey, pairValue); } } } // class public class SymbolData { private Symbol symbol; public bool isRollable; public bool currentPosition; public Symbol optSymbol; public List<Symbol> currentOptions = new List<Symbol>(); public SymbolData(Symbol passedSymbol, bool rollable, bool position, Symbol symbOpt) { symbol = passedSymbol; isRollable = rollable; currentPosition = position; optSymbol = symbOpt; } } } // namespace
using QuantConnect.Securities.Option; namespace QuantConnect.Algorithm.CSharp { public partial class CollarAlgorithm : QCAlgorithm { public class SSQRColumn { public decimal stockPrice = 0; public DateTime exDate = DateTime.Now; public DateTime putExpiry = DateTime.Now; public DateTime callExpiry = DateTime.Now; public int daysInPosition = 0; public decimal interestCost = 0; public Symbol uSymbol; public Symbol putSymbol; public Symbol callSymbol; public Symbol wCallSymbol; public decimal putPremium = 0; // paid for buying the body public decimal callPremium = 0; // received for selling back call public decimal wCallPremium = 0; // paid for buying the wings public decimal putStrike = 0; public decimal callStrike = 0; public decimal wCallStrike = 0; public decimal putOpenInterest = 0; public decimal callOpenInterest = 0; public decimal putDelta = 0; public decimal callDelta = 0; public decimal wcDelta = 0; public decimal wingFactor = 0; public decimal putGamma = 0; public decimal callGamma = 0; public decimal wcGamma = 0; public decimal putVega = 0; public decimal callVega = 0; public decimal putRho = 0; public decimal callRho = 0; public decimal putTheta = 0; public decimal callTheta = 0; public decimal putImpliedVol = 0; public decimal callImpliedVol = 0; public decimal divAmt = 0; public int divCount = 0; public decimal downsideRisk = 0; public decimal upsidePotential = 0; public decimal netIncome = 0; public decimal netOptions = 0; public decimal divDollars = 0; public decimal haircut = 0; // committed capital in a portfolio margin account public decimal ROC = 0; // Return on Capital public decimal ROR = 0; // Return on Risk public decimal CCOR = 0; // Call Coverage over downside Risk public string description1 = ""; public string description2 = ""; //public string description3; public override string ToString() { return this.description1; } public bool IsEmpty() { return this.description1.IsNullOrEmpty(); } } } }
///////////////////////////// 2020-12-01: Added CCOR member to SSQR Column and to description2 for SSQR Matrices spreadsheet using System.Linq; using QuantConnect.Securities.Option; namespace QuantConnect.Algorithm.CSharp { // // Make sure to change "BasicTemplateAlgorithm" to your algorithm class name, and that all // files use "public partial class" if you want to split up your algorithm namespace into multiple files. // public partial class CollarAlgorithm : QCAlgorithm { // ********************** assembleSSQRMatrix ************************************** // *** This sub routine takes in the options expiries and all the symbols // *** available in the Slice.Data and builds the puts chains and calls symbols lists // *** The puts and calls symbols lists are used to build the contracts lists // ** The contracts lists are used to build the SSQR Matrix // *********************************************************************************** // = assembleSSQRMatrix(algo, LD, expiries); /* foreach (var universe in UniverseManager.Values) { // User defined universe has symbols from AddSecurity/AddEquity calls if (universe is UserDefinedUniverse) { continue; } List<Symbol> UniverseMembers = new List<Symbol>(universe.Members.Keys); foreach (Symbol symb in UniverseMembers) { i = i + 1; Debug("," + i.ToString() + ", " + symb.Value); } } */ // *** NEED TO ENSURE THAT THE CALL IS NOT ITM <= EXPIRY - 10 DAYS --- PREVENT CALL ASSIGNMENT public void AssembleSSQRMatrix(QCAlgorithm algo, ref LookupData LD, Dictionary<int, DateTime> expiries) { int i = 1; if (LD.doTracing) algo.Debug($" -- AA AA ASSEMBLE SSQR MATRIX FOR {thisSymbol}"); if (LD.haltProcessing) { algo.Debug(" @@@@@ logging assembleSSQR processing"); foreach (var universe in UniverseManager.Values) { // User defined universe has symbols from AddSecurity/AddEquity calls if (universe is UserDefinedUniverse) { continue; } List<Symbol> UniverseMembers = new List<Symbol>(universe.Members.Keys); foreach (Symbol symb in UniverseMembers) { i = i + 1; Debug("," + i.ToString() + ", " + symb.Value); } } } Symbol symbU = LD.uSymbol; //List<OptionChain> allUnderlyingOptions = new List<OptionChain>(); // chain object to get all options //allUnderlyingOptions = thisSlice.OptionChains.Values.Where(u => u.Underlying.Symbol.Equals(symbU)).ToList(); OptionChain allUnderlyingOptions = null; // chain opbjec to get all contracts OptionChain putChain; // chain object to get put contracts OptionChain callChain; // chain object to get call contracts OptionChain wcChain; // chain object to get wc contracts OptionChain atmChain; // chain object to ATM call List<OptionContract> putContracts = new List<OptionContract>(); List<OptionContract> callContracts = new List<OptionContract>(); List<OptionContract> wCallContracts = new List<OptionContract>(); OptionContract putContract; // contract object to collect put greeks OptionContract callContract; // contract object to collect call greeks //OptionContract wcContract; // contract object to collect wing call greeks Greeks putGreeks; Greeks callGreeks; Greeks wcGreeks; Slice thisSlice = algo.CurrentSlice; DateTime tradeDate = thisSlice.Time; // current date, presumed date of trade // if(!thisSlice.OptionChains.TryGetValue(SD.optSymbol, out allUnderlyingOptions)) return; /// NOTE: DOES NOT RETURN wcChain foreach(var chain in thisSlice.OptionChains.Values){ if (chain.Underlying.Symbol != symbU) { continue; } allUnderlyingOptions = chain; break; } if (allUnderlyingOptions == null) { if (LD.doTracing) algo.Debug("-- No options returned for " + symbU.ToString() + " at " + thisSlice.Time); return; // return null SSQRMatrix and pass control back to OnData() } // Get the ATM call contract var atmCall = allUnderlyingOptions.Where(s => s.Right == OptionRight.Call) .OrderBy(s => Math.Abs(stockPrice - s.Strike))/// - stockPrice)) .FirstOrDefault(); var atmPut = allUnderlyingOptions.Where(s => s.Right == OptionRight.Put) .OrderBy(s => Math.Abs(stockPrice - s.Strike)) /// - stockPrice)) .FirstOrDefault(); var atmStrike = atmCall.Strike; if (atmStrike == 0 ) { return;} var lowStrike = (1 - (LD.maxPutOTM / (decimal)100)) * atmStrike; // ~~ eventually need a mechanism to determine strike steps var highStrike = (decimal)1.1 * atmStrike; // ~~ and use strike steps to set upper and lower bounds // decimal highWCStrike = 0; // for evaluating the range of wing call strikes // decimal lowWCStrike = 0; // for evaluating the range of wing call strikes // decimal wcInterval = 0; // for calculating wing calls // examine options expiries to get proper dividend-correlated time-frames // Alex informed me that the openInterest data has to be warmed up // Alex further informed me that .OpenInterest does not work, rather, use .Value //var callOpenInterest = History<OpenInterest>(atmCall, TimeSpan.FromDays(5)).FirstOrDefault(); //var putOpenInterest = History<OpenInterest>(atmPut, TimeSpan.FromDays(5)).FirstOrDefault(); //var totOpenInterest = callOpenInterest.Value + putOpenInterest.Value; //if (doTracing) Debug("0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O"); //if (doTracing) Debug("0O0O0O0O0O0O0O0O0O0O0O0O OPEN INTEREST 0O0O0O0O0O0O0O0O0O0O0O0O0O0O0"); //if (doTracing) Debug(" The total Put + Call Open Interest for " + atmCall.ID.Underlying + " is " + atmCallOpt.OpenInterest + "."); //if (doTracing) Debug("0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O0O"); int k = 1; // initialize iterator for AddOptionContracts below Symbol optSymbol; // initialize option symbol for building the list of contracts Option tempOption; // initialize option contract for building list of contracts and obtaining pricing data List<Option> callOptionsList = new List<Option>(); List<Option> putOptionsList = new List<Option>(); List<Option> wcCallsList = new List<Option>(); DateTime whichExpiry = new DateTime(); //daysInTrade = ((TimeSpan) (whichExpiry - tradeDate)).Days; // get the # of days from trade date to expiry for carry cost ///////// NOTE : CATCH THE EXCEPTION WHERE LOOKUP FAILS var justDate = tradeDate.Date; // separate out the DATEVALUE from the DateTime variable LD.thisFFRate = LD.fedFundsRates[justDate]; // fedFundsRates is a Dictionary where DateTime index are all 12:00:00am //interestCost = (thisFFRate + ibkrRateAdj)/workingDays * (decimal) daysInTrade * stockPrice; // create a range of expiration dates from the prior expiration to the whichExpiry date. //callSymbolsForThisExpiry = allUnderlyingOptionsSymbols.Where( o=> DateTime.Compare(o.ID.Date, pastExpiry) > 0 && DateTime.Compare(o.ID.Date, whichExpiry)<=0 && if (LD.haltProcessing) { algo.Debug("---------------------- Expiries ----------------------------"); algo.Debug("-----" + stockPrice.ToString() + ", " + lowStrike.ToString() + ", " + highStrike.ToString() + ", " + expiries[2].ToString("MM/dd/yy") + ", " + expiries[3].ToString("MM/dd/yy") + ", " + expiries[4].ToString("MM/dd/yy") + ", " + expiries[5].ToString("MM/dd/yy")); //IterateChain(allUnderlyingOptionsSymbols, "allUnderlyingOptionsSymbols"); } callContracts = allUnderlyingOptions.Where( o=> ( DateTime.Compare(o.Expiry, expiries[2])==0 | DateTime.Compare(o.Expiry, expiries[3])==0 | DateTime.Compare(o.Expiry, expiries[4])==0 | DateTime.Compare(o.Expiry, expiries[5])==0 ) && o.Right == OptionRight.Call && o.Strike >= lowStrike && o.Strike < highStrike) .OrderByDescending(o => o.Strike).ToList(); // **************** Check if any calls are returned. If not, increment expiries by 1 month and try again if (callContracts == null | callContracts.Count() == 0) { if (LD.doTracing) Debug("-- get callContracts failed 1st Pass "); /// use the expiries[1] date as the seed and find the subsequent 4 3-month expirations expiries[2] = FindNextOptionsExpiry(expiries[1], 4); expiries[3] = FindNextOptionsExpiry(expiries[1], 7); expiries[4] = FindNextOptionsExpiry(expiries[1], 10); expiries[5] = FindNextOptionsExpiry(expiries[1], 13); callContracts = allUnderlyingOptions.Where( o=> ( DateTime.Compare(o.Expiry, expiries[2])==0 | DateTime.Compare(o.Expiry, expiries[3])==0 | DateTime.Compare(o.Expiry, expiries[4])==0 | DateTime.Compare(o.Expiry, expiries[5])==0 ) && o.Right == OptionRight.Call && o.Strike >= lowStrike && o.Strike < highStrike) .OrderByDescending(o => o.Strike).ToList(); if (LD.haltProcessing) { if (LD.doTracing) algo.Debug("---------------------- Expiries 2nd Pass ----------------------------"); if (LD.doTracing) algo.Debug("--" + stockPrice.ToString() +", " + expiries[2].ToString("MM/dd/yy") + ", " + expiries[3].ToString("MM/dd/yy") + ", " + expiries[4].ToString("MM/dd/yy") + ", " + expiries[5].ToString("MM/dd/yy")); //if (doTracing);(callSymbolsForThisExpiry, "callSymbols"); } // ***************** If no calls are returned in 2nd pass, exit with null SSQRMatrix if (callContracts == null || callContracts.Count() == 0) { if (LD.doTracing) algo.Debug("-- get callContracts failed 2nd Pass "); return; } else if (LD.doTracing) algo.Debug("-- get callContracts succeeded 2nd Pass "); } else { if (LD.doTracing) algo.Debug(" -- getCallContracts succeded 1st pass "); // ***************** Log successful 1st pass options search } //callOptionsList.Clear(); // if the first attempt at obtaining calls fails, then expiries[2-5] are incremented by 1 month. If that fails // this subroutine was exited before here. In any case, if calls can be obtained, puts can be as well //putSymbolsForThisExpiry = allUnderlyingOptionsSymbols.Where( o=> DateTime.Compare(o.ID.Date, pastExpiry) > 0 && DateTime.Compare(o.ID.Date, whichExpiry)<=0 && putContracts = allUnderlyingOptions.Where( o=> ( DateTime.Compare(o.Expiry, expiries[2])==0 | DateTime.Compare(o.Expiry, expiries[3])==0 | DateTime.Compare(o.Expiry, expiries[4])==0 | DateTime.Compare(o.Expiry, expiries[5])==0 ) && o.Right == OptionRight.Put && o.Strike >= lowStrike && o.Strike < atmStrike) .OrderByDescending(o => o.Strike).ToList(); if (LD.haltProcessing) { if (LD.doTracing) algo.Debug("---------------------- Expiries PUTS Pass ----------------------------"); if (LD.doTracing) algo.Debug(" --" + stockPrice.ToString() +", " + expiries[2].ToString("MM/dd/yy") + ", " + expiries[3].ToString("MM/dd/yy") + ", " + expiries[4].ToString("MM/dd/yy") + ", " + expiries[5].ToString("MM/dd/yy")); //if (doTracing) IterateChain(putSymbolsForThisExpiry, "putSymbols"); } if (putContracts == null | putContracts.Count()== 0) { if (LD.doTracing) algo.Debug("-- get putSymbolsForThisExpiry failed 2nd Pass (after call succeeded)"); return; // return null SSQRMatrix and pass control back to OnData() } if (LD.doTracing) Debug("-- get putSymbolsForTheseExpiries succeeded."); var pEnumerator = putContracts.GetEnumerator(); // Now iterate through the puts and sub-iterate through the calls to assemble the SSQRMatrix // for pricing, puts are bought at the offer and calls are sold at the bid prices. // Each price should be the midpoint between the open and close. while (pEnumerator.MoveNext()) { var cEnumerator = callContracts.GetEnumerator(); putContract = pEnumerator.Current; atmCall = callContracts.Where(s => DateTime.Compare(s.Expiry, putContract.Expiry)==0) /// get atmCall for this Put Option Expiration .OrderBy(s => Math.Abs(s.Strike - stockPrice)) .FirstOrDefault(); wCallContracts.Clear(); wCallContracts = callContracts.Where( o=> ( DateTime.Compare(o.Expiry, putContract.Expiry)==0) & o.Strike >= atmStrike & o.Strike <= (decimal)1.1 * atmCall.Strike).Distinct().ToList(); if (LD.haltProcessing & LD.doTracing) Debug($" -- Put Option {pEnumerator.Current} "); wCallContracts.Sort((x,y) => x.Strike.CompareTo(y.Strike)); var wcEnumerator = wCallContracts.GetEnumerator(); while (cEnumerator.MoveNext()) { callContract = cEnumerator.Current; //if (thisCallStrike > thisPutStrike & DateTime.Compare(thisCallExpiry,thisPutExpiry)>=0 ) // only add put/call combinations where call strike is above put strike and call expiry is equal to or later than put if ((callContract.Strike > putContract.Strike & DateTime.Compare(callContract.Expiry, putContract.Expiry)>=0) | (callContract.Strike >= putContract.Strike & DateTime.Compare(callContract.Expiry,putContract.Expiry)>0 )) // only add put/call combinations where call strike is equal to or above put strike and call expiry is later than put OR (c.strike>=put.strike AND c.Expiry>=p.Expiry) { foreach (var wcContract in wCallContracts) { if (wcContract.Strike > callContract.Strike ) { SSQRColumn thisSSQRColumn = buildSSQRColumn(putContract, callContract, wcContract, algo, LD); if (thisSSQRColumn != null) LD.SSQRMatrix.Add(thisSSQRColumn); } } } // if thisCallStrike == thisPutStrike } // while callEnum } // while putEnum if (LD.doTracing) Debug($" -- AA AA RETURNED {LD.SSQRMatrix.Count()} SSQR MATRICES FOR {LD.uSymbol}" ); { } // !null return; } // AssembleSSQRMatrix // ********************** buildSSQRColumn ************************************** // *** This sub routine takes in the variables for the iterated put and call Options Lists // *** as well as the dividends count, dividend amount, and stock price // *** and returns an SSQRColumt to be added to the SSQRMatrix list // *********************************************************************************** public SSQRColumn buildSSQRColumn(OptionContract thisPutOpt, OptionContract thisCallOpt, OptionContract wcOpt, QCAlgorithm algo, LookupData LD) //public SSQRColumn buildSSQRColumn(Option thisPutOpt, Option thisCallOpt, OptionContract pGrks, OptionContract cGrks, DateTime whichExpiry, DateTime tradeDate, DateTime exDate, int dividends, decimal amtDividend, decimal stockPrice, int daysInTrade, decimal intCost) { decimal thisSpread = 1M; decimal wingFactor = .2M; // factor to determine wings contract load decimal wingPremium = 1; // added premium to do the wings int monthsInTrade = 0; int daysInTrade = 0; int dividends = 0; Slice thisSlice = algo.CurrentSlice; decimal stockPrice = thisSlice[LD.uSymbol].Price; SSQRColumn thisColumn = new SSQRColumn(); // get a new SSQRColumn if (thisPutOpt.AskPrice == 0 | thisCallOpt.BidPrice == 0) return thisColumn; // don't build SSQRColumns with missing premium values DateTime tradeDate = algo.CurrentSlice.Time; daysInTrade = (thisPutOpt.Expiry - tradeDate).Days; decimal intCost = (LD.thisFFRate + LD.ibkrRateAdj)/LD.workingDays * (decimal) daysInTrade * stockPrice; if (haltProcessing) { Debug(" Logging buildSSQRColumn processing") ; } monthsInTrade = thisPutOpt.Expiry.Month - LD.exDivdnDate.Month; if( thisPutOpt.Expiry.Year != LD.exDivdnDate.Year) { monthsInTrade = monthsInTrade + 12; } if (divFrequency.Equals("monthly", StringComparison.OrdinalIgnoreCase)) { dividends = monthsInTrade + 1; } else { dividends = monthsInTrade/3 + 1; // add 1 for the next dividend and 1 for every 3 months thereafter } thisColumn.uSymbol = LD.uSymbol; thisColumn.putSymbol = thisPutOpt.Symbol; thisColumn.callSymbol = thisCallOpt.Symbol; thisColumn.wCallSymbol = wcOpt.Symbol; // atm call for this column (based upon put) thisColumn.putPremium = thisPutOpt.AskPrice; thisColumn.callPremium = thisCallOpt.BidPrice; thisColumn.wCallPremium = wcOpt.AskPrice; // thisColumn.putStrike = thisPutOpt.Strike; thisColumn.callStrike = thisCallOpt.Strike; thisColumn.wCallStrike = wcOpt.Strike; thisColumn.exDate = LD.exDivdnDate; thisColumn.putExpiry = thisPutOpt.Expiry; thisColumn.callExpiry = thisCallOpt.Expiry; thisColumn.putDelta = thisPutOpt.Greeks.Delta; thisColumn.callDelta = thisCallOpt.Greeks.Delta; thisColumn.wcDelta = wcOpt.Greeks.Delta; thisColumn.putGamma = thisPutOpt.Greeks.Gamma; thisColumn.callGamma = thisCallOpt.Greeks.Gamma; thisColumn.wcGamma = wcOpt.Greeks.Gamma; //thisColumn.putVega = thisPutOpt.Greeks.Vega; //thisColumn.callVega = thisCallOpt.Greeks.Vega; //thisColumn.putRho = thisPutOpt.Greeks.Rho; //thisColumn.callRho = thisCallOpt.Greeks.Rho; //thisColumn.putTheta = thisPutOpt.Greeks.Theta; //thisColumn.callTheta = thisCallOpt.Greeks.Theta; thisColumn.putImpliedVol = thisPutOpt.ImpliedVolatility; thisColumn.callImpliedVol = thisCallOpt.ImpliedVolatility; thisColumn.divAmt = LD.divdndAmt; thisColumn.divCount = dividends; thisColumn.stockPrice = stockPrice; thisColumn.daysInPosition = daysInTrade; thisColumn.interestCost = intCost; thisSpread = thisCallOpt.Strike - thisPutOpt.Strike; if (!LD.ibkrHairCuts.ContainsKey( (thisSpread)) ) { //Debug("*^*^*^*^*^*^*^*^*^*^**^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*"); //Debug("Make a haircut entry for " + (thisCallStrike - thisPutStrike).ToString()); //Debug("*^*^*^*^*^*^*^*^*^*^**^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*"); if (thisSpread < 5M) { thisColumn.haircut = .5M; } else thisColumn.haircut = thisSpread; }else { thisColumn.haircut = LD.ibkrHairCuts[thisSpread]; } decimal divDollars = LD.divdndAmt * dividends; thisColumn.divDollars = divDollars; decimal stockLossIfCalled = (thisCallOpt.Strike>stockPrice) ? 0 : (thisColumn.putPremium>thisColumn.callPremium) ? (thisColumn.callStrike - stockPrice) : 0; // loss=0 if cStrike>stkPrice, otherwise negative ***Loss (negative value) if ITM calls are assigned (0 if #calls<#puts) decimal netOptions = -thisColumn.putPremium + thisColumn.callPremium; /// netOptions equals negative putPrem (expense) plus positive call premium (income) thisColumn.netOptions = netOptions; thisColumn.netIncome = divDollars + netOptions - intCost; // Net Income in SSQR.xls subtracts interest cost but does not allow for appreciation to OTM call strike /// obviated in Wing System which has an upside long call wingFactor = (netOptions + divDollars - intCost) / wingPremium; // wing factor defined as income(loss) from options plus dividend minus interest cost divided by the premium paid for the wings if (wingFactor < 0) wingFactor = 0; if (wingFactor > 0.2M ) wingFactor = 0.2M; thisColumn.wingFactor = wingFactor; thisColumn.ROC = (divDollars + netOptions + stockLossIfCalled - intCost) / thisColumn.haircut; // store ROC for statistical analysis // 2021-03-21 -- (factored in netOptions into downsideRisk calculation) //decimal downsideRisk = thisPutStrike - stockPrice + divDollars + netOptions - intCost; // downside risk is defined as the potential loss due to stock price depreciation _ decimal downsideRisk = ((stockPrice - thisColumn.netOptions) > thisColumn.putStrike) ? stockPrice - netOptions - thisColumn.putStrike + thisColumn.interestCost: thisColumn.interestCost; // downside risk is the net price of the collar - putStrike (deliberately discounts dividends as they are not guaranteed past the declared dividend) thisColumn.downsideRisk = downsideRisk; // subtracts dividends collected and net options premiums and intCost decimal upsidePotential = (thisColumn.callStrike>stockPrice) ? thisColumn.callStrike - stockPrice + divDollars + netOptions - intCost : divDollars + netOptions - intCost; // When writing OTM calls, there is a potential thisColumn.upsidePotential = upsidePotential; // upside appreciation from net collar cost to the call strike. // 2021-03-24 -- -- changed sign on downsideRisk from negative to positive. Earlier iterations represented downside risk as negative (putStrike - stock purchase price). thisColumn.ROR = upsidePotential/downsideRisk; // store ROR for statistical analysis /*if (stockPrice == thisPutStrike) { thisColumn.CCOR = (1 - thisPutPrem/thisCallPrem)/0.01M; // get the maximum upside potential for a unit of actual risk } else { thisColumn.CCOR = (1 - thisPutPrem/thisCallPrem)/(stockPrice - thisPutStrike); } */ // 2021-03-21 -- -- changed to ordered by downsideRisk/upsidePotential //thisColumn.CCOR = netOptions/downsideRisk; // get the maximum upside potential for a unit of actual risk thisColumn.CCOR = downsideRisk/upsidePotential; thisColumn.description1 = "Combination in " + LD.uSymbol + " @ " + stockPrice + " is the " + thisColumn.putStrike + "/" + thisColumn.callStrike + " collar "; thisColumn.description2 = "," + thisColumn.uSymbol + "," + String.Format("{0:0.00}", stockPrice) + "," + LD.exDivdnDate.ToString("MM/dd/yy") + "," + dividends + "," + String.Format("{0:0.00}", LD.divdndAmt) + "," + String.Format("{0:0.00}",divDollars) + "," + daysInTrade + ", " + String.Format("{0:0.00}", intCost) + ", " + thisColumn.putExpiry.ToString("MM/dd/yy") + ", " + thisColumn.callExpiry.ToString("MM/dd/yy") + ", " + String.Format("{0:0.00}",thisColumn.putStrike) + ", " + String.Format("{0:0.00}",thisColumn.putPremium) + ", " + String.Format("{0:0.00}",thisColumn.callStrike) + ", " + String.Format("{0:0.00}", thisColumn.callPremium) + ", " + String.Format("{0:0.00}", thisColumn.wCallStrike) + ", " + String.Format("{0:0.00}", thisColumn.wCallPremium) + ", " + String.Format("{0:0.00}",thisColumn.putDelta) + ", " + String.Format("{0:0.00}", thisColumn.callDelta) + ", " + String.Format("{0:0.00}",thisColumn.netOptions) + ", " + String.Format("{0:0.00}", thisColumn.netIncome) + ", " + String.Format("{0:0.00}", thisColumn.haircut) + ", " + String.Format("{0:0.00}",thisColumn.ROC) + "," + String.Format("{0:0.00}", thisColumn.upsidePotential) + "," + String.Format("{0:0.00}", thisColumn.downsideRisk) + "," + String.Format("{0:0.00}",thisColumn.ROR) + "," + String.Format("{0:0.00}", thisColumn.CCOR ) + "," + String.Format("{0:0.00}", thisColumn.wingFactor) + "," + thisColumn.putSymbol + "," + thisColumn.callSymbol; return thisColumn; } // ********************** AddCorrespondingPut ******************************************* // *** This code will add the put option which corresponds to the call shorted // *** for purposes of evaluating it in ex-dividend approachment. // *** Option must be constructed with correct parameters before it can be added // ****************************************************************************************** public Option AddCorrespondingPut(Symbol tradableCall, ref List<Symbol> currentOptions) { int indexOfC = tradableCall.ToString().LastIndexOf("C"); char[] charArrayC = tradableCall.ToString().ToCharArray(); char[] charArrayP = charArrayC; charArrayP[indexOfC] = 'P'; string putString = new string(charArrayP); var putSymbol = QuantConnect.Symbol.CreateOption( tradableCall.Underlying, Market.USA, OptionStyle.American, OptionRight.Put, tradableCall.ID.StrikePrice, tradableCall.ID.Date); Option correspondingPut = AddOptionContract(putSymbol); currentOptions.Add(correspondingPut.Symbol); return correspondingPut; } // ********************** GetCorrespondingPut ******************************************* // *** This code will get the put option which corresponds to the call shorted // *** for purposes of evaluating it in ex-dividend approachment -- // *** ??? return Symbol or string? // ****************************************************************************************** public string GetCorrespondingPut(Symbol tradableCall) { int indexOfC = tradableCall.ToString().LastIndexOf("C"); char[] charArrayC = tradableCall.ToString().ToCharArray(); char[] charArrayP = charArrayC; charArrayP[indexOfC] = 'P'; string putString = new string(charArrayP); return putString; } public SSQRColumn fillSSQRColumn () { SSQRColumn anotherSSQRColumn = new SSQRColumn(); return anotherSSQRColumn; } // ********************** GetOptionsExpiries ************************************** // *** Use this to find and return the next 4 options expirations expirations dates // *** Function will determine if a date is a holiday and subtract 1 day // *********************************************************************************** public Dictionary<int, DateTime> GetOptionExpiries(DateTime tradeD, DateTime nextExDate, DateTime thisMonthExpiry, bool isPrimary){ // Initialize expiration date variables // DateTime firstExpiry = new DateTime(); DateTime secondExpiry = new DateTime(); DateTime thirdExpiry = new DateTime(); DateTime fourthExpiry = new DateTime(); DateTime fifthExpiry = new DateTime(); // Initialize the dictionary for return // 1 : first expiry // 2 : second expiry... Dictionary<int, DateTime> expiries = new Dictionary<int, DateTime>(); // is the nextExDate before or after the 3rd Friday? Before ? use this month expiration // After ? use next month's expiration. if (isPrimary) // isPrimary ? 1stTPR : 2ndTPR 1stTPR do monthly options every quarter : 2ndTPR do monthly options every month { if (DateTime.Compare(nextExDate, thisMonthExpiry) <= 0) { firstExpiry = FindNextOptionsExpiry(thisMonthExpiry, 0); // first figure out the options expriry for exDivDate month if (firstExpiry.Subtract(tradeD).Days <= 10) { // if firstExpiry is less than 10 days after tradeDate, assignment risk is too high. Move expiries back a month firstExpiry = FindNextOptionsExpiry(thisMonthExpiry, 1); secondExpiry = FindNextOptionsExpiry(thisMonthExpiry, 4); thirdExpiry = FindNextOptionsExpiry(thisMonthExpiry, 7); fourthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 10); fifthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 13); } else { secondExpiry = FindNextOptionsExpiry(thisMonthExpiry, 3); thirdExpiry = FindNextOptionsExpiry(thisMonthExpiry, 6); fourthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 9); fifthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 12); } } else { firstExpiry = FindNextOptionsExpiry(thisMonthExpiry, 1); secondExpiry = FindNextOptionsExpiry(thisMonthExpiry, 4); thirdExpiry = FindNextOptionsExpiry(thisMonthExpiry, 7); fourthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 10); fifthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 13); } } else { // this is for 2ndTPRs -- monthly options every month to catch some if (DateTime.Compare(nextExDate, thisMonthExpiry) <= 0) { firstExpiry = FindNextOptionsExpiry(thisMonthExpiry, 0); secondExpiry = FindNextOptionsExpiry(thisMonthExpiry, 1); thirdExpiry = FindNextOptionsExpiry(thisMonthExpiry, 2); fourthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 3); fifthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 4); }else { firstExpiry = FindNextOptionsExpiry(thisMonthExpiry, 1); secondExpiry = FindNextOptionsExpiry(thisMonthExpiry, 2); thirdExpiry = FindNextOptionsExpiry(thisMonthExpiry, 3); fourthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 4); fifthExpiry = FindNextOptionsExpiry(thisMonthExpiry, 5); } } expiries.Add(1, firstExpiry); expiries.Add(2, secondExpiry); expiries.Add(3, thirdExpiry); expiries.Add(4, fourthExpiry); expiries.Add(5, fifthExpiry); return expiries; } // ********************** FindNextOptionsExpiry ************************************** // *** Use this to find and return the next options expirations date x months ahead // *** Check the new date to make sure it isn't a holiday and if it is, subtract 1 day // ******************************************************************************************** public DateTime FindNextOptionsExpiry(DateTime thisExpiry, int addedMonths){ // Given a 3rd friday expiration, it will find the next 3rd friday expiration, addedMonths ahead // figure out how to handle holidays such as Good Friday, April 19, 2019. // **************** should this be amended for non-quarterly dividend frequencies? **************** int year = thisExpiry.Year; int month = thisExpiry.Month; while (addedMonths >= 12) { year = year + 1; addedMonths = addedMonths - 12; } month = month + addedMonths; // Adjust if bigger than 12 if(month > 12){ month = month % 12; year = year + 1; } if (haltProcessing) { Debug(" Logging FindNextOptionsExpiry() " + year.ToString() + "-" + month.ToString() ); } DateTime findDate = FindDay(year, month, DayOfWeek.Friday, 3); // Evaluate if found expirations fall upon holidays and if they do, decrement them 1 day while (USHoliday.Dates.Contains(findDate)) findDate = findDate.AddDays(-1); return findDate; } // ********************** FindDay ******************************************************* // *** Generalized function to find and return a DateTime for a given year, month, DayOfWeek // *** and occurrence in the month. // *** // ******************************************************************************************** public DateTime FindDay(int year, int month, DayOfWeek Day, int occurrence) { if (haltProcessing) { Debug(" Logging FindDay() " + year.ToString() + "-" + month.ToString() + "-" + Day.ToString() + ", at " + occurrence.ToString() + " day"); } // Given a valid month, it will find the datetime for the 3rd friday of the month if (occurrence <= 0 || occurrence > 5) throw new Exception("occurrence is invalid"); DateTime firstDayOfMonth = new DateTime(year, month, 1); //Substract first day of the month with the required day of the week var daysneeded = (int)Day - (int)firstDayOfMonth.DayOfWeek; //if it is less than zero we need to get the next week day (add 7 days) if (daysneeded < 0) daysneeded = daysneeded + 7; //DayOfWeek is zero index based; multiply by the occurrence to get the day var resultedDay = (daysneeded + 1) + (7 * (occurrence - 1)); if (resultedDay > (firstDayOfMonth.AddMonths(1) - firstDayOfMonth).Days) throw new Exception(String.Format("No {0} occurrence(s) of {1} in the required month", occurrence, Day.ToString())); if (month == 2) { if (year == 2016 | year == 2020) { if (resultedDay > 29) { resultedDay = resultedDay - 29; month = 3; } } else { if (resultedDay > 28) { resultedDay = resultedDay - 28; month = 3; } } } try { return new DateTime(year, month, resultedDay); } catch { throw new Exception($"Invalid date: {year}/{month}/{resultedDay}"); } } // ********************** IterateChain ******************************************************* // *** Generalized function to iterate through and print members of an IEnumerable // *** This is used for debugging only // ******************************************************************************************** public void IterateChain(IEnumerable<Symbol> thisChain, string chainName) { int k = 1; Symbol optSymbol; var enumerator = thisChain.GetEnumerator(); Debug(" |||||||||||||||||||||||||||||||| NEW OPTION SYMBOL CHAIN |||||||||||||||||||||||||||||||"); Debug("There are " + thisChain.Count() + " options symbols in this " + chainName + ". "); while (enumerator.MoveNext()) { optSymbol = enumerator.Current; //Debug("Iterated " + k + " times"); //Debug(optSymbol.Value); Debug(optSymbol.Value + " " + optSymbol.ID.StrikePrice + " " + optSymbol.ID.Date + " " + optSymbol.ID.OptionRight); k++; } //Debug(" ---------------------------------------------------------------------------------------------"); } // ********************** IterateContracts ******************************************************* // *** Generalized function to iterate through and print members of an IEnumerable of Contracts // *** This is used for debugging only // ******************************************************************************************** public void IterateContracts(List<Option> thisOptionsList) { int k = 1; Option thisOption; var enumerator = thisOptionsList.GetEnumerator(); Debug(" |||||||||||||||||||||||||||||||| NEW OPTION CONTRACTS LIST |||||||||||||||||||||||||||||||"); Debug("There are " + thisOptionsList.Count() + " contracts in this options list."); while (enumerator.MoveNext()) { thisOption = enumerator.Current; //Debug("Iterated " + k + " times"); //Debug("Option Chain: " + thisOption.ToString()); //Debug(thisOption.StrikePrice + " " + thisOption.Expiry + " " + thisOption.Right + " " + thisOption.GetLastData()); Debug(thisOption.StrikePrice + " " + thisOption.Expiry + " " + thisOption.Right + " BID: " + thisOption.BidPrice + " ASK: " + thisOption.AskPrice); k++; } //Debug(" ---------------------------------------------------------------------------------------------"); } // ********************** Iterate Matrix ******************************************************* // *** Generalized function to iterate through and print members of an IEnumerable of Contracts // *** This is used for debugging only // ******************************************************************************************** public void IterateSSQRMatrix(List<SSQRColumn> thisMatrix) { int k = 1; SSQRColumn thisColumn; var matrixEnum = thisMatrix.GetEnumerator(); Debug(" |||||||||||||||||||||||||||||||| NEW OPTION SSQRMatrix |||||||||||||||||||||||||||||||"); Debug("There are " + thisMatrix.Count() + " columns in this SSQRMatrix."); // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 Debug(",Ticker,Stock Price,Ex-Date,# Dividends,Dividend,Dollars,Days In,Interest,PExpiry, CExpiry, PutStrike,PutASK,CallStrike,CallBid, atmStrike, atmCallAsk, PutDelta, CallDelta, NetOptions,Net Income,Haircut,ROC,Upside,Downside,ROR,CCOR, wingFactor, PutSymb, CallSymb"); while (matrixEnum.MoveNext()) { thisColumn = matrixEnum.Current; //Debug("Iterated " + k + " times"); Debug(thisColumn.description2); k++; } Debug(" ---------------------------------------------------------------------------------------------"); } // ********************** Iterate Ordered Matrix *********************************************** // *** Generalized function to iterate through and print members of an IEnumerable of Contracts // *** This is used for debugging only tricky part is passing an IOrderedEnumerable into this // **************************************************************************************************** public void IterateOrderedSSQRMatrix(IOrderedEnumerable<SSQRColumn> thisOrdMatrix) { int k = 1; Debug(" |||||||||||||||||||||||||||||||| NEW TRADABLE SSQRMatrix |||||||||||||||||||||||||||||||"); Debug("There are " + thisOrdMatrix.Count() + " columns in this SSQRMatrix."); // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 Debug(",Ticker,Stock Price,Ex-Date,# Dividends,Dividend,Dollars,Days In,Interest,PExpiry, CExpiry, PutStrike,PutASK,CallStrike,CallBid, atmStrike, atmCallAsk, PutDelta, CallDelta, NetOptions,Net Income,Haircut,ROC,Upside,Downside,ROR,CCOR, wingFactor, PutSymb, CallSymb"); foreach (SSQRColumn thisColumn in thisOrdMatrix) { //Debug("Iterated " + k + " times"); Debug(thisColumn.description2); //Debug(" "); k++; if (k == 21) break; } } // ********************** Iterate Ordered PutSpread ********************************************** // *** Generalized function to iterate through and print members of an IEnumerable of PutSpreads // *** This is used for debugging only tricky part is passing an IOrderedEnumerable into this // **************************************************************************************************** public void IterateOrderedPutSpreadList(IOrderedEnumerable<PutSpread> thisOrdSpreads) { string logLine = ""; // for writing the logs int k = 1; Debug(" |||||||||||||||||||||||||||||||| NEW TRADABLE PutSpreads List |||||||||||||||||||||||||||||||"); Debug(",¶¶,There are " + thisOrdSpreads.Count() + " PutSpreads in this List."); // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 //Debug("¶¶,Stock Price, Ex-Date, Trade Date, pExpiry, oldPutSymb, newPutSymb, oldBid, newAsk, oldStrike, newStrike, Open Interst, Div Amt, # Dividends, Div Dollars, stock Incr,Interest,DownSide, Upside, Net Income, NetOptions, Haircut, Descr logLine = ",¶¶"; foreach (PutSpread thisSpread in thisOrdSpreads) { if (k==1){ // iterate field names foreach (var fieldN in typeof(PutSpread).GetFields()) { logLine = logLine + "," + fieldN.Name; } Debug(logLine); logLine = ",¶¶"; //k = k + 1; } foreach (var fieldV in typeof(PutSpread).GetFields()) { if (fieldV.GetType() == typeof(decimal)) { logLine = logLine + "," + String.Format("{0:0.00}", fieldV.GetValue(thisSpread)); } else if (fieldV.GetType() == typeof(DateTime)) { logLine = logLine + "," + String.Format("{0:MM/dd/yy H:mm:ss}", fieldV.GetValue(thisSpread)); } else logLine = logLine + "," + fieldV.GetValue(thisSpread); } Debug(logLine); logLine = ",¶¶"; //Debug("Iterated " + k + " times"); //Debug(thisSpread.description1); //Debug(" "); k++; //if (k == 11) break; } } } }
using QuantConnect.Securities.Option; using System; using System.Collections.Generic; using System.Linq.Expressions; namespace QuantConnect.Algorithm.CSharp { public partial class CollarAlgorithm : QCAlgorithm { private bool goodThresh2 = false; //////////////////////////////////////////////////////////////////////////////////// // // ExecuteTrade // //////////////////////////////////////////////////////////////////////////////////// public void ExecuteTrade(Slice data, SSQRColumn bestSSQRColumn) { thisCCOR = bestSSQRColumn.CCOR; decimal maxWingFactor = 0; decimal thisWingFactor = 0; decimal wingPremium = 0; decimal thisNetOptions = bestSSQRColumn.netOptions; if (haltProcessing) { Debug(" Logging ExecuteTheTrade() "); } //goodThresh = (thisCCOR >= CCORThresh); goodThresh = true; if (goodThresh) { //sharesToBuy = Math.Round(stockDollarValue/stockPrice/100, 0) * 100; // set in top of OnData() optionsToTrade = sharesToBuy/100; //callsToTrade = Decimal.Round(optionsToTrade * bestSSQRColumn.putPremium / bestSSQRColumn.callPremium); /// legacy VCCPTS code //Debug(tradableColumn.ToString()); Symbol tradablePut = bestSSQRColumn.putSymbol; Symbol tradableCall = bestSSQRColumn.callSymbol; Symbol tradableWCall = bestSSQRColumn.wCallSymbol; if (Securities[tradableCall].AskPrice + bestSSQRColumn.callStrike < stockPrice) // make sure that no one can buy the option for less than the stock { Debug($" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ EXERCISE PREVENTION FADE FOR {bestSSQRColumn.uSymbol} @@@@@@@@@@@@"); Debug(" @@@@@@@@@@@@@@@@@@@ CALL ASK: " + Securities[tradableCall].AskPrice + " Strike: " + bestSSQRColumn.callStrike + " Stock Price: " + stockPrice +" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); Debug(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); return; } tradeRecCount = tradeRecCount + 1; // increment trade record count collarIndex = collarIndex + 1; doTheTrade = true; var stockTicket = MarketOrder(bestSSQRColumn.uSymbol, sharesToBuy); if (stockTicket.Status == OrderStatus.Filled) { didTheTrade = true; if (symbFilter != null) Plot("Stock Chart", "Buys", stockTicket.AverageFillPrice + 5); // make a new TradePerfRec TradePerfRec thisNewCollar = new TradePerfRec(); thisNewCollar.strtngCndtn = "INITIAL COLLAR"; thisNewCollar.isOpen = true; thisNewCollar.isInitializer = true; thisNewCollar.tradeRecCount = tradeRecCount; thisNewCollar.index = collarIndex; thisNewCollar.startDate = data.Time; thisNewCollar.expDate = bestSSQRColumn.putExpiry; thisNewCollar.thetaExpiration = bestSSQRColumn.callExpiry; thisNewCollar.uSymbol = bestSSQRColumn.uSymbol; thisNewCollar.cSymbol = tradableCall; thisNewCollar.pSymbol = tradablePut; thisNewCollar.wcSymbol = tradableWCall; thisNewCollar.uStartPrice = stockTicket.AverageFillPrice; thisNewCollar.pStrike = bestSSQRColumn.putStrike; thisNewCollar.cStrike = bestSSQRColumn.callStrike; thisNewCollar.wcStrike = bestSSQRColumn.wCallStrike; thisNewCollar.uQty = (int)stockTicket.QuantityFilled; thisNewCollar.ROR = thisROR; thisNewCollar.ROC = thisROC; thisNewCollar.CCOR = thisCCOR; thisNewCollar.RORThresh = RORThresh; thisNewCollar.ROCThresh = ROCThresh; thisNewCollar.CCORThresh = CCORThresh; //thisNewCollar.tradeCriteria = switchROC ? "ROC" : "ROR"; thisNewCollar.tradeCriteria = "Wing"; thisNewCollar.stockADX = lastAdx; thisNewCollar.stockADXR = lastAdxr; thisNewCollar.stockOBV = lastObv; //thisNewCollar.stockAD = lastAd; //thisNewCollar.stockADOSC = lastAdOsc; //thisNewCollar.stockSTO = lastSto; thisNewCollar.stockVariance = lastVariance; thisNewCollar.SSQRnetProfit = stockTicket.QuantityFilled * bestSSQRColumn.netIncome; //Option logCorrespondingPut = AddCorrespondingPut(tradableCall, ref symbolDataBySymbol[bestSSQRColumn.uSymbol].currentOptions); // Add the corresponding put here so system tracks its price for Ex-dividend approachment //logCorrespondingPut = AddCorrespondingPut(bestSSQRColumn.wCallSymbol, ref symbolDataBySymbol[bestSSQRColumn.uSymbol].currentOptions); // Add the wing call corresponding put here so system tracks its price for Ex-Dividend approachment doTheTrade = true; if (thisNewCollar.cStrike < thisNewCollar.uStartPrice) { var limitPrice = (Securities[tradableCall].AskPrice - Securities[tradableCall].BidPrice) / 2M; // get the mid point for the limit price var callTicket = LimitOrder(tradableCall, -optionsToTrade, limitPrice); // sell limit order thisNewCollar.cQty = -(int)optionsToTrade; OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = callTicket; oLO.tpr = thisNewCollar; oLO.oRight = OptionRight.Call; oLOs.Add(oLO); //if (closePutTicket.Status == OrderStatus.Submitted) oldTradeRec.pEndPrice = limitPrice; } else { var callTicket = MarketOrder(tradableCall, -optionsToTrade); if (callTicket.Status == OrderStatus.Filled) { thisNewCollar.cStartPrice = callTicket.AverageFillPrice; thisNewCollar.cQty = (int)callTicket.QuantityFilled; } } thisWingFactor = bestSSQRColumn.wingFactor; var putTicket = MarketOrder(tradablePut, (1 + thisWingFactor) * optionsToTrade); if (putTicket.Status == OrderStatus.Filled) { thisNewCollar.pStartPrice = putTicket.AverageFillPrice; thisNewCollar.pQty = (int)putTicket.QuantityFilled; } if (thisWingFactor > 0) { var wCallTicket = MarketOrder(tradableWCall, thisWingFactor * optionsToTrade); if (wCallTicket.Status == OrderStatus.Filled) { thisNewCollar.wcStartPrice = wCallTicket.AverageFillPrice; thisNewCollar.wcQty = (int)wCallTicket.QuantityFilled; } } doTheTrade = true; tradeRecs.Add(thisNewCollar); Debug("-"); } // marketOrder(bestSSQRColumn.uSymbol) == filled } // goodThresh is TRUE return; } /////////////////////////////////////////////////////////////////////////////////// // Close2ndTPR //////////////////////////////////////////////////////////////////////////////////// public void Close2ndTPR (TradePerfRec closeRec, DateTime closeDate, string reason) { decimal limitPrice = 0; if (haltProcessing) { //Debug(" Logging Close2ndTPR "); } doTheTrade = true; var stockTicket = MarketOrder(closeRec.uSymbol, -closeRec.uQty); // sell the stock Debug(" C2 ** MARKET ORDER TO SELL " + closeRec.uQty.ToString() + " shares of " + closeRec.uSymbol + " at the market."); if (doTracing) Debug(" C2 ** C2 ** STARTING CLOSE2ndTPR PROCESSING ** C2 ** C2 "); if (doTracing) Debug(" -- "); if (doTracing) { foreach(var kvp in Securities) /// make sure there's no leaking of abandoned stocks or options { var security = kvp.Value; if (security.Invested) { //saveString = "," + security.Symbol + ", " + security.Holdings.Quantity + Environment.NewLine; Debug($" |||| HOLDINGS: {security.Symbol} : {security.Holdings.Quantity} @ {security.BidPrice} by {security.AskPrice}"); } } } if (stockTicket.Status == OrderStatus.Filled) { //closeRec.isOpen = false; tprsToClose.Add(closeRec); closeRec.uEndPrice = stockTicket.AverageFillPrice; if (symbFilter != null) Plot("Stock Chart", "Sells", stockTicket.AverageFillPrice + 1); if (symbFilter != null) Plot("Stock Chart", "PTSs", divPlotValue); tradeRecCount = 0; // reset trade record count } doTheTrade = true; Debug(" C2 ** C2 ** C2 ** C2 ** KILLING 2nd TPR ** C2 ** C2 ** C2 ** C2 ** C2 ** "); //Debug(" C2 ** Stock Price: " + stockPrice.ToString() + " Call Bid/Offer: " + closeRec.cSymbol.BidPrice.ToString() + "/" + closeRec.cSymbol.AskPrice.ToString()); if (closeRec.pStrike >= stockPrice) /// ITM Put -- use limit order { limitPrice = closeRec.pStrike - stockPrice + 0.10M; closePutTicket = LimitOrder(closeRec.pSymbol, -closeRec.pQty, limitPrice); // sell the puts OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closePutTicket; oLO.tpr = closeRec; oLO.oRight = OptionRight.Put; oLOs.Add(oLO); Debug(" C2 ** LIMIT ORDER TO SELL " + closeRec.pQty.ToString() + " contracts of " + closeRec.pSymbol + " at " + limitPrice.ToString()); Debug("-"); } else { closePutTicket = MarketOrder(closeRec.pSymbol, -closeRec.pQty); // sell the puts Debug(" C2 ** MARKET ORDER TO SELL " + closeRec.pQty.ToString() + " contracts of " + closeRec.pSymbol + " at the market." ); Debug("-"); } if (closePutTicket.Status == OrderStatus.Filled) { closeRec.pEndPrice = closePutTicket.AverageFillPrice; } closeRec.reasonForClose = reason; closeRec.endDate = closeDate; // set the end date of this collar Debug(" C2 ** C2 ** C2 ** C2 ** CLOSED 2nd TPR ** C2 ** C2 ** C2 ** C2 ** C2 ** "); Debug("-"); } /////////////////////////////////////////////////////////////////////////////////// // KillTheCollar //////////////////////////////////////////////////////////////////////////////////// public bool KillTheCollar(TradePerfRec killRec, ref LookupData LUD, string reason) { bool bKTC = false; // controls Main.cs foreach TPR routine -- exit the for loop if .isOpen is changed. decimal limitPrice = 0; decimal currUPrice = Securities[killRec.uSymbol].Price; decimal currPPrice = killRec.pSymbol != null ? Securities[killRec.pSymbol].BidPrice : 0; decimal currCPrice = killRec.cSymbol != null ? Securities[killRec.cSymbol].AskPrice : 0; decimal currWCPrice = killRec.wcSymbol != null ? Securities[killRec.wcSymbol].BidPrice : 0; decimal stockPrice = Securities[killRec.uSymbol].Price; //decimal sellPnL = 0; //decimal exrcsPnL = 0; if (doTracing) Debug($" KK ** KK ** STARTING KILLTHECOLLAR PROCESSING FOR {thisSymbol} ** KK ** KK "); if (doTracing) Debug(" -- "); if (doTracing) { foreach(var kvp in Securities) /// make sure there's no leaking of abandoned stocks or options { var security = kvp.Value; if (security.Invested) { //saveString = "," + security.Symbol + ", " + security.Holdings.Quantity + Environment.NewLine; Debug($" |||| HOLDINGS: {security.Symbol} : {security.Holdings.Quantity} @ {security.BidPrice} by {security.AskPrice}"); } } Debug($" |||| SELL OPTS P&L: " + String.Format("{0:0.00}", currSellPnL)); Debug($" |||| Exrcs PUT P&L: " + String.Format("{0:0.00}", currExrcsPutPnL)); Debug($" |||| Exrcs CALL P&L: " + String.Format("{0:0.00}", currExrcsCallPnL)); } if (haltProcessing) { Debug(" Logging KILLTHECOLLAR "); } doTheTrade = true; // determine if this is an ITM call or ITM put and within 1 day of expiry if (killRec.pSymbol != null && stockPrice <= putStrike && LUD.daysRemainingP <= 1) { // determine if it's more expensive to sell or exercise ***** remember, killRec.cQty is negative for collars (sold calls) if (killRec.currExrcsPutPnL > killRec.currSellPnL) { // for an ITM PUT, both costs should be negative if (doTracing) Debug($" KK ** KK ** EXERCISING PUTS AND CALLS THETA IN KILLTHECOLLAR FOR {thisSymbol} ** KK ** KK "); if (killRec.cSymbol != null) { // Exercise the PUTs. Let longer expiry calls ride to attempt theta decay //var shrtCall = (Option)Securities[killRec.cSymbol]; //TimeSpan daysToCallExpiry = shrtCall.Expiry.Subtract(killDate); /*if (daysToCallExpiry.Days > 10 ) { Debug(" OO CALL " + shrtCall + " EXPIRES IN " + daysToCallExpiry.Days + "DAYS. CREATING THETA TPR."); // create a thetaTPR to move the call data and track it. Buy it back when theta decays. TradePerfRec newThTPR = new TradePerfRec(); newThTPR.uSymbol = killRec.uSymbol; newThTPR.index = killRec.index; newThTPR.isOpen = true; newThTPR.isInitializer = true; newThTPR.isSecondary =false; newThTPR.isTheta = true; newThTPR.startDate = killRec.startDate; newThTPR.strtngCndtn = "SPINNING OFF THETA CALLS"; newThTPR.expDate = shrtCall.Expiry; newThTPR.cSymbol = killRec.cSymbol; newThTPR.cStrike = killRec.cStrike; newThTPR.cQty = killRec.cQty; newThTPR.cStartPrice = killRec.cStartPrice; newThTPR.tradeCriteria = killRec.tradeCriteria; tradeRecs.Add(newThTPR); killRec.cSymbol = null; // eliminate the call from the existint TPR killRec.cStartPrice = 0; killRec.cQty = 0; } else { */ if (doTracing) Debug(" KK ** KK ** BUYING BACK SHORT CALLS IN KILLTHECOLLAR ** KK ** KK "); closeCallTicket = MarketOrder(killRec.cSymbol, -killRec.cQty); // buy the calls Debug(" KK ** MARKET ORDER TO BUY " + killRec.cQty.ToString() + " contracts of " + killRec.cSymbol + " at the market."); Debug("-"); if (closeCallTicket.Status == OrderStatus.Filled) { killRec.cEndPrice = closeCallTicket.AverageFillPrice; } } if (doTracing) Debug(" ------- "); if (doTracing) Debug(" KK ** KK ** EXERCISING PUTS IN KILLTHECOLLAR ** KK ** KK "); closePutTicket = ExerciseOption(killRec.pSymbol, killRec.pQty); /// underlying and calls will be closed in onOrder() event killRec.grossPnL = currExrcsPutPnL; /// log the PnL used in runtime decision //potentialCollars.Clear(); bestSSQRColumn = new SSQRColumn(); bKTC = true; return bKTC; } if (doTracing) Debug(" KK ** KK ** CLOSE POSITIONS IN KILLTHECOLLAR ** KK ** TT "); goto noExercise; } if (killRec.cSymbol != null && stockPrice >= callStrike && LUD.daysRemainingC <= 1) { if (doTracing) Debug(" KK ** KK ** EXERCISING CALLS AND SELLING BACK PUTS IN KILLTHECOLLAR ** KK ** TT "); if (currExrcsCallPnL > currSellPnL) { // for an ITM CALL, both costs should be positive if (doTracing) Debug(" KK ** KK ** EXIT KILLTHECOLLAR AND AWAIT CALL EXERCISE** KK ** TT "); killRec.grossPnL = currExrcsCallPnL; // log the PnL used in runtime decision return bKTC; // get out of the OnData() and await LEAN-driven call exercise } if (doTracing) Debug(" KK ** KK ** CLOSING POSITIONS IN KILLTHECOLLAR ** KK ** TT "); } noExercise: //if OTM or it's less costly to execute orders, then do so here. var stockTicket = MarketOrder(killRec.uSymbol, -killRec.uQty); // sell the stock Debug(" KK ** MARKET ORDER TO SELL " + killRec.uQty.ToString() + " shares of " + killRec.uSymbol + " at the market."); // Log the sale if (stockTicket.Status == OrderStatus.Filled) { Debug(" KK ** KK ** UPDATING U END PRICE ** KK ** KK"); // Log the UPDATING //killRec.isOpen = false; /// add the killTPR to TPRS to close; tprsToClose.Add(killRec); killRec.uEndPrice = stockTicket.AverageFillPrice; if (symbFilter != null) Plot("Stock Chart", "Sells", stockTicket.AverageFillPrice + 1); tradeRecCount = 0; // reset trade record count } doTheTrade = true; Debug(" KK ** KK ** KK ** KK ** KILLING COLLAR ** KK ** KK ** KK ** KK ** KK ** "); //Debug(" KK ** Stock Price: " + stockPrice.ToString() + " Call Bid/Offer: " + killRec.cSymbol.BidPrice.ToString() + "/" + killRec.cSymbol.AskPrice.ToString()); if (killRec.cSymbol != null) { // Exercise the PUTs. Buy back any calls if possible var shrtCall = (Option)Securities[killRec.cSymbol]; TimeSpan daysToCallExpiry = shrtCall.Expiry.Subtract(LUD.dtTst); /*if (daysToCallExpiry.Days > 10 ) { Debug(" OO CALL " + shrtCall + " EXPIRES IN " + daysToCallExpiry.Days + ". CREATING THETA TPR."); // create a thetaTPR to move the call data and track it. Buy it back when theta decays. TradePerfRec newThTPR = new TradePerfRec(); newThTPR.uSymbol = killRec.uSymbol; newThTPR.index = killRec.index; newThTPR.isOpen = true; newThTPR.isInitializer = true; newThTPR.isSecondary = true; newThTPR.isTheta = true; newThTPR.startDate = killRec.startDate; newThTPR.strtngCndtn = "SPINNING OFF THETA CALLS"; newThTPR.expDate = shrtCall.Expiry; newThTPR.cSymbol = killRec.cSymbol; newThTPR.cQty = killRec.cQty; newThTPR.cStartPrice = killRec.cStartPrice; newThTPR.tradeCriteria = killRec.tradeCriteria; tradeRecs.Add(newThTPR); killRec.cSymbol = null; // eliminate the call from the existint TPR killRec.cStartPrice = 0; killRec.cQty = 0; } else */ if (killRec.cStrike <= stockPrice) { /// ITM Call -- use limit order limitPrice = stockPrice - killRec.cStrike + 0.10M; closeCallTicket = LimitOrder(killRec.cSymbol, -killRec.cQty, limitPrice); OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closeCallTicket; oLO.tpr = killRec; oLO.oRight = OptionRight.Call; oLOs.Add(oLO); Debug(" KK ** LIMIT ORDER TO BUY TO CLOSE SHORT CALL " + killRec.cQty.ToString() + " contracts of " + killRec.cSymbol + " at " + limitPrice.ToString()); } else { closeCallTicket = MarketOrder(killRec.cSymbol, -killRec.cQty); // buy the calls Debug(" KK ** MARKET ORDER TO BUY TO CLOSE SHORT CALL" + killRec.cQty.ToString() + " contracts of " + killRec.cSymbol + " at the market."); if (closeCallTicket.Status == OrderStatus.Filled) { killRec.cEndPrice = closeCallTicket.AverageFillPrice; } } } Debug("---------------------------------------"); if (killRec.pStrike >= stockPrice) /// ITM Put -- use limit order { limitPrice = killRec.pStrike - stockPrice + 0.10M; closePutTicket = LimitOrder(killRec.pSymbol, -killRec.pQty, limitPrice); // sell the puts OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closePutTicket; oLO.tpr = killRec; oLO.oRight = OptionRight.Put; oLOs.Add(oLO); Debug(" KK ** LIMIT ORDER TO SELL TO CLOSE " + killRec.pQty.ToString() + " contracts of " + killRec.pSymbol + " at " + limitPrice.ToString()); Debug("-"); } else { closePutTicket = MarketOrder(killRec.pSymbol, -killRec.pQty); // sell the puts Debug(" KK ** MARKET ORDER TO SELL TO CLOSE " + killRec.pQty.ToString() + " contracts of " + killRec.pSymbol + " at the market." ); Debug("-"); } if (closePutTicket.Status == OrderStatus.Filled) { killRec.pEndPrice = closePutTicket.AverageFillPrice; Debug(" KK ** UPDATING PUT PRICE TO " + killRec.pEndPrice + " ** KK ** KK"); } if (killRec.wcSymbol != null && killRec.wcQty != 0 && killRec.wcEndPrice == 0) { if (killRec.wcStrike < stockPrice) /// ITM Put -- use limit order { limitPrice = stockPrice - killRec.wcStrike + 0.10M; Debug(" KK ** LIMIT ORDER TO SELL TO CLOSE WING " + killRec.wcQty.ToString() + " contracts of " + killRec.wcSymbol + " at " + limitPrice.ToString()); closeWCallTicket = LimitOrder(killRec.wcSymbol, -killRec.wcQty, limitPrice); // sell the puts OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closeWCallTicket; oLO.tpr = killRec; oLO.oRight = OptionRight.Call; oLO.isWingCall = true; oLOs.Add(oLO); Debug("-"); } else { closeWCallTicket = MarketOrder(killRec.wcSymbol, -killRec.wcQty); // sell the puts Debug(" KK ** LIMIT ORDER TO SELL TO CLOSE WING " + killRec.wcQty.ToString() + " contracts of " + killRec.wcSymbol + " at " + limitPrice.ToString()); Debug("-"); } if (closeWCallTicket.Status == OrderStatus.Filled) { killRec.wcEndPrice = closePutTicket.AverageFillPrice; Debug(" KK ** UPDATING WING END PRICE TO " + killRec.wcEndPrice + " ** KK ** KK"); } } killRec.reasonForClose = reason; killRec.endDate = LUD.dtTst; // set the end date of this collar killRec.grossPnL = currSellPnL; // for logging and analysis of runtime conditions Debug("-"); return bKTC; } /////////////////////////////////////////////////////////////////////////////////// // RollPut //////////////////////////////////////////////////////////////////////////////////// /* public void RollPut(Slice slcData, DateTime nExDvDt, TradePerfRec oldTPR, IEnumerable <Symbol> undrOptsSymbols, decimal sPrice, decimal incrAmt, string reason, bool forceAction){ int rollQty = 0; // change in qty, difference between total stock and covered stock = uncovered stock == amount to roll up. int findYear = slcData.Time.Year; int findMonth = slcData.Time.Month; PutSpread bestPutSpread; OrderTicket closePutTicket; // used to close the open puts OrderTicket openPutTicket; // used to open (roll up) new puts if (haltProcessing) { Debug(" RP ** RP ** RP ** Logging ROLLPUT RR ** RR ** RR **"); } if (doTracing) Debug(" RP ** RP ** STARTING ROLL2NDPUT PROCESSING ** RP ** RP "); if (doTracing) Debug(" -- "); if (doTracing) { foreach(var kvp in Securities) /// make sure there's no leaking of abandoned stocks or options { var security = kvp.Value; if (security.Invested) { //saveString = "," + security.Symbol + ", " + security.Holdings.Quantity + Environment.NewLine; Debug($" |||| HOLDINGS: {security.Symbol} : {security.Holdings.Quantity} @ {security.BidPrice} by {security.AskPrice}"); } } Debug($" |||| SELL OPTS P&L: " + String.Format("{0:0.00}", currSellPnL)); Debug($" |||| Exrcs PUT P&L: " + String.Format("{0:0.00}", currExrcsPutPnL)); Debug($" |||| Exrcs CALL P&L: " + String.Format("{0:0.00}", currExrcsCallPnL)); } // Compute the 3rd Friday of this month [options expiration] ---> do not adjust for potential holiday here DateTime thisMonthExpiry = FindDay(findYear, findMonth, DayOfWeek.Friday, 3); // Use the 3rd Friday of the current month to seed the function to return the next 4 ex-dividends expiries adjusted for holidays Dictionary<int, DateTime> expiries = GetOptionExpiries(slcData.Time, nExDvDt, thisMonthExpiry, false); /// final parameter, bool, isPrimary = true ? 1stTPR : 2ndTPR List<PutSpread> pSpreads = AssemblePutSpreads(slcData, expiries, oldTPR, undrOptsSymbols, sPrice, incrAmt); if (pSpreads == null | pSpreads.Count() == 0) { if (doTracing) Debug(" RP RP RP RP FAILED ROLLPUT -- NO PSPREADS"); if (doTracing) Debug(" - "); return bKTC; // loop around and try again } bestPutSpread = GetBestPutSpread(pSpreads); if (bestPutSpread == null) { // if (haltProcessing) { /// 2021-02-17 removed this //if (doTracing) Debug(" Logging ROLLPUT --NULL BESTPUTSPREAD -- ITERATE"); if (doTracing) Debug(" RP 2nd TPR PROCESSING CANNOT ROLL " + thisSymbol.ToString() + " CANNOT GET bestPutSpread -- FORCE PUT EXERCISE OOOOOOOOOOO"); // EXERCISE THE PUT removing PUTs and STOCK. Buy back calls in OnOrder() if (doTracing) Debug(" RP FORCE PUT EXERCISE OR CLOSE ON PUT: " + secondLongPutSymbol + " -- OOOOOOOOOOO OOOOOOOO OOOOOOOOOOO"); // EXERCISE THE PUT removing PUTs and STOCK. Buy back calls in OnOrder() if (doTracing){ var orderedPSpreads = pSpreads.Where(s => s.netIncome + s.netOptions > 0 ).OrderByDescending( s => (s.netIncome + s.netOptions)/Math.Abs(s.stockPrice - s.newPutStrike)); //var orderedPSpreads = pSpreads.OrderByDescending(s=>s.netIncome + s.netOptions); IterateOrderedPutSpreadList(orderedPSpreads); } if (oldTPR.isSecondary) { // close secondary tickets only if (oldTPR.pStrike > sPrice & forceAction) { oldTPR.reasonForClose = "FAILED TO OBTAIN PUT ROLL SPREAD"; var putExerciseTicket = ExerciseOption(oldTPR.pSymbol, oldTPR.pQty); } else if (oldTPR.pStrike < sPrice & forceAction) { Close2ndTPR(oldTPR, slcData.Time, " CLOSING 2nd TPR at Expiration with stock @: " + String.Format("{0:C2}", sPrice)); } if (doTracing) Debug(" ************** END 2nd TPR ITM PUT CALC ****************"); if (doTracing) Debug("-"); } if (symbFilter != null) Plot("Stock Chart", "PTSs", divPlotValue); return bKTC; // loop around and try again } if (doTracing){ var orderedPSpreads = pSpreads.OrderByDescending(s=>s.netIncome + s.netOptions); IterateOrderedPutSpreadList(orderedPSpreads); } /// Roll up the collar if (!oldTPR.isSecondary && oldTPR.pQty > oldTPR.cQty) { rollQty = oldTPR.pQty + oldTPR.cQty; // call Qty is stored as negative value. this is equivalent: abs(p)-abs(c) Debug(" RP ** RP ** RP ** RP ** ROLLING UP PUTS ** RP ** RP ** RP ** RP ** RP ** "); doTheTrade = true; Debug(" RP ** MARKET ORDER TO SELL " + rollQty + " contracts of " + oldTPR.pSymbol + " at market"); closePutTicket = MarketOrder(oldTPR.pSymbol, -rollQty); // sell the puts Debug(" RP ** MARKET ORDER TO BUY " + rollQty + " contracts of " + bestPutSpread.newPutSymb + " at market"); openPutTicket = MarketOrder(bestPutSpread.newPutSymb, rollQty); // buy the higher puts // first adjust the old tradePerfRec to decrement pQty and uQty. It remains open to be processed for the remaining covered, collared stock. oldTPR.pQty = oldTPR.pQty - rollQty; // decrement oldTPR to fully covered collar. Leave it open for future roll processing oldTPR.uQty = oldTPR.uQty - (100 * rollQty); TradePerfRec newTPR1 = new TradePerfRec(); // create a tradePerfRec #1 for the puts sold, solely to log their P/L (including underlying unrealized P/L). TradePerfRec newTPR2 = new TradePerfRec(); // create a TradePerfRec #2 for the new Synthetic Call (stock-covered puts) newTPR1.uSymbol = newTPR2.uSymbol = oldTPR.uSymbol; // newTPR1 for the uncovered synthetic call (put + stock) portion of the original collar newTPR1.index = newTPR2.index = oldTPR.index; // maintain collarIndex throughout the entire sequence of collars and synthCalls newTPR1.uQty = rollQty * 100; // log the starting and ending values and close the TradePerfRec newTPR1.uStartPrice = oldTPR.uStartPrice; newTPR1.uEndPrice = sPrice; newTPR1.pSymbol = oldTPR.pSymbol; newTPR1.pStrike = oldTPR.pStrike; newTPR1.expDate = oldTPR.expDate; newTPR1.pQty = rollQty; newTPR1.pStartPrice = oldTPR.pStartPrice; newTPR1.startDate = oldTPR.startDate; newTPR1.endDate = slcData.Time; newTPR1.isOpen = false; newTPR1.isInitializer = false; newTPR1.isSecondary = true; newTPR1.numDividends = oldTPR.numDividends; newTPR1.divIncome = oldTPR.divIncome; newTPR1.tradeRecCount = oldTPR.tradeRecCount; newTPR1.ROR = oldTPR.ROR; newTPR1.ROC = oldTPR.ROC; newTPR1.CCOR = oldTPR.CCOR; newTPR1.tradeCriteria = oldTPR.tradeCriteria; newTPR1.strtngCndtn = "OLD SYNTH CALL -- MAIN COLLAR SPLIT ON APPRECIATION"; newTPR1.reasonForClose = "P ROLL OLD FRAGMENT SPLIT-SOLD PUTS SPrice @ " + String.Format("{0:0.00}",sPrice) + " up " + String.Format("{0:0.00}", incrAmt) ; if (closePutTicket.Status == OrderStatus.Filled) { newTPR1.pEndPrice = closePutTicket.AverageFillPrice; } newTPR2.uQty = rollQty * 100; // newTPR2 for the new uncovered synthetic call (put + stock) newTPR2.uStartPrice = sPrice; // log the starting values for underlying and puts. newTPR2.pSymbol = bestPutSpread.newPutSymb; newTPR2.pStrike = bestPutSpread.newPutStrike; newTPR2.pQty = rollQty; newTPR2.expDate = bestPutSpread.putExpiry; newTPR2.startDate = slcData.Time; newTPR2.isOpen = true; newTPR2.isInitializer = true; // mark the first synthCall TPR as initializer newTPR2.isSecondary = true; //newTPR2. newTPR2.tradeRecCount = 1; newTPR2.ROR = oldTPR.ROR; newTPR2.ROC = oldTPR.ROC; newTPR2.CCOR = oldTPR.CCOR; newTPR2.tradeCriteria = oldTPR.tradeCriteria; newTPR2.strtngCndtn = "NEW SYNTH CALL -- COLLAR SPLIT ON APPRECIATION"; if (openPutTicket.Status == OrderStatus.Filled) { newTPR2.pStartPrice = openPutTicket.AverageFillPrice; } tradeRecs.Add(newTPR1); tradeRecs.Add(newTPR2); if (symbFilter != null) Plot("Stock Chart", "PTSs", divPlotValue); if (doTracing) Debug(" RP ** RP ** END OF ROLL PUT FROM PRIMARY TPR ** RP ** RP ** "); } else if (oldTPR.isSecondary) { // rollQty = oldTPR.pQty; // call Qty is stored as negative value. this is equivalent: abs(p)-abs(c) Debug(" RP ** RP ** RP ** RP ** ROLLING UP PUTS ** RP ** RP ** RP ** RP ** RP ** "); doTheTrade = true; Debug(" RP ** MARKET ORDER TO SELL " + rollQty + " contracts of " + oldTPR.pSymbol + " at market"); closePutTicket = MarketOrder(oldTPR.pSymbol, -rollQty); // sell the puts Debug(" RP ** MARKET ORDER TO BUY " + rollQty + " contracts of " + bestPutSpread.newPutSymb + " at market"); openPutTicket = MarketOrder(bestPutSpread.newPutSymb, rollQty); // buy the higher puts // first adjust the old tradePerfRec to decrement pQty and uQty. It remains open to be processed for the remaining covered, collared stock. //oldTPR.pQty = oldTPR.pQty - rollQty; // whether this is the first secondary TPR, or a subsequent, //oldTPR.uQty = 100M * rollQty; TradePerfRec newTPR1 = new TradePerfRec(); // create a tradePerfRec #1 for the puts sold, solely to log their P/L. //TradePerfRec newTPR2 = new TradePerfRec(); // create a TradePerfRec #2 for the new Synthetic Call (stock-covered puts) foreach (var field in typeof(TradePerfRec).GetFields()) // copy oldTPR to newTPR1 { field.SetValue(newTPR1, field.GetValue(oldTPR)); } oldTPR.uEndPrice = sPrice; if (closePutTicket.Status == OrderStatus.Filled) { oldTPR.pEndPrice = closePutTicket.AverageFillPrice; } oldTPR.endDate = slcData.Time; oldTPR.isOpen = false; oldTPR.grossPnL = closePutTicket.AverageFillPrice - oldTPR.pStartPrice; oldTPR.reasonForClose = "P ROLLUP " + oldTPR.uSymbol + " IS " + String.Format("{0:0.00}",sPrice) + "WHICH STARTED @ " + String.Format("{0:0.00}", oldTPR.uStartPrice); newTPR1.uStartPrice = sPrice; // set the newTPR.uPrice to 0-delta current sPrice if (openPutTicket.Status == OrderStatus.Filled) { newTPR1.pStartPrice = openPutTicket.AverageFillPrice; } newTPR1.pSymbol = bestPutSpread.newPutSymb; // set the pSymbol to the bestPutSpread put symbol newTPR1.pStrike = bestPutSpread.newPutStrike; newTPR1.expDate = bestPutSpread.putExpiry; newTPR1.startDate = slcData.Time; newTPR1.numDividends = 0; newTPR1.divIncome = 0; newTPR1.isInitializer = false; // tied to 1st synthCall TPR newTPR1.isSecondary = true; newTPR1.tradeRecCount = oldTPR.tradeRecCount + 1; // increment this iteration of TPR newTPR1.strtngCndtn = reason; //newTPR1.reasonForClose = ""; //newTPR1.ROR = oldTPR.ROR; //newTPR1.ROC = oldTPR.ROC; //newTPR1.CCOR = oldTPR.CCOR; //newTPR1.tradeCriteria = oldTPR.tradeCriteria; if (symbFilter != null) Plot("Stock Chart", "PTSs", divPlotValue); tradeRecs.Add(newTPR1); if (doTracing) Debug(" RP ** RP ** END OF ROLL PUT FROM SECONDARY TPR ** RP ** RP ** "); } } */ /////////////////////////////////////////////////////////////////////////////////// // // RollTheCollar // //////////////////////////////////////////////////////////////////////////////////// public bool RollTheCollar(CollarAlgorithm algo, ref LookupData LUD, TradePerfRec oldTradeRec, string reason) { Slice data = algo.CurrentSlice; decimal stockPrice = data[LUD.uSymbol].Price; thisCCOR = bestSSQRColumn.CCOR; decimal thisNetOptions = bestSSQRColumn.netOptions; decimal limitPrice = 0; decimal maxWingFactor = 0; decimal thisWingFactor = 0; decimal wingPremium = 0; OrderTicket closeCallTicket; OrderTicket closePutTicket; OrderTicket closeWCallTicket; if (haltProcessing) { Debug(" Logging ROLL "); } if (symbFilter != null) Plot("Stock Chart", "Rolls", stockPrice + 5); Symbol oldShortCallSymb = oldTradeRec.cSymbol; Symbol oldLongPutSymb = oldTradeRec.pSymbol; Symbol oldWCCallSymb = oldTradeRec.wcSymbol; // Cannot execute options spread orders at this time in QuantConnect, so do the collar as // individual legs // 1st sell the long put Debug(" ROLLING ** STARTING ** ROLLING ** STARTING ** ROLLING ** STARTING ** ROLLING ** STARTING ** ROLLING ** STARTING ** "); doTheTrade = true; if (doTracing) Debug(" -- "); if (doTracing) { foreach(var kvp in Securities) /// make sure there's no leaking of abandoned stocks or options { var security = kvp.Value; if (security.Invested) { //saveString = "," + security.Symbol + ", " + security.Holdings.Quantity + Environment.NewLine; Debug($" |||| HOLDINGS: {security.Symbol} : {security.Holdings.Quantity} @ {security.BidPrice} by {security.AskPrice}"); } } Debug($" |||| SELL OPTS P&L: " + String.Format("{0:0.00}", currSellPnL)); Debug($" |||| Exrcs PUT P&L: " + String.Format("{0:0.00}", currExrcsPutPnL)); Debug($" |||| Exrcs CALL P&L: " + String.Format("{0:0.00}", currExrcsCallPnL)); } if (oldTradeRec.pStrike >= stockPrice) /// ITM Put -- use limit order to close { limitPrice = oldTradeRec.pStrike - stockPrice + 0.10M; Debug(" ROLLING ** LIMIT ORDER TO SELL " + oldTradeRec.pQty.ToString() + " contracts of " + oldTradeRec.pSymbol + " at " + limitPrice.ToString()); closePutTicket = LimitOrder(oldTradeRec.pSymbol, -oldTradeRec.pQty, limitPrice); // sell the puts OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closePutTicket; oLO.tpr = oldTradeRec; oLO.oRight = OptionRight.Put; oLOs.Add(oLO); //if (closePutTicket.Status == OrderStatus.Submitted) oldTradeRec.pEndPrice = limitPrice; } else { Debug(" ROLLING ** MARKET ORDER TO SELL TO CLOSE " + oldTradeRec.pQty.ToString() + " contracts of " + oldTradeRec.pSymbol + " at market"); closePutTicket = MarketOrder(oldTradeRec.pSymbol, -oldTradeRec.pQty); // sell the puts } if (closePutTicket.Status == OrderStatus.Filled) { oldTradeRec.pEndPrice = closePutTicket.AverageFillPrice; Debug(" ROLLING ** UPDATING PUT " + oldTradeRec.pSymbol + " END PRICE @ " + oldTradeRec.pEndPrice ); } Debug("-"); // 2nd, buy back the long call doTheTrade = true; if (oldTradeRec.cStrike <= stockPrice) /// ITM Call -- use limit order { /// call QTY should be negative from the opening short trade limitPrice = stockPrice - oldTradeRec.cStrike + 0.10M; Debug(" ROLLING ** LIMIT ORDER TO BUY TO CLOSE " + oldTradeRec.cQty.ToString() + " contracts of " + oldTradeRec.cSymbol + " at " + limitPrice.ToString()); closeCallTicket = LimitOrder(oldTradeRec.cSymbol, -oldTradeRec.cQty, limitPrice); //if (closeCallTicket.Status == OrderStatus.Submitted) oldTradeRec.cEndPrice = limitPrice; OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closeCallTicket; oLO.tpr = oldTradeRec; oLO.oRight = OptionRight.Call; oLOs.Add(oLO); } else { Debug(" ROLLING ** MARKET ORDER TO BUY TO CLOSE " + oldTradeRec.cQty.ToString() + " contracts of " + oldTradeRec.cSymbol + " at market"); closeCallTicket = MarketOrder(oldTradeRec.cSymbol, -oldTradeRec.cQty); // buy the calls Debug(" ROLLING ** UPDATING CALL " + oldTradeRec.cSymbol + "END PRICE @ " + oldTradeRec.cEndPrice ); } Debug("-"); if (closeCallTicket.Status == OrderStatus.Filled) { oldTradeRec.cEndPrice = closeCallTicket.AverageFillPrice; Debug(" ROLLING ** UPDATING CALL END PRICE @ " + oldTradeRec.cEndPrice ); } // 3rd, buy back the long call doTheTrade = true; if (oldTradeRec.wcSymbol != null && oldTradeRec.wcQty != 0 && oldTradeRec.wcEndPrice == 0) { if (oldTradeRec.wcStrike <= stockPrice) /// ITM aCall -- use limit order { /// call QTY should be negative from the opening short trade limitPrice = stockPrice - oldTradeRec.wcStrike + 0.10M; Debug(" ROLLING ** LIMIT ORDER TO SELL TO CLOSE WING CALL " + oldTradeRec.wcQty.ToString() + " contracts of " + oldTradeRec.wcSymbol + " at " + limitPrice.ToString()); closeWCallTicket = LimitOrder(oldTradeRec.wcSymbol, -oldTradeRec.wcQty, limitPrice); //if (closeCallTicket.Status == OrderStatus.Submitted) oldTradeRec.cEndPrice = limitPrice; oldTradeRec.wcEndPrice = limitPrice; // set the wc Call End Price here bc finding this record in OnOrder() will be very difficult OpenLimitOrder oLO = new OpenLimitOrder(); oLO.oTicket = closeWCallTicket; oLO.tpr = oldTradeRec; oLO.oRight = OptionRight.Call; oLO.isWingCall = true; oLOs.Add(oLO); } else { Debug(" ROLLING ** MARKET ORDER TO SELL TO CLOSE WING CALL " + oldTradeRec.wcQty.ToString() + " contracts of " + oldTradeRec.wcSymbol + " at market"); closeWCallTicket = MarketOrder(oldTradeRec.wcSymbol, -oldTradeRec.wcQty); // buy the calls } Debug("-"); if (closeCallTicket.Status == OrderStatus.Filled) { oldTradeRec.wcEndPrice = closeWCallTicket.AverageFillPrice; Debug(" ROLLING ** UPDATING WING CALL " + oldTradeRec.wcSymbol + "END PRICE @ " + oldTradeRec.wcEndPrice ); } } // Keep the stock, but close this trade performance record. Debug(" ROLLING ** ROLLING ** ROLLING ** ROLLING ** ROLLING ** SELL NEW COLLAR ** ROLLING ** ROLLING ** ROLLING ** ROLLING ** ROLLING ** "); oldTradeRec.uEndPrice = stockPrice; oldTradeRec.reasonForClose = reason; //oldTradeRec.isOpen = false; oldTradeRec.endDate = data.Time; oldTradeRec.grossPnL = currSellPnL; // rolling essentially sells the existing options. Log the currSellPnL for analysis purposes oldTradeRec.SSQRnetProfit = oldTradeRec.uQty*bestSSQRColumn.netIncome; // log the best SSQRColumn.netIncome for tracking purposes // Put on a new collar and start a new trade performance record // make a new TradePerfRec tradeRecCount = oldTradeRec.tradeRecCount + 1; // increment trade record count TradePerfRec thisNewTPRec = new TradePerfRec(); thisNewTPRec.uSymbol = thisSymbol; // keep the underlying symbol thisNewTPRec.cSymbol = bestSSQRColumn.callSymbol; thisNewTPRec.pSymbol = bestSSQRColumn.putSymbol; thisNewTPRec.wcSymbol = bestSSQRColumn.wCallSymbol; thisNewTPRec.uStartPrice = stockPrice; // log the current slice stock price thisNewTPRec.uQty = oldTradeRec.uQty; // maintain the same quantity //thisNewTPRec.isOpen = true; // this new trade performance record is open thisNewTPRec.isInitializer = false; // this is a continuation Collar thisNewTPRec.strtngCndtn = "MAIN COLLAR ROLL / " + reason; thisNewTPRec.index = oldTradeRec.index; // maintain the collarIndex through the entire sequence of collars thisNewTPRec.tradeRecCount = tradeRecCount; // count the trades thisNewTPRec.startDate = data.Time; // set the start date thisNewTPRec.pStrike = bestSSQRColumn.putStrike; thisNewTPRec.cStrike = bestSSQRColumn.callStrike; thisNewTPRec.wcStrike = bestSSQRColumn.wCallStrike; thisNewTPRec.expDate = bestSSQRColumn.putExpiry; // set the options Expiry thisNewTPRec.thetaExpiration = bestSSQRColumn.callExpiry; // set the theta Expiry thisNewTPRec.ROC = bestSSQRColumn.ROC; thisNewTPRec.ROR = bestSSQRColumn.ROR; thisNewTPRec.CCOR = bestSSQRColumn.CCOR; thisNewTPRec.RORThresh = RORThresh; thisNewTPRec.ROCThresh = ROCThresh; thisNewTPRec.CCORThresh = CCORThresh; //thisNewTPRec.tradeCriteria = switchROC ? "ROC" : "ROR"; thisNewTPRec.tradeCriteria = "Wing"; thisNewTPRec.stockADX = lastAdx; thisNewTPRec.stockADXR = lastAdxr; thisNewTPRec.stockOBV = lastObv; //thisNewTPRec.stockAD = lastAd; //thisNewTPRec.stockADOSC = lastAdOsc; //thisNewTPRec.stockSTO = lastSto; thisNewTPRec.stockVariance = lastVariance; //Debug(tradableColumn.ToString()); var tradablePut = bestSSQRColumn.putSymbol; // retrieve the put to buy var tradableCall = bestSSQRColumn.callSymbol; // retrieve the call to sell var tradableWCall = bestSSQRColumn.wCallSymbol; // retrievce wc call to sell // Option logCorrespondingPut = AddCorrespondingPut(tradableCall, ref symbolDataBySymbol[thisSymbol].currentOptions); // Add the corresponding put here so system tracks its price for Ex-dividend approachment // logCorrespondingPut = AddCorrespondingPut(bestSSQRColumn.wCallSymbol, ref symbolDataBySymbol[thisSymbol].currentOptions); // Add the wing call corresponding put here so system tracks its price for Ex-Dividend approachment // netOptions should be greater than the put premium + wc call premium. Figure out how many wings can be bought. //wingPremium = bestSSQRColumn.wingFactor; // thisWingFactor = bestSSQRColumn.wingFactor; thisWingFactor = 1; doTheTrade = true; //calculate the # of call Options to sell in $-Neutral Variable Call Coverage model: optionsToTrade = oldTradeRec.uQty/100; //callsToTrade = Decimal.Round(optionsToTrade * bestSSQRColumn.putPremium / bestSSQRColumn.callPremium); /// VCCPTS legacy code doTheTrade = true; Debug(" ROLLING ** EXECUTING PUT BUY MARKET ORDER TO OPEN " + ((1 + thisWingFactor) * optionsToTrade) + " contracts of " + tradablePut ); var putTicket = MarketOrder(tradablePut, (1 + thisWingFactor) * optionsToTrade); if (putTicket.Status == OrderStatus.Filled) { thisNewTPRec.pSymbol = tradablePut; thisNewTPRec.pStartPrice = putTicket.AverageFillPrice; thisNewTPRec.pQty = (int)putTicket.QuantityFilled; Debug(" ROLLING ** UPDATING PUT START PRICE TO " + thisNewTPRec.pStartPrice + " FOR " + thisNewTPRec.pQty + " CONTRACTS" ); } doTheTrade = true; Debug(" ROLLING ** EXECUTING CALL SELL MARKET ORDER TO OPEN " + optionsToTrade + " contracts of " + tradableCall ); var callTicket = MarketOrder(tradableCall, -optionsToTrade); //var callTicket = MarketOrder(tradableCall, -callsToTrade); if (callTicket.Status == OrderStatus.Filled) { thisNewTPRec.cSymbol = tradableCall; thisNewTPRec.cStartPrice = callTicket.AverageFillPrice; thisNewTPRec.cQty = (int)callTicket.QuantityFilled; Debug(" ROLLING ** UPDATING SHORT CALL START PRICE TO " + thisNewTPRec.cStartPrice + " FOR " + thisNewTPRec.cQty + " CONTRACTS" ); } doTheTrade = true; if (thisWingFactor > 0) { Debug(" ROLLING ** EXECUTING WING CALL BUY MARKET ORDER TO OPEN " + (thisWingFactor*optionsToTrade) + " contracts of " + tradableWCall ); var wCallTicket = MarketOrder(tradableWCall, thisWingFactor * optionsToTrade); if (wCallTicket.Status == OrderStatus.Filled) { thisNewTPRec.wcSymbol = tradableWCall; thisNewTPRec.wcStartPrice = wCallTicket.AverageFillPrice; thisNewTPRec.wcQty = (int)wCallTicket.QuantityFilled; Debug(" ROLLING ** UPDATING WING CALL START PRICE TO " + thisNewTPRec.wcStartPrice + " FOR " + thisNewTPRec.wcQty + " CONTRACTS" ); } else { Debug(" ROLLING ** WING FACTOR IS 0 -- NO WINGS ADDED"); } } /// Roll is done. save the new trade performance record var orderedSSQRMatrix = LUD.SSQRMatrix.OrderByDescending(p => p.CCOR); IterateOrderedSSQRMatrix(orderedSSQRMatrix); // IterateTradeRecord(thisNewTPRec); tprsToClose.Add(oldTradeRec); tprsToOpen.Add(thisNewTPRec); //tradeRecs.Add(thisNewTPRec); return true; } /////////////////////////////////////////////////////////////////////////////////// // // GetBestCollar 1 parameters // //////////////////////////////////////////////////////////////////////////////////// public SSQRColumn GetBestCollar(CollarAlgorithm algo, ref LookupData LD) { if (haltProcessing) { Debug(" @@@@@@ Logging GetPotentialCollars 1"); } Slice thisSlice = CurrentSlice; Symbol thisStock = LD.uSymbol; // First get the underlying stock price in this Slice decimal stockPrice = thisSlice[thisStock].Price; SSQRColumn bestTradableColumn = new SSQRColumn(); OptionChain putChain; // instantiate an OptionChain var for updating SSQRMatrix with slice data OptionChain callChain; // OptionChain wcallChain; // OptionContract putContract; // OptionContract callContract; // Symbol ssqrPutSymbol; // instantiate a Symbol var for updating SSQRMatrix with slice Data Symbol ssqrCallSymbol; // // Second get its options symbols var allUnderlyingOptionsSymbols = OptionChainProvider.GetOptionContractList(thisStock, thisSlice.Time); if (allUnderlyingOptionsSymbols.Count() == 0) // missing data at this time { Debug(" DDDDDDDDDDDDDDDDDDDDD Missing Data at " + thisSlice.Time + " no options for " + thisStock); List<SSQRColumn> blankCollarsList = new List<SSQRColumn>(); return bestTradableColumn; } int findYear = thisSlice.Time.Year; int findMonth = thisSlice.Time.Month; // Compute the 3rd Friday of this month [options expiration] ---> do not adjust for potential holiday here DateTime thisMonthExpiry = FindDay(findYear, findMonth, DayOfWeek.Friday, 3); // Use the 3rd Friday of the current month to seed the function to return the next 4 ex-dividends expiries adjusted for holidays Dictionary<int, DateTime> expiries = GetOptionExpiries(thisSlice.Time, LD.exDivdnDate, thisMonthExpiry, true); // now assemble the SSQR matrix using the expiries dictionary and the contracts lists LD.SSQRMatrix.Clear(); AssembleSSQRMatrix(this, ref LD, expiries); /*foreach (SSQRColumn ssqrC in passedMatrix) /// loop through the SSQRMatris to update the deltas and open interest { ssqrPutSymbol = ssqrC.putSymbol; ssqrCallSymbol = ssqrC.callSymbol; if (thisSlice.OptionChains.TryGetValue(ssqrPutSymbol, out ssqrPutChain)) { Debug(" HEY THE ssqrPutChain count is " + ssqrPutChain + " AT " + thisSlice.Time + " in FROM COLLARS."); } else { Debug(" HEY NO OPTIONS IN THIS SLICE in FROM COLLARS" + thisSlice.Time); } if (thisSlice.OptionChains.TryGetValue(ssqrCallSymbol, out ssqrCallChain)) { // Moved this code to Main.cs *** ssqrCallChain will not be included in the same Slice // where the options contracts are added. } } */ // Get the SSQRColumn with the best reward to risk if (LD.SSQRMatrix == null | LD.SSQRMatrix.Count == 0) return bestTradableColumn; /// found it's possible to have no SSQRs, if so, pass the empty/null SSQRColumn to calling routine var qualifyingCollars = LD.SSQRMatrix.Where(s=>s.putPremium!=0 & s.putPremium<=s.callPremium).Count(); if (qualifyingCollars == 0) return bestTradableColumn; // bestTradableColumn = passedMatrix.OrderByDescending(p => p.CCOR).FirstOrDefault(); bestTradableColumn = LD.SSQRMatrix.OrderBy(bTC => bTC.CCOR).FirstOrDefault(); /// 2021-03-21 -- changed from OrderedByDescending ..... using downsideRisk/upsidePotential return bestTradableColumn; } /////////////////////////////////////////////////////////////////////////////////// // // GetBestCollar 2 parameters // //////////////////////////////////////////////////////////////////////////////////// public SSQRColumn GetBestCollar(QCAlgorithm algo, ref LookupData LD, SymbolData SD) { if (haltProcessing) { Debug(" @@@@@@ Logging GetPotentialCollars"); } Slice thisSlice = algo.CurrentSlice; Symbol thisStock = LD.uSymbol; // First get the underlying stock price in this Slice decimal stockPrice = thisSlice[thisStock].Price; SSQRColumn bestTradableColumn = new SSQRColumn(); OptionChain putChain; // instantiate an OptionChain var for updating SSQRMatrix with slice data OptionChain callChain; // OptionChain wcallChain; // OptionContract putContract; // OptionContract callContract; // Symbol ssqrPutSymbol; // instantiate a Symbol var for updating SSQRMatrix with slice Data Symbol ssqrCallSymbol; // // Second get its options symbols var allUnderlyingOptionsSymbols = OptionChainProvider.GetOptionContractList(thisStock, thisSlice.Time); if (allUnderlyingOptionsSymbols.Count() == 0) // missing data at this time { Debug(" DDDDDDDDDDDDDDDDDDDDD Missing Data at " + thisSlice.Time + " no options for " + thisStock); List<SSQRColumn> blankCollarsList = new List<SSQRColumn>(); return bestTradableColumn; } int findYear = thisSlice.Time.Year; int findMonth = thisSlice.Time.Month; // Compute the 3rd Friday of this month [options expiration] ---> do not adjust for potential holiday here DateTime thisMonthExpiry = FindDay(findYear, findMonth, DayOfWeek.Friday, 3); // Use the 3rd Friday of the current month to seed the function to return the next 4 ex-dividends expiries adjusted for holidays Dictionary<int, DateTime> expiries = GetOptionExpiries(thisSlice.Time, LD.exDivdnDate, thisMonthExpiry, true); // now assemble the SSQR matrix using the expiries dictionary and the contracts lists AssembleSSQRMatrix(algo, ref LD, expiries); /*foreach (SSQRColumn ssqrC in passedMatrix) /// loop through the SSQRMatris to update the deltas and open interest { ssqrPutSymbol = ssqrC.putSymbol; ssqrCallSymbol = ssqrC.callSymbol; if (thisSlice.OptionChains.TryGetValue(ssqrPutSymbol, out ssqrPutChain)) { Debug(" HEY THE ssqrPutChain count is " + ssqrPutChain + " AT " + thisSlice.Time + " in FROM COLLARS."); } else { Debug(" HEY NO OPTIONS IN THIS SLICE in FROM COLLARS" + thisSlice.Time); } if (thisSlice.OptionChains.TryGetValue(ssqrCallSymbol, out ssqrCallChain)) { // Moved this code to Main.cs *** ssqrCallChain will not be included in the same Slice // where the options contracts are added. } } */ // Get the SSQRColumn with the best reward to risk if (LD.SSQRMatrix.Count == 0) return bestTradableColumn; /// found it's possible to have no SSQRs, if so, pass the empty/null SSQRColumn to calling routine var qualifyingCollars = LD.SSQRMatrix.Where(s=>s.putPremium!=0 & s.putPremium<=s.callPremium).Count(); if (qualifyingCollars == 0) return bestTradableColumn; // bestTradableColumn = passedMatrix.OrderByDescending(p => p.CCOR).FirstOrDefault(); bestTradableColumn = LD.SSQRMatrix.OrderBy(bTC => bTC.CCOR).FirstOrDefault(); /// 2021-03-21 -- changed from OrderedByDescending ..... using downsideRisk/upsidePotential return bestTradableColumn; } } }
using QuantConnect.Securities.Option; using Newtonsoft.Json; namespace QuantConnect.Algorithm.CSharp { public partial class CollarAlgorithm : QCAlgorithm { public class optGrksRec { //algo.Debug(thisContract.Symbol.Value + ", " + thisContract.BidPrice + ", " + thisContract.AskPrice + ", " + thisContract.LastPrice + ", " + //thisContract.OpenInterest + ", "+ testVol + ", " + thisContract.TheoreticalPrice + ", " + thisContract.Greeks.Delta + ", " + thisContract.ImpliedVolatility); // "Gamma: " + thisContract.Greeks.Gamma + "Vega: " + thisContract.Greeks.Vega + "Rho: " + thisContract.Greeks.Rho + "Theta: " + thisContract.Greeks.Theta / 365 +4 public string uSymbol; // Underlying Symbol public string BidPrice; // Bid Price public string AskPrice; // Ask Price public string LastPrice; // Last Price public string OpenInterest; // Open Interest public string TheoreticalPrice; // Theoretical Price public string Delta; // Delta public string ImpliedVolatility; // Implied Vol public string Gamma; // Gamma public string Vega; // Vega public string Rho; // Rho public string Theta; // Theta public string ToJson() { string json = JsonConvert.SerializeObject(this, Formatting.Indented); return json; } } public class TradePerfRec { public Symbol uSymbol; // 1 Underlying Symbol public int index; // 2 Index to trace the trade and all offspring P&L public bool isOpen = false; // 3 Is the trade ongoing (open)? public bool isInitializer = false; // 4 Is this the collar-initializing trade public bool isSecondary = false; // 5 Is this a put roll up public bool isTheta = false; // 6 Is this a solely-call TPR public int tradeRecCount; // 7 counter for trade records -- use in the single-stock use case public DateTime startDate; // 8 starting date for collar public DateTime endDate; // 9 ending date for the collar public string strtngCndtn; // 10 for 2nd TPRs, record the starting conditions public string reasonForClose; // 11 reason why collar was killed (ITM options roll, etc.) public DateTime expDate; // 12 expiration date for collar public DateTime thetaExpiration; // 13 expiration date for the short call public Symbol pSymbol; // 14 Put Symbol public Symbol cSymbol; // 15 Call Symbol public Symbol wcSymbol; // 16 Wing Call Symbol public decimal pStrike; // 17 put strike public decimal cStrike; // 18 call strike public decimal wcStrike; // 19 ATM Call Strike public decimal pDelta; // 20 put Delta public decimal cDelta; // 21 call Delta public decimal wcDelta; // 22 atm Call Delta public decimal pGamma; // 23 put Gamma public decimal cGamma; // 24 call Gamma public decimal wcGamma; // 25 atm Call Gamma public int uQty; // 26 number of underlying shares public int pQty; // 27 number of put contracts public int cQty; // 28 number of call contracts public int wcQty; // 29 number of wing call contracts public decimal uStartPrice; // 30 Underlying Price when trade put on public decimal pStartPrice; // 31 Put Price when trade put on public decimal cStartPrice; // 32 Call Price when trade put on public decimal wcStartPrice; // 33 ATM Call Price when trade put on public decimal uEndPrice; // 34 Underlying Price when trade taken off public decimal pEndPrice; // 35 Put Price when trade taken off public decimal cEndPrice; // 36 Call Price when trade taken off public decimal wcEndPrice; // 37 ATM Call Price when trade taken off public int numDividends; // 38 # of dividends collected during the trade public decimal divIncome; // 39 $'s collected in Dividend income during the trade public decimal betaValue; // 40 beta value of underlying when trade put on public decimal RORThresh; // 41 Threshold for ROR public decimal ROCThresh; // 42 Threshold for ROC public decimal CCORThresh; // 43 Threshold for CCOR public string tradeCriteria; // 44 ROR or ROC or CCOR public decimal ROR; // 45 ROR calculation from SSQR Matrix public decimal ROC; // 46 ROC calculation from SSQR Matrix public decimal CCOR; // 47 CCOR calculation from SSQR Matrix public decimal stockADX; // 48 Average Directional Index Value public decimal stockADXR; // 49 Average Directional Index Rating public decimal stockOBV; // 50 On Balance Volume public decimal stockAD; // 51 Accumulation/Distribution public decimal stockADOSC; // 52 Accumulation/Distribution Oscillator public decimal stockSTO; // 53 Stochastic value public decimal stockVariance; // 54 Variance of underlying stock public decimal currSellPnL; // 55.. Rolltime evaluation of PnL if selling public decimal currExrcsPutPnL; // 56.. Rolltime evaluation of PnL if exercising put public decimal currExrcsCallPnL; // 57.. Rolltime evaluation of PnL if calls are assigned public decimal grossPnL; // 58 runtime calculation of PnL at close; public decimal SSQRnetProfit; // 59 runtime calculation of replacement bestSSQR net Profit // **** put class methods here to use collection of TradePerfRecs as basis to examine positions for expirations and assignments public bool CheckRolling(CollarAlgorithm algo, ref LookupData LUD) { Slice slc = algo.CurrentSlice; Symbol symbUndr = LUD.uSymbol; string strTckr = symbUndr.Value; decimal stkPrc = slc[symbUndr].Price; LUD.dtTst = slc.Time; LUD.GetNextExDate(algo); this.GetPnLs(algo, ref LUD, ref stkPrc); int daysRemainingDiv = LUD.exDivdnDate.Subtract(slc.Time).Days; if (daysRemainingDiv < 4 && daysRemainingDiv > 0) { LUD.SSQRMatrix.Clear(); if (this.CheckDivRoll(algo, ref LUD, ref daysRemainingDiv)) return true; } LUD.daysRemainingC = this.cSymbol.ID.Date.Subtract(LUD.dtTst).Days; LUD.daysRemainingP = this.pSymbol.ID.Date.Subtract(LUD.dtTst).Days; if (((stkPrc - this.cStrike)/stkPrc >= .05M && LUD.daysRemainingC <= 10 && LUD.daysRemainingC > 1) || ((stkPrc - this.cStrike) > 0 && LUD.daysRemainingC <= 1)) { LUD.SSQRMatrix.Clear(); if (this.CheckCallRoll(algo, ref LUD)) return true; } if (( (this.pStrike - stkPrc )/stkPrc >= .05M && LUD.daysRemainingP <= 10 && LUD.daysRemainingP > 1) || ( (this.pStrike > stkPrc) && LUD.daysRemainingP <= 1) ) { LUD.SSQRMatrix.Clear(); if (this.CheckPutRoll(algo, ref LUD)) return true; } if ((LUD.daysRemainingC <= 1 && stkPrc <= this.cStrike) | (LUD.daysRemainingP <= 1 && stkPrc >= this.pStrike)) // this is the put expiration by design. the puts always control the collar and the risk { LUD.SSQRMatrix.Clear(); if (CheckOTMRoll(algo, ref LUD) ) return true; } return false; } private void GetPnLs(CollarAlgorithm algo, ref LookupData LUD, ref decimal stockPrice) { decimal currPutPrice = algo.Securities[this.pSymbol].BidPrice; decimal currCallPrice = algo.Securities[this.cSymbol].AskPrice; this.currSellPnL = (this.uQty*(stockPrice-this.uStartPrice)) + (100*this.pQty*(currPutPrice - this.pStartPrice)) + (-100*this.cQty*(this.cStartPrice - currCallPrice)) + (100*this.wcQty*(this.wcEndPrice - this.wcStartPrice)); this.currExrcsPutPnL = (this.uQty*(this.pStrike-this.uStartPrice)) + (100*this.pQty*(0 - this.pStartPrice)) + (-100*this.cQty*(this.cStartPrice - currCallPrice)) + (100*this.wcQty*(this.wcEndPrice - this.wcStartPrice)); this.currExrcsCallPnL = (this.uQty*(this.cStrike-this.uStartPrice)) + (100*this.pQty*(currPutPrice - this.pStartPrice)) + (-100*this.cQty*(this.cStartPrice - 0)) + (100*this.wcQty*(this.wcEndPrice - this.wcStartPrice)); } //************************************************************************************************* //************** CheckDividendRoll ******************************************************* //************************************************************************************************* private bool CheckDivRoll(CollarAlgorithm algo, ref LookupData LUD, ref int daysRemaining) { bool isRolled = false; string strCorrSpndngPut = this.GetCorrspndngPut(); decimal decCrrSpndgPutPrice = algo.Securities[strCorrSpndngPut].AskPrice; Slice slc = algo.CurrentSlice; if (decCrrSpndgPutPrice < LUD.divdndAmt) { if (LUD.doTracing) algo.Debug(" ************** BEGIN APPROACHMENT CALC FOR " + this.uSymbol + " priced @" + algo.Securities[this.uSymbol].Price ); if (LUD.doTracing) algo.Debug(" ************** EX-Date: " + LUD.exDivdnDate.ToString() ); if (LUD.doTracing) algo.Debug(" ************** DIVIDEND " + LUD.divdndAmt.ToString() + " Extrinsic Value: " + decCrrSpndgPutPrice.ToString() ); //bestSSQRColumn = GetBestSSQR(data, LUD.uSymbol, nextExDate); // this is the normal route of non-delta execution SSQRColumn bestSSQRColumn = new SSQRColumn(); bestSSQRColumn = algo.GetBestCollar(algo, ref LUD); if (bestSSQRColumn == null || bestSSQRColumn.IsEmpty()) { if (daysRemaining <= 1) // Risk of Dividend Assignment too high at Ex-Dividend Date so if haven't been able to get at RollTheCollar, kill it here { if (LUD.doTracing) algo.Debug(" OOOOOOOOOOOO NO bestSSQR ON LAST DAY OF DIVIDEND-FORCED EXERCISE -- KILL THE COLLAR OOOOOOOOOO"); isRolled = algo.KillTheCollar(this, ref LUD, "NO bestSSQR ON LAST DAY OF DIVIDEND-APPROACHMENT -- KILL" ); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug("************** END APPROACHMENT PROCESSING ******************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; // Don't execute further processing in this slice if rolled due to dividend approachment } else { if (LUD.doTracing) algo.Debug("************** END DIV APPROACHMENT PROCESSING -- NULL bestSSQR -- TRY AGAIN ******************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; // Exit CheckDivRoll if there's no SSQR Column to process but don't move onto CallExpiryEvaluation for this reason } } if (!bestSSQRColumn.IsEmpty() ) { //TimeSpan expireDateDeltaSSQR = bestSSQRColumn.putExpiry.Subtract(slD.Time); //goodThresh = (bestSSQRColumn.CCOR >= CCORThresh); bool goodThresh = true; if (goodThresh) // roll the position forward { //newRollDate = slD.Time.Date; // don't do the roll if one has just been done -- // sometimes ex-dividend dates are within 10 days of options expiration and a roll has already been done decimal stockPrice = algo.Securities[this.uSymbol].Price; TimeSpan expireDateDeltaSSQR = bestSSQRColumn.putExpiry.Subtract(slc.Time); if ((bestSSQRColumn.callStrike < stockPrice) && expireDateDeltaSSQR.Days <= 10 ) // make sure that the collar won't be assigned because we're in the options danger zone { /////// THIS SHOULD NOT HAPPEN IN v17 AND BEYOND BECAUSE LINQ WAS AMENDED TO PREVENT THESE OPTIONS if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ DIVIDEND EXERCISE ROLL ABORT -- CALL PREVENTION @@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@ CALL ASK: " + algo.Securities[this.cSymbol].AskPrice + " Strike: " + bestSSQRColumn.callStrike + " Stock Price: " + algo.Securities[this.uSymbol].Price +" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug("-"); if (LUD.doTracing) algo.Debug("************** END APPROACHMENT PROCESSING ******************"); if (LUD.doTracing) algo.Debug("-"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); // DO NOT KILL THE COLLAR HERE. return isRolled; // Exit CheckDivRoll if there's no SSQR Column to process but don't move onto CallExpiryEvaluation for this reason } if (LUD.doTracing) algo.Debug(" ************** BEGIN DIV APPROACHMENT ROLL ****************"); //iterate potetialCollars here solely when executing a trade if (this.currSellPnL > 0 | this.uQty * bestSSQRColumn.netIncome > Math.Abs(this.currSellPnL)) { // Roll solely if we can sell the current collar profitably bool didTheTrade = algo.RollTheCollar(algo, ref LUD, this, "DIVIDEND APPROACHMENT ROLL"); if (didTheTrade) { isRolled = true; //oldRollDate = slc.Time.Date; // set the oldRollDate to Date of Roll if (LUD.doTracing) algo.Debug(" ************** SUCCESSFUL DIV APPROACHMENT ROLL WITH SSQR: "); var orderedSSQRMatrix = LUD.SSQRMatrix.OrderByDescending(p => p.CCOR); algo.IterateOrderedSSQRMatrix(orderedSSQRMatrix); //didTheTrade = false; } else if (daysRemaining <= 1) // Risk of Dividend Assignment too high at Ex-Dividend Date so if haven't been able to get at RollTheCollar, kill it here { isRolled = algo.KillTheCollar(this, ref LUD, "KILL- FAILED ROLL 1ST TPR IN DIVIDEND-FORCED EXERCISE ON LAST DAY" ); // KillTheCollar may return to try again as well } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); return isRolled; } else { algo.Debug(" 00 Some code"); if (daysRemaining <= 1) // Risk of Dividend Assignment too high at Ex-Dividend Date so if haven't been able to get at RollTheCollar, kill it here { isRolled = algo.KillTheCollar(this, ref LUD, "KILL- LOSS ON 1ST TPR IN DIVIDEND-FORCED EXERCISE ON LAST DAY" ); // KillTheCollar may return to try again as well } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug("************** END APPROACHMENT PROCESSING ******************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; // Don't execute further processing in this slice if rolled due to dividend approachment } if (LUD.doTracing) algo.Debug(" ************** END DIV APPROACHMENT ROLL ****************"); if (LUD.doTracing) algo.Debug("-"); if (LUD.doTracing) algo.Debug("************** END DIV APPROACHMENT PROCESSING ******************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; // get out of this Slice // prevent immediate call assignment } else { // NOT goodThresh --- kill the collar if (daysRemaining <= 1) // Risk of Dividend Assignment too high at Ex-Dividend Date so if haven't been able to get at RollTheCollar, kill it here { if (LUD.doTracing) algo.Debug(" OOOOOOOOOOOO BAD THRESH ON DIVIDEND-FORCED EXERCISE -- KILL THE COLLAR ON LAST DAY OOOOOOOOOO"); isRolled = algo.KillTheCollar(this, ref LUD, "KILL- LAST DAY BAD THRESH ON DIVIDEND-FORCED EXERCISE" ); // KillTheCollar may return to try again as well LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug("************** END APPROACHMENT PROCESSING ******************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } else { if (LUD.doTracing) algo.Debug(" OOOOOOOOOOOO BAD THRESH ON DIVIDEND-FORCED EXERCISE -- RETURN AND TRY AGAIN"); } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug("************** END APPROACHMENT PROCESSING ******************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; // Don't execute further processing in this slice if rolled due to dividend approachment } // not goodThresh return isRolled; } // !bestSSQRColumn /// there was no bestSSQRColumn } /// *** decCrrSpndgPutPrice > LUD.divdndAmt return isRolled; } //************************************************************************************************* //************** CheckCallRoll ******************************************************* //************************************************************************************************* public bool CheckCallRoll (CollarAlgorithm algo, ref LookupData LUD) { // Determine if it should be rolled forward. bool isRolled = false; Slice slD = algo.CurrentSlice; if (LUD.doTracing) algo.Debug(" ************** BEGIN ITM CALL CALC FOR {LUD.uSymbol} ****************"); //bestSSQRColumn = GetBestSSQR(data, LUD.uSymbol, nextExDate); SSQRColumn bestSSQRColumn = algo.GetBestCollar(algo, ref LUD); if (LUD.SSQRMatrix.Count == 0) { if (LUD.daysRemainingC <= 1) { // if at the last day of call expiration and haven't yet rolled, kill the collar. if (LUD.doTracing) algo.Debug($" ********* END ITM CALL FORCED ASSIGNMENT PROCESSING FOR {LUD.uSymbol} -- NO POTENTIAL COLLARS ON LAST DAY *************"); isRolled = algo.KillTheCollar(this, ref LUD, "KILL ITM CALL ASSIGNMENT -- NO POTENTIAL COLLARS ON LAST DAY"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" OOOOOOOOO TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug("-----"); } algo.Debug($" ************** END ITM CALL CALC PROCESSING FOR {LUD.uSymbol} -- NO MATRICES ***"); return isRolled; // if no collars then return and loop around again } if (bestSSQRColumn == null || bestSSQRColumn.IsEmpty() ) { if (LUD.daysRemainingC <= 1) { // if at the last day of call expiration and haven't yet rolled, kill the collar. if (LUD.doTracing) algo.Debug($" ********* END ITM CALL FORCED ASSIGNMENT PROCESSING FOR {LUD.uSymbol} -- bestSSQR null or empty ON LAST DAY"); algo.KillTheCollar(this, ref LUD, "KILL ITM CALL ASSIGNMENT -- EMPTY BEST COLLAR ON LAST DAY"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug("-"); } else { if (LUD.doTracing) algo.Debug($" ************** END ITM CALL CALC FOR {LUD.uSymbol} -- null bestSSQRColumn *************"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); } return isRolled; // return and exit OnData() } bool goodThresh = bestSSQRColumn.CCOR >= CCORThresh; if (goodThresh) // roll the position forward { if (LUD.doTracing) algo.Debug($" ************** BEGIN ITM CALL ROLL FOR {LUD.uSymbol} ****************"); decimal stockPrice = algo.Securities[bestSSQRColumn.uSymbol].Price; // check to make sure we don't roll into a collar that will be exercised // SHOULD NOT EXECUTE IN v17+ BECAUSE LINQ MODIDFIED TO PREVENT SUCH OPTIONS if (algo.Securities[bestSSQRColumn.callSymbol].AskPrice + bestSSQRColumn.callStrike < stockPrice) // make sure that no one can buy the option for less than the stock { if (LUD.doTracing) algo.Debug($" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ABORT ITM CALL ROLL TO PREVENT EXERCISE FOR {LUD.uSymbol} @@@@@@@@@@@"); if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@ CALL ASK: " + algo.Securities[bestSSQRColumn.callSymbol].AskPrice + " Strike: " + bestSSQRColumn.callStrike + " Stock Price: " + stockPrice +" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug("-"); if (LUD.daysRemainingC <= 1) // Risk of Dividend Assignment too high at Ex-Dividend Date so if haven't been able to get at RollTheCollar, kill it here { algo.KillTheCollar(this, ref LUD, "ABORT ITM CALL ROLL TO PREVENT EXERCISE ON LAST DAY" ); // KillTheCollar may return to try again as well } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug($" ------------------------------------------------ "); return isRolled; } if (algo.symbolDataBySymbol[LUD.uSymbol].isRollable == true && (this.currSellPnL > 0 | this.uQty * bestSSQRColumn.netIncome > Math.Abs(this.currSellPnL))) // only roll the collar if the current record may be closed profitably-- otherwise seek exercise in kill //if (currSellPnL > 0 ) { /// Roll the Collar if the bestSSQRColumn won't be subsequently exercised. if (algo.RollTheCollar(algo, ref LUD, this, "ROLL--ITM CALL EXPIRATION APPROACHMENT")) { if (LUD.doTracing) algo.Debug($" ************** ROLLED ITM CALLS COMPLETED FOR {LUD.uSymbol}*************"); var orderedSSQRMatrix = LUD.SSQRMatrix.OrderBy(p => p.CCOR); algo.IterateOrderedSSQRMatrix(orderedSSQRMatrix); //didTheTrade = false; } else if (LUD.daysRemainingC <= 1) { if (LUD.doTracing) algo.Debug($" ************** UNSUCCESSFUL ROLL FOR {LUD.uSymbol} -- KILL ITM PUT COLLAR ON LAST DAY **************"); algo.KillTheCollar(this, ref LUD, "KILL- LOSS IN 1st TPR IN ITM CALL ROLL" ); // Goto KillTheCollar and determine whether to close or allow call assignment there LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug($" ------------------------------------------------ "); } } else if (LUD.daysRemainingC <= 1) { algo.Debug($" ************** UNPROFITABLE ROLL FOR {LUD.uSymbol} -- KILL ITM PUT COLLAR ON LAST DAY **************"); algo.KillTheCollar(this, ref LUD, "KILL- LOSS IN 1st TPR IN ITM CALL ROLL" ); // Goto KillTheCollar and determine whether to close or allow call assignment there LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug($" ------------------------------------------------ "); return isRolled; } } else // If not goodThresh, but expireDateDelta<=1, may get assigned on ITM calls { // This programmatic flow allows days expireDateDelta -9 through -2 to be evaluated sequentially // because stock price fluctuations may trigger assignment in that date range. But on the last day // and the call is ITM, assignment will probably happen. If goodThresh above, RollTheCollar was called // Put options should expire without value but sell them and capture whatever value possible // exercise the calls here while puts may be sold for some value, even a penny. <4¢ can be sold for 0 commission // capture the ending prices and close the TradePerformanceRecord by removing the old instance and inserting the updated copy if (LUD.doTracing) algo.Debug($" ************** END ITM CALL FORCED ASSIGNMENT PROCESSING FOR {LUD.uSymbol}-- BAD THRESH ****************"); if (LUD.daysRemainingC <= 1) { if (LUD.doTracing) algo.Debug($" ************** KILL COLLAR IN ITM CALL FORCED ASSIGNMENT PROCESSING FOR {LUD.uSymbol} -- BAD THRESH ON LAST DAY"); algo.KillTheCollar(this, ref LUD, "KILL ITM CALL -- PREVENT ASSIGNMENT"); } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug($" ------------------------------------------------ "); return isRolled; // exit OnData() and loop around again until last day. May get assigned! //ExerciseOption(shortedCallSymbol, Decimal.ToInt32(this.cQty)); // LEAN error, cannot exercise short options } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT CALL ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug($" ------------------------------------------------ "); return false; // endif ITM calls -10 -> Expiry. Probably do an elseif {ITM puts here to definitively trap all assignments } // end CheckCallRoll function //************************************************************************************************* //************** CheckPutRoll ******************************************************* //************************************************************************************************* public bool CheckPutRoll (CollarAlgorithm algo , ref LookupData LUD) { bool isRolled = false; // Determine if it should be rolled forward. if (LUD.doTracing) algo.Debug($" ************** BEGIN ITM PUT CALC FOR {LUD.uSymbol} ****************"); Slice slD = algo.CurrentSlice; decimal stockPrice = algo.Securities[LUD.uSymbol].Price; //bestSSQRColumn = GetBestSSQR(data, LUD.uSymbol, nextExDate); SSQRColumn bestSSQRColumn = algo.GetBestCollar(algo, ref LUD); if (LUD.SSQRMatrix.Count == 0) { if (LUD.daysRemainingP <= 1) { if (LUD.doTracing) algo.Debug($" ********* END ITM PUT FORCED ASSIGNMENT PROCESSING FOR {LUD.uSymbol} -- NO POTENTIAL COLLARS ON LAST DAY *************"); isRolled = algo.KillTheCollar(this, ref LUD, "KILL ITM PUT ASSIGNMENT -- NO POTENTIAL COLLARS ON LAST DAY"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT PUT ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug("-----"); } algo.Debug($" ************** END ITM PUT CALC FOR {LUD.uSymbol} -- NO POTCOLS ***"); return isRolled; // if no collars then return and loop around again } if (bestSSQRColumn == null || bestSSQRColumn.IsEmpty() ) { if (LUD.daysRemainingP <= 1) { // if at the last day of put expiration and haven't yet rolled, kill the collar. if (LUD.doTracing) algo.Debug($" ********* KILL 1st TPR ON LAST DAY OF ITM PUT PROCESSING FOR {LUD.uSymbol} *************"); isRolled = algo.KillTheCollar(this, ref LUD, "KILL ITM PUT ASSIGNMENT -- EMPTY BEST COLLARS ON LAST DAY"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT PUT ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug("--------"); } else { if (LUD.doTracing) algo.Debug($" ********* END ITM PUT FORCED ASSIGNMENT PROCESSING FOR {LUD.uSymbol} -- bestSSQR null or empty LOOPING TO TRY AGAIN"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); return isRolled; // loop around and try again } } Symbol tradablePut = bestSSQRColumn.putSymbol; Symbol tradableCall = bestSSQRColumn.callSymbol; decimal fTPRPutPrice = algo.Securities[tradablePut].BidPrice; // determine if the loss on the put leg is greater than the intial "real potential loss". If it is, exercise the position /*if ((this.pStartPrice - fTPRPutPrice) > (this.uStartPrice + this.pStartPrice - this.cStartPrice) ) { if (LUD.doTracing) algo.Debug(" TT ITM PUT EXPIRATION -- FORCE PUT ASSIGNMENT CHEAPER OOOOOOOOOOO"); // EXERCISE THE PUT removing PUTs and STOCK. Buy back calls in OnOrder() var closeCallTicket = MarketOrder(shortedCallSymbol, -this.cQty); if (closeCallTicket.Status == OrderStatus.Filled) { this.cEndPrice = closeCallTicket.AverageFillPrice; } var putExerciseTicket = ExerciseOption(longPutSymbol, this.pQty); potentialCollars.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug(" ************** END ITM PUT CALC -- EXERCISED PUTS ******"); return isRolled; } */ bool goodThresh = bestSSQRColumn.CCOR >= CCORThresh; if (goodThresh) // roll the position forward { // check bestSSQRColumn to make sure we don't roll into a collar that will be subsequently exercised // this was fixed in v17+ by adding condition to .where() of LINQ to prevent such options from being returned if (algo.Securities[tradableCall].AskPrice + bestSSQRColumn.callStrike < stockPrice) // make sure that no one can buy the option for less than the stock { if (LUD.doTracing) algo.Debug($" @@@@@@@@@@@@@@@@@@@ ITM PUT ROLL ABORT FOR {LUD.uSymbol} -- IMMEDIATE CALL-EXERCISE PREVENTION FADE @@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@ CALL ASK: " + algo.Securities[tradableCall].AskPrice + " Strike: " + bestSSQRColumn.callStrike + " Stock Price: " + stockPrice +" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); if (LUD.doTracing) algo.Debug("------"); if (LUD.daysRemainingP <= 1) { isRolled = algo.KillTheCollar(this, ref LUD, "ABORT ITM PUT ROLL TO PREVENT SUBSEQUENT CALL ASSIGNMENT"); } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); return isRolled; } if (LUD.doTracing) algo.Debug($" ************** BEGIN ITM PUT ROLL FOR {LUD.uSymbol} ****************"); //if (!newRollDate.Equals(oldRollDate)) { if (algo.symbolDataBySymbol[LUD.uSymbol].isRollable == true && (this.currSellPnL > 0 | this.uQty * bestSSQRColumn.netIncome > Math.Abs(this.currSellPnL))) { // Roll solely if we can sell the current collar profitably //if (currSellPnL > 0 ) { // Roll solely if we can sell the current collar profitably if (algo.RollTheCollar(algo, ref LUD, this, "ROLL -- ITM PUT NEAR EXPIRATION")) { isRolled = true; if (LUD.doTracing) algo.Debug($" ************** ROLLED ITM PUTS COMPLETED FOR {LUD.uSymbol} ****************"); var orderedSSQRMatrix = LUD.SSQRMatrix.OrderBy(p => p.CCOR); // 2021-03-21 -- changed from OrderedByDescending algo.IterateOrderedSSQRMatrix(orderedSSQRMatrix); //didTheTrade = false; } else { if (LUD.daysRemainingP <= 1) { isRolled = algo.KillTheCollar(this, ref LUD, "ITM PUT ROLL FAILED"); } } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); } else { // un profitable roll if (LUD.daysRemainingP <= 1) { if (LUD.doTracing) algo.Debug($" ************** UNPROFITABLE ITM PUT ROLL FOR {LUD.uSymbol} ON LAST DAY -- ATTEMPT KILL"); isRolled = algo.KillTheCollar(this, ref LUD, "KILL- LOSS IN 1st TPR IN ITM PUT ROLL" ); } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" TT END CHECK IMPLICIT PUT ASSIGNMENT FOR {LUD.uSymbol} OOOOOOOOO"); if (LUD.doTracing) algo.Debug("-----"); } return isRolled; // exit OnData and try again until last day } else { // bad threshhold on ITM PUT ROLL -- EXERCISE IT if (LUD.daysRemainingP <= 1) { if (LUD.doTracing) algo.Debug($" ************** BAD SSQR THRESHOLD IN ITM PUT ROLL FOR {LUD.uSymbol} ON LAST DAY -- ATTEMPT KILL"); isRolled = algo.KillTheCollar(this, ref LUD, "KILL ON LAST DAY OF ITM PUT "); } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END ITM PUT CALC FOR {LUD.uSymbol} ****************"); if (LUD.doTracing) algo.Debug("---------"); return isRolled; // roll around and try again } return isRolled; } // end CheckPutRoll //************************************************************************************************* //************** CheckOTMRoll ******************************************************* //************************************************************************************************* public bool CheckOTMRoll(CollarAlgorithm algo , ref LookupData LUD) { bool isRolled = false; // risk of options expiration WITHOUT EXERCISE if (LUD.doTracing) algo.Debug($" ************** BEGIN OTM OPTIONS CALC FOR {LUD.uSymbol} ****************"); Slice slD = algo.CurrentSlice; decimal stockPrice = algo.Securities[LUD.uSymbol].Price; //bestSSQRColumn = GetBestSSQR(data, LUD.uSymbol, nextExDate); SSQRColumn bestSSQRColumn = algo.GetBestCollar(algo, ref LUD); if (LUD.haltProcessing) { algo.Debug(" Logging OTM OPTIONS CALC "); } if (LUD.SSQRMatrix.Count == 0) { if (LUD.daysRemainingC <= 1 | LUD.daysRemainingP <= 1) { isRolled = algo.KillTheCollar(this, ref LUD, "ABORT OTM ROLL -- NO POT COLLARS FOR " + LUD.uSymbol ); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS KILL FOR {LUD.uSymbol} ****************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } else { LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); algo.Debug($" ************** END OTM OPTIONS CALC -- NO POTCOLS FOR {LUD.uSymbol} -- LOOP AND TRY AGAIN LATER ***"); return isRolled; // if no collars then return and loop around again } } if (bestSSQRColumn == null || bestSSQRColumn.IsEmpty()) { if (LUD.doTracing) algo.Debug($" ************** null bestSSQRColumn in OTM Expiry Approachment FOR {LUD.uSymbol} *************"); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS CALC FOR {LUD.uSymbol} ****************"); if (LUD.daysRemainingC <= 1 | LUD.daysRemainingP <= 1) { isRolled = algo.KillTheCollar(this, ref LUD, "END OTM PROCESSING -- NO VIABLE SSQRS FOR " + LUD.uSymbol ); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS KILL FOR {LUD.uSymbol} LOOP AND TRY AGAIN LATER ****************"); if (LUD.doTracing) algo.Debug("-----"); return isRolled; } else { LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); algo.Debug($" ************** END OTM OPTIONS CALC FOR {LUD.uSymbol} -- bestSSQRColumn NULL or EMPTY ***"); return isRolled; // exit OnData() and loop around and try again } } // no bestSSQRColumn // IS IT NECESSARY TO SET THESE HERE Symbol tradablePut = bestSSQRColumn.putSymbol; Symbol tradableCall = bestSSQRColumn.callSymbol; //goodThresh = bestSSQRColumn.CCOR >= CCORThresh; bool goodThresh = true; if (goodThresh) // roll the position forward { if (LUD.doTracing) algo.Debug($" ************** BEGIN OTM OPTIONS ROLL FOR {LUD.uSymbol} ****************"); if (algo.symbolDataBySymbol[LUD.uSymbol].isRollable == true && (this.currSellPnL > 0 | this.uQty * bestSSQRColumn.netIncome > Math.Abs(this.currSellPnL))){ // only roll the collar if the current record may be closed profitably-- otherwise seek exercise in kill //if (currSellPnL > 0) { if (algo.RollTheCollar(algo, ref LUD, this, "OTM OPTIONS EXPIRATION ROLL")) { isRolled = true; if (LUD.doTracing) algo.Debug($" ************** ROLLED OTM OPTIONS FOR {LUD.uSymbol} COMPLETED WITH SSQR: ****************"); if (LUD.doTracing) algo.Debug("-"); var orderedSSQRMatrix = LUD.SSQRMatrix.OrderBy(p => p.CCOR); algo.IterateOrderedSSQRMatrix(orderedSSQRMatrix); //didTheTrade = false; LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END SUCCESSFUL OTM OPTIONS ROLL FOR {LUD.uSymbol} ****************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } else { if (LUD.daysRemainingC <= 1 | LUD.daysRemainingP <= 1) { if (LUD.doTracing) algo.Debug($" ************** KILLING OTM OPTIONS COLLAR FOR {LUD.uSymbol} ON LAST DAY - FAILED ROLL ****************"); isRolled = algo.KillTheCollar(this, ref LUD, "END OTM PROCESSING -- FAILED ROLL FOR " + LUD.uSymbol ); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS KILL FOR {LUD.uSymbol} ON LAST DAY - FAILED ROLL ****************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS ROLL FOR {LUD.uSymbol} -- FAILED ROLL ****************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } } else if (LUD.daysRemainingC <= 1 | LUD.daysRemainingP <= 1) { // CANNOT EXECUTE ROLL PROFITABLY SO KILL THE COLLAR IF ON LAST DAY isRolled = algo.KillTheCollar(this, ref LUD, "END OTM PROCESSING -- UNPROFITABLE ROLL FOR " + LUD.uSymbol + " ON THE LAST DAY" ); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS ROLL FOR {LUD.uSymbol} WITH KILL ****************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS ROLL PROCSSING FOR {LUD.uSymbol} ****************"); if (LUD.doTracing) algo.Debug("------------------------------------"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); return isRolled; } else if (LUD.daysRemainingC <= 1 | LUD.daysRemainingP <= 1) { // IF BADTHRESH if (LUD.doTracing) algo.Debug($" ************** BEGIN OTM OPTIONS COLLAR KILL FOR {LUD.uSymbol} ****************"); // kill the collar isRolled = algo.KillTheCollar(this, ref LUD, "BAD THRESH ON OTM OPTIONS ROLL"); LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS ROLL WITH KILL ON BAD THRESH FOR {LUD.uSymbol} ****************"); if (LUD.doTracing) algo.Debug("-------"); return isRolled; } // goodThresh on rolling OTM Options LUD.SSQRMatrix.Clear(); bestSSQRColumn = new SSQRColumn(); if (LUD.doTracing) algo.Debug($" ************** END OTM OPTIONS ROLL PROCESSING FOR {LUD.uSymbol} ****************"); if (LUD.doTracing) algo.Debug("-"); return isRolled; } /// END OTM OPTIONS ROLL public void CloseTPR() { this.isOpen = false; // effectively closes the tpr. called in looping through tprsToClose after processing them. } public void OpenTPR() { this.isOpen = true; // effectively opens the tpr. called in looping through tprsToOpen after processing them. } private string GetCorrspndngPut() { int indexOfC = this.cSymbol.ToString().LastIndexOf("C"); char[] charArrayC = this.cSymbol.ToString().ToCharArray(); char[] charArrayP = charArrayC; charArrayP[indexOfC] = 'P'; string putString = new string(charArrayP); return putString; } } /// ***** END CLASS TradePerformanceRecord public class OpenLimitOrder { public OrderTicket oTicket; // order ticket public TradePerfRec tpr; // Trade performance record for transaction public OptionRight oRight; // Option Right (OptionRight.Call or OptionRight.Put) public bool isWingCall = false; // is this oLO a Wing Call } public string ConvertTradePerfRec(List<TradePerfRec> tPR) { string tPRString = ""; string jasonString = ""; jasonString = "{"; tPRString = ",^^^"; foreach (var field in typeof(TradePerfRec).GetFields()) { tPRString = tPRString + ", " + field.Name; } Debug(tPRString); var tPREnum = tPR.GetEnumerator(); /////// NOTE: Have to get the JASON formatted correctly. Need one long string. CHECK THIS while (tPREnum.MoveNext()) { TradePerfRec thisPerfRec = tPREnum.Current; jasonString = "{"; tPRString = ",^^^"; tPRString = tPRString + ", " + thisPerfRec.uSymbol; tPRString = tPRString + ", " + thisPerfRec.index; tPRString = tPRString + ", " + thisPerfRec.isOpen; tPRString = tPRString + ", " + thisPerfRec.isInitializer; tPRString = tPRString + ", " + thisPerfRec.isSecondary; tPRString = tPRString + ", " + thisPerfRec.isTheta; tPRString = tPRString + ", " + thisPerfRec.tradeRecCount; tPRString = tPRString + ", " + String.Format("{0:MM/dd/yy H:mm:ss}", thisPerfRec.startDate); tPRString = tPRString + ", " + String.Format("{0:MM/dd/yy H:mm:ss}", thisPerfRec.endDate); tPRString = tPRString + ", " + thisPerfRec.strtngCndtn; tPRString = tPRString + ", " + thisPerfRec.reasonForClose; tPRString = tPRString + ", " + String.Format("{0:MM/dd/yy H:mm:ss}", thisPerfRec.expDate); tPRString = tPRString + ", " + String.Format("{0:MM/dd/yy H:mm:ss}", thisPerfRec.thetaExpiration); tPRString = tPRString + ", " + thisPerfRec.pSymbol.Value; tPRString = tPRString + ", " + thisPerfRec.cSymbol.Value; tPRString = tPRString + ", " + thisPerfRec.wcSymbol.Value; tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.pStrike); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.cStrike); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.wcStrike); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.pDelta); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.cDelta); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.wcDelta); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.pGamma); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.cGamma); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.wcGamma); tPRString = tPRString + ", " + thisPerfRec.uQty; tPRString = tPRString + ", " + thisPerfRec.pQty; tPRString = tPRString + ", " + thisPerfRec.cQty; tPRString = tPRString + ", " + thisPerfRec.wcQty; tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.uStartPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.pStartPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.cStartPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.wcStartPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.uEndPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.pEndPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.cEndPrice); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.wcEndPrice); tPRString = tPRString + ", " + thisPerfRec.numDividends; tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.divIncome); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.betaValue); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.RORThresh); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.ROCThresh); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.CCORThresh); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.tradeCriteria); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.ROR); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.ROC); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.CCOR); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockADX); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockADXR); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockOBV); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockAD); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockADOSC); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockSTO); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.stockVariance); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.grossPnL); tPRString = tPRString + ", " + String.Format("{0:0.00}", thisPerfRec.SSQRnetProfit); /*foreach (var field in typeof(TradePerfRec).GetFields()) { if (field is decimal) { //tPRString = tPRString + "," + String.Format("{0:0.00}", field.GetValue(thisPerfRec)); tPRString = tPRString + "," + String.Format("{0:0.00}", field.GetValue(thisPerfRec)); } else if (field is int) { tPRString = tPRString + "," + String.Format("{0}", field.GetValue(thisPerfRec)); } else if (field is DateTime) { tPRString = tPRString + "," + String.Format("{0:MM/dd/yy H:mm:ss}", field.GetValue(thisPerfRec)); } else if (field is bool) { tPRString = tPRString + ", " + field.GetValue(thisPerfRec); } else { //Console.WriteLine("{0} = {1}", field.Name, field.GetValue(thisPerfRec)); tPRString = tPRString + ", " + field.GetValue(thisPerfRec).ToString(); } jasonString = jasonString + "\"" + field.Name + "\":\"" + field.GetValue(thisPerfRec) + "\""; } ^/ /*foreach (var field in typeof(TradePerfRec).GetFields()) { if (field.GetType() == typeof(decimal)) { //tPRString = tPRString + "," + String.Format("{0:0.00}", field.GetValue(thisPerfRec)); tPRString = tPRString + "," + String.Format("{0:0.00}", field); } else if (field.GetType() == typeof(DateTime)) { tPRString = tPRString + "," + String.Format("{0:MM/dd/yy H:mm:ss}", field.GetValue(thisPerfRec)); } else if (field.GetType() == typeof(Symbol)) { tPRString = tPRString + ", " + field; } else { //Console.WriteLine("{0} = {1}", field.Name, field.GetValue(thisPerfRec)); tPRString = tPRString + ", " + field.GetValue(thisPerfRec); } jasonString = jasonString + "\"" + field.Name + "\":\"" + field.GetValue(thisPerfRec) + "\""; } */ jasonString = jasonString + "}," + Environment.NewLine; Debug(tPRString); } return jasonString; } } }