Jumat, 20 April 2012

TUGAS 1 Alpro artikel mengenai GNU-clisp

Belajar Salah satu program aplikasi pemrograman fungsional yakni GNU-clisp
Bahan-bahan:
Notepad++ & GNU-clisp tentunya.
1.      Kita mulai dari mengetikan skrip dasarnya pada notepad++ :
               (defun helo()
                              (write-string "mencoba belajar pemrograman fungsional")
               )

               Save as type “all files” lalu save dengan nama file coba.lisp d
               D:/coba.lisp

2.      Jalankan program GNU-clisp

3.      Ketikkan (compile-file “D:/coba.lisp”) untuk mengcompile file coba.lisp tekan enter.
[1]> (compile-file "D:/coba.lisp")
;; Compiling file D:\coba.lisp ...
;; Wrote file D:\coba.fas
0 errors, 0 warnings
#P"D:\\coba.fas" ;
NIL ;
NIL

4.      Lalu load file coba.lisp dengan mengetikkan (load file)
[2]> (load "D:/coba.lisp")
;; Loading file D:\coba.lisp ...
;; Loaded file D:\coba.lisp
T

5.      Lalu coba panggil fungsi helo yang telah kita buat tadi dengan mengetikan: (helo)
[3]> (helo)
mencoba belajar pemrograman fungsional
"mencoba belajar pemrograman fungsional"

6.      Selamat anda telah berhasil membuat suatu fungsi dalam GNU-clisp.

Berikut ini adalah sedikit materi pemrogaman fungsional menggunakan GNU_clisp
List dan Atom
Pada bagian ini kita akan mempelajari elemen-elemen dasar Lisp yaitu list dan atom. Contoh-contoh yang diberikan di bagian ini sebagian besar hanya untuk ilustrasi dan tidak dapat diketikkan ke dalam CLISP (akan menghasilkan error). Kita akan mulai menulis program pada bagian berikutnya, "Form".
Hal pertama yang harus kita tahu adalah bahwa segala sesuatu yang dimulai dan diakhiri tanda kurung adalah sebuah list. Sebagai contoh, hal-hal berikut adalah list:
(1 2 3 4 5)
(w x y z)
(rumah tanah kucing 123)
Sebuah list bisa saja kosong maupun berisi list lain. Jadi yang berikut adalah merupakan list juga:
()
((1 10 100))
((x y) 3 4 (hitam merah))
(defun kurangi-satu (x) (- x 1))
List bisa berisi program ataupun data, dan karena kita bisa memasukkan list di dalam list, kita bisa mencampur data dan program pada berbagai tingkatan. Inilah salah satu kekuatan LISP bagi yang sudah menguasainya, namun merupakan sumber kebingungan bagi yang belum menguasainya. Bersiap-siaplah juga untuk menghadapi banyak kurung buka dan kurung tutup.
Elemen-elemen yang berada di dalam list disebut atom. Jadi dalam list
(1 2 3 tangan kanan)
yang disebutkan di bawah merupakan atom:
1
2
3
tangan
kanan
Syarat utama dari atom adalah diawali dan diakhiri spasi (termasuk tab dan newline) atau kurung buka atau kurung tutup. Atom dapat terdiri dari karakter-karakter yang bukan pembatas atom. Perlu diketahui bahwa atom dapat berada di luar list. Inilah beberapa contoh atom lain:
:monitor
!**!
-
@hotmail.com
2*3+1
Lisp tidak case-sensitive, jadi ketiga atom di bawah adalah sama:
saya
SayA
SAYA
Lisp juga tidak mengenal operator, jadi 2*3+1 bukanlah suatu expresi matematika yang nilainya 7. Kalaupun digunakan spasi, maka 2 * 3 + 1 akan menjadi lima buah atom yang juga tidak bernilai 7.
Perhatikan bahwa spasi yang banyak sama saja dengan sebuah spasi, jadi kedua list di bawah ini sama (memang terlihat rumit, tapi untuk sekarang tidak perlu dimengerti artinya):
(defun faktorial (x) (if (eql x 0) 1 (* x (faktorial (- x 1)))))
(defun faktorial(x)(if(eql x 0)1(* x(faktorial(- x 1)))))
Tentunya penulisan yang pertama lebih mudah dibaca. Akan lebih baik lagi jika dituliskan sebagai berikut:
(defun faktorial (x)
  (if (eql x 0)
    1
    (* x faktorial (- x 1)))))
Form
Form adalah sesuatu yang akan dievaluasi/dicari nilainya. Form dapat berupa atom (non-list) maupun list.
Evaluasi form sangatlah sederhana jika yang terlibat adalah atom. Jika atom yang bersangkutan adalah angka (misalnya 100, -5, 3/4, 0.333), maka hasil evaluasinya adalah angka itu sendiri (disebut self-evaluating). Inilah beberapa contohnya (langsung saja anda coba pada CLISP):
> 100 (ini adalah input)
] 100 (ini adalah outputnya)

> 3/4
] 3/4

> -2.71828
] -2.71828
Kita bisa melihat bahwa Lisp memiliki beberapa tipe data angka. Yang pertama adalah integer, yang dapat menyimpan bilangan bulat sebesar atau sekecil apapun (hanya dibatasi oleh kapasitas memori yang ada). Tipe data lainnya adalah rational, yang berupa p/q dengan p dan q integer dan q lebih besar dari 1 (jika q = 1 maka bilangannya akan menjadi integer). Rational juga hanya dibatasi oleh memori yang tersedia. Tipe data ketiga adalah floating point, yang melambangkan angkanya menggunakan mantissa and eksponen. Floating point pasti dituliskan dengan tanda titik. Jadi 1 adalah integer sedangkan 1.0 adalah floating point. Pada tipe data floating point dapat terjadi underflow (jika nilai mutlak pecahannya terlalu kecil) maupun overflow (jika nilai mutlak angkanya terlalu besar). Inilah beberapa contohnya:
> 999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
] 999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

> 212/999999999999999999999999999999999999999999999999999999999
] 212/999999999999999999999999999999999999999999999999999999999

> 0.00000000000000000000000000000000000000000000000000000000001
] *** - floating point underflow

> 9999999999999999999999999999999999999999.0
] *** - floating point overflow
Jika terjadi error seperti underflow dan overflow, maka CLISP akan memasukkan kita ke mode debug. Banyak yang bisa kita lakukan di mode debug, tetapi untuk sekarang ketikkan saja "quit" saat berada di mode debug. Menuliskan "quit" akan mengabaikan input terakhir yang bermasalah. Inilah contohnya:
> 0.00000000000000000000000000000000000000000000000000000000001
] *** - floating point underflow
Break 1> quit
(input yang bermasalah diabaikan dan kita dapat melanjutkan penulisan program)
Form dapat juga berupa list. Jika form yang bersangkutan adalah list, maka atom pertama list tersebut haruslah merupakan sebuah fungsi. Atom-atom sisanya (jika ada) akan menjadi argumen fungsi. Sebagai contoh, fungsi yang telah didefinisikan dalam Lisp adalah fungsi +, yang akan menjumlahkan atom-atom lainnya. Inilah beberapa contoh penggunaannya:
> (+ 3 4)
] 7

> (+ 1 2 3)
] 6
Di dalam contoh yang pertama, + bertindak sebagai fungsi, sedangkan 3 dan 4 bertindak sebagai argumen untuk fungsi +. Contoh yang kedua memberikan tiga argumen untuk fungsi +. Fungsi-fungsi aritmatika lainnya adalah fungsi -*, dan /.
Karena kita dapat memasukkan list ke dalam list, kita dapat menyusun perhitungan yang kompleks hanya dengan aturan-aturan yang telah kita pelajari. Inilah contohnya:
> (* 2 (+ 3 4 5)) (artinya 2*(3+4+5) )
] 24

> (- (* 3 3) (* 4 4)) (artinya 3*3 - 4*4 )
] -7

> (* (+ 3 4) (- 3 4)) (artinya (3+4)(3-4) )
] -7
Fungsi-fungsi matematika lain contohnya adalah modsqrtexp (perpangkatan dengan basis e), expt (perpangkatan dengan basis apapun), log (logaritma natural), sincos, dan tan. Inilah beberapa contoh penggunaannya (dan maksudnya):
> (mod 8 3) (sisa pembagian pada saat 8 dibagi 3)
] 2

> (sin (+ 3 4)) (artinya sin(3+4) )
] 0.6569866

> (+ (* (sin 3) (cos 4)) (* (cos 3) (sin 4)) ) (artinya sin(3)cos(4) + cos(4)sin(3) )
] 0.6569866

> (exp 1) (artinya e pangkat 1)
> 2.7182817

> (expt 2 3) (artinya 2 pangkat 3)
> 8
Simbol adalah atom yang tidak self-evaluating, dan dapat kita beri nilai. Kita tidak perlu mendeklarasikan simbol dan menentukan tipe datanya. Artinya suatu simbol dapat berisi integer pada suatu waktu, namun di waktu lain dapat berisi data dengan tipe lain (contohnya list). Kita dapat memberikan nilai ke simbol dengan menggunakan fungsi setq. Inilah contohnya:
> (setq a 100) (memasukkan nilai 100 ke simbol a)
] 100

> (setq b 20)
] 20

> a
] 100

> b
> 20

> (+ a b) (menjumlahkan a dan b)
] 120

> (setq c (* 2 a)) (memberikan nilai 2*a ke simbol c)
] 40

> z
] *** - EVAL: variable Z has no value
Dengan pengetahuan yang kita punya sekarang, kita dapat memanfaatkan Lisp sebagai alat bantu perhitungan. Sebagai contoh, misalkan kita ingin mencari penyelesaian dari 2x2-5x-3=0. Kita akan menggunakan rumus abc, jadi pertama-tama kita akan memberikan nilai pada simbol a, b, dan c.
> (setq a 2)
] 2

> (setq b -5)
] -5

> (setq c -3)
] -3
Selanjutnya kita akan memberikan nilai ke diskriminannya d, yaitu b2-4ac.
> (setq d (- (* b b) (* 4 a c)) )
] 49
Karena d positif, pasti kita akan mendapat dua penyelesaian riil (sebetulnya Lisp juga dapat menangani bilangan complex, silahkan coba sendiri). Kita akan mencari penyelesaiannya satu-persatu:
> (/ (+ (- b) (sqrt d)) (* 2 a) ) (- b) sama dengan (- 0 b) )
] 3

> (/ (- (- b) (sqrt d)) (* 2 a) )
] -1/2
Kalau menuliskan semuanya di satu baris terlihat membingungkan, kita dapat juga menuliskannya sebagai berikut:
> 
(/
   (+ (- b) (sqrt d) )
   (* 2 a)
)
] 3

> 
(/
   (- (- b) (sqrt d) )
   (* 2 a)
)
] -1/2
Inilah akhir dari tutorial kita! Yang kita ulas barulah permukaan dari suatu bahasa pemrograman yang menakjubkan, yang diharapkan menarik minat anda untuk mempelajari Lisp lebih lanjut.
link terkait common lisp

Tidak ada komentar:

Poskan Komentar