# Tracking Last EntryPrice While Pyramiding on Minute Bars

## EasyLanguage’s EntryPrice Doesn’t Cut the Mustard

In writing the Hi-Res edition of Easing Into EasyLanguage I should have included this sample program.  I do point out the limitations of the EntryPrice keyword/function in the book.  But recently I was tasked to create a pyramiding scheme template that used minute bars and would initiate a position with N Shares and then pyramid up to three times by adding on N Shares at the last entry price + one 10 -Day ATR measure as the market moves in favor of the original position.  Here is an example of just such a trade.

EntryPrice only contains the original entry price.  So every time you add on a position, the EntryPrice doesn’t reflect this add on price.  I would like to be able to index into this keyword/function and extract any EntryPrice.  If you enter at the market, then you can keep track of entry prices because a market order is usually issued from an if-then construct:

``//Here I can keep track of entry prices because I know//exactly when and where they occur.if c > c[1] and value1 > value2 thenbegin	buy("MarketOrder") next bar at market;	lastEntryPrice = open of next bar;end;``
Last Entry Price tracking is easy if using Market Orders

But what if you are using a stop or limit order.  You don’t know ahead of time where one of these types of orders will hit up.  It could be the next bar or it could be five bars later or who knows.

## AvgEntryPrice Makes Up for the Weakness of EntryPrice

AvgEntryPrice is a keyword/function that  returns the average of the entries when pyramiding.  Assume you buy at 42.00 and pyramid the same number of shares at 46.50 – AvgEntryPrice will be equal to (42.00 + 46.50) / 2 = 44.25.  With this information you can determine the two entry prices.  You already know the original price.  Take a look at this code.

``// remember currentShares and avgEntryPrice ARE EasyLanguage Keywords/Functionsif mp[1] = mp and mp = -1 and currentShares > curShares thenbegin	totShorts = totShorts + 1;	if currentShares > initShares then	begin		lastEntryPrice = totShorts * avgEntryPrice - entryPriceSums;		entryPriceSums = entryPriceSums + lastEntryPrice;		print(d," Short addon ",lastEntryPrice," ",totShorts," ",avgEntryPrice," ",entryPriceSums);	end;end;``
Calculating the true LastEntryPrice

Remember currentShares is a keyword/function and it is immediately updated when more shares are added or taken off.  CurShares is my own variable where I keep track of the prior  currentShares , so if currentShares (real number of shares) is greater than the prior curShares (currentShares) then I know 100%, a position has been pyramided as long the the mp stays the same.  If currentShares increases and mp stays constant, then you can figure out the last entry price where the pyramid takes place.  First you tick totShorts up by 1.  If currentShares > initShares, then you know you are pyramiding so

lastEntryPrice = totShorts * avgEntryPrice – entryPriceSums

Don’t believe me.  Let’s test it.  Remember original entry was 42.00 and the add on was at 46.50.  TotShorts now equals 2.

1. Initial entryPrice = 42.00 so entryPriceSums is set to 42.00
2. After pyramiding avgEntryPrice is set to 44.25
3. lastEntryPrice = 2 * 44.25 – 42.00 = 46.50
4. entryPriceSums is then set to 42.00 + 46.50 or 88.50

So every time you add on a position, then you flow through this logic and you can keep track of the actual last entry price even if it is via a limit or stop order.

But wait there is more.  This post is also a small glimpse into what I will be writing about in the Easing Into EasyLanguage:  Advanced Topics.  This system definitely falls into what I discussed in the Hi-Res Edition.  Here is where we tip over into Advanced Topics.  The next book is not about creating dialogs or trading apps using OOEL (object oriented EasyLanguage), but we do use some of those topics to do some rather complicated back testing things.

Now that we know how to calculate the lastEntryPrice wouldn’t it be really cool if we could keep track of all of the entryPrices during the pyramid stream.   If I have pyramided four times, I would like to know entryPrice 1, entryPrice 2, entryPrice 3 and entryPrice 4.

## Dr. VectorLove or How I Learned to Stop Worrying and Love Objects

I have discussed vectors before but I really wanted to discuss them more.  Remember Vectors are just lists or arrays that don’t need all the maintenance.  Yes you have to create them which can be a pain, but once you learn and forget it twenty times it starts to sink in.  Or just keep referring back to this web page.

``Using elsystem.collections;vars: Vector entryPriceVector(Null);once Begin	entryPriceVector = new Vector;end;``
The Bare Minimum to Instantiate a Vector
1. Type – “Using elsystem.collections; “
2. Declare entryPriceVector as a Vector and set it equal to Null
3. Use Once and instantiate entryPriceVector by using the keyword new < object type>;

A Vector is part of elsystem’s collection objects.  Take a look at this updated code,

``if mp[1] = mp and mp = -1 and currentShares > curShares thenbegin	totShorts = totShorts + 1;	if currentShares > initShares then	begin		lastEntryPrice = totShorts * avgEntryPrice - entryPriceSums;		entryPriceVector.push_back(lastEntryPrice);		entryPriceSums = entryPriceSums + lastEntryPrice;		print(d," Short addon ",lastEntryPrice," ",entryPrice," ",entryPrice(1)," ",totShorts," ",avgEntryPrice," ",entryPriceSums," ",entryPriceVector.back() astype double," ",entryPriceVector.count asType int);		if not(entryPriceVector.empty()) then		begin			for m = 0 to entryPriceVector.count-1			begin				print(entryPriceVector.at(m) astype double);			end;		end;	end;end;``
LastEntryPrice and Pushing It onto the Vector and Then Printing Out the Vector

After the lastEntryPrice is calculated it is pushed onto the entryPriceVector using the function (method same thing but it is attached to the Vector class).push_back(lastEntryPrice);

entryPriceVector.push_back(lastEntryPrice);

So every time a new lastEntryPrice is calculated it is pushed onto the Vector at the back end.  Now if the entryPriceVector is not empty then we can print its contents by looping and indexing into the Vector.

``if not(entryPriceVector.empty()) thenbegin     for m = 0 to entryPriceVector.count-1     begin          print(entryPriceVector.at(m) astype double);     end;end;``
Looping through a Vector and Printing Out its Contents

Remember if you NOT a boolean value then it turns it to off/on or just the opposite of the boolean valueIf entryPriceVector is not empty then proceed.  entryPriceVector.count holds the number of values stuffed into the vectorYou can index into the Vector by using .at(m),  If you want to print out the value of the Vector .at(m), then you will need to typecast the Vector object as what ever it is holding.  We know we are pushing numbers with decimals (double type) onto the Vector so we know we can evaluate them as a double type.  Just remember you have to do this when printing out the values of the Vector.

Okay you can see where we moved into an Advanced Topics area with this code.  But it really becomes useful when trying to overcome some limitations of EasyLanguage.  Remember keep an eye open for Advanced Topics sometime in the Spring.

# 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

## Code in Universum

``//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;``
Pattern Dictionary Part II

# Using A Dictionary to Store Chart Patterns in EasyLanguage

## Dictionary – Another Cool Collection Object

The dictionary object in EasyLanguage works just like a real dictionary.  It stores values that referenced by a key.  In a real-life dictionary, the keys would be words and the values would be the definitions of those words.

### An Introduction

This little bit of code just barely skims the surface of the dictionary object, but it gives enough to get a nice introduction to such a powerful tool.  I am piggybacking off of my Pattern Smasher code here, so you might recognize some of it.

#### Object Delcaration

Like any of the objects in EasyLanguage a dictionary must be declared initially.

``Using elsystem.collections; vars: dictionary patternDict(NULL),vector index(null), vector values(null);input: patternTests(8);var: patternTest(""),tempString(""),patternString("");var: iCnt(0),jCnt(0);once begin    clearprintlog;    patternDict = new dictionary;    index = new vector;   values = new vector;end; ``
Declaring Objects

Here I tell the editor that I am going to be using the elsystem.collections and then a declare/define a dictionary named patterDict and two vectors:  index and values.  In the Once block, I create instances of the three objects.  This is boilerplate stuff for object instantiation.

``for iCnt = 5 downto 2begin    if(close[iCnt]> close[iCnt+1]) then    begin        patternString = patternString + "+";    end    else    begin        patternString = patternString + "-";    end;end; If patternString = "+++-" then Value99 = value99 + (c - c[2])/c[2];if patternDict.Contains(patternString) thenBegin//	print("Found pattern: ",patternString," 3-day return is: ", (c - c[2])/c[2]);	patternDict[patternString] = patternDict[patternString] astype double + (c - c[2])/c[2];endElse	patternDict[patternString] = (c - c[2])/c[2];``
Build the Pattern String and Then Store It

The keys that index into the dictionary are strings.  In this very simple example, I want to examine all of the different combinations of the last four-bar closing prices.   Once the pattern hits up I want to accumulate the percentage change over the past three days and store that value in the location pointed to by the patternString key.

Notice how I displace the loop by three days (5-2 insteat of 3-0)?  I do this so I can compare the close at the end of the pattern with today’s close, hence gathering the percentage change.  Also, notice that I test to make sure there is an entry in the dictionary with the specific key string.  If there wasn’t already an entry with the key and I tried to reference the value I would get an error message – “unable to cast null object.”

Once I store the keys and values I can regurgitate the entire dictionary very simply.  The keys and values are stored as vectors.  I can simply assign these components of the dictionary to the two vectors I instantiated earlier.

``If lastBarOnChart and patternDict.Count > 0 thenBegin	index = patternDict.Keys;	values = patternDict.Values; 	For iCnt = 0 to patternDict.Count-1	Begin		print(index[iCnt] astype string," ",values[iCnt] astype double);	end;	print("Value99 : ",value99:8:4);end;``
Printing Out the Dictionary

And then I can simply index into the vectors to print out their contents.  I will add some more commentary on this post a little later this week.  I hope you find this useful.  And remember this will not work with MultiCharts.

# Tired of Manipulating Arrays – Try a Vector and a Queue

## Vectors:

An array like structure but are dynamic and have a plethora of tools at your disposal.  Arrays are cool and can be multi-dimensional and can be easily manipulated.  But they require a lot of forethought as to how much size to reserve for their implementation.  Now don’t think this is going to be an advanced EasyLanguage tutorial, because it’s really not.  Most of us TRS-80, Ti-99/4A, Vic-20 and Commodore 64 trained programmers of the early ’80s have not welcomed objects with open arms and that is really a mistake.  In this sense we are like cavemen – we have all of the rudimentary tools at our disposal and can create some really cool stuff and we can really understand what we are doing.  With time and effort, we can get to the same place as object-oriented programmers.  We just don’t like the concept of using other’s tools as much as we like using ours.  So if you aren’t classically trained in programming you may have an advantage when tieing into the objects of a programming language.  This little tutorial is a very brief glimpse into a whole different world of programming.  The beauty is you can combine “old school” programming with objects – even if you don’t understand how the objects are truly constructed.    I want to introduce the concept of the Vector and the Queue-  truly cool Swiss Army knives.  First the vector.  Let’s just jump into some of the code – it really is simple.

##### Object Instantiation – a long word for declaring variable:
``Using elsystem.collections;Vars: Vector opVector(NULL),      Vector hiVector(Null),      Vector loVector(Null),      Vector clVector(Null),      Vector barVector(Null),      Queue timeStampQue(Null);OnceBegin	barVector = new Vector;	opVector = new Vector;	hiVector = new Vector;	loVector = new Vector;	clVector = new Vector;	timeStampQue = new Queue;end;``
Instantiating and Declaring Vectors and Queue

You have to tell EasyLanguage you want to use some of the tools in the elsystem.collections.  You do this by simply tell it you are Using elsystem.collections.  The word collections is a catch-all for a bunch of different types of data structures.  Remember data structures are just programming constructs used to hold data – like an array.  All the variables that you declare in EasyLanguage are arrays – you just aren’t really aware of it.   When you index into them to get prior values then you become slightly aware of it.  In this portion of code, I create five vectors and one queue and assign them the Null or an empty value.  I just finished a programming gig where I had to build dynamically sized bars from the base data.  Kind of like creating 15, 30, 60-minute bars from a 5-minute bar chart or stream.   I did this using arrays because I wanted to be able to index into them to go back in time and I didn’t how far I wanted to go back.  So I declared some arrays with large dimensions to be safe.  This really takes a bite out of your resources which costs space and time.  I had played with Vector like objects in Python, so I thought I would post about them here and show how cool they are.  Remember this is a rudimentary program and could be streamlined and cleaned up.  Each vector will store their respective time, open, high, low and close values of the combined bar.  In a later post, I would like to do this with a Dictionary.  So the opVector will hold the open price, the hiVector will hold the high price and so on.

### Build a Queue – why the extra ue?

I want to build 15-minute bars from 5-minute bars so I need to know when to sample the data to properly collect the corresponding data.  If I start at 9:30 then I want to sample the data at 9:45 and look back three bars to get the open and the highest high and the lowest low.  The close will simply be the close of the 9:45 bar.  I want to do this at 9:45, 10:00. 10:15 and so on.  I could manipulate the time and use the modulus function to see if the minutes are multiples of 15 and I tried this but it didn’t work too well.  So I thought since I was already in the collections why not build a list or a queue with all the timestamps I would need.  This is how I did it.

``vars: hrs(0),mins(0),barMult(3),combBarTimeInterval(0),totBarsInHour(0),startTime(930),endTime(1615),cnt(0);OnceBegin	mins = fracPortion(t/100);	combBarTimeInterval = barInterval*barMult;	While value1 < endTime	Begin		cnt = cnt + 1;		Value1 = calcTime(startTime,cnt*combBarTimeInterval);//		print("Inside queue : ",Value1," ",cnt*combBarTimeInterval);		timeStampQue.Enqueue(Value1);	end;	end;``
Populating A Queue With Time Stamps

I simply use the CalcTime function to add 15-minute intervals to the start time and then I add them to the queue:  timeStampQue.Enqueue(Value1);  You access the methods or tools to a class by using the dot (” . “) notation.  Once I instantiated or created the timeStampQue I gained access to all the tools that belong to that object.  The Enqueue method simply appends the list the value that you pass it.  I would have preferred the method to be labeled simply add.  How did I figure out the right method name you ask?  I accessed the Dictionary from the View menu in the TDE.  Here is a picture to help:

#### Dictionary:

I use the keyword Once to just execute the code one time.  You could have said if BarNumber = 1, but why not use the tools at your disposal,   I figured out the combBarTimeInterval by using the 5-minute bar multiplier (3).  I then looped from startTime to endTime in 15-minute intervals and stored the timeStamps in the queue.  So every time stamp I need is in the timeStampQue.  All I need now is to compare the time of the 5-minute bar to the time stamps inside the queue.  This is where using object really come in handy.

#### Queue Methods:

Old school would have looped through all of the elements in the list and compared them to the value I was seeking and if found it would return true.  In the object world, I can simply ask the object itself to see if the value is in it:

condition1 = timeStampQue.Contains(t);

Cool!  If condition1 is true then I know I am sitting on the 5-minute bar that shares the same timestamp as a 15-minute bar.  If the time stamps are the same then I can start building the large timeframe from the lower timeframe.  You add elements to a vector by using the insert method.  I simply looked it up in the dictionary.   I had to specify where to insert the value in the vector.  I simply inserted each value into the [0] location.  Remember we are inserting so everything else in the vector is moved down.

#### Vector Methods:

``If condition1 thenBegin	barVector.insert(0,t);	opVector.insert(0,open[2]);	hiVector.insert(0,highest(h[0],3)); 	loVector.insert(0,lowest(l[0],3));	clVector.insert(0,close[0]);end;``
Inserting Values at Vector Location 0

I only need to keep track of the last 10 15-minute bars, so once the vector count exceeded 10, I simply popped off the value at the back end – pop_back().  I figured this out by looking at Martin Whittaker’s awesome website – www.markplex.com.

``If opVector.Count > 10 then begin    barVector.pop_back();	opVector.pop_back();	hiVector.pop_back();	loVector.pop_back(); 	clVector.pop_back();end;``
Popping the Back-End

To check my work I printed the 15-minute bars on each 5-minute bar to make sure the bars were being built properly.  These data structures expect an object to be inserted, added, popped so when you print out one of their values you have to tell the print statement what the object should be translated as.  Here the keyword asType comes into play.  Take a look at my code, and you will see what I mean.  I hope this gets you excited about objects because the collections class can save you a ton of time and is really cool.  Use it and you can brag that you are an OOP programmer at your next cocktail party.

###### Code Listing:
``Using elsystem.collections;Vars: Vector opVector(NULL),      Vector hiVector(Null),      Vector loVector(Null),      Vector clVector(Null),      Vector barVector(Null),      Queue timeStampQue(Null);OnceBegin	barVector = new Vector;	opVector = new Vector;	hiVector = new Vector;	loVector = new Vector;	clVector = new Vector;	timeStampQue = new Queue;end;vars: hrs(0),mins(0),barMult(3),combBarTimeInterval(0),totBarsInHour(0),startTime(930),endTime(1615),cnt(0);OnceBegin	mins = fracPortion(t/100);	combBarTimeInterval = barInterval*barMult;	While value1 < endTime	Begin		cnt = cnt + 1;		Value1 = calcTime(startTime,cnt*combBarTimeInterval);//		print("Inside queue : ",Value1," ",cnt*combBarTimeInterval);		timeStampQue.Enqueue(Value1);	end;	end;				condition1 = timeStampQue.Contains(t);Print(d," ",t," ",condition1);If condition1 thenBegin	barVector.insert(0,t);	opVector.insert(0,open[2]);	hiVector.insert(0,highest(h[0],3)); 	loVector.insert(0,lowest(l[0],3));	clVector.insert(0,close[0]);end; If opVector.Count > 10 then begin    barVector.pop_back();	opVector.pop_back();	hiVector.pop_back();	loVector.pop_back(); 	clVector.pop_back();end;vars:vectCnt(0);print(d," ",t);If opVector.Count > 9 thenBegin	For vectCnt = 0 to 9 	begin		print(vectCnt," ",barVector.at(vectCnt) astype int," ",opVector.at(vectCnt) astype double," ",hiVector.at(vectCnt) astype double," ",loVector.at(vectCnt) astype double," ",clVector.at(vectCnt) astype double);	end;end;``
Program in its Entirety