ga_vyp

java

package GenetickyAlgoritmus;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Polygon;
import java.util.Random;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.swing.JPanel;

public class Vypocet extends JPanel
{

    public int a;
    public int b;
    public int parA;
    public int parB;
    public int pom;
    public int dlzkaChrom;
    public int dlzkaPola;
    public int cisloPopulacie;
    public int pravidlo1;
    public int pravidlo2;

    static int[] poleVykresli;

    public String krizenyJedinec1;
    public String krizenyJedinec2;
    public String mutovanyJedinec1;
    public String mutovanyJedinec2;
    public String inverznyJedinec1;
    public String inverznyJedinec2;
    public String funkcia;
    public String intervalA = Okno.interval1;
    public String intervalB = Okno.interval2;
    public String pozPres = Okno.pozPres1;
    public String pocJedPop = Okno.pocJedPop1;
    public String ukonPod = Okno.ukonPod1;
    public String globOpt = Okno.globOpt1;
    public String typKod = Okno.typKod1;
    public String elitizmusJed = Okno.elitizmus1;
    public String krizenieJed = Okno.krizenie1;
    public String mutaciaJed = Okno.mutacia1;
    public String inverziaJed = Okno.inverzia1;

    static String[] poleJedincovPom1;
    static String[] poleJedincov;
    static String[][] populacia;

    Random random = new Random();
    Prevod prevod = new Prevod();
    Ruleta ruleta = new Ruleta();
    Krizenie krizenie = new Krizenie();
    Mutacia mutacia = new Mutacia();
    Inverzia inverzia = new Inverzia();
    FunkciaFitness funkciaFitness = new FunkciaFitness();

    static ScriptEngineManager mgr = new ScriptEngineManager();
    static ScriptEngine engine = mgr.getEngineByName("JavaScript");

    public Vypocet()
    {
    }

    /*4. Náhodne vygeneruje p jednicov v binarnom zápise, napr. ako pole typu pxk. 
     Uloží ich do populácie P0.*/
    public String jedinec()
    {
        String jedinec = "";
        dlzkaChrom = prevod.dlzkaChromozonu((Integer.valueOf(intervalA)), (Integer.valueOf(intervalB)));

        for (int j = 0; j < dlzkaChrom; j++)
        {
            boolean chromozon = Math.random() < 0.5;
            if (chromozon == true)
            {
                jedinec = jedinec + "1";
            } else
            {
                jedinec = jedinec + "0";
            }
        }

        return jedinec;
    }

    public String[] prvaPopulacia()
    {
        poleJedincov = new String[Integer.parseInt(pocJedPop)];
        populacia = new String[Integer.parseInt(ukonPod)][Integer.parseInt(pocJedPop)];
        poleJedincovPom1 = new String[Integer.parseInt(pocJedPop)];

        System.out.print("1. Populácia: \t");
        for (int i = 0; i < poleJedincov.length; i++)
        {
            poleJedincov[i] = jedinec();
            //ulozeniePopulacie(0, i, poleJedincov[i]);
            System.out.print(poleJedincov[i] + ", ");
        }
        System.out.println("\n");

        return poleJedincov;
    }

    /*18. Ak nie je splnená ukončovacia podmienka, vráti sa na bod 5. Ak je splnená 
     ukončovacia podmienka, ako výsledok vypíše reálnu hodnotu jedinca s najväčšou hodnotu
     účelovej funkcie, ak hľadal globálne maximum, resp. s najmenšou hodnotou účelovej 
     funkcie, ak hľadal globálne minimum.*/
    public void Populacie(String[] pole)
    {
        cisloPopulacie = 2;
        poleVykresli = new int[Integer.valueOf(pocJedPop)];

        double[] polePrevod = new double[Integer.valueOf(pocJedPop)];
        double[] poleUcelFun = new double[Integer.valueOf(pocJedPop)];
        double[] poleFitness = new double[Integer.valueOf(pocJedPop)];

        for (int m = 0; m < Integer.valueOf(ukonPod); m++)
        {
            System.arraycopy(poleJedincov, 0, poleJedincovPom1, 0, poleJedincov.length);

            /*3. Nastaví hodnotu i = 0*/
            for (int i = 0; i < Integer.valueOf(pocJedPop); i++)
            {
                System.out.print(i + 1 + ". jedinec: \t");
                switch (typKod)
                {
                    /*5. Postupne prepočíta hodnotu každého jedinca z populácie Pi na reálne číslo. 
                     V závislosti od toho, aký typ kódovania používateľ zvolil, prepočet prebieha 
                     podľa jednej zo schém - a. BCD do Real.*/
                    case "BCD kód":
                        polePrevod[i] = prevod.BCDDoReal(Integer.valueOf(intervalA), Integer.valueOf(intervalB), poleJedincov[i]);

                        System.out.println("\t" + poleJedincov[i]);
                        System.out.println("\tBCD do Int: \t" + prevod.BCDDoInt(poleJedincov[i]));
                        System.out.println("\tBCD do Real: \t" + polePrevod[i]);
                        System.out.println("\tReal do BCD: \t" + prevod.RealDoBCD(Integer.valueOf(intervalA), Integer.valueOf(intervalB), polePrevod[i]));
                        break;

                    /*5. Postupne prepočíta hodnotu každého jedinca z populácie Pi na reálne číslo. 
                     V závislosti od toho, aký typ kódovania používateľ zvolil, prepočet prebieha 
                     podľa jednej zo schém - b. Gray do Real.*/
                    case "Grayov kód":
                        polePrevod[i] = prevod.GrayDoReal(Integer.valueOf(intervalA), Integer.valueOf(intervalB), poleJedincov[i]);

                        System.out.println("\t" + poleJedincov[i]);
                        //System.out.println("\tGray do BCD: \t" + prevod.GrayDoBCD(poleJedincov[i]));
                        System.out.println("\tGray do Int: \t" + prevod.GrayDoInt(poleJedincov[i]));
                        System.out.println("\tGray do Real: \t" + polePrevod[i]);
                        System.out.println("\tReal do Grey: \t" + prevod.RealDoGray(Integer.valueOf(intervalA), Integer.valueOf(intervalB), polePrevod[i]));
                        break;
                }

                /*6. Vypočíta hodnotu účelovej funkcie f každého jedinca dosadením jeho reálne hodnoty, 
                 t.j. x do zadanej hodnoty.*/
                poleUcelFun[i] = funkcia(polePrevod[i]);
                System.out.println("\tUčelová funk.:\t" + poleUcelFun[i]);

                poleVykresli[i] = (int) (polePrevod[i] * 100);
                System.out.println("\tVykreslenie: \t" + poleVykresli[i] + " na osi x");
                System.out.println();

            }
            /*9. Vypočitá fitnesss funkciu F pre kaďzého jedinca.*/
            switch (globOpt)
            {
                case "Maximum":
                    funkciaFitness.FitnessMax(poleUcelFun, poleFitness);
                    break;

                case "Minimum":
                    funkciaFitness.FitnessMin(poleUcelFun, poleFitness);
                    break;
            }

            System.out.println("Fitness funkcia: ---------------------------------------------------");
            for (int k = 0; k < poleFitness.length; k++)
            {
                System.out.println(k + 1 + ". jedinec - FF:\t" + poleJedincov[k] + " - " + poleFitness[k]);
            }
            System.out.println();

            /*11. Ak používateľ zvolí použitie elitizmu, program vyberie určený pocet
             najlepšich jedincov a prepíše hodnoty ich reťazcov do noveh generácie
             Pi+1 bez akýchkoľvek zmien. Zároveň ich ponechá aj v pôvodnej populácii Pi. 
             Počet takto vybraných jedincov uloží do hodnoty e. Ak nie je zvolený 
             žiadny jedinec položí e = 0 a prechádza na bod 12.*/
            switch (elitizmusJed)
            {
                case "Nepoužiť":
                    dlzkaPola = 0;

                    System.out.println("Elitizmus: Nepoužitý -----------------------------------------------");

                    break;

                case "1 - jedin.":
                    double prvyMax = 0;
                    int prvyMaxI = 0;

                    for (int k = 0; k < poleFitness.length; k++)
                    {
                        if (prvyMax < poleFitness[k])
                        {
                            prvyMax = poleFitness[k];
                            prvyMaxI = k;
                        }
                    }

                    int pocet1 = prvyMaxI + 1;

                    System.out.println("Elitizmus: 1 - jedinca ---------------------------------------------");
                    System.out.println("1. jedinec max FF:\t" + prvyMax + " - Index: " + pocet1);

                    poleJedincov[0] = poleJedincov[prvyMaxI];
                    dlzkaPola = 1;

                    break;

                case "2 - jedin.":
                    prvyMax = 0;
                    prvyMaxI = 0;
                    double druhyMax = 0;
                    int druhyMaxI = 0;

                    for (int k = 0; k < poleFitness.length; k++)
                    {
                        if (prvyMax < poleFitness[k])
                        {
                            prvyMax = poleFitness[k];
                            prvyMaxI = k;
                        }
                    }

                    for (int j = 0; j < poleFitness.length; j++)
                    {
                        if (j != prvyMaxI)
                        {
                            if (druhyMax < poleFitness[j])
                            {
                                druhyMax = poleFitness[j];
                                druhyMaxI = j;
                            }
                        }
                    }

                    int pocet2 = prvyMaxI + 1;
                    int pocet3 = druhyMaxI + 1;

                    System.out.println("Elitizmus: 2 - jedincov --------------------------------------------");
                    System.out.println("1. jedinec max FF:\t" + prvyMax + " - Index: " + pocet2);
                    System.out.println("2. jedinec max FF:\t" + druhyMax + " - Index: " + pocet3);

                    poleJedincov[0] = poleJedincovPom1[prvyMaxI];
                    poleJedincov[1] = poleJedincovPom1[druhyMaxI];
                    dlzkaPola = 2;

                    break;

                case "3 - jedin.":
                    prvyMax = 0;
                    prvyMaxI = 0;
                    druhyMax = 0;
                    druhyMaxI = 0;
                    double tretiMax = 0;
                    int tretiMaxI = 0;

                    for (int k = 0; k < poleFitness.length; k++)
                    {
                        if (prvyMax < poleFitness[k])
                        {
                            prvyMax = poleFitness[k];
                            prvyMaxI = k;
                        }
                    }

                    for (int j = 0; j < poleFitness.length; j++)
                    {
                        if (j != prvyMaxI)
                        {
                            if (druhyMax < poleFitness[j])
                            {
                                druhyMax = poleFitness[j];
                                druhyMaxI = j;
                            }
                        }
                    }

                    for (int l = 0; l < poleFitness.length; l++)
                    {
                        if (l != prvyMaxI)
                        {
                            if (l != druhyMaxI)
                            {
                                if (tretiMax < poleFitness[l])
                                {
                                    tretiMax = poleFitness[l];
                                    tretiMaxI = l;
                                }
                            }
                        }
                    }

                    int pocet4 = prvyMaxI + 1;
                    int pocet5 = druhyMaxI + 1;
                    int pocet6 = tretiMaxI + 1;

                    System.out.println("Elitizmus: 3 - jedincov --------------------------------------------");
                    System.out.println("1. jedinec max FF:\t" + prvyMax + " - Index: " + pocet4);
                    System.out.println("2. jedinec max FF:\t" + druhyMax + " - Index: " + pocet5);
                    System.out.println("3. jedinec max FF:\t" + tretiMax + " - Index: " + pocet6);

                    poleJedincov[0] = poleJedincovPom1[prvyMaxI];
                    poleJedincov[1] = poleJedincovPom1[druhyMaxI];
                    poleJedincov[2] = poleJedincovPom1[tretiMaxI];
                    dlzkaPola = 3;

                    break;
            }
            System.out.println();

            int dlzkaPolaPom = dlzkaPola;

            /*17. Ak nová populácia Pi+1 neobsahuje p jedincov, vráti sa na bod 12. Inak zvýši 
             hodnotu i o 1 a prechádza na pod 18*/
            for (int i = 0; i < (Integer.valueOf(pocJedPop) - dlzkaPolaPom) / 2; i++)
            {
                pravidlo1 = ruleta.ruleta(poleFitness);
                int pocet7 = pravidlo1 + 1;

                System.out.println("Index:\t\t\t" + pocet7);
                System.out.println();

                pravidlo2 = ruleta.ruleta(poleFitness);
                int pocet8 = pravidlo2 + 1;

                System.out.println("Index:\t\t\t" + pocet8);
                System.out.println();

                /*13. Ak je zvolenée kríženie, uplatní na dvojicu chromozómov v binárnom kóde operátor kríženia*/
                switch (krizenieJed)
                {
                    case "Nepoužiť":
                        System.out.println("Kríženie: Nepoužité ------------------------------------------------");

                        krizenyJedinec1 = poleJedincovPom1[pravidlo1];
                        krizenyJedinec2 = poleJedincovPom1[pravidlo2];

                        break;

                    case "Uniformné":
                        System.out.println("Kríženie: Uniformné ------------------------------------------------");

                        krizenyJedinec1 = poleJedincovPom1[pravidlo1];
                        krizenyJedinec2 = poleJedincovPom1[pravidlo2];

                        System.out.println("1. Jedinec - KR:\t" + krizenyJedinec1);
                        System.out.println("2. Jedinec - KR:\t" + krizenyJedinec2);

                        String krizeneJedince = krizenie.uniform(krizenyJedinec1, krizenyJedinec2);

                        krizenyJedinec1 = krizeneJedince.substring(0, dlzkaChrom);
                        krizenyJedinec2 = krizeneJedince.substring(dlzkaChrom);

                        System.out.println("1. Jedinec - PKR:\t" + krizenyJedinec1);
                        System.out.println("2. Jedinec - PKR:\t" + krizenyJedinec2);

                        break;

                    case "1 - bodové":
                        System.out.println("Kríženie: 1 - bodové -----------------------------------------------");

                        krizenyJedinec1 = poleJedincovPom1[pravidlo1];
                        krizenyJedinec2 = poleJedincovPom1[pravidlo2];

                        System.out.println("1. Jedinec - KR:\t" + krizenyJedinec1);
                        System.out.println("2. Jedinec - KR:\t" + krizenyJedinec2);

                        krizeneJedince = krizenie.jedbod(krizenyJedinec1, krizenyJedinec2);

                        krizenyJedinec1 = krizeneJedince.substring(0, dlzkaChrom);
                        krizenyJedinec2 = krizeneJedince.substring(dlzkaChrom);

                        System.out.println("1. Jedinec - PKR:\t" + krizenyJedinec1);
                        System.out.println("2. Jedinec - PKR:\t" + krizenyJedinec2);

                        break;

                    case "2 - bodové":
                        System.out.println("Kríženie: 2 - bodové -----------------------------------------------");

                        krizenyJedinec1 = poleJedincovPom1[pravidlo1];
                        krizenyJedinec2 = poleJedincovPom1[pravidlo2];

                        System.out.println("1. Jedinec - KR:\t" + krizenyJedinec1);
                        System.out.println("2. Jedinec - KR:\t" + krizenyJedinec2);

                        krizeneJedince = krizenie.dvojbod(krizenyJedinec1, krizenyJedinec2);

                        krizenyJedinec1 = krizeneJedince.substring(0, dlzkaChrom);
                        krizenyJedinec2 = krizeneJedince.substring(dlzkaChrom);

                        System.out.println("1. Jedinec - PKR:\t" + krizenyJedinec1);
                        System.out.println("2. Jedinec - PKR:\t" + krizenyJedinec2);

                        break;
                }
                System.out.println();

                /*14. Ak je zvolená mutácia, uplatní na každý z dvojice chromozónov v binárnom kóde operátor mutácie*/
                switch (mutaciaJed)
                {
                    case "Nepoužiť":
                        System.out.println("Mutácia: Nepoužitá -------------------------------------------------");

                        mutovanyJedinec1 = krizenyJedinec1;
                        mutovanyJedinec2 = krizenyJedinec2;

                        break;

                    case "Použiť":
                        System.out.println("Mutácia: Použitá ---------------------------------------------------");

                        mutovanyJedinec1 = krizenyJedinec1;
                        mutovanyJedinec2 = krizenyJedinec2;

                        System.out.println("1. Jedinec - MUT:\t" + mutovanyJedinec1);
                        System.out.println("2. Jedinec - MUT:\t" + mutovanyJedinec2);

                        System.out.println("\nMutovanie 1. jedinca:");
                        mutovanyJedinec1 = mutacia.mutacia(mutovanyJedinec1);

                        System.out.println("\nMutovanie 2. jedinca:");
                        mutovanyJedinec2 = mutacia.mutacia(mutovanyJedinec2);

                        System.out.println("\n1. Jedinec - PMUT:\t" + mutovanyJedinec1);
                        System.out.println("2. Jedinec - PMUT:\t" + mutovanyJedinec2);

                        break;

                }
                System.out.println();

                /*15. Ak je zvolená inverzia, uplatní na každý z dvojice chromozómoc v binárnom kóde operátor inverzie*/
                switch (inverziaJed)
                {
                    case "Nepoužiť":
                        System.out.println("Inverzia: Nepoužitá ------------------------------------------------");

                        inverznyJedinec1 = mutovanyJedinec1;
                        inverznyJedinec2 = mutovanyJedinec2;

                        break;

                    case "Použiť":
                        System.out.println("Inverzia: Použitá --------------------------------------------------");

                        inverznyJedinec1 = mutovanyJedinec1;
                        inverznyJedinec2 = mutovanyJedinec2;

                        System.out.println("1. Jedinec - INV:\t" + inverznyJedinec1);
                        System.out.println("2. Jedinec - INV:\t" + inverznyJedinec2);

                        System.out.println("\nInverzia 1. jedinca:");
                        inverznyJedinec1 = inverzia.iverzia(inverznyJedinec1);

                        System.out.println("\nInverzia 2. jedinca:");
                        inverznyJedinec2 = inverzia.iverzia(inverznyJedinec2);

                        System.out.println("\n1. Jedinec - PINV:\t" + inverznyJedinec1);
                        System.out.println("2. Jedinec - PINV:\t" + inverznyJedinec2);

                        break;
                }
                System.out.println();
                
                /*16. Takto získané jedince uloží v binárnom kóde do novej populácie Pi+1.*/
                poleJedincov[dlzkaPola] = inverznyJedinec1;
                dlzkaPola = dlzkaPola + 1;

                poleJedincov[dlzkaPola] = inverznyJedinec2;
                dlzkaPola = dlzkaPola + 1;
            }

            System.arraycopy(poleJedincov, 0, poleJedincovPom1, 0, poleJedincov.length);

            System.out.println("--------------------------------------------------------------------\n"
                    + "--------------------------------------------------------------------");

            ////////////////////
            ////VYKRESLENIE/////
            ////////////////////
			
            if (cisloPopulacie <= Integer.valueOf(ukonPod))
            {
                System.out.print(cisloPopulacie + ". Populácia: \t");
                for (int i = 0; i < (poleJedincov.length); i++)
                {
                    System.out.print(poleJedincov[i] + ", ");
                }
                cisloPopulacie++;
                System.out.println();
            }

            System.out.println();
        }
    }

    /*6. Vypočíta hodnotu účelovej funkcie f každého jedinca dosadením jeho reálne hodnoty, 
     t.j. x do zadanej hodnoty.*/
    public double funkcia(double vstup)
    {
        double vystup = 0;
        try
        {
            funkcia = Okno.funkcia1;

            if (funkcia != null)
            {
                String pom = String.valueOf(vstup);
                funkcia = funkcia.replaceAll("x", pom);
                try
                {
                    vystup = (double) engine.eval(funkcia);
                } catch (ScriptException e)
                {
                }
            }

        } catch (Exception e)
        {
        }

        return vystup;
    }

    @Override
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
		
        g.setColor(Color.darkGray);
        g.drawLine(0, 275, 1000, 275);
        g.drawLine(500, 0, 500, 600);

        Polygon polygon = new Polygon();
        int q = 0;

        try
        {
            if (pocJedPop.equals(""))
            {
                q = 1;
            } else
            {
                q = Integer.valueOf(pocJedPop);
            }

            a = (int) (Double.valueOf(intervalA) * 100);
            b = (int) (Double.valueOf(intervalB) * 100);

        } catch (Exception e)
        {
        }

        for (int i = a / 5; i <= b / 5; i++)
        {
            polygon.addPoint(i + 500, 275 - (int) (50 * funkcia((i / 20.0))));
        }

        for (int i = 0; i < q; i++)
        {
            g.setColor(Color.yellow);
            int x = poleVykresli[i] / 5;
            System.out.print(poleVykresli[i] + ", ");
            g.drawLine(x + 500, 275 - (int) (50 * funkcia((x / 20.0))), x + 500, 275);
        }
        
        g.setColor(Color.red);
        g.drawPolyline(polygon.xpoints, polygon.ypoints, polygon.npoints);
    }
}

Neformátovaný

Přidáno: 31.12.2016
Expirace: Neuvedeno

Autor: Pavol Franek