Articles

A comparison between moving averages.

asimon — Fri, 06 Oct 2006 22:54:30 GMT

A comparison between moving averages.

Moving averages are used in Technical Analysis of the Forex or Stock Market to determine the direction of the trend. Less sensitive averages are used for establishing longer term trends. Conversely, shorter term averages indicate the direction of the shorter trend. Popular values for technicians are the 10, 20 and 50 day Simple Moving Averages (SMA).

This short article will explore the behavior of different moving averages when using a sinusoidal wave as input. Noise will be introduced to study how fast the indicators respond and how long they remember the anomalous values.

This graph shows the behavior of different averages when calculated using a sinusoidal wave oscillating from -1 to +1. Noise has been introduced to the sine wave at the first positive peak.

The averages plotted are:

Modified Average: A front weighted average: ( prev avg * 4 + input value ) / 5.
Average: A 5 period simple moving average.
Short Average: a 3 period simple moving average.
FMA: The Fast Moving Average, calculated as follows: (3 period SMA + (3 period SMA - 5 period SMA)).

The front weighted Modified Average indicator has the most lag of them all. It also does not reach the +1 and -1 extremes of the input signal. The 5 period and 3 periods moving averages track closer, but still show some lag.

The Fast Moving Average tracks closer to the input wave than the other averages and its two components. It reacts faster to the noise introduced in the signal and returns to tracking the sine wave sooner than the other averages. This simple indicator returns values similar to other fast moving averages such as the Hull Moving Average (HMA), or the Jurik Moving Average (JMA).

The C# .NET source code for the Simple Moving Average, Fast Moving Average and Hull Moving Average are included in the 4XLab.NET platform. The graph for this article has been plotted using Excel. The spreadsheet is available for download as an attachment. The implementation of the Jurik Moving Average is available through Jurik's Research website http://www.jurikres.com

Creating a Mechanical Trading System Part 3: Get real time quotes using DDE

asimon — Mon, 11 Sep 2006 00:27:27 GMT

Introduction

This is the third article in the series:
Creating a Mechanical Trading System Part 1: Technical Indicators
Creating a Mechanical Trading System Part 2: Four Percent Trading System
Creating a Mechanical Trading System Part 3: Get real time quotes using DDE

The first article in this series introduced a project to code mechanical trading system robots for the .NET platform using the C# language. The second article introduced how to code a trading system that will watch price action and make buying or selling decisions. This article shows how to obtain real time forex quotes for several currency pairs using the DDE protocol and the Metatrader 4 trading terminal.

It is the aim of this project to write a program that does not depend on any underlying platform to execute, but rather receives price data directly from a broker and places orders via an API.

The code provided here is part of a larger project to create a backtesting platform and an automated FOREX trading robot. Source code for this project is available at http://www.4xlab.net/

Background

DDE (Dynamic Data Exchange) is an interprocess communication system that enables two applications to share the same data. This mechanism is deprecated in favor of other alternatives such as OLE or COM. In financial applications, it is popular and DDE enabled applications are still being built. The interaction between a quote provider and a client is typically limited to receiving real time quotes. DDE is not used to get historical data or enter trades.

For a DDE dialog to occur, two applications must be running, the server, or provider of data, and the client, or consumer. If the server application is not running, the client connection attempts will fail. In this example, the server will be Metatrader Terminal 4.0, and the clients will be Microsoft Excel and the 4X DDE Client.

Connecting to Metatrader 4 using Excel:

The default installation of Metatrader does not enable the DDE server. It must be manually enabled once. To do so, click on Tools -> Options on the Server tab (selected by default), ensure the 'Enable DDE server' option is checked, click OK to save your options.

Once Metatrader is running, connected to a server, and its DDE server has been enabled, launch Excel. To test the connection, type in a cell =MT4|ASK!EURUSD , this command obtains the ASK quote for the EUR USD pair using the MT4 DDE server. The cell content should display the last ask price for the pair and automatically update this value in real time if everything is working properly. If Metatrader is not running, or the DDE server is not enabled, Excel will try to start it using the non existing MT4.exe filename, which will fail and #VALUE! or #REF! will be displayed in cells using live data.

Excel implements a DDE client with a syntax that is extremely easy to use and helps in debugging. To communicate, the client needs to know the DDE Application name, the DDE Topic, and the DDE Item. To make a request, the syntax is as follows: =DDEAppName|DDETopic!DDEItem

To communicate with Metatrader 4, the DDEAppName is MT4, the DDETopic is one of the commands listed below and the DDEItem is the currency pair you are interested in.

MT4 DDE Topics

BID
Item: Currency Pair Example: =MT4|BID!USDCHF Sample Output: 1.2472
Returns the BID or selling price for the pair
ASK
Item: Currency Pair Example: =MT4|ASK!GBPUSD Sample Output: 1.8656
Returns the ASK or buying price for the pair
HIGH
Item: Currency Pair Example: =MT4|HIGH!EURUSD Sample Output: 1.2873
Returns the High price for the pair
LOW
Item: Currency Pair Example: =MT4|LOW!USDJPY Sample Output: 115.95
Returns the Low price for the pair
QUOTE
Item: Currency Pair Example: =MT4|QUOTE!AUDUSD Sample Output: 2006/09/08 19:58 0.7540 0.7546
Returns the Time, BID and ASK prices for the pair
TIME
Item: Does not take an Item Example: =MT4|TIME Sample Output: 2006/09/08 19:58
Returns the server time

The DDE Topic STATUS and DDE Items ACCOUNT, BALANCE and CONNECT have been deprecated and obsoleted in version 4.0 of the client. The queries =MT|STATUS!ACCOUNT =MT|STATUS!BALANCE and =MT|STATUS!CONNECT only work in previous versions of the trading terminal.

Other DDE Enabled Financial Applications

Other financial applications share some of the previous DDE topics. Some of those applications and their App Names are: eSignal (WINROS): Stock Quotes, Thinkorswim (TOS): Stocks and futures broker.

Using the code

The code below shows the minimum number of steps required to setup the NDDE library to receive real time quotes from Metatrader 4. Metatrader responds to the initial request for a value using client.Request(Item, 60000); with N\A and instead only sends the quotes as updates via the Advise mechanism.

This code connects to the MT4 DDE server and the QUOTE topic. It then sets up item update notifications using StartAdvise for the desired currency pairs. The OnAdvise event handler prints the tick received using the Item (pair) and Text (quote) attributes of the DdeAdviseEventArgs object it receives as a parameter.

If an exception is thrown during this process, it means that Metatrader is not started or its DDE server is not enabled. The user is informed to launch Metatrader, or to follow the procedure to enable the DDE server.

File: Form1.cs

//
// 4XDDEClient, a part of the www.4xlab.net Forex Lab Project
//

using NDde.Client;

namespace _4XDDEClient
{

  public partial class Form1 : Form
  {

	...

    private void StartQuotes()
    {
      try
      {
        if (TheContainer.TheDdeClient == null)
        {
          DdeClient client = new DdeClient("MT4", "QUOTE");
          TheContainer.TheDdeClient = client;

          // Subscribe to the Disconnected event.  
          // This event will notify the application when 
          // a conversation has been terminated.
          client.Disconnected += OnDisconnected;

          // Connect to the server.  
          // It must be running or an exception will be thrown.
          client.Connect();

          // Advise Loop
          client.StartAdvise("USDCHF", 1, true, 60000);
          client.StartAdvise("USDJPY", 1, true, 60000);
          client.StartAdvise("EURUSD", 1, true, 60000);
          client.StartAdvise("GBPUSD", 1, true, 60000);
          client.StartAdvise("EURJPY", 1, true, 60000);
          client.StartAdvise("EURCHF", 1, true, 60000);
          client.StartAdvise("EURGBP", 1, true, 60000);
          client.StartAdvise("USDCAD", 1, true, 60000);
          client.StartAdvise("AUDUSD", 1, true, 60000);
          client.StartAdvise("GBPCHF", 1, true, 60000);
          client.StartAdvise("GBPJPY", 1, true, 60000);
          client.StartAdvise("CHFJPY", 1, true, 60000);
          client.StartAdvise("NZDUSD", 1, true, 60000);
          client.StartAdvise("EURCAD", 1, true, 60000);
          client.StartAdvise("AUDJPY", 1, true, 60000);
          client.StartAdvise("EURAUD", 1, true, 60000);
          client.StartAdvise("AUDCAD", 1, true, 60000);
          client.StartAdvise("AUDNZD", 1, true, 60000);
          client.StartAdvise("NZDJPY", 1, true, 60000);

          // subscribe to the Advise event
          // this method will be called when a quote
          // is received.
          client.Advise += OnAdvise;

          Log("DDE Client Started");
        }
        else
        {
          Log("DDE Client Already Started");
        }
      }
      catch (Exception)
      {
        TheContainer.TheDdeClient = null;
        Log("An exception was thrown during DDE connection");
        Log("Ensure Metatrader 4 is running and DDE is enabled");
        Log("To activate the DDE Server go to Tools -> Options");
        Log("On the Server tab, ensure \"Enable DDE server\" is checked");
      }
    }

    private void OnAdvise(object sender, DdeAdviseEventArgs args)
    {
      Log(args.Item+": " + args.Text);
    }

  }

  public class TheContainer
  {
    public static Form1 TheForm;
    public static DdeClient TheDdeClient;
  }

Credits

This article uses the capable NDDE library which implements a DDE client, server and monitor in C# 2.0
This library is available at: http://workspaces.gotdotnet.com/ndde

This project and the NDDE library require the .NET Framework 2.0 installed with Visual Studio 2005, or available at
http://www.microsoft.com/downloads/details.aspx?FamilyID=0856EACB-4362-4B0D-8EDD-AAB15C5E04F5

Creating a Mechanical Trading System Part 2: Four Percent Trading System

asimon — Mon, 11 Sep 2006 00:23:42 GMT

Download source files - 35 Kb

Introduction

The first article in this series introduced a project to code mechanical trading system robots for the .NET platform using the C# language. This article introduces how to code a trading system that will watch price action and make buying or selling decisions. It is the aim of this project to write a program that does not depend on any underlying platform to execute, but rather receives price data directly from a broker and places orders via an API.

The code provided here is part of a larger project to create a backtesting platform and an automated FOREX trading robot. Source code for this project is available at http://www.4xlab.net

Background

This article implements the 4 percent model, developed by Ned Davis and popularized by Martin Zweig in his book Winning on Wall Street. This is a very simple trend following model that will put you on the right side of a sustained trend. This is not to say that this system does not have weaknesses. If too small of a percentage is chosen, the system can whipsaw, or execute many small losing trades.

This system makes an initial buying or selling decision depending on whether the prices rise or fall more than a certain percentage from the first price seen. Once the initial direction is set, the system reverses its position when the prices retrace a certain percentage from a local maximum or minimum value. For example, if the system is buying, and the price rises to a maximum of 104, then retraces back to 100, the system will then close the long position and sell to establish a short position.

This is a reversal system and it is continuously in the market. To fully utilize its potential, it must be implemented on a market that allows traders to go long or short with equal ease. The futures, options, and Forex markets all possess this property.

This project implements the random walk algorithm to generate simulated price data. The algorithm is shown in the boxes below. A virtual coin is flipped each time the function is called. If heads, the price increases by 1c, if tails, the price decreases by 1c. This random data is then sent to the account manager and to the trading system. The trading system makes a decision and notifies the account manager if it wants to buy or sell. The account manager then outputs the trade log to the screen.

Simulated Trading Example

The screenshot at the beginning of this article shows a run of the algorithm through random walk data. The price starts at 100 and starts randomly moving up and down by 1c. Since 100 is going to be the fist price, the first decision will be to buy if prices rise by 4% to 104, or sell if prices fall by 4% to 96. In this example, the 96 price target was hit first and the system places a sell order. The system is now looking for new lows, if prices retrace from this new low by 4%, then the system closes the sell order and places a buy order. In this example, the system reverses position at 98.01 as shown, since the prices must have come down to 94.08 (4% below 98.01). In the hypothetical example shown, after adding the transactions shown in the screen, the system shows a profit of 4.92. This very simple system that will put you on the right side of a sustained trend, but is susceptible to whipsaws if the percentage is not appropriate for the width of the oscillations between maximums and minimums. Perhaps use of the ATR or the ADX indicators could reduce the whipsaws.

Using the code

This project has been arranged so that an unmodified trading system taken from the 4xlab.net project executes successfully. The supporting class framework has been implemented in a minimalistic way to allow this system to output trading decisions. Features such as parameter optimization and end of trading reports containing gains, loses and drawdown figures are not available in this project.

The FourPercentModel.cs file contains a complete implementation for a trading system. The fPercentageChange class inherits from the ForexObject. This allows the framework to receive and execute trading systems by treating them as their base class (ForexObject).

The Base class ForexObject defines the following methods

public override void Init(string pParameters)
This method initializes the object. This was chosen instead of the constructor to allow an existing object to be re-initialized and allow the object to remember multiple runs with different parameters for optimization purposes.

The system is initialized by sending it a parameter string in which parameter:value pairs are separated by semicolons. If no parameters are sent, the object is responsible for selecting default values.
public override void ReceiveTick(sTick pTick)
The following two methods are used by the object to receive real time quote data. If the object wants to receive tick data, it will register itself with the framework as a tick listener. The private method DecisionFunction must be called either here, or in the ReceiveCandle method.

The DecisionFunction method is responsible for analyzing quote data and making buying or selling decisions executed through the Account object. In this example it can be seen that the decision function involves looking for new minimums or new maximums depending on the current trading direction. Once prices retrace by a specified percentage, the system reverses direction. Trades are entered by calling Framework.Account.EnterTrade(int pDirection). For buy orders, use +1 for direction, use -1 for sell orders. The Account object returns its trading status via the Framework.Account.InTrade() method. A positive value means a buy order is open; a negative value means a sell order is open. Zero is returned if the there are no trades open.
public override void ReceiveCandle(sCandle pCandle, int pPeriod, string pCBTitle)
This method is used by the object to receive candle data. To accomplish this, the object must register itself with the framework as a candle listener.
public override bool Finished()
This method allows the object to be called several times by the framework. The object can choose to change quote data after the end of each run and compare runs internally. If so, the first time the object is finished receiving quote data and this method is called, the object switches quote data and returns false. The second time around, this method will return true.
public override string Title()
This method allows individual objects in a collection to be identified by a friendly name.

File: FourPercentModel.cs

//
// 4X Lab.NET © Copyright 2005-2006 ASCSE LLC
// http://www.4xlab.net
// email: 4xlab@4xlab.net
//

using System;

namespace FourPercentShell
{
    // UNMODIFIED CLASS, SAME AS IN 4XLAB.NET
    
    public class fPercentageChange : ForexObject
    {
    double iPercentage;
    double iMin;
    double iMax;

    bool   FirstTick;
    sTick  Tick;
    double Spread;

    public fPercentageChange()
    {
    }

    public override void Init(string pParameters)
    {
        this.InitializeParameters(pParameters,"PERCENT:0.001;");

        iPercentage = PParser.GetDouble("PERCENT",0);

        Framework.TickServer.RegisterTickListener("System","*",this);

        Framework.WriteGraphLine("InTrade,Margin,Tick,Min,MinTh,Max,MaxTh");

        FirstTick = true;
    }

    public override void ReceiveTick(sTick pTick)
    {
        Spread    = pTick.Ask - pTick.Bid;
        Tick    = pTick;

        DecisionFunction();
    }

    public override void ReceiveCandle(sCandle pCandle, int pPeriod, string pCBTitle)
    {
    }

    
    private void DecisionFunction()
    {

        if (FirstTick)
        {
        FirstTick = false;
        iMin = Tick.Bid;
        iMax = Tick.Bid;
        }
        else
        {
        if (Framework.Account.InTrade()==1)
        {
            if (Tick.Bid > iMax)
            {
            iMax = Tick.Bid;
            }
            
            if ((iMax-Tick.Bid) > iPercentage*iMax)
            {
            Framework.Account.ExitTrade();
            Framework.Account.EnterTrade(-1);
            iMin = Tick.Bid;
            iMax = 0;
            }
        }

        if (Framework.Account.InTrade()==-1)
        {
            if (Tick.Bid < iMin)
            {
            iMin = Tick.Bid;
            }
            
            if ((Tick.Bid-iMin) > iPercentage*iMin)
            {
            Framework.Account.ExitTrade();
            Framework.Account.EnterTrade(1);
            iMax = Tick.Bid;
            iMin = 0;
            }
        }

        if (Framework.Account.InTrade()==0)
        {

            if ((Tick.Bid-iMin) > iPercentage*iMin)
            {
            Framework.Account.EnterTrade(1);
            iMax = Tick.Bid;
            iMin = 0;
            }

            if ((iMax-Tick.Bid) > iPercentage*iMax)
            {
            Framework.Account.EnterTrade(-1);
            iMin = Tick.Bid;
            iMax = 0;
            }

        }

        }

        double logInTrade = Framework.Account.InTrade();
        double logMargin  = Framework.Account.GetAccount().C;

        double MinTh = iMin + iMin*iPercentage;
        double MaxTh = iMax - iMax*iPercentage;

        Framework.WriteGraphLine(logInTrade+","+logMargin+","+Tick.Bid+","+
                     iMin+","+MinTh+","+iMax+","+MaxTh);
    }

    public override bool Finished()
    {
        bool returnv = true;

        return returnv;
    }

    public override string Title()
    {
        return "% Trend Change";
    }
    }

}

The following file shows how the Tick Server generates simulated price data based on the random walk model. First, the price is incremented or decremented depending on a random number. Then a Tick object is created with Bid and Ask prices. Afterwards, the tick is sent first to the account simulator and to the registered tick listener later. The code implemented here only allows for one registered tick listener in addition to the account simulator.

File: Framework.cs

    public class oTickServer
    {
    
    ...

    public void GenerateTick()
    {
        int randomint = (int)(RNG.NextDouble()*1000);

        if (randomint>500)
        {
        price++;
        }
        else
        {
        price--;
        }

        Tick = new sTick();

        Tick.Bid = price;
        Tick.Ask = Tick.Bid + 0.01;

        Framework.Account.ReceiveTick(Tick);
        tl.ReceiveTick(Tick);
    }

    ...

    }

Creating a Mechanical Trading System Part 1: Technical Indicators

asimon — Mon, 11 Sep 2006 00:10:14 GMT

Download source files - 1 Kb

Introduction

This article explains how to code technical analysis indicators on the .NET platform using the C# language. This is the first step towards creating a fully automated trading robot that does not depend on any underlying platform to perform its tasks. The final product will receive quotes directly from a broker via an API, perform price analysis, and decide whether or not to place orders to buy or sell.

The code provided here is part of a larger project to create a backtesting platform and an automated FOREX trading robot. Source code for this project is available at http://www.4xlab.net/

This will cover the implementation details of the Exponential Moving Average, and the Moving Average Convergence Divergence (MACD) indicators. These two indicators have been chosen to exemplify how modular design and object oriented programming can help create complex indicators out of simple ones.

The MACD indicator has been chosen for this article since it produces a rather distinct entry signal based on its two lines crossing. This article does not advocate taking the crossovers both as entry and exit signals since this indicator is lagging and produces signals once the trend has changed. The entries provided by this indicator should be complemented with exit techniques based on other indicators. Of particular interest are exits described by Charles Le Beau using the Average True Range indicator such as the Chandelier and Yoyo Exits.

Background

The nature of the final product, a trading robot, demands that the indicators are coded with real time signals in mind. Each indicator has four important methods:

Constructor: Initializes the object and instantiates any other indicators needed.
ReceiveTick: Informs the indicator that a new value has been received. The indicator can now store it in an internal buffer, or perform computations with the new value
Value: Returns the value of the indicator. This method uses the internal buffer filled by ReceiveTick to compute its data.
IsPrimed: Returns true when the indicator has received enough values to start producing a meaningful output. For example, a 14 period simple moving average will not return output values until 14 input values are received.

The MACD indicator is constructed with three EMAs. A slow (longer period) EMA and a fast (shorter period) EMA both receive the current price. The difference from the fast and slow EMAs is called the MACD, and is sent to a third EMA called the Signal. The values plotted in the chart are the MACD and the Signal. By instantiating three EMA objects and defining the relationships between them, a more complex indicator such as the MACD can be easily created.

Indicators have to be instantiated first with the proper parameters. Then the ReceiveTick method needs to be called with a value. To obtain the result from the indicator, the Value method needs to be called. This method returns a value of 0 if not enough values have been received. The IsPrimed method can be called to determine if the indicator has received enough values to compute a value.

Note that the ReceiveTick method can either receive price data, or data from another indicator. This flexibility is what enables the MACD indicator to be built from three Exponential Moving Average objects

Source Code

//
// 4X Lab.NET © Copyright 2005-2006 ASCSE LLC
// http://www.4xlab.net
// email: 4xlab@4xlab.net
//

using System;

namespace _4XLab.NET
{
    public class iEMA
    {
        private int tickcount;
        private int periods;
        private double dampen;
        private double emav;

        public iEMA(int pPeriods)
        {
            periods = pPeriods;
            dampen  = 2/((double)1.0+periods);
        }

        public void ReceiveTick(double Val)
        {
            if (tickcount < periods)
                emav += Val;
            if (tickcount ==periods)
                emav /= periods;
            if (tickcount > periods)
                emav = (dampen*(Val-emav))+emav;

            if (tickcount <= (periods+1) )
            {            
                // avoid overflow by stopping use of tickcount
                // when indicator is fully primed
                tickcount++;
            }
        }

        public double Value()
        {
            double v;

            if (isPrimed())
                v = emav;
            else
                v = 0;

            return v;
        }

        public bool isPrimed()
        {    
            bool v = false;
            if (tickcount > periods)
            {
                v = true;
            }
            return v;
        }
    }

    public class iMACD
    {
        int pSlowEMA, pFastEMA, pSignalEMA;
        iEMA slowEMA, fastEMA, signalEMA;

        // restriction: pPFastEMA < pPSlowEMA
        public iMACD(int pPFastEMA, int pPSlowEMA, int pPSignalEMA)
        {
            pFastEMA = pPFastEMA;
            pSlowEMA = pPSlowEMA;
            pSignalEMA = pPSignalEMA;

            slowEMA = new iEMA(pSlowEMA);
            fastEMA = new iEMA(pFastEMA);
            signalEMA = new iEMA(pSignalEMA);
        }

        public void ReceiveTick(double Val)
        {
            slowEMA.ReceiveTick(Val);
            fastEMA.ReceiveTick(Val);

            if (slowEMA.isPrimed() && fastEMA.isPrimed())
            {
                signalEMA.ReceiveTick(fastEMA.Value()-slowEMA.Value());
            }
        }

        public void Value(out double MACD, out double signal, out double hist)
        {
            if (signalEMA.isPrimed())
            {
                MACD = fastEMA.Value() - slowEMA.Value();
                signal = signalEMA.Value();
                hist = MACD - signal;
            }
            else
            {
                MACD = 0;
                signal = 0;
                hist = 0;
            }
        }

        public bool isPrimed()
        {    
            bool v = false;
            if (signalEMA.isPrimed())
            {
                v = true;
            }
            return v;
        }

    }

}

Credits

The image in this article was obtained with a product that includes software developed as part of the NPlot library project available from: http://www.nplot.com/

Articles

A comparison between moving averages.

Creating a Mechanical Trading System Part 3: Get real time quotes using DDE

Introduction

Background

Connecting to Metatrader 4 using Excel:

MT4 DDE Topics

Other DDE Enabled Financial Applications

Using the code

Credits

Read More About It

Creating a Mechanical Trading System Part 2: Four Percent Trading System

Introduction

Background

Simulated Trading Example

Using the code

Read More About It

Creating a Mechanical Trading System Part 1: Technical Indicators

Introduction

Background

Source Code

Credits

Read More About It