GenAlg.cpp

#include "GenAlg.h"
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <random>
#include "OptScheduling.h"
#include "FirstOptScheduling.h"

GenAlg::GenAlg(GenType genType):mGenType(genType)
{
    mOptScheduling = std::make_unique<FirstOptScheduling>();
}

double GenAlg::random(int min , int max)
{
    double m1 = (double)(rand() % 101) / 101;                        // 计算 0，1之间的随机小数,得到的值域近似为(0,1)
    min++;                                                                             //将 区间变为(min+1,max),
    double m2 = (double)((rand() % (max - min + 1)) + min);    //计算 min+1,max 之间的随机整数，得到的值域为[min+1,max]
    m2 = m2 - 1;                                                                        //令值域为[min,max-1]
    return m1 + m2;                                                                //返回值域为(min,max),为所求随机浮点
}

void GenAlg::init(int popsize, double MutRate, double CrossRate, int GenLength, double LeftPoint, double RightPoint)
{
    mPopSize = popsize;
    mMutationRate = MutRate;
    mCrossoverRate = CrossRate;
    mChromoLength = GenLength;
    mTotalFitness = 0;
    mGeneration = 0;

    mBestFitness = 0.0;
    mWorstFitness = 99999999;
    mAverageFitness = 0;
    mMaxPerturbation = 0.001;

    mLeftPoint = LeftPoint;
    mRightPoint = RightPoint;

    // 清空种群容器，以初始化  
    vecPop.clear();
    for (int i = 0; i < mPopSize; i++)
    {
        // 类的构造函数已经把适应性评分初始化为0  
        vecPop.push_back(Genome());

        // 把所有的基因编码初始化为函数区间内的随机数。  
        for (int j = 0; j < mChromoLength; j++)
        {
            switch (mGenType)
            {
            case RealValueCoding:
                vecPop[i].vecGenome.push_back(random(0,MAX_RANDOM) * (mRightPoint - mLeftPoint) + mLeftPoint);
                break;
            case BinaryCoding:
                vecPop[i].mBinaryGenVec.push_back((int)random() % 2);
                break;
            default:
                break;
            }
            
        }
    }
}

void GenAlg::mutate(vector<double>& chromo)
{
    // 遵循预定的突变概率,对基因进行突变  
    for (int i = 0; i < chromo.size(); ++i)
    {
       // 如果发生突变的话  
        if (random(0,1) < mMutationRate)
        {
            // 使该权值增加或者减少一个很小的随机数值  
            chromo[i] += ((random() - 0.5) * mMaxPerturbation);

            // 左右边界  
            if (chromo[i] < mLeftPoint)
            {
                chromo[i] = mRightPoint;
            }
            else if (chromo[i] > mRightPoint)
            {
                chromo[i] = mLeftPoint;
            }
        }
    }
}

void GenAlg::mutate(vector<char>& chromo)
{
    // 遵循预定的突变概率,对基因进行突变  
    for (int i = 0; i < chromo.size(); ++i)
    {
        // 如果发生突变的话  
        if (random(0,1) < mMutationRate)
        {
            chromo[i] =( chromo[i]&0x01) ^ 0x01;
        }
    }
}

void GenAlg::select()
{

}

void GenAlg::corssver()
{
    // 染色体个数
    int popSize = vecPop.size();

    // 种群数组的索引
    std::vector<int> randIndexVec;
    for (int i = 0; i < popSize; i++)
        randIndexVec.push_back(i);

    // 随机排序，为了随机配对染色体
    std::random_shuffle(randIndexVec.begin(), randIndexVec.end());

    int left = 0;
    int right = popSize-1;
    while (left < right)
    {
        int indexLeft = randIndexVec[left];
        int indexRight = randIndexVec[right];

        // 两个染色体互换
        crossover(vecPop[indexLeft].mBinaryGenVec, vecPop[indexRight].mBinaryGenVec);

        left++;
        right--;
    }
}

void GenAlg::crossover(vector<char>& chromo1, vector<char>& chromo2)
{
    if (chromo1.size() != chromo2.size())
        return;

    int total = chromo1.size();
   
    // 基因交叉重组
    for (int i = 0; i < total; i++)
    {
        // 满足交叉概率
        if (random(0, 1) < mCrossoverRate)
        {
            int index = random(0, total);
            for (int i = index; i < total; i++)
            {
                swap(chromo1[i], chromo2[i]);
            }          
        }    
    }
}

Genome GenAlg::chromoRoulette()
{
    // 产生一个 0 到种群总适应性评分总和之间的随机数.  mTotalFitness记录了整个种群的适应性分数总和
    double slice = (random(0,1)) * mTotalFitness;

    // 这个基因将承载转盘所选出来的那个个体.  
    Genome theChosenOne;

    // 累计适应性分数的和.  
    double fitnessSoFar = 0;

    // 遍历总种群里面的每一条染色体。  
    for (int i = 0; i < mPopSize; ++i)
    {
        //累计适应性分数.  
        fitnessSoFar += vecPop[i].fitness;

        // 如果累计分数大于随机数,就选择此时的基因.  
        if (fitnessSoFar >= slice)
        {
            theChosenOne = vecPop[i];
            break;
        }
    }
    //返回转盘选出来的个体基因  
    return theChosenOne;
}

void GenAlg::calculateBestWorstAvTot()
{
    int total = vecPop.size();
    for (int i = 0; i < total; i++)
    {
        double fitNessTemp = vecPop[i].fitness;

        // 计算总适应度值
        mTotalFitness += fitNessTemp;

        // 查找最好适应度值
        if (mBestFitness < fitNessTemp)
            mBestFitness = fitNessTemp;

        // 查找最差适应度值
        if (mWorstFitness > fitNessTemp)
            mWorstFitness = fitNessTemp;
    }

    // 计算平均适应度
    mAverageFitness = mTotalFitness / (double)total;
}

void GenAlg::reset()
{
    mPopSize = 0;
    mMutationRate = 0;
    mCrossoverRate =0;
    mChromoLength = 0;
    mTotalFitness = 0;
    mGeneration = 0;

    mBestFitness = 0.0;
    mWorstFitness = 99999999;
    mAverageFitness = 0;
    mMaxPerturbation = 0.001;

    mLeftPoint =0;
    mRightPoint = 0;

    // 清空种群容器，以初始化  
    vecPop.clear();
}

void GenAlg::epoch(vector<Genome>& vecNewPop)
{

}

Genome GenAlg::bestFitness()
{
    int maxIndex = -1;
    for (int i = 0; i < vecPop.size(); i++)
    {
        if (mBestFitness == vecPop[i].fitness)  
            maxIndex = i;    
    }

    // 没找到构造一个空的基因型对象
    if (maxIndex == -1)
        return Genome();

    return vecPop[maxIndex];
}

double GenAlg::averageFitness()
{
    return mAverageFitness;
}

double  GenAlg::fitnessfunction(float cost, map<string, double>& monitorValues)
{
    // 计算适应
    double objVal = mOptScheduling->objectiveFunction(cost, monitorValues);
    return objVal;
}

void GenAlg::encoding(map<string, int>& phenotype, vector<char>& chromo)
{
    map<string, int>::iterator iter = phenotype.begin();
    for (; iter != phenotype.end(); iter++)
    {

    }
}

void GenAlg::decoding(vector<map<string, int>>& phenotype)
{
    size_t total = vecPop.size();
    
    for (int i = 0; i < total; i++)
    {
        Genome genome = vecPop[i];
        vector<char> genVec = genome.mBinaryGenVec;
        for (int j = 0; j < genVec.size(); j++)
        {
            phenotype[i].insert(pair<string, char>(mPumpBits[j], genVec[j]));
        }     
    }
}

void GenAlg::decodingSingle(vector<char>& chromo, map<string, int>& phenotype)
{
    for (int j = 0; j < chromo.size(); j++)
    {
        phenotype.insert(pair<string, char>(mPumpBits[j], chromo[j]));
    }
}

void GenAlg::setMaxMonitorVals(const  map<string, double>& maxMonitors)
{
    mOptScheduling->setMaxMonitorVals(maxMonitors);
}

void GenAlg::setMinMonitorsVals(const map<string, double>& minMonitors)
{
    mOptScheduling->setMinMonitorsVals(minMonitors);
}

void GenAlg::setPumpBit(const vector<string>& pumpBit)
{
    mPumpBits = pumpBit;
}