In the spirit of open source ....

Discussion in 'Technical Analysis' started by neophyte321, Mar 1, 2008.

  1. neophyte321

    neophyte321 Guest

    here's a routine I coded awhile back ... may be some use to fellow data junkies ...


    public Period getPeriod(String symbol,int tdays, MarketDay[] tradedays, Period prevPeriod){

    Period period = new Period(symbol,tdays,prevPeriod);

    float prevmax = 0;
    float prevmin = 0;
    float prevclose = 0;
    float prevopen = 0;
    long prevvol = 0;
    float prevrs = 0;
    float prevrsi = 0;
    float prevrsigain = 0;
    float prevrsiloss = 0;
    float prevendvol = 0;

    period.DX = 0;
    period.ADX = 0;
    period.symbol = symbol;

    if (prevPeriod.Exists){
    prevmax = prevPeriod.startmax;
    prevmin = prevPeriod.startmin;
    prevclose = prevPeriod.startclose;
    prevopen = prevPeriod.startopen;
    prevvol = prevPeriod.startvol;
    prevrs = prevPeriod.RS;
    prevrsi = prevPeriod.RSI;
    prevrsigain = prevPeriod.RSIGAIN;
    prevrsiloss = prevPeriod.RSILOSS;
    }

    try{
    int up = 0;
    int down = 0;
    float vols = 0;
    float pvols = 0;
    float posDI = 0;
    float negDI = 0;
    float posSDI = 0;
    float negSDI = 0;
    float sma = 0;
    float ema = 0;
    float recs = 0;
    float momntm = 0;
    float loss = 0;
    float gain = 0;
    float days = tdays;
    float TR = 0;

    float posDM = 0;
    float negDM = 0;
    float curmax = 0;
    float curmin = 0;
    float curclose = 0;
    float curopen = 0;
    String curdate;
    int curvol = 0;
    float accm = 0;
    float[] cl = new float[tdays];
    int dy = 0;
    float sumtypicals = 0;
    float[] typicals = new float[tdays];
    float sATR = 0;

    period.ATR = 0 ;
    period.SWA = 0;
    period.SMA = 0;
    period.EMA = 0;

    int hiday = 0;
    int loday = 0;
    int newhghs = 0;
    int newlws = 0;
    int gns = 0;
    int lss = 0;

    int dnm = 0;
    for (int i = 1; i<tdays+1; i++){
    dnm += i;
    }

    float pbpp = 0;
    float nbpp = 0;
    int h,l;

    double X = 0;

    for (int i = 0; i<tdays; i++){

    posDM = 0;
    negDM = 0;

    curdate = tradedays.qdate;
    curopen = tradedays.open;
    curclose = tradedays.close;
    curmax = tradedays.maxprice;
    curmin = tradedays.minprice;
    curvol = tradedays.volume;

    if ((period.minprice==0) || (period.minprice>curmin)){
    period.minprice = curmin;
    h = i+1;
    }

    if (period.maxprice<curmax){
    period.maxprice = curmax;
    l = i+1;
    }

    if (i==0){
    period.sdate = curdate;
    period.startdate = sdf.parse(curdate);
    period.startopen = curopen;
    period.startclose = curclose;
    period.startmax = curmax;
    period.startmin = curmin;
    period.startvol = curvol;
    }
    if (i==tdays-1){
    period.edate = curdate;
    period.enddate = sdf.parse(curdate);
    period.endopen = curopen;
    period.endclose = curclose;
    period.endmax = curmax;
    period.endmin = curmin;
    period.endvol = curvol;
    }

    period.volume += curvol;

    if (prevPeriod.Exists){

    //SET BPP ================================
    if (i>0){
    if ((curclose > prevclose)){
    period.PBPP += (float)(i+1)/dnm*100;
    }else{
    period.NBPP += (float)(i+1)/dnm*100;
    }
    }else{
    if ((curclose > prevPeriod.startclose)){
    period.PBPP += (float)(i+1)/dnm*100;
    }else{
    period.NBPP += (float)(i+1)/dnm*100;
    }
    }

    //SET DX===========================
    if (curmax>prevmax){
    posDM = (curmax - prevmax);
    }
    if (curmin<prevmin){
    negDM = (prevmin - curmin);
    }

    if (posDM>negDM){
    negDM = 0;
    }else if (posDM < negDM){
    posDM = 0;
    }else{
    posDM = negDM = 0;
    }
    //==================================

    //SET ATR===========================
    float a = Math.abs(curmin - prevclose);
    float b = Math.abs(curmax - prevclose);
    float c = Math.abs(curmax - curmin);
    float d = 0;

    if (a>b){
    if (a>c){d = a;
    }else{d = c;}
    }else{
    if (b>c){d = b;
    }else{d = c;}
    }

    TR = d;
    sATR +=TR;
    //==================================

    //SET DX============================
    if (TR != 0){
    posSDI += posDM;
    negSDI += negDM;
    }
    //==================================

    //SET RSI===========================
    if (curclose>prevclose){
    gain += (curclose-prevclose);
    }else{
    loss += (prevclose-curclose);
    }
    //===================================

    period.velocity += curclose - prevclose;

    //SET ACCUMULATION===================
    if (curmax != curmin){
    period.accumulation += Math.abs(curvol * ((curclose - curmin) - (curmax - curclose))/(curmax-curmin));
    }
    //===================================

    //SET CCI============================
    cl[dy] = curclose;
    typicals[dy] = (curmax+curmin+curclose)/3;
    sumtypicals += typicals[dy];

    dy++;
    //====================================

    //SET HVA============================
    X += Math.log((double)(curclose/prevclose));
    //===============================

    }

    //SET SMA, WMA==========================
    sma += curclose;
    vols += curvol;
    pvols += ((Math.abs(curclose-curopen)/2)+curopen) * curvol;

    //set prev as cur
    prevmax = curmax;
    prevmin = curmin;
    prevclose = curclose;
    prevopen = curopen;
    prevvol = curvol;


    }
    // end loop through period Quotes=====================

    period.dvolume = period.volume/tdays;

    //SET AROONUP=========================
    //ARNUP = (float)h/(tdays*100);
    //====================================
    //SET AROONDWN========================
    //ARNDWN = (float)l/(tdays*100);
    //====================================
    //ARNOS = ARNUP - ARNDWN;
    //====================================

    // set stochastics ===================================
    if (period.maxprice!=period.minprice){
    period.stochk = 100 * (period.endclose - period.minprice) / (period.maxprice - period.minprice);
    }

    if (!prevPeriod.Exists){
    period.stochs[0] =period.stochk;
    }

    int sint = 3;

    for (int i = sint-1; i>0; i--){
    period.stochs = prevPeriod.stochs[i-1];
    }
    period.stochs[0] = period.stochk;

    float sd = 0;
    boolean b = true;

    for (int j=0; j<sint; j++){
    if (period.stochs[j] == 0){
    b = false;
    }
    sd += period.stochs[j];
    }

    if (b){
    period.stochd = sd / sint;
    }
    //====================================================

    if (period.endclose>period.startclose){
    period.uptrend = true;
    }else{
    period.uptrend = false;
    }

    if (period.startclose!=0){
    period.momentum = (period.endclose/period.startclose) * 100;
    }

    //SET SWA=============================
    if (vols!=0){
    period.SWA = pvols / vols;
    }else{
    period.SWA = 0;
    }
    //====================================

    //SET SMA=============================
    period.SMA = sma / days;
    //====================================

    if (!prevPeriod.Exists){
    //SET EMA as SMA for first period
    period.EMA = period.SMA;
    }
     
  2. neophyte321

    neophyte321 Guest

    if (prevPeriod.Exists){

    //SET ATR============================
    period.ATR = (float)(sATR / days);
    //===================================

    //SET DX =============================
    if (sATR!=0){
    posDI = posSDI / sATR;
    negDI = negSDI / sATR;
    }

    if ((posDI + negDI)!=0){
    period.DX = ((float)(Math.abs(posDI - negDI))/(Math.abs(posDI + negDI))) * 100;
    }
    //====================================

    //SET RSI=============================
    if ((prevPeriod.RSILOSS==0) && (prevPeriod.RSIGAIN==0)){
    if ((loss!=0)){
    period.RSIGAIN = gain/days;
    period.RSILOSS = loss/days;
    period.RS = (period.RSIGAIN/period.RSILOSS);
    period.RSI = 100 - (100/(1+period.RS));
    }
    }else{
    float curgain = 0;
    float curloss = 0;

    if (period.endclose>prevPeriod.endclose){
    curgain = (period.endclose-prevPeriod.endclose);
    }else{
    curloss = (prevPeriod.endclose-period.endclose);
    }

    float rsig = ((prevrsigain * (days-1)) + curgain)/days;
    float rsil = ((prevrsiloss * (days-1)) + curloss)/days;

    if ((rsil!=0)){
    period.RS = rsig/rsil;
    period.RSI = 100 - (100/(1+period.RS));
    period.RSIGAIN = rsig;
    period.RSILOSS = rsil;
    }
    }
    //===================================

    //SET CCI============================
    double tmp = 0;
    double typ = 0;
    double avetypc = (double)sumtypicals/tdays;
    double x = 0;

    //sum for each tday in period
    //X += Math.log((double)(curclose/prevclose));

    X = X/tdays;


    for (int z=0; z<tdays; z++){
    //tmp += (Math.exp(cl[z] - period.SMA));
    tmp += (cl[z] - period.SMA)*(cl[z] - period.SMA);
    typ += (Math.abs(typicals[z] - avetypc));
    if (z > 0){
    x += Math.pow((Math.log((float)(cl[z]/cl[z-1])) - X),2);
    }else{
    x = Math.pow((Math.log((float)(period.startclose/prevPeriod.startclose)) - X),2);
    }
    }

    double typc = typ / tdays;

    if (typc != 0){
    period.CCI = (typicals[tdays-1] - avetypc)/(.015 * typc);
    }
    //====================================

    double df = (double)252/period.tdays;
    //SET HVA============================
    period.HV = Math.sqrt((double)(x/(period.tdays-1)));
    //period.AHV = 100*period.HV*(df);
    period.HV = 100*period.HV;

    // 'ditching' the mean
    // HV = Math.sqrt(Math.sq(x)/period.tdays);
    period.AHV = period.HV * 15.8745;
    //===============================

    //SET Standard Deviation==============
    period.StdDev = Math.sqrt((float)tmp/(tdays-1));
    //====================================

    //SET BOLLINGER BANDS=================
    if (period.StdDev<100000){
    period.upperband = period.SMA + (period.numOfStdDev * period.StdDev);
    period.lowerband = period.SMA - (period.numOfStdDev * period.StdDev);
    }
    //====================================


    //SET EMA=============================
    float t = tdays;
    float multipler = (float)2/(t+1);
    period.EMA = ((period.endclose - prevPeriod.EMA) * multipler) + prevPeriod.EMA;
    //====================================

    //SET PRICE ACCELARATION==============
    period.acceleration = period.velocity - prevPeriod.velocity;
    //===================================

    //set stoch moves=======================
    period.stdmv = period.stochd - prevPeriod.stochd;
    period.stkmv = period.stochk - prevPeriod.stochk;
    //======================================

    }

    for (int i = 0; i < period.tdays; i++){

    }


    period.perup = ((period.endclose - period.startclose)/period.startclose)*100;

    period.periodId = period.symbol + ((period.sdate.replaceAll("/","")).replaceAll(":","")).replaceAll(" ","") + tdays;

    }catch(Exception e){
    e.printStackTrace();
    }

    return period;

    }
     
  3. neophyte321

    neophyte321 Guest

    it looks like some of the code is not being displayed ...


    hit reply to see all the code ...
     
  4. PROGRAM kiss:

    IF price > moving_average
    THEN be long
    ELSE be flat.