lawang code

lawang Code


Tanyakan kode disini

tolong di konvert ke php dong gan

ditanyakan oleh Eno Rahmandha 3 tahun yang lalu

Source Code Java import java.util.ArrayList; import java.util.Random; import java.util.Collections;

public class ArtificialBeeColony {

/* parameter ABC */

public int MAX_LENGTH;      /* Jumlah parameter dari masalah yang akan dioptimalkan */
public int NP;              /* Jumlah ukuran total lebah / koloni. penonton + dipekerjakan */
public int FOOD_NUMBER;     /* Jumlah sumber makanan sama dengan setengah dari ukuran koloni */
public int LIMIT;           /* Sumber makanan yang tidak dapat ditingkatkan melalui "batas" percobaan */
public int MAX_EPOCH;       /* Jumlah siklus untuk mencari makan {kriteria berhenti} */
public int MIN_SHUFFLE;
public int MAX_SHUFFLE;

public Random rand;
public ArrayList<Honey> foodSources;
public ArrayList<Honey> solutions;
public Honey gBest;
public int epoch;

/* Instantiates algoritma Koloni lebah Buatan Bersama DENGAN parameter. */
public ArtificialBeeColony(int n) {
    MAX_LENGTH = n;
    NP = 40;                    // Ukuran pop 20 sampai 40 atau bahkan 100
    FOOD_NUMBER = NP/2;
    LIMIT = 50;
    MAX_EPOCH = 1000;
    MIN_SHUFFLE = 8;
    MAX_SHUFFLE = 20;
    gBest = null;
    epoch = 0;
}

/* Mulai algoritma optimasi segerombolan partikel pemecahan untuk n ratu. */
public boolean algorithm() {
    foodSources = new ArrayList<Honey>();
    solutions = new ArrayList<Honey>();
    rand = new Random();
    boolean done = false;
    epoch = 0;

    initialize();
    memorizeBestFoodSource();

    while(!done) {
        if(epoch < MAX_EPOCH) {
            if(gBest.getConflicts() == 0) {
                done = true;
            }
            sendEmployedBees();
            getFitness();
            calculateProbabilities();
            sendOnlookerBees();
            memorizeBestFoodSource();
            sendScoutBees();

            epoch++;
            // di sini hanya untuk menunjukkan status runtime.
            System.out.println("Epoch: " + epoch);
        } else {
            done = true;
        }

    }

    if(epoch == MAX_EPOCH) {
        System.out.println("Tidak ada solusi ditemukan");
        done = false;
    }

    System.out.println("Selesai.");
    System.out.println("Komplet " + epoch + " epochs.");

    for(Honey h: foodSources) {
        if(h.getConflicts() == 0) {
            System.out.println("SOLUTION");
            solutions.add(h);
            printSolution(h);
            System.out.println("conflicts:"+h.getConflicts());
        }
    }

    return done;
}

/* Mengirimkan lebah pekerja untuk mengoptimalkan solusi */
public void sendEmployedBees() {
    int neighborBeeIndex = 0;
    Honey currentBee = null;
    Honey neighborBee = null;

    for(int i = 0; i < FOOD_NUMBER; i++) {
        // Sebuah solusi yang dipilih secara acak digunakan 
        // dalam memproduksi solusi mutan dari solusi i 
        // neighbor = getRandomNumber (0, Food_Number-1);
        neighborBeeIndex = getExclusiveRandomNumber(FOOD_NUMBER-1, i);
        currentBee = foodSources.get(i);
        neighborBee = foodSources.get(neighborBeeIndex);
        sendToWork(currentBee, neighborBee);
    }
}

/* Mengirim lebah penonton untuk mengoptimalkan solusi. 
 * Lebah penonton bekerja pada solusi terbaik dari lebah yang digunakan. 
 * solusi terbaik memiliki probabilitas tinggi pilihan. */
public void sendOnlookerBees() {
    int i = 0;
    int t = 0;
    int neighborBeeIndex = 0;
    Honey currentBee = null;
    Honey neighborBee = null;

    while(t < FOOD_NUMBER) {
        currentBee = foodSources.get(i);
        if(rand.nextDouble() < currentBee.getSelectionProbability()) {
            t++;
            neighborBeeIndex = getExclusiveRandomNumber(FOOD_NUMBER-1, i);
            neighborBee = foodSources.get(neighborBeeIndex);
            sendToWork(currentBee, neighborBee);
        }
        i++;
        if(i == FOOD_NUMBER) {
            i = 0;
        }
    }
}

/* Optimalisasi bagian dari algoritma. meningkatkan lebah saat ini 
 * dengan memilih tetangga lebah acak. perubahan adalah nomor 
 * secara acak kali untuk mencoba dan meningkatkan solusi saat. */
public void sendToWork(Honey currentBee, Honey neighborBee) {
    int newValue = 0;
    int tempValue = 0;
    int tempIndex = 0;
    int prevConflicts = 0;
    int currConflicts = 0;
    int parameterToChange = 0;

    // dapatkan jumlah konflik
    prevConflicts = currentBee.getConflicts();

    // Parameter yang akan diubah ditentukan secara acak
    parameterToChange = getRandomNumber(0, MAX_LENGTH-1);

    /* v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) 
     * solution[param2change]=Foods[i][param2change]+(Foods[i]
     * [param2change]-Foods[neighbour][param2change])*(r-0.5)*2;
    */
    tempValue = currentBee.getNectar(parameterToChange);
    newValue = (int)(tempValue+(tempValue - neighborBee.getNectar(parameterToChange))*(rand.nextDouble()-0.5)*2);

    // perangkap nilai dalam batas terikat dan batas bawah atas
    if(newValue < 0) {
        newValue = 0;
    }
    if(newValue > MAX_LENGTH-1) {
        newValue = MAX_LENGTH-1;
    }

    // mendapatkan indeks dari nilai baru
    tempIndex = currentBee.getIndex(newValue);

    // swap
    currentBee.setNectar(parameterToChange, newValue);
    currentBee.setNectar(tempIndex, tempValue);
    currentBee.computeConflicts();
    currConflicts = currentBee.getConflicts();

    // proses seleksi greedy
    if(prevConflicts < currConflicts) {                     // tidak ada perbaikan
        currentBee.setNectar(parameterToChange, tempValue);
        currentBee.setNectar(tempIndex, newValue);
        currentBee.computeConflicts();
        currentBee.setTrials(currentBee.getTrials() + 1);
    } else {                                                // ada perbaikan
        currentBee.setTrials(0);
    }   

}

/* Menemukan sumber makanan yang telah ditinggalkan / mencapai batas.
 * Lebah pengintai akan menghasilkan solusi benar-benar acak 
 * dari yang sudah ada dan juga akan mengatur ulang uji coba kembali ke nol.
 */
public void sendScoutBees() {
    Honey currentBee = null;
    int shuffles = 0;

    for(int i =0; i < FOOD_NUMBER; i++) {
        currentBee = foodSources.get(i);
        if(currentBee.getTrials() >= LIMIT) {
            shuffles = getRandomNumber(MIN_SHUFFLE, MAX_SHUFFLE);
            for(int j = 0; j < shuffles; j++) {
                randomlyArrange(i);
            }
            currentBee.computeConflicts();
            currentBee.setTrials(0);

        }
    }
}

/* Menetapkan kebugaran setiap solusi berdasarkan konflik 
 */
public void getFitness() {
    // kesalahan terendah = 100%, kesalahan tertinggi = 0%
    Honey thisFood = null;
    double bestScore = 0.0;
    double worstScore = 0.0;

    // Nilai terburuk akan menjadi satu dengan energi tertinggi, terbaik akan terendah.
    worstScore = Collections.max(foodSources).getConflicts();

    // Mengkonversi ke persentase.
    bestScore = worstScore - Collections.min(foodSources).getConflicts();

    for(int i = 0; i < FOOD_NUMBER; i++) {
        thisFood = foodSources.get(i);
        thisFood.setFitness((worstScore - thisFood.getConflicts()) * 100.0 / bestScore);
    }   
}

/* Menetapkan probabilitas pemilihan masing-masing solusi. 
 * semakin tinggi kebugaran semakin besar probabilitas 
 */ 
public void calculateProbabilities() {
    Honey thisFood = null;
    double maxfit = foodSources.get(0).getFitness();

    for(int i = 1; i < FOOD_NUMBER; i++) {
        thisFood = foodSources.get(i);
        if(thisFood.getFitness() > maxfit) {
            maxfit = thisFood.getFitness();
        }
    }

    for(int j = 0; j < FOOD_NUMBER; j++) {
        thisFood = foodSources.get(j);
        thisFood.setSelectionProbability((0.9*(thisFood.getFitness()/maxfit))+0.1);
    }
}

/* Menginisialisasi semua penempatan solusi 'ratu dalam posisi acak.
 */ 
public void initialize() {
    int newFoodIndex = 0;
    int shuffles = 0;

    for(int i = 0; i < FOOD_NUMBER; i++) {
        Honey newHoney = new Honey(MAX_LENGTH);

        foodSources.add(newHoney);
        newFoodIndex = foodSources.indexOf(newHoney);

        shuffles = getRandomNumber(MIN_SHUFFLE, MAX_SHUFFLE);

        for(int j = 0; j < shuffles; j++) {
            randomlyArrange(newFoodIndex);
        }

        foodSources.get(newFoodIndex).computeConflicts();
    } // i
}

/* Mendapat nomor acak di kisaran parameter
 */ 
public int getRandomNumber(int low, int high) {
    return (int)Math.round((high - low) * rand.nextDouble() + low);
}

/* Mendapat nomor acak dengan pengecualian parameter
 */ 
public int getExclusiveRandomNumber(int high, int except) {
    boolean done = false;
    int getRand = 0;

    while(!done) {
        getRand = rand.nextInt(high);
        if(getRand != except){
            done = true;
        }
    }

    return getRand;     
}

/* Perubahan posisi dari ratu di sebuah partikel dengan menukar posisi yang dipilih secara acak
 */ 
public void randomlyArrange(int index) {
    int positionA = getRandomNumber(0, MAX_LENGTH - 1);
    int positionB = getExclusiveRandomNumber(MAX_LENGTH - 1, positionA);
    Honey thisHoney = foodSources.get(index);
    int temp = thisHoney.getNectar(positionA);
    thisHoney.setNectar(positionA, thisHoney.getNectar(positionB));
    thisHoney.setNectar(positionB, temp);          
}

/* Menghafal solusi terbaik
 */ 
public void memorizeBestFoodSource() {
    gBest = Collections.min(foodSources);
}

/* Mencetak papan nxn dengan ratu
 */ 
public void printSolution(Honey solution) {
    String board[][] = new String[MAX_LENGTH][MAX_LENGTH];

    // Bersihkan papan.
    for(int x = 0; x < MAX_LENGTH; x++) {
        for(int y = 0; y < MAX_LENGTH; y++) {
            board[x][y] = "";
        }
    }

    for(int x = 0; x < MAX_LENGTH; x++) {
        board[x][solution.getNectar(x)] = "Q";
    }

    // tampilkan papan.
    System.out.println("Board:");
    for(int y = 0; y < MAX_LENGTH; y++) {
        for(int x = 0; x < MAX_LENGTH; x++) {
            if(board[x][y] == "Q") {
                System.out.print("Q ");
            } else {
                System.out.print(". ");
            }
        }
        System.out.print("\n");
    }
}    

/*Dapatkan solusi
 */  
public ArrayList<Honey> getSolutions() {
    return solutions;
}

 /* dapatkan nilai epoch
 */ 
public int getEpoch() {
    return epoch;
}

 /* set epoch maksimum
 */ 
public void setMaxEpoch(int newMaxEpoch) {
    this.MAX_EPOCH = newMaxEpoch;
}

/* dapatkan besar populasi
 */ 
public int getPopSize() {
    return foodSources.size();
}

/* mendapat ukuran awal
 */ 
public int getStartSize() {
    return NP;
}

/* dapatkan jumlah makanan
 */ 
public double getFoodNum() {
    return FOOD_NUMBER;
}

/* mendapat batas untuk uji coba untuk semua sumber makanan
 */ 
public int getLimit() {
    return LIMIT;
}

/* menetapkan batas untuk uji coba untuk semua sumber makanan
 */    
public void setLimit(int newLimit) {
    this.LIMIT = newLimit;
}

/* mendapatkan epoch maksimum
 */ 
public int getMaxEpoch() {
    return MAX_EPOCH;
}

/* dapatkan min shuffle
 */ 
public int getShuffleMin() {
    return MIN_SHUFFLE;
}

/* dapatkan max shuffle
 */ 
public int getShuffleMax() {
    return MAX_SHUFFLE;
}  

}

Anda harus login terlebih dahulu untuk memberikan komentar

Recent Tag

X 6
X 48
X 14
X 10
X 1
X 5
X 4
X 18
X 10

Bantuan

Help

Feedback

Help