adhoc.h

拓扑结构

#ifndef ADHOC_H
#define ADHOC_H

#include <iostream>
#include <fstream>

#include <string>
#include <math.h>
#include <time.h>



	const static double radiusValve = 8.0;	//半径阀值
	const static double radiusMax = 15.0;	//最大半径值
	const static int MaxsumOfNode=20;
	using namespace std;

	class Adhoc

	{

	public:
	Adhoc(const int);
	~Adhoc();

						//构造函数

	double Evaluate( const double [] );
						//计算染色体测量值的适应度

	int Adhoc::InputAdhoc();	//由指定文件中读入Ad Hoc网络的节点位置
//	int Adhoc::SaveToFile( ostream& outFile)
	//PrintPosition();	//打印节点位置矩阵
	//PrintDistance();	//打印距离矩阵
	//PrintAdjacency();	//打印邻接矩阵
	//PrintConnexity();	//打印连通矩阵
	
					
	int MakeDistance();
						//由位置矩阵position[sumOfNode][2]求
						//距离矩阵distance[sumOfNode][sumOfNode]
	int MakeAdjacency( const double [] );
						//求邻接矩阵
	int MakeConnexity();
						//求连通矩阵
	int MatrixMultiplication( int [][MaxsumOfNode], 
		int [][MaxsumOfNode], int [][MaxsumOfNode] );





private:
	
	int sumOfNode;				//节点总数
	double radius[MaxsumOfNode];       //节点的辐射半径
	double position[MaxsumOfNode][2];		//节点的位置信息，(x,y)坐标形式
	double distance[MaxsumOfNode][MaxsumOfNode];	//节点两两之间的距离
	int adjacency[MaxsumOfNode][MaxsumOfNode];	//由节点半径，求节点形成的邻接矩阵
	int connexity[MaxsumOfNode][MaxsumOfNode];	//邻接矩阵的n次幂，
							//用于判断网络是否连通

	

						//矩阵相乘


};



//构造函数
Adhoc::Adhoc(const int nodenum)
{
	sumOfNode=nodenum;
	Adhoc::InputAdhoc();
//	int num;
//	srand(unsigned(time(NULL)));
//	for(num=0;num<sumOfNode;num++)
//	for(int i=0;i<2;i++)
//	position[num][i]=rand()%32;
	MakeDistance();

	
};

Adhoc::~Adhoc()
{
}


int Adhoc::MakeDistance()
{
	int num1;
	int num2;

	for ( num1 = 0 ; num1 < sumOfNode ; num1++ )
	{
		for ( num2 = 0 ; num2 < sumOfNode ; num2++ )
		{
			if ( num1 < num2 )
				distance[ num1 ][ num2 ] = sqrt(
				( position[ num1 ][0] - position[ num2 ][0] ) * 
				( position[ num1 ][0] - position[ num2 ][0] ) +
				( position[ num1 ][1] - position[ num2 ][1] ) *
				( position[ num1 ][1] - position[ num2 ][1] ));
			else if ( num1 == num2 )
				distance[ num1 ][ num2 ] = 0;
			else if ( num1 > num2 )
				distance[ num1 ][ num2 ] = distance[ num2 ][ num1 ];
		};
	};

	return 1;
};

int Adhoc::InputAdhoc()
{
	char string[10];
	int num;
	
	num = 0;

	ifstream sourceFile(".\\node.txt");
	if ( sourceFile.fail() )
		return 0;
	else
	{
		
		while ( !sourceFile.eof() ) 
		{
			sourceFile >> string >> position[ num ][0]
				>> string >> position[ num ][1] >> string;
			num++;
		};
	};
	return 1;
};

/*int Adhoc::SaveToFile( ostream& outFile)
{
	int num1;
	int num2;
	
	outFile << "~~~~~~~~~~~~~~~~~~~~" << endl ;
	for ( num1 = 0 ; num1 < MaxsumOfNode ; num1 ++ )
	{
		for ( num2 = 0 ; num2 < MaxsumOfNode ; num2 ++ )
		{
			outFile <<	adjacency[ num1 ][ num2 ] << ' ';			
		};
		outFile << endl;
	}
	outFile << "~~~~~~~~~~~~~~~~~~~~"<< endl ;

	for ( num1 = 0 ; num1 < MaxsumOfNode ; num1 ++ )
	{
		for ( num2 = 0 ; num2 < MaxsumOfNode ; num2 ++ )
		{
		outFile <<	connexity[ num1 ][ num2 ] << ' ';			
		};
		outFile << endl;
	};
	outFile << "~~~~~~~~~~~~~~~~~~~~";
	return 1;

};*/

int Adhoc::MakeAdjacency(const double radius[])
{
	int num1;
	int num2;

	for ( num1 = 0 ; num1 < sumOfNode ; num1 ++ )
	{
		for ( num2 = 0 ; num2 < sumOfNode ; num2 ++ )
		{
			if ( num1 == num2 )
				adjacency[ num1 ][ num2 ] = 1;
			else if ( radius[ num1 ] < distance[ num1 ][ num2 ] )
				adjacency[ num1 ][ num2 ] = 0;
			else
				adjacency[ num1 ][ num2 ] = 1;
		};
	}

	return 1;
};


int Adhoc::MakeConnexity()
{
	int num1;
	int num2;
	int times;		//矩阵相乘的次数
	int matrix[MaxsumOfNode][MaxsumOfNode];

	for ( num1 = 0 ; num1 < sumOfNode ; num1++ )
		for ( num2 = 0 ; num2 < sumOfNode ; num2++ )
			connexity[ num1 ][ num2 ] = adjacency[ num1 ][ num2 ];

	for ( times = 1 ; times <= sumOfNode - 1 ; times++ )
	{
		MatrixMultiplication( connexity, adjacency, matrix );
		for ( num1 = 0 ; num1 < sumOfNode ; num1++ )
			for ( num2 = 0 ; num2 < sumOfNode ; num2++ )
			connexity[ num1 ][ num2 ] = matrix[ num1 ][ num2 ];
	};		

	return 1;
			
}

int Adhoc::MatrixMultiplication( int matrixA[][MaxsumOfNode], 
		int matrixB[][MaxsumOfNode], int result[][MaxsumOfNode])
{
	int num1;
	int num2;
	int num3;

	for ( num1 = 0 ; num1 < sumOfNode ; num1++ )
		for ( num3 = 0 ; num3 < sumOfNode ; num3++ )
		{
			result[ num1 ][ num3 ] = 0;
			for ( num2 = 0 ; num2 < sumOfNode ; num2++ )
				result[ num1 ][ num3 ] =  result[ num1 ][ num3 ] || 
				( matrixA[ num1 ][ num2 ] && matrixB[ num2 ][ num3 ]);
		};

	return 1;
};


//
double Adhoc::Evaluate( const double radius[] )
{
	int sumOfNodeOverValue;		//超过阀值半径的节点数
	double sumOfPower;		//网络中所有节点的辐射功率
	int sumOfConnected;		//连通的节点数
	double maxPower;			//理论上所能达到的最大功率

	double factorNode;
	double factorPower;
	double factorConnexity;
	
	int num1;
	int num2;

	double ret;					//返回值

	
	MakeAdjacency( radius );
	MakeConnexity();


	sumOfNodeOverValue = 0;
	sumOfPower = 0;
	for ( num1 = 0 ; num1 < sumOfNode; num1++ )
	{
		if ( radius[ num1 ] > radiusValve )
			sumOfNodeOverValue++;
		sumOfPower = sumOfPower + radius[ num1 ] * radius[ num1 ] *
			radius[ num1 ] * radius[ num1 ];
	};

	maxPower = radiusMax * radiusMax * radiusMax * 
		radiusMax * sumOfNode;

	sumOfConnected = 0;
	for ( num1 = 0 ; num1 < sumOfNode; num1++ )
		for ( num2 = 0 ; num2 < sumOfNode; num2++ )
		{
			if ( connexity[ num1 ][ num2 ] == 1 )
				sumOfConnected++ ;
		};

	if ( sumOfConnected ==  ( sumOfNode * sumOfNode ) ) 
	{
		factorNode = 0.15;
		factorPower = 0.10;
		factorConnexity = 0.75;
	}
	else
	{
		factorNode = 0.15;
		factorPower = 0.10;
		factorConnexity = 0.5;
	};

	ret = (double)5*((( 1 - (float)sumOfNodeOverValue / sumOfNode ) * factorNode
			+ ( 1 - (float)sumOfPower / maxPower ) * factorPower +
			(float)sumOfConnected / ( sumOfNode * sumOfNode ) *
			factorConnexity ) * sumOfNode );
//	cout<<"factorNode is"<<factorNode<<"factorPower is "<<factorPower<<"factorConnexity is "<<factorConnexity<<"fitness is "<<ret ;

//	cout<<"ret is"<<ret<<"   ";
	return ret;
};



#endif