您喜欢这篇文章？
分享或-
发布链接！

使用MetaTrader 5新的可能性

相似文章

利用 MQL5 实现 Janus 因子

MetaTrader 5 — 示例 | 5 九月 2023, 09:29

503

Francis Dube

概述

每位交易者都知道市场价格遵循两种广义的形态之一。价格要么形成趋势，要么横盘移动。这样的结果就是，市场参与者的策略在很大程度上可以简化为顺势、或在某种程度上逆势。 Janus 因子是一种捕捉这种二元市场行为的理论。在本文中，我们将解密其基础，并演示促进这种分析方法的指标实现。

反馈

根据 Janus 理论，市场是由价格之间的相互作用，以及交易者对价格的反应驱动的。安德森（Anderson）将这种相互作用比作反馈系统。读者可以在维基百科上了解有关反馈系统的更多信息。当市场处于趋势时，市场参与者会因利润奔跑而展现出信心。在上升趋势中，较高的价格证实了参与者对趋势的预期，而这反过来又会吸引更多人买入。这样做具有推高价格的效果。

图例.1 上升趋势中的正反馈。

图例.1 描绘上升趋势中的正反馈。

在下降趋势中，价格下跌会给交易者灌输恐惧，导致他们抛售从而尽量减少损失。更多的抛售给价格带来压力，推动它们走低。因此，市场趋势是反馈最积极的一个例子。价格将继续加速，直到交易者对价格变化做出反应。

图例.2 下跌趋势中的正反馈。

图例.2 描绘下跌趋势中的正反馈。

当交易者对市场缺乏信心时，就会看到负面反馈，因此他们选择在价格走势后提前锁定盈利。过早获利回吐会扼杀限制价格走势幅度的动量。再加上多头和空头之间的不断争斗，效果是价格暂时趋于稳定。

图例.3 负反馈

图例.3 市场的负反馈

资金流

这种反馈概念的一个重要因素是，当不同条件盛行时交易者偏好的品种类型。安德森对股票的分析表明，在上升趋势中，交易者青睐绩效相对更好的股票，同时从表现不佳的股票撤资。在下跌趋势中，表现不佳的股票损失最大，因为交易员看中它们只是为了短线盈利。

在缺乏趋势的情况下，无法区分出很多强势和弱势股票，因为交易者会选择特定的价格水平来入场和离场。考虑到这一点，他假设，通过分析一组股票的相对绩效，可以检测到负反馈和正反馈的时期。

计算 Janus 因子

为了确定绩效，计算定期回报。将所研究的一组股票的回报结合起来，产生一个平均值，当作衡量基准线。称其为基准回报。被评估股票的集合则作为参照指数。

在 Janus Factor - Trend Follower's Guide to Market Dialectics 一书中，安德森阐述了根据回报率计算的各种股票指标，他用它来洞察市场行为。

Janus 函数库 - janus.mqh

所有计算 Janus 相关的通用数据和例程都包含在 janus.mqh 之中。包含文件声明了三种自定义类型：

CSymboldata 类处理品种数据和相关操作。

//+------------------------------------------------------------------+
//|Class which manage the single Symbol                              |
//+------------------------------------------------------------------+
class CSymbolData
  {

private:
   string            m_name;    // name of the symbol
   ENUM_TIMEFRAMES   m_timeframe;// timeframe
   int               m_length;  // length for copy rates
   MqlRates          m_rates[]; // store rates
   datetime          m_first;   // first date on server or local history

   datetime          SetFirstDate(void)
     {
      datetime first_date=-1;
      if((datetime)SymbolInfoInteger(m_name,SYMBOL_TIME)>0)
         first_date=(datetime)SeriesInfoInteger(m_name,m_timeframe,SERIES_FIRSTDATE);
      //---
      if(first_date==WRONG_VALUE || first_date==0)
        {
         if(TerminalInfoInteger(TERMINAL_CONNECTED))
           {
            while(!SeriesInfoInteger(m_name,m_timeframe,SERIES_SERVER_FIRSTDATE,first_date) && !IsStopped())
               Sleep(10);
           }
        }
      //---
#ifdef DEBUG
      Print(m_name," FirstDate ",first_date);
#endif
      return first_date;
     }

public:
                     CSymbolData(string name,ENUM_TIMEFRAMES tf=PERIOD_CURRENT)
     {
      m_name = name;
      m_length = 0;
      m_timeframe = tf;
      SymbolSelect(m_name,true);
     }

                    ~CSymbolData(void)
     {
      ArrayFree(m_rates);
     }
   datetime          GetFirstDate(void)
     {
      m_first = SetFirstDate();
      return m_first;
     }
   string            GetName(void)
     {
      return m_name;
     }

   int               GetLength(void)
     {
      return m_length;
     }

   void              SetLength(const int set_length)
     {
      if(set_length>0)
        {
         m_length=set_length;
         ArrayResize(m_rates,m_length,m_length);
         ArraySetAsSeries(m_rates,true);
        }
     }

   bool              Update(void)
     {
      int copied = CopyRates(m_name,m_timeframe,0,m_length,m_rates);
#ifdef DEBUG
      Print("copied ", copied, " requested ", m_length);
#endif
      //--
      return copied == m_length;
     };

   MqlRates          GetRateAtPos(const int i)
     {
      if(i<0 || i>=m_length)
        {
#ifdef DEBUG
         Print("Array out of range ",i,".Size of array is ",m_length);
#endif
         return (i<0)?m_rates[0]:m_rates[m_length-1];
        }
      return m_rates[i];
     }
  };

CSymbolCollection

代码库ea商城

为了演示 Janus 因子技术，我们将将其应用于外汇对的分析。安德森最初设计的方法是为了分析股票，但大多数经纪商的股票代码数据可用性并不一致。

//+------------------------------------------------------------------+
//| Class that mange the collection of symbols                       |
//+------------------------------------------------------------------+
class CSymbolCollection
  {

private:

   int               m_calculation_length; // global length
   ENUM_TIMEFRAMES   m_collection_timeframe;  // timeframe of data
   string            m_raw_symbols;    // delimited symbol list
   datetime          m_synced_first;  // synced first bar opentime for all symbols
   bool              m_synced;        // flag of whether all symbols are synchronized
   CSymbolData       *m_collection[]; // Collection of Symbol Pointer
   int               m_collection_length; // Collection of Symbol Length
   //+------------------------------------------------------------------+
   //|                                                                  |
   //+------------------------------------------------------------------+
   bool               CheckSymbolBars(const string __sym)
     {
      int bars=-1;
      bars=iBarShift(__sym,m_collection_timeframe,m_synced_first)+1;//SeriesInfoInteger(__sym,PERIOD_CURRENT,SERIES_BARS_COUNT);
#ifdef DEBUG
      Print("Bars found in history for ",__sym," ",bars);
#endif
      if(bars>=m_calculation_length)
         return(true);
      //---
      return(SyncSymbol(__sym));
     }
   //+------------------------------------------------------------------+
   //|                                                                  |
   //+------------------------------------------------------------------+
   bool               SyncSymbol(const string __sym)
     {
      //--- load data step by step
      bool downloaded=false;
      datetime times[1];
      int bars=-1;
      
     /* if(MQLInfoInteger(MQL_PROGRAM_TYPE)==PROGRAM_INDICATOR)
        {
#ifdef DEBUG
         Print(" cannot download ",__sym," history from an indicator");
#endif
         return(downloaded);
        }*/
          
#ifdef DEBUG
      Print(" downloading ",__sym," history");
#endif
      while(!IsStopped() && !downloaded && TerminalInfoInteger(TERMINAL_CONNECTED))
        {
         //---
         while(!SeriesInfoInteger(__sym,m_collection_timeframe,SERIES_SYNCHRONIZED) && !IsStopped())
            Sleep(5);
         //---
         bars=Bars(__sym,PERIOD_CURRENT);
         if(bars>=m_calculation_length)
           {
            downloaded=true;
            break;
           }
         //--- copying of next part forces data loading
         if(CopyTime(__sym,m_collection_timeframe,m_calculation_length-1,1,times)==1)
           {
            downloaded=true;
            break;
           }
         //---
         Sleep(5);
        }
#ifdef DEBUG
      if(downloaded)
         Print(bars," ",__sym," bars downloaded ");
      else
         Print("Downloading ",__sym," bars failed");
#endif
      return(downloaded);
     }

public:

                     CSymbolCollection(const ENUM_TIMEFRAMES tf=PERIOD_CURRENT)
     {
      m_raw_symbols="";
      m_collection_length = 0;
      m_calculation_length = -1;
      m_synced_first=0;
      m_synced=false;
      m_collection_timeframe=tf;
     }

                    ~CSymbolCollection(void)
     {

      for(int i=0; i<m_collection_length; i++)
        {
         if(CheckPointer(m_collection[i])==POINTER_DYNAMIC)
            delete m_collection[i];
        }
     }
   //+------------------------------------------------------------------+
   //|return the set timeframe for bars stored in the collection        |
   //+------------------------------------------------------------------+
   ENUM_TIMEFRAMES   GetTimeFrame(void)
     {
      return(m_collection_timeframe);
     }
   
   //+------------------------------------------------------------------+
   //|Checks the history available and syncs it across all symbols      |
   //+------------------------------------------------------------------+
   bool              CheckHistory(const int size)
     {
      if(size<=0)
         return(false);

      int available=iBarShift(NULL,m_collection_timeframe,m_synced_first)+1;

      if(available<size)
         m_calculation_length=available;
      else
         m_calculation_length=size;

#ifdef DEBUG
      Print("synced first date is ", m_synced_first);
      Print("Proposed size of history ",m_calculation_length);
#endif

      if(m_calculation_length<=0)
         return(false);

      ResetLastError();

      for(int i=0; i<m_collection_length; i++)
        {
         m_synced=CheckSymbolBars(m_collection[i].GetName());
         if(!m_synced)
           {
            Print("Not Enough history data for ", m_collection[i].GetName(), " > ", GetLastError());
            return(m_synced);
           }
         m_collection[i].SetLength(m_calculation_length);
        }

      return m_synced;

     }


   //+------------------------------------------------------------------+
   //| Add a symbol by name to the collection                           |
   //+------------------------------------------------------------------+
   int               Add(string name)
     {
      CSymbolData *ref = new CSymbolData(name,m_collection_timeframe);
      datetime f=ref.GetFirstDate();
      int found=GetIndex(name);
      if(f==WRONG_VALUE || found>-1)
        {
#ifdef DEBUG
         if(f==WRONG_VALUE)
            Print("Failed to retrieve information for symbol ",name,". Symbol removed from collection");
         if(found>-1)
            Print("Symbol ",name,"already part of collection");
#endif
         delete ref;
         return(m_collection_length);
        }
      ArrayResize(m_collection, m_collection_length + 1,1);
      m_collection[m_collection_length] = ref;
      //---
      if(f>m_synced_first)
         m_synced_first=f;
      //---

      return(++m_collection_length);

     }
   //+------------------------------------------------------------------+
   //|Return symbol name                                                |
   //+------------------------------------------------------------------+
   string            GetSymbolNameAtPos(int pos)
     {
      return m_collection[pos].GetName();
     }
   //+------------------------------------------------------------------+
   //|return index of symbol                                            |
   //+------------------------------------------------------------------+
   int               GetIndex(const string symbol_name)
     {
      for(int i=0; i<m_collection_length; i++)
        {
         if(symbol_name==m_collection[i].GetName())
            return(i);
        }
      //---fail
      return(-1);
     }
   //+------------------------------------------------------------------+
   //| Return Collection length                                         |
   //+------------------------------------------------------------------+
   int               GetCollectionLength(void)
     {
      return m_collection_length;
     }

   //+------------------------------------------------------------------+
   //| Update every currency rates                                      |
   //+------------------------------------------------------------------+
   bool              Update(void)
     {

      int i;
      for(i = 0; i < m_collection_length; i++)
        {
         bool res = m_collection[i].Update();
         if(res==false)
           {
            Print("missing data on " + m_collection[i].GetName());
            return false;
           }
        }
      return true;
     }
   //+------------------------------------------------------------------+
   //|                                                                  |
   //+------------------------------------------------------------------+
   int               GetHistoryBarsLength(void)
     {
      return m_calculation_length;
     }
   //+------------------------------------------------------------------+
   //| Return MqlRates of currency at position                          |
   //+------------------------------------------------------------------+
   MqlRates          GetRateAtPos(int pos, int i)
     {
      return m_collection[pos].GetRateAtPos(i);
     }

   //+------------------------------------------------------------------+
   //| Return Open price of currency at position                        |
   //+------------------------------------------------------------------+
   double            GetOpenAtPos(int pos, int i)
     {
      return m_collection[pos].GetRateAtPos(i).open;
     }

   //+------------------------------------------------------------------+
   //| Return Close price of currency at position                       |
   //+------------------------------------------------------------------+
   double            GetCloseAtPos(int pos, int i)
     {
      return m_collection[pos].GetRateAtPos(i).close;
     }

   //+------------------------------------------------------------------+
   //| Return High price of currency at position                        |
   //+------------------------------------------------------------------+
   double            GetHighAtPos(int pos, int i)
     {
      return m_collection[pos].GetRateAtPos(i).high;
     }

   //+------------------------------------------------------------------+
   //| Return Low price of currency at position                         |
   //+------------------------------------------------------------------+
   double            GetLowAtPos(int pos, int i)
     {
      return m_collection[pos].GetRateAtPos(i).low;
     }

   //+------------------------------------------------------------------+
   //| Return Median price of currency at position                      |
   //+------------------------------------------------------------------+
   double            GetMedianAtPos(int pos, int i)
     {
      return (GetHighAtPos(pos,i) + GetLowAtPos(pos, i))/2;
     }

   //+------------------------------------------------------------------+
   //| Return Typical price of currency at position                     |
   //+------------------------------------------------------------------+
   double            GetTypicalAtPos(int pos, int i)
     {
      return (GetHighAtPos(pos,i) + GetLowAtPos(pos, i) + GetCloseAtPos(pos,i))/3;
     }

   //+------------------------------------------------------------------+
   //| Return Weighted price of currency at position                    |
   //+------------------------------------------------------------------+
   double            GetWeightedAtPos(int pos, int i)
     {
      return (GetHighAtPos(pos,i) + GetLowAtPos(pos, i) + GetCloseAtPos(pos,i) * 2)/4;
     }
  };
//+------------------------------------------------------------------+

代码按下面定档的三个自定义枚举开头。

#include<Math\Stat\Math.mqh>
#include <Arrays\ArrayObj.mqh>
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ENUM_INDEX_TYPE
  {
   INDEX_FOREX_MAJORS=0,//forex majors only list
   INDEX_CUSTOM,//custom symbol list
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ENUM_PRICE
  {
   CLOSE=0,//close price
   MEDIAN,//median price
   TYPICAL,//typical price
   WEIGHTED//weighted price
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ENUM_DIFF_TYPE
  {
   DIFF_PERCENT=0,//percent difference
   DIFF_LOG//log difference
  };

枚举	说明	选项
ENUM_INDEX_TYPE	代表所分析集合中包含的品种类型	INDEX_FOREX - 此选项构建了由所有外汇主要货币组成的品种集合。一组 28 个品种。 INDEX_CUSTOM - 带此选项时，品种集合需要指定。
ENUM_PRICE	允许选择计算中所用的价格序列。应该注意的是，价格信息以序列形式存储，最新价格位于索引 0。	CLOSE - 收盘价 MEDIAN - 中间价 - high+low/2 TYPICAL - 典型价 - high+low+close/3 WEIGHTED - 加权价 high+low+close+close/4
ENUM_DIFF_TYPE	这代表可应用于所选价格序列的不同差异方法。	DIFF_LOG - 此处记录所用的差值 DIFF_PERCENT - 此选项意即使用百分比差值

为了使用 CJanus 类，必须明白这 5 种方法。在创建 CJanus 对象之后，且在调用任何方法之前，应首先调用 Initialize 成员函数。该方法执行两个重要操作，首先它初始化 CSymbolCollection 对象，并取选定品种填充它，以备构成我们的索引。然后，它会检查并同步集合中品种的历史记录柱线。

//+------------------------------------------------------------------+
//|Janus class for calculating janus family of indicators.           |
//+------------------------------------------------------------------+
class CJanus
  {
private:
   CSymbolCollection* m_symbol_list;    //object container of symbols
   ENUM_PRICE         m_price_type;     //applied price for calculations
   ENUM_DIFF_TYPE     m_diff_type;      //method of differencing applied
   ENUM_INDEX_TYPE    m_index_type;     //type of index
   int                m_hist_size;      // synchronized size of history across all selected symbols in collection
   ENUM_TIMEFRAMES    m_list_timeframe; //timeframe for bars to be used in calculations
   //---private methods
   double            market_return(const uint barshift, const uint symbolshift);
   void              market_offense_defense(const uint barshift,const uint symbolshift,const uint rs_period,double& out_offense,double& out_defense);
   double            rs(const uint barshift,const uint symbolshift,const uint rs_period,uint lag=0);
   double            rs_off_def(const uint barshift, const uint symbolshift,const uint lag,const double median,const double index_offense, const double index_defense, double &array[]);
   //---
public:
   //constructor
                     CJanus(void):m_symbol_list(NULL),
                     m_price_type(WRONG_VALUE),
                     m_diff_type(WRONG_VALUE),
                     m_index_type(WRONG_VALUE),
                     m_list_timeframe(WRONG_VALUE),
                     m_hist_size(0)
     {

     }
   // destructor
                    ~CJanus(void)
     {
      if(CheckPointer(m_symbol_list)==POINTER_DYNAMIC)
         delete m_symbol_list;
     }
   //public methods
   bool              Initialize(const ENUM_PRICE set_price_type, const ENUM_DIFF_TYPE set_diff_type, const ENUM_INDEX_TYPE set_index_type, ENUM_TIMEFRAMES set_timeframe,const int history_size, const string symbol_list);
   bool              Update(void);
   int               HistorySize(void);
   string            GetSymbolAt(const int sym_ind);
   int               GetSymbolsTotal(void);
   double            CalculateReturn(const uint barshift, const string symbol__);
   double            CalculateBenchMarkReturn(const uint barshift);
   double            CalculateSummedIndexReturn(const uint barshift);
   void              CalculateBenchMarkOffenseDefense(const uint barshift,const uint rs_period,double& out_offense,double& out_defense);
   void              CalculateMarketOffenseDefense(const uint barshift,const string symbol__,const uint rs_period,double& out_offense,double& out_defense);
   double            CalculateRelativeStrength(const uint barshift,const string symbol__,const uint rs_period,uint lag=0);
   void              CalculateRelativeStrengthLeaderLaggard(const uint barshift,const uint rs_period,const double rs_percent_top,double& leader,double& laggard);
   double            CalculateRelativeStrengthSpread(const uint barshift,const uint rs_period,const double rs_percent_top);
   double            CalculateRelativeStrengthSpreadChange(const uint barshift,const uint rs_period,const double rs_percent_top);

  };

下表解释了 Initialize() 方法的输入参数。

参数	说明	数据类型
set_price_type	设置所有计算要用到的基础价格序列的枚举	ENUM_PRICE
set_diff_type	设置应用于价格序列的差值方法	ENUM_DIFF_TYPE
set_index_type	仅设置自定义或外汇直盘品种集合的类型，如果选择自定义，则必须在 symbol_list 参数中指定品种	ENUM_INDEX_TYPE
set_timeframe	指定在计所用的柱线时间帧	ENUM_TIMEFRAME
history_size	定义应请求的最大柱线数量。由于我们正在处理多个品种，因此这是一种确保集合中的所有品种都拥有相同的可用历史柱线数据数量的方法。	integer
symbol_list	当 set_index_type 设置为 INDEX_CUSTOM 时，用户必须指定一个逗号分隔的品种列表，该列表将构成要分析的品种集合	string

其它值得注意的方法有：

Update() 方法刷新品种数据，从而检索最新报价。

HistorySize() 方法返回可用的历史柱线的数量。请注意，此数字可以小于调用 Initialize 方法时指定的数字。这是因为所有品种的历史记录可能会有所不同，因此该函数返回同步后的历史大小。

GetSymbolsTotals() 返回已添加并确认在终端中可用的品种数量。
GetSymbolAt() 按索引获取品种名称。

其余方法均以 Calculate 为前缀，执行计算并返回一个或两个数值。它们的第一个输入参数 barshift 是执行计算的柱线偏移值。
每种方法都将在实现各种指标时加以解释。

衡量绩效

如前所述，绩效是通过计算回报来衡量的。对于我们的实现，我们可以选择应用的价格和计算回报的方法。调用 CalculateReturns() 方法计算给定偏移值柱线和品种的回报。

//+------------------------------------------------------------------+
//|private method that calculates the returns                        |
//+------------------------------------------------------------------+
double CJanus::market_return(const uint barshift, const uint symbolshift)
  {
   double curr,prev;
   curr=0;
   prev=1.e-60;

   switch(m_price_type)
     {
      case CLOSE:
         curr=m_symbol_list.GetCloseAtPos(symbolshift,barshift);
         prev=m_symbol_list.GetCloseAtPos(symbolshift,barshift+1);
         break;
      case MEDIAN:
         curr=m_symbol_list.GetMedianAtPos(symbolshift,barshift);
         prev=m_symbol_list.GetMedianAtPos(symbolshift,barshift+1);
         break;
      case TYPICAL:
         curr=m_symbol_list.GetTypicalAtPos(symbolshift,barshift);
         prev=m_symbol_list.GetTypicalAtPos(symbolshift,barshift+1);
         break;
      case WEIGHTED:
         curr=m_symbol_list.GetWeightedAtPos(symbolshift,barshift);
         prev=m_symbol_list.GetWeightedAtPos(symbolshift,barshift+1);
         break;
      default:
         return WRONG_VALUE;
     }

   if(prev==0)
      return(WRONG_VALUE);

   switch(m_diff_type)
     {
      case DIFF_PERCENT:
         return(((curr-prev)/prev)*100);
      case DIFF_LOG:
         return(MathLog(curr/prev));
      default:
         return(WRONG_VALUE);
     }
  }
//+------------------------------------------------------------------+
//|public method to calculate returns for single bar                 |
//+------------------------------------------------------------------+
double CJanus::CalculateReturn(const uint barshift, const string symbol_)
  {
   int sshift=m_symbol_list.GetIndex(symbol_);
   if(sshift>-1)
      return(market_return(barshift,sshift));
   else
      return(WRONG_VALUE);
  }

下面的 IndexReturns 指标代码显示图表品种的回报以及基准回报。

//+------------------------------------------------------------------+
//|                                                 IndexReturns.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   2
//--- plot IndexReturns
#property indicator_label1  "IndexReturns"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Returns
#property indicator_label2  "Returns"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrBlue
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
#include<Janus.mqh>
//inputs
input ENUM_PRICE AppliedPrice=CLOSE;
input ENUM_DIFF_TYPE AppliedDiffType=DIFF_LOG;
input ENUM_INDEX_TYPE SelectIndexType=INDEX_FOREX_MAJORS;
input string BenchMarkSymbols="";
input int MaxBars = 300;
//--- indicator buffers
double         IndexReturnsBuffer[];
double         ReturnsBuffer[];
CJanus *janus;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,IndexReturnsBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,ReturnsBuffer,INDICATOR_DATA);
  
   ArraySetAsSeries(IndexReturnsBuffer,true);
   ArraySetAsSeries(ReturnsBuffer,true);  
//--- 
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetString(1,PLOT_LABEL,_Symbol+" Returns");
//---
   IndicatorSetInteger(INDICATOR_DIGITS,8);
   IndicatorSetString(INDICATOR_SHORTNAME,"IndexReturns("+_Symbol+")");
//---
   janus=new CJanus();   
//--- 
   if(!janus.Initialize(AppliedPrice,AppliedDiffType,SelectIndexType,PERIOD_CURRENT,MaxBars,BenchMarkSymbols))
     return(INIT_FAILED);     
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//|Custom indicator deinitialization function                        |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
 {
//--- 
  switch(reason)
   {
    case REASON_INITFAILED:
      ChartIndicatorDelete(ChartID(),ChartWindowFind(),"IndexReturns("+_Symbol+")");
       break;
    default:
       break;
   } 
//---
   if(CheckPointer(janus)==POINTER_DYNAMIC)
      delete janus;       
 }   
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int limit;
   if(prev_calculated<=0)
     {
      limit=janus.HistorySize()-2;
      PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rates_total-limit+1);
      PlotIndexSetInteger(1,PLOT_DRAW_BEGIN,rates_total-limit+1);
     } 
   else 
     limit=rates_total-prev_calculated;
   //---  
   if(!janus.Update())
     return(prev_calculated); 
     
   for(int bar=limit;bar>=1;bar--)
    {
     ReturnsBuffer[bar]=janus.CalculateReturn(bar,_Symbol);
     IndexReturnsBuffer[bar]=janus.CalculateBenchMarkReturn(bar);
    }    
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

IndexReturns 指标

基准

为了计算基准回报，我们取每个相应时间点的品种的单独回报来得到中间值。此计算由 CalculateBenchmarkReturns() 方法实现。

//+------------------------------------------------------------------+
//|public method to calculate index returns                          |
//+------------------------------------------------------------------+
double CJanus::CalculateBenchMarkReturn(const uint barshift)
  {
   double sorted[];
   int size=m_symbol_list.GetCollectionLength();

   if(size<=0)
      return(WRONG_VALUE);

   ArrayResize(sorted,size);

   for(int i=0; i<size; i++)
     {
      sorted[i]=market_return(barshift,i);
     }

   if(!ArraySort(sorted))
     {
      Print("sorting error ",__LINE__," ",__FUNCTION__);
      return(0);
     }

   return(MathMedian(sorted));
  }

进攻和防守

为了更好地理解相对绩效，安德森提出了一个品种的进攻和防守得分的概念。进攻得分是基准回报高于平均水平时达到的绩效。

防御性分数的计算方式类似，使用基准回报率低于平均水平时达到的回报。该值示意当市场价格波动时，品种的持有优劣。

为了计算这些数值，基准回报分为两个：进攻和防守基准回报。这些是通过选择合适的窗口长度来计算平均基准的。

在 CJanus 类中，中间值用作覆盖指定窗口的平均值。进攻基准回报是通过累积大于或等于平均回报的基准回报率之间的差额得出的。

防御基准回报的计算方式类似，取小于窗口平均值的基准值。

//+------------------------------------------------------------------+
//|public method to calculate Index offense and defense scores       |
//+------------------------------------------------------------------+
void CJanus::CalculateBenchMarkOffenseDefense(const uint barshift,const uint rs_period,double& out_offense,double& out_defense)
  {
   out_defense=out_offense=WRONG_VALUE;

   double index[],sorted[],median,i_offense,i_defense;
   median=i_offense=i_defense=0;

   ArrayResize(index,rs_period);
   ArrayResize(sorted,rs_period);

   int begin=0;

   for(int i=0; i<(int)rs_period; i++)
     {
      index[i]=CalculateBenchMarkReturn(barshift+i);
      if(i>=begin)
         sorted[i-begin]=index[i];
     }

   if(!ArraySort(sorted))
     {
      Print("sorting error ",__LINE__," ",__FUNCTION__);
      return;
     }

   median=MathMedian(sorted);

   i_offense=1.e-30;
   i_defense=-1.e-30;

   for(int i=begin; i<(int)rs_period; i++)
     {
      if(index[i]>=median)
         i_offense+=index[i]-median;
      else
         i_defense+=index[i]-median;
     }

   if(i_offense<0 || i_defense>0)
     {
#ifdef DEBUG
      Print("error invalid figures ","Offensive ",i_offense," Defensive ",i_defense);
#endif
      return;
     }

   out_offense=i_offense;
   out_defense=i_defense;

   return;
  }

一旦计算出进攻和防御基准回报。它们用于计算品种的进攻和防御得分。对应基准的同一窗口内，基准回报大于或等于窗口平均值的每个时间点，将实现的回报相加。然后将此总和表示为相应进攻基准的分数并乘以 100。

防御基准回报的计算与此类似。 CalculateSymbolOffenseDefense() 方法实现了进攻和防御得分的计算。

//+------------------------------------------------------------------+
//|public method to calculate market offense and defense                                                                  |
//+------------------------------------------------------------------+
void CJanus::CalculateSymbolOffenseDefense(const uint barshift,const string symbol__,const uint rs_period,double &out_offense,double &out_defense)
  {
   out_defense=out_offense=0.0;
   int sshift=m_symbol_list.GetIndex(symbol__);
   if(sshift>-1)
      market_offense_defense(barshift,sshift,rs_period,out_offense,out_defense);
   else
      return;
  }

//+------------------------------------------------------------------+
//|private method that calculates market defense and offense values  |
//+------------------------------------------------------------------+
void CJanus::market_offense_defense(const uint barshift,const uint symbolshift,const uint rs_period,double& out_offense,double& out_defense)
  {
   out_defense=out_offense=0.0;

   double index[],sorted[],median,i_offense,i_defense;
   median=i_offense=i_defense=0;

   ArrayResize(index,rs_period);
   ArrayResize(sorted,rs_period);

   int begin=0;

   for(int i=0; i<(int)rs_period; i++)
     {
      index[i]=CalculateBenchMarkReturn(barshift+i);
      if(i>=begin)
         sorted[i-begin]=index[i];
     }

   if(!ArraySort(sorted))
     {
      Print("sorting error ",__LINE__," ",__FUNCTION__);
      return;
     }

   median=MathMedian(sorted);

   i_offense=1.e-30;
   i_defense=-1.e-30;

   for(int i=begin; i<(int)rs_period; i++)
     {
      if(index[i]>=median)
         i_offense+=index[i]-median;
      else
         i_defense+=index[i]-median;
     }

   if(i_offense<0 || i_defense>0)
     {
#ifdef DEBUG
      Print("error invalid figures ","Offensive ",i_offense," Defensive ",i_defense);
#endif
      return;
     }

   double m_offense,m_defense;
   m_offense=m_defense=0;

   for(int i=0; i<(int)rs_period; i++)
     {
      if(index[i]>=median)
         m_offense+=market_return(barshift+i,symbolshift);
      else
         m_defense+=market_return(barshift+i,symbolshift);
     }

   out_defense= (m_defense/i_defense) * 100;
   out_offense= (m_offense/i_offense) * 100;

  }

通过绘制进攻和防御得分，安德森注意到根据当前市场条件会出现的形态。在正反馈期间，得分发散很广，绩效最好和最差的品种之间存在显著差异。相反，绩效最佳和最差之间的差值收窄时，就是负面反馈时期。安德森将此称为指数的扩张和收缩。

下面的代码描述了进攻防御散点图脚本，它具有与上述指标类似的输入，并将进攻和防御得分绘制为动画图。

//+------------------------------------------------------------------+
//|                                OffensiveDefensiveScatterPlot.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property script_show_inputs
#include <Graphics\Graphic.mqh>
#include<Janus.mqh>

input ENUM_PRICE AppliedPrice=CLOSE;
input ENUM_DIFF_TYPE AppliedDiffType=DIFF_LOG;
input ENUM_INDEX_TYPE SelectIndexType=INDEX_FOREX_MAJORS;
input uint AppliedPeriod = 25;
input string BenchMarkSymbols="";
input int MaxBars = 50;

CJanus janus;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   if(!janus.Initialize(AppliedPrice,AppliedDiffType,SelectIndexType,PERIOD_CURRENT,MaxBars,BenchMarkSymbols))
     {
      Print("error with janus object");
      return;
     }
//---
   janus.Update();
//---
   double y[];
   double x[];

   int size=janus.GetSymbolsTotal();

   ArrayResize(x,size);
   ArrayResize(y,size);

   long chart=0;
   string name="OffenseDefense";

   for(int k=MaxBars-(int)AppliedPeriod-1; k>=0; k--)
     {
      for(int i=0; i<size; i++)
        {
         string ssy=janus.GetSymbolAt(i);
         janus.CalculateSymbolOffenseDefense(k,ssy,AppliedPeriod,y[i],x[i]);
        }

      CGraphic graphic;
      if(ObjectFind(chart,name)<0)
         graphic.Create(chart,name,0,0,0,780,380);
      else
         graphic.Attach(chart,name);
      //---
      graphic.CurveAdd(x,y,ColorToARGB(clrBlue),CURVE_POINTS,"DefensiveOffensive ");
      //---
      graphic.CurvePlotAll();
      //---
      graphic.Update();
      Sleep(1*1000);
      graphic.Destroy();
      ChartRedraw();

     }

   ChartSetInteger(0,CHART_SHOW,true);

  }
//+------------------------------------------------------------------+

该脚本生成下图

进攻/防御散点图

相对强度

当使用下面的公式链接品种的进攻和防御得分时，我们得到品种的相对强度。

相对强度公式

在安德森所著书中有这个公式的推导记录。相对强度由 CalculateRelativeStrength() 方法计算。

//+------------------------------------------------------------------+
//|public method to calculate relative strength                      |
//+------------------------------------------------------------------+
double CJanus::CalculateRelativeStrength(const uint barshift,const string symbol__,const uint rs_period,uint lag=0)
  {
   int sshift=m_symbol_list.GetIndex(symbol__);
   if(sshift>-1)
      return(rs(barshift,sshift,rs_period,lag));
   else
      return(WRONG_VALUE);
  }

//+------------------------------------------------------------------+
//|private method that calculates the relative strength              |
//+------------------------------------------------------------------+
double CJanus::rs(const uint barshift,const uint symbolshift,const uint rs_period,uint lag=0)
  {
   if(lag>=rs_period)
      return(WRONG_VALUE);

   double index[],sorted[],median,i_offense,i_defense;
   median=i_offense=i_defense=0;

   ArrayResize(index,rs_period);
   ArrayResize(sorted,rs_period);

   int begin=(int)lag;

   for(int i=0; i<(int)rs_period; i++)
     {
      index[i]=CalculateBenchMarkReturn(barshift+i);
      if(i>=begin)
         sorted[i-begin]=index[i];
     }

   if(!ArraySort(sorted))
     {
      Print("sorting error ",__LINE__," ",__FUNCTION__);
      return(EMPTY_VALUE);
     }

   median=MathMedian(sorted);

   i_offense=1.e-30;
   i_defense=-1.e-30;

   for(int i=begin; i<(int)rs_period; i++)
     {
      if(index[i]>=median)
         i_offense+=index[i]-median;
      else
         i_defense+=index[i]-median;
     }

   if(i_offense<0 || i_defense>0)
     {
#ifdef DEBUG
      Print("error invalid figures ","Offensive ",i_offense," Defensive ",i_defense);
#endif
      return(WRONG_VALUE);
     }

   return(rs_off_def(barshift,symbolshift,lag,median,i_offense,i_defense,index));
  }

下面的指标代码绘制图表品种的相对强度

//+------------------------------------------------------------------+
//|                                             RelativeStrength.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_plots   1
//--- plot RelativeStrength
#property indicator_label1  "RelativeStrength"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
#include<Janus.mqh>
//inputs
input ENUM_PRICE AppliedPrice=CLOSE;
input ENUM_DIFF_TYPE AppliedDiffType=DIFF_LOG;
input ENUM_INDEX_TYPE SelectIndexType=INDEX_FOREX_MAJORS;
input uint AppliedPeriod = 7;
input string BenchMarkSymbols="";
input int MaxBars = 300;
//--- indicator buffers
double         RelativeStrengthBuffer[];
//---
CJanus *janus;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,RelativeStrengthBuffer,INDICATOR_DATA);
//---    
   ArraySetAsSeries(RelativeStrengthBuffer,true);
//---   
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   IndicatorSetString(INDICATOR_SHORTNAME,"RS("+_Symbol+")("+string(AppliedPeriod)+")");
//---
   janus=new CJanus();   
//--- 
   if(!janus.Initialize(AppliedPrice,AppliedDiffType,SelectIndexType,PERIOD_CURRENT,MaxBars,BenchMarkSymbols))
     return(INIT_FAILED);     
//---
   
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//|Custom indicator deinitialization function                        |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
 {
//--- 
  switch(reason)
   {
    case REASON_INITFAILED:
      ChartIndicatorDelete(ChartID(),ChartWindowFind(),"RS("+_Symbol+")("+string(AppliedPeriod)+")");
       break;
    default:
       break;
   } 
//---
   if(CheckPointer(janus)==POINTER_DYNAMIC)
      delete janus;       
 }     
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],p
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int limit;
   if(prev_calculated<=0)
     {
      limit=janus.HistorySize()-int(AppliedPeriod+2);
      PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rates_total-limit+1);
     } 
   else 
     limit=rates_total-prev_calculated;
   //---  
   if(!janus.Update())
     return(prev_calculated); 
     
   for(int i=limit;i>=1;i--)
    {
     RelativeStrengthBuffer[i]=janus.CalculateRelativeStrength(i,_Symbol,AppliedPeriod);
    } 
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

相对强弱指标

使用相对强度值，我们可以更清楚地了解随时间推移而发生的扩张和收缩。下图显示由最高和最低相对强弱值的指标。

上行和下行 RS

该指标的代码如下所示。

//+------------------------------------------------------------------+
//|                                    RelativeStrenghtBestWorst.mq5 |
//|                        Copyright 2023, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   2
//--- plot Upper
#property indicator_label1  "Upper"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Lower
#property indicator_label2  "Lower"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrRed
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
#include<Janus.mqh>
//inputs
input ENUM_PRICE AppliedPrice=CLOSE;
input ENUM_DIFF_TYPE AppliedDiffType=DIFF_LOG;
input ENUM_INDEX_TYPE SelectIndexType=INDEX_FOREX_MAJORS;
input uint AppliedPeriod = 25;
input string BenchMarkSymbols="";
input int MaxBars = 300;
//--- indicator buffers
double         UpperBuffer[];
double         LowerBuffer[];
double rsv[];

CJanus *janus;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,UpperBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,LowerBuffer,INDICATOR_DATA);
//---   
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
//--- 
   ArraySetAsSeries(UpperBuffer,true);
   ArraySetAsSeries(LowerBuffer,true);
//---    
   IndicatorSetString(INDICATOR_SHORTNAME,"RS_Upperlower("+_Symbol+")("+string(AppliedPeriod)+")");
//---   
   janus=new CJanus();   
//--- 
   if(!janus.Initialize(AppliedPrice,AppliedDiffType,SelectIndexType,PERIOD_CURRENT,MaxBars,BenchMarkSymbols))
     return(INIT_FAILED);  
     
   ArrayResize(rsv,janus.GetSymbolsTotal());     
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//|Custom indicator deinitialization function                        |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
 {
//--- 
  switch(reason)
   {
    case REASON_INITFAILED:
      ChartIndicatorDelete(ChartID(),ChartWindowFind(),"RS_Upperlower("+_Symbol+")("+string(AppliedPeriod)+")");
       break;
    default:
       break;
   } 
//---
   if(CheckPointer(janus)==POINTER_DYNAMIC)
      delete janus;       
 }       
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int limit;
   if(prev_calculated<=0)
     {
      limit=janus.HistorySize()-int(AppliedPeriod+2);
      PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rates_total-limit+1);
     } 
   else 
     limit=rates_total-prev_calculated;
   //---  
   if(!janus.Update())
     return(prev_calculated); 
     
   for(int i=limit;i>=1;i--)
    {
      for(int k=0;k<ArraySize(rsv);k++)
        {
         string sym=janus.GetSymbolAt(k);
         rsv[k]= janus.CalculateRelativeStrength(i,sym,AppliedPeriod);
        }
        
      ArraySort(rsv);
      
     UpperBuffer[i]=rsv[ArraySize(rsv)-1];
     LowerBuffer[i]=rsv[0];    
    } 
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

相对强度领先者和落后者

当依据绩效最好和最差的回报得出的相对绩效处于平均时，我们分别得到相对强度领先者和落后者。这些值根据反馈状态指示最佳交易时间。相对强度（rs）领先者和落后者是通过指定绩效最好和最差的数量来计算平均值。

//+------------------------------------------------------------------+
//|public method to calculate relative strength leaders and laggards |
//+------------------------------------------------------------------+
void CJanus::CalculateRelativeStrengthLeaderLaggard(const uint barshift,const uint rs_period,const double rs_percent_top,double& leader,double& laggard)
  {
   leader=laggard=0;
   
   uint lag=rs_period;

   double sorted[];
   int iwork[],k,n,isub;
   k=isub=-1;

   int size=m_symbol_list.GetCollectionLength();

   ArrayResize(sorted,size);
   ArrayResize(iwork,size);

   for(int i=0; i<size; i++)
     {
      sorted[i]=rs(barshift,uint(i),rs_period,lag);
      iwork[i]=i;
     }

   MathQuickSortAscending(sorted,iwork,0,size-1);

   k=(int)(rs_percent_top*(size+1))-1;
   if(k<0)
      k=0;
   n=k+1;

   while(k>=0)
     {
      isub=iwork[k];
      for(uint i=0; i<lag; i++)
        {
         laggard+=market_return(barshift+i,isub);
        }
      isub=iwork[size-1-k];
      for(uint i=0; i<lag; i++)
        {
         leader+=market_return(barshift+i,isub);
        }
      --k;
     }
   leader/=n*lag;
   laggard/=n*lag;

   return;
  }

CalculateRelativeStrengthLeadersLaggards() 方法的 rs_percent_top 输入表示计算平均相对强度的品种分数。例如，将 rs_percent_top 设置为 0.1 意味着顶部和底部 10% 的品种将用于计算领先者和落后者。

下面是领导者和落后者指标的屏幕截图

领导者和落后者

价差

当市场被正反馈所笼罩时，最弱和最强的证券会根据趋势的方向而分道扬镳。在上升趋势中，交易者青睐较强的证券，而在下降趋势中，较弱的证券会被做空。

如果价格滞留在一个范围内，则最弱和最强的证券之间的差值相对较小，存在收敛。为了辨别这些发展，我们计算最弱和最强证券之间相对强度的平均差值。这就是相对强度价差衡量的。

相对强度价差在 CalculateRelativeStrengthSpread() 方法中实现。

//+------------------------------------------------------------------+
//|public method to calculate the relative strength spread.          |
//+------------------------------------------------------------------+
double CJanus::CalculateRelativeStrengthSpread(const uint barshift,const uint rs_period,const double rs_percent_top)
  {
   double sorted[],width,div;
   int k=0;
   int size=m_symbol_list.GetCollectionLength();

   width=div=0;
   ArrayResize(sorted,size);

   for(int i=0; i<size; i++)
     {
      sorted[i]=rs(barshift,uint(i),rs_period);
     }

   if(!ArraySort(sorted))
     {
      Print("sorting error ",__LINE__," ",__FUNCTION__);
      return(WRONG_VALUE);
     }

   k=(int)(rs_percent_top*(size+1))-1;

   if(k<0)
      k=0;
   double n=double(k+1);

   while(k>=0)
     {
      width+=sorted[size-1-k]-sorted[k];
      --k;
     }

   return(width/=n);
  }

相对强弱价差指标

价差和 rs 领先者/落后者指标的组合可用于制定有形的交易规则。根据安德森的说法，最佳机会来自接近或处于所研究指数相对强度上限和下限的品种。

//+------------------------------------------------------------------+
//|public method to calculate relative strength leaders and laggards |
//+------------------------------------------------------------------+
void CJanus::CalculateRelativeStrengthLeaderLaggard(const uint barshift,const uint rs_period,const double rs_percent_top,double& leader,double& laggard)
  {
   leader=laggard=0;
   
   uint lag=1;

   double sorted[];
   int iwork[],k,n,isub;
   k=isub=-1;

   int size=m_symbol_list.GetCollectionLength();

   ArrayResize(sorted,size);
   ArrayResize(iwork,size);

   for(int i=0; i<size; i++)
     {
      sorted[i]=rs(barshift,uint(i),rs_period,lag);
      iwork[i]=i;
     }

   MathQuickSortAscending(sorted,iwork,0,size-1);

   k=(int)(rs_percent_top*(size+1))-1;
   if(k<0)
      k=0;
   n=k+1;

   while(k>=0)
     {
      isub=iwork[k];
      for(uint i=0; i<lag; i++)
        {
         laggard+=market_return(barshift+i,isub);
        }
      isub=iwork[size-1-k];
      for(uint i=0; i<lag; i++)
        {
         leader+=market_return(barshift+i,isub);
        }
      --k;
     }
   leader/=n*lag;
   laggard/=n*lag;

   return;
  }

当价差趋势与 rs 领先者一起上升时，这表明正反馈以及强劲绩效的净买入。显示买入最高相对强度的品种的好时机。如果 rs 落后者正在上涨，则瞄准较弱的品种做空。在任何这些情形下，谨慎的做法是将这些规则与有效的入场方法相结合，并该方法应用于所选品种。

另一种选择是使用价差指标作为风险过滤器。当出现正反馈时，市场风险较小，负面反馈是可能出现波动状况的指标。一个可能远离市场的时间。

结束语

尽管外汇品种的分析可能不是 Janus 因子的最佳应用，但本文的重点在于让读者熟悉该方法。有关它的更多信息可以在下面参考的安德森的书中找到。

随附的 zip 文件包含本文中引用工具的所有代码。下表列出了每一个。

为了指标正常工作，用户应首先确保构成索引的所有品种的历史数据可用。

文件名	类型	说明
Mql5/include/Janus.mqh	包含	包含文件内含 CSymbolData、CSymbolCollection 和 CJanus 类定义
Mql5/scripts/OffensiveDefensiveScatterPlot.mq5	脚本	绘制进攻/防御得分的动画散点图的脚本
Mql5/indicators/IndexReturns.mq5	指标	显示品种和基准回报的指标代码
Mql5/indicators/RelativeStrengthBestWorst.mq5	指标	显示最高和最低相对强弱值图的指标。
Mql5/indicators/RelativeStrength.mq5	指标	显示品种相对强度的指标
Mql5/indicators/RelativeStrengthSpread.mq5	指标	显示相对强度价差的指标
Mql5/indicatorr/RssLeaderlaggards.mq5	指标	绘制 RS 领先者和落后者的指标