0

Hai i need help in C++.. this is my code. By using this code I have to alter it and do Evolutionary Text/ Poem.
The poem is :
**“Berburu ke padang datar,
Dapat rusa berbelang kaki,
Berguru kepalang ajar,
Bagai bunga kembang tak jadi.” **

**There are 3 files.. Evo0.cpp(below code), mtrand.h and mtrand.cpp Click Here **

#include <iostream>
#include <ctime>
#include <windows.h>
#include <fstream>
#include "mtrand.h"

using namespace std;

int main () {
    const int chromosome_length = 40;
    const int pop_size = 20;    
    int max_generation = 200;
    int mutate_position;        // pos to mutate
    int xover_position; // pos to xover
    int rand_val;       // to hold random value, i.e. allele
    MTRand_int32 mt;    // create MTRand object
    mt.seed( time(NULL) ); // seed the RNG object
    MTRand mtreal;  // create MTRand object, real value of [0, 1) interval
    mtreal.seed( time(NULL) ); // seed the RNG object

    int pop[ pop_size ][ chromosome_length] = {0}; // un-init pop
    int mating_pool[ pop_size ][ chromosome_length] = {0}; // un-init pop

    int best[ chromosome_length ] = {0}; // un-init pop
    int best_fitness = 0; // var to store best[] fitness value
    int total_fitness = 0;  // var to store total sum of fitness values
    double avg_fitness = 0.0;   // var to store avg fitness value

    int fitness_values[ pop_size ]; // array to store fit value for all ind

    ofstream myfile;
    myfile.open ("output.txt");

    // randomize pop here!----------------------------------------
    for ( int i = 0; i < pop_size ; i++ ) {
        cout << i << ": ";

        for ( int j = 0; j < chromosome_length; j++ ) {
            // get random value 
            //srand ( time(NULL) );     /* initialize random seed */            

            rand_val = 0; // re-init random value
            rand_val = mt() % 2;    /* generate random value - 0 or 1 */

            pop[ i ][ j ] = rand_val;

            //Sleep(1000);

            cout << pop[ i ][ j ];
        } // end for - inner loop

        cout << endl;
    } // end for - outer loop
    cout << endl;

    // randomize pop ENDS!----------------------------------------

    int gen_num = 0; // init gen num
    while ( gen_num < max_generation ) {
        // re-init total & avg fitness values
        total_fitness = 0;
        avg_fitness = 0.0;

        // output best ind here - use (highest) fitness value
        int ind_fitness; // declare var for fitness
        for ( int i = 0; i < pop_size; i++ ) {
            ind_fitness = 0; // re-init fitness value

            for ( int j = 0; j < chromosome_length; j++ ) {              
                ind_fitness = ind_fitness + pop[ i ][ j ];
            } // end for - calc fitness value for one ind

            fitness_values[ i ] = ind_fitness;  // store every ind fitness

            //compare current ind with (currently) best ind here
            if ( ind_fitness > best_fitness ) {
                for ( int k = 0; k < chromosome_length; k++ ) {
                    best[ k ] = pop[ i ][ k ];
                } // end for loop - copy best ind

                best_fitness = ind_fitness; // copy the current fitness into best ind
            } // replace the best ind with current ind

            // output (currently) best ind here - just to have a look!
            cout << gen_num << ":" << i << " Current best ind: ";
            // loop to print out best chromosome
            for ( int m = 0; m < chromosome_length; m++ ) {
                cout << best[ m ];        
            } // end for - print out best chromosome
            cout << gen_num << ":" << i << " Current Best Fitness value: " << best_fitness << endl;

            // summation of ind fitness values
            total_fitness = total_fitness + fitness_values[ i ];

        } // end for - calc fitness value for all ind

        // avg fitness here!
        avg_fitness = total_fitness / pop_size;

        // dump data here!
        myfile << gen_num << " " << best_fitness;
        myfile << " " << avg_fitness << endl;     

        // parent selection----------------------------------------
        int parent1;
        int parent2;
        int selected;
        int z = 0;
        int k = 2;      // tournament selection parameter

        // parent - tournament selection method
        for ( int count = 0; count < pop_size; count++ ) {
            parent1 = mt() % pop_size;  /* generate random value, [0,pop_size) */
            parent2 = mt() % pop_size;  /* generate random value, [0,pop_size) */

            if ( fitness_values[ parent1 ] > fitness_values[ parent2 ] ) {
                selected = parent1;
            } else {
                selected = parent2;
            }

            for ( int m = 0; m < chromosome_length; m++ ) {          
                mating_pool[ z ][ m ] = pop[ selected ][ m ];
            } // end for - copy winner into parent pool

            z = z + 1; // increment parent pool counter
        } // end for - loop each two individual
        // print out parent pop
        // parent selection ENDS----------------------------------

        // xover here----------------------------------------
        int p1[ chromosome_length ]; // temp parent1
        int p2[ chromosome_length ]; // temp parent2
        int offspring[ pop_size ][ chromosome_length ]; // offsprings array
        int j = 0; // counter for index of 2nd parent
        // prob of recombination
        double Pc = 0.6;    // arbitrary threshold value (higher than Pm)
        double prob_recombine;  // var to hold the generated prob

        for ( int i = 0; i < pop_size; i = i + 2) {
            j = i + 1;

            for ( int k = 0; k < chromosome_length; k++ ) {
                p1[ k ] = mating_pool[ i ][ k ];
                p2[ k ] = mating_pool[ j ][ k ]; // p2 gets the next ind
            }

            //copy the chromosome array, i.e. the ind
            for ( int z = 0; z < chromosome_length; z++ ) {
                offspring[ i ][ z ] = p1[ z ];
                offspring[ j ][ z ] = p2[ z ];
            }

            // get random position here for xover   
            // NO NEED to seed RNG object, already hv list of random numbers
            //mt.seed( time(NULL) ); // seed the RNG object         

            xover_position = 0; // re-init pos value
            // NEED to CHECK LOWER VALUE: should be
            // 0 till (chromosome_length - 1)           
            xover_position = mt() % chromosome_length;  /* generate xover position */

            prob_recombine = mtreal();

            // do recombination if prob LESS than threshold!
            if ( prob_recombine < Pc ) {
                for ( int counter = xover_position; counter < chromosome_length - 1; counter++ ) {
                    offspring[ i ][ counter ] = p2[ counter ];
                    offspring[ j ][ counter ] = p1[ counter ];
                } // end for - loop for xover starting from xover_position
            } // else here is just to display, actually no need!
            else {  // DO NOT do recombination if prob GREATER than threshold!
                // maintain offspring i and j values as is!
                cout << gen_num << ":" << i << " did not do recombination" << endl;
            }
        } // end for - loop select 2 parents        
        // xover ENDS----------------------------------------

        // mutate here----------------------------------------
        // prob of mutation
        double Pm = 0.4;    // arbitrary threshold value (lower than Pc)
        double prob_mutate; // var to hold the generated prob

        // go thru ALL ind
        for ( int i = 0; i < pop_size; i++ ) {
            // get random position here 
            // NO NEED to seed RNG object, already hv list of random numbers
            //mt.seed( time(NULL) ); // seed the RNG object         

            mutate_position = 0; // re-init pos value
            mutate_position = mt() % chromosome_length; /* generate position */

            prob_mutate = mtreal();

            // do mutation if prob LESS than threshold!
            if ( prob_mutate < Pm ) {
                // bit-flip the value at position
                if ( offspring[ i ][ mutate_position ] == 0 ) {
                    offspring[ i ][ mutate_position ] = 1;
                } else {
                    offspring[ i ][ mutate_position ] = 0;
                } // end if-else bit-flip
            } // else here is just to display, actually no need!
            else { // DO NOT do mutation if prob GREATER than threshold!
                cout << gen_num << ":" << i << " did not do mutation" << endl;
            }
        } // end for - mutate all ind
        // mutate ENDS----------------------------------------

        // survivor select here----------------------------------------
        // since offspring is NOT in pop[][],
        // so MUST write back into pop[][]
        for ( int i = 0; i < pop_size; i++ ) {
            for ( int j = 0; j < chromosome_length; j++ ) {
                pop[ i ][ j ] = offspring[ i ][ j ];
            } // end for - loop each ind 
        } // end for -loop write offspring into pop
        // survivor select ENDS----------------------------------------

        gen_num = gen_num + 1; // increment gen num
    } // end while loop - GA finish

    // output end best ind here
    // output (the final) best ind here - just to have a look!
    cout << "FINAL best ind: ";
    // loop to print out best chromosome
    for ( int j = 0; j < chromosome_length; j++ ) {
        cout << best[ j ];        
    } // end for - print out best chromosome

    cout << " FINAL Fitness value: " << best_fitness << endl;

    myfile.close();

    return 0;
} // end main
2
Contributors
1
Reply
3
Views
5 Years
Discussion Span
Last Post by PrimePackster
0

Hai i need help in C++

What help you want with the code you posted. We don't compile your code, you have to specify the error you face.

This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.