extrema.cpp

Implementation of genetic algorithm, to search for desired extreme n-variable function.

//---------------------------------------------------------------------------
#include <Dialogs.hpp>
#pragma hdrstop
#include "extrema.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)

//---------------------------------------------------------------------------
using std::random;
using namespace EXTR;

/////// TLOSOWANIE //////////////////////////////////////////////////////////
void __fastcall TGenerator::Generuj(TZakres register const* Zakres)
{
	register double Begin = Zakres->Begin;
	register double End   = Zakres->End;

	register int A = Begin * PRZEDZIAL;
	register int B = End * PRZEDZIAL;

	register double Value = (double)(random(B - A));
	Value /= PRZEDZIAL;
	Value += Begin;

	Znak = 1; if(Value < 0) Znak = -1;
	Value = sqrt(Value * Value);
	ValueC = (int) (Value);
	ValueU = (int) ((Value - ValueC) * PRZEDZIAL);
}

//---------------------------------------------------------------------------
int __fastcall TGenerator::Get_CzescC(void) {return ValueC;}

//---------------------------------------------------------------------------
int __fastcall TGenerator::Get_CzescU(void) {return ValueU;}

//---------------------------------------------------------------------------
int __fastcall TGenerator::Get_Znak(void) {return Znak;}

/////// TCHROMOSOM /////////////////////////////////////////////////////////
void __fastcall TChromosom::IntToBinary(register int Value, TBinary& Binary)
{
	Binary = "";
	while(Value / 2)
	{
		Binary.insert(0, IntToString(Value % 2));
		Value /= 2;
	}
	Binary.insert(0, IntToString(Value));
}

//---------------------------------------------------------------------------
int __fastcall TChromosom::BinaryToInt(register TBinary const& Binary)
{
	 register int Count = Binary.size();
	 register int Wartosc = 0;
	 register bool Zero = true;
	 for(register int i = 0; i < Count; i++)
	 {
		if(Binary[i] == '1')
		{
			Wartosc += pow(2, Count - i - 1);
			Zero = false;
		}
	 }
	 if(Zero) Wartosc = 0;
	 return Wartosc;
}

//---------------------------------------------------------------------------
double __fastcall TChromosom::BinaryToFenotyp(void)
{
	return IntToFenotyp(BinaryToInt(BinaryC), BinaryToInt(BinaryU));
}

//---------------------------------------------------------------------------
double __fastcall TChromosom::IntToFenotyp(register int CzescC, register int CzescU)
{
	return (Znak * (((double)CzescC) + ((double)CzescU) / PRZEDZIAL));
}

//---------------------------------------------------------------------------
__fastcall TChromosom::TChromosom(TZakres register const* Zakres)
{
	Geny = new TGeny();

	boost::scoped_ptr<TGenerator> Generator(new TGenerator());
	Generator->Generuj(Zakres);
	register int CzescC = Generator->Get_CzescC();
	register int CzescU = Generator->Get_CzescU();
	Znak = Generator->Get_Znak();
	Sign = Zakres->Sign;

	IntToBinary(CzescC, BinaryC);
	IntToBinary(CzescU, BinaryU);

	Fenotyp = IntToFenotyp(CzescC, CzescU);
}

//---------------------------------------------------------------------------
__fastcall TChromosom::TChromosom(TGeny register const* Geny_)
{
	Geny = new TGeny();

	BinaryC = Geny_->BinaryC;
	BinaryU = Geny_->BinaryU;
	Znak = Geny_->Znak;
	Sign = Geny_->Sign;

	Fenotyp = BinaryToFenotyp();
}

//---------------------------------------------------------------------------
__fastcall TChromosom::~TChromosom(void) { delete Geny;}

//---------------------------------------------------------------------------
char __fastcall TChromosom::Get_Sign(void) {return Sign;}

//---------------------------------------------------------------------------
double __fastcall TChromosom::Get_Fenotyp(void) {return Fenotyp;}

//---------------------------------------------------------------------------
TGeny* __fastcall TChromosom::Get_Geny(void)
{
	Geny->BinaryC = BinaryC;
	Geny->BinaryU = BinaryU;
	Geny->Znak    = Znak;
	Geny->Sign    = Sign;

	return Geny;
}

//---------------------------------------------------------------------------
TGeny* __fastcall TChromosom::Mutacja(register int Pozycja)
{
	register TBinary BinaryBisC = BinaryC;
	register TBinary BinaryBisU = BinaryU;
	register int    ZnakBis    = Znak;

	register int Numer;
	if(Pozycja) Numer = 3;
	else
	{
		Numer = random(10) + 1;
		if(Numer > 3) Numer = 3;
	}

	register int Locus;
	switch(Numer)
	{
		case 1:
		{
			if(ZnakBis == -1) ZnakBis = 1;
			else              ZnakBis = -1;
		} break;
		case 2:
		{
			Locus = random(BinaryBisC.size());
			if(BinaryBisC[Locus] == '0') BinaryBisC[Locus] = '1';
			else                         BinaryBisC[Locus] = '0';
		} break;
		case 3:
		{
			if(Pozycja)
			{
				switch(Pozycja)
				{
					case 1: Locus = 4; break;
					case 2: Locus = 8; break;
					case 3: Locus = 12; break;
					case 4: Locus = 16; break;
					case 5: Locus = 20; break;
					case 6: Locus = 24; break;
					default: Locus = 24;
				}
			}
			else
				Locus = random(BinaryBisU.size());

			if(BinaryBisU[Locus] == '0') BinaryBisU[Locus] = '1';
			else                         BinaryBisU[Locus] = '0';

		} break;
	}

	Geny->BinaryC = BinaryBisC;
	Geny->BinaryU = BinaryBisU;
	Geny->Znak    = ZnakBis;
	Geny->Sign    = Sign;

	return Geny;
}

/////// TGENOTYP ////////////////////////////////////////////////////////////
void __fastcall TGenotyp::Formatuj(double& Value)
{
     double Temp = pow(10, (int)PRECYZJA);
     Value = (double)(((int)(Value * Temp + 0.5)) / Temp);
}

//---------------------------------------------------------------------------
__fastcall TGenotyp::TGenotyp(TWektorZakresow register const* WektorZakresow,
                              register TPFuncOceny PFuncOceny, TPRECYZJA PREC)
						:
                        PRECYZJA(PREC),
						ArrayOfCh(new TArrayOfCh()),
						WektorGenow(new TWektorGenow())
{
	boost::scoped_ptr<TWektorOfWsp> WektorOfWsp(new TWektorOfWsp());

	register int Count = WektorZakresow->count();
	for(register int i = 0; i < Count; i++)
	{
		ArrayOfCh->add(new TChromosom(WektorZakresow->item(i)));

		TWspolrzedna* Wsp = new TWspolrzedna(ArrayOfCh->item(i)->Get_Sign(),
								  ArrayOfCh->item(i)->Get_Fenotyp());
		WektorOfWsp->add(Wsp);
	}

	if(Count)
     {
		Fitnes = PFuncOceny(WektorOfWsp.get());
          Formatuj(Fitnes);
     }
}

//---------------------------------------------------------------------------
__fastcall TGenotyp::TGenotyp(TPFuncOceny register PFuncOceny,
                              TWektorGenow register const* WektorGenow_, TPRECYZJA PREC)
						:
                              PRECYZJA(PREC),
						ArrayOfCh(new TArrayOfCh()),
						WektorGenow(new TWektorGenow())
{
	boost::scoped_ptr<TWektorOfWsp> WektorOfWsp(new TWektorOfWsp());

	register int Count = WektorGenow_->count();
	for(register int i = 0; i < Count; i++)
	{
		ArrayOfCh->add(new TChromosom(WektorGenow_->item(i)));

		TWspolrzedna* Wsp = new TWspolrzedna(ArrayOfCh->item(i)->Get_Sign(),
								  ArrayOfCh->item(i)->Get_Fenotyp());
		WektorOfWsp->add(Wsp);
	}

	if(Count)
     {
		Fitnes = PFuncOceny(WektorOfWsp.get());
          Formatuj(Fitnes);
     }
}

//---------------------------------------------------------------------------
__fastcall TGenotyp::~TGenotyp(void) {}

//---------------------------------------------------------------------------
TWektorGenow const* __fastcall TGenotyp::Get_Geny(void)
{
	register int LiczbaGenow = ArrayOfCh->count();
	WektorGenow->clear();
	for(register int i = 0; i < LiczbaGenow; i++)
		WektorGenow->add(new TGeny(ArrayOfCh->item(i)->Get_Geny()));

	return WektorGenow.get();
}

//---------------------------------------------------------------------------
double __fastcall TGenotyp::Get_Fenotyp(register int Index) const
{
	return ArrayOfCh->item(Index)->Get_Fenotyp();
}

//---------------------------------------------------------------------------
double __fastcall TGenotyp::Get_Fitnes(void) const {return Fitnes;}


//---------------------------------------------------------------------------
TWektorGenow const* __fastcall TGenotyp::Mutacja(register char Sign, register unsigned Pozycja)
{
	WektorGenow->clear();

	register int Count = ArrayOfCh->count();
	for(register int i = 0; i < Count; i++)
	{
		if(Sign == ArrayOfCh->item(i)->Get_Sign())
			WektorGenow->add(new TGeny(ArrayOfCh->item(i)->Mutacja(Pozycja)));
		else
			WektorGenow->add(new TGeny(ArrayOfCh->item(i)->Get_Geny()));
	}

	return WektorGenow.get();
}

/////// TPOPULACJA //////////////////////////////////////////////////////////
void __fastcall TPopulacja::Algorytm(void)
{
     UtworzPopulacje();

     int LiczbaCykli = (int) (Precyzja);
     for(int i = 0; i < LiczbaCykli; i++)
     {
          WykonajCykle();
          Wysegreguj();
          PozycjaLocus = i;
     }
     Selekcja();
}

//--------------------------------------------------------------------------
void __fastcall TPopulacja::UtworzPopulacje(void)