API tools faq
paste
Advertisement
Guest User

Ocn_BTXx

a guest
May 1st, 2012
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.56 KB | None | 0 0
raw download clone embed print report
  1. // Ocn_BTXx version 1.0
  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 4
  7. #property indicator_color1 Magenta
  8. #property indicator_color2 Silver
  9. #property indicator_color3 Silver
  10. #property indicator_color4 Silver
  11. #property indicator_level1 35
  12. #property indicator_levelcolor Gray
  13. #property indicator_levelstyle 2
  14. #property indicator_minimum 0
  15. #property indicator_maximum 100
  16.  
  17. extern int    BTX_period           = 40;
  18. extern int    SmLen                = 20;
  19. extern bool   Use_JMA_instead_TEMA = false;
  20. extern double JMA_Length           = 10;
  21. extern int    JMA_Phase            = 50;
  22. extern int    MaxBars              = 0;
  23. extern bool   Show_SD              = true;
  24. extern int    SD_len               = 20;
  25. extern double SD_up                = 1.5;
  26. extern double SD_dn                = 1.5;
  27. extern bool   Show_SD_up           = true;
  28. extern bool   Show_SD_dn           = true;
  29. extern bool   Show_SD_md           = true;
  30.  
  31. double BTX[];
  32. double SD[];
  33. double SD2[];
  34. double SD3[];
  35. double RawBTX[];
  36. double maBTX[];
  37.  
  38. double fC0Buffer[];
  39. double fA8Buffer[];
  40. double fC8Buffer[];
  41. double list[128], ring1[128], ring2[11], buffer[62];
  42. bool   initFlag;
  43. int    limitValue, startValue, loopParam, loopCriteria;
  44. int    cycleLimit, highLimit, counterA, counterB;
  45. double cycleDelta, lowDValue, highDValue, absValue, paramA, paramB;
  46. double phaseParam, logParam, JMAValue, series, sValue, sqrtParam, lengthDivider;
  47. int    s58, s60, s40, s38, s68;
  48.  
  49. bool   initialized;
  50. #import "OBP1Lock32x.dll"
  51.   bool LTInitializeFromInix(string);
  52.   double LTCalcValx(string, double, double, double, double, string);
  53. #define dll "OBP1Lock32.dll"
  54. #import
  55. double arr6[99], arr7[99], arr8[99], arr9[99], arr10[99], arr11[99];
  56.  
  57. int init()
  58. {
  59.   initialized = LTInitializeFromInix(dll);
  60.   if(!initialized) return(0);
  61.  
  62.   if(SmLen < 1) SmLen = 1;
  63.   if(BTX_period > 98) BTX_period = 98;
  64.   string btxname = "BTX(" + BTX_period + ", " + SmLen + ")";
  65.   if(Use_JMA_instead_TEMA) btxname = "BTX_JMA(" + BTX_period + ", " + JMA_Length + ", " + JMA_Phase + ")";
  66.   IndicatorShortName(btxname);
  67.   IndicatorDigits(2);
  68.   IndicatorBuffers(6);
  69.   SetIndexBuffer(0, BTX);
  70.   SetIndexLabel(0, btxname);
  71.   SetIndexBuffer(1, SD);
  72.   SetIndexBuffer(2, SD2);
  73.   SetIndexBuffer(3, SD3);
  74.   if(Show_SD_up) SetIndexLabel(1, "BTX_SD_up(" + SD_len + ")");
  75.   else           SetIndexLabel(1, "unused");
  76.   if(Show_SD_dn) SetIndexLabel(2, "BTX_SD_dn(" + SD_len + ")");
  77.   else           SetIndexLabel(2, "unused");
  78.   if(Show_SD_md) SetIndexLabel(3, "BTX_SD_md(" + SD_len + ")");
  79.   else           SetIndexLabel(3, "unused");
  80.   SetIndexBuffer(4, RawBTX);
  81.   SetIndexBuffer(5, maBTX);
  82.   ArraySetAsSeries(arr6, true); ArraySetAsSeries(arr7, true); ArraySetAsSeries(arr8, true);
  83.   ArraySetAsSeries(arr9, true); ArraySetAsSeries(arr10, true); ArraySetAsSeries(arr11, true);
  84.   return(0);
  85. }
  86.  
  87. int start()
  88. {
  89.   if(!initialized) return(0);
  90.  
  91.   int limit, i, ii, counted_bars = IndicatorCounted()-1, bars;
  92.  
  93.   if(MaxBars > 0) { bars = MaxBars; if(counted_bars > bars) counted_bars = bars - 2; } else bars = Bars;
  94.   if(Use_JMA_instead_TEMA) { if(bars <= BTX_period + JMA_Length) return(0); }
  95.   else                     { if(bars <= BTX_period + 3*SmLen) return(0); }
  96.   if(counted_bars < 0) counted_bars = 0;
  97.   if(counted_bars > BTX_period) limit = bars - counted_bars;
  98.   else                          limit = bars - BTX_period - 1;
  99.  
  100.   for(i = limit; i >= 0; i--)
  101.     {
  102.     double var2 = 0, var3 = 0;
  103.     ArrayInitialize(arr6, 0); ArrayInitialize(arr7, 0); ArrayInitialize(arr8, 0);
  104.     ArrayInitialize(arr9, 0); ArrayInitialize(arr10, 0); ArrayInitialize(arr11, 0);
  105.     arr6[0] = LTCalcValx(dll, Close[i], 0.5, High[i], Low[i], "eBBcmGJhfe");
  106.     for(ii = 1; ii <= BTX_period; ii++)
  107.       {
  108.       arr6[ii] = LTCalcValx(dll, Close[i+ii], Close[i+ii-1], 0.5, Close[i], "FpmqUGJh");
  109.       arr7[ii] = LTCalcValx(dll, arr6[ii-1], arr6[ii], Close[i], 0.5, "rmEsGMDfF");
  110.       arr8[ii] = LTCalcValx(dll, arr8[ii-1], (arr7[ii]), arr8[ii], arr7[ii-1], "smUDecGMJYh");
  111.       if(arr8[ii] == 0) arr9[ii] = 0;
  112.       else              arr9[ii] = LTCalcValx(dll, arr6[0], arr6[ii], arr8[ii], arr7[ii], "rUGMecDJYBBXU");
  113.       arr10[ii] = 1 / LTCalcValx(dll, 0.5, ii, arr9[ii], -MathAbs(arr9[ii-1]), "UhWGceMBBJn");
  114.       arr11[ii] = LTCalcValx(dll, arr9[ii], arr10[ii], arr9[ii-1], arr8[ii], "F3ecmGBBMqec");
  115.       var2 = LTCalcValx(dll, var2, arr11[ii], arr11[ii], var2, "ceGMhftTds");
  116.       var3 = LTCalcValx(dll, var3, arr10[ii], var2, var3, "jTGceMBBh");
  117.       }
  118.     RawBTX[i] = LTCalcValx(dll, var2, var3, 100, 0.5, "mUDF0AA8GMUXBBq");
  119.     }
  120.  
  121.   if(!Use_JMA_instead_TEMA)
  122.     {
  123.     double ExpSmooth = 2, XAvg1, XAvg2, XAvg3;
  124.     ExpSmooth = ExpSmooth / (SmLen + 1);
  125.     for(i = bars - BTX_period - 1; i >= 0; i--)
  126.       {
  127.       XAvg1 += ExpSmooth * (RawBTX[i] - XAvg1);
  128.       XAvg2 += ExpSmooth * (XAvg1 - XAvg2);
  129.       XAvg3 += ExpSmooth * (XAvg2 - XAvg3);
  130.       maBTX[i] = 3 * XAvg1 - 3 * XAvg2 + XAvg3;
  131.       if(i < bars - BTX_period - 1 - 3*SmLen)
  132.         BTX[i] = NormalizeDouble(maBTX[i], 2);
  133.       }
  134.     }
  135.   else
  136.     {
  137.     ArrayResize(fC0Buffer, bars - BTX_period); ArraySetAsSeries(fC0Buffer, true); ArrayInitialize(fC0Buffer, 0);
  138.     ArrayResize(fA8Buffer, bars - BTX_period); ArraySetAsSeries(fA8Buffer, true); ArrayInitialize(fA8Buffer, 0);
  139.     ArrayResize(fC8Buffer, bars - BTX_period); ArraySetAsSeries(fC8Buffer, true); ArrayInitialize(fC8Buffer, 0);
  140.     ArrayInitialize(list, 0);
  141.     initFlag = false;
  142.     limitValue = 0; startValue = 0; loopParam = 0; loopCriteria = 0;
  143.     cycleLimit = 0; highLimit = 0; counterA = 0; counterB = 0;
  144.     cycleDelta = 0; lowDValue = 0; highDValue = 0; absValue = 0; paramA = 0; paramB = 0;
  145.     phaseParam = 0; logParam = 0; JMAValue = 0; series = 0; sValue = 0; sqrtParam = 0; lengthDivider = 0;
  146.     s58 = 0; s60 = 0; s40 = 0; s38 = 0; s68 = 0;
  147.     ArrayInitialize(ring2, 0);
  148.     ArrayInitialize(ring1, 0);
  149.     ArrayInitialize(buffer, 0);
  150.     double lengthParam;
  151.     limitValue = 63;
  152.     startValue = 64;
  153.     for(i = 0; i <= limitValue; i++)   list[i] = -1000000;
  154.     for(i = startValue; i <= 127; i++) list[i] = 1000000;
  155.     initFlag = true;
  156.     if(JMA_Length < 1.0000000002) lengthParam = 0.0000000001;
  157.     else                          lengthParam = (JMA_Length - 1) / 2.0;
  158.     if(JMA_Phase < -100)     phaseParam = 0.5;
  159.     else if(JMA_Phase > 100) phaseParam = 2.5;
  160.     else                     phaseParam = JMA_Phase / 100.0 + 1.5;
  161.     logParam = MathLog(MathSqrt(lengthParam)) / MathLog(2.0);
  162.     if(logParam + 2.0 < 0) logParam = 0;
  163.     else                   logParam = logParam + 2.0;
  164.     sqrtParam     = MathSqrt(lengthParam) * logParam;
  165.     lengthParam   = lengthParam * 0.9;
  166.     lengthDivider = lengthParam / (lengthParam + 2.0);
  167.     for(i = bars - BTX_period - 1; i >= 0; i--)
  168.       {
  169.       jma(RawBTX, maBTX, i);
  170.       if(i < bars - BTX_period - 1 - JMA_Length)
  171.         BTX[i] = NormalizeDouble(maBTX[i], 2);
  172.       }
  173.     }
  174.  
  175.   int limitx;
  176.   if(!Use_JMA_instead_TEMA) limitx = bars - BTX_period - 1 - 3*SmLen;
  177.   else                      limitx = bars - BTX_period - 1 - JMA_Length;
  178.   if(Show_SD)
  179.     for(i = limit; i >= 0; i--)
  180.       if(i < limitx - SD_len)
  181.         {
  182.         if(Show_SD_up) SD[i] = iBandsOnArray(BTX, 0, SD_len, SD_up, 0, MODE_UPPER, i);
  183.         if(Show_SD_dn) SD2[i] = iBandsOnArray(BTX, 0, SD_len, SD_dn, 0, MODE_LOWER, i);
  184.         if(Show_SD_md) SD3[i] = (iBandsOnArray(BTX, 0, SD_len, SD_up, 0, MODE_UPPER, i)+
  185.                                  iBandsOnArray(BTX, 0, SD_len, SD_dn, 0, MODE_LOWER, i)) / 2;
  186.         }
  187.  
  188.   return(0);
  189. }
  190.  
  191. double jma(double& input[], double& output[], int shift)
  192. {
  193.   series = input[shift];
  194.   if(loopParam < 61)
  195.     {
  196.     loopParam++;
  197.     buffer[loopParam] = series;
  198.     }
  199.   if(loopParam > 30)
  200.     {
  201.     if(initFlag)
  202.       {
  203.       initFlag = false;
  204.       int diffFlag = 0;
  205.       for(int i = 1; i <= 29; i++)
  206.         if(buffer[i + 1] != buffer[i]) diffFlag = 1;
  207.       highLimit = diffFlag * 30;
  208.       if(highLimit == 0) paramB = series;
  209.       else               paramB = buffer[1];
  210.       paramA = paramB;
  211.       if(highLimit > 29) highLimit = 29;
  212.       }
  213.     else
  214.       highLimit = 0;
  215.     for(i = highLimit; i >= 0; i--)
  216.       {
  217.       if(i == 0) sValue = series; else sValue = buffer [31 - i];
  218.       if(MathAbs(sValue - paramA) > MathAbs(sValue - paramB)) absValue = MathAbs(sValue - paramA); else absValue = MathAbs(sValue - paramB);
  219.       double dValue = absValue + 0.0000000001;
  220.       if(counterA <= 1) counterA = 127; else counterA--;
  221.       if(counterB <= 1) counterB = 10;  else counterB--;
  222.       if(cycleLimit < 128) cycleLimit++;
  223.       cycleDelta += (dValue - ring2[counterB]);
  224.       ring2[counterB] = dValue;
  225.       if(cycleLimit > 10) highDValue = cycleDelta / 10.0; else highDValue = cycleDelta / cycleLimit;
  226.       if(cycleLimit > 127)
  227.         {
  228.         dValue = ring1[counterA];
  229.         ring1[counterA] = highDValue;
  230.         s68 = 64; s58 = s68;
  231.         while(s68 > 1)
  232.           {
  233.           if(list[s58] < dValue)
  234.             {
  235.             s68 = s68 / 2.0;
  236.             s58 += s68;
  237.             }
  238.           else if(list[s58] == dValue)
  239.             s68 = 1;
  240.           else
  241.             {
  242.             s68 = s68 / 2.0;
  243.             s58 -= s68;
  244.             }
  245.           }
  246.         }
  247.       else
  248.         {
  249.         ring1[counterA] = highDValue;
  250.         if((limitValue + startValue) > 127)
  251.           {
  252.           startValue--;
  253.           s58 = startValue;
  254.           }
  255.         else
  256.           {
  257.           limitValue++;
  258.           s58 = limitValue;
  259.           }
  260.         if(limitValue > 96) s38 = 96; else s38 = limitValue;
  261.         if(startValue < 32) s40 = 32; else s40 = startValue;
  262.         }
  263.       s68 = 64;
  264.       s60 = s68;
  265.       while(s68 > 1)
  266.         {
  267.         if(list[s60] >= highDValue)
  268.           {
  269.           if(list[s60 - 1] <= highDValue)
  270.             s68 = 1;
  271.           else
  272.             {
  273.             s68 = s68 / 2.0;
  274.             s60 -= s68;
  275.             }
  276.           }
  277.         else
  278.           {
  279.           s68 = s68 / 2.0;
  280.           s60 += s68;
  281.           }
  282.         if((s60 == 127) && (highDValue > list[127])) s60 = 128;
  283.         }
  284.       if(cycleLimit > 127)
  285.         {
  286.         if(s58 >= s60)
  287.           {
  288.           if(((s38 + 1) > s60) && ((s40 - 1) < s60))
  289.             lowDValue += highDValue;
  290.           else if((s40 > s60) && ((s40 - 1) < s58))
  291.             lowDValue += list[s40 - 1];
  292.           }
  293.         else if(s40 >= s60)
  294.           {
  295.           if(((s38 + 1) < s60) && ((s38 + 1) > s58))
  296.             lowDValue += list[s38 + 1];
  297.           }
  298.         else if((s38 + 2) > s60)
  299.           lowDValue += highDValue;
  300.         else if(((s38 + 1) < s60) && ((s38 + 1) > s58))
  301.           lowDValue += list[s38 + 1];
  302.         if(s58 > s60)
  303.           {
  304.           if(((s40 - 1) < s58) && ((s38 + 1) > s58))
  305.             lowDValue -= list[s58];
  306.           else if((s38 < s58) && ((s38 + 1) > s60))
  307.             lowDValue -= list[s38];
  308.           }
  309.         else
  310.           {
  311.           if(((s38 + 1) > s58) && ((s40 - 1) < s58))
  312.             lowDValue -= list[s58];
  313.           else if((s40 > s58) && (s40 < s60))
  314.             lowDValue -= list[s40];
  315.           }
  316.         }
  317.       if(s58 <= s60)
  318.         {
  319.         if(s58 >= s60) list[s60] = highDValue;
  320.         else
  321.           {
  322.           for(int j = s58 + 1; j <= (s60 - 1); j++)
  323.             list[j - 1] = list[j];
  324.           list[s60 - 1] = highDValue;
  325.           }
  326.         }
  327.       else
  328.         {
  329.         for(j = s58 - 1; j >= s60; j--)
  330.           list[j + 1] = list[j];
  331.         list[s60] = highDValue;
  332.         }
  333.       if(cycleLimit <= 127)
  334.         {
  335.         lowDValue = 0;
  336.         for(j = s40; j <= s38; j++)
  337.           lowDValue += list[j];
  338.         }
  339.       if((loopCriteria + 1) > 31) loopCriteria = 31; else loopCriteria++;
  340.       double JMATempValue, sqrtDivider = sqrtParam / (sqrtParam + 1.0);
  341.       if(loopCriteria <= 30)
  342.         {
  343.         if(sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * sqrtDivider;
  344.         if(sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * sqrtDivider;
  345.         JMATempValue = series;
  346.         if(loopCriteria == 30)
  347.           {
  348.           fC0Buffer[shift] = series;
  349.           int intPart;
  350.           if(MathCeil(sqrtParam) >= 1) intPart = MathCeil(sqrtParam); else intPart = 1;
  351.           int leftInt = IntPortion(intPart);
  352.           if(MathFloor(sqrtParam) >= 1) intPart = MathFloor(sqrtParam); else intPart = 1;
  353.           int rightPart = IntPortion (intPart);
  354.           if(leftInt == rightPart) dValue = 1.0;
  355.           else                     dValue = (sqrtParam - rightPart) / (leftInt - rightPart);
  356.           if(rightPart <= 29) int upShift = rightPart; else upShift = 29;
  357.           if(leftInt <= 29) int dnShift = leftInt; else dnShift = 29;
  358.           fA8Buffer[shift] = (series - buffer[loopParam - upShift]) * (1 - dValue) / rightPart + (series - buffer[loopParam - dnShift]) * dValue / leftInt;
  359.           }
  360.         }
  361.       else
  362.         {
  363.         double powerValue, squareValue;
  364.         dValue = lowDValue / (s38 - s40 + 1);
  365.         if(0.5 <= logParam - 2.0) powerValue = logParam - 2.0;
  366.         else                      powerValue = 0.5;
  367.         if(logParam >= MathPow(absValue/dValue, powerValue)) dValue = MathPow(absValue/dValue, powerValue); else dValue = logParam;
  368.         if(dValue < 1) dValue = 1;
  369.         powerValue = MathPow(sqrtDivider, MathSqrt (dValue));
  370.         if(sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * powerValue;
  371.         if(sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * powerValue;
  372.         }
  373.       }
  374.     if(loopCriteria > 30)
  375.       {
  376.       JMATempValue = output[shift + 1];
  377.       powerValue   = MathPow(lengthDivider, dValue);
  378.       squareValue  = MathPow(powerValue, 2);
  379.       fC0Buffer[shift] = (1 - powerValue) * series + powerValue * fC0Buffer[shift + 1];
  380.       fC8Buffer[shift] = (series - fC0Buffer[shift]) * (1 - lengthDivider) + lengthDivider * fC8Buffer[shift + 1];
  381.       fA8Buffer[shift] = (phaseParam * fC8Buffer[shift] + fC0Buffer[shift] - JMATempValue) *
  382.                          (powerValue * (-2.0) + squareValue + 1) + squareValue * fA8Buffer[shift + 1];
  383.       JMATempValue += fA8Buffer[shift];
  384.       }
  385.     JMAValue = JMATempValue;
  386.     }
  387.   if(loopParam <= 30) JMAValue = 0;
  388.   output[shift] = JMAValue;
  389. }
  390.  
  391. int IntPortion(double param)
  392. {
  393.   if (param > 0) return (MathFloor (param));
  394.   if (param < 0) return (MathCeil (param));
  395.   return (0);
  396. }
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!