public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
        {
            var vector1 = ((VectorChromosome <T>)chromosome1).GetVector();
            var vector2 = ((VectorChromosome <T>)chromosome2).GetVector();
            var length  = vector1.Length;

            (var start, var end) = ComponetsUtils.GetTwoRandomNumbers(length + 1);
            var genomesFromChromosome1 = new HashSet <T>();

            for (int i = start; i < end; i++)
            {
                genomesFromChromosome1.Add(vector1[i]);
            }

            var newVector = new T[length];
            var lastAddedIndexFromChromsome2 = 0;

            for (int i = 0; i < start; i++)
            {
                while (genomesFromChromosome1.Contains(vector2[lastAddedIndexFromChromsome2]))
                {
                    lastAddedIndexFromChromsome2++;
                }

                newVector[i] = vector2[lastAddedIndexFromChromsome2];
                lastAddedIndexFromChromsome2++;
            }
            for (int i = start; i < end; i++)
            {
                newVector[i] = vector1[i];
            }

            for (int i = end; i < length; i++)
            {
                while (genomesFromChromosome1.Contains(vector2[lastAddedIndexFromChromsome2]))
                {
                    lastAddedIndexFromChromsome2++;
                }

                newVector[i] = vector2[lastAddedIndexFromChromsome2];
                lastAddedIndexFromChromsome2++;
            }

            return(new VectorChromosome <T>(newVector, mutationManager, evaluator));
        }
        public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
        {
            var vector1      = ((VectorChromosome <T>)chromosome1).GetVector();
            var vector2      = ((VectorChromosome <T>)chromosome2).GetVector();
            var indexManager = new IndexManager <T>(vector2);
            var length       = vector1.Length;

            (var start, var end) = ComponetsUtils.GetTwoRandomNumbers(length + 1);
            var addedIndexes           = new List <int>();
            var genomesFromChromosome1 = new List <T>();

            for (int i = start; i < end; i++)
            {
                genomesFromChromosome1.Add(vector1[i]);
            }

            T[] newVector = new T[length];
            for (int i = start; i < end; i++)
            {
                addedIndexes.Add(i);
                newVector[i] = vector1[i];
            }
            for (int i = start; i < end; i++)
            {
                if (genomesFromChromosome1.Contains(vector2[i]))
                {
                    continue;
                }
                var valueToReplace = vector1[i];
                var index          = indexManager.GetIndex(valueToReplace);
                addedIndexes.Add(index);
                newVector[index] = vector2[i];
            }
            for (int i = 0; i < vector1.Length; i++)
            {
                if (!addedIndexes.Contains(i))
                {
                    newVector[i] = vector2[i];
                }
            }

            return(new VectorChromosome <T>(newVector, mutationManager, evaluator));
        }
        public T[] Mutate(T[] vector)
        {
            (var start, var end) = ComponetsUtils.GetTwoRandomNumbers(vector.Length + 1);
            var insertionIndex       = ProbabilityUtils.GetRandomInt(vector.Length - (end - start));
            var vectorWithoutStretch = new T[vector.Length - (end - start)];

            for (int i = 0; i < start; i++)
            {
                vectorWithoutStretch[i] = vector[i];
            }
            for (int addTo = start, addFrom = end; addFrom < vector.Length; addFrom++, addTo++)
            {
                vectorWithoutStretch[addTo] = vector[addFrom];
            }

            var newVector = new T[vector.Length];

            for (int i = 0; i < insertionIndex; i++)
            {
                newVector[i] = vectorWithoutStretch[i];
            }
            if (inversionSttretch)
            {
                for (int addTo = insertionIndex, addFrom = end - 1; addFrom >= start; addFrom--, addTo++)
                {
                    newVector[addTo] = vector[addFrom];
                }
            }
            else
            {
                for (int addTo = insertionIndex, addFrom = start; addFrom < end; addFrom++, addTo++)
                {
                    newVector[addTo] = vector[addFrom];
                }
            }
            for (int addTo = insertionIndex + (end - start), addFrom = insertionIndex; addTo < vector.Length; addFrom++, addTo++)
            {
                newVector[addTo] = vectorWithoutStretch[addFrom];
            }

            return(newVector);
        }
Beispiel #4
0
        public T[] Mutate(T[] vector)
        {
            (var start, var end) = ComponetsUtils.GetTwoRandomNumbers(vector.Length + 1);

            var newVector = new T[vector.Length];

            for (int i = 0; i < start; i++)
            {
                newVector[i] = vector[i];
            }
            for (int addTo = start, addFrom = end - 1; addTo < end; addTo++, addFrom--)
            {
                newVector[addTo] = vector[addFrom];
            }
            for (int i = end; i < vector.Length; i++)
            {
                newVector[i] = vector[i];
            }

            return(newVector);
        }
        public T[] Mutate(T[] vector)
        {
            (var start, var end) = ComponetsUtils.GetTwoRandomNumbers(vector.Length + 1);
            var scrambledGenomes = vector.Skip(start).Take(end - start).ToArray().Shuffle();

            var newVector = new T[vector.Length];

            for (int i = 0; i < start; i++)
            {
                newVector[i] = vector[i];
            }
            for (int addTo = start, addFrom = 0; addTo < end; addTo++, addFrom++)
            {
                newVector[addTo] = scrambledGenomes[addFrom];
            }
            for (int i = end; i < vector.Length; i++)
            {
                newVector[i] = vector[i];
            }

            return(newVector);
        }