CartesianMutSilent.cpp

#include "CartesianMutSilent.h"
#include "Cartesian_c.h"
#include <cmath>
#include <vector>
#include <algorithm>
 
namespace Cartesian
{
 
    void CartesianMutSilent::registerParameters(StateP state)
    {
        myGenotype_->registerParameter(state, "mut.silent", (voidP) new double(0), ECF::DOUBLE);
    }
 
 
    bool CartesianMutSilent::initialize(StateP state)
    {
        voidP sptr = myGenotype_->getParameterValue(state, "mut.silent");
        probability_ = *((double*)sptr.get());
        return true;
    }
 
 
    bool CartesianMutSilent::mutate(GenotypeP gene)
    {
        Cartesian* cart = (Cartesian*)(gene.get());
        RandomizerP randP = cart->state_->getRandomizer();
        const uint nConstants = cart->nConstants_;
        const uint nOutputs = cart->nOutputs_;
        const uint nVariables = cart->nVariables_;
        const uint nRows = cart->nRows_;
        const uint nCols = cart->nCols_;
        const uint nLevelsBack = cart->nLevelsBack_;
        const uint maxArity = cart->maxArity_;
        const uint nInputs = cart->nInputs_;
 
        std::vector<uint> activeNodes;
        cart->getActiveFunctionNodes(activeNodes);
 
        // If all nodes are active
        if (activeNodes.size() == nRows * nCols)
            return true;
 
        std::vector<uint> allNodes;
        for (uint i = 0; i < nRows * nCols; i++) {
            allNodes.push_back(i + nInputs);
        }
 
        std::vector<uint> silentNodes;
        std::sort(activeNodes.begin(), activeNodes.end());
        set_difference(allNodes.begin(), allNodes.end(), activeNodes.begin(), activeNodes.end(), inserter(silentNodes, silentNodes.begin()));
 
        // Choose silent node that will be mutated
        uint silentNodeIndex = randP->getRandomInteger(0, silentNodes.size() - 1);
        uint silentNode = silentNodes.at(silentNodeIndex);
 
        uint nodeColumn = (silentNode - nInputs) / nRows;
        int minColumn = nodeColumn - nLevelsBack;
        uint lowerBound = nInputs + minColumn * nRows;
        if (minColumn < 0) lowerBound = 0;
        uint upperBound = nInputs + nodeColumn * nRows;
        uint newSilentNodeInput = randP->getRandomInteger(lowerBound, upperBound - 1);
 
        // Choose random input of silent node that will be mutated
        uint inputIndex = randP->getRandomInteger(1, maxArity);
        // Find the right index of node in genotype
        uint genotypeIndex = (silentNode - nInputs) * (maxArity + 1);
 
        cart->at(genotypeIndex + inputIndex) = newSilentNodeInput;
 
        return true;
    }
 
}