FIRAT UNIVERSİTESİ BILGISAYAR MUHENDISLIGI

LİSP

PROGRAMLAMA

DİLİ

http://www.fazlamesai.net/

http://www.cocreateusers.org

http://alibaytok.blogcu.com

http://home.att.net/~gobruen/progs/lisp/

http://www.n-a-n-o.com/lisp/cmucl-tutorials/LISP-tutorial.html#toc9

http://www.psg.com/~dlamkins/sl/chapter03-10.html

http://en.wikipedia.org/wiki/Lisp_(programming_language)

http://www.brothersoft.com/ufasoft-common-lisp-14749.html

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

*Diziler ve Çok Boyutlu Diziler

*Lisp‟te Yüksek Seviyeli Fonksiyonlar(apply – mapcar)

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.

*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)

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

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

*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.

*LİSP Context free gramerdir.

*Geliştirişmiş hata tutma sistemine

sahiptir.

*Lispte Garbage- Collection vardır ve

bununla daha emniyetli daha kesin ve

doğru hafıza yönetimi sağlarsınız.

*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.

*LİSP ; C ,C++‟ta run time anında yapılması gereken

bir çok şeyi compiler anında yapmaya izin verir.

Kurulumun ardından kod yazmaya hazır lisp studio derleyicimiz ekranda görülmektedir.LİSP‟te kodlar metin belgesi

görünümlü file menüsünden seçtiğimiz new adlı boş bir sayfaya öncelikle yazılır ardından derlenilip hataları varsa

gözden geçirilir ve çalıştırılır.Çalıştırma işleminin ardından terminal ekranda defun ile tanımladığımız fonksiyonumuzun

adı görünür ve ekranda terminal adı ile belirtilen sayfanın en altına çalıştırmak ve ekranda çıktısını görmek istediğimiz

fonksiyonun adını yazarak amacımıza ulaşabiliriz.

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

ATOMLARLisp 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.

(= a b) => eşit mi

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

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

(> 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ı

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)

Local değişkenler “let” ile tanımlanırlar.Diğer dillere

benzer yönde tanımlandığı fonksiyonun parantezi dışındaki

ifadeler bu local değişkene ariş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)

)

"1 sayi giriniz.." 10

53

"b nin son haline dikkat"

10

Global değişkenler :

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

Örnek :

>> ( defparameter x 120 )

X

>>x

120

>> ( defvar y 50 )

Y

>>Y

50

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

Defvar ile tanımlanan değişkenin değeri ise tekrar defvarkullanı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

>>Y

555

>> ( setq y 304 )

Y

>> y

304

Programda değerinin zor değişmesini

istediğimiz değişkenleri defvar ile tanımlamamız

daha doğru olacaktır.

(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))

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.Bölmeyi ö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 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)

(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, 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)

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 returneder.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.

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.

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 <fonksiyon_adı> <parametre_listesi>

<fonksiyonun_gö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]>

Ö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) )

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ç C 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() fonksiyonuBu fonksiyonla bir listeyi ters çevirebiliriz.

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

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 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 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.!!!

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.

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ç ;

1

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ç ;

0

1

2

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))

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 AKBUGAASLIHAN 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

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

4

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..

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()

(apply '*' (3 3 4)) ) sonuç olarak 36 verir.

(apply '-' (12 30 2 5)) -25

Parametre olarak bir fonksiyon ve bir liste alır.

Listenin her elemanına bu fonksiyonu uygular ve sonuçları bir liste olarak geri döndürür.(MAPCAR „<FONK_ADI> „<LİSTE>)(MAPCAR „<FONK_ADI> <DEĞİŞKEN>)

Mapcar kullanımına bir örnek verecek olursak;

(defun karekok(n)

(expt n 0.5) ) karekok fonksiyonu

(defun a()

(mapcar 'karekok'(4 81 36 100)) 2 9 6 10

(setq sonuc(mapcar #'karekok'(25))) 5

(print sonuc) )

Görüldüğü gibi a() fonksiyonu içerisinde karekok()

fonksiyonu mapcar ile çagırılmıştır.Dikkat edileceği

üzere mapcar #‟karekok‟(…) şeklinde yazılabileceği

gibi mapcar „karekok‟(..) şeklinde de yazılabilmektedir.

Mapcar fonksiyonunu örneğin birden fazla eleman üzerinde aynı değişiklik yapılacaksa kullanabiliriz.Bu sayede döngü yapmak derdinden kurtulmuş ve programın hem kod bakımından uzamasına engel olmuş hem de hız bakımından daha verimli hale gelmesini sağlamış oluruz.

Örneğin elimizdeki sayıların mutlak değerini almak istersek döngü yerine aşağıdaki kod işimizi görür

(defun mutlak(n)

(* n -1) )

(defun x()

(mapcar #'mutlak'(-4 -81 -36 -100)) )

Sonuç olarak (4 81 36 100) listesini verir..

(defun aa()

(mapcar #'car'((8 0 1)(ali veli can)(x y z))) )

İfadesi ise çıktı olarak (8 ali x) listesini verir..