API tools faq
paste
Advertisement
Guest User

Ocn_BTX_2linex

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