sacode.h

一个有关生产排序的模拟退火算法

#include <vector>
using namespace std;


struct SYCoordinate		////城市坐标，在这里改为坯料的硬度,宽度,厚度参数
{
	SYCoordinate()
	{
		m_fcodx = 0.0;
		m_fcody = 0.0;
		m_fcodz = 0.0;
	}

	double m_fcodx;
	double m_fcody;
	double m_fcodz;
};

struct Hardpanish		////硬度惩罚
{
	Hardpanish()
	{
		m_fcodx = 0.0;
		m_tcodx = 0.0;
		m_hdPanish = 0.0;
	}

	double m_fcodx;
	double m_tcodx;
	double m_hdPanish;
};

struct WidethpanishP		////宽度惩罚
{
	WidethpanishP()
	{
		m_fcody = 0.0;
		m_tcody = 0.0;
		m_wPanish = 0.0;
	}

	double m_fcody;
	double m_tcody;
	double m_wPanish;
};

struct WidethpanishN		////宽度惩罚
{
	WidethpanishN()
	{
		m_fcody = 0.0;
		m_tcody = 0.0;
		m_wPanish = 0.0;
	}

	double m_fcody;
	double m_tcody;
	double m_wPanish;
};

struct Gaugepanish		////厚度惩罚
{
	Gaugepanish()
	{
		m_fcodz = 0.0;
		m_tcodz = 0.0;
		m_gPanish = 0.0;
	}

	double m_fcodz;
	double m_tcodz;
	double m_gPanish;
};


struct SYCity			////城市索引，改为坯料标号索引,坯料应按一定规则（如硬度降序）排列，然后对应顺序号
{
	SYCity()
	{
		m_nIndex = 0;
		m_strName.Empty();
	}

	int m_nIndex;					//城市编号 顺序号
	CString m_strName;				//城市名称 坯料号
	SYCoordinate m_Coordinate;		//城市坐标 
};

struct SYCityDistance	////城市间距离，改为惩罚函数值
{
	SYCityDistance()
	{
		m_nFromCity = 0;
		m_nToCity = 0;
		m_fDistance = 0.0;
		m_hdPanish = 0.0;
		m_wPanish = 0.0;
		m_gPanish = 0.0;
	}

	int m_nFromCity;				//源城市           ////改为前一块坯料
	int m_nToCity;					//目标城市		   ////改为后一块坯料
	double m_fDistance;				//城市之间的距离   ////惩罚函数值
	double m_hdPanish;				////硬度惩罚函数值
	double m_wPanish;				////宽度惩罚函数值
	double m_gPanish;				////厚度惩罚函数值
};

typedef std::vector<int>	CityRouterDef;	////坯料路径定义

void InitialSA();
void CreateCityRouter( CityRouterDef &CityRouter );
void CreateCityRouter2opt( CityRouterDef &preCityRouter, CityRouterDef &CityRouter );
double CountTotalDistance( CityRouterDef &CityRouter );
double CountCityDistance( SYCity &FromCity, SYCity &ToCity, SYCityDistance &CityDistance );
double FindCityDistance( int FromCityIndex, int ToCityIndex );
double CountInitialTemperature();
double CountDownTemperature( int DownMode );
BOOL JudgeOverInnerLoop( int JudgeMode );
BOOL JudgeOverExternalLoop( int JudgeMode );

struct SYRouter
{
	SYRouter()		////构造函数，初始化
	{
		m_CityRouter.clear();
		m_fTotalDistance = 0.0;
		m_fTemperature = 0.0;
		m_nExternalIterNumber = 0;
		m_nInnerIterNumber = 0;
	}

	SYRouter( double nowTemp,
			  int nowExtIterNum,
			  int nowInIterNum )	////(当前温度，当前外循环次数，当前内循环次数)
	{
		CreateCityRouter( m_CityRouter );	////创建(初始化)城市路径,改为初始化坯料顺序
		m_fTotalDistance = CountTotalDistance( m_CityRouter );  ////计算路径总的距离，改为计算总的惩罚函数值
		m_fTemperature = nowTemp;
		m_nExternalIterNumber = nowExtIterNum;
		m_nInnerIterNumber = nowInIterNum;

	}

	SYRouter( CityRouterDef &preCityRouter,
			  double nowTemp,
			  int nowExtIterNum,
			  int nowInIterNum )   ////(前一个路径,当前温度,当前外循环数,当前内循化数)
								   ////改为(前一个轧制顺序排列,当前温度,当前外循环数,当前内循环数)
	{
		CreateCityRouter2opt( preCityRouter, m_CityRouter ); ////生成下一个路径(当前路径)
		m_fTotalDistance = CountTotalDistance( m_CityRouter );////计算总的距离数,---总的惩罚函数值
		m_fTemperature = nowTemp;
		m_nExternalIterNumber = nowExtIterNum;
		m_nInnerIterNumber = nowInIterNum;
	}

	void operator=(const SYRouter& srcRouter)
	{
		m_CityRouter = srcRouter.m_CityRouter;
		m_fTotalDistance = srcRouter.m_fTotalDistance;
		m_fTemperature = srcRouter.m_fTemperature;
		m_nExternalIterNumber = srcRouter.m_nExternalIterNumber;
		m_nInnerIterNumber = srcRouter.m_nInnerIterNumber;
	}

	CityRouterDef m_CityRouter;
	double m_fTotalDistance;
	double m_fTemperature;
	int m_nExternalIterNumber;
	int m_nInnerIterNumber;
};