#include "inout.h"

int main (int argc, char *argv[])
{

    int a;
    cout<<"Zahl: ";
    cin>>Zahl;

    POP pop;
    pop.setsize(5);
    pop.pop_init();

    pop.check_Fitness();
    while(1){
            if(pop.return_best_fitness()>-5){//wenn die fitness in einem grenzwert ist ausgeben
                string out=pop.return_best_genes();
                cout<<"Fitness : "<<pop.return_best_fitness()<<endl;
                cout<<out<<endl;
            }

            pop.find_the_best();
            pop.changeGenes();
            pop.mutate(0.2);
            pop.check_Fitness();
             string out=pop.return_best_genes();
             cout<<"Fitness : "<<pop.return_best_fitness()<<endl;

            if((pop.return_best_fitness()==0)){//wenn fitness 0 abbrechen und ausgeben
                cout<<"Fitness ist 0 abbruch\n"<<"Gene der Zahl:"<<endl;
                break;
            }
    }
    string out=pop.return_best_genes();
    cout<<out.data()<<endl;
  return 0;
}  /* main()*/

void swap(int *pa,int *pb)
{
   int tmp=*pa;
   *pa=*pb;
   *pb=tmp;
}

so jetzt meine inout.h header:

#include <iostream>
#include <stdlib.h>

#include <time.h>
#include <math.h>
#include <string>
#define drand()  (rand()*(1.0/(RAND_MAX +1.0)))
#
void swap(int *pa,int *pb);
int Zahl;
using namespace std;

class IND{
    public:
        void ind_init(){
            for(int i=0;i<5;i++){//es gib nur die 5 Gene
                genes[i]=Zahl*drand() ;

            }
        }

        void ind_fitness(){
            int sum=0;
            for(int i=0;i<5;i++){
                sum=sum+genes[i];
            }
            if(sum==Zahl){
                fitness=abs(sum-Zahl);
            }
            else
                fitness=-abs(sum-Zahl);
        }
        void ind_mutate(double prob){
            if (drand() >= prob) return;
            do genes[(int)(5 *drand())] = (int)(Zahl *drand());
            while (drand() < prob);
        }

        string ind_genes_return(){
            string output;
            for(int i=0;i<5;i++){
            output=output.data()+genes[i];
            }
            return output;
        }

        string ind_fitness_return(){
            string output;
            output=fitness;
            return output;
        }

    public:
        int fitness;
        int n;
        int genes[5];
};
class POP{
    public:
        void pop_init(){
            srand (time(NULL));
            best.fitness=0;

            for(int i=0;i<size;i++){
            best.genes[i]=0;
            inds[i].n=i;
            inds[i].ind_init();
            }
        }
    void find_the_best(){
        for(int obergrenze=5;obergrenze>0;--obergrenze)
            {
                for(int pos=0;pos<4;pos++)
                {

                    if(inds[pos].fitness>inds[pos+1].fitness){
                    swap(inds[pos].genes,inds[pos+1].genes);
                    swap(&inds[pos].fitness,&inds[pos+1].fitness);
                    }

                }
            }
        best=inds[0];
    }

    void changeGenes(){
        int i,t;
        for (int i = 0; i < size-2; i += 2) {
        i=(rand() %5);

        t              = inds[i].genes[i];
        inds[i].genes[i] = inds[i+1].genes[i];
        inds[i+1].genes[i] = t;
        }
    }

    void check_Fitness(){
        for(int i=0;i<size;i++){
            inds[i].ind_fitness();
            }
    }

    void mutate(double prob){
        for(int i=0;i<size;i++){
            inds[i].ind_mutate(prob);
        }
        inds[0]=best;
    }

    void setsize(int i){
        size=i;
    }

    string return_best_genes(){
        string output;
        char buffer[20];
        for(int i=0;i<5;i++){
        sprintf(buffer,"%d",best.genes[i]);

        output.append(buffer);
        output.append(" ");
        }
        return output;
    }
    int return_best_fitness(){
        return best.fitness;
    }

    public:
        int size;
        IND inds[5];
        IND best;
};

                        /* (population) */

#endif // INOUT_H_INCLUDED

schonmal danek für eure antworten und entschuldigung dass der quelltext so lang ist aber ich weiß einfach ni woran dass liegt

so habe soweit meinen algorythmus fertig

Das heißt "Algorithmus" mit i.

nja habt ihr ahnung von genetischen algorithmen? oder soll ich den thread in rechtschreibreform umbenennen?

Aber du...

if(sum==Zahl){
                fitness=abs(sum-Zahl);
            }

klg71 schrieb:

nja habt ihr ahnung von genetischen algorithmen? oder soll ich den thread in rechtschreibreform umbenennen?

Aber du...

if(sum==Zahl){
                fitness=abs(sum-Zahl);
            }

Wird wohl immer 0 rauskommen ...

#ifndef INOUT_H_INCLUDED
#define INOUT_H_INCLUDED

#include <cassert>
#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
#include <numeric>
#include <string>
#include <sstream>
#include <iterator>

template<typename T>
inline T random(T factor) { return factor * std::rand() / ( RAND_MAX + 1 ); }

class Individual
{
public:
    explicit Individual(std::size_t num_genes, int num_variants)
    {
        std::generate_n( std::back_inserter( genes ), num_genes, std::tr1::bind( random<int>, num_variants ) );
    }

	friend Individual make_individual(std::size_t num_genes, int num_variants)
    {
        return Individual( num_genes, num_variants );
    }

    int get_fitness(int optimum_value) const
    {
        return -std::abs( std::accumulate( genes.begin(), genes.end(), -optimum_value ) );
    }

    std::string get_genes() const
    {
        std::ostringstream result;
        std::copy( genes.begin(), genes.end(), std::ostream_iterator<int>( result, " " ) );
        return result.str();
    }

    void crossover(Individual& other)
    {
        assert( genes.size() == other.genes.size() );
        using std::swap;
        std::size_t gene = random( genes.size() );
        swap( genes[ gene ], other.genes[ gene ] );
    }

    void mutate(int num_variants)
    {
        for ( std::size_t num_mutations = random( genes.size() ) + 1; num_mutations-- != 0; )
            genes[ random( genes.size() ) ] = random( num_variants );
    }

private:
    std::vector<int> genes;
};

class FitnessCompare : public std::binary_function<Individual,Individual,bool>
{
public:
    explicit FitnessCompare(int optimum) : optimum( optimum ) {}
    bool operator()(const Individual& lhs, const Individual& rhs)
    {
        return lhs.get_fitness( optimum ) < rhs.get_fitness( optimum );
    }
private:
    int optimum;
};
class Population
{
public:
	Population(std::size_t num_individuals, std::size_t num_genes, int num_variants)
    {
        std::generate_n( std::back_inserter( individuals ), num_individuals, std::tr1::bind( make_individual, num_genes, num_variants ) );
    }

    const Individual& best_individual(int optimum) const
    {
        return *std::max_element( individuals.begin(), individuals.end(), FitnessCompare( optimum ) );
    }

    void crossover()
    {
        for ( std::vector<Individual>::iterator individual = individuals.begin(); individual != individuals.end(); ++individual )
            individual->crossover( individuals[ random( individuals.size() ) ] );
    }

    void mutate(int num_variants, double prob)
    {
        for ( std::vector<Individual>::iterator individual = individuals.begin(); individual != individuals.end(); ++individual )
            if ( random( 1.0 ) < prob )
                individual->mutate( num_variants );
    }

private:
    std::vector<Individual> individuals;
};

#endif // INOUT_H_INCLUDED

#include "inout.h"
#include <ctime>

int main()
{
    std::srand( static_cast<unsigned>( std::time( NULL ) ) );

    int num_individuals = 0; std::cout << "Anzahl Individuen: "; std::cin >> num_individuals;
    int num_genes = 0;       std::cout << "Anzahl Gene: ";       std::cin >> num_genes;
    int num_variants = 0;    std::cout << "Anzahl Varianten: ";  std::cin >> num_variants;
    int optimum = 0;         std::cout << "Optimum: ";           std::cin >> optimum;

    Population population( num_individuals, num_genes, num_variants );

    for ( ;; )
    {
        const Individual& best = population.best_individual( optimum );
        int fitness = best.get_fitness( optimum );
        if ( fitness > -num_genes )
        {
            std::cout << "Fitness : " << fitness << '\n'
                      << best.get_genes() << std::endl;
            if ( fitness == 0 )
                break;
        }

        population.crossover();
        population.mutate( num_variants, 0.2 );
    }
}

Dabei ist mir dann aufgefallen, dass die changeGenes Funktion nicht funktionieren dürfte.
Ohne Selektion ist das natürlich noch kein genetischer Algorithmus.

Ich nehme immer das Roulettewheel-Verfahren.
Das geht aber nur solange gut, wie man von Inzucht weit entfernt ist. Wenn fast alle Elemente gleich sind, macht das keinen Spaß mehr. Insofern ist es manchmal auch besser, ein weniger "perfektes" Genome für Crossover zu nutzen, damit mal etwas "frisches Blut" in die Population kommt.

Ich logge immer die Durchschnittswerte und Standardabweichungen jedes Gens mit und kann so prüfen, ob sich
a) der genetische Algorithmus an einzelnen Stellen auf einen bestimmten Wert festlegt ( ist auch eine Aussage )
b) die Population sich der Inzucht nähert, wogegen man dann etwas unternehmen sollte. ( Paarungen mit einer anderen Population ( sofern vorhanden ), einkreuzen von neuen Genomen, Mutationsrate erhöhen, etc. )