I knew Robert Pardo as the author of a well known trading book that’s also mentioned in Zorro’s book list. Long before algorithmic trading was widely used, Pardo was thinking about the practical problems that every system developer still faces today: How can you distinguish a robust trading system from a system that has a beautiful backtest, but will go belly-up when exposed to the live market? Pardo’s solution, described in his book, was Walk-Forward Analysis. The idea sounds almost obvious: Optimize a system on one segment of historical data, test it on the next unseen segment, roll the whole window forward, and repeat the process. But this turned what previously was a kind of black art, needing experience and intuition, into a repeatable engineering process.

From Software Pioneer to System Designer

Pardo built some of the early software tools for technical analysis and trading system development. His platforms, such as Chartist and Swing Trader, were part of the prehistory of today’s algorithmic trading platforms such as TradeStation or Zorro. His book, The Evaluation and Optimization of Trading Strategies, became a classic because it addressed the uncomfortable part of trading system development: not how to generate signals, but how to know whether those signals deserve trust.

Using his experience and his development process, Pardo provided algorithmic strategies and consulting to large firms such as Goldman Sachs, Daiwa Securities, Transworld Oil, and DUNN Capital. His systems XT99 Diversified and Pardo Renaissance Diversified systems proved consistently profitable over the years. XT99 alone has been cited over 30 times for excellence and top performance, and made – according to Pardo – millions of dollars for its users. Ranger is the final consequence of his trading philosophy.

What Ranger Is — and What It Is Not

Superficially, Ranger is a strategy script for TradeStation. But calling Ranger “a strategy” is somewhat misleading. Ranger is better understood as a strategy generator.

It is built around a classic idea: the range breakout. The simplest version of a range breakout buys when price exceeds the highest high of the last n bars and sells when price breaks below the lowest low of the last n bars. This idea goes back to Richard Donchian’s four-week breakout system and later became famous in a generalized form through the Turtle Trading system.

Ranger starts there. But instead of giving the trader a fixed breakout model, Ranger offers many switches and variables that change the nature of the system. A Ranger strategy can trade breakouts, pullbacks, with the trend, against the trend, or only when the market is moving sidewards. It can use volatility filters, entry filters, exit orders, profit targets, risk stops, and trailing stops. With different combinations of those elements, Ranger can produce thousands of structurally different strategies.

That is the central idea: not one magic system, but a factory for generating robust systems. 

The Portfolio Concept

One of the interesting aspects of Ranger is not any single indicator or rule, but the portfolio idea. A trader can try to build the perfect strategy for a particular market. That is the traditional approach. Ranger uses a different approach: build a family of strategies whose logic differs enough that they do not all make and lose money at the same time.

This is especially relevant for single-market portfolios. If ten strategies all buy the same breakout and use the same exit, they are not really ten strategies, but ten incarnations of one strategy. Ranger tries to avoid that by offering structural variation: stop versus limit entry, with-trend versus counter-trend logic, volatility regimes, trend-neutral modes, and different exit behavior.

This is where Pardo’s background becomes visible. Ranger is not just a clever signal generator. It reflects the thinking of someone who spent decades worrying about validation, robustness, and the difference between a strategy that looks good in a particular backtest and a strategy that really survives all sorts of market regimes.

RangerZ – the Zorro Version

Robert Pardo contacted us last year for creating a Zorro variant of his Ranger system. RangerZ had to replicate the components, variables, and trading behavior of Ranger, but take advantage of Zorro’s superior speed, optimizing, and analysis functions. My colleague Petra took over the development, and recently wrote an article about it.

I became quickly conviced of Ranger’s flexibility and proven performance. But I was, for various reasons, not so convinced of the ‘Rangermaker’ tool that Robert Pardo uses to evaluate Ranger strategies and build Ranger portfolios, even though they had an impressive track record. That’s why we decided not to replicate this tool and its evaluation process, but developed our own one last year, the Evaluation Shell. 

The Shell converted RangerZ from a manual strategy laboratory to an automated research environment. The setup consists of jobs, variables, assets, time frames, and algorithms. A job defines a particular combination of Ranger variables; Zorro then trains and tests that configuration with all assets and time periods. After further analysis steps, a final portfolio is created. All these processes run fully automated, only at the last stage the user can pick the most uncorrelated strategies by their equity curves from a preselected set. The basic portfolio included in RangerZ results from this process. 

The important point is that RangerZ does not merely translate Ranger from EasyLanguage to C. It embeds Ranger in a full development workflow. Strategies can be compared by their individual equity curves, filtered by cluster analysis, and finally subjected to a Monte Carlo reality check. Although this concept is not reviewed or approved by Robert Pardo, it fits very well with his philosophy: a trading system should not be trusted because its backtest looks good, but because it has survived a disciplined validation process.

RangerZ also makes the Ranger idea more accessible to systematic experimentation. Variable settings can be stored as CSV job files, reused, modified, and combined. Users can begin with the included jobs, then create their own combinations of markets, time frames, trend modes, entry types, volatility filters, exits, stops, targets, and position-sizing rules. Asset lists can be freely defined, so the strategy architecture can be applies to various asset types – CFDs, ETFs, or futures – based on the same markets such as indexes, commodities, or bitcoin.

In that sense, RangerZ is a natural continuation of Pardo’s work. Ranger supplied the strategy architecture. Zorro supplies the engineering machinery around it. Together they turn Ranger from a powerful strategy toolbox into a complete research and development system that can generate almost any sort of strategy.

The old dream of traders was to find the one perfect system. Ranger’s approach is more realistic: Build many good systems, test them properly, and combine them to the final robust portfolio that rules them all.

The strategy in question is arguably the largest trading script ever written. At least it’s the largest I’ve ever seen. The system was created by a famous trader, and is said to produce ‘stellar returns’ for his customers. It had to be now migrated to Zorro. It’s not a single strategy, but a combination of multiple algorithms, similar to Zorro’s Z12 system. However unlike Z12, it is not divided into separate algos that trade simultaneously. Rather, its many indicators, filters, entry and exit conditions can be combined with each other in multiple ways.  With the right combinations, you got the ultimate strategy. What are these magic combinations? I don’t know, but if you buy the system, you can maybe find out.

It turned out that coding the system in C++ was the easiest part of the job. The code was large, but well structured and not very complex. Using C++ reduced the code size by 50% and increased the speed by up to 2000%. I suppose some of its functions are now also more reliable. The challenging part was not the code conversion, but exactly replicating the trade behavior of TS. And that is the main topic of this article.

When you convert an EasyLanguage script to a different platform, you’ll face the problem that TS opens positions – or not – in a way you might not always expect. The usual command for entering a long position with an entry limit looks like this:

TS:  Buy N Contracts Next Bar at MyEntry Limit;
Zorro:  enterLong(N,-MyEntry);

Zorro would then just enter a pending trade at the given limit. But what TS does depends on the context. This is only partially documented, so I had to find out by experiment. Here are the rules by which TS appears to trade and fill positions (unless ‘pyramiding’ is enabled):

• If another buy or sell command was given within the current bar, the new command is ignored.
• If a position in the same direction was already open, the command is ignored.
• If a position in the opposite direction was already open, the command is executed and closes the opposite position when filled.
• If a position in the same direction is currently pending, and if no other buy or sell short command was already given within the current bar, the entry limit of the pending position is set to the current entry limit.
• If no position is open and no other buy or sell short command was given within the current bar, the command is executed.
• If several pending positions hit their entry limits within the current bar, only the first one is filled.
• If a position is filled, the fill price is the given entry limit with no slippage, but 1 point penalty.

Similar rules apply for closing a position.

For replicating the TS behavior, you first need to set up Zorro’s trading parameters in this way:

void emulateTS()
{
  setf(TradeMode,TR_EXTEND); // update pending trades
  MaxLong = MaxShort = 1; // only 1 open position
  Hedge = 1; // close opposite positions
  Fill = 3; // next bar, optimistic mode
  Penalty = 1*PIP; // 1 point
  Slippage = 0; // don’t simulate slippage
  Interest = 0; // don’t calculate margin interest
}

When the entry limit is hit, you must check whether it’s the first hit of the current bar or not. If not, don’t enter. You need a trade management function for this:

#define LastEntryBar AssetInt[0] 
int manage() // fill only the first pending position at any bar
{
  if(TradeIsEntry) {
    if (Bar == LastEntryBar)
      return 1; // don’t open it
    LastEntryBar = Bar;
  }
  return 16; // open it or wait for next entry
}

TS adjusts the entry limits and stops of open positions only if no other buy/sell command was given before on the same bar:

#define LastBarLong AssetInt[1]; 
void buyNextBar(var Limit)
{
  if(Bar != LastBarLong) { // first command of the bar?
    setf(TradeMode,TR_ANYLIMIT|TR_ANYSTOP); // adjust limit/stop
    LastBarLong = Bar;
  } else // don’t adjust 
    resf(TradeMode,TR_ANYLIMIT|TR_ANYSTOP);
  enterLong(Lots,-Limit);
}

#define LastBarShort AssetInt[2]; 
void sellShortNextBar(var Limit) 
{
  if(Bar != LastBarShort) { // first command of the bar?
    setf(TradeMode,TR_ANYLIMIT|TR_ANYSTOP); // adjust limit/stop
    LastBarShort = Bar;
  } else // don’t adjust 
    resf(TradeMode,TR_ANYLIMIT|TR_ANYSTOP);
  enterShort(Lots,-Limit);
}

I do not recommend using this code for other purposes than for emulating TradeStation. But the monster strategy with this trading code opened exactly the same positions at exactly the same time and entry price as the original system on TS.  Only exceptions were a few differences by rounding or by fixing bugs of the original code.

By the way, here are some code lines to replicate some often-used TradeStation parameters in C/C++:

int MarketPosition = sign(NumOpenLong-NumOpenShort); 
var PriceScale = 100; // always 100 for stocks and futures 
var MinMove = PIP * PriceScale; // Stock: 0.01 * 100, Emini: 0.25 * 100 
var PointValue = LotAmount / PriceScale; // Stock: 0.01, Emini: 0.50 
var BigPointValue = LotAmount; 
var EntryPrice = 0; 
for(current_trades) if(TradeIsOpen) EntryPrice = TradeFill;

I hope this helps anyone who happens to get the task of replicating a large TradeStation system on a different platform. Good luck!

A robust trading strategy has to meet several criteria:

• It must exploit a real and significant market inefficiency. Random-walk markets cannot be algo traded.
• It must work in all market situations. A trend follower must survive a mean reverting regime.
• It must work under many different optimization settings and parameter ranges.
• It must be unaffected by random events and price fluctuations.

There are metrics and algorithms to test all this. The robustness under different market situations can be determined through the R2 coefficient or the deviations between the walk forward cycles. The parameter range robustness can be tested with a WFO profile (aka cluster analysis), the price fluctuation robustness with oversampling. A Montecarlo analysis finds out whether the strategy is based on a real market inefficiency.

Some platforms, such as Zorro, have functions for all this. But they require dedicated code in the strategy, often more than for the algorithm itself. In this article I’m going to describe an evaluation framework – a ‘shell’ – that skips the coding part. The evaluation shell is included in the latest Zorro version. It can be simply attached to any strategy script. It makes all strategy variables accessible in a panel and adds stuff that’s common to all strategies – optimization, money management, support for multiple assets and algos, cluster and montecarlo analysis. It evaluates all strategy variants in an automated process and builds the optimal portfolio of combinations from different algorithms, assets, and timeframes. 

The process involves these steps: 

The first step of strategy evaluation is generating sets of parameter settings, named jobs. Any job is a variant of the strategy that you want to test and possibly include in the final portfolio. Parameters can be switches that select between different indicators, or variables (such as timeframes) with optimization ranges. All parameters can be edited in the user interface of the shell, then saved with a mouse click as a job. 

The next step is an automated process that runs through all previously stored jobs, trains and tests any of them with different asset, algo, and time frame combinations, and stores their results in a summary. The summary is a CSV list with the performance metrics of all jobs. It is automatically sorted – the best performing job variants are at the top – and looks like this:

So you can see at a glance which parameter combinations work with which assets and time frames, and which are not worth to examine further. You can repeat this step with different global settings, such as bar period or optimization method, and generate multiple summaries in this way. 

The next step in the process is cluster analysis. Every job in a selected summary is optimized multiple times with different walk-forward settings. The result with any job variant is stored in WFO profiles or heatmaps:

After this process, you likely ended up with a couple survivors in the top of the summary. The surviving jobs have all a positive return, a steady rising equity curve, shallow drawdowns, and robust parameter ranges since they passed the cluster analysis. But any selection process generates selection bias. Your perfect portfolio will likely produce a great backtest, but will it perform equally well in live trading? To find out, you run a Montecarlo analysis, aka ‘Reality Check’.

This is the most important test of all, since it can determine whether your strategy exploits a real market inefficiency. If the Montecarlo analysis fails with the final portfolio, it will likely also fail with any other parameter combination, so you need to run it only close to the end. If your system passes Montecarlo with a p-value below 5%, you can be relatively confident that the system will return good and steady profit in live trading. Otherwise, back to the drawing board.

The use case

For a real life use case,  we generated algorithms for the Z12 system that comes with Zorro. Z12 is a portfolio from several trend and counter trend algorithms that all trade simultaneously. The trading signals are generated with spectral analysis filters. The system trades a subset of Forex pairs and index CFDs on a 4-hour timeframe. The timeframe was choosen for best performance, as were the traded Forex pairs and CFDs. 

We used the evaluation shell to create new algos, not from a selected subset, but from all major Forex pairs and major index CFDs, with 3 different time frames from 60, 120, and 240 minutes. 29 algorithms passed the cluster and montecarlo analysis, of which the least correlated were put into the final portfolio. This is the equity curve of the new Z12 system:

Other performance parameters, such as Profit Factor, Sharpe ratio, Calmar Ratio, and R2 also improved by more than 30%. The annual return almost doubled, compared with the average of the previous years. Nothing in the basic Z12 algorithms has changed. Only new combinations of algos, assets, and timeframes are now traded.

The evaluation shell is included in Zorro version 3.01 or above. Usage and details are described under https://zorro-project.com/manual/en/shell.htm.  Attaching the shell to a strategy is described under https://zorro-project.com/manual/en/shell2.htm.

Just like the performance of a stock, the performance of a company is measured by numerical indicators. They are named key figures. Key figures play a major role in quality management, such as the ISO 9000 standards. An ISO 9000 key figure is a detail indicator, such as the number of faults in a production line, the number of bugs found in a beta test, the number of new clients acquired per day, the total of positive minus negative online reviews, an so on. Aside from being essential for an ISO 9000 certification, these key figures have two purposes:

• They give detailed insight and expose strengths and weaknesses.
• And they give a strong motivation for reaching a certain goal.

The script below opens a user interface for entering various sorts of key figures. It calculates an overall score that reflects the current performance of a company – or of a person – and displays it in a chart. If you use it not for a company, but for yourself, it helps improving your personal life. And from the short script you can see how to create a relatively complex software with relatively few lines of code.

Hackers like the concept of key figures. They are plain numbers that you can work with. Anyone can define key figures for herself. If you’re a writer, an important key figure is the number of words you’ve written today; if you’re an alcolohic, it’s the number of drinks you had today. Many self-improvement books tell you precisely what you need to do for living a healthier, wealthier, happier life – but they all suffer from the same problem: long-term motivation. If you lack the iron will to keep your daily exercises, reduce smoking, stay away from fast food, and so on – all good resolutions will eventually fall into oblivion. If you had resolutions for 2025, you’ll soon know what I mean.

Failure is less likely when you can observe your progress any day and see its immediately effect on your overall performance score. This score is a direct measure of your success in live. Whether you’re a company or a person, you want to keep this core rising. This feedback produces a strong motivation, every day again.

The above performance chart is plotted by the key figure management script in C for the Zorro platform. The red line is the overall score, derived from all key figures in a way explained below. The blue line is the key figure for which you just entered a new value (in the example it’s the number of large or small features implemented in the last 6 months in the Zorro platform). The X axis is the date in YYMMDD format.

Of course, key figures can be very different. Some may have a daily goal, some not, some shall sum up over time, others (like your bank account value) are just taken as they are. The idea is that your overall score rises when you exceed the daily goals, and goes down otherwise. All key figures and their parameters can be freely defined in a CSV file, which can be edited with a text editor or with Excel. It looks like this:

In the first column you can assign a name. The second column is the number of decimals in the display, the third is their unit in the overall score, the fourth is an offset in the score, the fifth is the daily goal, and the last tells if the figures shall sum up over time (1) or not (0).

Example. Suppose you’re a president of a large country and want to pimp up your personal performance. What’s your key figures? First, of course, approval rate. Any tenth percent adds one point to your score. So the first entry is simple:

Name, Decimals, Unit, Offset, Growth, Sum
Appr, 1, 0.1, 0, 0, 0

Next, fame. Key figure is the daily number of praises on Fox News, OneAmerica, and Newsmax. You’ve ordered a White House department to count the praises; of course you’re personally counting them too, just in case. Less than 30 praises per day would be bad and reduce your score, more will improve it. So 30 praises are daily subtracted from your score. Any 10 further praises add one point. This is an accumulative key figure:

Praise, 0, 10, 0, -30, 1

Next, health. Key figure is weight. Your enemies spread rumors that you’re unfit and obese. Your doctors urge you to shed weight. So you want to lose one pound every month, which (you have your mathematicians for calculating difficult things) is about 0.033 per day. Any lost 0.1 pound adds one point to your score. The numbers are negative since you want your weight to go down, not up. The offset is your current weight.

Weight, 1, -0.1, -250, 0.033, 0

Next, literacy. Your enemies spread rumors you’re illiterate. To prove them wrong, you’ve decided to read at least half a page per day in a real book (you’ve chosen Duck for President to begin with). Any further half page adds one point to your score. This is also an accumulative figure.

Duck, 1, 0.5, 0, -0.5, 1

Finally, net worth. You’ve meanwhile learned to better avoid business attempts. Let your net worth grow due to the value increase of your inherited real estate, which is currently at 6 billion. Any million further growth adds one point to your score (numbers given in millions):

Worth, 0, 1, -6000, 0, 0

For improving your personal performance, download the script from the 2025 repository. Copy the files KeyFigures.csv and KeyFigures.c in your Strategy folder. Edit KeyFigures.csv for entering your personal key figures, as in the above example (you can later add or remove key figures and use Excel to add or remove the new columns to the data file). This is the script:

// Pimp Your Performance with Key Figures //////////////////////

string Rules = "Strategy\\KeyFigures.csv";
string Data = "Data\\KeyData.csv"; // key figures history
string Format = "0%d.%m.%Y,f1,f,f,f,f,f,f,f,f,f,f,f,f,f,f";
int Records,Fields;

var value(int Record,int Field,int Raw)
{
	var Units = dataVar(1,Field,2);
	var Offset = dataVar(1,Field,3);
	var Growth = dataVar(1,Field,4);
	var Value = 0;
	int i;
	for(i=0; i<=Record; i++) {
		if(dataVar(2,i,Field+1) < 0.) continue; // ignore negative entries
		Value += Growth;
		if(i == Record || (dataInt(1,Field,5)&1)) // Sum up? 
			Value += dataVar(2,i,Field+1)+Offset;
	}
	if(Raw) return Value-Offset;
	else return Value/Units;
}

var score(int Record)
{
	int i,Score = 0;
	for(i=0; i<Fields; i++) 
		Score += value(Record,i,0);
	panelSet(Record+1,Fields+1,sftoa(Score,0),YELLOW,16,4);
	return Score;
}


void click(int Row,int Col)
{
	dataSet(2,Row-1,Col,atof(panelGet(Row,Col)));
	score(Row-1);
	if(dataSaveCSV(2,Format,Data)) sound("Click.wav");
	int i;
	for(i=0; i<Records; i++) {
		var X = ymd(dataVar(2,i,0)) - 20000000;
		plotBar("Score",i,X,score(i),LINE,RED);
		plotBar(dataStr(1,Col-1,0),i,NIL,value(i,Col-1,1),AXIS2,BLUE);
	}
	if(Records >= 2) plotChart("");
}

void main()
{
	int i = 0, j = 0;
	printf("Today is %s",strdate("%A, %d.%m.%Y",NOW));
	ignore(62);
	PlotLabels = 5;
// File 1: Rules
	Fields = dataParse(1,"ssss,f1,f,f,f,i",Rules);
// File 2: Content
	Records = dataParse(2,Format,Data);
	int LastDate = dataVar(2,Records-1,0);
	int Today = wdate(NOW);
	if(LastDate < Today) { // no file or add new line
		dataAppendRow(2,16);
		for(i=1; i<=Fields; i++)
			if(!(dataInt(1,i-1,5)&1))
				dataSet(2,Records,i,dataVar(2,Records-1,i));
		Records++;
	}
	dataSet(2,Records-1,0,(var)Today);

// display in panel
	panel(Records+1,Fields+2,GREY,-58);
	panelFix(1,0);
	print(TO_PANEL,"Key Figures");
	for(i=0; i<Fields; i++)
		panelSet(0,i+1,dataStr(1,i,0),ColorPanel[0],16,1);
	panelSet(0,i+1,"Score",ColorPanel[0],16,1);
	panelSet(0,0,"Date",ColorPanel[0],16,1);
	for(j=0; j<Records; j++) {
		panelSet(j+1,0,strdate("%d.%m.%y",dataVar(2,j,0)),ColorPanel[0],0,1);
		score(j);
		for(i=0; i<Fields; i++) 
			panelSet(j+1,i+1,sftoa(dataVar(2,j,i+1),-dataVar(1,i,1)),ColorPanel[2],0,2);
	}
	panelSet(-1,0,"Rules",0,0,0);
}

The file locations and the CSV format of the key figures history are defined at the begin. The value function calculates the contribution of a particular key figure to the overall score. The score function updates the overall score. The click function, which is called when you enter a new value, calculates the score of that day, updates the spreadsheet, and prints the chart. The main function imports the data and key figures from their CSV files into datasets, prints the current day and displays a spreadsheet of your key figures and score history, like this:

 

 
You will need Zorro S because the spreadsheet function is not available in the free version. Start the script any morning. It will open the spreadsheet, where you can click in any of the white fields and enter a new key figure value for today. You can anytime enter new figures for today or for past days. At any entry, the score is calculated and – if the history spans more than 2 days – a chart is plotted as in the above example.

Normally, personal performance depends on about 5-10 key figures (maximum is 15). For instance, miles you’ve jogged today, steps walked, exercises done, pages read, words written, words learned in a new language, value of your bank account, value of your stock portfolio, burgers eaten, cigarettes smoked, enemies killed, or number of old ladies you helped crossing the street. If you’re a president, consider the script a free present (we hope for generous tax exceptions in exchange). If you’re an ISO 9000 certified company and want to use the script for your quality management, please contact oP group to pay your fee. For personal use, the script is free. Pimp your performance and make the world a better place!

They told that they will now charge hefty fees for using their store, for asking support questions, and for paying out. Mentioning the payout, they also told that they will from now on hold back payments for 2 months. Aside from the fact that they cannot legally change conditions in this way without their client’s consent, emails like that are normally business suicide. Since all competitors offer much better conditions, Digital  River would clearly sooner or later lose all their clients in this way. This email was a mystery. It made only sense under the assumption that Digital River intended to go out of business, but keep as much as their currernt client’s money as possible by offsetting them with insane fees.  

But Digital River did not hold back payments for 2 months. In November they stopped paying altogether. They did not give explanations. Reminders were answered with meaningless text blocks like this:

Please know that we are fully aware of the situation and are working diligently to resolve these issues as quickly as possible. Our team is investigating the cause of these delays to ensure they address them effectively and prevent such occurrences. We understand how important these payments are for you and your business. We are committed to ensuring that all outstanding payments are processed and that our communication with you is clear and timely moving forward. We appreciate your long-standing partnership and your trust in us over the years. Rest assured we are taking your concerns very seriously and trying to rectify this situation.“

There is a lot of speculation about what is behind it. Some believe that Digital River ran in liquidity problems, and originally intended to still pay, although later and fewer. The legality of this is disputable, but it does not yet constitute obvious fraud. However, most clients now assume that they prepared an exit fraud with the intention to keep all their client’s sales. In that case the mysterious email had just the purpose to delay legal action.

On their website, Digital River gives no hint of any trouble, and continues to run the stores and charge the customer’s credit cards as if nothing happened. The only thing certain is that clients are now hurrying to switch to other eCommerce providers, such as PayPro Global or Paddle, and that their last three months earnings are possibly gone. Unless some part of if can be recovered by lawsuits or criminal proceedings.

Since most Zorro S license subscribers run their subscriptions through Digital River, oP group has activated a fallback server for verifying subscription tokens. So all subscriptions will remain valid until renewed with the new online store provider, PayPro Global. If you have recently purchased a product from Digital River, better cancel the charge on your credit card or request a refund. At least in some cases, it was reported that refunds were indeed paid.  

More details: Digital_river_runs_dry | Missing payments and evasive communication

We are going to define some windowing functions that operate on a data series and thus can be applied to any indictor. First, the triangle:

vars triangle(vars Data, int Length)
{
  vars Out = series(0,Length);
  int i;
  for(i=0; i<Length; i++)
    Out[i] = Data[i] * ifelse(i<Length/2,i+1,Length-i);
  return Out;
}

The triangle factors are simply increasing until the middle of the Data series, then decreasing again. The function takes a data series and returns the modified data series. Next, the Hamming window: 

vars hamming(vars Data, int Length, var Pedestal)
{
  vars Out = series(0,Length);
  int i;
  for(i=0; i<Length; i++)
    Out[i] = Data[i] * sin(Pedestal+(PI-2*Pedestal)*(i+1)/(Length-1));
  return Out;
}

This one produces a sine curve with a phase shift given by the Pedestal parameter. Finally, the Hann window that multiplies the data with a reversed cosine curve:

vars hann(vars Data, int Length)
{
  vars Out = series(0,Length);
  int i;
  for(i=0; i<Length; i++)
    Out[i] = Data[i] * (1-cos(2*PI*(i+1)/(Length+1)));
  return Out;
}

For testing the effect of  windowing, we’re applying the 3 functions to the SMA of the SPY price curve derivative. The code and the resulting chart:

void run()
{
  StartDate = 20191101;
  EndDate = 20210101;
  BarPeriod = 1440;
  assetAdd("SPY","STOOQ:*"); // load data from STOOQ
  asset("SPY");

  vars Deriv = series(priceClose() - priceOpen()); // slope
  plot("FIR_SMA",SMA(Deriv,20),NEW,RED);
  plot("Triangle",SMA(triangle(Deriv,20),20),NEW,RED);
  plot("Hamming",SMA(hamming(Deriv,20,10*PI/360),20),NEW,RED);
  plot("Hann",SMA(hann(Deriv,20),20),NEW,RED);
}

The chart displays at the top the original SMA, and below the SMA applied with a triangle, Hamming, and Hann data window. For testing the smoothness of the indicator, Ehlers used the rate-of-change (ROC) of the SMA. The code in C:

var ROC_SMA(vars Data,int Length)
{
  vars Filt = series(SMA(Data,Length),2);
  return Length/(2*PI)*(Filt[0]-Filt[1]);
}

Now we can replace the SMA in the above run() function with ROC_SMA. Again, first the original ROC_SMA, and below applied on a triangle, Hamming, and Hann data window:

We see in the chart that the Hann window generates the smoothest curve, and this at no cost of lag. What can you now do with a Hann windowed indicator, such as the ROC_SMA of the SPY derivative? Well I think the same that you did with the original indicator, whatever it was, only better. The windowing functions and test script can be downloaded from the 2021 script repository.

If it were true…

Our politics and media are controlled by elites who worship Satan and run a child sex ring. According to a recent poll, 17% of Americans agree to this statement, 46% disagree, 37% say they don’t know. The 17% believers seem no  big surprise. In most groups of 100 people you’ll  find 17 crackpots . Or maybe 17 antisemitists, since “elites” or “globalists” are code for “the Jews”. But how is it possible that 37% “don’t know”?

You normally match a conspiration narrative with your model of reality. How plausible is it? If it were true, how would it work? How many had to be involved? How could it be hidden? Why would someone post it when it’s so secret? How trustworthy is the source? What interest has the source in spreading it? What interest have I in believing it?

It’s not too difficult to answer these questions. But if half of the US population still either wants to believe, or just doesn’t know whether their country is run by a satan worshipping, child abusing cabal, we have a problem.

The Bear Test

In the far past, alternative facts tended to correct themselves. If you propagated that cave bears don’t exist, sooner or later all your followers would end up in bears’ bellies. Reality check at work. But if you today believe in QAnon, chemtrails, evil elites, or China funded election stealing conspiracies, reality won’t reach out and slap you in the face. Your belief won’t put you at an immediate disadvantage. But nevertheless it will have consequences.

The obvious one is incompetent political leadership. Representative democracies compete all the time with other forms of government. The United States, with their economical and military power, could be the natural leader in that competition. Instead, in the last 4 years they became the global laughingstock. Administration by bragging and alternative facts can please followers, but is ill suited for real challenges, such as handling a pandemic. And when US voters decided in November 2020 to terminate that debacle, they were unaware that the worst was yet to come…

There might be other, more sinister consequences of widespread conspiration belief. Real conspirations can easily hide behind the walls of disinformation. Real whistleblowers are not taken seriously because of all the crackpots. In this way, conspiration theories can become self fulfilling prophecies.

Monetizing Twitter Likes

Trump & Co. are not the cause, but the effect of a global phenomenon – the emergence of bizarre parallel worlds that compete with reality. In those wolds, Trump has won the election, communists invade America, and evil scientists, pedophiles, the FBI, Fauci, and George Soros plot to take away citizens’ freedom, their health, even their steaks. Far-right social platforms such as Parler or Gettr are full of invented quotes or made up ‘news’ that endlessly confirm themselves. Those parallel worlds won’t disappear by voting, nor by censorship. Attempts by Twitter and others to shield users from the flood of misinformation are futile: People will always find ways of confirming what they want to believe. You cannot censor the Internet – and if you could, like China, it would be a questionable achievement. But it is still possible to fight disinformation. And even derive a decent income in this way. 

This post, 8 weeks after the election, was obviously at odds with reality. Still, 128700 people apparently agreed to the alternative fact. But instead of the lame “Election officials have certified bla bla bla…”, or even worse, censoring the nice TV lady – dear Twitter, how about this? 

If you’re Twitter, imagine that you would get 50 cents for any of the 128k likes to this post. Simply add a [Buy] and [Sell] button for any post with a controversial, but easily verifiable claim. Any user that’s buying Christina’s brilliant analysis can just click [Buy] and invest one dollar in that post. Then they will be able to like or retweet it. If someone is not buying it, they click [Sell] and short the post for 1 $. After a previously defined time, Twitter will evaluate the Pennsylvania outcome and distribute 50% of the stakes to the buyers or sellers, whoever were right. The remaining 50%  stay with Twitter. 

The Q Opportunity

You don’t need to wait for Twitter to monetize alternative facts. There are already some platforms that show how this works – check out  https://www.predictit.org/, https://polymarket.com/, or https://ftx.com/trade/TRUMPGO/USD. You can see that many conspiration believers are indeed investing money on those platforms. There are bets that Joe Biden will soon get arrested, or that Trump will soon have a comeback as president, and possibly execute some leading democrats on the way. The stakes are usually in the 80% range that this won’t happen, but a trade with 20% certain profit is still not to be sniffed at. Look out for conspiration bet opportunities! Do it before major contenders, such as Twitter or Facebook, enter that lucrative business. That will be in the interest of the common good – but it will likely reduce your profit. 

In this way, just being reasonable minded can earn you some decent extra income. Admittedly, if you’re a cult follower, conspiration believer, and/or Trump fanboy, you might have to pay the price – but hey: consider it a proof of faith. And if you lost too much money with your bets, you could be motivated to check facts before buying them. This will possibly improve your grip on reality. And can end up, maybe, with better leadership of your country. So it’s a win-win situation.

That’s my comment to last week’s events, and my today’s tip for getting rich, or even richer if you’re Twitter or Facebook. Establish fact brokerages, let more people bet on facts, and let the truth win!

Kaufman’s 6 patterns were named Key Reversal, Island Reversal, Outside Days, Wide Ranging days, 3-Day Compression, and Gap opening. All are calculated from the previous 3 or 4 candles or price ranges. All but one are symmetric, meaning they deliver bullish and bearish signals. And because I’m a bit on the evil side, I added a 7th pattern that I just invented: TotalRandom.

Here’s how the patterns look as indicators in C:

// a higher high followed by a lower close. 
var cdlKeyReversal()
{
  if(priceHigh(0) > priceHigh(1) && priceLow(0) < priceLow(1)) {
    if(priceClose(0) < priceLow(1)) return -100; // sell
    if(priceClose(0) > priceHigh(1)) return 100; // buy
  } 
  return 0;
}


// recent 3 days each have a true range smaller than the 4th previous day.
var cdl3DayCompression()
{
  vars TRs = series(TrueRange(),4);
  if(TRs[0] < TRs[3] && TRs[1] < TRs[3] && TRs[2] < TRs[3])
    return 100;
  else
    return 0;
}

// a gap higher followed by a lower close, but not filling the gap. 
var cdlIslandReversal()
{
  if(priceLow(0) > priceHigh(1) && priceClose(0) < priceOpen(0)) 
    return -100; // sell
  if(priceLow(1) > priceHigh(0) && priceClose(0) > priceOpen(0)) 
    return 100; // buy
  else return 0;
}

// a higher high and a lower low, close in upper or lower 25% of the range.
var cdlOutsideDay()
{
  if(priceHigh(0) > priceHigh(1) && priceLow(0) < priceLow(1)) {
    if(priceClose(0) < 0.75*priceLow(0) + 0.25*priceHigh(0)) 
      return -100; // sell
    if(priceClose(0) > 0.25*priceLow(0) + 0.75*priceHigh(0)) 
      return 100; // buy
  } 
  return 0; 
}

// same as outside days, but true range must exceed 1.5 × 20-day ATR
var cdlWideRangeDays()
{
  if(TrueRange() > 1.5*ATR(20))
    return cdlOutsideDay();
  else
    return 0;
}

// gap must be larger than 0.5 × 20-day ATR.
var cdlGapOpening()
{
  var Ratio = (priceOpen(0) - priceClose(1))/ATR(20);
  if(Ratio >= 0.5) return 100;
  if(Ratio <= -0.5) return -100;
  return 0; 
}

// just enter a trade when you feel lucky
var cdlTotalRandom()
{
  int Pattern = random(100);
  if(Pattern > 90) return 100;
  if(Pattern < 10) return -100;
  return 0;
}

Following the convention of the classic candle pattern indicators from the TA library, the pattern functions return +100 for a bullish pattern, -100 for a bearish pattern, and 0 for no pattern.

We’re now putting them to the  test. We want to trade the patterns with IWM, AAPL, AMZN, GE, WMT, and TSLA stocks, with SPY and QQQ index ETFs, and with and without an additional trend filter. For any detected pattern, we’re entering a long or short position depending on if it’s bullish or bearish. We always invest the same amount, regardless of the price of the stock. The position is closed after 1, 2, 3, 4, or 5 days. For any asset and any exit type we’ll export the number of trades and the total win and loss to a table in HTML format. That is convenient for me because I can paste it directly in this blog article.

The test script:

var pattern();

function run()
{
  pattern = cdlKeyReversal;
  bool WithTrend = 0;
  string Name = "KeyRev";

  BarPeriod = 1440;
  StartDate = 20100101; // TSLA went public in 2010
  EndDate = 2020; // test until 2020
  var Investment = 10000;
  TradesPerBar = 40; // 8 assets * 5 algos

  char File[100];
  if(is(EXITRUN)) {
    sprintf(File,"Log\\%s.htm",strf("%s%s",
      Name,ifelse(WithTrend,"WithTrend","NoTrend")));
    printf("\nStoring results in %s",File);
    file_write(File,strf("<p>%s:</p>\n<table><tr>",File),0);
// write the table header
    file_append(File,"<td>Asset</td>",0);
    file_append(File,"<td>Long/Short</td>",0);
    file_append(File,"<td>Day 1</td>",0);
    file_append(File,"<td>Day 2</td>",0);
    file_append(File,"<td>Day 3</td>",0);
    file_append(File,"<td>Day 4</td>",0);
    file_append(File,"<td>Day 5</td></tr>",0);
  }

  assetAdd("SPY","STOOQ:*.US"); // load price history from Stooq
  assetAdd("QQQ","STOOQ:*.US");
  assetAdd("IWM","STOOQ:*.US");
  assetAdd("AAPL","STOOQ:*.US");
  assetAdd("AMZN","STOOQ:*.US");
  assetAdd("GE","STOOQ:*.US");
  assetAdd("WMT","STOOQ:*.US");
  assetAdd("TSLA","STOOQ:*.US");

  while(asset(loop("SPY","QQQ","IWM","AAPL","AMZN","GE","WMT","TSLA"))) {
  vars Trend = series(SMA(seriesC(),80));
  while(algo(loop("Day1","Day2","Day3","Day4","Day5"))) {

  Lots = Investment/priceClose();
  LifeTime = Itor2+1; // life time in days
  int Signal = pattern();
  if(Signal > 0 && (!WithTrend || rising(Trend)))
    enterLong();
  else if(Signal < 0 && (!WithTrend || falling(Trend)))
    enterShort();
  if(is(EXITRUN)) {
    if(Algo == "Day1") // first loop run
      file_append(File,strf("\n<tr><td>%s</td><td>%i/%i</td>",
        Asset,NumWinLong+NumLossLong,NumWinShort+NumLossShort),0);
    string Color = ifelse(WinLong-LossLong+WinShort-LossShort > 0,
      "bgcolor=\"lime\"","bgcolor=\"red\"");
    file_append(File,strf("<td %s>%.0f/%.0f</td>",
      Color,WinLong-LossLong,WinShort-LossShort),0);
    if(Algo == "Day5")
      file_append(File,"</tr>",0);
  }

  }} // loops
  if(is(EXITRUN)) {
    file_append(File,"</table>",0);
    file_append(File,strf("<p>Total Profit: %.0f (%.0f%%)</p>",
      WinTotal-LossTotal,100*(WinTotal-LossTotal)/Investment),0);
  }
}

Some explanations about the code. At the begin of the run() function the pattern and the trend mode are set up. For convenience we’re using a function pointer that is set to the pattern function to be tested. Afterwards, when it’s the last run, the table header is written into the HTM file. A char array (File) and the sprintf() function is used for the file name instead of the more convenient strf(), because we need to keep the file name for later writing into the table.

The test uses two nested loops, first for selecting the stocks, second for selecting the trade life time to get the results from a 1-day trade up to a 5-days trade. The predefined Itor2 variable is the iterator of the second loop and runs from 0 to 4, so we just use it to set the LifeTime variable for the subsequent trade. The results are printed in the EXITRUN at the last day of the simulation.

The numbers in the tables are the results from long/short trades. A winning pattern is displayed in green, a losing pattern in red. Transaction costs are considered.

One should think that most clients come up with very similar trading systems, so we could meanwhile just click them together from ready code. But it is not so. There’s apparently no limit of trading ideas. Almost any other system uses some new trading method, unusual data source, or exotic indicator. Still, the systems can be classified in several simple categories. Any of them has its specific success and failure rate.

Trading systems categorized

We classify the systems by their market and by their trading rules, both specified by the client. The 4 main markets are Forex/ CFDs, cryptocurrencies, stocks/ETFs/futures, and options. And the 4 main algorithmic trading methods are risk premia, market models, data mining, and indicator soups.  To recap:

Risk premium systems gain higher profits by accepting higher risks. In that category fall many stock portfolio rotation and options trading systems.

Market model systems exploit a particular market inefficiency by detecting anomalies in price curves. Mean reversion, market cycles, market events, or statistical arbitrage are typical model based trade methods. 

Data mining systems predict a price trend by evaluating signals with a machine learning algorithm (aka ‘artificial intelligence’). Those signals are usually derived from the order book or the price curve, but sometimes also from fundamental data or exotic data sources.

Indicator soups are the most often demanded systems. They do not target a particular market inefficiency, except maybe for going with the trend. They generate trade signals from a combination of traditional or new invented ‘technical indicators’. 

Some algo trading systems can fall in more than one category. For instance, a grid trader can be considered a risk premium system (high probability of small wins against low probability of high losses), but also a model based system (exploitation of volatility anomalies). If a system cannot be clearly assigned, it is split among several categories in the table below. We can see that clients favor some of the 16 possible combinations, while others are rare:

For determining the success or failure rate, we used 8-years backtests for unoptimized systems, and a walk forward analysis for optimized systems. A successful system had to return at least 12% CAGR for stocks, futures, or options, or 30% annual profit for Forex, CFDs, or cryptocurrencies. The R2 parameter had to be above 0.7. If clients ordered a Montecarlo analysis, the system had to pass it at 95% confidence. If one of those conditions was not fulfilled, the system was classified as failure. 

The percentages of successful systems:

 The average success rates at the end of the columns and rows are weighted by the number of systems. We can see that the overall success rate was only 66%. In 34% of cases we had to break the bad news to the client that it’s not advised to trade this system live. It produced no, or too little profit in the tests. Sometimes we could see what the problem was, and suggest ways to improve the system. But even total failures were no wasted money. When you know that your favorite manually traded system won’t work in the long run, you’ll save a lot more money than spent for programming and testing. 

And the winner is…

The statistics are spoiled by the forex and crypto systems, half of which were losers. This is at least better than most such systems from trading books or trader forums, of which 90% fail already in a simple out-of-sample test, or at least in a cluster or Montecarlo analysis. We got a surprising result in the ‘Indicator soup’ systems. You would normally expect that they all fail big time, since they are not based on a market model. But in fact almost every third indicator hodgepodge was successful, even in live trading on a test server. Maybe the clients knew more than we did. 

It is also a bit surprising that the most complex systems of all, the data mining systems that usually employ deep learning algorithms, did not fare much better. They have an acceptable success rate, but are easily surpassed by a certain sort of much simpler systems. 

Of all systems we tested so far, the big winners were the long-term trading systems for stocks, ETFs, or options. Of the option traders, the simpler systems had often better performance. It’s relatively hard to specify a losing option system, but some still managed it by using short expiration dates, complex entries, fancy rollovers, or intraday buying and selling. One of the very simple, but successful option traders was included in the Zorro scripts.

We found another trend that is not visible in the table: With a few exceptions like HFT or arbitrage, there was an almost linear correlation between time frames and performances. Systems on one, five, or ten minute bars were rarely profitable. The good systems traded mostly on 1-hour, 4-hour, or 24-hour time frames. Faster is not always better.

This does not mean that we all should now abandon forex and cryptos and trade only long-term options or ETF portfolios. Diversification is a key to success. All markets still have long periods of ineffectivity and plenty opportunities of trading profits. Maybe the statistics above help to look for them. 

Update (2025): This article was posted 5 years ago, and we have meanwhile more than 2000 systems programmed for clients. Due to technical progress especially with machine learning systems the overall success rate is now slightly better at 71%. But the success relations between the various trading methods are still the same.

Related articles

⇒ I Hired a Contract Coder

⇒ Build Better Strategies!

‘Activator’ is an indicator synonym that I didn’t know before. However the Gann Hi-Lo Activator (GHLA) does not activate something, but compares the current price with the SMAs of the highs and lows of a price series. Depending on the comparison, it returns one of the two SMAs. It is said to indicate a bullish market when the current price is above the Activator, and a bearish market when it is below. The comparison sign is also stored in a ‘Color’ variable which we must later use for the swing trading system. The C code:

var ColorGHLA;
var GHLA(int HPeriod,int LPeriod)
{
 vars H = series(priceHigh());
 vars L = series(priceLow());
 vars MaH = series(SMA(H,HPeriod),2);
 vars MaL = series(SMA(L,LPeriod),2);
 vars State = series(0,2);
 if(priceClose() > MaH[1]) State[0] = 1;
 else if(priceClose() < MaL[1]) State[0] = -1;
 else State[0] = State[1]; // return the previous state
 ColorGHLA = State[0];
 return ifelse(State[0] < 0,MaH[0],MaL[0]);
}

We store the sign in the series State of length 2 because the indicator inventor required to return the previous sign when the price was between the two SMAs. If you wonder why I did not just use a static variable to store the previous sign: That would work for one asset, but not for a portfolio, if someone ever wants to trade one with this indicator.

Two other indicators are used in the author’s swing trading system: the difference of Welles Wilder’s plus and minus directional indicators, named DMI, and a variant by William Blau of the Stochastic indicator, named ‘Stochastic Momentum Index’ (SMI). The code:

var DMI(int Period)
{
 return PlusDI(Period) - MinusDI(Period);
}

var SMI(int DLength,int KLength)
{
 var Hi = HH(KLength), Lo = LL(KLength);
 var Diff = Hi-Lo;
 var RelDiff = priceClose()-(Hi+Lo)/2;
 var AvgRel = EMA(EMA(RelDiff,DLength),DLength);
 var AvgDiff = EMA(EMA(Diff,DLength),DLength);
 return ifelse(AvgDiff!=0,AvgRel/AvgDiff*200,0);
}

All 3 together on a chart gives already an impressive show of colorful lines. Here’s the script for replicating the author’s chart with the indicators on an NVDA price curve:

function run()
{
 BarPeriod = 1440;
 StartDate = 20200201;
 EndDate = 20200410;
 assetAdd("NVDA","STOOQ:NVDA.US");
 asset("NVDA");

 var Ghla = GHLA(3,3);
 var Smi = SMI(3,8);
 var Dmi = DMI(10);
 plot("GHLA",Ghla,LINE,BLUE);
 plot("DMI",Dmi,NEW|BARS,BLUE);
 plot("SMI",Smi,NEW|LINE,BLUE);
 plot("Zero",0,0,BLACK);
}

The resulting chart (sorry, blue colors only):

For trading this indicator soup, the author recommends opening a position when all 3 indicators are in sync, meaning they have the same sign. That’s why we needed the ‘color’ of the GHLA. So we will now open a long position when all signs are positive, and reverse to a short one when they are all negative. We can just use the charting script with this additional code:

MaxLong = MaxShort = 1;
if(ColorGHLA > 0 && Dmi > 0 && Smi > 0)
 enterLong();
if(ColorGHLA < 0 && Dmi < 0 && Smi < 0)
 enterShort();

Sure enough, this system shows stellar performance in the author’s example chart of Spring 2020. 3 out of 4 trades are winners. But what happens when we trade it for a longer period, for example 5 years? Set the StartDate variable to a 2015 date and repeat the test.

The sad result:

We can see that the system can do anything: win, lose, and stay flat over long periods. The end result is zero. Apparently,  successful swing trading needs other methods. Or maybe better indicators? Of course, this quick test does not mean much. It’s possible that the GHLA works when removing the other indicators and using other entry conditions, such as entering positions only on a peak. Or maybe the indicator periods were ill chosen and had to be adapted to the market by an optimization process. But at least we got now three more indicators for our collection.

The SMI, DMI, and GHLA indicators, as well as the code for the chart and the trading system can be downloaded from the 2020 script repository.