nearest.cpp

DNA分类

// CNearest.cpp: implementation of the CNearest class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "DNAClassification.h"
#include "Nearest.h"
#include"util.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CNearest::CNearest()
{
	training = NULL;
	m_nK = 1;
}

CNearest::~CNearest()
{
	Clear();
}

BOOL CNearest::Training(double **ppSample, int *pClass, int n, int c)
{
	training=Alloc2D(n,c+1,0);
	NumTraining=n;
	NumDim=c;
	for(int i=0;i<NumTraining;i++)
	{
		for(int j=0;j<NumDim;j++)
			training[i][j]=ppSample[i][j];
		training[i][NumDim]=pClass[i];
		double dRate = (double)((double)i/NumTraining);
		ReportStatus(&dRate);
	}
	return TRUE;   
}


void CNearest::Clear()
{
	if(training)
		Delete2D(training,NumTraining);
}
//////////////////
/*BOOL CNearest::Classify(double **ppTestSample, int *pClass, int n, int c)
{
	double *distance;
	int i,j,temp,test;
	distance=new double[NumTraining];
	NumClassify=n;
	for(test=0;test<NumClassify;test++)
	{	

		for(i=0;i<NumTraining;i++){
			distance[i]=0;
			for(j=0;j<NumDim;j++)		 
				distance[i]+=(training[i][j]-ppTestSample[test][j])*(training[i][j]-ppTestSample[test][j]);							
		}		 
		temp=0;			
		for(i=1;i<NumTraining;i++)
			if(distance[i]<distance[temp])temp=i;
		pClass[test]=(int)training[temp][NumDim];
	}
	delete []distance;
	return TRUE;
}
*/
////////////////////////////
BOOL CNearest::Classify(double **ppTestSample, int *pClass, int n, int c)
{
	double *distance,maxdis;
	int i,j,*temp,*distemp,test,max,types[4];
	distance=new double[NumTraining];
	temp=new int[m_nK];
	distemp=new int[m_nK];
	for(i=0;i<4;i++)types[i]=0;
	NumClassify=n;
	for(test=0;test<NumClassify;test++)
	{	

		for(i=0;i<NumTraining;i++){
			distance[i]=0;
			for(j=0;j<NumDim;j++)		 
				distance[i]+=(training[i][j]-ppTestSample[test][j])*(training[i][j]-ppTestSample[test][j]);							
		}		 
		
		max=0;
		for(i=1;i<NumTraining;i++)
			if(distance[i]>distance[max])max=i;
		maxdis=distance[max];//
		for(i=0;i<m_nK;i++){	
			temp[i]=0;		
			for(j=1;j<NumTraining;j++)
				if(distance[j]<distance[temp[i]])temp[i]=j;
			distance[temp[i]]=maxdis;
		}//
		for(i=0;i<m_nK;i++)
			temp[i]=(int)training[temp[i]][NumDim];//temp will be the types
		for(int tFlag=0;tFlag<4;tFlag++)
			for(i=0;i<m_nK;i++)
				if(temp[i]==tFlag)types[tFlag]++;
		
		max=0;
		for(tFlag=1;tFlag<4;tFlag++)
			if(types[tFlag]>types[max])max=tFlag;
		max=types[max];//max will be the numbers of the largest nearest neighbour

		for(i=0;i<m_nK;i++)
			if(types[temp[i]]==max)distemp[i]=max;
		for(i=0;i<m_nK;i++)if(distemp[i]==max){
				//max=i;
				break;
		}
		pClass[test]=temp[i];
	}
	delete []distance;
	return TRUE;
}