Recursion

Prolog Dersleri - 3.Hafta

Tekrarlama ve

rekürsiyon

Prosedür ve veri yapılarında tekrarlama iĢlemleri Visual Prolog‟da kolay bir şekilde yapılır. Bu bölümde önce tekrarlı işlemler (döngüler ve rekursif prosedürler), daha sonra ise rekursiv veri yapıları incelenecektir.

Tekrarlı İşlemler

Pascal, BASIC veya C gibi konvansiyonel programlama dilleriyle çalışanlar, Prologla çalışmaya başladıklarında FOR, WHILE, REPEAT gibi ifadeleri göremeyince şaşırabilirler. Çünkü Prologda iterasyonu anlatan direkt bir yol yoktur. Prolog sadece iki türlü tekrarlama-geriye dönüş imkanı tanır. Bu işlemlerde bir sorguya birden fazla çözüm bulmak ve bir prosedürün kendisini çağırdığı rekürsiyon işlemine imkan tanır.

Geriye İz Sürme

•Bir prosedür, istenilen bir hedef için uygun bir çözüm yerine alternatif başka çözümler aramak için geriye döner. Bunun için geriye henüz denenmemiş bir alternatifi kalan en son alt hedefe gidileceğini, bu noktadan tekrar aşağıya doğru inileceği bilinmektedir. Geriye dönüşü iptal edip tekrarlı işlemler yaptırmak mümkündür.

Örnek•PREDICATES

•nondeterm ulke_adi(symbol)

•ulke_adlarini_yaz

•CLAUSES

•ulke_adi("Türkiye").

•ulke_adi("Kazakistan").

•ulke_adi("Azerbaycan").

•ulke_adi("Amerika").

•ulke_adlarini_yaz:-

•ulke_adi(Ulke), write(Ulke), nl, fail.

•ulke_adlarini_yaz.

•GOAL ulke_adi(Ulke).

Yukarıdaki ulke_adi yüklemi sadece ülke isimlerini sıralar. Dolayısıyla GOAL ulke_adi(Ulke) şeklindeki bir hedefin birden fazla sonucu vardır ve ulke_adlarini_yaz yuklemi bunların hepsini görüntüler.

•ulke_adlarini_yaz :- ulke_adi(Ulke), write(Ulke), nl, fail. satırıyla söylenmek istenen şey şudur: “Bütün ülke isimlerini yazmak için, önce ulke-adi(Ulke) cümlesine cevap bul, bunu yaz, yeni bir satıra geç ve işlemi yeniden başlat.”

•„fail‟ komutunun programa yüklediği görev şöyle özetlenebilir: “GOAL cümlesine uygun bir çözüm bulunduğunda, geriye dönüş yap ve başka alternatiflere bak”.

•„fail‟ yerine, sonucu daima yanlış olan ve bu yüzden geriye dönüşü zorlayan başka bir alt hedef kullanmak mümkündür. Örneğin, 10=5+6 satırı her zaman yanlış olacağı için, Prolog başka alternatifler bulmak için daima geriye dönüş yapar.

•Örneğimizde ilk önce Ulke=Türkiye olur ve sonuç ekrana yazılır. „fail‟ komutuna sıra geldiğinde program, bir alt hedefe geri döner. Fakat nl veya write(Ulke) satırları için kullanılabilecek herhangi bir veri olmadığı için, bilgisayar ulke_adi(Ulke) iliĢkisi için baĢka çözümler arar.

•Ulke_adi(Ulke) iliĢkisi çalıĢtırıldığında, önceden boĢ değiĢken olan Ulke değiĢkeni „Türkiye‟ değerini almıĢtı. Bu yüzden bu iliĢkiyi yeniden kullanmadan önce Ulke değiĢkeni yeniden serbest hale getirilir. Daha sonra Ulke değiĢkeninin alabileceği baĢka bir olgu aranır. Ġkinci oluguda bu sağlanır ve ulke_adi yüklemindeki Ulke değiĢkeni „Kazakistan‟ değerini alır. Bu iĢlem böylece devam eder ve sonuçta Ģu satırlar görüntülenir.

•Türkiye

•Kazakistan

•Azerbaycan

•Amerika

•4 Solutions

•Eğer ulke_adlarini_yaz yüklemi „fail‟ komutundan sonra yazılmamıĢ olsaydı, cevap yine aynı olurdu fakat „yes‟ yerine „no‟ satırı görüntülenirdi.

Önceki ve Sonraki Eylemler Bir hedef için gerekli olan bütün çözümleri sağlayan bir program, çözüm yapmadan ve yaptıktan sonra başka şeyler de yapabilir. Örneğin

1. Yaşanacak güzel yerler

2. Ulke_adi(Ulke) yükleminin bütün sonuçlarını yaz.

3. Başka yerler de olabilir...

şeklinde bir mesaj yazarak bitirebilir.

Ulke_adlarini_yaz cümlesin ulke_adi(Ulke) yükleminin bütün sonuçlarını içerir ve sonunda bir bitiş mesajı yazar.

Örnekte geçen ilk ulke_adlarini_yaz cümlesi yukarıdaki adımlardan ikincisi içindir ve bütün çözümleri yazar. ikinci cümlesi ise üçüncü adıma tekabül eder ve sadece hedef cümlesini başarılı bir şekilde bitirmek içindir. Çünkü ilk cümle daima yanlıştır.

•Programı başka şekilde yazmak gerekirse:

•PREDICATES

•nondeterm ulke_adi(symbol)

•ulke_adlarini_yaz

•CLAUSES

•ulke_adi("Türkiye").

•ulke_adi("Kazakistan").

•ulke_adi("Azerbaycan").

•ulke_adi("Amerika").

•ulke_adlarini_yaz:-

•write("YaĢanacak bazı yerlerin listesi.."), nl, fail.

•ulke_adlarini_yaz :-

•ulke_adi(Ulke), write(Ulke), nl, fail.

•ulke_adlarini_yaz:-

•write("BaĢka güzel yerler de vardır..."), nl.

•İlk cümledeki „fail‟ komutu çok önemlidir. Çünkü bu komut ilk cümle çalıştırıldıktan sonra programın ikinci cümleye geçişini sağlar. Buradaki write ve nl http://alikoker.name.tr

•76

•komutlarının başka bir iş yapmaması çok önemlidir. Son „fail‟ komutundan sonra programın ikinci cümleciğe geçişi sağlanmalıdır.

Döngülü Geriye Dönüşün

Uygulanması Geriye dönüş işlemi bir hedefin bütün çözümlerinin bulunması açısından son derece

önemlidir. Birden fazla çözüm sunamayan hedefler için yine de geriye dönüş işlemi

yapılabilir. Bu da tekrarlama işlemini yapar. Örneğin:

tekrar.

tekrar:-tekrar.

gibi iki cümlecik sonsuz sayıda çözüm olduğunu göstermektedir.

Örnek:

PREDICATES

nondeterm tekrar

nondeterm karakteri_ekrana_yaz

CLAUSES

tekrar.

tekrar:-tekrar.

karakteri_ekrana_yaz:-

tekrar, readchar(Harf), /*Klavyeden girilen harfi oku ve C'ye ata*/

write(Harf),

Harf='\r', !. /* Satır sonu tuşuna (Enter/Return) basılmadıysa devam et*/

•GOAL karakteri_ekrana_yaz, nl.Yukarıdaki örnekte tekrar işleminin nasıl yapılacağını görülebilir. Karakteri_ekrana_yaz:-... kuralı, „Enter/Return‟ basılmadığı müddetçe, klavyeden girilen kararterleri kabul edip ekranda gösteren bir prosedür tanımlamaktadır.

•Karakteri_ekrana_yaz kuralının çalışma mekanizması şöyle sıralanabilir:

•1. tekrar‟ı çalıştır. (Hiçbir şey yapmaz)

•2. bir karakter oku (Harf)

•3. Harf karakterini yaz

•4. Harf‟in satır sonu karakteri olup olmadığını kontrol et.

•

•5. Eğer satır sonu elemanı ise, işlemi bitir, değilse, geriye iz sürme işlemini yap ve alternatif ara. Buradaki write ve readchar kurallarının hiçbiri alternatif sağlayamaz. Dolayısıyla geriye dönüş hemen tekrar kuralına gider, bunun ise alternatif sunması tabiidir.

•6. İşlem devam eder. Bir karakter oku, onu ekrana yaz, satır sonu elemanı olup olmadığını kontrol et.

•

Rekursif Prosedürler (A³)

● Kendisini çağırabilen prosedüre rekursif prosedür

diyoruz.

● Tekrarlama işlemin yapmanın diğer bir yolu da

rekursiyondur.

● Rekursif prosedürler yaptıkları işlerin sayısını, toplamını

veya işlmelerin ara sonuçlarını saklayabilir ve bunları bir

döngüden diğerine rahatlıkla aktarabilirler.

Örnek: N sayısının faktöryelini (N!) hesaplamak

Standart Sistem

● Başlangıç değeri 1 olan bir

return değişkeni oluştur.

● 1 den N e kadar bir döngü

oluştur.

● return değerini döngünün

indisi ile çarparak return

değişkenine ata.

● Sonuç return değişkenidir.

Rekursif Sistem

● Kural 1: N sayısı 0 ise sonuç

1 dir.

● Kural 2: N sayısı 0 den

büyük ise sonuç N-1

faktöryeldir ((N-1)!).

Örnek Kod

factorial(0,1).

factorial(N,F) :-

N>0,

N1 is N-1,

factorial(N1,F1),

F is N * F1.

Ama ??

Faktöriyel kuralını N=6 olacak şekilde

çağırılırsa, faktöriyel kendini N=5 için

çağırılacaktır. Bu durumda N deki 6 değeri

nereye gitti ?

Rekursif Prosedürlerin Avantajları

● Mantıksal olarak iterasyondan çok daha basittir.

● Listeleri işlemede çok yaygın olarak kullanılır.

● Rekursiyon işlemi özellikle probleme içerisinde dallanmaların mevcut

olduğu, yani bir problemin çözümünün bir alt probleme bağlı olduğu

durumlarda çok faydalıdır.

Sondan Rekursion Optimizasyonu

Rekursiyon işleminin en önemli dezavantajı, belleği fazlaca kullanmasıdır.

Bir prosedür başka bir alt prosedürü çağırdığında, çağrıyı yapan prosedürün

çağrıyı yaptığı anki çalışma durumu mutlaka kaydedilmelidir. Böylece çağrılan

işlemini bitirdikten sonra çağıran kaldığı yerden devam edebilir. Ama dallanma

çok fazla olursa hafızaya kaydettikleri de fazla olacağından bu bir hafıza

şişmesine bile neden olabilir.

Yani biz 6! i hesaplamak isterken otamatik olarak 5! , 4! , 3! , 2! , 1! , 0! i de

hesaplamış oluyoruz ve bu hesaplamalar için ekstradan hafızaya bunları atmış

oluyoruz.

Peki bunun için ne yapmalı?

Bir prosedürün, başka bir prosedürü kendisinin en son adımı olarak çağırdığını

düşünelim. Çağrılan prosedür görevini yaptıktan sonra, çağrıyı yapan prosedürün

yapması gereken başka bir şey kalmaz. Çağrıyı yapan prosedürün kendisinin çalışma

anını kaydetmesi gerekmez, çünkü o andaki bilgi artık gereksizdir. Çağrılan prosedür

biter bitmez, program akışı normal biçimde devam eder.

Bu durum daha açık olarak aşağıdaki şekilde ifade edilebilir. A prosedürünün B

prosedürünü, B prosedürünün ise C prosedürünü son adım olarak çağırdığını düşünelim.

B prosedürü C’yi çağırdığında, B’nin başka bir şey yapması gerekmez. Yani C‟nin o anki

çalışma durumunu B olarak kaydetmek yerine, B’nin kaydedilen eski durumun C’ya

aktarmak, depolanan bilgi içinde uygun değişiklik yapmak mümkündür. C bittiği zaman,

doğrudan A prosedürü tarafından çağrılmış gibi olacaktır.

Sondan Rekursiyonun Kullanımı

Prologda bir prosedürün başka bir prosedürü ‘kendisinin

en son adımı olarak çağırması’ bu prosedürü sondan

rekursiyon yapacaktır. Bu da bu prosedürün geriye dönüş

yapması olasılığını kaldırır. (Yani heryede kullanamayız.)

######yani

sayac(Sayi):-

write(Sayi), nl,

yeni_sayi=Sayi+1,

sayac(Yeni_sayi).

Sondan Rekursiyonu Engelleme

Engellemek için :

● Başka prosedürü son adımda çağırmamak.

● Başka bir alternatif bırakmak.

(Bu ne midir? *)

Rekursiyonda Cut Kullanımı

Rekursif Prosedürleri çalıştırırken bazı noktalarda durdurmamız gerekir. bunun

için içinde bir koşul yazarak bu prosedürü durdurabiliriz.sayac(Sayi):-

Sayi>=0,!, /*Burada sayı 0 dan küçük olma durumunda boş bir sonuç döndürür*/

Sayi<1000,!, /*Burada ise sayı 1000 i geçtiği takdirde programı sonlandırması için*/

write(Sayi),

write(","),

Ysayi is Sayi+1,

sayac(Ysayi).

sayac(_):-

write("Sayi negatiftir.").

swipl_hakkinda.pl #oguzhancoo

%Değişken tanımları

?- assert(like(x,y)). %kabukta

like(x,y). %dosyada

%kabukta dosya çağırırken

?- [‘dosya.pl’].

%Konsole’da çalıştırırken

swipl -f dosya.pl

Args On The Loop%factorial

fact(Num,NumF):-

m_fact(Num,NumF,1,1).

m_fact(Num,NumF,I,P):-

I<=Num,!,

NewP=P*I, %kendisini yeni değerlerle çağırır

NewI=I+1, % //

m_fact(Num,NumF,NewI,NewP).

m_fact(Num,NumF,I,P):-

I>Num,

NumF=P.

%P=P+1 prologda değişken ataması yapmaz.

%YP = P+1 şeklinde yeni bir değişken sorunu çözecektir.

fact.pl%factorial

factorial(N,Fact) :-

fact_iter(N, 1, Fact).

fact_iter(0, SoFar, SoFar) :- !.

fact_iter(N, SoFar, Ans) :-

N1 is N - 1,

SoFar1 is N * SoFar,

fact_iter(N1, SoFar1, Ans).

%source http://www.cs.toronto.edu/~sheila/384/w11/simple-prolog-examples.html

hanoi.pl%hanoi towers

move(1,X,Y,_) :-

write('Disk '),

write(X),

write(' ten '),

write(Y),

write(' ye taşındı.'),

nl.

move(N,X,Y,Z) :-

N>1,

M is N-1,

move(M,X,Z,Y),

move(1,X,Y,_),

move(M,Z,Y,X).

Recursive Data Structures

recursive_exmp.pl

%A(B(D,E),C(F,G))

A

B C

D E F G

%Depth First Searching

tree_exmp.pl%DOMAINS

agac_yapisi=agac(string, agac_yapisi, agac_yapisi); bos_dal

%PREDICATES

agaci_tara(agac_yapisi)

%CLAUSES

agaci_tara(bos_dal).

agaci_tara(agac(Isim, Sol, Sag)):-

write(Isim, '\n'),

agaci_tara(Sol), agaci_tara(Sag).

%GOAL

agaci_tara(agac("Emine", agac("Ali", agac("Hasan", bos_dal, bos_dal),agac("Fatma", bos_dal, bos_dal)), agac("Ayse",

agac("Fuat", bos_dal, bos_dal),agac("Leyla", bos_dal, bos_dal)))).

swipl -s tree.exmp.pl ?-agaci_tara(agac("Emine", agac("Ali", agac("Hasan", bos_dal, bos_dal),agac("Fatma", bos_dal, bos_dal)),

agac("Ayse", agac("Fuat", bos_dal, bos_dal),agac("Leyla", bos_dal, bos_dal)))).

Emine

Ali

Hasan

Fatma

Ayse

Fuat

Leyla

yes

?-

ağaç oluşturmak

#s

Ağaç biçiminde bir yapı oluşturmanın bir yolu

operatörlerden ve argümanlardan oluşan iç içe

geçmeli bir yapı yazmaktır.

agac_olustur(Sayi, agac(Sayi, bos_dal, bos_dal))

# Eğer Sayi bir sayı ise, agac(Sayi, bos_dal,

bos_dal) tek hücreli bir ağaç olup veri olarak bu

sayıyı içerir.

sola_yerlestir(Sayi, agac(A, _,B), agac(A,Sayi,B))

#İlk ağacı, ikinci ağacın alt dalı olarak alır ve üçüncü ağacı

da sonuç olarak verir.

domains

agac_yapisi=agac(string,agac_yapisi,agac_yapisi)

tek daldan oluşan ağaç

agac_olustur(String, deger)

dal birleştirme

sola_yerlestir(deg1,degx,degy)

saga_yerlestir(deg1,degx,degy)