Announcement

Collapse
No announcement yet.

J TPO Velocity

Collapse
This topic is closed.
X
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • J TPO Velocity

    File Name: J_TPO_Velocity.efs

    Description:
    J TPO Velocity

    Formula Parameters:
    Length : 14
    Point : 0.01


    Notes:
    J_TPO is in its original form, an oscillator between -1 and +1,
    a nonparametric statistic quantifying how well the prices are ordered
    in consecutive ups (+1) or downs (-1) or intermediate cases in between.


    Download File:
    J_TPO_Velocity.efs



    EFS Code:
    PHP Code:
    /*********************************
    Provided By:  
        eSignal (Copyright c eSignal), a division of Interactive Data 
        Corporation. 2009. All rights reserved. This sample eSignal 
        Formula Script (EFS) is for educational purposes only and may be 
        modified and saved under a new file name.  eSignal is not responsible
        for the functionality once modified.  eSignal reserves the right 
        to modify and overwrite this EFS file with each new release.

    Description:        
        J TPO Velocity
        
    Version:            1.0  10/29/2009
     
    Formula Parameters:                     Default:
        Length                              14
        Point                               0.01
        
    Notes:
        J_TPO is in its original form, an oscillator between -1 and +1,                  
        a nonparametric statistic quantifying how well the prices are ordered            
        in consecutive ups (+1) or downs (-1) or intermediate cases in between.          
        
    **********************************/
    var fpArray = new Array();
    var 
    bInit false;

    function 
    preMain(){
        
    setPriceStudy(false);
        
    setShowCursorLabel(true);
        
    setShowTitleParameters(false);
        
    setStudyTitle("J TPO Velocity");
        
    setCursorLabelName("JTPOVelocity"0);
        
    setPlotType(PLOTTYPE_LINE0);
        
    setDefaultBarFgColor(Color.blue0);
        var 
    0;
        
    fpArray[x] = new FunctionParameter("Length"FunctionParameter.NUMBER);
        
    with(fpArray[x++]) {
            
    setLowerLimit(1);
            
    setDefault(14);
        }    
        
    fpArray[x] = new FunctionParameter("Point"FunctionParameter.NUMBER);
        
    with(fpArray[x++]) {
            
    setLowerLimit(0);
            
    setDefault(0.01);
        }            
    }

    var 
    xJTPOV null;

    function 
    main(LengthPoint) {
    var 
    nBarState getBarState();
    var 
    nJTPOV 0;
        if (
    nBarState == BARSTATE_ALLBARS) {
            if(
    Length == nullLength 14;
            if(
    Point == nullPoint 0.01;
        }
        if (
    bInit == false) {
            
    addBand(0PS_SOLID1Color.black"Zero");    
            
    xJTPOV efsInternal("Calc_xJTPOV"LengthPoint);
            
    bInit true;
        }
        
    nJTPOV xJTPOV.getValue(0);
        if (
    nJTPOV == null) return;
        return 
    nJTPOV;
    }

    var 
    bSecondInit false;
    var 
    xRange null;
    var 
    xTPO null;

    function 
    Calc_xJTPOV(LengthPoint) {
    var 
    nRes 0;
    var 
    nRange 0;
    var 
    nTPO 0;
        if (
    bSecondInit == false) {
            
    xRange efsInternal("Calc_Range"LengthPoint);
            
    xTPO efsInternal("Calc_TPO"Length);
            
    bSecondInit true;
        }
        
    nRange xRange.getValue(0);
        
    nTPO xTPO.getValue(0);
        if (
    nRange == null || nTPO == null) return;
        
    nRes nTPO nRange Length;
        return 
    nRes;
    }

    var 
    bThirdInit false;
    var 
    xHighest null;
    var 
    xLowest null;

    function 
    Calc_Range(LengthPoint) {
    var 
    nRes 0;
    var 
    nHighest 0;
    var 
    nLowest 0;
        if (
    bThirdInit == false) {
            
    xHighest upperDonchian(Lengthhigh());
            
    xLowest lowerDonchian(Lengthlow());
            
    bThirdInit true;
        }
        
    nHighest xHighest.getValue(0);
        
    nLowest xLowest.getValue(0);
        if (
    nHighest == null || nLowest == null) return;
        
    nRes = (nHighest nLowest) / Point;
        return 
    nRes;
    }

    var 
    bFourInit false;
    var 
    xClose null;

    function 
    Calc_TPO(Length) {
    var 
    nRes 0;
    var 
    normalization 0;
    var 
    Lenp1half 0;
    var 
    accum 0;
    var 
    tmp 0;
    var 
    maxval 0;
    var 
    0;
    var 
    maxloc 0;
    var 
    0;
    var 
    0;
    var 
    arr1 = new Array();
    var 
    arr2 = new Array();
    var 
    arr3 = new Array();
    var 
    flag false;
        if (
    bFourInit == false) {
            
    xClose close();
            
    bFourInit true;
        }
        if (
    xClose.getValue(-Length) == null) return;
        
    accum 0;
        for(
    1<= Lengthm++) {
            
    arr2[m]=m;
            
    arr3[m]=m;
            
    arr1[m]= xClose.getValue(-(Length m));
        }
        for(
    1<= (Length 1); m++) {
            
    maxval arr1[m];
            
    maxloc m;
            for(
    m+1<= Lengthj++) {
                if (
    arr1[j] < maxval) {
                    
    maxval=arr1[j];
                    
    maxloc=j;
                }
            }
            
    tmp arr1[m];
            
    arr1[m] = arr1[maxloc];
            
    arr1[maxloc] = tmp;
            
    tmp arr2[m];
            
    arr2[m] = arr2[maxloc];
            
    arr2[maxloc] = tmp;
        }
        
    m=1;
        while(
    Length) {
            
    1;
            
    flag true;
            
    accum arr3[m];
            while(
    flag) {
                if (
    arr1[m] != arr1[j]) {
                    if ((
    m) > 1) {
                        
    accum accum / (m);
                        for(
    m<= (j-1); n++) {
                            
    arr3[n] = accum;
                        }    
                    }
                    
    flag false;
                } else {
                    
    accum += arr3[j];
                    
    j++;
                } 
            } 
            
    m=j;
         } 
        
    normalization 12.0 / (Length * (Length 1) * (Length 1));
        
    Lenp1half = (Length 1) * 0.5;
        for(
    accum 01<= Lengthm++) {
            
    accum += (arr3[m] - Lenp1half) * (arr2[m] - Lenp1half);
        }
        
    nRes normalization accum;
        return 
    nRes;

Working...
X