TradeInterceptor SDK Quick Start Guide

Size: px

Start display at page:

Download "TradeInterceptor SDK Quick Start Guide"

Cora Shelton
6 years ago
Views:

1 TradeInterceptor SDK Quick Start Guide Installation Custom indicators and trading strategies can be created using the Java programming language, version 6.0. A free copy of Java development kit (JDK) can be downloaded from the Java site. In this guide we using the Eclipse Java development environment, which can be downloaded for free from the Eclipse site eclipse.org. Although it is not described here, custom indicators and strategies can be developed using any other Java development environment. The examples in this guide were developed using Eclipse 3.5. TradeInterceptor SDK Contents The TradeInterceptor SDK contains jar files with the compiled interfaces, the corresponding source files, and the javadoc documentation. The javadocs, along with this guide, are also available unjarred. The files in the distribution are as follows: chartingsdk_x.x.x.jar The compiled interfaces to be linked against your indicator. This file is required for building any indicators. It is not necessary to deploy this file in the TradeInterceptor environment. chartingsdk_x.x.x-doc.jar The API docs for the SDK interfaces. This file is not required for building, but development environments may use it to provide handy autocomplete or online help during development. For desktop browsing, deflated view of the same files is provided in the doc directory. It is not necessary to deploy this file in the TradeInterceptor environment. doc The TradeInterceptor API documentation, this guide, and an example Eclipse project. To get started, import the example project in Eclipse, and build it using the provided build script. A test-indicator.tip file is created in the project's build folder (the project view may need to be refreshed in order to make this file visible). This file should be opened by the TradeInterceptor platform in order to install theindicators and strategies in it. Creating the First Custom Indicator Lets look at a very simple custom indicator. This indicator draws a single close line over a chart. package com.riflexo.charting.test; 1

2 import com.riflexo.charting.api.abstracteasycalculator; import com.riflexo.charting.api.barproperties; import com.riflexo.charting.api.line; import com.riflexo.charting.api.plugin.annotation.indicator; import Indicator") public class HelloWorldIndicator extends AbstractEasyCalculator { private Line<BarProperties> public void calculate() { public void declare() { output = declareoutput("close"); output.setdefaultcolor(color.black); setname("hello World Indicator"); The custom indicator contains two main pieces: the declaration and the calculation. Declaration Custom indicators declare the resources they are using, the parameters they are receiving, and the output they are providing the their declare method. Our simple indicator is providing only a single line output, declared as the variable output. We decide to paint this line in black using the setdefaultcolor method. Consult the javadocs for more information for the capabilities of the Line outputs. The declared line output is placed on the main chart by default. By using the setstandalone(false) method, indicator developer can instruct its line to reside in another pane, below the main chart. When this method is invoked, indicator should forfeit its internal values, and redeclare its resources. Invocation of this method signals, that this indicator will be recalculated in somehow changed context, and its current internal state may be no longer relevant. Indicator developer should not invoke this method by himself. The declare method is called each time the indicator is placed on the chart, or when its parameters are changed. This method may also be called as a response to internal charting events. Calculation All the calculations of the indicator are performed in the calculate method. In our example, this method merely gets the close value for the current bar, and sets it as current value for the output, which was already declared in the declare method. 2

3 The getmainseries() method retrieves the main time series for the chart, which is, the time series first loaded. The individual bars of this time series are accessible as Items reflecting the open, low, high and close, volume, the timestamp and some more proeprties for an individual bar. In a general convention, the current bar is accessed by the getdataitem() method, without parameters. The previous bar can be accessed using the getdataitem(int) method with parameter 1; the second previous bar is accessed using getdataitem(2), etc. The same applies for other types of time series. As with the declare method, user should invoke the calculate method directly. The calculate method is invoked automatically each time a new bar of one of the referenced time series should be processed. The Indicator Lifecycle When user places this indicator on the chart, first its declare method is invoked by TradeInterceptor. The indicator declares its output and the declare phase is finished. Then all the available bars from the main chart are automatically traversed, and the indicator's calculate method is invoked on each bar. The indicator thransfers the current close price from the data series to its output, and the calculation for this bar is finished. Finally, when all bars in the history are traversed, the indicator starts receiving realtime history updates. The indicator promptly transfers the current close to its output, and we can see the line on the chart following the last bar's close value. Note that both calculate and declare methods are invoked automatically by the runtime. Also, the calcualte method of the indicator should not iterate itself over the bar history - instead, it can concentrate on calculating the current last value. The Calculation Context The custom indicator can communicate with its runtime using its Calculation Context. Once the indicator is instantiated, a trading context is associated with it using the setcontext method. If the indicator extends the AbstractEasyCalculator (which is strongly recommended), the storing and accessing this context is automatically performed. The AbstractEasyCalculator, on its side, implements the CalculationContext interface, and delegates to the already configured calculation context. Creating the First Trading Strategy A trading strategy analyzes market data, optionally using some indicators, to execute market decision. In TradeInterceptor, market strategies fit in the same framework as the custom indicator. Indeed, the only defining feature of a strategy is that its implementing class is annotated with annotation. All the discussion about indicator lifecycle, calculation context, and the declare and calculate and methods in the indicator section applies also to the trading strategy development. Position Management Strategies should create and manipulate positions in their calculate method. All position management of a trading strategy should be performed using the position manager in the calcualtion context. 3

4 Strategy should assign a client agent to the created positions, so that later these positions can be looked up later easily. By default, a custom strategy is executed in auto commit mode. In this mode created and modified positions are automatically committed to the server when the execution of the calculate method exit successfully. If the calculate method exits with exception, these modifications are not committed to the server. The auto commit mode can be turned off using the autocommit property of the Strategy annotation. If the autocommit mode is turned off, it is strategy developer's responsibility to commit or rollback changes. In the autocommit mode, Position instances created during a run of the calculate method become invalid on the next run of the calculate method. If particular position needs to be preserved for later examination (for example, to be canceled if certain conditions are held), it can be obtained from the position manager using its getpositionbyid method. If this position is no longer available, an exception is thrown. This signals that the very existence of this position should be forgot, so the strategy may need to adjust its internal state accordingly. 4

5 A Simple Strategy Here is the code for a simple strategy. package com.riflexo.charting.test; import java.awt.color; import com.riflexo.charting.api.abstracteasycalculator; import com.riflexo.charting.api.line; import com.riflexo.charting.api.numbervaluedescriptor; import com.riflexo.charting.api.param; import com.riflexo.charting.api.stockindicator; import com.riflexo.charting.api.plugin.annotation.strategy; import com.riflexo.trading.api.position; import com.riflexo.trading.api.positionmanager; import com.riflexo.trading.api.positionside; import com.riflexo.trading.api.positionstate; import = "Test strategy", autocommit=true) public class HelloWorldStrategy extends AbstractEasyCalculator { private Line<Object> output; private StockIndicator<Object> movingaverage; private Object positionid; private Param<Integer> qtyparam; private Param<Integer> movingaverageperiod; private enum CrossOverType { CROSS_OVER, CROSS_UNDER, NONE public void calculate(){ try{ docalculate(); catch(tradingexception _ex){ // no position - getpostionbyid has thrown exception positionid=null; throw _ex; protected void docalculate() { if(getmainseries().getindex() < movingaverageperiod.get() + 2) { return; // not enough data. PositionManager positionmanager = getpositionmanager(); output.set(movingaverage.get()); 5

6 CrossOverType crossovertype = CrossOverType.NONE; if(movingaverage.get(1) < getmainseries().getdataitem(1).getclose() && movingaverage.get(2) > getmainseries().getdataitem(2).getclose()) { crossovertype = CrossOverType.CROSS_OVER; output.setcolor(color.red); else if(movingaverage.get(1) > getmainseries().getdataitem(1).getclose() && movingaverage.get(2) < getmainseries().getdataitem(2).getclose()) { crossovertype = CrossOverType.CROSS_UNDER; output.setcolor(color.blue); else { output.setcolor(color.black); if(crossovertype == CrossOverType.NONE) { return; Position position = positionid==null?null:positionmanager.getpositionbyid(positionid); if(position!= null) { if(position.getstate().compareto(positionstate.closed) >= 0) { positionid = null; // position was closed elsewhere else if( // we have opened position (crossovertype == CrossOverType.CROSS_OVER && position.getside() == PositionSide.SELL) (crossovertype == CrossOverType.CROSS_UNDER && position.getside() == PositionSide.BUY) ) { position.cancel(); positionid = null; else { if(crossovertype == CrossOverType.CROSS_OVER) { position = getpositionmanager().newposition(getmainseries()); position.setprice(double.nan); position.setside(positionside.buy); else if(crossovertype == CrossOverType.CROSS_UNDER) { position = getpositionmanager().newposition(getmainseries()); position.setprice(double.nan); position.setside(positionside.sell); if(position!= null) { position.setreason(crossovertype+"->"); String id = String.valueOf(position.getId()); String pref = "HW-"; 6

7 id = pref+id; position.setid(id); position.setclientagent("helloworldstrategy"); position.setquantity(qtyparam.get()); positionid = public void declare() { qtyparam = declareinput(new NumberValueDescriptor<Integer>("Position size", "qty", 1000, 1000, 1000, )); movingaverageperiod = declareinput(new NumberValueDescriptor<Integer> ("Period", "period", 20, 1, 1, 10000)); movingaverage = declarestockindicator("ma", "ExponentialMovingAverage", movingaverageperiod.get()); output = declareoutput("close"); 7

8 Declaration The strategy declares two parameters - the quantity of each trade, and the length of the moving average. Parameters for strategies and indicators are declared using the declareinput method of the calculation context. These method allows use to define a human-readable name of the parameter, an internal, developer name, and, where applicable - minimum, maximum and default value of the parameter. The declareinput methods returns a Param instance which can be used during the calcualtions. In this example we also declare a stock indicator - the ExponentialMovingAverage. Calculation To illustrate the concept of the missing position, this strategy does store the object id of its currently open position or null, if no position is opened. Since this position may disappear without the knowledge of the strategy, we catch the trading exception thrown by the getpositionbyid method and reset the field to null when such exception is thrown. Important: strategy developers are strongly encouraged to use listposition method of the context position manager and look up for the positions opened by this strategy when they need to access their positions. In the docalculate code, we skim the logic of the strategy itself and focus on how positions are placed. The snippet position = getpositionmanager().newposition(getmainseries()); position.setprice(double.nan); position.setside(positionside.buy); shows how a long market position should be created. The context position manager is used to create a new position using the main series of the current chart. For illustration of the concept, the price is set to Double.NaNm which is anyway the default value. This means, that this is a market order; if the price is set to a non-nan value, this position would be a pending order. The side of the position can be buy or sell. The position may also be set with stop loss and take profit, an expiration, etc. Few lines below, if new position is created, it is decorated with some other options: position.setreason(crossovertype+"->"); String id = String.valueOf(position.getId()); String pref = "HW-"; id = pref+id; position.setid(id); position.setclientagent("helloworldstrategy"); position.setquantity(qtyparam.get()); The reason property describes why this particular action on the position is executed. Positions has a history of modifications, starting with its creation, and for each modification the modificator supplied reason can be accessed. 8

9 Note that the position id is also modified. Position ids on new positions can be changed, and in this example we choose to brand the position id with the HW prefix. Also, we set the client agent property, so that positions created by this strategy can be easily spotted later. And, finally, the quantity of the position is set. The quantity itself comes from the qtyparam parameter, which was declared in the declaration phase. 9

BEAAquaLogic. Service Bus. Interoperability With EJB Transport

BEAAquaLogic. Service Bus. Interoperability With EJB Transport BEAAquaLogic Service Bus Interoperability With EJB Transport Version 3.0 Revised: February 2008 Contents EJB Transport Introduction...........................................................1-1 Invoking