main.cpp

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

//---------------------------------------------------------------------------

#include <vcl.h>
#include <math.h>
#include <boost/scoped_ptr.hpp>
#pragma hdrstop

#include "main.h"
#include "funkcje.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TFormM *FormM;

using namespace EXTR;
//---------------------------------------------------------------------------
int __fastcall Algorytm(LPVOID Parametr)
{
     FormM->Wykonaj();
     return 0;
}

//---------------------------------------------------------------------------
void __fastcall TFormM::Wykonaj(void)
{
     PBPop->Position = 0;
     PBPop->Max = ELPopulacji->Text.ToInt();
     WyczyscTabele1();
     WyczyscTabele2();
     Wyzeruj();

     double Extr = Extremum();
     Formatuj(Extr);
     LNum->Caption = Extr;

     for(int i = 0; i < ELPopulacji->Text.ToInt(); i++)
     {
          //-------------------------------------------------

          //------------------------------------------------
          std::vector<TZakres> WektorZakresow;
          int Xmin = EXmin->Text.ToInt();
          int Xmax = EXmax->Text.ToInt();
          TZakres Zakres = TZakres('X', Xmin, Xmax);
          WektorZakresow.push_back(Zakres);

          int Index = CBFunkcjaOceny->ItemIndex;
          if(Index == -1) return;

          boost::scoped_ptr<TPopulacja>
               Populacja(new TPopulacja(WektorZakresow, PFuncOceny[Index], MAXIMUM));

          Populacja->Set_PMutacji(EPMutacji->Text.ToInt());
          Populacja->Set_PKrzyzowania(EPKrzyzowania->Text.ToInt());
          Populacja->Set_Sigma(ESigma->Text.ToInt());
          Populacja->Set_LCykli(ELCykli->Text.ToInt());
          Populacja->Set_LGenotypow(ELOsobnikow->Text.ToInt());
          Populacja->Set_PRECYZJA((TPRECYZJA) EPrecyzja->Text.ToInt());
          Populacja->Set_PopulacjaDocelowa(EDoc->Text.ToInt());

          Populacja->Execute();
          PopStartowa = Populacja->Get_GenotypyPoczatkowe();
          PopDocelowa = Populacja->Get_Array();

          //-------------------------------------------------
          PBPop->Position++;
          LPopulacja->Caption = IntToStr(i + 1);
          WyczyscTabele2();
          WypelnijPola();

          //-------------------------------------------------
          WaitForSingleObject((LPVOID) BiezacyWatek, Opoznienie);

          //-------------------------------------------------

     }
     DodajAnalize();
     SBZakonczClick(this);
}

//---------------------------------------------------------------------------
double __fastcall TFormM::ObliczOdchylenie(void)
{
     int Count = ELPopulacji->Text.ToInt();
     double ExtremumNum = LNum->Caption.ToDouble();
     double Suma = 0.0;
     for(int i = 0; i < Count; i++)
     {
          double Extremum = (SGWybor->Cells[2][i + 1]).ToDouble();
          Suma += ExtremumNum - Extremum;
     }
     double Odchylenie = (Suma / Count) / ExtremumNum;
     Formatuj(Odchylenie);
     return Odchylenie;
}

//---------------------------------------------------------------------------

void __fastcall TFormM::DodajAnalize(void)
{
     int Count = SGWyniki->RowCount;

     SGWyniki->Cells[0][Count - 1] = Count - 1;
     SGWyniki->Cells[1][Count - 1] = CBFunkcjaOceny->Items->Strings[CBFunkcjaOceny->ItemIndex];
     SGWyniki->Cells[2][Count - 1] = EXmin->Text;
     SGWyniki->Cells[3][Count - 1] = EXmax->Text;
     SGWyniki->Cells[5][Count - 1] = ELOsobnikow->Text;
     SGWyniki->Cells[6][Count - 1] = EDoc->Text;
     SGWyniki->Cells[7][Count - 1] = ESigma->Text;
     SGWyniki->Cells[8][Count - 1] = EPMutacji->Text;
     SGWyniki->Cells[9][Count - 1] = EPKrzyzowania->Text;
     SGWyniki->Cells[10][Count - 1] = EPrecyzja->Text;
     SGWyniki->Cells[11][Count - 1] = ELCykli->Text;
     SGWyniki->Cells[12][Count - 1] = ELPopulacji->Text;
     SGWyniki->Cells[13][Count - 1] = LNum->Caption;
     SGWyniki->Cells[14][Count - 1] = ObliczOdchylenie();

     SGWyniki->RowCount++;
}

//---------------------------------------------------------------------------
void __fastcall TFormM::WyczyscTabele1(void)
{
     int Count = SGWybor->RowCount;
     for(int i = 1; i < Count; i++)
          SGWybor->Rows[i]->Clear();
     SGWybor->RowCount = 2;
}

//---------------------------------------------------------------------------
void __fastcall TFormM::WyczyscTabele2(void)
{
     int Count = SGPopPocz->RowCount;
     for(int i = 1; i < Count; i++)
          SGPopPocz->Rows[i]->Clear();
     SGPopPocz->RowCount = 2;
     Count = SGPopBiez->RowCount;
     for(int i = 1; i < Count; i++)
          SGPopBiez->Rows[i]->Clear();
     SGPopBiez->RowCount = 2;
}

//--------------------------------------------------------------------------
void __fastcall TFormM::Wyzeruj(void)
{
     PBPop->Position = 0;
     LPopulacja->Caption = "";
     PopStartowa = 0;
     PopDocelowa = 0;
}

//---------------------------------------------------------------------------
void __fastcall TFormM::WypelnijPola(void)
{
     if(!PopStartowa) return;
     TGenotyp* Genotyp = 0;
     int Count = PopStartowa->count();
     for(int i = 0; i < Count; i++)
     {
          Genotyp = PopStartowa->item(i);
          SGPopPocz->Cells[0][i + 1] = IntToStr(i + 1);
          SGPopPocz->Cells[1][i + 1] = Genotyp->Get_Fenotyp(0);
          SGPopPocz->Cells[2][i + 1] = Genotyp->Get_Fitnes();
          SGPopPocz->RowCount++;
     }

     if(!PopDocelowa) return;
     Count = PopDocelowa->count();
     for(int i = 0; i < Count; i++)
     {
          Genotyp = PopDocelowa->item(i);
          SGPopBiez->Cells[0][i + 1] = IntToStr(i + 1);
          SGPopBiez->Cells[1][i + 1] = Genotyp->Get_Fenotyp(0);
          SGPopBiez->Cells[2][i + 1] = Genotyp->Get_Fitnes();
          SGPopBiez->RowCount++;
     }

     Count = SGWybor->RowCount;
     Genotyp = PopDocelowa->item(0);
     SGWybor->Cells[0][Count - 1] = IntToStr(Count - 1);
     SGWybor->Cells[1][Count - 1] = Genotyp->Get_Fenotyp(0);
     SGWybor->Cells[2][Count - 1] = Genotyp->Get_Fitnes();
     SGWybor->RowCount++;
}

//---------------------------------------------------------------------------
void __fastcall TFormM::Init(void)
{
     SGPopPocz->Cells[0][0] = " Lp.";
     SGPopPocz->Cells[1][0] = "    Fenoptyp ";
     SGPopPocz->Cells[2][0] = "    Fitnes ";

     SGPopBiez->Cells[0][0] = " Lp.";
     SGPopBiez->Cells[1][0] = "    Fenoptyp ";
     SGPopBiez->Cells[2][0] = "    Fitnes ";

     SGWybor->Cells[0][0] = " Lp.";
     SGWybor->Cells[1][0] = "    Fenoptyp ";
     SGWybor->Cells[2][0] = "    Fitnes ";

     SGWyniki->Cells[0][0] = " Lp.";
     SGWyniki->Cells[1][0] = " Funkcja";
     SGWyniki->Cells[2][0] = " X min";
     SGWyniki->Cells[3][0] = " X max";
     SGWyniki->Cells[4][0] = " Rodzaj";
     SGWyniki->Cells[5][0] = " Pop. pocz.";
     SGWyniki->Cells[6][0] = " Pop doc.";
     SGWyniki->Cells[7][0] = " Sigma";
     SGWyniki->Cells[8][0] = " P. mut.";
     SGWyniki->Cells[9][0] = " P. Krzy?.";
     SGWyniki->Cells[10][0] = " Precyzja";
     SGWyniki->Cells[11][0] = " L. cykli";
     SGWyniki->Cells[12][0] = " L. populacji";
     SGWyniki->Cells[13][0] = " Extremum";
     SGWyniki->Cells[14][0] = " Odchylenie";

     //----------------------------------------------------
     BiezacyWatek = 0;
     SecurityAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
     SecurityAttr.lpSecurityDescriptor = 0;
     SecurityAttr.bInheritHandle = true;

     //----------------------------------------------------
     Populacja = 0;
     Opoznienie = EOpoznienie->Text.ToInt();
     LStop->Caption = "";

     //----------------------------------------------------
     Przedzial[0].Min = -10;
     Przedzial[0].Max = 10;
     Przedzial[1].Min = 0;
     Przedzial[1].Max = 10;

     //----------------------------------------------------
     Wyzeruj();
}

//---------------------------------------------------------------------------
double __fastcall TFormM::Extremum(void)
{
     int Precyzja = EPrecyzja->Text.ToInt();
     double Begin = EXmin->Text.ToDouble();
     double End   = EXmax->Text.ToDouble();
     int Index = CBFunkcjaOceny->ItemIndex;

     double Extr, Punkt;
     for(int I = 0; I < Precyzja; I++)
     {
          PBNum->Position = 0;
          PBNum->Max = (End - Begin) / (1.0 / pow(10, I));
          Extr = PFunc[Index](Begin);
          for(double x = Begin; x < End; x += 1.0 / pow(10, I))
          {
               if(Extr < PFunc[Index](x))
               {
                    Extr = PFunc[Index](x);
                    Punkt = x;
               }
               PBNum->Position++;
          }
          if(Begin != Punkt)
               Begin = Punkt - 1.0 / pow(10, I);
          if(End != Punkt)
               End = Punkt + 1.0 / pow(10, I);
     }
     return Extr;
}

//---------------------------------------------------------------------------
void __fastcall TFormM::Formatuj(double& Value)
{
     double Temp = pow(10, EPrecyzja->Text.ToInt());
     Value = (double)(((int)(Value * Temp + 0.5)) / Temp);
}

//---------------------------------------------------------------------------
__fastcall TFormM::TFormM(TComponent* Owner)
                         :
                         TForm(Owner)
{
     Init();
}

//---------------------------------------------------------------------------
void __fastcall TFormM::SBStartClick(TObject *Sender)
{
     BiezacyWatek = BeginThread(&SecurityAttr, 4096, Algorytm, this,
                                                  CREATE_SUSPENDED, NumerID);

     if(BiezacyWatek == (int) INVALID_HANDLE_VALUE)
     {
          MessageBox(0, " B??d wykonania w?tku ", "B??d", MB_OK);
     }
     else
     {
          ResumeThread((LPVOID) BiezacyWatek);
          Uchwyt = CreateEvent(0, false, false, 0);
          if(Uchwyt)
          {
               WaitForSingleObject(Uchwyt, 100);

               LStop->Font->Color = clTeal;
               LStop->Caption = "Wykonywanie";
               SBStart->Enabled = false;
               SBZamknij->Enabled = false;

               CloseHandle(Uchwyt);
          }
     }
}

//---------------------------------------------------------------------------
void __fastcall TFormM::SBWstrzymajClick(TObject *Sender)
{
     SuspendThread((LPVOID) BiezacyWatek);
     Zawieszony = true;

     LStop->Font->Color = clRed;
     LStop->Caption = "Wstrzymane";
}
//---------------------------------------------------------------------------

void __fastcall TFormM::SBPonowClick(TObject *Sender)
{
     ResumeThread((LPVOID) BiezacyWatek);
     Zawieszony = false;

     LStop->Font->Color = clTeal;
     LStop->Caption = "Wykonywanie";
}

//---------------------------------------------------------------------------
void __fastcall TFormM::SBZakonczClick(TObject *Sender)
{
     SBStart->Enabled = true;
     SBZamknij->Enabled = true;
     LStop->Font->Color = clTeal;
     LStop->Caption = "Zako?czone";

     if(Zawieszony == false)
     {
          SuspendThread((LPVOID) BiezacyWatek);
          WaitForSingleObject((LPVOID) BiezacyWatek, 10);
     }
     CloseHandle((LPVOID) BiezacyWatek);
}

//---------------------------------------------------------------------------

void __fastcall TFormM::CBFunkcjaOcenyChange(TObject *Sender)
{
     int Index = CBFunkcjaOceny->ItemIndex;
     if(Index == -1) return;

     UDXmin->Position = Przedzial[Index].Min;
     UDXmax->Position = Przedzial[Index].Max;
}
//---------------------------------------------------------------------------


void __fastcall TFormM::EOpoznienieChange(TObject *Sender)
{
     Opoznienie = EOpoznienie->Text.ToInt();
}
//---------------------------------------------------------------------------

void __fastcall TFormM::SBZamknijClick(TObject *Sender)
{
     this->Close();     
}
//---------------------------------------------------------------------------

void __fastcall TFormM::FormClose(TObject *Sender, TCloseAction &Action)
{
     Action = caFree;
}
//---------------------------------------------------------------------------