By acquiring the ADR Engine, clients can reduce the costs and uncertainties of developing trading systems and internal order books without sacrificing flexibility. The trade matching engine can be configured and re-configured in accordance with changing business requirements. It was developed by people who understand the requirements imposed on trading systems by users and the regulatory authorities.

Range of Orders supported:

The ADR Engine handles a full range of input types including:

• Normal Limit orders
• Quotes
• Spread Orders (for linked, automatic execution of strategies)
• Cross Orders
• Trade Legs (for OTC Trade Matching)
• Stop Limit Orders
• 'At Market' Orders (can be supported during the opening phase if required)

Supported Order Validity and Execution restrictions include:

• Good For Day
• Good 'Till Cancelled
• Good 'Till Date
• All or None
• Fill or Kill

The ADR Engine registers and acknowledges new orders as part of its audit trail functionality. Orders are time stamped so that the matching algorithm can calculate time priority. The engine can process order modifications and cancellations according to a set of pre-defined rules. These rules may reflect the user's requirements. For example, the user can specify the restrictions on the traders' ability to modify an order before the order loses its time stamp and thus its priority in the queue of orders.

Our product processes partial fills and enables users to track the progress of their business.

Market Management

Through its trading phase management function (see 'Trading phases' below) the ADR Engine supports market management functions, including contract expiry and contract re-specification within the trading day.

The engine also supports the sub-division of a market into 'trading groups' and 'contract groups'. A 'contract group' is a group of contracts or securities and a trading group is a group of contract groups. All contracts in a contract group change phases simultaneously. The engine supports randomised opening if required.

Derived Orders

The ADR Engine is able to generate Derived orders when Good 'Til or Good For Day spread orders are entered which cannot be fulfilled immediately. Derived orders are intended to give price improvement for spread traders and to improve market liquidity in spread trading.

Derived orders can be displayed differently from other orders by appropriate coding in the 'wrapper'.

The engine allows normal orders to execute against derived orders and ensures that both legs of a derived order execute together.


The ADR Engine generates outputs detailing those orders held in the books with their current status on input and again whenever any event causes the order status to change (e.g. an order fill, modification or cancellation). Trade information is also output indicating the trade price and volume together with details of the orders involved in the trade. The engine also outputs 'market watch' messages. These can be used to display current best bid and ask prices for all traded instruments by driving either market trade tickers or information dissemination interfaces. All outputs are sent to the 'wrapper' where the customer's code is responsible for forwarding them to other sub-systems such as the 'market watch' function and the information dissemination interface.

Trading Phases

The ADR Engine supports the following trading phases which can be configured to support the user's requirements:

• Pre-call (delete derived orders, sort open orders, calculate theoretical opening price; order entry permitted)

• Call to market (generate trades, order entry suspended)

• Pre-open (execute limit orders, generate derived orders)

• Open (continuous matching)

• Close (matching stops)

Our product can handle Trading Phase changes automatically. Once a phase change is requested, the engine will carry out all necessary operations on the order books to move to the requested phase, for example order book balancing and calculation of the market opening prices. The engine also allows the user to move a market between phases manually if necessary, for example if it needs to be closed and re-opened with an amended contract specification.

Technical features and benefits

The ADR Engine is an object oriented application written in C++. Object oriented programming allows designers and engineers to replicate the business environment in the structure of the software more readily than previous computer languages. Once compiled, C++ code can run on a variety of machines with a variety of operating systems. Object oriented programs make it easier to incorporate business rules into computer code and also facilitate changes to the characteristics of the contracts being traded. The engine uses lists and binary trees to hold information about tradable instruments and details of buy, sell and stop limit orders together with quotes and trade legs. Trade legs can be used for post trade OTC matching and can, if required, be disabled within a particular installation of the engine in accordance with the user's needs. The combination of C++ code and the table and tree structure provides for maximum throughput for the matching process.

The matching engine may be run as multiple 'instances' of the same program. This increases resilience and can also provide performance benefits. If the user runs multiple instances, the derived order functions (see above) create orders only within the instance. For example, if an exchange ran one instance for banks and one for industrials, it would be possible automatically to execute spreads involving two or more banks or two or more industrials.

The user of the Matching Engine does not need to know anything about the internals of the list structures or how the engine works in order to use it. All order validation, matching, queue priority and modification rules are built into the engine.

There is no system dependent coding in the ADR Engine. It was initially developed and tested on SUN Solaris using standard C++ syntax and functions and has also been successfully run on AIX and Windows NT. The engine is not a complete matching server but does support all matching functionality. It requires to be 'wrapped' within a user application process which is responsible for communication between the engine and other servers in the customer's trading system (e.g. Order Entry Server, Order and Trade Blotter servers etc.). This design isolates the engine from customer specific code used to communicate between server processes.

Input to the ADR Engine is accomplished using calls and passing pre-defined structures containing order information. Output from the engine is handled using "call backs" in the user's application code which are again passed structures by the engine containing output from the relevant event which has occurred. The engine has special calls for initialisation and for registering user "call-back" functions together with calls to handle exception processing and recovery, for example following a hardware failure.

The product has been tested to high standards of processing capacity, though its performance in a particular computing environment will necessarily depend on the characteristics of the environment as well as the engine itself.

The ADR Engine is delivered as an object library for the customer's own platform. Our consultants are able to make any necessary alterations to the input / output structures to support specific customer needs for data items and assist with integration of the product if required.

A test harness is also provided with the engine which allows customers to test engine functions fully independently of the rest of the system thereby isolating matching functionality and providing the ability to verify test scenarios and expected results of the overall system during integration testing of the customer's application. Full technical support is available including hotline or on-call support. Training can be provided by arrangement.

For further information please call or email us.