Stocks with Non-1-Cent Tick Values (Tick Size Pilot Program)

Dave B.

#1

10/31/2016 5:30 PM

Eugene, Cone:

In my backtesting, I have run into a new issue (for me) that I would like to hear your general thoughts on.

My understanding is that the SEC has begun testing a new program where certain (and I don’t know their selection criteria) reasonable size stocks now trade with a “tick” value larger than $0.01 (1 cent), usually $0.05 (5 cents). I believe they phrased this as an experiment, which I take to mean that the selected symbols can change and the tick values could also change.

Some example Nasdaq symbols: ABCB, AGII, AMSF, BANF, BNCL, BNCN, CBF, ESGR, FFBC, FIBK, FULT, IBKC, INDB, IPCC, KRNY, MHLD, NAVG, OPB, PRAA, SAFT, SFNC, SIGI, TCBI, TOWN, UBSI, WAFD, WSFS.

I realize this would not affect market orders, but obviously would affect Limit and Stop orders (any order with a stated price). I searched the forums and could not find a specific reference to this issue, but if I missed it, I apologize.

Questions:
• Does this imply Wealth-Lab (and potentially many other backtesters), at present, do not handle this situation correctly?
• Can Wealth-Lab automatically gather this information from Fidelity, a broker (IB has this information available), or other information source and assign non-1-cent tick values to stocks as part of normal data collection and build a stock symbol table with this information?
• Would this be an extension of the way futures are handled, such as rounding (floor / ceiling) prices to a tick value automatically?

Please discuss this issue and / or point us to the necessary information.

Thanks
Dave

Cone

#2

10/31/2016 6:23 PM

I haven't heard about it, but it looks like they started doing it with that set of symbols on 10/17/2016.

You could add the symbols to the Symbol Info Manager with a 0.05 tick, but considering they were trading at 0.01 tick prior to that date, it sure complicates things!

It sure seems like the easiest solution is to check the date. If prior to 10/17/2016, round your stop/limit orders to 0.01, otherwise round to a nickel

Questions:
1. No, it's not handled.
2. Anything's possible, but we'll have to look for that info source.
3. I think it's easiest to deal with it in the strategy code.

Thanks for the heads up!

Eugene

#3

10/31/2016 6:26 PM

Hi Dave,

You could adjust to this change now by activating the Symbol info manager (Tools menu). Set up each stock participating in the SEC program (there's even support for regular expressions if needed) and configure its tick value as 0.05.

Theoretically yes. Assuming there's a bunch of symbols in the pilot program. If such information source exists then a motivated user could come up with a solution to poll the source and create entries in the SymbolInfo.xml file. The source must be freely accessible and easily parseable. Although a WealthScript strategy is powerful enough for this task, he/she might have to do it outside Wealth-Lab because overwriting program's XML files isn't possible while WLP is running.

Cone

#4

11/1/2016 9:24 AM

Just thinking, if you've been in the business for a while you'll recall that it wasn't all that long ago that the U.S. stock market used fractional prices...
Refs:
Stock Market Decimalization.
SEC Decimals Implementation Plan for the Equities and Options Markets

There might have been, but I don't remember any special considerations made by Wealth-Lab or other technical analysis platforms to account for this change in backtesting limit order strategies.

Dave B.

#5

11/1/2016 8:37 PM

Guys, thanks for the discussion.

In my testing, IB currently rejects Limit orders for any stocks that do not conform to the (new) tick level pricing.

This same exact trade can be executed (filled) by Wealth-Lab during backtesting at a non-tick level of pricing via a limit order.

Robert, your comment on fractional pricing made me stop and think – how was this handled before? If memory serves, limit / stop prices on stocks had to conform to the fractional pricing, even back then. This may have been and probably is still different for the big boys and their special treatment (fractional cents).

This implies backtesting is at present and has been in the past a little too optimistic on fills. Do you agree?

I see this as a three (3) part problem:

1. Ideally, this type of stock data (including inception dates, which I agree makes it more complicated) should be collected and stored in an editable table for proper use in Wealth-Lab.
2. Wealth-Lab should reference this collected data as it does now for futures and automatically adjust any prices contained in orders to the proper tick value using Round, Ceiling and Floor functions.
3. Previous backtests using Limit and Stop orders should be rerun for accuracy.

Am I missing something or overreacting?

Does the Wealth-Lab community agree?

Cone

#6

11/2/2016 1:22 PM

Backtesting is generally too optimistic using current symbol lists. That said, limit orders fills can be made precise and highly realistic if you use Limit order slippage (which actually makes the result overly pessimistic). If you don't use Wealth-Data for EOD testing, you're often not testing with "realistic" opening prices. (I trade market and limit orders every day, and my live results precisely match my backtests for both order types, except for those handful of days where I'm not filled at the limit price matching the low of the day.)

Anyway, it's a good discussion but this is just a "12 month pilot program". And, there are 3 test groups of symbols, each with different quote and trade requirements. The first group is actually quoted in nickels, but traded in pennies! If you trade those symbols in the second group (see article), it seems that you'll need your strategy to adjust the limit price to conform to your broker's requirements. Example:

Size:

Color:

[quote]This implies backtesting is at present and has been in the past a little too optimistic on fills.[/quote]Backtesting is generally too optimistic using current symbol lists. That said, limit orders fills can be made precise and highly realistic if you use Limit order slippage (which actually makes the result overly pessimistic).  If you don't use [link=https://www.wealth-data.com/]Wealth-Data[/link] for EOD testing, you're often not testing with "realistic" opening prices.   (I trade market and limit orders every day, and my live results precisely match my backtests for both order types, except for those handful of days where I'm not filled at the limit price matching the low of the day.)

Anyway, it's a good discussion but this is just a "[link=http://www.sec.gov/News/PressRelease/Detail/PressRelease/1370542172819]12 month pilot program[/link]".  And, there are 3 test groups of symbols, each with different quote and trade requirements.  The first group is actually quoted in nickels, but traded in pennies!  If you trade those symbols in the second group (see article), it seems that you'll need your strategy to adjust the limit price to conform to your broker's requirements.  Example:

[code]using System;
using System.Collections.Generic;
using WealthLab;

namespace WealthLab.Strategies
{
	public class MyStrategy : WealthScript
	{
		protected override void Execute()
		{
			ClearDebug();
			double d = 11.21;
			PrintDebug("Testing: " + d);
			PrintDebug("Nickle Rounded: " + NickelRounder(d));
			PrintDebug("Nickle Ceiling: " + NickelRounder(d, true));	
			PrintDebug("Nickle Floored: " + NickelRounder(d, false));
			
		}
		
		double NickelRounder(double price)
		{
			double r = Math.Round(price * 20);
			r /= 20;
			return r;			
		}
		
		double NickelRounder(double price, bool ceiling)
		{
			double r = price * 20;
			if (ceiling)
				r = Math.Ceiling(r);
			else
				r = Math.Floor(r);
			
			r /= 20;
			return r;			
		}
	}
}
[/code]

Dave B.

#7

11/2/2016 5:40 PM

Thanks Eugene and Robert.

I appreciate you guys taking the time to discuss and even providing a routine to modify prices.

We have decided to implement the automatic data collection part of this issue in our external data collection program. This will automatically gather the tick values of the stocks as they are downloaded. We will then modify the necessary Wealth-Lab routines as you have suggested. We have not implemented Wealth-Data yet.

As always, world-class service.

Dave

Eugene

#8

11/30/2016 11:48 AM

Cone's code from post #6 has been added to Community Components:

RoundToNickel

superticker

#9

11/30/2016 5:22 PM

In theory that's true. But due to a Fidelity server bug, the first group (G1) also must trade in 0.05 increments--occasionally. See the screenshot below for the 11/30/2016 trading day.

But there's more. I placed a stop order for MOD the day before in 0.01 increments, and the request went through the server okay. So this is an intermittent server bug; your millage will vary. If your order fails through Wealth-Lab server, you might try placing it by another means.

UPDATE: For the 12/1/2016 trading day, I found some more Group 1 (G1) stocks that get rejected by the Fidelity WL orders server: IIVI, SCHN. Will this continue to be the case or should we just nickle round all stop/limit order prices for all Group 1 stocks as well? Either way works for me.

tick pilot server bug.jpg

superticker

#10

12/14/2016 4:53 AM

Here's a simple Quantize (Quant) class that will round appropriately based on stocks entered into the Symbol Info Manager. It may be included it in the Community.Components library if you like. If you're including it in your own class library, change the Superticker.Components namespace to your own class library namespace.

To use it, you need to call the Quant(Bars) constructor near the very top of the Execute{ } procedure as shown. Most of the internal testing occurs inside the constructor so that overhead stays out of the trading loop.

Then the Round member function, refName.Rnd(proposedPrice), needs to be included with all the prices for every Stop and Limit order directive inside the trading loop as shown. If no rounding is required, the proposedPrice simply passes through the Rnd() call. Otherwise, if rounding is required, the rounded price is returned.

Finally, one needs to include all symbols that require rounded pricing in the Symbol Info Manager, which is found under the WL Tools menu. For each symbol, be sure to set Type to "Equity" and Tick to "0.05" if you want it to round to the nearest nickel.

Size:

Color:

Here's a simple Quantize (Quant) class that will round appropriately based on stocks entered into the Symbol Info Manager.  It may be included it in the Community.Components library if you like.  If you're including it in your own class library, change the Superticker.Components namespace to your own class library namespace.
[code]using System;
using WealthLab;

namespace Superticker.Components
{
	public struct Quant //Quantize price to the nearest tick value in Symbol Info Manager
	{	//developed by Superticker
		private double symbolTick;
		private bool roundPrice;

public Quant(Bars bars)
		{
			symbolTick = bars.SymbolInfo.Tick;
			roundPrice = symbolTick != 0.01 && bars.SymbolInfo.SecurityType == SecurityType.Equity ? true : false;
		}

public double Rnd(double priceProposed)
		{
			return roundPrice ? Math.Round(priceProposed / symbolTick) * symbolTick : priceProposed;
		}

public bool RoundPrice
		{
			get { return roundPrice; }
		}
	}
}
[/code]
To use it, you need to call the Quant(Bars) constructor near the very top of the Execute{ } procedure as shown.  Most of the internal testing occurs inside the constructor so that overhead stays out of the trading loop.
[code]protected override void Execute()
{
	double buyVelocity = paramBuyVelocity.Value;
	double sellThreshold = paramSellThreshold.Value;
	Quant quant = new Quant(Bars); //initialize Quantize with current Bars object
[/code]
Then the Round member function, refName.Rnd(proposedPrice), needs to be included with all the prices for every Stop and Limit order directive inside the trading loop as shown.  If no rounding is required, the proposedPrice simply passes through the Rnd() call.  Otherwise, if rounding is required, the rounded price is returned.
[code]for (int bar=GetTradingLoopStartBar(DataSeries.FirstValidValue); bar<Bars.Count; bar++)
{ //In the trading loop ...
	Position pos=LastActivePosition;
	if (condition code)
	{
		if (!SellAtStop(bar+1,pos,quant.Rnd(proposedStopPrice),"Stop sell"))  //bracketed Stop/Limit order
			SellAtLimit(bar+1,pos,quant.Rnd(proposedLimitPrice),"Limit sell");
	}
}
[/code]
Finally, one needs to include all symbols that require rounded pricing in the Symbol Info Manager, which is found under the WL Tools menu.  For each symbol, be sure to set Type to "Equity" and Tick to "0.05" if you want it to round to the nearest nickel.

Frank1972

#11

1/9/2017 9:31 PM

Here is an implementation that does the following:
- Downloads the http://tsp.finra.org/finra_org/ticksizepilot/TSPilotSecurities.txt file
- Processes that file into a class structure that holds the data
- Processes the PilotData and all of the group 2 securities are then put into SymbolInfo.xml
- If SymbolInfo.xml exists it will process and update this file.
- If SymbolInfo.xml does not exist it will create one and add the TSPilotSecurities to it.

The assumption here is that only group 2 needs to be put into SymbolInfo.xml. If this wrong it can be changed by modifying:

I have tested this. The code below is a console application called "UpdateSymbolInfoWithPilotData" created using Visual Studio. The assumption is that you can run this code once each day before or after the market opens or closes, as the file may be updated each day at or after 2:00 PM EST. The other assumption is that all the symbols that matter are in the TSPilotSecurities.txt and not the TSPilotChanges.txt. If I am wrong about this please let me know and I will update the code.

The way that I know which symbols should be removed or replaced is that there is comment in the SymbolInfo.xml. All SymbolInfo below this comment is considered to be part of the Securities in the Pilot Data. If there is a symbol above this comment the code will modify the entries but won't remove it from SymbolInfo.xml. Because of this you cannot use the Symbol Info Manager because it will overwrite SymbolInfo.xml and remove the comment. This is how I choose to implement this and may not work for everyone.

I hope that this may be helpful to others.

-Frank

Sample SymbolInfo.xml to show the comment and layout of the file that I used to test this code.

Size:

Color:

Here is an implementation that does the following:
   - Downloads the http://tsp.finra.org/finra_org/ticksizepilot/TSPilotSecurities.txt file
   - Processes that file into a class structure that holds the data
   - Processes the PilotData and all of the group 2 securities are then put into SymbolInfo.xml
      - If SymbolInfo.xml exists it will process and update this file.
      - If SymbolInfo.xml does not exist it will create one and add the TSPilotSecurities to it.

The assumption here is that only group 2 needs to be put into SymbolInfo.xml. If this wrong it can be changed by modifying: [code]if (pd.Group == "G2")[/code] I have tested this. The code below is a console application called "UpdateSymbolInfoWithPilotData" created using Visual Studio. The assumption is that you can run this code once each day before or after the market opens or closes, as the file may be updated each day at or after 2:00 PM EST. The other assumption is that all the symbols that matter are in the TSPilotSecurities.txt and not the TSPilotChanges.txt. If I am wrong about this please let me know and I will update the code.

The way that I know which symbols should be removed or replaced is that there is comment in the SymbolInfo.xml. All SymbolInfo below this comment is considered to be part of the Securities in the Pilot Data. If there is a symbol above this comment the code will modify the entries but won't remove it from SymbolInfo.xml. Because of this you cannot use the Symbol Info Manager because it will overwrite SymbolInfo.xml and remove the comment. This is how I choose to implement this and may not work for everyone.

I hope that this may be helpful to others.

-Frank

Sample SymbolInfo.xml to show the comment and layout of the file that I used to test this code.

[code]
<?xml version="1.0" encoding="utf-8"?>
<ArrayOfSymbolInfo xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <SymbolInfo>
    <Symbol>AAME</Symbol>
    <SecurityType>Equity</SecurityType>
    <Margin>1</Margin>
    <PointValue>1</PointValue>
    <Tick>0.05</Tick>
    <Decimals>2</Decimals>
  </SymbolInfo>
  
  <SymbolInfo>
    <Symbol>AAWW</Symbol>
    <SecurityType>Equity</SecurityType>
    <Margin>1</Margin>
    <PointValue>1</PointValue>
    <Tick>0.05</Tick>
    <Decimals>2</Decimals>
  </SymbolInfo>
</ArrayOfSymbolInfo>
[/code]

[code]
using System;
using System.Collections.Generic;
using System.Xml;
using System.Xml.Linq;
using System.Text;
using System.IO;

namespace UpdateSymbolInfoWithPilotData {
    class Program {
        static void Main(string[] args) {
            //-----------------------------------------------------------------------------------------------
            //                                    DOWNLOAD SECURITY FILE
            //-----------------------------------------------------------------------------------------------
            Console.Write("Downloading - http://tsp.finra.org/finra_org/ticksizepilot/TSPilotSecurities.txt...");
            string securitiesRemoteUri = "http://tsp.finra.org/finra_org/ticksizepilot/TSPilotSecurities.txt";
            string securitiesFilename = @"TSPilotSecurities.txt";
            System.Net.WebClient webClient = new System.Net.WebClient();

webClient.DownloadFile(securitiesRemoteUri, securitiesFilename);
            Console.WriteLine("Done");

//-----------------------------------------------------------------------------------------------
            //                            PROCESS SECURITY FILE INTO PILOTDATA
            //-----------------------------------------------------------------------------------------------
            Console.Out.Write("Processing TSPilotSecurity.txt...");
            string[] lines = System.IO.File.ReadAllLines(securitiesFilename);
            string[] header = lines[0].Split('|');
            List<PilotData> pilotData = new List<PilotData>();

for (int i = 1; i < lines.Length; i++) {
                string line = lines[i];
                System.Collections.Generic.Dictionary<string, string> items = getItems(ref header, line);

PilotData pd = new PilotData(ref items);

if (pd.Symbol != "END_FILE") {
                    pilotData.Add(pd);
                }
            }

Console.WriteLine("Done");

//-----------------------------------------------------------------------------------------------
            //                          PROCESS PILOTDATA INTO SYMBOLINFO.XML
            //-----------------------------------------------------------------------------------------------
            Console.Out.Write("Processing TSPilotSecurity.txt to SymbolInfo.xml...");
            try {
                SymbolInfoWriter symbolInfoWriter = new SymbolInfoWriter();

foreach (PilotData pd in pilotData) {
                    // Only add pilot security data that is in group 2
                    if (pd.Group == "G2") {
                        string symbol = pd.Symbol;
                        SymbolInfoWriter.SecurityType securityType = SymbolInfoWriter.SecurityType.Equity;
                        double margin = 1;
                        double pointValue = 1;
                        double tick = 0.05;
                        int decimals = 2;

symbolInfoWriter.addSymbolInfo(symbol, securityType, margin, pointValue, tick, decimals);
                    }
                }

symbolInfoWriter.write();
                Console.WriteLine("Done");
            } catch (Exception e) {
                Console.Error.WriteLine("Exception thrown:\n" + e.Message);
                Console.Error.WriteLine("-------------------------------------------\n" + e.StackTrace);
            }
        }

// Process delimited data into a map with keys equal to the header and the value from the data in the line
        private static Dictionary<string, string> getItems(ref string[] headers, string line) {
            Dictionary<string, string> retVal = new Dictionary<string, string>();
            string[] items = line.Split('|');

for (int i = 0; i < items.Length; i++) {
                string header = headers[i];
                string item = items[i];

retVal[header] = item;
            }

return retVal;
        }

/*
         * Represents the Wealth Lab SymbolInfo.xml file
         * Reading it and added to it
         */
        class SymbolInfoWriter {
            public enum SecurityType { Equity, Future, MutualFund, StockOption }
            //                 symbol  index
            private Dictionary<string, int> symbolInfoToIndex = new Dictionary<string, int>();
            // List is used to maintain the order of the symbols in the file as it relates to the comment 
            private List<SymbolInfo> symbolInfos = new List<SymbolInfo>();
            public int symbolInfoCnt { get; private set; }

/*
             * Holds the information for a single SymbolInfo entry in the Wealth Lab SymbolInfo.xml file
             */
            private class SymbolInfo {
                // Create a SymbolInfo entry by reading data from the xml file
                public SymbolInfo(XmlReader reader) {
                    while (reader.NodeType != XmlNodeType.EndElement) {
                        reader.Read();

if (reader.NodeType == XmlNodeType.Element) {
                            if (reader.Name == "Symbol") {
                                reader.Read();

if (reader.NodeType == XmlNodeType.Text) {
                                    Symbol = reader.Value;
                                    goToNextElement(reader);
                                } else {
                                    handleError("SymbolInfo.Constuctor - Error in reading XML element 'Symbol'");
                                }
                            } else if (reader.Name == "SecurityType") {
                                reader.Read();

if (reader.NodeType == XmlNodeType.Text) {
                                    SecurityType = reader.Value;
                                    goToNextElement(reader);
                                } else {
                                    handleError("SymbolInfo.Constuctor - Error in reading XML element 'Security' for symbol:" + Symbol);
                                }
                            } else if (reader.Name == "Margin") {
                                reader.Read();

if (reader.NodeType == XmlNodeType.Text) {
                                    this.Margin = reader.Value;
                                    goToNextElement(reader);
                                } else {
                                    handleError("SymbolInfo.Constuctor - Error in reading XML element 'Margin' for symbol:" + Symbol);
                                }
                            } else if (reader.Name == "PointValue") {
                                reader.Read();

if (reader.NodeType == XmlNodeType.Text) {
                                    this.PointValue = reader.Value;
                                    goToNextElement(reader);
                                } else {
                                    handleError("SymbolInfo.Constuctor - Error in reading XML element 'PointValue' for symbol:" + Symbol);
                                }
                            } else if (reader.Name == "Tick") {
                                reader.Read();

if (reader.NodeType == XmlNodeType.Text) {
                                    this.Tick = reader.Value;
                                    goToNextElement(reader);
                                } else {
                                    handleError("SymbolInfo.Constuctor - Error in reading XML element 'Tick' for symbol:" + Symbol);
                                }
                            } else if (reader.Name == "Decimals") {
                                reader.Read();

if (reader.NodeType == XmlNodeType.Text) {
                                    this.Decimals = reader.Value;
                                    goToNextElement(reader);
                                } else {
                                    handleError("SymbolInfo.Constuctor - Error in reading XML element 'Decimals' for symbol:" + Symbol);
                                }
                            }
                        }
                    }
                }

// Create a SymbolInfo entry from the pilot data file using these parameters
                public SymbolInfo(string symbol, string securityType, double margin, double pointValue, double tick, int decimals) {
                    Symbol = symbol;
                    SecurityType = securityType;
                    Margin = margin.ToString();
                    PointValue = pointValue.ToString();
                    Tick = tick.ToString();
                    Decimals = decimals.ToString();
                }

private void handleError(string message) {
                    Console.Error.WriteLine(message);
                    throw new Exception(message);
                }

// Move to the next element
                private void goToNextElement(XmlReader reader) {
                    while (reader.NodeType != XmlNodeType.EndElement) {
                        reader.Read();
                    }

reader.Read();
                }

public string Symbol { get; set; }
                public string SecurityType { get; set; }
                public string Margin { get; set; }
                public string PointValue { get; set; }
                public string Tick { get; set; }
                public string Decimals { get; set; }
            }

/*
             * Reads the SymbolInfo.xml file up to the comment ()
             * Allows for more SymbolInfo to be added after the comment
             */
            public SymbolInfoWriter() {
                // "C:\Users\<user name>\AppData\Roaming\Fidelity Investments\WealthLabPro\1.0.0.0\Data\SymbolInfo.xml"
                string symbolInfoFileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"Fidelity Investments\WealthLabPro\1.0.0.0\Data\SymbolInfo.xml");

if (File.Exists(symbolInfoFileName) == true) {
                    //---------------------------------------
                    //         READ XML FILE
                    //---------------------------------------
                    XmlReader reader = XmlReader.Create(symbolInfoFileName);

while (reader.Read()) {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "SymbolInfo") {
                            SymbolInfo symbolInfo = new SymbolInfo(reader);

symbolInfos.Add(symbolInfo);

int indexAddAt = symbolInfos.Count - 1;
                            symbolInfoToIndex.Add(symbolInfo.Symbol, indexAddAt);
                            symbolInfoCnt++;
                        } else if (reader.NodeType == XmlNodeType.Comment) {
                            if (reader.Value.Equals("Tick Size Pilot") == true) {
                                break;
                            }
                        }
                    }
                } else {
                    //---------------------------------------
                    //         CREATE EMPTY FILE
                    //---------------------------------------
                    File.Create(symbolInfoFileName);
                }
            }

// Add a new SymbolInfo or update one that already exists
            public void addSymbolInfo(string symbol, SecurityType securityType, double margin, double pointValue, double tick, int decimals) {
                // See if the symbol is already in the list 
                // Update if it is
                if (symbolInfoToIndex.ContainsKey(symbol) == true) {
                    int indexAddedAt = symbolInfoToIndex[symbol];
                    SymbolInfo symbolInfo = symbolInfos[indexAddedAt];

symbolInfo.SecurityType = securityType.ToString();
                    symbolInfo.Margin = margin.ToString();
                    symbolInfo.PointValue = pointValue.ToString();
                    symbolInfo.Tick = tick.ToString();
                    symbolInfo.Decimals = decimals.ToString();
                } else {
                    SymbolInfo symbolInfo = new SymbolInfo(symbol, securityType.ToString(), margin, pointValue, tick, decimals);
                    symbolInfos.Add(symbolInfo);

int indexAddAt = symbolInfos.Count - 1;
                    symbolInfoToIndex.Add(symbolInfo.Symbol, indexAddAt);
                }
            }

// Write the Wealth Lab SymbolInfo.xml file
            public void write() {
                int elementCnt = 0;
                XElement elements = new XElement("ArrayOfSymbolInfo",
                                    new XAttribute(XNamespace.Xmlns + "xsd", "http://www.w3.org/2001/XMLSchema"),
                                    new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"));

foreach (SymbolInfo symbolInfo in symbolInfos) {
                    if (elementCnt == symbolInfoCnt) {
                        elements.Add(new XComment("Tick Size Pilot"));
                    }

elements.Add(new XElement("SymbolInfo", new XElement("Symbol", symbolInfo.Symbol),
                                                            new XElement("SecurityType", symbolInfo.SecurityType),
                                                            new XElement("Margin", symbolInfo.Margin),
                                                            new XElement("PointValue", symbolInfo.PointValue),
                                                            new XElement("Tick", symbolInfo.Tick),
                                                            new XElement("Decimals", symbolInfo.Decimals)));
                    elementCnt++;
                }

XmlWriterSettings xws = new XmlWriterSettings();
                StringWriterWithEncoding sw = new StringWriterWithEncoding(Encoding.GetEncoding("utf-8"));

xws.Indent = true;
                xws.Encoding = Encoding.GetEncoding("utf-8");

using (XmlWriter xw = XmlWriter.Create(sw, xws)) {
                    string version = "1.0";
                    string encoding = "utf-8";
                    string standalone = String.Empty;
                    XDocument doc = new XDocument(new XDeclaration(version, encoding, standalone), elements);

doc.WriteTo(xw);
                }

string filename = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"Fidelity Investments\WealthLabPro\1.0.0.0\Data\SymbolInfo.xml");

using (StreamWriter writer = new StreamWriter(File.Open(filename, FileMode.Create), Encoding.UTF8)) {
                    writer.WriteLine(sw.ToString());
                }
            }
        }

/*
         * Represents the data that is in the TSPilotSecurities.txt file
         */
        class PilotData {
            public PilotData(ref Dictionary<string, string> items) {
                Symbol = items["Ticker_Symbol"];

if (Symbol != "END_FILE") {
                    SecurityName = items["Security_Name"];
                    ListingExchange = items["Listing_Exchange"];

// Process the Effective_Date into a DateTime object
                    string dateString = items["Effective_Date"]; // Format: yyyymmdd
                    string yearStr = dateString.Substring(0, 4); // pull yyyy out of dateString
                    string monthStr = dateString.Substring(4, 2);// pull mm out of the dateString
                    string dayStr = dateString.Substring(6);     // pull dd out of the dateString
                    string parseStr = monthStr + "-" + dayStr + "-" + yearStr; // Create a date string that C# can parse

EffectiveDate = DateTime.Parse(parseStr);
                    Group = items["Tick_Size_Pilot_Program_Group"];
                }
            }

public DateTime EffectiveDate { get; private set; }
            public string Group { get; private set; }
            public string ListingExchange { get; private set; }
            public string SecurityName { get; private set; }
            public string Symbol { get; private set; }
        }

/*
         * This class is needed to write the file out as utf-8
         * http://stackoverflow.com/questions/427725/how-to-put-an-encoding-attribute-to-xml-other-that-utf-16-with-xmlwriter
         */
        public sealed class StringWriterWithEncoding : StringWriter {
            private readonly Encoding encoding;

public StringWriterWithEncoding(Encoding encoding) {
                this.encoding = encoding;
            }

public override Encoding Encoding {
                get { return encoding; }
            }
        }
    }
}
[/code]

Eugene

#12

1/10/2017 5:03 AM

Frank, thanks for sharing!

Eugene

#13

8/28/2017 8:49 PM

In a deleted duplicate thread, 123blee9 wrote:

I'm analyzing a stock that participates in the tick size pilot program.

http://www.nasdaq.com/article/tick-size-pilot-program-what-investors-need-to-know-cm688067

The tick size for the stock of interest has changed from 1-cent to 5-cent tick increments.

I can easily round buy/sell prices to the nearest nickel [ Math.Round(Price*20,0)/20 ], but WLP will take 1-cent entry/exits based on market movement. Is there a way to force WLP to enter/exit only at prices in 5-cent increments?

Thanks

dansmo

#14

2/25/2019 1:25 PM

In Europe it is even more complicated as ticksizes can change regularly due to regulatory rules that came into effect 2018. This also means that they changed an Jan 1st for almost all instruments. So for realistic backtests one needs the apllicable ticksize for every date and symbol in the test. As it is very difficult to get this data one approach could be to "guesstimate" the ticksize of the symbol. With this I mean to guess the current alid ticksize based on the prices (ohlc) we see for the last n bars. Did anyone do this before?