SHARE
TWEET

Untitled

a guest May 20th, 2019 59 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. import java.util.ArrayList;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. import java.util.Random;
  6.  
  7. public class Funkcije {
  8.  
  9.     // Funkcija racuna dobrotu jedinke (int jedinka) prema funkciji prikaznoj u tekstu zadatka
  10.     // Dozvoljene ulazne vrijednosti su u otvorenom intervalu [0, 1023]
  11.     // Funkcija vraca -1 ako je zadana nedozvoljena vrijednost
  12.     public static double dobrota(int jedinka) {
  13.  
  14.         if (jedinka < 0 || jedinka >= 1024) {
  15.             return -1;
  16.         }
  17.  
  18.         if (jedinka >= 0 && jedinka < 30) {
  19.             return 60.0;
  20.         }
  21.         else if (jedinka >= 30 && jedinka < 90) {
  22.             return (double)jedinka + 30.0;
  23.         }
  24.         else if (jedinka >= 90 && jedinka < 120) {
  25.             return 120.0;
  26.         }
  27.         else if (jedinka >= 120 && jedinka < 210) {
  28.             return -0.83333 * (double)jedinka + 220;
  29.         }
  30.         else if (jedinka >= 210 && jedinka < 270) {
  31.             return 1.75 * (double)jedinka - 322.5;
  32.         }
  33.         else if (jedinka >= 270 && jedinka < 300) {
  34.             return 150.0;
  35.         }
  36.         else if (jedinka >= 300 && jedinka < 360) {
  37.             return 2.0 * (double)jedinka - 450;
  38.         }
  39.         else if (jedinka >= 360 && jedinka < 510) {
  40.             return -1.8 * (double)jedinka + 918;
  41.         }
  42.         else if (jedinka >= 510 && jedinka < 630) {
  43.             return 1.5 * (double)jedinka - 765;
  44.         }
  45.         else if (jedinka >= 630 && jedinka < 720) {
  46.             return -1.33333 * (double)jedinka + 1020;
  47.         }
  48.         else if (jedinka >= 720 && jedinka < 750) {
  49.             return 60.0;
  50.         }
  51.         else if (jedinka >= 750 && jedinka < 870) {
  52.             return 1.5 * (double)jedinka - 1065;
  53.         }
  54.         else if (jedinka >= 870 && jedinka < 960) {
  55.             return -2.66667 * (double)jedinka + 2560;
  56.         }
  57.         else {
  58.             return 0;
  59.         }
  60.     }
  61.  
  62.     // funkcija stvara populaciju od 20 jedinki nasumično generiranih brojeva u intervalu [0, 1023]
  63.     public static List<Integer> stvoriPopulaciju(int vel_pop) {
  64.         List<Integer> populacija = new ArrayList<>();
  65.  
  66.         for (int i = 0; i < vel_pop; i++) {
  67.             populacija.add(new Random().nextInt(1023));
  68.         }
  69.  
  70.         return populacija;
  71.     }
  72.  
  73.     // jednostavka selekcija - odabir roditelja čija je vjerojatnost selekcije proporcionalna njihovoj dobroti
  74.     // funkcija racuna dobrotu svake jedinke i odbacuje iz populacije one jednike kod kojih je omjer
  75.     // dobrota jedinke / dobrota cijele populacije najmanji
  76.     // funkcija vraća 10 najboljih jedinki nove populacije
  77.     public static List<Integer> jednostavnaSelekcija(List<Integer> populacija) {
  78.  
  79.         populacija.sort((j1,j2)->Double.compare(dobrota(j1),dobrota(j2)));
  80.         int polaPopulacije=populacija.size()/2;
  81.  
  82.         for(int i=0;i<polaPopulacije;i++){
  83.             populacija.remove(0);
  84.         }
  85.  
  86.         return populacija;
  87.     }
  88.  
  89.     // funkcija vraća slučajna dva roditelja iz populacije
  90.     public static List<Integer> vratiDvaSlucajnaRoditelja(List<Integer> populacija) {
  91.         List<Integer> dvaSlucajnaRoditelja = new ArrayList<>();
  92.         int index1 = 0, index2 = 0;
  93.  
  94.         do {
  95.             index1 = new Random().nextInt(populacija.size());
  96.             index2 = new Random().nextInt(populacija.size());
  97.         } while (index1 == index2);
  98.  
  99.         dvaSlucajnaRoditelja.add(populacija.get(index1));
  100.         dvaSlucajnaRoditelja.add(populacija.get(index2));
  101.  
  102.         return dvaSlucajnaRoditelja;
  103.     }
  104.  
  105.     // funkcija pretvara Integer u binarni broj i svaku znamenku stavlja u Integer polje
  106.     public static Integer[] pretvoriIntegerUbinarniBroj(Integer broj) {
  107.         List<Integer> pomocnaLista = new ArrayList<>();
  108.         List<Integer> binarnaLista = new ArrayList<>();
  109.  
  110.         int bit = 0, brojDodatnihNula = 0;
  111.  
  112.         while (broj > 0) {
  113.             bit = broj % 2;
  114.             pomocnaLista.add(bit);
  115.             broj /= 2;
  116.         }
  117.  
  118.         brojDodatnihNula = 10 - pomocnaLista.size();
  119.         if (brojDodatnihNula != 0) {
  120.             for (int i = 0; i < brojDodatnihNula; i++) {
  121.                 pomocnaLista.add(0);
  122.             }
  123.         }
  124.  
  125.         for (int i = pomocnaLista.size() - 1; i >= 0; i--) {
  126.             binarnaLista.add(pomocnaLista.get(i));
  127.         }
  128.  
  129.         Integer[] binarniBroj = binarnaLista.toArray(new Integer[10]);
  130.  
  131.         return binarniBroj;
  132.     }
  133.  
  134.     // funkcija pretvara binarni broj u Integer
  135.     public static Integer pretvoriBinarniBrojUinteger(Integer[] broj) {
  136.         Integer intBroj = 0;
  137.  
  138.         for (int i = broj.length - 1, j = 0; i >= 0; i--, j++) {
  139.             intBroj = (int) (intBroj + broj[i]*Math.pow(2, j));
  140.         }
  141.  
  142.         return intBroj;
  143.     }
  144.  
  145.     // funkcija koja vraca true ako je vjerojatnost krizanja 90% ili true ako je vjerojatnost mutacije 1%
  146.     public static boolean izracunajVjerojatnost(Double vjerojatnost) {
  147.         Double broj = new Random().nextDouble();
  148.  
  149.         if (broj < vjerojatnost) {
  150.             return true;
  151.         }
  152.  
  153.         return false;
  154.     }
  155.  
  156.     // funkcija racuna maksimalnu dobrotu populacije
  157.     public static Double maksimalnaDobrotaPopulacije(List<Integer> populacija){
  158.         Double maxDobrota = dobrota(populacija.stream().max(Comparator.comparingDouble((jedinka)->dobrota(jedinka))).get());
  159.  
  160.         return maxDobrota;
  161.     }
  162.  
  163.     // funkcija racuna prosjecnu vrijednost dobrote populacije
  164.     public static Double prosjecnaVrijednostDobrotePopulacije(List<Integer> populacija){
  165.         Double prosjekDobrote = populacija.stream().mapToDouble((jedinka)->dobrota(jedinka)).average().orElse(0);
  166.  
  167.         return prosjekDobrote;
  168.     }
  169.  
  170.     // funkcija vraća najbolju jedinku populacije (elitizam)
  171.     public static Integer najboljaJedinkaPopulacije(List<Integer> populacija) {
  172.  
  173.         populacija.sort((j1, j2) -> Double.compare(dobrota(j1), dobrota(j2)));
  174.  
  175.         return populacija.get(populacija.size() - 1);
  176.     }
  177.  
  178.     // funkcija kriza random roditelje i stvara djecu te vraca novu populaciju
  179.     public static List<Integer> populacijaNakonKrizanjaImutacije(List<Integer> populacija, Double Pc, Double Pm) {
  180.         List<Integer> novaPopulacija = new ArrayList<>();
  181.         List<Integer> djeca = new ArrayList<>();
  182.         int brojacIsteDjece=0;
  183.         for (int k = 0; k < populacija.size(); k++) {
  184.             boolean imaDuplikata = false;
  185.  
  186.             List<Integer> roditelji = vratiDvaSlucajnaRoditelja(populacija);
  187.  
  188.             Integer intRoditelj1 = roditelji.get(0);
  189.             Integer intRoditelj2 = roditelji.get(1);
  190.  
  191.             Integer[] roditelj1 = pretvoriIntegerUbinarniBroj(intRoditelj1);
  192.             Integer[] roditelj2 = pretvoriIntegerUbinarniBroj(intRoditelj2);
  193.             Integer[] dijete = new Integer[10] ;
  194.             Integer intDijete = 0;
  195.  
  196.             for (int i = 0; i < dijete.length; i++) {
  197.                 dijete[i] = 0;
  198.             }
  199.  
  200.             if (izracunajVjerojatnost(Pc)) {
  201.                 for (int i = 0; i < roditelj1.length; i++) {
  202.                     if (roditelj1[i] == roditelj2[i]) {
  203.                         dijete[i] = roditelj1[i];
  204.                     }
  205.                     else {
  206.                         if (new Random().nextBoolean()) {
  207.                             dijete[i] = roditelj1[i];
  208.                         }
  209.                         else {
  210.                             dijete[i] = roditelj2[i];
  211.                         }
  212.                     }
  213.                 }
  214.             }
  215.  
  216.             roditelji.clear();
  217.             intDijete = pretvoriBinarniBrojUinteger(dijete);
  218.  
  219.             // provjeravam da li već postoji to dijete, ako da, ponavljam križanje, if je tu da bi se spriječila beskonačna petlja ako se uvijek dobivaju ista dijeca
  220.             if(brojacIsteDjece<=500) {
  221.                 for (int j = 0; j < djeca.size(); j++) {
  222.                     if (djeca.get(j).equals(intDijete)) {
  223.                         brojacIsteDjece++;
  224.                         imaDuplikata = true;
  225.                         k--;
  226.                         break;
  227.                     }
  228.                 }
  229.             }
  230.  
  231.             // ako dobiveno dijete ne postoji, dodajem ga u populaciju
  232.             if (imaDuplikata == false) {
  233.                 brojacIsteDjece=0;
  234.                 djeca.add(intDijete);
  235.             }
  236.         }
  237.  
  238.         novaPopulacija.addAll(djeca);
  239.         novaPopulacija.addAll(populacija);
  240.  
  241.         // sortiramo novu populaciju po vrijednosti dobrote, zadnja jedinka u novoj populaciji je najbolja
  242.         novaPopulacija.sort((j1, j2) -> Double.compare(dobrota(j1), dobrota(j2)));
  243.  
  244.         // napravi mutaciju nad svim jedinkama osim nad najboljom (zadnjom u populaciji) -> elitizam, čuvamo najbolju jedinku
  245.         for (int i = 0; i < novaPopulacija.size()-1; i++) {
  246.             Integer[] jedinka = pretvoriIntegerUbinarniBroj(novaPopulacija.get(i));
  247.             for (int j = 0; j < jedinka.length; j++) {
  248.                 if (izracunajVjerojatnost(Pm)) {
  249.                     if (jedinka[j] == 1) {
  250.                         jedinka[j] = 0;
  251.                     }
  252.                     else {
  253.                         jedinka[j] = 1;
  254.                     }
  255.                 }
  256.             }
  257.         }
  258.  
  259.         return novaPopulacija;
  260.     }
  261.  
  262. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top