indeks dan pencarian chained hash table pada - PLAGIAT ...

i

INDEKS DAN PENCARIAN CHAINED HASH TABLE PADAPEMEROLEHAN INFORMASI MENGGUNAKAN HASH

FUNCTION : KNUTH’S MULTIPLICATION METHOD DANDIVISION METHOD STUDI KASUS : PERPUSTAKAAN

UNIVERSITAS SANATA DHARMA

SKRIPSI

Diajukan untuk Memenuhi Salah Satu SyaratMemperoleh Gelar Sarjana Teknik Komputer (S.Kom.)

Program Studi Teknik Informatika

Oleh:Linardi

NIM : 085314057

FAKULTAS SAINS DAN TEKNOLOGIUNIVERSITAS SANATA DHARMA

YOGYAKARTA2012

PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJIPLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI

ii

CHAINED HASH TABLE INDEX AND SEARCHING ININFORMATION RETRIEVAL WITH HASH FUNCTION :KNUTH’S MULTIPLICATION METHOD DAN DIVISION

METHOD CASE STUDY :LIBRARY OF SANATA DHARMA UNIVERSITY

THESIS

Presented as Partial Fullfilment of the RequirementsTo Obtain the Computer Bachelor Degree

In Informatics Engineering

By:Linardi

NIM : 085314057

FACULTY OF SCIENCE AND TECHNOLOGYSANATA DHARMA UNIVERSITY

YOGYAKARTA2012


iii

HALAMAN PERSETUJUAN


iv

HALAMAN PENGESAHAN


v

PERNYATAAN KEASLIAN KARYA


vi

HALAMAN MOTO

Tetapi carilah dahulu Kerajaan Allah dan

kebenarannya, maka semuanya itu akan ditambahkan

kepadamu.

( Matius 6:33 )


vii

HALAMAN PERSEMBAHAN

Skripsi ini saya persembahkan kepada Tuhan YME yang selalu

menjadi sandaran dan topangan saat menghadapi masalah, dan

menyertaiku dalam menyelesaikan skripsi.

Untuk Ibu , Ayah, kakak, dan keponakan saya atas dukungan

kalian semua.

Buat yang tercinta, Silvia Natalia, atas support, dukungan dan

doa dalam menyelesaikan skripsi.


viii

ABSTRAKSI

Perpustakaan Universitas Sanata Dharma ( USD ) menggunakan sebuah

sistem pencarian koleksi yang mengharuskan pemustaka untuk memiliki informasi

yang memadai seperti judul, pengarang, dll. Pemustaka akan mengalami kesulitan

dalam menemukan koleksi apabila hanya memiliki sedikit informasi mengenai isi

koleksi yang ingin ditemukan. Sistem IR (Information Retrieval) dapat menjadi salah

satu solusi penyelesaiannya. Terdapat beberapa permasalahan dalam pengembangan

IR, salah satunya yaitu bagaiman melakukan pencarian yang cepat dan hemat sumber

daya. Hal ini berkaitan dengan bentuk dan struktur data yang digunakan sebagai

indeks. Salah satu struktur data yang dapat digunakan untuk menyelesaikannya

adalah struktur data Hash table.

Dari latar belakang tersebut, dikembangkan sebuah sistem untuk menguji

unjuk kerja Division method dan Knuth’s multiplication method sebagai hash function

pada index dalam bentuk inverted index yang menggunakan struktur data hash table.

Sistem dikembangkan dengan bahasa pemrograman JAVA. Hasil akhir penelitian

berupa data-data pengukuran waktu pemrosesan indeks, persebaran data dalam hash

table, penggunaan memori, dan waktu pencarian. Diperoleh bahwa untuk waktu

pembentukan dan penggunaan memori, division method lebih unggul, dan Knuth’s

multiplication method memiliki persebaran data yang lebih merata tetapi memiliki

lebih banyak bucket yang tidak terisi.


ix

ABSTRACT

Library of Sanata Dharma University (USD) uses a collection searching

system that requires the user to have adequate information such as title, author, etc.

Users will have difficulty in finding the collection if they just have little information

about the contents of the collection. This problem can be solved by an IR

(Information retrieval) system. In developing IR, there are some problem such as how

to do a fast and efficient searching. This relates to the form and data structure that

used for the index. Hash table data structure can be used to solve this problems.

From these background, a system was developed to measure the

performance of Division method and Knuth’s multiplication method as a hash

function in inverted index with hash table data structure. The system was developed

with the JAVA programming language. The final results is measurement of time for

index processing, distribution of data in hash table, memory usage and searching

time. The results provide that division method is superior in processing time and

memory usage, and Knuth's multiplication method has a more equitable distribution

of the data but it has more empty buckets in the hash table.


x

LEMBAR PENYATAAN PERSETUJUANPUBLIKASI KARYA ILMIAH

UNTUK KEPENTINGAN AKADEMIS


xi

KATA PENGANTAR

Puji dan syukur saya panjatkan pada Tuhan YME yang telah melimpahkan

berkatnya sehingga saya dapat menyelesaikan tugas akhir ini.

Pada kesempatan ini saya ingin mengucapkan terima kasih pada pihak-pihak

yang telah membantu saya dalam menyelesaikan skripsi ini, baik dalam hal

bimbingan, perhatian, kasih sayang, semangat, kritik dan saran yang diberikan.

Ucapan terima kasih ini saya sampaikan antara lain kepada :

1. Ibu Paulina Heruningsih Prima Rosa, S.Si., M.Sc selaku Dekan Fakultas

Sains dan Teknologi Universitas Sanata Dharma.

2. Ibu Ridowati Gunawan, S.Kom, M.T. selaku ketua jurusan Teknik

Informatika Sanata Dharma.

3. Bapak Eko Hari Parmadi S.Si., M.Kom. selaku Dosen Pembimbing

Akademik Teknik Informatika angkatan 2008.

4. Ibu Sri Hartati Wijono, S.Si., M.Kom. selaku Dosen Pembimbing TA, terima

kasih atas bimbingannya selama saya mengerjakan skripsi ini.

5. Bapak JB. Budi Darmawan, S.T, M.Sc. dan Albertus Agung Hadhiatma S.T.,

M.T. selaku Dosen Penguji Pendadaran skripsi saya, terima kasih atas

masukkan dalam memperbaiki skripsi ini.

6. Ibu, kakak dan kekasih saya terima kasih atas dukungan, semangat dan kasih

sayang yang diberikan sehingga saya dapat menyelesaikan tugas akhir ini.


xii


xiii

DAFTAR ISI

HALAMAN JUDUL INDONESIA............................................................................... i

HALAMAN JUDUL INGGRIS ................................................................................... ii

HALAMAN PERSETUJUAN.....................................................................................iii

HALAMAN PENGESAHAN...................................................................................... iv

PERNYATAAN KEASLIAN KARYA ....................................................................... v

HALAMAN MOTO ....................................................................................................vi

HALAMAN PERSEMBAHAN .................................................................................vii

ABSTRAKSI .............................................................................................................viii

ABSTRACT................................................................................................................. ix

LEMBAR PENYATAAN PERSETUJUAN ................................................................ x

KATA PENGANTAR .................................................................................................xi

DAFTAR ISI..............................................................................................................xiii

DAFTAR GAMBAR .................................................................................................xix

DAFTAR TABEL......................................................................................................xxi

DAFTAR LISTING ..................................................................................................xxii

DAFTAR LAMPIRAN............................................................................................xxiii


xiv

BAB I PENGANTAR................................................................................................... 1

1.1. Latar Belakang ........................................................................................... 1

1.2. Rumusan Masalah ...................................................................................... 4

1.3. Tujuan Penelitian........................................................................................ 4

1.4. Batasan Permasalahan ................................................................................ 4

1.5. Manfaat Penelitian...................................................................................... 5

1.6. Luaran......................................................................................................... 5

1.7. Metodologi Penelitian ................................................................................ 5

1.8. Sistematika Penulisan................................................................................. 7

BAB II LANDASAN TEORI ....................................................................................... 8

2.1. Perpustakaan............................................................................................... 8

2.1.1. Perpustakaan Universitas Sanata Dharma.................................................. 8

2.2. Information Retrieval ( IR ) ....................................................................... 9

2.3. Data Preprocessing .................................................................................. 10

2.3.1. Tokenizing ................................................................................................ 10

2.3.2. Stopword Removal.................................................................................... 10

2.3.3. Stemming .................................................................................................. 11

2.4. Index ......................................................................................................... 15


xv

2.5. Indexing and Searching ............................................................................ 16

2.6. Hash Table ............................................................................................... 17

2.6.1. Chained Hash Table................................................................................. 17

2.6.2. Hash Function .......................................................................................... 19

2.6.2.1. Mixing Step ....................................................................................... 19

2.6.2.2. Division Method................................................................................ 21

2.6.2.3. Knuth’s Multiplication Method......................................................... 21

2.7. Metodologi FAST .................................................................................... 22

BAB III ANALISIS DESAIN..................................................................................... 26

3.1. Analisis Sistem......................................................................................... 26

3.1.1. Fase Definisi Ruang Lingkup (Scope Definition Phase) ......................... 26

3.1.2. Fase Analisis Masalah (Problem Analysis Phase) ................................... 27

3.1.2.1. Gambaran Sistem Lama .................................................................... 27

3.1.2.2. Gambaran Sistem Penelitian ............................................................. 27

3.2. Perancangan Penelitian ............................................................................ 28

3.2.1. Data Penelitian ......................................................................................... 28

3.2.2. Diagram Blok Penelitian .......................................................................... 28

3.2.3. Diagram Kelas UML................................................................................ 29


xvi

3.2.4. Flowchart Proses...................................................................................... 30

3.2.4.1. Flowchart Scanning dan Tokenizing ................................................. 31

3.2.4.2. Flowchart Stopword Removal ........................................................... 32

3.2.4.3. Flowchart Porter Stemmer................................................................. 33

3.2.4.4. Flowchart Indexing............................................................................ 34

3.2.4.5. Flowchart Searching.......................................................................... 37

3.2.5. Skenario Pengujian................................................................................... 38

3.2.5.1. Pengujian Waktu Pemrosesan Index ................................................. 38

3.2.5.2. Pengujian Sumberdaya Memori ........................................................ 38

3.2.5.3. Pengujian Persebaran Data dalam Hash Table.................................. 38

3.2.5.4. Pengujian Waktu Pencarian Koleksi ................................................. 39

BAB IV IMPLEMENTASI ........................................................................................ 40

4.1. Implementasi Proses................................................................................. 40

4.1.1. Implementasi Preprocessing .................................................................... 40

4.1.1.1. Tahap Scanning dan Tokenizing ........................................................ 41

4.1.1.2. Tahap Stopword Removal.................................................................. 43

4.1.1.3. Tahap Stemming ................................................................................ 44

4.1.2. Implementasi Indexing ............................................................................. 45


xvii

4.1.3. Implementasi Searching ........................................................................... 66

BAB V HASIL PENGUJIAN DAN ANALISA......................................................... 72

5.1. Hasil Pengujian ........................................................................................ 72

5.1.1. Hasil Pengujian Waktu Pemrosesan Index............................................... 73

5.1.2. Hasil Pengujian Sumber Daya Memori.................................................... 74

5.1.3. Hasil Pengujian Persebaran Data dalam Hash Table ............................... 75

5.1.3.1. Grafik Persebaran Division Method ( 383 Bucket )........................... 75

5.1.3.2. Grafik Persebaran Knuth’s Multiplication Method ( 383 Bucket ).... 76

5.1.3.3. Grafik Persebaran Division Method ( 1531 Bucket )......................... 77

5.1.3.4. Grafik Persebaran Knuth’s Multiplication Method ( 1531 Bucket ).. 78

5.1.3.5. Grafik Persebaran Division Method ( 6143 Bucket )......................... 79

5.1.3.6. Grafik Persebaran Knuth’s Multiplication Method ( 6143 Bucket ).. 80

5.1.3.7. Grafik Persebaran Division Method ( 24571 Bucket )....................... 81

5.1.3.8. Grafik Persebaran Knuth’s Multiplication Method ( 24571 Bucket ) 82

5.1.4. Hasil Pengujian Waktu Pencarian ............................................................ 83

5.2. Analisa Hasil Pengujian ........................................................................... 85

5.2.1. Analisa Pengujian Waktu Pemrosesan Indeks ......................................... 85

5.2.2. Analisa Pengujian Sumber Daya Memori ................................................ 86


xviii

5.2.3. Analisa Pengujian Persebaran Data dalam Hash Table ........................... 87

5.2.4. Analisa Pengujian Waktu Pencarian ........................................................ 88

BAB VI KESIMPULAN DAN SARAN .................................................................... 93

6.1. Kesimpulan............................................................................................... 93

6.2. Saran......................................................................................................... 94

DAFTAR PUSTAKA ................................................................................................. 95

LAMPIRAN................................................................................................................ 97


xix

DAFTAR GAMBAR

Gambar 2.1. Komponen Inverted Index ...................................................................... 16

Gambar 2.2. Ilustrasi struktur chained hash table ...................................................... 18

Gambar 2.3. Algoritma PJWHash............................................................................... 20

Gambar 3.1. Diagram Blok Penelitian ........................................................................ 29

Gambar 3.2. Diagram Kelas UML.............................................................................. 30

Gambar 3.3. Flowchart Scanning dan Tokenizing ...................................................... 31

Gambar 3.4. Flowchart Stopword Removal ................................................................ 32

Gambar 3.5. Flowchart Porter Stemmer (Porter, 1980) ............................................. 33

Gambar 3.6. Flowchart Indexing dengan Knuth’s multiplication method .................. 35

Gambar 3.7. Flowchart Indexing dengan Division Method ........................................ 36

Gambar 3.8. Flowchart Searching .............................................................................. 37

Gambar 5.1. Grafik Persebaran Data untuk Division Method dengan ukuran

383 Bucket ................................................................................................ 76

Gambar 5.2. Grafik Persebaran Data untuk Knuth’s Multiplication Method

dengan ukuran 383 Bucket ....................................................................... 77


1531 Bucket .............................................................................................. 78


dengan ukuran 1531 Bucket ..................................................................... 79


xx


6143 Bucket .............................................................................................. 80


dengan ukuran 6143 Bucket ..................................................................... 81


24571 Bucket ............................................................................................ 82


dengan ukuran 24571 Bucket ................................................................... 83

Gambar 5.9. Grafik Perbandingan Waktu Pembentukan Hash Table......................... 86

Gambar 5.10. Grafik Perbandingan Penggunaan Memori .......................................... 87

Gambar 5.15. Grafik Perbandingan Standar Deviasi Persebaran Data dalam

Hash Table ............................................................................................... 88


xxi

DAFTAR TABEL

Tabel 5.1. Hasil Pengukuran Waktu Pembentukan Indeks ......................................... 73

Tabel 5.2. Hasil Pengukuran Jumlah Memori Pembentukan Indeks .......................... 74

Tabel 5.3. Hasil Pengukuran Pengujian Waktu Pencarian pada Hash

Function : Division Method...................................................................... 84

Tabel 5.4. Hasil Pengukuran Pengujian Waktu Pencarian pada Hash

Function : Knuth’s Multiplication Method ............................................... 84

Tabel 5.5. Tabel Persebaran Data kedua Hash Function ............................................ 90


xxii

DAFTAR LISTING

Listing 4.1. Scanning dan Tokenizing ......................................................................... 43

Listing 4.2. Stopword Removal ................................................................................... 44

Listing 4.3. Stemming.................................................................................................. 45

Listing 4.4. Pengindeksan kedalam HashTable .......................................................... 49

Listing 4.4.1. Variabel pencatat waktu pengindeksan ............................................ 50

Listing 4.4.2. Pengecekan status pemanggilan method .......................................... 50

Listing 4.6.3. Penentuan mixing step...................................................................... 51

Listing 4.4.4. Pengubahan Mixing code negatif menjadi positif............................ 51

Listing 4.6.5. Penghitungan Hash code.................................................................. 51

Listing 4.4.6. Pengisian objek koleksi kedalam Hash table................................... 53

Listing 4.4.7. Pencatatan dan perhitungan total waktu pengindeksan.................... 54

Listing 4.5. Penyimpanan hasil indeks........................................................................ 56

Listing 4.6. Pembuatan indeks dari file text ................................................................ 59

Listing 4.7. Penyimpanan LOG HashTable ................................................................ 65

Listing 4.8. PJWHash.................................................................................................. 66

Listing 4.9. Pencarian data koleksi ............................................................................. 71


xxiii

DAFTAR LAMPIRAN

Lampiran 1 Listing PreProcessing .............................................................................. 97

Lampiran 2 Listing IndexingProcess ........................................................................ 100

Lampiran 3 Listing SearchingProcess....................................................................... 108

Lampiran 4 Listing Koleksi ...................................................................................... 110

Lampiran 5 Listing Stemmer .................................................................................... 111

Lampiran 6 Listing PJWHash ................................................................................... 121


1

BAB I

PENGANTAR

1.1. Latar Belakang

Perpustakaan Universitas Sanata Dharma (USD) yang terletak di Yogyakarta

merupakan salah satu Perpustakaan Perguruan Tinggi. Perpustakaan terdiri dari 2

(dua) unit perpustakaan yaitu Perpustakaan USD yang terletak di Mrican dan Paingan

yang dikelola secara sentralisasi. Koleksi yang terdapat dalam Perpustakaan USD

dibagi kedalam beberapa kategori yaitu : koleksi buku, tugas akhir, majalah, artikel

majalah, suara (audio), gambar (image), gambar bergerak (video), dan e-book.

Terdapat lebih dari 350.000 judul koleksi yang siap digunakan pada Perpustakaan

USD. Dalam melakukan pelayanannya, Perpustakaan USD mengunakan sebuah

"sistem terbuka" yang memungkinkan pemustaka untuk dapat memilih dan mencari

sendiri koleksi yang diinginkannya.

Sistem yang digunakan pada hakekatnya bertujuan untuk mempermudah

pencarian koleksi perpustakaan oleh para pemustaka. Sistem pencarian koleksi

Perpustakaan USD sekarang ini memiliki sebuah antar-muka yang nantinya meminta

pengguna untuk terlebih dahulu menentukan jenis koleksi yang ingin ditemukan.

Kemudian koleksi dapat dicari dengan memasukkan satu atau lebih kata kunci. Kata

kunci yang terdapat pada sistem berupa judul buku, pengarang, penerbit, nomor

identitas buku, dan lain sebagainya. Dengan demikian, pemustaka harus memiliki


2

informasi yang memadai mengenai kata kunci yang dibutuhkan. Contohnya, seorang

pemustaka ingin mencari koleksi yang mengandung informasi mengenai

pertumbuhan bakteri, maka pemustaka harus mengetahui kata kunci pencarian yang

dapat dikenal oleh sistem, misalnya kata “mikrobiologi” sebagai kata kunci judul

buku atau kata “Gemilang” sebagai kata kunci penerbit. Jika pemustaka hanya

mengetahui penggalan kalimat yang terdapat pada pustaka tanpa mengetahui kata

kunci yang terdapat pada sistem, maka pemustaka akan kesulitan untuk menemukan

koleksi yang dibutuhkan. Hal ini menjadi keterbatasan sistem pencarian Perpustakaan

USD karena pemustaka harus mengetahui kata kunci yang tepat agar pemustaka

menemukan koleksi yang diinginkan.

Salah satu pendekatan yang dapat digunakan untuk menyelesaikan

permasalahan tersebut adalah dengan menggunakan Information Retrieval System

(Sistem Pemerolehan Informasi). Sebuah Sistem Pemerolehan Informasi

memungkinkan untuk dilakukannya pencarian bukan hanya pada kata kunci (judul,

penerbit, dan lainnya) tertentu melainkan juga pada keseluruhan isi atau teks yang

terdapat dalam pustaka koleksi. Beberapa tahapan dalam pengembangan sebuah

Sistem Pemerolehan Informasi yaitu : pengumpulan data, tokenizing, stemming,

indexing, searching, dan pemodelan hasil pencarian.

Sebagian besar kajian pengembangan sebuah Sistem Pemerolehan Informasi

ditujukan untuk meningkatkan efisiensi dan efektifitas sistem. Dalam hal efisiensi,

kajian lebih ditekankan pada bagaimana melakukan pencarian (retrieval) yang cepat

dan hemat sumberdaya (Rijsbergen, 1979). Salah satu bagian yang memberikan


3

pengaruh besar dalam hal efisiensi Information Retrieval System adalah pada proses

pembuatan index dan pencarian informasi (searching). Menurut (Loudon, 1999),

struktur data yang dapat mengakomodasi kebutuhan dalam pembuatan index dan

pencarian (searching) adalah Hash Table.

Terdapat beberapa permasalahan yang kerap muncul dalam pengembangan

sebuah Hash Table yaitu : menentukan jenis hash table, fungsi hash (hash function)

yang optimal untuk bentuk data tertentu, panjang hash table yang optimal dalam

penggunaan sumber daya memori dan kecepatan akses. Sebuah hash table yang baik

apabila diterapkan kedalam sebuah Information Retrieval System akan mendukung

efisiensi dalam pencarian informasi (Bell, Harries, McKenzie, 1990). Dalam

penelitian ini, penulis akan menganalisa unjuk kerja Knuth’s multiplication method

dan Division Method sebagai hash function pada Chained Hash Table dengan mixing

step PJWHash sebagai proses indexing untuk data berupa data teks koleksi

Perpustakaan Universitas Sanata Dharma yang berupa teks berbahasa Indonesia.

Diharapkan penelitian ini dapat memberikan dukungan positif dalam pengembangan

sebuah mesin Pencarian Koleksi Perpustakaan berbasis Information Retrieval System

yang lebih handal dalam sisi pengindeksan dan pencarian.


4

1.2. Rumusan Masalah

Adapun masalah-masalah yang dapat dirumuskan dalam penelitian ini antara

lain :

1. Bagaimanakah unjuk kerja Knuth’s multiplication method dan Division

method sebagai hash function pada Chained Hash Table dengan mixing step

PJWHash pada data berupa data teks berbahasa Inggris?

1.3. Tujuan Penelitian

Tujuan-tujuan yang ingin dicapai penulis dalam penelitian ini adalah sebagai

berikut :

1. Mengetahui unjuk kerja Knuth’s multiplication method dan Division method

sebagai hash function pada Chained Hash Table dengan mixing step

PJWHash pada data berupa data teks berbahasa Inggris.

1.4. Batasan Permasalahan

Beberapa batasan permasalahan dalam penelitian ini adalah sebagai berikut :

1. Kategori data teks yang akan digunakan yaitu : data e-book.

2. Data teks koleksi Perpustakaan USD yang akan digunakan akan melalui

melalui proses scanning, tokenizing, stemming, dan indexing (inverted

index).

3. Data teks yang akan melalui proses stemming berupa data teks Bahasa

Inggris.


5

4. Pengujian hash table yang akan dilakukan adalah berupa pengujian

persebaran data dalam hash table, penggunaan sumberdaya memori,

processing time (waktu pemrosesan), dan searching time (waktu pencarian).

5. Pengujian sistem pada penelitian dilakukan dengan bahasa pemrograman

Java.

6. Proses stemming dilakukan dengan menggunakan algoritma Porter Stemmer.

1.5. Manfaat Penelitian

Penelitian ini diharapkan dapat membantu pengembangan Sistem Pencarian

Koleksi Perpustakaan USD berbasis Information Retrieval System yang lebih efisien

dalam melakukan proses indexing dan pencarian koleksi.

1.6. Luaran

Luaran yang diharapkan penulis melalui penelitian ini adalah diperolehnya

informasi mengenai unjuk kerja Knuth’s multiplication method dan Division method

sebagai hash function pada Chained Hash Table untuk studi kasus Perpustakaan

Universitas Sanata Dharma.

1.7. Metodologi Penelitian

Metode yang digunakan penulis dalam melaksanakan penelitian ini adalah

Framework for the Application of Sistem Thinking (FAST). Adapun tahapan-tahapan

yang dilakukan dijabarkan sebagai berikut :


6

1. Analisis Ruang Lingkup

Menganalisis ruang lingkup permasalahan baik mengenai sistem sebelumnya

dan solusi yang ditawarkan.

2. Analisis Permasalahan

Melakukan analisis dari permasalahan yang muncul pada sistem

sebelumnya.

3. Perancangan Penelitian

Melakukan perancangan penelitian yang akan dilakukan dan metode

pengujian yang akan diterapkan pada hasil penelitian.

4. Pelaksanaan Penelitian

Melakukan penelitian yang telah dirancang sebelumnya untuk mengetahui

unjuk kerja indexing dan pencarian menggunakan Knuth’s multiplication

method dan Division method sebagai hash function pada chained hash table.

5. Analisis Hasil Penelitian

Melakukan analisis pada hasil yang diperoleh dari penelitian yang telah

dilaksanakan.


7

1.8. Sistematika Penulisan

Sistematika penulisan pada penelitian ini dibagi kedalam beberapa bagian

sebagai berikut :

BAB I : Berisi latar belakang munculnya permasalahan yang akan

diteliti, rumusan permasalahan, tujuan penelitian, batasan

masalah, metodologi penelitian, dan sistematika penulisan.

BAB II : Berisi landasan-landasan teori yang digunakan penulis dalam

penyusunan penulisan penelitian ini.

BAB III : Berisi analisis permasalahan dan perancangan penelitian yang

akan dilaksanakan.

BAB IV : Berisi implementasi sistem pengujian.

BAB V : Berisi hasil dan pembahasan penelitian yang telah

dilaksanakan.

BAB VI : Berisi kesimpulan dan saran dari hasil analisis peneltian.


8

BAB II

LANDASAN TEORI

Pada bagian ini, penulis akan membahas mengenai dasar-dasar teori yang

digunakan dalam penulisan penelitian. Dasar-dasar teori tersebut dapat dipaparkan

sebagai berikut :

2.1. Perpustakaan

Menurut Undang-undang Nomor 43 Tahun 2007 tentang Perpustakaan,

dtuliskan bahwa Perpustakaan adalah institusi pengelola koleksi karya tulis, karya

cetak, dan/atau karya rekam secara profesional dengan sistem yang baku guna

memenuhi kebutuhan pendidikan, penelitian, pelestarian, informasi, dan rekreasi para

pemustaka. Seperti yang diketahui, Perpustakaan dibedakan menjadi : Perpustakaan

Nasional, Umum, Sekolah / Madrasah, Perguruan Tinggi, dan Khusus. Perpustakaan

Sekolah dan Perguruan Tinggi harus mengikuti Standar Nasional Perpustakaan

sebagai acuan penyelenggaraan, pengelolaan, dan pengembangannya (Indonesia,

2007).

2.1.1. Perpustakaan Universitas Sanata Dharma

Perpustakaan Universitas Sanata Dharma merupakan salah satu

Perpustakaan yang cukup berkembang di wilayah Yogyakarta. Perpustakaan terdiri

dari 2 (dua) unit perpustakaan yaitu Perpustakaan Kampus Mrican dan Perpustakaan


9

Kampus Paingan. Kedua Perpustakaan Universitas Sanata Dharma (USD) dikelola

secara sentralisasi. Perpustakaan kampus Mrican merupakan perpustakaan Pusat,

sedangkan Perpustakaan Kampus Paingan merupakan perpustakaan cabang.

Perpustakaan Kampus Paingan berkonsentrai pada pelayanan pengguna bagi civitas

akademika Universitas Sanata Dharma (USD) yang berada di Kampus Paingan.

Sebuah jaringan komputer digunakan untuk menghubungkan Perpustakaan Mrican

dan Paingan agar dapat melayani penggunanya secara online.

2.2. Information Retrieval ( IR )

Sistem Pemerolehan Informasi adalah sebuah sistem yang dapat melakukan

penyimpanan, peneriamaan, dan pemeliharaan informasi. Informasi yang dimaksud

dalam konteks ini dapat terdiri dari teks (termasuk numerik dan data tanggal), citra,

audio, video, dan objek multimedia lainnya (Kowalsky, 1997). Terdapat beberapa

tahap dalam pengembangan sebuah Sistem Pemerolehan Informasi yaitu :

pemotongan setiap kata dari data teks hasil scan (Tokenizing), penghilangan kata

sambung dan lain sebagainya (Stop-word Removal), pengubahan setiap kata kedalam

bentuk dasarnya (Stemming), penataan data guna mempermudah proses pencarian

(Indexing), pencarian kembali koleksi oleh pengguna sistem (Searching), dan

menampilkan hasil pencarian (Modeling). Tahap-tahap yang dilalui sebelum

mencapai tahap Modeling sering disebut Data Preprocessing.


10

2.3. Data Preprocessing

Data preprocessing merupakan tahap awal dalam pengembangan sebuah

Sistem Pemerolehan Informasi. Adapun tahap-tahap yang dikerjakan meliputi :

scanning data, tokenizing, stop-word removal, dan proses stemming.

2.3.1. Tokenizing

Teks dalam bentuk asli nya, berupa rangkaian karakter tanpa

informasi eksplisit mengenai batas-batas kata dan kalimat. Sebelum proses lebih

lanjut dapat diterapkan, teks perlu untuk dipotong ke dalam bentuk kata-kata. Proses

pemotongan ini disebut tokenization atau tokenizing. Hasil pemotongan biasa disebut

sebagai tokens. Tidak hanya kata-kata yang dianggap sebagai tokens, tetapi

juga angka, tanda baca, tanda kurung, tanda kutip, dan lainnya (Schmid, 2008).

Sebagai contoh terdapat sebuah kalimat : Andi bermain bola bersama Koko

di lapangan. Kalimat tersebut apabila dikenakan proses tokenizing maka akan

diperoleh hasil berupa potongan-potongan kata yaitu : Andi; bermain; bola; bersama;

Koko; di; lapangan. Dari hasil proses tokenizing, masih diperlukan beberapa langkah

sebelum data dapat di proses kedalam bentuk index. Langkah berikut setelah data teks

melalui proses tokenizing ini adalah proses stopword removal.

2.3.2. Stopword Removal

Beberapa kata umum yang sering muncul dalam jumlah besar dan tidak

memiliki makna yang berarti dalam sebuah kalimat disebuat sebagai stopword


11

(Manning, Raghavan, Schutze, 2008). Contoh-contoh stopword dalam bahasa Inggris

seperti : is, am, a, at, the, in, on, dan lain sebagainya.

Salah satu strategi umum yang sering digunakan dalam menentukan kata-

kata stopword dalam koleksi kata (dictionary) yang didapatkan adalah dengan

mengurutkan kata-kata pada koleksi berdasarkan collecction frequency yaitu

frekuensi kemunculan kata bersangkutan didalam seluruh koleksi dokumen. Pada

umumnya kata-kata yang termasuk kedalam stopword adalah kata-kata yang memiliki

frekuensi kemunculan tertinggi. Pembuangan stopword ini disebut sebagai proses

stopword removal. Proses stopword removal ini memberikan sedikit banyak

sumbangan kedalam hal efisiensi dalam penyimpanan dan pembuatan index dari

koleksi kata yang didapatkan melalui proses tokenizing (Manning, 2008).

2.3.3. Stemming

Untuk alasan ketatabahasaan dalam sebuah dokumen teks, akan digunakan

berbagai bentuk berbeda dari sebuah kata seperti kata “compute” dapat diubah

kedalam beberapa bentuk lain seperti : “computer”, “computing”, “computation”, dan

lain sebagainya. Dalam tata bahasa Inggris, hal ini dikenal sebagai penambahan

akhiran. Tugas dari proses stemming ini adalah untuk mengubah kembali kata-kata

dalam koleksi yang memiliki imbuhan kedalam bentuk kata dasarnya atau kata unik

yang sudah pasti menggambarkan kata dasarnya. Salah satu algoritma stemming

bahasa Inggris yaitu algoritma Porter Stemmer. Berikut penjelasan mengenai

algoritma stemming Porter Stemmer :


12

1. Langkah 1 : menghilangkan kejamakan kata, akhiran –ed dan –ing

caresses -> caress

ponies -> poni

ties -> ti

caress -> caress

cats -> cat

feed -> feed

agreed -> agree

disabled -> disable

matting -> mat

mating -> mate

meeting -> meet

milling -> mill

messing -> mess

meetings -> meet

2. Langkah 2 : mengubah huruf “y” pada akhir kata menjadi “i” apabila

terdapat huruf vokal didalam kata yang stem.

(m>0) ATIONAL → ATE relational → relate

(m>0) TIONAL → TION conditional → condition

(m>0) ENCI → ENCE valenci → valence

(m>0) ANCI → ANCE hesitanci → hesitance

(m>0) IZER → IZE digitizer → digitize


13

(m>0) ABLI → ABLE conformabli → conformable

(m>0) ALLI → AL radicalli → radical

(m>0) ENTLI → ENT differentli → different

(m>0) ELI → E vileli vile

(m>0) OUSLI → OUS analogousli → analogous

(m>0) IZATION → IZE vietnamization → vietnamize

(m>0) ATION → ATE predication → predicate

(m>0) ATOR → ATE operator → operate

(m>0) ALISM → AL feudalism → feudal

(m>0) IVENESS → IVE decisiveness → decisive

(m>0) FULNESS → FUL hopefulness → hopeful

(m>0) OUSNESS → OUS callousness → callous

(m>0) ALITI → AL formaliti → formal

(m>0) IVITI → IVE sensitiviti → sensitive

(m>0) BILITI → BLE sensibiliti → sensible

3. Langkah 3 : menghilangkan akhiran ganda (double suffix) seperti kata yang

berakhiran –ization (mangandung akhiran –ize dan –ation) diubah misal

menjadi –ize.

(m>0) ICATE → IC triplicate → triplic

(m>0) ATIVE → formative → form

(m>0) ALIZE → AL formalize → formal

(m>0) ICITI → IC electriciti → electric


14

(m>0) ICAL → IC electrical → electric

(m>0) FUL → hopeful → hope

(m>0) NESS → goodness → good

4. Langkah 4 : menangani beberapa imbuhan seperti -ic-, -full, -ness dan

sebagainya.

(m>1) AL → revival → reviv

(m>1) ANCE → allowance → allow

(m>1) ENCE → inference → infer

(m>1) ER → airliner → airlin

(m>1) IC → gyroscopic → gyroscop

(m>1) ABLE → adjustable → adjust

(m>1) IBLE → defensible → defens

(m>1) ANT → irritant → irrit

(m>1) EMENT → replacement → replac

(m>1) MENT → adjustment → adjust

(m>1) ENT → dependent → depend

(m>1 and (*S or *T)) ION → adoption → adopt

(m>1) OU → homologou → homolog

(m>1) ISM → communism → commun

(m>1) ATE → activate → activ

(m>1) ITI → angulariti → angular

(m>1) OUS → homologous → homolog


15

(m>1) IVE → effective → effect

(m>1) IZE → bowdlerize → bowdler

5. Langkah 5 : menghilangkan akhiran seperti -ant, -ence dan sebagainya.

(m>1) E → probate -> probat, rate -> rate

(m=1 and not *o) E → cease → ceas

(m > 1 and *d and *L) → single letter

controll → control

roll → roll

1. Langkah 6 : menghilangkan akhiran terakhir yaitu –e.

Untuk setiap langkah algoritma diatas, terdapat implementasi tertentu yang

dilakukan oleh porter, seperti variabel “m” yang merupakan variabel yang

menandakan jumlah pasangan vokal-konsonan ditengah kata. Contoh :

m=0 TR, EE, TREE, Y, BY.

m=1 TROUBLE, OATS, TREES, IVY.

m=2 TROUBLES, PRIVATE, OATEN, ORRERY.

2.4. Index

Pengindeksan merupakan bagian yang ditujukan untuk mempercepat

pencarian informasi pada sebuah Information Retrieval System. Salah satu bentuk

pengindeksan yang kerap digunakan yaitu inverted index / inverted file (Kowalski,

2011). Bentuk dari struktur inverted index dapat dilihat pada gambar 2.2.


16

Gambar 2.1. Komponen Inverted Index

Sebuah inverted index terdiri dari tiga komponen utama yaitu document file

(data pada hasil proses dokumen), dictionary (kamus yang berisi daftar kata unik

yang didapat), dan inversion list (daftar letak atau posisi terdapatnya kata tersebut)

(Kowalsky, Maybury, 2002).

2.5. Indexing and Searching

Indexing dan Searching merupakan proses yang cukup krusial didalam

sebuah Information Retrieval System dikarenakan kedua hal inilah yang nantinya

akan membawa pengaruh besar pada sisi efisiensi (Borko, 1977). Seperti yang

diketahui, ukuran sebuah index pada Information Retrieval System akan berpengaruh

dalam besarnya sumber daya yang digunakan dan waktu pencarian (retrieval) akan

informasi yang diinginkan. Salah satu struktur data yang dapat mengakomodasi

kebutuhan tersebut adalah struktur data hash table.


17

2.6. Hash Table

Hash table merupakan sebuah struktur data berbentuk array yang

pengaksesan isinya dilakukan melalui sebuah key value (nilai kunci). Gagasan utama

dari stuktur data hash table ini adalah untuk membentuk sebuah pemetaan data dan

posisi data tersebut terletak. Sebuah hash table yang baik akan memiliki persebaran

data yang merata. Hash value yang digunakan untuk mengakses posisi data dalam

array dihasilkan melalui sebuah hash function.

Sebuah hash function yang baik akan dapat memetakan data secara merata

kedalam array yang tersedia. Saat sebuah hash funtion dapat menjamin bahwa tidak

akan dihasilkannya sebuah hash value yang sama, maka akan terbentuk perfect hash

(pemetaan sempurna). Perfect hash merupakan best case (kondisi terbaik) dari sebuah

hash table dimana dimiliki kompleksitas algoritma untuk melakukan pencarian yaitu

O(1). Kompleksitas O(1) berarti bahwa pencarian dapat dilakukan dengan waktu

instant (Loudon, 1999).

Unjuk kerja sebuah hash function juga sangat dipengaruhi oleh bagaimana

bentuk integer data yang dimasukkan. Terutama apabila data input berupa data teks

(string), maka data harus terlebih dahulu melalui process String Processing (Cormen,

1990).

2.6.1. Chained Hash Table

Chained Hash Table merupakan salah satu cara untuk menyelesaikan

masalah collision yang terjadi dalam sebuah hash table. Collision terjadi saat sebuah


18

hash function, memetakan dua atau lebih data dengan sebuah hash value yang sama.

Chained Hash Table memiliki sebuah ide bahwa array statik pada hash table akan

berupa bucket atau array yang didalamnya berisi struktur data linked list. Gagasan ini

dapat mengatasi collision dengan cara, data dengan hash value yang sama, akan

dipetakan kedalam sebuah posisi array namun berada dalam linked list yang berbeda.

Contoh chained hash table dapat dilihat pada gambar 2.3 :

Gambar 2.2. Ilustrasi struktur chained hash table

Dalam sebuah chained hash table dikenal istilah load factor yaitu nilai

harapan jumlah maksimal data pada sebuah posisi dalam hash table (dengan asumsi

terjadi keseragaman pada persebaran data dalam hash table).

Menurut (Kruse, Rybe, 1998) salah satu keuntungan utama penggunaan

chained hash table sebagai solusi collision adalah dapat dihematnya pemakaian

sumberdaya yang dibutuhkan untuk penyimpanan data. Unjuk kerja sebuah chained

hash table juga tidak lepas dari hash function yang digunakan untuk menentukan

hash value-nya.


19

2.6.2. Hash Function

Hash Function adalah suatu fungsi atau aturan yang digunakan untuk

memetakan key value kedalam bentuk hash value sesuai dengan panjang hash table.

Adapun bentuk umum rumus sebuah hash function adalah sebagai berikut (persamaan

(1)) :

Pemilihan hash function yang baik sangat signifikan dalam mempengaruhi

unjuk kerja suatu hash table. Hal ini dikarenakan dengan memilih suatu hash function

yang baik, data-data dapat dipetakan kedalam hash table secara merata sehingga

dapat menghindari terjadinya collision yang terlalu banyak. Contoh hash function

yang sederhana seperti Division method dan Knuth’s multiplication method.

2.6.2.1. Mixing Step

Mixing step merupakan tahap dimana data dalam bentuk String akan diubah

kedalam bentuk data Integer agar dapat diproses ketahap perhitungan hash code.

PJWHash merupakan mixing function yang dikembangkan oleh P.J. Weinberger yang

didalamnya terjadi beberapa proses pergeseran bit dari kode ASCII masing-masing

karakter dari key ( Aho, Sethi, Ullman, 1986).

h (k) = x ......... (1)

keterangan :h = fungsi Hashk = key valuex = hash value


20

Proses pada PJWHash dimulai dengan membuat sebuah variabel h=0. Untuk

setiap karakter dari key, dilakukan pergeseran bit kekiri sebanyak 4 bit kemudian

ditambahkan dengan bit karakter bersangkutan dan disimpan kedalam variabel “h”.

Jika pada 4 bit atas hasil penjumlahan tersebut terdapat bit 1, maka lakukan

pergeseran 4 bit tersebut kekanan sebanyak 24 bit, hasilnya dikenakan operasi XOR

terhadap variabel “h” dan hasilnya disimpan kedalam variabel “h”. Kemudian ubah 4

bit atas pada variabel “h” menjadi bit 0 ( Aho, Sethi, Ullman, 1986).

Algoritma tersebut dapat digambarkan dalam bahasa pemrograman C

sebagai berikut :

Gambar 2.3. Algoritma PJWHash

Pada bahasa pemrograman JAVA tidak terdapat tipe data Unsigned Integer,

sehingga untuk mendapatkan hasil yang sama dengan hasil pada bahasa C,


21

dibutuhkan konversi tipe data kedalam tipe data Long pada bahasa pemrograman

JAVA dimana hasil dari sebuah tipe data Integer akan dikenakan operasi AND

terhadap bit 0xffffffffL yang merupakan bit 1 pada semua 32-bit bawah pada tipe data

Long.

2.6.2.2. Division Method

Prinsip kerja division method adalah dengan mengambil sisa pembagian key

value dengan panjang hash table sebagai hash value. Metode ini merupakan metode

sederhana yang sering digunakan dalam merancang sebuah hash table. adapun

penjabaran dari perhitungan pada metode division method ini adalah sebagai berikut

(persamaan (2)) :

Pemilihan panjang hash table (m) pada division method sebaiknya dilakukan

dengan memilih suatu bilangan prima yang terletak jauh dari bilangan pangkat 2

dengan tetap memperhatikan load factor hash table yang diinginkan (Loudon, 1999).

2.6.2.3. Knuth’s Multiplication Method

Prinsip kerja dari Knuth’s Multiplication Method adalah dengan

mengkalikan key value dengan sebuah konstanta A yang bernilai 0 < A < 1.

h(k) = k mod m ......... (2)

Keterangan :h(k) = hash valuek = key valuem = panjang hash table


22

Kemudian nilai yang didapat akan dikalikan dengan jumlah slot / bucket pada hash

table. Nilai yang menjadi hash value adalah nilai hasil pembulatan kebawah dari hasil

yang didapat pada perhitungan sebelumnya. Nilai A yang sering digunakan adalah

0,618 yang disebut sebagai Golden Ratio. Perhitungan golden ratio dilihat pada

persamaan (3) (Loudon, 1999) :

Penjabaran rumus perhitungan hash value pada Knuth’s multiplication

method dapat dituliskan sebagai berikut (persamaan (4)) :

2.7. Metodologi FAST

Metodologi FAST (Framework for the Application of Sistem Thinking)

merupakan kerangka yang fleksibel untuk menyediakan tipe-tipe berbeda proyek dan

strategi (Whitten, 2004). Adapun tahapan-tahapan yang terdapat dalam FAST adalah

sebagai berikut :

ℎ( ) = ⌊ ( 1 ) ⌋ ......... (4)

Keterangan :h(k) = hash valuem = panjang hash tablek = key valueA = golden ratio

≈ 5− 12 ......... (3)

Keterangan :A = Golden Ratio


23

1. Scope Definition Phase

Pada tahap ini dilakukan pengumpulan informasi yang akan diteliti tingkat

feasibility dan ruang lingkup proyek yaitu dengan menggunakan kerangka

PIECES (Performance, Information, Economics, Control, Efficiency,

Service). Hal ini dilakukan untuk menemukan inti dari masalah-masalah

yang ada (problems), kesempatan untuk meningkatkan kinerja organisasi

(opportunity), dan kebutuhan-kebutuhan baru yang dibebankan oleh

pihak manajemen atau pemerintah (directives).

2. Problem Analysis Phase

Problem Analysis adalah studi untuk memahami sistem yang ada sekarang

dan menganalisa untuk menyediakan informasi kepada tim proyek. Pada

tahap ini akan diteliti masalah-masalah yang muncul pada sistem yang ada

sebelumnya.

3. Requirement Analysis Phase

Tujuan dari tahapan ini adalah mengidentifikasi data, proses dan antarmuka

yang diinginkan pengguna dari sistem yang baru. Alat bantu untuk

memahami kebutuhan yang ada adalah dengan pemodelan use case.

4. Logical Design Phase

Merupakan terjemahan dari kebutuhan pengguna bisnis ke dalam suatu

model sistem. Dengan kata lain pada fase ini akan menjawab pertanyaan-

pertanyaan seputar penggunaan teknologi (data, process, interface) yang


24

menjamin usability, reliability, completeness, performance, dan quality yang

akan dibangun di dalam sistem.

5. Decision Analysis Phase

Pada tahap ini akan akan dipertimbangkan beberapa kandidat dari perangkat

lunak dan keras yang nantinya akan dipilih dan dipakai dalam implementasi

sistem sebagai solusi atas problems dan requirements yang sudah

didefinisikan pada tahapan-tahapan sebelumnya.

6. Physical Design and Integration Phase

Tujuan dari tahapan ini adalah mentransformasikan kebutuhan bisnis yang

direpresentasikan sebagai logical design menjadi physical design yang

nantinya akan dijadikan sebagai acuan dalam membuat sistem yang akan

dikembangkan. Jika di dalam logical design tergantung kepada berbagai

solusi teknis, maka physical design merepresentasikan solusi teknis yang

lebih spesifik.

7. Construction and Testing Phase

Mulai mengkonstruksi dan menguji komponen-komponen sistem untuk

desain. Ada dua tujuan fase ini yaitu :

aMembangun dan menguji sebuah sistem yang memenuhi persyaratan

bisnis dan spesifikasi desain fisik.

b. Mengimplementasikan interface antara sistem yang baru dengan sistem

yang telah ada.


25

8. Installation and Delivery Phase

Kegiatan yang dilakukan pada fase ini adalah instalasi sistem, training user,

manual sistem, mengkonversi file dan database yang ada ke dalam database

yang baru, final testing dan menyiapkan prosedur konversi.


26

BAB III

ANALISIS DESAIN

3.1. Analisis Sistem

Pada bagian ini akan dijelaskan mengenai analisa dari perancangan sistem

penelitian yang akan dilakukan. Adapun perancangan sistem penelitian ini

berdasarkan tahapan metodologi FAST.

3.1.1. Fase Definisi Ruang Lingkup (Scope Definition Phase)

Sistem yang ada saat ini dibangun menggunakan metodologi dan prosedur

perangkat lunak secara terstruktur. Sistem pencarian koleksi adalah sebuah sistem

yang digunakan untuk melakukan pencarian data koleksi berdasarkan keyword yang

diinputkan oleh pengguna dan pengelolaan data oleh administrator serta staff dalam

hal ini petugas di perpustakaan. Pengguna dapat melakukan pencarian (searching)

pada data koleksi yang sudah terkumpul dan terekam pada database perpustakaan.

Sedangkan administrator dapat mengelola data user dengan melakukan login terlebih

dahulu. Akan dibangun sebuah sistem pencarian lebih canggih yang akan

memungkinkan pengguna melakukan pencarian dengan tidak hanya berdasarkan kata

kunci tertentu dan pada kategori tertentu saja. Sistem pencarian koleksi baru yang

akan dibangun akan menerapkan metode Information Retrieval (IR). Pada sistem

pencarian baru yang akan dibangun, muncul permasalahan mengenai efisiensi dan


27

efektifitas pemerolehan informasi. Masalah yang terdapat pada sisi efisiensi adalah

bagaimana membentuk index data koleksi yang efektif dan melakukan pencarian

dengan cepat.

3.1.2. Fase Analisis Masalah (Problem Analysis Phase)

3.1.2.1. Gambaran Sistem Lama

Sistem pencarian yang digunakan saat ini memungkinkan pengguna untuk

melakukan pencarian pada data koleksi Perpustakaan dengan memasukkan query

pada salah satu jenis kata kunci (pengarang, penerbit, judul, dan lainnya) dengan

terlebih dahulu memilih kategori koleksi (buku, majalah, tugas akhir, dan lain

sebagainya). Sistem dibangun menggunakan bahasa pemrograman PHP dan database

SQL. Pencarian data koleksi dilakukan menggunakan query database.

3.1.2.2. Gambaran Sistem Penelitian

Sistem yang dibangun pada penelitian ini adalah sistem yang digunakan

untuk menguji salah satu solusi pembentukan index. Penelitian yang akan dilakukan

ditujukan pada membandingkan unjuk kerja dua buah hash function pada chained

hash table yaitu Knuth’s multiplication method dan Division method. Sistem

pengujian akan dibangun dengan bahasa pemrograman JAVA. Sistem pengujian akan

melakukan pengujian mengenai pemrosesan pembentukan index dan pencarian pada

index. Parameter yang diujikan berupa waktu pembentukan index, sumber daya


28

memori yang digunakan, persebaran data dalam hash table, dan waktu pencarian

yang dibutuhkan untuk menemukan kembali koleksi yang tersimpan.

3.2. Perancangan Penelitian

Berikut akan dipaparkan perancangan sistem pengujian yang akan dibangun

pada penelitian ini.

3.2.1. Data Penelitian

Data yang digunakan penulis dalam penelitian ini berupa sejumlah data E-

book yang diperoleh dari Perpustakaan Universitas Sanata Dharma (USD). Data E-

book yang digunakan berupa 71 buah E-book berbahasa Inggris.

3.2.2. Diagram Blok Penelitian

Pada bagian ini akan dipaparkan diagram blok proses penelitian yang akan

dilakukan. Adapun diagram tersebut sebagai berikut :


29

Gambar 3.1. Diagram Blok Penelitian

Pada proses pencarian koleksi, dapat dilakukan pengujian dengan

memasukkan lebih dari 1 kata pencarian. Proses pencarian yang dilakukan dengan

memasukkan lebih dari 1 kata pencarian adalah proses pencarian dengan operasi

AND yang akan menghasilkan koleksi yang mengandung semua kata pencarian.

3.2.3. Diagram Kelas UML

Pada bagian ini akan dipaparkan kelas-kelas, atribut-atribut beserta method-

method yang dibutuhkan pada pembangunan sistem pengujian penelitian ini.

Diagram kelas UML tersebut dapat dilihat pada gambar 3.2.


30

Gambar 3.2. Diagram Kelas UML

3.2.4. Flowchart Proses

Pada bagian berikut ini akan dijelaskan mengenai alur kerja proses-proses

(method-method) yang terdapat dalam sistem pengujian yang dibangun. Alur kerja

proses-proses tersebut akan digambarkan dengan sebuah flowchart.


31

3.2.4.1. Flowchart Scanning dan Tokenizing

Gambar 3.3. Flowchart Scanning dan Tokenizing


32

3.2.4.2. Flowchart Stopword Removal

Gambar 3.4. Flowchart Stopword Removal


33

3.2.4.3. Flowchart Porter Stemmer

Gambar 3.5. Flowchart Porter Stemmer (Porter, 1980)


34

3.2.4.4. Flowchart Indexing

Terdapat 2 (dua) jenis indexing yang akan diujikan dalam penelitian ini yaitu

indexing menggunakan hash function Knuth’s multiplication method dan Division

method. Gambar 3.11 menunjukkan flowchart proses indexing dengan Knuth’s

multiplication method sebagai hash function dan gambar 3.12 menunjukkan flowchart

proses indexing Division Method sebagai hash function.


35

Gambar 3.6. Flowchart Indexing dengan

Knuth’s multiplication method


36

Gambar 3.7. Flowchart Indexing dengan

Division Method


37

3.2.4.5. Flowchart Searching

Gambar 3.8. Flowchart Searching


38

3.2.5. Skenario Pengujian

Dibawah ini akan dijabarkan lebih lengkap mengenai parameter pengujian

yang akan dilaksanakan dalam penelitian ini. Adapun parameter pengujian tersebut

adalah sebagai berikut :

3.2.5.1. Pengujian Waktu Pemrosesan Index

Pengujian waktu pemrosesan merupakan pengujian yang dilakukan pada saat

pembentukan index. Waktu pemrosesan yang diukur dimulai dari saat sistem mulai

mengambil data pertama dari hasil stemming sampai saat sistem meletakkan data

terakhir. Waktu yang didapat melalui Knuth’s multiplication method dan Division

method akan dibandingkan dan dianalisis.

3.2.5.2. Pengujian Sumberdaya Memori

Pengujian sumberdaya memori merupakan pengujian pada besarnya jumlah

free memory (memori bebas) yang digunakan atau dipakai pada saat pembentukan

Hash table yang bersangkutan. besarnya free memory akan diukur mulai dari saat

pembacaan koleksi Perpustakaan sampai dengan saat Hash table berhasil dibentuk.

Free memory akan ditampilkan dalam bentuk besaran bytes memory.

3.2.5.3. Pengujian Persebaran Data dalam Hash Table

Pengujian persebaran data dalam hash table merupakan pengujian yang

dilakukan pada kondisi index telah terbentuk. Persebaran data dalam hash table akan

dipaparkan dalam bentuk diagram kartesius. Pada diagram kartesius, sumbu (x) akan


39

menampilkan nomor bucket pada hash table dan sumbu (y) akan menampilkan

panjang chain (linked list) yang terbentuk didalam bucket tersebut. Pengujian yang

dilakukan adalah dengan membandingkan dan menganalisis panjang chain terbesar

dan terkecil, rata-rata, varians dan standar deviasi panjang chain.

3.2.5.4. Pengujian Waktu Pencarian Koleksi

Pengujian waktu pencarian merupakan pengujian yang dilakukan pada saat

pengguna memasukkan query. Untuk mengukur waktu pencarian pada hash table

yang terbentuk melalui proses pengindeksan, dibutuh teknik sampling yang akan

menjamin bahwa data yang digunakan pada pencarian sudah mewakili keseluruhan

populasi dan lokasi bucket. Tanpa menggunakan sampling yang tepat, dapat

dihasilkan data pengukuran waktu pencarian yang bias.

Untuk mengetahui lebih lanjut unjuk kerja dalam hal waktu pencarian pada

kedua jenis hash function dapat dilakukan dengan mencatat beberapa informasi

terkait persebaran data-data dalam hash table. Pengukuran yang dilakukan akan

meliputi pencatatan persentase jumlah bucket yang tidak terisi, persentase jumlah

bucket yang terisi, panjang chain maksimum yang terbentuk, panjang chain minimum

yang terbentuk, varians persebaran data, dan standar deviasinya. Kemudian hasil

pengukuran yang diperoleh akan dianalisa.


40

BAB IV

IMPLEMENTASI

Pada bagian ini penulis akan memaparkan proses implementasi sistem

pengujian yang telah dirancang kedalam bahasa yang dapat dimengerti mesin.

Spesifikasi perangkat lunak yang digunakan dalam melakukan implementasi sistem

pengujian adalah sebagai berikut :

1. Sistem operasi : Windows 7 Ultimate Edition

2. Netbeans IDE 6.9.1

4.1. Implementasi Proses

Berikut akan ditampilkan proses implementasi masing-masing proses utama

yang terdapat dalam sistem pengujian antara lain proses Preprocessing, proses

Indexing, dan proses Searching.

4.1.1. Implementasi Preprocessing

Proses Preprocessing ini merupakan proses yang akan mengolah data

mentah yang berupa koleksi-koleksi perpustakaan menjadi data-data yang siap

dipakai didalam tahap Indexing maupun Searching koleksi. Pada proses

Preprocessing ini, terdapat tahapan-tahapan pengolahan data yaitu : tahap Scanning

dan Tokenizing, tahap Stopword Removal, dan tahap Stemming.


41

4.1.1.1. Tahap Scanning dan Tokenizing

Pada tahap ini, data koleksi perpustakaan akan dibaca dan diekstrak data

tulisan kedalam bentuk data String. Data String yang diperoleh masih berupa

kesatuan sekumpulan kata-kata yang terdapat dalam file yang dibaca. Kemudian data

String ini akan dipecah kedalam bentuk Object[ ] (Object Array) dimana setiap posisi

dalam Array tersebut akan diisi dengan 1 buah kata. Proses ini dilaksanakan dengan

memanggil method bacaDocument(String).

public Object[] bacaDocument(String bookSource) {

double timeStart = (double) System.nanoTime();

String inputFile = bookSource;

Object[] dataTextArray = null;

ArrayList<String> dataTextVector = new ArrayList <String>();

try {

reader = new PdfReader(inputFile);

int numberOfPages = reader.getNumberOfPages();

//dimulai pengulangan untuk ektraksi kata pada tiap halaman

String dataText = "";

for (int i = 0; i < numberOfPages; i++) {

dataText = PdfTextExtractor.getTextFromPage(reader, i + 1);

dataText = dataText.replaceAll("[^a-zA-Z0-9]", " ");

dataText = dataText.replaceAll(" ", " ");


42




//tokenizing kata menjadi array

dataTextArray = dataText.split(" ");

for (int j = 0; j < dataTextArray.length; j++) {

dataTextVector.add(dataTextArray[j].toString()); }}

reader.close();

} catch (IOException ex) {

Logger.getLogger(PreProcessing.class.getName()).log(Level.SEVERE, null,

ex); }

//perhitungan waktu pemrosesan ektraksi kata

double timeFinish = (double) System.nanoTime();

double time = ((double) (timeFinish - timeStart)) / 1000000000;

System.out.println("Start time extraction : " + timeStart);

System.out.println("Finish time extraction : " + timeFinish);

System.out.println("Total time use : " + time);

//menampilkan hasil panjang array keseluruhan kata dari semua halaman

System.out.println("Jumlah keseluruhan array kata : " + dataTextVector.size());

//mengembalikan hasil ekstraksi

dataTextArray = dataTextVector.toArray();


43

return dataTextArray; }

Listing 4.1. Scanning dan Tokenizing

4.1.1.2. Tahap Stopword Removal

Pada tahap ini, data hasil Scanning dan Tokenizing yang berbentuk data

Object Array akan dikenai proses penghapusan atau penghilangan kata-kata yang

termasuk kedalam daftar kata “Stopword”. Proses ini dilaksanakan dengan

memanggil method stopwordRemoval(Object [ ]). Kata yang dikenai proses Stopword

Removal ini akan melalui dua tahap pengecekan, yaitu pengecekan terhadap kata

Stopword bahasa Indonesia dan bahasa Inggris. Keluaran method method

stopwordRemoval(Object [ ]) berupa sebuah variabel bertipe Object. Method

stopwordRemoval(Object [ ]) dapat dijabarkan sebagai berikut :

public Object[] stopwordRemoval(Object[] dataEkstraksi) {


String checkedData;

ArrayList<String> hasilStopWordRemoval = new ArrayList<String>();

//permulaan pengecekan dan penghapusan stopwords dengan data hasil Ektraksi

for (int i = 0; i < dataEkstraksi.length; i++) {

checkedData = (String) dataEkstraksi[i];

if (isInStopWordDictionary(checkedData) || checkedData.equals ("") ||

checkedData.length() <= 2 || checkedData.contains(" ")) {


44

} else {

hasilStopWordRemoval.add(checkedData); } }

//perhitungan waktu proses stopwordsRemoval

double timeFinish = (double) System.nanoTime();

double time = ((double) (timeFinish - timeStart)) / 1000000000;

System.out.println("Start time stopword Removal : " + timeStart);

System.out.println("Finish time stopword Removal : " + timeFinish);


//menampilkan jumlah kata setelah stopword removal

System.out.println("Jumlah kata setelah stopword removal : " +

hasilStopWordRemoval.size());

//mengembalikan hasil data array stopword removal

return hasilStopWordRemoval.toArray(); }

Listing 4.2. Stopword Removal

4.1.1.3. Tahap Stemming

Tahap Stemming merupakan proses pencarian kata dasar dari kata-kata yang

diperoleh sebelumnya (tahap Stopword Removal). Proses stemming ini akan mencari

kata dasar untuk kata berbahasa Inggris akan dilakukan dengan menerapkan

algoritma Porter stemmer. Proses Stemming dilaksanakan dengan memanggil method

stemming (Object [ ]). Keluaran method stemming ini berupa sebuah variabel bertipe

Object[ ].


45

public Object[] stemming(Object[] hasilStopwordRemoval) {


char[] sequenceWord;

porterStemmer = new Stemmer();

ArrayList<String> hasilStemming = new ArrayList<String>();

//proses stemming dimulai

String rootWord = "";

for (int i = 0; i < hasilStopwordRemoval.length; i++) {

sequenceWord = ((String) hasilStopwordRemoval[i]).toCharArray();

porterStemmer.add(sequenceWord, sequenceWord.length);

porterStemmer.stem();

rootWord = porterStemmer.toString().toLowerCase();

hasilStemming.add(rootWord); }

Listing 4.3. Stemming

Rincian listing Porter stemmer terlampir pada dokumen ini.

4.1.2. Implementasi Indexing

Setelah data-data diproses melalui tahap-tahap PreProcessing, maka

selanjutnya data akan dibentuk kedalam sebuah Indeks. Pada bagian ini, data-data

hasil stemming akan disusun kedalam HashTable sebagai bentuk struktur data

penyimpanannya. Didalam HashTable terdapat bucket-bucket yang menampung

masing-masing kata yang berbentuk Objek dari kelas Koleksi. Proses ini akan


46

dikerjakan dengan memanggil method startIndexingProcess(Object[ ], String, String,

String, int). Berikut merupakan hasil implementasi method

startIndexingProcess(Object[ ], String, String, String, int).

public void startIndexingProcess(Object[] hasilStemmingIndonesia, String status,

String idBuku, String hashMethod, int mixingStepTipe) {


double timeFinish;

double time;

//pengecekan status pengindeksan apakah permulaan atau sambungan

if (status.equalsIgnoreCase("start")) {

wordCount = 0;

koleksiArrayList = (ArrayList<Koleksi>[])

Array.newInstance(ArrayList.class, jumlahBucket);

for (int i = 0; i < jumlahBucket; i++) {

koleksiArrayList[i] = new ArrayList<Koleksi>(); } }

//mulai meletakkan kedalam hash table perkata

long mixingCode;

String word;

for (int i = 0; i < hasilStemmingIndonesia.length; i++) {

word = ((String) hasilStemmingIndonesia[i]);

mixingCode = 0;


47

mixingCode=MS.PJWHash(word);

//penghilangan angka negatif

mixingCode = Math.abs(mixingCode);

int hashCode;

if (hashMethod.equalsIgnoreCase("division")) {

//division method

hashCode = (int) (mixingCode % this.getJumlahBucket());

//end division method

} else {

//selesai pemotongan

hashCode = (int) (this.getJumlahBucket() * ((mixingCode * knuth) % 1));

//end multiplication method

}

boolean isIdBukuFind = false;

boolean isWordFind = false;

int posisiKataInHashTable = 0;

for (int j = 0; j < this.getKoleksiArrayList()[hashCode].size(); j++) {

if

(this.getKoleksiArrayList()[hashCode].get(j).getKata().equalsIgnoreCase((String)

hasilStemmingIndonesia[i])) {

isWordFind = true;


48

posisiKataInHashTable = j;

for (int k = 0; k <

this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().size(); k++) {

if

(this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().get(k).equalsIgnoreCase(id

Buku)) {

isIdBukuFind = true;

this.getKoleksiArrayList()[hashCode].get(j).getJumlahKataDalamBuku().set(k,

this.getKoleksiArrayList()[hashCode].get(j).getJumlahKataDalamBuku().get(k) + 1);

break; } }

break; } }

if (!isWordFind) {

wordCount++;

Koleksi temp = new Koleksi();

temp.setKata((String) hasilStemmingIndonesia[i]);

temp.getIdBuku().add(idBuku);

temp.getJumlahKataDalamBuku().add(1);

this.getKoleksiArrayList()[hashCode].add(temp);

} else if (!isIdBukuFind) {

koleksiArrayList[hashCode].get(posisiKataInHashTable).getIdBuku().add(idBuku);


49

koleksiArrayList[hashCode].get(posisiKataInHashTable).getJumlahKataDalamBuku(

).add(1); } }

//selesai meletakkan kedalam hash table perkata

// memulai perhitungan waktu Hash

timeFinish = (double) System.nanoTime();

time = ((double) (timeFinish - timeStart)) / 1000000000;

System.out.println("Start time indexing HashTable : " + timeStart);

System.out.println("Finish time indexing HashTable : " + timeFinish);


System.out.println("Total words created in HashTable : " + wordCount); }

Listing 4.4. Pengindeksan kedalam HashTable

Berikut akan dipaparkan lebih jauh mengenai fungsi-fungsi yang dikerjakan

pada method startIndexingProcess(Object[ ], String, String, String, int) ini. Pada awal

method startIndexingProcess(Object[ ], String, String, String, int) terdapat beberapa

variabel yang digunakan untuk mencatat lama waktu yang digunakan pada saat proses

pengindeksan berlangsung. Pada tahap awal akan dilakukan pencatatan waktu mulai

dilakukannya proses pengindeksan (Listing 4.4.1).


50


double timeFinish;

double time;

Listing 4.4.1. Variabel pencatat waktu pengindeksan

Sebelum melakukan proses pengindeksan, akan dilakukan terlebih dahulu

pengecekan terhadap status pemanggilan method startIndexingProcess(Object[ ],

String, String, String, int), hal ini dikarenakan terdapat dua jenis status pemanggilan

yaitu “start” atau “continue”. Apabila satus pemanggilan adalah “start” maka

Hashtable yang digunakan merupakan Hashtable yang baru sedangkan bila tidak,

maka Hashtable yang digunakan merupakan Hashtable sebelumnya (Lisitng 4.4.2).

//pengecekan status pengindeksan apakah permulaan atau sambungan

if (status.equalsIgnoreCase("start")) {

wordCount=0;

koleksiArrayList = (ArrayList<Koleksi>[])

Array.newInstance(ArrayList.class, jumlahBucket);


koleksiArrayList[i] = new ArrayList<Koleksi>(); } }

Listing 4.4.2. Pengecekan status pemanggilan method

Kemudian akan mulai dilakukan pengisian setiap kata kedalam Hashtable

yang telah disediakan. Pada awalnya akan dihitung mixing code dengan mixing step

PJWHash (Listing 4.4.3).


51

mixingCode = 0;


Listing 4.6.3. Penentuan mixing step

Mixing code yang diperoleh dapat berupa nilai negatif yang tidak dapat

digunakan dalam perhitungan menggunakan Hash function sehingga harus diubah

kedalam bentuk positif (Listing 4.4.4).

mixingCode=Math.abs(mixingCode);

Listing 4.4.4. Pengubahan Mixing code negatif menjadi positif

Kemudian tahap selanjutnya adalah menghitung Hash code menggunakan

salah satu dari kedua Hash function yang digunakan dalam penelitian sesuai

parameter yang dimasukkan (Listing 4.4.5).

int hashCode;


//division method

hashCode = (int) (mixingCode % this.getJumlahBucket());


} else {

//multiplication method

hashCode = (int) (this.getJumlahBucket() * ((mixingCode * knuth) % 1));

//end multiplication method }

Listing 4.6.5. Penghitungan Hash code


52

Setelah Hash code diperoleh, maka dilakukan pengisian kata bersangkutan

kedalam Hash table yang disediakan. Kata (word) yang akan dimasukkan dibentuk

kedalam sebuah objek dari kelas Koleksi. Proses ini dapat dilihat pada listing 4.4.6

dibawah ini.

boolean isIdBukuFind = false;

boolean isWordFind = false;

int posisiKataInHashTable = 0;

for (int j = 0; j < this.getKoleksiArrayList()[hashCode].size(); j++) {

if

(this.getKoleksiArrayList()[hashCode].get(j).getKata().equalsIgnoreCase((String)

hasilStemmingIndonesia[i])) {

isWordFind = true;

posisiKataInHashTable = j;

for (int k = 0; k <


if

(this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().get(k).equalsIgnoreCase(id

Buku)) {

isIdBukuFind = true;

this.getKoleksiArrayList()[hashCode].get(j).getJumlahKataDalamBuku().set(k,


53


break; } }

break; } }

if (!isWordFind) {

wordCount++;

Koleksi temp = new Koleksi();

temp.setKata((String) hasilStemmingIndonesia[i]);

temp.getIdBuku().add(idBuku);

temp.getJumlahKataDalamBuku().add(1);

this.getKoleksiArrayList()[hashCode].add(temp);

} else if (!isIdBukuFind) {

koleksiArrayList[hashCode].get(posisiKataInHashTable).getIdBuku().add(idBuku);

koleksiArrayList[hashCode].get(posisiKataInHashTable).getJumlahKataDalamBuku(

).add(1); }

Listing 4.4.6. Pengisian objek koleksi kedalam Hash table

Setelah semua kata (word) telah diisikan kedalam Hash table maka akan

dicatat waktu selesainya proses pengindeksan yang dilakukan dan menampilkan

hasilnya berupa lama pemprosesan (waktu selesai - waktu mulai). Hal ini dapat

dilihat pada Listing 4.4.7.


54



System.out.println("Start time indexing HashTable : " + timeStart);

System.out.println("Finish time indexing HashTable : " + timeFinish);


System.out.println("Total words created in HashTable : " + wordCount);

Listing 4.4.7. Pencatatan dan perhitungan total waktu pengindeksan

Selain melakukan proses pengindeksan, sistem pengujian juga

memungkinkan untuk menyimpan HashTable yang telah terbentuk kedalam bentuk

sebuah file .txt (file text) sebagai bentuk penyimpanan permanen. Proses

penyimpanan ini dilakukan dengan memanggil method saveIndexHashTable(String).

public void saveIndexHashTable(String namaFile) {


double timeFinish;

double time;

FileWriter fw = null;

try {

String lokasiSaveHashTable = workSpace + namaFile;

fw = new FileWriter(lokasiSaveHashTable);

BufferedWriter bw = new BufferedWriter(fw);

bw.write(String.valueOf(getJumlahBucket()));


55

bw.newLine();

for (int i = 0; i < getJumlahBucket(); i++) {

bw.write(String.valueOf(koleksiArrayList[i].size()));

bw.newLine();

for (int j = 0; j < koleksiArrayList[i].size(); j++) {

bw.write(koleksiArrayList[i].get(j).getKata());

bw.newLine();

bw.write(String.valueOf(koleksiArrayList[i].get(j).getIdBuku().size()));

bw.newLine();

for (int k = 0; k < koleksiArrayList[i].get(j).getIdBuku().size(); k++) {

bw.write(koleksiArrayList[i].get(j).getIdBuku().get(k));

bw.newLine();

bw.write(String.valueOf(koleksiArrayList[i].get(j).getJumlahKataDalamBuku().get(k

)));

bw.newLine(); } } }

bw.close();


Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE,

null, ex);

} finally {


56

try {

fw.close();



null, ex); } }



System.out.println("Start time Save HashTable : " + timeStart);

System.out.println("Finish time Save HashTable : " + timeFinish);

System.out.println("Total time use : " + time); }

Listing 4.5. Penyimpanan hasil indeks

Sistem pengujian juga dapat mengambil dan membentuk sebuah indeks

melalui sebuah file .txt (file text). Hal ini dapat dilakukan dengan memanggil method

loadIndexHashTable(String).

public void loadIndexHashTable(String namaFile) {


double timeFinish;

double time;

FileReader fr = null;

wordCount=0;

try {


57

String lokasiLoadHashTable = workSpace + namaFile;

fr = new FileReader(lokasiLoadHashTable);

BufferedReader br = new BufferedReader(fr);

String jumlahBucket = "";

try {

//baca jumlahBucket

jumlahBucket = br.readLine();

this.setJumlahBucket(Integer.parseInt(jumlahBucket));

//selesai baca jumlahBucket

//buat koleksiArrayList baru dari hasil Load sesuai jumlahBucket

setKoleksiArrayList((ArrayList<Koleksi>[])

Array.newInstance(ArrayList.class, this.getJumlahBucket()));

for (int i = 0; i < this.getJumlahBucket(); i++) {

koleksiArrayList[i] = new ArrayList<Koleksi>(); }

//selesai buat koleksiArrayList baru dari hasil Load sesuai jumlahBucket


//baca jumlah Koleksi dari bucket i

String jumlahKoleksi = br.readLine();

//for untuk jumlah Koleksi

for (int j = 0; j < Integer.parseInt(jumlahKoleksi); j++) {

Koleksi koleksi = new Koleksi();


58

wordCount++;

String kata = br.readLine();

koleksi.setKata(kata);

String jumlahKoleksiUntukKata = br.readLine();

for (int k = 0; k < Integer.parseInt(jumlahKoleksiUntukKata); k++) {

String idBuku = br.readLine();

koleksi.getIdBuku().add(idBuku);

String jumlahKataDalamBuku = br.readLine();

koleksi.getJumlahKataDalamBuku().add(Integer.parseInt(jumlahKataDalamBuku));

}

koleksiArrayList[i].add(koleksi); } }



null, ex); }

} catch (FileNotFoundException ex) {


null, ex);

} finally {

try {

fr.close();


59



null, ex); } }



System.out.println("Start time Load HashTable : " + timeStart);

System.out.println("Finish time Load HashTable : " + timeFinish);


System.out.println("Total words loaded in HashTable : " + wordCount); }

Listing 4.6. Pembuatan indeks dari file text

Terdapat juga method untuk melakukan proses penyimpanan LOG dari

indeks HashTable yang telah terbentuk baik melalui proses indexing maupun proses

pembacaan hasil indeks dari sebuah file teks. Method ini akan menyimpan panjang

chain pada tiap bucket didalam HashTable dan menunjukkan statistik persebaran data

didalam HashTable itu sendiri. Proses ini dilaksanakan dengan memanggil method

saveLOGHashTable(String).

public void saveLOGHashTable(String namaFile) {


double timeFinish;

double time;

FileWriter fw = null;


60

try {

String lokasiSaveLOG = getWorkSpace() + namaFile;

fw = new FileWriter(lokasiSaveLOG);

BufferedWriter bw = new BufferedWriter(fw);

int total = 0;

double average = 0;

double standardDeviation = 0;

double varians = 0;

int max = Integer.MIN_VALUE;

int min = Integer.MAX_VALUE;


int ukuranChain = this.getKoleksiArrayList()[i].size();

//menulis kedalam LOG

bw.write(String.valueOf(ukuranChain));

bw.write("\t");

for (int j = 0; j < ukuranChain; j++) {

bw.write("-"); }

bw.newLine();

//selesai menulis kedalam LOG

total = total + ukuranChain;

if (ukuranChain > max) {


61

max = ukuranChain; }

if (ukuranChain < min) {

min = ukuranChain; } }

average = total / jumlahBucket;

//perhitungan standar deviasi

double totalKuadrat = 0;


int ukuranChain = this.getKoleksiArrayList()[i].size();

totalKuadrat = totalKuadrat + (Math.pow((ukuranChain - average), 2));

}

varians = totalKuadrat / jumlahBucket;

standardDeviation = Math.sqrt((totalKuadrat / jumlahBucket));

//selesai perhitungan standar deviasi

bw.newLine();

bw.write("Total Hash Bucket=" + this.getKoleksiArrayList().length);

bw.newLine();

bw.write("Total=" + total);

bw.newLine();

bw.write("Max=" + max);

bw.newLine();

bw.write("Min=" + min);


62

bw.newLine();

bw.write("Average=" + average);

bw.newLine();

bw.write("Varians=" + varians);

bw.newLine();

bw.write("Standar Deviasi=" + standardDeviation);

bw.newLine();

//tambahan

int counterZeroBucket=0;

int

counterSector1=0,counterSector2=0,counterSector3=0,counterSector4=0,counterSect

or5=0;

double sector1=0,sector2=0,sector3=0,sector4=0,sector5=0;

double sizeOfEachSector=((double)max/5);

sector1=(sizeOfEachSector*1);

sector1=Double.parseDouble(String.format("%.5g%n",sector1));







63




for (int i = 0; i < this.getKoleksiArrayList().length; i++) {

if (this.getKoleksiArrayList()[i].size()==0) {

counterZeroBucket++;

}else if (this.getKoleksiArrayList()[i].size()<sector1) {

counterSector1++;


counterSector2++;


counterSector3++;


counterSector4++;

}else if (this.getKoleksiArrayList()[i].size()<=sector5) {

counterSector5++; } }

double

emptyBucket=(double)(((double)counterZeroBucket)/((double)this.getKoleksiArrayL

ist().length))*100;

double filledBucket=(double)((((double)this.getKoleksiArrayList().length)-

((double)counterZeroBucket))/((double)this.getKoleksiArrayList().length))*100;


64

bw.write("Empty Bucket (%) =" + emptyBucket);

bw.newLine();

bw.write("Filled Bucket (%) =" + filledBucket);

bw.newLine();

bw.write("Sector 1 : 0<=x< " + sector1+" ="+counterSector1);

bw.newLine();

bw.write("Sector 2 : "+(sector1-1)+"<x< " + sector2+" ="+counterSector2);

bw.newLine();


bw.newLine();


bw.newLine();

bw.write("Sector 5 : "+(sector4-1)+"<x<= " + sector5+" ="+counterSector5);

bw.newLine();

//tambahan

bw.newLine();

//persiapan data excel


bw.write(String.valueOf(this.getKoleksiArrayList()[i].size()));

bw.newLine(); }

//selesai persiapan data excel


65

bw.close();



null, ex);

} finally {

try {

fw.close();



null, ex); } }



System.out.println("Start time LOG HashTable : " + timeStart);

System.out.println("Finish time LOG HashTable : " + timeFinish);

System.out.println("Total time use : " + time); }

Listing 4.7. Penyimpanan LOG HashTable

Berikut akan ditunjukkan hasil implementasi dari algoritma mixxing step

PJWHash yang digunakan dalam sistem pengujian yang dibangun :

public class MixingStep {

public long PJWHash(String input) {

char[] key = input.toCharArray();


66

long val = 0;

for (int i = 0; i < key.length; i++) {

long tmp;

val = ((val << 4) + (key[i]));

if ((tmp = (val & 0xf0000000)) != 0) {

val = (val ^ (tmp >> 24));

val = (val ^ tmp); } }

val=val& 0xffffffffL;

return val; }}

Listing 4.8. PJWHash

4.1.3. Implementasi Searching

Setelah indeks terbentuk, maka dilanjutkan dengan pengujian pencarian data

koleksi. Pengujian pencarian data koleksi ini dapat dilakukan dengan memanggil

method searchInHashTable(String). Pencarian data koleksi dapat dilakukan dengan

memasukkan parameter berupa 1 kata atau lebih sekaligus. Dengan memasukkan kata

pencarian berjumlah lebih dari 1 kata, maka akan dimunculkan juga hasil pencarian

dengan operasi pencarian AND yang akan mendaftarkan idBuku yang memiliki

semua kata yang digunakan dalam pencarian bersangkutan. Berikut hasil

implementasi dari method searchInHashTable(String).

public void searchInHashTable(String keyWords, String hashMethod, int


67

mixingStepTipe) {

String[] keywordArray = keyWords.split(" ");

Object[] stopwordRemoval = preProcessing.stopwordRemoval(keywordArray);

Object[] stemmingIndonesia = preProcessing.stemming(stopwordRemoval);

String word;

long mixingCode;

ArrayList<Koleksi> andSearch=new ArrayList<Koleksi>();

for (int i = 0; i < stemmingIndonesia.length; i++) {

String keyWord = (String) stemmingIndonesia[i];

MixingStep MS = new MixingStep();

mixingCode = 0;

word = ((String) stemmingIndonesia[i]);

//perhitungan waktu mulai pencarian menggunakan HashTable


double timeFinish=0;

double time;

//perhitungan waktu mulai pencarian menggunakan HashTable


int hashCode;


//division method


68

hashCode = (int) (mixingCode % this.koleksiArrayList.length);


} else {

//multiplication method

hashCode = (int) (this.koleksiArrayList.length * ((mixingCode * knuth) %

1));

//end multiplication method

}

//proses pencarian dengan menggunakan hashCode

boolean isFindInHashTable = false;

ArrayList<Koleksi> bucket = this.getKoleksiArrayList()[hashCode];

for (int j = 0; j < bucket.size(); j++) {

if (bucket.get(j).getKata().equalsIgnoreCase(keyWord)) {


System.out.println("\nBuku yang mengandung keyWord : " + keyWord +

", berhasil ditemukan di " + bucket.get(j).getIdBuku().size() + " koleksi.");

andSearch.add(this.getKoleksiArrayList()[hashCode].get(j));

System.out.println("\nBuku yang mengandung keyWord : " + keyWord +

", berhasil ditemukan : \n");

for (int k = 0; k <


69


String idBuku =

this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().get(k);

int jumlahKataDalamBuku =

this.getKoleksiArrayList()[hashCode].get(j).getJumlahKataDalamBuku().get(k);

isFindInHashTable = true;

System.out.println("ID Buku : " + idBuku + " --- Jumlah kata : " +

jumlahKataDalamBuku); }

isFindInHashTable = true;

break; } }

if (!isFindInHashTable) {


System.out.println("\nBuku yang mengandung keyWord : " + keyWord + ",

gagal ditemukan.");

}

//selesai proses pencarian dengan menggunakan hashCode

}

if (andSearch.size()==stemmingIndonesia.length) {

int positionOfSmallestSumOfBookID=Integer.MAX_VALUE;

for (int i = 0; i < andSearch.size(); i++) {

int sumOfBookID=andSearch.get(i).getIdBuku().size();


70

if (sumOfBookID<=positionOfSmallestSumOfBookID) {

positionOfSmallestSumOfBookID=i; } }

Koleksi temp=new Koleksi();

Koleksi selectedKoleksi=andSearch.get(positionOfSmallestSumOfBookID);

temp.setKata(selectedKoleksi.getKata());

temp.setIdBuku(selectedKoleksi.getIdBuku());

temp.setJumlahKataDalamBuku(selectedKoleksi.getJumlahKataDalamBuku());

andSearch.set(positionOfSmallestSumOfBookID, andSearch.get(0));

andSearch.set(0, temp);

ArrayList<String> listOfBookID=andSearch.get(0).getIdBuku();

boolean find=true;

for (int i = 0; i < listOfBookID.size(); i++) {

find=true;

String idBuku="";

ArrayList<Integer> frek=new ArrayList<Integer>();

idBuku=andSearch.get(0).getIdBuku().get(i);

frek.add(andSearch.get(0).getJumlahKataDalamBuku().get(i));

for (int j = 1; j < andSearch.size(); j++) {

if (!andSearch.get(j).getIdBuku().contains(listOfBookID.get(i))) {

find=false;


71

break;

}else{

int index=andSearch.get(j).getIdBuku().indexOf(listOfBookID.get(i));

frek.add(andSearch.get(j).getJumlahKataDalamBuku().get(index));

} }

if (find) {

System.out.println("Hasil pencarian AND didapat pada koleksi :

"+idBuku+" dengan rincian : ");

for (int j = 0; j < andSearch.size(); j++) {

System.out.println("Kata "+andSearch.get(j).getKata()+" ditemukan

sebanyak : "+frek.get(j)+" buah.");

} } }

}else{

System.out.println("Hasil pencarian AND, tidak berhasil ditemukan.");

} }

Listing 4.9. Pencarian data koleksi


72

BAB V

HASIL PENGUJIAN DAN ANALISA

Pada bagian ini, penulis akan memaparkan hasil dan analisa dari penelitian

yang telah dilakukan. Hasil penelitian yang diperoleh berupa hasil pengukuran

pengujian yang telah dirancang sebelumnya yaitu : Pengujian waktu pemrosesan

Index, Pengujian sumber daya memori, Pengujian persebaran data didalam Hash

table, dan Pengujian waktu pencarian. Pengujian dilaksanakan pada sebuah komputer

dengan spesifikasi :

1. Processor : Intel Core2Duo E7200 @ 2,53GHz

2. Operating System : Windows 7 Ultimate Edition 32-bit

3. Memory : 2GB kit Dual Channel DDR2-800

4. Harddisk : 250GB Sata SEAGATE 7200rpm

5.1. Hasil Pengujian

Dengan memproses data-data E-book ke dalam sistem pengujian yang telah

dibangun, maka diperoleh beberapa jenis hasil pengukuran yang dapat dipaparkan

sebagai berikut.


73

5.1.1. Hasil Pengujian Waktu Pemrosesan Index

Berikut merupakan hasil pengukuran waktu pemrosesan atau pembentukan

indeks berupa Hash Table. Pengukuran waktu didapatkan melalui pencatatan waktu

saat memasuki blok program PreProcessing dan Indexing. Pengukuran waktu

diujikan kepada 4 jenis ukuran Hash Table yaitu 383, 1531, 6143, dan 24571 buckets.

Masing-masing ukuran Hash table yang digunakan merupakan bilangan prima

dengan posisi paling jauh dari perpangkatan 2 ( contoh : 2x ) terdekatnya.

Tabel 5.1. Hasil Pengukuran Waktu Pembentukan Indeks

Hash FunctionUkuran Hash Table

(Bucket)

Waktu

Pembentukan

(Second)

Rerata Waktu

Pembentukan

(Second)

Division

Method

383 218,538

212,9241531 211,422

6143 210,544

24571 211,192

Knuth’s

Multiplication

Method

383 219,072

213,3631531 212,220

6143 211,167

24571 210,993


74

5.1.2. Hasil Pengujian Sumber Daya Memori

Berikut merupakan hasil pengukuran jumlah sumberdaya memori ( RAM )

yang digunakan dalam pembentukan indeks berupa Hash table. Pengukuran jumlah

memori juga diukur mulai dari baris program dimulainya PreProcessing sampai

selesainya Indexing. Ukuran Hash table yang digunakan sama dengan ukuran saat

pengukuran waktu pembentukan indeks.

Tabel 5.2. Hasil Pengukuran Jumlah Memori Pembentukan Indeks

Hash functionUkuran Hash Table

(Bucket)

Pengunaan Memori

(Bytes)

Rerata Penggunaan

Memori

(Bytes)

Division

Method

383 304215

305226,2501531 305431

6143 305533

24571 305726

Knuth’s

Multiplication

Method

383 324007

325310,0001531 324537

6143 324620

24571 328076


75

5.1.3. Hasil Pengujian Persebaran Data dalam Hash Table

Berikut akan ditampilkan hasil pengukuran terhadap persebaran data di

dalam Hash table yang telah terbentuk saat proses Indexing. Grafik persebaran data

akan ditampilkan untuk masing-masing jenis ukuran Hash table bagi kedua jenis

Hash function. Sumbu x akan merepresentasikan jumlah bucket, sedangkan sumbu y

akan merepresentasikan panjang chain di dalam bucket x.

5.1.3.1. Grafik Persebaran Division Method ( 383 Bucket )

Data-data yang diperoleh dari pengukuran persebarannya adalah sebagai

berikut :

Total Hash Bucket=383

Total=174141

Max=523

Min=365

Average=454.0

Varians=459.1357702349869

Standar Deviasi=21.42745365728245


76

Gambar 5.1. Grafik Persebaran Data untuk Division Method dengan

ukuran 383 Bucket

5.1.3.2. Grafik Persebaran Knuth’s Multiplication Method ( 383 Bucket )


berikut :


Total=174141

Max=517

Min=394

Average=454.0

Varians=450.54046997389037


0

100

200

300

400

500

600

1 17 33 49 65 81 97 113

129

145

161

177

193

209

225

241

257

273

289

305

321

337

353

369


77

Gambar 5.2. Grafik Persebaran Data untuk Knuth’s Multiplication

Method dengan ukuran 383 Bucket



berikut :


Total=174141

Max=156

Min=80

Average=113.0

Varians=115.0907903331156


0

100

200

300

400

500

600

1 17 33 49 65 81 97 113

129

145

161

177

193

209

225

241

257

273

289

305

321

337

353

369


78


ukuran 1531 Bucket



berikut :


Total=174141

Max=153

Min=80

Average=113.0

Varians=119.54147615937296


0

20

40

60

80

100

120

140

160

180

1 63 125

187

249

311

373

435

497

559

621

683

745

807

869

931

993

1055

1117

1179

1241

1303

1365

1427

1489


79





berikut :


Total=174141

Max=52

Min=8

Average=28.0

Varians=37.2985511964838


0

20

40

60

80

100

120

140

160

180

1 63 125

187

249

311

373

435

497

559

621

683

745

807

869

931

993

1055

1117

1179

1241

1303

1365

1427

1489


80


ukuran 6143 Bucket



berikut :


Total=174141

Max=49

Min=10

Average=28.0

Varians=30.230343480384178


0

10

20

30

40

50

60

123

847

571

294

911

8614

2316

6018

9721

3423

7126

0828

4530

8233

1935

5637

9340

3042

6745

0447

4149

7852

1554

5256

8959

26


81





berikut :


Total=174141

Max=21

Min=0

Average=7.0

Varians=7.760205119856741


0

10

20

30

40

50

60

123

847

571

294

911

8614

2316

6018

9721

3423

7126

0828

4530

8233

1935

5637

9340

3042

6745

0447

4149

7852

1554

5256

8959

26


82


ukuran 24571 Bucket



berikut :


Total=174141

Max=23

Min=0

Average=7.0

Varians=7.8245085670098895


0

5

10

15

20

25

194

718

9328

3937

8547

3156

7766

2375

6985

1594

6110

407

1135

312

299

1324

514

191

1513

716

083

1702

917

975

1892

119

867

2081

321

759

2270

523

651


83



5.1.4. Hasil Pengujian Waktu Pencarian

Hasil pengukuran waktu pencarian diperoleh melalui pencatatan waktu saat

mulai memasuki perhitungan nilai Mixing code sampai dengan saat kata pencarian

dinyatakan berhasil ditemukan atau tidak. Hasil pengukuran yang didapat merupakan

hasil pengujian pencarian sebanyak 3 kali percobaan dengan jumlah kata yang

berbeda-beda pada jenis dan panjang Hash table yang berbeda pula.. Dibawah ini

merupakan kata-kata pencarian yang diujikan pada tiap percobaan :

1. Information retrieval system

2. Indexing with hash table for fast response of searching algorithms

3. (digunakan kata-kata pada percobaan ke-2 diulang sebanyak 50 kali)

0

5

10

15

20

25

194

718

9328

3937

8547

3156

7766

2375

6985

1594

6110

407

1135

312

299

1324

514

191

1513

716

083

1702

917

975

1892

119

867

2081

321

759

2270

523

651


84

Berikut merupakan hasil pengukuran waktu pencarian koleksi dari semua

Hash table yang telah dibentuk.

Tabel 5.3. Hasil Pengukuran Pengujian Waktu Pencarian pada Hash Function :

Division Method

Ukuran

Hash TablePercobaan 1 (detik) Percobaan 2 (detik) Percobaan 3 (detik)

383 9.084376799E-4 9.34064249E-4 0.0022670964

1531 9.362226801E-4 9.29634159E-4 0.00134765628

6143 9.423990602E-4 9.14977659E-4 0.001301803179

24571 9.446706401E-4 8.65114782E-4 0.0012255131396

Rerata 9.3293252E-04 9.1094771E-04 1.5355172E-03

Tabel 5.4. Hasil Pengukuran Pengujian Waktu Pencarian pada Hash Function :

Knuth’s Multiplication Method

Ukuran

Hash TablePercobaan 1 (detik) Percobaan 2 (detik) Percobaan 3 (detik)

383 9.302807201E-4 9.538864796E-4 0.01725547134

1531 9.4178454E-4 9.464168206E-4 0.00489826128

6143 9.8573804E-4 9.289469799E-4 0.002084532436

24571 9.330537395E-4 9.161983798E-4 0.001406702802

Rerata 9.4771426E-04 9.3636216E-04 6.4112420E-03


85

5.2. Analisa Hasil Pengujian

Pada bagian ini akan dijabarkan hasil analisa penulis terhadap hasil-hasil

yang didapat dari masing-masing aspek yang diujikan.

5.2.1. Analisa Pengujian Waktu Pemrosesan Indeks

Dalam melakukan pengujian pemrosesan indeks ini, beberapa variabel

pengujian telah dikendalikan sedemikian rupa agar tidak turut mempengaruhi waktu

pembentukan indeks. beberapa variabel yang dikendalikan seperti spesifikasi

perangkat keras pelaksanaan pengujian, kondisi mesin saat dilakukannya pengujian,

dan jumlah koleksi Perpustakaan yang digunakan.

Dari hasil pengujian, dapat diketahui bahwa rata-rata waktu yang dibutuhkan

proses pembentukan Indeks menggunakan Division Method sedikit lebih banyak

(212,924 detik) dibandingkan dengan menggunakan Knuth’s Multiplication Method

(213,363 detik). Hal ini berarti bahwa Knuth’s Multiplication Method bekerja dengan

lebih cepat dan lebih efisien (0.205 %) dalam penggunaan sumber daya processor

untuk melakukan perhitungan Hash code. Perbedaan yang sangat kecil ini dapat

disebabkan karena kondisi mesin yang tidak selalu sama dari waktu ke waktu.

Keduanya dapat dikatakan bekerja sama cepat. Hal ini dapat dilihat melalui gambar

5.9 berikut ini :


86

Gambar 5.9. Grafik Perbandingan Waktu Pembentukan Hash Table

5.2.2. Analisa Pengujian Sumber Daya Memori

Hasil pengujian menunjukkan penggunaan memori (RAM) pada proses

pembentukan indeks dengan Knuth’s Multiplication Method ( 325310,000 bytes)

sebagai Hash function lebih banyak dibanding menggunakan Division method (

305226,250 bytes)sebagai Hash function. Keduanya memiliki selisih penggunaan

memori sebesar ( 20083.75 ) yaitu 6.174%. Jika ditinjau dari sisi matematis program,

Knuth’s Multiplication Method menggunakan lebih banyak operasi perhitungan

dibandingkan dengan Division method. Akan tetapi, perbedaan jumlah pembentukan

chain didalam hash table juga turut mempengaruhi penggunaan memori (RAM). Hal

ini dapat dilihat pada gambar 5.10 berikut ini :

206,000

208,000

210,000

212,000

214,000

216,000

218,000

220,000

383 buckets 1531 buckets 6143 buckets 24571 buckets

Wak

tu P

rose

s ( D

etik

)

Jumlah Bucket

division

multiplication


87

Gambar 5.10. Grafik Perbandingan Penggunaan Memori

5.2.3. Analisa Pengujian Persebaran Data dalam Hash Table

Menurut data Hashtable yang terbentuk, pada Hashtable dengan ukuran

1531 dan 24571 didapat hasil standar deviasi yang lebih kecil pada Division method,

sedangkan ukuran 383 dan 6143 Knuth’s multiplication method memiliki standar

deviasi yang lebih kecil. Jika ditinjau dari sisi program, Division method merupakan

Hash function yang lebih sederhana daripada Knuth’s multiplication method, dan

diperkirakan bahwa Knuth’s multiplication method akan memberikan hasil

persebaran data yang lebih baik.

Apabila dilihat dari hasil pengujian persebaran data dalam Hash table pada

grafik 5.1 sampai dengan grafik 5.8, dapat dilihat bahwa Knuth’s multiplication

290000

295000

300000

305000

310000

315000

320000

325000

330000


Jum

lah

Peng

guna

an M

emor

i ( M

Byte

)

Jumlah Bucket

division

multiplication


88

method memiliki persebaran data yang lebih merata dibanding persebaran data pada

Division method. Walaupun Knuth’s multiplication method memiliki persebaran data

yang lebih merata didalam Hash table, kedua metode tersebut memiliki standar

deviasi persebaran data yang hampir sama. Gambar 5.15 dibawah ini akan

menunjukkan perbandingan standar deviasi persebaran data dari kedua metode :

Gambar 5.15. Grafik Perbandingan Standar Deviasi Persebaran Data dalam

Hash Table

5.2.4. Analisa Pengujian Waktu Pencarian

Berdasarkan hasil pengukuran pada tabel 5.5 dan 5.6 untuk percobaan 1 dan

2, Division method membutuhkan rata-rata waktu pencarian sebesar 9.3293252E-04

detik dan 9.1094771E-04 detik, sedangkan Knuth’s multiplication method

membutuhkan waktu sebesar 9.4771426E-04 detik dan 9.3636216E-04 detik. Dengan

0

5

10

15

20

25


Stan

dar D

evia

si

Jumlah Bucket

division

multiplication


89

demikian, terdapat perbedaan masing-masing sebesar sebesar 0.0000147817 detik dan

0.0000254144 detik antara kedua method. Sehingga hal ini dapat diartikan bahwa

Division method lebih cepat sebanyak 1.5597 % dan 2.7142 % dari waktu yang

dibutuhkan Knuth’s multiplication method.

Akan tetapi, untuk hasil pengukuran waktu pencarian pada percobaan 3,

didapatkan perbedaan waktu pencarian yang digunakan keduanya semakin besar.

Untuk percobaan 3 kedua method memiliki perbedaan waktu pencarian mencapai

0.0048757248 detik (76.0496 %). Hal tersebut berarti bahwa semakin besar data yang

digunakan pada pencarian maka semakin besar perbedaan waktu pencarian yang

dibutuhkan oleh kedua method.

Hal ini dapat disebabkan karena letak kata yang dicari berada dalam posisi

chain yang berbeda dalam hash table yang terbentuk menggunakan kedua hash

function. Jadi, terdapat kemungkinan bahwa kata-kata query yang diujikan,

merupakan worst case bagi hash table yang terbentuk menggunakan hash function :

Knuth’s multiplication method dan merupakan best case pada hash table yang

terbentuk menggunakan hash function : Division method. Permasalahan ini muncul

karena pengambilan sample kata query yang mungkin tidak mewakili semua kriteria

koleksi atau dengan kata lain, perlu dilakukan percobaan dengan memasukkan kata

query berupa semua kata yang terdapat dalam hash table dan waktu pencarian yang

dibutuhkan dihitung rata-ratanya.

Terdapat juga faktor lain yang mungkin mempengaruhi waktu pencarian

kedua metode seperti dengan menggunakan data pencarian yang banyak, akan


90

dilakukan lebih banyak perhitungan Hash code pada Knuth’s multiplication method

sehingga menghasilkan waktu pencarian yang lebih lama.

Data-data pencatatan terhadap persebaran data dari hasil pembentukan hash

table dengan menggunakan kedua hash function dapat dilihat sebagai berikut :

Tabel 5.5. Tabel Persebaran Data kedua Hash Function

Hash

FunctionInformation

383

buckets

1531

buckets

6143

buckets

24571

buckets

Division

Method

Max. chain 523 156 52 21

Min. chain 365 80 8 0

Load Factor 454 113 28 7

Varians 459.13577 115.09079 37.29855 7.76020

Standard deviation 21.42745 10.72803 6.10725 2.78571

Empty buckets (%) 0.0 0.0 0.0 0.13837

Filled buckets (%) 100.0 100.0 100.0 99.86162

Knuth’s

Multiplication

Method

Max. chain 517 153 49 23

Min. chain 394 80 10 0

Load Factor 454 113 28 7

Varians 450.54046 119.54147 30.23034 7.82450

Standard deviation 21.22593 10.93350 5.49821 2.79723

Empty buckets (%) 0.0 0.0 0.0 0.14244

Filled buckets (%) 100.0 100.0 100.0 99.85755


91

Dengan asumsi bahwa semakin banyak bucket yang berhasil diisi dan

semakin merata panjang chain yang terbentuk (semakin mengecilnya standar

deviasi), maka semakin cepat pencarian dapat dilakukan. Dapat dilihat pada table 5.5,

bahwa pengukuran Max. chain dan Min. chain untuk ukuran hash table 383, 1531,

dan 6143 buckets, Knuth’s multiplication method memiliki rentang yang lebih kecil

dibandingkan Division method. Akan tetapi pada ukuran hash table 24571 buckets,

Division method memiliki rentang yang lebih kecil untuk pengukuran Max dan Min

chain.

Untuk pengukuran standar deviasi pada ukuran hash table sebesar 383 dan

6143 buckets, Division method memiliki standar deviasi yang lebih besar

dibandingkan dengan Knuth’s multiplication method. Namun untuk ukran hash table

sebesar 1531 dan 24571 buckets, Division method memiliki standar deviasi yang

lebih kecil. Keduanya bisa dikatakan hampir sama karena salah satu hash function

mengungguli hash function lainnya pada ukuran hash table tertentu dana begitu juga

sebaliknya.

Untuk pengukuran persentase jumlah bucket yang terisi dan bucket yang

kosong, dapat dilihat bahwa untuk ukuran hash table sebesar 383, 1531, dan 6143

bucket kedua hash function memiliki hasil yang sama yaitu 0% untuk bucket yang

kosong dan 100% untuk bucket yang terisi. Sedangkan untuk pengukuran pada

ukuran hash table sebesar 24571 buckets, dapat dilihat bahwa persentase jumlah


92

bucket kosong pada Knuth’s multiplication method lebih besar dibandingkan dengan

Division method.


93

BAB VI

KESIMPULAN DAN SARAN

6.1. Kesimpulan

Melalui penelitian yang telah dilakukan, dapat diambil beberapa kesimpulan

sebagai berikut :

1. Division method memiliki waktu proses pembuatan indeks pada Hash table

yang hampir sama dengan Knuth’s multiplication method.

2. Knuth’s multiplication method menggunakan sumber daya memori komputer

yang lebih banyak jika dibandingkan dengan Division method.

3. Persebaran data dalam Hash table lebih merata dengan menggunakan

Knuth’s multiplication method tetapi memiliki standar deviasi yang hampir

sama dengan Division method.

4. Untuk pengukuran waktu pencarian pada hash table, digunakan hasil

pengukuran pola persebaran data pada bucket dan variasi panjang chain yang

terbentuk dengan aturan semakin banyak bucket yang tidak kosong dan

semakin kecil standar deviasi panjang chain, maka semakin cepat sebuah

pencarian data dapat dilakukan. Hasil pengujian dapat dijabarkan sebagai

berikut :


94

a. Knuth’s multiplication method memiliki selisih antara Max. chain dan

Min. chain yang lebih kecil dibandingkan selisih pada Division method

untuk ukuran hash table : 383, 1531, dan 6143 buckets.

b. Kedua hash function memiliki standar deviasi persebaran data yang

hampir sama satu dengan yang lainnya.

c. Division method memiliki persentase jumlah bucket kosong yang lebih

kecil pada ukuran hash table : 24571 buckets dibandingkan dengan

Knuth’s multiplication method.

6.2. Saran

1. Pengembangan pengujian dengan jumlah koleksi yang lebih besar.

2. Membandingkan kinerja kedua metode Hash table dengan Java Hash table.

3. Melakukan pengujian waktu pencarian yang lebih akurat.


95

DAFTAR PUSTAKA

Agusta, L.2009. Perbandingan Algoritma Stemming Porter Dengan Algoritma Nazief

dan Adriani Untuk Stemming Dokumen Teks Bahasa Indonesia. Konferensi

Nasional Sistem dan Informatika 2009. Bali.

Aho, Alfred V., Sethi Ravi, Ullman, Jeffrey D. 1986. Compilers : Priciples,

Techniques, and Tools. Pearson Education. China. page 435-436.

Bobby, A., A. Nazief, dan Mirna Adriani. 1996. Confix Stripping: Approach to

Stemming Algorithm for Bahasa Indonesia. Internal publication. Faculty of

Computer Science, University of Indonesia, Depok.

Borko, Harold. 1977. Toward a Theory of Indexing, information Processing and

Management Vol.13. Pergamon Press. page 355-365

Cormen, Thomas H. 1990. Introduction to Algorithms Second Edition. Massachusetts

Institute of Technology Press. page 201.

Indonesia. Undang-Undang Nomor 43 Tahun 2007 tentang Perpustakaan.

Kowalski, Gerald. 2011. Information Retrieval Architexture and Algorithms. Springer

Science+Business Media. page 29-32.

Kowalski, G.J, Maybury, M.T. 2002. Information Storage and Retrieval Systems :

Theory and Implementation, second edition”. Kluwer Academic Publishers.

page 83.


96

Kruse, Robert L., Ryba, Alexander J. 1998. Data Structures and Program Design in

C++. Prentice Hall. page 406-407.

Loudon, Kyle. 1999. “Mastering Algorithms With C”. O’Reilly Media, Inc. page

153-158.

Manning, Christopher D. Prabhakar Raghavan & Hinrich Schütze. 2008.

“Introduction to Information Retrieval”. Cambridge University Press. page

23-24.

McKenzie, B.J., Harries, R., and Bell, T.C.. 1990.“Selecting a hashing algorithm,”

Software Practice and Experience 20. 209–224.

Porter, M. F. 1980. An Algorithm for Suffix Stripping. Computer Laboratory. Corn

Exchange Street. Cambridge

Rijsbergen, C. J. van. 1979. “Information Retrieval”. Information Retrieval Group.

University of Glasglow. page 6-7.

Schimd.H. 2008. Tokenizing and Part-of-Speech Tagging in Corpus Linguistics : An

International handbook. Walter de Gruyter GmbH & Co. Berlin, Germany.

page 527-552

Yates, Ricardo Baeza & Neto, Berthier Ribeiro. 1992. Modern Information Retrieval

: The Concepts and Technology Behind Search. ACM Press Book.

Whitten, Bentley Dittman. 2004. Sistem Analysis and Design Method 6th Edition,

Irwin/McGraw-Hill, New York.


97

LAMPIRAN

Lampiran 1 Listing PreProcessing

package skripsi;import com.itextpdf.text.pdf.PdfReader;import com.itextpdf.text.pdf.parser.ImageRenderInfo;import com.itextpdf.text.pdf.parser.PdfTextExtractor;import com.itextpdf.text.pdf.parser.TextExtractionStrategy;import com.itextpdf.text.pdf.parser.TextRenderInfo;import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.io.IOException;import java.util.ArrayList;import java.util.Dictionary;import java.util.ArrayList;import java.util.logging.Level;import java.util.logging.Logger;/**** @author Lie_Lianx*/

public class PreProcessing {Hashtable kamusHash;Hashtable kamusStopWordHash;Hashtable kamusStopWordEngHash;PdfReader reader;Stemmer porterStemmer;public PreProcessing() {

//permulaan membaca daftar kata dari kamus .txtdouble timeStart = (double) System.nanoTime();String str;String kamus = "";String[] kamusArray = new String[0];kamusHash = new Hashtable();kamusStopWordHash = new Hashtable();kamusStopWordEngHash = new Hashtable();try {

BufferedReader in = new BufferedReader(new FileReader("G:\\Skripsi\\pustaka\\Stopword n stemming\\kamus.txt"));while ((str = in.readLine()) != null) {

str=str.substring(0, (str.length()-1));kamusHash.put(str, str);

}in.close();

} catch (IOException e) {}try {

BufferedReader in = new BufferedReader(new FileReader("G:\\Skripsi\\pustaka\\Stopword n stemming\\stopword.txt"));while ((str = in.readLine()) != null) {

kamusStopWordHash.put(str, str);}in.close();in.close();

} catch (IOException e) {}

// //permulaan membaca daftar stopwords english dari sebuah .txtString stopwordsEng = "";String[] stopwordsEngArray = new String[0];


98

try {BufferedReader in = new BufferedReader(new FileReader("G:\\Skripsi\\pustaka\\Stopword n

stemming\\stopwordeng.txt"));while ((str = in.readLine()) != null) {

stopwordsEng = str;}stopwordsEngArray = stopwordsEng.split(",");for (int i = 0; i < stopwordsEngArray.length; i++) {

kamusStopWordEngHash.put(stopwordsEngArray[i], stopwordsEngArray[i]);}in.close();

} catch (IOException e) {}double timeFinish = (double) System.nanoTime();double time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time read dictionary : " + timeStart);System.out.println("Finish time read dictionary : " + timeFinish);System.out.println("Total time use : " + time);

}

public Object[] stemming(Object[] hasilStopwordRemoval) {double timeStart = (double) System.nanoTime();char[] sequenceWord;porterStemmer = new Stemmer();ArrayList<String> hasilStemming = new ArrayList<String>();//proses stemming dimulaiString rootWord = "";for (int i = 0; i < hasilStopwordRemoval.length; i++) {

sequenceWord = ((String) hasilStopwordRemoval[i]).toCharArray();porterStemmer.add(sequenceWord, sequenceWord.length);porterStemmer.stem();rootWord = porterStemmer.toString().toLowerCase();

hasilStemming.add(rootWord);}//perhitungan waktu proses stemmingdouble timeFinish = (double) System.nanoTime();double time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time stemming : " + timeStart);System.out.println("Finish time stemming : " + timeFinish);System.out.println("Total time use : " + time);//menampilkan jumlah kata setelah stemmingSystem.out.println("Jumlah kata setelah stemming : " + hasilStemming.size());//mengembalikan hasil data array stemmingreturn hasilStemming.toArray();

}public boolean isInStopWordDictionary(String string) {

string = string.toLowerCase();boolean isInDict = false;String temp = (String) kamusStopWordHash.get(string);if (string.equalsIgnoreCase(temp)) {

isInDict = true;} else {

temp = (String) kamusStopWordEngHash.get(string);if (string.equalsIgnoreCase(temp)) {

isInDict = true; } }return isInDict; }

public boolean isInDictionary(String string) {string = string.toLowerCase();boolean isInDict = false;String temp = (String) kamusHash.get(string);if (string.equalsIgnoreCase(temp)) {

isInDict = true; }return isInDict; }

public Object[] stopwordRemoval(Object[] dataEkstraksi) {


99

double timeStart = (double) System.nanoTime();String checkedData;ArrayList<String> hasilStopWordRemoval = new ArrayList<String>();//permulaan pengecekan dan penghapusan stopwords dengan data hasil Ektraksifor (int i = 0; i < dataEkstraksi.length; i++) {

checkedData = (String) dataEkstraksi[i];if (isInStopWordDictionary(checkedData) || checkedData.equals ("") || checkedData.length() <= 2 ||

checkedData.contains(" ")) {} else {

hasilStopWordRemoval.add(checkedData); } }//perhitungan waktu proses stopwordsRemoval

double timeFinish = (double) System.nanoTime();double time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time stopword Removal : " + timeStart);System.out.println("Finish time stopword Removal : " + timeFinish);System.out.println("Total time use : " + time);//menampilkan jumlah kata setelah stopword removalSystem.out.println("Jumlah kata setelah stopword removal : " + hasilStopWordRemoval.size());//mengembalikan hasil data array stopword removalreturn hasilStopWordRemoval.toArray(); }

public Object[] bacaDocument(String bookSource) {double timeStart = (double) System.nanoTime();String inputFile = bookSource;Object[] dataTextArray = null;ArrayList<String> dataTextVector = new ArrayList<String>();try {

reader = new PdfReader(inputFile);// System.out.println(reader.getNumberOfPages());

int numberOfPages = reader.getNumberOfPages();// System.out.println("page"+numberOfPages);

//dimulai pengulangan untuk ektraksi kata pada tiap halamanString dataText = "";

// for (int i = 0; i < numberOfPages - (numberOfPages - 5); i++) {for (int i = 0; i < numberOfPages; i++) {

//perubahan for menjadi pendek// dataText = dataText.concat(PdfTextExtractor.getTextFromPage(reader, i + 1));

dataText = PdfTextExtractor.getTextFromPage(reader, i + 1);// System.out.println(dataText.length());

dataText = dataText.replaceAll("[^a-zA-Z0-9]", " ");dataText = dataText.replaceAll(" ", " ");dataText = dataText.replaceAll(" ", " ");dataText = dataText.replaceAll(" ", " ");dataText = dataText.replaceAll(" ", " ");

// System.out.println(dataText);//tokenizing kata menjadi arraydataTextArray = dataText.split(" ");

// System.out.println(dataTextArray.length);for (int j = 0; j < dataTextArray.length; j++) {

dataTextArrayList.add(dataTextArray[j].toString()); } }reader.close();

} catch (IOException ex) {Logger.getLogger(PreProcessing.class.getName()).log(Level.SEVERE, null, ex); }

//perhitungan waktu pemrosesan ektraksi katadouble timeFinish = (double) System.nanoTime();double time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time extraction : " + timeStart);System.out.println("Finish time extraction : " + timeFinish);System.out.println("Total time use : " + time);//menampilkan hasil panjang array keseluruhan kata dari semua halamanSystem.out.println("Jumlah keseluruhan array kata : " + dataTextVector.size());//mengembalikan hasil ekstraksidataTextArray = dataTextVector.toArray();return dataTextArray; }

public static void main(String[] args) {


100

PreProcessing preProcess = new PreProcessing();Object[] hasilStopwordRemoval = {"pentingnya"};Object[] hasilStemming = preProcess.stemming(hasilStopwordRemoval);System.out.println(""+(String)hasilStemming[0]); }}

Lampiran 2 Listing IndexingProcess

package skripsi;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;import java.lang.reflect.Array;import java.util.ArrayList;import java.util.logging.Level;import java.util.logging.Logger;import javax.naming.spi.DirectoryManager;import skripsi.Koleksi;/**** @author Lie_Lianx*/

public class IndexingProcess {

private ArrayList<Koleksi>[] koleksiArrayList;private int jumlahBucket;private String workSpace;GeneralHashFunctionLibrary ghfl = new GeneralHashFunctionLibrary();int wordCount;double knuth;public IndexingProcess() {

knuth=((double)(((Math.sqrt(5))) - 1) / 2); }public IndexingProcess(int jumlahBucket) {

this.jumlahBucket = jumlahBucket; }/*** @param jumlahBucket the jumlahBucket to set*/

public void setJumlahBucket(int jumlahBucket) {this.jumlahBucket = jumlahBucket; }

/*** @return the jumlahBucket*/

public int getJumlahBucket() {return jumlahBucket; }

/*** @param koleksiArrayList the koleksiArrayList to set*/

public void setKoleksiArrayList(ArrayList<Koleksi>[] koleksiArrayList) {this.koleksiArrayList = koleksiArrayList; }

/*** @return the koleksiArrayList*/

public ArrayList<Koleksi>[] getKoleksiArrayList() {return koleksiArrayList; }

public static void main(String[] args) {// //comment jika LOAD


101

// PreProcessing preProcess = new PreProcessing();// //comment jika LOAD

IndexingProcess indexingProcess = new IndexingProcess();indexingProcess.setWorkSpace("C:\\Users\\Lie_Lianx\\Desktop\\TA\\finish4\\try1\\");

//// comment jika LOAD//// indexingProcess.setJumlahBucket(193);//// indexingProcess.setJumlahBucket(383);//// indexingProcess.setJumlahBucket(769);//// indexingProcess.setJumlahBucket(1531);//// indexingProcess.setJumlahBucket(3067);//// indexingProcess.setJumlahBucket(6143);//// indexingProcess.setJumlahBucket(12289);//// indexingProcess.setJumlahBucket(24571);//// indexingProcess.setJumlahBucket(49157);//// indexingProcess.setJumlahBucket(98299);//// String hashMethod;// int mixingStepCode;// boolean skip = true;//// //book source// String bookSource = "G:\\Skripsi\\pustaka\\E-Book\\training_ready\\ebook";//// String bookSource = "H:\\ROY BACKUP\\Skripsi\\Stopword_stemming";// //end of book source//// //akses buku didalam folder// File dir = new File(bookSource);// String[] bookName = dir.list();//// System.out.println(bookName.length);// //selesai akses buku didalam folder//// Object[] dataEkstraksi;//// ArrayList<String> dataEkstraksi2;// Object[] hasilStopwordRemoval;// Object[] hasilStemming;//// //memulai perulangan untuk semua mixingStep yang ada// for (int j = 1; j < 5; j++) {// mixingStepCode = j;// //memulai perulangan untuk 2 jenis Hash Function// for (int k = 0; k < 2; k++) {// if (k == 0) {// hashMethod = "division";// } else {// hashMethod = "multiplication";// }////// System.out.println("Total Memory Allowed : " + Runtime.getRuntime().totalMemory());//// System.out.println("Max Memory Allowed : " + Runtime.getRuntime().maxMemory());//// System.out.println("Free Memory before GC : " + Runtime.getRuntime().freeMemory());//// System.gc();//// System.out.println("Free Memory after GC : " + Runtime.getRuntime().freeMemory());//// //mulai menghitung waktu proses dan free memory// double timeStart = (double) System.nanoTime();//// System.gc();// long freeMemoryStart = Runtime.getRuntime().freeMemory();//// //mulai perulangan sebanyak file buku yang ada di dalam folder// //bookCount untuk menghitung jumlah yg merupakan buku di dalam folder source// int bookCount = 0;// for (int i = 0; i < bookName.length; i++) {// if (bookName[i].endsWith(".pdf")) {// bookCount++;


102

// //preprocessing data// System.out.println(i + "-->" + bookSource + "\\" + bookName[i]);// dataEkstraksi = preProcess.bacaDocument(bookSource + "\\" + bookName[i]);//// dataEkstraksi2 = preProcess.bacaDocument2(bookSource + "\\" + bookName[i]);// hasilStopwordRemoval = preProcess.stopwordRemoval(dataEkstraksi);// dataEkstraksi = null;//// for (int l = 0; l < hasilStopwordRemoval.length; l++) {//// System.out.println(hasilStopwordRemoval[l]);//// }// // Object[] hasilStopwordRemoval = {"seseorang"};// hasilStemming = preProcess.stemming(hasilStopwordRemoval);// hasilStopwordRemoval = null;// //selesai preprocessing data//// //mulai proses indexing// String idBuku = "buku " + bookCount;// if (bookCount == 1) {// indexingProcess.startIndexingProcess(hasilStemming, "start", idBuku, hashMethod, mixingStepCode);// } else {// indexingProcess.startIndexingProcess(hasilStemming, "continue", idBuku, hashMethod, mixingStepCode);// }// hasilStemming = null;// //selesai proses indexing// }// }// //selesai perulangan untuk semua buku dalam folder////// //hitung free memory setelah process// long freeMemoryFinish = Runtime.getRuntime().freeMemory();//////// comment jika LOAD//// if (!skip) {//////// //save HashTable// indexingProcess.saveIndexHashTable("HashTableEBooks_" + hashMethod + "_" + mixingStepCode + "_" +indexingProcess.getJumlahBucket() + ".txt");//// //selesai save HashTable

//selingan jika Hash berasal dari LOAD// System.out.println(indexingProcess.getKoleksiArrayList().length);

indexingProcess.loadIndexHashTable("HashTableEBooks_division_1_383.txt");// System.out.println(indexingProcess.getKoleksiArrayList()[0].get(3).getKata());// System.out.println(indexingProcess.getKoleksiArrayList().length);

//selesai selingan jika Hash berasal dari LOAD//// //catat LOG// indexingProcess.saveLOGHashTable("LOGHashTableEBooks_" + hashMethod + "_" + mixingStepCode + "_" +indexingProcess.getJumlahBucket() + ".txt");//// //selesai catat LOG

//proses searchtry {

double timeStart = 0;double timeFinish = 0;double time;boolean cont = true;String searchWord;BufferedReader br = new BufferedReader(new InputStreamReader(System.in));searchingProcess search = new searchingProcess(indexingProcess.getKoleksiArrayList());while (cont) {

System.out.print("\n\nMasukkan kata yang ingin dicari : ");searchWord = br.readLine();if (!searchWord.equalsIgnoreCase("xxx")) {

timeStart = (double) System.nanoTime();search.searchInHashTable(searchWord, "division", 1);


103

timeFinish = (double) System.nanoTime();time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("------------------------------------------------------------------------------------------------------");System.out.println("Start time All Search HashTable : " + timeStart);System.out.println("Finish time All Search HashTable : " + timeFinish);System.out.println("Total time use for All search : " + time);System.out.println("------------------------------------------------------------------------------------------------------");

} else {cont = false;

}System.gc();

}System.gc();

} catch (Exception e) {System.out.println("Error reading Input!!");

}//selesai proses search

// //comment jika LOAD// double timeFinish = (double) System.nanoTime();// double time = ((double) (timeFinish - timeStart)) / 1000000000;// System.out.println("Start time ALL (" + hashMethod + "_" + mixingStepCode + ") : " + timeStart);// System.out.println("Finish time ALL (" + hashMethod + "_" + mixingStepCode + ") : " + timeFinish);// System.out.println("Total time use ALL (" + hashMethod + "_" + mixingStepCode + ") : " + time);////// System.out.println("Max Memory Allowed : " + Runtime.getRuntime().maxMemory());// System.out.println("Free Memory start process : " + freeMemoryStart + " bytes");// System.out.println("Free Memory finish process : " + freeMemoryFinish + " bytes");// System.out.println("Memory used for process : " + ((long) (freeMemoryFinish - freeMemoryStart)) + " bytes");// System.out.println("Free Memory before GC : " + Runtime.getRuntime().freeMemory() + " bytes");// System.gc();// System.out.println("Free Memory after GC : " + Runtime.getRuntime().freeMemory() + " bytes");//////// //untuk skip//// }else{//// skip=false;//// j--;//// }////// //comment jika LOAD// }// if (skip) {// skip = false;// j--;// }// }// //comment jika LOAD

}public void saveIndexHashTable(String namaFile) {

double timeStart = (double) System.nanoTime();double timeFinish;double time;FileWriter fw = null;try {

String lokasiSaveHashTable = getWorkSpace() + namaFile;fw = new FileWriter(lokasiSaveHashTable);BufferedWriter bw = new BufferedWriter(fw);bw.write(String.valueOf(getJumlahBucket()));bw.newLine();for (int i = 0; i < getJumlahBucket(); i++) {

bw.write(String.valueOf(koleksiArrayList[i].size()));bw.newLine();


104

for (int j = 0; j < koleksiArrayList[i].size(); j++) {bw.write(koleksiArrayList[i].get(j).getKata());bw.newLine();bw.write(String.valueOf(koleksiArrayList[i].get(j).getIdBuku().size()));bw.newLine();for (int k = 0; k < koleksiArrayList[i].get(j).getIdBuku().size(); k++) {

bw.write(koleksiArrayList[i].get(j).getIdBuku().get(k));bw.newLine();bw.write(String.valueOf(koleksiArrayList[i].get(j).getJumlahKataDalamBuku().get(k)));bw.newLine(); } } }

bw.close();} catch (IOException ex) {

Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE, null, ex);} finally {

try {fw.close();

} catch (IOException ex) {Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE, null, ex);

} }timeFinish = (double) System.nanoTime();time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time Save HashTable : " + timeStart);System.out.println("Finish time Save HashTable : " + timeFinish);System.out.println("Total time use : " + time); }

public void loadIndexHashTable(String namaFile) {double timeStart = (double) System.nanoTime();double timeFinish;double time;FileReader fr = null;wordCount = 0;try {

String lokasiLoadHashTable = getWorkSpace() + namaFile;fr = new FileReader(lokasiLoadHashTable);BufferedReader br = new BufferedReader(fr);String jumlahBucket = "";try {

//baca jumlahBucketjumlahBucket = br.readLine();this.setJumlahBucket(Integer.parseInt(jumlahBucket));//selesai baca jumlahBucket

//buat koleksiArrayList baru dari hasil Load sesuai jumlahBucketsetKoleksiArrayList((ArrayList<Koleksi>[]) Array.newInstance(ArrayList.class, this.getJumlahBucket()));for (int i = 0; i < this.getJumlahBucket(); i++) {

koleksiArrayList[i] = new ArrayList<Koleksi>();}//selesai buat koleksiArrayList baru dari hasil Load sesuai jumlahBucketfor (int i = 0; i < this.getJumlahBucket(); i++) {

//baca jumlah Koleksi dari bucket iString jumlahKoleksi = br.readLine();//for untuk jumlah Koleksifor (int j = 0; j < Integer.parseInt(jumlahKoleksi); j++) {

Koleksi koleksi = new Koleksi();wordCount++;String kata = br.readLine();koleksi.setKata(kata);String jumlahKoleksiUntukKata = br.readLine();for (int k = 0; k < Integer.parseInt(jumlahKoleksiUntukKata); k++) {

String idBuku = br.readLine();koleksi.getIdBuku().add(idBuku);String jumlahKataDalamBuku = br.readLine();koleksi.getJumlahKataDalamBuku().add(Integer.parseInt(jumlahKataDalamBuku)); }

koleksiArrayList[i].add(koleksi); } }} catch (IOException ex) {


105


try {br.close();

} catch (IOException ex) {Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE, null, ex); }

}} catch (FileNotFoundException ex) {


try {fr.close();

} catch (IOException ex) {Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE, null, ex); }

}timeFinish = (double) System.nanoTime();time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time Load HashTable : " + timeStart);System.out.println("Finish time Load HashTable : " + timeFinish);System.out.println("Total time use : " + time);System.out.println("Total words loaded in HashTable : " + wordCount); }

public void startIndexingProcess(Object[] hasilStemmingIndonesia, String status, String idBuku, String hashMethod, intmixingStepTipe) {

double timeStart = (double) System.nanoTime();double timeFinish;double time;//pengecekan status pengindeksan apakah permulaan atau sambunganif (status.equalsIgnoreCase("start")) {

wordCount = 0;koleksiArrayList = (ArrayList<Koleksi>[]) Array.newInstance(ArrayList.class, jumlahBucket);for (int i = 0; i < jumlahBucket; i++) {

koleksiArrayList[i] = new ArrayList<Koleksi>();} }

//mulai meletakkan kedalam hash table perkatalong mixingCode;String word;for (int i = 0; i < hasilStemmingIndonesia.length; i++) {

word = ((String) hasilStemmingIndonesia[i]);mixingCode = 0;mixingCode=MS.PJWHash(word);//penghilangan angka negatifmixingCode = Math.abs(mixingCode);int hashCode;if (hashMethod.equalsIgnoreCase("division")) {

//division methodhashCode = (int) (mixingCode % this.getJumlahBucket());//end division method

} else {//multiplication methodhashCode = (int) (this.getJumlahBucket() * ((mixingCode * knuth) % 1));//end multiplication method

}boolean isIdBukuFind = false;boolean isWordFind = false;int posisiKataInHashTable = 0;for (int j = 0; j < this.getKoleksiArrayList()[hashCode].size(); j++) {

if (this.getKoleksiArrayList()[hashCode].get(j).getKata().equalsIgnoreCase((String) hasilStemmingIndonesia[i])) {isWordFind = true;posisiKataInHashTable = j;for (int k = 0; k < this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().size(); k++) {

if (this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().get(k).equalsIgnoreCase(idBuku)) {isIdBukuFind = true;this.getKoleksiArrayList()[hashCode].get(j).getJumlahKataDalamBuku().set(k,



106

break; } }break;

} }if (!isWordFind) {

wordCount++;Koleksi temp = new Koleksi();temp.setKata((String) hasilStemmingIndonesia[i]);temp.getIdBuku().add(idBuku);temp.getJumlahKataDalamBuku().add(1);this.getKoleksiArrayList()[hashCode].add(temp);

} else if (!isIdBukuFind) {koleksiArrayList[hashCode].get(posisiKataInHashTable).getIdBuku().add(idBuku);koleksiArrayList[hashCode].get(posisiKataInHashTable).getJumlahKataDalamBuku().add(1);

} }//selesai meletakkan kedalam hash table perkata// memulai perhitungan waktu HashtimeFinish = (double) System.nanoTime();time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time indexing HashTable : " + timeStart);System.out.println("Finish time indexing HashTable : " + timeFinish);System.out.println("Total time use : " + time);System.out.println("Total words created in HashTable : " + wordCount);

}public void saveLOGHashTable(String namaFile) {

double timeStart = (double) System.nanoTime();double timeFinish;double time;FileWriter fw = null;try {

String lokasiSaveLOG = getWorkSpace() + namaFile;fw = new FileWriter(lokasiSaveLOG);BufferedWriter bw = new BufferedWriter(fw);int total = 0;double average = 0;double standardDeviation = 0;double varians = 0;int max = Integer.MIN_VALUE;int min = Integer.MAX_VALUE;for (int i = 0; i < this.getJumlahBucket(); i++) {

int ukuranChain = this.getKoleksiArrayList()[i].size();//menulis kedalam LOGbw.write(String.valueOf(ukuranChain));bw.write("\t");for (int j = 0; j < ukuranChain; j++) {

bw.write("-"); }bw.newLine();//selesai menulis kedalam LOGtotal = total + ukuranChain;if (ukuranChain > max) {

max = ukuranChain; }if (ukuranChain < min) {

min = ukuranChain; } }average = total / jumlahBucket;//perhitungan standar deviasidouble totalKuadrat = 0;for (int i = 0; i < jumlahBucket; i++) {

int ukuranChain = this.getKoleksiArrayList()[i].size();totalKuadrat = totalKuadrat + (Math.pow((ukuranChain - average), 2)); }

varians = totalKuadrat / jumlahBucket;standardDeviation = Math.sqrt((totalKuadrat / jumlahBucket));//selesai perhitungan standar deviasibw.newLine();bw.write("Total Hash Bucket=" + this.getKoleksiArrayList().length);bw.newLine();


107

bw.write("Total=" + total);bw.newLine();bw.write("Max=" + max);bw.newLine();bw.write("Min=" + min);bw.newLine();bw.write("Average=" + average);bw.newLine();bw.write("Varians=" + varians);bw.newLine();bw.write("Standar Deviasi=" + standardDeviation);bw.newLine();

//tambahanint counterZeroBucket=0;int counterSector1=0,counterSector2=0,counterSector3=0,counterSector4=0,counterSector5=0;double sector1=0,sector2=0,sector3=0,sector4=0,sector5=0;double sizeOfEachSector=((double)max/5);sector1=(sizeOfEachSector*1);sector1=Double.parseDouble(String.format("%.5g%n",sector1));sector2=(sizeOfEachSector*2);sector2=Double.parseDouble(String.format("%.5g%n",sector2));sector3=(sizeOfEachSector*3);sector3=Double.parseDouble(String.format("%.5g%n",sector3));sector4=(sizeOfEachSector*4);sector4=Double.parseDouble(String.format("%.5g%n",sector4));sector5=(sizeOfEachSector*5);sector5=Double.parseDouble(String.format("%.5g%n",sector5));for (int i = 0; i < this.getKoleksiArrayList().length; i++) {

if (this.getKoleksiArrayList()[i].size()==0) {counterZeroBucket++;

}else if (this.getKoleksiArrayList()[i].size()<sector1) {counterSector1++;




}else if (this.getKoleksiArrayList()[i].size()<=sector5) {counterSector5++;

} }double emptyBucket=(double)(((double)counterZeroBucket)/((double)this.getKoleksiArrayList().length))*100;double filledBucket=(double)((((double)this.getKoleksiArrayList().length)-

((double)counterZeroBucket))/((double)this.getKoleksiArrayList().length))*100;bw.write("Empty Bucket (%) =" + emptyBucket);bw.newLine();bw.write("Filled Bucket (%) =" + filledBucket);bw.newLine();bw.write("Sector 1 : 0<=x< " + sector1+" ="+counterSector1);bw.newLine();bw.write("Sector 2 : "+(sector1-1)+"<x< " + sector2+" ="+counterSector2);bw.newLine();bw.write("Sector 3 : "+(sector2-1)+"<x< " + sector3+" ="+counterSector3);bw.newLine();bw.write("Sector 4 : "+(sector3-1)+"<x< " + sector4+" ="+counterSector4);bw.newLine();bw.write("Sector 5 : "+(sector4-1)+"<x<= " + sector5+" ="+counterSector5);bw.newLine();//tambahanbw.newLine();//persiapan data excelfor (int i = 0; i < jumlahBucket; i++) {

bw.write(String.valueOf(this.getKoleksiArrayList()[i].size()));bw.newLine(); }


108

//selesai persiapan data excelbw.close();

} catch (IOException ex) {Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE, null, ex);

} finally {try {

fw.close();} catch (IOException ex) {

Logger.getLogger(IndexingProcess.class.getName()).log(Level.SEVERE, null, ex); } }timeFinish = (double) System.nanoTime();time = ((double) (timeFinish - timeStart)) / 1000000000;System.out.println("Start time LOG HashTable : " + timeStart);System.out.println("Finish time LOG HashTable : " + timeFinish);System.out.println("Total time use : " + time); }

/*** @return the workSpace*/

public String getWorkSpace() {return workSpace; }

/*** @param workSpace the workSpace to set*/

public void setWorkSpace(String workSpace) {this.workSpace = workSpace; }}

Lampiran 3 Listing SearchingProcess

/** To change this template, choose Tools | Templates* and open the template in the editor.*/

package skripsi;

import java.util.ArrayList;

/**** @author Lie_Lianx*/

public class searchingProcess {

private ArrayList<Koleksi>[] koleksiArrayList;private PreProcessing preProcessing;double knuth;

public searchingProcess(ArrayList<Koleksi>[] koleksiArrayList) {this.koleksiArrayList = koleksiArrayList;preProcessing = new PreProcessing();knuth=((double)(((Math.sqrt(5))) - 1) / 2);

}

public void searchInHashTable(String keyWords, String hashMethod, int mixingStepTipe) {String[] keywordArray = keyWords.split(" ");Object[] stopwordRemoval = preProcessing.stopwordRemoval(keywordArray);Object[] stemmingIndonesia = preProcessing.stemming(stopwordRemoval);String word;long mixingCode;ArrayList<Koleksi> andSearch=new ArrayList<Koleksi>();for (int i = 0; i < stemmingIndonesia.length; i++) {

String keyWord = (String) stemmingIndonesia[i];MixingStep MS = new MixingStep();


109

mixingCode = 0;word = ((String) stemmingIndonesia[i]);//perhitungan waktu mulai pencarian menggunakan HashTabledouble timeStart = (double) System.nanoTime();double timeFinish=0;double time;//perhitungan waktu mulai pencarian menggunakan HashTablemixingCode=MS.PJWHash(word);int hashCode;if (hashMethod.equalsIgnoreCase("division")) {

//division methodhashCode = (int) (mixingCode % this.koleksiArrayList.length);//end division method

} else {//multiplication methodhashCode = (int) (this.koleksiArrayList.length * ((mixingCode * knuth) % 1));//end multiplication method

}//proses pencarian dengan menggunakan hashCodeboolean isFindInHashTable = false;ArrayList<Koleksi> bucket = this.getKoleksiArrayList()[hashCode];

for (int j = 0; j < bucket.size(); j++) {if (bucket.get(j).getKata().equalsIgnoreCase(keyWord)) {

timeFinish = (double) System.nanoTime();System.out.println("\nBuku yang mengandung keyWord : " + keyWord + ", berhasil ditemukan di " +

bucket.get(j).getIdBuku().size() + " koleksi.");andSearch.add(this.getKoleksiArrayList()[hashCode].get(j));System.out.println("\nBuku yang mengandung keyWord : " + keyWord + ", berhasil ditemukan : \n");for (int k = 0; k < this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().size(); k++) {

String idBuku = this.getKoleksiArrayList()[hashCode].get(j).getIdBuku().get(k);int jumlahKataDalamBuku = this.getKoleksiArrayList()[hashCode].get(j).getJumlahKataDalamBuku().get(k);isFindInHashTable = true;System.out.println("ID Buku : " + idBuku + " --- Jumlah kata : " + jumlahKataDalamBuku);

}isFindInHashTable = true;break;

}}if (!isFindInHashTable) {

timeFinish = (double) System.nanoTime();System.out.println("\nBuku yang mengandung keyWord : " + keyWord + ", gagal ditemukan.");

}//selesai proses pencarian dengan menggunakan hashCode

}if (andSearch.size()==stemmingIndonesia.length) {

int positionOfSmallestSumOfBookID=Integer.MAX_VALUE;for (int i = 0; i < andSearch.size(); i++) {

int sumOfBookID=andSearch.get(i).getIdBuku().size();if (sumOfBookID<=positionOfSmallestSumOfBookID) {

positionOfSmallestSumOfBookID=i;} }

Koleksi temp=new Koleksi();Koleksi selectedKoleksi=andSearch.get(positionOfSmallestSumOfBookID);temp.setKata(selectedKoleksi.getKata());temp.setIdBuku(selectedKoleksi.getIdBuku());temp.setJumlahKataDalamBuku(selectedKoleksi.getJumlahKataDalamBuku());andSearch.set(positionOfSmallestSumOfBookID, andSearch.get(0));andSearch.set(0, temp);ArrayList<String> listOfBookID=andSearch.get(0).getIdBuku();boolean find=true;for (int i = 0; i < listOfBookID.size(); i++) {

find=true;String idBuku="";


110

ArrayList<Integer> frek=new ArrayList<Integer>();idBuku=andSearch.get(0).getIdBuku().get(i);frek.add(andSearch.get(0).getJumlahKataDalamBuku().get(i));for (int j = 1; j < andSearch.size(); j++) {

if (!andSearch.get(j).getIdBuku().contains(listOfBookID.get(i))) {find=false;break;

}else{int index=andSearch.get(j).getIdBuku().indexOf(listOfBookID.get(i));frek.add(andSearch.get(j).getJumlahKataDalamBuku().get(index));

} }if (find) {

System.out.println("Hasil pencarian AND didapat pada koleksi : "+idBuku+" dengan rincian : ");for (int j = 0; j < andSearch.size(); j++) {

System.out.println("Kata "+andSearch.get(j).getKata()+" ditemukan sebanyak : "+frek.get(j)+" buah.");} } }

}else{System.out.println("Hasil pencarian AND, tidak berhasil ditemukan.");

} }

/*** @return the koleksiArrayList*/

public ArrayList<Koleksi>[] getKoleksiArrayList() {return koleksiArrayList;

}

/*** @param koleksiArrayList the koleksiArrayList to set*/

public void setKoleksiArrayList(ArrayList<Koleksi>[] koleksiArrayList) {this.koleksiArrayList = koleksiArrayList;

}}

Lampiran 4 Listing Koleksi

package skripsi;import java.util.ArrayList;/**** @author Lie_Lianx*/

public class Koleksi {private String kata;private ArrayList<String> idBuku;private ArrayList<Integer> jumlahKataDalamBuku;public Koleksi(){

kata="";idBuku=new ArrayList<String>();jumlahKataDalamBuku=new ArrayList<Integer>(); }

/*** @return the kata*/

public String getKata() {return kata; }

/*** @param kata the kata to set*/

public void setKata(String kata) {this.kata = kata; }

/**


111

* @return the idBuku*/

public ArrayList<String> getIdBuku() {return idBuku; }

/*** @param idBuku the idBuku to set*/

public void setIdBuku(ArrayList<String> idBuku) {this.idBuku = idBuku; }

/*** @return the jumlahKataDalamBuku*/

public ArrayList<Integer> getJumlahKataDalamBuku() {return jumlahKataDalamBuku; }

/*** @param jumlahKataDalamBuku the jumlahKataDalamBuku to set*/

public void setJumlahKataDalamBuku(ArrayList<Integer> jumlahKataDalamBuku) {this.jumlahKataDalamBuku = jumlahKataDalamBuku; } }

Lampiran 5 Listing Stemmer

package skripsi;/**** @author Lie_Lianx*/

/*Porter stemmer in Java. The original paper is in

Porter, 1980, An algorithm for suffix stripping, Program, Vol. 14,no. 3, pp 130-137,

See also http://www.tartarus.org/~martin/PorterStemmer

History:

Release 1

Bug 1 (reported by Gonzalo Parra 16/10/99) fixed as marked below.The words 'aed', 'eed', 'oed' leave k at 'a' for step 3, and b[k-1]is then out outside the bounds of b.

Release 2

Similarly,

Bug 2 (reported by Steve Dyrdahl 22/2/00) fixed as marked below.'ion' by itself leaves j = -1 in the test for 'ion' in step 5, andb[j] is then outside the bounds of b.

Release 3

Considerably revised 4/9/00 in the light of many helpful suggestionsfrom Brian Goetz of Quiotix Corporation ([email protected]).

Release 4

*/import java.io.*;


112

/*** Stemmer, implementing the Porter Stemming Algorithm** The Stemmer class transforms a word into its root form. The input* word can be provided a character at time (by calling add()), or at once* by calling one of the various stem(something) methods.*/

class Stemmer {

private char[] b;private int i, /* offset into b */

i_end, /* offset to end of stemmed word */j, k;

private static final int INC = 50;/* unit of size whereby b is increased */

public Stemmer() {b = new char[INC];i = 0;i_end = 0;

}

/*** Add a character to the word being stemmed. When you are finished* adding characters, you can call stem(void) to stem the word.*/

public void add(char ch) {if (i == b.length) {

char[] new_b = new char[i + INC];for (int c = 0; c < i; c++) {

new_b[c] = b[c];}b = new_b;

}b[i++] = ch;

}

/** Adds wLen characters to the word being stemmed contained in a portion* of a char[] array. This is like repeated calls of add(char ch), but* faster.*/

public void add(char[] w, int wLen) {if (i + wLen >= b.length) {

char[] new_b = new char[i + wLen + INC];for (int c = 0; c < i; c++) {

new_b[c] = b[c];}b = new_b;

}for (int c = 0; c < wLen; c++) {

b[i++] = w[c];}

}

/*** After a word has been stemmed, it can be retrieved by toString(),* or a reference to the internal buffer can be retrieved by getResultBuffer* and getResultLength (which is generally more efficient.)*/

public String toString() {return new String(b, 0, i_end);

}

/**


113

* Returns the length of the word resulting from the stemming process.*/

public int getResultLength() {return i_end;

}

/*** Returns a reference to a character buffer containing the results of* the stemming process. You also need to consult getResultLength()* to determine the length of the result.*/

public char[] getResultBuffer() {return b;

}

/* cons(i) is true <=> b[i] is a consonant. */private final boolean cons(int i) {

switch (b[i]) {case 'a':case 'e':case 'i':case 'o':case 'u':

return false;case 'y':

return (i == 0) ? true : !cons(i - 1);default:

return true;}

}

/* m() measures the number of consonant sequences between 0 and j. if c isa consonant sequence and v a vowel sequence, and <..> indicates arbitrarypresence,

<c><v> gives 0<c>vc<v> gives 1<c>vcvc<v> gives 2<c>vcvcvc<v> gives 3....*/

private final int m() {int n = 0;int i = 0;while (true) {

if (i > j) {return n;

}if (!cons(i)) {

break;}i++;

}i++;while (true) {

while (true) {if (i > j) {

return n;}if (cons(i)) {

break;}i++;

}


114

i++;n++;while (true) {

if (i > j) {return n;

}if (!cons(i)) {

break;}i++;

}i++;

}}

/* vowelinstem() is true <=> 0,...j contains a vowel */private final boolean vowelinstem() {

int i;for (i = 0; i <= j; i++) {

if (!cons(i)) {return true;

}}return false;

}

/* doublec(j) is true <=> j,(j-1) contain a double consonant. */private final boolean doublec(int j) {

if (j < 1) {return false;

}if (b[j] != b[j - 1]) {

return false;}return cons(j);

}

/* cvc(i) is true <=> i-2,i-1,i has the form consonant - vowel - consonantand also if the second c is not w,x or y. this is used when trying torestore an e at the end of a short word. e.g.

cav(e), lov(e), hop(e), crim(e), butsnow, box, tray.

*/private final boolean cvc(int i) {

if (i < 2 || !cons(i) || cons(i - 1) || !cons(i - 2)) {return false;

}{

int ch = b[i];if (ch == 'w' || ch == 'x' || ch == 'y') {

return false;}

}return true;

}

private final boolean ends(String s) {int l = s.length();int o = k - l + 1;if (o < 0) {

return false;}


115

for (int i = 0; i < l; i++) {if (b[o + i] != s.charAt(i)) {

return false;}

}j = k - l;return true;

}

/* setto(s) sets (j+1),...k to the characters in the string s, readjustingk. */private final void setto(String s) {

int l = s.length();int o = j + 1;for (int i = 0; i < l; i++) {

b[o + i] = s.charAt(i);}k = j + l;

}

/* r(s) is used further down. */private final void r(String s) {

if (m() > 0) {setto(s);

}}

/* step1() gets rid of plurals and -ed or -ing. e.g.

caresses -> caressponies -> ponities -> ticaress -> caresscats -> cat

feed -> feedagreed -> agreedisabled -> disable

matting -> matmating -> matemeeting -> meetmilling -> millmessing -> mess

meetings -> meet

*/private final void step1() {

if (b[k] == 's') {if (ends("sses")) {

k -= 2;} else if (ends("ies")) {

setto("i");} else if (b[k - 1] != 's') {

k--;}

}if (ends("eed")) {

if (m() > 0) {k--;

}} else if ((ends("ed") || ends("ing")) && vowelinstem()) {

k = j;


116

if (ends("at")) {setto("ate");

} else if (ends("bl")) {setto("ble");

} else if (ends("iz")) {setto("ize");

} else if (doublec(k)) {k--;{

int ch = b[k];if (ch == 'l' || ch == 's' || ch == 'z') {

k++;}

}} else if (m() == 1 && cvc(k)) {

setto("e");}

}}

/* step2() turns terminal y to i when there is another vowel in the stem. */private final void step2() {

if (ends("y") && vowelinstem()) {b[k] = 'i';

}}

/* step3() maps double suffices to single ones. so -ization ( = -ize plus-ation) maps to -ize etc. note that the string before the suffix must givem() > 0. */private final void step3() {

if (k == 0) {return;

} /* For Bug 1 */ switch (b[k - 1]) {case 'a':

if (ends("ational")) {r("ate");break;

}if (ends("tional")) {

r("tion");break;

}break;

case 'c':if (ends("enci")) {

r("ence");break;

}if (ends("anci")) {

r("ance");break;

}break;

case 'e':if (ends("izer")) {

r("ize");break;

}break;

case 'l':if (ends("bli")) {

r("ble");break;


117

}if (ends("alli")) {

r("al");break;

}if (ends("entli")) {

r("ent");break;

}if (ends("eli")) {

r("e");break;

}if (ends("ousli")) {

r("ous");break;

}break;

case 'o':if (ends("ization")) {

r("ize");break;

}if (ends("ation")) {

r("ate");break;

}if (ends("ator")) {

r("ate");break;

}break;

case 's':if (ends("alism")) {

r("al");break;

}if (ends("iveness")) {

r("ive");break;

}if (ends("fulness")) {

r("ful");break;

}if (ends("ousness")) {

r("ous");break;

}break;

case 't':if (ends("aliti")) {

r("al");break;

}if (ends("iviti")) {

r("ive");break;

}if (ends("biliti")) {

r("ble");break;

}break;


118

case 'g':if (ends("logi")) {

r("log");break;

}}

}

/* step4() deals with -ic-, -full, -ness etc. similar strategy to step3. */private final void step4() {

switch (b[k]) {case 'e':

if (ends("icate")) {r("ic");break;

}if (ends("ative")) {

r("");break;

}if (ends("alize")) {

r("al");break;

}break;

case 'i':if (ends("iciti")) {

r("ic");break;

}break;

case 'l':if (ends("ical")) {

r("ic");break;

}if (ends("ful")) {

r("");break;

}break;

case 's':if (ends("ness")) {

r("");break;

}break;

}}

/* step5() takes off -ant, -ence etc., in context <c>vcvc<v>. */private final void step5() {

if (k == 0) {return;

} /* for Bug 1 */ switch (b[k - 1]) {case 'a':

if (ends("al")) {break;

}return;

case 'c':if (ends("ance")) {

break;}


119

if (ends("ence")) {break;

}return;

case 'e':if (ends("er")) {

break;}return;

case 'i':if (ends("ic")) {

break;}return;

case 'l':if (ends("able")) {

break;}if (ends("ible")) {

break;}return;

case 'n':if (ends("ant")) {

break;}if (ends("ement")) {

break;}if (ends("ment")) {

break;}/* element etc. not stripped before the m */if (ends("ent")) {

break;}return;

case 'o':if (ends("ion") && j >= 0 && (b[j] == 's' || b[j] == 't')) {

break;}/* j >= 0 fixes Bug 2 */if (ends("ou")) {

break;}return;

/* takes care of -ous */case 's':

if (ends("ism")) {break;

}return;

case 't':if (ends("ate")) {

break;}if (ends("iti")) {

break;}return;

case 'u':if (ends("ous")) {

break;}


120

return;case 'v':

if (ends("ive")) {break;

}return;

case 'z':if (ends("ize")) {

break;}return;

default:return;

}if (m() > 1) {

k = j;}

}

/* step6() removes a final -e if m() > 1. */private final void step6() {

j = k;if (b[k] == 'e') {

int a = m();if (a > 1 || a == 1 && !cvc(k - 1)) {

k--;}

}if (b[k] == 'l' && doublec(k) && m() > 1) {

k--;}

}

/** Stem the word placed into the Stemmer buffer through calls to add().* Returns true if the stemming process resulted in a word different* from the input. You can retrieve the result with* getResultLength()/getResultBuffer() or toString().*/

public void stem() {k = i - 1;if (k > 1) {

step1();step2();step3();step4();step5();step6();

}i_end = k + 1;i = 0;

}

/** Test program for demonstrating the Stemmer. It reads text from a* a list of files, stems each word, and writes the result to standard* output. Note that the word stemmed is expected to be in lower case:* forcing lower case must be done outside the Stemmer class.* Usage: Stemmer file-name file-name ...*/

public static void main(String[] args) {char[] w = new char[501];Stemmer s = new Stemmer();for (int i = 0; i < args.length; i++) {

try {FileInputStream in = new FileInputStream(args[i]);


121

try {while (true) {

int ch = in.read();if (Character.isLetter((char) ch)) {

int j = 0;while (true) {

ch = Character.toLowerCase((char) ch);w[j] = (char) ch;if (j < 500) {

j++;}ch = in.read();if (!Character.isLetter((char) ch)) {

/* to test add(char ch) */for (int c = 0; c < j; c++) {

s.add(w[c]);}

/* or, to test add(char[] w, int j) *//* s.add(w, j); */

s.stem();{

String u;

/* and now, to test toString() : */u = s.toString();

/* to test getResultBuffer(), getResultLength() : *//* u = new String(s.getResultBuffer(), 0, s.getResultLength()); */

System.out.print(u);}break;

}}

}if (ch < 0) {

break;}System.out.print((char) ch);

}} catch (IOException e) {

System.out.println("error reading " + args[i]);break;

}} catch (FileNotFoundException e) {

System.out.println("file " + args[i] + " not found");break; } } }}

Lampiran 6 Listing PJWHash

/** To change this template, choose Tools | Templates* and open the template in the editor.*/

package skripsi;

/***


122

* @author Lie_Lianx*/

public class MixingStep {

public long PJWHash(String input) {char[] key = input.toCharArray();long val = 0;

for (int i = 0; i < key.length; i++) {long tmp;val = ((val << 4) + (key[i]));if ((tmp = (val & 0xf0000000)) != 0) {

val = (val ^ (tmp >> 24));val = (val ^ tmp);

}

}val=val& 0xffffffffL;return val;

}}


indeks dan pencarian chained hash table pada - PLAGIAT ...

Documents

Transcript of indeks dan pencarian chained hash table pada - PLAGIAT ...