返回
外汇指标
non lag ma mtf histo alerts arrows
回复:0  浏览:470
  • 楼主admin 圈主
  • 2019-05-05 05:03
nlma histo filter 2.png

  1. //------------------------------------------------------------------
  2. #property copyright "www.forex-station.com"
  3. #property link      "www.forex-station.com"
  4. //------------------------------------------------------------------

  6. #property indicator_separate_window
  7. #property indicator_buffers 2
  8. #property indicator_minimum 0
  9. #property indicator_maximum 1
  10. #property strict

  12. //
  13. //
  14. //
  15. //
  16. //

  18. enum enPrices
  19. {
  20.    pr_close,      // Close
  21.    pr_open,       // Open
  22.    pr_high,       // High
  23.    pr_low,        // Low
  24.    pr_median,     // Median
  25.    pr_typical,    // Typical
  26.    pr_weighted,   // Weighted
  27.    pr_average,    // Average (high+low+open+close)/4
  28.    pr_medianb,    // Average median body (open+close)/2
  29.    pr_tbiased,    // Trend biased price
  30.    pr_tbiased2,   // Trend biased (extreme) price
  31.    pr_haclose,    // Heiken ashi close
  32.    pr_haopen ,    // Heiken ashi open
  33.    pr_hahigh,     // Heiken ashi high
  34.    pr_halow,      // Heiken ashi low
  35.    pr_hamedian,   // Heiken ashi median
  36.    pr_hatypical,  // Heiken ashi typical
  37.    pr_haweighted, // Heiken ashi weighted
  38.    pr_haaverage,  // Heiken ashi average
  39.    pr_hamedianb,  // Heiken ashi median body
  40.    pr_hatbiased,  // Heiken ashi trend biased price
  41.    pr_hatbiased2  // Heiken ashi trend biased (extreme) price
  42. };
  43. enum enFilterWhat
  44. {
  45.    flt_prc,  // Filter the price
  46.    flt_val,  // Filter the non lag ma value
  47.    flt_both  // Filter both
  48. };

  50. extern ENUM_TIMEframeS Timeframe         = PERIOD_CURRENT;    // Time frame to use
  51. extern int             NlmPeriod         = 25;                // Non lag ma period
  52. extern enPrices        NlmPrice          = pr_close;          // Price to use
  53. extern double          Filter            =  0;                // Filter to use (<=0 no filter)
  54. extern int             FilterPeriod      =  0;                // Filter period (<=0 use Non lag ma period)
  55. extern enFilterWhat    FilterOn          = flt_prc;           // Apply filter to:
  56. extern int             Shift             = 0;                 // Shift
  57. extern int             HistoWidth        = 3;                 // Histogram bars width
  58. extern color           UpHistoColor      = clrLimeGreen;      // Up Histogram color
  59. extern color           DnHistoColor      = clrRed;            // Down histogram color
  60. extern bool            alertsOn          = true;              // Turn alerts on?
  61. extern bool            alertsOnCurrent   = false;             // alerts on current (still opened) bar?
  62. extern bool            alertsMessage     = true;              // alerts should display a message?
  63. extern bool            alertsSound       = false;             // alerts should play a sound?
  64. extern bool            alertsEmail       = false;             // alerts should send an email?
  65. extern bool            alertsNotify      = false;             // alerts should send notification?
  66. extern bool            arrowsVisible     = false;             // Arrows visible?
  67. extern bool            arrowsOnNewest    = false;             // Arrows drawn on newst bar of higher time frame bar?
  68. extern string          arrowsIdentifier  = "nlm Arrows1";     // Unique ID for arrows
  69. extern double          arrowsUpperGap    = 1.0;               // Upper arrow gap
  70. extern double          arrowsLowerGap    = 1.0;               // Lower arrow gap
  71. extern color           arrowsUpColor     = clrLimeGreen;      // Up arrow color
  72. extern color           arrowsDnColor     = clrOrange;         // Down arrow color
  73. extern int             arrowsUpCode      = 241;               // Up arrow code
  74. extern int             arrowsDnCode      = 242;               // Down arrow code
  75. extern int             arrowsSize        = 2;                 // Arrows size

  77. //
  78. //
  79. //
  80. //
  81. //

  83. double nlmDa[];
  84. double nlmDb[];
  85. double trend[];
  86. double nlm[];
  87. string indicatorFileName;
  88. bool   returnBars;

  90. //------------------------------------------------------------------
  91. //
  92. //------------------------------------------------------------------
  93. //
  94. //
  95. //
  96. //
  97. //

  99. int init()
  100. {
  101.    IndicatorBuffers(4);
  102.    SetIndexBuffer(0,nlmDa);  SetIndexStyle(0, DRAW_HISTOGRAM,EMPTY,HistoWidth,UpHistoColor);
  103.    SetIndexBuffer(1,nlmDb);  SetIndexStyle(1, DRAW_HISTOGRAM,EMPTY,HistoWidth,DnHistoColor);
  104.    SetIndexBuffer(2,nlm);
  105.    SetIndexBuffer(3,trend);

  107.       //
  108.       //
  109.       //
  110.       //
  111.       //
  112.          
  113.           indicatorFileName = WindowExpertName();
  114.           returnBars        = Timeframe==-99;
  115.           Timeframe         = fmax(Timeframe,_Period);
  116.           for (int i=0; i<7; i++) SetIndexShift(i,Shift*Timeframe/Period());
  117.    
  118.       //
  119.       //
  120.       //
  121.       //
  122.       //
  123.       
  124. return(0);
  125. }
  126. int deinit()
  127. {
  128.    string lookFor       = arrowsIdentifier+":";
  129.    int    lookForLength = StringLen(lookFor);
  130.    for (int i=ObjectsTotal()-1; i>=0; i--)
  131.    {
  132.       string objectName = ObjectName(i);
  133.          if (StringSubstr(objectName,0,lookForLength) == lookFor) ObjectDelete(objectName);
  134.    }
  135. return(0);
  136. }

  138. //------------------------------------------------------------------
  139. //
  140. //------------------------------------------------------------------
  141. //
  142. //
  143. //
  144. //
  145. //

  147. int start()
  148. {
  149.    int i,limit,counted_bars=IndicatorCounted();
  150.       if(counted_bars<0) return(-1);
  151.       if(counted_bars>0) counted_bars--;
  152.          limit = fmin(Bars-counted_bars,Bars-1);
  153.          if (returnBars) { nlmDa[0] = limit+1; return(0); }

  155.    //
  156.    //
  157.    //
  158.    //
  159.    //

  161.    if (Timeframe == Period())
  162.    {
  163.       for(i=limit; i>=0; i--)
  164.       {  
  165.          int    tperiod = FilterPeriod; if (tperiod<=0)  tperiod=(int)NlmPeriod;
  166.          double pfilter = Filter; if (FilterOn==flt_val) pfilter=0;
  167.          double vfilter = Filter; if (FilterOn==flt_prc) vfilter=0;
  168.          double price   = iFilter(getPrice(NlmPrice,Open,Close,High,Low,i),pfilter,tperiod,i,0);
  169.          nlm[i]   = iFilter(iNoLagMa(price,NlmPeriod,i),vfilter,tperiod,i,1);
  170.          nlmDa[i] = EMPTY_VALUE;
  171.          nlmDb[i] = EMPTY_VALUE;
  172.          trend[i] = (i<Bars-1) ? (nlm[i]>nlm[i+1]) ? 1 : (nlm[i]<nlm[i+1]) ? -1 : trend[i+1] : 0;
  173.          if (trend[i] == 1) nlmDa[i] = 1;
  174.          if (trend[i] ==-1) nlmDb[i] = 1;
  175.          
  176.          //
  177.          //
  178.          //
  179.          //
  180.          //
  181.          
  182.          if (arrowsVisible)
  183.           {
  184.             string lookFor = arrowsIdentifier+":"+(string)Time[i]; ObjectDelete(lookFor);            
  185.             if (i<(Bars-1) && trend[i] != trend[i+1])
  186.             {
  187.                if (trend[i] == 1) drawArrow(i,arrowsUpColor,arrowsUpCode,false);
  188.                if (trend[i] ==-1) drawArrow(i,arrowsDnColor,arrowsDnCode, true);
  189.             }
  190.          }
  191.      }
  192.    managealerts();
  193.    return(0);
  194.    }
  195.    
  196.    //
  197.    //
  198.    //
  199.    //
  200.    //
  201.    
  202.    limit = (int)fmax(limit,fmin(Bars-1,iCustom(NULL,Timeframe,indicatorFileName,-99,0,0)*Timeframe/Period()));
  203.    for (i=limit; i>=0; i--)
  204.    {
  205.       int y = iBarShift(NULL,Timeframe,Time[i]);
  206.          nlmDa[i] = iCustom(NULL,Timeframe,indicatorFileName,PERIOD_CURRENT,NlmPeriod,NlmPrice,Filter,FilterPeriod,FilterOn,0,HistoWidth,UpHistoColor,DnHistoColor,alertsOn,alertsOnCurrent,alertsMessage,alertsSound,alertsEmail,alertsNotify,arrowsVisible,arrowsOnNewest,arrowsIdentifier,arrowsUpperGap,arrowsLowerGap,arrowsUpColor,arrowsDnColor,arrowsUpCode,arrowsDnCode,arrowsSize,0,y);
  207.          nlmDb[i] = iCustom(NULL,Timeframe,indicatorFileName,PERIOD_CURRENT,NlmPeriod,NlmPrice,Filter,FilterPeriod,FilterOn,0,HistoWidth,UpHistoColor,DnHistoColor,alertsOn,alertsOnCurrent,alertsMessage,alertsSound,alertsEmail,alertsNotify,arrowsVisible,arrowsOnNewest,arrowsIdentifier,arrowsUpperGap,arrowsLowerGap,arrowsUpColor,arrowsDnColor,arrowsUpCode,arrowsDnCode,arrowsSize,1,y);         
  208.    }
  209. return(0);      
  210. }

  212. //------------------------------------------------------------------
  213. //                                                                  
  214. //------------------------------------------------------------------
  215. //
  216. //
  217. //
  218. //
  219. //

  221. #define _length  0
  222. #define _len     1
  223. #define _weight  2

  225. #define numOfSeparateCalculations 3
  226. double  nlm_values[3][numOfSeparateCalculations];
  227. double  nlm_prices[ ][numOfSeparateCalculations];
  228. double  nlm_alphas[ ][numOfSeparateCalculations];

  230. double iNoLagMa(double price, int length, int r, int instanceNo=0)
  231. {
  232.    r = Bars-r-1;
  233.    if (ArrayRange(nlm_prices,0) != Bars(Symbol(),0)) ArrayResize(nlm_prices,Bars(Symbol(),0));
  234.                                nlm_prices[r][instanceNo]=price;
  235.    if (length<3 || r<3) return(nlm_prices[r][instanceNo]);
  236.    
  237.    //
  238.    //
  239.    //
  240.    //
  241.    //
  242.    
  243.    if (nlm_values[_length][instanceNo] != length)
  244.    {
  245.       double Cycle = 4.0;
  246.       double Coeff = 3.0*M_PI;
  247.       int    Phase = length-1;
  248.       
  249.          nlm_values[_length][instanceNo] = length;
  250.          nlm_values[_len   ][instanceNo] = length*4 + Phase;  
  251.          nlm_values[_weight][instanceNo] = 0;

  253.          if (ArrayRange(nlm_alphas,0) < nlm_values[_len][instanceNo]) ArrayResize(nlm_alphas,(int)nlm_values[_len][instanceNo]);
  254.          for (int k=0; k<nlm_values[_len][instanceNo]; k++)
  255.          {
  256.             double t;
  257.             if (k<=Phase-1)
  258.                  t = 1.0 * k/(Phase-1);
  259.             else t = 1.0 + (k-Phase+1)*(2.0*Cycle-1.0)/(Cycle*length-1.0);
  260.             double beta = MathCos(M_PI*t);
  261.             double g = 1.0/(Coeff*t+1); if (t <= 0.5 ) g = 1;
  262.       
  263.             nlm_alphas[k][instanceNo]        = g * beta;
  264.             nlm_values[_weight][instanceNo] += nlm_alphas[k][instanceNo];
  265.          }
  266.    }
  267.    
  268.    //
  269.    //
  270.    //
  271.    //
  272.    //
  273.    
  274.    if (nlm_values[_weight][instanceNo]>0)
  275.    {
  276.       double sum = 0;
  277.            for (int k=0; k < nlm_values[_len][instanceNo] && (r-k)>=0; k++) sum += nlm_alphas[k][instanceNo]*nlm_prices[r-k][instanceNo];
  278.            return( sum / nlm_values[_weight][instanceNo]);
  279.    }
  280.    else return(0);           
  281. }

  283. //------------------------------------------------------------------
  284. //                                                                  
  285. //------------------------------------------------------------------
  286. //
  287. //
  288. //
  289. //
  290. //

  292. #define filterInstances 2
  293. double workFil[][filterInstances*3];

  295. #define _fchange 0
  296. #define _fachang 1
  297. #define _fprice  2

  299. double iFilter(double tprice, double filter, int period, int i, int instanceNo=0)
  300. {
  301.    if (filter<=0 || period<=0) return(tprice);
  302.    if (ArrayRange(workFil,0)!= Bars) ArrayResize(workFil,Bars); i = Bars-i-1; instanceNo*=3;
  303.    
  304.    //
  305.    //
  306.    //
  307.    //
  308.    //
  309.    
  310.    workFil[i][instanceNo+_fprice]  = tprice; if (i<1) return(tprice);
  311.    workFil[i][instanceNo+_fchange] = fabs(workFil[i][instanceNo+_fprice]-workFil[i-1][instanceNo+_fprice]);
  312.    workFil[i][instanceNo+_fachang] = workFil[i][instanceNo+_fchange];

  314.    for (int k=1; k<period && (i-k)>=0; k++) workFil[i][instanceNo+_fachang] += workFil[i-k][instanceNo+_fchange];
  315.                                             workFil[i][instanceNo+_fachang] /= period;
  316.    
  317.    double stddev = 0; for (int k=0;  k<period && (i-k)>=0; k++) stddev += MathPow(workFil[i-k][instanceNo+_fchange]-workFil[i-k][instanceNo+_fachang],2);
  318.           stddev = MathSqrt(stddev/(double)period);
  319.    double filtev = filter * stddev;
  320.    if( MathAbs(workFil[i][instanceNo+_fprice]-workFil[i-1][instanceNo+_fprice]) < filtev ) workFil[i][instanceNo+_fprice]=workFil[i-1][instanceNo+_fprice];
  321.    return(workFil[i][instanceNo+_fprice]);
  322. }

  324. //------------------------------------------------------------------
  325. //
  326. //------------------------------------------------------------------
  327. //
  328. //
  329. //
  330. //
  331. //
  332. //

  334. #define priceInstances 1
  335. double workHa[][priceInstances*4];
  336. double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i, int instanceNo=0)
  337. {
  338.   if (tprice>=pr_haclose)
  339.    {
  340.       if (ArrayRange(workHa,0)!= Bars) ArrayResize(workHa,Bars); instanceNo*=4;
  341.          int r = Bars-i-1;
  342.          
  343.          //
  344.          //
  345.          //
  346.          //
  347.          //
  348.          
  349.          double haOpen;
  350.          if (r>0)
  351.                 haOpen  = (workHa[r-1][instanceNo+2] + workHa[r-1][instanceNo+3])/2.0;
  352.          else   haOpen  = (open[i]+close[i])/2;
  353.          double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
  354.          double haHigh  = fmax(high[i],fmax(haOpen,haClose));
  355.          double haLow   = fmin(low[i] ,fmin(haOpen,haClose));

  357.          if(haOpen  <haClose) { workHa[r][instanceNo+0] = haLow;  workHa[r][instanceNo+1] = haHigh; }
  358.          else                 { workHa[r][instanceNo+0] = haHigh; workHa[r][instanceNo+1] = haLow;  }
  359.                                 workHa[r][instanceNo+2] = haOpen;
  360.                                 workHa[r][instanceNo+3] = haClose;
  361.          //
  362.          //
  363.          //
  364.          //
  365.          //
  366.          
  367.          switch (tprice)
  368.          {
  369.             case pr_haclose:     return(haClose);
  370.             case pr_haopen:      return(haOpen);
  371.             case pr_hahigh:      return(haHigh);
  372.             case pr_halow:       return(haLow);
  373.             case pr_hamedian:    return((haHigh+haLow)/2.0);
  374.             case pr_hamedianb:   return((haOpen+haClose)/2.0);
  375.             case pr_hatypical:   return((haHigh+haLow+haClose)/3.0);
  376.             case pr_haweighted:  return((haHigh+haLow+haClose+haClose)/4.0);
  377.             case pr_haaverage:   return((haHigh+haLow+haClose+haOpen)/4.0);
  378.             case pr_hatbiased:
  379.                if (haClose>haOpen)
  380.                      return((haHigh+haClose)/2.0);
  381.                else  return((haLow+haClose)/2.0);        
  382.             case pr_hatbiased2:
  383.                if (haClose>haOpen)  return(haHigh);
  384.                if (haClose<haOpen)  return(haLow);
  385.                                     return(haClose);        
  386.          }
  387.    }
  388.    
  389.    //
  390.    //
  391.    //
  392.    //
  393.    //
  394.    
  395.    switch (tprice)
  396.    {
  397.       case pr_close:     return(close[i]);
  398.       case pr_open:      return(open[i]);
  399.       case pr_high:      return(high[i]);
  400.       case pr_low:       return(low[i]);
  401.       case pr_median:    return((high[i]+low[i])/2.0);
  402.       case pr_medianb:   return((open[i]+close[i])/2.0);
  403.       case pr_typical:   return((high[i]+low[i]+close[i])/3.0);
  404.       case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);
  405.       case pr_average:   return((high[i]+low[i]+close[i]+open[i])/4.0);
  406.       case pr_tbiased:   
  407.                if (close[i]>open[i])
  408.                      return((high[i]+close[i])/2.0);
  409.                else  return((low[i]+close[i])/2.0);        
  410.       case pr_tbiased2:   
  411.                if (close[i]>open[i]) return(high[i]);
  412.                if (close[i]<open[i]) return(low[i]);
  413.                                      return(close[i]);        
  414.    }
  415.    return(0);
  416. }   

  418. //-------------------------------------------------------------------
  419. //
  420. //-------------------------------------------------------------------
  421. //
  422. //
  423. //
  424. //
  425. //

  427. string sTfTable[] = {"M1","M5","M15","M30","H1","H4","D1","W1","MN"};
  428. int    iTfTable[] = {1,5,15,30,60,240,1440,10080,43200};

  430. string timeframeToString(int tf)
  431. {
  432.    for (int i=ArraySize(iTfTable)-1; i>=0; i--)
  433.          if (tf==iTfTable[i]) return(sTfTable[i]);
  434.                               return("");
  435. }

  437. //-------------------------------------------------------------------
  438. //                                                                  
  439. //-------------------------------------------------------------------
  440. //
  441. //
  442. //
  443. //
  444. //

  446. void managealerts()
  447. {
  448.    if (alertsOn)
  449.    {
  450.       int whichBar = 1; if (alertsOnCurrent) whichBar = 0;
  451.       if (trend[whichBar] != trend[whichBar+1])
  452.       {
  453.          if (trend[whichBar] ==  1) doalert(whichBar,"up");
  454.          if (trend[whichBar] == -1) doalert(whichBar,"down");
  455.       }
  456.    }
  457. }

  459. //
  460. //
  461. //
  462. //
  463. //

  465. void doalert(int forBar, string doWhat)
  466. {
  467.    static string   previousalert="nothing";
  468.    static datetime previousTime;
  469.    string message;
  470.    
  471.    if (previousalert != doWhat || previousTime != Time[forBar]) {
  472.        previousalert  = doWhat;
  473.        previousTime   = Time[forBar];

  475.        //
  476.        //
  477.        //
  478.        //
  479.        //

  481.        message =  StringConcatenate(Symbol()," ",timeframeToString(_Period)," at ",TimeToStr(TimeLocal(),TIME_SECONDS)," NonLag MA slope changed to ",doWhat);
  482.           if (alertsMessage) alert(message);
  483.           if (alertsSound)   PlaySound("alert2.wav");
  484.           if (alertsEmail)   SendMail(StringConcatenate(Symbol(),"NonLag MA"),message);
  485.           if (alertsNotify)  SendNotification(message);
  486.    }
  487. }

  489. //-------------------------------------------------------------------
  490. //                                                                  
  491. //-------------------------------------------------------------------
  492. //
  493. //
  494. //
  495. //
  496. //

  498. void drawArrow(int i,color theColor,int theCode,bool up)
  499. {
  500.    string name = arrowsIdentifier+":"+(string)Time[i];
  501.    double gap  = iATR(NULL,0,20,i);   
  502.    
  503.       //
  504.       //
  505.       //
  506.       //
  507.       //

  509.       datetime time = Time[i]; if (arrowsOnNewest) time += _Period*60-1;      
  510.       ObjectCreate(name,OBJ_ARROW,0,time,0);
  511.          ObjectSet(name,OBJPROP_ARROWCODE,theCode);
  512.          ObjectSet(name,OBJPROP_WIDTH,arrowsSize);
  513.          ObjectSet(name,OBJPROP_COLOR,theColor);
  514.          if (up)
  515.                ObjectSet(name,OBJPROP_PRICE1,High[i] + arrowsUpperGap * gap);
  516.          else  ObjectSet(name,OBJPROP_PRICE1,Low[i]  - arrowsLowerGap * gap);
  517. }
打赏