Bilgisayar Mühendisliği Hakkında Herşey: Aralık 2011

Lisp Programlama Dili

LISP

· Lisp Nedir ?

· Lisp’in Özellikleri

· Kullanılan LİSP Derleyicisi

· Lisp programlama dili

- Lisp Dilinin Yapısı

- Operatörler ve Atomlar

- Karşılaştırmalar

- Setf ve Setq Fonksiyonları

- Değişkenler(Local ve Global)

- Matematiksel İfadeler

- Listeler

- Lisp’te Fonksiyon Yapısı ve Built-in Fonksiyonlar

- Kontrol Yapısı ve Döngüler

- I/O Yapısı

- Diziler

- Lisp’te Yüksek Seviyeli Fonksiyonlar

Lisp Nedir?

· Lisp, 1958 yılında John McCarty tarafından geliştirilmiş en eski, ikinci üst seviye programlama dilidir.

· List Processing 'in (Liste İşleme) kısaltılmış ifadesidir.

· Çoğunlukla yapay zeka uygulamalarında kullanılmakla beraber birçok probleme etkin çözümler üretebilen modüler programlama dilidir.

· Diğer dillerin sunduğu birçok yararlı özelliğe sahiptir( structures, çok boyutlu diziler, nesneler, karakter katarları vs ).

· LISP, yüksek seviyeli programlama dillerinin bir çoğuna göre daha az sınırlayıcı syntax yapısına sahiptir.

Lisp’in Özellikleri

· Değişkenleri liste olarak kabul eder.

· Dinamiktir; kullandığınız veri tiplerinden fonksiyonlara kadar bütün girdiler(entry) her yönüyle değişebilmektedir. Esneklik sağlar.

· Değişken tipi tanımlamaya gerek yoktur. Programın çalışır hale gelmesi için kendisi belirler. (Implicit tanımlama)

· LİSP Context free gramerdir.

· Güvenlidir. Bütün olayları kontrol altında tutar, beklenmedik bellek hatalarına ve çakışmalara izin vermez.

· LİSP ; C ,C++’ta run time anında yapılması gereken bir çok şeyi compiler anında yapmaya izin verir.

· Hata bildirimi ve hata eleme için güçlü araçlar sunar.

· Lispte Garbage- Collection vardır ve bununla daha emniyetli daha kesin ve doğru hafıza yönetimi sağlarsınız.

· En az sınırlayıcı syntax’a sahip olması en önemli avantajlarındandır.

· Case sensitive değildir.İstediğiniz şekilde büyük ve küçük harf ayrımında özgürsünüz.

· Geliştirilmiş hata tutma sistemine sahiptir.

· Diğer modern diller gibi sınırlayıcı, bir sürü yazım biçimini zorlayıcı da değildir. Basit ve esnek bir yazımı vardır.

Lisp Dilinin Yapısı

· Parantezler LİSP dilinin temel yapısını oluşturlar.

Örnek:

(defun a()

(setq b 5)

(setq c 6)

(setq d (+ b c))

(print d)) =>b ve c‘ye atanan iki değeri toplayıp d’ye atan ve sonucu ekrana yazan program

· Kesme işareti veri girilmesi durumunda kullanılır. Kesme işareti kullanılarak komut kipinden çıkılarak veri kipine geçilmiş olur.

(setq a’(ali ahmet mehmet))

· LİSP dilinde bir ifadeye değer atamak o ifadenin değişken olması için yeterlidir.

· Bir değişkenin değerini, değişkene başka değer vererek değiştirebiliriz.Değişken integer iken bir anda float ya da daha farklı bir tip olabilir.

Örnek:

(defun degisken()

(setq a 3)

(setq a’sayı) )

Operatörler

· + toplama

· - çıkarma

· * çarpma

· / bölme

· Mod mod alma

Atomlar

· Lisp te 2 özel atom vardır. Bunlar: - t

- Nil’dir.

· t “true “ olarak telaffuz edilip doğruyu temsil etmektedir . Nil ise yanlış veya boş listeyi temsil etmektedir.

Karşılaştırmalar

· (= a b) => eşit mi

· (/= a b) => eşit değil mi

· (< a b) => a

· (> a b) => a>b doğru mu?

· (<= a b) => a<=b doğru mu?

· (>= a b) => a>=b doğru mu?

max ve min karşılaştırma fonksiyonları:

· (max 10 11) ==> 11

· (min -12 -10) ==> -12

· (max -1 2 -3) ==> 2

tek-çift kontrol fonksiyonları:

· (evenp a) => a çift mi? =>parametre integer olmalı

· (oddp a) => a tek mi? =>parametre integer olmalı

Setf ve Setq

· Setq: Basit bir setq kullanımına örnek olarak değişkenlere değer atama verilebilir. Örneğin aşağıdaki kodda a,b ve c değerlerine 0,1 ve 2 değerleri atanıyor.

>(setq a 0 b 1 c 2)

a => 0

b => 1

c => 2

setq nun diğer bir kullanımı da sıralı değerleri kullanarak güncelleştirmeler yapmaktır. Örneğin aşağıdaki kodda önceden tanımlanmış değerler ile yeni değerler oluşturulurken setq komutu kullanılmış.

>(setq a (1+ b) b (1+ a) c (+ a b))

a => 2

b => 3

c => 5

· Setf: setf komutu liste tanımlamasında kullanılır. Yukarıda tanımladığımız yapı üzerinde düşünürsek a değeri ilk başta 0 iken aşağıdaki setf komutu ile bu değeri 3 yapıyoruz.

>(setf a 3)

Lokal Değişkenler

Local değişkenler “let” ile tanımlanırlar.Diğer dillere benzer yöndetanımlandığı fonksiyonun parantezi dışındaki ifadeler bu local değişkene erişemezler.Farklı olarak aynı fonksiyonun içinde de bu değişkene erişilemez.

Örnek1:

(defun yaz ()

(let ((a 5))

(print a)) "erisebilir"

"(print a) --> hata erisemez.."

)

(defun yaz2()

"a lokal degiskenine ulasamaz"

(print a))

Ornek2;

(defun topla()

(let ((a 4)(b 4)(c 5))

(setq d (+ a b c)))

(print d)

)

(defun ulas()

"topla fonksiyonu calismadan yazamaz"

(print d))

Ornek3;

(defun v()

(print "1 sayi giriniz..")

(setq b(read))

(let ((a b)(b 3))

(setq d (+(* a 5) b))) "d=(a*5)+b demek"

(print d)

(print "b nin son haline dikkat")

(print b)

)

Global Değişkenler

· Global değişkenler :

Lisp’ deki global değişkenler , defparameter ve defvar ile tanımlanırlar.

Örnek :

>> ( defparameter x 120 )

>>x

120

>> ( defvar y 50 )

>>Y

Defparameter ile tanımladığımız değişkenin değerini tekrar defparameter veya setq kullanarak değiştirebiliriz;fakat defvar kullanarak değiştiremeyiz.

Defvar ile tanımlanan değişkenin değeri ise tekrar defvar kullanılarak değiştirilemez. Ancak defparameter ile tekrar değiştirebiliriz.

Defvar ile tanımlanmış değişkenin değeri setq kullanılarak değiştirilebilir.

Örnek :

>> ( defvar y 555 )

>>Y

555

>> ( setq y 304 )

>> y

304

Programda değerinin zor değişmesini istediğimiz değişkenleri defvar ile tanımlamamız

daha doğru olacaktır.

Örnek:

(defparameter x 30)

(defun a()

(print x))

(defun b()

(defvar x 5) "x sayisi degistirilemedi"

(print x))

(defun c()

(defparameter x 333) "x sayisi degisti.."

(print x))

(defun d()

(setq x 222) "x sayisi degisti.."

(print x))

(defun e()

(defparameter x 123) "x sayisi degisti.."

(setq x 456) "x sayisi degisti.."

(defvar x 789) "x sayisi degismedi"

(print x))

Lisp’te Matematiksel Ifadeler

· Lispte matematiksel ifadeler java veya c’deki gibi int a=3+6; şeklinde yazılmaz.Bunun lispteki karşılığı tam olarak (setq a(+ 3 6)) şeklindedir.

Örneğin;

(defun islem1()

(setq sonuc(+(-(* 1 2)4)6)))

· İşlemi sonuc=(((1*2)-4)+6) ifadesine denk gelir.Benzer bir islemde daha gösterecek olursak;

(defun cikarma()

(- 9 3 5 1 2) ) işlemi sonuç olarak -2 verecektir.

· İfadelerden de anlaşılacağı gibi lispte operatörler sola dayalı yazılır ve önce parantez içleri işlem görür.Örnek verecek olursak;

(/ 6 (/ 3 2)) = (6 / (3/2)) =1

(-(+(* 1 2)9)4) = ((9+(1*2))-4 = 7

· (setq bol(/ 6 3 2)) = {bol = (6/3)/2} = 1

Burada dikkat edilecek nokta işlemlerin sola dayalı yapılacağıdır.

· Devam edersek;

(/ 5 3) =1.6666 değildir..(5/3) tür..

· (defun bolme1()

(/ 10 4) ) işleminin sonucu 5/2 dir.

· Fakat;

(/ 5.0 3) = 1.666667 olur.

Bolmede rasyonel değer sonuç almak yerine reel sayı almak istiyorsak argümanlardan birini reel yapmalıyız.

· (defun bolme2()

(setq s1(+(/ 5 3) 2))

(setq s2(+(/ 5.0 3) 2)) )

İfadesi için s1={11/3} iken s2=3.666667 dir.

· Hazır fonksiyonlara bakacak olursak;

· (sqrt 16) = 4 , (sqrt 34) = 5.830 “karekök”

· (expt 4 0.5) =2 , (expt 3 3) = 27 “genel”

· Örnek programa bakacak olursak;

(defun us(n m)

(expt n m) )

İfadesi genel bir üs alma ifadesidir. (us 16 0.5) diye çağırırsak 4 değerini döndürecektir.

· (random 5) à 0 ve 5 arası rastgele sayı üretir.

· (abs -8) = 8 àargümanın mutlak değerini alır.

( let x 2.67) için;

· (floor x) à 2 tabana göre yuvarlama yaptı.

· (ceiling x) à3 alabileceği en yüksek tamsayıya göre yuvarlama yapar.

· (round x) à 3 ondalıklı kısma göre yuvarlama yaptı.0.5 ten büyük olduğu için sonuç 3 oldu.

Listeler

· Listeler, belirli özelliklere göre oluşturulmuş nesneler kümesidir. Değişik amaçlar için kullanılabilirler.

· Listelerin önüne kesme işareti( ‘ ) konulur. Bu listeler ile fonksiyonların ayırt edilmesini sağlar.Gelen verinin fonksiyon değil de data olarak algılanmasını sağlar.

· Fonksiyonlarda olduğu gibi listeler de parantez içine yazılır.

· Listenin içeriği ve listede kaç tane değer olacağı hakkında bir sınırlama yoktur.

· Listede elemanların boşluk içermemesi gerekir ; çünkü listede boşluk ,eleman ayırma

Listeler

· Listeler, belirli özelliklere göre oluşturulmuş nesneler kümesidir. Değişik amaçlar için kullanılabilirler.

· Listelerin önüne kesme işareti( ‘ ) konulur. Bu listeler ile fonksiyonların ayırt edilmesini sağlar.Gelen verinin fonksiyon değil de data olarak algılanmasını sağlar.

· Fonksiyonlarda olduğu gibi listeler de parantez içine yazılır.

· Listenin içeriği ve listede kaç tane değer olacağı hakkında bir sınırlama yoktur.

· Listede elemanların boşluk içermemesi gerekir ; çünkü listede boşluk ,eleman ayırmada kullanılır.

· Örnek:

(defun fonk()

(setq a‘(MUSTAFA KEMAL) ))=>Listede iki eleman yer alıyor.

· Lisp elemanları liste olan listeler oluşturulmasına da imkan verir.

Örnek: (defun a()

(setq liste‘((aslihan emrah ali) (1 2 3) (f i r a t) )))

Çıktısı: (ASLIHAN EMRAH ALI)(1 2 3)(F I R A T)

Liste Fonksiyonları

· Car: Bir listenin ilk elemanını return eder.Bu fonksiyon yerine aynı zamanda first de kullanılabilir.

(car’(a b c))=>çıktısı: (a) olur

· Cdr:ilk elemana gittikten sonra geriye kalan listeyi return eder.Bu fonksiyon yerine rest de kullanılabilir.

(cdr’(a b c))=>çıktısı: (b c) olur.

· Cons:Bir parça ve bir listeyi alır ve parça listenin ilk elemanı olacak şekilde yeni liste oluşturur.

(cons’a’(b c))=>çıktısı: (a b c) olur.

Lisp Listelerinde Yapılan Işlemler

· Liste Oluşturma:

(defun a()

(setq liste'(1 2 3)))

Setq ve setf fonksiyonları ile liste yapısı oluşturabiliriz.

· Listeden silme:

(defun a()

( setq data '( 9 3 5 11 23 ) )

(remove 11 data ))

Yukarıdaki örnek listeden 11 elemanını siler.

· Listede Sıralama:

(setf data '(1 3 5 8 2 12 6 ) ) oluşturulan bir listeyi sıralamak istersek;

(setf data ( sort data '< )) ile küçükten büyüge sıralar:

(1 2 3 4 5 6 8 12)

(setf data ( sort data '> )) ile büyükten küçüge sıralar.

(12 8 6 5 4 3 2 1)

· Not: ‘< yerine #’< kullanılabilir.

Örnek:

(defun siralama()

(setf dizi'(1 23 455 2 90 3 44))

(setf dizi ( sort dizi '< ))

(print dizi)

(setf dizi ( sort dizi '>)))

· Listede Birleştirme:

İki farklı listeyi birleştirme:

Örnek: (defun a()

(union '(1 2 3 5 7 8 ) '(2 3 4 6)))

Sonuç:(1 5 7 8 2 3 4 6)

Örnek:

(defun a()

(setf li1'(1 2 3 5 7 8) li2'(2 3 4 6))

(union li2 li1 ))

Sonuç: (4 6 1 2 3 5 7 8 )

Birleştirme işleminde öncelikle aynı olmayan elemanları küçükten büyüğe dogru sıralı bi şekilde yazar ardından aynı olan elemanları yazar.

· Ortak Elemanları Bulma:

(defun x()

(intersection '( 1 4 6 9 13 11)'(2 4 13 7 11)))

Sonuç: (4 13 11)

· Ortak Olmayan Elemanlar Bulma:

(defun a()

( setf liste1'(1 4 8 2 12)

liste2'(32 1 8 20))

(set-difference liste2 liste1))

Sonuç: (32 20)

· Listede eleman aratma:

(defun a()

(member '2'(1 2 3 4 5 6)))

İfadesini yazdığımız zaman 2 ye eşit ve büyük olanları ekrana yazar.

Sonuç : (2 3 4 5 6)

· Nth ile bir listenin n. elemanını istiyorsak o elemana ulaşabiliriz.

>(nth0 ‘( a b c d e f )) àsonuç a olur

>( nth4 ‘( a b c d e f )) à sonuç e olur.

Lisp’te Fonksiyon Yapısı

· DEFUN (DEfine FUNction ):

Lisp programlama dilinde fonksiyon tanımlamak için kullanılır.

Defun ile fonksiyon olustururken gerekli unsurlar:

-Birincisi fonksiyon ismi

-İkincisi fonksiyon için parametre listesi

-Üçüncüsü fonksiyon gövdesi

· (defun <FONKSIYONUN_G&OUML;VDESI> )

Örnek1:

(defun fonk(x y) ;girilen iki sayıyı toplayıp a değişkenine atan program

(setq a(+x y))

(print a))

Örnek2:

(defun kareal(n) ;girilen n sayısının karesini alıp ekranda gösteren program

( * n n) )

· Defun fonksiyonunun içinde bir veya birden fazla parametre olabileceği gibi hiç parametre de olmayabilir.(bizim tanımlayabildiğimiz user-defined fonksiyonlar)

(DEFUN fonksiyon_adi(parametre digerparametre)

(* parametre digerparametre) )

*Lisp studio için bir fonksiyonun çalıştırılması..

[1]> à F5(run file) ile çalıştırdık.

FONKSIYON_ADI

[2]> (fonksiyon_adi 21 10) àFonksiyonu çağırdık

210 àsonuç

[3]>

· Fonksiyon İçinde Fonksiyon Çağırma:

Örnek 1;

(defun topla (x y)

(+ x y) )

(defun yazmaislemi ()

(print (topla 21 21)) ) àsonuç (42) olacaktır.

Örnek 2;

(defun carp(x y)

(* x y) )

(defun klavyeOku()

(setq x(read)) àgirilen x ve y değerlerini çarpmaktadir

(setq y(read))

(carp x y) )

Hazır(built-in) Fonksiyonlar

a) fisrt()-Second()-nth() fonksiyonları

(first '(a b c)) ; sonuç A olacaktır.

(second '(a b c)) ; sonuç B olacaktır.

(nth 2 '(a b c)) ; sonuç B olacaktır.

b) rest() fonksiyonu

(rest '(a b c))

àsonuç ( b c) olacaktır. (ilk karakter hariç diğerlerini listede tutar)

c) lenght() fonksiyonu

length ile yukarıda görülen listelerin uzunluğu bulunur.

( length '(bana bir bardak su getirir misin 12 0 21 ) )

à sonuç 9 olacaktır.

d) subseq() fonksiyonu

liste içerisinden başlangıç ve bitiş parametreleri verilerek liste içerisinden seçer.

(subseq '(a b c d e f ) 1 5)

başlangıç parametresi 1 , bitiş parametresi de 5 verilmiş

à sonuç (b c d e ) olacaktır.

e) position() fonksiyonu

Bu fonksiyon ile listede bir elemanın pozisyonunu bulabiliriz.

(position ‘kipel‘ (emrah aslıhan ali kipel akbuga guleryuz ))

à sonuç 4 olacaktır

f) sort() fonksiyonu

Bu fonksiyon ile liste içerisinde sıralama yapabiliriz.

(sort ‘(5 1 8 2) ‘<)

à sonuc (1 2 5 8 ) olacaktır.

(sort ‘(5 1 8 2) ‘>)

à sonuc (8 5 2 1) olacaktır.

g) apply() fonksiyonu

(apply ‘fonksiyonismi’(liste))

Aldığı fonksiyonu listeye uygular.Örneğin;

(apply ‘+ ‘( 4 5 6 7 8 ))

+ fonksiyonunu listeye uygular toplamlarını verir.

à sonuç (30 ) olacaktır.

h) car() fonksiyonu

Bu fonksiyon listenin ilk elemanını bulur ve döndürür.

(car ‘(a 2 c )) à sonuç A olacaktır.

(car '((a b) (c d))) à sonuç (A B) olacaktır.

i) Cdr() fonksiyonu

Bu fonksiyon listenin ilk elemanından sonra geriye kalan liseyi döndürür.

(cdr ‘(a e d)) àsonuç (e d)

(cdr '((1 b) (2 d))) àsonuç ((2 D)) olur

(car (cdr '(ali mehmet murat))) àsonuç (MEHMET) olacaktır.

(cdr '(a)) àsonuç () olacaktır.

j) reverse() fonksiyonu

Bu fonksiyonla bir listeyi ters çevirebiliriz.

( reverse ‘(1 2 3 a b c )) à sonuç (C B A 3 2 1) olacaktır.

If() İfadesi

LISP diğer bilinen diller gibi eşitliklere ve koşullara sahiptir.

( if(koşul)

“Koşul dogruysa yap”

“Koşul doğru değilse yap” ) àelse durumunda yapılacak

(defun kucukmu (x)

(if (< x 10)

(princ " x<10")

(princ "x>10")))

(defun esitmi (x)

(if (eq x 10)

(princ " x=10")

(princ "x!=10")))

(defun esitmi2 (x)

(if (= x 10)

(princ " x=10")

(princ "x!=10")))

Şeklinde kullanabiliriz.

Cond(Condition=Koşul) Deyimi

Cond ifadesi switch-case ifadesine çok benzemektedir ve if deyimiyle aynı göreve sahiptir.

Aralarındaki farklar yazılış tipleri ve pek çok if ifadesi yerine tek bir cond fonksiyonu kullanılabilmesidir.

Örneğin;

(defun condkontrol (t)

(cond ((> t 0) "Sayi > 0")

((= t 0) "Sayi = 0")

((< t 0) "Sayi < 0") ))

When() İfadesi

When bir şart ifadesidir.When ifadeside if ifadesi gibi parantez içindeki koşul doğru olduğu zaman çalışır ve alt satırdaki kodu icra eder ama if deyiminden farklı olarak else durumu yoktur.Else kısmının nil(boş) olduğu durumlarda if yerine kullanılabilir.

(defun whenkontrol (x)

(when (> x 0)

(print "x pozitif")

(print "x negatif")))

Koşul sağlanırsa ekrana x pozitif yazacaktır ;fakat koşul sağlanmazsa ekrana NIL yazacaktır , x negatif yazmayacaktır.

Case() Kontrol İfadesi

Diğer dillerde bulunan switch-case yapısına denktir.

Cond ifadesi de bir nevi switch-case ifadesine benzerdi ama bu ifade Cond ifadesine göre daha kullanışlıdır.

(defun kontrolcase (x)

(case x

(0 "Sari") ; x = 0 ise SARI stringini return edecek

(m "Mavi") ; x = m ise MAVI stringini return edecek

(otherwise "Diger") )) ; girilen x default deger ise ekrana

; DIGER yazdıracak.

Döngüler

Dolist() döngüsü

Lisp’te en çok kullanılan döngü dolist döngüsüdür. Listedeki her bir eleman “NIL”e ulaşıncaya kadar teker teker parametre olarak verilen değişkene atanır.

(dolist (degisken '(1 ali emrah))

(print degisken))

àsonuç ;

ali

emrah

NIL şeklinde olacaktır.

Dotimes() döngüsü:

Bu döngüde ifadenin kaç kere döneceğine müdahale edebilmekteyiz.

Bu değişken 0’dan başlayıp, (değişken-1)’e kadar dönmektedir.

(dotimes (i 3)

(print i)) àçalıştırılırsa..

àsonuç ;

NIL …olacaktır.

Do() döngüsü

Bu döngüyü tamamen biz yönetmekteyiz.Döngünün başlangıç ,bitiş ve artış miktarı değerlerini biz belirlemekteyiz.

(do ((i 0 (1+ i)))

((>= i 4))

(print i))

i, 0’dan başlayıp, her seferinde 1 artarak ve 4’ten küçük veya eşit oluncaya kadar dönmektir.

Bu komutu daha basit bir şekilde dotimes makrosuyla da yapabilirdik ama her zaman dotimes döngüsü işimize yaramamaktadır.

(dotimes (i 4)

(print i))

I/O Işlemleri

Okuma İşlemi

Lisp run-time input yapabilmektedir.Read()

fonksiyonu bir değeri klavyeden alır ve biz o alınan

Değişkeni istediğimiz gibi kullanabiliriz .

(setq X(read))

Girilen degeri X değişkenine atar .

Okuma İşlemi

Lisp run-time input yapabilmektedir.Read()

fonksiyonu bir değeri klavyeden alır ve biz o alınan

Değişkeni istediğimiz gibi kullanabiliriz .

(setq X(read))

Girilen degeri X değişkenine atar .

Aynı zamanda satır satır da okuyabiliriz. Bu karakter stringleri ile çalışırken lazım olabilir. Klavyeden bir satır okumak için:

(setq line (readline))

Buradaki ”line“ bir karekter stringi olacak şekilde bir lisp değişkenidir.

Yazma işlemi

Çıkış için “princ “,”print” yada “prin1” fonksiyonları kullanılabilir.

*Princ fonsiyonu en sona newline yerleştirmez. Bunun için “print” kullanılır. Print fonksiyonu princ gibidir ama çıkışa newline işareti koyar. Yani yazdırılan bilgiden sonra alt satıra geçer.

Örneğin;

(princ “ali kipel”)

(princ “emrah akbuga”)

(princ “aslıhan güleryüz”)

àsonuç: ALI KIPELEMRAH AKBUGA ASLIHAN GÜLERYÜZ olacaktır.

(print “ali kipel”)

(print “emrah akbuga”)

(print “aslıhan güleryüz”)

àsonuc:

ALI KIPEL

EMRAH AKBUGA

ASLIHAN GÜLERYÜZ

Lisp’te Diziler

· Dizi tanımı make-array fonksiyonu ile olur.Dizi elemanlarını okuma işlemi aref fonksiyonu ile gerçekleştirilir.Dizi tanımlandıktan sonra otomatik olarak değerleri nil’olur.Dizi indis numaraları daima sıfırdan başlar.Ayrıca Lisp matris tanımlamayı kabul eder.Örneğin;

· (defun dizim()

(setf dizi(make-array '(3 3):initial-element 2))

(aref dizi 1 1) )

Dizi adında 3x3 lük 2 boyutlu bir dizi oluşturduk ve her elemanına 2 değerini atadık.(aref dizi 1 1) komutu ile de dizinin 2.satır 2.sütunundaki elemana ulaştık.

Dizilerin her elemanı aynı tipe sahip sahip olmak zorunda değildir.Örneğin elemanlar sırasıyla;

{33,elma,0,armut,xb,aaa} olabilir.Bu lispin esnekliğinden kaynaklanan bir özelliktir.

· Bir örnek daha verecek olursak;

· (defun dizi3()

(setf d(make-array '(2 2)))

(print "d[0][0] elemanini giriniz")

(setf (aref d '0 0)(read))

(print "d[0][1] elemanini giriniz")

(setf (aref d '0 1)(read))

(print "d[1][0] elemanini giriniz")

(setf (aref d '1 0)(read))

(print "d[1][1] elemanini giriniz")

(setf (aref d '1 1)(read))

(setq eleman0(aref d 0 0))

(setq eleman1(aref d 0 1))

(setq eleman2(aref d 1 0))

(setq eleman3(aref d 1 1))

(print eleman0)

(print eleman1)

(print eleman2)

(print eleman3) )

Burada kullanıcıdan d[2][2] dizisi için eleman girmesi istenmektedir.Kullanıcı istediği gibi eleman girebilir..

· Dizilere doğrudan elaman atamak istersek aşağıdaki örneğe bakalım ;

· (defun dizi4()

(setf d(make-array '(2 1)))

(setf (aref d '0 0) ‘emrah) "setq hata verir"

(setf (aref d '1 0) 4)

(setq eleman0(aref d '0 0))

(setq eleman1(aref d '1 0))

(print eleman0)

(print eleman1) )

Program parçasının çıktısı;

EMRAH

olur..Görüldüğü gibi dizilere aynı tipte eleman atamak zorunda değiliz.

Ayrıca lispte diğer dillerde oluğu gibi diziler birbirine de eşitlenebilir.

· (setf dizi1(make-array '(2 2)))

· (setf dizi2(make-array '(2 2)))

· (setf (aref dizi2 '0 0) (aref dizi1 '1 1))

Yapılan işlem dizi2[0][0]=dizi1[1][1];

· Dizilere initial-contents ile de doğrudan eleman aktarılabilir.Örnekler verecek olursak;

· (defun dizi6()

(setf d(make-array '(2):initial-contents '(a b)))

(aref d 0) )

Fonksiyonunun çıktısı A olur.

2 Boyutlu dizilere örnek verirsek;

· (defun dizi7()

(setf d(make-array '(2 2):initial-contents '((33 b)(k1 d)))

(aref d 1 0) )

Fonksiyonunun çıktısı ise K1 olarak görülecektir.

Lisp’te Yüksek Seviyeli Fonksiyonlar

Lispte APPLY ve MAPCAR olmak üzere 2 tane yüksek seviyeli fonksiyon vardır.Bunlar işlerin uzun yoldan yapılması yerine kısa yoldan sorunları çözmemize yardımcı olmak üzere hazır olan fonksiyonlardır.

APPLY FONKSİYONU

Apply fonksiyonu aldığı listeye parametre olarak aldığı işlemi uygulayan bir fonksiyondur.Örnek verecek olursak;

· (defun a()

16 Aralık 2011 Cuma

Dns Engelleme

4 Aralık 2011 Pazar

Lisp Programlama Dili

Lisp Programlama Dili