Example #1
0
 public Jedinka(Jedinka jedinka)
 {
     MAX_INT    = (int)Math.Pow(2, MAXSTRING) - 1;
     MIN_X      = jedinka.MIN_X;
     MAX_X      = jedinka.MAX_X;
     x          = jedinka.x;
     chromosome = int2bin((int)x);
 }
Example #2
0
 void mutacija(Jedinka jedinka, double prag)
 {
     //TODO 4: Implementirati operaciju mutacije
     for (int i = 0; i < jedinka.chromosome.Length; i++)
     {
         double a = rand.NextDouble();
         if (a <= prag)
         {
             jedinka.chromosome[i] = 1 - jedinka.chromosome[i];
         }
     }
     jedinka.x = jedinka.bin2double(jedinka.chromosome);
 }
Example #3
0
 public Kodiranje()
 {
     InitializeComponent();
     jedinka = new Jedinka(5, 0, 65535);
     jedinkaPanel1.jedinka = jedinka;
     jedinkaPanel1.Refresh();
     tbMaxInt.Text           = "" + jedinka.MAX_INT;
     tbMaxString.Text        = "" + Jedinka.MAXSTRING;
     tbMaxX.Text             = "" + jedinka.MAX_X;
     tbMinX.Text             = "" + jedinka.MIN_X;
     tbX.Text                = "" + jedinka.x;
     kodiranjePanel1.jedinka = jedinka;
     kodiranjePanel1.Refresh();
 }
Example #4
0
        void ukrstanje(Jedinka jedinka1, Jedinka jedinka2, double prag)
        {
            //TODO 3: Implementirati operaciju ukrstanja
            int N = rand.Next(0, Jedinka.MAXSTRING / 2); //slucajno se generise N
            int M = Jedinka.MAXSTRING - 2 * N;

            //menja se centralnih M hromozoma
            for (int i = N; i < N + M; ++i)
            {
                int temp = jedinka1.chromosome[i];
                jedinka1.chromosome[i] = jedinka2.chromosome[i];
                jedinka2.chromosome[i] = temp;
            }
        }
Example #5
0
        //TODO 5: Mrzim konstruktore
        public Jedinka(Jedinka jedinka)
        {
            MAX_INT  = (int)Math.Pow(2, PRVA) - 1;
            MAX_INT2 = (int)Math.Pow(2, MAXSTRING - PRVA) - 1;

            MIN_X  = jedinka.MIN_X;
            MAX_X  = jedinka.MAX_X;
            MIN_X2 = jedinka.MIN_X2;
            MAX_X2 = jedinka.MAX_X2;

            x  = jedinka.x;
            x2 = jedinka.x2;

            chromosome = int2bin((int)x, (int)x2);
        }
Example #6
0
 void ukrstanje(Jedinka jedinka1, Jedinka jedinka2, double prag)
 {
     //TODO 3: Implementirati operaciju ukrstanja
     for (int i = 0; i < jedinka1.chromosome.Length; i++)
     {
         double a = rand.NextDouble();
         if (a <= prag)
         {
             int k = jedinka1.chromosome[i];
             jedinka1.chromosome[i] = jedinka2.chromosome[i];
             jedinka2.chromosome[i] = k;
         }
     }
     jedinka1.x = jedinka1.bin2double(jedinka1.chromosome);
     jedinka2.x = jedinka2.bin2double(jedinka2.chromosome);
 }
Example #7
0
 void ukrstanje(Jedinka jedinka1, Jedinka jedinka2, double prag)
 {
     //TODO 3: Implementirati operaciju ukrstanja
     for (int i = 0; i < Jedinka.MAXSTRING; i++)
     {
         double t = rand.NextDouble();
         if (t < prag)
         {
             int tmp = jedinka1.chromosome[i];
             jedinka1.chromosome[i] = jedinka2.chromosome[i];
             jedinka2.chromosome[i] = tmp;
         }
     }
     jedinka1.x = jedinka1.bin2double(jedinka1.chromosome);
     jedinka2.x = jedinka2.bin2double(jedinka2.chromosome);
 }
Example #8
0
        void mutacija(Jedinka jedinka, double prag)
        {
            //za svaki gen u hromozomu jednike se generise slucajni broj koji odlucuje da li se taj bit invertuje
            for (int i = 0; i < Jedinka.MAXSTRING; ++i)
            {
                double slucajanBroj = rand.NextDouble();
                if (slucajanBroj < prag)
                {
                    jedinka.chromosome[i] = 1 - jedinka.chromosome[i];
                }
            }

            jedinka.x = jedinka.bin2double(jedinka.chromosome);
            //TODO 11: Ne zaboraviti promeniti double vrednost i druge promenljive
            jedinka.x2 = jedinka.bin2double2(jedinka.chromosome);
        }
Example #9
0
        private void btnPopulacija_Click(object sender, EventArgs e)
        {
            int brojVrsta = 10;

            Jedinka[] populacija = new Jedinka[brojVrsta];
            try
            {
                double maxX = Convert.ToDouble(tbMaxX.Text);
                double minX = Convert.ToDouble(tbMinX.Text);
                Random rnd  = new Random();
                for (int i = 0; i < brojVrsta; i++)
                {
                    double x = minX + (maxX - minX) * rnd.NextDouble();
                    populacija[i]       = new Jedinka(x, minX, maxX);
                    populacija[i].ocena = GenetskiAlgoritam.funkcija(x);
                }
                // odrediti ocenuP
                double minOcena = populacija[0].ocena;
                double maxOcena = populacija[0].ocena;
                for (int i = 0; i < brojVrsta; i++)
                {
                    minOcena = Math.Min(minOcena, populacija[i].ocena);
                    maxOcena = Math.Max(maxOcena, populacija[i].ocena);
                }
                // skaliranje minOcena = 0 maxOcena = 100
                double a      = 100 / (maxOcena - minOcena);
                double b      = -a * minOcena;
                double ukupno = 0;
                for (int i = 0; i < brojVrsta; i++)
                {
                    double ocenaP = (float)(a * populacija[i].ocena + b);
                    ukupno += ocenaP;
                    populacija[i].ocenaP = ocenaP / 100.0;
                    //Debug.WriteLine("Za X : " + populacija[i].x + ", ocena je : " + populacija[i].ocena + " i ocenaP je " + populacija[i].ocenaP);
                }

                populacijaPanel1.populacija = populacija;
                populacijaPanel1.Refresh();
            }
            catch (Exception ex)
            {
                statusBar.Text = "Greška!";
            }
        }
Example #10
0
        public PopulacijaPanel()
        {
            InitializeComponent();
            int brojVrsta = 10;

            populacija = new Jedinka[brojVrsta];
            Random rnd  = new Random();
            double minX = 0;
            double maxX = 100;

            for (int i = 0; i < brojVrsta; i++)
            {
                double x = minX + (maxX - minX) * rnd.NextDouble();
                populacija[i]       = new Jedinka(x, minX, maxX);
                populacija[i].ocena = GenetskiAlgoritam.funkcija(x);
            }
            // odrediti ocenuP
            double minOcena = populacija[0].ocena;
            double maxOcena = populacija[0].ocena;

            for (int i = 0; i < brojVrsta; i++)
            {
                minOcena = Math.Min(minOcena, populacija[i].ocena);
                maxOcena = Math.Max(maxOcena, populacija[i].ocena);
            }
            // skaliranje minOcena = 0 maxOcena = 100
            double a      = 100 / (maxOcena - minOcena);
            double b      = -a * minOcena;
            double ukupno = 0;

            for (int i = 0; i < brojVrsta; i++)
            {
                double ocenaP = (float)(a * populacija[i].ocena + b);
                populacija[i].ocenaP = ocenaP / 100.0;
                ukupno += populacija[i].ocenaP;
            }
            // procentualno
            //for (int i = 0; i < brojVrsta; i++)
            //{
            //    double ocenaP = populacija[i].ocenaP / ukupno ;
            //    populacija[i].ocenaP = ocenaP;
            //}
        }
Example #11
0
 void mutacija(Jedinka jedinka, double prag)
 {
     //TODO 4: Implementirati operaciju mutacije
     for (int i = 0; i < Jedinka.MAXSTRING; i++)
     {
         double t = rand.NextDouble();
         if (t < prag)
         {
             if (jedinka.chromosome[i] == 0)
             {
                 jedinka.chromosome[i] = 1;
             }
             else
             {
                 jedinka.chromosome[i] = 0;
             }
         }
     }
     jedinka.x = jedinka.bin2double(jedinka.chromosome);
 }
Example #12
0
        void ukrstanje(Jedinka jedinka1, Jedinka jedinka2, double prag)
        {
            //za svaki gen se generise slucajan broj koji odlucuje da li ce se zameniti geni u dve jedinke
            for (int i = 0; i < Jedinka.MAXSTRING; ++i)
            {
                double slucajanBroj = rand.NextDouble();
                if (slucajanBroj < prag)
                {
                    int temp = jedinka1.chromosome[i];
                    jedinka1.chromosome[i] = jedinka2.chromosome[i];
                    jedinka2.chromosome[i] = temp;
                }
            }

            //Jedinka sadrzi i normalnu predstavu broja, mi smo menjali kodiranu predstavu, pa nju treba uskladiti
            jedinka1.x = jedinka1.bin2double(jedinka1.chromosome);
            jedinka2.x = jedinka2.bin2double(jedinka2.chromosome);

            //TODO 9: Ne zaboraviti promeniti double vrednost i druge promenljive
            jedinka1.x2 = jedinka1.bin2double2(jedinka1.chromosome);
            jedinka2.x2 = jedinka2.bin2double2(jedinka2.chromosome);
        }
Example #13
0
        private void btnKodiranje_Click(object sender, EventArgs e)
        {
            try
            {
                //TODO 1: Dopuniti metodu
                double x    = double.Parse(tbX.Text);
                double minX = double.Parse(tbMinX.Text);
                double maxX = double.Parse(tbMaxX.Text);

                jedinka = new Jedinka(x, minX, maxX);
                jedinkaPanel1.jedinka = jedinka;
                jedinkaPanel1.Refresh();
                double dekodiranoX = jedinka.bin2double(jedinka.chromosome);
                tbDekodiranoX.Text      = "" + dekodiranoX.ToString("#0.000");
                kodiranjePanel1.jedinka = jedinka;
                kodiranjePanel1.Refresh();
                statusBar.Text = "";
            }
            catch (Exception ex) {
                statusBar.Text = "Greška!";
            }
        }
Example #14
0
        void ukrstanje2(Jedinka jedinka1, Jedinka jedinka2)
        {
            //jedinka1 treba da bude N roditelj 1 - M roditelj 2 - N roditelj 1
            //jedinka2 treba da bude N roditelj 2 - M roditelj 1 - N roditelj 2

            int N = rand.Next(0, Jedinka.MAXSTRING / 2); //slucajno se generise N
            int M = Jedinka.MAXSTRING - 2 * N;

            //menja se centralnih M hromozoma
            for (int i = N; i < N + M; ++i)
            {
                int temp = jedinka1.chromosome[i];
                jedinka1.chromosome[i] = jedinka2.chromosome[i];
                jedinka2.chromosome[i] = temp;
            }

            //Jedinka sadrzi i normalnu predstavu broja, mi smo menjali kodiranu predstavu, pa nju treba uskladiti
            jedinka1.x = jedinka1.bin2double(jedinka1.chromosome);
            jedinka2.x = jedinka2.bin2double(jedinka2.chromosome);
            //TODO 10: Ne zaboraviti promeniti double vrednost i druge promenljive
            jedinka1.x2 = jedinka1.bin2double2(jedinka1.chromosome);
            jedinka2.x2 = jedinka2.bin2double2(jedinka2.chromosome);
        }
Example #15
0
 void ukrstanje(Jedinka jedinka1, Jedinka jedinka2, double prag)
 {
     //TODO 3: Implementirati operaciju ukrstanja
 }
Example #16
0
        public double algoritam()
        {
            // prva generacija
            generacija      = new Jedinka[broj_jedinki];
            nova_generacija = new Jedinka[broj_jedinki];
            for (int i = 0; i < broj_jedinki; i++)
            {
                double xx  = rand.NextDouble() * (MAX_X - MIN_X) + MIN_X;
                double xx2 = rand.NextDouble() * (MAX_X2 - MIN_X2) + MIN_X2;
                generacija[i] = new Jedinka(xx, MIN_X, MAX_X, xx2, MIN_X2, MAX_X2); //TODO 12: Lepo pozvati novu metodu
            }
            //nove generacije
            for (int j = 0; j < broj_iteracija; j++)
            {   //TODO 16: Promeniti i pozive funkcije
                max_ocena       = funkcija(generacija[0].x, generacija[0].x2);
                index_najboljeg = 0;
                for (int i = 0; i < broj_jedinki; i++)
                {
                    generacija[i].ocena = funkcija(generacija[i].x, generacija[i].x2);
                    if (max_ocena < generacija[i].ocena)
                    {
                        max_ocena       = generacija[i].ocena;
                        index_najboljeg = i;
                    }
                }
                // odrediti ocenuP
                double minOcena = generacija[0].ocena;
                double maxOcena = generacija[0].ocena;
                for (int i = 0; i < broj_jedinki; i++)
                {
                    minOcena = Math.Min(minOcena, generacija[i].ocena);
                    maxOcena = Math.Max(maxOcena, generacija[i].ocena);
                }
                // skaliranje minOcena = 0 maxOcena = 100
                double a      = 100 / (maxOcena - minOcena);
                double b      = -a * minOcena;
                double ukupno = 0;
                for (int i = 0; i < broj_jedinki; i++)
                {
                    double ocenaP = (float)(a * generacija[i].ocena + b);
                    generacija[i].ocenaP = ocenaP / 100.0;
                    ukupno += generacija[i].ocenaP;
                }
                suma_ocena = ukupno;
                resenjeX   = generacija[index_najboljeg].x;
                resenjeX2  = generacija[index_najboljeg].x2; //TODO 13: Sacuvati i x2
                int start = 0;

                if (elitizam == 1)
                {
                    nova_generacija[0] = new Jedinka(generacija[index_najboljeg]);
                    nova_generacija[1] = new Jedinka(generacija[index_najboljeg]);
                    start = 1;
                }
                for (int i = start; i < broj_jedinki / 2; i++)           // sa elitizmom
                {
                    int roditelj1 = selekcija(generacija);
                    int roditelj2 = selekcija(generacija);

                    Jedinka A = new Jedinka(generacija[roditelj1]);
                    Jedinka B = new Jedinka(generacija[roditelj2]);
                    ukrstanje(A, B, prag_ukrstanja);
                    mutacija(A, prag_mutacije);
                    mutacija(B, prag_mutacije);
                    nova_generacija[i * 2]     = A;
                    nova_generacija[i * 2 + 1] = B;
                }
                for (int i = 0; i < broj_jedinki; i++)
                {
                    generacija[i] = nova_generacija[i];
                }
            }
            return(resenjeX);
        }
Example #17
0
        protected override void OnPaint(PaintEventArgs e)
        {
            int brojKolona = Jedinka.MAXSTRING;
            int brojVrsta  = populacija.Length;

            base.OnPaint(e);

            Graphics gr = e.Graphics;

            Rectangle rec = this.ClientRectangle;

            // nacrtaj grid
            int width            = rec.Width;
            int height           = rec.Height;
            int ukupanBrojKolona = 2 + // redni broj
                                   brojKolona +
                                   3 + // za x
                                   3 + // za f(x)
                                   4;  // za selekciju

            int dx = (int)(width / ukupanBrojKolona);
            int dy = (int)(height / brojVrsta);

            Rectangle rPanel = new Rectangle(0, 0, dx * ukupanBrojKolona, dy * brojVrsta);

            gr.FillRectangle(Brushes.White, rPanel);

            for (int j = 0; j < brojKolona; j++)
            {
                Color c  = Color.FromArgb(40, Color.Gray);
                int   xx = dx * (j + 2);
                // pomeri sve za dve kolone
                int y0 = 0;
                int yH = dy * brojVrsta;
                gr.DrawLine(new Pen(c), xx, y0, xx, yH);
            }
            for (int i = 0; i < brojVrsta + 1; i++)
            {
                Color c  = Color.FromArgb(100, Color.Blue);
                int   yy = dy * i;
                int   x0 = 0;
                int   xH = dx * ukupanBrojKolona;
                gr.DrawLine(new Pen(c), x0, yy, xH, yy);
                if (i == mark1 || i == mark2)
                {
                    gr.DrawLine(Pens.Red, x0, yy, xH, yy);
                }
                if (i - 1 == mark1 || i - 1 == mark2)
                {
                    gr.DrawLine(Pens.Red, x0, yy, xH, yy);
                }
            }

            for (int i = 0; i < brojVrsta; i++)
            {
                Jedinka jedinka = populacija[i];
                // ispisi redni broj
                int xx = (int)(dx / 2) + dx * 0;
                int yy = (int)(dy / 2) + dy * i;

                Font  f  = new Font(FontFamily.GenericSerif, 8);
                SizeF sf = gr.MeasureString("" + i, f);
                Brush br = Brushes.Blue;
                if (i == mark1)
                {
                    br = Brushes.Red;
                }
                else if (i == mark2)
                {
                    br = Brushes.Yellow;
                }
                gr.DrawString("" + i, f, br, xx - sf.Width / 2, yy - sf.Height / 2);


                for (int j = 0; j < brojKolona; j++)
                {
                    Rectangle r   = new Rectangle(dx * (j + 2) + 2, dy * i + 2, dx - 4, dy - 4);
                    Color     cc1 = Color.FromArgb(40, Color.White);
                    int       tt  = jedinka.chromosome[j];
                    if (tt == 1)
                    {
                        cc1 = Color.FromArgb(100, Color.Black);
                    }
                    gr.FillRectangle(new SolidBrush(cc1), r);

                    xx = (int)(dx / 2) + dx * (j + 2);
                    yy = (int)(dy / 2) + dy * i;

                    sf = gr.MeasureString("" + tt, f);
                    if (i == mark1 || i == mark2)
                    {
                        gr.DrawString("" + tt, f, Brushes.Red, xx - sf.Width / 2, yy - sf.Height / 2);
                    }
                    else
                    {
                        gr.DrawString("" + tt, f, Brushes.Black, xx - sf.Width / 2, yy - sf.Height / 2);
                    }
                }

                // ispisi x
                xx = (int)(dx / 2) + dx * (2 + brojKolona + 1);// + 1 je da bude u sredini grupe od 3 celije
                yy = (int)(dy / 2) + dy * i;

                f = new Font(FontFamily.GenericSerif, 8);
                String xS = "" + jedinka.x.ToString("#0.00");
                sf = gr.MeasureString(xS, f);
                gr.DrawString(xS, f, Brushes.Red, xx - sf.Width / 2, yy - sf.Height / 2);

                // ispisi ocenu
                xx = (int)(dx / 2) + dx * (2 + brojKolona + 3);// + 3 je da bude u sredini grupe od 3 celije
                yy = (int)(dy / 2) + dy * i;

                f = new Font(FontFamily.GenericSerif, 8);
                String yS = "" + jedinka.ocena.ToString("#0.00");
                sf = gr.MeasureString(yS, f);
                gr.DrawString(yS, f, Brushes.Red, xx - sf.Width / 2, yy - sf.Height / 2);

                // nacrtaj ocenuP
                xx = dx * (2 + brojKolona + 5);
                yy = dy * i + 4;

                int sirinaOcene = (int)((dx * 5.0 - 5) * populacija[i].ocenaP);

                Rectangle ocenaPR = new Rectangle(xx, yy, sirinaOcene, dy - 8);
                gr.FillRectangle(Brushes.Yellow, ocenaPR);
            }
        }
Example #18
0
 void mutacija(Jedinka jedinka, double prag)
 {
     //TODO 4: Implementirati operaciju mutacije
     jedinka.x = jedinka.bin2double(jedinka.chromosome);
 }
Example #19
0
 public JedinkaPanel()
 {
     InitializeComponent();
     jedinka = new Jedinka(5, 0, 100);
 }
Example #20
0
 private void kodiranjePanel1_JedinkaPromenjena(Jedinka jedinka, double xNovo)
 {
     tbX.Text = "" + xNovo.ToString("#0.00");
     btnKodiranje_Click(null, null);
 }
Example #21
0
 public KodiranjePanel()
 {
     InitializeComponent();
     jedinka = new Jedinka(35, 0, 100);
 }