Tablo 7.3: Liste eşleştirme örnekleri

7.2.4. Listelerin Kullanılması

Listeler gerçek anlamda rekursiv bileşik veri yapıları olduklarından bunların kullanılmaları için rekursiv algoritmaların kullanılması gerekir. Liste işlemesinin en temel yöntemi, listenin son elemanına ulaşıncaya kadar listenin her elemanını incelemektir. Bu tür işlemde kullanılması gereken algoritmalar genelde iki cümleden oluşurlar. Bir cümle, baş ve kuyruk olarak ikiye bölünebilen listeler için, ikincisi ise boş listeler için kullanılır.

Örneğin aşağıdaki programda bir listenin elemanlarını nasıl görüntüleyeceğimizi görelim:

DOMAINS

benim_listem = string*

PREDICATES

benim_listemi_yaz(benim_listem)

CLAUSES

benim_listemi_yaz ([]).                /*Liste boş ise yapılacak bir şey yok.*/

benim_listemi_yaz ([Bas|Kuyruk]):-write(Bas), nl,

benim_listemi_yaz (Kuyruk).

GOAL benim_listemi_yaz([“Visual”, “Prolog”, “4.0”]). 

Bu programdaki benim_listemi_yaz ([“Visual”, “Prolog”, “4.0”] sorgusuyla Bas=”Visual”, Kuyruk=[“Prolog”,”4.0″] değerlerini alır ve Visual değeri yazılır. Daha sonra benim_listemi_yaz yüklemi rekursiv olduğu için [“Prolog”, “4.0”] kısmı yeniden bölünür. Bu kez Bas=Prolog, Kuyruk=4.0 olur ve Prolog değeri görüntülenir. Rekursiv işlem bir kez daha “4.0” için uygulanır ve bu defa Bas=4.0, Kuyruk=[] olur. Kuyruk kısmı boş liste olduğundan sadece 4.0 görüntülenir. Rekursiv çağrı bu kez boş liste için yapılır, fakat listenin Baş ve Kuyruk kısımlarının eşleşebilecekleri değer olmadığından, program akışındaki benim_listemi_yaz([]) cümlesi çağrılır ve program bir şey yapmadan normal şekilde durur. benim_listemi_yaz ([]) şeklindeki cümle, programın normal bir biçimde durmasını sağlar.

7.2.5. Liste Elemanlarının Sayılması

Bir listenin kaç elemandan oluştuğunu nasıl bulabiliriz? Bunun için kullanılması gereken temel mantık şudur.

Liste boş [] ise, listedeki toplam eleman sayısı 0’dır.

Bunun dışındaki listelerin eleman sayısı 1+ Kuyruk Uzunluğu ile bulanabilir. Prolog’da karşılığı aşağıda verilmiştir.

DOMAINS

liste=integer*

PREDICATES

liste_uzunlugu(liste, integer)

CLAUSES

liste_uzunlugu([], 0).

liste_uzunlugu([_|Kuyruk],Eleman_sayisi):-liste_uzunlugu(Kuyruk, Kuyruk_uzunlugu),

Eleman_sayisi=Kuyruk_uzunlugu+1.

GOAL liste_uzunlugu([1, 2, 3], Eleman_sayisi).

İlk cümledeki [_|Kuyruk] boş olmayan bütün listelerle eşleşebilir. Bizim için önemli olan kısım listenin kuyruk kısmı olduğu için baş kısmı yerine anonim değişken kullanılmıştır.

GOAL liste_uzunlugu([1, 2, 3], Eleman_sayisi).

sorgusu ikinci cümle ile eşleşir ve Kuyruk=[2, 3] olur. Daha sonraki adım Kuyruk uzunluğunu hesaplamaktır. Bu yapıldığı zaman Kuyruk=2 olur. Uzunluk=kuyruk_uzunluğu+1 olduğundan Uzunluk=3 olur.

Liste_uzunlugu yüklemi kendisini çağırarak [2, 3] listesinin uzunluğunu bulur. Bunun için

·       Cümledeki kuyruk=[3] değerini alır.

·       Kuyruk_uzunlugu=Eleman_sayisi değerini alır.

Her rekursiv cümlenin kendisine ait değişken kümesi olduğundan, cümledeki kuyruk_uzunlugu ve sorgudaki kuyruk_uzunlugu birbirine karışmadığı unutulmamalıdır.

Bu durumda bütün mesele [3] uzunluğunu bulmaktır. Bu 1 olduğu için buna 1 ilave edilirse [2, 3] için toplam uzunluk 2 olur. [3] listesinin uzunluğu için liste_uzunlugu yüklemi kendisin tekrar çağırır. Bu kez [3] listesinin kuyruk uzunluğu Kuyruk=[] olur. Kuyruk uzunluğunu hesaplamak için ise liste_uzunlugu([], Kuyruk_uzunlugu) ilk cümle ile eşleşir ve Kuyruk_uzunlugu=0 olur. Şimdi bilgisayar bu değere, yani 0’a 1 ilave ederek [3]’ün uzunluğunu bulur. Buna 1 ilave ederek [2, 3]’ün uzunluğunu bulur. Nihayet buna da 1 ilave ederek [1, 2, 3] listesinin toplam uzunluğunu bulur.

Şimdi bu işlemlerin tamamını sıralayarak konuyu biraz daha netleştirelim.

Liste_uzunlugu([1, 2, 3], Eleman_sayisi1).

Liste_uzunlugu([2, 3], Eleman_sayisi2).

Liste_uzunlugu([3], Eleman_sayisi3).

Liste_uzunlugu([], 0).

L3=0+1=1

L2=L3+1=2

L1=L2+1=3

7.2. Sondan Rekursiyona Yeniden Bakış

Rekursiv bir çağrı, cümledeki son adım olamayacağı için liste_uzunlugu’nun sondan rekursiv olamayacağı bellidir. Bunu sondan rekursiv yapmanın yolu vardır.

Burada problem olan şey, kuyruk uzunluğu bilinmeden bir listenin toplam uzunluğunun hesaplanamayışıdır. Yani bu probleme bir çözüm bulunabilirse, liste_uzunlugu yüklemini sondan rekursiv yapmak mümkündür. Bunun için liste_uzunlugu yükleminin üç argümanının olması gerekir.

1.     Birincisi, her seferinde kırpılarak sonunda boş bir liste elde edilecek listenin kendisi.

2.     Bir diğeri, liste uzunluğunu saklayacak boş bir değişken

3.     Sonuncusu ise 0 ile başlayan ve her seferinde değerinin 1 arttığı bir sayaç değişken.

Geriye sadece boş olan liste kaldığı zaman bu sayaç hiçbir değişkene atanmamış olan sonucu alır.

DOMAINS

liste=integer*

PREDICATES

liste_uzunlugu(liste, integer, integer)

CLAUSES

liste_uzunlugu([], Sonuc, Sonuc).

liste_uzunlugu([_|Kuyruk], Sonuc, Sayac):-

Yeni_sayac=Sayac+1,

liste_uzunlugu(Kuyruk, Sonuc, Yeni_Sayac).

GOAL liste_uzunlugu([1, 2, 3], Uzunluk, 0), write (“Uzunluk =”, Uzunluk), nl.

Verilen bir listedeki elemanlar üzerinde işlem yaptıktan sonra bu elemanların yerine hesaplanan elemanlardan oluşan başka bir liste oluşturmak mümkündür. Aşağıdaki örnekte listenin her elemanını 1 ilave ederek yeni bir liste elde edilmiştir.

DOMAINS

liste = integer*

PREDICATES

yeni_deger_ilave_et(liste, liste)

CLAUSES

yeni_deger_ilave_et([], []).  /* İlk şart*/

yeni_deger_ilave_et([Bas|Kuyruk],[Bas1|Kuyruk1]):- /* Bas ve Kuyruk ayrılması*/

Bas1=Bas+1,            /* Listenin ilk elemanına 1 ilave et*/

yeni_deger_ilave_et(Kuyruk, Kuyruk1).  /* elemanı listenin geriye kalanıyla çağır*/

GOAL yeni_deger_ilave_et([1, 2, 3], Yeni_Liste).

Yukarıda yapılan işlemler, sözel olarak aşağadaki şekilde yazılır.

Boş bir listenin bütün elemanlarına 1 ilave etmek için sadece başka bir boş liste oluştur.

Boş olmayan herhangi bir listenin bütün elemanlarına 1 ilave etmek için, listenin baş kısmına 1 ilave et ve ilave edilen bu değeri yeni listenin başı olarak al. Daha sonra kuyruk kısmının bütün elemanlarına 1 ilave et ve yeni değerleri de yeni listenin kuyruk kısmı olarak al. Sonucu Yeni_liste olarak ekranda görüntüle.

Verilen liste [1, 2, 3] olduğu için:

1.     Önce Baş ve Kuyruk kısımları ayrılır ve sırasıyla [1] ve [2, 3] olurlar.

2.     Sonuç listenin baş ve kuyruk kısımlarına Bas1 ve Kuyruk1 değerlerini ata. Burada Bas1 ve Kuyruk1’in henüz değer almadığına dikkat edilmelidir.

3.     Bas kısmına 1 ilave et ve Bas1’i elde et.

4.     Rekursiv olarak Kuyruk kısmındaki bütün elemanlara 1 ilave et ve Kuyruk1’i elde et.

Bu yapıldığı zaman Bas1 ve Kuyruk1 kendiliğinden sonuç listesinin Bas ve Kuyruk kısmı olur. Bunları birleştirmek için ayrı bir operasyon gerekmez. Dolayısıyla rekursiv çağrı gerçekten de prosedürün son adımı durumundadır.

Örnek:

Bir listedeki sayıları tarayıp negatif olanları eleyen program

DOMAINS

liste=integer*

PREDICATES

negatifleri_ele(liste, liste)

CLAUSES

negatifleri_ele([], []).

negatifleri_ele([Bas|Kuyruk], IslenmisKuyruk):-

Bas<0, !, negatifleri_ele(Kuyruk, IslenmisKuyruk).

negatifleri_ele([Bas|Kuyruk], [Bas|IslenmisKuyruk]):-

negatifleri_ele(Kuyruk, IslenmisKuyruk).

GOAL negatifleri_ele([2, -45, 3, 4, -5, -45], Yeni_Liste).

Aşağıdaki yüklem, bir listenin her elemanını başka bir listeye iki kez aktarmaktadır.

elemanlari_ikile([], []).

elemanlari_ikile([Bas|Kuyruk], [Bas, Bas|Ikilenmis_Kuyruk]):-

elemanlari_ikile(Kuyruk, İkilenmis_Kuyruk).

7.3. Liste Elemanlığı

Ahmet, Mehmet, Hasan ve Nejla isimlerini eleman olarak içeren bir listede, örneğin Ahmet isminin var olup olmadığını öğrenilmek istensin. Yani isim ve bir isim arasında bir ilişki sorgulansın. Bunun için kullanılan bir yüklem vardır.

uye(isim, isimlistesi).  /*Burada ‘isim’ listede geçen bir isimdir.*/

DOMAINS

isim_listesi = isim*

isim = symbol

PREDICATES

nondeterm uye(isim, isim_listesi)

CLAUSES

uye(Isim, [Isim|_]).

uye(Isim, [_|Kuyruk]):- uye(Isim, Kuyruk).

GOAL uye(ahmet, [ mehmet, ahmet, hasan, nejla]).

Yukarıdaki örnekte önce birinci cümleyi inceleyelim. uye(Isim, [Isim|_]) cümlesindeki Isim değişkeni listenin öncelikle baş kısmında araştırılır. Eğer eşleşme sağlanırsa üyeliğin var olduğu sonucuna varılır ve olumlu sonuç görüntülenir. Listenin kuyruk kısmı bizi ilgilendirmediği için burada anonim değişken kullanılmıştır.

Eğer aradığımız isim listenin baş kısmı ile eşleşmezse bu kez listenin kuyruk kısmını incelemek için ikinci cümle kullanılır.

7.4. Listeleri Birleştirme

Aşağıdaki iki cümleyi tekrar inceleyelim. Bu iki cümleye prosedürel ve dekleratif olarak bakmak mümkündür.

uye(Isim, [Isim|_]).

uye(Isim, [_|Kuyruk]):- uye(Isim, Kuyruk).

Bu cümlenin dekleratif olarak anlamı şudur:

Eğer cümlenin baş kısmı Isim değişkenine eşitse, bu durumda Isim, listenin bir elemanıdır. Bu durum doğru değilse, Isım değişkeni kuyruk kısmının üyesi ise Isim listenin bir elemanıdır.

Prosedürel olarak bu iki cümle şöyle yorumlanabilir.

Bir listedeki herhangi bir elemanı bulmak için, listenin baş kısmını; aksi takdirde, bu listenin kuyruk kısmının bir üyesini bulunuz.

Bu iki durumu denemek için uye(2, [1, 2, 3, 4]) ve uye[X, [1, 2, 3, 4]) sorgularını kullanınız. İlk sorgu, bir durumun doğru olup olmadığını sorgulamak için kullanılırken, ikinci sorgu listenin bütün üyelerini bulmak için kullanılmaktadır.

7.5. Rekursiyona Prosedürel Bir Bakış

Bu kısımda bir listeyi başka bir listeye ekleyen bir yüklem oluşturulacaktır. Ekle yükleminin üç argümanla birlikte tanımlanması gerekir.

Ekle(Liste1, Liste2, Liste3)

Ekle yüklemi Liste1’i Liste2’ye ilave ederek Liste3’ü elde eder. Eğer Liste1 boş ise, bu durumda 1. Listeyi 2. Listeye ilave etmek bir şeyi değiştirmez. Yani:

Ekle([], Liste2, Liste2).

Eğer liste1 boş değilse,

Ekle([Bas|Kuyruk1], Liste2, [Bas|Kuyruk3]):-ekle (Kuyruk1, Liste2, Kuyruk3]).

Liste1 boş değilse, rekursiv olan yüklem her seferinde bir elemanı Liste3’e transfer eder. Liste1 boş olduğunda ilk cümle Liste2’yi liste3’ün sonuna ilave eder.

Örnek:

DOMAINS

sayilar=integer*

PREDICATES

ekle(sayilar, sayilar, sayilar)

CLAUSES

ekle([], Liste, Liste).

ekle([Bas|Kuyruk1], Liste2, [Bas|Kuyruk3]):-

ekle (Kuyruk1, Liste2, Kuyruk3).

GOAL ekle ([1, 3, 5], [2, 4, 6], Yeni_Liste).

Yukarıdaki programı sadece birleştirilen iki listenin sonucunu almak için değil, aynı zamanda sonuç listesini yazıp ilk iki liste için geçerli bütün alternatifleri bulmak için kullanmak mümkündür. Örneğin GOAL ekle (Birinci_Liste, Ikinci_liste, [2, 4, 5, 6]). Denendiğinde toplam 5 çözüm bulunur. Ayrıca GOAL ekle ([3, Ikinci_eleman],Liste_2, [3, 4, 5, 6]) şeklindeki bir sorgu ile birinci listenin, örneğin ikinci elemanı ve ikinci listenin tamamını bulmak da mümkündür.

7.6. Bütün Çözümleri Bir Defada Bulma

Rekursiyon ve geriye iz sürme işlemlerini karşılaştırırken rekursiyonun daha avantajlı olduğu daha önce belirtilmişti. Bunun nedeni, rekursiyon esnasında argümanlar vasıtasıyla aradaki adımlarda elde edilen verilerin saklanabilmesidir. Öte yandan geriye dönüş işlemi bir sorguyu sağlayan bütün çözümleri bulabilirken, rekursiyon bunu yapamaz.

Bunun için Prolog’un hazır yüklemlerinden olan findall yüklemi kullanılır. Findall bir sorguyu kendi argümanlarından biri olarak alır ve bu sorgunun bütün çözümlerini tek bir liste altında toplar. Findall yükleminin toplam 3 argümanı vardır.

·       İlk değişken, örneğin Degisken_Ismi, yüklemden listeye aktarılacak değişkenin hangisi oldugunu gösterir.

·       İkinci değişken, örneğin yeni_yuklem, değerlerin alınacağı yüklemi gösterir.

·       Üçüncü argüman, örneğin Yeni_Degisken, geriye dönüş işlemiyle elde edilen değerlerin listesi tutan bir değişkendir. Yeni_degisken değerlerinin ait olduğu bir tip tanımının kullanıcı tarafından yapılmış olması lazımdır.

Bir gruptaki yaş ortalamasını bulan bir program, aşağıdaki şekilde yazılabilir.

DOMAINS

isim, adres = string

yas = integer

liste = yas*

PREDICATES

nondeterm kisi(isim, adres, yas)

toplam_liste(liste, yas, integer)

calistir

CLAUSES

toplam_liste([], 0, 0).

toplam_liste([Bas|Kuyruk], Toplam, N):-

toplam_liste(Kuyruk, S1, N1),

Toplam=Bas+S1, N=1+N1.

kisi(“Oktay DUYMAZ”, “Cumhuriyet Cad.”, 36).

kisi(“O.Faruk AKKILIÇ”, “Nail Bey Mah. “, 30).

kisi(“Hakay TAŞDEMİR”, “Firat Cad. No: 17”, 28).

calistir:-

findall(Yas, kisi(_,_, Yas), L),

toplam_liste(L, Toplam, N),

Ortalama=Toplam/N,

write(“Ortalama = “, Ortalama), nl.

GOAL calistir.

Programdaki findall cümlesi L listesini oluşturarak kisi yükleminden elde edilen bütün yaşları buraya aktarır.

7.7. Bileşik Listeler

Şimdiye kadar oluşturulan listelerde daima aynı türden olan elemanlar saklanmıştır. Listeler tamsayı, symbol vs.den oluşuyordu. Bir liste içerisinde farklı tipte elemanları bir arada yazmak oldukça faydalı olur. Birden fazla tipte olan elemanları bir arada tutmak için özel tanımlamaların yapılması gerekir. Bu da farklı operatörler tanımlamakla olur.

Örnek:

Domains.

Benim_listem = 1(liste); i(integer); c(char); s(string)

Liste=benim_listem*

[i(2), i(9), 1([s(“araba”), s(“bilgisayar”)]), s(“kalem”)]

Örnek:

DOMAINS

benim_listem =l(liste); i(integer); c(char); s(string)

liste=benim_listem*

PREDICATES

ekle(liste, liste, liste)

CLAUSES

ekle([], L, L).

ekle([X|L1], L2, [X|L3]):-

ekle(L1, L2, L3).

GOAL

ekle([s(sever), l([s(ahmet), s(deniz)])], [s(ahmet), s(ayse)], Sonuc),

write(“Ilk Liste : “, Sonuc, “\n”),

ekle([l([s(“Bu”), s(“bir”), s(“listedir.”)]), s(test)], [c(‘c’)],Sonuc2),nl,

write (“İkinci Liste: “, Sonuc2,’\n’).

8. AKIŞ DENETİMİ

Bir yüklem içinde değeri bilinen değişkenlere input (giriş değişkenleri), bilinmeyenlere ise output (çıkış değişkenleri) denir. Bu argümanların, input argümanları ise başlangıç değeri verilerek, output argümanları ise çıktı almak üzere uygun biçimde kullanılmasına akış biçimi denir. Örneğin bir argümanın iki değişkenle çağrılması durumunda 4 farklı akış biçiminden söz edilebilir.

(i, i)                      (i,o)                 (o,i)                 (o, o)

Programlar derlendiği zaman yüklemlerin global bir akış analizi yapılır. Ana sorgu ile başlayıp bütün programın değerlendirmesi yapılır. Bu esnada programdaki bütün yüklemlere akış biçimleri atanmış olur.

Akış analizi oldukça basittir. Çünkü program yazarken farkında olmadan aynı şey tarafımazdan da yapılmaktadır.

Örnek:

GOAL cursor(R, C), R1=R+1, cursor(R1, C).

Cursor yüklemine yapılan ilk çağrıda R ve C değişkenlerinin hiçbir değeri olmadığı için serbest değişken durumundadırlar. Dolayısıyla akış biçimi cursor(o, o) olur. R1=R+1 ifadesinde R değişkeninin değeri cursor yükleminden geleceği için, R değişkenin bağlı olduğu bellidir. Bu çağrıdan sonra R1 değişkeni değer almış olur. Eğer R değişkeni boş olsaydı, bu durumda bir hata mesajı görüntülenirdi.

Cursor yükleminin son kez çağrılmasında R1 ve C değişkenlerinin ikisi de önceden çağrıldığı için artık giriş değişkenleri olarak işlem görürler. Yani çağrının akış biçimi cursor(i, i) olur.

Burada sadece DOS Metin Modu ortamında çalışan aşağıdaki örnekler irdenelecektir.

Predicates

ozellik_degistir(Integer, Integer)

Clauses

ozellik_degistir(Yeni_ozellik,Eski_ozellik):-ozellik(Eski_ozellik), ozellik(Yeni_ozellik).

GOAL ozellik_degistir(112, Eski), write(“Merhaba”), ozellik(Eski, write(” millet”).

GOAL kısmındaki ilk çağrı ozellik_degistir(i, o) ile yapılır. Burada 112 bilinen, Eski ise bilinmeyen değişkendir. Bu durumda ozellik_degistir cümlesi Yeni_ozellik değişkeni ile çağrıldığında bunun değeri belli olduğu için input, Eski_ozellik’in değeri belli olmadığı için output olacaktır. Akış denetçisi ilk alt hedef olan ozellik(Eski_ozellik) cümlesine geldiği zaman ozellik yüklemi ozellik(o) akış biçimi ile çağrılır. Ozellik yükleminin ikinci çağrılışı ozellik(i) şeklinde olacaktır. Ana sorgudaki ozellik yüklemine yapılan çağrı input olacaktır, çünkü ozellik_degistir yükleminden alınır.

8.1. Bileşik Akış

Bir yüklemdeki değişken bileşik bir nesne ise, akış biçimi bileşik bir şekilde olabilir. Şimdi aşağıdaki örnekte olduğu gibi, bir ülke hakkında bilgilerin verildiği bir veritabanı düşünelim. Yeni bilgileri rahatlıkla ilave edebilmek için her bilgiyi kendi tipiyle saklamak istenebilir.

DOMAINS

ulke_bilgileri=alan(string, ulong); nufus(string, ulong);baskent(string, string)

PREDICATES

nondeterm ulke(ulke_bilgileri)

CLAUSES

ulke(alan(“Türkiye”,876000)).

ulke(nufus(“Türkiye”, 65000000)).

ulke(baskent(“Türkiye”, “Ankara”)).

ulke(alan(“Almanya”,840000)).

ulke(nufus(“Almanya”, 50000000)).

ulke(baskent(“Almanya”, “Bohn”)).

GOAL ulke(alan(Ad, Alan)), ulke(nufus(Ad, Nuf)).

Sorguyu aşağıdaki cümlelerle deneyiniz:

ulke (C)                                                   (o)

ulke(alan(Ulke_adi, Alani))                    (o,o)

ulke(nufus(“Türkiye”, Nuf))                    (i, o)

ulke(baskent(“Türkiye”, “Ankara”))        (i)

Son örnekteki bütün terimler bilindiği için akış biçim düz metindir.

8.2. Yüklemlerin Akış Biçimlerini Tanımlama

Yüklemler için uygun bir akış biçimi tanımlamak bazen daha güvenlidir. Yüklemlerin sadece özel akış biçimleri durumunda geçerli olacağı biliniyorsa, önceden akış biçimi tanımlamak faydalıdır. Çünkü bu durumda akış denetçisi bu yüklemlerden yanlış kullanılanı çok rahatlıkla bulabilir. Tip tanımı yapıldıktan sonra ‘-‘ işareti yazarak akış biçimi vermek mümkündür.

PREDICATES

musteri_bilgi_listesi(string, string, slist) -(i, o, o)(o, i, o)

8.3. Akış Analizini Kontrol Etmek

Analiz mekanizması, standart bir yüklemin yanlış bir akış biçimi ile çağrıldığını tesbit ettiği an hata mesajı verir. Bu hata mesajı, standart yüklemleri çağıran yüklemler tanımladığımız zaman, bunlardan akış biçimi anlamsız olanları tesbit etmede bize yardımcı olur.

Örnek:

C=A+B

ifadesinde A ve B serbest değişken olduğundan, akış denetçisi bu yüklem için akış biçimi olmadığını bildiren bir hata mesajı verecektir. Bu durumu kontrol etmek için free ve bound standart yüklemleri kullanılır.

İki sayı arasında toplama yapmak veya toplam ile ilk sayısı verilen bir durumda ikinci sayıyı bulan, bütün akış biçimleriyle çağrılabilen topla adında bir yüklem tanımlayalım.

Örnek:

PREDICATES

nondeterm topla(integer, integer, integer)

nondeterm sayi(integer)

CLAUSES

topla(X,Y,Z):-

     bound(X),

     bound(Y),

     Z=X+Y. /* (i,i,o) */

topla(X,Y,Z):-

     bound(Y),

     bound(Z),

     X=Z-Y. /* (o,i,i) */

topla(X,Y,Z):-

     bound(X),

     bound(Z),

     Y=Z-X. /* (i,o,i) */

topla(X,Y,Z):-

     free(X),

     free(Y),

     bound(Z),

     sayi(X),

     Y=Z-X. /* (o,o,i) */

topla(X,Y,Z):-

     free(X),

     free(Z),

     bound(Y),

     sayi(X),

     Z=X+Y. /* (o,i,o) */

topla(X,Y,Z):-

     free(Y),

     free(Z),

     bound(X),

     sayi(Y),

     Z=X+Y. /* (i,o,o) */

topla(X,Y,Z):-

     free(X),

     free(Y),

     free(Z),

     sayi(X),

     sayi(Y),

     Z=X+Y. /* (o,o,o) */

  /* 0’dan başlayan sayıları bulma*/

sayi(0).

sayi(X):-

     sayi(A),

     X = A+1.

GOAL topla(Ilk_sayi,7,10).

8.4. Referans Değişkenler

Akış denetçisi bir cümleyi incelerken, bu cümlenin başındaki bütün çıktı değişkenlerinin cümlenin gövdesinde bağlı olup olmadığını kontrol eter. Bir cümlede bir değişken bağlı değilse, bu değişkenin referans değişkeni olarak işlem görmesi gerekir. Bu karmaşayı gösteren bir örnek aşağıda verilmiştir.

Predicates

p(integer)

Clauses

p(X):-!.

Goal p(V), V=99, write(V).

Sorgudaki p yüklemi çıktı biçiminde çağrılır fakat clauses bölümündeki p yükleminde bulunan X değişkeni bağlı değişken değildir. Akış denetimi sırasında bu fark edildiğinde, değişkenin domains bölümündeki tip tanımına bakılır. Eğer değişken tipi referans olarak tanımlıysa problem çıkmaz. Tanımsızsa uyarı mesajı görüntülenir.

Bir cümledeki bir değişken bağlı değilse, bu durumda cümlenin herhangi bir değer aktarması mümkün değildir. Bunun yerine referans değişkenine bir pointer yollayarak daha sonra bu noktaya gerçek değerin yazılması sağlar. Bu, bu tipteki bazı değişkenlere değer aktarmak yerine, tip tanımının tamamına aynı işlemin yapılmasını gerektirir. Kayıtlara gönderilen pointerlar referans tipe ait argümanlara iletilir. Yani bileşik bir tip referans bir tip haline gelirse, bu durumda bütün alt tiplerin de referans tip olarak işlem görmesi gerekir. Bileşik bir tipin referans tip olarak tanımlanması durumunda, derleyici diğer bütün alt tipleri de referans tip olarak kabul eder.

8.4.1. Referans Tip Tanımı

Akış denetçisi program içerisinde bağımsız bir değişken bulduğunda değişken sadece bir cümleden dönüş sırasında bağımlı değilse uyarı verir. Bu durum sizin için uygunsa, bu tip tanımı otomatik olarak referans tip olarak kabul edilir. Bununla birlikte referans tip olarak tanımlamak istenen bir tipi domains bölümünde net olarak tanımlamak daha mantıklıdır.

8.4.2. Referens Tip ve İzleme Dizileri(array)

Zorlama ve ekstra eşleştirme gerektirdiği için, referans tipler programın çalışma hızında genel bir azalmaya neden olur. Fakat referans tip tanımının neden olduğu problemler daha etkili biçimde kullanılabilir ve bu tip tanımlarının etkileri azaltılabilir.

Referans tipler kullanıldığı zaman, Visual Prolog izleme dizini kullanır. Bu izleme dizini referans değişkenlerin değer aldıkları anı bildirmek için kullanılırlar. Referans bir değişkenin oluşturulması ve değer alması arasındaki herhangi bir noktaya geriye dönüş yapıldığı zaman, bu değişkenin yeniden değer almamış hale getirilmesi gerekir. Fakat bu problem düz değişkenlerle uğraşırken meydana gelmez. Çünkü bunların oluşturulması ve değer alma noktaları aynıdır. İzlemede kaydedilen her bir çağrı 4 byte (32 bit bir pointerin büyüklüğü) kullanır.

Gerektiğinde kuyruk büyüklüğü otomaki olarak arttırılır. İzin verilen maksimum büyüklük 16-bit Visual Prolog için 64K, 32-bit için ise sınırsızdır.

Standart tipleri referans tip olarak kullanmak iyi bir fikir değildir. Çünkü program kullanıcının tanımladığı bu referans tipi, aynı tip için daima geçerliymiş gibi kullanır. Bunun yerine, istenilen temel tip için referans bir tip tanımlamak daha uygundur. Örneğin aşağıdaki program parçasında kullanıcının tanımladığı tamsayi_referans_tipi tamsayılar için referans tiptir. Dolayısıyla tamsayi_referans_tipi her kullanımda referans tip olarak işlem görür. Fakat tamsayı tipindeki değişken referans tip olarak değil, normal olarak integer olarak işlem görür,.

Domains

tamsayi_referans_tipi= reference integer

Predicates

P(tamsayi_referans_tipi)

Clauses

P(_).

8.5. Referans Tip Kullanımı

Referans tip kullanımının en doğru biçimi, sadece gerekli olan birkaç yerde kullanıp geri kalan kısımların tamamında referans olmayan tipi kullanmaktır. Zaten gerekli olan durumlarda referans ve referans olmayan tipler arasında dönüşüm yapmak mümkündür. Şimdi referans olan bir tamsayıyı referans olmayan bir tamsayıya dönüştürelim.

Domains

Referans_tamsayi=reference integer

Predicates

Donustur(referans_tamsayi, tamsayi)

Clauses

Donustur(X, X).

İsmi aynı olan bir değişken referans ve referans olmayan tipte kullanıldığı zaman dönüşüm otomatik olarak yapılır. Yukarıdaki örnekte referans_tamsayi ve tamsayi arasında dönüşüm otomatik olarak yapılır. Referans bir değişkenin, referans olmayan bir değere dönüştürülebilmesi için öncelikle bir değer almış olması gerekir. Yani referans tip olarak tanımlı bir değişkeni dönüştürmek için (örneğin referans tamsayılardan referans karaktere) öncelikle bu değişkenin bir değer almış olduğundan emin olmak gerekir. Aksi takdirde serbest değişken kullanılamaz şeklinde hata mesajı görüntülenir. Referans tip tanımlarının nasıl çalıştığını tam olarak anlamak için aşağıdaki programı değişik sorgularla çalıştırılmalıdır.

DOMAINS

referans_tamsayi = integer

referans_liste= reference referans_tamsayi*

PREDICATES

nondeterm eleman(referans_tamsayi, referans_liste)

ekle(referans_liste, referans_liste, referans_liste)

CLAUSES

eleman(X, [X|_]).

eleman(X, [_|L]):-

eleman(X, L).

ekle([], L, L).

ekle([X|L1], L2, [X|L3]):-

ekle(L1, L2, L3).

GOAL eleman(1, L).

Aşağıdaki sorguları da deneyin

eleman(X, L), X=1.  Elemanları arasında 1 olan bütün listeleri bul.

eleman(1, L), eleman(2, L). Elemanları arasında 1 ve 2 olan bütün listeleri bul

X=Y, eleman(X, L),eleman(Y, L), X=3. X ve Y’nin eleman olduğu listeler

eleman(1, L), ekle(L, [2, 3], L1).

ekle(L, L, L1), eleman(1, L). 1’in iki kez eleman olduğu listeler.

8.6. Akış Biçimine Yeni Bir Bakış

Referans bir değişken serbest halde olmasına rağmen, bir yüklem çağrısı içinde çağrıldığı anda mevcut olabilir. Ülkeler hakkındaki programda ayni_baskentler:-ulke(baskent(Kent, Kent), write(Kent, ‘\n’), fail şeklindeki bir sorguyla, başkentleri ülke ismiyle aynı olan bütün ülkeleri bulmak isteyelim. Burada kent değişkeni iki kez çıktı akışı ile kullanılmıştır. Fakat bu sorgu satırının söylediği şey; Kent değişkeni değer aldığı anda ikinci değişken olan Kent’in de aynı değeri alması gerektiğidir. Bu yüzden her iki değişken çağrı yapılmadan önce yaratılıp eşleştirilir. İşte bunu yapabilmek için bunların tipi referans tipe dönüştürülür ve iki değişken çağrı anından itibaren kullanıma girerler.

Standart tip tanımlarının referans tip haline getirmenin çok yanlış bir kullanım olacağı daha önce söylenmişti. Eğer böyle bir şey yapılmak isteniyorsa, uygun bir referans tip tanımlamak daha mantıklıdır.

8.7. İkili (Binary) Ağaç Yapısının Referans Tip İle Kullanımı

Önceki sıralama işlemleri ikili ağaç yapısı ile çözülmüştü. Aynı şeyi referans tip tanımı ile daha güzel biçimde yapmak mümkündür. Ağaç yapısındaki bir dalı, bir değer aldıktan sonra değiştirmek mümkün değildir. Ağaç oluşturulurken pek çok noktanın kopyası oluşturulur. Sıralama işlemini büyük miktarda veri üzerinde yapıldığı düşünülürse, bunun hafıza taşmasına neden olabileceği görülür. Referans bir tip, ağacın dallarını serbest değişken olarak bırakarak, bu durumu düzeltebilir. Bir referans tipi bu şekilde kullanarak yeni bir dalın ilave edileceği noktanın üzerindeki dalı kopyalamaya gerek kalmaz.

Örnek:

Domains

agac = reference t(isim, agac, agac)

isim = string

PREDICATES

araya_ekle(isim, agac)

CLAUSES

araya_ekle(ID, t(ID,_,_)):-!.

araya_ekle(ID, t(ID1, Agac,_)):-

ID<ID1, !, araya_ekle(ID, Agac).

araya_ekle(ID, t(_,_,Agac)):-

araya_ekle(ID, Agac).

GOAL

araya_ekle(“Alper”, Agac),

araya_ekle(“Kasim”, Agac),

araya_ekle(“Paki”, Agac).

İlk araya_ekle(“Alper”, Agac) alt hedefi ilk kural ile eşleşir ve bileşik nesne t(“Alper”,_,_) biçimini alır. T’deki son iki argüman bağlı değişken olmasalar da t diğer alt hedefe iletilir:

araya_ekle(“Kasim”, Agac).

Bu, agac değişkenini t(“Alper”, t(“Kasim”,_,_),_) değerini aldırır. Son olarak son alt hedef araya_ekle(“Paki”, Agac) agac değişkenini t(“Alper”, t(“Kasim”,_, t(“Paki”,_,_)),_) değerine atar ve sonuçta bu değer görüntülenir.

8.8. Referans Tip Kullanarak Sıralama

Daha önce ikili ağaç kullanarak yapılan sıralama örneğini, referans ve referans olmayan tipler arasında ayrım yaparak nasıl yapabileceğini gösteren bir örnek, aşağıda verilmiştir.

DOMAINS

agac=reference t(deger, agac, agac)

deger=integer

liste = integer*

PREDICATES

araya_ekle(integer, agac)

agac_ekle(liste, agac)

nondeterm agacin_elemanlari(integer, agac)

sirala(liste, liste)

CLAUSES

araya_ekle(Deger, t(Deger,_,_)):-!.

araya_ekle(Deger, t(Deger1,Agac,_)):-

Deger<Deger1,!,

araya_ekle(Deger, Agac).

araya_ekle(Deger, t(_,_,Agac)):-

araya_ekle(Deger, Agac).

agac_ekle([],_).

agac_ekle([Bas|Kuyruk],Agac):-

araya_ekle(Bas,Agac), agac_ekle(Kuyruk, Agac).

agacin_elemanlari(_,Kuyruk):-

free(Kuyruk),!, fail.

agacin_elemanlari(X,t(_,L,_)):-

agacin_elemanlari(X, L).

agacin_elemanlari(X,t(RefStr,_,_)):-

X=RefStr.

agacin_elemanlari(X,t(_,_,R)):-

agacin_elemanlari(X, R).

sirala(L,L1):-

agac_ekle(L, Agac),

findall(X, agacin_elemanlari(X,Agac), L1).

GOAL sirala([10,9,17,21,114,5], L), write(“Liste= “, L),nl.

Bu örnekte referans tipler sadece agac değişkeninde kullanılmıştır. Diğer argümanların tamamı referans olmayan tiplerdedir.

8.9. Binary (İkili) Tip

Visual Prolog’da ikili verileri kullanmak için özel tip, ikili terimlerin elemanlarına erişmek için özel yüklemler vardır. İkili terim kullanmanın tek amacı, başka türlü anlamlı bir şekilde gösterilemeyen verileri kullanmak ve bunları saklamaktır. Binary terimleri okuma, bunları dosyaya aktarma işlemi için özel yüklemler vardır.

Binary terimlerin temel amacı mantıksal olmayan nesneler diğer programlama dillerinin içine kolayca yerleştirilmesine imkan tanımaktır. Binary terimler, geriye iz sürme mekanizması çerçevesinde Prologdaki diğer terimlerden farklı davranırlar. Geriye iz sürme mekanizması, binary terimin oluşturulduğu noktadan öncesine giderse, binary terimlerin o ana kadar aldıkları değerleri kaybederler. Geriye dönüş, herhangi bir binary terimin oluşturulduğu noktadan öncesine dönmezse, binary terimdeki değişikliklere bir şey olmaz.

8.9.1. Binary Terimlerin Kullanılması

Bir binary terim byte biçiminde bir dizi ve bu dizinin büyüklüğünü saklayan word (16 bit) veya dword(32 bit ortam) değişkenden oluşur.

Diğer dillerden çağrı yapıldığında, binary tipindeki bir terim (diğer bir dildeki fonksiyonun çağrısayla aktarılan değişken) gerçek içeriğe işaret eder. Buradaki büyüklük alanı, alanın kendisinin sahip olduğu büyüklüktür. Binary terimler 16 bit platformlarda genelde 64K ile sınırlıdır.

8.9.2. Binary Terimlerin Yazım Biçimi

Binary terimler okunup metin biçimde yazılabilir. Visual Prolog’da program satırları gibi yazılabilir. Yazılım biçimi:

$[b1, b2, ….., bn]

Burada b1, b2 vs. ilgili terimin byte olarak yazılmış halidir. Program akışı içerisinde yazıldığı zaman, buradaki her byte uygun bir pozitif biçimde desimal, hegzadesimal, oktal veya karakter olarak yazılabilir. Karakter olarak yazılan byte, program çalışırken daima hegzadesimal biçime dönüştürülür ve “0x” kısımları bulunmaz.

Örnek:

GOAL write(“Binary terimi metin biçiminde yaz: “, $[‘C’, 12, 15, 0x14, ‘e’, 5], ‘\n’).

8.9.3. Binary Terimlerin Oluşturulması

Binary terim oluşturmak için Visual Prolog’da mevcut olan yüklemler sırayla aşağıda verilmiştir.

8.9.3.1. makebinary(1)

makebinary, tanımlanan byte sayısında bir binary terim oluşturur ve içeriğini binary 0 olarak ayarlar.

…., Bin=makebinary(10), ….

Burada byte sayısı, alan büyüklüğü hariç, net büyüklük olmalıdır.

8.9.3.2. makebinary(2)

İki argüman alabilen biçiminde eleman büyüklüğü tanımlanabilir.

…., Usize=sizeof(unsigned), Bin=makebinary(10, Usize), ….

Bu yüklem, terim büyüklüğü eleman sayısının eleman büyüklüğüyle çarpımıyla belirtilen bir binary terim oluşturur. Örnekte eleman sayısı 10, eleman büyüklüğü ise sizeof(unsigned) olarak tanımlıdır. Terim içeriği 0 olur.

8.9.3.3. composebinary(2)

Mevcut olan bir pointer ve bir uzunluktan bir binary terim oluşturur. Kullanım biçimi:

…, Bin=composebinary(StringVar, Buyukluk), ….

8.9.3.4. getbinarysize(1)

getbinarysize, verinin önündeki alan büyüklüğünü hariç tutarak, bir binary terimin net büyüklüğünü byte türünden verir.

…, Buyukluk=getbinary(Bin), …

8.9.4. Binary Terimlere Erişim

4’ü giriş, diğer 4’ü de çıkış elde etmek için kullanılan 8 yüklem binary terimlere erişmek için kullanılabilir. Bunların hepsi binary terim büyüklüğü, tanımlı indeks ve istenilen maddenin büyüklüğüne (byte, word, dword veya real) bağlı olarak bu değişkenlerin doğru aralıklarda olup olmadıklarını kontrol eder. Bu yüzden bu girişleri, ikili terimlerin tanımlı sınırları dışında tanımlamak ve çağırmak hataya neden olur.

İndislerin (eleman numaraları) 0’a göre değişir. Yani binary bir terimin ilk elemanının indisi 0, en son elemanın da N-1 olur.

8.9.4.1. getentry(2)

getentry yüklemi getbyteentry, getwordentry, getdwordentry veya getrealentry biçimlerinden biri olur ve sırasıyla byte, word, dword veya real tiplerinde giriş yapıp, giriş alabilir.

Deger= getbyteentry(Bin, 3), ….

8.9.4.2. setentry(3)

getentry’ye karşılık gelen bir yüklem olup byte, word, dword eya real girişleri yapar.

…., setbyteentry(Bin, 3, Baytlar), ….

8.9.5. Binary Terimleri Eşleştirme

Binary terimler de diğer terimler gibi eşleştirilebilir. Kullanım biçimi:

…, Bin1=Bin2, ….

Eşleştirme anında terimlerden biri serbest halde ise, birbirine eşitlenirler. Her ikisi de bağlı ise, bu durumda binary terimlerin birbirine eşit olup olmadıkları kontrol edilir.

8.9.6. Binary Terimleri Karşılaştırma

Binary iki terim eşleştirilirken şu sonuçlara dikkat edilir:

Eğer büyüklükleri farklı ise, büyük olan büyük kabul edilir, değilse byte bazında karşılaştırılırlar. İki farklı byte bulunduğu anda karşılaştırma durur, sonuç toplam terimin karşılaştırılması olarak gönderilir. Örneğin $[1, 2] $[100]’den daha büyüktür fakat $[1,3]’den daha küçüktür.

Binary terimlerin bazı özelliklerini gösteren bir program aşağıda verilmiştir.

PREDICATES

binary_karsilastir_ve_eslestir

binary_karsilastir(binary, binary)

al(binary)

CLAUSES

binary_karsilastir_ve_eslestir:-

Bin=makebinary(5),

binary_karsilastir(Bin, _),

binary_karsilastir($[1,2], $[100]),

binary_karsilastir($[0], Bin),

binary_karsilastir($[1, 2, 3], $[1, 2, 4]).

binary_karsilastir(B,B):-!,

write(B, ” = “, B, ‘\n’).

binary_karsilastir(B1, B2):-

B1>B2, !,

write(B1, ” > “, B2, ‘\n’).

binary_karsilastir(B1, B2):-

B1<B2, !,

write(B1, ” < “, B2, ‘\n’).

al(Bin):-

setwordentry(Bin, 3, 255), fail.

al(Bin):-

Buyukluk=getbinarysize(Bin), X=getwordentry(Bin, 3),

write(“\nBuyukluk= “, Buyukluk, “X = “, X, ” Binary= “, Bin, ‘\n’).

GOAL

binary_karsilastir_ve_eslestir, % Binary kaşılaştırma ve eşleştirme için

KelimeBuyuklugu=sizeof(word), Bin=makebinary(4,KelimeBuyuklugu), al(Bin),

write(“Run-time hataları yanlış indeksten kaynaklanıyor:\n”), Indeks=4,

trap(Setwordentry(Bin, Indeks, 0), E,

write(Bin, “teriminin kelime indeksi”, Indeks, ” olustururken “, E, ” hatasi olustu”, ‘\n’)).

8.9.7. Terimleri Binary Terimlere Dönüştürme

Bileşik bir terimin argümanları belleğin değişik yerlerinde olabilir. Basit tipleri doğrudan kayıtlı terimde tutulurken karmaşık olanlar (pointer ile erişilenler ve global bir stack’da olanlar) içindeki göründükleri terimin yakınlarında olmayabilir. Böyle bir terimi programdan dışarıya yollamak zor olur. Çünkü terimin bütün içeriğinin kopyasını almanın açık bir yolu yoktur. Dolayısıyla bir terimdeki değişkeni başka bir değişkenle eşleştirirken sadece bu terime giden pointerin bir kopyası alınmış olur.

term_str yüklemini kullanarak, bir terimi diziye ve diziden tekrar terime dönüştürmek mümkündür. Bu ise, sadece terimi içeriğini kopyalamak için gerektiğinde, oldukça yetersiz kalır. İşte bu problemi term_bin yüklemini çözer.

8.9.7.1. term_bin(3)

term_bin, herhangi bir tipteki terim ve binary veri bloku arasında dönüşümü, terim içeriği ve pointer sabitle bilgisini tutarak, yapar. Pointerin sabitleme bilgisi, binary veriye dönüştürülmüş terimi yeniden diziye dönüştürmek için kullanılır. Kullanımı şöyledir:

term_bin(tip, Terim, Bin)            /* (i,i,o), (i,_,i) */

Tip, Terimin ait olduğu tip, Bin ise Terimin içeriğini tutan binary terimdir.

8.10. Hatalar ve İstisnalarla Uğraşma

 Kaliteli yazılımlar geliştikçe, güvenilir programlar üretmek için hataların bulunması ve tek tek ayıklanması da önemli hale gelmektedir. Visual Prolog, program çalışırken meydana gelen hataları kontrol etmek için standart yüklemlere sahiptir. Programın işleyişi esnasında meydana gelebilecek bütün hatalar DOS ortamıda PROLOG.ERR, UNIX ortamında PDCProlog.err dosyasında saklanır. Hata mesajı numarası 10000 ve yukarısı kullanıcının programında kullanması için exit kodları olarak ayrılmıştır.

Hata ve istisna durumlarıyla uğraşmak için Visual Prolog’da temel olarak trap yüklemi kullanılır. Bu yüklem, run-time hatalarını ve exit yüklemiyle harekete geçirilen istisna durumları yakalayabilir. Bu yüklem kullanarak, örneğin Ctr+Break tuşlarına basılıp basılmadığını da kontrol edilebilir.

8.10.1. exit(0), exit(1)

exit yüklemine yapılan bir çağrı, run-time hataya eşdeğerdir. Kullanım biçimleri:

exit ve exit(CikisKodu)

Argüman kullanmadan exit yüklemini kullanmak, exit(0) gibi çalışır. exit’e giden çağrı trap yükleminde doğrudan veya dolaylı olarak çalıştırılırsa, CikisKodu trap yüklemine geçer.

8.10.2. trap(3)

Üç argüman alan bu yüklem hata yakalama ve istisna yönetimini gerçekleştirir. İlk ve son argümanlar yüklem çağırma, ikinci argüman ise değişkendir. Kullanım biçimi:

trap(YuklemCagirma, CikisKodu, HataDurumundaCagrilacakYuklem)

Örneğin trap(islem(P1,P2,P3), CikisKodu, hata(CikisKodu,P1)),…. şeklindeki bir çağrı göz önüne alınırsa, işlem yüklemi çağrılırken hata oluşursa CikisKodu ilgili hatayı verirken hata yönetme yüklemi olarak tanımladığımız hata yüklemi çağrılmış olur. Hata yükleminden dönüşte ise trap yüklemi başarısız olur.

Metin modu ortamında BREAK açıkken BREAK yapılırsa, yani Ctrl+Break tuşlarına basılırsa, trap yüklemi bunu yakalar ve CikisKodu değerini olarak 0’ı görüntüler.

Örnek:

Açılmamış olan bir dosyadan dolayı hata mesajı yakalayan program aşağıda verilmiştir.

include “c:\\vip\\include\\error.con”

DOMAINS

file = giris_dosyasi

PREDICATES

hata_yakalama(integer, file)

satir_al(file, string)

CLAUSES

hata_yakalama(err_notopen, Dosya):-!,

write(Dosya, ” isimli dosya açık değil\n”),

exit(1).

hata_yakalama(Hata, Dosya):-!,

write(Dosya, “adli dosyada”,Hata, ” hatasi “, ‘\n’),

exit(1).

satir_al(Dosya, Satir):-

readdevice(Eski),

readdevice(Dosya),

readln(Satir),

readdevice(Eski).

GOAL trap(satir_al(giris_dosyasi, Ilk), Hata, hata_yakalama(Hata, giris_dosyasi)), write(Ilk).

8.10.3. errormsg(4)

errormsg yüklemi, Visual Prolog hata mesajları dosyasıyla aynı biçimde olan dosyalara erişmek için kullanılabilir. Kullanım biçimi:

errormsg(DosyaAdi,HataNo,HataMesaji,YardimMesaji)   / (i, i, o, o)/

Bu işlem için aşağıdaki program örneği kullanılabilir:

PREDICATES

hata(integer)

ana_kisim

/* ………. */

CLAUSES

hata(0):-!. % Ctrl+Break tuşuna basılınca bir şey yapma

hata(H):-

errormsg(“prolog.err”, H, HataMesaji, _),

write(“\nSayin Kullanici, Programınızda”, H, “nolu “, ErrorMsg, “hatasi meydana geldi”),

write(“\nDosyanizi”, hata.txt,” dosyasina yaziyorum”),

save(“hata.txt”).

GOAL trap(ana_kisim, CikisKodu, hata(CikisKodu)).

8.10.4. Hataların Bildirilmesi

Visual Prolog’daki bazı derleyici direktiflerini kullanarak, programlarınız içindeki run-time hataları kontrol edilebilir. Bu direktifler şu amaçlarla kullanılır:

·       Tamsayı taşma(overflow) hatalarını kontrol edip etmeme durumu

·       run-time hataları hangi ayrıntı düzeyinde verileceği

·       Yığın taşması(Stack overflow) kontrolünü yapma

Bu direktifler programın baş tarafında verilebileceği gibi, VIP çalıştırıldıktan sonra Compiler Options seçeneğiyle de verilebilir.

8.11. Hata Düzeyi

Visual Prologun, run-time hatanın oluştuğu yeri göstermeye yarayan çok güzel bir mekanizması vardır. Meydana gelen hatanın hangi düzeyde bildirileceğini, hatanın meydana geldiği yeri, derleyicinin errorlevel direktifi belirler. Kullanım biçimi şöyledir:

errorlevel=n

n’nin alabileceği değerler 0, 1 veya 2 olabilir. Bu değerlere göre derleyicinin sunacağı hata düzeyi şunları kapsar:

0   Bu durumda en küçük ve en etkin hata mesajı verilir. Fakat hatanın yeri kaydedilmez, sadece hatanın numarası verilir.

1   Default olarak kabul edilen düzey budur. Hata meydana geldiğinde hatanın meydana geldiği nokta, dosyanın başlangıcından itibaren byte türünden gösterilir.

2   Bu düzey seçildiğinde, 1 durumunda gösterilmeyen stack overflow, heap overflow, trail oveflow vs. gibi hataları görülebilir. Burada da hatanın meydana geldiği yer bildirilir.

Proje bazında çalışırken hata mesajı düzeylerini ayarlarken dikkatli olmak gerekir. Bir projede birden fazla dosya bulunacağı için, birbirine bağlı olan dosyalardaki hata düzeyleri farklı biçimde ayarlanırsa, errorlevel=0 olan bir alt dosyada hata meydana gelirse ve ana dosyada errorlevel=1 veya 2 olursa, bu durumda hatanın meydana geldiği yeri tam olarak bulmak imkansız olur.

8.11.1. lasterror(4)

lasterror, en son olan hatayla ilgili bütün bilgiyi verir. Kullanım biçimi:

lasterror(HataNo,Modul,IncDosyasi,HataYeri)

Burada Modul, hatanın meydana geldiği dosya adı, IncDosyasi ise include dosyasıdır. Bellek taşması hatalarının doğru olarak alabilmek için programın errorlevel=1 olarak derlenmesi gerekir. Sadece basit hataların mesajları alınması isteniyorsa errorlevel=1 yeterlidir.

8.11.2. Terim Okuyucudan Gelen Hataları Görme

consult veya readterm yüklemleri çağrıldığında okunacak satırda bir hata var ise, bu yüklemlerin hata mesajı vererek duracakları bilinmektedir. Hata nedenleri ise okunacak satırın uygun biçimde hazırlanmamış olmamasıdır.

Örneğin:

·       Bir diziyi sonlandırmamak

·       Symbol türünde bir karakter yerine integer bir karakter yazmak

·       Yüklem adı için büyük harfler kullanmak

·       Sabit değerleri “ “ içinde yazmamak vs.

readtermerror ve consulterror yüklemlerini kullanarak readterm veya consult yüklemlerinin okumaya çalıştığı dosyalarda ne tür hatalar meydana geldiğini kontrol edebililir.

consult ve readterm yüklemlerinden gelen hatalar trap yüklemi tarafından yakalanırsa, consulterror ve readtermerror yüklemlerini kullanarak hatanın nedenini görmek ve yazmak mümkündür.

8.11.3. consulterror(3)

consulterror, hatalı yazımın bulunduğu satırdaki hata hakkında bilgi verir. Kullanım biçimi

consulterror(Satir, HataYeri, DosyadakiYeri)

Satir, hatanın bulunduğu satır, HataYeri hatanın bulunduğu nokta, 3. parametre ise hatalı satırın bulunduğu yer verilir.

Örnek:

CONSTANTS

yardim_dosyasi=”prolog.hlp”

hata_dosyasi=”prolog.err”

DOMAINS

dom = a(integer)

liste= integer*

DATABASE – firat_dba

p1(integer, string, char, real, dom, liste)

PREDICATES

consult_hatalarini_ayiklama(string, integer)

CLAUSES

consult_hatalarini_ayiklama(Dosya, Hata):-

Hata>1400, Hata<1410, !,

retractall(_, firat_dba),

consulterror(Satir, Hatanin_Yeri,_),

errormsg(hata_dosayasi, Hata, Mesaj, _),

str_len(Bosluklar, Hatanin_Yeri),

write(Dosya, ” dosyasinin “, Satir, ” satırında “, Bosluklar, Mesaj, “meydana gelmistir”),

exit(1).

consult_hatalarini_ayiklama(Dosya, Hata):-

errormsg(hata_doyasi, Hata, Mesaj, _),

write(Dosya, ” dosyasi açılmaya çalışırken “, Mesaj, ” hatası oluştu”),

exit(2).

GOAL Dosya=”test.dba”,

trap(consult(Dosya, firat_dba), Hata, consult_hatalarini_ayiklama(Dosya, Hata)),

write(“\n Tamam \n”).

8.11.4. readtermerror(2)

readtermerror, readterm yükleminin okuduğu satırdaki hatayı verir. Kullanım biçimi:

readtermerror(Satir, HataYeri)

8.12. Break Kontrolü (Sadece Metin Modunda)

Visual Prolog’daki break mekanizmasının nasıl çalıştığına bakalım. Genelde, break için gerekli komutlar o anda çalışan programı hemen durdurmazlar. Prolog’da, istisnai durumları yöneten bir birim vardır. Sinyal ile aktif edilen bu parça bir flag yerleştirir. Visual Prolog bu flagı iki farklı durumda kontrol eder.

·       Yazılan program, break-kontrolü açık halde derlenirse, her yüklem girildiğinde break-flag durumu kontrol edilir. Break-kontrol seçeneği, VIP seçeneklerinden iptal uygun direktif seçilerek (Options/Compiler Directives/Run-time check) iptal edilebilir.

·       Library rutinlerinin bazıları break-flag kontrolü yaparlar.

8.12.1. break(1)

break, bir program çalışırken break-flag kontrolünün yapılıp yapılmayacağını belirtir. Kullanım biçimleri şöyledir.

break(on), break(off)

break(BreakDurumu)

DOS tabanlı pgogramlar için break komutundan kaynaklanan çıkış kodları daima 0 olur.

8.12.2. breakpressed(1)

break-flag kurulmuşsa, break(off) olsa veya program nobreak seçeneğiyle derlense bile, breakpressed yüklemi başarılı olur. Başarılı olunca, yakalanan en son sinyale göre bir çıkış kodu verir ve break-flagı siler.

8.13. DOS Metin Modunda Kritik Hata Kontrolü

Bu bölüm sadece DOS metin modu ortamında geçerlidir. Dolayısıyla VPI programlarına uygulanamaz.

Visual Prolog’un DOS versiyonu hata durumlarıyla ilgilenen bazı rutinler içerir. Bir DOS hatası olduğu zaman DOS, criticalerror rutinini çağrır. Visual Prolog’daki sistem ise, run-time editörü de bir dosya hatası bulduğunda fileerror yüklemini çağırır. Bu yüklemler global olarak tanımlanır ve kendinize ait cümlecikler kullanırsanız, library’deki rutinler yerine size ait rutinleri programa bağlar. Dolayısıyla hataları daha iyi kontrol etmek mümkündür. Bu durumda .EXE programlarının büyüklüğü büyük oranda azalır. criticalerror ve fileerror için global deklerasyon include dosyasında error.pre içinde hazır olarak bulunmaktadır.

8.13.1. criticalerror(4)

Visual Prolog, bu rutini DOS kritik hatalarıyla uğraşmak için tanımlar. criticalerror yüklemi kullanılmak istenirse, ERROR.PRE dosyası programa dahil edilmelidir. Tanımlanması şöyledir:

global predicates

criticalerror(HataNo, HataTuru, DiskNo, Eylem)

criticalerror yüklemi daima başarılı olmalıdır. Bu yüklem sadece .EXE dosyasından çalışır ve DOS kritik hata interrupt tutucusuyla yer değiştirir. Aşağıdaki tabloda criticalerror yükleminin argümanlarının aldığı değerler verilmiştir.

Tablo 8.4. Criticalerror yükleminin argümanlarının aldığı değerler

8.13.2. fileerror(2)

Metin modundaki bir dosya eylemi başarısız olunca fileerror yüklemi harekete geçirilir. Kendinize ait fileerror yüklemini tanımlarsanız, bu yüklemin başarısız olmasına izin verilmez ve bu yüklem sadece .EXE uygulamalarından çalışır. fileerror’un ERROR.PRE dosyasındaki tanımlanması şöyledir:

global predicates

fileerror(integer, string) – (i, i) language c as “_MNU_FileError”

Bu tanım tipi doğrudur. Kaynak kod Prolog’da olsa bile language c mutlaka belirtilmelidir.

8.14. Dinamik Cut

Prolog’daki cut statiktir. Geleneksel cut işleminde, program akışı ancak ! sembolüne geldiği zaman cut devreye girer ve sadece içinde bulunulan cümleleri etkiler. Dolayısıyla bir cut komutunun etkisini başka bir yükleme aktarmak mümkün değildir. Normal cut komutunun diğer bir dezavantajı da; yüklemde cut komutunu takip eden cümlelerdeki geriye dönüş noktalarını ortadan kaldırmadan, bir alt hedefteki diğer çözümleri arama ihtimalini ortadan kaldırmanın mümkün olmamasıdır.

Visual Prolog’da dinamik kesme mekanizmasında getbacktrack ve cutbacktrack yüklemleri kullanılır. Bu mekanizma sayesinde bu iki dezavantaj ortadan kalkmış olur. getbacktrack, geriye iz sürme noktalarının yığını içerisinde en üstteki pointer’i verir. Bu noktanın üstünde kalan bütün geriye dönüş noktaları silinebilir.

Bu iki yüklemin kullanımı hakkındaki örnekler, aşağıda verilmiştir.

1.     Elimizdeki veritabanında sahislarin isim ve aylık gelirleri var. Bu sahısların arkadaşlarını kaydetmiş durumdayız.

database

sahis(symbol, income)

arkadas(symbol, symbol)

Arkadaşı olan veya az bir vergi ödeyen insanların listesini görmek için aşağıdaki cümlecikleri kullanabiliriz:

sansli_insanlar(aradasi_var(P)):-sahis(P,_), arkadas(P,_).

sansli_insanlar(zengindir(P)):-sahis(P, AylikGelir), not(zengin(AylikGelir)).

Bir şahsın birden fazla arkadaşı varsa, ilk cümlecik birden fazla çözüm getirir. Bu arada dinamik cut kullanabiliriz.

sahsli_insanlar(arkadasi_var(P)):-

sahis(P,_), getbacktrack(BTOP), arkadas(P,_), cutbacktrack(BTOP).

Geriye dönüş mekanizması yapılırsa, arkadaş yüklemi birden fazla çözüm sunabilir. Fakat cutbacktrack yüklemi çağrılarak bu ihtimal ortadan kaldırılır.

Dinamik cut kullanmanın daha önemli avantajı, geriye dönüş pointerini başka bir yükleme geçirmek ve cut komutunu şartlı olarak çalıştırmaktır. Pointer pozitif tipte olup yine pozitif tipteki değişkenlere aktarılabilir.

Örnek:

Bir tuşa basıncaya kadar ekrandan girilen rakamları okuyan bir program, aşağıda sunulmuştur.

PREDICATES

sayi(integer)

sayilari_yaz(integer)

kullanici_komutu(unsigned)

CLAUSES

sayi(0).

sayi(N):-sayi(N1), N=N1+1.

sayilari_yaz(N):- getbacktrack(BTOP), sayi(N), kullanici_komutu(BTOP).

kullanici_komutu(BTOP):- keypressed, cutbacktrack(BTOP).

kullanici_komutu(_).

Derleyici, cümleleri determinism bakımından kontrol eden yüklemdeki cutbacktrack yüklemini tanımaz. Yani check_term direktifini kullanırken non-deterministic cümle uyarısı alınabilir. Dinamik kesme kullanırken çok dikkatli olmak gerekir. Çünkü programın tamamını tahrip etmek, programı çalışamaz hale getirmek mümkündür.

8.15. Programlama Stilleri

Visual Prolog’da program yazarken dikkat edilmesinde fayda olan bazı temel özellikler vardır. Bu özellikler artık kural haline gelmiştir. Etkili programlama yapabilmek için şu kurallara dikkat edilmelidir:

Kural 1. Fazla yüklem yerine daha fazla değişken kullanın

Bu kural programın okunabilirliği ile ters orantılıdır. Genelde Prolog’un dekleratif olan stili, diğer konvansiyonel yaklaşımlara göre daha az verimlidir. Örneğin, bir listenin elemanlarını tersine çeviren bir yüklem yazmak için aşağıdaki program parçası kullanılabilir:

tersine_cevir(A, B):- tersine_cevir1([], A, B).

tersine_cevir1(B, [], B).

tersine_cevir1(A1, [U|A2], B):- tersine_cevir1([U|A1], A2, B).

Kural 2. Çözüm olmadığı zaman program çalışmasının etkili bir biçimde bittiğinden emin olun

Yazdığımız bir maksimum_deger yüklemiyle bir listedeki tamsayıların büyük bir sayıya kadar düzenli olarak arttığını, daha sonra yine düzenli bir şekilde azaldığını kontrol etmek istiyoruz. Bu yüklemi kullanarak

maksimum_deger([1, 2, 5, 7, 11, 8, 6, 4]) şeklindeki bir sorgu başarılı olur. Fakat

maksimum_deger([1, 2, 3, 9, 6, 8, 5, 4, 3]) başarısız olur.

Kural 3. Geriye İz Sürme mekanizmasını mümkün olduğunca çok kullanın.

esitlik seklinde tanımlanan bir yüklemin iki listenin elemanlarını karşılaştırmak için kullanalım. Bunun için:

esitlik([], []).

esitlik([U|X], [U|Y]):- esitlik(X, Y)

kullanmak gereksizdir. Çünkü bunun yerine daha basit olan esitlik(X, X) kullanılabilir.

Kural 4. Rekursiyon veya Tekrarlama Yerine Geriye İz Sürme Mekanizmasını Kullanın

Geriye İz Sürme mekanizması bellek ihtiyacını azaltır. Bu yüzden rekursiyon yerine repeat-fail kombinasyonunu kullanmak gerekir. Bu konu hakkında birkaç örnek verelim.

Alt hedefleri tekrarlı bir şekilde kullanmak için genelde basla gibi bir yüklem tanımlayıp sonuçları hesaplamak gerekir.

Örnek:

basla:-

readln(X), islem_yap(X, Y), write(Y), basla.

Bu tür bir tanımlama gereksiz yere rekursiyon yapar. islem_yap(X,Y) non-deterministic ise sistem tarafından gereksiz olan bu rekursiyon otomatik olarak ortadan kaldırılabilir.

Bu durumda repeat…fail ikilisi kullanmak gerekir. Bunun için yukarıdaki işlemleri şöyle yazmak mümkündür.

basla:-

tekrar, readln(X), islem_yap(X, Y), write(Y), fail.

fail komutu, islem_yap yükleminine geriye dönüş yapar, buradan da tekrar yüklemine geçer, bu yüklem daima başarılı olur. Burada önemli olan şey bu döngünün dışına çıkmaktır. Genelde döngü dışına çıkmak için belli şartlar aranıldığı için, döngü içine bu şartı yazmak mümkündür. Yani:

basla:-

tekrar, readln(X), islem_yap(X, Y), write(Y), bitisi_kontrol_et(Y), !.

8.15. Cut Yüklemini Yerleştirmek

check_determ direktifi, cut yükleminin nereye yerleştirilmesi gerektiği konusunda karar verirken çok faydalıdır. Non-deterministic davranışı olan cümlecikleri deterministic hale getirip geriye dönüşü engellemek için cut kullanılmadır.

Böyle bir durumda genel bir kural olarak şunu söyleyebiliriz: cut komutunu, programın mantığını bozmayacak şekilde, mümkün olduğuca bir kuralın başına yakın bir yere konulmalıdır. Derleyici aşağıdaki iki kuralı dikate alarak bir cümleciğin deterministic veya non-deterministic olduğuna ;

2.     Cümlede cut yoksa ve cümlenin başındaki argümanlarla eşleşebilecek başka bir cümlecik varsa

3.     Cümle gövdesinde non-deterministic başka bir yükleme çağrı varsa ve non-deterministic olan bu çağrıdan sonra cut yoksa bulunarak karar verilir.

9. ÖZEL GELİŞTİRİLMİŞ PROLOG ÖRNEKLERİ

9.1. Küçük bir Uzman Sistem örneği

Bu örnekte, bazı özellikleri hakkında kullanıcıya soru sorarak 7 hayvandan biri bulunacaktır. Bu hayvanlar hakkında bilinen olgulardan hareketle geriye dönüş mekanizması kullanılarak doğru cevap bulunmaya çalışılacaktır.

DATABASE

     xpositif(symbol,symbol)

     xnegatif(symbol,symbol)

PREDICATES

     nondeterm aranan_canli(symbol)

     nondeterm canli_turu(symbol)

     soru_sor(symbol,symbol,symbol)

     sakla(symbol,symbol,symbol)

     positif(symbol,symbol)

     negatif(symbol,symbol)

     olgulari_sil

     basla

CLAUSES

aranan_canli(cita):-

     canli_turu(memelil),

     canli_turu(etobur),

     positif(sahiptir,sari_kahverengi_renklere),

     positif(sahiptir,siyah_benekler).

aranan_canli(tiger):-

     canli_turu(memeli),

     canli_turu(etobur),

     positif(sahiptir, sari_kahverengi_renkler),

     positif(sahiptir, siyah_seritli).

aranan_canli(zurafa):-

     canli_turu(tirnakli),

     positif(sahiptir,uzun_boyunlu),

     positif(sahiptir,uzun_bacakli),

     positif(sahiptir, siyah_benekler).

aranan_canli(zebra):-

     canli_turu(tirnakli),

     positif(sahiptir,siyah_seritli).

aranan_canli(devekusu):-

     canli_turu(kus),

     negatif(eylem,ucar),

     positif(sahiptir,uzun_boyunlu),

     positif(sahiptir,uzun_bacakli),

     positif(sahiptir, siyah_beyaz_renk).

aranan_canli(penguen):-

     canli_turu(kus),

     negatif(eylem,ucar),

     positif(eylem,yuzer),

     positif(sahiptir,siyah_beyaz_renk).

aranan_canli(albatros):-

     canli_turu(kus),positif(eylem,iyi_ucar).

canli_turu(memeli):-

     positif(sahiptir,tuylu).

canli_turu(memeli):-

     positif(eylem,sut_verir).

canli_turu(kus):-

     positif(sahiptir,kus_tuyleri).

canli_turu(kus):-

     positif(eylem,ucar),

     positif(eylem,yumurtlar).

canli_turu(etobur):-

     positif(eylem,et_yer).

canli_turu(etobur):-

     positif(sahiptir,sivri_disleri),

     positif(sahiptir, pencelere),

        positif(sahiptir,patlak_gozler).

canli_turu(tirnakli):-

     canli_turu(memeli),

     positif(sahiptir,toynaklar).

canli_turu(tirnakli):-

     canli_turu(memeli),

     positif(eylem,gevis_getirme).

positif(X,Y):-

     xpositif(X,Y),!.

positif(X,Y):-

     not(xnegatif(X,Y)),

     soru_sor(X,Y,evet).

negatif(X,Y):-

     xnegatif(X,Y),!.

negatif(X,Y):-

     not(xpositif(X,Y)),

     soru_sor(X,Y,hayir).

soru_sor(X,Y,evet):-!,

     write(X,” aranan canli:”,Y,’\n’),

     readln(Cevap),nl,

     frontchar(Cevap,’e’,_),

     sakla(X,Y,evet).

soru_sor(X,Y,hayir):-!,

     write(X,” aranan canli: “,Y,’\n’),

     readln(Cevap),nl,

     frontchar(Cevap,’h’,_),

     sakla(X,Y,hayir).

sakla(X,Y,evet):-

     assertz(xpositif(X,Y)).

sakla(X,Y,hayir):-

     assertz(xnegatif(X,Y)).

olgulari_sil:-

     write(“\n\nBitirmek icin space tusuna basiniz.\n”),

     retractall(_,dbasedom),readchar(_).

basla:-

     aranan_canli(X),!,

     write(“\n Aradiginiz canli bir “,X, “olabilir.”),

     nl,nl,olgulari_sil.

basla :-

     write(“\nAradiginiz canliyi bulmak mumkun degildir.\n\n”),

     olgulari_sil.

GOAL      basla.

Veritabanındaki her hayvan, sahip olduğu veya olmadığı bazı özelliklerle tanımlanmıştır. Kullanıcının cevaplayacağı sorular olumlu(A, B) veya olumsuz(A, B) şeklindedir. Sorulan bir soruya evet veya hayır şeklinde cevap aldıktan sonra, verilen cevabın veritabanına eklenmesi gerekir. Böylece program karar verirken eski bilgileri kullanır. Burada olumlu ve olumsuz olmak üzere sadece iki yüklem kullanılmıştır.

database

xpozitif(symbol, symbol)

xnegatif(symbol, symbol)

Böylece aradığımız hayvanın tüylü değilse, xnegative(vardir, tuy) şeklindeki olguyu kullandık. Pozitif ve negatif kurallar, kullanıcının verdiği cevabın önceden bilinip bilinmediğini kontrol eder.

pozitif(X,Y):-

     xpozitif(X,Y),!.

pozitif(X,Y):-

     not(xnegatif(X,Y)),

     soru_sor(X,Y,evet).

negatif(X,Y):-

     xnegatif(X,Y),!.

negatif(X,Y):-

     not(xpozitif(X,Y)),

     soru_sor(X,Y,hayir).

Pozitif ve negatif kurallarının ikinci kuralı, kullanıcıya yeni bir soru sormadan önce arada bir zıtlık olup olmadığını kontrol eder. Tanımladığımız soru_sor yüklemi kullanıcıya soru sorar ve alınan cevapları düzenler. Cevap e ile başlarsa olumlu, h ile başlarsa olumsuz olarak kabul edilir.

ask(X,Y,yes):-!, write(X,” it “,Y,’\n’), readln(Reply),nl,

frontchar(Reply,’y’,_), remember(X,Y,yes).

ask(X,Y,no):-!, write(X,” it “,Y,’\n’), readln(Reply),nl,

frontchar(Reply,’n’,_), remember(X,Y,no).

remember(X,Y,yes):-assertz(xpositive(X,Y)).

remember(X,Y,no):-assertz(xnegative(X,Y)).

clear_facts:-write(“\n\nÇıkmak için boşluk tuşuna basınız\n”), retractall(_,dbasedom),readchar(_).

9.2. Basit bir yön problemi

Türkiye’deki birkaç şehir arasındaki en uygun yolu bulmak için bir program yapalım. Program bize iki şehir arasında yol olup olmadığını sorsun. Vereceğimiz cevaba göre en uygun yolu bize göstersin. Burada geriye iz sürme ve rekursiyon metotlarını kullanacağız.

DOMAINS

sehir           = symbol

mesafe      = integer

PREDICATES

nondeterm yol(sehir,sehir,mesafe)

nondeterm guzergah(sehir,sehir,mesafe)

CLAUSES

yol(mardin,sanliurfa,190).

yol(gaziantep,mardin,320).

yol(sanliurfa,gaziantep,146).

yol(sanliurfa,elazig,348).

yol(gaziantep,elazig,540).

guzergah(_1_Sehir,_2_Sehir,Mesafe):-

yol(_1_Sehir,_2_Sehi, Mesafe).

guzergah(_1_Sehir,_2_Sehir,Mesafe):-

yol(_1_Sehir,X,Mesafe1),

guzergah(X,_2_Sehir,Mesafe2),

Mesafe=Mesafe1+Mesafe2, !.

GOAL guzergah(sanliurfa,elazig, Toplam_Mesafe).

Yol yüklemi için kullanılan her bir cümlede, bir şehirden diğerine olan yolun km cinsinden değeri verilmiştir. guzergah yüklemi ise iki şehir arasında yol olduğunu göstermektedir. Güzergahı takip eden bir sürücünün mesafe parametresiyle gösterilen miktarda gideceği belirtilmiştir. Burada güzergah yüklemi rekursiv olarak tanımlanmıştır. Güzergah, birinci cümlede olduğu gibi sadece tek yol olabilir. Bu durumda toplam mesafe sadece iki şehir arasındaki yoldur. Bir şehirden diğerine gittikten sonra ana hedefe gidiliyorsa, bu durumda toplam yol Mesafe1+Mesafe2 olur.

9.3. Hazine Avcısı

Labirent biçimindeki dehliz ve mağaralardan oluşan bir yerde gizli bir hazine bulunsun. Aynı yerden tekrar geçmeden, tehlikeye yakalanmadan giriş noktasından başlayıp emniyetli bir şekilde çıkıştan geçmek ve hazineyi almak için hangi yolu takip etmeliyiz?

Önce hazinenin yerini gösteren haritaya bakalım.

DOMAINS

oda                        =  symbol

odalarin_listesi     = oda*

PREDICATES

nondeterm galeri(oda,oda)

nondeterm komsu_oda(oda,oda)

buralara_girmek_tehlikeli(odalarin_listesi)

nondeterm git(oda,oda)

nondeterm guzergah(oda,oda,odalarin_listesi)

nondeterm eleman(oda,odalarin_listesi)

CLAUSES

galeri(giris,canavar).       

galeri(giris,cesme).

galeri(cesme,bataklik).    

galeri(cesme,gida).

galeri(cikis,hazine).         

galeri(cesme,denizkizi).

galeri(haydut,hazine).     

galeri(cesme,haydut).

galeri(gida,hazine).

galeri(denizkizi,cikis).

galeri(canavar,hazine).    

galeri(hazine,cikis).

komsu_oda(X,Y):-galeri(X,Y).

komsu_oda(X,Y):-galeri(Y,X).

buralara_girmek_tehlikeli([canavar,haydut]).

git(Baslama_noktasi,Bitis_noktasi):-

guzergah(Baslama_noktasi,Bitis_noktasi,[Baslama_noktasi]).

git(_,_).

guzergah(Oda,Oda,Gidilen_odalar):-

eleman(hazine,Gidilen_odalar),

write(Gidilen_odalar),nl.

guzergah(Oda,Cikis_yolu,Gidilen_odalar):-

komsu_oda(Oda,Sonraki_oda),

buralara_girmek_tehlikeli(Tehlikeli_odalar),

not(eleman(Sonraki_Oda,Tehlikeli_odalar)),

not(eleman(Sonraki_Oda,Gidilen_odalar)),

guzergah(Sonraki_Oda,Cikis_yolu,[Sonraki_Oda|Gidilen_odalar]).

eleman(X,[X|_]).

eleman(X,[_|H]):-eleman (X,H).

GOAL git(cikis, giris).

Buradaki her dehliz bir olguyla temsil edilmiştir. git ve guzergah yüklemleri kuralları belirler. Sorgudan elde edeceğimiz cevapta hazineyi alıp emniyetli bir şekilde dışarı çıkmak için gerekli güzergah belirtilecektir. Programdaki önemli bir özellik, rekursiv olarak tanımlı olan guzergah sayesinde gidilen odaların kataloga alınmasıdır. Çıkış odasına geldiğiniz anda üçüncü parametre o ana kadar ziyaret ettiğiniz odaları listeler. Bu odalar arasında hazine var ise, hedefe varıldı demektir. Eğer listede hazine odası yoksa, Sonraki_oda seçeneği tehlikeli odalara gidilmeyecek şekilde genişletilir.

TARTIŞMA VE SONUÇ

Yapay Zeka kavramı ortaya çıktıktan sonra, yurtdışında bu konuda çok sayıda teorik çalışma, değişik disiplinlerde kullanılan birçok uygulama program gerçekleştirilmiştir. Bu programlar sayesinde, bir insan tarafından yapılması çok zaman alabilen ve hata oranı oldukça yüksek olabilen durumlar ortadan kalkmıştır. Örneğin Digital firması yetkilileri, müşterilerinin siparişlerine göre yeni bir sistem dizaynı yaparken, bu sistemde kullanılabilecek donanım seçeneklerinin çokluğu, her bir parçanın birden fazla parça ile uyumlu çalışabilmesi veya bazı parçaların birbirleriyle hiç uyuşmaması gibi durumlardan dolayı, yapılan montajlarda büyük oranda hataların ortaya çıktığını; ancak yazılan bir uzman sistem ve parçalar hakkındaki gerçeklerden oluşan bir bilgi veritabanı ile bu durumun ortadan kalktığını, ayrıca yılda milyonlarca dolar tasarruf sağladıklarını belirtmişlerdir. Bunun haricinde farklı alanlarda kullanılmak üzere hazırlanan ve başarılı bir şekilde çalışan çok sayıda uzman sistem örneği vermek mümkündür.

Tıpta teşhis ve tedavi planlaması amacıyla bilgi tabancı sistemler, birçok alanda (Örneğin Laboratuar, Onkoloji veya Kardiyoloji gibi) kullanım sahası bulmaktadır. Diş tedavisi alanında bilgisayar kullanımı daha ziyade sadece kayıt amaçlı kullanılmaktadır. Karlsruhe’deki Diş Hekimliği Akademisi ile Bremen Üniversitesi Yapay Zeka Laboratuarı arasında işbirliği yapılarak, bir yazılım geliştirilmiştir. Bu çalışma, diş doktorları için bilgi tabanlı bir dökümantasyon ve karar verme sisteminin oluşturulmasını sağlamaktadır. Sistemin kullanılması halinde, diş hekimliği ile ilgili teşhis ve tedavi önerileri yapılabilmektedir.

Türkiye’de ise, bu alanda çok ciddi çalışmaların var olduğunu söylemek çok zordur. Gebze Yüksek Teknoloji Enstitüsü’ndeki Yapay Zeka Bölümü’nde, askeri amaçlı projeler üzerinde çalışmalar yürütülmektedir. Ayrıca Bilkent ve Orta Doğu Teknik Üniversitelerinde yürütülmekte olan TurkLang gibi büyük projeler mevcuttur. Fakat bu çalışmaların çoğu Unix ortamında yapılmakta olup, bireysel ve endüstriyel kullanıma yönelik değildir.

Yapay Zeka ve bunun alt bölümleri olarak kabul edilen Uzman Sistemler, Yapay Sinir Ağları, Tabii Dil İşlenmesi gibi alanlarda program yapmak için mantık dillerinin yanı sıra, Pascal, C++ gibi konvansiyonel programlama dilleri de kullanılmaktadır. Prolog (Programming in Logic) mantık dillerinden en popüler olanıdır. Önceleri daha çok Unix, VAX gibi işletim sistemleriyle çalışan anaçatı bilgisayarlarda kullanılan Prolog, zamanla DOS, daha sonraları ise Windows ve diğer işletim sistemlerine de aktarılmıştır. Visual Prolog, işte bu aşamalardan sonra çıkarılan, çoklu ortamlarda rahatlıkla kullanılabilen bir mantık dilidir. Visual Prolog’un diğer konvansiyonel dillerden ayrıldığı bazı özellikler şunlardır:

a)      Visual Prolog prosedürel değil tamamen dekleratif bir yapıya sahiptir. Yani çözümü aranan bir problemin nasıl çözüleceğini tanımlamak yerine, problemin kendisini tanımlamak yeterlidir. Kullanıcı tarafından verilen gerçeklere dayanarak, Prolog’da var olan Inference Engine(Karar verme motoru) istenilen problem için mümkün olan bütün çözümleri bulur.

b)      Visual Prolog’daki Geriye İz Sürme mekanizması, konvansiyonel dillerin hiçbirinde bulunmayan güçlü bir özelliktir. Bu özellik sayesinde konvansiyonel dillerdeki FOR..NEXT, DO..WHILE gibi döngüler ortadan kalkar. Prolog, bu özelliği sayesinde, çözüm aranan bir sorguya uygun bütün çözümleri kendiliğinden bulur. Bu durum, döngü komutlarının neden olabileceği hataları baştan itibaren ortadan kaldırır.

c)      Visual Prolog’un diğer bir özelliği ise, nesneler arasındaki ilişkilerin çok kolay bir şekilde tanımlanabilmesi, bu ilişkilere dayalı işlemler yapabilmesidir. Örneğin, kullanilir(“Visual Prolog”, uzman_sistemler) şeklinde ifade edilebilen ‘Visual Prolog dili uzman sistemlerde kullanılır’ cümlesini, konvansiyonel dillerle ifade etmek mümkün değildir.

Visual Prolog ile uygulama Programları yazarken, nesneler arasındaki ilişkileri ifade etmek son derece kolay olmasına rağmen, uygulamanın sonuçları hakkında Türkçe bilgi vermek ve Türkçe’de düzgün cümleler kurmak açısından bazı zorluklar mevcuttur. Bunun temel nedeni, İngilizce ve Türkçe cümle yapılarında öğelerin dizilişlerinde farklılıklar bulunmasıdır. Bu yüzden, Türkçe ifade edilen bir cümlede, özne ve yüklem arasında akıcı bir ilişki kurabilmek için, öğeler arasındaki özelliklerin önceden veritabanına yüklenmesi faydalı olacaktır. Bu çalışma sayesinde, Prolog’un Türkçe’ye uyarlanmasında karşılaşılan problemler detaylı olarak ele alınmış, problemlerin en doğru şekilde nasıl çözümlenebileceği konusunda bazı yazılımlar geliştirilmiştir.

Visual Prolog kullanarak yapay zeka konusunda çalışma yapacaklar için önemli birçok ipuçları örneklerle verildiği bu tez çalışması sayesinde, yapay zeka alanında Türkçe uygulamalarda önemli gelişmeler sağlanabilecektir.

KAYNAKLAR

(1) STERLING; Leon; SHAPHIRO, Ehud; The Art of Prolog, Advanced Programming Techniques, The MIT Press, London, England, 1992.

(2) CLOCKSIN, W.F, MELLISH, C.S, Programming in Prolog, Springer-Verlag Berlin Heidelberg, Germany, 1987.

(3) O’KEEFE, Richard A.; The Craft of Prolog, The MIT Press, London, England, 1990

(4) CASTILLO, E., ALVAREZ, E., Expert Systems: Uncertainity and Learning, Computational Mechanics Publications, Southampton, Boston, America, 1991

(5) GIARRATANO, JOSEPH. C, Expert Systems: Principles and Programming, PWS-KENT Publishing Company, Boston, America,1989.

(6) IGNIZIO, JAMES. P., Introduction to Expert Systems, McGraw-Hill, Inc., America, 1991.

(7) PDC, Visual Prolog Language Tutorial, Copenhagen, Denmark, 1996.

(8) KUŞ, M.; VAROL, A.; OĞUROL, Y.; VAROL, Y.: Verarbeitung von unsiherem Wissen mit Fuzzy-Prolog, Second Turkish-German Joint Computer Application Days, 15-16 October, Konya, 1998

(9) OĞUROL, Y.; VAROL, A.; KUŞ, M.: Anforderungen und Lösungsansätze einer transferierbaren Entwicklungsumgebung für die medizinische Wissenverarbeitung, Second Turkish-German Joint Computer Application Days, 15-16 October, Konya, 1998.

(10) VAROL, A.; VAROL, N.: ESTA İle Bilgisayar Destekli Eğitim, Beta Basım Yayım Dağıtım A.Ş., 299, 1996.

(11) VAROL, A.; VAROL, N.: ESTA Bilgisayar Yazılımı İle Uzman Sistemlerin Hazırlanması Teknikleri, Süleyman Demirel Üniversitesi, Makine Mühendisliği Dergisi, Cilt 1, Sayı 9, 67-72, 1996.

(12) KUŞ, M.; VAROL, A.; OĞUROL, Y.: Uzman Sistemin Dişçilik Alanında Kullanımına Ait Bir Uygulama, Endüstri&Otomasyon, Aylık Elektrik, Elektronik, Makine, Bilgisayar ve Kontrol Sistemleri Dergisi, Sayı: 18, 1998

(13) KUŞ, M.; VAROL, A.; OĞUROL, Y.: Uzman Sistemin Dişçilik Alanında Kullanımına Ait Bir Uygulama, Endüstri&Otomasyon, Aylık Elektrik, Elektronik, Makine, Bilgisayar ve Kontrol Sistemleri Dergisi, Sayı: 18, 1998

(14) VAROL, A.; VAROL, N.: Uzman Sistemlerde ESTA Yazılımının Önemi, Bilişim’96, 18-22 Eylül 1996 İstanbul, Bildiriler Kitabı, 289-294, 1996.

(15) VAROL, A.; VAROL, N.: Uzman Sistem Hazırlanırken Hangi Kriterler Göz Önünde Bulundurulmalı, GAP 2. Mühendislik Kongresi, 21-23 Mayıs 1998, Şanlıurfa, Bildiri Kitabı, S: 559-566,  1998.

ŞEKİLLER ve TABLOLAR

Şekil 1. Aile Fertlerinin Şecere Olarak Gösterilmesi……………………………………….. 88

Şekil 2. Şekil 6.1’deki ağaç yapısında Aşağıya-Doğru-Arama metodunun uygulanması.     90

Şekil 3. Binary tarama yapısı………………………………………………………………………. 94

Tablo 3.1: Visual Prolog’da Tipler ve Alabilecekleri değerler.…………………………. 25

Tablo 7.2. Listelerin baş ve kuyruk halinde gösterilmeleri……………………………… 100

Tablo 7.3: Liste eşleştirme örnekleri…………………………………………………………. 101

Tablo 8.4. Criticalerror yükleminin argümanlarının aldığı değerler…………………. 134

Prolog Dili

 İÇİNDEKİLER 

1. GİRİŞ

İngilizce Expert System kelimelerinden türetilerek Türkçe’ye kazandırılmış olan Uzman Sistem yazılımları alanında, ülkemizde yoğun çalışmaların yapıldığı gözlenmektedir.

Bir Uzman Sistem, Bilgisayar Destekli Eğitim amaçlı da kullanılabileceğine göre, eğitim ve öğretim için gerekli olabilecek her türlü formasyonu taşımalıdır. Öğrenme, doğrudan bilgisayardan yapılacağı için, klasik öğretmen merkezli eğitime nazaran, içeriğin daha doyurucu ve cazip özellikler taşıması gerekir. Cazip unsurlar, bilgisayar tarafından yönetilmeli ve uygun ortamlarda ekranda veya bilgisayarın çevre birimlerinde ortaya çıkabilmelidir.

Öğretilmek istenen bir konuda işlem basamaklarının sırası çok önemlidir. Öğrenciye yöneltilecek sorular çok iyi belirlenmeli ve soru sorarken öğretme mekanizması devreye alınmalıdır. Soruların sıralanışında yeterli hassasiyet gösterilmediği takdirde, hem öğrenme eksik olabilir, hem de öğrenci yanlış bilgilendirmeye sevk edilebilir.

Uzman sistem üzerinde çalışan öğrenci, bilgisayarı ile yalnız başına kalacaktır. Sürekli monoton bir ekran görüntüsü yüzünden, öğrencinin öğrenme arzusu kırılabilir, bilgisayar önünde canı sıkılabilir. O halde öğretme esnasında, öğrencinin dikkatinin konuya sevk edilebilmesi için, program arasında görsel ve işitsel yöntemlerle uygun uyarılar yapılabilmelidir.

Bilgisayar destekli eğitimin kullanılabileceği her yere ilave olarak, problemlere çözüm getirilmek istenen her sahada Uzman Sistem kullanılabilir.

Bir Uzman Sistem hazırlanırken asgari olarak aşağıdaki hususların göz önünde bulundurulması gerekir.

·      Hazırlanacak proje konusu hem güncel olmalı hem de o konuda yeterli kaynak bulunabilmelidir.

·      Konunun bol miktarda resim ve şekil içermesi, kullanıcının öğrenme hızını artıracak bir faktördür.

·      Proje başlangıcında, güzel bir sunu yazılımıyla (örneğin Power Point gibi) proje hakkında özet bilgiler verilmeli, proje tasarımcısı ve denetleyen kişilerin isimleri, resimleri ve faydalanılan kaynaklar hakkında bilgi verilmelidir.

·      Konu anlatımına geçmeden önce, güzel bir müzik eşliğinde bilgisayar, kullanıcının ismini girmesini istenmelidir. Çünkü ilerleyen konular içerisinde bazı yerlerde esprili cümlelerle bilgisayarın kullanıcıya ismi ile hitap etmesi, kullanıcının aniden dikkatini çekmeye neden olabilmekte ve kullanıcı bu durumdan fazlasıyla memnun kalabilmektedir.

2. PROLOG’UN (PROGRAMMING IN LOGIC) TEMELLERİ

Bir Prolog programı, (Basic, Fortran, Pascal, C) olduğu gibi bir dizi komut satırından değil, doğruluğu önceden bilinen gerçeklerden ve bu gerçeklerden bilgi sağlamaya yarayan kurallardan oluşur.

Prolog, cümlecikler (Horn Clauses) üzerine bina edilmiştir. Cümlecikler, yüklem mantığı denilen formal sistemin bir alt kümesidir.

Prolog’da bir Karar Motoru (Inference Engine) vardır. Bu motor, verilen bilgiyi kullanarak cevabı aranan bir problem için, mantıksal bir şekilde karar veren bir işlemdir. Karar motorundaki Kalıp Eşleştirici (Pattern Matcher) sorulara uygun olan cevapları eşleştirerek önceden bilinen ve program içine kaydedilen bilgiyi geri çağırır. Prolog, program satırları içinde sorulan bir soruyu veya hipotezi doğrulamak için, doğruluğu önceden bilinen ve veri olarak yüklenmiş olan bilgi kümesini sorgulayıp hipotezin doğruluğu hakkında karar vermeye çalışır. Kısaca söylemek gerekirse, bir Prolog programının temelini, program akışı içinde önceden verilen gerçekler ve kurallar oluşturur.

Prolog’un önemli diğer bir özelliği de şudur: Sorulan sorulara mantıklı cevaplar bulmanın yanısıra, bulduğu tek bir çözümle yetinmez, başka alternatifleri de inceleyerek mümkün olan bütün çözümleri bulur. Prolog, bir programın birinci satırından başlayıp sonuncu satırına kadar ilerleyip sadece bir çözüm bulmak yerine, zaman zaman geriye dönüş yaparak problemin her bir bölümünün çözümü için alternatif yolları da arar.

Yüklem mantığı, mantığa dayalı fikirleri yazılı bir şekilde ifade etmeye yarayacak şekilde geliştirilmiştir ve Prolog’da bu mekanizma gayet iyi kullanılır. Yüklem mantığının yaptığı ilk iş, cümlelerdeki gereksiz kelimeleri ayıklamaktır. Daha sonra cümleler-kelimeler arasındaki ilişkiler ilk sıraya, nesneler ise ilişkilerden sonra sıralanır. Bu nesneler ise ilişkilerin etkili olduğu argümanlar olarak yazılır.

Konuşma Dili                                             Prolog’daki Karşılığı

Ahmet bir insandır.                                     insan(Ahmet).

Gül kırmızıdır.                                             kirmizi(gul).

Ahmet, gülü kırmızı ise sever.                     sever(Ahmet, gul) if kirmizi(gul).

Prolog ile program yazarken, ilk önce nesneler ve bu nesneler arasındaki ilişkiler tanımlanır. ‘Ahmet gülleri sever’ cümlesindeki Ahmet ve gül kelimeleri nesne, ‘sevmek’ ise bu iki nesne arasındaki ilişkidir. Bu ilişkinin ne zaman doğru olacağını belirleyen ifadeye ise Kural denir. ‘Ahmet, gülü kırmızı ise sever’ cümlesindeki ‘sevmek’ hangi durumda Ahmet’in gülü seveceğini belirttiği için bu durumda Kural olur.

2.1. Gerçekler: Bilinen olgular

Prolog’da, nesneler arasındaki ilişkiye Yüklem denir. Tabii dilde bir ilişki bir cümle ile sembolize edilir. Prolog’un kullandığı yüklem mantığında ise bir ilişki, bu ilişkinin ismi ve bunu takiben parantez içinde yazılan nesne veya nesnelerden oluşan basit ifadelerle özetlenir. Gerçekler, tıpkı cümlelerdeki gibi ‘.’ ile biter. Aşağıdaki örneklerde ‘sevmek’ fiilinin tabii dilde ifade edilmesi gösterilmiştir.

Yasin Esra’yı sever.

Esra Cihat’ı sever.

Yasin kedileri sever.

Yukarıdaki ifadeleri olgu olarak kabul edip Prolog’daki karşılıklarını yazalım:

sever(yasin, esra).

sever(esra, cihat).

sever(yasin, kediler).

Görüldüğü gibi, gerçekler nesnelerin ve ilişkilerin değişik özelliklerini de ifade edebilirler.

2.2. Kurallar: Verilen Gerçeklerden Hüküm Çıkarma

Kurallar, gerçek olguları kullanarak bir sonuca varmak için kullanılır. Aşağıda ‘sevmek’ ilişkisinden elde edilen bazı kurallar verilmiştir:

Yasin, Esra’nın sevdiği her şeyi sever.

Hasan kırmızı olan her şeyi sever.

Bu kuralları Prolog dilinde yazmak gerekirse:

sever(yasin, hersey):-sever(esra, hersey).

sever(hasan, hersey):- kirmizi(hersey).

Buradaki :- sembolü, prosedürel dillerdeki if(eğer) anlamında olup, bir kuralın iki parçasını birleştirir.

Prolog, sever(yasin, hersey):-sever(esra, hersey) kuralını kullanarak, Yasin’in sevdiği nesneyi bulmak için önce kuralın ikinci kısmını, yani Esra’nın sevdiği nesneyi bulur. Bunun doğruluğu ispatlandıktan sonra Yasin’in sevdiği nesneyi belirler.

2.3. Sorgulamalar: (Querries)

Prolog’a bazı gerçekler tanıtıldıktan sonra, artık bu gerçeklerle ilgili sorular sormaya başlanabilir. Bunu Prolog Sistemini Sorgulama diyoruz. Veri olarak saklanan gerçekler ve gerçekler arasındaki ilişkiler bilindikten sonra, bu ilişkiler hakkında soru sorup cevap almak kolaydır.

Günlük konuşmalarda Esra Yasin’i seviyor mu? şeklindeki bir soruyu Prolog’da şöyle ifade edilir.

sever(esra, yasin).

Bunun cevabı program akışı içerisinde verdiğimiz gerçeklere bağlıdır. Yasin neyi sever? şeklindeki bir soruyu Prolog’a sormamız mümkündür. Bunu sever(yasin, Neyi) şeklinde kodlarsak, Prolog’dan şu cevabı alırız:

Neyi=esra

Neyi=kediler

2 Solutions

Çünkü önceden verilen sever(yasin, esra) ve sever(yasin, kediler) ilişkileri, bunu ispatlamaktadır.

Burada Yasin ve Esra’ın küçük harfle, Neyi kelimesinin ise büyük harfle başlamaktadır. Çünkü, yüklemdeki Yasin sabit bir nesnedir, yani değeri sabittir. Oysa Neyi bir değişkendir. Yani farklı gerçeklerle beraber, sorgudan alınacak cevaplar da farklı olacaktır. Bu yüzden değişkenler daima büyük harf veya bir ‘_’ ile başlar.

Bu durumda Neyi kelimesinin cevapları değişebilir. Prolog bir sorguya cevap ararken daima önceden verilen gerçeklerin ilkinden başlar ve hiçbirini ihmal etmeden en sondaki gerçeğe kadar ilerler.

Prolog’da, bir insana sorulabilecek başka soruları da sormak mümkündür. Fakat ‘Mehmet hangi kızı sever?’ şeklindeki bir soruya hiçbir cevap alınamaz. Çünkü yukarıdaki satırlar dikkate alındığında, bu konuyla ilgili bir bilginin mevcut olmadığı görülür. Yasin Esra’yı sevmektedir, fakat Esra’nın kız olduğuna dair bir bilgi mevcut olmadığından, Prologun bu gerçeklerden hareketle bir karara varması mümkün olamaz.

2.4. Gerçekler, Kurallar ve Sorgulamaların Bir Araya Yazılması

1. Aşağıdaki gerçekler ve kuralların var olduğunu kabul edilsin.

Büyük araba hızlıdır.

Büyük bir araba iyidir.

Küçük bir araba daha kullanışlıdır.

Kasım, eğer hızlı ise, büyük arabayı ister.

Yukarıdaki gerçeklerden anlaşılan şey, Kasım’ın hızlı ve büyük arabalardan hoşlandığıdır. Prolog da aynı sonuca varacaktır. Zaten hızlı arabalar hakkında bilgi verilmeseydi, hiçkimse Kasım’ın hızlı arabalardan hoşlandığı sonucuna varamazdı. Yapılabilecek tek şey, ne tür bir arabanın hızlı olacağını tahmin etmektir.

2.   Aşağıdaki örneğe bakarak, Prolog’un kuralları kullanarak sorgulara nasıl cevap bulduğu açıklanmıştır.

hoslanir(cengiz, masa_tenisi).

hoslanir(mehmet, yuzme).

hoslanir(yavuz, futbol).

hoslanir(levent, Spor):-hoslanir(yavuz, Spor).

Son satırdaki hoslanir(levent, Spor):-hoslanir(yavuz, Spor) bir kural olup, konuşma dilindeki karşılığı şudur: Levent, bir spor türünden eğer Yavuz da hoşlanıyorsa hoşlanır.

Bu kuralın baş tarafı hoslanir(levent, Spor) ve gövde kısmı hoslanir(yavuz, Spor) olur. Burada Levent’in yüzmeyi sevip sevmediği hakkında hiçbir bilgi yoktur. Bunu öğrenmek için hoslanir(levent,yuzme) şeklinde bir sorgu kullanmak yeterlidir. Cevap bulmak için Prolog hoslanir(levent, Spor):-hoslanir(yavuz, Spor) kuralını kullanır. Yukarıda geçen gerçeklerle bunlar arasındaki ilişkiler, aşağıdaki şekilde bir program haline getirilir

PREDICATES

nondeterm hoslanir(symbol,symbol)

CLAUSES

hoslanir(cengiz, masa_tenisi).

hoslanir(mehmet, yuzme).

hoslanir(yavuz, futbol).

hoslanir(levent, Spor):- hoslanir(yavuz, Spor).

GOAL hoslanir(levent, futbol).

Bu program Prolog’da derlenirse, ‘yes’ cevabını alınır. Çünkü hoslanir(yavuz, futbol) gerçeği Yavuz’un futboldan hoşlandığını göstermektedir. hoslanir(levent, Spor):-hoslanir(yavuz, Spor) kuralı ise Levent’in, Yavuz’un yaptığı spor türlerinden hoşlandığını göstermektedir. İlgili olgu Yavuz’un futboldan hoşlandığını gösterdiği için, Levent’in de futboldan hoşlandığını söylemek mümkündür. Bu yüzden GOAL hoslanir(levent, futbol) sorgusunun cevabı ‘yes’ olur.

Fakat hoslanir(levent, tenis) sorgusunun cevabı ‘no’ olacaktır. Çünkü:

1.   Bu sorgunun doğrulanabilmesi için gerçekler arasında öncelikle Yavuz’un tenisten hoşlandığını gösteren bir olgunun var olması gerekir.

2.   hoslanir(levent,Spor):-hoslanir(yavuz, Spor) kuralı, üstteki gerçekleri kullanarak bu konuda bir karara varamaz. Çünkü kuralın gövdesini doğrulayacak bir bilgi olmadığından, kural başarısız olur.

2.5. Değişkenler: Genel Cümleler

Prolog’da değişkenler kullanılarak genel gerçekler, kurallar yazılabilir ve genel sorular sorulabilir. Değişkenler tabii dilde de kullanılır. Tipik bir örnek vermek gerekirse:

Kasım, Ferit’in sevdiği şeyi sever.

Bu bölümün başında da belirtildiği gibi, Prolog’da değişkenler daima büyük harf veya bir ‘_’ ile başlar. sever(kasim, Sey):-sever(ferit, Sey) şeklinde ifade edilebilecek yukarıdaki cümlede, Sey değişkendir. kasim ve ferit kelimeleri sabit semboller oldukları için küçük harfle başlarlar. Bu sabitleri de ekrana büyük harfle başlayacak şekilde yazmak mümkündür. Bunun için sadece (“Kasim”, Sey) veya (“Ferit”, Sey) şeklinde yazmak yeterlidir.

2.6. Bölüm Özeti

1.   Bir Prolog programı iki tür ifadelerden oluşur: Gerçekler ve Kurallar.

·        Gerçekler, programcının doğruluğundan emin olduğu bilgiyi ilişkiler veya özellikler olarak anlattığı satırlardır.

·        Kurallar, bağımlı ilişkilerdir. Prolog bu kuralları kullanarak bir bilgiden hareketle bir konuda karar verir. Bir kural, verilen şartlar yerine geliyorsa başarılı olur, yani doğru olur.

·        Prolog’da bütün kuralların iki kısmı vardır: Baş ve Gövde kısmı. Bunlar birbirinden :- sembolleri ile ayrılırlar.

·        Baş kısmı verilen gerçekler doğrulanıyorsa doğrudur. Bu kısım aynı zamanda sonuç veya bağımlı ilişki olarak da bilinir.

·        Gövde kısmı ise doğru olması gereken şartları taşır. Böylece Prolog, programın baş kısmının doğru olduğunu ispatlayabilir.

2.   Gerçekler ve kurallar birbirinin aynısıdır. Gerçeklerin kurallardan tek farkı, açıklayıcı bilgi taşıyan gövdelerinin olmamasıdır.

3.   Prolog’a bir dizi gerçek veya kural tanıttıktan sonra, bu gerçekler veya kurallar hakkında soru sormak mümkündür. Buna Prolog Sistemini Sorgulama denir. Prolog, sorgulama esnasında, verilen gerçekler listesinin başından sonuna kadar tarama yapar ve sorguya uyan cevapları bulmaya çalışır.

4.   Prolog’daki Karar Motoru bir kuralın baş ve gövde kısmını incelerken, bilinen gerçek ve kurallara başvurur. Şartların yerine gelip gelmediğini kontrol eder. Bir kuraldaki bütün şartlar doğrulandıktan sonra, bağımlı olan kısım, yani kuralın baş kısmının doğru olduğuna karar verir. Bütün şartlar, bilinen gerçeklere göre karşılanamazsa, sorguya olumlu cevap verilemez.

Örnekler:

Prolog gerçeklerinin konuşma diline çevrilmesi, aşağıda verilmiştir.

1.   yapmaktan_hoslanir(oya, resim) = Oya, resim yapmaktan hoşlanır.

2.   cocuk(arif).= Arif, bir çocuktur.

3.   bulunur(“Çankaya Köşkü”, “Ankara”). = Çankaya Köşkü Ankara’dadır.

4.   adres(abuzer, zonturlu, “ Fatih Cad. 6. Sokak.”, “Dışkapı”, “ANKARA”, 06412).= Abuzer Zonturlu’nun adresi Fatih Cad. 6. Sokak Dışkapı, ANKARA, 06412’dir.

Şimdi tam tersini yapalım, konuşma dilinden Prolog diline çevrilme ise, aşağıdaki gibi yapılır.

1.   Vedat iyi kebap yapar = yapar(vedat, iyi_kebap).

2.   Keban Barajı Elazığ’dadır = bulunur(“Keban Barajı”, “Elazığ”).

3.   Kasım Kaya’nın telefon numarası 314 41 17’dir. telefon_no(“Kasım KAYA”, “314 41 17”).

4.   Hüseyin Meryem’in babasıdır. = baba(huseyin, meryem).

2.7. Konuşma Dilindeki Cümlelerin Prolog Programlarına Aktarılması

Bu bölümün ilk kısmında gerçekler, kurallar, ilişkiler, genel cümleler ve sorgulamalar konusunu incelenmiştir. Aynı kelimeler üzerinde çalışmakla beraber, Prolog’la daha fazla ilgili kelimeler üzerinde, yani cümlecikler, yüklemler, değişkenler ve hedefler üzerinde durulacaktır.

2.8. Cümleler (Gerçekler ve Kurallar)

Prolog dilini oluşturan iki türlü ifade vardır. Bu ifadeler gerçekler veya kurallardan ibarettir. Prolog dilinin kalbini oluşturan bu ifadelere clause denilmektedir.

Bir gerçek, bir nesnenin veya nesneler arasındaki ilişkinin bir özelliğinin sadece tek bir yönünü temsil eder. Bir gerçeğin Prolog tarafından tamamen doğru kabul edildiğini, bir sorgulamaya cevap ararken bu gerçeklerden yola çıkıldığını ve bu gerçeklerin doğruluğunun kontrol edilmediği unutulmamalıdır.

Günlük hayatımızda da doğruluğu bilinen gerçeklerden yola çıkarak bir şeyin doğru olup olmadığı araştırlır. İşte, mevcut gerçeklerden hareket ederek neyin doğru olabileceğini gösteren yapıya Prolog’da Kural denir. Şimdi Prolog’daki Kural yapısına bir örnekle yakından bakalım. Örnek:

1.   Aşağıdaki cümlede, menü’de olan bir yemeğin Mehmet’e uygun olup olmadığı sorgulanmaktadır.

Mehmet ülser olduğu için sadece doktorunun izin verdiği yemekleri yer.

Menü ve yukarıdaki kurala bakarak, Mehmet’in hangi yemeği sipariş edebileceğine karar verilebilir. Bunu yapabilmek için, menüdeki yemeğin belirli şartları taşıyıp taşımadığına bakılmaladır.

a.   Menudeki_yemek bir sebze mi?

b.   Menudeki_yemek doktorun tavsiye ettiği listede var mı?

c.   Sonuç: Eğer a ve b şıklarının ikisinin de cevabı ‘Evet’ ise, bu durumda Mehmet menüdeki bu yemeği yiyebilir.

Prolog’da bu tür ilişkilerin bir kuralla ifade edilmesi zorunludur, çünkü verilecek karar tamamen gerçeklere bağlıdır. Yukarıdaki ifadeler; Prolog gerçekleri olarak şöyle yazılabilir:

mehmet_yiyebilir(Menudeki_yemek):-

sebze(Menudeki_yemek), doktor_tavsiyeli(Menudeki_yemek).

sebze(Menudeki_yemek) ifadesinden sonra ‘,’ konulmuştur. Çünkü virgül, iki amaç arasındaki bağlantıyı gösterir ve ‘and’ anlamındadır. mehmet_yiyebilir(Menudeki_yemek) ilişkisinin doğrulanabilmesi için, sebze(Menudeki_yemek), doktor_tavsiyeli(Menudeki_yemek) ilişkilerinin her ikisinin de doğru olması gerekir.

Örnek:

Ebeveyn ilişkisini anlatan bir Prolog gerçeği aşağıdaki gibi yazılır.

ebeveyn(omer, nejla) = Omer, Nejla’nın ebeveynidir.

Programın veritabanında babalık durumunu gösteren gerçeklerin zaten var olduğunu, yani baba(omer, nejla) gerçeğinin mevcut olduğu ve aynı zamanda annelik ilişkisini de gösteren anne(leyla, nejla) gerçeğinin de var olduğu kabul edilsin. Babalık veya annelik bağı hakkında yeterince bilgi olduğundan, ayrıca baba ve anne bilgilerini anlatmak vakit kaybına neden olur. Bunu yerine genel bir kural yazmak daha mantıklıdır. Yani,

ebeveyn(Sahis1, Sahis2):-baba(Sahis1, Sahis2).

ebeveyn(Sahis1, Sahis2):-baba(Sahis1, Sahis2).

Örnek:

Bir müşteri arabayı severse ve araba satılık ise bu arabayı satın alabilir.

Tabii dildeki bu ilişki, aşağıdaki kuralla Prolog’a aktarılabilir:

satin_alabilir(Musteri, Model):-

sahis(Musteri), araba(Model), hoslanir(Musteri, Model), satilik(Model).

Aynı kural, konuşma dilinde aşağıdaki şekilde ifade edilir.

Müşteri modeli satın alabilir :-

Müşteri bir şahıs ve

Model bir araba ve

Müşteri modelden hoşlanırsa ve

Model satılık ise.

Bu kuralın baş kısmı, gövde kısmındaki her dört şartın da doğrulanması halinde doğru olacaktır. Yukarıda yazılan gerçekler, aşağıdaki şekilde program haline getirilebilir.

PREDICATES

nondeterm satin_alabilir(symbol, symbol)

nondeterm sahis(symbol)

nondeterm araba(symbol)

hoslanir(symbol, symbol)

satilik(symbol)

CLAUSES

satin_alabilir(X,Y):-

sahis(X),

araba(Y),

hoslanir(X,Y),

satilik(Y).

sahis(ahmet).

sahis(paki).

sahis(cengiz).

sahis(levent).

araba(buick).

araba(bmw).

araba(passat).

araba(toyota).

hoslanir(paki,buick).

hoslanir(levent, toyota).

hoslanir(cengiz, passat).

hoslanir(ahmet, tenis).

satilik(pizza).

satilik(toyota).

satilik(buick).

satilik(passat).

Yukarıdaki programı yazdıktan sonra Levent ve Cengiz’in ne satın alabileceğini, kimin buick marka arabayı alabileceğini bulmak için aşağıdaki hedef cümleleri kullanılabilir:

satin_alabilir(Kim, Ne).

satin_alabilir(levent, Ne).

satin_alabilir(cengiz, Ne).

satin_alabilir(Kim, buick).

2.9. Olgular Arasındaki İlişkiler: Yüklemler (Predicates)

Bir ilişkinin sembolik ismine yüklem denir ve yükleme bağlı olan nesnelere argüman denir. Mesela sever(yasin, esra) gerçeğindeki sever ilişkisi yüklem, yasin ve esra ise bu yüklemin agrümanları olan nesnelerdir.

Argümanlı ve agrümansız yüklem örnekleri:

sahis(soyad, ad, cinsiyet). sahis yüklem; soyad, ad, cinsiyet ise bu yüklemin argümanlarıdır.

basla = argümanı olmayan yüklem

dogum_gunu(isim, soyisim, tarih). Dogum_gunu yüklem, isim, soyisim ve tarih nesneleri ise argümanlarıdır. Sınırlı olmakla beraber, bir yüklem argümansız olarak da kullanılabilir.

2.10. Değişkenler (Genel Cümleler)

Basit bir sorgulamada, sever(Kim, tenis) kuralını kullanarak kimin tenis oynamaktan hoşlandığı öğrenilebilir. Bu sorguda Kim, değişken olarak kullanılmıştır. Visual Prolog’da değişken isimlerinin daima büyük harfle veya ‘_’ ile başladığı, daha önceden söylenmişti. İlk karakteri büyük bir harf veya ‘_’ olmak şartıyla, değişkenler istenilen kadar rakam, büyük veya küçük harf alabilirler. Konu ile ilgili birkaç örnek, aşağıda verilmiştir.

Geçerli Değişkenler                                     Geçersiz Değişkenler

Prolog_ile_yazdigim_ilk_program                1.deneme

_14_10_1978_tarihinde_doganlar                14.program

_1_nolu_ogrenci                                            “prolog”

Değişken ismi seçimine dikkat etmek, programın başkaları tarafından rahat bir şekilde okunması ve anlaşılması bakımından önemlidir. sever(Kim, tenis) kuralı sever(X, tenis) kuralına tercih edilir. Çünkü Sahis X’e göre daha fazla anlamlıdır.

2.10.1. Prolog’da Değişkenlerin Değer Alması

Diğer programlama dillerinde, değişkenlerin değer almalarına imkan tanıyan atama ifadeleri Prolog’da yoktur. Prolog’u diğer programlama dillerinden ayıran en önemli özelliklerden biri de budur. Prologdaki değişkenler almaları gereken değerleri atamayla değil, gerçekler veya kurallardaki sabitlere eşleştirilirken alırlar.

Bir değişken, değer almadığı müddetçe serbest değişken olarak kalır. Fakat herhangi değer aldığı andan itibaren sınırlı hale gelir. Bu sınırlılık bir sorguya cevap almak için gerekli olan süre kadar sınırlı kalır. Bu işlem bittikten sonra değişken yeniden sınırlı hale gelir, program başa döner ve alternatif çözümler arar. Dolayısıyla bir değişkene bir değer vererek bilgi depolanamaz. Değişkenler bilgi depolamak için değil, kalıp-eşleştirme ve işlemenin bir parçası olarak kullanılır.

PREDICATES

nondeterm sever(symbol, symbol)

CLAUSES

sever(oktay, okuma).

sever(yavuz, bilgisayar).

sever(orhan, tavla).

sever(vedat, uyuma).

sever(ismail, yuzme).

sever(ismail, okuma).

Hem okuma hem de yüzmeden kimin hoşlandığı sorusuna cevap aramak için şu sorguyu kullanılır.

GOAL sever(Sahis, okuma), sever(Sahis, yuzme).

Prolog bu kuralı çözmek ve önce sever(Sahis, okuma) kısmının doğru olup olmadığını bulmak için bütün gerçekleri baştan sonra kadar inceler. Çözüm bulunmadan önce Sahis değişkeninin değeri yoktur, yani serbesttir. Öte yandan okuma kısmı bilinmektedir. İlk sever(oktay, okuma) gerçeğindeki okuma kısmı sorguya uyduğu için Sahis ‘oktay’ değerini alır. Prolog aynı zamanda aşağıya doğru nereye kadar tarama yaptığını göstermek için kuralın başıyla eşleşen ilk noktaya bir ‘pointer’ koymaktadır.

Sorgunun ilk kısmı doğrulandıktan sonra ikinci kısmının da doğrulanması gerekir. Yani yüzmeden hoşlanan kişinin de bulunması gerekir. Sahis değişkeni ‘oktay’ değeri aldığı için artık sever(oktay, yuzme) gerçeğinin doğru olup olmadığı araştırılır. Gerçekler incelenirse, ‘oktay’ isimli şahsın yüzmeden hoşlanmadığı görülür. Bu durumda Prolog Sahis değişkenine atadığı ‘oktay’ değerini etkisiz hale getirir ve Sahis yeniden serbest hale gelir. Kuralın ilk kısmını doğrulayan gerçeği bulmak için Prolog bu kez kuralların başından değil, gerçekler listesine daha önce yerleştirmiş olduğu pointer’den aşağıya kadar doğru taramaya başlar. İlk gerçek gereken şartları sağlayamadığı için artık dikkate alınmaz. Bu işleme Geriye İz Sürme denir.

Yapılan taramada okumadan hoşlanan kişinin ismail olduğu görülünce Sahis değişkeni bu kez ‘ismail’ değerini alır. Kuralın ikinci kısmının doğrulanması için tarama yapılırsa, yüzme için gereken şartın yine ‘ismail’ ile sağlandığı görülür. Dolayısıyla Prolog’un vereceği cevap şu olur:

Sahis=ismail

1 Solution

2.11. Anonim Değişkenler

Anonim değişkenler, programların gereksiz bilgi ve satırlarla karmaşık hale gelmelerini engeller. Böylece bir sorgulamadan beklenilen bilgileri alabilir ve ihtiyaç olmayan değerler iptal edilmiş olur. Prolog’da anonim değişkenler ‘_’ ile gösterilir.

Aşağıdaki örnekte anonim değişkenin kullanımı verilmiştir:

PREDICATES

erkek(symbol)

bayan(symbol)

nondeterm ebeveyn(symbol, symbol)

CLAUSES

erkek(selahattin).

erkek(cihat).

bayan(sacide).

bayan(sezen).

ebeveyn(selehattin, cihat).

ebeveyn(sacide, cihat).

ebeveyn(selehattin, sezen).

GOAL ebeveyn(Ebeveyn,_).

Diğer değişkenlerin yerine kullanılabilen anonim değişkenlerin, normal değişkenlerden tek farkları şudur: anonim değişkenler hiçbir zaman bir değere eşitlenemezler.

Yukarıdaki örnek yazdıktan sonra GOAL ebeveyn(Ebeveyn,_) sorgusu çalıştırılarak, ebeveyn olan kişilerin isimleri öğrenilebilir. Çocukların isimleri istenmediği için isimlerinin yerine anonim değişken kullanılmıştır.

Programın sonucunda şu sonuç görüntülenir:

Ebeveyn=selehattin                     /*Cihat’ın ebeveyni */

Ebeveyn=sacide                          /* Cihat’ın ebeveyni*/

Ebeveyn=selehattin                     /* Sezen’in ebeveyni*/

2 solutions

Tanımlanan değişken anonim olduğu için, alınacak cevabın ikinci argümanla bağlantısı olmayacaktır. Anonim değişkenler, gerçeklerin tanımlanmasında da kullanılabilir.

vardir(_,televizyon).

yemek_yer(_).

İfadeleri konuşma dilinde “Herkesin televizyonu var” ve “Herkes yemek yer” olarak çevrilebilir.

2.12. Hedefler (Sorgular)

Şimdiye kadar Prolog’a soru sormak anlamında kullanılan sorgulama kelimesinin yerine bu andan itibaren Hedef(Goal) kelimesi kullanılacaktır. Sorgulamaları hedef olarak tanımlamak daha anlamlıdır, çünkü Prolog’a bir sorgu yöneltmekle, ona yerine getirilmesi gereken bir hedef verilmiş olur.

Hedefler sever(ismail, yuzme) gibi basit olabileceği gibi sever(Sahis, okuma), sever(Sahis, yuzme) gibi daha karmaşık da olabilir. Birden fazla parçadan oluşan hedefe Birleşik Hedef, her bir parçaya da alt hedef denir.

2.12.1. Birleşik Hedefler: Bağlaçlar ve Ayraçlar

Birleşik bir hedefin çözümünü bulmak için her iki alt hedefin doğru olması gerekir. Bu durumda, iki alt hedef arasında (ve) anlamına gelen ‘,’ kullanılır. Fakat istenilen durumlarda alt hedeflerden sadece birinin doğru olması şartı da aranabilir. Bu durumda alt hedefler arasında (veya) anlamına gelen ‘;’ kullanılması gerekir. Bu duruma Ayırma işlemi denilmektedir.

Şimdi bu durumu gösteren bir örnek inceleyelim:

PREDICATES

nondeterm araba(symbol,long,integer,symbol,long)

nondeterm kamyon(symbol,long,integer,symbol,long)

nondeterm arac(symbol,long,integer,symbol,long)

CLAUSES

araba(chrysler,130000,3,kirmizi,12000).

araba(ford,90000,4,gri,25000).

araba(datsun,8000,1,kirmizi,30000).

kamyon(ford,80000,6,mavi,8000).

kamyon(datsun,50000,5,sari,20000).

kamyon(toyota,25000,2,siyah,25000).

arac(Marka,Kilometresi,Yas,Renk,Fiyat):-

araba(Marka,Kilometresi,Yas,Renk,Fiyat);

kamyon(Marka,Kilometresi,Yas,Renk,Fiyat).

GOAL araba(Marka, Kilometresi, Kullanim_Suresi, Renk, 25000).

Bu örnekteki hedef, cümleciklerde tarif edilen 25000 dolarlık arabayı bulur. Benzer şekilde; fiyatı 25.000 dolardan daha az olan bir araba var mı? şeklindeki bir soruya cevap bulmak da mümkündür. Bunun için araba(Marka, Kilometresi, Kullanim_Suresi, Renk, Fiyat), Fiyat< 25000 şeklindeki bir sorguyla bu sorunun cevabını bulmak mümkündür. Bu kuralı sorgulandığında, alınacak cevap chrysler olacaktır.

Şimdi ‘fiyatı 25.000 dolardan az olan bir araba veya fiyatı 20.000 dolardan daha az olan bir kamyon var mıdır?’ şeklindeki bir soruya uygun bir hedef yazalım:

araba(Marka, Kilometresi, Kullanim_Suresi, Renk, Fiyat), Fiyat< 25000; kamyon (Marka, Kilometresi, Kullanim_Suresi, Renk, Fiyat), Fiyat< 20000.

Prolog ilk önce fiyatı 25.000 dolardan daha az olan bir araba olup olmadığını araştırır. Sonuç doğru olsun veya olmasın, ikinci alt hedef de araştırılır. Her ikisinden birinin doğru olması durumunda alınacak cevap olumlu olacaktır. Hedefin doğrulanması için birden fazla alt hedefin aynı anda doğru olması gerekmez. Bu tür hedeflere ayrıştırma denilmektedir ve bunun için alt hedefler arasında ‘;’ ayracı kullanılmaktadır.

2.13. Açıklama Satırları

Program yazarken program satırları arasına açıklamalar yazmak, başkalarının da programı okuyup anlamasına imkan tanır. Program içerisine yazılan bu yorum satırları derleyici tarafından dikkate alınmaz. Prolog’da yorum satırları bir kaç satırdan oluşacaksa ‘/*’ ile başlamalı ve ‘*/’ ile bitmelidir. Eğer tek bir satır yorum yazılacaksa ‘%’ işareti kullanılabilir.

/* Program yazarken kullanılan değişkenler, yüklem ve kurallar*/

/*hakkında bilgi vermek için bu tür yorum satırları yazılabilir*/

%Tek satırlık yoruma bir örnek.

/* İç içe /* yorum */ satırı yazmak da mümkündür*/

2.14. Eşleştirme

Prolog’da eşleştirme yapılırken eşlenik yapılar birbiriyle eşleşebilir. ebeveyn(selehattin, X), ebeveyn(sacide, cihat) kuralındaki X değişkeni ‘cihat’ değerini alır ve serbest olan bu değişken artık bağlı hale gelir. Bağlı hale gelen başka bir değişkene atanırsa, diğer değişken de aynı değeri alır.

2.15. Bölüm özeti

1.   Prolog’da bir program gerçekler ve kurallardan oluşan cümleciklerden oluşur.

·      Gerçekler, doğru oldukları kabul edilen ilişkiler ve özelliklerdir.

·      Kurallar bağımlı ilişkiler olup, gerçekler ve ilişkileri kullanarak bilgi elde etmeye yararlar.

2. Gerçeklerin genel yazılış biçimi şöyledir:

ozellik(nesne1, nesne2,….. nesneN)

veya

ilişki(nesne1, nesne2,….. nesneN)

Burada özellik nesnelerin herhangi bir özelliği, ilişki ise nesneler arasındaki herhangi bir ilişkidir. Özellik ve ilişki kelimelerinin her ikisi de Prolog’da aynı anlamda kullanılır.

3.   Bir programda verilen bir ilişki bir veya daha fazla nesne arasındaki ilişkiden ibarettir. sevmek(ahmet, futbol) gerçeğindeki ‘sevmek’ bir ilişkiyi, ahmet ve futbol ise bu ilişkinin nesnelerini temsil eder. solak(hasan) gerçeğinde ‘solak’ bir özelik, hasan ise bir nesnedir.

4.   Kuralların genel yazılma şekli:

Baş:-Gövde

olup, daha açık hali aşağıdaki gibidir.

ilişki(nesne, nesne, ….., nesne) :-

ilişki(nesne, nesne, …, nesne),

 .

 .

ilişki(nesne, nesne, …., nesne).

5.   İlişki ve nesne isimlerinin yazılması bazı kurallara bağlıdır. Nesne ve ilişki isimleri daima küçük harfle başlar. Bunu takiben istenilen sayıda büyük-küçük harf, rakam, ‘_’ kullanılabilir.

6.   Değişken isimleri daima büyük bir harf veya ‘_’ ile başlar. Bunu takiben istenildiği kadar küçük_büyük harf, rakam vs. kullanılabilir. Değişkenler bir değer almadan önce serbest, değer aldıktan sonra ise bağlı hale gelirler. Bir değişkene değer atayıp bilgi depolamak mümkün değildir. Çünkü bir değişken sadece bir cümlecikte bağımlıdır.

7.   Bir sorgudan sadece belirli bir bilgi alınmak isteniyorsa, anonim değişken (_) kullanılabilir. Anonim değişkene hiçbir zaman değer atanması yapılamaz.

8.   Prolog’a programda verilen gerçeklere göre bir soru sormak Prolog Sistemini Sorgulama olarak adlandırılır ve bu sorguya Hedef denir.

Bileşik bir hedef iki veya daha fazla hedeften oluşur. Bu parçaların her birine alt hedef adı verilir. Bileşik hedefler Bağlaç veya Ayraç şeklinde olabilir.

10. Eşleştirme birbirine denk yapılar arasında gerçekleştirilir. Serbest bir değişken bir sabite veya önceden değer alıp bağımlı hale gelmiş başka bir değişkene atanabilir. Serbest olan iki değişken birbirine atanırsa, birinin alacağı değer otomatik olarak diğerine atanmış olur.

3. VISUAL PROLOG PROGRAMLARININ TEMEL BÖLÜMLERİ

Bir VIP Programı genelde şu dört bölümden oluşur: Clauses (Gerçekler ve Kurallar), Predicates (Yüklemler), Domains (Değişken Tipleri) ve Goals(Hedefler).

3.1. Clauses(Olgular veya Kurallar)

Bu bölüm bir programın kalbi durumundadır. Çünkü programda tanımlı hedefler doğrulanmaya çalışılırken, doğruluğu daha önceden bilinen gerçeklerden yola çıkılır. Gerçek ve gerçekler arasındaki ilişkileri tanımlayan kuralların tanımlandığı yer bu bölümdür. Bir yüklem için tanımlanması gereken bütün clauselar kümesine Procedure denir.

3.2. Predicates (Yüklemler)

Yüklemlerin ve yüklemlerdeki argümanların tiplerinin tanımlandığı yer bu bölümdür. Visual Prolog’da mevcut olan hazır yüklemlerin tanımlanması gerekmez.

3.3. Domains (Değişken Tipleri)

Burada, Visual Prolog’da olmayan tiplerin tanımlanması yapılır.

3.4. Goal (Hedef)

Programdaki sorgular buraya yazılır.

3.5. Yüklem Tanımı

Bir yüklemin genel yazılış biçimi şöyledir:

yuklem_adi(argüman_tip1, argüman_tip2, argüman_tip3,…., argüman_tipN)

Yüklemlerin bitiş parantezinin clauses bölümündeki gibi ‘.’ ile sonlanmadığına dikkat edilmelidir. Yüklem isimleri en fazla 250 karakterten oluşabilir ve herhangi bir harfle başlayabilir. Yüklemler için isim seçilirken küçük veya büyük harfle başlamak önemli değildir. Fakat küçük bir harfle başlayan bir isim seçilmesi önerilir. Çünkü Prolog derleyicilerin çoğu ancak küçük harfle başlayan yüklem isimlerini kabul etmektedir. Kullanılabilecek karakterler şunlardır:

Büyük harfler: A, B, ………., Z

Küçük harfler: a, b, …………, z.

Rakamlar: 0, 1, ………………, 9

Alt tire: _.

Geçerli Yüklem İsimleri                                    Geçersiz Yüklem İsimleri

Olgu                                                                  [olgu]

Oynar                                                                *gider*

sahip_olunan_servet                                         Sahiptir/araba

tahakkuk_fisi                                                    bu-ayin-bordrosu

10_kisilik_sinif                                                 <10-kisiden_biri

Örnekler:

domains

isim=symbol

numara=integer

predicates

ilk_yuklem(isim, numara)

domains

sahis, eylem=symbol

araba, marka, renk=symbol

kilometresi, kullanim_yili, fiyat=integer

predicates

sever(sahis, eylem)

ebeveyn(sahis, sahis)

satin_alabilir(sahis, araba)

araba(marka, kilometresi, kullanim_suresi, renk, fiyat)

yesil(symbol)

derece(symbol, integer)

Yukarıdaki program parçasında yüklem ve argümanların anlamları aşağıda verilmiştir.

·        sever yüklemi iki argüman alır: sahis ve eylem. Bu argümanların her ikisi de değer olarak symbol, yani alfabetik karakterler alabilir.

·        ebeveyn yükleminin iki argümanı da sahis olup, domainde tanımladığı şekliyle symbol tipindedir.

·        satin_alabilir yüklemi tipi symbol olan sahis ve araba argümanlarını almıştır.

·        araba yüklemi 5 adet argüman almıştır. İlk ikisinin tipi symbol, son üçünün ise integer’dır (tamsayı).

·        yesil yüklemi, tipi symbol olan tek bir argüman almıştır. Symbol tipi zaten Visal Prolog’un standart tipleri arasında yer aldığından, ayrıca tanımlamaya gerek yoktur.

·        derece yükleminin argümanları da standart domain’de yer almaktadır.

3.6. Domains (Tip tanımları) Bölümü

Domain kısmında argümanların tipleri tanımlanır. Bir argüman alfabetik, nümerik veya her ikisinden oluşan karakterleri değer olarak alabilir. Domain kısmı, birbirinin aynısı gibi görünebilecek verilere farklı isimler vermemize imkan tanır. VIP programlarında ilişki veya gerçeklerde tanımlanmış olan nesneler (yüklemdeki argümanlar) domainlere aittir. Bu tipler standart olarak tanımlı olabileceği gibi, kullanıcı tarafından sonradan da tanımlanabilir.

Domain kısmı son derece faydalı iki görev icra eder. Birincisi, yüklemlerde tanımlanan argümanların tipleri VIP’de standart olarak tanımlamış olan symbol, tamsayı vs. domainleri olsalar bile, argümanlara farklı anlamlı isimler vermemize imkan tanır. İkincisi, standart domainler tarafından tanımlanmamış veri yapılarını tanımlanmasına imkan sağlar.

Ayrıca, yüklemdeki argümanların net olarak anlatılabilmesi için farklı domainler olarak tanımlanması da faydalıdır.

Örnekler:

1.   Aşağıdaki tabii dil cümlesinin VIP’de karşılığını yazıp, özel domain tanımı aşağıdaki şekilde yapılır.

Hasan, 28 yaşında bir erkektir.

Eğer özel olarak domain tanımlanmazsa, yani VIP’deki standart tipler kullanılırsa yukarıdaki cümle şöyle yazılabilir:

sahis(symbol, symbol, integer)

Bu yüklem ve argümanlar doğru biçimde tanımlandığı için çalışır. Fakat sahis yüklemi içinde tanımlanan üç argümanın neye işaret ettiğini hatırlamak zor olabilir.

Bunun yerine:

domains

isim, cinsiyet        = symbol

yas                                   = integer

predicates

sahis(isim, cinsiyet, yas)

şeklinde üç ayrı domain tanımlanırsa sahis argümanındaki isim, cinsiyet ve yas argümanlarının anlamı her zaman için barizdir. Bu tanımlamanın bir faydası da argüman tipleri arasında olabilecek tip eşleştirme hatalarını önlemektir.

Özel domainler, argümanların anlamını çok daha iyi ifade ettikleri halde, bütün argümanlar için özel domain kullanmak gerekmez. Bir argüman için belli bir tip tanımlanması yapıldıktan sonra, bu argüman, tipi aynı olan bir başka argümanla hiçbir şekilde karıştırılmaz. Örneğin isim ve cinsiyet argümanlarının her ikisinin de tipi symbol olmasına rağmen birbiriyle karıştırılmazlar. Fakat kullanıcının tanımladığı argümanların hepsi önceden tanımlanmış argümanlarla karıştırılabilir.

Aşağıdaki örnek, çalıştırıldığı zaman bir tip hatası verir.

DOMAINS

carpma, toplam = integer

PREDICATES

toplama_yap(toplam, toplam, toplam)

carpma_yap(carpma, carpma, carpma)

CLAUSES

toplama_yap(X, Y, Toplam):-

Toplam=X+Y.

carpma_yap(X, Y, Carpma):-

Carpma=X*Y.

GOAL toplama_yap(32, 54, Toplam).

Buradaki GOAL toplama_yap(32, 54, Toplam) doğru çalışır ve

Toplam=86

1 Solution

cevabı alınır. Carpma_yap fonksiyonu için 35 ve 25 değerlerleri kullanılırsa,

Carpma=875

1 Solution

sonucu alnır.

31 ve 17 sayılarının çarpımını bulup, elde edilen sayıyı kendisiyle toplayıp Cevap argümanının değeri aşağıdaki şekilde bulunur.

carpma_yap(31, 17, Toplam), toplama_yap(Toplam, Toplam, Cevap) şeklinde bir hedef yazılabilir. Bu hedefe göre, bulunacak sonucun

Toplam=527 (31*17), Cevap=1054 (527+527)

olması gerekirken, VIP derleyici bir hata mesajı verir. Çünkü carpma_yap fonksiyonundaki Toplam argümanı 527 değerini aldıktan sonra bu değeri ikinci yüklem olan toplama_yap’taki ilk iki argümana taşımaya çalışır. Her iki argüman da tamsayı tipinde olmasına rağmen farklı isimlerde olduklarından, birbirleriyle eşleştirilemezler ve neticede hata mesajı görüntülenir. Bu yüzden bir cümledeki fonksiyonda tanımlanan değişken birden fazla fonksiyonda kullanılacaksa, her fonksiyonda aynı şekilde tanımlanmalıdır.

Örnek:

DOMAINS

marka, renk = symbol

yas=byte

fiyat, yol=ulong

PREDICATES

nondeterm araba(marka, yol, yas, renk, fiyat)

CLAUSES

araba(chrysler,130000,3,kirmizi,12000).

araba(ford,90000,4,gri,25000).

araba(datsun,8000,1,siyah,30000).

GOAL araba(renault, 13, 40000, kirmizi,12000).

GOAL araba(ford, 90000, gri, 4, 25000).

GOAL araba(1, kirmizi, 30000, 80000, datsun).

Burada araba yükleminin 5 argümanı mevcuttur. Yas argümanı byte tipinde olduğu için alabileceği değer 8 bitlik ve 0-255 arasında değişen pozitif bir sayıdır. Aynı şekilde yol ve fiyat tipleri ulong (uzun tamsayı) olup 32-bit pozitif tamsayı değerleri alır. Son olarak marka ve renk tipleri symbol tipindedir. Yukarıdaki sorguları tek tek deneyince her birinin ayrı bir tip hatasına neden olduğu görülecektir. GOAL araba(renault, 13, 40000, kirmizi, 12000) sorgusunda byte tipinde olması gereken yas argümanı 40000 değerini almıştır. Bunun 0-255 arasında olması gerekir. İkinci sorguda yas ve renk argümanlarının değerleri yer değiştirmiştir. Bu nedenle yine hataya neden olur.

3.7. Goal Bölümü

Goal bölümünün bir kuralın yapısından sadece iki farkı vardır.

1.   Goal kelimesinden sonra ‘if’ anlamındaki ‘:-‘ operatörü kullanılamaz.

2.   Program çalışırken VIP ilk önce GOAL satırını çalıştırır.

3.8. Deklarasyon ve Kurallara Ayrıntılı Bakış

Bir yüklemdeki argümanların tiplerini tanımlarken, VIP’de hazır bulunan standart tipler kullanılabilir. Bu tiplerin domains kısmında, ayrıca tanımlanması gerekmez. Aşağıdaki tabloda hazır olarak bulunan tipler verilmiştir (Tablo 1).

Tablo 3.1: Visual Prolog’da Tipler ve Alabilecekleri değerler.

Her değişken tipi verilen aralıkta bulunan bir değeri alabilir. Integer ve unsigned tipleri, değişkenlerin tanımlandığı bilgisayar veya sistemlere göre değişen aralıktaki değerleri alırlar.

Domain tanımı yapılırken signed veya unsigned kelimeleri byte, word ve dword domainleri ile birlikte kullanılabilirler.

Domains

i8 = signed byte

tanımı normalde unsigned olan ve bu yüzden 0-255 aralığından değer alan byte yerine -128…+127 değerleri arasında değer alan bir tip haline gelir.

3.8.1. Char

İşaretsiz bir byte olarak kullanılır. Örnek: ‘A’, ‘b’…

3.8.2. Real

+/- DDDD.DDDD şeklinde olan 8 bitlik bir değişken. (1*10-^307-1*10+³⁰⁸)

3.8.3. String

255 karakter uzunluğunda olabilen bu tipin iki formatı vardır.

a)   İlki küçük harf olmak üzere harf, sayı veya altçizgiden oluşur.

b)  Çift tırnak arasına alınmış karakterlerden oluşur. Örnek

Örnekler: Adı_soyadı, “Müşterinin Adı”, “Fox Ltd.”

3.8.4. Symbol

Formatı string’ler ile aynıdır.

Symbol ve string değişkenler birbirinin aynısı olmakla beraber, VIP bunları farklı şekillerde depolar. Symbol tipleri bir tabloda saklanır. Adresleri ise nesneleri temsil edecek şekilde saklanır. Böylece eşleştirme işleminde hızlı kullanılırlar. Fakat karşılaştırmalarda String tipler karakter bazında eşleştirilir.

3.9. Yüklemlerdeki Argümanların Yazılması

Predicates bölümündeki bir argümanın tipini tanımlamaya, argüman tipi tanımlama denilmektedir.

Hasan, 28 yaşında olan bir erkektir = sahis(hasan, erkek, 28).

Sahis bu argümanlarla birlikte kullanan bir yüklem olarak tanımlamak için aşağıdaki satırın predicates bölümünde yazılması gerekir.

sahis(symbol, symbol, unsigned)

Görüldüğü gibi her üç argüman da standart tipte tanımlanmıştır. Yani, program içerisinde her ne zaman sahis yüklemi geçerse, bu yüklemi sadece 3 argümanla birlikte kullanılabilir. Bunların ilk ikisi symbol, üçüncüsü ise unsigned tipinde bir integer olmalıdır.

Alfabedeki bir harfin yerini belirleyen alfabedeki_yer(Harf, Yer) şeklinde bir ilişkiyi incelendiğinde, Harf ve Yer argümanlarının her ikisi de değişken olarak tanımlandığı görülür. Böylece Harf=a ise Yer=1, Harf=b ise Yer=2 vs. şeklinde devam eder. Bu durum kısaca şöyle ifade edilebilir.

alfabedeki_yer(Bir_harf, N).

Bunun için yazılması gereken olgular:

alfabedeki_yer(‘a’, 1).

alfabedeki_yer(‘b’, 2).

alfabedeki_yer(‘c’, 3).

………..

alfabedeki_yer(‘z’, 29.)

şeklinde olmalıdır.

PREDICATES

alfabedeki_yer(char, integer)

CLAUSES

alfabedeki_yer(‘a’, 1).

alfabedeki_yer(‘b’, 2).

alfabedeki_yer(‘c’, 3).

GOAL alfabedeki_yer(‘c’, Nerede).

Program çalıştırıldığında ‘c’ harfinin yerini veren Nerede değişkeni 3 değerini alır.

Örnek:

DOMAINS

adi_soyadi, tel_no = symbol

PREDICATES

nondeterm telefon_numarasi(adi_soyadi, tel_no)

CLAUSES

telefon_numarasi(“Orhan AYDIN”, “255 45 47”).

telefon_numarasi(“Arif GÜREL”, “3134578”).

telefon_numarasi(“Husamettin BULUT”, “3145869”).

telefon_numarasi(“Kasim YENIGÜN”, “3174152”).

Bu program, aşağıdaki sorgularla veya yenileri ilave edilerek çalıştırılabilir.

GOAL telefon_numarasi(Kimin_Telefonu, “3145869”).

GOAL telefon_numarasi(“Orhan AYDIN”, Telefon_Numarasi).

GOAL telefon_numarasi(Telefon_Sahibinin_Adi, Telefon_Numarasi).

Örnek: Ekrandan girilen bir karakterin harf olup olmadığını kontrol eden bir program yazınız. (Not: char tipi sadece bir tek karakteri tanımlar)

REDICATES

nondeterm aranan_harf(char)

CLAUSES

aranan_harf(Harf):-

‘a’<=Harf,

Harf<=’z’.

aranan_harf(Harf):-

‘A’<=Harf,

Harf<=’Z’.

GOAL

aranan_harf(‘x’).

aranan_harf(‘2’).

aranan_harf(“Merhaba”).

aranan_harf(‘a’).

aranan_harf(x).

Yukarıdaki program, verilen bir karakterin alfabenin bir harfi olup olmadığını test etmektedir. Yazılan sorguları kullanarak elde edilen sonuçları inceleyiniz. Bazı şıklarda neden hata verdiğini bulmaya çalışınız.

Predicate bölümünde aynı isimde birden fazla yüklem tanımlanabilir. Fakat bunların argümanlarının farklı sayıda olması gerekir. Predicates ve Clauses bölümlerinde aynı isimde olanların birlikte gruplanmaları gerekir. Bu yüklemler, tamamen farklıymış gibi işlem görürler.

Örnek:

DOMAINS

sahis=symbol

PREDICATES

baba(sahis) %Buradaki şahıs bir babadır.

baba(sahis, sahis) %Buradaki birinci kişi ikinci kişinin babasıdır.

CLAUSES

baba(Insan):-,

baba(Insan, _).

baba(ahmet, mehmet).

baba(omer, yavuz).

3.10. Kuralların Yazım Biçimi

VIP’de kurallar, Baş ve Gövde olmak üzere iki kısımdan meydana gelir.

Genel Biçim:

Baş:- <alt hedef1>, <alt hedef2>,……, <alt hedefN>.

Alt hedefler biribirinden ‘,’ ile ayrılır ve sonuncusu nokta ile biter. Alt hedeflerin her biri ayrı bir yüklem çağırır. Alt hedefin doğru olup olmadığı kontrol edilir. Sonuç ne olursa olsun, bu işlem bütün alt hedeflere uygulanır. Alt hedeflerin tamamının olumlu netice vermesiyle beraber o kuralın doğruluğu ispatlanmış olur. Sadece bir alt hedef bile yanlış olursa, bütün kural yanlış olur.

3.11. Prolog ve Diğer Dillerdeki ‘if’ Komutunun Karşılaştırılması

VIP’de baş ve gövde kısmını ayıran ‘:-‘ sembolü if anlamına gelir. Örneğin Pascal’daki if komutu, öncelikle if komutundan sonra gelen ifadenin doğru olup olmadığını kontrol eder. Eğer ifade doğrulanırsa, komut then ifadesinden sonraya geçer geçer.

Yani if x>10 then writeln(“Bu işlem tamam”);

satırında öncelikle x değişkeninin 10’dan büyük olup olmadığı kontrol edilir. Eğer sonuç doğru ise ‘Bu işlem tamam’ satırı görüntülenir. Aksi takdirde program bir alt satırdan itibaren çalışmaya devam eder. Bu tip ifadeye if/then şartlı denir. VIP ise bunun tam tersi olan bir sistem uygular. Öncelikle gövdedeki alt hedeflerin doğru olup olmadığına bakılır. Tamamı olumlu sonuç verirse, kuralın gövde kısmının doğruluğu ispatlanmış olur. Bu ise VIP’da then/if şartının geçerli olduğunu gösterir.

3.12. Otomatik Tip Dönüştürmeler

VIP’de iki değişken karşılaştırıldığında her ikisinin de aynı tipte olması her zaman gerekmez. Değişkenler bazen başka tiplerdeki sabit değişkenlere de atanabilir. Çünkü VIP aşağıdaki tipler arasında otomatik olarak tip dönüştürmesini yapar.

· string ve symbol

· Bütün integral tipler ve reel değişkenler. Bir karakter sayısal bir değere dönüştürülürken, bu karakterin karşılığı, sayının ASCII tablosundaki karşılığı olur.

Örneğin string tipindeki bir agüman symbol tipi ile uyumludur. Benzer şekilde integer olarak tanımlı bir tip real, char, word etc. Tipleriyle uyumludur. Bu tür tip değişikliği şu kolaylıkları sağlar:

·      string tipiyle tanımlı bir yüklem symbol tipindeki bir argümanla çağrılabilir.

·      real tipiyle tanımlı bir yüklem integer tipindeki bir argümanla çağrılabilir.

·      char tipiyle tanımlı bir yüklem integer tipindeki bir argümanla çağrılabilir.

·      Alfabetik karakterler ASCII değerleri bilinmeden de rahatlıkla kullanılabilir.

Argümanlar, tanımlı olduklarının dışında bir tipe dönüşürken ne gibi kuralların etkili olduğu, sonuçta ortaya çıkan argümanının hangi tipte olacağı konusu ileride incelenecektir.

3.13. Bir Programın Diğer Bölümleri

Şimdiye kadar VIP’daki clauses, predicates, domains ve goals bölümleri incelenmiş ve bol miktarda örnek verilmiştir. Şimdi database, constants ve global bölümlerine kısa bir giriş yapılacaktır.

3.13.1. Database Bölümü

Bir VIP programının gerçekler ve kurallardan oluştuğu bilinmektedir. Program çalışırken bazen kullanılan gerçek ve kuralları değiştirmek, güncellemek, ilave yapmak veya çıkarmak gerekebilir. Böyle bir durumda gerçekler, dinamik bir dahili veritabanı oluşturur. Program çalışırken değiştirilebilecek gerçeklerin tanımlı olduğu bölüme database bölümü denilmektedir.

3.13.2. Constants Bölümü

Diğer dillerde olduğu gibi VIP’de de sabit değişkenler kullanılabilir. Bu değişkenler constants bölümünde tanımlanır. Her bir satıra sadece tek bir sabit yazılabilir.

constants

yuz=(10*(10-1)+10)

pi=3.14159265

maas_katsayisi=4

mavi=5

Program derlenmeden önce her sabit değişkenin karşısındaki string olduğu gibi atanır. Örnek:

A=yuz*34, bekle(A)

şeklindeki A değişkenine yuz sabiti yerine 100 değil, yuz sabit değişkeninde tanımlı şekliyle (10*(10-1)+10) değeri atanır.

Sembolik sabitlerin yazımında şu kurallar geçerlidir:

· Sabit bir değişken kendisini çağıramaz. Yani sayi= 2*sayi/2 yanlıştır.

· Büyük veya küçük harfle başlayan sabit değişkenler, farklı olarak işlem görmezler. Bu yüzden büyük harfle başlayan sabit bir değişken clause veya goal bölümünde küçük harfle başlatılmalıdır. Böylece büyük harfle başlamaları zorunlu olan normal değişkenlerle karışmazlar. Örnek:

constants

iki=2

goal A=iki, write(A).

·      Bir programda birden fazla constants bölümü olabilir. Fakat programda kullanılmadan önce bu değişkenlerin mutlaka tanımlanmış olmaları gerekir.

·      Tanımlanan sabitler tanımlanan noktadan başlayıp programın sonuna kadar aynı değerde kalırlar. Bir sabit değişken sadece bir kez tanımlanabilir.

3.13.3. Global Bölümü

VIP’de şimdiye kadar tanımladığımız domains, predicates ve clauses bölümleri tamamen lokal idi. Bunları global yapmak için programın en başında global domains, global predicates vs. bölümler oluşturulabilir. Bu konu daha sonra incelenecektir.

3.14. Derleyici Direktifleri

VIP, yazılan bir program parçasının derleme sırasında belirtilen şekilde işlem görmesi için bazı direktiflerin kullanılmasına imkan tanır. Bu seçenekler menüdeki Options/Compiler Directives başlığından ayarlanabilir.

3.14.1. Include Direktifi

Bu direktif daha önce yazılan bir program parçasının veya prosedürün her çağrıldığında aynı program içerisinde tekrar tekrar kullanılmasını sağlar. Bu durum basit bir örnek üzerinde açıklanmaktadır.

İçinde en sık kullanılan tip ve yüklemlerin bulunduğu TEST.PRO isminde bir programın olduğunu varsayalım. Hazırlanan başka bir programda bu program çağırılıp kullanılmak istendiğinde, kullanılan

include “test.pro”

bir derleyici direktifidir. Ana program derlendiği zaman VIP test.pro isimli programı derleyip ana programa ilave eder. Include direktifiyle tanımlanan bir programda da başka bir include satırı bulunabilir ve o da başka bir programı çağırabilir. Fakat bir programda bir dosya sadece bir kez include “dosyaismi.pro” şeklinde kullanılabilir.

3.15. Bölüm Özeti

1.   Bir VIP programının yapısı şu şekildedir:

domains

argüman1,…,argümanN=tip

predicates

yüklem_ismi(argüman1,…, argümanN)

clauses

kurallar ve gerçekler

GOAL

alt_hedef1, alt_hedef2, …….., alt_hedefN

2.   Domains bölümünde kullanılacak değişkenlerin tipleri tanımlanır. VIP’da kullanılabilecek bazı tipler: char, byte, short, ushort, word, integer vs.

3.   Yazılmış olan gerçek ve kuralları inceleyerek doğruluğunun sağlanması istenilen Goal (sorgu), programın içine yazılması gerekir. Bu dahili bir sorgudur. Harici olarak tanımlanacak olan bir sorgu program çalışırken açılan Dialog penceresine yazılır.

4.   Aynı isimde fakat farklı sayıda argüman taşıyan yüklemler tamamen farklı yüklemlermiş gibi işlem görür.

5.   Kurallar Baş:- alt_hedef1, alt_hedef2, ………, alt_hedefN genel şekliyle yazılır. Bir kuralın istenilen sonucu vermesi için alt hedeflerin tamamının doğrulanması gerekir.

6.   Prolog’daki if komutu diğer dillerdeki if komutundan farklıdır. Prolog’da then/if şeklinde tanımlı olan bu komut diğer dillerde if/then şeklinde tanımlıdır.

4. EŞLEŞTİRME VE GERİYE İZ SÜRME

VIP bir alt hedeften gelen bir çağrıyı clauses bölümünde tanımlı bir cümle ile karşılaştırmaya çalışırken belirli bir işlem kullanır. Bu işleme eşleştirme denir. Bir program çalışırken

Goal yazdi(X,Y).

sorgusunun kullanıldığını kabul edilsin. Bu sorgunun doğruluğunu araştırırken, clauses bölümdeki bütün yazdi(X,Y) cümlecikleri eşleştirme işlemi için test edilir. Goal yazdi(X,Y) ifadesindeki X ve Y argümanları, clauses bölümündeki yazdi(…) cümlecikleriden kontrol edilir. Bunun için bütün cümlecikler tek tek incelenir. Sorguyla eşleşen bir cümle bulunduğu zaman cümledeki değer serbest olan değişkene atanır ve böylece cümle ile goal eşleşmiş olur. Bu duruma ‘sorgunun cümle ile eşleşmesi’, bu işleme de eşleştirme denilir.

Örnek

DOMAINS

kitap_adi, yazar = symbol

sayfa_sayisi       = unsigned

PREDICATES

kitap(kitap_adi, sayfa_sayisi)

nondeterm yazdi(yazar, kitap_adi)

nondeterm roman(kitap_adi)

CLAUSES

yazdi(eco, “Gülün Adı”).

yazdi(tolstoy, “İnsan Ne İle Yaşar”).

kitap(“İnsan Ne İle Yaşar “, 245).

kitap(“Gülün Adı”, 760).

roman(Kitap_adi):- yazdi(_, Kitap_adi), kitap(Kitap_adi, Sayfa_sayisi), Sayfa_sayisi> 400.

GOAL yazdi(Yazar, Kitap_adi).

Sorgudaki Yazar ve Kitap_adi değişkenleri serbest değişkenler olduklarından herhangi bir argümana eşitlenebilirler. Dolayısıyla sorgu clauses bölümündeki ilk yazdi cümlesi ile eşleşir. Yani yazdi(Yazar, Kitap_adi) cümleciği yazdi(eco, “Gülün Adı”) olur. Burada Yazar=eco, Kitap_adi=Gülün Adı değerini alır. Aynı işlem bütün alternatif çözümler için tekrar edileceğinden, Yazar ve Kitap_adi değişkenleri sırasıyla tolstoy ve İnsan Ne İle Yaşar değerlerini de alır. Yani sonuçta 2 çözüm bulunur.

GOAL roman(Roman_adi) çağrısının nasıl çalıştığı incelenecektir. Bir çağrının bir olgu veya kuralın baş kısmıyla eşleşip eşleşmediği kontrol edilir. Yani kuralın baş kısmı olan roman(Kitap_adi) kısmıyla eşleşir. Kullanılan olgudaki argümanlar eşleştirilir. X argümanı bağlı olmadığı için herhangi bir argümanla eşleşebilir. Kuralın başı olan roman(Kitap_adi)’ında, Kitap_adi argümanı bağımsız bir değişkendir. Kuralın başıyla sorgu kısmı eşleştirilir. VIP, eşleştirme yapıldıktan sonra alt hedefleri sırasıyla doğrulamaya çalışır.

roman(Kitap_adi):-

yazdi(_, Kitap_adi),

kitap(Kitap_adi, Sayfa),

Sayfa>400.

GOAL roman(Roman_adi) kodunda ilk önce yazdi(_,Kitap_adi) kısmı sorgulanır. Buradaki ilk argüman anonimdir. Dolayısıyla ilk olgudaki eco ve Gülün Adı ‘_’ ve ‘Kitap_adi’ argümanlarıyla eşleşir. Bundan sonra kitap(Kitap_adi,Sayfa_sayisi) cümleciğindeki kitap olgusuna çağrı yapılır. İlk cümlecikteki ‘eco’ ve ‘Gülün Adı’ değerlerini alır. İlk alt hedef doğrulandığı için sonraki adım olarak kitap(Kitap_adi, Sayfa_sayisi) alt hedefine geçilir. Kitap_adi argümanı ‘Gülün Adı’ değerine bağlı hale geldiği için çağrı kitap(“Gülün Adı’, Sayfa_sayisi) şeklinde devam eder. Programın başından başlayan sorgu kitap(“Gülün Adı”, 760) cümleciğinde eşleştirme yapmaz. Çünkü ilk argüman ‘Gülün Adı’ olmuştu. İkinci cümlecik sorguyu doğrular ve Sayfa_sayisi 760 değerini alır. Sayfa_sayisi>400 alt hedef halini alır. 760 değeri 400’den büyük olduğu için alt hedef doğrulanır ve böylece bütün hedef doğrulanmış olur. Sonuçta şu mesaj görüntülenir:

Roman_adi=Gülün Adı

1 Solution

4.1. Geriye İz Sürme

Gerçek problemlere çözüm ararken, verilen karar doğrultusunda mantıklı olan bir yol takip eder, yolun sonuca ulaşmaması durumunda alternatif bir yol aranır. Mesela bir labirent oyununda çıkış yolunu ararken sola veya sağa doğru gidilir. Çıkmaz sokağa gelindiğinde geriye döner, başka bir yolu takip eder. Bu yönteme göre devam edilirse, sonunda çıkış noktası bulunur.

VP, geriye iz sürme denilen bu sistemi kullanır. Bir sorgunun doğru olup olmadığı araştırılırken alt hedeflerin herbirinin ayrı ayrı doğrulanmaya çalışılır. VP, doğrulama işlemini yürütürken sorgulanması gereken durumların başlangıç noktasına bir işaret koyar. Sonra bu yolların ilkini dener. Eğer olumlu sonuç alınırsa işleme oradan itibaren devam eder. Sonucun olumsuz çıkması durumunda, işaret konulan yere döner ve ikinci yolu, yani bir sonraki alt hedefi dener. İşte bu ileriye gidiş ve gerektiğinde yine geriye dönüş işlemine Geriye İz Sürme denir.

Örnek

PREDICATES

nondeterm yemeyi_sever(symbol, symbol)

nondeterm yemek(symbol)

yemegin_tadi(symbol, symbol)

CLAUSES

yemeyi_sever(besir,X):-

yemek(X),

yemegin_tadi(X, iyi).

yemegin_tadi(kebap, iyi).

yemegin_tadi(kapuska, kotu).

yemek(kapuska).

yemek(kebap).

GOAL yemeyi_sever(besir, Besirin_Sevdigi_Yemek).

Programda iki olgu kümesi, bir de kural bulunmaktadır. Kural, Bülent’in, tadı güzel olan yemeklerden hoşlandığını söylemektedir. Sorgunun doğrulanması için VP ilk satırdan başlayarak tarama yapar. Hedefe uyan ilk satır yemeyi_sever(bulent, X) kuralının başı olduğu için Besirin_Sevdigi_Yemek argümanı X ile eşleşir. Bu durumda kuralın geri kalan kısmının doğrulanmasına çalışılır. Buradaki ilk alt hedef yemek(X) cümleciğidir. VP alt hedefi doğrulamak için yine programın en başına gider. VP eşleşen bir olgu ararken yemek(kapuska) cümleciğine ulaşır ve burada X değişkeni ‘kapuska’ değerini alır. VIP, buraya geri dönüş işaretini koyar ve alternatif bir çözüm ararken hareket edilecek ilk noktanın başlangıcı belirtilmiş olur.

Bir sonraki hedef, yemegin_tadi(X, iyi) alt hedefi olur. X ‘kapuska’ değerini aldığına göre bu cümle yemegin_tadi(lahana, iyi) şekline dönüşür. Bunun doğrulanması sırasında argümanlar başka bir olguyla eşleşmediği için bu alt hedef olumsuz olur. Dolayısıyla sorgunun bu doğrulanması başarısız olur. İşte bu noktada VP geri dönüş işaretini koyduğu en son noktaya, yani yemek(kapuska) cümleciğine gider. Geri dönüş noktasına gelindiğinde, bu noktadan sonra değer almış olan bütün değişkenler yeniden serbest hale gelirler.

Bu noktadan sonra ilk eşleşme yemek(kebap) olgusu ile olur ve X değişkeni kebap değerini alır. Daha sonraki alt hedef yemegin_tadi(kebap, iyi) olduğundan, programın başından itibaren yapılacak bir taramadan olumlu sonuç alınır. Çünkü yemegin_tadi(kebap, iyi) olgusu önceden tanımlanmıştı. Sonuçta görüntülenecek mesaj şu olur:

Besirin_sevdigi_yemek=kebap

1 Solution

Geriye İz Sürme yöntemiyle sadece tek çözüm değil, mümkün olan bütün çözümler elde edilir.

DOMAINS

aday=symbol

adayin_yasi=integer

PREDICATES

nondeterm oyuncu(aday, adayin_yasi)

CLAUSES

oyuncu(ahmet, 10).

oyuncu(mehmet, 12).

oyuncu(ali, 10).

oyuncu(huseyin, 10).

GOAL oyuncu(Birinci_oyuncu, 10), oyuncu(Ikinci_oyuncu, 10),

Birinci_oyuncu<>Ikinci_oyuncu.

VP’den yaşları 10 olan çocuklar arasında düzenlenecek bir masa tenisi turnuvası için muhtemel ikili rakip listesi istensin. Eşleştirme sırasında yaşları 10 olan, fakat kendileriyle eşleşmeyecek ikili gruplar istensin. Geriye İz Sürme yönteminin nasıl çalıştığını görmek için VP’nin takip edeceği prosedürü adım adım yazarsak:

1.   VP ilk önce sorgunun oyuncu(Birinci_oyuncu, 10) alt hedefini doğrulamaya çalışır. Bu hedef oyuncu(ahmet, 10) cümleciğiyle sağlanmış olur. VP hemen ikinci alt hedefi doğrulamaya çalışır. (Bu sırada programın en başına dönüş yapılır) oyuncu(İkinci_oyuncu, 10) alt hedefini sağlamaya çalışırken yine 10 yaş şartını birinci cümlecik sağlar. Dolayısıyla İkinci_oyuncu argümanı da ‘ahmet’ değerini alır. Her iki alt hedef sağlandıktan sonra şimdi üçüncü alt hedef sağlanmaya çalışılır. Yani Birinci_oyuncu<>İkinci_oyuncu (Birinci ve ikinci oyuncu aynı kişi olmayacak)

2.   Oyuncuların her ikisi de ahmet olarak eşleştiği için bu hedef sağlanamaz, dolayısıyla sorgu başarısız olur. VP’nin Geriye İz Sürme mekanizması yeniden bir önceki alt hedefi, yani ikinci alt hedefi sağlamaya yönelir. Bu kez ikinci_oyuncu argümanı ali değerini alır.

3.   Üçüncü alt hedef sağlanmış olur. Çünkü ahmet ve ali, yaşları 10 olan farklı kişilerdir. Bütün alt hedefler sağlandığından sorgunun tamamı başarılmış olur. Sonuçta oluşan ilk ikili

Birinci_oyuncu= ahmet, İkinci_oyuncu=ali

olarak bulunmuş olur.

4.   VP’nin sadece bir çözüm değil, mümkün olan bütün çözümleri bulur. Bu yüzden 3. alt hedef sağlandıktan sonra başka çözüm olup olmadığını bulmak için bütün alternatifler tükeninceye kadar ikinci alt hedefi sorgulanır. Bu kez ikinci_oyuncu olarak Hüseyin seçilir. Ahmet ve Hüseyin 3. şartı da sağladığı için ikinci grup ahmet ve hüseyin’den oluşur.

5.   Peki başka çözüm var mı? VP bunu bulmak için yine ikinci alt hedefe dönüş yapar. Görüldüğü gibi son oyuncu olan Hüseyin ile bu şanş tükenmiştir. İşte bu noktada Geriye İz Sürme yine ilk alt hedefe döner. İkinci eşleşme oyuncu(ali, 10) cümlesinde olur. İkinci oyuncu Hüseyin ile eşleşir. En son alt hedef de sağlandığı için bu kez ali=hüseyin ikilisi oluşturulur.

6.   Başka çözüm için VP 2. alt hedefe döner. VP ikinci kez hüseyin ismiyle eşleşme yapar. Fakat kişi aynı olduğundan sonuç alınamaz. Geriye İz Sürme yöntemiyle bütün seçeneklerin sırasıyla denenmesi sonucunda şu tablo ortaya çıkar.

Birinci_oyuncu=ahmet, İkinci_oyuncu=ali

Birinci_oyuncu=ahmet, İkinci_oyuncu=hüseyin

Birinci_oyuncu=ali, İkinci_oyuncu=ahmet

Birinci_oyuncu=ali, İkinci_oyuncu=hüseyin

Birinci_oyuncu=hüseyin, İkinci_oyuncu=ahmet

Birinci_oyuncu=hüseyin, İkinci_oyuncu=ali

6 Solutions

Bulunan sonuçların bazıları, isimlerin sadece yer değiştirilmesinden oluşmuş aynı ikili gruplardır. Bunu engellemek mümkündür.

(Not: Aynı program ile yaşları 10 ve 12 olan ikili grupları bulunuz)

4.2. Geriye İz Sürme Mekanizmasının Ayrıntıları

Aşağıdaki programa bakarak Geriye İz Sürme işlemenin nasıl işlediğini anlamaya çalışalım.

DOMAINS

isim, sey= symbol

PREDICATES

sever(isim, sey)

okur(isim)

merakli(isim)

CLAUSES

sever(ahmet, limonata):-!.

sever(murat, yuzme):-!.

sever(murat, kitap):-!.

sever(murat, basketbol):-!.

sever(Z,kitap):-

okur(Z), merakli(Z).

okur(ahmet).

merakli(ahmet).

GOAL sever(X, limonata), sever(X, kitap).

VP hedefi değerlendirirken, doğrulanan ve doğrulanamayan alt hedefleri belirler. Yukarıdaki programa aşağıdaki hedefi göz önüne alarak bakalım. Hedef aşağıdaki gibi bir ağaç dalı şeklinde gösterilebilir. Doğrulanan alt hedefi altı çizili halde, bununla eşleşen cümleciği de bunun hemen altına yazalım.

4.2.1. Geriye İz Sürmenin 4 Temel Prensibi

Yukarıdaki örnekte, hedefin gerçekleştirilmesi için doğrulanması gereken iki alt hedef vardır. Bunun için VP dört temel prensibe göre çalışır:

1.   Bütün alt hedefler, ilkinden başlanmak üzere, birer birer doğrulanmalıdır. Bir cümleciğin doğrulanması için hangi alt hedefin kullanılacağına ikinci kurala göre karar verilir.

2.   Yüklem cümlecikleri (fonksiyonlar) programdaki sırasıyla, yukarıdan aşağıya göre test edilirler. Buna göre yukarıdaki program çalışırken ‘sever’ yüklemini sağlayan sever(ahmet, limonata) cümleciğiyle doğrulanır. Dolayısıyla sever(X, limonata) alt hedefindeki X argümanı ‘ahmet’ değerini alır. Daha sonra ikinci alt hedef doğrulanmaya çalışılır. Burada bağlı hale gelen X=ahmet argümanı kullanılır. Fakat sever(ahmet, limonata) alt hedefi sever(ahmet, kitap) alt hedefine eşitlenemez, çünkü limonata ve kitap aynı değildir. Bütün cümleciklerin sırayla deneneceği için bir sonraki cümlecik sever(murat, kitap) olacaktır. Fakat X daha önce ‘ahmet’ değerini aldığı için bu şık da başarısız olur. Bu yüzden bir sonraki sever cümleciğinin sağlanması gerekir.

sever(Z,kitap):-okur(Z), merakli(Z).

Z argümanı bir değişkendir ve X değişkeni ile eşleşebilir. Zaten ‘kitap’ argümanları da eşleşir. Dolayısıyla hedef, kuralın baş kısmıyla eşleşmiş olur.

Bir alt hedef bir kuralın baş kısmıyla eşleştiği zaman, kuralın gövde kısmının doğrulanması sağlanmalıdır. Böylece kuralın gövdesi doğrulanması gereken bir alt hedefler kümesi oluşturur.

Şimdi yeniden örneğe dönelim.

sever(X,limonata)                      sever(X,kitap)

okur(Z)                                                        merakli(Z)

okur(Z) ve merakli(Z) alt hedeflerinin doğrulanması gerekir. Burada Z değişkeninin ‘ahmet’ değerini aldığı söylenmişti. Şimdi ise her iki alt hedefi de sağlayan sorgulama başlayacaktır. Sonuçta elde edilecek ağaç:

sever(X,wine)                              sever(X,kitap)

sever(ahmet,wine)                     sever(Z,kitap)

                                       okur(Z)                 merakli(Z)

okur(ahmet)                merakli(ahmet)

4.   Hedef ağacının her bir dalını sağlayan bir gerçek bulunduğu zaman hedef sağlanmış olur.

Sonuçta

X=ahmet

1 Solution

cevabı görüntülenir. Harici bir hedef doğrulandıktan sonra VP’nin, eğer varsa, bütün alternatifleri bulmak için çalışacağı söylenmişti. Bir alt hedef başarısız olursa, VP yeniden bir önceki alt hedefe döner. Bu alt hedefi, biraz önce başarısız hale gelen alt hedefi de doğrulayacak bir cümlecik ile doğrulamaya çalışır.

VP bir alt hedefi sağlamak için sorgulamaya yüklemi tanımlayan ilk cümlecikten başlar. Bu sırada aşağıdaki durumlardan biri meydana gelebilir:

1.   İlk cümlecik verilen yüklemle eşleşir. Bu durumda;

a.   Alt hedefi doğrulama ihtimali olan başka bir cümlecik varsa, Geriye İz Sürme işleminde kullanılmak üzere bu cümleciğin yanına bir işaret konur.

b.   Alt hedefteki bütün serbest değişkenler cümlecikteki değerleri alır ve bağlı hale gelirler.

c.   Eğer eşleşen cümlecik bir kuralın baş tarafı ise, hemen kuralın gövde kısmı değerlendirilir. Bu durumda gövdedeki bütün alt hedeflerin doğrulanması gerekir.

2.   Eşleşen herhangi bir cümlecik bulunmaz ve sorgu başarısız hale gelir. VP bir önceki alt hedefi doğrulamak için geriye iz sürer. En son geriye dönüş noktasına geldiğinde, VP geriye dönüş noktasından sonra değer almış bütün değişkenleri serbest hale getirir. Daha sonra alt hedefi yeniden doğrulamaya çalışır.

Tarama, programın başından başlar. Geriye İz Sürme işlemi, daha önce yerleştirilen geriye dönüş noktasından itibaren başlar. Sorgu burada da başarısız olursa, geriye iz sürme işlemi tekrar edilir. Bütün alt hedef ve cümlecikler için geriye dönüş işlemi tamamlandığında sonuç elde edilemezse, hedef başarısız olur.

Geriye dönüş işlemi için başka bir örnek.

Örnek:

PREDICATES

nondeterm tur(symbol, symbol)

nondeterm canli(symbol, symbol)

yasar(symbol, symbol)

nondeterm yuzebilir(symbol)

CLAUSES

tur(tirnakli, hayvan).

tur(balik, hayvan)

canli(zebra, tirnakli).

canli(alabalik, balik).

canli(kopekbaligi, balik).

yasar(zebra, karada).

yasar(kurbaga, karada).

yasar(kurbaga, suda).

yasar(kopekbaligi, suda).

yuzebilir(Y):-

tur(X, hayvan),

canli(Y,X),

yasar(Y, suda).

GOAL yuzebilir(Ne), write(“Bir “,Ne,” yüzebilir\n”).

Program yazılıp çalıştırıldığında ilk olarak GOAL bölümü sağlanmaya çalışılır. Şimdi yapılacak işlemleri adım adım yazalım:

1.   yuzebilir yüklemi, ‘Ne’ serbest değişkeni ile çağrılır. Eşleşme olup olmadığını bulmak için program tarandığında ‘Ne’ argümanı ‘Y’ değerini alır.

2.   Hemen sonra hedefin gövde kısmına geçersek tur(X,hayvan) alt hedefinin doğrulanması gerekir. Programın başından itibaren yapılacak bir taramada tur(tirnakli, hayvan) cümleciği bu alt hedefi sağlar. Böylece X=tirnakli değerini alır.

3.   Burada tur(X,hayvan) alt hedefini sağlayabilecek birden fazla alternatif olduğu için, tur(tirnakli,hayvan) cümleciğinin yanına Geriye İz Sürme işareti konur.

4.   X değişkeni ‘tirnakli’ değerini alınca birinci alt hedef doğrulanmış olur. Bu kez ikinci alt hedef yani canli(Y, X) doğrulanmaya çalışılır. Bu hedef ise canli(Y, tirnakli) olarak sağlanır. canli(zebra, tirnakli) cümleciği ikinci alt hedefi sağlar ve Y değişkeni ‘zebra’ değerini alır ve bu hedefi sağlayan başka cümlecikler de mevcut olduğundan, VP bu cümleciğin yanına da bir Geriye İz Sürme işareti koyar.

5.   Şimdi X=tirnakli ve Y=zebra olacak şekilde en son alt hedefin doğrulanması gerekir. yasar(Y, suda) alt hedefinin sağlanması için yasar cümleciklerinin biriyle eşleşmesi gerekir. Fakat cümlecikler arasından bunu sağlayan bir gerçek olmadığı için hedef başarısız olur.

6.   VP bu noktada geriye dönüş işareti koyduğu en son noktaya, yani ikinci alt hedef ve canli(zebra, tirnakli) cümleciğine döner.

7.   Geriye dönüş noktasına geldiğinde, bu noktadan sonra değer almış bütün değişkenler serbest hale gelir. Daha sonra canli(Y, tirnakli) alt hedefine yeni bir çözüm arar.

8.   VP daha önce işaret koyup durduğu satırdan başlamak üzere, geriye kalan cümlecikler arasında tarama yaparak şimdiki alt hedefe uyacak bir çözüm arar. Programımızda alt hedefi doğrulayacak başka bir seçenek bulunmadığından, yapılan çağrı başarısız olur ve VP yeniden bir önceki alt hedefe döner.

9.   Bu kez tur(tirnakli, hayvan) hedefini doğrulamaya çalışır. Çünkü geriye dönüş işareti buraya konulmuştu.

10. Bütün değişkenler serbest hale getirilir ve yeniden tur(X, hayvan) alt hedefine çözüm arar. Geriye dönüş noktasından sonraki tur(balik, hayvan) cümleciği bu hedefi doğrular ve X=balik değerini alır. VP bu kez geriye dönüş noktasını bu cümleciğin yanına yerleştirir.

11. VP şimdi kuraldaki ikinci alt hedefi doğrulamak üzere aşağıya doğru hareket eder. Bu tarama yeni bir tarama olduğu için tarama yine cümleciklerin başından, yani canli(Y, tirnakli) cümleciğinden başlar.

12.  canli(alabalik, balik) cümleciği alt hedefi doğrular ve Y=alabalik değerini alır.

13. Y şimdi ‘alabalik’ değerini aldığı için, yasar(alabalik, suda) alt hedefi çağrılır. Bu da yeni bir çağrı olduğu için program yine baştan başlar.

14. Cümleciklerde görüldüğü gibi, yasar yüklemleri arasında yasar(alabalik, suda) alt hedefini doğrulayacak bir seçenek yoktur. Bu yüzden çağrı başarısız olur ve bir önceki alt hedefe yeniden dönüş yapılır.

15. canli(alabalik, balik) geriye dönüş noktasına gidilir.

16. Bu noktadan sonra değer alın bütün değişkenler yeniden serbest hale geldikten sonra canli(Y, balik) çağrısına cevap aranır.

17. Bu kez Y=kopekbaligi değeri alt hedefi sağlar.

18. VP üçüncü alt hedefi yeniden doğrulamaya çalışır. Y ‘kopekbaligi’ değerini aldığı için yasar(kopekbaligi, suda) alt hedefinin doğrulanması gerekir. Bu yeni çağrı doğrulanır, çünkü son cümlecik eşleşmektedir.

19. Alt hedeflerin doğrulanmasından sonra kuralın baş kısmı da sağlanmış olur. VP, Y değişkeninin aldığı ‘kopekbaligi’ değerini yuzebilir(Ne) kuralındaki Ne değişkenine atar ve böylece Goal bölümündeki write(“Bir “,Ne,” yüzebilir\n”) alt hedefi de çağrılır. Sonuç:

Bir köpekbalığı yüzebilir

Ne=kopekbaligi

1 Solution

4.3. Tarama İşleminin Kontrol Edilmesi

VP’de var olan geriye iz sürme mekanizması bazen gereğinden fazla tarama yapabilir. Bu ise verimi düşürür. Bazen verilen bir problem için sadece bir çözüm bulmak istenebilir. Bazen de, bir çözüm bulunsa bile –varsa- başka alternatif çözümleri de bulmak istenebilir. İşte bu gibi durumlarda geriye dönüş işleminin kontrol edilmesi gerekir.

Geriye İz Sürme işlemini kontrol edebilmek için VP’nin iki özelliğinden faydalanılabilir. Bunlar,: VP’yi geriye iz sürme işlemi yapmaya zorlayan fail yüklemi ve geriye dönüş mekanizmasını engelleyen cut ‘!’ özelliğidir.

4.4. fail Yükleminin Kullanılması

Alt hedeflerden birinin sağlanamaması durumunda geriye dönüş işlemi yapılır. Bazı durumlarda alternatif çözümleri bulabilmek için bu işlemin yapılması gereklidir. VP’nin fail yüklemi, bir sorgunun başarısız olmasına ve böylece geriye dönüş işleminin yapılmasına imkan tanır.

DOMAINS

isim=symbol

PREDICATES

nondeterm baba(isim, isim)

herkesi_bul

CLAUSES

baba(“Ömer “, yavuz).

baba(ahmet, kasim).

Baba(huseyin, veli).

Baba(murat, yusuf).

herkesi_bul:-

baba(X,Y), write(X, Y,” Babası\n”),

fail.

herkesi_bul.

GOAL herkesi_bul.

Programdaki dahili hedef doğrulandıktan sonra VP’nin geriye iz sürmesine gerek yoktur.  Bundan dolayı baba ilişkisine yapılan ilk çağrı başarılı olur ve sadece bir tek çözüm sağlanmış olur. Fakat yüklem bölümündeki herkesi_bul yüklemi fail özelliğini kullanarak Prologu geriye iz sürme mekanizmasını kullanmaya zorlar ve mümkün olan bütün çözümlerin bulunmasını sağlar. Herkes yükleminin amacı, görüntülenen cevapların daha net olmasıdır.

Herkes yüklemi VP’yi zorlayarak, baba(X,Y) kuralının sağlanması için geriye dönüş işleminin çalıştırılmasını sağlar. Daima olumsuz cevap vereceği için fail kuralının doğrulanması mümkün değildir. Bu yüzden VP daima bir üstteki alt hedefe geriye dönüş yapar. Geriye dönüş olduğunda VP, birden fazla çözüm verebilecek en son hedefe döner. Bu tür bir çağrı belirsiz (non-deterministic) olarak tanımlanır. Belirsiz bir çağrı, belirli olan ve sadece bir tek çözüm sunabilen bir çağrının tam tersidir.

‘write’ yükleminin doğruluğu yeniden sağlanamaz, çünkü yeni çözümler sunmaz. Haliyle VP kuraldaki ilk alt hedefe geriye dönüş yapar.

‘fail’ yüklemini takiben başka alt hedeflerin yazılması hiçbir işe yaramaz. Çünkü ‘fail’ yükleminin kendisi daima başarısız olacağından, ‘fail’ yüklemini takip eden bir alt hedefin sorgulaması mümkün değildir.

4.5. Geriye İz Sürmeyi Engelleme

VP’de ünlem işareti ile gösterilen (!) cut yükleminden itibaren geriye dönüş mümkün değildir. Cut yüklemi, bir kuralın içinde herhangi bir alt hedefmiş gibi yazılır. Program çalışırken cut alt hedefi daima doğrulanır ve işlem bir alt hedefe geçer. Bu hedeften önceki alt hedeflere ve cut komutunu içeren alt hedefin kendisine geriye dönüş artık mümkün değildir.

Cut komutu iki amaç için kullanılır:

1.     Alternatif çözümün mümkün olmadığına önceden karar verilirse, vakit ve bellek kaybını önlemek için bu komut kullanılabilir. Böylece program daha hızlı çalışır. Buna ‘green cut (Olumlu Cut)’ denir.

2.     Programın kendi mantığı cut yüklemini gerektiriyorsa, alternatif alt hedeflerin incelenmesini önlemek için de cut kullanılır. Buna ise ‘red cut (Olumsuz Işık)’ adı verilmektedir.

4.5.1. Cut Komutunun Kullanımı

Bu bölümde cut komutunun kullanımı ile ilgili örnekler üzerinde çalışalım. r1, r2, r3 kuralları r yüklemini, a, b, c ise alt hedefleri gösterir.

Bir kural içindeki bir alt hedefe geri dönüşü engellemek için

R1:- a, b, !, c. yazılabilir.

Yukarıdaki kuralın anlamı şudur: Kural içerisindeki a ve b alt hedeflerini doğrulayan bir çözüm bulunduğunda programı durdur. Bu yüzden cut komutunu geçip c alt hedefine geçmek mümkün değildir. Dolayısıyla a ve b için alternatif çözümler mümkün olsa da, sadece bulunan ilk çözümle yetinilir. Cut komutu r1 yüklemini tanımlayan başka bir cümlecik içine gitmeyi de engeller.

Örnek

PREDICATES

araba_satin_al(symbol,symbol)

nondeterm araba(symbol,symbol,integer)

renkler(symbol,symbol)

CLAUSES

araba_satin_al(Model,Renk):-

araba(Model,Renk,Fiyat),

renkler(Renk,cazip),!,

Fiyat > 20000.

araba(murat,yesil,25000).

araba(mersedes,siyah,24000).

araba(bmw,kirmizi,28000).

araba(renault,kirmizi,24000).

araba(toyota, sari, 30000).

renkler(kirmizi,cazip).

renkler(siyah,orta).

renkler(yesil,berbat).

renkler(sari, cazip).

GOAL araba_satin_al(bmw, Hangi_renk).

Bu örneğin verilmesinin amacı, rengi cazip, fiyatı da uygun olan bir BMW almaktır. Veri tabanında BMW için zaten bir satır vardır. Prolog’un yapması gereken tek şey, fiyatının verilen şarta uyup uymadığını kontrol etmektir. Goal içerisindeki ! komutu, BMW için fiyat uygun değilse, başka bir araba aranmasını engeller. Programı çalıştırıldığında

Hangi_renk=kirmizi

1 Solution

yanıtı alınır.

4.5.2. Geriye İz Sürmeyi Engelleme

Cut komutu, bir yüklem için doğru olan bir cümlenin seçildiğini belirtmek için de kullanılabilir.

r(1):-!, a, b, c

r(1):-!, d

r(1):-!, c

r(_):- write (“Cümlelerin tamamı buraya yazılır”).

Cut komutu r yüklemini deterministic (belirli) yapar. Dolayısıyla r yüklemi bir tamsayı argümanı ile çağrılır. Yapılan çağrının r(1) olduğunu kabul edelim. Prolog yapılan çağrıya uygun bir eşleşme ararken, r’yi tanımlayan bir cümlecik bulur. Birden fazla çözüm mümkün olduğundan, Prolog ilk cümleciğe geri dönüş noktası işareti koyarak aşağıda doğru işleme devam eder ve geri kalan satırlara geçer. Olacak ilk şey, cut komutu geçmektir. Böyle yapmak artık başka bir r cümleciğine geri dönüşü ortadan kaldırır ve geri dönüş noktası ortadan kalktığı için, programın çalışma hızı oldukça artar.

Bu tür yapının diğer dillerde yazılan ‘Case’ yapılarına benzediği görülür. Deneme şartı, kuralın baş tarafında yazılır. Yukarıdaki satırları daha anlaşılır yapmak için şöyle yazalım:

r(x):- X=1, !, a, b, c.

r(x):- X=2, !, d.

r(x):- X=3, !,c.

r(_):-write (“Cümlelerin tamamı buraya yazılır”).

Örnek:

PREDICATES

arkadas(symbol,symbol)

kiz(symbol)

sever(symbol,symbol)

CLAUSES

arkadas(ahmet,fatma):- kiz(fatma), sever(ahmet,fatma),!.

arkadas(ahmet,mehmet):- sever(mehmet,futbol),!.

arkadas(ahmet,esra):- kiz(esra).

kiz(tuba).

kiz(fatma).

kiz(esra).

sever(mehmet,futbol).

sever(ahmet,esra).

GOAL arkadas(ahmet,Kimin_Arkadasi).

Program akışı içerisinde Cut komutu kullanılmazsa, yukarıdaki örnekten iki ayrı sonuç elde edilir. Yani Ahmet hem Mehmet’in hem de Esra’nın arkadaşıdır. Fakat arkadas iliskisini tanımlayan ilk cümledeki Cut komutu, bu cümlenin doğrulanıp Ahmet’in bir arkadaşının bulunması durumunda, artık ikinci bir arkadaş bulmanın gereksiz olduğunu vurgular. Bu yüzden yukarıdaki Goal için sadece Mehmet’in Ahmet’in arkadaşı olduğu cevabı görüntülenir.

4.6. Determinism ve Cut

Yukarıdaki örnekte ‘arkadas’ yüklemi Cut kullanılmadan tanımlanmış olsaydı, non-deterministic, yani geriye iz sürme işlemiyle birden fazla çözüm üretmesi mümkün bir yüklem olacaktı. Programların ihtiyaç duyacakları bellek miktarı artacağından, özellikle non-deterministic yüklemler ile çalışılırken dikkatli olmak gerekir. VIP non-deterministic yüklemleri dahili olarak kontrol etmekle beraber, güvenli bir program yazmak için check_determ derleyici direktifini kullanmak faydalıdır. Eğer check_determ programın hemen ilk satırına yerleştirilirse, programın çalıştırılması esnasında non-deterministic yüklemlere gelindiğinde bir uyarı mesajı görüntülenir. Böylece non-deterministic olan bir yüklemin gövde kısmında (body) uygun bir Cut komutu kullanarak yüklemi deterministic hale getirebiliriz.

4.7. Not Yüklemi

Genel Not Ortalaması 3.5 olan ve beklemeli olmayan Şeref Öğrencisini bulman program:

DOMAINS

isim= symbol

gno= real

PREDICATES

nondeterm seref_ogrencisi(isim)

nondeterm ogrenci(isim, gno)

beklemeli(isim)

CLAUSES

seref_ogrencisi(Isim):-ogrenci(Isim,Gno),Gno>=3.5, not(beklemeli(Isim)).

ogrenci (“Kasım Yenigün”, 3.5).

ogrenci(“Ferit DAĞDEVİREN”, 2.8).

ogrenci(“Orhan AYDIN”, 3.8).

beklemeli(“Kasım Yenigün”).

beklemeli(“Ferit DAĞDEVİREN”).

GOAL seref_ogrencisi(Seref_Ogrencisinin_Adi_Soyadi).

Not komutunu kullanırken dikkat edilmesi gereken tek bir kural vardır: Not komutu, sadece alt hedefin doğruluğunun ispatlanamaması durumunda işlem görür. Serbest değişkenli bir alt hedef Not içerisinden çağrıldığı zaman, Prolog, Free variables not allowed in ‘not’ or ‘retractall’ (Not veya retractall içerisinde serbest değişkenler kullanılamaz) hata mesajını verecektir. Prolog’un bir alt hedefteki serbest değişkenlere değer ataması için, bu alt hedefin başka cümlecikle eşleşmesi ve alt hedefin doğrulanması gerekir. Not içeren bir alt hedefteki bağımsız değişkenleri kullanmanın en doğru yolu anonim değişkenler (_) kullanmaktır.

Aşağıda bu konu ile ilgili yanlış ve doğru örnekler verilmiştir:

sever(ahmet, Herhangi_Biri):-                 /* ‘Herhangi_Biri çıktı argümanıdır’*/

sever(esra, Herhangi_Biri),

not(nefret_eder(ahmet, Herhangi_Biri).