Check out the google code site at http://code.google.com/p/ib-csharp/

I haven’t updated any links in my blog but will gradually get there. I also changed the license to the very permissive MIT license, so you are free to use this as you wish (at your own risk… as always).

I also finally compile a help file again! I need to add some additional source comments, but the release files now contain a compiled chm file. Also every build is built on a build server finally, so dropping releases should be quicker.

I have one known bug where if you use the disconnect logic heavily you can run into issues – I will tackle this when I get a chance.

I am thinking of moving the library to google code or codeplex, so this may happen in the coming weeks. I have also been receiving a lot of requests for documentation, so I will look at building helpfiles again. I used to use sandbox, but their web documentation is asp.net, and this server is a linux machine, so I’ll see what I can do.

Also need to work on forums – some spam bot has taken over.

I also finally added parameterless constructors to all of the event args so that they can be serialized/deserialized.

Added the warrant type to securitytype.

Fixed orderId going to 2^31-1 when it should be interpreted as zero.

Check it out in subversion, or I will make another release soon.

As you can see in the above central box, our trading system abstracts several core functionalities.

• Settings Management – the entire trading system is configured via a straightforward xml configuration file. The actual storage and management of this is abstracted by the particular profile. For live running, these settings are version controlled and managed in a central replicated sql database. For simulation, these are stored as a simple file provided to a console based simulator. For optimization purposes, these files serve as the basis for chromosomes in the genetic optimizer (with an optimization file providing the constraints for the search space). At the end of the day, develop a simple generic settings management system that can be abstracted for different targets.
• Contract Manager / Base Contract – The core component of any system is the instrument that you are trading / measuring. The contract manager provides position management and risk management abstractions, as well as contract locating functionalities. Ultimately any object that requires a contract, goes through the contract manager, and is given an abstraction of a base contract. The base contract can be a futures contract, equity, bond etc. This provides for a universal interface to subscribe to market data, and issue / monitor orders.
• Strategy Engine / Base Strategies – The strategy engine is the very heart of any trading system. This basic class subscribes to message pumps and processes the messages to handle orders. It is the most versatile object in the trading system, allowing for nearly any type of strategy.
• Charting – Few systems put enough emphasis on thorough charting, but I find it critical for visualizing the results of a simulation, as well as determining what is happening during live trading. All contracts and strategies implement a simple IChartable interface that allows them to output highly configurable charts, right down to the Graphics handles. This allows the charts to be presented in a live windows forms view, or painted to a Bitmap class for saving to disk.
• Logging – At the end of the day, traceability is critical. Every trade made needs to be serialized to disk / database in order to reconcile with your clearing house. Furthermore, every strategy needs to output useful tracing information to aid in debugging. Beyond the obvious tracing, strategies also need to implement a reporting interface to provide live state information to the user interface in order to determine how it is behaving, and if necessary to modify its parameter set, or to debug the strategy. This again is abstracted, just like settings and charting to go to different destinations based on the target of the trading engine. For simulation it outputs to the simulation results, whereas in live trading we work against easily queried database engines.

Next up I want to cut into application design and multithreading. There is a lot to cover, and I am swamped, so expect the articles to continue to appear as I have time. And if you have any questions feel free to email email hidden; JavaScript is required.

• Live Trading Engine – Any given system will start with the live trading engine. This is the piece of software which runs in real time and actually places orders and reacts to market data.
• Simulation Engine – When developing strategies, you often need to back test them. In an ideal world back testing would demonstrate profitability, but in reality it is just used to verify that your strategy does what you think it does. The key to a good simulation engine is that you run the exact same code in simulation as you do in production. I can’t understate that last sentence, so I’ll state it again – the key to a good simulation engine is that you run the exact same code in simulation as you do in production.
• Historical Service – this runs hand in hand with the simulation engine. You need a tick database for simulation. This is the backbone of all research applications, from back testing strategies to developing market models, you need a thorough, indexed, tick database. You can also build bar data from ticks, but you better have ticks available for simulation.
• Optimization Engine – All of your automated strategies require parameterization. Generally speaking these are best optimized by hand through selection of sensible variables. Sometimes however, you need to parameterize a simple strategy for a large number of symbols, in which case you want an automated system for optimization. Our system uses a cloud computing service to distribute instances of our simulation engine which run chromosomes from a centralized genetic optimization engine.
• Analytics – You need to ruthlessly track your trading performance. At the core of any solid trading engine is a solid analytics engine which tracks your various strategies.
• Reconciler – This was the biggest surprise coming from retail brokers to institutional brokers, but everyone makes mistakes. Sometimes the exchange will fail to tell your clearing house about trades you made, other times your clearing house will accidentally include another clients trades in your account. At the end of every day you need to reconcile every fill you think you made with the statements you receive from your clearing house and immediately reconcile any errors with your clearing house and the exchange.

Next up, I will cover the major components of the Trading Engine.

Believe it or not – it is this simple, and is how I suggest most developers get started. You really need to see your automated widget trade sooner than later. The longer you live in development hell, the longer it is before you understand what your system need to do. The key to your first automated trader is to make it as simple as possible. Do not try to start off with an interface abstracted, general purpose strategy engine; instead build as simple an engine that trades every day, and recognize the common challenges / design patterns required as you develop.

My next series of articles will cover the architecture of a monolithic strategy engine, but I do not want to preach this as the solution to everyone’s needs. Keep it Simple Stupid.

Because of this website, nearly every automated trader I have met has started this way:

1. Manual trading with interactive brokers
2. Seeing a strange phenomena in the market
3. Building a simple widget to hook up to Ib
4. Exploiting the mispricing until their trading volume grows and they realize Ib does not negotiate fees and on a bum day auto liquidates your account without any notice.
5. Decides they need to go the institutional route, and figure out what their other options are.

This is exactly how I got started, and it is only after developing a full institutional system that I appreciated how good Interactive Brokers is, and why they can charge such a premium.

If you are still in steps 1 – 3, then you will want to stick with IB (in fact after step 5, for many people, sticking with IB will still be the right call). For those who have gotten to step 5, my next series of posts will cover your basic decision space.

Your first step is to get your requirements figured out. What contracts do you trade? Equities, Options, Futures, Bonds? Interactive Brokers is incredible in their support for cross asset class trading in a single account. Starting with them, it seems trivial to expect all clearing houses to let you short shares on the ASX and use your acquired buying power to buy futures on Eurex. This is simply not the case. Interactive Brokers provides both clearing services, and execution services. In institutional land these services are broken up, and the most important piece is partnering with the right clearing house.

Your clearing house determines which exchanges you can trade. They establish relationships with each exchange, and guarantee your trades. If you place a loosing bet in a leveraged account, you stand to loose more money than you have in the account, and if the clearing house mistakenly allows you to do this, they will have to cover your losses. I mentioned you have to choose your products, this is because if you want to trade futures on the LME and NYMEX, you will have to find a clearing house with relationships to both exchanges. Likewise if you would like to trade equities, you will need a clearing house that specializes in equities. Generally, clearing houses do not support all asset classes, and execution platforms certainly don’t. Example clearing houses are Advantage Futures, MF Global, NewEdge, Goldman Sachs etc.

So if clearing houses are the first piece of the puzzle, then execution platforms are the second. The clearing house will clear your trades and manage your account on behalf of an exchange, but to actually place trades, you will need an execution platform. For interactive brokers, this is their Trader Workstation front end, and their timberhill backend. In the futures market, there are a few major players, Trading Technologies, RTS (Real Time Systems Group), CQG, and Pats. These are the interfaces you will use to actually trade, and are generally all supported by the major clearing houses and exchanges, so you can use the same execution platform regardless of who you clear with.

The above diagram generally illustrates the basic relationship between the parties. What you will notice is that the only time money exchanges hands is at night. Intraday there is no relationship between your cash and your maximum position. That is strictly a risk management function of your clearing house. This is where your clearing house relationship becomes incredibly important. It is not uncommon for clearing houses to let you have much lower intraday margins than required by the exchange (how do you think velocity futures gives out $500 margin on intraday e-minis), but at night time the clearing house has to settle with the exchange. Here again, the clearing house will frequently lend you money to increase your margin , but in general over night is dangerous enough, no reason to over leverage it.

There is a lot more to this, but I want to cut to the technology. If you are going through this process, and want a lot more detail on the various fee structures and technology tradeoffs, please email hidden; JavaScript is required. I have worked with or thoroughly researched nearly every major futures clearing house and execution platform, as well as most of the equities options.

My next posts are going to continue to be overview posts, but I am particularly excited to cut to the technical / code, so stay tuned.

I’d like to break these up into three major pieces:

1. Vendors and Organization – this includes clearing houses, execution platforms etc, fees etc.
2. Technology – These are your basic platform decisions, Windows vs *nix, x86 vs x64 etc.
3. Software – the meat of our system – cover the various components required to build a fully functional ATS, as well as a research system.

My next post will be an overview of what is required to do automated trading.

Stay Tuned…

We are looking for independant traders – people who are generally using interactive brokers to trade their own money, and are consistent but perhaps have to keep a day job to pay the bills or are still in school.

If this is you, and you are interested in working with us, please drop me a line email hidden; JavaScript is required

All of my prior interfaces with Ib have been for strictly self contained situations. Essentially where the program is placing orders and monitoring messages for the orders it has placed. I am now writing an interface to listen for any orders placed by any application or directly through the TWS interface. It appears I can use the RequestOpenOrders method with a clientId of -1 and receive all open orders at that moment in time, or I can use the RequestAutoOpenOrders to map TWS order messages to my client with a clientId of 0. But it does not appear there is any way to get all order updates from any target without constantly querying the open orders method.

Does anyone have a better way to do this?

If you have any problems, email hidden; JavaScript is required.

Download the release here, or go to the utilities page.

This is a non-relational database, which is well suited for things like raw tick data, where you are not querying them by values, but instead by an indexed time and symbol field.

To give you an idea of why this is important, take a look at their white paper from 2006 on performance. In a transacted environment they achieved 125,486 single record writes per second. With modern 2009 hardware, and multiple CPU / Solid State Disk systems, this could readily record every single tick coming off of the NYSE and NASDAQ (multiple million per second).

Check them out at Oracle Berkeley DB. I’m in the process of testing this out for our historical logging, and am very impressed so far, even on commodity hardware.

To illustrate a common problem with trading systems. You have a producer consumer model, where your data is coming in from the exchange on a single thread. This data is going to a large number of contracts, and it would be nice to do this in a multithreaded model. Under the ordinary paradigm, you would create a queue, have your producer thread lock on the queue, add the new market ticks, and unlock, letting your consumers take locks on the queue, and beginning to work on this. There are special concerns though, for a given contract you need to make sure all ticks are handled synchronously, and whenever the queue hits zero for a particular contract after data has changed, you want to tell your strategy to process the new data. Here you would need a second producer consumer framework, and things continue expanding from there.

With the CCR, you would break things down into tasks. There would be a task that consumes raw market data and posts it to a port. There would be a task that takes a tick from the market data and posts it to a contract. There would be a task that takes a tick in a contract and updates the contract, checking at the end if the contract’s queue is empty, if so, it would post the entire contract to the strategy saying it has been updated. There would be a task that consumes a contract and updates the strategy. All of these are small work tasks that are setup to run in a common dispatcher pool, and are all invoked every time a work product is posted to a port. No complicated setup, just arbitrated registrations.

I’d love to spend a lot more time talking about this, but here is one short example.

</code>using (var dispatcher = new Dispatcher(0, "Master Dispatcher"))
{
var dispatcherQueue = new DispatcherQueue("Master Queue");
var tickPort = new Port<int>();

Arbiter.Activate(dispatcherQueue, Arbiter.Receive(true, tickPort, tick=>
{
if(tick > 25)
{
Market.PlaceOrder(tick, 1);
}
}));
while(true)
{
tickPort.Post(new Random().Next(50));
}
}

I realize there are many simplifications made in this post – I just wanted to convey how cool the CCR framework is. If it were free, I’d post my Ib wrapper for it! Easily worth the $400, and if you are a student you can get it from the Robotics Studio for free. There is talk of merging it with the parallels framework added in C# 4.0 (another great invention… waiting for VS 2010 to fully integrate it though).

I also added an overload to RequestHistory which allows you to specify the duration to allow you to pass a string for duration directly to Ib.

If you have any problems, email hidden; JavaScript is required.

Download the release here, or go to the utilities page.

• I’m new to programming and I just don’t get your TestApp running. How exactly do I link to TWS ? Do I need to add any references or components from the IB API software?

In TWS you will need to goto Configure -> API -> Enable ActiveX and Socket Clients.
Next select Configure -> API -> All API Settings
In the window that appears, under Trusted IP Addresses, select Create, and add “127.0.0.1″ (The local machine) to the Trusted IP Addresses. Select OK, and you are good to go.

• 9.6.3.13 New Release – 7/20/09
• Update to Ib’s 9.63 api
• Add shortable tickType
• Fixes to ReadDecimal
• Fix 1 second barsize enum.
• Fixed Bug with IBClient.ReadDecimal()
• Fixed bug in ExecutionFilter

I also reorganized subversion to relink all of the files’ history, I had accidentally broken things when I first made the archive public.

This release has not gone through quite the normal scrutiny of my prior releases, but it was so overdue, I thought I’d get it out there, and if you have any problems, email hidden; JavaScript is required.

Download the release here, or go to the utilities page.

• If you stop maintaining your wrapper to the latest versions and the IB API changes to newer versions, how long will your existing C# API wrapper keep working?

Ib goes to great lengths to maintain backwards compatibility with old apis. If you look at their api code, it is clearly version controlled by the method, and I wouldn’t be surprised if code from many years ago still works.

As an example, I have been running an API app I wrote in Jan / Feb of 2008 every day since without updating the api once and have had no problems.

• If you stop maintaining your wrapper to the latest versions, would you possibly update it for a small fee? (I am not rich, just trying my hand to get rich!)  I would hate to lose all the effort into coding this ATS.

Always a possibility, but it is my intent to keep updating it for free. I’ve become somewhat less reactive to Ib version updates because each update adds relatively obscure features, and since compatibility is always maintained, it is not super urgent. That being said, I will get myself caught up here shortly, and continue to update to the latest version.

• Has your wrapper matured over time and currently working well?  No inherent hard to debug problems?  (Sorry for my asking but my Delphi friend has many of these!)  I noticed your excellent forum for help.

Good question, it certainly has matured. Occasionally some parsing bugs have been pointed out, specifically with my use of decimals, but I address those quickly with updates to subversion, and changes get rolled into the next release.

Let me know if you have any other general questions and I will create an FAQ page.

This will also make it easier for users to generate patches against the Api, and if anyone is interested in becoming a contributor, I am certainly open to it. Drop me a email hidden; JavaScript is required.

I just downloaded the latest VS2010 Beta 1 to play with, and am contemplating making breaking changes to the library that use C# 3.5 features. How important is VS 2005 support to people? Is everyone running VS2008 or later? Or do I need to maintain the 2005/C# 2.0 backwards compatibility?

Let me know in the comments, I will be steadily making changes here.

Also, I’m thinking about a new theme if any solid theme developers are out there, email hidden; JavaScript is required.

I will still be maintaining the IbAPI open source library (just saw IB posted a 9.62 beta), and if anything will be more responsive now.

I am also always interested in discussing interesting opportunities, so please continue to drop me a line at email hidden; JavaScript is required

Good Trading!

-Karl

I also made a large update to the event handler framework to make the calls thread safe now.

Please download it directly here or from the utilities page here.

In any case, this release has incorporated all of the changes with IB’s 9.51 release, the decimal conversion, and a series of bug fixes.

As always, goto the utilities page to download here, or download directly from here.

9.4.0.9 Bug Fix and Clean up – 2/10/09

• Made all EventArgs Serializable as well as the new enumeration FATypes.
• Fixed bug in OrderType.MarketOnClose – changed Description from "MKTCLS" to "MOC"
• Fixed RequestExecution method to allow you to pass a null or empty filter to get all executions.
• Changed HistoricalRequest Response. Added two parameters to the event args that lets the user know how far the download is. Also no longer calls function after download completed with null entries, since you can determine that the call is complete by the Record Number / Record Count properties.
• Made EnumDescConverter Static, as all methods were static.

As usual, download it from the utilities page here, or directly here.

Please note this release has breaking changes, not to functionality, but you will have to update your events and function calls to the correctly spelled equivalents.

• 9.4.0.8 Code Clean up – 1/31/09
  • Ran Vs2008 Code Analysis Wizard / FxCop and implemented cleanup
    • Numerous Spelling Changes
      • All Mkt references went to Market
      • All Req references went to Request etc.
      • All Lmt references went to Limit
      • All Indice references went to index
    • Added a lot of CultureInfo related fixes, making sure to provide invarient parsing
  • Fixed VB Client, used old contracts, and changed contract references to equity/future

As always, please go to the utility page here to get the latest release, or directly from here.

The following is the change log from the release notes

• 9.4.0.7 Bug Fix Release – 1/26/08
  • Changed FAMethod to Enumeration
  • Changed OrderState.Status to enumeration
  • Fixed several data parsing problems related to empty strings
  • Added Visual Studio 2008 solution, all files are still C# 2.0 compliant.

As I mentioned above, I now develop in Visual Studio 2008 against .net 3.5, but have been careful to keep this library C# 2.0 compliant. Let me know what platform you are using, if everyone has switched to .net 3.5, I may consider using new feature in future releases.

Without further ado, goto the utilities page to download the latest version or download directly from here.

• 9.4.0.6 API and Bug Fix Release – 12/9/07
  • Updated to support 9.40 Interactive Brokers API Release
    • What-If Order Support
    • Commission Data
    • Contract/Contract Details Refactored
  • Fixed Historical Request 1 day limitation
  • Changed TickSizeEvent Args to use TickType instead of TickerType
  • All Enums / Container classes are now marked serializable
  • Fixed bug on Stop Limit Orders "STPLMT" -> "STP LMT"

As always please post on the forums if you find any issues, or email hidden; JavaScript is required with any questions.

Please precede to download from the utilities page, or directly here.

So today I completed my expiration roll over (better late than never!) and even traded a round trip. I have been ridiculously busy at work lately, which has kept me from getting to trading, but I will try to make time next week again.

Rolling over isn’t as bad as I though – in quote tracker you just add the symbols, and then drag and drop the new symbols onto the current chart, and wallah!

Button trader was a little more work as you had to add the symbols and recreate the containers. No big deal really. I just had to request a new password from these guys, their license scheme is a little annoying, but very reliable software!

In any case, no additional indicators today, I have to run to work early. Hopefully this post works from Beta 3!

Various sites report implementations, but always define it in terms of indicators which have varying definitions. Namely FxStreet defines the general concept here, but only in terms of DI+/-, TR and DM+/-, each of which has varying definitions. ForexReal defines ADX here, but uses a completely different concept of TR. Stockwiz has a good overview of all of the variables used (at least they define all of their variables) here. I will be defining the ADX all the way down to price action (what you need when you are coding this…) as best I can to the original definition by J Welles Wilder.

Lets start by defining the Directional Move indicators

Directional Move Indicator

         = the Positive Direction Movement Indicator

          = the Negative Direction Movement Indicator

We use two helper variables to track the delta extreme price changes from yesterday

If today’s range is entirely within yesterday’s range, or the range is the same, then there has been no directional movement.

If the range moved up, then there has been a positive directional move.

If the range moved down, then there has been a negative directional move.

Average Directional Move Indicator

          = the Average Positive Direction Movement Indicator for N periods

          = the Average Negative Direction Movement Indicator for N periods

The Welles Wilder Average is used here to stay true to form, but this average introduces a lot of latency, so I will also implement an exponential moving average.

Alternatively, the formula for the ADM with an exponential moving average is shown below.

True Range

          is the true range for a given period. It is a measure of volatility and takes into account any overnight gap in the period’s price.

Average True Range

          is the average true range for N periods.

The Welles Wilder Average is used here again to stay true to form, but for my C# implementation I will be using the exponential moving average.

Alternatively the ATR can be calculated with the exponential moving average as shown below.

Directional Index

          is the average positive directional movement indicator normalized by the average true range.

          is the average negative directional movement indicator normalized by the average true range.

The directional index calculation is very straight forward and shown below.

Directional Movement Index

          - the directional movement index is the difference of the directional indices over the sum directional indices.

Average Directional Movement Index

          is the average directional movement calculated over N periods.

Staying true to form again, the Welles Wilder Average is used below.

Again, you can alternatively use the exponential moving average as shown below.

C# implementation

So after the laborious research to determine exactly what the ADX is and should be (exponential vs Welles Wilder Average), here is the C# implementation of this indicator.

    //The Average Directional Indicator

    if(barHistory[timePeriod].Count > 1)

    {

        //Directional Movement Indicator

        double deltaHigh = cBar.High – barHistory[timePeriod][barHistory[timePeriod].Count – 2].High;

        double deltaLow = barHistory[timePeriod][barHistory[timePeriod].Count – 2].Low – cBar.Low;

        if((deltaHigh < 0 && deltaLow < 0) || (deltaHigh == deltaLow))

        {

            sig.DmPlus = 0;

            sig.DmMinus = 0;

        }

        else
if(deltaHigh > deltaLow)

        {

            sig.DmPlus = deltaHigh;

            sig.DmMinus = 0;

        }

        else
if (deltaHigh < deltaLow)

        {

            sig.DmPlus = 0;

            sig.DmMinus = deltaLow;

        }

        //Average Directional Movement Indicator

        if(barHistory[timePeriod].Count <= 2)

        {

            sig.AdmPlus = sig.DmPlus;

            sig.AdmMinus = sig.DmMinus;

        }

        else

        {

            double a = (double) 2/(double) (calc.DMIPeriod + 1);

            sig.AdmPlus = sig.DmPlus * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count-2].AdmPlus * (1-a);

            sig.AdmMinus = sig.DmMinus * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].AdmMinus * (1 – a);

        }

        //True Range Indicator

        sig.TrueRange = Math.Max(Math.Abs(cBar.High – cBar.Low),

                                 Math.Max(

                                     Math.Abs(cBar.High – barHistory[timePeriod][barHistory[timePeriod].Count – 2].Close),

                                     Math.Abs(barHistory[timePeriod][barHistory[timePeriod].Count – 2].Close – cBar.Low)));

        //Average True Range Indicator

        if(barHistory[timePeriod].Count <= 2)

        {

            sig.AverageTrueRange = sig.TrueRange;

        }

        else

        {

            double a = (double)2 / (double)(calc.ADXPeriod + 1);

            sig.AverageTrueRange = sig.TrueRange * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].AverageTrueRange * (1 – a);

        }

        //Directional index Indicator

        if (sig.TrueRange != 0)

        {

            sig.DiPlus = 100 * sig.AdmPlus/sig.TrueRange;

            sig.DiMinus = 100 * sig.AdmMinus/sig.TrueRange;

        }

        else

        {

            sig.DiPlus = symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].DiPlus;

            sig.DiMinus = symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].DiMinus;

        }

        //Directional Movement Index Indicator

        if ((sig.DiPlus + sig.DiMinus) != 0)

            sig.Dx = Math.Abs((sig.DiPlus – sig.DiMinus)) / (sig.DiPlus + sig.DiMinus) * 100;

        else

            sig.Dx = symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].Dx;

        //Average Directional Movement Indicator

        if (barHistory[timePeriod].Count <= 2)

        {

            sig.Adx = sig.Dx;

        }

        else

        {

            double a = (double)2 / (double)(calc.DMIPeriod + 1);

            sig.Adx = sig.Dx * a +

                symbolHistory[timePeriod][symbolHistory[timePeriod].Count – 2].Adx * (1 – a);

        }

    }

Sample Data

This is a sample data set consisting of the NYSE A/D 1-min bar data (“Close”) from August 28, 2007 and the 14 period ADX in red.

You can download the new release here. Or go to the utilities page here for all releases.

The release notes for changes are below – enjoy!

9.3.0.5 Bug Fix Release
* Fixed Historical Data Requests (had improperly formatted parameter and timestamps)
* Fixed Disconnect call to properly kill the reader thread
* Added support for additional contracts (Forex, Futures, Indices)
* Began Order Classes, incomplete for now, but started a Limit Order class.
* Fixed Current Time call, it now returns a date time instead of a string.

9.3.0.4 Bug Fix Release
* Added Market On Open enumeration to Time in Force

The Kaufman Adaptive Moving Average is a great low latency moving average filter. It technically has an infinite tail, but cleverly weights the amount of signal for each new bar based on the historical trendiness. If the past data has been choppy, then each new bar is weighed very low in the average, however if the past data has offered a strong direction (regardless of magnitude) then the average weighs new signal very heavily.

There aren’t too many sites discussing the actual formula – I based my implementation on the MetaStock code found here.

I started writing this post in windows Live Writer, and found that it does not keep Visual Studio’s source formatting, so I will try to post this from Word 2007. Word is much better at formatting, but terrible with images, while Live is great with images and managing the site, but terrible with formatting.

//Direction is just present over previous price
double direction = cBar.Close - BarHistory[timePeriod][BarHistory[timePeriod].Count - cnt].Close;
double vol = 0;
//Vol is the sum of all differences in the past period
for (int ix = 1; ix < cnt; ix++)
{
	vol += Math.Abs(BarHistory[timePeriod][BarHistory[timePeriod].Count - ix - 0].Close - BarHistory[timePeriod][BarHistory[timePeriod].Count - ix - 1].Close);
}

//if not enough data, or there has been no price change, then AMA is price.
if ((direction == 0 && vol == 0) || cnt == 1)
{
	sig.Ama = cBar.Close;
}
else
{
	//Elastic ratio
	double ER = Math.Abs(direction/vol);
	double FastSC = 2/(calc.AMAFastEMA + 1);
	double SlowSC = 2/(calc.AMASlowEMA + 1);
	double SSC = ER*(FastSC - SlowSC) + SlowSC;

	//This is the magic scaling/smoothing constant.
	double conC = SSC*SSC;
	if (cnt == 2)
	{
		sig.Ama = BarHistory[timePeriod][0].Close + conC*(cBar.Close - BarHistory[timePeriod][1].Close);
	}
		else if (cnt > 2)
	{
		sig.Ama = BarHistory[timePeriod][barHistory[timePeriod].Count - 2].Close +
		conC*(cBar.Close - BarHistory[timePeriod][barHistory[timePeriod].Count - 2].Close);
	}
}

This is easily my favorite indicator, and with a lot of tweaking can actually be made to have a lot lower latency. The key thing about noise removal, is that signals are noisiest when their trending derivative is lowest. This fact allows a lot of clever hacks to lower the latency of filters like the ATX. That being said, it is often important to use an indicator unscathed, as so much of the market uses it, its performance is a self fulfilling prophesy.

No Trading again today. I have been very actively working on an Auto Trading System, and spent this morning refining my historical data. I realize I owe everyone an updated C# IBAPI release, as I have found numerous bugs.

I also hate the way IB’s historical data works, and have spent a lot of time working out the details on how it should be parsed. I think I have the time zone stuff worked out well, but I can’t decide what the best way to call historical data is.

This was too perfect picture to not post about – the macd cross at 12:30, the stochastics at 12:35, and that was the sell signal. Lead to 4 pt profit!

Not the best way to kick off September, but given how many contracts I traded, I guess I can be grateful I didn’t lose more. Again my problem is that my average loss is much larger than my average win. This is because of my trading style, and needs to be evaluated. I have been scalping a few ticks each time, and when I brought my stop in to two ticks, I got stopped out very frequently (hence the last hour of my trading were all small losses). I need to mechanize this strategy if it will ever work. I am working now on how to download historical data. It appears I have a bug in my implementation, and will likely have to spend some time going over it. I will keep you posted!

I made up to $50 today! Then it was all gone in a single bad quick move trade…

So call your card companies and push down your rates – easiest $150/month I have ever made!

So this month there is at least a green square above! I made money before fees this month, which doesn’t mean anything, except that I have improved over my last month.

As you can see my average loser was almost twice my average winner, hence the losing money problem. I need to develop a system to cut short losing days, as I always let them grow. My win:loss ratio is exactly 50:50 (9 positive days, 9 negative).

This chart illustrates the problem, you can see several strings of positive days, but they are all for small amounts. I need to let my profits run and cut my losses short, a lot easier said than done.

Here we see the problem of fees. The gross sales accumulate very quickly, but I just whipsawed between positive and negative every day. I need to get my winners up, and my losers down.

This month, the number of contracts correlated with my net profits with a ratio of 0.0067, which is incredibly low, in fact it would be difficult for them to be less correlated. This change is especially prevalent from mid august on, as I stopped placing large orders, and kept my bets generally to single contracts.

Next month, I am going to work on a strategy to at least get my winners to be the same size as my losers.

So this post is a month late, but I think it is important to have something to compare myself to before I calculate August’s totals. This was my first month of trading, and as such I did a lot of experimenting. My undoing was that I was trading too many contracts per trade. I was entering with a minimum of two and often three contracts each time. This was my first chance to begin to get a “feel” for the market.

I averaged a daily loss of $85.50 over ten days of trading, trading an average of 45 contracts per day. This will certainly have to turn green before I consider trading real money, but it was a valuable learning experience.

This chart shows my day by day performance, I was profitable for my last two days, which finally began to dig me out of my hole. These charts are net of fees, next I will show the gross to demonstrate the problem of fees.

Here we can see that I was on a healthy clip to breaking even for the month. In fact, had I done the exact opposite of every trade I did, I would be positive! Clearly my overtrading skewed this graph in my net, as you can see days with high contract counts were made that much worst.

Here we can see a light correlation between the number of contracts and the net profit per day,  -0.58732 to be precise. This just emphasizes that I need to be more careful with my bet sizing, as it is costing me heavily.

Next Month I will work heavily on controlling my bet sizing – we will see how I did in my next post.

Sorry about these posts. For some reason Live Writer has been unable to upload – giving me a strange “XMLPC is unreachable” error, when I could easily visit my site in Internet Explorer. I just got things fixed by restarting my computer. I was out for work on Friday, and out of town yesterday, so I did not get a chance to trade the pre-labor day market. I will work on my monthly review this weekend and hopefully get those up by Tuesday.

Have a good weekend everyone!

So I blame experimentation and mistakes on my losses, well today I blame them for my gains. I lost money on the ER2 which is what I was primarily trading, but accidentally punched a forex trade in the wrong direction and left it because it immediately moved against me… I wasn’t watching it but 10 minutes later it was $75 in my favor and I came out profitable for the day!

What I am really spending my morning on is looking for some automated strategies. I am exploring relationships between raw ticks and seeing if I can find 2+tick moves that have some small predictability. I want a consistent low profit strategy, and am making progress.

Do yooooou see anything here?