API tools faq
paste
Advertisement
Guest User

Jurik_JMAofRSX

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