# MULTI-TIME FRAME – KEEPING TRACK OF DISCRETE TIME FRAMES

Just a quick post here.  I was asked how to keep track of the opening price for each time frame from our original Multi-Time Frame indicator and I was answering the question when I thought about modifying the indicator.  This version keeps track of each discrete time frame.  The original simply looked back a multiple of the base chart to gather the highest highs and lowest lows and then would do a simple calculation to determine the trend.  So let’s say its 1430 on a five-minute bar and you are looking back at time frame 2.  All I did was get the highest high and lowest low two bars back and stored that information as the high and low of time frame 2.  Time frame 3 simply looked back three bars to gather that information.  However if you tried to compare these values to a 10-minute or 15-minute chart they would not match.

In this version, I use the modulus function to determine the demarcation of each time frame.  If I hit the border of the time frame I reset the open, high, low and carry that value over until I hit the next demarcation.  All the while collecting the highest highs and lowest lows.  In this model, I am working my way from left to right instead of right to left.  And in doing so each time frame is discrete.

Let me know which version you like best.

``Inputs:tf1Mult(2),tf2Mult(3),tf3Mult(4),tf4Mult(5);vars: mtf1h(0),mtf1l(0),mtf1o(0),mtf1c(0),mtf1pvt(0),diff1(0),      mtf2h(0),mtf2l(0),mtf2o(0),mtf2c(0),mtf2pvt(0),diff2(0),      mtf3h(0),mtf3l(0),mtf3o(0),mtf3c(0),mtf3pvt(0),diff3(0),      mtf4h(0),mtf4l(0),mtf4o(0),mtf4c(0),mtf4pvt(0),diff4(0),      mtf0pvt(0),diff0(0);If barNumber = 1 thenBegin	mtf1o = o;	mtf2o = o;	mtf3o = o;	mtf4o = o;end;If barNumber > 1 thenBegin	Condition1 =  mod((barNumber+1),tf1Mult) = 0;	Condition2 =  mod((barNumber+1),tf2Mult) = 0;	Condition3 =  mod((barNumber+1),tf3Mult) = 0;	Condition4 =  mod((barNumber+1),tf4Mult) = 0;		mtf1h = iff(not(condition1[1]),maxList(high,mtf1h[1]),high);	mtf1l = iff(not(condition1[1]),minList(low,mtf1l[1]),low);	mtf1o = iff(condition1[1],open,mtf1o[1]);	mtf1c = close;		mtf0pvt = (close + high + low) / 3;	diff0 = close - mtf0pvt;		mtf2h = iff(not(condition2[1]),maxList(high,mtf2h[1]),high);	mtf2l = iff(not(condition2[1]),minList(low,mtf2l[1]),low);	mtf2o = iff(condition2[1],open,mtf2o[1]);	mtf2c = close;			mtf1pvt = (mtf1h+mtf1l+mtf1c) / 3;	diff1 = mtf1c - mtf1pvt;			mtf2pvt = (mtf2h+mtf2l+mtf2c) / 3;	diff2 = mtf2c - mtf2pvt;			mtf3h = iff(not(condition3[1]),maxList(high,mtf3h[1]),high);	mtf3l = iff(not(condition3[1]),minList(low,mtf3l[1]),low);	mtf3o = iff(condition3[1],open,mtf3o[1]);	mtf3c = close;		mtf3pvt = (mtf3h+mtf3l+mtf3c) / 3;	diff3 = mtf3c - mtf3pvt;		mtf4h = iff(not(condition4[1]),maxList(high,mtf4h[1]),high);	mtf4l = iff(not(condition4[1]),minList(low,mtf4l[1]),low);	mtf4o = iff(condition4[1],open,mtf4o[1]);	mtf4c = close;	mtf4pvt = (mtf4h+mtf4l+mtf4c) / 3;	diff4 = mtf4c - mtf4pvt;			Condition10 = diff0 > 0;	Condition11 = diff1 > 0;	Condition12 = diff2 > 0;	Condition13 = diff3 > 0;	Condition14 = diff4 > 0;	 	If condition10 then setPlotColor(1,Green) else SetPlotColor(1,Red);	If condition11 then setPlotColor(2,Green) else SetPlotColor(2,Red);	If condition12 then setPlotColor(3,Green) else SetPlotColor(3,Red);	If condition13 then setPlotColor(4,Green) else SetPlotColor(4,Red);	If condition14 then setPlotColor(5,Green) else SetPlotColor(5,Red);		condition6 = condition10 and condition11 and condition12 and condition13 and condition14;	Condition7 = not(condition10) and not(condition11) and not(condition12) and not(condition13) and not(condition14);	If condition6 then setPlotColor(7,Green);	If condition7 then setPlotColor(7,Red);		If condition6 or condition7 then plot7(7,"trend");	Plot6(5,"line");		Plot1(4,"t1");	Plot2(3,"t2");	Plot3(2,"t3");	Plot4(1,"t4");	Plot5(0,"t5"); end;``
Multi-Time Frame with Discrete Time Frames

# Using a Dictionary to Create a Trading System

## Dictionary Recap

Last month’s post on using the elcollections dictionary was a little thin so I wanted to elaborate on it and also develop a trading system around the best patterns that are stored in the dictionary.  The concept of the dictionary exists in most programming languages and almost all the time uses the (key)–>value model.  Just like a regular dictionary a word or a key has a unique definition or value.  In the last post, we stored the cumulative 3-day rate of return in keys that looked like “+ + – –” or “+ – – +“.  We will build off this and create a trading system that finds the best pattern historically based on average return.  Since its rather difficult to store serial data in a Dictionary I chose to use Wilder’s smoothing average function.

## Ideally, I Would Have Liked to Use a Nested Dictionary

Initially, I played around with the idea of the pattern key pointing to another dictionary that contained not only the cumulative return but also the frequency that each pattern hit up.  A dictionary is designed to have  unique key–> to one value paradigm.  Remember the keys are strings.  I wanted to have unique key–> to multiple values. And you can do this but it’s rather complicated.  If someone wants to do this and share, that would be great.  AndroidMarvin has written an excellent manual on OOEL and it can be found on the TradeStation forums.

## Ended Up Using A Dictionary With 2*Keys Plus an Array

So I didn’t want to take the time to figure out the nested dictionary approach or a vector of dictionaries – it gets deep quick.  So following the dictionary paradigm I came up with the idea that words have synonyms and those definitions are related to the original word.  So in addition to having keys like “+ + – -” or “- – + -” I added keys like “0”, “1” or “15”.  For every  + or – key string there exists a parallel key like “0” or “15”.  Here is what it looks like:

 –  –  –  – = “0” – – – + = “1” – – + – = “2”

You can probably see the pattern here.  Every “+” represents a 1 and every “0” represent 0 in a binary-based numbering system.  In the + or – key I store the last value of Wilders average and in the numeric string equivalent, I store the frequency of the pattern.

## Converting String Keys to Numbers [Back and Forth]

To use this pattern mapping I had to be able to convert the “++–” to a number and then to a string.  I used the numeric string representation as a dictionary key and the number as an index into an array that store the pattern frequency.  Here is the method I used for this conversion.  Remember a method is just a function local to the analysis technique it is written.

``//Lets convert the string to unique numbermethod int convertPatternString2Num(string pattString) Vars: int pattLen, int idx, int pattNumber;begin	pattLen = strLen(pattString);	pattNumber = 0;	For idx = pattLen-1 downto 0 	Begin		If MidStr(pattString,pattLen-idx,1) = "+" then pattNumber = pattNumber + power(2,idx);	end;	Return (pattNumber);end;``
String Pattern to Number

This is a simple method that parses the string from left to right and if there is a “+” it is raised to the power(2,idx) where idx is the location of “+” in the string.  So “+  +  –  –  ” turns out to be 8 + 4 + 0 + 0 or 12.

Once I retrieve the number I used it to index into my array and increment the frequency count by one.  And then store the frequency count in the correct slot in the dictionary.

``patternNumber = convertPatternString2Num(patternString); //Keep track of pattern hitspatternCountArray[patternNumber] = patternCountArray[patternNumber] + 1;//Convert pattern number to a string do use as a Dictionary KeypatternStringNum = numToStr(patternNumber,2);//Populate the pattern number string key with the number of hitspatternDict[patternStringNum] = patternCountArray[patternNumber] astype double;``
Store Value In Array and Dictionary

## Calculating Wilder’s Average Return and Storing in Dictionary

Once I have stored an instance of each pattern [16] and the frequency of each pattern[16] I calculate the average return of each pattern and store that in the dictionary as well.

``//Calculate the percentage change after the displaced pattern hitsValue1 =  (c - c[2])/c[2]*100;//Populate the dictionary with 4 ("++--") day pattern and the percent changeif patternDict.Contains(patternString) thenBegin	patternDict[patternString] = (patternDict[patternString] astype double * 	(patternDict[patternStringNum] astype double - 1.00) + Value1) / patternDict[patternStringNum] astype double;endElsebegin	patternDict[patternString] = value1;//	print("Initiating: ",patternDict[patternString] astype double);end;``
(pAvg * (N-1) + return) / N

When you extract a value from a collection you must us an identifier to expresses its data type or you will get an error message : patternDict[patternString] holds a double value {a real number}  as well as patternDict[patternStringNum] – so I have to use the keyword asType.  Once I do my calculation I ram the new value right back into the dictionary in the exact same slot.  If the pattern string is not in the dictionary (first time), then the Else statement inserts the initial three-day rate of return.

## Sort Through All of The Patterns and Find the Best!

The values in a dictionary are stored in alphabetic order and the string patterns are arranged in the first 16 keys.  So I loop through those first sixteen keys and extract the highest return value as the “best pattern.”

``//  get the best pattern that produces the best average 3 bar returnvars: hiPattRet(0),bestPattString("");If patternDict.Count > 29 thenBegin	index = patternDict.Keys;	values = patternDict.Values; 	hiPattRet = 0;	For iCnt = 0 to 15	Begin		If values[iCnt] astype double > hiPattRet then		Begin			hiPattRet = values[iCnt] astype double ;			bestPattString = index[iCnt] astype string;		end;	end;//	print(Date," BestPattString ",bestPattString," ",hiPattRet:8:4," CurrPattString ",currPattString);end;``
Extract Best Pattern From All History

If Today’s Pattern Matches the Best Then Take the Trade

``// if the current pattern matches the best pattern then bar next bar at openIf currPattString = BestPattString then buy next bar at open;// cover in three daysIf barsSinceEntry > 2 then sell next bar at open;``
Does Today Match the Best Pattern?

If today matches the best pattern then buy and cover after the second day.

## Conclusion

I didn’t know if this code was worth proffering up but I decided to posit it because it contained a plethora of programming concepts: dictionary, method, string manipulation, and array.  I am sure there is a much better way to write this code but at least this gets the point across.

## Contents of Dictionary at End of Run

``++++    0.06+++-   -0.08++-+    0.12++--   -0.18+-++    0.08+-+-    0.40+--+   -0.46+---    0.34-+++    0.20-++-    0.10-+-+    0.23-+--    0.31--++    0.02--+-    0.07---+    0.22----    0.460.00  103.001.00  128.0010.00  167.0011.00  182.0012.00  146.0013.00  168.0014.00  163.0015.00  212.002.00  157.003.00  133.004.00  143.005.00  181.006.00  151.007.00  163.008.00  128.009.00  161.00``
Contents of Dictionary

``//Dictionary based trading sytem//Store pattern return//Store pattern frequency// by George PruittUsing elsystem.collections; vars: string keystring("");vars: dictionary patternDict(NULL),vector index(null), vector values(null);array: patternCountArray[100](0);input: patternTests(8);  var: patternTest(""),tempString(""),patternString(""),patternStringNum("");var: patternNumber(0);var: iCnt(0),jCnt(0);//Lets convert the string to unique numbermethod int convertPatternString2Num(string pattString) Vars: int pattLen, int idx, int pattNumber;begin	pattLen = strLen(pattString);	pattNumber = 0;	For idx = pattLen-1 downto 0 	Begin		If MidStr(pattString,pattLen-idx,1) = "+" then pattNumber = pattNumber + power(2,idx);	end;	Return (pattNumber);end;once begin    clearprintlog;    patternDict = new dictionary;    index = new vector;   values = new vector;end;   //Convert 4 day pattern displaced by 2 dayspatternString = ""; for iCnt = 5 downto 2begin    if(close[iCnt]> close[iCnt+1]) then    begin        patternString = patternString + "+";    end    else    begin        patternString = patternString + "-";    end;end;//What is the current 4 day patternvars: currPattString("");currPattString = "";for iCnt = 3 downto 0begin    if(close[iCnt]> close[iCnt+1]) then    begin        currPattString = currPattString + "+";    end    else    begin        currPattString = currPattString + "-";    end;end;//Get displaced pattern numberpatternNumber = convertPatternString2Num(patternString); //Keep track of pattern hitspatternCountArray[patternNumber] = patternCountArray[patternNumber] + 1;//Convert pattern number to a string do use as a Dictionary KeypatternStringNum = numToStr(patternNumber,2);//Populate the pattern number string key with the number of hitspatternDict[patternStringNum] = patternCountArray[patternNumber] astype double;//Calculate the percentage change after the displaced pattern hitsValue1 =  (c - c[2])/c[2]*100;//Populate the dictionary with 4 ("++--") day pattern and the percent changeif patternDict.Contains(patternString) thenBegin	patternDict[patternString] = (patternDict[patternString] astype double * 	(patternDict[patternStringNum] astype double - 1.00) + Value1) / patternDict[patternStringNum] astype double;endElsebegin	patternDict[patternString] = value1;//	print("Initiating: ",patternDict[patternString] astype double);end;//  get the best pattern that produces the best average 3 bar returnvars: hiPattRet(0),bestPattString("");If patternDict.Count > 29 thenBegin	index = patternDict.Keys;	values = patternDict.Values; 	hiPattRet = 0;	For iCnt = 0 to 15	Begin		If values[iCnt] astype double > hiPattRet then		Begin			hiPattRet = values[iCnt] astype double ;			bestPattString = index[iCnt] astype string;		end;	end;//	print(Date," BestPattString ",bestPattString," ",hiPattRet:8:4," CurrPattString ",currPattString);end;// if the current pattern matches the best pattern then bar next bar at openIf currPattString = BestPattString then buy next bar at open;// cover in three daysIf barsSinceEntry > 2 then sell next bar at open;``