BAB IV IMPLEMENTASI DAN ANALISA HASIL
4.1 Implementasi Proses
4.1.1 Implementasi Algoritma Semut
Implementasi algoritma semut yang digunakan untuk pembuatan jadwal mata kuliah. Dalam dalam algoritma ini, akan ada beberapa proses untuk menjadikan sebuah jadwal perkuliahan. Tahap pertama adalah menentukan nilai awal parameter dan menempatkan semut berisi data mata kuliah ke dalam matriks timeslote * ruang, untuk menentukan node pertama secara random. Tahap kedua adalah mengecek setiap calon node dengan node yang sudah dilalui. Tahap ketiga adalah mencari probabilitas node terbesar, untuk menentukan node selanjutnya yang akan dilalui semut. Tahap keempat, jika semut telah menyelesaikan perjalanan, maka dilakukan update feromon dari semua node di matriks timeslot * ruang. Tahap terakhir adalah update / mengubah semut dengan pelanggaran terkecil. Berikut adalah proses pertama, menentukan nilai awal parameter dan menempatkan semut berisi data mata kuliah ke dalam matriks timeslote * ruang, untuk menentukan node pertama secara random :
double ALPHA = 9.6; double BETA = 0.2; double RHO = 0.5; double Q = 0.5; double τ0 = 0.2;
Semut semut[] = new Semut[5]; int iterasi = 5;
List<String> bantuNode = getRandomNode();
Pada bagian ini, selain menentukan node awal untuk setiap semut, node yang telah dipilih secara random beserta kelas mata kuliah yang dipilih akan disimpan kedalam list bernama bantuSemutList. Selanjutnya, pada tahap kedua mengecek jumlah iterasi, membuat atribut baru simpanKelasMataKuliah (atribut ini berguna dalam pengecekan soft constrain kelas mata kuliah), menginisilaisasi maxKunjungan (nilai maksimal kunjungan yang nanti akan bertambah setiap perulangan), atribut tampungTSkelasMaKul (untuk menampung jumlah soft constrain kelas mata kuliah) dan pelanggaranHardConstraint (untuk menampung jumlah hard constrain).
Selanjutnya, program akan mengecek jumlah maksimal kunjungan semut. Selain itu, program akan mengecek setiap calon node yang akan dan sudah dilalui. Dalam tahap ini, dibagi beberapa tahapan pengecekan. Pengecekan pertama adalah perulangan sebanyak semut untuk mendapatkan node terakhir dikunjungi.
List<String> dapat_PermintaanKelasMakul = getKelasMaKul_Permintaan(); for (int i = 0; i < semut.length; i++) { semut[i] = new SemutList();
semut[i].setSemut("Semut " + i);
for (int j = 0; j < jumlahKunjungan; j++) { list1 = new SemutList();
list1.setKm(bantuMataKuliah.get(j)); list1.setNode(bantuNode.get(i)); bantuSemutList.add(list1); } semut[i].setSimpan(bantuSemutList); }
for (int it = 0; it < iterasi; it++) { maxKunjungan = 1;
ArrayList<String> simpanKelasMataKuliah = new ArrayList<String>(); TampungTSdosen[][] = new double[iterasi][semut.length];
Pada bagian ini, akan diambil node timeslot dan ruang tertentu yang telah disimpan di dalam list bantuSemutList. Selain itu, hanya membuat inisialisasi dan pembuatan atribut baru. Pengecekan kedua adalah perulangan sebanyak node
while (maxKunjungan < (km.size() - dapat_PermintaanKelasMakul.size())) {
for (int banyakSemut = 0; banyakSemut < semut.length; banyakSemut++) {
pelanggaranHardConstraint[it][banyakSemut] = 0.0; int tsDosen[ ][ ] = new int[6][jumlahDosen.size()];
int tsKelasMaKul[ ][ ] = new int[6][jumlahKelasMakul.size()]; int kelompokKelasMaxTS_next = 0;
nodeTerkunjung = new ArrayList<String>(); nodeTerkunjungBantu = 0;
double bantuProbabilitas1; double bantuProbabilitas2 = 0.0; String cariTS = null;
String cariRG = null;
for (int kunjunganLast = maxKunjungan - 1; kunjunganLast < maxKunjungan; kunjunganLast++) {
double probabilitas = 0.0;
double hitungPelanggaranHard = 0.0;
int persamaantsDosen[ ][ ] = new int[6][jumlahDosen.size()];
int persamaantsKelasMaKul[ ][ ] =
new int[6][jumlahKelasMakul.size()];
double[ ][ ] localMatrix = new double[timeslot.size()][ruang.size()]; double[ ][ ] hitungHardConstraint =
new double[timeslot.size()][ruang.size()];
double probabilitasNode[][] = new double[timeslot.size()][ruang.size()]; String bantuSemut1 =
semut[banyakSemut].getSimpan().get(((bantuSemutList.size() - semut.length))).getNode();
String split[] = bantuSemut1.split(" "); String tsString = split[0];
timeslot * ruang. Pengecekan kedua akan membandingkan beberapa node. Perbandingan pertama antara node timeslot * ruang dengan node di dalam permintaan kelas mata kuliah.
for (int iTS = 0; iTS < timeslot.size(); iTS++) { for (int iRG = 0; iRG < ruang.size(); iRG++) { int persamaan[][] = new int[timeslot.size()][ruang.size()]; persamaan[iTS][iRG] = 0
if (it == 0) { TAU[iTS][iRG] = τ0; } TimeSlot ts = new TimeSlot();
ts.setIdTS(timeslot.get(iTS).getIdTS().substring(2)); RuangKelas rg = new RuangKelas();
rg.setIdRuang(ruang.get(iRG).getIdRuang().substring(1)); String tsMaxDosen[] =
bantuMataKuliah.get(maxKunjungan).split(" "); String cariIdDosen1 = cekIdDOsen(tsMaxDosen[1]);
String cariKelompokKelas1 = tsMaxDosen[2] + " " + tsMaxDosen[3]; String dosenMaxTS_next = cekIdDOsen(tsMaxDosen[1]);
kelompokKelasMaxTS_next = cekListPembandingKelasMataKuliah(simpanKelasMataKuliah, cariKelompokKelas1); hitungHardConstraint[iTS][iRG] = 0.0; tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))][Integer.parseInt(dosen MaxTS_next)] = 0; tsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))][kelompokKelas MaxTS_next] = 0;
for (int kunjunganPermintaan = 0; kunjunganPermintaan <
dapat_PermintaanKelasMakul.size(); kunjunganPermintaan++) { String dapat_PermintaanKelasMakul_pisah[] = dapat_PermintaanKelasMakul.get(kunjunganPermintaan).split(" "); String iTS_Permintaan = cekIdTimeSlot(dapat_PermintaanKelasMakul_pisah[1]); String iRG_Permintaan = cekIdRuang(dapat_PermintaanKelasMakul_pisah[2]);
Pada bagian ini, terdapat inisialisasi untuk menghitung pelanggaran setiap node. Selain itu, saat masuk bagian untuk mengecek kelas mata kuliah permintaan, dibuat atribut untuk menampung data timeslot, ruang, dosen, dan kelompok kelas yang telah ditentukan sebelum pembuatan jadwal (bagian ini adalah kelompok kelas yang tidak masuk dalam pembuatan jadwal dengan algoritma semut), agar calon node, calon dosen, dan calon kelompok mata kuliah tidak sama dengan permintaan yang ada.
Bagian di bawah ini adalah koding program untuk menghitung pelanggaran hard constraint dan penghitungan jumlah pelanggaran soft constrain sesuai dengan perbandingan sebelumnya. String dosen_Permintaan = cekIdDOsen(dapat_PermintaanKelasMakul_pisah[4]); String kelompokKelasPermintaan = dapat_PermintaanKelasMakul_pisah[5] + " " + dapat_PermintaanKelasMakul_pisah[6];
if (!dosen_Permintaan.equals("0") && !iRG_Permintaan.equals("0")) { hitungHardConstraint[iTS][iRG] = hitungHardConstraint[iTS][iRG]
+ (cariTabrakanDosen(iTS_Permintaan, ts.getIdTS(), dosen_Permintaan, cariIdDosen1) + cariTabrakanRuang (iTS_Permintaan, ts.getIdTS(), iRG_Permintaan,
rg.getIdRuang()) + cariTabrakanKelompokKelas
(iTS_Permintaan, ts.getIdTS(), kelompokKelasPermintaan, cariKelompokKelas1));
}else if (dosen_Permintaan.equals("0")|| iRG_Permintaan.equals("0")) { hitungHardConstraint[iTS][iRG] = hitungHardConstraint[iTS][iRG] + cariTabrakanKelompokKelas(iTS_Permintaan, ts.getIdTS(), kelompokKelasPermintaan, cariKelompokKelas1); } tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))][Integer.parseInt(dosen MaxTS_next)] = tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))][Integer.parseIn t(dosenMaxTS_next)] + cariDosenMaxTS(iTS_Permintaan,
Setelah perbandingan pertama antara node timeslot * ruang dengan node di dalam permintaan kelas mata kuliah selesai, selanjutnya adalah melakukan perbandingan antara node timeslot * ruang dengan node yang pernah dilalui semut.
if (tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))] [Integer.parseInt(dosenMaxTS_next)] >= 3) { hitungHardConstraint[iTS][iRG] = hitungHardConstraint[iTS][iRG] + 1;}kelompokKelasMaxTS_nextPermintaan = cekListPembandingKelasMataKuliah(simpanKelasMataKuliah, kelompokKelasPermintaan); tsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))][kelompokKelas MaxTS_next] = tsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))][kelompo kKelasMaxTS_next] + cariKelasMaKulMaxTS(iTS_Permintaan, ts.getIdTS(), kelompokKelasMaxTS_nextPermintaan, kelompokKelasMaxTS_next);if (tsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))][kelomp okKelasMaxTS_next] >=3) { persamaantsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))][kelo mpokKelasMaxTS_next] = persamaantsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS() )][kelompokKelasMaxTS_next] + 1; }}
for (int kunjunganBantu = 0; kunjunganBantu < jumlahKunjungan; kunjunganBantu++) { String bantuSemut2 = semut[banyakSemut].getSimpan().get((((semut.length * (kunjunganBantu + 1)) - semut.length) + banyakSemut)).getNode(); String bantuSemutKM2 = semut[banyakSemut].getSimpan().get((((semut.length * (kunjunganBantu + 1)) - semut.length) + banyakSemut)).getKm();
Pada bagian sebelumnya, terdapat atribut untuk menampung data timeslot, ruang, dosen, dan kelompok kelas yang diambil dari list (node yang telah dikunjungi oleh node). Sedangkan pada bagian di bawah ini, menghitung pelanggaran hard constraint dan penghitungan jumlah pelanggaran soft constrain sesuai dengan perbandingan dengan node yang pernah dilalui semut.
String pisahCariTabrakan2[] = bantuSemutKM2.split(" "); String iddosen2 = pisahCariTabrakan2[1];
String kelas2 = pisahCariTabrakan2[2] + " " + pisahCariTabrakan2[3]; String cariIdDosen2 = cekIdDOsen(iddosen2);
String cariKelompokKelas2 = kelas2;
String rgString1 = cekIdRuang(pisah1[1]);
String dosenMaxTS_before = cekIdDOsen(iddosen2);
String kelompokKelasMaxTS_2 = kelas2;
if (!rgString1.equals("0") && !cariIdDosen2.equals("0")) { hitungHardConstraint[iTS][iRG] = hitungHardConstraint[iTS][iRG]
+ (cariTabrakanDosen(tsString1, ts.getIdTS(), cariIdDosen2, cariIdDosen1) + cariTabrakanRuang(tsString1, ts.getIdTS(), rgString1, rg.getIdRuang()) +
cariTabrakanKelompokKelas(tsString1, ts.getIdTS(), cariKelompokKelas2, cariKelompokKelas1));
} else if (rgString1.equals("0") || cariIdDosen2.equals("0")) { hitungHardConstraint[iTS][iRG] = hitungHardConstraint[iTS][iRG] + cariTabrakanKelompokKelas(tsString1, ts.getIdTS(), cariKelompokKelas2, cariKelompokKelas1); } tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))] [Integer.parseInt(dosenMaxTS_next)] = tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))] [Integer.parseInt(dosenMaxTS_next)] + cariDosenMaxTS(tsString1, ts.getIdTS(), dosenMaxTS_before, dosenMaxTS_next); if (tsDosen[cariHari(Integer.parseInt(ts.getIdTS()))] [Integer.parseInt(dosenMaxTS_next)] >= 3) { hitungHardConstraint[iTS][iRG] = hitungHardConstraint[iTS][iRG] + 1;}
Setelah perbandingan kedua antara node timeslot * ruang dengan node yang pernah dilalui semut, maka perbandingan terakhir adalah jika node tidak memiliki hard constrain, maka akan dimasukkan ke dalam list untuk perbandingan di tahap selanjutnya. Berikut koding program tersebut :
int kelompokKelasMaxTS_before = 0; kelompokKelasMaxTS_before = cekListPembandingKelasMataKuliah(simpanKelasMataKuliah, kelompokKelasMaxTS_2); if (tsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))][kelompokKela sMaxTS_next] >= 3) { persamaantsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))] [kelompokKelasMaxTS_next] = persamaantsKelasMaKul[cariHari(Integer.parseInt(ts.getIdTS()))] [kelompokKelasMaxTS_next] + 1; } if (hitungHardConstraint[iTS][iRG] == 0) { persamaan[iTS][iRG] = persamaantsKelasMaKul[cariHari(Integer.parseInt (ts.getIdTS()))][kelompokKelasMaxTS_next] + persamaantsDosen[cariHari(Integer.parseInt(ts.getIdTS()))] [Integer.parseInt(dosenMaxTS_next)]; localMatrix[iTS][iRG] = kalkulasiEuclidianDistance(Integer.parseInt(ts.getIdTS()), Integer.parseInt(tsString), Integer.parseInt(rg.getIdRuang()), Integer.parseInt(rgString)); ETA[iTS][iRG] = invertDouble(localMatrix[iTS][iRG]); bantuProbabilitas1 = Math.pow(TAU[iTS][iRG], ALPHA) *
Math.pow(ETA[iTS][iRG], BETA);
bantuProbabilitas2 = bantuProbabilitas2 + bantuProbabilitas1; nodeTerkunjung.add(nodeTerkunjungBantu,
Double.toString(bantuProbabilitas1) + " " + iTS + " " + iRG + " " + hitungHardConstraint[iTS][iRG] + " " +
persamaan[iTS][iRG]);
nodeTerkunjungBantu = nodeTerkunjungBantu + 1;}
Sedangkan jika terdapat pelanggaran hard constrain, maka perhitungan untuk probabilitas adalah nol. Berikut koding untuk node yang memiliki pelanggaran hard constrain.
Jika sudah sampai pada tahap perbandingan ini, maka tahap selanjutnya adalah mencari probabilitas node terbesar diantara node yang dilalui. Berikut ini adalah koding program untuk mencari probabilitas node terbesar.
Pada tahap ini, data node yang dikunjungi akan diambil sesuai urutan, lalu di pisahkan secara urut yaitu timeslot, ruang, pelanggaran hardconstraint, pelanggaran softconstraint, serta probabilitas node tersebut.
} else if (hitungHardConstraint[iTS][iRG] != 0) { persamaan[iTS][iRG] = persamaantsKelasMaKul[cariHari(Integer.parseInt (ts.getIdTS()))][kelompokKelasMaxTS_next] + persamaantsDosen[cariHari(Integer.parseInt(ts.getIdTS()))] [Integer.parseInt(dosenMaxTS_next)]; bantuProbabilitas1 = 0; bantuProbabilitas2 = bantuProbabilitas2 + 0; nodeTerkunjung.add(nodeTerkunjungBantu,
Double.toString(bantuProbabilitas1) + " " + iTS + " " + iRG + " " + hitungHardConstraint[iTS][iRG] + " " + persamaan[iTS][iRG]); }}
for (int i = 0; i < nodeTerkunjung.size(); i++) {
String pisahTerkunjung[ ] = nodeTerkunjung.get(i).split(" ");
double bantuProbabilitas = Double.parseDouble(pisahTerkunjung[0]); int TSnodeTerkunjung = Integer.parseInt(pisahTerkunjung[1]);
int RGnodeTerkunjung = Integer.parseInt(pisahTerkunjung[2]); double pelanggaranHard = Double.parseDouble(pisahTerkunjung[3]); double pelanggaranSoft = Double.parseDouble(pisahTerkunjung[4]); probabilitasNode[TSnodeTerkunjung][RGnodeTerkunjung] =
Pada koding di atas, terdapat cuplikan koding program untuk menyimpan node dengan ruang 0 dan timeslot 0 menjadi probabilitas terbesar awal. Selanjutnya, jika terdapat probabilitas yang lebih besar, maka koding program seperti berikut.
if (TSnodeTerkunjung == 0 && RGnodeTerkunjung == 0) { probabilitas =
probabilitasNode[TSnodeTerkunjung][RGnodeTerkunjung]; TimeSlot ts = new TimeSlot();
ts.setIdTS(timeslot.get(TSnodeTerkunjung).getIdTS().substring(2)); RuangKelas rg = new RuangKelas();
rg.setIdRuang(ruang.get(RGnodeTerkunjung).getIdRuang().substring(1)); cariTS = ts.getIdTS(); cariRG = rg.getIdRuang(); if (simpanNodeKunjung.size() > js) { simpanNodeKunjung.remove(js); } simpanNodeKunjung.add((js), TSnodeTerkunjung + " " +
RGnodeTerkunjung + " " + pelanggaranHard + " " + pelanggaranSoft); hitungPelanggaranHard = pelanggaranHard; } Else { if (probabilitasNode[TSnodeTerkunjung][RGnodeTerkunjung] >= probabilitas) { probabilitas = probabilitasNode[TSnodeTerkunjung][RGnodeTerkunjung]; TimeSlot ts = new TimeSlot();
ts.setIdTS(timeslot.get(TSnodeTerkunjung).getIdTS().substring(2)); RuangKelas rg = new RuangKelas();
rg.setIdRuang(ruang.get(RGnodeTerkunjung).getIdRuang().substring(1)); cariTS = ts.getIdTS();
Setelah mendapat probabilitas tertinggi, maka tahap selanjutnya adalah mengakumulasi pelanggaran hard constraint, lalu menyimpan node dengan probabilitas tertinggi kedalam list.
Selanjutnya adalah tahap keempat, yaitu saat semut telah menyelesaikan perjalanan, maka dilakukan update feromon dari semua node di matriks timeslot * ruang.
if (simpanNodeKunjung.size() > js) { simpanNodeKunjung.remove(js); }
simpanNodeKunjung.add((js), TSnodeTerkunjung + " " +
RGnodeTerkunjung + " " + pelanggaranHard + " " + pelanggaranSoft); hitungPelanggaranHard = pelanggaranHard; }} pelanggaranHardConstraint[it][banyakSemut] = pelanggaranHardConstraint[it][banyakSemut] + hitungPelanggaranHard; js = js + 1; }
semut[banyakSemut] = new SemutList();
semut[banyakSemut].setSemut("Semut" + banyakSemut); bantuNode = cariNode(cariTS, cariRG);
int j = jumlahKunjungan;
if (j < (jumlahKunjungan + 1)) {
list1 = new SemutList(); list1.setKm(bantuMataKuliah.get(j)); list1.setNode(bantuNode.get(0)); bantuSemutList.add(list1); } semut[banyakSemut].setSimpan(bantuSemutList); } jumlahKunjungan = jumlahKunjungan + 1;}
Tahap terakhir adalah update / mengubah semut dengan pelanggaran terkecil. Proses ini juga dikenal sebagai update global best. Semut yang telah selesai menjalankan tugas, akan dicek, dan akan dijadikan solusi terbaik, jika semut pada iterasi tertentu memiliki kriteria pelanggaran paing kecil diantara semut lain pada semua iterasi. Berikut koding program untuk tahap ini :
for (int iTS = 0; iTS < timeslot.size(); iTS++) {
for (int iRG = 0; iRG < ruang.size(); iRG++) { double totalPelanggaran = 0.0;
int cekKetersediaan = 0;
for (int i = 0; i < simpanNodeKunjung.size(); i++) { String pisah2[ ] = simpanNodeKunjung.get(i).split(" "); int TSnodeTerkunjung = Integer.parseInt(pisah2[0]); int RGnodeTerkunjung = Integer.parseInt(pisah2[1]); double pelanggaranHard = Double.parseDouble(pisah2[2]); double pelanggaranSoft = Double.parseDouble(pisah2[3]);
if (iTS == TSnodeTerkunjung && iRG == RGnodeTerkunjung) { cekKetersediaan = cekKetersediaan + 1;
if (pelanggaranSoft == 0.0 && pelanggaranHard == 0.0) { totalPelanggaran = totalPelanggaran + 1;
} else { totalPelanggaran = totalPelanggaran + (Q / (pelanggaranSoft + pelanggaranHard));
}}}
if (cekKetersediaan == 0) {
TAU[iTS][iRG] = (1 - RHO) * TAU[iTS][iRG]; } else {
TAU[iTS][iRG] = (1 - RHO) * TAU[iTS][iRG] + totalPelanggaran; }}}
4.2 Implementasi Tampilan Antar Muka