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!

 For connecting the Zorro platform to a particular broker API, a DLL must be dropped in its Plugin folder. The DLL is then automatically recognized and appears in Zorro’s Broker selection box. For trading with the broker, the DLL exports functions for getting prices and sending orders. These functions are standardized and described in the Zorro manual. They are the same for all brokers. The following 4 functions are the most important:

BrokerOpen – identify the DLL.
BrokerLogin – initialize and store login credentials.
BrokerAsset – retrieve price and other parameters of an asset.
BrokerBuy2 – send a buy or sell order.

These four are sufficient for running most trading strategies. The DLL can export additional functions that are useful, but not mandatory, since Zorro works around them when they are not implemented:

BrokerAccount -get the account state.
BrokerTrade – get the trade or order state.
BrokerHistory2 -get price history.
BrokerCommand – set special modes, get order book, etc.

Zorro users have written DLLs for several broker APIs, but the code is often redundant and invents the wheel many times again. I’ll give here an example of a relatively lean broker DLL that can be used as template for individual REST API implementations. Bittrex is a US based digital currency exchange that supports several hundred crypto currencies and provides free API access. We’re first going to implement the 4 mandatory functions, following the API description on the Bittrex website:

https://bittrex.github.io/api/v3

We will use the free Visual C++ Community Edition from Microsoft. Aside from the exported functions, we need some internal functions to print messages, send HTTP requests, parse a JSON response, and generate a digital signature. For all this there’s ready code available on the Internet, but there are also ready functions in Zorro’s library. To make life easier, we simply import the Zorro function library to the DLL. The VC++ setup for generating such a DLL is described here:

https://zorro-project.com/manual/en/dlls.htm

The setup is for a C++ trading strategy, but works as well for a broker API DLL. First we’re going to implement the adminstrative stuff, the BrokerOpen and BrokerLogin functions:

#define PLUGIN_TYPE 2
#define PLUGIN_NAME "Bittrex V3"
#define DLLFUNC extern "C" __declspec(dllexport)

int (__cdecl *BrokerMessage)(const char *Text);
int (__cdecl *BrokerProgress)(const int Progress);
...

DLLFUNC int BrokerOpen(char* Name,FARPROC fpMessage,FARPROC fpProgress)
{
  strcpy_s(Name,32,PLUGIN_NAME);
  (FARPROC&)BrokerMessage = fpMessage;
  (FARPROC&)BrokerProgress = fpProgress;
  return PLUGIN_TYPE;
}

The BrokerOpen function is Zorro specific. It sets up two function pointers for printing message and sending heartbeats to Zorro. It’s needed for recognizing the DLL in the Plugin folder and letting the plugin name, “Bittrex V3”, appear in the broker scrollbox. 

Next we need the login function that’s called at the begin and the end of any algo trading session

struct GLOBAL {
  int PriceType,VolType,OrderType;
  double Unit; // smallest trade unit
  char Path[256]; // send path buffer
  char Key[256],Secret[256]; // credentials
  char Symbol[64],Uuid[256]; // last trade symbol and UUID
  char AccountId[16]; // account currency
} G; // parameter singleton
...

DLLFUNC int BrokerLogin(char* User,char* Pwd,char* Type,char* Accounts)
{
  if(User) { // login
    memset(&G,0,sizeof(G));
    strcpy_s(G.Key,User);
    strcpy_s(G.Secret,Pwd);
    return 1;
  } else  // logout
    return 0;
}

This function only sets up the G struct, a singleton that holds all global variables of the DLL. The User and Pwd arguments contain the Bittrex key and secret. They are taken from the Zorro login fields or from the account list. Type is the account type, ignored here because Bittrex has no demo accounts.  Account is the account identifier and also ignored since we’re not using sub-accounts.

Next comes the function to retrieve prices and other parameters of a particular cryptocurrency. It’s a bit more complex and requires a HTTP request to the API. Some requests require authentication, some not. For all this we first implement a send() function in the DLL that uses Zorro’s functions for sending http requests and generating a HMAC signature. The authentication method by the Bittrex REST API V3 is a bit complex:

To properly sign an authenticated request for the Bittrex v3 API, the following headers must be included: Api-Key, Api-Timestamp, Api-Content-Hash, Api-Signature. Api-Timestamp is the current time as a UNIX timestamp in epoch-millisecond format. Api-Content-Hash is a SHA512 hash of the request body, Hex-encoded (with no request body, a SHA512 hash of an empty string). For creating the Api-Signature, first generate a string by concatenating the following items: Contents of the Api-Timestamp header; the full URI used to make the request, including query string; the HTTP method of the request, in all caps (GET, POST, DELETE, etc.); Contents of the Api-Content-Hash header. Sign this string via HmacSHA512, using the API secret as the signing secret. Hex-encode the result and populate the Api-Signature header with it.

This is the implementation:

#define RHEADER "https://api.bittrex.com/v3/"
...

int sleep(int ms)
{
  Sleep(ms); 
  return BrokerProgress(0);
}

char* send(const char* Url,
  int Mode = 0,
  const char* Method = NULL,
  const char* Body = NULL)
{
  static char Url[1024], Header[2048], Signature[1024],
    Buffer1[1024*1024], Buffer2[2048];
  *Signature = *Header = 0;
  sprintf_s(Url,"%s%s",RHEADER,Url);
  if (Mode & 1) { // Authentication required
    strcpy_s(Header, "Content-Type:application/json");
    strcat_s(Header, "\nAccept:application/json");
    strcat_s(Header, "\nApi-Key: ");
    strcat_s(Header,G.Key);
    strcat_s(Header, "\nApi-Timestamp: ");
    __time64_t Time; _time64(&Time);
    static __time64_t Offset = 0;
    char* TimeStamp = i64toa(Time*1000 + Offset++); 
    strcat_s(Header, TimeStamp);
    strcat_s(Header, "\nApi-Content-Hash: ");
    char* Hash = hmac(Body, 0, 0, 512);
    strcat_s(Header,Hash);
    strcpy_s(Signature, TimeStamp);
    strcat_s(Signature, Url);
    if(Method && *Method)
      strcat_s(Signature, Method);
    else if(!Body)
      strcat_s(Signature,"GET");
    else
      strcat_s(Signature,"POST");
    strcat_s(Signature, Hash);
    strcat_s(Header, "\nApi-Signature: ");
    strcat_s(Header, hmac(Signature, 0, G.Secret, 512));
  }

  char* Response = Mode & 2? Buffer2 : Buffer1;
  int MaxSize = Mode & 2? sizeof(Buffer2) : sizeof(Buffer1);
  int Id = http_request(Url,Body,Header,Method);
  if(!Id) goto send_error;
// wait 30 seconds for the server to reply
  int Size = 0, Wait = 3000;  
  while (!(Size = http_status(Id)) && --Wait > 0)
    if(!sleep(10)) goto send_error;
  if (!Size) goto send_error;
  if(!http_result(Id,Response,MaxSize)) goto send_error;
  Response[MaxSize-1] = 0; // prevent buffer overrun
  http_free(Id);
  return Response;

// transfer unsuccessful?
send_error:
  if(Id) http_free(Id);
  return NULL;
}

The above code adds an authentication header with signature when Mode == 1. Mode == 2 selects a second, smaller response buffer and thus allows to evaluate two API responses at the same time. The sleep function generates a delay with a heartbeat to keep the Zorro window responsive during long requests. If it returns 0, someone has hit Zorro’s [Stop] key and all operations should be aborted. The Windows _time64 function has only 1-second resolution, so we add an incremented Offset for generating unique timestamps.

We’re now prepared to implement the BrokerAsset function:

double fixAmount(double Value)
{
  int Exp = log10(Value);
  if (Exp >= 0) Exp++;
  return pow(10,Exp);
}

DLLFUNC int BrokerAsset(char* Symbol,double* pPrice,double* pSpread,
double *pVolume, double *pPip, double *pPipCost, double *pMinAmount,
double *pMargin, double *pRollLong, double *pRollShort, double *pCommission)
{
  sprintf_s(G.Url,"markets/%s/ticker",fixSymbol(Symbol));
  char* Response = send(G.Url,2);
  if(!Response) return 0;
  double Bid = strvar(Response, "bidRate", 0.),
    Ask = strvar(Response,"askRate",0.);
  if (Ask > 0. Bid > 0. && pSpread) 
    *pSpread = Ask - Bid;
  double Last = strvar(Response, "lastTradeRate", 0.);
  if(Ask == 0. || G.PriceType == 2) 
    Ask = Last;
  if (Ask == 0.) return 0; // symbol does not exist
  if(pPrice) *pPrice = Ask;
  if(pVolume) {
    sprintf_s(G.Url,"markets/%s/summary",fixSymbol(Symbol));
    Response = send(G.Url,2);
    if (Response) {
      if (G.VolType == 4)
        *pVolume = strvar(Response, "volume", 0);
    else
        *pVolume = strvar(Response, "quoteVolume", 0);
    }
  }
  if (pMinAmount) { // get lot amount
    sprintf_s(G.Url,"markets/%s",fixSymbol(Symbol));
    Response = send(G.Url,2);
    if (Response) {
      *pMinAmount = fixAmount(strvar(Response,"minTradeSize",0.000001));
      if (pPip) {
        int Exp = strvar(Response,"precision",8);
        *pPip = pow(10,-Exp); 
        while (*pPip * *pMinAmount < 0.000000001)
         *pPip *= 10; // avoid too small pip cost
        if (pPipCost)
          *pPipCost = *pPip * *pMinAmount;
      }
    }
  }
  if (pMargin) 
    *pMargin = -100; // no leverage
  return 1;
} 

This function is supposed to return current price, current ask-bid spread, and current volume. It can also optionally request other asset specific parameters when available from the API. Otherwise Zorro will replace them with parameter values from the asset list. Broker APIs rarely provide all requested parameters. Make sure to only calculate and fill a parameter when its pointer passed to the function is nonzero. Most of the pointers are NULL most of the time.

The send function uses the second buffer because we’ll need price requests internally for calculating the account state. For getting lot amount, pip size, and pip cost, two more API requests are needed. The values from the response string are parsed with Zorro’s strvar function. The fixAmount function converts a value to its next-higher power of 10 – for instance, 7 is converted to 10 and 0.07 to 0.1. We’re doing this because we don’t want a strange number for the lot amount. The pip size is calculated from the precision, but we prevent it from going too small. Bittrex has no leverage, so the margin cost is always 100%.    

The next and final function sends an order to the API:

DLLFUNC int BrokerBuy2(char* Symbol,int Volume,double StopDist,double Limit,double *pPrice,int *pFill)
{
  if(!isConnected() || !Volume) return 0;

// compose the body
  char Body[256] = "{\n";
  strcat_s(Body,"\"marketsymbol\": \"");
  strcat_s(Body,fixSymbol(Symbol));
  strcat_s(Body,"\",\n\"direction\": \"");
  strcat_s(Body,Volume > 0? "BUY" : "SELL");
  strcat_s(Body,"\",\n\"type\": \"");
  strcat_s(Body,Limit > 0. ? "LIMIT" : "MARKET");
  strcat_s(Body,"\",\n\"quantity\": \"");
  double Size = labs(Volume);
  if(G.Amount < 1.) Size *= G.Amount;
  strcat_s(Body,ftoa(Size));
  if (Limit > 0.) {
    strcat_s(Body,"\",\n\"limit\": \"");
    strcat_s(Body,ftoa(Limit));
  }
  strcat_s(Body,"\",\n\"timeInForce\": \"");
  if ((G.OrderType&2) && Limit > 0.) 
    strcat_s(Body,"GOOD_TIL_CANCELLED"); // limit orders only
  else if (G.OrderType&1) 
    strcat_s(Body,"FILL_OR_KILL"); // fill all or nothing
  else 
    strcat_s(Body,"IMMEDIATE_OR_CANCEL");
  strcat_s(Body,"\"\n}");

  char* Response = send("orders",1,0,Body);
  if(!Response) return 0;

  char* Uuid = strtext(Response,"id","");
  if(!*Uuid) return 0; // failed
  strcpy(G.Uuid,Uuid);
  double Filled = strvar(Response,"fillQuantity",0);
  if(Filled == 0. && !(G.OrderType&2))
    return 0; // unfilled FOK/IOC order
  double Price = strvar(Response,"proceeds",0);
  if (Filled > 0. && Price > 0. && pPrice)
    *pPrice = Price/Filled;
  if (*pFill) *pFill = Filled/min(1.,G.Unit);
  return -1; 
}

The function first composes a message body in this JSON format (example):

{
  "marketSymbol": "ETH/BTC",
  "direction": "BUY",
  "type": "LIMIT",
  "quantity": "0.1",
  "limit": "0.008",
  "timeInForce": "IMMEDIATE_OR_CANCEL"
}

If the order is accepted, the response has this JSON format:

{
  "id": "12345-6789-007-4711",
  "marketSymbol": "ETH/BTC",
  "direction": "BUY",
  "type": "LIMIT",
  "quantity": "0.1",
  "limit": "0.008",
  "timeInForce": "IMMEDIATE_OR_CANCEL",
  "fillQuantity": "0.05",
  "commission": "0.000002",
  "proceeds": "0.00001",
  "status": "CLOSED"
}

The relevant fields, especially the id, the fill amount, and the fill price, are parsed from the response and returned. The return value -1 indicates to Zorro that the order generated no identifer number, but an UUID. It was stored and can be retrieved with a subsequent command. G.Unit is the lot amount that was generated with the previous BrokerAsset call. 

The remaining functions not described here – BrokerTrade, BrokerAccount, BrokerHistory2, and BrokerCommand –  are implemented in a similar way. You can find them in the full source code in the Source folder of the latest Zorro version. 

Update, November 2023: Bittrex recently announced that they will terminate their operation. So the Bittrex API plugin described herein lost its purpose, but you can still use the code as a template for connecting Zorro to any other broker or crypto exchange APIs – at least as long as they remain operational.  

The algorithm is plain math, based on three variables: The vaccination percentage of your country, the vaccination percentage among cases, and the 7-day incidence, i.e. the number of cases per week and per 100,000 people.  ‘Case’ can be infection, hospitalization, or death, dependent on what result you want to calculate. Those 3 variables are often available from health organizations in most countries, or can be derived from publicly available statistics. The script calculates the vaccinated and unvaccinated incidences and the average survival time in weeks before a vaccinated or unvaccinated person is infected, hospitalized, or dead. It makes no assumptions about the effectivity of vaccinations.

First, incidence calculation. Let’s assume that your country has a total 7-day incidence of 400, and that 70% of people, and 35% of the infected are vaccinated. The incidence of the vaccinated is then:

I_vac = 400 * 35/70 = 200

The incidence of the unvaccinated:

I_unv = 400 * (100-35)/(100-70) = 867

Thus, in that hypothetical case you’re four times more likely to catch the virus when you’re unvaccinated – despite the relatively high 35% vaccinated infection rate. But what does this mean for your survival time?

The probability P to survive a week without becoming a ‘case’ depends on incidence I:

P = 1-I/100000

The chance to survive N weeks is thus

(1-I/100000)^N

The half life – the time T in weeks until 50% of people are infected – is given by

T = ln(0.5)/ln(P)

When we enter the above figures, first for the vaccinated:

T = ln(0.5)/ln(1-200/100000) = 346 weeks

Then for the unvaccinated:

T = ln(0.5)/ln(1-867/100000) = 80 weeks

Thus, in the given scenario most of the unvaccinated will be either dead or recovered within two years. Of course under the assumption that the incidence does not change during that time. We know that this is not the case: due to the exponential spread, pandemics tend to come and go in waves, as in the above image. Therefore, in the case of COVID, use not the current incidence, but the  average incidence from top to valley of the most recent wave for estimating your average survival time.

The script in C for Zorro:

// Covid Vaxxed vs Unvaxxed survival calculator ///////////////////////////

void click(int Row,int Col)
{
	if(Row != -1) return; // [Result] clicked?
	sound("click.wav");
	printf("\nTotal: Vaxx %.0f%% Unvaxx %.0f%%",
		slider(1),100-slider(1));
	printf("\nCases: Vaxx %.0f%% Unvaxx %.0f%%",
		slider(2),100-slider(2));
	var Vaxx = slider(3)*slider(2)/slider(1);
	var Unvaxx = slider(3)*(100-slider(2))/(100-slider(1));
	printf("\nIncidence: Vaxx %.0f Unvaxx %.0f",
		Vaxx,Unvaxx);
	printf("\nRisk/week: Vaxx %.2f%% Unvaxx %.2f%%",
		Vaxx/1000,Unvaxx/1000);
	printf("\nSurvival/weeks: Vaxx %.0f Unvaxx %.0f",
		log(0.5)/log(1.-Vaxx/100000),
		log(0.5)/log(1.-Unvaxx/100000));
	printf("\n");
}

void main()
{
	slider(1,70,1,99,"Total %","Vaccinated in population");
	slider(2,30,1,99,"Cases %","Vaccinated cases");
	slider(3,1000,1,2000,"Incidence","Weekly cases per 100,000"); 
	while(wait(100)); // keep script alive
}

Start the script and set up the 3 sliders to:

• the total vaccination percentage in the population,
• the vaccination percentage of cases,
• the 7-day per 100,000 case incidence.

Then click on [Result]. The printout should look like this:

Total: Vaxx 70% Unvaxx 30%
Cases: Vaxx 35% Unvaxx 65%
Incidence: Vaxx 200 Unvaxx 867
Risk/week: Vaxx 0.20% Unvaxx 0.87%
Survival/weeks: Vaxx 346 Unvaxx 80

The script can be downloaded from the 2021 repository. Zorro can be downloaded from zorro-project.com. 

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.

The MyRSI indicator sums up positive and negative changes in a data series, and returns their normalized difference. The C version for Zorro:

var MyRSI(vars Data,int Period)
{
 var CU = SumUp(Data,Period+1);
 var CD = -SumDn(Data,Period+1);
 return ifelse(CU+CD != 0,(CU-CD)/(CU+CD),0);
}

For eliminating noise, the function below (NET = Noise Elimination Technology) calculates the Kendall Correlation of a data series with a rising slope. This is supposed to remove all components that are not following the main trend of the indicator output. The code:

var NET(vars Data,int Period)
{
 int i,k;
 var Num = 0;
 for(i=1; i<Period; i++)
   for(k=0; k<i; k++)
     Num -= sign(Data[i]-Data[k]);
 var Denom = .5*Period*(Period-1);
 return Num/Denom;
}

For making the effect of the denoising visible, we produce a SPY chart from 2019-2020. The red line is the original MyRSI, the blue line the de-noised version:

The technology appears to work well in this example for removing the noise. But the NET function is not meant as a replacement of a lowpass or smoothing filter: its output is always in the -1 .. +1 range, so it can be used for de-noising oscillators, but not, for instance, to generate a smoothed version of the price curve.

One might be tempted to use the blue line in the above chart for trade signals. RSI-based signals usually trigger a long trade when the indicator crosses below a lower threshold, and a short trade when it crosses above an upper threshold. But alas, neither is strategy development this easy nor is the de-noised MyRSI the holy grail of indicators. I tested several methods to use it for generating SPY trade signals, but neither was a strong improvement over a simple lowpass filter strategy or even to buy-and-hold. Maybe a reader can find a more convincing solution?

The MyRSI and NET functions and the script for generating the chart can be downloaded from the 2020 script repository. You need Zorro 2.33 or above.

‘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.

For getting the 4-dimensional relative strength we start with two dimensions. The RS2 indicator divides a securities’ price by a market index, then calculates four moving averages of the result and encodes their relations in a number that is then returned. Here’s the RS2 code:

var RS2(var Close, string Index)
{
   assetAdd(strf("IDX%i",NumIndex),strf("YAHOO:%s",Index)); 
   if(!asset(Asset)) return quit("Index not found!");
   var RS2 = Close/priceClose(0);
   var Fast = EMA(series(RS2),10*PERIOD);
   var Med = SMA(series(Fast),7*PERIOD);
   var Slow = SMA(series(Fast),15*PERIOD);
   var VSlow = SMA(series(Slow),30*PERIOD);
   if(Fast >= Med && Med >= Slow && Slow >= VSlow)
      return 10;
   else if(Fast >= Med && Med >= Slow && Slow < VSlow)
      return 9;
   else if(Fast < Med && Med >= Slow && Slow >= VSlow)
      return 9;
   else if(Fast < Med && Med >= Slow && Slow < VSlow)
      return 5;
   else
      return 0;
}

The code above takes the Close of the security and the name of the index for the division. It gets the index price from Yahoo, then determines 4 moving averages as prescribed by the author, and returns either 10, 9, 5, or 0 depending on how fast the price quotient is rising. Note that I had to multiply all MA periods with a predefined PERIOD factor. That’s because I could at first not reproduce the author’s charts, until I found out that his MA periods are apparently not days, but candle width units of his chart. He used 3-day candles for some reason. So I had to multiply all MA periods with a PERIOD of 3. Without this correction, the resulting charts would be very different.

The next step is the RS4, which combines the RS2 values of 11 major market indexes. I used the same Fidelity indexes as the author. The C code of the RS4 indicator:

var RS4(var Close)
{
  var RS3 = RS2(Close,"FXAIX") // SPX 500
    + RS2(Close,"FNCMX") // Nasdaq
    + RS2(Close,"FSMDX") // Mid Cap
    + RS2(Close,"FSSNX") // Small Cap
    + RS2(Close,"FSPGX") // Large Growth
    + RS2(Close,"FLCOX") // Large Val
    + RS2(Close,"FPADX") // Emerging Market
    + RS2(Close,"FSRNX") // Real Estate
    + RS2(Close,"FSAGX") // Gold
    + RS2(Close,"FSUTX") // Utilities
    + RS2(Close,"FTBFX"); // Total Bond
  return 10*RS3/11;
}

The returned value is multiplied with 10 and normalized by the number of indexes. Now we got all 4 dimensions together, the 4th one apparently being the normalization. We can now reproduce the author’s chart with a smoothed RS4 – named “RS4osc” – and a further smoothed signal line. For the security we’re using Fidelity Gold, FSAGX. The code:

voidrun()
{
  BarPeriod = 1440;
  StartDate = 20181201;
  EndDate = 20200415;
  LookBack = 200;
  assetAdd("Gold","YAHOO:FSAGX");
  asset("Gold");
  var RS4Osc = SMA(series(RS4(priceClose(0))),3*PERIOD);
  var Mv = SMA(series(RS4Osc),5*PERIOD);
  plot("RS4Osc",RS4Osc,NEW|LINE,BLUE);
  plot("Mv",Mv,LINE,RED);
}

The resulting chart:

Before you even try: No, the red and blue line crossings in the chart do not indicate profitable trade entries. Not even the author claims that. So what do we do with this indicator? Since it represents strength, let’s try it in a basic portfolio rotation system. Of a universe of 10 major stocks, it shall select the 4 strongest stocks and invest in them according to their strength. The portfolio is rebalanced at any month. First, we use a simple momentum based strength. The code:

void run() 
{
  BarPeriod = 1440;
  LookBack = 200;
  StartDate = 2012;
  EndDate = 2020;
  Capital = 10000;
  var Weights[10],Strengths[10];
  string Stock,Stocks[10];
  assetList("assetsIB");
  while(Stock = loop("AAPL","MSFT","XOM","AMZN","JNJ","FB","GE","TSLA","JPM","PG"))
  {
    if(Init) assetHistory(Stock,FROM_STOOQ);
    asset(Stock);
    Stocks[Itor1] = Stock;
    Strengths[Itor1] = RET(30*PERIOD);
  }
  if(month(0) != month(1)) // at any month
  {
    distribute(Weights,Strengths,10,4,0);
    int i;
    for(i = 0; i<10; i++) {
      asset(Stocks[i]);
      int NewShares = Weights[i]*Balance/priceClose(0) - LotsPool;
      if(NewShares > 0)
        enterLong(NewShares);
      else if(NewShares < 0)
        exitLong("",-NewShares);
    }
  } 
}

I’ve used the 10 top stocks from the S&P 500. The strength is simply defined as the stock return over 30*3 days, which is the same as the “very long” MA period of the RS2. The distribute function in the code is a special Zorro function that sorts the stocks according to their strength, and assigns weights among the 4 strongest stocks. The remaining 6 weaker stocks get weight 0. The weights are then converted to positions and rebalanced at the first workday of any month by buying or selling stocks.

The resulting equity curve (mind the Covid-19 drop):

In the backtest from 2012-2020, this system achieves 47% CAGR, mostly due to the strong volatility at the end. It’s not an optimal system and you would probably not want to trade it live. Now what happens when we replace the 90-day return with the RS4? For this we only need to change the line where the strength is calculated:

Strengths[Itor1] = RS4(priceClose(0));

The equity curve of the RS4-based portfolio rotation system:

The CAGR has dropped to 35%. The Covid-19 drop is not as significant, but the the recovery afterwards isn’t either. Although the equity curve looks less volatile, the Sharpe Ratio is in fact lower, 1.01 compared to 1.11 with the previous return-based system.

Does this mean that the RS4 is inferior to a simple 90-day return? No, because I just tried it with the first and simplest stock rotation system that came in mind. For really judging the RS4, a lot more tests with a lot more systems and with walk forward analysis had to be done.

The RS2 and RS4 indicators, as well as the code for the portfolio rotation system can be downloaded from the 2020 script repository.

The PMO is the EMA of the EMA of the 1-day rate-of-change (ROC) of a stock or index price, multiplied with 10. Since his inventor Swenlin used a nonstandard EMA formula, the two EMA periods, supposed to be 35 and 20, are in fact 34 and 19. I also am not sure why he multiplied the result with 10 – but who am I to doubt? Once an indicator is established, we must stick with its formula, no matter if it resulted from a typo, from not knowing the EMA formula, or from whatever else. 

The PMO code in C:

var PMO(vars Data) { return 10*EMA(EMA(ROC(Data,1),34),19); }

(If you know Zorro indicators and wonder why it’s not EMA(series(EMA(series(ROC(... – both is possible, but since Zorro 2.28 the EMA function also accepts single values instead of series.)

Apirine’s CPMO is no new indicator, but a comparison of two index PMOs in hope of deriving useful information from their divergences or crossing points. The author gave several examples in his magazine article. We’re replicating one of them, the PMOs of the Consumer Discretionary Select Sector (IXY) and the Consumer Staples Select Sector (IXR) compared with the trend of the S&P 500 index (SPX). Below is the code. It retrieves the historical data from Stooq and Yahoo:

function run()
{
  BarPeriod = 1440;
  assetAdd("SPX","STOOQ:^SPX");
  asset("SPX");
  assetAdd("IXY","YAHOO:IXY");
  asset("IXY");
  vars PricesIXY = series(priceClose());
  assetAdd("IXR","YAHOO:IXR");
  asset("IXR");
  vars PricesIXR = series(priceClose());

  plot("IXY",PMO(PricesIXY),NEW|LINE,GREEN);
  plot("IXR",PMO(PricesIXR),LINE,RED);
}

The script produces this chart:

According to the author, the IXR-IXY PMO crossings identify changes in investor sentiment and therefore indicate upcoming SPX trend. Indeed they do in the selected chart, although with some delay and only three out of five times. So it’s hard to judge the CPMO’s usefulness in that context. But as the author says: CPMO […] should be used in conjunction with other indicators like moving averages, chart patterns, or other forms of technical analysis.

Add enough other indicators, and you will succeed. Maybe. For your own experiments, the PMO indicator and script can be downloaded from the 2020 script repository.

Bandpass filters are normally used for detecting cycles in price curves. But they do not work well with steep edges in the curve. Sudden price jumps cause a narrow-band filter to ‘ring like a bell’ and generate artificial cycles that can cause false triggers. As a solution, Ehlers proposed to truncate the candle history of the filter. Limiting the history to 10 bars effectively dampened the filter output and produced a better representation of the cycles in the price curve.

For limiting the history of a cumulative indicator, we’re not using Ehler’s code here, but write a general ‘truncate’ function that works for any indicator:

var indicator(vars Data,int Period,var Param);

var truncate(function Indicator,vars Data,int Period,var Param)
{
 indicator = Indicator;
 var *Trunc = zalloc(UnstablePeriod*sizeof(var));
 var Ret;
 int i;
 for(i = UnstablePeriod-1; i >= 0; i--) {
   SeriesBuffer = Trunc;
   Ret = indicator(Data+i,Period,Param);
   shift(Trunc,0,UnstablePeriod);
 }
 return Ret;
}

This function accesses the internal data series of the cumulative indicator which is passed as the first argument. The SeriesBuffer variable replaces that series with an external array that’s temporarily allocated on the C heap with the zalloc function. UnstablePeriod is a global variable already used by Zorro for limiting the history range of traditional indicators, such as EMA or MACD. The truncate function returns the value of the truncated indicator.

The following code shows how the truncate function is used with our narrow bandpass filter:

function run()
{
 BarPeriod = 1440;
 StartDate = 20181101;
 assetAdd("SPY","STOOQ:SPY.US"); // load price history from Stooq
 asset("SPY");
 UnstablePeriod = 10;
 vars Prices = series(priceClose());
 var PB = BandPass(Prices, 20, 0.1);
 var Trunc = truncate(BandPass, Prices, 20, 0.1);
 plot("Bandpass",BP,NEW|LINE,RED);
 plot("Truncated",Trunc,LINE,BLUE);
}

Applied to SPY:

The chart confirms Ehler’s observation that the truncated narrow bandpass (blue line) represents cycles better than the original bandpass (red line). For comparison I’ve added a medium-wide bandpass filter as it’s normally used in trading systems (green line). This filter doesn’t ‘ring’ either, truncated or not. This makes me wonder: What is the better choice for detecting cycles, a truncated narrow bandpass or simply a non-truncated wide bandpass?

For finding out, we feed the three bandpass variants with a sine chirp and compare their responses. The resulting charts:

The top chart is the chirp, a sine wave with a period rising from 5 to 60 cycles. The charts below show the chirp responses of the original narrow bandpass, the truncated narrow bandpass, and the wide bandpass. And here we can see that truncation produced strange artifacts: the bandpass got a wider bandwidth, some wiggles at the low cycles, and a shifted center frequency. A nontruncated filter with an already wider bandwidth seems here the clearly better solution.

I think you should not truncate a filter to just 10 bars. The ta-lib used by Zorro truncates indicators to 40 bars by default, and affects only classical indicators such as EMA. The advantage of proper truncating is that the indicator output does not depend on the previous history and lookback period of the trading system. A disadvantage is speed: truncating makes indicators much slower because they run in a loop. Not very relevant for normal trading systems, but for HFT systems.

The truncate function and the test scripts can be downloaded from the 2020 script repository. Zorro 2.28 or above is required.

Ehlers published the indicator together with TradeStation code in the recent S&C magazine. Since the C language supports function pointers, we can code it in a shorter and more elegant way:

var correlY(var Phase); // function pointer
var cosFunc(var Phase) { return cos(2*PI*Phase); }
var sinFunc(var Phase) { return -sin(2*PI*Phase); }

var correl(vars Data, int Length, function Func)
{
   correlY = Func; 
   var Sx = 0, Sy = 0, Sxx = 0, Sxy = 0, Syy = 0;
   int count;
   for(count = 0; count < Length; count++) {
      var X = Data[count];
      var Y = correlY((var)count/Length);
      Sx += X; Sy += Y;
      Sxx += X*X; Sxy += X*Y; Syy += Y*Y;
   }
   if(Length*Sxx-Sx*Sx > 0 && Length*Syy-Sy*Sy > 0)
      return (Length*Sxy-Sx*Sy)/sqrt((Length*Sxx-Sx*Sx)*(Length*Syy-Sy*Sy));
   else return 0;
}

var CCY(vars Data, int Length) { return correl(Data,Length,cosFunc); }
var CCYROC(vars Data, int Length) { return correl(Data,Length,sinFunc); }

The correl function measures the correlation of the Data series with an arbitrary curve given by the Func function. This allows us to create all sorts of correlation indicators by just using a different Func. For example, it reduces Ehlers’ Correlation Trend Indicator from the previous article to 2 lines:

var trendFunc(var Phase) { return -Phase; }

var CTI(vars Data,int Length) { return correl(Data,Length,trendFunc); }
 

The empty correlY function pointer in the code above serves as a template for Func, and is used for calling it inside the correl function. For the CTI it’s simply a rising slope (negative because series are in reverse order), for the CCY it’s the standard cosine function.

At first let’s see how the CCY indicator behaves when applied to a sine wave. We’re using Zorro’s wave generator to produce a sine chirp with a rising cycle length from 15 up to 30 bars, which is 25% below and 50% above the used CCY period of 20 bars. The code:

function run()
{
   MaxBars = 300;
   LookBack = 40;
   asset(""); // dummy asset
   ColorUp = ColorDn = 0; // don't plot a price curve
   
   vars Chirp = series(genSine(15,30));
   plot("Chirp",2*Chirp[0]-1,LINE,BLUE);
   plot("CCY",CCY(Chirp,20),LINE,RED);
}
 

And the result:

This confirms Ehlers’ stress test. A shorter period results in a phase lag, a longer period in a phase lead. We’re now going to apply the indicator to real-world price curves. This code displays the CCY and its rate of change (CCYROC) in a SPY chart:

function run()
{
   BarPeriod = 1440;
   LookBack = 40;
   StartDate = 20190101;

   assetAdd("SPY","STOOQ:SPY.US"); // load price history from Stooq
   asset("SPY");

   vars Prices = series(priceClose());
   plot("CCY(14)",CCY(Prices,14),NEW|LINE,RED);
   plot("ROC(14)",CCYROC(Prices,14),LINE,GREEN);
 }

What’s the use of the Correlation Cycle indicator in a trading system? The chart might hint that its peaks or valleys could be used for trade signals, but you can save the time of testing it: I did already. The CCY is no good for trade signals. But Ehlers had another idea. The phase angle of the CCY and CCYROC reflects the market state. It returns 1 for a rising trend, -1 for a falling trend, and 0 for cycle regime. Here’s the code of Ehlers CCY market state indicator:

var CCYState(vars Data,int Length,var Threshold)
{
   vars Angles = series(0,2);
   var Real = correl(Data,Length,cosFunc);
   var Imag = correl(Data,Length,sinFunc);
// compute the angle as an arctangent function and resolve ambiguity
   if(Imag != 0) Angles[0] = 90 + 180/PI*atan(Real/Imag);
   if(Imag > 0) Angles[0] -= 180;
// do not allow the rate change of angle to go negative
   if(Angles[1]-Angles[0] < 270 && Angles[0] < Angles[1])
      Angles[0] = Angles[1];
   //return Angles[0];
// compute market state
   if(abs(Angles[0]-Angles[1]) < Threshold)
      return ifelse(Angles[0] < 0,-1,1);
   else return 0;
}

Applied to SPY:

At first glance, trends and cycles seem to be rather well and timely detected. But how useful is the indicator in a real trading system?

For finding out, we’ll compare the performance with and without market state detection of a simple trend follower, as in the first Zorro workshop. It uses a lowpass filter for detecting trend reversals. The only parameter is the cutoff period of the low pass filter. This parameter is walk forward optimized, so the system does depend on any choosen parameter value. The trend follower without market state detection:

function run() 
{
   set(PARAMETERS);
   BarPeriod = 1440;
   LookBack = 40;
   NumYears = 8;

   assetAdd("SPY","STOOQ:SPY.US"); // load price history from Stooq
   asset("SPY");
   
   NumWFOCycles = 4;
   int Cutoff = optimize(10,5,30,5);

   vars Prices = series(priceClose());
   vars Signals = series(LowPass(Prices,Cutoff));
   if(valley(Signals))
      enterLong();
   else if(peak(Signals))
      enterShort();
}

The system enters a long position on any valley of the lowpass filtered price curve, and a short position on any peak. The resulting equity curve:

We can see that the simple SPY trend follower is not very good. Yes, it’s profitable, but the main profit came from some lucky trades at the corona drop. In the years before the system had long flat periods. Let’s see if the CCYState indicator can help. Its two parameters, period and threshold, are also walk forward optimized. The new script:

function run() 
{
   set(PARAMETERS);
   BarPeriod = 1440;
   LookBack = 40;
   NumYears = 8;

   assetAdd("SPY","STOOQ:SPY.US"); // load price history from Stooq
   asset("SPY");
   
   NumWFOCycles = 4;
   int Cutoff = optimize(10,5,30,5);
   int Period = optimize(14,10,25,1);
   var Threshold = optimize(9,5,15,1);

   vars Prices = series(priceClose());
   var State = CCYState(Prices,Period,Threshold);
   plot("State",State*0.9,NEW|LINE,BLUE);
   vars Signals = series(LowPass(Prices,Cutoff));
   
   if(State != 0) {
      if(valley(Signals))
         enterLong();
      else if(peak(Signals))
         enterShort();
   }
   else {
      exitLong(); 
      exitShort();
   }
}

The new system trades only when the market state is 1 or -1, indicating trend regime. It goes out of the market when the market state is 0. We can see that this improves the equity curve remarkably:

I think most people would prefer this system to the previous one, even though it stayed out of the market at the corona drop. Ehlers’ market state indicator did a good job.

Reference

John Ehlers, Correlation Cycle Indicator, Stocks&Commodities 6/2020

The indicators and trade systems are available in the Scripts 2020 repository.