nicht deklarierte Bezeichner?
Immer Fehler mit code, es ist eine Konvertierung von alten VS 2010 version:
#include <string>
#include <stdlib.h>
#include <iostream>
#include <time.h>
#include <math.h>
using std::string;
#define CROSSOVER_RATE 0.7
#define MUTATION_RATE 0.001
#define POP_SIZE 100 //must be an even number
#define CHROMO_LENGTH 300
#define GENE_LENGTH 4
#define MAX_ALLOWABLE_GENERATIONS 400
//returns a float between 0 & 1
#define RANDOM_NUM ((float)rand()/(RAND_MAX+1))
//----------------------------------------------------------------------------------------
//
// define a data structure which will define a chromosome
//
//----------------------------------------------------------------------------------------
struct chromo_typ
{
//the binary bit string is held in a std::string
string bits;
float fitness;
chromo_typ(): bits(""), fitness(0.0f){};
chromo_typ(string bts, float ftns): bits(bts), fitness(ftns){}
};
/////////////////////////////////prototypes/////////////////////////////////////////////////////
void PrintGeneSymbol(int val);
string GetRandomBits(int length);
int BinToDec(string bits);
float AssignFitness(string bits, int target_value);
void PrintChromo(string bits);
void PrintGeneSymbol(int val);
int ParseBits(string bits, int* buffer);
string Roulette(int total_fitness, chromo_typ* Population);
void Mutate(string &bits);
void Crossover(string &offspring1, string &offspring2);
//-------------------------------main--------------------------------------------------
//
//-------------------------------------------------------------------------------------
int main()
{
//seed the random number generator
srand((int)time(NULL));
//just loop endlessly until user gets bored :0)
while (true)
{
//storage for our population of chromosomes.
chromo_typ Population[POP_SIZE];
//get a target number from the user. (no error checking)
float Target;
cout << "\nInput a target number: ";
cin >> Target;
cout << endl << endl;
//first create a random population, all with zero fitness.
for (int i=0; i<POP_SIZE; i++)
{
Population[i].bits = GetRandomBits(CHROMO_LENGTH);
Population[i].fitness = 0.0f;
}
int GenerationsRequiredToFindASolution = 0;
//we will set this flag if a solution has been found
bool bFound = false;
//enter the main GA loop
while(!bFound)
{
//this is used during roulette wheel sampling
float TotalFitness = 0.0f;
//test and update the fitness of every chromosome in the
//population
for (int i=0; i<POP_SIZE; i++)
{
Population[i].fitness = AssignFitness(Population[i].bits, Target);
TotalFitness += Population[i].fitness;
}
//check to see if we have found any solutions (fitness will be 999)
for (i=0; i<POP_SIZE; i++)
{
if (Population[i].fitness == 999.0f)
{
cout << "\nSolution found in " << GenerationsRequiredToFindASolution << " generations!" << endl << endl;;
PrintChromo(Population[i].bits);
bFound = true;
break;
}
}
//create a new population by selecting two parents at a time and creating offspring
//by applying crossover and mutation. Do this until the desired number of offspring
//have been created.
//define some temporary storage for the new population we are about to create
chromo_typ temp[POP_SIZE];
int cPop = 0;
//loop until we have created POP_SIZE new chromosomes
while (cPop < POP_SIZE)
{
//we are going to create the new population by grabbing members of the old population
//two at a time via roulette wheel selection.
string offspring1 = Roulette(TotalFitness, Population);
string offspring2 = Roulette(TotalFitness, Population);
//add crossover dependent on the crossover rate
Crossover(offspring1, offspring2);
//now mutate dependent on the mutation rate
Mutate(offspring1);
Mutate(offspring2);
//add these offspring to the new population. (assigning zero as their
//fitness scores)
temp[cPop++] = chromo_typ(offspring1, 0.0f);
temp[cPop++] = chromo_typ(offspring2, 0.0f);
}//end loop
//copy temp population into main population array
for (i=0; i<POP_SIZE; i++)
{
Population[i] = temp[i];
}
++GenerationsRequiredToFindASolution;
//exit app if no solution found within the maximum allowable number
//of generations
if (GenerationsRequiredToFindASolution > MAX_ALLOWABLE_GENERATIONS)
{
cout << "No solutions found this run!";
bFound = true;
}
}
cout << "\n\n\n";
}//end while
return 0;
}
//---------------------------------GetRandomBits-----------------------------------------
//
// This function returns a string of random 1s and 0s of the desired length.
//
//-----------------------------------------------------------------------------------------
string GetRandomBits(int length)
{
string bits;
for (int i=0; i<length; i++)
{
if (RANDOM_NUM > 0.5f)
bits += "1";
else
bits += "0";
}
return bits;
}
//---------------------------------BinToDec-----------------------------------------
//
// converts a binary string into a decimal integer
//
//-----------------------------------------------------------------------------------
int BinToDec(string bits)
{
int val = 0;
int value_to_add = 1;
for (int i = bits.length(); i > 0; i--)
{
if (bits.at(i-1) == '1')
val += value_to_add;
value_to_add *= 2;
}//next bit
return val;
}
//---------------------------------ParseBits------------------------------------------
//
//Given a chromosome this function will step through the genes one at a time and insert
//the decimal values of each gene (which follow the operator -> number -> operator rule)
//into a buffer. Returns the number of elements in the buffer.
//------------------------------------------------------------------------------------
int ParseBits(string bits, int* buffer)
{
//counter for buffer position
int cBuff = 0;
//step through bits a gene at a time until end and store decimal values
//of valid operators and numbers. Don't forget we are looking for operator -
//number - operator - number and so on... We ignore the unused genes 1111
//and 1110
//flag to determine if we are looking for an operator or a number
bool bOperator = true;
//storage for decimal value of currently tested gene
int this_gene = 0;
for (int i=0; i<CHROMO_LENGTH; i+=GENE_LENGTH)
{
//convert the current gene to decimal
this_gene = BinToDec(bits.substr(i, GENE_LENGTH));
//find a gene which represents an operator
if (bOperator)
{
if ( (this_gene < 10) || (this_gene > 13) )
continue;
else
{
bOperator = false;
buffer[cBuff++] = this_gene;
continue;
}
}
//find a gene which represents a number
else
{
if (this_gene > 9)
continue;
else
{
bOperator = true;
buffer[cBuff++] = this_gene;
continue;
}
}
}//next gene
// now we have to run through buffer to see if a possible divide by zero
// is included and delete it. (ie a '/' followed by a '0'). We take an easy
// way out here and just change the '/' to a '+'. This will not effect the
// evolution of the solution
for (i=0; i<cBuff; i++)
{
if ( (buffer[i] == 13) && (buffer[i+1] == 0) )
buffer[i] = 10;
}
return cBuff;
}
//---------------------------------AssignFitness--------------------------------------
//
// given a string of bits and a target value this function will calculate its
// representation and return a fitness score accordingly
//------------------------------------------------------------------------------------
float AssignFitness(string bits, int target_value)
{
//holds decimal values of gene sequence
int buffer[(int)(CHROMO_LENGTH / GENE_LENGTH)];
int num_elements = ParseBits(bits, buffer);
//ok, we have a buffer filled with valid values of: operator - number - operator - number..
//now we calculate what this represents.
float result = 0.0f;
for (int i=0; i < num_elements-1; i+=2)
{
switch (buffer[i])
{
case 10:
result += buffer[i+1];
break;
case 11:
result -= buffer[i+1];
break;
case 12:
result *= buffer[i+1];
break;
case 13:
result /= buffer[i+1];
break;
}//end switch
}
//Now we calculate the fitness. First check to see if a solution has been found
//and assign an arbitarily high fitness score if this is so.
if (result == (float)target_value)
return 999.0f;
else
return 1/(float)fabs((double)(target_value - result));
// return result;
}
//---------------------------------PrintChromo---------------------------------------
//
//decodes and prints a chromo to screen
//-----------------------------------------------------------------------------------
void PrintChromo(string bits)
{
//holds decimal values of gene sequence
int buffer[(int)(CHROMO_LENGTH / GENE_LENGTH)];
//parse the bit string
int num_elements = ParseBits(bits, buffer);
for (int i=0; i<num_elements; i++)
{
PrintGeneSymbol(buffer[i]);
}
return;
}
//--------------------------------------PrintGeneSymbol-----------------------------
//
// given an integer this function outputs its symbol to the screen
//----------------------------------------------------------------------------------
void PrintGeneSymbol(int val)
{
if (val < 10 )
cout << val << " ";
else
{
switch (val)
{
case 10:
cout << "+";
break;
case 11:
cout << "-";
break;
case 12:
cout << "*";
break;
case 13:
cout << "/";
break;
}//end switch
cout << " ";
}
return;
}
//------------------------------------Mutate---------------------------------------
//
// Mutates a chromosome's bits dependent on the MUTATION_RATE
//-------------------------------------------------------------------------------------
void Mutate(string &bits)
{
for (int i=0; i<bits.length(); i++)
{
if (RANDOM_NUM < MUTATION_RATE)
{
if (bits.at(i) == '1')
bits.at(i) = '0';
else
bits.at(i) = '1';
}
}
return;
}
//---------------------------------- Crossover ---------------------------------------
//
// Dependent on the CROSSOVER_RATE this function selects a random point along the
// lenghth of the chromosomes and swaps all the bits after that point.
//------------------------------------------------------------------------------------
void Crossover(string &offspring1, string &offspring2)
{
//dependent on the crossover rate
if (RANDOM_NUM < CROSSOVER_RATE)
{
//create a random crossover point
int crossover = (int) (RANDOM_NUM * CHROMO_LENGTH);
string t1 = offspring1.substr(0, crossover) + offspring2.substr(crossover, CHROMO_LENGTH);
string t2 = offspring2.substr(0, crossover) + offspring1.substr(crossover, CHROMO_LENGTH);
offspring1 = t1; offspring2 = t2;
}
}
//--------------------------------Roulette-------------------------------------------
//
// selects a chromosome from the population via roulette wheel selection
//------------------------------------------------------------------------------------
string Roulette(int total_fitness, chromo_typ* Population)
{
//generate a random number between 0 & total fitness count
float Slice = (float)(RANDOM_NUM * total_fitness);
//go through the chromosones adding up the fitness so far
float FitnessSoFar = 0.0f;
for (int i=0; i<POP_SIZE; i++)
{
FitnessSoFar += Population[i].fitness;
//if the fitness so far > random number return the chromo at this point
if (FitnessSoFar >= Slice)
return Population[i].bits;
}
return "";
}
Die Fehler die ich bekomme sind:
error C2065: 'cin' : undeclared identifier
error C2065: 'cout' : undeclared identifier
error C2065: 'endl' : undeclared identifier
error C2065: 'i' : undeclared identifier
error C2228: left of '.bits' must have class/struct/union
error C2228: left of '.fitness' must have class/struct/union
InformationsquelleAutor Garrith Graham | 2011-05-31
Du musst angemeldet sein, um einen Kommentar abzugeben.
Präfix jeder
cin, cout
( std::cin, std::cout ) mit std oder erklärenusing namespace std;
am Anfang.Wäre +1 mit Ausnahme deklarieren "using namespace std;" am Anfang.
namespace std
ist riesig. Wenn er verwendet dieses Muster in allen Programmen, es wird wahrscheinlich in Konflikt mit seinem code an einem gewissen Punkt.Dank mahesh alle jetzt behoben
InformationsquelleAutor Mahesh
Du entweder wollen
std::cin
(usw.) oderusing std::cin;
an der Spitze der Quellcode-Datei.Als für das problem mit
i
; na, hast du eine Schleife, die verwendeti
ohne Sie zu deklarieren (dies wiederum verursacht auch das problem mit.bits
und.fitness
.InformationsquelleAutor Oliver Charlesworth
Entweder Präfix jeder
cin
,cout
, undendl
mitstd::
, oder fügen Sie diese Zeilen in Ihr Programm nach Ihren enthält:Als für den nächsten Fehler:
Ändern Sie diese Zeile:
:
Schleife Variablen-Deklarationen außerhalb des Bereichs am Ende der Schleife.
P. s. Lieber
cout << '\n'
zucout << endl
. Letztere leert den Ausgabe-stream (oft unnötig), was eine schreckliche langsam nach unten, wenn Sie schreiben viele Zeilen in einer Datei.InformationsquelleAutor Robᵩ