CartesianMutOnePoint.cpp

#include "CartesianMutOnePoint.h"
#include "Cartesian_c.h"
#include "FunctionSet.h"
#include <cmath>
#include <algorithm>
 
namespace Cartesian
{
 
    void CartesianMutOnePoint::registerParameters(StateP state)
    {
        myGenotype_->registerParameter(state, "mut.onepoint", (voidP) new double(0), ECF::DOUBLE);
    }
 
 
    bool CartesianMutOnePoint::initialize(StateP state)
    {
        voidP sptr = myGenotype_->getParameterValue(state, "mut.onepoint");
        probability_ = *((double*)sptr.get());
        return true;
    }
 
 
    bool CartesianMutOnePoint::mutate(GenotypeP gene)
    {
        Cartesian* cart = (Cartesian*)(gene.get());
        RandomizerP rand = cart->state_->getRandomizer();
        const uint size = cart->getGenomeSize();
        const uint nOutputs = cart->nOutputs_;
        const uint nRows = cart->nRows_;
        const uint nCols = cart->nCols_;
        const uint nFunctions = cart->nFunctions_;
        const uint nInputs = cart->nInputs_;
        uint randomGeneIndex;
 
        // select random function or output node
        randomGeneIndex = nInputs + rand->getRandomInteger(size);
 
        if (randomGeneIndex < (size + nInputs - nOutputs)) {
            // Function node
            uint iColumn = (randomGeneIndex - nInputs) / nRows;
            if (rand->getRandomInteger(2) == 0) {
                // mutate function
                uint currentNArgs = cart->nodes_[randomGeneIndex].primitive_->getNumberOfArguments();
                int functionID = rand->getRandomInteger(nFunctions);
                Function* func = cart->functionSet_->vFunctions[functionID].get();
                cart->nodes_[randomGeneIndex].setPrimitive(cart->functionSet_->vFunctions[functionID]);
 
                // generate random arguments if needed
                uint newNArgs = func->getNumberOfArguments();
                cart->nodes_[randomGeneIndex].arguments_.resize(func->getNumberOfArguments());
                if (newNArgs > currentNArgs) {
                    for (uint k = currentNArgs; k < newNArgs; k++) {
                        uint iArgument = cart->randomNodeInputConnection(iColumn);
                        cart->nodes_[randomGeneIndex].arguments_[k] = iArgument;
                    }
                }
            }
            else {
                // mutate one of the arguments
                uint iArg = rand->getRandomInteger(cart->nodes_[randomGeneIndex].primitive_->getNumberOfArguments());
                cart->nodes_[randomGeneIndex].arguments_[iArg] = cart->randomNodeInputConnection(iColumn);
            }
        }
        else {
            // Output gene
            cart->outputs_[randomGeneIndex - cart->nodes_.size()] = cart->randomOutputConnection();
        }
 
        //std::cout << randomGeneIndex << "\n";
 
        return true;
    }
 
}