Technology Overview


Trading-System-API is a C++ class library that supports the simulation and deployment of automated trading and investment strategies as well as related research and development. The current 3.0 release is an important milestone as it introduces a host of new features as well as substantial architectural changes. While previous releases were primarily focused on enabling highly complex trading system simulations, this latest release introduces functionality that allows strategies to trade any number of instruments simultaneously with advanced order management functionality such as required by strategies that place and manage an arbitrary number of active orders. This change in product focus led us to change the product name from Time-Series-API to Trading-System-API.


Architecture

Trading-System-API was developed with the following goals in mind:

 

Trading-System-API builds on the power of the C++ language and offers intuitive semantics and class design. There are few practical limits to the type and complexity of the applications that can be implemented. This is important as the key to successful trading is the ability to develop innovative trading strategies that go beyond what the competition does. C++ is an ideal language for such undertaking as it can natively call any one of the thousands of C and C++ API's in existence today covering all domains of interest such as database connectivity, statistics, digital signal processing, neural networks, genetic algorithms, and many others.

Trading-System-API introducing a number of powerful abstractions that greatly simplify the process of working with timeseries. There is no need to use pointers or manually allocate memory. Furthermore, the library introduces outstanding order and a transaction management functionality that fits well with its event based architecture.

Trading-System-API is a 'library' and not a 'platform', which is why developers can use fully featured IDE's such as Eclipse CDT or MS-Visual Studio to benefit from advanced debugging and profiling capabilities. Trading strategies are compiled to standard executable files that are then launched on the command line, taking startup parameters in the familiar way. Applications are run in debug mode for testing and in release mode for deployment, just like any other software project. This means that the learning curve is low for experienced C++ programmer.

This approach also facilitates the modeling of trading strategies that are too complex to evaluate in a linear fashion as these can be broken into manageable steps, allowing for various methods of pre-processing and normalization with interim data storage stages between steps.


Applications

The following are some of the applications for which the library was designed:

  • Automation of trading and investment strategies

    • Intraday strategies (down to microsecond intervals)

    • End-of-day strategies

    • Multi instrument strategies

    • Company / Country fundamental strategies

  • Computational modeling

    • Brute Force optimizations

    • Genetic algorithms

    • Monte Carlo simulations

  • Economic modeling

  • Timeseries normalization and processing

    • Timeframe conversions

    • Data Transformations

    • Data Normalizations

  • Data Monitoring

    • Event monitoring

    • Filtering applications

    • Pattern recognition


Product Features



Multi-Contract Strategies

  • Trade multiple futures, equities, options, currencies - all from within a single strategy.
  • Multi instrument functionality allows you to do your portfolio hedging from within the same strategy that manages the portfolio.

Order Types

  • Limit, stop, stop-limit and market orders.
  • Fixed price orders - these are for more accurate historical simulations and allow you to create an order with a fixed execution price, such as the current bid or ask.

 

 

Comprehensive Reporting

  • Strategy simulations produce output in the form of interactive HTML.
  • Each strategy run produces its own output directory for easy record keeping.
  • Simulation analysis: Strategy-Performance-Report, Trade-Report, Transaction-Report, Order-Report.

Chart Types

  • Strategy simulations can produce charts and chart-books (.png).
  • Bar, area and line plots.
  • Discontinuous and variable color plots.
  • Plots showing strategy transactions and active orders.

Order Features

  • Fractional units for trade size and position size (simulation only).
  • Execution type specific allocation of slippage.
  • User defined limit order fill proviso (in simulation) for more realistic limit order fills.

 

 

 

Bar (Interval)Types

  • Variable length bars: volume-bars, tick-bars, etc.
  • Fixed length bars: 1-sec, 5-min, etc.
  • Bar length as short as 1 microsecond.

 

Endless Simulations

  • Advanced load-on demand memory management.
  • Run simulations over decades of tick data without straining ressources.

Strategy Scheduling

  • Internal (auto) scheduling.
  • Scheduling from external data sources.
  • Strategies can access multiple series with non-compatible record timestamps.

 

 

 

Metrics Aggregations

  • Performance metrics from multiple independent strategies can be aggregated.
  • Metric Aggregations themselves can be further aggregated.

Data Input

  • From native database tables.
  • From memory based tables.
  • From other sources (such as SQL databases), possible via custom adapters.

 

Data Output

  • to native database tables
  • to standard streams / files
  • to charts / chart-books
  • other output targets ( such as SQL databases ), possible via custom adapters.

 

 

 

Standards Based

  • Written in standards based C++(11)
  • Integrates well with various toolchains and platforms.

License

  • Reasonable license terms

 

Source Code

  • Human readable source code is available for a fee

 

 

 

Support and Consulting

  • We provide support and consulting services