Portfolio Trader Strategy Examples

Portfolio Trader Strategy Examples for regular MultiCharts (PowerLanguage) can be downloaded here

Rotation Strategy

This strategy was suggested by kbeary33 on MultiCharts Forum (http://www.multicharts.com/discussion/viewtopic.php?f=19&t=45413).

Strategy Description

Rotation Strategy is a simple strategy that calculates a specific indicator by using every instrument in the portfolio. Positions are opened for those instruments which have the best indicator value(s).

Take for example the % Change indicator. This set of instruments is determined by the user in the Portfolio Trading application. The number of instruments to enter a Long position is configured by the BuyBestX input. Standard stop loss +profit target strategy is used to exit positions.

Strategy Development

Portfolio_Rotation Signal

This signal generates entry orders and calculates indicator values for all instruments in the portfolio.

Indicator formula is entered into the input field and it is calculated on every bar.

inputs:
Formula (PercentChange(close, 14));
variables: formulaValue(0);
formulaValue = Formula;

To further compare and decide to enter the position, the formula is then entered into global variables:

pmm_set_my_named_num ("RotationalValue", formulaValue);

Entries for all instruments are generated:

buy("LE") next bar market;
sellshort("SE") next bar market;

To manage the capital, standard Portfolio settings Margin per Contract and Potential Loss per Contract set by the user will be used:

pmm_set_my_named_num("MoneyCostForInvestPerCtrct", pmms_to_portfolio_currency(MoneyCostForInvestPerCtrct));

var: PotentialEntryPrice(close), MoneyCostForInvestPerCtrct(0);
if (entryprice > 0) then PotentialEntryPrice = entryprice;
MoneyCostForInvestPerCtrct =
pmms_calc_money_cost_for_entry_per_cntrct(PotentialEntryPrice, Portfolio_GetMarginPerContract)
+
pmms_calc_money_cost_for_entry_per_cntrct(PotentialEntryPrice, Portfolio_GetMaxPotentialLossPerContract);

When one lot price value is calculated, this value will be converted into portfolio currency and written into portfolio global variables.

pmm_set_my_named_num("MoneyCostForInvestPerCtrct", pmms_to_portfolio_currency(MoneyCostForInvestPerCtrct));

Standard Stop Loss and Profit Target set in percent from portfolio capital will be used for exit.

inputs: StopLossPcntsOfPortfolio(0.1),
ProfitTargetPcntsOfPortfolio(0.1);
variable: value(0);
setstopposition;
value = StopLossPcntsOfPortfolio * 0.01 * Portfolio_Equity;
setstoploss(convert_currency(datetime[0], portfolio_CurrencyCode, SymbolCurrencyCode, value));
value = ProfitTargetPcntsOfPortfolio * 0.01 * Portfolio_Equity;
setprofittarget(convert_currency(datetime[0], portfolio_CurrencyCode, SymbolCurrencyCode, value));

Portfolio_Rotation_MM Signal

The signal is used as a Money management signal in portfolio. This study verifies the indicator values for all the portfolio instruments and manages positions opening. The number of portfolio instruments for which positions will be opened is set by the user:

inputs:
BuyBestX(10),
SellWorstY(10);

Indicator values will be extracted for all the strategies and a sorted list of values at every calculation will be created. To do so, we will need to use 2-dimensional array of the indicator values and the strategy indexes:

variables: idx(0), strategyIdx(0), strategyValue(0);
arrays: allStrategies[10000, 1](-1);

Entry orders generation before every calculation is denied:

pmms_strategies_deny_entries_all;

Fill the array with the indicator values and the index for each strategy and then we will sort out the array by values:

for strategyIdx = 0 to pmms_strategies_count - 1 begin
strategyValue = pmms_get_strategy_named_num(strategyIdx, "RotationalValue");
allStrategies[strategyIdx , 0] = strategyValue;
allStrategies[strategyIdx , 1] = strategyIdx;
end;
Sort2DArrayByKey(allStrategies, pmms_strategies_count, 1);

Let’s count the number of strategies that are now in position. According to the best indicator indexes BuyBestX instruments should have Long position and SellWorstY instruments should have Short position:

variables: inLong(0), inShort(0);
arrays: strategiesLong[](-1), strategiesShort[](-1);
inLong = pmms_strategies_in_long_count(strategiesLong);
inShort = pmms_strategies_in_short_count(strategiesShort);

In calculation we cycle through those strategies that should have Long position according to the indicator indexes (wherein, if the strategy is already in position, we track it in strategiesLong array):

for idx = 0 to BuyBestX - 1 begin
cur_idx = allStrategies[idx, 1];
if (not array_contains(strategiesLong, cur_idx)) then
pmms_strategy_allow_long_entries(cur_idx)
else
strategiesLong[array_indexof(strategiesLong, cur_idx)] = -1;
if UsePortfolioMoneyPcnt then
pmms_strategy_set_entry_contracts(
cur_idx,
pmms_calc_contracts_for_entry( PortfolioMoneyPcntForEntry, cur_idx )
);
End;

Strategies which are in position, but are not among the best according to the indicator indexes are forced to close:

for idx = 0 to inLong - 1 begin
value1 = strategiesLong[idx];
if value1 >= 0 then begin
pmms_strategy_close_position(value1);
end;
end;

Strategies for Short entry are processed likewise.

Spread Trading Strategy

Strategy Description

Spread trading is a type of trading where instruments, divided into pairs, trade in opposite directions. This type of trading occurs when a Long Position is opened for one instrument, while another is opened simultaneously in the opposite direction (Short). Both of these positions open and close synchronously.

Here is an example. A portfolio has two pairs of instruments: QQQ vs SPY and KO vs PEP.

The strategy will enter into position when the spread deviation exceeds a Standard Deviation value for the last 20 bars. The Second Pair of Instruments enters synchronously into a position opposite the Main Instruments (First Pair).

Strategy Development

Portfolio_SpreadTradingSystem.Master Signal

This signal is calculated based on an instrument’s data series. It contains opening and closing logic positions:

inputs: Ratio(c / c data2), Length(10), PercentOfEquity(10);
var: AvgRatio(0), StdDevRatio(0);
var: intrabarpersist cur_pos(0);
var: Contracts_(0);
Contracts_ = Portfolio_Equity * PercentOfEquity / 100;
if 1 < currentbar then begin
if AvgRatio + StdDevRatio < Ratio then begin// short data1, long data2
if -1 <> cur_pos then begin
sellshort Contracts_ contracts this bar at c;
cur_pos = -1;
end;
end else if AvgRatio - StdDevRatio > Ratio then begin// buy data1, short data2
if 1 <> cur_pos then begin
buy Contracts_ contracts this bar at c;
cur_pos = 1;
end;
end else begin
cur_pos = 0;
sell this bar c;
buytocover this bar c;
end;
end;
AvgRatio = XAverage(Ratio, Length);
StdDevRatio = StdDev(Ratio, Length);

Other calculations require the strategy to be applied to a portfolio of symbols, so we need to check and see if that’s the case:

if 1 = getappinfo(aiisportfoliomode) then begin
// code
end;

For the basic strategy, we need to return the strategy index of the second instrument and check if it has been applied:

var: slave_idx(pmms_strategies_get_by_symbol_name(symbolname data2));
once if 0 > slave_idx then
raiseruntimeerror(text("specified slave trader on instrument ", doublequote, symbolname data2, doublequote, " not found"));

To synchronize the capital invested into positions for both instruments, we need to send the price of the current position of the main instrument to the pair strategy:

value22 = absvalue(cur_pos*Contracts_) * c * bigpointvalue;
if 0 < value22 then
value22 = pmms_to_portfolio_currency(value22);
pmms_set_strategy_named_num(slave_idx, "MPMoney", -cur_pos * value22);

Portfolio_SpreadTradingSystem.Slave Signal

This signal Portfolio_SpreadTradingSystem.Slave Signal is calculated for the second instrument of the pair. It monitors all entries and exits generated by the previous signal Portfolio_SpreadTradingSystem.Master Signal for the main instrument of the pair and trades in the opposite direction. Firstly, all synchronization is done when MPMoney variable returned by master strategy changes.

value1 = pmms_from_portfolio_currency( pmm_get_my_named_num("MPMoney") );

We extract this variable and convert it from portfolio currency into instrument currency. Then, based on its value, we calculate the number of contracts for potential entry positions:

value33 = c;
if marketposition <> 0 then
value33 = entryprice;
master_mp = IntPortion( value1 / ( value33 * bigpointvalue) );

The instrument’s current position:

my_mp = currentcontracts*marketposition;

Now we will check to see if its position is unsynchronized. If that’s the case, then we will synchronize it with the main strategy:

if sign(my_mp) <> sign(master_mp) then begin
...
end;

We’ll check if the main instrument’s position has closed:

if 0 = value1 then begin // need to close position
if my_mp > 0 then
sell all contracts this bar c
else
buytocover all contracts this bar c;
#return;
end;

If it has closed, we’ll close the position for the second instrument as well. If the main instrument has an open position, then we will determine the position’s direction for the second instrument:

if 0 < value1 then begin // we must buy
if 0 < value1 then begin // we must buy

Value1 > 0 means that to synchronize the positions we should buy. There can be two cases:

1. The current flat or short position should change to long, i.e., the master strategy has reversed its position or has entered a long position from the flat state.
2. The current position is already long which means that the first instrument partially closed its short position, signifying that we need to partially close the second instrument’s position.

if Sign(master_mp) <> Sign(my_mp) then
buy absvalue(master_mp) contracts this bar c
else
buytocover value1 contracts this bar c;

In the opposite case:

end else begin
if Sign(master_mp) <> Sign(my_mp) then
sell short absvalue(master_mp) contracts this bar c
else
sell absvalue(value1) contracts this bar c;
end;

Value1 < 0 means that we need to sell to synchronize the positions; there also can be two cases:

1. The current flat or long position should change to short, i.e., the master strategy has reversed its position or has entered a short position from the flat state.
2. The current position is already short which means that the first instrument partially closed its long position, signifying that we need to partially close the second instrument’s position.

Appendix

Portfolio signals scripts are added to MultiCharts and MultiCharts64 by default.

Rank Strategy

This strategy can be considered a modification of the Rotation Strategy.

This strategy was suggested by Angelos Diamantis.