IMPLEMENTASI DAN PENGUJIAN
4.1. Pengujian Sistem
Pencarian istilah dalam kamus komputer dirancang akan menggunakan algoritma string matching sebagai solusi dalam pencarian istilah berdasarkan isi Kamus, berhubung isi kamus komputeryang sangat banyak, maka sangat sulit untuk merealisasikan penyajian arti dari istilah berdasarkan isi Kamus komputer secara keseluruhan karena terbatasnya ukuran layar handphone yang berbasis Android. Oleh karena itu pada implementasi algoritma string matching untuk pencarian istilah dalam kamus komputer diharapkan dapat menyelesaikan masalah tersebut, dimana dalam algoritma string matching penyajian arti dari istilah lebih sedikit karena adanya proses seleksi sampai ditemukan istilah berdasarkan isi kamus itu sendiri dengan menggunakan kata kunci.Dalam algoritma string matching, pencarian string dirumuskan sebagai berikut:
1. Sebuah teks(text), yaitu sebuah long string yang panjang n karakter
2. Pattern, yaitu sebuah string dengan panjang m karakter (m<n) yang akan dicari dalam text.
Dalam algoritma pencocokan string, teks diasumsikan berada dalam memori, sehingga bila kita mencari string di dalam sebuah arsip, maka semua isi arsip perlu dibaca terlebih dahulu kemudian disimpan didalam memory. Jika pattern muncul lebih dari sekali didalam teks, maka pencarian hanya akan memberikan keluaran berupa lokasi pattern ditemukan pertama kali.
Algoritma Knuth , Morris dan Pratt memanfaatkan informasi yang diperoleh dengan perbandingan simbol sebelumnya. Ini tidak pernah kembali membandingkan simbol teks yang telah cocok simbol pattern.Ada beberapa definisi yang perlu dipahami pada algoritma ini: Misalkan A adalah alfabet dan x = x1x2…xk adalah string yang panjangnya k yang dibentuk dari karakter-karakter di dalam alfabet A.
• Awalan (prefix) dari x adalah upa-string (substring) u dengan u = x1x2…xj – 1 , j є{1, 2, …, k}
dengan kata lain, x diawali dengan u.
• Akhiran (suffix) dari x adalah upa-string(substring) u dengan u = xj – b xj – b + 1 …xk , j є {1, 2, …, k}
dengan kata lain, x di akhiri dengan v.
• Pinggiran (border) dari x adalah upa-string r sedemikian sehingga r = x1x2…xj – 1
dan
u = xj – b xj – b + 1 …xj , j є {1, 2, …, k}
dengan kata lain, pinggiran dari x adalah upastring yang keduanya awalan dan juga akhiran sebenarnya dari x.
Misalkan A adalah alfabet dan x = x0 ..., bilangan elemen k - 1 xk serangkaian panjang k atas A. Sebuah awalan x adalah substring u dengan u = x0 ... xb - 1 di mana b elemen {0 , ... , k} yaitu x dimulai dengan u. Sebuah akhiran x adalah substring u dengan u = xk - b ... xk - 1 di mana b elemen {0 , ... , k}
yaitu x berakhir dengan u.
Sebuah awalan u x atau akhiran u x disebut awalan yang tepat atau akhiran, masing-masing, jika equalx Unot, yaitu jika panjang b kurang dari k.
Sebuah perbatasan x adalah r substring dengan r = x0 ... xb - 1 dan r = xk - b ... xk - 1 di mana b elemen {0 , ... , k - 1}
Sebuah perbatasan x adalah substring yang baik awalan yang tepat dan akhiran yang tepat x. Kami menyebutnya panjangnya b lebar perbatasan.
Contoh: Misalkan x = Abacab. Awalan yang tepat x adalah ε, a, ab, aba, Primero, abaca
Akhiran yang tepat x adalah ε, b, ab, taksi, ACAB, bacab Perbatasan x adalah
Perbatasan ε memiliki lebar 0, perbatasan ab memiliki lebar 2. The string kosong ε selalu perbatasan x, untuk semua x elemen A +. String kosong ε sendiri tidak memiliki perbatasan.
Contoh berikut menggambarkan bagaimana jarak pergeseran algoritma Knuth - Morris - Pratt ditentukan dengan menggunakan gagasan perbatasan string.
contoh :
0 1 2 3 4 5 6 7 8 9... a b c a b c a b d a b c a b d a b c a b d
Simbol pada posisi 0,...,4 telah dicocokkan. Perbandingan c - d pada posisi 5 menghasilkan ketidakcocokan. Pattern bisa digeser oleh 3 posisi, dan perbandingan yang kembali pada posisi 5.
Jarak pergeseran ditentukan oleh perbatasan terluas dari awalan pencocokan p. Dalam contoh ini , awalan pencocokan abcab , panjangnya j = 5. Perbatasan terluas adalah ab lebar b = 2. Jarak shift j - b = 5-2 = 3.
Pada tahap preprocessing, lebar perbatasan terluas setiap awalan dari pattern ditentukan. Kemudian pada tahap pencarian, jarak pergeseran dapat dihitung sesuai dengan awalan yang cocok .
Teorema : Biarkan r, s menjadi perbatasan string x, di mana | r | < | s |. Maka r adalah perbatasan s.
Bukti : Gambar 1 menunjukkan string x dengan batas r dan s. Karena r adalah awalan dari x, juga merupakan awalan yang tepat s, karena lebih pendek dari s. Tetapi r juga merupakan akhiran x dan, oleh karena itu, akhiran yang tepat s. Dengan demikian r adalah perbatasan s
Definisi: Misalkan x berupa string dan elemen A simbol . Sebuah r perbatasan x dapat diperpanjang oleh , jika ra adalah perbatasan xa .
Gambar 4.2. Perpanjangan Perbatasan
Gambar 4.2 menunjukkan bahwa r perbatasan j lebar x dapat diperpanjang oleh , jika xj = a .
Pada tahap preprocessing array b panjang m + 1 dihitung . Setiap entri b [ i ] berisi lebar perbatasan terluas awalan panjang i dari pattern ( i = 0 , ... , m ) . Karena ε awalan panjang i = 0 tidak memiliki perbatasan , dan menetapkan b [ 0 ] = -1 .
Gambar 4.3 : Awalan panjang i dari pattern dengan perbatasan lebar b [ i ]
Asalkan nilai b [ 0 ], ... , b [ i ] sudah diketahui, nilai b [ i + 1 ] dihitung dengan memeriksa jika perbatasan p0 awalan ... pi - 1 dapat diperpanjang oleh simbol pi. Hal ini terjadi jika pb [ i ] = pi ( Gambar 4.3 ). Perbatasan untuk diperiksa diperoleh dalam urutan menurun dari nilai b [ i ], b [ b [ i ] ] dll
Algoritma preprocessing terdiri dari lingkaran dengan j variabel mengambil nilai-nilai ini. Sebuah perbatasan lebar j dapat diperpanjang oleh pi, jika pj = pi. Jika tidak, perbatasan berikutnya terluas diperiksa dengan menetapkan j = b [ j ]. Loop berakhir paling lambat jika tidak ada batas dapat diperpanjang ( j = -1 ).
Setelah meningkatkan j oleh pernyataan j++ dalam setiap kasus j adalah lebar perbatasan terluas dari p0 ... pi. Nilai ini ditulis untuk b[ i + 1 ] (b [ i ] setelah meningkat i dengan pernyataan i ++).
Proses Algoritma void kmpPreprocess() { int i=0, j=-1; b[i]=j; while (i<m) {
while (j>=0 && p[i]!=p[j]) j=b[j]; // karakter berikutnya yang tidak cocok
i++; j++;// karakter berikutnya yang tidak cocok
b[i]=j; }
}
Contoh : Untuk patternp = ababaa lebar dari perbatasan dalam array b memiliki nilai berikut . Misalnya kita telah b [ 5 ] = 3 , karena ababa awalan panjang 5 memiliki perbatasan lebar 3 . j: 0 1 2 3 4 5 6 p[j]: a b a b a a b[j]: -1 0 0 1 2 3 1
Secara konseptual , algoritma preprocessing di atas dapat diterapkan pada string pt bukan p . Jika sampai batas lebar m dihitung saja, maka perbatasan m lebar beberapa awalan x pt sesuai dengan perbandingan dari pattern di t (asalkan perbatasan tidak self- overlapping ) ( Gambar 4.4 ) .
Hal ini menjelaskan kesamaan antara algoritma preprocessing dan algoritma pencarian berikut .
Pencarian Algoritma
void kmpSearch() {
int i=0, j=0;
while (i<n) // memindai teks dari kiri ke kanan {
while (j>=0 && t[i]!=p[j]) j=b[j]; // karakter berikutnya yang tidak cocok
i++; j++; // karakter berikutnya yang tidak cocok
if (j==m) // Apakah semua Pattern cocok?
{ report(i-j); j=b[j]; } } } Keterangan :
Ketika di saat loop ketidakcocokan pada posisi j terjadi ,perbatasan terluas dari awalan pencocokan panjang j dari parttern dianggap (Gambar 4.5). Melanjutkan perbandingan pada posisi b [j], lebar perbatasan, menghasilkan pergeseran daripattern sehingga perbatasan cocok. Jika lagi ketidakcocokan terjadi, perbatasan berikutnya terluas dianggap, dan seterusnya, sampai tidak ada batas kiri (j = -1) atau simbol berikutnya perbandingan. Kemudian kita memiliki awalan pencocokan baru dari pattern dan lanjutkan dengan while loop luar.
Gambar 4.5 : Pergeseran Pattern Ketika Ketidakcocokan Pada Posisi j Terjadi
Jika semua simbol m dari pattern telah dicocokkan jendela teks yang sesuai (j = m), laporan fungsi disebut untuk melaporkan perbandingan di posisi ij. Setelah itu, pattern digeser sejauh perbatasan terluas memungkinkan.
Pada contoh berikut perbandingan yang dilakukan oleh algoritma pencarian yang ditampilkan, di mana perbandingan diambil dalam warna hijau dan ketidaksesuaian merah. Contoh: 0 1 2 3 4 5 6 7 8 9 ... a b a b b a b a a a b a b a c a b a b a c a b a b a c a b a b a c a b a b a c
Contoh pada aplikasi pada kamus Komputer : Teks : FAST ETHERNET
Pattern : THER
Teks :
F A S T E T H E R N E T
T H E R
Langkah 1:
F A S T E T H E R N E T
Pattern[1] tidak cocok dengan Teks[1], maka digeser satu langkah ke kanan.
Langkah 2:
F A S T E T H E R N E T
Pattern[1] tidak cocok dengan Teks[2], maka digeser 1 karakter ke kanan.
Langakah 3:
F A S T E T H E R N E T
Pattern[1] tidak cocok dengan Teks[3], maka Pettern digeser satu karakter ke kanan. Langkah 4: F A S T E T H E R N E T T H E R T H E R T H E R T H E R
Pattern[1] cocok dengan Teks[4], maka dilanjutkan membandingkan Pattern[2] dengan Teks[5].
Langkah 5:
F A S T E T H E R N E T
Pattern[2] ternyata tidak cocok dengan Teks[5]. Maka Pencocokan selanjutnya dimulai lagi dari Pattern[1] dengan membandingkan Pattern[1] dengan Teks[6].
Langkah 6:
F A S T E T H E R N E T
Pattern[1] cocok dengan Teks[6], maka Patterntidak melakukan pergeseran dan selanjutnya membandingkan Pattern[2] dengan Teks[7].
Langkah 7:
F A S T E T H E R N E T
Pattern[2] cocok dengan Teks[7], maka dilanjutkan membandingkan Pattern[3] dengan Teks[8].
Langkah 8:
F A S T E T H E R N E T
Pattern[3] cocok dengan Teks[8], maka dilanjutkan membandingkan Pattern[4] dengan Teks[9].
T H E R
T H E R
T H E R
Langkah 9:
F A S T E T H E R N E T
Pattern[4] cocok dengan Teks[9], maka pencocokan berhenti karena Patternyang dicari telah cocok dengan Teks sehingga terbentuk pattern kata di Teks sesuai dengan Pattern. Pencocokan berhenti meskipun karakter dalam Teks belum habis.
Berdasarkan contoh di atas maka dapat disimpulkan bahwa informasi yang digunakan untuk melakukan pergeseran adalah berdasarkan hitungan ketidak cocokan Pattern dari kiri pada Teks.
Adapun potongan script pada Eclipse yang digunakan untuk algoritma KMP string matching sebagai berikut:
KMP.java
package com.indah.kmp;
publicclass KMP {
publicint[] prekmp(Stringpattern) {
int[] next = newint[pattern.length()]; int i=0, j=-1;
next[0]=-1;
while (i<pattern.length()-1) {
while (j>=0 &&pattern.charAt(i)!=pattern.charAt(j)) j = next[j]; i++; j++; next[i] = j; } return next; T H E R
}
publicint kmp(String text, Stringpattern) { int[] next = prekmp(pattern);
int i=0, j=0;
while (i<text.length()) { while (j>=0 &&
text.charAt(i)!=pattern.charAt(j))
j = next[j]; i++; j++;
if (j==pattern.length()) return i-
pattern.length();
}
return -1; }
}
