In all but the simplest applications the Switch() is the preferred method to the IF() to change program flow. It can be used to code complex decision trees and state machines, for example as these are often needed in automated trading systems.

For more detailed explanations click IF(), IIF(), or Switch(). A search of the afl library will also get you many more examples.

The IIF() function

It is possible to use if()s to individually test and modify each bar in an array for a condition. An example on how this would be done is shown in the function below (copied from the AmiBroker help). This function is an AFL equivalent for the IIF() function.

1
2
3
4
5
6
7
8
9
10
11
12

function IIF_AFL( condition, inputA, inputB )
{
    result = Null;
    for( bar = 0; bar < BarCount; bar++ )
    {
       if( condition[ bar ] )
           result[ bar ] = inputA[ bar ];
       else
           result[ bar ] = inputB[ bar ];
     }
    return result;
}

While the above approach works, using the IIF() function always provides a better and faster solution. The IIF() is very powerful and should be used whenever possible. Below are a few simple examples to get started. btw, It is highly unlikely that you will be able to improve on execution time by using a loop or writing a DLL.

To color all bars that fall on a Monday White:

1
2

Color = IIf( DayOfWeek()==1, colorWhite, colorBlack);
Plot( C, "Close", color, styleBar );

IIF()s Can be nested. This example colors Monday bars White, Wednesday bars Blue and Friday bars Yellow:

1
2
3

D = DayOfWeek();
Color = IIf(D==1, colorWhite, IIf(D==3, colorBlue, IIf(D==5, colorYellow, colorBlack)));
Plot( C, "Close", color, styleBar );

The IF() Statement

One of the most common applications for the if() is to select what you want to see on your chart:

1
2
3
4
5
6
7
8
9
10
11
12

 
Plot( C, "Close", colorBlack, styleBar );
ShowMA10 = ParamToggle( "Moving Average", "MA|EMA", 0 );
 
if ( ShowMA10 )
{
Plot( MA( C, 10 ), "MA10", colorWhite, styleLine );
}
else
{
Plot( EMA( C, 10 ), "MA10", colorWhite, styleLine );
}

In the above example the IF() basically selects one of two sections of code.  To select one of many options you could the use the else-if extension:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 
SelectedIndicator = ParamList( "Show", "MA10,MA50,MA100", 1 );
 
if ( SelectedIndicator == "MA10" )
{
Plot( MA( C, 10 ), "MA10", colorBlue, styleLine );
}
else
if ( SelectedIndicator == "MA10" )
{
Plot( EMA( C, 50 ), "MA10", colorRed, styleLine );
}
else
if ( SelectedIndicator == "MA100" )
{
Plot( EMA( C, 100 ), "MA100", colorYellow, styleLine );
}

The Switch() Statement

When there are many conditions, the lengthy If() expressions can become confusing, difficult to compose, and difficult to modify. In such cases it is often better to use the Switch() statement. Using a simple Switch() the last example looks much cleaner:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 
SelectedIndicator = ParamList( "Show", "MA10,MA50,MA100", 1 );
switch ( SelectedIndicator )
{
 
case "MA10":
Plot( MA( C, 10 ), "MA10", colorBlue, styleLine );
break;
 
case "MA10":
Plot( MA( C, 50 ), "MA50", colorBlue, styleLine );
break;
 
case "MA10":
Plot( MA( C, 100 ), "MA100", colorBlue, styleLine );
break;
}

There are times that you will have many individually named variables that you would like to process in a Switch() statement. Even though the Switch() can only accept a single variable name as argument you can use the method below to work around this limitation:

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
30
31
32
33
34
35

function SayOnce( Text )
{
    if ( StaticVarGetText( "Lastsay" ) != Text )
    {
        Say( Text, False );
        StaticVarSetText( "LastSay", Text );
    }
}
 
RequestTimedRefresh(1);
Trigger1 = ParamTrigger( "Trigger 1", "TRIGGER1" );
Trigger2 = ParamTrigger( "Trigger 2", "TRIGGER2" );
Trigger3 = ParamTrigger( "Trigger 3", "TRIGGER3" );
Trigger4 = ParamTrigger( "Trigger 4", "TRIGGER4" );
 
switch( 1 )
{
    case Trigger1:
    SayOnce( "One" );
    break;
 
    case Trigger2:
    case Trigger4:
    SayOnce( "2 or 4" );
    break;
 
    case Trigger3:
    SayOnce( "Three" );
    break;
 
    default:
    SayOnce( "Default" );
    // Here you can place code that will execute
    // repeatedly while no other case is true
}

The Switch() argument can be a string or number. Using strings makes code easier to read. Another advantage of using the Switch() is that they format nicely using Edit->Prettify Selection in you editor window, using too many else-if statements tends to run the if()s of the page. As shown above you can stack case statements to have multiple conditions trigger the same task.

To implement a simple State Machine you pass the system “state” to the Switch(). This way you can have any event trigger any sequence of tasks, and do so in any desired order. In a real application the SayOnce() functions in the example code below would be replaced by the task you want to be performed in the state. The next state would usually be conditionally set inside each state, for example you only want to proceed to the next state after an order is filled, or a price is crossed. You can use multilevel Switch()s or if()s inside each case section. This use of Switch() statements is very useful in Automated Trading systems. For example to process order status (Pending, Filled, Error, etc) and parsing TWS error messages.

Since states are saved in a Static Variables they remain valid over multiple AFL executions, and can last indefinitely. You can also save states in Persistent Variables.

States are processed in sequential afl executions, i.e., if you change the state in a case statement this next state will be processed in the next AFL refresh. In some applications this delay can cause problems. To ensure responsive code you might want to use a 0.1 second refresh rate. You could remove the delay by using the Switch() inside a loop/while statement, anf loop until a stable state is reached.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

function SayOnce( Text )
{
    if ( StaticVarGetText( "Lastsay" ) != Text )
    {
        Say( Text, False );
        StaticVarSetText( "LastSay", Text );
    }
}
 
RequestTimedRefresh(1);
if( ParamTrigger( "Reset System", "RESET" ) ) StaticVarSetText( "State", "RESET" );
if( ParamTrigger( "Task 1", "TASK 1" ) ) StaticVarSetText( "State", "TASK1" );
if( ParamTrigger( "Task 2", "TASK 2" ) ) StaticVarSetText( "State", "TASK2" );
if( ParamTrigger( "Task 3", "TASK 3" ) ) StaticVarSetText( "State", "TASK3" );
 
State = StaticVarGetText( "State" );
switch( State )
{
    case "RESET":
    SayOnce( "Reset" );
    StaticVarSetText( "State", "READY" );
    break;
 
    case "READY":
    SayOnce( "Ready" );
    StaticVarSetText( "State", "IDLE" );
    break;
 
    case "TASK1":
    SayOnce( "Task 1" );
    StaticVarSetText( "State", "IDLE" );
    break;
 
    case "TASK2":
    SayOnce( "Task 2" );
    StaticVarSetText( "State", "TASK1" );
    break;
 
    case "TASK3":
    SayOnce( "Task 3" );
    StaticVarSetText( "State", "TASK2" );
    break;
 
    case "IDLE":
    SayOnce( "Idle" );
    break;
}

To be worked on:

1. In Bar-Replay you can only place one trade/bar. I don’t think it is possible to changes this.
2. The Backtester doesn’t scale in/out as the TWS would. This may be solved later.
3. The code has not been optimized for speed, this may be a problem for some of you. I am using TDash with a 60-day 5-Sec Local DB — so far no major problems.
4. Buttons for functions yet to be implemented are grayed-out.

Coding level:

Demo Video:

TDash Features:

1. Modify Pending orders by dragging their Markers
2. Increment/Decrement price, and Cancel pending orders from the markers
3. Place multiple orders to scale in/out (But Backtester code is not ready for scaling yet)
4. A floating order bar (QBar) to place MKT, LMT, and STP orders
5. When placing a LMT order at the wrong side of the price the order changes to a MKT. This allows you to place MKT and LMT orders without having to change type each time.
6. The use of composites to log multiple trading sessions for long term Backtesting
7. 3D buttons for Trigger, Toggle, and Rotate functions
8. Flexibility in custom sizing all objects
9. Auto-sizing of button layout
10. Ability to dynamically hide/show buttons and button groups
11. Use button to control indicators on the main chart
12. Optional Auto-Backtests when an order is filled to create real-time tradelists and statistics

Misc. Notes:

For the arrows to display properly you need to set Preferences -> Intraday -> “Time of first tick inside bar” or “START time of interval”. Be sure to select REPLAY data by setting the DATA selector in the SETUP button group to REPLAY.

The look of buttons and their layout can be changed in the Parameter window. These parameters are for experimenting, they can be hard-coded when you have decided what you want. To prevent very large buttons when you are re-sizing the TDash pane you can set their maximum height and width in the Parameter window. Button functions have arguments to place buttons groups anywhere in the window/pane.

You can change many other features, like button shape and shadow width, group header height, colors etc. You can make similar adjustments for the QBar and markers. In addition to the settings in the Parameter window the Button3D() function has size, offset, and color arguments you can change from afl. Using these functions you can create dynamically configured button panels, i.e., show/hide buttons or groups, change dimensions and color, to meet virtually any requirement.

At this time there are only three button functions: Trigger, Toggle, and Rotate. The Rotate button is used to select items from a short list. Buttons states are persistent. Grayed-out buttons are not functional yet, or are deactivated from afl because they are not required in the current button layout.

To learn more about buttons, toggle TIPS in the SETUP group to ON, and hover your cursor over the buttons. Except for MKT orders the QBar tracks your vertical cursor position. When MKT type is selected (in the ORDERS button group) the QBar position is fixed at the vertical center of the TDash window and orders will be placed at the last price. LMT@LastPrice or a STP order. For the moment the number of shares traded is set in the parameter window.

STP and LMT prices are monitored during Bar-Replay and fill when the price crosses the threshold. MKT orders will fill immediately. Bracket orders and Pattern orders haven’t been implemented yet. Pattern orders you probably haven’t heard of yet: a pattern order can contain a complex order pattern and are very handy when trading fast, it allows you to place any number of orders with a single click.

Markers for pending orders have a point to the left, a Position Marker is pointed at both ends. Order markers can be dragged; incremented, decremented, and canceled from pop-up controls that appear when you hover your cursor to the right of the marker.

Position Markers have a colored line extending onto the main chart that ends at the entry arrow. Inside the TDash window there is a small profit histogram that shows you current trade profit. If this histogram doesn’t show adjust the X-Offset for Markers to make space.

To run this code you need to apply the TDashMain104.afl to the left top window, the TDash104.afl to the right top window, and TDashInclude104 to the indicator pane below the TDash window (the include is only shown for easy access). The left bottom window can be used for other indicators. To run Auto/Manual Backtests you need to copy TDashBacktest.js to the \TDash\JS folder in your AmiBroker folder

Eventually the TDash window will be extended to the right (perhaps place or extend it on another monitor) to make room for a collection of custom gfx trading indicators.

I use small solid triangles for Buy and Sell signals, and hollow triangles for Short and Cover signals. This allows me to overlay the Buy and Cover signals, and the Sell and Short signals, to display trade reversals. The triangles are placed at the actual trading price (the Close in this example). This is what the arrows look like:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

_SECTION_BEGIN( "USING A TRADE COMPOSITE" );
function DeleteComposite( CompositeName )
{
    global Ticker;
    oAB = CreateObject( "Broker.Application" );
    oStocks = oAB.Stocks();
    oStocks.Remove( CompositeName );
    oAB.RefreshAll();
}
 
function  AddTradeToComposite( Ticker, Action, LMTPrice )
{
    global Ticker;
    BI  = BarIndex();
    LBI = LastValue( BI );
 
    if ( Action != "" )
    {
        SignalArray = Nz( Foreign( Ticker + "~SignalArrays", "V", False ) );
        BuyPriceArray = Nz( Foreign( Ticker + "~SignalArrays", "O", False ) );
        SellPriceArray = Nz( Foreign( Ticker + "~SignalArrays", "H", False ) );
        ShortPriceArray = Nz( Foreign( Ticker + "~SignalArrays", "L", False ) );
        CoverPriceArray = Nz( Foreign( Ticker + "~SignalArrays", "C", False ) );
 
        switch ( Action )
        {
 
            case "BUY":
                SignalArray[LBI] = SignalArray[LBI] | 1;
                BuyPriceArray[LBI] = LMTPrice;
                break;
 
            case "SELL":
                SignalArray[LBI] = SignalArray[LBI] | 2;
                SellPriceArray[LBI] = LMTPrice;
                break;
 
            case "SHORT":
                SignalArray[LBI] = SignalArray[LBI] | 4;
                ShortPriceArray[LBI] = LMTPrice;
                break;
 
            case "COVER":
                SignalArray[LBI] = SignalArray[LBI] | 8;
                CoverPriceArray[LBI] = LMTPrice;
                break;
 
            case "REVLONG":
                SignalArray[LBI] = SignalArray[LBI] | 8 | 1;
                CoverPriceArray[LBI] = BuyPriceArray[LBI] = LMTPrice;
                break;
 
            case "REVSHORT":
                SignalArray[LBI] = SignalArray[LBI] | 2 | 4;
                SellPriceArray[LBI] = ShortPriceArray[LBI] = LMTPrice;
                break;
        }
 
        AddToComposite( SignalArray, Ticker + "~SignalArrays", "V", 7 | atcFlagEnableInIndicator );
        AddToComposite( BuyPriceArray, Ticker + "~SignalArrays", "O", 7 | atcFlagEnableInIndicator );
        AddToComposite( SellPriceArray, Ticker + "~SignalArrays", "H", 7 | atcFlagEnableInIndicator );
        AddToComposite( ShortPriceArray, Ticker + "~SignalArrays", "L", 7 | atcFlagEnableInIndicator );
        AddToComposite( CoverPriceArray, Ticker + "~SignalArrays", "C", 7 | atcFlagEnableInIndicator );
    }
}
 
Ticker = Name();
Action = "";
 
if ( ParamTrigger( "Buy", "BUY" ) ) Action = "BUY";
if ( ParamTrigger( "Sell", "SELL" ) ) Action = "SELL";
if ( ParamTrigger( "Short", "SHORT" ) ) Action = "SHORT";
if ( ParamTrigger( "Cover", "COVER" ) ) Action = "COVER";
if ( ParamTrigger( "Reverse to Long", "REVLONG" ) ) Action = "REVLONG";
if ( ParamTrigger( "Reverse to Short", "REVSHORT" ) ) Action = "REVSHORT";
if ( ParamTrigger( "Delete Signal Compoiste", "DELETE" ) ) DeleteComposite( Ticker + "~SignalArrays" );
AddTradeToComposite( Ticker, Action, LastValue( Close ) );
 
RequestTimedRefresh( 0.1 );
if ( SetForeign( Ticker + "~SignalArrays" ) )
{
    SignalArray	= Nz( Foreign( Ticker + "~SignalArrays", "V", False ) );
    Buy 		= IIf( SignalArray & 1, 1, 0 );
    Sell 		= IIf( SignalArray & 2, 1, 0 );
    Short 		= IIf( SignalArray & 4, 1, 0 );
    Cover 		= IIf( SignalArray & 8, 1, 0 );
 
    BuyPrice 	= Nz( Foreign( Ticker + "~SignalArrays", "O" ) );
    SellPrice 	= Nz( Foreign( Ticker + "~SignalArrays", "H" ) );
    ShortPrice	= Nz( Foreign( Ticker + "~SignalArrays", "L" ) );
    CoverPrice 	= Nz( Foreign( Ticker + "~SignalArrays", "C" ) );
 
    PlotShapes( IIf( Buy, shapeSmallUpTriangle, shapeNone ), 5, 0, BuyPrice, 0 );
    PlotShapes( IIf( Sell, shapeSmallDownTriangle, shapeNone ), 4, 0, SellPrice, 0 );
    PlotShapes( IIf( Short, shapeHollowDownTriangle, shapeNone ), 4, 0, ShortPrice, 0 );
    PlotShapes( IIf( Cover, shapeHollowUpTriangle, shapeNone ), 5, 0, CoverPrice, 0 );
 
}
RestorePriceArrays();
 
Plot( C, "", 1, 128 );
_SECTION_END();

The QBar is a small tool bar that tracks the Y-position of the cursor. It is designed for fast real-time trading and has only three buttons: Buy, Sell, and Reverse. You can add/delete buttons, for example, you could add a button to Cancel the last order placed. Order parameters are set in the Control panel.

The main advantage of the QBar is that you can place an order with a single-click. You do not have to move your eyes away from the last bar on your chart to place the order, you simply move your mouse cursor to the required price and click.

The QBar and the Order Markers share some functionality. The main difference is that the QBar is designed for placing new orders, and that the Order Markers are designed to display and modify pending orders.

The QBar has two display modes:

1. Auto-Hide Off. The QBar displays continuously. When the cursor moves out of the QBar area the QBar remains in its last position.
2. Auto-Hide ON. The QBar displays only when the cursor is in the Qbar area, i.e., in the vertical column space reserved for the QBar. When the cursor leaves the QBar area, it remains positioned at the last price selected. This mode allows the display of trade and system information in the QBar area when the QBar is auto-hidden.

The QBar also has an “Auto Modify” mode. When this is turned on you can place an order and, holding down the left mouse button, drag the QBar to a new price. As long as you keep the mouse button down the order on the TWS will be modified, in real-time, each time the price changes.

Below is a short video that shows what the QBar looks like. I removed the Order markers while working on the QBar.

Because the cursor can only be in one location at a time, all TDash commands are exclusive. Hence we do not need to assign individual names to each parameter, instead we can use a single string variable to tell us the name of the button and action performed. Compared to using traditional Param()s, where each Param() assigns a value to a unique variable, this eliminates about 50-100 variable names, and allows us to use a single Switch() command to process the commands. It also makes code easier to read, modify, and maintain.

To make this work requires that buttons are organized as follows:

1. Buttons are assigned to uniquely named groups like “Markers”, “Menus”, “Trading”, “Setup”, “Account”, “Status”, etc. For example, the Order Markers covered in the previous post would fall in the “Marker” group, the forthcoming QBar controls will fall in the “QBar” group, etc.
2. All buttons must have an upper “Header”, and may have an optional lower “Label”. The visible header and label is unique to the group it belongs to. A typical example would be a Buy @ LMT button, “Buy” would be the Header, and “LMT” would be the lower Label. In this case the lower label may take on different values, such as “MKT”, “STP”, and “STPLMT”. Header-only buttons are typically used for trigger functions which have no changing state to display, for example “Reset” or “Abort” buttons.
3. Since all buttons respond to mouse movement and button clicks, buttons can have four possible possible action states:
   Hover: the cursor hovers over the button
   LeftClick: the left button is clicked while the cursor is over the button
   LeftDown: the left button is held down while the cursor is over the button (Dragging)
   LeftRelease: The left button is released while over the button

These four action states are encoded by prefixing a “~” for a Leftclick, “~~” for a LeftDown condition, and “~~~” for the LeftRelease. Concatenating the action prefix, group name, visible header string, and visible Label string into a csv string provides us with a “TDashAction” string that uniquely defines the button and its transient states. Because for multi-state buttons the lower label describes the state of the button, this string also tells us the state of the button. For additional clarity we can also change the button-color to indicate its state.

For example, dragging the Buy Order Marker shown in the previous post would, over consecutive executions, generate the following sequence of changes in the TDashAction variable:

Marker,Buy // cursor hovers over the button
~Marker,Buy // left-click on the button is detected
~~Marker,Buy // the left mouse button is down on the button (dragging)
~~~Marker,Buy // the left mouse button is released while over the button

This type of encoding is used for all TDash buttons and controls. While this method may be a little esoteric it makes reading the code very easy, and allows us to add controls without having to dream up a new set of variable names. We just look at the displayed TDashAction string and we know the name for the action to be decoded in our Switch().

This method makes decoding TDash action using a switch() simple and easy to debug. Note that in most cases not all possible states need a case statement. A major advantage of using a Switch() statement is that one can, at any time, easily add and/or remove buttons.

Below is a simple Switch(0 to decode the “Marker Buy” command used in the previous post:

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

TDashAction =  VarGetText( "TDashAction" );
 
switch ( TDashAction )
{
 
case "Marker,Buy":
    // perform tasks in response to hovering over the Marker
    _TRACE( "TDashAction: " + TDashAction );
    break;
 
case "~Marker,Buy":
    // Perform action in response to a left click on the Marker
    _TRACE( "TDashAction: " + TDashAction );
    break;
 
case "~~Marker,Buy":
    // React to dragging the marker
    _TRACE( "TDashAction: " + TDashAction );
    break;
 
case "~~~Marker,Buy":
    // Perform action in response to releasing the mouse button
    _TRACE( "TDashAction: " + TDashAction );
    break;
}

This function can be copied to an include file that is included in each program from which you might want to synchronize the datetime range for all visible windows. The function places a small [R] button at the right top of your chart. Clicking this button will set the datetime ranges of all windows equal to the one you click the button in. Note that this window has to be active for the button to work, i.e., if the window was not active (selected) it will require two clicks for the button to respond.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

function RangeAllWindows()
{
    MX = GetCursorXPosition( 1 );
    MY = GetCursorYPosition( 1 );
    LeftClick = GetCursorMouseButtons() == 9;
 
    // Place Ranging Button
    ButtonSize=20;
    X2 = Status( "pxchartright" )+1;
    X1 = X2 - ButtonSize;
    Y1 = 0;
    Y2 = Y1 + ButtonSize;
    GfxSelectFont( "Tahoma", ButtonSize / 1.5, 800 );
    GfxSelectPen( colorBlack , 1 );
    GfxSelectSolidBrush( colorYellow );
    GfxRectangle( X1, Y1, X2, Y2 );
    GfxSetTextColor( colorBlack );
    GfxSetBkMode( 1 );
    GfxDrawText( "R", X1, Y1, X2, Y2, 41 );
    OnButton = MX >= X1 AND MY >= Y1 AND MX <= X2 AND MY <= Y2;
 
    if ( OnButton AND LeftClick )
    {
        DT = DateTime();
        BI = BarIndex();
        FirstBarIndex = Status( "firstvisiblebarindex" );
        LastBarIndex = Status( "lastvisiblebarindex" );
        FirstDateTime = LastValue( ValueWhen( FirstBarIndex == BI, DT ) );
        LastDateTime = LastValue( ValueWhen( LastBarIndex == BI, DT ) );
        FirstDateTimestr = DateTimeToStr( FirstDateTime );
        LastDateTimestr = DateTimeToStr( LastDateTime );
        AB = CreateObject( "Broker.Application" );
        docs = AB.Documents;
        Qty = docs.Count;
 
        for ( i = 0; i < Qty; i++ ) // Range all windows
        {
            doc = docs.Item( i );
            AW = doc.ActiveWindow;
            AW.Activate();
            AW.ZoomToRange( FirstDateTimestr, LastDateTimestr );
            // correct shift due to blank bars
            WSHShell = CreateObject( "WScript.Shell" );
            WSHShell.AppActivate( "AmiBroker" );
            WSHShell.Sendkeys( "{PGDN}" );
        }
    }
}
 
//Demo Code
RangeAllWindows();
Plot(C,"",1,128);