comm.cpp

HOPFIELD的一个经典用例

#include "comm.h"
#include <stdlib.h>
#include <time.h>
#include <IOSTREAM.H>

int BestRes = 0;
int BestWeight = 0;
int Array_BestRes[NUMBER];

#define RandCount	50
int Array_Tmp[FIELD];

int Array_Value[NUMBER];

int Array_Weight[NUMBER] = 
	{253,245,243,239,239,239,238,238,237,232,
 231,231,230,229,228,227,224,217,213,207,
 203,201,195,194,191,187,187,177,175,171,
 169,168,166,164,161,160,158,150,149,147,
 141,140,139,136,135,132,128,126,122,120,
 119,116,116,114,111,110,105,105,104,103,
 93,92,90,79,78,77,76,76,75,73,
 62,62,61,60,60,59,57,56,53,53,
 51,50,44,44,42,42,38,36,34,28,
 27,24,22,18,12,10,7,4,4,1};	

int Array_Field[FIELD][NUMBER] ;
double	Array_Validate[FIELD];

int GetCurWeight()
{
	return BestWeight;
}

void GetDom(int* s)
{
	for(int k=0;k<NUMBER;k++)
		s[k] = Array_BestRes[k];
}

double FloatRand()
{
	int k = rand() ;
	return ((float)k / RAND_MAX);
}

int IntRand(int nRange)
{
	int k = rand() ;
	return int(k / RAND_MAX * nRange);
}

void Rand_Tmp()
{
	int i,j,tmp;

	for(int d=0;d<RandCount;d++)
	{
		i = IntRand(FIELD-1);
		j = IntRand(FIELD-1);
		tmp = i;
		i = j;
		j = tmp;
	}
}

void DoValidate()	//	求适应度
{
	for(int k=0; k<FIELD; k++)
	{
		double v_sum = 0;
		double w_sum = 0;
		
		for(int j=0; j<NUMBER; j++)
		{
			if(Array_Field[k][j]>0)
			{
				v_sum += Array_Value[j];
				w_sum += Array_Weight[j];
			}
		}

		//	Do some validate func

		if(w_sum<=OVERBAG)
		{
			Array_Validate[k] = v_sum;
			if(v_sum>BestRes)
			{
				BestRes = v_sum;
				BestWeight = w_sum;
				for(int b=0;b<NUMBER;b++)
					Array_BestRes[b] = Array_Field[k][b];
			}
		}
		else
			Array_Validate[k] = 1 / (double)w_sum;
	}
}
void init2()	//	初始化
{
	srand( (unsigned)time( NULL ) );

	for(int k=0; k<NUMBER; k++)
		Array_Value[k] = 1;

	int y,r;
	for(y=0; y<FIELD; y++)
	{
		for(r=0; r<NUMBER; r++)
		{
			if(FloatRand()<0.5)
				Array_Field[y][r] = 1;
		}
	}	

	BestRes = 0;
	BestWeight = 0;
}

int DoGA()
{
	int k,c1,c2,tmp;
	double sum_validate;
	
	for(int v=0;v<T;v++)
	{

	for(k=0; k< FIELD/2; k++)
	{
		if(FloatRand()<=Pc)
		{
			c1 = IntRand(NUMBER);
			c2 = IntRand(NUMBER);
			
			if(c1>c2)
			{
				tmp = c2;
				c2 = c1;
				c1 = tmp;
			}


			for(int h=c1;h<=c2;h++)	//	Two points cross-over
			{
				tmp = Array_Field[k][h];
				Array_Field[k][h] = Array_Field[k+1][h];
			}
		}
	}
 
//	DoValidate();
//	for(k=0; k<FIELD; k++)
//		cout << Array_Validate[k] << " ";
//	cout << endl << "=======================================" << endl;

	for(k=0; k< FIELD; k++)	//	point mutation
	{
		for(tmp=0; tmp< NUMBER; tmp++)
			if(FloatRand()<Pm)
			{
				Array_Field[k][tmp] = 1 - Array_Field[k][tmp];
			}
	}
	
	DoValidate();
//	for(k=0; k<FIELD; k++)
//		cout << Array_Validate[k] << " ";
//	cout << endl << "=======================================" << endl;

	//	比例选择
	/*
	sum_validate = 0;
	for(k=0; k<FIELD; k++)
		sum_validate += Array_Validate[k];
	int a = 0;
	for(k=0; k<FIELD; k++)
	{
		int p = 1;
		double r = Array_Validate[k] / sum_validate * FIELD + 0.5;
		//cout << Array_Validate[k] << ":" << r << endl;
		while(p<=int(r) && a<FIELD)
		{
			Array_Tmp[a] = k;
			a++;
			p++;
		}
	}
	Rand_Tmp();
	for(k=0;k<FIELD;k++)
	{
		int h = Array_Tmp[k];
		for(tmp=0;tmp<NUMBER;tmp++)
		{
			Array_Field[k][tmp] = Array_Field[h][tmp];
		}
	}
	*/
	
	//由于直接使用比例选择在这个适应度函数下效果并不好
	//故目前采用了排序型选择的（末位淘汰）方法
	
	double min = 100000;
	double max = -1;
	int in,ax;
	in = 0, ax = 0;

	for(k=0; k<FIELD; k++)
	{
		if(Array_Validate[k]<min)
		{
			min = Array_Validate[k];
			in = k;
		}
		if(Array_Validate[k]>max)
		{
			max = Array_Validate[k];
			ax = k;
		}
	}

	for(k=0;k<NUMBER;k++)
		Array_Field[in][k] = Array_Field[ax][k];

	}


	//DoValidate();
	//for(k=0; k<FIELD; k++)
	//	cout << Array_Validate[k] << " ";
	//cout << endl << "=======================================" << endl;
	
	cout << "Best Answer is: " << BestRes << ".   The weight is: " << BestWeight << endl;
	for(k=0; k<NUMBER; k++)
		cout << Array_BestRes[k] << " ";
	cout << endl;

	return BestRes;
}