/*

All code to change is in Main method.

​

1)

Chromosome c1 = new Chromosome( -2, 0 );

Chromosome c2 = new Chromosome( -1, -2 );

Chromosome c3 = new Chromosome( 0, -1 );

Chromosome c4 = new Chromosome( 2, 1 );

​

Format of chromosome:

Chromosome ci = new Chromosome( x, y );

​

​

2)

geneticAlgorithmExecutor.setZFunction(

    ( double _x, double _y ) =>

    {

        return _x / ( _x * _x + 2.0 * _y * _y + 1.0 );

    }

);

​

here user should write Z function by variant.

​

*/

​

​

using System;

using System.Collections.Generic;

using System.Text;

​

public static class Constants

{

    public const int s_stepsCount = 4;

}

​

​

public class Chromosome

{

    public Chromosome( int _gen1, int _gen2 )

    {

        m_gen1 = _gen1;

        m_gen2 = _gen2;

    }

​

    public Chromosome makeCopy()

    {

        return new Chromosome( m_gen1, m_gen2 );

    }

​

    public int m_gen1;

    public int m_gen2;

}

​

​

​

public class GeneticAlgorithmExecutor

{

    public GeneticAlgorithmExecutor( int _stepsCount )

    {

        m_stepsCount = _stepsCount;

​

        m_chromosomes = new List<List<Chromosome>>();

        m_chromosomes.Add( new List<Chromosome>() );

​

        m_sortedChromosomes = new List<List<Chromosome>>();

        m_chromosomeToFitness = new Dictionary<Chromosome, double>();

        m_sumFitnesses = new List<double>();

        //m_maxFitnesses = new List<double>();

    }

​

    public void addChromose( Chromosome _chromosome )

    {

        if ( m_chromosomes.Count != 1 )

            throw new Exception();

​

        m_chromosomes[ 0 ].Add( _chromosome );

        addToFitnessModel( _chromosome );

    }

​

    public void setZFunction( Func< double /*x*/, double /*y*/, double /*result*/> _zFunction )

    {

        m_zFunction = _zFunction;

    }

​

    public void execute()

    {

        for ( int i = 0; i < m_stepsCount; ++i )

        {

            makeStep();

        }

​

        initSumFitnesses();

        //initMaxFitnesses();

    }

​

    private void makeStep()

    {

        List<Chromosome> currentChromosomes = getCurrentChromosomes();

        List<Chromosome> chromosomesToSort = makeCopy( currentChromosomes );

​

        chromosomesToSort.Sort(

            ( Chromosome _c1, Chromosome _c2 ) =>

            {

                double dif = getFitness( _c2 ) - getFitness( _c1 );

                if ( dif < 0.0 )

                    return -1;

                return 1;

            }

        );

​

        m_sortedChromosomes.Add( chromosomesToSort );

​

        Chromosome newChromosome1 = new Chromosome( chromosomesToSort[ 1 ].m_gen1, chromosomesToSort[ 0 ].m_gen2 );

        Chromosome newChromosome2 = new Chromosome( chromosomesToSort[ 2 ].m_gen1, chromosomesToSort[ 0 ].m_gen2 );

        Chromosome newChromosome3 = new Chromosome( chromosomesToSort[ 0 ].m_gen1, chromosomesToSort[ 1 ].m_gen2 );

        Chromosome newChromosome4 = new Chromosome( chromosomesToSort[ 0 ].m_gen1, chromosomesToSort[ 2 ].m_gen2 );

​

        List<Chromosome> newChromosomes = new List<Chromosome>();

        newChromosomes.Add( newChromosome1 );

        newChromosomes.Add( newChromosome2 );

        newChromosomes.Add( newChromosome3 );

        newChromosomes.Add( newChromosome4 );

​

        foreach ( Chromosome chromosome in newChromosomes )

        {

            addToFitnessModel( chromosome );

        }

​

        m_chromosomes.Add( newChromosomes );

    }

​

    private List<Chromosome> makeCopy( List< Chromosome > _list )

    {

        List<Chromosome> result = new List< Chromosome >();

        foreach ( Chromosome chromosome in _list )

        {

            result.Add( chromosome );

        }

        return result;

    }

​

    private void initSumFitnesses()

    {

        foreach ( List<Chromosome> chromosomesSuite in m_chromosomes )

        {

            double sum = 0.0;

            foreach ( Chromosome chromosome in chromosomesSuite )

            {

                sum += getFitness( chromosome );

            }

            m_sumFitnesses.Add( sum );

        }

    }

/*

    private void initMaxFitnesses()

    {

        foreach ( List<Chromosome> chromosomesSuite in m_chromosomes )

        {

            double max = Double.MinValue;

            foreach ( Chromosome chromosome in chromosomesSuite )

            {

                double fitness = getFitness( chromosome );

                if ( max < fitness )

                    max = fitness;

            }

            m_maxFitnesses.Add( max );

        }

    }

*/

    private List<Chromosome> getCurrentChromosomes()

    {

        return m_chromosomes[ m_chromosomes.Count - 1 ];

    }

​

    private void addToFitnessModel( Chromosome _chromosome )

    {

        m_chromosomeToFitness.Add( _chromosome, calculateFitness( _chromosome ) );

    }

​

    private double calculateFitness( Chromosome _chromosome )

    {

        return m_zFunction( _chromosome.m_gen1, _chromosome.m_gen2 );

    }

​

    public double getFitness( Chromosome _chromosome )

    {

        return m_chromosomeToFitness[ _chromosome ];

    }

​

    private Func<

            double /*x*/

        ,   double /*y*/

        ,   double /*result*/

    >

    m_zFunction;

    private int m_stepsCount;

​

    public List<List<Chromosome>> m_chromosomes;

    public List<List<Chromosome>> m_sortedChromosomes;

    public Dictionary<Chromosome, double> m_chromosomeToFitness;

    public List<double> m_sumFitnesses;

    //public List<double> m_maxFitnesses;

}

​

public class ReportPrinter

{

    public ReportPrinter( int _height, int _length )

    {

        m_length = _length;

        m_height = _height;

​

        m_data = new string[ m_height, m_length ];

        init();

    }

​

    public void normalize()

    {

        for ( int i = 0; i < m_length; ++i )

        {

            int maxColumnElementLength = getMaxElementLength( i );

            normalizeColumn( i, maxColumnElementLength );

        }

    }

​

    public int getMaxElementLength( int _columnIndex )

    {

        int maxLength = 0;

        for ( int i = 0; i < m_height; ++i )

        {

            int elementLength = m_data[ i, _columnIndex ].Length;

            if ( maxLength < elementLength )

                maxLength = elementLength;

        }

        return maxLength;

    }

​

    public void normalizeColumn( int _columnIndex, int _maxColumnElementLength )

    {

        for ( int i = 0; i < m_height; ++i )

        {

            string element = m_data[ i, _columnIndex ];

            int elementLength = element.Length;

            int lengthDifference = _maxColumnElementLength - elementLength;

            if ( lengthDifference == 0 )

                continue;

​

            string spaces = new String( ' ', lengthDifference );

            StringBuilder sb = new StringBuilder();

            sb.AppendFormat( "{0}{1}", element, spaces );

            m_data[ i, _columnIndex ] = sb.ToString();

        }

    }

​

    public void print()

    {

        normalize();

        for ( int i = 0; i < m_height; ++i )

        {

            Console.Write( "\n" );

            for ( int j = 0; j < m_length; ++j )

            {

                Console.Write( "{0}\t", m_data[ i, j ] );

            }

        }

    }

​

    private void init()

    {

        for ( int i = 0; i < m_height; ++i )

        {

            for ( int j = 0; j < m_length; ++j )

            {

                m_data[ i, j ] = "";

            }

        }

    }

​

    private int m_height;

    private int m_length;

​

    public string[,] m_data;

}

​

​

public class GeneticAlgorithmPrinter

{

    public GeneticAlgorithmPrinter()

    {

​

    }

​

    public void print( GeneticAlgorithmExecutor _executor )

    {

        int stepsCount = _executor.m_sortedChromosomes.Count;

        for ( int i = 0; i < stepsCount; ++i )

        {

            printChromosomes( _executor, i );

            printZResults( _executor, i );

            printSumFitness( _executor, i );

            printSortedChromosomes( _executor, i );

        }

        printMaxFitness( _executor );

    }

​

    private void printChromosomes( GeneticAlgorithmExecutor _executor, int _index )

    {

        List< Chromosome > chromosomes = _executor.m_chromosomes[ _index ];

​

        int height = 2;

        int width = 1 + chromosomes.Count;

​

        ReportPrinter reportPrinter = new ReportPrinter( height, width );

​

        int xLineIndex = 0;

        int yLineIndex = 1;

​

        reportPrinter.m_data[ xLineIndex, 0 ] = "x";

        reportPrinter.m_data[ yLineIndex, 0 ] = "y";

​

        for ( int columnIndex = 1; columnIndex < width; ++columnIndex )

        {

            int chromosomeIndex = columnIndex - 1;

​

            reportPrinter.m_data[ xLineIndex, columnIndex ] =

                chromosomes[ chromosomeIndex ].m_gen1.ToString();

            reportPrinter.m_data[ yLineIndex, columnIndex ] =

            chromosomes[ chromosomeIndex ].m_gen2.ToString();

        }

​

        Console.WriteLine( "\nChromosomes:" );

        reportPrinter.print();

    }

​

​

​

    private void printSortedChromosomes( GeneticAlgorithmExecutor _executor, int _index )

    {

        List<Chromosome> sortedChromosomes = _executor.m_sortedChromosomes[ _index ];

​

        int height = 2;

        int width = 1 + sortedChromosomes.Count;

​

        ReportPrinter reportPrinter = new ReportPrinter( height, width );

​

        int xLineIndex = 0;

        int yLineIndex = 1;

​

        reportPrinter.m_data[ xLineIndex, 0 ] = "x";

        reportPrinter.m_data[ yLineIndex, 0 ] = "y";

​

        for ( int columnIndex = 1; columnIndex < width; ++columnIndex )

        {

            int chromosomeIndex = columnIndex - 1;

​

            reportPrinter.m_data[ xLineIndex, columnIndex ] =

                sortedChromosomes[ chromosomeIndex ].m_gen1.ToString();

            reportPrinter.m_data[ yLineIndex, columnIndex ] =

                sortedChromosomes[ chromosomeIndex ].m_gen2.ToString();

        }

​

        Console.WriteLine( "\nSorted chromosomes:" );

        reportPrinter.print();

    }

​

    private void printZResults( GeneticAlgorithmExecutor _executor, int _index )

    {

        Console.WriteLine( "\nResults of Z function:" );

​

        List<Chromosome> chromosomes = _executor.m_chromosomes[ _index ];

        int chromosomesCount = chromosomes.Count;

​

        for ( int i = 0; i < chromosomesCount; ++i )

        {

            Console.WriteLine( "Z{0} = {1}", i + 1, _executor.getFitness( chromosomes[ i ] ) );

        }

    }

    /*

        public void printSumFitnesses( GeneticAlgorithmExecutor _executor )

        {

            Console.WriteLine( "Sums:" );

​

            List<double> sumFitnesses = _executor.m_sumFitnesses;

            foreach ( double sum in sumFitnesses )

            {

                Console.WriteLine( "{0}", sum );

            }

        }

    */

    private void printSumFitness( GeneticAlgorithmExecutor _executor, int _index )

    {

        Console.WriteLine( "" );

​

        List<double> sumFitnesses = _executor.m_sumFitnesses;

        Console.WriteLine( "Fitness sum = {0}", sumFitnesses[ _index ] );

    }

​

    private void printMaxFitness( GeneticAlgorithmExecutor _executor )

    {

        Console.WriteLine( "" );

        double maxFitness = double.MinValue;

​

        int stepsCount = _executor.m_sortedChromosomes.Count;

        for ( int i = 0; i < stepsCount; ++i )

        {

            List<Chromosome> chromosomes = _executor.m_chromosomes[ i ];

            foreach ( Chromosome chromosome in chromosomes )

            {

                double fitness = _executor.getFitness( chromosome );

                if ( maxFitness < fitness )

                    maxFitness = fitness;

            }

        }

​

        Console.WriteLine( "Max fitness = {0}", maxFitness );

    }

​

}

​

public class Program

{

    public static void Main( string[] args )

    {

        Chromosome c1 = new Chromosome( -2, 0 );

        Chromosome c2 = new Chromosome( -1, -2 );

        Chromosome c3 = new Chromosome( 0, -1 );

        Chromosome c4 = new Chromosome( 2, 1 );

​

​

        GeneticAlgorithmExecutor geneticAlgorithmExecutor =

            new GeneticAlgorithmExecutor( Constants.s_stepsCount );

​

        geneticAlgorithmExecutor.setZFunction(

            ( double _x, double _y ) =>

            {

                return _x / ( _x * _x + 2.0 * _y * _y + 1.0 );

            }

        );

​

​

        geneticAlgorithmExecutor.addChromose( c1 );

        geneticAlgorithmExecutor.addChromose( c2 );

        geneticAlgorithmExecutor.addChromose( c3 );

        geneticAlgorithmExecutor.addChromose( c4 );

​

        geneticAlgorithmExecutor.execute();

​

        GeneticAlgorithmPrinter printer = new GeneticAlgorithmPrinter();

        printer.print( geneticAlgorithmExecutor );

​

    }

}

​