Put in simple terms, a Random Walk basically involves taking successive random steps and tracing the trajectory. I adapted the example from part one of Wilmott on Quantitative Finance and wrote a quick MATLAB script to simulate a simple random walk. Basically flip a coin if it is heads multiply the equity seed by 1.01 and if its tails multiply by 0.99.

Results

The graphs below show succesive runs of the script. I simulated 10,000 coin tosses in each test.

Sim one: You flipped 5069 heads & 4931 tails

Sim Two: You flipped 4946 heads & 5054 tails

Sim Three: You flipped 5026 heads & 4974 tails

Sim Four: You flipped 5042 heads & 4958 tails

MATLAB Code

Writing the code in MATLAB is very straightforward I wrote the code in less then five minutes so it is a bit rough around the edges. I probably could refactor it but it does the job.

% Simple Simulated Random Walk Adapted
% from part 1 Paul Wilmott on Quant Fin

% create matrix with random int either 1 or 2
randMat = randi(2,10000,1);
randEquity = [1:10000];

headCount = 0;
tailCount = 0;
equitySeed = 100.00;

for i=1:10000
    if randMat(i)==1
        % we flipped a heads
        headCount = headCount + 1;
        equitySeed = 1.01 * equitySeed;
        randEquity(i) = equitySeed;
    else
        % must have flipped tails
        tailCount = tailCount + 1;
        equitySeed = 0.99 * equitySeed;
        randEquity(i) = equitySeed;
    end
end

fprintf('You flipped %i heads & %i tails\n', headCount, tailCount);
plot(randEquity);
title('\bf \fontname{Arial} \fontsize{16}Simulated Random Walk');
xlabel('\bf \fontname{Arial} \fontsize{12}Number of Coin Tosses');
ylabel('\bf \fontname{Arial} \fontsize{12}Price in ($)');

% clean-up
clear equitySeed headCount tailCount randMat i;

I have finally settled on a prototyping environment for my trading strategies. I have tested many different options but I keep coming back to MATLAB. I have tried python with both iPython and sciLab. I used Octave for a bit and I even tried Excel. None of these solutions have even com close to MATLAB. Given the widespread use in industry and the speed and flexibility I can test trading ideas MATLAB is clearly the superior option.

“MATLAB is a high-level language and interactive environment that enables you to perform computationally intensive tasks faster than with traditional programming languages such as C, C++, and Fortran.”

-MathWorks.com

Back in 2010 I first read Ernest Chan’s Book How to Build Your Own Algorithmic Trading Business.  I found the book interesting however I didn’t implement any of the ideas from the book. I have got the book of the shelf and I am going to work through it.

MATLAB on Mac & Solarized Colour Scheme

MTALAB 2011b is much more Mac friendly then previous versions. The menu items are now all at the top of the screen on the Mac menu bar. Below is a basic screenshot showing the setup I use. For all my programming work I use a solarized colour theme with Monaco as the font face. When you spend at least 8 hours a day looking at a computer screen I have found these colour schemes to be easier on the eyes.

Clean up MATLAB Environment

I am always looking to save time so I wrote a quick cleanup script that removes all variables, clears history and clears the command window. It is trivial but I have posted it below as it might be helpful to someone.

% simple script to clean up workspace

% remove vars
clear;

% clear command window
clc;

% remove command history
com.mathworks.mlservices.MLCommandHistoryServices.removeAll;

Implementation

I will probably use C++ or a DSL for the actual implemntation of the strategies. I will post some screen casts as I think information is more easily digestible in that format. I am just waiting for my podcasting mic to arrive. I think it is on a slow boat from china.

Getting The Symbol List’s For ASX Listed Companies

The first step in the process is to download the symbol lists from the ASX website. The ASX listed companies list is updated daily at 12Am. The easiest way to get the data is to download the CSV file, then we can work with it in Excel. As you can see in the image below there are three columns of data: Company Name, ASX Code and GICS Industry Group.

If you are unfamiliar with the GCIS or Global Industry Classification Standard you can read up on it here. Basically it is just the industry group assigned to a specific company by Standard and Poor’s.

Converting and Sorting the Symbol List

eSignal requires the symbol code and then an exchange code to be added on the end. So for example BHP in eSignal would have the code BHP-ASX. There is over 2000 companies that we wish to change the code for so we need to automate the process. In Excel this can be done with a simple formula and a fill. What we want to do is take the text string in column B of our spreed-sheet and add the text string “-ASX” to the end of the stock code. To do this we use the CONCATENATE function, this function takes n text strings and adds them together to form a new string.

As you can see from the above image in cell D1 we simply type: =CONCATENATE(B4, “-ASX”) and we fill down for the entire range and we now have our eSignal symbols ready for export. In order to export our symbol list by GCIS sector we need to custom sort the data first. Simply go to Sort -> Custom Sort and then sort by GCIS Industry Group as shown below.

Creating a New Page in eSignal 11 and Adding a Watch List

The first step is to create a new page in eSignal, to do this go to eSignal menu -> New Page or CTRL + SHIFT + N.

In the New Window template select Watch List. This will add a blank watch list to the page. After the Watch List has been added it is a good idea to save the page. You can do this be right clicking on the page tab and selecting save.

For each GCIS group I will create a new list. To do this simply click on the gear icon to the right of the blank symbol list, now rename the list to the appropriate GCIS group.

Copy and paste the group symbols from the Excel spreed-sheet, save the list rinse and repeat. The image below shows my ASX sorted GCIS watch lists.

In total there are 21 separate lists with 2227 symbols.

]]> http://www.traineetrader.com/esignal-11-creating-your-own-watch-list-ordering-by-sector/feed/ 0 http://www.traineetrader.com/numerical-computing-environments-for-traders/ http://www.traineetrader.com/numerical-computing-environments-for-traders/#comments Mon, 10 Jan 2011 04:52:07 +0000 Mark http://www.traineetrader.com/?p=1271 Microsoft Excel is an excellent tool and you will be able to accomplish most of your work in it. However there will come a time when you need to test a complex model, run a large simulation or work with a huge data set that would grind Excel to a halt.

Numerical Computing Environments

When all is said and done there are 5 main options that each have a large community base. You should try out each environment to see which works best for you and is most cost effective. I have found a happy medium using SciPy and Matlab. I will however be testing out SciLab over the next few weeks.

Matlab

Matlab is the “Big Daddy” or the King of Numerical computing environments. I don’t think I really need to add much more. It does pretty much everything and you can extend it with .m code, however you need deep pockets.

Scilab

Scilab provides features similar to Matlab and has a built-in Matlab translator. Scilab comes in a complete package and is easy to setup and run. Scilab also has a code editor and allows for C++ code integration.

Octave

Octave is essentially an open source Matlab clone. You will have to port your code between Matlab and octave as they have subtle differences and Octave has no IDE.

SciPy

SciPy + numpy + matplotlib provides modules for plotting, large datasets, statistics, optimisation, numerical integration, linear algebra, Fourier transforms, signal processing, image processing, ODE solvers, special functions and of course all the power and simplicity of the python. This is the option I have gone with.

R

R is a software environment for statistical computing and graphics. R is a very powerful yet arcane programming language. I would only recommend for people comfortable programming. I have it on the computer but have as yet not put in the time to learn R.

Writing Pseudo Code in MeataEditor

For simplicity reasons we will write our trend following system pseudo code in MetaEditor. Open MetaEditor from “[drive]:/Program Files/MetaTrader4/” folder. Alternatively you can open MetaTrader and press F4 or Tools –> Meta Quotes Language Editor.

Step One

Create a New File of type Expert Advisor. File –> New or CTRL +N.

Step Two

Click Next an enter appropriate details for the system. Call your Expert Advisor Turtle System.

Finally, you should see a code window similar to the one below:

We will be following the pseudo code convention outlined in the pseudo standard presented in the previous article. We will enter the pseudo code as comments in MetaEditor, for simplicity we will use the quote modifier. Below is sample pseudo code I have written to implement most parts of the Turtle Trading system. This is the first iteration and there are errors present in the code. Can you find the errors in the pseudo code?

// Calculate True Range
FUNCTION trueRange WITH todaysHigh AND todaysLow AND pDayClose
    RETURN CALL findMax((todaysHigh - todaysLow), abs(todaysHigh - pDayClose), abs(pDayClose - todaysLow))
END FUNCTION       

// Calculate N
FUNCTION calcN WITH prevN and trueRange
    RETURN (19 * prevN + trueRange) / 20
END FUNCTION

// Detrmine the dollar value of a pip
// 1 lot = 100,000 base currency
// PPV = Per Pip Value
FUNCTION PPV WITH lotSize, currentPrice, accCurrency, pipVal
    inCurr = pipVal / currentPrice
    RETURN accCurrency * inCurr * (lotSize *100000)
END FUNCTION

// Calculate the dollar volatility of a currency pair
FUNCTION dollarVol WITH n AND ppv
    RETURN n * ppv
END FUNCTION

// Calculate unit value for given account
FUNCTION calcUnit WITH dollarVol, accBalance
    return (0.01 * accBalance) / dollarVol
END FUNCTION

// Misc rules
// max 12 units in one direction
// if account drops 10% reduce available equity by 20%

////////////////////// Entries ///////////////////
// System One A shorter term 20 period breakout
// buy or sell 20 period breakout
// buy or sell 1 unit
// if previous breakout winner skip trade
// losing if previous breakout 2N loss
// stops set at 2n below entry

IF currentPrice > 20periodHigh AND prevLongTradeLoser THEN
    CALL buyCurr
ELSE IF currentPrice < 20periodLow AND prevShortTradeLoser THEN
    CALL sellCurr
END

// System Two 55 period breakout entry
IF currentPrice > 55periodHigh AND THEN
    CALL buyCurr
ELSE IF currentPrice < 55periodLow THEN
    CALL sellCurr
END

// Adding units
// Additional units added stops raised by half n
// add a unit every 1n move
IF tradeLong AND currentPrice > (lngEntPrice + n) THEN
    CALL buyCurr
    CALL adjStop
ELSE IF tradeShort AND currentPrice < (lngEntPrice - n) THEN
    CALL sellCurr
    CALL adjStop
END

///////////////////Exits ///////////////////////
// System one
// 10 period low for long posn
// 10 period high for short posn 

IF s1tradeLong AND currentPrice < 10periodLow THEN
    CALL sellCurr
ELSE IF s1tradeShort AND currentPrice > 10periodHigh THEN
    CALL buyCurr
END

// System two exit
// 20 period low for long posn
// 20 period high for short posn

IF s2tradeLong AND currentPrice < 20periodLow THEN
    CALL sellCurr
ELSE IF s2tradeShort AND currentPrice > 20periodHigh THEN
    CALL buyCurr
END

As you can see this code gives us an excellent starting point for the development of our Turtle Trading system. In the next article we will go through the specifics of coding in MQL. I have provided a basic implementation of the code for this trading system but you will derive most benefit from creating your own implementations of this system.

Related Articles

• Building an Automated FOREX System: Designing a Simple Strategy and Introduction to Pseudo Code.
• Building an Automated FOREX System: Expert Advisors & Indicators
• Building an automated currency trading system from scratch.

• Connect to Interactive Brokers via IbPy.
• Connect and download free stock data from Yahoo finance via ystockquote.
• Visualise stock data using matplotlib.

I wont  go through connecting to Interactive Broker here as max has written an excellent tutorial on his site. Max provides some excellent resources on quant trading.

Getting Stock Quotes From Yahoo via Python

Corey Goldberg has written a simple module that is a good starting point for getting stock data. I am yet to modify the code but when I do I will post the modified source code. You can download the source code for ystockquote.py below:

#!/usr/bin/env python
#
#  Copyright (c) 2007-2008, Corey Goldberg (corey@goldb.org)
#
#  license: GNU LGPL
#
#  This library is free software; you can redistribute it and/or
#  modify it under the terms of the GNU Lesser General Public
#  License as published by the Free Software Foundation; either
#  version 2.1 of the License, or (at your option) any later version.

import urllib

"""
This is the "ystockquote" module.

This module provides a Python API for retrieving stock data from Yahoo Finance.

sample usage:
>>> import ystockquote
>>> print ystockquote.get_price('GOOG')
529.46
"""

def __request(symbol, stat):
    url = 'http://finance.yahoo.com/d/quotes.csv?s=%s&f=%s' % (symbol, stat)
    return urllib.urlopen(url).read().strip().strip('"')

def get_all(symbol):
    """
    Get all available quote data for the given ticker symbol.

    Returns a dictionary.
    """
    values = __request(symbol, 'l1c1va2xj1b4j4dyekjm3m4rr5p5p6s7').split(',')
    data = {}
    data['price'] = values[0]
    data['change'] = values[1]
    data['volume'] = values[2]
    data['avg_daily_volume'] = values[3]
    data['stock_exchange'] = values[4]
    data['market_cap'] = values[5]
    data['book_value'] = values[6]
    data['ebitda'] = values[7]
    data['dividend_per_share'] = values[8]
    data['dividend_yield'] = values[9]
    data['earnings_per_share'] = values[10]
    data['52_week_high'] = values[11]
    data['52_week_low'] = values[12]
    data['50day_moving_avg'] = values[13]
    data['200day_moving_avg'] = values[14]
    data['price_earnings_ratio'] = values[15]
    data['price_earnings_growth_ratio'] = values[16]
    data['price_sales_ratio'] = values[17]
    data['price_book_ratio'] = values[18]
    data['short_ratio'] = values[19]
    return data

def get_price(symbol):
    return __request(symbol, 'l1')

def get_change(symbol):
    return __request(symbol, 'c1')

def get_volume(symbol):
    return __request(symbol, 'v')

def get_avg_daily_volume(symbol):
    return __request(symbol, 'a2')

def get_stock_exchange(symbol):
    return __request(symbol, 'x')

def get_market_cap(symbol):
    return __request(symbol, 'j1')

def get_book_value(symbol):
    return __request(symbol, 'b4')

def get_ebitda(symbol):
    return __request(symbol, 'j4')

def get_dividend_per_share(symbol):
    return __request(symbol, 'd')

def get_dividend_yield(symbol):
    return __request(symbol, 'y')

def get_earnings_per_share(symbol):
    return __request(symbol, 'e')

def get_52_week_high(symbol):
    return __request(symbol, 'k')

def get_52_week_low(symbol):
    return __request(symbol, 'j')

def get_50day_moving_avg(symbol):
    return __request(symbol, 'm3')

def get_200day_moving_avg(symbol):
    return __request(symbol, 'm4')

def get_price_earnings_ratio(symbol):
    return __request(symbol, 'r')

def get_price_earnings_growth_ratio(symbol):
    return __request(symbol, 'r5')

def get_price_sales_ratio(symbol):
    return __request(symbol, 'p5')

def get_price_book_ratio(symbol):
    return __request(symbol, 'p6')

def get_short_ratio(symbol):
    return __request(symbol, 's7')

def get_historical_prices(symbol, start_date, end_date):
    """
    Get historical prices for the given ticker symbol.
    Date format is 'YYYYMMDD'

    Returns a nested list.
    """
    url = 'http://ichart.yahoo.com/table.csv?s=%s&' % symbol + \
          'd=%s&' % str(int(end_date[4:6]) - 1) + \
          'e=%s&' % str(int(end_date[6:8])) + \
          'f=%s&' % str(int(end_date[0:4])) + \
          'g=d&' + \
          'a=%s&' % str(int(start_date[4:6]) - 1) + \
          'b=%s&' % str(int(start_date[6:8])) + \
          'c=%s&' % str(int(start_date[0:4])) + \
          'ignore=.csv'
    days = urllib.urlopen(url).readlines()
    data = [day[:-2].split(',') for day in days]
    return data

As you can see python is a very simple easy to read and understand language.

A Very Simple Example

In this simple example we will work in the interactive ipython environment with matplotlib. We will download the data separate the data and store it in separate list data structures. This is a very inefficient way of doing things and is not optimal. This example is for demonstration purposes.

import ystockquote

# Get Quotes 01/01/2006 - 01/01/2009
GOOG = ystockquote.get_historical_prices('GOOG', '20060101', '20090101')

# Create empty lists, quick and dirty
GOOGOpen = [ ]
GOOGClose = [ ]
GOOGDate = [ ]
GOOGHigh = [ ]
GOOGLow = [ ]
GOOGAdj = [ ]
GOOGVolume = [ ]

# Populate lists from downloaded data
for i in range(1, 755):
	GOOGDate.append(GOOG[i][0])
	GOOGOpen.append(GOOG[i][1])
	GOOGHigh.append(GOOG[i][2])
	GOOGLow.append(GOOG[i][3])
	GOOGClose.append(GOOG[i][4])
	GOOGVolume.append(GOOG[i][5])
 	GOOGAdj.append(GOOG[i][6])

plot(GOOGAdj)
title("Google Adjusted Close")
ylabel(r"GOOG Closing Price ($USD)", fontsize = 12)
xlabel(r"Date", fontsize = 12)
grid(True)

The image below shows the output we get when we save the plot as a .png file.

As you can see we need to adjust the x category labels. We will do this in an upcoming tutorial.

Creating a simple linked chart in Python

In Matlab it is very easy to create linked graphs, it is also possible to create linked graphs using matplotlib. The example below shows how we can link volume and adjusted close for Google.

import ystockquote

# Get Quotes 01/01/2006 - 01/01/2009
GOOG = ystockquote.get_historical_prices('GOOG', '20060101', '20090101')

# Create empty lists, quick and dirty
GOOGOpen = [ ]
GOOGClose = [ ]
GOOGDate = [ ]
GOOGHigh = [ ]
GOOGLow = [ ]
GOOGAdj = [ ]
GOOGVolume = [ ]

# Populate lists from downloaded data
for i in range(1, 755):
	GOOGDate.append(GOOG[i][0])
	GOOGOpen.append(GOOG[i][1])
	GOOGHigh.append(GOOG[i][2])
	GOOGLow.append(GOOG[i][3])
	GOOGClose.append(GOOG[i][4])
	GOOGVolume.append(GOOG[i][5])
 	GOOGAdj.append(GOOG[i][6])

#create canvas add two plots linked via x-axis
fig = figure()
ax = fig.add_subplot(311)
ax2 = fig.add_subplot(312, sharex=ax)
ax.plot(GOOGAdj)
ax2.plot(GOOGVolume)

Below you can see the output, you can scroll and zoom these graphs and they remain aligned.

Below shows what happens when you zoom in on a chart.

As you can see from the above examples python is easy to use and is very flexible. In my next post I will go through some more advanced charting and drawing functions.

I have kept my head in the sand as I hear readers and colleagues constantly extol the virtues of working with Python. I am for the most part happy with Matlab for strategy evaluation, however it is not very good when it comes to the execution side of a strategy. So this weekend I have decided to get in touch with my inner Python. I like the idea of being able to develop, test and implement a strategy all in the same development environment. The best part about using Python is it’s Open Source and has a number of useful packages available.

The Zen of Python

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!
—Tim Peters

To get this gem of wisdom simply type import this at the interactive python prompt. After a little research I have decided to use iPython as my interactive development environment at this stage I am not sure what I will use to write my static python code. For the moment I will just use emacs while I look into WingIDE.

Setting up Python

If you are not experienced with a UNIX like environment you may have a few issues with setting up all the libraries that are required. For the most part is smooth sailing. As I am running OS X I decided to take the easy / lazy option and just use mac ports.

At the moment I am experimenting with the following packages:

• Ipython – An enhanced interactive python shell.
• SciPy + NumPy – Scientific computing library.
• SciKits.timeseries – Functions for time series manipulation.
• matplotlib – Python 2d plotting library.
• Mayavi – 3d data visualization.
• IbPy – Interactive brokers python API.

I tested matplotlib with the different back ends and in the end went with TkAgg backend. I have written a few simple shell scripts so I can launch IBTWS and Ipython from the desktop.

Hint: If you are running OS X you can simply save your shell scripts as .command files and chmod +x and they are executable from finder.

Now I am going to work through learning the programming language over the coming weeks. The language is very simple and easy to understand and coming from C++ I don’t think it will be to hard to pick up.

Strategy Design

Designing a trading strategy could be the focus of whole encyclopedia, what we discuss here will simply be a quick overview. In it’s simplest from a trading strategy is simply  a set of predefined rules for executing trading decisions. By using an automated trading strategy emotional bias is removed. There are several different types of trading strategies that have been used over the years and usually fall into one of the following categories: 

• Fundamental Analysis based systems.
• Technical Analysis Based systems.
• Volatility based systems
• Mean reversion based systems.
• Trend Following systems.

Building a Trend Following Based System

We will be building a Trend Following system, this will be a very basic system and will help highlight the development process. When developing a trading system it is very tempting to try and re-invent the wheel, however we will start with a tried and tested system that is publically available. The trading system we will be implementing is the original Turtle Trading System and you will need to download a copy of the rules in order to continue with the tutorial.

Learning to Write Pseudo Code

Before reading any more make sure you have printed out and read through the original Turtle Trading System Rules document. This step is very important as the only way to learn this materiel is by taking action and carrying out the steps outlined.

STOP!

Now we can get on with our discussion of pseudo code. When it comes to writing computer programs or in this case automated trading systems translating English into programming code can be fraught with danger. Pseudo Code on the other hand refers to a more structured English for describing a process or program. It is important that you learn to write quality pseudo code as it will make a big difference when you come to coding your system your self or hiring a programmer.

There are many benefits in writing your algorithms or trading logic in pseudo code these include:

• You will gain a detailed understanding of the program or algorithm you are developing.
• Errors in logic picked up early.
• Not constrained by a single programming language.

Below is a brief example of pseudo code:

IF movingAverage1 == movingAverage2 THEN
    SEND buyOrder
END IF

Structured Pseudo Code

In order for us to write quality code we have to take a step back and think about what it is we are actually trying to achieve. Rather then using a trading example we will use an example that everyone is familiar with. Think about the process of going to the shop and buying 1 item let’s say it is milk. What I will ask you to do is sit down and write a step by step process that you could give to a an alien that describes the process in as much detail as possible.

STOP!

Do not move on until you have done this.  Below is the first iteration of solving the get milk problem:

Get into the car –> Start the car –> Drive to the closest shop that sells milk –> Get Out of Car –> Lock Car

Enter shop –> Locate milk –> Determine quantity –> Pay for milk –> Locate car –> Unlock Car –> Drive home.

As you can see if you think about the steps required to carry out this task it is much more complex then first thought. Let’s try and make this a bit more detailed iteration two:

DEFINE approxMilkCost

DEFINE moneyInWallet

 

IF moneyInWallet < approxMilkCost THEN

           CALL enterCar WITH keys

           CALL driveTo WITH bank

           CALL leaveCar

           CALL getMoneyFromBank WITH accountDetails

           CALL driveTo WITH shop

           CALL leaveCar

ELSE

          CALL enterCar WITH keys

          CALL driveTo WITH shop

          CALL leaveCar

ENDIF

 

enter shop

CALL locateItem WITH milk

CALL payForItem WITH money

leave shop

CALL enterCar WITH keys

CALL driveTo WITH home

CALL leaveCar

You can quickly see that by using a more formal language it breaks down complex tasks into simple steps. If we wanted to write a program to solve this problem we would probably go through several more iterations of pseudo code before actually starting coding. I have created a PDF file and have uploaded it so you can fully understand the pseudo code presented and can practice writing some pseudo code for yourself.  In the next article we will be looking at writing our trend following system out in pseudo code so make sure you review everything presented here.

MetaTrader 4

The current version that is most widely used and supported is MetaTrader 4 however beta versions of MetaTrader 5 are currently in testing. In order to build an automated trading system using MetaTrader 4 we will need to write a program that will run inside MetaTrader. There are three types of programs that run inside MetaTrader, these are Custom Indicators, Expert Advisors and Scripts. The screen shot on the right shows the built in indicators that ship with MetaTrader.

MetaTrader- MetaQuotes Language

Custom Indicators, Expert Advisors and scripts are all written in a programming language called MetaQuotes Language, often abbreviated MQL.  Although all three application types are written in MQL there are slight differences between program types.

MetaTrader- Indicators and Custom Indicators

Custom indicators are written in MQL the client terminal will execute the indicator every time a tick is received. The main use of indicators is to graphically display some user defined or built in data relationship. The most common use for indicators is for Technical Analysis. Below are some screenshots which show a built-in indicator being applied to the daily AUD/USD currency chart.

1. With AUD/USD chart open double click on desired indicator.
2. Enter parameter settings and execute.

MetaTrader- Expert Advisors

An Expert Advisor or EA for short share similar properties to Indicators. Expert Advisors or EA’s are written in MQL and are executed on tick data. Expert Advisors or EA’s have trade logic written into them. Basically an EA does everything an indicator can do, however an EA will also open, close and modify trades programmatically. To attach an EA to a currency pair the process is exactly the same as it is for an indicator. There are two sample EA’s that ship with MetaTrader 4 these are the MACD Sample and Moving Average.

MetaTrader- Scripts

Scripts are the final type of application that are available in MetaTrader. A script is designed to be executed only once. Scripts are usually used to automate client side non-trading actions, like modifying data. They can however be used to perform simple trade logic tasks.

MetaTrader – MetaEditor

All the code we write for our automated trading system will be done MetaTrader’s Integrated Development Environment called MetaEditor. MetaEditor allows you to store and manage source code for all projects in an easy to use way. If you are used to Visual Studio or X-Code IDE’s then you will be disappointed with the functionality of MetaEditor. MedEditor does offer syntax highlighting and code completion which is very handy. There is also a built in on-line library that covers most topics. Below is a screenshot of the IDE:

To open MetaEditor from MetaTrader simply press F4 or from the menu bar:

Tools –> MetaQuotes Language Editor

Home Work

Before next article make sure you understand the three different program types that are used in MetaTrader. Also try attaching and using some of the built in indicators in MetaTrader. Before moving on I would also recommend downloading the MQL4 book from MetaQuotes. This is a free book that covers the basics of programming in MQL and in later articles I will assume you are up to speed with the concepts presented in the book.

In the next article we will discuss designing a simple trading strategy and pseudo code.

int handlFile;
handlFile = FileOpen(“symbol.csv”, FILE_CSV | FILE_WRITE | FILE_READ, ‘,’);
FileSeek(handlFile, 0, SEEK_END);
FileWrite(handlFile, Bid, Ask, Close[1], Volume[1]);
FileClose(handlFile);

Note: This code above is intended as a very rough solution. Time permitting I will write a proper EA with error checking and better features. This code however should be sufficient for basic tasks. For more information on EA coding I strongly recommend you download the getting started book:

MQL Tutorial

The Non EA Export Option

Can’t be bothered with that coding garbage? Never fear there is a very simple option. Go to the Tools Menu then History Centre a dialog box similar to the one shown below will appear simply chose the currency you wish to export and select a file name and your done. This process is shown below:

MetaTrader really is an excellent platform for learning the basics of trading and trading systems. I would recommend to anyone starting out in currency trading that they download MetaTrader and start exploring. If you want to learn more about Forex Trading I suggest you visit the Forex section of this website.