Inverted index adalah indeks yang terbentuk dari proses pengindeksan. Secara umum strukturnya sebagai berikut:

Dapat dilihat tabel sebelah kiri adalah “dokumen” atau teks yang akan diindeks. Sedangkan sebelah kanan adalah hasil pengindeksan. Jadi term (sederhananya: kata) yang ada pada dokumen menunjuk ke ID dokumen yang mengandung term tersebut.

Secara intuitif, indeks seperti ini mirip dengan indeks pada buku. Pada buku yang cukup tebal sering dijumpai halaman “Indeks” yang cara kerjanya sama dengan inverted index seperti ini. Lebih lengkap mengenai inverted index silakan baca buku Introduction to Information Retrieval.

Untuk membangun indeks seperti ini dengan database relasional (misalnya MySQL), perlu dibuat tabel yang merepresentasikan struktur indeks ini. Pada posting sebelumnya saya membuat struktur tabel indeks, namun rasanya itu kurang efisien, sehingga struktur tabel indeks harus diubah. Tabel “index” yang lama hanya menjadi tabel sementara dalam proses pengindeksan. Sedangkan tabel indeks yang sebenarnya diubah menjadi berikut, beserta contoh isinya:

Jadi daftar dokumen yang mengandung term tertentu disimpan sebagai string dalam kolom posting_list, begitu pula frekuensi term pada dokumen (freq_list).

Untuk membentuk indeks seperti itu dalam database, saya membaginya menjadi dua fase sebagai berikut:

Fase I (pembangunan indeks sementara)

1. Baca seluruh teks dari dokumen
2. Untuk setiap dokumen yang dibaca:
   1. Lakukan tokenisasi atau ekstraksi term dari teks dokumen
   2. Hitung frekuensi setiap term dalam dokumen
   3. Untuk setiap term yang didapat, masukkan ke tabel indeks sementara (term, ID dokumen, frekuensi term)
3. Selesai, indeks sementara terbentuk

Fase II (pembangunan indeks)

1. Baca seluruh term unik dari tabel indeks sementara
2. Untuk setiap term:
   1. Baca daftar ID dokumen yang mengandung term tersebut (dari tabel indeks sementara)
   2. Selain ID, baca frekuensi term dalam dokumen dan jumlah dokumen yang mengandung term
   3. Gabungkan daftar ID dokumen dengan koma, inilah posting_list
   4. Gabungkan daftar frekuensi term dengan koma, inilah freq_list
   5. Masukkan dalam tabel indeks yang sesungguhnya (term, jumlah dokumen, ID dokumen, frekuensi term)
3. Selesai, indeks terbentuk
4. Hapus tabel indeks sementara

Dengan langkah-langkah di atas, maka akan terbentuk inverted index seperti ilustrasi yang dibuat. Implementasi saya dengan PHP dan term berupa trigram dapat dilihat pada repositori kode.

Mengenai cara pencarian dengan struktur indeks seperti ini, Insya Allah akan dibahas kemudian.

Sederhana, hanya untuk menyimpan informasi tentang dokumen dan untuk indeks nantinya. Skema ini diimplementasikan pada DBMS MySQL.

Sejauh ini yang sudah dilakukan adalah mengisi tabel surah dan sebagian tabel doc. Tabel doc baru diisi pada field id, surat, ayat, dan teks, sedangkan kode fonetiknya belum diisikan karena prosedur pengodeannya belum diimplementasikan. Sedangkan tabel index dan trigram akan diisi pada saat proses pengindeksan nantinya.

Selain itu, telah dibuat repository kode program di Google Project Hosting + SVN. Belum banyak kode yang dibuat. Repository dapat dilihat pada alamat http://code.google.com/p/pencarian-fonetik-quran/.

• Cara membaca Al-Quran (tajwid)
• Kesalahan umum cara pelafalan Al-Quran

Berikut langkah-langkahnya yang harus dilakukan secara berurutan.

Dengan prosedur di atas, misalkan untuk ayat Al-Quran berikut (Surah Al-Qadr ayat 4) :

تَنَزَّلُ الْمَلَائِكَةُ وَالرُّوحُ فِيهَا بِإِذْنِ رَبِّهِم مِّن كُلِّ أَمْرٍ

Maka akan diubah menjadi kode berikut :

TNZLLMLXKTWRHFHBXDNRBHMNKLXMR

Namun prosedur ini masih memiliki kekurangan, di antaranya karena tidak memperhitungkan tanda waqaf sehingga beberapa hukum bacaan saat waqaf tidak dapat ditangani. Kelemahan lain adalah tidak semua hukum tajwid tingkat lanjut dapat ditangani, di antaranya idgham mutaqarribain, dan idgham mutajanisain.

Dengan demikian, langkah selanjutnya adalah implementasi prosedur ini dalam bahasa pemrograman. Semoga dimudahkan. Bila ada masukan silakan mengisikan pada kolom komentar.

Angell et al. 1983

Pengolahan string untuk teks non-ASCII seperti tulisan Arab tidak dapat dilakukan seperti biasa di PHP. String demikian (karakter Unicode) termasuk multybite string, sehingga perlu penanganan khusus. Bila menggunakan fungsi string biasa di PHP, maka hasilnya akan muncul karakter-karakter aneh.

Untungnya di PHP ada pustaka fungsi untuk string multibyte. Misalnya fungsi mb_strlen sebagai pengganti fungsi strlen. Langsung saja, berikut potongan kode untuk memecah string Arabic menjadi array dari karakter-karakternya. Harap diketahui bahwa tanda harakat juga dihitung satu karakter. Ini terkait posting saya sebelumnya.

<?php

$ar_string = "صِرَاطَ الَّذِينَ أَنْعَمْتَ عَلَيْهِمْ غَيْرِ الْمَغْضُوبِ عَلَيْهِمْ وَلَا الضَّالِّينَ";

$ar_array = array();
$len = mb_strlen($ar_string, 'UTF-8');

for($i = 0; $i < $len; $i++){
    $ar_array[] = mb_substr($ar_string, $i, 1, 'UTF-8');
}

print_r($ar_array);

?>

Dan bila dijalankan, maka akan sesuai harapan, yaitu string dipecah menjadi array dari karakter-karakternya.

Array
(
    [0] => ص
    [1] => ِ
    [2] => ر
    [3] => َ
    [4] => ا
    [5] => ط
    [6] => َ
    [7] =>
    [8] => ا
    [9] => ل
    [10] => ّ
    [11] => َ
    [12] => ذ
    [13] => ِ
    [14] => ي
    [15] => ن
    [16] => َ
    [17] =>
    [18] => أ
    [19] => َ
    [20] => ن
    [21] => ْ
    [22] => ع
    [23] => َ
    [24] => م
    [25] => ْ
    [26] => ت
    [27] => َ
    [28] =>
    [29] => ع
    [30] => َ
    [31] => ل
    [32] => َ
    [33] => ي
    [34] => ْ
    [35] => ه
    [36] => ِ
    [37] => م
    [38] => ْ
    [39] =>
    [40] => غ
    [41] => َ
    [42] => ي
    [43] => ْ
    [44] => ر
    [45] => ِ
    [46] =>
    [47] => ا
    [48] => ل
    [49] => ْ
    [50] => م
    [51] => َ
    [52] => غ
    [53] => ْ
    [54] => ض
    [55] => ُ
    [56] => و
    [57] => ب
    [58] => ِ
    [59] =>
    [60] => ع
    [61] => َ
    [62] => ل
    [63] => َ
    [64] => ي
    [65] => ْ
    [66] => ه
    [67] => ِ
    [68] => م
    [69] => ْ
    [70] =>
    [71] => و
    [72] => َ
    [73] => ل
    [74] => َ
    [75] => ا
    [76] =>
    [77] => ا
    [78] => ل
    [79] => ض
    [80] => ّ
    [81] => َ
    [82] => ا
    [83] => ل
    [84] => ّ
    [85] => ِ
    [86] => ي
    [87] => ن
    [88] => َ
)

Sedikit pengantar saja, setiap huruf Arab terdiri dari 4 posisi (case) untuk menentukan bagaimana penulisannya. Ibarat pada alfabet di mana setiap hurufnya terdiri dari 2 case, yaitu uppercase dan lowercase (huruf kapital dan huruf kecil). Maka pada huruf Arab ada 4 keadaan:

• Huruf berdiri sendiri
• Huruf di awal kata
• Huruf di tengah kata
• Huruf di akhir kata

Pada saat kita mengetik dengan keyboard yang dapat mengetik huruf Arab, kita tidak perlu menentukan keempat posisi tersebut. Kita cukup menuliskan saja per huruf (disertai tanda vokal atau harakat bila perlu) dan secara otomatis komputer akan “menggambar”  posisi huruf yang sesuai.

Misalnya kita mengetik pada keyboard urutan berikut:

ا ل ل ه ُ أ َ ك ْ ب َ ر

Maka secara otomatis komputer akan menggabungkannya menjadi:

اللهُ أَكْبَرُ

Bagaimana komputer melakukannya?

Sebenarnya, yang disimpan di komputer tetap urutan huruf seperti yang kita ketikkan, bukan huruf dengan posisi di awal, tengah, atau akhir. Jadi yang menyambungkan seluruh huruf itu adalah pada saat display saja oleh sistem operasi, bukan pada penyimpanannya. Prosedur display seperti ini disebut complex text layout.

Ilustrasi dari Wikipedia:

Bagian atas adalah representasi huruf pada penyimpanan. Bagian tengah adalah huruf yang disusun sesuai urutan yang seharusnya dalam tulisan Arab. Bagian ketiga adalah proses display akhir, di mana seluruh huruf sudah disambung sesuai aturan penulisannya.

Hal yang lebih rumit ada pada saat display tanda vokal atau harakat. Di mana satu huruf bisa memiliki lebih dari satu tanda vokal, misalnya fathah sekaligus tasydid. Maka display harus bisa menyusun tanda vokal ini agar nyaman dilihat. Ilustrasinya bisa dilihat pada artikel ini.

Langkah selanjutnya adalah penelitian itu sendiri. Kalau saya berarti mulai merancang aplikasinya. Semoga dimudahkan.

• Depot tunggal (single depot)
• Kendaraan bervariasi (mixed fleet)
• Time windows jenis hard

Berikut modelnya. Dicoba dengan LINGO versi 11. Model ini hanya untuk 6 customer. Jika lebih atau kurang, harus diubah pada kendala penghilangan subtour.

! referensi :
	[1] Dell'Amico et al. 2007. Heuristic Approaches for the FSMVRP with Time Windows. Transportation Science 41(4), pp. 516-526, © 2007 INFORMS.
	[2] Suthikarnnarunai. 2008. A Sweep Algorithm for the Mix Fleet Vehicle Routing Problem. Proceedings of the International MultiConference of Engineers and Computer Scientists 2008 Vol III MECS 2008, 19-21 March, 2008, Hong Kong.
;

! waktu running dengan data hipotetik ini : sekitar 10 detik ;
! contoh hasil rute dengan data ini :

      X( 1, 3, 2)        1.000000
      X( 1, 4, 1)        1.000000
      X( 2, 7, 2)        1.000000
      X( 3, 6, 2)        1.000000
      X( 4, 5, 1)        1.000000
      X( 5, 1, 1)        1.000000
      X( 6, 2, 2)        1.000000
      X( 7, 1, 2)        1.000000

! jadi rutenya: 
      kendaraan 2 : 1 - 3 - 6 - 2 - 7 - 1 
      kendaraan 1 : 1 - 4 - 5 - 1

;

DATA:
	JUMLAH_KENDARAAN = 3;
	JUMLAH_NODE = 7; ! 6 + depot ;
	M = 1000000000;
ENDDATA

SETS:
	KENDARAAN /1..JUMLAH_KENDARAAN/: Z, KAPASITAS, FIXED_COST, V, PHI;
	CUSTOMER /1..JUMLAH_NODE/: DEMAND, A, B, TAU, S;

	PELAYANAN(CUSTOMER, KENDARAAN) : Y;
	RUTE(CUSTOMER, CUSTOMER, KENDARAAN) : X;
	ARRIVAL(CUSTOMER, KENDARAAN) : T;

	BIAYA(CUSTOMER, CUSTOMER, KENDARAAN): COST;
	JARAK(CUSTOMER, CUSTOMER): D;
	DURASI(CUSTOMER, CUSTOMER, KENDARAAN): DUR;
ENDSETS

! parameter input :
	KAPASITAS(K)	= kapasitas maksimum kendaraan K		[2]
	FIXED_COST(K)	= fixed cost kendaraan K				[1]
	V(K)			= kecepatan kendaraan K
	DEMAND(I)		= demand customer I						[2]
	A(I)			= waktu buka customer I					[1]
	B(I)			= waktu tutup customer I				[1]
	S(I)			= waktu pelayanan di customer I			[1]
	D(I, J)			= jarak customer I ke customer J		[1]
	COST(I, J, K)	= cost dari customer I ke customer J dengan kendaraan K
	DUR(I, J, K)	= lama perjalanan dari customer I ke customer J dengan kendaraan K

! variabel yang dicari :
	X(I, J, K)	= 1 jika pelanggan J dikunjungi setelah I oleh K 	[2]
	Y(I, K)		= 1 jika pelanggan I dilayani oleh K 				[2]
	Z(K)		= 1 jika kendaraan K digunakan 					[1]
	T(I, K)		= waktu minimum kendaraan K untuk customer I 		[1]
	PHI(K)		= waktu berangkat kendaraan K						[1]
	TAU(I)		= waktu pelayanan customer I 						[1]
;

DATA:
	KAPASITAS  = 150 200 300;
	FIXED_COST = 400 250 500;
	V          =  60  60  50;

	D =   ! antara depot dengan depot (diagonal matriks) diberi nilai bilangan besar (misal 999) ;
		999	8.9	4.2	4.7	7.7	9.3	6.7
		8.9	999	5.9	2.9	2.6	2.3	4.7
		4.2	5.9	999	6.3	5.9	3.7	2.9
		4.7	2.9	6.3	999	2.3	3	5.6
		7.7	2.6	5.9	2.3	999	6.2	6.7
		9.3	2.3	3.7	3	6.2	999	5.4
		6.7	4.7	2.9	5.6	6.7	5.4	999;

	! depot diset 0 ;
	DEMAND =  0	 30 70 90 60 56 36;
	A      =  0	  8  8 10  8 12 10;
	B      =  0	 15 13 16 17 18 17;
	S      =  0	  1  2  2  1  2  3;

ENDDATA

! fungsi objektif ;

MIN = 
	@SUM(KENDARAAN(K) : FIXED_COST(K) * Z(K) + T(1, K) - PHI(K))
	+
	@SUM(CUSTOMER(I) :
		@SUM(CUSTOMER(J) :
			@SUM(KENDARAAN(K) : COST(I, J, K) * X(I, J, K));
		);
	);

! setiap customer dikunjungi sekali ;
! kendala (2) dalam [2] ;

@FOR(CUSTOMER(I) | I #NE# 1 :
	@SUM(KENDARAAN(K) : Y(I, K)) = 1;
);			

! jumlah keluar masuk depot harus sama ;
! kendala (3) dalam [2] ;

@SUM(KENDARAAN(K) : Y(1, K)) <= JUMLAH_KENDARAAN;

! kendaraan yang sama harus masuk dan keluar node kecuali depot ;
! kendala (4) dan (5) dalam [2] ;

@FOR(CUSTOMER(I) : 
	@FOR(KENDARAAN(K) :
		@SUM(CUSTOMER(J) | J #NE# I : X(I, J, K)) = Y(I, K);
		@SUM(CUSTOMER(J) | J #NE# I : X(J, I, K)) = Y(I, K);
	);
);

! demand tidak boleh melebihi kapasitas ;
! kendala (5) dalam [1] ;

@FOR(KENDARAAN(K) :
	@SUM(CUSTOMER(I) | I #NE# 1 : DEMAND(I) * Y(I, K)) <= KAPASITAS(K) * Z(K);
);	

! waktu pelayanan harus di antara jam buka dan jam tutup ;
! kendala (11) dalam [1] ;

@FOR(CUSTOMER(I) :
	TAU(I) >= A(I);
	TAU(I) <= B(I);
);

! pengaturan time windows ;
! kendala (7) sampai (10) dalam [1] ;

@FOR(KENDARAAN(K) :
	T(1, K) >= PHI(K);	
);

@FOR(KENDARAAN(K) :
	@FOR(CUSTOMER(I) | I #NE# 1 :
		TAU(I) >= T(I, K);
	);
);

@FOR(KENDARAAN(K) :
	@FOR(CUSTOMER(J) | J #NE# 1 :
		T(J, K) >= PHI(K) + DUR(1, J, K) - M*(1 - X(1,J,K));
	);
);

@FOR(KENDARAAN(K) :
	@FOR(CUSTOMER(I) | I #NE# 1 :
		@FOR(CUSTOMER(J) :
			T(J, K) >= TAU(I) + S(I) + DUR(I, J, K) - M*(1 - X(I, J, K));
		);	
	);
);

! hubungan antara jarak, kecepatan, dan biaya ;

@FOR(KENDARAAN(K) :
	@FOR(CUSTOMER(I) :
		@FOR(CUSTOMER(J) :
			V(K) * DUR(I, J, K) = D(I, J);
			COST(I, J, K) = DUR(I, J, K);
		);
	);
);


! subtour elimination, mengenumerasi seluruh subset ;
! {2, 3}  |  {2, 4}  |  {2, 5}  |  {2, 6}  |  {2, 7}  |  {3, 4}  |  {3, 5}  |  {3, 6}  |  {3, 7}  |  {4, 5}  |  {4, 6}  |  {4, 7}  |  {5, 6}  |  {5, 7}  |  {6, 7}  |  {2, 3, 4}  |  {2, 3, 5}  |  {2, 3, 6}  |  {2, 3, 7}  |  {2, 4, 5}  |  {2, 4, 6}  |  {2, 4, 7}  |  {2, 5, 6}  |  {2, 5, 7}  |  {2, 6, 7}  |  {3, 4, 5}  |  {3, 4, 6}  |  {3, 4, 7}  |  {3, 5, 6}  |  {3, 5, 7}  |  {3, 6, 7}  |  {4, 5, 6}  |  {4, 5, 7}  |  {4, 6, 7}  |  {5, 6, 7}  |  {2, 3, 4, 5}  |  {2, 3, 4, 6}  |  {2, 3, 4, 7}  |  {2, 3, 5, 6}  |  {2, 3, 5, 7}  |  {2, 3, 6, 7}  |  {2, 4, 5, 6}  |  {2, 4, 5, 7}  |  {2, 4, 6, 7}  |  {2, 5, 6, 7}  |  {3, 4, 5, 6}  |  {3, 4, 5, 7}  |  {3, 4, 6, 7}  |  {3, 5, 6, 7}  |  {4, 5, 6, 7}  |  {2, 3, 4, 5, 6}  |  {2, 3, 4, 5, 7}  |  {2, 3, 4, 6, 7}  |  {2, 3, 5, 6, 7}  |  {2, 4, 5, 6, 7}  |  {3, 4, 5, 6, 7}  |  {2, 3, 4, 5, 6, 7};
! kendala (7) dalam [2] ;

@FOR(KENDARAAN(K) :

	X(2, 3, K) + X(3, 2, K) <= 1;
	X(2, 4, K) + X(4, 2, K) <= 1;
	X(2, 5, K) + X(5, 2, K) <= 1;
	X(2, 6, K) + X(6, 2, K) <= 1;
	X(2, 7, K) + X(7, 2, K) <= 1;
	X(3, 4, K) + X(4, 3, K) <= 1;
	X(3, 5, K) + X(5, 3, K) <= 1;
	X(3, 6, K) + X(6, 3, K) <= 1;
	X(3, 7, K) + X(7, 3, K) <= 1;
	X(4, 5, K) + X(5, 4, K) <= 1;
	X(4, 6, K) + X(6, 4, K) <= 1;
	X(4, 7, K) + X(7, 4, K) <= 1;
	X(5, 6, K) + X(6, 5, K) <= 1;
	X(5, 7, K) + X(7, 5, K) <= 1;
	X(6, 7, K) + X(7, 6, K) <= 1;
	X(2, 3, K) + X(2, 4, K) + X(3, 2, K) + X(3, 4, K) + X(4, 2, K) + X(4, 3, K) <= 2;
	X(2, 3, K) + X(2, 5, K) + X(3, 2, K) + X(3, 5, K) + X(5, 2, K) + X(5, 3, K) <= 2;
	X(2, 3, K) + X(2, 6, K) + X(3, 2, K) + X(3, 6, K) + X(6, 2, K) + X(6, 3, K) <= 2;
	X(2, 3, K) + X(2, 7, K) + X(3, 2, K) + X(3, 7, K) + X(7, 2, K) + X(7, 3, K) <= 2;
	X(2, 4, K) + X(2, 5, K) + X(4, 2, K) + X(4, 5, K) + X(5, 2, K) + X(5, 4, K) <= 2;
	X(2, 4, K) + X(2, 6, K) + X(4, 2, K) + X(4, 6, K) + X(6, 2, K) + X(6, 4, K) <= 2;
	X(2, 4, K) + X(2, 7, K) + X(4, 2, K) + X(4, 7, K) + X(7, 2, K) + X(7, 4, K) <= 2;
	X(2, 5, K) + X(2, 6, K) + X(5, 2, K) + X(5, 6, K) + X(6, 2, K) + X(6, 5, K) <= 2;
	X(2, 5, K) + X(2, 7, K) + X(5, 2, K) + X(5, 7, K) + X(7, 2, K) + X(7, 5, K) <= 2;
	X(2, 6, K) + X(2, 7, K) + X(6, 2, K) + X(6, 7, K) + X(7, 2, K) + X(7, 6, K) <= 2;
	X(3, 4, K) + X(3, 5, K) + X(4, 3, K) + X(4, 5, K) + X(5, 3, K) + X(5, 4, K) <= 2;
	X(3, 4, K) + X(3, 6, K) + X(4, 3, K) + X(4, 6, K) + X(6, 3, K) + X(6, 4, K) <= 2;
	X(3, 4, K) + X(3, 7, K) + X(4, 3, K) + X(4, 7, K) + X(7, 3, K) + X(7, 4, K) <= 2;
	X(3, 5, K) + X(3, 6, K) + X(5, 3, K) + X(5, 6, K) + X(6, 3, K) + X(6, 5, K) <= 2;
	X(3, 5, K) + X(3, 7, K) + X(5, 3, K) + X(5, 7, K) + X(7, 3, K) + X(7, 5, K) <= 2;
	X(3, 6, K) + X(3, 7, K) + X(6, 3, K) + X(6, 7, K) + X(7, 3, K) + X(7, 6, K) <= 2;
	X(4, 5, K) + X(4, 6, K) + X(5, 4, K) + X(5, 6, K) + X(6, 4, K) + X(6, 5, K) <= 2;
	X(4, 5, K) + X(4, 7, K) + X(5, 4, K) + X(5, 7, K) + X(7, 4, K) + X(7, 5, K) <= 2;
	X(4, 6, K) + X(4, 7, K) + X(6, 4, K) + X(6, 7, K) + X(7, 4, K) + X(7, 6, K) <= 2;
	X(5, 6, K) + X(5, 7, K) + X(6, 5, K) + X(6, 7, K) + X(7, 5, K) + X(7, 6, K) <= 2;
	X(2, 3, K) + X(2, 4, K) + X(2, 5, K) + X(3, 2, K) + X(3, 4, K) + X(3, 5, K) + X(4, 2, K) + X(4, 3, K) + X(4, 5, K) + X(5, 2, K) + X(5, 3, K) + X(5, 4, K) <= 3;
	X(2, 3, K) + X(2, 4, K) + X(2, 6, K) + X(3, 2, K) + X(3, 4, K) + X(3, 6, K) + X(4, 2, K) + X(4, 3, K) + X(4, 6, K) + X(6, 2, K) + X(6, 3, K) + X(6, 4, K) <= 3;
	X(2, 3, K) + X(2, 4, K) + X(2, 7, K) + X(3, 2, K) + X(3, 4, K) + X(3, 7, K) + X(4, 2, K) + X(4, 3, K) + X(4, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 4, K) <= 3;
	X(2, 3, K) + X(2, 5, K) + X(2, 6, K) + X(3, 2, K) + X(3, 5, K) + X(3, 6, K) + X(5, 2, K) + X(5, 3, K) + X(5, 6, K) + X(6, 2, K) + X(6, 3, K) + X(6, 5, K) <= 3;
	X(2, 3, K) + X(2, 5, K) + X(2, 7, K) + X(3, 2, K) + X(3, 5, K) + X(3, 7, K) + X(5, 2, K) + X(5, 3, K) + X(5, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 5, K) <= 3;
	X(2, 3, K) + X(2, 6, K) + X(2, 7, K) + X(3, 2, K) + X(3, 6, K) + X(3, 7, K) + X(6, 2, K) + X(6, 3, K) + X(6, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 6, K) <= 3;
	X(2, 4, K) + X(2, 5, K) + X(2, 6, K) + X(4, 2, K) + X(4, 5, K) + X(4, 6, K) + X(5, 2, K) + X(5, 4, K) + X(5, 6, K) + X(6, 2, K) + X(6, 4, K) + X(6, 5, K) <= 3;
	X(2, 4, K) + X(2, 5, K) + X(2, 7, K) + X(4, 2, K) + X(4, 5, K) + X(4, 7, K) + X(5, 2, K) + X(5, 4, K) + X(5, 7, K) + X(7, 2, K) + X(7, 4, K) + X(7, 5, K) <= 3;
	X(2, 4, K) + X(2, 6, K) + X(2, 7, K) + X(4, 2, K) + X(4, 6, K) + X(4, 7, K) + X(6, 2, K) + X(6, 4, K) + X(6, 7, K) + X(7, 2, K) + X(7, 4, K) + X(7, 6, K) <= 3;
	X(2, 5, K) + X(2, 6, K) + X(2, 7, K) + X(5, 2, K) + X(5, 6, K) + X(5, 7, K) + X(6, 2, K) + X(6, 5, K) + X(6, 7, K) + X(7, 2, K) + X(7, 5, K) + X(7, 6, K) <= 3;
	X(3, 4, K) + X(3, 5, K) + X(3, 6, K) + X(4, 3, K) + X(4, 5, K) + X(4, 6, K) + X(5, 3, K) + X(5, 4, K) + X(5, 6, K) + X(6, 3, K) + X(6, 4, K) + X(6, 5, K) <= 3;
	X(3, 4, K) + X(3, 5, K) + X(3, 7, K) + X(4, 3, K) + X(4, 5, K) + X(4, 7, K) + X(5, 3, K) + X(5, 4, K) + X(5, 7, K) + X(7, 3, K) + X(7, 4, K) + X(7, 5, K) <= 3;
	X(3, 4, K) + X(3, 6, K) + X(3, 7, K) + X(4, 3, K) + X(4, 6, K) + X(4, 7, K) + X(6, 3, K) + X(6, 4, K) + X(6, 7, K) + X(7, 3, K) + X(7, 4, K) + X(7, 6, K) <= 3;
	X(3, 5, K) + X(3, 6, K) + X(3, 7, K) + X(5, 3, K) + X(5, 6, K) + X(5, 7, K) + X(6, 3, K) + X(6, 5, K) + X(6, 7, K) + X(7, 3, K) + X(7, 5, K) + X(7, 6, K) <= 3;
	X(4, 5, K) + X(4, 6, K) + X(4, 7, K) + X(5, 4, K) + X(5, 6, K) + X(5, 7, K) + X(6, 4, K) + X(6, 5, K) + X(6, 7, K) + X(7, 4, K) + X(7, 5, K) + X(7, 6, K) <= 3;
	X(2, 3, K) + X(2, 4, K) + X(2, 5, K) + X(2, 6, K) + X(3, 2, K) + X(3, 4, K) + X(3, 5, K) + X(3, 6, K) + X(4, 2, K) + X(4, 3, K) + X(4, 5, K) + X(4, 6, K) + X(5, 2, K) + X(5, 3, K) + X(5, 4, K) + X(5, 6, K) + X(6, 2, K) + X(6, 3, K) + X(6, 4, K) + X(6, 5, K) <= 4;
	X(2, 3, K) + X(2, 4, K) + X(2, 5, K) + X(2, 7, K) + X(3, 2, K) + X(3, 4, K) + X(3, 5, K) + X(3, 7, K) + X(4, 2, K) + X(4, 3, K) + X(4, 5, K) + X(4, 7, K) + X(5, 2, K) + X(5, 3, K) + X(5, 4, K) + X(5, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 4, K) + X(7, 5, K) <= 4;
	X(2, 3, K) + X(2, 4, K) + X(2, 6, K) + X(2, 7, K) + X(3, 2, K) + X(3, 4, K) + X(3, 6, K) + X(3, 7, K) + X(4, 2, K) + X(4, 3, K) + X(4, 6, K) + X(4, 7, K) + X(6, 2, K) + X(6, 3, K) + X(6, 4, K) + X(6, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 4, K) + X(7, 6, K) <= 4;
	X(2, 3, K) + X(2, 5, K) + X(2, 6, K) + X(2, 7, K) + X(3, 2, K) + X(3, 5, K) + X(3, 6, K) + X(3, 7, K) + X(5, 2, K) + X(5, 3, K) + X(5, 6, K) + X(5, 7, K) + X(6, 2, K) + X(6, 3, K) + X(6, 5, K) + X(6, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 5, K) + X(7, 6, K) <= 4;
	X(2, 4, K) + X(2, 5, K) + X(2, 6, K) + X(2, 7, K) + X(4, 2, K) + X(4, 5, K) + X(4, 6, K) + X(4, 7, K) + X(5, 2, K) + X(5, 4, K) + X(5, 6, K) + X(5, 7, K) + X(6, 2, K) + X(6, 4, K) + X(6, 5, K) + X(6, 7, K) + X(7, 2, K) + X(7, 4, K) + X(7, 5, K) + X(7, 6, K) <= 4;
	X(3, 4, K) + X(3, 5, K) + X(3, 6, K) + X(3, 7, K) + X(4, 3, K) + X(4, 5, K) + X(4, 6, K) + X(4, 7, K) + X(5, 3, K) + X(5, 4, K) + X(5, 6, K) + X(5, 7, K) + X(6, 3, K) + X(6, 4, K) + X(6, 5, K) + X(6, 7, K) + X(7, 3, K) + X(7, 4, K) + X(7, 5, K) + X(7, 6, K) <= 4;
	X(2, 3, K) + X(2, 4, K) + X(2, 5, K) + X(2, 6, K) + X(2, 7, K) + X(3, 2, K) + X(3, 4, K) + X(3, 5, K) + X(3, 6, K) + X(3, 7, K) + X(4, 2, K) + X(4, 3, K) + X(4, 5, K) + X(4, 6, K) + X(4, 7, K) + X(5, 2, K) + X(5, 3, K) + X(5, 4, K) + X(5, 6, K) + X(5, 7, K) + X(6, 2, K) + X(6, 3, K) + X(6, 4, K) + X(6, 5, K) + X(6, 7, K) + X(7, 2, K) + X(7, 3, K) + X(7, 4, K) + X(7, 5, K) + X(7, 6, K) <= 5;

);

! kendala biner untuk variabel ;

@FOR(KENDARAAN(K) : 
	@BIN(Z(K));
	@FOR(CUSTOMER(I) :
		@BIN(Y(I, K));
		@FOR(CUSTOMER(J) :
			@BIN(X(I, J, K));
		);
	);
);

Alhamdulillah, saya sendiri sudah mendapatkannya. Topik penelitian saya tidak “wah” seperti yang lainnya, hanya membuat program saja. Program yang akan dibuat adalah sistem pencarian ayat Al-Quran berbasis kemiripan fonetik. Apa maksudnya?

Jadi begini, selama ini kalau kita hendak mencari di program Al-Quran, maka kita harus mencari dalam bahasa Arab, dan mengetikkan pencariannya dalam tulisan Arab. Masalahnya, tidak semua orang paham bagaimana merepresentasikan bunyi ayat yang dia ketahui dalam tulisan Arab. Mungkin banyak yang salah menuliskan “rabbil ‘aalamiin” dengan ” ربل عالمين ” padahal yang benar adalah ” رب العالمين ”. Oleh karena itu, program sistem pencarian yang dibuat bisa mencari ayat dalam Al-Quran dengan cukup mengetikkan bunyi kata dalam tulisan Latin, bukan dengan tulisan Arab.

Itulah yang disebut kemiripan fonetik, atau kemiripan pengucapan. Kemudian, untuk metode pencariannya menggunakan teknik indeks trigram yang cukup terkenal dalam bidang information retrieval.

Pembimbing skripsi saya adalah bapak Ahmad Ridha, salah satu dosen Ilmu Komputer yang insya Allah berkompeten dalam hal Al-Quran dan information retrieval. Semoga yang dikerjakan akan bermanfaat bagi kaum muslimin.

Sejauh ini, yang sudah dibuat adalah makalah kolokium atau proposal penelitian. Insya Allah proposal akan diseminarkan pada akhir Januari mendatang, setelah beberapa revisi atas arahan pembimbing. Targetnya bulan Juli harus sudah beres :)

Tambahan: Seluruh dokumen terkait penelitian saya backup di Google Documents pada link ini. Dan log jalannya penelitian saya usahakan selalu di-update di blog ini.