List Of List LISP

List Of List

Definisi :
List of list adalah list yang :
• mungkin kosong,
• mungkin terdiri dari sebuah elemen yang disebut atom dan sisanya adalah list of list,
• mungkin terdiri dari sebuah elemen berupa list dan sisanya adalah list of list
Jadi List of List adalah list S yang elemennya adalah list dan atom
Untuk membedakan antara list dengan atom: List dituliskan di antara tanda kurung (),
sedangkan Atom dituliskan tanpa tanda kurung
Contoh List :
[ ] adalah list kosong
[ad , a , b ] adalah list dengan elemen berupa 3 atom
[ [ ], [a ,b ,c] ,[ d ,e] ,f ] adalah :
list dengan elemen list kosong, L1, L2 dan sebuah atom
L1 adalah list dengan elemen 3 buah atom a, b, c
L2 adalah list dengan elemen 2 buah atom d,e
Untuk list khusus ini, nama Konstruktor dan Selektor tidak dibedakan dengan list yang
hanya mengandung elemen dasar, namun diperlukan predikat tambahan sebagai berikut:
yaitu untuk mengetahui apakah sebuah ekspresi adalah Atom atau List.
Atom dapat berupa:
– atom numerik (yang dapat dipakai sebagai operan dalam ekspresi aritmatik)
– atom simbolik

TYPE LIST-OF-LIST
Definisi dan Spesifikasi Predikat Khusus Untuk List Of List:
IsEmpty : list of list → boolean
{IsEmpty(S) benar jika S adalah list of list kosong}
IsAtom : list of list → boolean
{IsAtom(S) menghasilkan true jika list adalah atom, yaitu terdiri dari sebuah atom }
IsList : list of list → boolean
{ IsList(S) menghasilkan true jika S adalah sebuah list (bukan atom)}
Definisi dan Spesifikasi Konstruktor :
KonsLo : List, List of list → List of list
{ KonsLo(L,S) diberikan sebuah List L dan sebuah List of List S, membentuk list baru
dengan List yang diberikan sebagai elemen pertama List of list: L o S → S’}
KonsL• : List of list , List → List of list
{KonsL• (S,L) diberikan sebuah List of list S dan sebuah list L, membentuk list baru
dengan List yang diberikan sebagai elemen terakhir list of List: S • L → S’}
Definisi dan Spesifikasi Selektor :
FirstList: List of list tidak kosong → List
{FirstList(S) Menghasilkan elemen pertama list, mungkin sebuah list atau atom }
TailList : List of list tidak kosong → List of list
{TailList(S) Menghasilkan “sisa” list of list S tanpa elemen pertama list S }
LastList : List of list tidak kosong → List of list
{LastList(S) : Menghasilkan elemen terakhir list of list S, mungkin list atau atom }
HeadList : List of list tidak kosong → List of list
{HeadList(S) Menghasilkan “sisa” list of list tanpa elemen terakhir list }

;Predikat
(defun IsEmpty (S) ;benar jika S adalah list of list kosong
(null S)
)
(defun IsOneElmt (S) ;benar jika S adalah list of list yang terdiri dari 1 elemen
(and (not (isEmpty S)) (null (cdr S)))
)
(defun IsAtom (S) ;benar jika S terdiri dari sebuah atom
(atom S)
)
(defun IsList (S) ;benar jika S menghasilkan sebuah List
(listp S)
)
;konstruktor
(defun KonsLo (L S) ;menambahkan List L kedalam List of List S, dan List L menjadi elemen pertama List of list
(cons L S)
)
(defun KonsL. (S L) ;menambahkan List L kedalam List of List S, dan List L menjadi elemen Terakhir List of List
(append S L)
)
;selektor
(defun firstList (S) ;menghasilkan elemen pertama list yang mungkin sebuah list atau atom
(car S)
)
(defun TailList (S) ;menghasilkan “sisa” list of list tanpa elemen pertama list S
(cdr S)
)
(defun LastList (S) ;menghasilkan elemen terakhir list yang mungkin sebuah list atau atom
(car (reverse S))
)
(defun HeadList (S) ;menghasilkan “sisa” list of list tanpa elemen terakhir list S
(reverse (cdr (reverse S)))
)

lol1
lol2

Himpunan (Set) LISP

Himpunan(set)

Definisi :
Himpunan (set) adalah sebuah list yang setiap elemennya hanya muncul sekali (unik). List
“kosong” adalah himpunan kosong.
Contoh :
[apel, jeruk, pisang] adalah himpunan
[jeruk, jeruk, mangga, jeruk, pisang, apel] bukan himpunan

TYPE SET (HIMPUNAN)
Definisi dan Spesifikasi Type :
{Set adalah List dengan tambahan syarat bahwa tidak ada elemen yang sama }
{ Semua konstruktor, selektor dan fungsi pada List berlaku untuk Himpunan }
Definisi dan Spesifikasi Konstruktor Himpunan dari List :
{ Himpunan dibentuk dari list }
MakeSet (L) : list → set
{ membuat sebuah set dari sebuah list }
{ yaitu membuang semua kemunculan yang lebih dari satu kali}
{ List kosong tetap menjadi list kosong }
Definisi dan Spesifikasi Predikat:
IsSet : list → boolean
{ IsSet(L) true jika L adalah set }
IsSubSet : 2 set → boolean
{ IsSubSet (H1,H2) true jika H1 adalah subset dari H2: semua elemen H1 adalah juga
merupakan elemen H2 }
Definisi dan Spesifikasi Operasi Terhadap Himpunan :
MakeIntersect : 2 set → set
{ Intersect (H1,H2) membuat interseksi H1 dengan H2 : yaitu set baru dengan anggota
elemen yang merupakan anggota H1 dan juga anggota H2 }
MakeUnion : 2 set → set
{ Union (H1,H2) membuat union H1 dengan H2 : yaitu set baru dengan semua anggota
elemen H1 dan anggota H2 }
Untuk kasus himpunan berikut, dibutuhkan beberapa fungsi terhadap list sebagai berikut :
IsMember : elemen, list → boolean
{ IsMember(e,L) true jika e adalah elemen list L }
Rember : elemen, list → list
{ Rember (x,L) menghapus sebuah elemen bernilai x dari list }
{ list yang baru berkurang SATU elemennya yaitu yang bernilai e }
{ List kosong tetap menjadi list kosong }
MultiRember : elemen, list → list
{ MultiRember (x,L) menghapus semua elemen bernilai x dari list }
{ list yang baru tidak lagi mempunyai elemen yang bernilai x }
{ List kosong tetap menjadi list kosong }

Realisasi dalam Lisp

;Konstruktor
(defun konso (e L) ;menambahkan satu elemen didepan suatu Liat
(cons e L)
)
(defun kons (e L) ;menambahkan satu elemen dibelakang suatu List
(reverse (cons e (reverse L)))
)
;Selektor
(defun firstElmt (L) ;memanggil elemen pertama dari suatu List
(car L)
)
(defun tail (L) ;memanggil semua elemen yang berada dibelakang elemen pertama
(cdr L)
)
(defun lastElmt (L) ;memanggil elemen terakhir dalam suatu list
(car (reverse L))
)
(defun Head (L) ;memanggil semua elemen sebelum elemen terakhir
(reverse (cdr (reverse L)))
)
(defun IsEmpty (L) ;memastikan apakah L suatu List kosong atau bukan
(null L)
)
(defun Makeset (L) ;membuat suatu set
(cond ((isEmpty L) nil)
((IsMember (firstElmt L) L) (konso (firstElmt L) (Makeset (Multirember (firstElmt L) L))))
(t (konso (firstElmt L) (Makeset (tail L))))
)
)
(defun IsSet (L) ;Benar jika L adalah set
(if (equal (Makeset L) L)
t
nil
)
)
(defun IsSubset (H1 H2) ;benar jika semua elemen H1 sama dengan H2
(cond ((IsEmpty H1) t)
((IsMember (firstElmt H1) H2) (IsSubset (tail H1) H2))
(t nil)
)
)
(defun MakeIntersect (H1 H2) ;membuat set baru dengan anggota elemen yang merupakan anggota H1 dan anggota H2 yang sama
(cond ((isEmpty H1 ) nil)
((IsMember (firstElmt H1) H2) (konso (firstElmt H1) (MakeIntersect (tail H1) H2)))
(t (MakeIntersect (tail H1) H2))
)
)
(defun MakeUnion (H1 H2) ;Membuat set baru dengan semua anggota dari semua anggota H1 dan H2
(cond ((isEmpty H1) H2)
((IsMember (firstElmt H1) H2) (konso (firstElmt H1) (MakeUnion (tail H1) (Multirember (firstElmt H1) H2))))
(t (konso (firstElmt H1) (MakeUnion (tail H1) H2)))
)
)
;Fungsi Bantu
(defun IsMember (x L) ;Bernilai benar jika Nilai x berada di dalam List
(cond ((IsEmpty L) nil)
((equal x (firstElmt L)) t)
(t (IsMember x (tail L)))
)
)
(defun Multirember (x L) ;Menghapus semua elemen bernilai x pada List
(cond ((isEmpty L) nil)
((equal (firstElmt L) x) (Multirember x (tail L)))
(t (konso (firstElmt L) (Multirember x (tail L))))
)
)
(defun rember (x L) ;Menghapus Sebuah elemen bernilai x pada List
(cond ((isEmpty L) nil)
((equal (firstElmt L) x) (tail L))
(t (konso (firstElmt L) (Rember x (tail L))))
)
)

himpunanbro

List Of Integer LISP

List Of Integer

Definisi :
Integer adalah himpunan angka yang tak terhingga
Definisi rekursif list integer
Basis: List kosong adalah list bilangan integer
Rekurens : list bilangan integer dibuat dengan cara menambahkan sebuah integer pada
list bilangan integer.

Definisi dan Spesifikasi Type :
type List of integer
(Definisi: list yang elemennya integer, menambahkan sebuah integer pada list bilangan integer )
Definisi dan Spesifikasi Konstruktor:
Konso : integer, List of integer tidak kosong → List of integer
{Konso(e,L): menghasilkan sebuah list dari e dan L, dengan e sebagai elemen
pertama e : e o L → L’}
Kons• : List of integer tidak kosong, integer → List of integer
{ Kons(L,e): menghasilkan sebuah list dari L dan e, dengan e sebagai elemen terakhir
list : L • e → L’}

Definisi dan Spesifikasi Selektor:
FirstElmt: List of integer tidak kosong → integer
{FirstElmt(L) Menghasilkan elemen pertama list L }
Tail : List of integer tidak kosong → List of integer
{Tail(L) : Menghasilkan list tanpa elemen pertama list L }
LastElmt : List of integer tidak kosong → integer
{LastElmt(L) : Menghasilkan elemen terakhir list L }
Head : List of integer tidak kosong → List of integer
{Head(L) : Menghasilkan list tanpa elemen terakhir list L}

Realisasi dalam Lisp

(defun konso(e L) ;menghasilkan sebuah list dari e dan L, dengan e sebagai elemen pertama
(cons e L)
)
(defun kons(L e) ;menghasilkan sebuah list dari L dan e, dengan e sebagai elemen terakhir
(reverse (cons e (reverse L)))
)
(defun firstelmt(L) ;Menghasilkan karakter pertama Teks L
(car L)
)
(defun tail(L) ;Menghasilkan list tanpa elemen pertama Teks L
(cdr L)
)
(defun lastelmt(L) ;Menghasilkan karakter terakhir Teks L
(car (reverse L))
)
(defun head(L) ;Menghasilkan list tanpa elemen terakhir Teks L
(reverse (cdr (reverse L)))
)

loi
Contoh penggunaan List Of Integer
Judul :
genap (L)
Definisi dan Spesifikasi :
genap : list of integer → integer
{ genap(L) menghitung banyaknya angka genap dalam List }
Ralisasi :
Basis : jika list kosong 0
Rekurens: if (FirstElment L) genap, then + 1 genap (Tail L)
else genap (Tail L)

;mencari banyaknya angka genap dalam list of int
(defun genap ( L)
(cond((null L)0)
((evenp(car L) )(+ 1 (genap (cdr L))))
(t(genap(cdr L)))
)
)

List Of Integer.mp4_snapshot_03.01_[2015.06.23_17.00.33]

List Of Character LISP

List of Character

Definisi :
Teks adalah list yang elemennya terdiri dari karakter. Karakter adalah himpunan terhingga dari ‘a’…’z’, ‘A’…’B’, ‘0’…’9′
Definisi Rekursif terdiri dari Basis dan Rekuren
Basis : Teks Kosong adalah teks
Rekurens : Teks dapat dibentuk dengan menambahkan sebuah karakter pada teks

Definisi dan Spesifikasi Type :
type Teks : List of character
(Definisi Teks : sesuai dengan definisi rekursif di atas )

Definisi dan Spesifikasi Konstruktor:
Konso : character, Teks → Teks
Konso (e,T): menghasilkan sebuah list dari e dan L, dengan e sebagai elemen
pertama e : e o L → L’
Kons : Teks, character → Teks
Kons (L,e): menghasilkan sebuah list dari T dan e, dengan e sebagai elemen terakhir
teks : L • e → L

Definisi dan Spesifikasi Selektor:
FirstChar: Teks tidak kosong → character
FirstElmt(L) Menghasilkan character pertama Teks L
Tail : Teks tidak kosong → Teks
Tail(L) : Menghasilkan list tanpa elemen pertama Teks L
LastChar : Teks tidak kosong → character
LastElmt(L) : Menghasilkan character terakhir Teks L
Head : Teks tidak kosong → Teks
Head(L) : Menghasilkan list tanpa elemen terakhir Teks L

Realisasi dalam Lisp

(defun konso(e L) ;menghasilkan sebuah list dari e dan L, dengan e sebagai elemen pertama
(cons e L)
)
(defun kons(L e) ;menghasilkan sebuah list dari L dan e, dengan e sebagai elemen terakhir
(reverse (cons e (reverse L)))
)
(defun firstelmt(L) ;Menghasilkan karakter pertama Teks L
(car L)
)
(defun tail(L) ;Menghasilkan list tanpa elemen pertama Teks L
(cdr L)
)
(defun lastelmt(L) ;Menghasilkan karakter terakhir Teks L
(car (reverse L))
)
(defun head(L) ;Menghasilkan list tanpa elemen terakhir Teks L
(reverse (cdr (reverse L)))
)

loc 1

Contoh penggunaan List Of Character
Judul :
Hitchar (L)
Definisi dan Spesifikasi :
Hitchar : Teks → integer > 0
{ Hitchar(L) menghasilkan banyaknya kemunculan ‘char1’ dalam List }
Ralisasi :
Basis : jika list kosong 0
Rekurens: if (FirstElment L) = char1, then + 1 Hitchar char1 (Tail L)
else Hitchar char1 (Tail L)

;mencari banyaknya char dalam list of char
(defun hitChar (char1 L)
(cond((null L)0)
((eq(car L) char1)(+ 1 (hitChar char1 (cdr L))))
(t(hitChar char1(cdr L)))
)
)

loc2
 

Rekursif dalam LISP

Rekursif adalah fungsi yang memanggil dirinya sendiri dalam rekursif terdiri 2 bagian yaitu  :

  • Basis : Kondisi dimana fungsi akan berhenti.
  • Rekurens : Fungsi yang memanggil dirinya sendiri.

NbElmnt(L) : fungsi untuk menghitung jumlah element didalam list.

NbElmnt(L) :

basis = > if (null L) then 0

else

rekuren => 1 + NbElmnt(cdr L)

Program:

(defun NbELmnt (L)
(if (null L) 0
(+ 1 (NbElmnt(cdr L) ) )
)
)

Aplikasi:

(NbElemnt (1 2 3 4))

4

 

List dalam LISP

List adalah sekumpulan elemen yang ditampung dalam suatu variabel.

Contoh : L  (2 3 4 5) adalah list yang berisi elemen 2 3 4 5

Selector adalah suatu fungsi yang kegunaannya untuk mengambil salah satu atau beberapa elemen pada list.

Pada List terdapat selector sebagai berikut :

  1. FirstElement
  2. Tail
  3. LastElement
  4. Head

FirstElement adalah selector yang mengambil pertama pada List.

  • Contoh : L = (1 2 3 4) -> FirstElement (L) = 1

Tail adalah selektor yang mengambil List selain FirstElement pada List.

  • Contoh : L = (1 2 3 4) -> Tail (L) = 2 3 4

LastElement adalah selektor yang mengambil List terakhir.

  • Contoh : L = (1 2 3 4) -> LastElement (L) =  4

Head adalah selektor yang mengambil List selain LastElement pada List.

  • Contoh : L = (1 2 3 4) -> LastElement(L) = 1 2 3

Konso adalah Menambah element didepan List.

  • Contoh : L = (1 2 3 4) -> Konso ( 2,L) = 2 1 2 3 4

KonsoB adalah Menambah element dibelakang List.

  • Contoh : L = (1 2 3 4) -> KonsoB (2,L) = 1 2 3 4 2

List dalam LISP banyak fungsi yang harus dipahami :

  1. Car : mengambil element pertama List.
  2. Cdr : mengambil element List selain element pertama.
  3. Reverse : membalik List.
  4. Null : cek kosong.
  5. Cons : menambah element didepan pada List.

 

Tutorial singkat Lisp

saya akan memberi tutorial singkat tentang membuat program lisp yaitu perkalian 3 angka lisp :

1. Buka notepad ++

2.tuliskan codingnya di notepad ++

1

(defun kali3angka(a b c)
(* a b c)
)

3. save file notepad tersebut dengan format “list processing language file(*.lsp;*.lisp)”

2

4.buka program Clisp lalu compile file yang telah di save tadi (compile-file “tempat file tersimpan”) contohnya

(compile-file “G:/Contoh.lsp”) 

3

5.jika compile sukses tanpa error load file yang telah di compile contoh (load “G:/Contoh.lsp”)

 4

6. pengkaplikasianya yaitu

(kali3angka 2 2 2)

8

5

lihat video dibawah jika kurang jelas

Kondisi dalam LISP

Ekspresi kondisional adalah suatu ekspresi yang hasil evaluasinya tergantung kepada
hasil evaluasi beberapa kondisi. Karena itu, dikatakan bahwa ekspresi kondisional ditulis
dengan melakukan analisa kasus

Contoh :

(cond(kondisi)
(ekspresi benar)
(ekspresi salah)
)

misalnya program menghitung gaji, yaitu jika tidak punya anak gaji pokok ditambah 500
jika punya anak 1 gaji pokok ditambah 750
jika punya anak 2 gaji pokok ditambah 1000
jika punya anak lebih dari 2 maka gaji pokok ditambah 1200

(defun hitGaji (pokok anak)
(cond((<= anak 0)(+ pokok 500))
((= anak 1)(+ pokok 750))
((= anak 2)(+ pokok 1000))
(t (+ pokok 1200))
)
)

Untitled

Let in dalam LISP

Let digunakan untuk membuat sebuah variabel dalam lisp dan juga untuk :
• menghindari evaluasi berulang-ulang.
• menjadikan program lebih mudah dibaca

Contoh :

(defun fungsi (variable)
(let ((variable(nilai)))
(ekspresi)
)

misalnya ekspresi (1+a*b) * (1-2*a*b)  a * b di evaluasi

(defun f (a b)
let ( (p (* a b) ) )
(* (+ 1 p) (- 1 (* 2 p)) )
)
)

Untitled

Notasi Fungsional

Notasi Fungional adalah catatan yang kemudian diterjemahkan dalam bahasa pemrograman. Dibawah ini adalah contoh notasi fungsional :

 Judul
       pangkat2(x)
Definisi dan Spesifikasi
       pangkat2(x) : integer -> integer
       pangkat2(x) menghitung pangkat dua dari sebuah nilai x
Realisasi
       pangkat2(x) : x * x
Aplikasi
       (pangkat2 2)

Ada 4 bagian dalam notasi fungsional yaitu Judul, Definisi, Spesifikasi, Realisasi, Aplikasi. Dibawah ini adalah pengertian 4 bagian dalam fungsional :

  • Judul : Nama fungsinya dengan parameternya
  • Definisi dan Spesifikasi: Penjelasan dari fungsi serta tipe data domain (input) dan range (output).
  • Realisasi : Bagaimana fungsi melakukan komputasi.
  • Aplikasi : Penggunaan fungsi dalam program.