JTPO Velocity indicator for translation, please

[jtrade]

Here's the EasyLanguage code for an indicator I have started using for exits : would anyone be willing to code it for NT, please (I also have the MT4 code if preferred) ?

Example of use in screenshot attached to end of post.

EL as follows :

Function :

[LegacyColorValue = true];

{function JTPOSeries(Series Integer; Len Integer) integer;}
inputs: Series(NumericSeries),Len(NumericSimple);
begin
var: sBar(0);
{ var sName: string;
var Value: float;
sName := 'JTPO(' + GetDescription(Series) + ',' + IntToStr(Len) + ')';
Result := FindNamedSeries(sName); if Result >= 0 then Exit;
Result := CreateNamedSeries(sName);
}
var: f0(0), f8(0), f10(0), f18(0), f20(0), f28(0);
var: f30(0), f38(0), f40(0), f48(0);
var: var6(0), varA(0), varE(0), var12(0), var14(0);
var: var18(0), var1C(0), var20(0), var24(0);
array: arr0[301](0), arr1[301](0), arr2[301](0), arr3[301](0);

{ for sBar = 0 to BarCount() - 1 }
begin var14 = 0; var1C = 0;
if (f38 = 0) then
begin
f38 = 1;
f40 = 0;
if (Len-1 >= 2)
then
f30 = Len-1
else
f30 = 2;
f48 = f30 + 1;
f10 = Series;
arr0[f38] = Series;
f18 = 12 / (f48 * (f48 - 1) * (f48 + 1));
f20 = (f48 + 1) * 0.5;
end
else begin
if (f38 <= f48)
then f38 = f38 + 1
else f38 = f48 + 1;
f8 = f10;
f10 = Series;
if (f38 > f48) then
begin
for var6 = 2 to f48 begin
arr0[var6 - 1] = arr0[var6];end;
arr0[f48] = Series;
end
else arr0[f38] = Series;
if ((f30 >= f38) and (f8 <> f10))
then f40 = 1;
if ((f30 = f38) and (f40 = 0))
then f38 = 0; end;
if (f38 >= f48)
then begin
for varA = 1 to f48
begin
arr2[varA] = varA;
arr3[varA] = varA;
arr1[varA] = arr0[varA];
end;
for varA = 1 to f48-1
begin
var24 = arr1[varA];
var12 = varA;
var6 = varA + 1;
for var6 = varA + 1 to f48 begin
if ( arr1[var6] < var24 )
then begin
var24 = arr1[var6];
var12 = var6;
end; end;
var20 = arr1[varA];
arr1[varA] = arr1[var12];
arr1[var12] = var20;
var20 = arr2[varA];
arr2[varA] = arr2[var12];
arr2[var12] = var20;
end;
varA = 1;
while (f48 > varA)
begin
var6 = varA + 1;
var14 = 1;
var1C = arr3[varA];
while (var14 <> 0)
begin
if (arr1[varA] <> arr1[var6])
then
begin
if (var6 - varA > 1)
then
begin
var1C = var1C / (var6 - varA);
varE = varA;
for varE = varA to var6-1 begin
arr3[varE] = var1C; end;
end;
var14 = 0;
end
else
begin
var1C = var1C + arr3[var6];
var6 = var6 + 1;
end;
end;
varA = var6;
end;
var1C = 0;
for varA = 1 to f48 begin
var1C = var1C + (arr3[varA] - f20) * (arr2[varA] - f20); end;
var18 = f18 * var1C;

end else var18 = 0;
JTPO = var18;

end;end;

Indicator

[LegacyColorValue = true];

inputs:len(13);
PLOT1(JTPO(C,len),"JTPO");
Plot2(0,"Null");

Thanks,

J.

[jtrade]

PS. Where are the code tags on this forum, please, such that code can be correctly & clearly posted within its own "box" ?

[NinjaTrader_Bertrand]

Thanks for sharing, if no ones takes it up for conversion, you can also contact one of those certified consultants - http://www.ninjatrader.com/webnew/pa...injaScript.htm

When you post code, just highlight it and then click on the 'Hash Key' to wrap the code tags around it.

[jtrade]

Thanks for sharing, if no ones takes it up for conversion, you can also contact one of those certified consultants - http://www.ninjatrader.com/webnew/pa...injaScript.htm

When you post code, just highlight it and then click on the 'Hash Key' to wrap the code tags around it.

Thanks for the response and the posting tip, Bertrand.

In general, if no-one feels like coding an indicator, I'll happily pay someone to do it... but then I'm less inclined to share it

[thrunner]

Please use the # icon for code box.
J_TPO_Clean.mq4

http://codebase.mql4.com/2051

//+------------------------------------------------------------------+
//|                                                  J_TPO_Clean.mq4 |
//|                      Copyright © 2005,                           |
//|                                                                  |
//+------------------------------------------------------------------+
 
// J_TPO_Clean is a cleanup of the original J_TPO code, which
// was incomprehensible, and obviously translated poorly from some 
// other implementation.   Some bugs have been eliminated.
// It now does J_TPO on Close[] and High[] and Low[], in
// white, green and red respectively.   If you want classic J_TPO,
// then just turn the colors of the green and red to 'none'.
// Matt ([email protected])
// This code is released under the terms of the GNU General Public License V2
 
#property copyright "Copyright © 2005"
#property link      "www.metatrader.org"
//----
#property indicator_separate_window
#property indicator_minimum -1
#property indicator_maximum 1
#property indicator_buffers 3
#property indicator_color1 White
#property indicator_color2 Green
#property indicator_color3 Red
//---- input parameters
extern int       Len=14;
//---- buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0, ExtMapBuffer1);
   SetIndexStyle(1,DRAW_LINE);
   SetIndexBuffer(1, ExtMapBuffer2);
   SetIndexStyle(2,DRAW_LINE);
   SetIndexBuffer(2, ExtMapBuffer3);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| J_TPO indicatop                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int limit;
   int counted_bars=IndicatorCounted();
//---- check for possible errors
   if(counted_bars<0) return(-1);
//---- last counted bar will be recounted
   if(counted_bars>0) counted_bars--;
   limit=MathMin(Bars-counted_bars-Len,Bars-Len-1);
     if (Len < 3) 
     {
      Print("J_TPO_B:  length must be at least 3");
      return(0); //  
     }
     for(int i=limit; i>=0; i--) 
     {
      ExtMapBuffer1[i]=J_TPO_value(Close,Len,i);
      ExtMapBuffer2[i]=J_TPO_value(High,Len,i);
      ExtMapBuffer3[i]=J_TPO_value(Low,Len,i);
     }
//---- done
   return(0);
  }
//----
  double J_TPO_value(double input[], int Len, int shift) 
  {
   // compute the J_TPO function on input[shift], looking back up to Len data previous
   double value, normalization, Lenp1half;
   double accum, tmp, maxval;
   int j, maxloc, m;
   double arr1[], arr2[], arr3[];
   bool flag;
   accum=0;
//----
   ArrayResize(arr1,Len+1);
   ArrayResize(arr2,Len+1);
   ArrayResize(arr3,Len+1);
//----   
     for(m=1; m<=Len; m++) 
     {
      arr2[m]=m;
      arr3[m]=m;
      arr1[m]=input[shift+Len-m];
     }
   // sort arr1[] in ascending order, arr2[] is the permutation index 
   // Note, this is a poor quadratic search, and will not scale well with Len
     for(m=1; m<=(Len-1); m++) 
     {
      // find max value & its location in arr1 [m..m+Len]
      maxval=arr1[m];
      maxloc=m;
        for(j=m+1; j<=Len; j++) 
        {
           if (arr1[j] < maxval) 
           {
            maxval=arr1[j];
            maxloc=j;
           }
        }
      // Swap arr1[m] with its max value
      // amd similarly for arr2.
      tmp=arr1[m];
      arr1[m]=arr1[maxloc];
      arr1[maxloc]=tmp;
      tmp=arr2[m];
      arr2[m]=arr2[maxloc];
      arr2[maxloc]=tmp;
     }
   // arr3[1..Len] is nominally 1..m, but this here adjusts for
   // ties.
   m=1;
     while(m < Len) 
     {
      // Search for repeated values. 
      j=m + 1;
      flag=true;
      accum=arr3[m];
        while(flag) 
        {
           if (arr1[m]!=arr1[j])
           {
              if ((j - m) > 1) 
              {
               // a streak of repeated values was found
               // and so replace arr3[] for those with 
               // its average
               accum=accum/(j - m);
               for(int n=m; n<=(j-1); n++)
                  arr3[n]=accum;
              }
            flag=false;
            }
             else 
            {
            accum+=arr3[j];
            j++;
           }  // if
        } // while flag 
      m=j;
     } // while (Len > m) 
   // This is the real guts of the J_TPO
   // it is a simple statistic to see if the ranks, when applied in sorted order are
   // "correlated" with 1..Len, a simple cross correlation of ranks.
   // so if they are sorted then this gives 1, and if they are anti-sorted they give -1
   // and similarly for intermediate values. 
   normalization=12.0/(Len*(Len-1)*(Len+1));
   Lenp1half=(Len + 1) * 0.5;
//----
     for(accum=0,m=1; m<=Len; m++) 
     {
      // Print("m="+m+"Arr2[m] ="+arr2[m]+" arr3[m]="+arr3[m]); 
      accum+=(arr3[m] - Lenp1half) * (arr2[m] - Lenp1half);
     }
   value=normalization * accum;
   // Print("JTPO_B:  accum = "+accum+" norm = "+normalization); 
   return(value);
  }
//+------------------------------------------------------------------+

[jtrade]

Thanks, thrunner, that's similar to the mq4 code that I have... fancy converting into Ninjascript ?

[jtrade]

Thanks, thrunner, that's similar to the mq4 code that I have... fancy converting into Ninjascript ?

Any takers at $50 (via PayPal) ?

[easytrader]

Any takers at $50 (via PayPal) ?

Did you ever get it coded for Ninja?