package tscore;

/* File : Simplestat.java

* Project: Math Tools in Java

* Purpose: Compute basic statistics

* frequency, central tendency, measure of variation.

* nomal curve distribution.

* Author : Wachara R.

* First Released: Th 3 May 2007

* Last Updated : Tu 8 July 2008

* add constructor SimpleStat ( double, int)

*/

import static java.lang.Math.*;

import static java.lang.Double.*;

//import simpleStat.SimpleStatException;

//import static common.CommonConstants.*;

//import common.Function;

//import integration.*;

/** class for basic statistics algorithm: frequency, central tendency,

* measure of variation.

* some inference statistics*/

public class SimpleStat {

/** data for computing the basic statistics */ public double[ ] data;

/** number of data */ public int numData;

/** number of data after finding frequency */public int numDataAtLast;

/** basic statistic quantities */

/** mean value */ double mean;

/** median value */ double median;

/** range of data */ double range;

/** standard deviation */ double sd;

//sorted data */ double [ ] sData;

/** managed data */ double [] mData;

/** keeping repeated mode data */ double[] modeData;

/** mode of data */ int mode;

/** frequency of data set */ public int [] frequency;

/** accumulated frequency */ public int [] cFrequency;

/** checking data have been sorted */ protected boolean isSorted = false;

/** checking data have been classified with frequencies */

boolean isClassified = false;

/** checking data have been computed for cumulated frequencies */

protected boolean havingCumulatedFreq=false;

/** Constructor

* @param dat data for computing basic statistics

*/

/** Constructor */

public SimpleStat( ) {

}

public SimpleStat( double [ ] dat ){

data = dat;

numData = dat.length;

findMean();

findSD();

// sData = new double[ numData];

// sData = copyData(data,numData);

quickSort( data, 0,numData-1,false);

findMedian();

findFrequency();

findCumulativeFrequency();

findMode();

findRange();

/*

System.out.println("Data frequency...: ");

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

System.out.println( mData[i] +" " + frequency[i]);

}

*/

}

public SimpleStat( double [ ] dat, int numberOfData ){

data = dat;

numData = numberOfData;

findMean();

findSD();

quickSort( data, 0,numData-1,false);

findMedian();

findFrequency();

findCumulativeFrequency();

findMode();

findRange();

}

/** copy data from current array to another array */

private double[ ] copyData(double[] itemToBeCopied,int nItem) {

double[ ] dummy = new double[ nItem];

for(int i = 0 ; i < nItem; i++)

dummy[i] = itemToBeCopied[i];

return dummy;

}

private int[ ] copyData(int[] itemToBeCopied,int nItem) {

int[ ] dummy = new int[ nItem];

for(int i = 0 ; i < nItem; i++)

dummy[i] = itemToBeCopied[i];

return dummy;

}

// ========= Frequency ==========

/** finding frequency of each data */

private void findFrequency( ){

int n_freq = 0;

int tempfrequency[ ] = new int[numData];

double temp [ ] = new double[numData];

double dummy[] = new double [numData];

if (isSorted == false) quickSort( data, 0,numData-1,false);

temp = copyData(data, numData);

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

if (temp[i] != MAX_VALUE) {

tempfrequency[n_freq]=1;

dummy[n_freq] = temp[i];

int j = i;

while ( (j < numData-1) && (temp[j+1] == temp[i])){

tempfrequency[n_freq] +=1;

temp[j+1] = MAX_VALUE;

j = j+1;

}

n_freq +=1;

}

}

mData= new double[n_freq];

mData = copyData ( dummy, n_freq);

frequency = new int[n_freq];

frequency = copyData(tempfrequency, n_freq);

isClassified = true;

numDataAtLast = n_freq;

}

/** finding cumulative frequency */

protected void findCumulativeFrequency(){

// if data are not sorted, sort them decendingly.

if (isSorted == false) quickSort( data, 0,numData-1,true);

cFrequency = new int[numDataAtLast];

cFrequency[ numDataAtLast-1] =frequency[numDataAtLast-1];

for(int i = numDataAtLast -2; i >=0; i--){

cFrequency[i] = frequency[i] + cFrequency[i+1];

}

havingCumulatedFreq=true;

}

/** quick sort: sort all data in ascending or decending

* param item data to be sorted

* param left the first item of data

* param right the last item of data

* param ascending if true , data will be sort in ascending othrewise decending

*/

protected void quickSort(double [ ] item, int left, int right, boolean ascending) {

int i,j;

double comparand, temp;

i = left;

j = right;

comparand = item[(left+right)/2];

do { if (ascending) {

while( item[i] < comparand && i < right) i++;

while (comparand < item[j] && j > left) j--;

}else {

while( item[i] > comparand && i < right) i++;

while (comparand > item[j] && j > left) j--;

}

if ( i <= j) {

temp = item[i];

item[i] = item[j];

item[j] = temp;

i++;

j--;

}

}while ( i <= j );

if (left < j) quickSort(item, left, j, ascending);

if(i < right ) quickSort(item, i,right, ascending);

isSorted = true;

}

// ============ Central tendecy =============

/** find mean or average of data */

private void findMean( ) {

double sumData=0;

for(int i = 0 ; i < numData; i++ )

sumData +=data[i];

mean = sumData/(double)numData;

}

/** find median of data */

private void findMedian( ) {

if (isSorted == false) quickSort(data, 0,numData-1,true);

if (numData%2 == 0)

// number of data is even, find the average

median = (data[numData/2] + data[(numData/2)-1])/2.0 ;

else

median = data[numData/2];

}

/** find mode of data */

private void findMode( ) {

int multiMode =1;

if (isClassified == false) findFrequency( );

if(numData == numDataAtLast) {

modeData = new double[1];

modeData[0] =0;

mode = 0;

return;

}

// walk through classified data looking for double mode or multimode

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

if(frequency[i] >= mode) {

if (frequency[i] == mode)

multiMode +=1;

else {

mode = frequency[i];

multiMode = 1;

}

}

}

if (multiMode ==1 ) {

modeData = new double[1];

} else {

modeData = new double[multiMode];

}

int j =0;

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

if (frequency[i] == mode) {

modeData[j] = mData[i];

j = j+1;

}

}

}

// ===========Measure of variation =====

/** find range of data */

private void findRange(){

if (isClassified == false) findFrequency( );

range = data[0] - data[data.length-1];

}

/** find standard deviation of data */

private void findSD() {

double sumDifference=0;

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

sumDifference += (data[i] - mean)*(data[i]-mean);

}

sd = sqrt(sumDifference/(double)(numData-1));

}

// ========== Some parameter inference statistics ==========

/** Compute the area between 2 statistic z value

* @param lower_z lower limit of area

* @param upper_z upper limit of area

* @ return area under normal curve between 2 value of z

*/

public double findAreaUnderNormalCurve(double lower_z, double upper_z) {

Function normalFunction = new Function() {

public double Of(double x) {

return (1/sqrt(2.0*PI)*exp(-(x*x)/2.0));}

};

Simpson1_3Integration si = new Simpson1_3Integration (normalFunction,lower_z, upper_z,1000);

return (si.getIntegrationResult());

}

/** finding statistic Z of any data x

* @param x any data x

* @return z value statistic Z

*/

public double findZ(double x){

return ( x - mean)/sd;

}

/** finding statistic Z value at known area under normal curve

* @param area the area under normal curve should be between 0 to 1.

* @return z value at known area

*/

public double findZAtKnownArea (double area) throws SimpleStatException {

boolean isAreaGreaterThanHalf = false;

double lowerLimit=0;

double newArea=0;

double deltaX;

double z=0 , sumArea=0;

double dA;

if ( area < 0 || area >1 ) throw new SimpleStatException(SimpleStatException.BAD_AREA);

if (area > 0.5){

newArea = area - 0.5;

isAreaGreaterThanHalf = true;

} else {

newArea = 0.5 - area;

}

if (newArea >= 0.01993880583837) {

lowerLimit = 0.05;

sumArea = 0.01993880583837;

}

if (newArea >= 0.09870632568292) {

lowerLimit = 0.25;

sumArea = 0.09870632568292;

}

if (newArea >= 0.19146246127401) {

lowerLimit = 0.5;

sumArea = 0.19146246127401;

}

if (newArea >= 0.34134474606854 ) {

lowerLimit = 1.0;

sumArea = 0.34134474606854;

}

if (newArea >= 0.43319279873114) {

lowerLimit = 1.5;

sumArea = 0.43319279873114;

}

if (newArea >= 0.47724986805182) {

lowerLimit = 2;

sumArea = 0.47724986805182;

}

if (newArea >= 0.48609655248650) {

lowerLimit = 2.2;

sumArea = 0.48609655248650;

}

if (newArea >= 0.48927588997832) {

lowerLimit = 2.3;

sumArea = 0.48927588997832;

}

if (newArea >= 0.49180246407540) {

lowerLimit = 2.4;

sumArea = 0.49180246407540;

}

if (newArea >= 0.49379033467422) {

lowerLimit = 2.5;

sumArea = 0.49379033467422;

}

if (newArea >=0.49653302619696) {

lowerLimit = 2.7;

sumArea = 0.49653302619696;

}

if (newArea >=0.49744486966957) {

lowerLimit = 2.8;

sumArea =0.49744486966957 ;

}

if (newArea >=0.49813418669962) {

lowerLimit = 2.9;

sumArea =0.49813418669962 ;

}

if (newArea >= 0.49865010196837) {

lowerLimit = 3;

sumArea = 0.49865010196837;

}

if (newArea >=0.49903239678678 ) {

lowerLimit = 3.1;

sumArea = 0.49903239678678;

}

if (newArea >= 0.49931286206208) {

lowerLimit = 3.2;

sumArea = 0.49931286206208;

}

if (newArea >= 0.49951657585762) {

lowerLimit = 3.3;

sumArea = 0.49951657585762;

}

z = lowerLimit;

deltaX = 0.00001;

while( newArea - sumArea > CommonConstants.DEFAULT_TOLERANCE) {

dA = (1/sqrt(2*PI))*0.5*deltaX*(exp(-0.5*z*z) + exp(-0.5*(z+deltaX)*(z+deltaX)));

sumArea += dA;

z += deltaX;

}

// System.out.println(" z in method = " + z);

// System.out.println(" Sumarea = " + sumArea);

if (isAreaGreaterThanHalf) return z+deltaX;

else return -(z+deltaX);

}

// ========= Getter ==============

public double getMean(){ return mean;}

public double getMedian() { return median;}

public double getStandardDeviation( ){ return sd;}

public double getRange() { return range;}

public int getFrequencyOfMode() { return mode;}

public double[] getModeData(){ return modeData;}

public double[] getSortedData( ) { return data;}

public double[]getManagedData() { return mData;}

public int[ ] getFrequency() { return frequency;}

public int[] getCumulativeFrequency() { return cFrequency;};

public int getnumDataAtLast() { return numDataAtLast;};

}