API tools faq
paste
Advertisement
Guest User

Jurik_RSXofJMA

a guest
Apr 15th, 2012
82
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.83 KB | None | 0 0
raw download clone embed print report
  1. //+SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS+
  2. //|                                                         JRSX.mq4 |
  3. //|          JRSX: Copyright © 2005,            Weld, Jurik Research |
  4. //|                                          http://weld.torguem.net |
  5. //|          MQL4: Copyright © 2005,                Nikolay Kositsin |
  6. //|                                   Khabarovsk, violet@mail.kht.ru |  
  7. //+SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS+
  8. #property copyright "Weld"
  9. #property link "http://weld.torguem.net"
  10. #property indicator_separate_window
  11. #property indicator_buffers 1
  12. #property indicator_color1 Magenta
  13. #property indicator_level1 80
  14. #property indicator_level2 20
  15. #property indicator_level3 50
  16. #property indicator_maximum 100
  17. #property indicator_minimum 0
  18. //---- input parameters
  19. extern int    RSX_Length = 14;
  20. extern double JMA_Length = 10;
  21. extern int    JMA_Phase  = 0;
  22. //---- buffers
  23. double JRSX_Bufer[];
  24. double JMAValueBuffer[];
  25. //----
  26. int    shift,r,w,k,Tnew,counted_bars,T0,T1;
  27. //----
  28. double v4,v8,v10,v14,v18,v20,v0C,v1C,v8A;  
  29. double F28,F30,F38,F40,F48,F50,F58,F60,F68,F70,F78,F80;
  30. double f0,f28,f30,f38,f40,f48,f50,f58,f60,f68,f70,f78,f80,Kg,Hg;
  31.  
  32. double fC0Buffer[];
  33. double fA8Buffer[];
  34. double fC8Buffer[];
  35. double list[128], ring1[128], ring2[11], buffer[62];
  36. bool   initFlag;
  37. int    limitValue, startValue, loopParam, loopCriteria;
  38. int    cycleLimit, highLimit, counterA, counterB;
  39. double cycleDelta, lowDValue, highDValue, absValue, paramA, paramB;
  40. double phaseParam, logParam, JMAValue, series, sValue, sqrtParam, lengthDivider;
  41. int    s58, s60, s40, s38, s68;
  42. //+SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS+
  43. //| Custom indicator initialization function                         |
  44. //+SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS+
  45. int init()
  46.   {
  47. //---- indicators
  48.    IndicatorBuffers(5);
  49.    SetIndexStyle(0,DRAW_LINE);
  50.    SetIndexBuffer(0,JRSX_Bufer);
  51.    IndicatorShortName("RSXofJMA("+RSX_Length+","+JMA_Length+","+JMA_Phase+")");
  52.    SetIndexEmptyValue(0,50.0);
  53.    double   lengthParam;
  54.    SetIndexBuffer (1, JMAValueBuffer);
  55.    SetIndexBuffer (2, fC0Buffer);
  56.    SetIndexBuffer (3, fA8Buffer);
  57.    SetIndexBuffer (4, fC8Buffer);
  58.    ArrayInitialize (ring2, 0);
  59.    ArrayInitialize (ring1, 0);
  60.    ArrayInitialize (buffer, 0);
  61.    limitValue = 63;
  62.    startValue = 64;
  63. //----  
  64.    for (int i = 0; i <= limitValue; i++) list [i] = -1000000;
  65.    for (i = startValue; i <= 127; i++)   list [i] = 1000000;
  66. //----
  67.    initFlag  = true;
  68.    if (JMA_Length < 1.0000000002) lengthParam = 0.0000000001;
  69.    else lengthParam = (JMA_Length - 1) / 2.0;
  70. //----  
  71.    if (JMA_Phase < -100) phaseParam = 0.5;
  72.    else if (JMA_Phase > 100) phaseParam = 2.5;
  73.    else phaseParam = JMA_Phase / 100.0 + 1.5;
  74. //----  
  75.    logParam = MathLog (MathSqrt (lengthParam)) / MathLog (2.0);
  76. //----
  77.    if (logParam + 2.0 < 0) logParam = 0;
  78.    else logParam = logParam + 2.0;
  79. //----
  80.    sqrtParam     = MathSqrt(lengthParam) * logParam;
  81.    lengthParam   = lengthParam * 0.9;
  82.    lengthDivider = lengthParam / (lengthParam + 2.0);
  83. //----
  84. return(0);
  85.   }
  86. //+SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS+
  87. //| Custor indicator deinitialization function                       |
  88. //+SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS+
  89. int start()
  90. {
  91. counted_bars=IndicatorCounted()-1;
  92. if(counted_bars < 0) counted_bars = 0;
  93.  
  94. if (counted_bars>JMA_Length) shift=Bars-counted_bars;
  95. else shift=Bars-JMA_Length-1;
  96.  
  97. while (shift >= 0) {
  98.       series = Close [shift];
  99.  
  100.       if (loopParam < 61) {
  101.          loopParam++;
  102.          buffer [loopParam] = series;
  103.       }
  104.       if (loopParam > 30) {
  105.          if (initFlag) {
  106.             initFlag = false;
  107.              
  108.             int diffFlag = 0;
  109.             for (int i = 1; i <= 29; i++) {
  110.                if (buffer [i + 1] != buffer [i]) diffFlag = 1;
  111.             }  
  112.             highLimit = diffFlag * 30;
  113.              
  114.             if (highLimit == 0) paramB = series;
  115.             else paramB = buffer[1];
  116.              
  117.             paramA = paramB;
  118.             if (highLimit > 29) highLimit = 29;
  119.          } else
  120.             highLimit = 0;
  121. //---- big cycle
  122.          for (i = highLimit; i >= 0; i--) {
  123.                if (i == 0) sValue = series; else sValue = buffer [31 - i];
  124.        
  125.                if (MathAbs (sValue - paramA) > MathAbs (sValue - paramB)) absValue = MathAbs(sValue - paramA); else absValue = MathAbs(sValue - paramB);
  126.                double dValue = absValue + 0.0000000001; //1.0e-10;
  127.    
  128.                if (counterA <= 1) counterA = 127; else counterA--;
  129.                if (counterB <= 1) counterB = 10;  else counterB--;
  130.                if (cycleLimit < 128) cycleLimit++;
  131.                cycleDelta += (dValue - ring2 [counterB]);
  132.                ring2 [counterB] = dValue;
  133.                if (cycleLimit > 10) highDValue = cycleDelta / 10.0; else highDValue = cycleDelta / cycleLimit;
  134.                
  135.                if (cycleLimit > 127) {
  136.                    dValue = ring1 [counterA];
  137.                    ring1 [counterA] = highDValue;
  138.                    s68 = 64; s58 = s68;
  139.                    while (s68 > 1) {
  140.                        if (list [s58] < dValue) {
  141.                            s68 = s68 / 2.0;
  142.                            s58 += s68;
  143.                        } else
  144.                        if (list [s58] <= dValue) {
  145.                            s68 = 1;
  146.                        } else {
  147.                            s68 = s68 / 2.0;
  148.                            s58 -= s68;
  149.                        }
  150.                }
  151.             } else {
  152.                   ring1 [counterA] = highDValue;
  153.                   if ((limitValue + startValue) > 127) {
  154.                       startValue--;
  155.                       s58 = startValue;
  156.                   } else {
  157.                       limitValue++;
  158.                       s58 = limitValue;
  159.                   }
  160.                   if (limitValue > 96) s38 = 96; else s38 = limitValue;
  161.                   if (startValue < 32) s40 = 32; else s40 = startValue;
  162.               }
  163. //----           
  164.               s68 = 64;
  165.               s60 = s68;
  166.               while (s68 > 1) {
  167.                   if (list [s60] >= highDValue) {
  168.                       if (list [s60 - 1] <= highDValue) {
  169.                           s68 = 1;
  170.                       }
  171.                       else {
  172.                           s68 = s68 / 2.0;
  173.                           s60 -= s68;
  174.                       }
  175.                   }
  176.                   else {
  177.                       s68 = s68 / 2.0;
  178.                       s60 += s68;
  179.                   }
  180.                   if ((s60 == 127) && (highDValue > list[127])) s60 = 128;
  181.               }
  182.                if (cycleLimit > 127) {
  183.                    if (s58 >= s60) {
  184.                        if (((s38 + 1) > s60) && ((s40 - 1) < s60))
  185.                             lowDValue += highDValue;
  186.                        else if ((s40 > s60) && ((s40 - 1) < s58))
  187.                             lowDValue += list [s40 - 1];
  188.                    }
  189.                    else if (s40 >= s60) {
  190.                        if (((s38 + 1) < s60) && ((s38 + 1) > s58))
  191.                                 lowDValue += list[s38 + 1];
  192.                     }
  193.                    else if ((s38 + 2) > s60)
  194.                            lowDValue += highDValue;
  195.                    else if (((s38 + 1) < s60) && ((s38 + 1) > s58))
  196.                            lowDValue += list[s38 + 1];
  197.            
  198.                    if (s58 > s60) {
  199.                        if (((s40 - 1) < s58) && ((s38 + 1) > s58))
  200.                            lowDValue -= list [s58];
  201.                        else if ((s38 < s58) && ((s38 + 1) > s60))
  202.                            lowDValue -= list [s38];
  203.                    }
  204.                    else {
  205.                        if (((s38 + 1) > s58) && ((s40 - 1) < s58))
  206.                            lowDValue -= list [s58];
  207.                        else if ((s40 > s58) && (s40 < s60))
  208.                            lowDValue -= list [s40];
  209.                    }
  210.                }
  211.                if (s58 <= s60) {
  212.                    if (s58 >= s60) list[s60] = highDValue; else {
  213.                        for (int j = s58 + 1; j <= (s60 - 1); j++) {
  214.                            list [j - 1] = list[j];
  215.                        }
  216.                        list [s60 - 1] = highDValue;
  217.                    }
  218.                } else {
  219.                    for (j = s58 - 1; j >= s60; j--) {
  220.                        list [j + 1] = list [j];
  221.                    }
  222.                    list [s60] = highDValue;
  223.                }
  224.            
  225.                if (cycleLimit <= 127) {
  226.                    lowDValue = 0;
  227.                    for (j = s40; j <= s38; j++) {
  228.                        lowDValue += list[j];
  229.                    }
  230.                }
  231. //----             
  232.                if ((loopCriteria + 1) > 31) loopCriteria = 31; else loopCriteria++;
  233.                double JMATempValue, sqrtDivider = sqrtParam / (sqrtParam + 1.0);
  234.                
  235.                if (loopCriteria <= 30) {
  236.                    if (sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * sqrtDivider;
  237.                    if (sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * sqrtDivider;
  238.                    JMATempValue = series;
  239.                  
  240.                    if (loopCriteria == 30) {
  241.                      fC0Buffer [shift] = series;
  242.                      int intPart;
  243.                      
  244.                      if (MathCeil(sqrtParam) >= 1) intPart = MathCeil(sqrtParam); else intPart = 1;
  245.                      int leftInt = IntPortion (intPart);
  246.                      if (MathFloor(sqrtParam) >= 1) intPart = MathFloor(sqrtParam); else intPart = 1;
  247.                      int rightPart = IntPortion (intPart);
  248.                      
  249.                      if (leftInt == rightPart) dValue = 1.0;
  250.                      else
  251.                          dValue = (sqrtParam - rightPart) / (leftInt - rightPart);
  252.                  
  253.                      if (rightPart <= 29) int upShift = rightPart; else upShift = 29;
  254.                      if (leftInt <= 29) int dnShift = leftInt; else dnShift = 29;
  255.                      fA8Buffer [shift] = (series - buffer [loopParam - upShift]) * (1 - dValue) / rightPart + (series - buffer[loopParam - dnShift]) * dValue / leftInt;
  256.                }
  257.                } else {
  258.                   double powerValue, squareValue;
  259.                  
  260.                   dValue = lowDValue / (s38 - s40 + 1);
  261.                   if (0.5 <= logParam - 2.0) powerValue = logParam - 2.0;
  262.                else powerValue = 0.5;
  263.                
  264.                    if (logParam >= MathPow(absValue/dValue, powerValue)) dValue = MathPow (absValue/dValue, powerValue); else dValue = logParam;
  265.                    if (dValue < 1) dValue = 1;
  266.                    
  267.                    powerValue = MathPow (sqrtDivider, MathSqrt (dValue));
  268.                    if (sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * powerValue;
  269.                    if (sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * powerValue;
  270.            }
  271.          }
  272. // ---- end of big cycle                               
  273.          if (loopCriteria > 30) {
  274.                 JMATempValue = JMAValueBuffer [shift + 1];
  275.             powerValue   = MathPow (lengthDivider, dValue);
  276.             squareValue  = MathPow (powerValue, 2);
  277.                          
  278.                 fC0Buffer [shift] = (1 - powerValue) * series + powerValue * fC0Buffer [shift + 1];
  279.             fC8Buffer [shift] = (series - fC0Buffer [shift]) * (1 - lengthDivider) + lengthDivider * fC8Buffer [shift + 1];
  280.            
  281.             fA8Buffer [shift] = (phaseParam * fC8Buffer [shift] + fC0Buffer [shift] - JMATempValue) *
  282.                                  (powerValue * (-2.0) + squareValue + 1) + squareValue * fA8Buffer [shift + 1];  
  283.             JMATempValue += fA8Buffer [shift];
  284.          }
  285.          JMAValue = JMATempValue;
  286.       }
  287.       if (loopParam <= 30) JMAValue = 0;
  288.       JMAValueBuffer [shift] = JMAValue;
  289. //---- End of main cycle
  290. shift--;
  291.    }
  292.  
  293. if (counted_bars>JMA_Length+RSX_Length) shift=Bars-counted_bars;
  294. else shift=Bars-JMA_Length-RSX_Length-1;
  295.  
  296. Tnew=Time[shift+1];
  297.  
  298. //+--- âînnnríîâëlícl dldlelííuo +=====================+
  299. if((Tnew!=T0)&&(shift<Bars-JMA_Length-RSX_Length-1))
  300. {
  301. if (Tnew==T1)
  302. {
  303. f28=F28; f30=F30; f38=F38; f40=F40; f48=F48; f50=F50;
  304. f58=F58; f60=F60; f68=F68; f70=F70; f78=F78; f80=F80;
  305. }
  306. else return(-1);
  307. }
  308. //+--- +===============================================+
  309.  
  310. if (RSX_Length-1>=5)w=RSX_Length-1;else w=5; Kg=3/(RSX_Length+2.0); Hg=1.0-Kg;
  311.  
  312. while (shift >= 0)
  313. {//+-------------------+
  314. if (r==0)
  315. {//...
  316. r = 1; k = 0;
  317. }//...
  318. else
  319. {//++++++++++++++++++++
  320. if (r>=w) r=w+1; else r=r+1;
  321.  
  322. v8 = JMAValueBuffer[shift]-JMAValueBuffer[shift+1]; v8A=MathAbs(v8);
  323.  
  324. //---- âu÷cnëlícl V14 ------
  325. f28 = Hg  * f28 + Kg  *  v8;
  326. f30 = Kg  * f28 + Hg  * f30;
  327. v0C = 1.5 * f28 - 0.5 * f30;
  328. f38 = Hg  * f38 + Kg  * v0C;
  329. f40 = Kg  * f38 + Hg  * f40;
  330. v10 = 1.5 * f38 - 0.5 * f40;
  331. f48 = Hg  * f48 + Kg  * v10;
  332. f50 = Kg  * f48 + Hg  * f50;
  333. v14 = 1.5 * f48 - 0.5 * f50;
  334. //---- âu÷cnëlícl V20 ------
  335. f58 = Hg  * f58 + Kg  * v8A;
  336. f60 = Kg  * f58 + Hg  * f60;
  337. v18 = 1.5 * f58 - 0.5 * f60;
  338. f68 = Hg  * f68 + Kg  * v18;
  339. f70 = Kg  * f68 + Hg  * f70;
  340. v1C = 1.5 * f68 - 0.5 * f70;
  341. f78 = Hg  * f78 + Kg  * v1C;
  342. f80 = Kg  * f78 + Hg  * f80;
  343. v20 = 1.5 * f78 - 0.5 * f80;
  344.  
  345. if ((r <= w) && (v8!= 0)) k = 1;
  346. if ((r == w) && (k == 0)) r = 0;
  347. }//++++++++++++++++++++
  348. if ((r >  w) &&(v20 > 0.0000000001 )) ///0.0000000001=={1.0e-10};
  349. {//...
  350. v4 = (v14/v20+1.0)*50.0; if(v4>100.0)v4=100.0; if(v4<0.0)v4=0.0;
  351. }//...
  352. else  v4 = 50.0;
  353. JRSX_Bufer[shift]=v4;
  354.  
  355. //+--- Nîodrílícl dldlelííuo +========================+  
  356. if (shift==1)
  357. {
  358. T1=Time[1];T0=Time[0];
  359. F28=f28; F30=f30; F38=f38; F40=f40; F48=f48; F50=f50;
  360. F58=f58; F60=f60; F68=f68; F70=f70; F78=f78; F80=f80;
  361. }
  362. //+---+===============================================+
  363.  
  364. shift--;
  365. }
  366. //+-------------------+
  367. return(0);
  368. }
  369.  
  370. //+------------------------------------------------------------------+
  371. int IntPortion (double param) {
  372.    if (param > 0) return (MathFloor (param));
  373.    if (param < 0) return (MathCeil (param));
  374.    return (0.0);
  375. }
  376. //+------------------------------------------------------------------+
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!