custom indicator tutorial
TRANSCRIPT
Tutorial: Creating Custom Indicator with Forex Strategy Builder
by Denny Imanuel
1. Preparing the Tools
Forex Strategy Builder indicators are developed in C# (CSharp) Language. So the basic C# programming knowledge is
necessary if you want to develop a custom indicator on this platform. In this tutorial I assumed that the reader has
the basic knowledge of C# programming language. If you need to learn the C# programming language you can find a
lot of free resources in internet. In order to develop the indicator firstly you need the C# IDE (Integrated
Development Environment) software, such as:
1. Notepad: a basic ASCII editor.
2. Notepad++: free source code editor that support several programming language downloadable from
Sourceforge website.
3. Visual C# Express Edition: a free version of Visual Studio downloadable from Microsoft website.
Forex Strategy Builder comes in bundle with the debugger, so all you need is just the ASCII editor and may be syntax
checker. And for this tutorial purpose we will use Notepad++. How to use these softwares is beyond this tutorial
topic.
Next you need to download the basic original indicator source code from Forexsb website. These original indicators
are your template to create your own custom indicator. So all you need to do is to select one of the original
indicators that most suitable to your current indicator. You don’t need to write all the code from scratch.
2. Understanding the Original Indicator Code Structures
Let’s open up one of the original indicator source code for an example “Momentum.cs”. You can narrow down the
sourcode view by clicking minus sign below the procedure in order to see the overall structures of the code as shown
below.
The momentum indicator consists of Momentum main class declaration inside namespace Forex_Strategy_Builder.
One indicator must be represented by one class. And inside this Momentum class there are four main procedure:
− Momentum(), this is a constructor procedure which contains class initiation. When you set the indicator’s
input parameters on FSB (setting the indicator logic, choosing the smoothing method, setting the period
value), this procedure is executed. Your custom indicators parameters input should be located here. This
procedure is only called once when the indicator is loading.
− Calculate(), this is the main procedure for the indicator where the indicator algorithm is performed. Your
main custom indicator code should be located here. This procedure is called repeatedly on tick by tick basis
when the backtesting is simulated on FSB or trading is performed in FST.
− SetDescription(), this is the additional part of the indicator which lest important to take a look currently. It
contains the strategy overview and description. This procedure is called when you click the strategy
overview on the FSB.
− ToString(), this is also the minor part of the indicator which shows the label name for the indicator which
displayed on the top left corner of charts data.
Constructor() Procedure
So let’s focus on the first two procedure and take a look at the breakdown. On the beginning of this procedure
the IndicatorName is set to “Momentum” and then the new object IndParam is created.
The IndParam object consists of SlotType parameter which describe which slot the indicator can be applied to.
The possible value will be: SlotType.Open, SlotType.Close, SlotType.OpenFilter, SlotType.CloseFilter, as show on
the picture below.
The IndParam object consist of ListParam which represent the list box control, NumParam which represent the
up down numeric control, CheckParam which represent the checkbox control.
IndParam.IndicatorName
IndParam.ListParam[0]
IndParam.ListParam[1] IndParam.ListParam[2]
IndParam.NumParam[0]
IndParam.NumParam[2]
IndParam.NumParam[1]
IndParam.CheckParam[2]
SlotType.Open
SlotType.Close
SlotType.OpenFilter
SlotType.CloseFilter
Calculate() Procedure
Calculate() procedure is the main calculation of the overall indicator. Here you will see four major portion of the this
procedure, as shown on the picture below:
1. Initiation Part, in this part, some of the parameters selected on the input controls are transferred to the
initial variables, and some of the initial variables are initiated.
2. Calculation Part, this is where the actual indicator calculation is scripted. So, as the programmer you can
focus on this part more. Usually the indicator is calculated on an array of bars from the first bar until the last
bar. So the loop start from iFirstBar (that you must initiate) and end before the number of bar represented
by Bars: for(int iBar = iFirstBar; iBar<Bars; iBar++)
{
adMomentum[iBar] = … ;
}
3. Component Creation, in this part, the components are created and the calculation data is stored in these
components. These components can either represent the indicator value which will be used as a chart plot
data or represent the trading signal which will be used as trading entry or exit signal.
a. Plotting the Graph:
- If the Component.DataType=IndicatorValue then the data stored in Component.Value will be
passed to the chart to be plotted. There are a few chart types are available: Component.ChartType=IndChartType.Line;
Component.ChartType=IndChartType.Histogram;
Component.ChartType=IndChartType.Level;
Component.ChartType=IndChartType.CloudUp;
Component.ChartType=IndChartType.CloudDown;
b. Setting the Trading Signal:
- Otherwise, the data stored in Component.Value will be used as trading signals, which generates
opening or closing position for specific slot type as follows:
Component.DataType=OpenPrice � SlotType.Close
Component.DataType=ClosePrice � SlotType.Open
Component.DataType=AllowOpenLong/AllowOpenShort � SlotType.OpenFilter
Component.DataType=ForceCloseLong/ForceCloseShort � SlotType.CloseFilter
1
2
3a
4. Execution of Logic, the last portion of the Calculate() procedure consist of standard logic depending on what
type of indicator being executed. If the indicator is oscillator type then use OscillatorLogic() method, and if
indicator is band type then use BandIndicatorLogic(), if it is a non directional indicator you can use
NoDirectionOscillatorLogic(). May be some combination can be used depending on the usage. Available
method are:
OscillatorLogic()
NoDirectionOscillatorLogic()
BandIndicatorLogic()
IndicatorRisesLogic()
IndicatorFallsLogic()
IndicatorIsHigherThanAnotherIndicatorLogic()
IndicatorIsLowerThanAnotherIndicatorLogic()
IndicatorCrossesAnotherIndicatorUpwardLogic()
IndicatorCrossesAnotherIndicatorDownwardLogic()
BarOpensAboveIndicatorLogic()
BarOpensBelowIndicatorLogic()
BarOpensAboveIndicatorAfterOpeningBelowLogic()
3b
4
BarOpensBelowIndicatorAfterOpeningAboveLogic()
BarClosesAboveIndicatorLogic()
BarClosesBelowIndicatorLogic()
This logic is the smart brain where your indicator rising up or falling down, crossing up or crossing down, etc.
are executed. You don’t need to worry about this logic at the moment because you only need to modify the
available indicators, so you don’t need to write your own program from scratch on this part.
3. Modifying the Original Indicator and Create a Custom Indicator
Now, let’s try to make a simple indicator. For an example, you want to make an indicator that count up when the
price is increasing and counting down when the price is decreasing. We call it as directional counter indicator. So,
you can conceptualize your code in the pseudo code as follow:
- If Current Close > Current Open then Counter = Counter + 1;
- If Current Close < Current Open then Counter = Counter – 1;
However the counter value must reset to zero when the price is reverse it’s direction.
- If (Current Close > Current Open) and (Previous Close < Previous Open) then Counter=0;
- If (Current Close < Current Open) and (Previous Close > Previous Open) then Counter=0;
And when this code is translated into the C# with loop from first bar to last bar it feels and appears like below:
for (int iFirstBar; iBar<Bars; iBar++)
{
if (Close[iBar]>Open[iBar] && Close[iBar-1]<Open[iBar-1]) adCounter[iBar] = 0;
if (Close[iBar]<Open[iBar] && Close[iBar-1]>Open[iBar-1]) adCounter[iBar] = 0;
if (Close[iBar]>Open[iBar]) adCounter[iBar] += 1;
if (Close[iBar]<Open[iBar]) adCounter[iBar] += 1;
}
Don’t worry whether this code is correct or not because you are going to debug it later. Imagine that the resulting
array will produce a double side sawtooth wave, and the indicator logic that we can use is oscillator indicator. So, we
can use Momentum Indicator as a template for our new indicator. You can use another type of indicator depends on
your preference, but make sure that the logic is still using oscillator type.
The first step is to open “Momentum.cs” file and save it into a new filename, let’s say “Directional Counter.cs”. Then
change the class name, constructor name, indicator name, and don’t forget to insert CustomIndicator = true;
Then replace all the “Momentum” words inside the code with “DC” which stand for Directional Counter.
Take a look at the Indicator Parameter part of the program, and check whether you need to add some parameters or
delete some parameters. In this case we don’t need the” Smoothing Method”, “Base Price”, and ”Period “parameter,
so we can delete portion of code related to this parameter on the whole of part of the program. However, we want
to retain “Level” and “Use Previous Bar” parameter.
Special note: “Use Previous Bar” is standard parameter that must be available for all the indicators, the reason is that the last bar is
always changing from tick to tick, so we can’t use this bar to do the calculation before this bar is fully closed, because it will generate
false entry and exit signal. That the reason why we can only use the previous bar.
DELETE
DELETE
You need to delete or change the initialization part of the indicator the calculation part of the indicator. Then after
that, inserting your own indicator calculation and initiation of the variables used in the calculation. And finally, don’t
forget to pass on the resulting calculation array, in this case adCounter, to the component to be plotted.
May be you need to check the Indicator Logic part of the Calculate() procedure if some changes needed. On this case,
we do not need to change this part. And also check on the SetDescription() part of the program and finally on the
ToString() part of the program for some changes might be required. In the ToString() procedure, we need to make a
slight change because we already deleted some of the ListParam and NumParam above.
4. Debugging the Code
Now the program is already finish, however we are not sure whether it is correct or not, so we must debug it. Before
debugging, we must put the program on the “Custom Indicator” folder of your Forex Strategy Builder installation
folder. Now you can run Forex Strategy Builder after the custom indicator located on this folder. Forex Strategy
Builder automatically runs and compiles the custom indicator during start-up and display all the error message.
And from the displayed error message you can refer to which line and column part of the program does the error
comes from. In our case above the iBar, iFirsBar, and adCounter are not initiated, and the adMomentum is not fully
replaced by adCounter. So we need to do the necessary correction and after that you don’t need to re-run the Forex
Strategy Builder anymore in order to recompile the program, you can save the code and then press Ctrl+I shortcut in
the Forex Strategy Builder to recompile the program.
After debugging it seems that the data is not displayed properly even though there is no error message. So there
must be something wrong with the algorithm. We have to check again the source code and find out that the data is
not reset-ing as required. Because adCounter[iBar]+=1 is actually the same with adCounter[iBar]=adCounter[iBar]+1,
and the adCounter[iBar], is actually empty even after each loop is increased. So now, we change the algorithm of the
code by inserting a dCounter variable and it’s initiation as shown below.
Finally, you want the data to be displayed as histogram so you need to change this portion of the code.
Ok, after recompiling (press Ctrl+I on FSB), and add your indicator, you can see on the graph below your indicator is
increasing its value by one-step when the price bar is increase (white bar) and decreasing its value by one-step when
the price bar is decrease (black bar). And it will reset the value to zero when the price bar is reverse, or turning black
to white or turning white to black. So, congratulation! You have made a great job!
So until here is my tutorial. Try your own indicator idea and don’t forget to upload your indicator to our website
forum and share with others.
Warmest Regards,
Denny Imanuel