E:/Projects/Visual Studio/CSharp/GEP .NET Framework/GEP.Core/Float/Genotype.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 System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace GEP.Core.Float
{
    [Serializable]
    public class Genotype : Common.Genotype
    {
        protected float[] _linearStructureValues;
        public float[] _geneValues;
        public float _value;

        protected Genotype() { }

        public Genotype(Common.Population population)
            : base(population)
        {
            _linearStructureValues = ((Population)population)._linearStructureValues;
        }

        protected override void InitializeGeneValuesArray()
        {
            _geneValues = new float[_n_Genes];
        }


        protected override void CalculateValue()
        {
            if (_genesLinkingFunction != null)
                _value = ((Symbol)_genesLinkingFunction).Value(_geneValues, 0);
        }

        protected override void CalculateGene(int geneIndex, int variableValuesIndex)
        {
            Common.Symbol[] gene = _linearStructure[geneIndex];
            int randomNumericalConstantIndex = _headLength + _tailLength;
            if (gene[0] == null)
            {
                _linearStructureValues[0] =
                    ((Symbol)gene[randomNumericalConstantIndex]).Value(_linearStructureValues, 0);
            }
            else if (gene[0].N_Parameters == 0)
            {
                _linearStructureValues[0] =
                    ((Symbol)gene[0]).Value(_linearStructureValues, variableValuesIndex);
            }
            else
            {
                _functionStack[0] = 0;
                int functionStackPointer = 2;
                int functionStackInnerPointer = 0;
                int n_UnprocessedParameters = gene[0].N_Parameters;
                _functionStack[1] = 1;
                int parametersLoopEnd;
                //Filling the function stack with functions to be calculated, evaluating
                //constants and variables and storing the result in _linearStructureValues.
                do
                {
                    parametersLoopEnd = _functionStack[functionStackInnerPointer + 1]
                        + gene[_functionStack[functionStackInnerPointer]].N_Parameters;
                    for (int j = _functionStack[functionStackInnerPointer + 1]; j < parametersLoopEnd; j++)
                    {
                        if (gene[j] == null)
                        {
                            _linearStructureValues[j] =
                                ((Symbol)gene[randomNumericalConstantIndex++]).Value(_linearStructureValues, 0);
                        }
                        else if (gene[j].N_Parameters == 0)
                        {
                            _linearStructureValues[j] =
                                ((Symbol)gene[j]).Value(_linearStructureValues, variableValuesIndex);
                        }
                        else
                        {
                            _functionStack[functionStackPointer] = j;
                            _functionStack[functionStackPointer + 1] = _functionStack[functionStackPointer - 1]
                                + gene[_functionStack[functionStackPointer - 2]].N_Parameters;
                            n_UnprocessedParameters += gene[j].N_Parameters;
                            functionStackPointer += 2;
                        }
                        n_UnprocessedParameters--;
                    }
                    functionStackInnerPointer += 2;
                } while (n_UnprocessedParameters > 0);
                functionStackPointer -= 2;
                //Unwinding the stack and calculating function values.
                while (functionStackPointer >= 0)
                {
                    _linearStructureValues[_functionStack[functionStackPointer]] =
                                ((Symbol)gene[_functionStack[functionStackPointer]])
                                .Value(_linearStructureValues, _functionStack[functionStackPointer + 1]);
                    functionStackPointer -= 2;
                }
            }
            _geneValues[geneIndex] = _linearStructureValues[_functionStack[0]];
        }

        public override Common.Genotype Clone()
        {
            Genotype result = new Genotype();
            result._functionStack = _functionStack;
            result._geneLength = _geneLength;
            result._genesLinkingFunction = _genesLinkingFunction;
            result._geneValues = new float[_n_Genes];
            result._headLength = _headLength;
            result._linearStructure = new Common.Symbol[_n_Genes][];
            for (int i = 0; i < _n_Genes; i++)
            {
                result._linearStructure[i] = new Common.Symbol[_geneLength];
                for (int j = 0; j < _geneLength; j++)
                {
                    result._linearStructure[i][j] = _linearStructure[i][j];
                }
            }
            result._linearStructureValues = _linearStructureValues;
            result._n_Genes = _n_Genes;
            result._tailLength = _tailLength;
            return result;
        }

        public override Common.Genotype CloneWithoutLinearStructure()
        {
            Genotype result = new Genotype();
            result._functionStack = _functionStack;
            result._geneLength = _geneLength;
            result._genesLinkingFunction = _genesLinkingFunction;
            result._geneValues = _geneValues;
            result._headLength = _headLength;
            result._linearStructure = new Common.Symbol[_n_Genes][];
            for (int i = 0; i < _n_Genes; i++)
            {
                result._linearStructure[i] = new Common.Symbol[_geneLength];
            }
            result._linearStructureValues = _linearStructureValues;
            result._n_Genes = _n_Genes;
            result._tailLength = _tailLength;
            return result;
        }

        public override int IsValid()
        {
            for (int i = 0; i < _n_Genes; i++)
            {
                for (int j = _headLength + _tailLength - 1; _headLength <= j; j--)
                {
                    if (_linearStructure[i][j] != null && _linearStructure[i][j].N_Parameters != 0)
                        return i;
                }
                for (int j = _headLength + _tailLength; j < _geneLength; j++)
                {
                    if (_linearStructure[i][j] != null && _linearStructure[i][j].N_Parameters != 0)
                        return i;
                }
            }
            return -1;
        }
    }
}

GEP .NET Framwork Main Page