datapoints.java

RBFN for nuro analysis

import java.io.*;
import java.util.*;
class DataPoints{
	private Point points[]=new Point[1003];
	private Point TPoints[]=new Point[1003];
	private double x[][]=new double[4][1003];
	private double result[]=new double[1003];
//	private double TrainingSet[][];
//	private double TestingSet[][];
//	private int y0[]=new int[1001];
//	private int y1[]=new int[1001];
	private int NTrainingSet=0;
	private int dim=0;    //number of token per line
	private int MaxClusterNum=0;
	private int Lcount=0; 	//total input line 
	private int CLcount[];   //input line per cluster
	private int TrainingCount=0;
	private int TestingCount=0;
	private String FileName="";
public DataPoints(String fileName) {
	FileName=fileName;
}
/*
public String ReadLn(int maxLength){  // utility function to read from stdin,
        // Provided by Programming-challenges, edit for style only
	byte line[] = new byte [maxLength];
	int length = 0;
	int input = -1;
	try{
		while (length < maxLength){//Read untill maxlength
			input = System.in.read();
			if ((input < 0) || (input == '\n')) break; //or untill end of line ninput
			line [length++] += input;
		}

		if ((input < 0) && (length == 0)) return null;  // eof
		return new String(line, 0, length);
	}catch (IOException e){
		return null;
	}
	}
	*/
//	public DataPoints(String FileName) {
		
//	}
public void parse() throws Exception{
	String input;
	StringTokenizer st;
	

	BufferedReader br = new BufferedReader(
            new FileReader(FileName));
//	if(br.ready())
//	{
//		input=br.readLine();
		//st=new StringTokenizer(input);
		//int dim=st.countTokens();
		//for(int i=0;i<dim-1;i++)
		//	double x[][]=new double[4][1000];
		//	double result[]=new double[1000];
//	}
	
	while(br.ready())
	 {
		if((input=br.readLine()) == null)
			break;
		st=new StringTokenizer(input);
		//  R = Integer.parseInt(st.nextToken());
      //  C = Integer.parseInt(st.nextToken());
		//System.out.println("dim"+st.countTokens());
		dim=st.countTokens();
		for(int i=0;i<(dim-1);i++){
			x[i][Lcount]=Double.parseDouble(st.nextToken());
			//points[Lcount].position[i]=x[i][Lcount];
		}
		if(FileName=="800.txt")
			result[Lcount]=Double.parseDouble(st.nextToken())+1;
		else
			result[Lcount]=Double.parseDouble(st.nextToken());
		//points[Lcount].DefaultClassify=result[Lcount];
		if(result[Lcount]>MaxClusterNum) {
			MaxClusterNum=(int)result[Lcount];
			
		}
		Lcount++;
	 }
	CLcount=new int[MaxClusterNum];
	
}

public void DivideTrainingSet() {
	NTrainingSet=(int)(Lcount*0.75);
	points=new Point[NTrainingSet];
	for(int c=0;c<NTrainingSet;c++) {
		points[c]=new Point();
	}
//	TPoints=new TestingPoint[Lcount-NTrainingSet];
	for(int f=0;f<(/*Lcount-*/NTrainingSet);f++) {
		TPoints[f]=new Point();
	}
	Random generator2 = new Random( 123456 );
	   //Number of trainning set
	
//	TrainingSet=new double[dim-1][NTrainingSet];
//	TestingSet=new double[dim-1][Lcount-NTrainingSet];
/*	for(int k=0;k<NTrainingSet;k++) {
		Boolean flag=true; //flag=true will generate random number 
		while(flag) {
		for(int n=0;n) {
			generator2.nextInt(Idata.getLcount())
		}
		}
	}
	*/

	System.out.println("Tpoint_Length:"+(Lcount-NTrainingSet));
	for(int s=0;s<Lcount;s++) {
		
		if(  ((generator2.nextInt(1000)>200) && TrainingCount<NTrainingSet) ||
				(TestingCount>(Lcount-NTrainingSet-1))
				){
			for(int j=0;j<dim-1;j++) {
			//	TrainingSet[j][TrainingCount]=x[j][s];
				points[TrainingCount].position[j]=x[j][s];
				System.out.println("points"+TrainingCount+":"+s+":"+points[TrainingCount].position[j]);
			}
			points[TrainingCount].DefaultClassify=result[s];
		//	points[TrainingCount].DefaultClassify=(points[TrainingCount].DefaultClassify-1)/(MaxClusterNum-1);
			TrainingCount=TrainingCount+1;
		}
		else {
			for(int w=0;w<dim-1;w++) {
			//	TestingSet[w][TestingCount]=x[w][s];
				TPoints[TestingCount].position[w]=x[w][s];
				System.out.println("Tpoint"+TestingCount+":"+TPoints[TestingCount].position[w]);
			}
			TPoints[TestingCount].DefaultClassify=result[s];
			TPoints[TestingCount].FinalClassify=(TPoints[TestingCount].DefaultClassify-1)/(MaxClusterNum-1);
			System.out.println("testingCount:"+TestingCount);
			TestingCount++;
		}
		
	}
	System.out.println("");
//	for(int q=0;q<points.length;q++)
//		System.out.println("Point:"+points[q].position+" , "+points[q].position);
	
}

public int getTrainingCount(){
	return TrainingCount;
}
public int getTestingCount(){
	return TestingCount;
}
public Point[] getPoint() {
	return points;
}
public Point[] getTestPoint() {
	return TPoints;
}
public double[][] getX(){
	return x;
}
public double[] getResult(){
	return result;
}
public int getMaxClusterNum(){
	return MaxClusterNum;
}
public int getLcount(){
	return Lcount;
}
public int[] getCLcount(){
	return CLcount;
}
public int getDim(){
	return dim;
}
}