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

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GEP.Core.Common;
using GEP.Core.Common.GeneticOperators;
using System.Threading;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace GEP.Core.Common
{
    public delegate void GenerationCalculatedCallback(Population population);

    [Serializable]
    public abstract class Population
    {
        public GenerationCalculatedCallback _generationCalculatedCallback;

        protected Random _random = new Random();
        public int _n_generations;
        public string _autoSaveFilePath;
        public int _autoSaveInterval; //Minutes
        public DateTime _previousAutoSave = DateTime.Now;
        public List<Genotype> _fittestList = new List<Genotype>(20);
        protected Genotype _fittest;
        public Genotype Fittest
        {
            get
            {
                return _fittest;
            }
        }
        public int N_generations
        {
            get
            {
                return _n_generations;
            }
        }
        internal OperatorsSet _operators;
        public int Size
        {
            get
            {
                return _genotypes.Length;
            }
        }

        internal double _totalMatingProbability;
        public double TotalMatingProbability
        {
            get
            {
                return _totalMatingProbability;
            }
        }

        internal int[] _functionStack;
        internal Genotype[] _genotypes;
        public Genotype this[int genotypeIndex]
        {
            get
            {
                return _genotypes[genotypeIndex];
            }
            set
            {
                _genotypes[genotypeIndex] = value;
            }
        }

        protected int _generation;
        public int Generation
        {
            get
            {
                return _generation;
            }
        }

        protected Symbol _genesLinkingFunction;

        public Symbol GenesLinkingFunction
        {
            get
            {
                return _genesLinkingFunction;
            }
        }
        protected Alphabet _functionsSet;
        public Alphabet FunctionsSet
        {
            get
            {
                return _functionsSet;
            }
        }
        protected Alphabet _variablesSet;
        public Alphabet VariablesSet
        {
            get
            {
                return _variablesSet;
            }
        }
        protected Alphabet _constantsSet;
        public Alphabet ConstantsSet
        {
            get
            {
                return _constantsSet;
            }
        }
        protected double[] _symbolSetsProbabilityDistribution;
        protected int _n_Genes;
        public int N_Genes
        {
            get
            {
                return _n_Genes;
            }
        }
        protected int _geneLength;
        public int GeneLength
        {
            get
            {
                return _geneLength;
            }
        }
        protected int _headLength;
        public int HeadLength
        {
            get
            {
                return _headLength;
            }
        }
        protected int _tailLength;
        public int TailLength
        {
            get
            {
                return _tailLength;
            }
        }
        protected int _genotypeLength;
        public int GenotypeLength
        {
            get
            {
                return _genotypeLength;
            }
        }

        public Population(int n_Genes, int headLength, int n_generations, Alphabet functionsSet, Alphabet variablesSet,
            Alphabet constantsSet, double[] symbolSetsProbabilityDistribution, Symbol genesLinkingFunction,
            OperatorsSet operators)
        //setsDistribution :
        //functions' probability to appear in the random generation of the ET = symbolSetsProbabilityDistribution[0]
        //variables' probability to appear in the random generation of the ET =
        //symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0]
        //constants' probability to appear in the random generetin of the ET =
        //1 - symbolSetsProbabilityDistribution[0] - (symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0])
        //symbolSetsProbabilityDistribution[0] <= symbolSetsProbabilityDistribution[1] <= 1 must be true.
        {
            if (n_Genes == 0)
                throw new GepException("The number of genes must be greater than 1.");
            if (constantsSet.Length == 0 && variablesSet.Length == 0)
                throw new GepException("The constants' set or the variables' set must have at least 1 element.");
            for (int i = constantsSet.Length - 1; 0 <= i; i--)
            {
                if (constantsSet[i].N_Parameters != 0)
                    throw new GepException("The symbols in the constants' set must accept no parameters.");
            }
            for (int i =  variablesSet.Length - 1; 0 <= i; i--)
            {
                if (variablesSet[i].N_Parameters != 0)
                    throw new GepException("The symbols in the variables' set must accept no parameters.");
            }
            if (symbolSetsProbabilityDistribution[0] > 1 || symbolSetsProbabilityDistribution[0] < 0)
                throw new GepException("The probability of function random generation must be between 0 and 1.");
            if (symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0] > 1 ||
                symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0] < 0)
                throw new GepException("The probability of variable random generation must be between 0 and 1.");
            if (1 - symbolSetsProbabilityDistribution[0] - (symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0]) > 1 ||
                1 - symbolSetsProbabilityDistribution[0] - (symbolSetsProbabilityDistribution[1] - symbolSetsProbabilityDistribution[0]) < 0)
                throw new GepException("The probability of constant random generation must be between 0 and 1.");
            if (genesLinkingFunction != null && genesLinkingFunction.N_Parameters == 0)
                throw new GepException("The genes linking function can be either null or must accept more than 0 parameters.");
            if (genesLinkingFunction != null && genesLinkingFunction.N_Parameters == 1 && n_Genes != 1)
                throw new GepException("When the genes linking function accepts only 1 parameter, the number of genes must be 1.");
            else if (genesLinkingFunction != null && n_Genes != genesLinkingFunction.N_Parameters)
                throw new GepException("The linking function number of parameters must be equal to the number of genes.");
            _n_generations = n_generations;
            _n_Genes = n_Genes;
            _headLength = headLength;
            _tailLength = headLength * (functionsSet.MaxN_Parameters - 1) + 1;
            _functionsSet = functionsSet;
            _variablesSet = variablesSet;
            _constantsSet = constantsSet;
            _symbolSetsProbabilityDistribution = symbolSetsProbabilityDistribution;
            _geneLength = headLength + 2 * _tailLength;
            _genotypeLength = n_Genes * _geneLength;
            _genesLinkingFunction = genesLinkingFunction;
            _operators = operators;
        }

        public abstract void Initialize(int populationSize);

        public void UpdateSymbolRefereces(Alphabet functionsSet, Alphabet variablesSet, Alphabet constantsSet)
        {
            for (int i = _genotypes.Length - 1; 0 <= i; i--)
            {
                _genotypes[i].UpdateFunctionReferences(_functionsSet, functionsSet);
                _genotypes[i].UpdateVariableReferences(_variablesSet, variablesSet);
                _genotypes[i].UpdateConstantReferences(_constantsSet, constantsSet);
            }
        }

        public void NextGeneration()
        {
            CalculateFitnessAndMatingProbabilities();
            Genotype fittest = _fittest;
            for (int i = _genotypes.Length - 1; 0 <= i; i--)
            {
                if (double.IsNaN(_genotypes[i]._fitness) || double.IsInfinity(_genotypes[i]._fitness))
                    continue;
                if (_operators._matingProbabilityFunction._fitnessCloserToZeroIsBetter)
                {
                    if (_genotypes[i]._fitness < _fittest._fitness)
                    {
                        _fittest = _genotypes[i];
                        _fittest.CloneConstants();
                    }
                }
                else
                {
                    if (_fittest._fitness < _genotypes[i]._fitness)
                    {
                        _fittest = _genotypes[i];
                        _fittest.CloneConstants();
                    }
                }
            }
            if (!ReferenceEquals(fittest, _fittest))
            {
                _operators._fitnessFunction.SetFitness(_fittest, true);
                _fittestList.Add(_fittest);
            }
            AutoSave();
            if (_generationCalculatedCallback != null)
                _generationCalculatedCallback(this);
            if (_generation > _n_generations)
                return;
            _generation++;
            Genotype[] newGenotypes = new Genotype[_genotypes.Length];
            int destinationIndex = 0;
            int n_GeneticOperators = _operators._geneticOperators.Length;
            for (int i = 0; i < n_GeneticOperators; i++)
            {
                if (_operators._geneticOperators[i]._applyOnNewGeneration)
                    continue;
                if (_operators._geneticOperators[i].ProducesNewOffspring)
                    _operators._geneticOperators[i].Apply(this, newGenotypes, ref destinationIndex);
                else
                    _operators._geneticOperators[i].Apply(this);
            }
            _genotypes = newGenotypes;
            for (int i = 0; i < n_GeneticOperators; i++)
            {
                if (!_operators._geneticOperators[i]._applyOnNewGeneration)
                    continue;
                if (_operators._geneticOperators[i].ProducesNewOffspring)
                    _operators._geneticOperators[i].Apply(this, newGenotypes, ref destinationIndex);
                else
                    _operators._geneticOperators[i].Apply(this);
            }
            MutateConstants();
        }

        public void CalculateFitnessAndMatingProbabilities()
        {
            for (int i = _genotypes.Length - 1; 0 <= i; i--)
            {
                _operators._fitnessFunction.SetFitness(_genotypes[i], false);
            }
            _operators._matingProbabilityFunction.SetMatingProbability(this);
        }

        protected abstract void MutateConstants();

        public void Start()
        {
            for (int i = 0; i <= _n_generations; i++)
            {
                NextGeneration();
            }
        }

        public void AutoSave()
        {
            if (_autoSaveFilePath == null)
                return;
            if (DateTime.Now > _previousAutoSave.AddMinutes(_autoSaveInterval))
            {
                Save(_autoSaveFilePath);
                _previousAutoSave = _previousAutoSave.AddMinutes(_autoSaveInterval);
            }
        }

        public void Save(string filePath)
        {
            FileStream s = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite);
            BinaryFormatter b = new BinaryFormatter();
            b.Serialize(s, this);
            s.Close();
        }

        public static Population Load(string filePath)
        {
            FileStream s = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            BinaryFormatter b = new BinaryFormatter();
            Population population = (Population)b.Deserialize(s);
            s.Close();
            return population;
        }
    }
}

GEP .NET Framwork Main Page