API tools faq
paste
Advertisement
Guest User

Ocn_BTXx

a guest
May 6th, 2012
123
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 23.45 KB | None | 0 0
raw download clone embed print report
  1. // Ocn_BTXx version 1.1
  2. #property  copyright "© jim sloman, jma © mark jurik, for metatrader reprogrammed by udc"
  3. #property  link      "udc@seznam.cz"
  4.  
  5. #property indicator_separate_window
  6. #property indicator_buffers 6
  7. #property indicator_color1 Magenta
  8. #property indicator_color2 Silver
  9. #property indicator_color3 Silver
  10. #property indicator_color4 Silver
  11. #property indicator_color5 Lime
  12. #property indicator_color6 Red
  13. #property indicator_level1 35
  14. #property indicator_levelcolor Gray
  15. #property indicator_levelstyle 2
  16. #property indicator_minimum 0
  17. #property indicator_maximum 100
  18.  
  19. extern int    BTX_period             = 40;
  20. extern int    SmLen                  = 20;
  21. extern bool   Use_JMA_instead_TEMA   = false;
  22. extern double JMA_Length             = 10;
  23. extern int    JMA_Phase              = 50;
  24. extern int    MaxBars                = 0;
  25. extern bool   Show_SD                = true;
  26. extern int    SD_len                 = 20;
  27. extern double SD_up                  = 1.5;
  28. extern double SD_dn                  = 1.5;
  29. extern bool   Show_SD_up             = true;
  30. extern bool   Show_SD_dn             = true;
  31. extern bool   Show_SD_md             = true;
  32. extern bool   BTX_2line_based_colors = false;
  33.  
  34. double BTX[];
  35. double SD[];
  36. double SD2[];
  37. double SD3[];
  38. double BTXbull[];
  39. double BTXbear[];
  40. double RawBTX[];
  41. double maBTX[];
  42.  
  43. int    oldbars;
  44. double RawBTXp[], newRawBTXp[];
  45. double maBTXp[], newmaBTXp[];
  46. double RawBTXn[], newRawBTXn[];
  47. double maBTXn[], newmaBTXn[];
  48.  
  49. double fC0Buffer[];
  50. double fA8Buffer[];
  51. double fC8Buffer[];
  52. double list[128], ring1[128], ring2[11], buffer[62];
  53. bool   initFlag;
  54. int    limitValue, startValue, loopParam, loopCriteria;
  55. int    cycleLimit, highLimit, counterA, counterB;
  56. double cycleDelta, lowDValue, highDValue, absValue, paramA, paramB;
  57. double phaseParam, logParam, JMAValue, series, sValue, sqrtParam, lengthDivider;
  58. int    s58, s60, s40, s38, s68;
  59.  
  60. bool   initialized;
  61. #import "OBP1Lock32x.dll"
  62.   bool LTInitializeFromInix(string);
  63.   double LTCalcValx(string, double, double, double, double, string);
  64. #define dll "OBP1Lock32.dll"
  65. #import
  66. double arr6[99], arr7[99], arr8[99], arr9[99], arr10[99], arr11[99];
  67. double arr9x[99], arr10x[99], arr11x[99], arr12x[99], arr13x[99], arr14x[99], arr15x[99], arr16x[99], arr17x[99], arr18x[99];
  68.  
  69. int init()
  70. {
  71.   initialized = LTInitializeFromInix(dll);
  72.   if(!initialized) return(0);
  73.  
  74.   if(SmLen < 1) SmLen = 1;
  75.   if(BTX_period > 98) BTX_period = 98;
  76.   string btxname = "(" + BTX_period + ", " + SmLen + ")";
  77.   if(Use_JMA_instead_TEMA) btxname = "_JMA(" + BTX_period + ", " + JMA_Length + ", " + JMA_Phase + ")";
  78.   IndicatorShortName("BTX"+btxname);
  79.   IndicatorDigits(2);
  80.   IndicatorBuffers(8);
  81.   SetIndexBuffer(0, BTX);
  82.   SetIndexLabel(0, "BTX"+btxname);
  83.   SetIndexBuffer(1, SD);
  84.   SetIndexBuffer(2, SD2);
  85.   SetIndexBuffer(3, SD3);
  86.   if(Show_SD_up) SetIndexLabel(1, "BTX_SD_up(" + SD_len + ")");
  87.   else           SetIndexLabel(1, "unused");
  88.   if(Show_SD_dn) SetIndexLabel(2, "BTX_SD_dn(" + SD_len + ")");
  89.   else           SetIndexLabel(2, "unused");
  90.   if(Show_SD_md) SetIndexLabel(3, "BTX_SD_md(" + SD_len + ")");
  91.   else           SetIndexLabel(3, "unused");
  92.   SetIndexBuffer(4, BTXbull);
  93.   SetIndexBuffer(5, BTXbear);
  94.   if(BTX_2line_based_colors) { SetIndexLabel(4, "BTX_bull"+btxname); SetIndexLabel(5, "BTX_bear"+btxname); }
  95.   else                       { SetIndexLabel(4, "unused"); SetIndexLabel(5, "unused"); }
  96.   SetIndexBuffer(6, RawBTX);
  97.   SetIndexBuffer(7, maBTX);
  98.  
  99.   ArraySetAsSeries(arr6, true); ArraySetAsSeries(arr7, true); ArraySetAsSeries(arr8, true);
  100.   ArraySetAsSeries(arr9, true); ArraySetAsSeries(arr10, true); ArraySetAsSeries(arr11, true);
  101.  
  102.   if(BTX_2line_based_colors)
  103.     {
  104.     ArraySetAsSeries(RawBTXp, true); ArraySetAsSeries(newRawBTXp, true); ArrayResize(RawBTXp, Bars); ArrayInitialize(RawBTXp, 0);
  105.     ArraySetAsSeries(maBTXp, true); ArraySetAsSeries(newmaBTXp, true); ArrayResize(maBTXp, Bars); ArrayInitialize(maBTXp, 0);
  106.     ArraySetAsSeries(RawBTXn, true); ArraySetAsSeries(newRawBTXn, true); ArrayResize(RawBTXn, Bars); ArrayInitialize(RawBTXn, 0);
  107.     ArraySetAsSeries(maBTXn, true); ArraySetAsSeries(newmaBTXn, true); ArrayResize(maBTXn, Bars); ArrayInitialize(maBTXn, 0);
  108.     oldbars = Bars;
  109.     ArraySetAsSeries(arr9x, true); ArraySetAsSeries(arr10x, true); ArraySetAsSeries(arr11x, true);
  110.     ArraySetAsSeries(arr12x, true); ArraySetAsSeries(arr13x, true); ArraySetAsSeries(arr14x, true);
  111.     ArraySetAsSeries(arr15x, true); ArraySetAsSeries(arr16x, true); ArraySetAsSeries(arr17x, true);
  112.     ArraySetAsSeries(arr18x, true);
  113.     }
  114.  
  115.   return(0);
  116. }
  117.  
  118. int start()
  119. {
  120.   if(!initialized) return(0);
  121.  
  122.   int limit, i, ii, counted_bars = IndicatorCounted()-1, bars;
  123.  
  124.   if(MaxBars > 0) { bars = MaxBars; if(counted_bars > bars) counted_bars = bars - 2; } else bars = Bars;
  125.   if(Use_JMA_instead_TEMA) { if(bars <= BTX_period + JMA_Length) return(0); }
  126.   else                     { if(bars <= BTX_period + 3*SmLen) return(0); }
  127.   if(counted_bars < 0) counted_bars = 0;
  128.   if(counted_bars > BTX_period) limit = bars - counted_bars;
  129.   else                          limit = bars - BTX_period - 1;
  130.  
  131.   if((BTX_2line_based_colors) && (oldbars != Bars))
  132.     {
  133.     ArrayResize(newRawBTXp, Bars); ArrayCopy(newRawBTXp, RawBTXp, (Bars-oldbars)); ArrayResize(RawBTXp, Bars); ArrayCopy(RawBTXp, newRawBTXp);
  134.     ArrayResize(newmaBTXp, Bars); ArrayCopy(newmaBTXp, maBTXp, (Bars-oldbars)); ArrayResize(maBTXp, Bars); ArrayCopy(maBTXp, newmaBTXp);
  135.     ArrayResize(newRawBTXn, Bars); ArrayCopy(newRawBTXn, RawBTXn, (Bars-oldbars)); ArrayResize(RawBTXn, Bars); ArrayCopy(RawBTXn, newRawBTXn);
  136.     ArrayResize(newmaBTXn, Bars); ArrayCopy(newmaBTXn, maBTXn, (Bars-oldbars)); ArrayResize(maBTXn, Bars); ArrayCopy(maBTXn, newmaBTXn);
  137.     oldbars = Bars;
  138.     }
  139.  
  140.   for(i = limit; i >= 0; i--)
  141.     {
  142.     double var2 = 0, var3 = 0;
  143.     ArrayInitialize(arr6, 0); ArrayInitialize(arr7, 0); ArrayInitialize(arr8, 0);
  144.     ArrayInitialize(arr9, 0); ArrayInitialize(arr10, 0); ArrayInitialize(arr11, 0);
  145.     arr6[0] = LTCalcValx(dll, Close[i], 0.5, High[i], Low[i], "eBBcmGJhfe");
  146.     for(ii = 1; ii <= BTX_period; ii++)
  147.       {
  148.       arr6[ii] = LTCalcValx(dll, Close[i+ii], Close[i+ii-1], 0.5, Close[i], "FpmqUGJh");
  149.       arr7[ii] = LTCalcValx(dll, arr6[ii-1], arr6[ii], Close[i], 0.5, "rmEsGMDfF");
  150.       arr8[ii] = LTCalcValx(dll, arr8[ii-1], (arr7[ii]), arr8[ii], arr7[ii-1], "smUDecGMJYh");
  151.       if(arr8[ii] == 0) arr9[ii] = 0;
  152.       else              arr9[ii] = LTCalcValx(dll, arr6[0], arr6[ii], arr8[ii], arr7[ii], "rUGMecDJYBBXU");
  153.       arr10[ii] = 1 / LTCalcValx(dll, 0.5, ii, arr9[ii], -MathAbs(arr9[ii-1]), "UhWGceMBBJn");
  154.       arr11[ii] = LTCalcValx(dll, arr9[ii], arr10[ii], arr9[ii-1], arr8[ii], "F3ecmGBBMqec");
  155.       var2 = LTCalcValx(dll, var2, arr11[ii], arr11[ii], var2, "ceGMhftTds");
  156.       var3 = LTCalcValx(dll, var3, arr10[ii], var2, var3, "jTGceMBBh");
  157.       }
  158.     RawBTX[i] = LTCalcValx(dll, var2, var3, 100, 0.5, "mUDF0AA8GMUXBBq");
  159.     if(BTX_2line_based_colors)
  160.       {
  161.       double var2x = 0, var3x = 0, var4x = 0, var5x = 0;
  162.       ArrayInitialize(arr9x, 0); ArrayInitialize(arr10x, 0); ArrayInitialize(arr11x, 0);
  163.       ArrayInitialize(arr12x, 0); ArrayInitialize(arr13x, 0); ArrayInitialize(arr14x, 0);
  164.       ArrayInitialize(arr15x, 0); ArrayInitialize(arr16x, 0); ArrayInitialize(arr17x, 0);
  165.       ArrayInitialize(arr18x, 0);
  166.       arr9x[0] = MathLog(Close[i]);
  167.       for(ii = 1; ii <= BTX_period; ii++)
  168.         {
  169.         arr9x[ii] = LTCalcValx(dll, Close[i+ii], Close[i+ii-1], 0.5, Close[i], "mmGBBJhfgg");
  170.         if((arr9x[ii-1]-arr9x[ii]) > 0) arr10x[ii] = LTCalcValx(dll, arr9x[ii-1], arr9x[ii], Close[i], 0.5, "qUGecBBMD");
  171.         else                            arr10x[ii] = 0;
  172.         if((arr9x[ii-1]-arr9x[ii]) < 0) arr11x[ii] = LTCalcValx(dll, arr9x[ii-1], arr9x[ii], Close[i], 0.5, "hrmGMBBceDf");
  173.         else                            arr11x[ii] = 0;
  174.         arr12x[ii] = LTCalcValx(dll, arr12x[ii-1], arr10x[ii], 0.5, Close[i], "F9mGMcehfft");
  175.         arr13x[ii] = LTCalcValx(dll, arr13x[ii-1], arr11x[ii], 0.5, Close[i], "F9mGMcehfft");
  176.         if((arr9x[0]-arr9x[ii]) > 0) { if(arr12x[ii] == 0) arr14x[ii] = 0; else arr14x[ii] = LTCalcValx(dll, arr9x[0], arr9x[ii], arr12x[ii], arr10x[ii], "CqdGMDBBXUfA"); }
  177.         else                         arr14x[ii] = 0;
  178.         if((arr9x[0]-arr9x[ii]) < 0) { if(arr13x[ii] == 0) arr15x[ii] = 0; else arr15x[ii] = LTCalcValx(dll, arr9x[0], arr9x[ii], arr13x[ii], arr11x[ii], "FmGMBBDXUfa"); }
  179.         else                         arr15x[ii] = 0;
  180.         arr16x[ii] = 1 / LTCalcValx(dll, 0.5, ii, arr14x[ii], arr15x[ii], "UhWGceMBBJn");
  181.         arr17x[ii] = LTCalcValx(dll, arr14x[ii], arr16x[ii], arr14x[ii-1], arr12x[ii], "BBWGMecqfrr");
  182.         arr18x[ii] = LTCalcValx(dll, arr15x[ii], arr16x[ii], arr15x[ii-1], arr13x[ii], "ceGWWMBBqffr");
  183.         var2x = LTCalcValx(dll, var2x, arr17x[ii], arr17x[ii-1], var2x, "ceGMhftTds");
  184.         var3x = LTCalcValx(dll, var3x, arr18x[ii], arr18x[ii-1], var3x, "ceGMhftTds");
  185.         var4x = LTCalcValx(dll, var4x, arr16x[ii], var2x, var4x, "jTGceMBBhffv");
  186.         var5x = LTCalcValx(dll, var5x, arr16x[ii], var3x, var5x, "jTGceMBBhffv");
  187.         }
  188.       RawBTXp[i] = LTCalcValx(dll, var2x, var4x, 100, 0.5, "mGBBMUceXq");
  189.       RawBTXn[i] = LTCalcValx(dll, var3x, var5x, 100, 0.5, "mGMUXecqfUr");
  190.       }
  191.     }
  192.  
  193.   if(!Use_JMA_instead_TEMA)
  194.     {
  195.     double ExpSmooth = 2, XAvg1, XAvg2, XAvg3;
  196.     ExpSmooth = ExpSmooth / (SmLen + 1);
  197.     for(i = bars - BTX_period - 1; i >= 0; i--)
  198.       {
  199.       XAvg1 += ExpSmooth * (RawBTX[i] - XAvg1);
  200.       XAvg2 += ExpSmooth * (XAvg1 - XAvg2);
  201.       XAvg3 += ExpSmooth * (XAvg2 - XAvg3);
  202.       maBTX[i] = 3 * XAvg1 - 3 * XAvg2 + XAvg3;
  203.       if(i < bars - BTX_period - 1 - 3*SmLen)
  204.         BTX[i] = NormalizeDouble(maBTX[i], 2);
  205.       }
  206.     if(BTX_2line_based_colors)
  207.       {
  208.       ExpSmooth = 2; XAvg1 = 0; XAvg2 = 0; XAvg3 = 0;
  209.       ExpSmooth = ExpSmooth / (SmLen + 1);
  210.       for(i = bars - BTX_period - 1; i >= 0; i--)
  211.         {
  212.         XAvg1 += ExpSmooth * (RawBTXp[i] - XAvg1);
  213.         XAvg2 += ExpSmooth * (XAvg1 - XAvg2);
  214.         XAvg3 += ExpSmooth * (XAvg2 - XAvg3);
  215.         maBTXp[i] = 3 * XAvg1 - 3 * XAvg2 + XAvg3;
  216.         }
  217.       ExpSmooth = 2; XAvg1 = 0; XAvg2 = 0; XAvg3 = 0;
  218.       ExpSmooth = ExpSmooth / (SmLen + 1);
  219.       for(i = bars - BTX_period - 1; i >= 0; i--)
  220.         {
  221.         XAvg1 += ExpSmooth * (RawBTXn[i] - XAvg1);
  222.         XAvg2 += ExpSmooth * (XAvg1 - XAvg2);
  223.         XAvg3 += ExpSmooth * (XAvg2 - XAvg3);
  224.         maBTXn[i] = 3 * XAvg1 - 3 * XAvg2 + XAvg3;
  225.         }
  226.       for(i = bars - BTX_period - 1 - 3*SmLen; i >= 0; i--)
  227.         {
  228.         if(maBTXp[i] > maBTXn[i]) BTXbull[i] = BTX[i];
  229.         else if(maBTXn[i] > maBTXp[i]) BTXbear[i] = BTX[i];
  230.         }
  231.       }
  232.     }
  233.   else
  234.     {
  235.     ArrayResize(fC0Buffer, bars - BTX_period); ArraySetAsSeries(fC0Buffer, true); ArrayInitialize(fC0Buffer, 0);
  236.     ArrayResize(fA8Buffer, bars - BTX_period); ArraySetAsSeries(fA8Buffer, true); ArrayInitialize(fA8Buffer, 0);
  237.     ArrayResize(fC8Buffer, bars - BTX_period); ArraySetAsSeries(fC8Buffer, true); ArrayInitialize(fC8Buffer, 0);
  238.     ArrayInitialize(list, 0);
  239.     initFlag = false;
  240.     limitValue = 0; startValue = 0; loopParam = 0; loopCriteria = 0;
  241.     cycleLimit = 0; highLimit = 0; counterA = 0; counterB = 0;
  242.     cycleDelta = 0; lowDValue = 0; highDValue = 0; absValue = 0; paramA = 0; paramB = 0;
  243.     phaseParam = 0; logParam = 0; JMAValue = 0; series = 0; sValue = 0; sqrtParam = 0; lengthDivider = 0;
  244.     s58 = 0; s60 = 0; s40 = 0; s38 = 0; s68 = 0;
  245.     ArrayInitialize(ring2, 0);
  246.     ArrayInitialize(ring1, 0);
  247.     ArrayInitialize(buffer, 0);
  248.     double lengthParam;
  249.     limitValue = 63;
  250.     startValue = 64;
  251.     for(i = 0; i <= limitValue; i++)   list[i] = -1000000;
  252.     for(i = startValue; i <= 127; i++) list[i] = 1000000;
  253.     initFlag = true;
  254.     if(JMA_Length < 1.0000000002) lengthParam = 0.0000000001;
  255.     else                          lengthParam = (JMA_Length - 1) / 2.0;
  256.     if(JMA_Phase < -100)     phaseParam = 0.5;
  257.     else if(JMA_Phase > 100) phaseParam = 2.5;
  258.     else                     phaseParam = JMA_Phase / 100.0 + 1.5;
  259.     logParam = MathLog(MathSqrt(lengthParam)) / MathLog(2.0);
  260.     if(logParam + 2.0 < 0) logParam = 0;
  261.     else                   logParam = logParam + 2.0;
  262.     sqrtParam     = MathSqrt(lengthParam) * logParam;
  263.     lengthParam   = lengthParam * 0.9;
  264.     lengthDivider = lengthParam / (lengthParam + 2.0);
  265.     for(i = bars - BTX_period - 1; i >= 0; i--)
  266.       {
  267.       jma(RawBTX, maBTX, i);
  268.       if(i < bars - BTX_period - 1 - JMA_Length)
  269.         BTX[i] = NormalizeDouble(maBTX[i], 2);
  270.       }
  271.     if(BTX_2line_based_colors)
  272.       {
  273.       ArrayInitialize(fC0Buffer, 0);
  274.       ArrayInitialize(fA8Buffer, 0);
  275.       ArrayInitialize(fC8Buffer, 0);
  276.       ArrayInitialize(list, 0);
  277.       initFlag = false;
  278.       limitValue = 0; startValue = 0; loopParam = 0; loopCriteria = 0;
  279.       cycleLimit = 0; highLimit = 0; counterA = 0; counterB = 0;
  280.       cycleDelta = 0; lowDValue = 0; highDValue = 0; absValue = 0; paramA = 0; paramB = 0;
  281.       phaseParam = 0; logParam = 0; JMAValue = 0; series = 0; sValue = 0; sqrtParam = 0; lengthDivider = 0;
  282.       s58 = 0; s60 = 0; s40 = 0; s38 = 0; s68 = 0;
  283.       ArrayInitialize(ring2, 0);
  284.       ArrayInitialize(ring1, 0);
  285.       ArrayInitialize(buffer, 0);
  286.       limitValue = 63;
  287.       startValue = 64;
  288.       for(i = 0; i <= limitValue; i++)   list[i] = -1000000;
  289.       for(i = startValue; i <= 127; i++) list[i] = 1000000;
  290.       initFlag = true;
  291.       if(JMA_Length < 1.0000000002) lengthParam = 0.0000000001;
  292.       else                          lengthParam = (JMA_Length - 1) / 2.0;
  293.       if(JMA_Phase < -100)     phaseParam = 0.5;
  294.       else if(JMA_Phase > 100) phaseParam = 2.5;
  295.       else                     phaseParam = JMA_Phase / 100.0 + 1.5;
  296.       logParam = MathLog(MathSqrt(lengthParam)) / MathLog(2.0);
  297.       if(logParam + 2.0 < 0) logParam = 0;
  298.       else                   logParam = logParam + 2.0;
  299.       sqrtParam     = MathSqrt(lengthParam) * logParam;
  300.       lengthParam   = lengthParam * 0.9;
  301.       lengthDivider = lengthParam / (lengthParam + 2.0);
  302.       for(i = bars - BTX_period - 1; i >= 0; i--)
  303.         jma(RawBTXp, maBTXp, i);
  304.       ArrayInitialize(fC0Buffer, 0);
  305.       ArrayInitialize(fA8Buffer, 0);
  306.       ArrayInitialize(fC8Buffer, 0);
  307.       ArrayInitialize(list, 0);
  308.       initFlag = false;
  309.       limitValue = 0; startValue = 0; loopParam = 0; loopCriteria = 0;
  310.       cycleLimit = 0; highLimit = 0; counterA = 0; counterB = 0;
  311.       cycleDelta = 0; lowDValue = 0; highDValue = 0; absValue = 0; paramA = 0; paramB = 0;
  312.       phaseParam = 0; logParam = 0; JMAValue = 0; series = 0; sValue = 0; sqrtParam = 0; lengthDivider = 0;
  313.       s58 = 0; s60 = 0; s40 = 0; s38 = 0; s68 = 0;
  314.       ArrayInitialize(ring2, 0);
  315.       ArrayInitialize(ring1, 0);
  316.       ArrayInitialize(buffer, 0);
  317.       limitValue = 63;
  318.       startValue = 64;
  319.       for(i = 0; i <= limitValue; i++)   list[i] = -1000000;
  320.       for(i = startValue; i <= 127; i++) list[i] = 1000000;
  321.       initFlag = true;
  322.       if(JMA_Length < 1.0000000002) lengthParam = 0.0000000001;
  323.       else                          lengthParam = (JMA_Length - 1) / 2.0;
  324.       if(JMA_Phase < -100)     phaseParam = 0.5;
  325.       else if(JMA_Phase > 100) phaseParam = 2.5;
  326.       else                     phaseParam = JMA_Phase / 100.0 + 1.5;
  327.       logParam = MathLog(MathSqrt(lengthParam)) / MathLog(2.0);
  328.       if(logParam + 2.0 < 0) logParam = 0;
  329.       else                   logParam = logParam + 2.0;
  330.       sqrtParam     = MathSqrt(lengthParam) * logParam;
  331.       lengthParam   = lengthParam * 0.9;
  332.       lengthDivider = lengthParam / (lengthParam + 2.0);
  333.       for(i = bars - BTX_period - 1; i >= 0; i--)
  334.         jma(RawBTXn, maBTXn, i);
  335.       for(i = bars - BTX_period - 1 - JMA_Length; i >= 0; i--)
  336.         {
  337.         if(maBTXp[i] > maBTXn[i]) BTXbull[i] = BTX[i];
  338.         else if(maBTXn[i] > maBTXp[i]) BTXbear[i] = BTX[i];
  339.         }
  340.       }
  341.     }
  342.  
  343.   int limitx;
  344.   if(!Use_JMA_instead_TEMA) limitx = bars - BTX_period - 1 - 3*SmLen;
  345.   else                      limitx = bars - BTX_period - 1 - JMA_Length;
  346.   if(Show_SD)
  347.     for(i = limit; i >= 0; i--)
  348.       if(i < limitx - SD_len)
  349.         {
  350.         if(Show_SD_up) SD[i] = iBandsOnArray(BTX, 0, SD_len, SD_up, 0, MODE_UPPER, i);
  351.         if(Show_SD_dn) SD2[i] = iBandsOnArray(BTX, 0, SD_len, SD_dn, 0, MODE_LOWER, i);
  352.         if(Show_SD_md) SD3[i] = (iBandsOnArray(BTX, 0, SD_len, SD_up, 0, MODE_UPPER, i)+
  353.                                  iBandsOnArray(BTX, 0, SD_len, SD_dn, 0, MODE_LOWER, i)) / 2;
  354.         }
  355.  
  356.   return(0);
  357. }
  358.  
  359. double jma(double& input[], double& output[], int shift)
  360. {
  361.   series = input[shift];
  362.   if(loopParam < 61)
  363.     {
  364.     loopParam++;
  365.     buffer[loopParam] = series;
  366.     }
  367.   if(loopParam > 30)
  368.     {
  369.     if(initFlag)
  370.       {
  371.       initFlag = false;
  372.       int diffFlag = 0;
  373.       for(int i = 1; i <= 29; i++)
  374.         if(buffer[i + 1] != buffer[i]) diffFlag = 1;
  375.       highLimit = diffFlag * 30;
  376.       if(highLimit == 0) paramB = series;
  377.       else               paramB = buffer[1];
  378.       paramA = paramB;
  379.       if(highLimit > 29) highLimit = 29;
  380.       }
  381.     else
  382.       highLimit = 0;
  383.     for(i = highLimit; i >= 0; i--)
  384.       {
  385.       if(i == 0) sValue = series; else sValue = buffer [31 - i];
  386.       if(MathAbs(sValue - paramA) > MathAbs(sValue - paramB)) absValue = MathAbs(sValue - paramA); else absValue = MathAbs(sValue - paramB);
  387.       double dValue = absValue + 0.0000000001;
  388.       if(counterA <= 1) counterA = 127; else counterA--;
  389.       if(counterB <= 1) counterB = 10;  else counterB--;
  390.       if(cycleLimit < 128) cycleLimit++;
  391.       cycleDelta += (dValue - ring2[counterB]);
  392.       ring2[counterB] = dValue;
  393.       if(cycleLimit > 10) highDValue = cycleDelta / 10.0; else highDValue = cycleDelta / cycleLimit;
  394.       if(cycleLimit > 127)
  395.         {
  396.         dValue = ring1[counterA];
  397.         ring1[counterA] = highDValue;
  398.         s68 = 64; s58 = s68;
  399.         while(s68 > 1)
  400.           {
  401.           if(list[s58] < dValue)
  402.             {
  403.             s68 = s68 / 2.0;
  404.             s58 += s68;
  405.             }
  406.           else if(list[s58] == dValue)
  407.             s68 = 1;
  408.           else
  409.             {
  410.             s68 = s68 / 2.0;
  411.             s58 -= s68;
  412.             }
  413.           }
  414.         }
  415.       else
  416.         {
  417.         ring1[counterA] = highDValue;
  418.         if((limitValue + startValue) > 127)
  419.           {
  420.           startValue--;
  421.           s58 = startValue;
  422.           }
  423.         else
  424.           {
  425.           limitValue++;
  426.           s58 = limitValue;
  427.           }
  428.         if(limitValue > 96) s38 = 96; else s38 = limitValue;
  429.         if(startValue < 32) s40 = 32; else s40 = startValue;
  430.         }
  431.       s68 = 64;
  432.       s60 = s68;
  433.       while(s68 > 1)
  434.         {
  435.         if(list[s60] >= highDValue)
  436.           {
  437.           if(list[s60 - 1] <= highDValue)
  438.             s68 = 1;
  439.           else
  440.             {
  441.             s68 = s68 / 2.0;
  442.             s60 -= s68;
  443.             }
  444.           }
  445.         else
  446.           {
  447.           s68 = s68 / 2.0;
  448.           s60 += s68;
  449.           }
  450.         if((s60 == 127) && (highDValue > list[127])) s60 = 128;
  451.         }
  452.       if(cycleLimit > 127)
  453.         {
  454.         if(s58 >= s60)
  455.           {
  456.           if(((s38 + 1) > s60) && ((s40 - 1) < s60))
  457.             lowDValue += highDValue;
  458.           else if((s40 > s60) && ((s40 - 1) < s58))
  459.             lowDValue += list[s40 - 1];
  460.           }
  461.         else if(s40 >= s60)
  462.           {
  463.           if(((s38 + 1) < s60) && ((s38 + 1) > s58))
  464.             lowDValue += list[s38 + 1];
  465.           }
  466.         else if((s38 + 2) > s60)
  467.           lowDValue += highDValue;
  468.         else if(((s38 + 1) < s60) && ((s38 + 1) > s58))
  469.           lowDValue += list[s38 + 1];
  470.         if(s58 > s60)
  471.           {
  472.           if(((s40 - 1) < s58) && ((s38 + 1) > s58))
  473.             lowDValue -= list[s58];
  474.           else if((s38 < s58) && ((s38 + 1) > s60))
  475.             lowDValue -= list[s38];
  476.           }
  477.         else
  478.           {
  479.           if(((s38 + 1) > s58) && ((s40 - 1) < s58))
  480.             lowDValue -= list[s58];
  481.           else if((s40 > s58) && (s40 < s60))
  482.             lowDValue -= list[s40];
  483.           }
  484.         }
  485.       if(s58 <= s60)
  486.         {
  487.         if(s58 >= s60) list[s60] = highDValue;
  488.         else
  489.           {
  490.           for(int j = s58 + 1; j <= (s60 - 1); j++)
  491.             list[j - 1] = list[j];
  492.           list[s60 - 1] = highDValue;
  493.           }
  494.         }
  495.       else
  496.         {
  497.         for(j = s58 - 1; j >= s60; j--)
  498.           list[j + 1] = list[j];
  499.         list[s60] = highDValue;
  500.         }
  501.       if(cycleLimit <= 127)
  502.         {
  503.         lowDValue = 0;
  504.         for(j = s40; j <= s38; j++)
  505.           lowDValue += list[j];
  506.         }
  507.       if((loopCriteria + 1) > 31) loopCriteria = 31; else loopCriteria++;
  508.       double JMATempValue, sqrtDivider = sqrtParam / (sqrtParam + 1.0);
  509.       if(loopCriteria <= 30)
  510.         {
  511.         if(sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * sqrtDivider;
  512.         if(sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * sqrtDivider;
  513.         JMATempValue = series;
  514.         if(loopCriteria == 30)
  515.           {
  516.           fC0Buffer[shift] = series;
  517.           int intPart;
  518.           if(MathCeil(sqrtParam) >= 1) intPart = MathCeil(sqrtParam); else intPart = 1;
  519.           int leftInt = IntPortion(intPart);
  520.           if(MathFloor(sqrtParam) >= 1) intPart = MathFloor(sqrtParam); else intPart = 1;
  521.           int rightPart = IntPortion (intPart);
  522.           if(leftInt == rightPart) dValue = 1.0;
  523.           else                     dValue = (sqrtParam - rightPart) / (leftInt - rightPart);
  524.           if(rightPart <= 29) int upShift = rightPart; else upShift = 29;
  525.           if(leftInt <= 29) int dnShift = leftInt; else dnShift = 29;
  526.           fA8Buffer[shift] = (series - buffer[loopParam - upShift]) * (1 - dValue) / rightPart + (series - buffer[loopParam - dnShift]) * dValue / leftInt;
  527.           }
  528.         }
  529.       else
  530.         {
  531.         double powerValue, squareValue;
  532.         dValue = lowDValue / (s38 - s40 + 1);
  533.         if(0.5 <= logParam - 2.0) powerValue = logParam - 2.0;
  534.         else                      powerValue = 0.5;
  535.         if(logParam >= MathPow(absValue/dValue, powerValue)) dValue = MathPow(absValue/dValue, powerValue); else dValue = logParam;
  536.         if(dValue < 1) dValue = 1;
  537.         powerValue = MathPow(sqrtDivider, MathSqrt (dValue));
  538.         if(sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * powerValue;
  539.         if(sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * powerValue;
  540.         }
  541.       }
  542.     if(loopCriteria > 30)
  543.       {
  544.       JMATempValue = output[shift + 1];
  545.       powerValue   = MathPow(lengthDivider, dValue);
  546.       squareValue  = MathPow(powerValue, 2);
  547.       fC0Buffer[shift] = (1 - powerValue) * series + powerValue * fC0Buffer[shift + 1];
  548.       fC8Buffer[shift] = (series - fC0Buffer[shift]) * (1 - lengthDivider) + lengthDivider * fC8Buffer[shift + 1];
  549.       fA8Buffer[shift] = (phaseParam * fC8Buffer[shift] + fC0Buffer[shift] - JMATempValue) *
  550.                          (powerValue * (-2.0) + squareValue + 1) + squareValue * fA8Buffer[shift + 1];
  551.       JMATempValue += fA8Buffer[shift];
  552.       }
  553.     JMAValue = JMATempValue;
  554.     }
  555.   if(loopParam <= 30) JMAValue = 0;
  556.   output[shift] = JMAValue;
  557. }
  558.  
  559. int IntPortion(double param)
  560. {
  561.   if (param > 0) return (MathFloor (param));
  562.   if (param < 0) return (MathCeil (param));
  563.   return (0);
  564. }
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!