E:/Projects/Visual Studio/CSharp/GEP .NET Framework/GEP.Core/Common/GeneticOperators/Mutation.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GEP.Core.Common.GeneticOperators
{
    [Serializable]
    public class Mutation : GeneticOperator
    {
        internal double _mutationProbabilityInHead;
        internal double _mutationProbabilityInTail;
        internal double _mutationProbabilityInConstants;
        internal double[] _symbolSetsProbabilityDistribution;
        internal double _varConstProbabilityDistribution;
        internal Alphabet _functionsSet;
        internal Alphabet _variablesSet;
        internal Alphabet _constatnsSet;

        protected Mutation(Alphabet functionsSet, Alphabet variablesSet, Alphabet constatnsSet,
            double[] symbolSetsProbabilityDistribution,
            bool applyOnNewGeneration, GenotypeSelection.GenotypeSelection selection)
            : base(1, 1, false, applyOnNewGeneration, selection, "Mutation")
        {
            _symbolSetsProbabilityDistribution = symbolSetsProbabilityDistribution;
            _functionsSet = functionsSet;
            _variablesSet = variablesSet;
            _constatnsSet = constatnsSet;
            double varConstRatioInTail =
                    (double)((symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0])
                    / (1 - symbolSetsProbabilityDistribution[0] - (symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0])));
            _varConstProbabilityDistribution = varConstRatioInTail / (varConstRatioInTail + 1);
        }

        public Mutation(Alphabet functionsSet, Alphabet variablesSet, Alphabet constatnsSet,
            double[] symbolSetsProbabilityDistribution, double mutationProbabilityInHead,
            double mutationProbabilityInTail, double mutationProbabilityInConstants,
            bool applyOnNewGeneration, GenotypeSelection.GenotypeSelection selection)
            : this(functionsSet, variablesSet, constatnsSet, symbolSetsProbabilityDistribution,
            applyOnNewGeneration, selection)
        {
            _mutationProbabilityInHead = Math.Abs(mutationProbabilityInHead);
            _mutationProbabilityInTail = Math.Abs(mutationProbabilityInTail);
            _mutationProbabilityInConstants = Math.Abs(mutationProbabilityInConstants);
        }

        public override void Apply(Genotype[] parameters, int[] selectionIndexes, Genotype[] destination, ref int destIndex)
        {
            throw new NotImplementedException();
        }

        public override void Apply(Genotype[] parameters, int[] selectionIndexes)
        {
            Genotype genotype = parameters[selectionIndexes[0]];
            int headLength = genotype.HeadLength;
            int headAndTailLength = headLength + genotype.TailLength;
            int geneLength = genotype.GeneLength;
            double rd;
            for (int i = 0; i < genotype.N_Genes; i++)
            {
                for (int j = 0; j < headLength; j++)
                {
                    rd = _random.NextDouble();
                    if (rd <= _mutationProbabilityInHead)
                    {
                        rd = _random.NextDouble();
                        if (rd <= _symbolSetsProbabilityDistribution[0])
                        {
                            genotype._linearStructure[i][j] = _functionsSet[_random.Next(_functionsSet.Length)];
                        }
                        else if (rd <= _symbolSetsProbabilityDistribution[1])
                        {
                            genotype._linearStructure[i][j] = _variablesSet[_random.Next(_variablesSet.Length)];
                        }
                        else
                        {
                            genotype._linearStructure[i][j] = null;
                        }
                    }
                }
                for (int j = headLength; j < headAndTailLength; j++)
                {
                    rd = _random.NextDouble();
                    if (rd <= _mutationProbabilityInTail)
                    {
                        rd = _random.NextDouble();
                        if (rd <= _varConstProbabilityDistribution)
                        {
                            genotype._linearStructure[i][j] = _variablesSet[_random.Next(_variablesSet.Length)];
                        }
                        else
                        {
                            genotype._linearStructure[i][j] = null;
                        }
                    }
                }
                for (int j = headAndTailLength; j < geneLength; j++)
                {
                    rd = _random.NextDouble();
                    if (rd <= _mutationProbabilityInConstants)
                    {
                        genotype._linearStructure[i][j] = _constatnsSet[_random.Next(_constatnsSet.Length)];
                    }
                }
            }
        }

        public Mutation(Mutation symbol)
            :base(symbol)
        {
            _mutationProbabilityInHead = symbol._mutationProbabilityInHead;
            _mutationProbabilityInTail = symbol._mutationProbabilityInTail;
            _mutationProbabilityInConstants = symbol._mutationProbabilityInConstants;
            _symbolSetsProbabilityDistribution = symbol._symbolSetsProbabilityDistribution;
            _varConstProbabilityDistribution = symbol._varConstProbabilityDistribution;
            _functionsSet = symbol._functionsSet;
            _variablesSet = symbol._variablesSet;
            _constatnsSet = symbol._constatnsSet;
        }

        public override GEP.Core.Common.Symbol Clone()
        {
            return new Mutation(this);
        }
    }
}

GEP .NET Framwork Main Page