In the spirit of open source ....

[neophyte321]

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;
}

 

[neophyte321]

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;

}

 

[neophyte321]

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


hit reply to see all the code ...

 

[PretzelPiece]

PROGRAM kiss:

IF price > moving_average
THEN be long
ELSE be flat.