problem1.h

文化算法的实际应用

#ifndef CAEP_PROBLEM_H
#define CAEP_PROBLEM_H

#include <cmath>
#include <iostream>
#include <algorithm>
#include "config.h"
#include "cell.h"

using namespace std;

namespace CAEP
{
	class Individual
	{
	private:

	public:
		float mValue;
		vector<float> mConstraints;
		float mViolation;
		bool mIsFeasible;
		Cell *mCell;
		int mVictoryCount;
		vector<float> mVariables;
		Configer &mConfiger;
		
		Individual(Configer &cfg):mConfiger(cfg),mConstraints(cfg.ConstraintCount),mVariables(cfg.VariableCount)
		{
		}
		
		static void Limit(vector<float>& low, vector<float>& high)
		{
			int i;
			for (i = 0; i < 9; i++) {
				low[i] = 0.0;
				high[i] = 1.0;
			}
			for (i = 9; i < 12; i++) {
				low[i] = 0.0;
				high[i] = 100.0;
			}
			low[12] = 0.0;
			high[12] = 1.0;
		}

		bool operator <(Individual& b)
		{
			if(b.mIsFeasible && mIsFeasible) { return b.mValue > mValue; }

			if(mIsFeasible) { return 1; }
			if(b.mIsFeasible) { return -1; }

			return b.mValue < mValue;
		}

		static void SetConfiger(Configer *cfg)
		{
			cfg->VariableCount = 13;
			cfg->ConstraintCount = 9;
			cfg->EqConstraintCount = 0;
			cfg->TestTreeCount = 13;
			cfg->MaxDepth = 5;
			cfg->TreeDim = 3;
			cfg->TreeNodeCount = 8;
			cfg->PopulationSize = 100;
			cfg->TopCount = 3;
			cfg->IsTrustIndividual = true;
		}

		void Evaluate()
		{
			int i;
			float s1 = 0.0, s2 = 0.0, s3 = 0.0;
			float delta = 0.001; // For the equality restrictions  

			for (i = 0; i < 4; i++) {
				s1 += mVariables[i];
				s2 += mVariables[i]*mVariables[i];
			}
			for (i = 4; i < 13; i++) {
				s3 += mVariables[i];
			}

			mValue  = 5*s1 - 5*s2 - s3;

			mConstraints[0] = 2*mVariables[0] + 2*mVariables[1] + mVariables[9] + mVariables[10] - 10;
			mConstraints[1] = 2*mVariables[0] + 2*mVariables[2] + mVariables[9] + mVariables[11] - 10;
			mConstraints[2] = 2*mVariables[1] + 2*mVariables[2] + mVariables[10] + mVariables[11] - 10;
			mConstraints[3] = -8*mVariables[0] + mVariables[9];
			mConstraints[4] = -8*mVariables[1] + mVariables[10];
			mConstraints[5] = -8*mVariables[2] + mVariables[11];
			mConstraints[6] = -2*mVariables[3] - mVariables[4] + mVariables[9];
			mConstraints[7] = -2*mVariables[5] - mVariables[6] + mVariables[10];
			mConstraints[8] = -2*mVariables[7] - mVariables[8] + mVariables[11];

			mIsFeasible = 1;
			for (i = 0; i < mConfiger.ConstraintCount; i++) {
				if (i < mConfiger.ConstraintCount - mConfiger.EqConstraintCount) {
					if (mConstraints[i] > 0) {
						mIsFeasible = false;
						break;
					}
				}
				else {
					if (fabs(mConstraints[i]) - delta > 0) {
						mIsFeasible = false;
						break;
					}
				}
			}
		}

		void Violation(vector<float> max)
		{
			int i;
			float v;

			if (mConfiger.IsTrustIndividual) {
				return;
			}

			mViolation = 0;

			for (i = 0; i < mConfiger.ConstraintCount; i++) {
				// Inequiality constraints 
				if (i < mConfiger.ConstraintCount - mConfiger.EqConstraintCount) {
					v = (mConstraints[i] > 0)? mConstraints[i]: 0;
				}
				// Equality constraints
				else {
					v = fabs(mConstraints[i]);
				}

				if (v > max[i]) {
					max[i] = v;
				}
				mViolation += v/max[i];
			}
		}
	};
}

#endif