Ocean Theory indis from TSD elite

The JMA code I could find here and on TSD repaint in the sense that real time JMA is very different from historical JMA. Just let JMA run on a 1M chart for a few minutes and then open another 1M chart and add same period JMA and you will see what I mean. Did I rediscover the obvious, or am I missing something? I looked at JMA_SL (StarLight) from TSD and saw some code that seemed like it was trying to preserve some variables across ticks, but even that does repaint.

Anyone cares to set me straight? Or point me to the the RT version, pls?

@udc, I noticed you were recalculating JMA across all bars on every tick in your JMA function, is that to take care of this situation?

Any help is appreciated. I am trying to port these to esignal and that is where I ran into this and was wondering if this is a bug or a feature!

josephR

udc,

how did the tsd-guys solve the dll problem of the BTX/STX indicators ?

Sixer

@udc, I noticed you were recalculating JMA across all bars on every tick in your JMA function, is that to take care of this situation?

Yes. The code, as was written for MT4 by someone else (and I don't know how close or far it is from the original Jurik's software), does use some variables which are initialized only once at the very beginning and then they are just modified as the calculations progress. I didn't examine the logic much but at the first glance it seemed to me like it was calculating some error and as more bars are calculated the error is lesser and lesser. But that's just my wild guess and the reality may be totally different. Now the problem with Metatrader is that the last two bars are recalculated at every tick. Thus if my assumption was correct then this whole error calculation would get logically broken because for the same bar the error (and thus the resulting indicator value) would be different every time. That's why I simply reset all those values and calculate everything from the beginning at every new tick, that way it can't end up with different values. I know it's lame but I wanted to get it done fast and move forward.

udc,

 

how did the tsd-guys solve the dll problem of the BTX/STX indicators ?

 

Sixer

They didn't, there is no BTX/STX on Metatrader to my knowledge. Even more reason to want it :)

Yes. The code, as was written for MT4 by someone else (and I don't know how close or far it is from the original Jurik's software), does use some variables which are initialized only once at the very beginning and then they are just modified as the calculations progress. I didn't examine the logic much but at the first glance it seemed to me like it was calculating some error and as more bars are calculated the error is lesser and lesser. But that's just my wild guess and the reality may be totally different. Now the problem with Metatrader is that the last two bars are recalculated at every tick. Thus if my assumption was correct then this whole error calculation would get logically broken because for the same bar the error (and thus the resulting indicator value) would be different every time. That's why I simply reset all those values and calculate everything from the beginning at every new tick, that way it can't end up with different values. I know it's lame but I wanted to get it done fast and move forward.

I think you are onto something! It treats tick values as a stream of data (series) so it does not have any notion of whether that tick is in the middle of the bar or at the close. Obviously this is very different with historical series which is just the bar closes and missing all the interim ticks.

[[The more confusing bit is that the same logic, once used with the RSX series in the "JMA of RSX" seems to produce results the are very consistent in rt vs historical!! RSX values certainly change within each bar just as closes do in each tick, yet results are consistent both in MT4 and eSignal. There is got to be an easy explanation but it is evading me now! ]] Update: it does do as JMA albeit harder to see!

BTW, thank you so much for the this fantastic volume of work you have produced and generously shared.

You are an inspiration to us all.

Keep up the great work,

josephR

Great !! There are quite a few here -- http://mir.cr/0SZQTGQ3

 

Appreciate if you could go through the logic of a few and place the best one out.

 

thanks for your efforts UDC...

 

You provide commercial solutions too? Maybe you could also point out a few indicators of yours which are promising and not too expensive ;)

Hi UDC,

Were you able to do something about plotting the divergence on indicator and price. Appreciate if you could make it. Thanks

BTX for MT4

Behold the magnificent BTX on Metatrader :)

And since we have the luxury of JMA which is faster and smoother with less overshooting, you can of course choose JMA instead of the default TEMA.

Original BTX on TradeStation:

http://img688.imageshack.us/img688/4426/btxtradestation.png

Ocn_BTXx on Metatrader:

http://img841.imageshack.us/img841/3442/btxmetatrader.png

Original size screenshots:

http://img338.imageshack.us/img338/4426/btxtradestation.png

http://img85.imageshack.us/img85/3442/btxmetatrader.png

// Ocn_BTXx version 1.0
#property  copyright "© jim sloman, jma © mark jurik, for metatrader reprogrammed by udc"
#property  link      "[email protected]"

#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1 Magenta
#property indicator_color2 Silver
#property indicator_color3 Silver
#property indicator_color4 Silver
#property indicator_level1 35
#property indicator_levelcolor Gray
#property indicator_levelstyle 2
#property indicator_minimum 0
#property indicator_maximum 100

extern int    BTX_period           = 40;
extern int    SmLen                = 20;
extern bool   Use_JMA_instead_TEMA = false;
extern double JMA_Length           = 10;
extern int    JMA_Phase            = 50;
extern int    MaxBars              = 0;
extern bool   Show_SD              = true;
extern int    SD_len               = 20;
extern double SD_up                = 1.5;
extern double SD_dn                = 1.5;
extern bool   Show_SD_up           = true;
extern bool   Show_SD_dn           = true;
extern bool   Show_SD_md           = true;

double BTX[];
double SD[];
double SD2[];
double SD3[];
double RawBTX[];
double maBTX[];

double fC0Buffer[];
double fA8Buffer[];
double fC8Buffer[];
double list[128], ring1[128], ring2[11], buffer[62];
bool   initFlag;
int    limitValue, startValue, loopParam, loopCriteria;
int    cycleLimit, highLimit, counterA, counterB;
double cycleDelta, lowDValue, highDValue, absValue, paramA, paramB;
double phaseParam, logParam, JMAValue, series, sValue, sqrtParam, lengthDivider;
int    s58, s60, s40, s38, s68;

bool   initialized;
#import "OBP1Lock32x.dll"
 bool LTInitializeFromInix(string);
 double LTCalcValx(string, double, double, double, double, string);
#define dll "OBP1Lock32.dll"
#import
double arr6[99], arr7[99], arr8[99], arr9[99], arr10[99], arr11[99];

int init()
{
 initialized = LTInitializeFromInix(dll);
 if(!initialized) return(0);

 if(SmLen < 1) SmLen = 1;
 if(BTX_period > 98) BTX_period = 98;
 string btxname = "BTX(" + BTX_period + ", " + SmLen + ")";
 if(Use_JMA_instead_TEMA) btxname = "BTX_JMA(" + BTX_period + ", " + JMA_Length + ", " + JMA_Phase + ")";
 IndicatorShortName(btxname);
 IndicatorDigits(2);
 IndicatorBuffers(6);
 SetIndexBuffer(0, BTX);
 SetIndexLabel(0, btxname);
 SetIndexBuffer(1, SD);
 SetIndexBuffer(2, SD2);
 SetIndexBuffer(3, SD3);
 if(Show_SD_up) SetIndexLabel(1, "BTX_SD_up(" + SD_len + ")");
 else           SetIndexLabel(1, "unused");
 if(Show_SD_dn) SetIndexLabel(2, "BTX_SD_dn(" + SD_len + ")");
 else           SetIndexLabel(2, "unused");
 if(Show_SD_md) SetIndexLabel(3, "BTX_SD_md(" + SD_len + ")");
 else           SetIndexLabel(3, "unused");
 SetIndexBuffer(4, RawBTX);
 SetIndexBuffer(5, maBTX);
 ArraySetAsSeries(arr6, true); ArraySetAsSeries(arr7, true); ArraySetAsSeries(arr8, true);
 ArraySetAsSeries(arr9, true); ArraySetAsSeries(arr10, true); ArraySetAsSeries(arr11, true);
 return(0);
}

int start()
{
 if(!initialized) return(0);

 int limit, i, ii, counted_bars = IndicatorCounted()-1, bars;

 if(MaxBars > 0) { bars = MaxBars; if(counted_bars > bars) counted_bars = bars - 2; } else bars = Bars;
 if(Use_JMA_instead_TEMA) { if(bars <= BTX_period + JMA_Length) return(0); }
 else                     { if(bars <= BTX_period + 3*SmLen) return(0); }
 if(counted_bars < 0) counted_bars = 0;
 if(counted_bars > BTX_period) limit = bars - counted_bars;
 else                          limit = bars - BTX_period - 1;

 for(i = limit; i >= 0; i--)
   {
   double var2 = 0, var3 = 0;
   ArrayInitialize(arr6, 0); ArrayInitialize(arr7, 0); ArrayInitialize(arr8, 0);
   ArrayInitialize(arr9, 0); ArrayInitialize(arr10, 0); ArrayInitialize(arr11, 0);
   arr6[0] = LTCalcValx(dll, Close[i], 0.5, High[i], Low[i], "eBBcmGJhfe");
   for(ii = 1; ii <= BTX_period; ii++)
     {
     arr6[ii] = LTCalcValx(dll, Close[i+ii], Close[i+ii-1], 0.5, Close[i], "FpmqUGJh");
     arr7[ii] = LTCalcValx(dll, arr6[ii-1], arr6[ii], Close[i], 0.5, "rmEsGMDfF");
     arr8[ii] = LTCalcValx(dll, arr8[ii-1], (arr7[ii]), arr8[ii], arr7[ii-1], "smUDecGMJYh");
     if(arr8[ii] == 0) arr9[ii] = 0;
     else              arr9[ii] = LTCalcValx(dll, arr6[0], arr6[ii], arr8[ii], arr7[ii], "rUGMecDJYBBXU");
     arr10[ii] = 1 / LTCalcValx(dll, 0.5, ii, arr9[ii], -MathAbs(arr9[ii-1]), "UhWGceMBBJn");
     arr11[ii] = LTCalcValx(dll, arr9[ii], arr10[ii], arr9[ii-1], arr8[ii], "F3ecmGBBMqec");
     var2 = LTCalcValx(dll, var2, arr11[ii], arr11[ii], var2, "ceGMhftTds");
     var3 = LTCalcValx(dll, var3, arr10[ii], var2, var3, "jTGceMBBh");
     }
   RawBTX[i] = LTCalcValx(dll, var2, var3, 100, 0.5, "mUDF0AA8GMUXBBq");
   }

 if(!Use_JMA_instead_TEMA)
   {
   double ExpSmooth = 2, XAvg1, XAvg2, XAvg3;
   ExpSmooth = ExpSmooth / (SmLen + 1);
   for(i = bars - BTX_period - 1; i >= 0; i--)
     {
     XAvg1 += ExpSmooth * (RawBTX[i] - XAvg1);
     XAvg2 += ExpSmooth * (XAvg1 - XAvg2);
     XAvg3 += ExpSmooth * (XAvg2 - XAvg3);
     maBTX[i] = 3 * XAvg1 - 3 * XAvg2 + XAvg3;
     if(i < bars - BTX_period - 1 - 3*SmLen)
       BTX[i] = NormalizeDouble(maBTX[i], 2);
     }
   }
 else
   {
   ArrayResize(fC0Buffer, bars - BTX_period); ArraySetAsSeries(fC0Buffer, true); ArrayInitialize(fC0Buffer, 0);
   ArrayResize(fA8Buffer, bars - BTX_period); ArraySetAsSeries(fA8Buffer, true); ArrayInitialize(fA8Buffer, 0);
   ArrayResize(fC8Buffer, bars - BTX_period); ArraySetAsSeries(fC8Buffer, true); ArrayInitialize(fC8Buffer, 0);
   ArrayInitialize(list, 0);
   initFlag = false;
   limitValue = 0; startValue = 0; loopParam = 0; loopCriteria = 0;
   cycleLimit = 0; highLimit = 0; counterA = 0; counterB = 0;
   cycleDelta = 0; lowDValue = 0; highDValue = 0; absValue = 0; paramA = 0; paramB = 0;
   phaseParam = 0; logParam = 0; JMAValue = 0; series = 0; sValue = 0; sqrtParam = 0; lengthDivider = 0;
   s58 = 0; s60 = 0; s40 = 0; s38 = 0; s68 = 0;
   ArrayInitialize(ring2, 0);
   ArrayInitialize(ring1, 0);
   ArrayInitialize(buffer, 0);
   double lengthParam;
   limitValue = 63;
   startValue = 64;
   for(i = 0; i <= limitValue; i++)   list[i] = -1000000;
   for(i = startValue; i <= 127; i++) list[i] = 1000000;
   initFlag = true;
   if(JMA_Length < 1.0000000002) lengthParam = 0.0000000001;
   else                          lengthParam = (JMA_Length - 1) / 2.0;
   if(JMA_Phase < -100)     phaseParam = 0.5;
   else if(JMA_Phase > 100) phaseParam = 2.5;
   else                     phaseParam = JMA_Phase / 100.0 + 1.5;
   logParam = MathLog(MathSqrt(lengthParam)) / MathLog(2.0);
   if(logParam + 2.0 < 0) logParam = 0;
   else                   logParam = logParam + 2.0;
   sqrtParam     = MathSqrt(lengthParam) * logParam;
   lengthParam   = lengthParam * 0.9;
   lengthDivider = lengthParam / (lengthParam + 2.0);
   for(i = bars - BTX_period - 1; i >= 0; i--)
     {
     jma(RawBTX, maBTX, i);
     if(i < bars - BTX_period - 1 - JMA_Length)
       BTX[i] = NormalizeDouble(maBTX[i], 2);
     }
   }

 int limitx;
 if(!Use_JMA_instead_TEMA) limitx = bars - BTX_period - 1 - 3*SmLen;
 else                      limitx = bars - BTX_period - 1 - JMA_Length;
 if(Show_SD)
   for(i = limit; i >= 0; i--)
     if(i < limitx - SD_len)
       {
       if(Show_SD_up) SD[i] = iBandsOnArray(BTX, 0, SD_len, SD_up, 0, MODE_UPPER, i);
       if(Show_SD_dn) SD2[i] = iBandsOnArray(BTX, 0, SD_len, SD_dn, 0, MODE_LOWER, i);
       if(Show_SD_md) SD3[i] = (iBandsOnArray(BTX, 0, SD_len, SD_up, 0, MODE_UPPER, i)+
                                iBandsOnArray(BTX, 0, SD_len, SD_dn, 0, MODE_LOWER, i)) / 2;
       }

 return(0);
}

double jma(double& input[], double& output[], int shift)
{
 series = input[shift];
 if(loopParam < 61)
   {
   loopParam++;
   buffer[loopParam] = series;
   }
 if(loopParam > 30)
   {
   if(initFlag)
     {
     initFlag = false;
     int diffFlag = 0;
     for(int i = 1; i <= 29; i++)
       if(buffer[i + 1] != buffer[i]) diffFlag = 1;
     highLimit = diffFlag * 30;
     if(highLimit == 0) paramB = series;
     else               paramB = buffer[1];
     paramA = paramB;
     if(highLimit > 29) highLimit = 29;
     }
   else
     highLimit = 0;
   for(i = highLimit; i >= 0; i--)
     {
     if(i == 0) sValue = series; else sValue = buffer [31 - i];
     if(MathAbs(sValue - paramA) > MathAbs(sValue - paramB)) absValue = MathAbs(sValue - paramA); else absValue = MathAbs(sValue - paramB);
     double dValue = absValue + 0.0000000001;
     if(counterA <= 1) counterA = 127; else counterA--;
     if(counterB <= 1) counterB = 10;  else counterB--;
     if(cycleLimit < 128) cycleLimit++;
     cycleDelta += (dValue - ring2[counterB]);
     ring2[counterB] = dValue;
     if(cycleLimit > 10) highDValue = cycleDelta / 10.0; else highDValue = cycleDelta / cycleLimit;
     if(cycleLimit > 127)
       {
       dValue = ring1[counterA];
       ring1[counterA] = highDValue;
       s68 = 64; s58 = s68;
       while(s68 > 1)
         {
         if(list[s58] < dValue)
           {
           s68 = s68 / 2.0;
           s58 += s68;
           }
         else if(list[s58] == dValue)
           s68 = 1;
         else
           {
           s68 = s68 / 2.0;
           s58 -= s68;
           }
         }
       }
     else
       {
       ring1[counterA] = highDValue;
       if((limitValue + startValue) > 127)
         {
         startValue--;
         s58 = startValue;
         }
       else
         {
         limitValue++;
         s58 = limitValue;
         }
       if(limitValue > 96) s38 = 96; else s38 = limitValue;
       if(startValue < 32) s40 = 32; else s40 = startValue;
       }
     s68 = 64;
     s60 = s68;
     while(s68 > 1)
       {
       if(list[s60] >= highDValue)
         {
         if(list[s60 - 1] <= highDValue)
           s68 = 1; 
         else
           {
           s68 = s68 / 2.0;
           s60 -= s68;
           }
         }
       else
         {
         s68 = s68 / 2.0;
         s60 += s68;
         }
       if((s60 == 127) && (highDValue > list[127])) s60 = 128;
       }
     if(cycleLimit > 127)
       {
       if(s58 >= s60)
         {
         if(((s38 + 1) > s60) && ((s40 - 1) < s60))
           lowDValue += highDValue;
         else if((s40 > s60) && ((s40 - 1) < s58))
           lowDValue += list[s40 - 1];
         }
       else if(s40 >= s60)
         {
         if(((s38 + 1) < s60) && ((s38 + 1) > s58))
           lowDValue += list[s38 + 1];
         }
       else if((s38 + 2) > s60)
         lowDValue += highDValue;
       else if(((s38 + 1) < s60) && ((s38 + 1) > s58)) 
         lowDValue += list[s38 + 1];
       if(s58 > s60)
         {
         if(((s40 - 1) < s58) && ((s38 + 1) > s58))
           lowDValue -= list[s58];
         else if((s38 < s58) && ((s38 + 1) > s60))
           lowDValue -= list[s38];
         }
       else
         {
         if(((s38 + 1) > s58) && ((s40 - 1) < s58))
           lowDValue -= list[s58];
         else if((s40 > s58) && (s40 < s60))
           lowDValue -= list[s40];
         }
       }
     if(s58 <= s60)
       {
       if(s58 >= s60) list[s60] = highDValue;
       else
         {
         for(int j = s58 + 1; j <= (s60 - 1); j++)
           list[j - 1] = list[j];
         list[s60 - 1] = highDValue;
         }
       }
     else
       {
       for(j = s58 - 1; j >= s60; j--)
         list[j + 1] = list[j];
       list[s60] = highDValue;
       }
     if(cycleLimit <= 127)
       {
       lowDValue = 0;
       for(j = s40; j <= s38; j++)
         lowDValue += list[j]; 
       }
     if((loopCriteria + 1) > 31) loopCriteria = 31; else loopCriteria++;
     double JMATempValue, sqrtDivider = sqrtParam / (sqrtParam + 1.0);
     if(loopCriteria <= 30)
       {
       if(sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * sqrtDivider;
       if(sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * sqrtDivider;
       JMATempValue = series;
       if(loopCriteria == 30)
         {
         fC0Buffer[shift] = series;
         int intPart;
         if(MathCeil(sqrtParam) >= 1) intPart = MathCeil(sqrtParam); else intPart = 1;
         int leftInt = IntPortion(intPart);
         if(MathFloor(sqrtParam) >= 1) intPart = MathFloor(sqrtParam); else intPart = 1;
         int rightPart = IntPortion (intPart);
         if(leftInt == rightPart) dValue = 1.0;
         else                     dValue = (sqrtParam - rightPart) / (leftInt - rightPart);
         if(rightPart <= 29) int upShift = rightPart; else upShift = 29;
         if(leftInt <= 29) int dnShift = leftInt; else dnShift = 29;
         fA8Buffer[shift] = (series - buffer[loopParam - upShift]) * (1 - dValue) / rightPart + (series - buffer[loopParam - dnShift]) * dValue / leftInt;
         }
       }
     else
       {
       double powerValue, squareValue;
       dValue = lowDValue / (s38 - s40 + 1);
       if(0.5 <= logParam - 2.0) powerValue = logParam - 2.0;
       else                      powerValue = 0.5;
       if(logParam >= MathPow(absValue/dValue, powerValue)) dValue = MathPow(absValue/dValue, powerValue); else dValue = logParam;
       if(dValue < 1) dValue = 1;
       powerValue = MathPow(sqrtDivider, MathSqrt (dValue));
       if(sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * powerValue;
       if(sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * powerValue;
       }
     }
   if(loopCriteria > 30)
     {
     JMATempValue = output[shift + 1];
     powerValue   = MathPow(lengthDivider, dValue);
     squareValue  = MathPow(powerValue, 2);
     fC0Buffer[shift] = (1 - powerValue) * series + powerValue * fC0Buffer[shift + 1];
     fC8Buffer[shift] = (series - fC0Buffer[shift]) * (1 - lengthDivider) + lengthDivider * fC8Buffer[shift + 1];
     fA8Buffer[shift] = (phaseParam * fC8Buffer[shift] + fC0Buffer[shift] - JMATempValue) *
                        (powerValue * (-2.0) + squareValue + 1) + squareValue * fA8Buffer[shift + 1];
     JMATempValue += fA8Buffer[shift];
     }
   JMAValue = JMATempValue;
   }
 if(loopParam <= 30) JMAValue = 0;
 output[shift] = JMAValue;
}

int IntPortion(double param)
{
 if (param > 0) return (MathFloor (param));
 if (param < 0) return (MathCeil (param));
 return (0);
}

The source code is also available for download here:

http://pastebin.com/xdiirCT1

So yeah, it took me a white. I wasted most of the time digging deep into RE assuming that the DLL was just so well protected while in fact the problem was in Metatrader the whole time. As it turned out the DLL is quite dull, definitely not what the authors (http://www.investlabs.com/diamondlock2000.html) are trying to pull. Metatrader just can't work with it directly, though. Before I realized that I even programmed float data type emulation because the DLL is using float and Metatrader doesn't have it at all (if you need it for anything suit yourself: http://pastebin.com/EwmAM8jD). So I ended up programming a wrapper - a tiny DLL that Metatrader is capable to talk with and which on the other hand is capable to talk with the Ocean DLL. I actually made it a bit universal so when you call the wrapper the first parameter is the name of the target DLL so it may work even for other Tradestation indicators using the Diamond Lock DLL, if someone chooses to port them into Metatrader.

Now the instructions:

1. install Ocean Plus package and keygen it
   
2. use OBP1Lock32test.exe to verify the installation - it should give you this result:
   

   C:\Documents and Settings\Administrator\Desktop>OBP1Lock32test.exe
   flag: 1
   result: 0.693147
   

   
   

3. copy OBP1Lock32x.dll either into Metatrader folder experts\libraries or where OBP1Lock32.dll is installed (C:\WINDOWS\system) or anywhere in the system path as you please
   
4. use the .mq4 code as usual
   

The Ocean Plus package can be found here:

http://uloz.to/xk2fMRJ/ocean-plus-indicator-package-manual-for-ts-7z

Both OBP1Lock32test.exe and OBP1Lock32x.dll can be found here (mirror it, please, in case I die or something :) ):

http://uloz.to/xKFrnBk/obp1lock32x-7z

Now what remains is 2-line BTX and then STX. Also, I've got an idea to make a simple oscilator FastNMA compared to NMA. It may be useful for those who are interested in FastNMA vs NMA crossovers. And of course the divergence implementation for fawaz79 (a bit more patience, please).

[[The more confusing bit is that the same logic, once used with the RSX series in the "JMA of RSX" seems to produce results the are very consistent in rt vs historical!! RSX values certainly change within each bar just as closes do in each tick, yet results are consistent both in MT4 and eSignal. There is got to be an easy explanation but it is evading me now! ]] Update: it does do as JMA albeit harder to see!

I see what probably confused you - while in Ocean indis where I used JMA I do calculate JMA all over again at every new tick, I do not do that in JMAofRSX and RSXofJMA I posted here. The explanation is quite simple - those two were just "by the way", just quickies. If you look at the Ocean indis I published here I had to transform the JMA code into a function, I adjusted the code to the visual style I am used to and while reviewing it I noticed a potential problem with repainting as I explained before so I did what I could to avoid it. With JMAofRSX and RSXofJMA I didn't think about anything, I was just reading the Jurik tools manual and there were pictures of JMAofRSX and RSXofJMA so I just wanted to see it in my Metatrader so I simply took the original JMA and RSX codes off the TSD forum and just put them together. It took just a few minutes, I didn't review nor adjust nor improve the code, I didn't give it any thought. I published it simply because "why not?", but it isn't "my" code meaning it didn't go through my way of programming, didn't pass my QA so to speak.

So, sorry for confusion. On the other hard thanks to that you discovered and confirmed my suspicion which is really great because I most probably wouldn't have time to do that. Thank you for that! It's cool that people are that observing.

install Ocean Plus package and keygen it ? please explain

Hi udc, thank you for your expertise in programming this amazing indicators.

Is the installation package for MetaTrader 4 or Trade Station? Where can I find the installation package?

Also, can the installation package run on Win7 64 bit environment?

Mirror for OBP1Lock32test.exe and OBP1Lock32x.dll :

http://[email protected]/archive/5rQQNsev/OBP1Lock32x.html

" (mirror it, please, in case I die or something ):"

Hey udc, you are much needed here, please don't die ;-)

Is the installation package for MetaTrader 4 or Trade Station? Where can I find the installation package?

 

Also, can the installation package run on Win7 64 bit environment?

I edited my previous post and added the link to the Ocean Plus package.

The installation includes the actual Ocean Plus DLL and a few supporting files, manual files and .ELD file to import into Tradestation. You of course won't import anything into Tradestation, just run the setup to install the DLL, then you get machine ID from GenPCID32.Exe, run keygen and put the ID there and you get the password which in turn enter into OBP1LockPW32.Exe. Both GenPCID32.Exe and OBP1LockPW32.Exe have their shortcuts in the Start menu, so just run the respective shortcuts. When it's installed and keygened verify the proper function of the DLL by running the OBP1Lock32test.exe.

In case someone doesn't want to run the setup, I included the actual files in the "installed_files" folder, so you can simply copy the files into c:\windows\system or anywhere else in the system path and then go on with keygenning.

The setup doesn't run on Win7 64, that can by bypassed by copying the actual files instead. However the Ocean DLL doesn't run on Win7 64 either, I suspect its that (******) Diamond Lock protection. If anyone wants to investigate, you can try it on WinXP 64. If the DLL would run there there is a chance it could be modified to run on Win7 64 as well. That would make sense since the DLL is from 2007 and the protection itself is from 2004. But you need to test it in various OSs first to gather information.

" (mirror it, please, in case I die or something ):"

Hey udc, you are much needed here, please don't die ;-)

I am not planning to, but, you know, you never know :) Jim & Pat may send assassins after me or something :-S

UDC thanks for the BTX!! and eagerly waiting for the divergence addition. For thos asking for the ocean package and keygen find it here

http://uloz.to/x83ecYT/jim-sloman-ocean-theory-7z

But i get a compatibility issue and am unable to install it in Win 7 64bit. I tried to change the compatibility to winxp SP2/3 but still get the same error. Anyone with similar issues?

Are you trying it in 64 or 32 bit Win 7? If 32 bit then try to just copy the files as I just described and see if you could keygen it.

64 bit Win 7

udc,

i support your idea mentioned in post#165 for further improvement.

Sixer

Anyone having luck with 64bit win7 installation?

Keygen requires formal installation, or so it seems.

jR

Why did you jump on the bacon like mouse? Win XP professional have no limitation. Win 7 is anyway a BS just to make it not compatible with many software's to let you reach in your pocket deeper! Serving your idol Bill Gates? Rich will be richer?

Hermes

Win XP professional have no limitation

Skeptics said the same about Win 95 when Win XP came up. It wasn't true about Win 95, it is not true about Win XP and it will never ever be true simply because the "limitation" comes up naturally as time goes and new things are made. Old thing (Win XP from 2002) will always be somehow limited in newer environment (new world, new software, new people's needs etc. in 2012) because it logically can't be ready for it. Being backward is not and never was a solution. We don't live in caves anymore, we don't burn witches to death anymore, we don't wash only once a week anymore, whatever way you look at it you just can't stop progress, sadly even if the progress is towards worse (maybe that's what you meant). For example I very don't like the new user interface of Windows 8 but I know sooner or later I will have no choice, eventually. You can't install some new software on Win XP anymore, mainstream support ended already 3 years ago and the extended support will end in 2014 and that will be it.

But why do you put equal sign between a new version of Windows and the money? How many people here actually paid for Windows? I didn't and I am not ashamed to admit it. I am using Windows since 1992 and for the countless times I got irritated, for the countless times Windows damaged or broke something, for the countless gray hairs I got and for apparently shortening my lifetime expectancy, it's me the user, not Microsoft, who should be actually paid. I've never heard that they paid for the damages their defective software caused. But every time I get angry at this software I can at least say to myself "thanks god I didn't pay for this !@#$% of !@#$". I was happy with unix thorough the '80s, since 1995 I am happy with linux, but for some activities the Windows is actually more convenient. But paying for it? Never.

Anyway, to stay on the subject - my trading machines are Wine/Win XP but my workstation is of course Win 7 64 (the same as many others) and not being able to run something on it (Ocean Plus DLL in this case) is just inconvenient to say the least. But maybe there is an updated version compatible with Windows 7 64. I found some other Tradestation indicator using Diamond Lock DLL too and that one does seem to work on Windows 7 64: http://www.neweratrader.com/The-Oscillator/tradestation-net-indicators-and-workspace-installation.html, so there is a hope.

Why did you jump on the bacon like mouse? Win XP professional have no limitation. Win 7 is anyway a BS just to make it not compatible with many software's to let you reach in your pocket deeper! Serving your idol Bill Gates? Rich will be richer?

Hermes

Mouse on bacon? Bill Gates the idol? Thanks.

When (and if) you buy a new machine, it comes with win7. And some of us have to choose our battles carefully. Obviously, you don't!

jR

josephr

I believe that the Ocean software was written for windows XP and Tradestation 8 and that is the reason you are not able to load it on W7, my advise since computers are so cheap, is you should get a 2nd computer, XP since most of the older programs were written for XP, Ocean software is a $8000 software so it would be worth to invest in getting a 2nd computer

josephr

I believe that the Ocean software was written for windows XP and Tradestation 8 and that is the reason you are not able to load it on W7, my advise since computers are so cheap, is you should get a 2nd computer, XP since most of the older programs were written for XP, Ocean software is a $8000 software so it would be worth to invest in getting a 2nd computer

I think you are right and it would be a wise investment! I am on it already.

Best,

jR

BTX_2line for MT4

Here goes Ocn_BTX_2linex, as usual with optional JMA.

Also a new version of Ocn_BTXx with optional "BTX_2line_based_colors" switch which makes BTX to be drawn in green/red color based on relative positions of BTX_2line's BTXp and BTXn.

Original BTX_2line on TradeStation:

http://img821.imageshack.us/img821/7572/btx2linetradestation.png

Ocn_BTX_2linex (and Ocn_BTXx in colors) on Metatrader:

http://img13.imageshack.us/img13/5236/btx2linemetatrader.png

Original size screenshots:

http://img806.imageshack.us/img806/7572/btx2linetradestation.png

http://img210.imageshack.us/img210/5236/btx2linemetatrader.png

Ocn_BTX_2linex:

http://pastebin.com/eF1Ek6Ld

Ocn_BTXx:

http://pastebin.com/mhVwMsNM

These DLL calculations are rather CPU consuming so if the initial calculation (when attaching the indi to a chart) takes too long do use the MaxBars variable to limit how many bars should be initially calculated.

hi UDC

Just wondering if you have the Jurik manual that explains how to plot the different settings for his indicators, not the basic jurik manual that gives an overview of the indicators, just wondering if there was an additional manual with suggested settings