An algorithmic trading simulation

The purpose of this simulation is to buy one million shares using an algorithm working on a limit order book. The simulation is based on a statistical model of limit order and market order arrival: there is no inherent direction to price movements - this is truly a random walk - but the statistical order flow will adjust to reflect the balance of orders on the book.

The diagram opposite is updated as limit orders and market orders arrive. On the far left is the Open-High-Low-Close chart for the limit order book. The market VWAP is shown on the line joining the market metrics to those of the order being worked.

To the right in blue are the limit price for the order and the average execution price achieved by the algorithm. The figure in grey is the average execution price of another 'shadow' algorithm working an equivalent order.

The simulation runs one step at a time, during which limit and market orders arrive and the algorithms can also place their orders.

#	quantity	price	price	quantity	#
			561.5
			561.25
			561
		560
		559.75
		559.5

The algorithm

The default trading algorithm is a simple implementation of a single synthetic iceberg order pegged to the bid. The iceberg quantity is calculated in relation to recent market volume, the order open quantity and a standard tranche size. When the order book is heavier on the bid, the algorithm will use a market order. To make it easy to understand, the algorithm omits complexities such as selling as well as buying.

The script is written in JavaScript based on a number of predefined objects. You can edit this script and replace the default by using the link below.

/*
 *    Keep the iceberg size and other information in the state.
 */
if (!state.size) {
    state.size = 5000;
    state.share = 0.3;
    state.volume = 0;
}
/*
 *    Snapshot the market volume.
 */
var vol = symbol.orderbook.volume();
/*
 *    What quantity is available to work?
 */
var available = 0;
if (state.volume > 0) {
    available = Math.min(state.size, Math.round(state.share * (vol - state.volume)));
    available = Math.min(order.open(), available);
} else {
    available = Math.min(state.size, order.open());
}
/*
 *    Remember the volume for next time.
 */
state.volume = vol;
/*
 *    What is the price to work at?
 */
var bestbid = symbol.orderbook.bestBid();
var bestask = symbol.orderbook.bestAsk();
var bestprice = bestask.price - (2 * symbol.ticksize);
if (bestprice < bestbid.price) {
    bestprice = bestbid.price;
}
if (bestprice > order.limit) {
    bestprice = order.limit;
}
/*
 *    Aggress if there is significantly more bid quantity but at a smaller size
 *    to lessen the impact on the average price.
 */
var biddepth = symbol.orderbook.bidLevels();
var askdepth = symbol.orderbook.askLevels();
if (biddepth.length > 0 && askdepth.length > 0 && biddepth[0].quantity > 2 * askdepth[0].quantity) {
    if (askdepth[0].price <= order.limit) {
        var marketorder = new MarketOrder();
        marketorder.direction = order.direction;
        marketorder.quantity = Math.min(order.open(), askdepth[0].quantity);
        marketorder.add();
        log.info('Algorithm takes ' + marketorder.quantity);
    }
} else {
    /*
     *    What is on the limit order book?
     */
    var ownbids = symbol.orderbook.ownBids();
    if (ownbids.length == 0) {
        /*
         *    Submit a new limit order.
         */
        log.info('Algorithm makes new bid for ' + available + ' at ' + bestprice);
        var limitorder = new LimitOrder();
        limitorder.direction = order.direction;
        limitorder.quantity = available;
        limitorder.price = bestprice;
        limitorder.add();
    } else {
        /*
         *    Amend the existing limit order.
         */
        var narrative = '';
        var limitorder = ownbids[0];
        if (limitorder.price != bestprice) {
            limitorder.price = bestprice;
            narrative = ' amends bid price to ' + bestprice;
        }
        if (limitorder.quantity < available) {
            var qty = available - limitorder.quantity;
            limitorder.quantity += qty;
            narrative += ' increases bid quantity by ' + qty;
        }
        if (narrative.length > 0) {
            log.info('Algorithm' + narrative);
            limitorder.amend();
        }
    }
}

Use this script

The shadow algorithm

The shadow trading algorithm is a pure synthetic iceberg order pegged to the bid, with no aggression.