1

BAB I
DASAR TEORI

1.1 Perulangan
Perulangan ialah melakukan aksi yang sama berulang kali dengan jumlah yang
telah ditentukan atau sampai kondisi perulangan tercapai. Pada prolog struktur
perulangan diwujudkan dengan suatu aturan (aturan induk) yang terdiri dari aksi
inisialisasi dan aturan lain (aturan cabang) yang terdiri dari sejumlah aksi lain baik
yang hendak diulang dalam struktur perulangan tersebut maupun aksi yang menjadi
penentu kondisi berhentinya perulangan. Aksi yang hendak diulang dapat berupa aksi
aritmatika maupun aksi input-output, sedangkan aksi yang menjadi penentu kondisi
berhentinya perulangan adalah aksi perbandingan. Operator untuk aksi aritmatika
terdiri dari +, -, *, /, mod, div, aksi input-ouput terdiri dari fungsi write dan read,
sedangkan operator untuk aksi perbandingan terdiri dari operator <, >, <=, >=, =, <>.
Contoh : get_answer(Ans):-
write('Enter answer to question'),nl,
repeat,write('answer yes or no'),read(Ans),
valid(Ans),write('Answer is
'),write(Ans),nl.
valid(yes). valid(no).


2

1.2 Rekursi
Rekursi dalam bahasa apa pun adalah fungsi yang dapat memanggil dirinya
sendiri sampai tujuan telah berhasil. Dalam Prolog, rekursi muncul ketika sebuah
predikat mengandung tujuan yang mengacu pada dirinya sendiri. Sebagaimana telah
kita lihat dalam bab-bab sebelumnya, ketika aturan disebut Prolog membuat query baru
dengan variabel baru. Jadi tidak membuat perbedaan cuaca aturan panggilan peraturan
lain atau telepon itu sendiri. Dalam Prolog dan dalam bahasa apapun, definisi rekursi
selalu memiliki paling sedikit dua bagian. Fakta pertama yang bertindak seperti kondisi
berhenti dan aturan yang panggilan itself disederhanakan. Pada setiap tingkat fakta
pertama diperiksa. Jika kenyataannya adalah benar maka rekursi berakhir. Jika tidak
maka rekursi terus berlanjut. Aturan rekursi tidak pernah menyebut dirinya dengan
argumen sames! Jika itu terjadi maka program tidak akan pernah berakhir.
Contoh program berikut menunjukkan penggunaan rekursi untuk membaca term yang
dimasukkan user melalui keyboard dan menampilkannya ke layar, hingga kata end
dimasukkan:
Source file :
go:-loop(start).
the looping process started.
loop(end).
loop(X):-X\=end,write(Type end to end),read(Word),
write(Input was ),write(Word),nl,loop(Word)
3

Suatu prosedur dikatakan rekursi jika memanggil dirinya sendiri. Dengan
rekursi tidak sulit untuk menyimpan nilai hasil program karena perhitungan loop,
jumlah dan hasil sementara dapat dikirim ke tiap pengulangan dan rekursi.





















4

BAB II
PEMBAHASAN

2.1 Percobaan 1
1. Buka jendela baru.
2. Ketikkan program berikut ini ke dalam visual prolog.


















Gambar 2.1 Percobaan 1
Penjelasan : untuk Gambar 2.1 Percobaan 1 di atas, adalah bahwa suatu predikat
dengan menampilkan suatu negara (mencetak nama negara), di mana variabel
PREDICATES
nondeterm negara(symbol)
nondeterm cetak_negara
CLAUSES
negara("Inggris").
negara("Perancis").
negara("Jerman").
negara("Denmark").

cetak_negara:-
negara(X)
,write(X), /* tulis nilai X */
nl, /* ganti baris baru */
fail.
cetak_negara.

GOAL
cetak_negara.
5

negara di tulis dengan X, kemudian mengganti baris baru dengan n. dan melakukan
lacak balik karena ada predikat fail sehingga predikat negara(symbol) diganti
dengan cetak_negara. Jalankan program dengan menekan CTRL+G maka akan
terlampirkan Goal sebagai berikut.

Gambar 2.2 Percobaan 1.
Hasil Goal dari Gambar 2.1 Percobaan 1





6

2.2 Percobaan 2
1. Buka jendela baru.
2. Masukkan program berikut ke dalam visual prolog.















Gambar 2.2.1 Percobaan 2
Penjelasan : Melakukan implementasi lacak balik dengan loop yaitu suatu pelacakan
dengan berulang-ulang sampai ketemu yang dimaksud. Untuk pembahasannya yaitu
suatu predicates ulang dan mesinketik yang memilik jawaban kemungkinan ada
sejumlah fakta (lebih dari satu jawaban). Jalankan program dengan menekan CTRL+G.
PREDICATES
nondeterm ulang
nondeterm mesinketik

CLAUSES
ulang.
ulang:-ulang.

mesinketik:-
ulang,readchar(C),
/* baca sebuah karakter,
ikat ke variabel C */write(C),
C = '\r'.
/* Apakah ditekan Enter? Gagal jika tidak */

GOAL
mesinketik,nl.
7


Gambar 2.2.2 percobaan 2
Hasil Goal dari Gambar 2.2.1 Percobaan 2







8

2.3 Percobaan 3
1. Buka jendela baru.
2. Masukkan program berikut ke dalam visual prolog.












Gambar 2.3.1 Percobaan 3
Penjelasan : Untuk percobaan 3 yaitu mencari faktorial dari suatu angka.
Clauses faktorial percobaan 3 yaitu pada tanda (:-) merupakan tanda kata jika
untuk memisahkan dua bagian dari aturan yaitu head dan body. Diketahui X=3
jika Y=X-1, maka faktorial X dan Y adalah untuk X=3 dan Y=1. Jalankan
program dengan menekan CTRL+G.

PREDICATES
faktorial(unsigned,real)

CLAUSES
faktorial(1,1):-!.

faktorial(X,FaktoX):-
Y=X-1,
faktorial(Y,FaktoY),
FaktoX = X*FaktoY.

GOAL
X=3,faktorial(X,Y).
9


Gambar 2.3.2 Percobaan 3
Hasil Goal dari Gambar 2.3.1 Percobaan 3












10

2.4 Percobaan 4
1. Buka jendela baru
2. Masukkan program berikut ke dalam visual prolog.
















Gambar 2.4.1 Percobaan 4
Penjelasan : Untuk percobaan 4, ini merupakan perbaikan program mencari
faktorial dengan menggunakan rekursi ekor. Dimana suatu predicates
menanyakan bilangan real diketahui N= 0,
jika Ibaru=I+1 danPbaru=P*Ibaru. Untuk varibel N berulang dua kali.
PREDICATES
faktorial(unsigned,real)
faktorial(unsigned,real,unsigned,real)

CLAUSES
faktorial(N,FaktoN):-
faktorial(N,FaktoN,1,1).
faktorial(N,FaktoN,N,FaktoN):-!.
faktorial(N,FaktoN,I,P):-
IBaru = I+1,
PBaru = P*IBaru,
faktorial(N, FaktoN, IBaru, PBaru).

GOAL
faktorial(3,X).
11

Sehingga pada goal faktorial (3,X)=6. Jalankan program dengan menekan
CTRL+G.

Gambar 2.4.2 Percobaan 4
Hasil Goal dari Gambar 2.4.1 Percobaan 4











12

2.5 Percobaan 5
1. Buka jendela baru.
2. Masukkan program berikut ke dalam visual prolog.
























DOMAINS
tipepohon = pohon(string,tipepohon,tipepohon) ;
empty()
PREDICATES
buat_pohon(string,tipepohon)
sisip_kiri(tipepohon,tipepohon,tipepohon)
sisip_kanan(tipepohon, tipepohon, tipepohon)
bentuk_pohon(tipepohon)
CLAUSES
buat_pohon(A,pohon(A,empty,empty)).
sisip_kiri(X,pohon(A,_,B),pohon(A,X,B)).
sisip_kanan(X,pohon(A,B,_),pohon(A,B,X)).
bentuk_pohon(Ca3):-
buat_pohon("Charles",Ch),
buat_pohon("Hazel",H),
buat_pohon("Michael",Mi),
buat_pohon("Jim",J),
buat_pohon("Eleanor",E),
buat_pohon("Melody",Me),
buat_pohon("Cathy",Ca),

sisip_kiri(Ch, Mi, Mi2),
sisip_kanan(H, Mi2, Mi3),
sisip_kiri(J, Me, Me2),
sisip_kanan(E, Me2, Me3),
sisip_kiri(Mi3, Ca, Ca2),
13




Gambar 2.5.1 Percobaan 5
Jalankan program dengan menekan CTRL+G.





Gambar 2.5.2 Percobaan 5
Hasil Goal dari Gambar 2.5.1 Percobaan 1.
sisip_kanan(Me3, Ca2, Ca3).

GOAL
bentuk_pohon(Pohon).
14

BAB III
Tugas Praktikum

1. Ketikkan program di bawah ini :























DOMAINS
pohonchar = pohon(char, pohonchar,
pohonchar); akhir

PREDICATES
nondeterm lakukan(pohonchar)
kerjakan(char, pohonchar, pohonchar)
buat_pohon(pohonchar, pohonchar)
sisip(char, pohonchar, pohonchar)
cetak_pohon(pohonchar)
nondeterm ulang

CLAUSES
lakukan(Pohon):-
ulang,nl,
write("*************************************
******************"),nl,
write("Ketik 1 meng-update pohon\n"),
write("Ketik 2 mencetak pohon\n"),
write("Ketik 7 keluar\n"),
write("*************************************
******************"),nl,

15



























write("Masukkan angka - "),
readchar(X),nl,
kerjakan(X, Pohon, PohonBaru),
lakukan(PohonBaru).

kerjakan('1',Pohon,PohonBaru):-
write("Ketik karakter # untuk mengakhiri: "),
buat_pohon(Pohon, PohonBaru).
kerjakan('2',Pohon,Pohon):-
cetak_pohon(Pohon),
write("\nTekan sembarang tombol"),
readchar(_),nl.
kerjakan('7', _, akhir):-
exit.

buat_pohon(Pohon, PohonBaru):-
readchar(C),
C<>'#',!,
write(C, " "),
sisip(C, Pohon, PohonTemp),
buat_pohon(PohonTemp, PohonBaru).
buat_pohon(Pohon, Pohon).

sisip(Baru,akhir,pohon(Baru,akhir,akhir)):-!.

sisip(Baru,pohon(Elemen,Kiri,Kanan),pohon(Elemen
,KiriBaru,Kanan)):-
Baru<Elemen,!,
sisip(Baru,Kiri,KiriBaru).

16














Pertanyaannya adalah:
1. Gambarkan struktur pohon yang terbuat dari serangkaian karakter dari
namamu!
2. Apa yang dimaksud dengan struktur data rekursif.
3. Mengapa rekursi ekor (tail recursion) lebih baik dari rekursi biasa?







sisip(Baru,pohon(Elemen,Kiri,Kanan),pohon(Elemen
,Kiri,KananBaru)):-
sisip(Baru,Kanan,KananBaru).

cetak_pohon(akhir).
cetak_pohon(pohon(Item,Kiri,Kanan)):-
cetak_pohon(Kiri),
write(Item, " "),
cetak_pohon(Kanan).

ulang.
ulang:-ulang.

GOAL
write("********** Sortir Pohon Karakter
************"),nl,
lakukan(akhir).

17

Jawaban :


1.













2. Struktur data rekursif adalah prosedur yang di dalamnya ada pemanggilan
terhadap dirinya sendiri. Prosedur rekursi dapat merekam perkembangannya karena
ia melewatkan (passing) pencacah, total, dan hasil sementara sebagai argumen dari
satu iterasi ke iterasi berikutnya.
1
A
C R
L
O
2
3
4
5
18

3. Rekursif ekor lebih baik daripada rekursif biasa karena dalam rekursif ekor
Pemanggil merupakan subgoal terakhir dari klausa tersebut dan tidak ada titik lacak
balik sebelumnya pada klausa. Sehingga misalnya kita selain memanggil prosedur
C, prosedur B memanggil dirinya sendiri pada langkah terakhir. Ketika prosedur B
memanggil B, stack frame dari pemanggilan B akan ditimpa nilainya oleh sebuah
stack frame dari pemanggil B, jadi tidak menambah stack frame baru. Hanya
argumen yang perlu di-update nilainya dan kemudian proses akan melompat ke awal
prosedur. Sedangkan pada rekursif biasa, ketika suatu prosedur memanggil dirinya,
keadaan pemanggil prosedur dari eksekusi harus disimpan sehingga prosedur
pemanggil dapat meresume keadaan tersebut setelah prosedur pemanggil selesai. Ini
berarti jika ada suatu prosedur memanggil dirinya 100 kali, maka ada 100 keadaan
dari eksekusi yang harus disimpan. Keadaan (state) yang disimpan tersebut dikenal
dengan nama stack frame. Ukuran stack maksimum pada platform 16 bit, seperti
IBM-PC dengan sistem operasi DOS, adalah 64KByte yang bisa mengandung
sekitar 3000 atau 4000 stack frame. Pada paltform 32 bit, secara teoritis bisa sampai
ukuran Giga Byte.




19

BAB IV
KESIMPULAN

Perulangan dan Rekursi
Komputer memiliki bermacam kemampuan yang berguna salah satunya adalah
kemampuan melakukan sesuatu berulang-ulang. Prolog dapat melakukan perulangan
dalam dua hal yaitu berupa prosedur dan struktur data. Ide dari struktur data repetitif
(rekursi) adalah bagaimana menciptakan struktur data yang ukuran (size) akhirnya
belum diketahui ketika struktur tersebut pertama kali dibuat (create).
Dalam hal ini dapat saya simpulkan bahwa program-program permulaian
sangat membantu kita dalam mencari data baik secara lacakbalik maupun rekursi. Dan
saya juga bisa mengetahui bahwa lacakbalik dan rekursi berbeda prosedurnya. Dalam
lacakbalik prosedurnya akan memcari sendiri jawaban dengan mencari jawaban
alternatif dari sebuah goal. Sedangkan rekursi prosedurnya memanggil dirinya sendiri.







20

DAFTAR PUSTAKA

http://mouvaisbee.blogspot.com/2010/10/rekursif-perulangan-dalam-bahasa-
prolog.html
http://wiwidrainshinbi.blogspot.com/2010/10/rekursif-perulangan-dalam-prolog.html
http://chacaatmika.blogspot.com/2011/12/prolog.html