datatab.c

vc的源代码程序的基于最小特征向量的元素的集合方法的程序源代码

#include "dataTab.h"

void DataTable::copyExtended(DataTable &tbl)
{
	register int r,c;

	setRow( tbl.numOfRows());
	setCol( tbl.numOfColumns()+1);

	if(head == NULL) head = alloc();
	else { dealloc(head); head = alloc(); }

	for(r=0;r<Row();r++) 
		for(c=0;c<Col()-1;c++) 
			head[r][c] = tbl.value(r, c);
}

void DataTable::copy(DataTable &tbl)
{
	register int r,c;

	setRow( tbl.numOfRows());
	setCol( tbl.numOfColumns());

	if(head == NULL) head = alloc();
	else { dealloc(head); head = alloc(); }

	for(r=0;r<Row();r++) 
		for(c=0;c<Col();c++) 
			head[r][c] = tbl.value(r, c);

}

// The stream must be writable
void DataTable::printDataTableRowToOutStream(FILE *fp, int r)
{
	int c, nC = Col() - 1;
	for(c=0;c<nC;c++) 
		fprintf( fp, "%g,", head[r][c]);
	fprintf( fp, "%g\n", head[r][c]);
}

void DataTable::printDataTableToOutStream(FILE *fp)
{
	register int r,c;
	int nC = Col() - 1;

	for(r=0;r<Row();r++) 
	{
		for(c=0;c<nC;c++) 
			fprintf( fp, "%g,", head[r][c]);
		fprintf( fp, "%g\n", head[r][c]);
	}
}

void DataTable::printDataTable(char *fn, char *prefix)
{
	FILE *fp;
	if(fn == NULL) fp = stdout; 
	else {  
		char fname[2048];
		fname[0] = 0;
		if(prefix)
			strcpy(fname, prefix);
		else
		// default will be used by discretization
		//farhad strcpy(fname, "disc_");
		//before it was disc_filename
		//now I have changed to filename.disc  
		    strcpy(fname, fn);
		strcat(fname, ".disc");
		fp = fopen(fname, "w+");
		ERROR2(fp, "File %s: cannot be opened for writing!\n",
										fname);
	}

  printDataTableToOutStream(fp);
	
	fclose(fp);
}


void DataTable::Swap(int a, int b)
{
  Description *tmp;

  tmp = head[a];
  head[a] = head[b];
  head[b] = tmp;
}

void DataTable::QSort(int first, int last, int column)
{
	int lower=first;
	int upper=last;

	Description mid = head[(first+last)/2][column];

	while (lower<=upper) {
		while (head[lower][column]<mid)
			lower++;
		while (mid<head[upper][column])
			upper--;
		if (lower<upper) {
			Swap(lower, upper);
			upper--;
		}
		lower++;
	}

	if (first<upper) QSort(first, upper, column);
	if (upper+1<last) QSort(upper+1, last, column);
}

void DataTable::sort(int column)
{
	QSort(0, Row()-1, column);
}

void DataTable::sortWithClass(int column)
{
	QSortWithClass(0, Row()-1, column);
}

void DataTable::QSortWithClass(int first, int last, int column)
{
	int lower=first;
	int upper=last;

	Description mid = head[(first+last)/2][column];
	Description midC = head[(first+last)/2][Col()-1]; // the class

	while (lower<=upper) {
		while (head[lower][column]<mid||
			(head[lower][column]==mid &&
			 head[lower][Col()-1]<midC))
			lower++;
		while (mid<head[upper][column]||
			(head[upper][column]==mid &&
			 head[upper][Col()-1]>midC))
			upper--;
		if (lower<upper) {
			Swap(lower, upper);
			upper--;
		}
		lower++;
	}

	if (first<upper) QSortWithClass(first, upper, column);
	if (upper+1<last) QSortWithClass(upper+1, last, column);

}

void DataTable::getMaxMin(int column, Description *max,
								Description *min)
{
	*max = *min = value(0,column);

	for(int r=1; r<Row(); r++)
	{
		Description v = value(r,column);
		if(v> *max) *max = v;
		else if(v< *min) *min = v;
	}
}
				
void DataTable::Normalize()
{
	Description Max, Min;

	for(int c=0; c<Col()-1; c++) // exclude the class column
	{
		getMaxMin(c, &Max, &Min);
		Description mx = fabs(Max), mn = fabs(Min), v;
		v = (mx>mn)?mx:mn;
		if(mx <= 1 && mn <= 1)
		{
			normalVec[c] = 0;
			continue; // ingore
		}

		normalVec[c] = v; // record it down

		// also normalize it
		for(int r=0; r<Row(); r++)
			head[r][c] = value(r,c)/v;
	}
}

void DataTable::reportInconsistencyRate()
{
	int classCol = Col() - 1;
	sort(classCol);

	int n_Errors=0;
	int *mark = new int [Row()];

#ifdef DBG
	cout << "Total number of instances: " << Row() <<endl;
#endif
	for(int r=0; r<Row(); r++)
	{
		Description h = value(r, classCol);
		for(int r1=r+1; r1<Row(); r1++)
		{
			if(!mark[r1]) // never marked
			if(h != value(r1, classCol))  // different class value
				if(value(r, classCol) == value(r1, classCol)) {
					mark[r1] = 1;
					n_Errors++;
				}
		}
	}
	cout << "Number of errors: " <<n_Errors <<endl;
}

float DataTable::getInconsistencyRate()
{
	int classCol = Col() - 1;
	sort(classCol);

	int n_Errors=0;
	int *mark = new int [Row()];

#ifdef DBG
	cout << "Total number of instances: " << Row() <<endl;
#endif
	for(int r=0; r<Row(); r++)
	{
		Description h = value(r, classCol);
		for(int r1=r+1; r1<Row(); r1++)
		{
			if(!mark[r1]) // never marked
			if(h != value(r1, classCol))  // different class value
				if(value(r, classCol) == value(r1, classCol)) {
					mark[r1] = 1;
					n_Errors++;
				}
		}
	}

	return (float)n_Errors/Row();
}

void DataTable::printSee(int begin, int end, int c)
{
	for(int r = begin; r<=end; r++) // r will be increment by 1
		cout << value(r,c) << "-" << value(r, Col()-1) <<endl;
	cout << "------\n";
}