[bao cao]tim hieu ve mo hinh lap trinh

Trường Đại Học Bách Khoa Hà Nội

Trường Đại Học Bách Khoa Hà Nội2012-2013

BÁO CÁOTÌM HIỂU VỀ CÁC MÔ HÌNH LẬP TRÌNH

Môn học:Kỹ Thuật Lập TrìnhGiảng viên:Vũ Đức Vượng

Email:[email protected]ã lớp:54470

Người thực hiệnSinh viên:Trần Xuân QuýMSSV:20112030Email:[email protected]

Báo cáo:Tìm hiểu về các mô hình lập trình 0


MỤC LỤC

I.Lời nói đầu........................................................................................................................ 2

II. Tổng quan về các mô hình lập trình phổ biến.......................................................... 21. Functional Paradigm…….............................................................................................. 22. Visual Paradigm……...................................................................................................... 32.1 Đặc điểm nổi bật của phương pháp lập trình trực quan ......................................... 43. Parallel Programming .................................................................................................. 53.1 Quá trình song song hóa gồm ba giai đoạn bước chính .......................................... 54. Distributed Programming ............................................................................................ 65. Extreme Programming ................................................................................................... 75.1 Ưu Điểm ........................................................................................................................ 75.2 Phương thức tiến hành XP ......................................................................................... 76. Concurrent Programming ............................................................................................ 86.1 Đặc điểm ....................................................................................................................... 8

III. Logic programming...................................................................................................... 81. Đặc điểm ......................................................................................................................... 82. Ngôn ngữ PROLOG .................................................................................................... 92.1 Giới thiệu...................................................................................................................... 92.2 Các yếu tố cơ bản của Turbo Prolog ........................................................................ 92.3 Cấu trúc của một chương trình Prolog .................................................................... 102.4 Các nguyên tắc của ngôn ngữ Prolog ....................................................................... 132.5 Bộ ký tự, từ khoá ....................................................................................................... 132.6 Các kiểu dữ liệu .......................................................................................................... 142.7 Các hàm xuất nhập chuẩn ......................................................................................... 172.8 Kỹ thuật đệ quy ........................................................................................................... 172.9 Một số ví dụ về chương trình prolog ....................................................................... 19

IV. Lời kết ......................................................................................................................... 20

V. Tài liệu tham khảo ........................................................................................................ 21



I.Lời nói đầu Bất kỳ một ngôn ngữ lập trình nào cũng đều mang tính logic cao và tuân theo những quy

chuẩn cơ bản về toán học. Tuy vậy, mỗi ngôn ngữ lại có những phương thức riêng để thực hiện những quy chuẩn đó, đặc biệt là trên các lĩnh vực như hàm (function), biến (variable), phương thức (method) và đối tượng (object). Bên cạnh sự đa dạng của ngôn ngữ lập trình, cũng dần có rất nhiều mô hình lập trình được ra đời, trong đó phổ biến nhất có thể kể đến như: Lập trình hướng đối tượng (object-oriented programming), lập trình thủ tục (procedural programming) và lập trình cấu trúc (structured programming). Mỗi một mô hình lập trình lại có những đặc trưng riêng về cách sử dụng cũng như tính trừu tượng hóa đối với các quá trình xác định.

Ở thời kỳ đầu, công nghệ phần mềm hoàn toàn dựa trên những thao tác lập trình bằng mã nhị phân hoặc mã máy, mà đại diện là các giá trị 0 và 1. Điều này khiến cho quá trình thiết kế, kiểm soát sự hoạt động cũng như sửa lỗi đối với một ứng dụng trở nên vô cùng rắc rối và không hiệu quả. Chúng ta coi những phương thức lập trình ở thời điểm này thuộc mô hình lập trình bậc thấp (low-level programming paradigm). Về sau, cùng với sự phát triển của công nghệ, những hạn chế của giai đoạn đầu tiên dần được xóa bỏ với sự ra đời của các ngôn ngữ lập trình thế hệ thứ 3 là COBOL, Fortran và BASIC, đồng thời, một mô hình lập trình mới cũng xuất hiện và vẫn tiếp tục được sử dụng hiệu quả và phổ biến cho đến ngày nay, đó là mô hình lập trình thủ tục (procedural paradigm). Dần dần, chúng ta chứng kiến sự phát triển mạnh mẽ về số lượng của các mô hình lập trình, mà cơ bản có thể kể đến các mô hình sau:

Lập trình cấu trúc - Structured programming. Lập trình mệnh lệnh - Imperative programming. Lập trình truyền báo - Message passing programming. Lập trình thủ tục - Procedural programming. Lập trình chức năng - Functional programming. Lập trình trực quan - Visual programming. Lập trình song song - Parallel programming. Lập trình phân tán - Distributed programming. Lập trình tương tranh - Concurrent programming. Lập trình bậc giá trị - Value-level programming. Lập trình điều khiển theo luồng - Flow-driven programming.

II.Tổng quan về các mô hình lập trình phổ biến

1. Functional Programming

Nguyên lý và ý tưởng: Toán học và lý thuyết về hàm. Các giá trị đã được tạo là không thể biến đổi. Trừu tượng hóa một biểu thức thành một hàm và ngược lại, một hàm có thể được tính

toán như một biểu thức. Hàm là lớp giá trị đầu tiên. Hàm là những giá trị hoàn chỉnh, tương tự như số, danh sách... Thích hợp với nh ững tính toán theo yêu cầu. Mở ra những khả năng mới.



Functional Programming là thể loại lâu đời nhất trong ba paradigm lập trình chính. Ngôn ngữ FP đầu tiên là IFP, được phát minh vào năm 1955, một năm trước khi có Fortran. Sau đó, LISP ra đời năm 1958, một năm trước khi có COBOL. Cả Fortran và COBOL đều là những ngôn ngữ imperative (hay còn gọi là procedural). Chúng đặc biệt thành công khi được ứng dụng vào tính toán khoa học và nghiệp vụ, và trở thành paradigm thống trị trong suốt 30 đ ầu của kỉ nguyên thông tin.

Ví dụ

Với n = 5, ta có th ứ tự tính toán của đoạn chương trình trên như sau:

giai_thua(5)= 5 * giai_thua(4)= 5 * 4 * giai_thua(3)= 5 * 4 * 3 * giai_thua(2)= 5 * 4 * 3 * 2 * giai_thua(1)= 5 * 4 * 3 * 2 * 1= 5 * 4 * 3 * 2= 5 * 4 * 6= 5 * 24= 120

2. Visual Paradigm

Như chúng ta đã biết, mỗi loại máy tính (sử dụng loại CPU – Central Processing Unit xác định) chỉ có thểhiểu và thực hiện trực tiếp được các lệnh cũng như chương trình theo một loại ngôn


int giai_thua(int n){if (n == 1){return n;}else{return n * giai_thua(n - 1);}}


ngữ dành riêng được gọi là ngôn ngữ máy. Tuy nhiên, nếu triển khai các ứng dụng trong thực tế mà phải viết chương trình trực tiếp bằng ngôn ngữ máy thì sẽ rất ph ức tạp, đòi hỏi thời gian và công sức rất lớn, nhiều khi không thể thực hiện được. Vì vậy, người ta tìm cách xây dựng một ngôn ngữ lập trình riêng gần với các ngôn ngữ tự nhiên, thuận lợi cho việc triển khai các ứng dụng. Khi thực hiện các chương trình bằng ngôn ngữ này phải qua một bước dịch chương trình đó sang ngôn ngữ máy để nó có thể thực hiện. Từ trước đến nay có rất nhiều ngôn ngữ lập trình được ra đời và phục vụ đắc lực cho việc triển khai các ứng dụng trên máy tính. Trong giai đoạn đầu, các ngôn ngữ lập trình tuy dễ sử dụng hơn ngôn ngữ máy nhưng rất khó với các lập trình viên vì chưa đủ mạnh để dễ dàng triển khai các thuật toán. Chương trình chưa có tính cấu trúc chặt chẽ về mặt dữ liệu cũng như tổ chức chương trình. Vì vậy, việc triển khai các ứng dụng trong thực tế bằng các ngôn ngữ lập trình này là rất khó khăn. Giai đoạn 2 là thời kỳ của các ngôn ngữ lập trình có cấu trúc. Các ngôn ngữ lập trình này có đặc điểm là có tính cấu trúc chặt chẽ về mặt dữ liệu và tổ chức chương trình. Một loạt các ngôn ngữ l ập trình có cấu trúc ra đời và dược sử dụng rộng rãi như : PASCAL, C, BASIC... Giai đoạn 3 là thời kỳ của lập trình hướng đối tượng và phương pháp lập trình có bước biến đổi mạnh. Trong các ngôn ngữ l ập trình có cấu trúc thì một ứng dụng bao gồm hai thành phần riêng là dữ liệu và chương trình. Tuy chúng có quan hệ chặt chẽ nhưng là hai đối tượng riêng biệt. Trong phương pháp lập trình hướng đối tượng thì mỗi một đối tượng lập trình sẽ bao hàm cả dữ liệu và phương thức hành động trên dữ liệu đó. Vì vậy, việc lập trình sẽ đơn giản và mang tính kế thừa cao, tiết kiệm được thời gian lập trình. Tuy nhiên, với các phương pháp lập trình trên đều đòi hỏi lập trình viên phải nhớ rất nhiều câu lệnh với mỗi lệnh có một cú pháp và tác dụng riêng, khi viết chương trình phải tự lắp nối các lệnh để có một chương trình giải quyết từng bài toán riêng biệt.Trong xu hướng phát triển mạnh mẽ hiện nay của tin học, số người sử dụng máy tính tăng lên rất nhanh và máy tính được sử dụng trong hầu hết các lĩnh vực của đời sống nên đòi hỏi các ngôn ngữ lập trình cũng phải đơn gi ản, dễ sử dụng và mang tính đại chúng c ao. Chính vì vậy phương pháp lập trình trực quan ra đời.

Đặc điểm của các ngôn ngữ lập trình trực quan là dễ sử dụng, triển khai các ứng dụng một cách nhanh chóng.2.1. Đặc điểm nổi bật của phương pháp lập trình trực quan

Cho phép xây dựng chương trình theo hướng sự kiện (Event-Driven Programming, nghĩa là một chương trình ứng dụng được viết theo kiểu này đáp ứng dựa theo tình huống xảy ra lúc thực hiện chương trình. Tình huống này bao gồm người s ử dụng ấn một phím tương ứng, chọn lựa một nút lệnh hoặc gọi một lệnh từ một ứng dụng khác chạy song song cùng lúc.

Người lập trình trực tiếp tạo ra các khung giao diện (interface), ứng dụng thông qua các thao tác trên màn hình dựa vào các đối tượng (ojbect) như hộp hội thoại hoặc nút điều khiển (control button), những đối tượng này mang các thuộc tính (properties) riêng biệt như : màu sắc, Font chữ.. mà ta chỉ cần chọn lựa trên một danh sách cho sẵn.

Khi dùng các ngôn ngữ lập trình trực quan ta rất ít khi phải tự viết các lệnh, tổ chức chương trình... một cách rắc rối mà chỉ cần khai báo việc gì cần làm khi một tình huống xuất hiện.

Máy tính sẽ dựa vào phần thiết kế và khai báo của lập trình viên để tự động tạo lập chương trình.

Như vậy với k ỹ thuật lập trình trực quan, lập trình viên giống như một nhà thiết kế, tổ chức để tạo ra các biểu mẫu, đề nghị các công việc cần thực hiện và máy tính sẽ dựa vào đó để xây dựng



chương trình. Hiện nay các ngôn ngữ l ập trình, hệ quản trị cơ sở dữ liệu theo hướng trực quan thường dùng như: Visual Basic, Visual Foxpro, Visual C, Delphi...

3. Parallel Programming

Tính toán song song (Parallel Computing) là việc chia một công việc ra thành các công việc nhỏ và cho các công việc này thực hiện đồng thời với nhau bởi các hệ thống có nhiều bộ vi xử lý (multiprocessor) hay bộ vi xử lý đa nhân (multicore) nhằm giảm thời gian thực hiện công việc đó xuống. Việc lập trình để tách ra các công việc nhỏ và sắp xếp để xử lý song song thì được gọi là lập trình song song. “Số lượng transistor trong bộ vi xử lý sẽ tăng lên gấp đôi sau mỗi 24 tháng.” Gordon Moore - sáng lập viên của tập đoàn Intel. Cùng với định luật Moore, các máy tính hiện nay đã được trang bị các bộ vi xử lý đa nhân mạnh mẽ. Tuy nhiên, để tận dụng được sức mạnh đó đòi hỏi các lập trình viên phải tận dụng được hết các nhân trong bộ vi xử lý. Vì vậy, thay vì lập trình tuần tự như trước đây chỉ sử dụng



một nhân của bộ vi xử lý thì người lập trình viên ngày nay phải dùng kỹ thuật lập trình song song để tận dụng hiệu suất của bộ vi xử lý đa nhân. Bộ vi xử lý có nhiều nhân sẽ tăng tốc chương trình song song tuy nhiên không có nghĩa là nó sẽ tăng lên 100% trên một nhân (core) được thêm vào. Thậm chí chương trình song song không hề tăng hiệu suất lên trong một số trường hợp. Vì vậy lập trình viên phải biết quyết định khi nào sử dụng lập trình song song bằng cách sử dụng các công cụ đo lường để xác định được tốc độ thực thi của chương trình. Lập trình song song là một công việc rất phức tạp so với lập trình tuần tự thông thường, người phát triển phải thực hiện một quá trình “song song hóa”, biến đổi các chương trình tuần tự thành chương trình song song có khả năng tận dụng tối đa sức mạnh của hệ thống. 3.1. Quá trình song song hóa gồm ba giai đoạn bước chính Phân chia chương trình thành các công việc con (Sub-task decomposition). Phân tích sự phụ thuộc (Dependence analysic). Định thời các công việc (Task scheduling).

4. Distributed Programming

Lập trình phân tán là một dạng của lập trình song song (tính toán song song). Lập trình song song tạo ra mối liên hệ giữa máy tính và các đơn vị tính toán, khiến chúng hoạt động đồng thời đối với một vấn đề cụ thể (dự báo thời tiết chẳng hạn). Các đơn vị tính toán có thể đặt rất gần nhau hoặc tách rời nhau. Khi các đơn vị tính toán được đặt tách rời, ta gọi đó là lập trình phân tán. Với mô hình lập trình này, các đơn vị tính toán thường rất khác nhau, cũng như sự khác nhau giữa các hệ điều hành và thiết lập mạng máy tính. Những yếu tố đó khiến cho việc lập trình các tính toán của máy tính trở nên tương đối phức tạp và khó khăn. Lập trình mạng phân tán, thường có 2 khái niệm chính: peer to peer và client - server... peer to peer là lập trình ngang hàng giữa 2 máy tính... còn lập trình client - server là lập trình cho phép n máy client kết nối tới m máy server - đây cũng là mô hình chúng ta sẽ gặp nhiều trong thực tế … Có thể chia lập trình mạng thành 3 cấp độ, căn cứ theo mức độ thân thiện với developer và khả năng triển khai:

Mức thấp nhất là lập trình sử dụng socket - có thể truyền từng byte, từng stream lên trên mạng, ứng dụng này thường gặp trong các ứng dụng mạng cỡ nhỏ (vd: trong 2 máy tính, trong 1 mạng LAN...).

Mức cao hơn là lập trình sử dụng, triển khai ứng dụng theo mô hình dịch vụ (service) - quản lí mạng theo mô hình: kết nối, tạo tham chiếu client trên server và trả về, gọi hàm và truyền dữ liệu thông qua proxy của đối tượng trả về từ server (vd: RMI trên Java hay Remoting trên.NET...), mô hình này thường gặp trong các ứng dụng mạng cỡ trung bình và lớn, đòi hỏi tính performance cao (vd: các ứng dụng mạng đòi hỏi kết nối nhiều - liên tục và sử dụng diện rộng như các dịch vụ chat, game online...), ưu điểm chính của mô hình này là tính performance cao, bảo mật, nhưng nhược điểm là tính đa nền (multiplatform) và tính khả chuyển chưa cao (server và client phải cùng 1 công nghệ phát triển.)

Mức cao nhất là triển khai ứng dụng theo mô hình triển khai trên web, điển hình nhất ta có thể thấy là các web application và web service, mới nhất giờ có công nghệ WCF của M$ (tổng hợp tất cả trong 1)... mô hình này cho phép triển khai trên diện rộng, phục vụ



lượng khách hàng lớn... nhưng cũng có nhược điểm là tính performance chưa cao, bù lai, nó có khả năng mềm dẻo (flexibility) cao (server và client không cần sử dụng chung một công nghệ). Chúng ta thường thấy những ứng dụng loại này trong các ứng dụng được cung cấp từ một nhà cung cấp nào đó (vd: các số liệu chứng khoán, thời tiết …).

5. Extreme Programming

Lập trình cực độ (eXtreme Programming viết tắt là XP) là một trong những nhóm các phương pháp phát triển phần mềm một cách linh hoạt. XP sử dụng các nhóm làm việc kết hợp gồm những người lập trình, khách hàng và các nhà quản trị để phát triển phần mềm có chất lượng cao trong thời gian nhanh chóng. Một chương trình chạy được là thước đo đầu tiên của tiến trình theo XP. XP có thể phát triển và tồn tại được là do sự hiểu biết ngày một tiến bộ về các vấn đề đang giải quyết và cũng là vì các công cụ sẵn có cho phép ta thay đổi được cái giá của sự thay đổi (cost-of-change) ( đang là dạng hàm mũ trước đây ). XP giữ cho cái giá phải trả này ở mức thấp do vậy sẽ thúc đẩy môi trường sản xuất phần mềm. 5.1. Ưu Điểm Như ta đã biết hầu hết các phương pháp đều xem xét việc phát triển phần mềm như là một quy trình gia công với tiến trình viết phần mềm đi theo một con đường: Nhu cầu (thị trường) – Phân tích – Thiết kế – Viết code – Thử nghiệm – Bảo trì. Cách tiếp cận này có một sự thừa nhận quan trọng đó là ta đã biết được sản phẩm cuối cùng trước khi tiến trình bắt đầu. Nhưng hầu hết các dự án phần mềm hiện đại không thể thoả mãn cái sự thừa nhận này. Khách hàng sẽ đưa ra một cách đầy đủ những cái gì mới và người sản xuất cần những thông tin phản hồi một cách liên tục để đánh giá lại các lựa chọn của họ. Người lập trình cần phải có một phương án để luôn sẵn sàng đón nhận những thay đổi trong Nhu cầu để họ có thể đối phó được với các thông tin phản hồi. Nếu bạn làmviệc trong một môi trường mà ở đó các Nhu cầu được chờ để thay đổi và các khách hàng sẽ được lợi từ việc bàn giao phần mềm sớm và thường xuyên thì chắc chắn nên xem xét XP. Các nhóm làm theo XP sẽ thường xuyên nhận ra rằng họ đang bàn giao các sản phẩm phần mềm chất lượng cao với số lượng rất lớn và nhanh hơn trước đây rất nhiều. 5.2. Phương thức tiến hành XP XP là một phương pháp có khả năng thích nghi, thích ứng. Điều đó có nghĩa là sẽ không có hai dự án XP nào giống nhau cả. XP cung cấp một tập hợp các thực hành và được sử dụng như là điểm khởi đầu, và sau đó được làm cho thích ứng để phù hợp với các ràng buộc của từng dự án riêng. Sau đây là một tập hợp các nguyên tắc được mong đợi:

Liên lạc: một XP team lớn mạnh dựa trên các kiến thức, sự hiểu biết bài toán và hiểu biết phần mềm được chia sẻ. Các phương pháp giải quyết vấn đề được trao đổi trực tiếp. Những thứ cản trở đến công việc đều được loại bỏ.

Đơn giản hoá: công việc cần giảm tối thiểu độ phức tạp để đạt được hiệu quả cao nhất. Thông tin phản hồi thường các đội làm dự án và khách hàng của họ không nhận ra những

vấn đề rắc rối cho tới khi sắp bàn giao sản phẩm. Nhưng các XP teams thường xuyên lấy



feedback – trong quá trình làm việc, test, bàn giao sản phẩm… Khi đó sẽ control được các vấn đề phát sinh.

Thế mạnh: các đội làm phần mềm thành công cần phải kiểm soát được ngay cả khi xuất hiện các lỗi. XP đưa ra 12 phương án thực hành, và điểm mạnh của XP chính là đã kết hợp được các phương án này lại. Mỗi một phương án tuy đơn giản nhưng rất cần thiết phải nắm vững, sẽ góp phần làm giảm bớt đáng kể cái giá của sự thay đổi.

6. Concurrent Programming

Lập trình tương tranh là một trong những kỹ thuật quan trọng và cũng là một thách thức. Một mặt, nó đem lại khả năng sử dụng hiệu quả cho những hệ thống song song và phân tán. Mặt khác, những rủi ro trong việc tương tác giữa các tiến trình thực hiện đồng thời có thể gây ra những lỗi phần mềm không dễ dàng để tìm ra. Trong lập trình tương tranh, một số dòng lệnh có thể được thực hiện đồng thời. Mỗi dòng lệnh là một chương trình tuần tự, ngoại trừ một thực tế là các dòng lệnh có thể giao tiếp và gây trở ngại lẫn nhau. Mỗi một dòng lênh là một luồng ( thread ), các chương trình tuần tự còn gọi là chương trình đơn luồng, còn chương trình viết theo phương pháp tương tranh là chương trình đa luồng. 6.1. Đặc điểm

Người dùng có thể tương tác với các ứng dụng khi tiến trình đang thực thi. Những tiến trình chạy thời gian dài làm trì hoãn các tiến trình ngắn. Các chương trình phức tạp được thực hiện tốt hơn trên các bộ xử lý đa luồng. Những tiến trình đòi hỏi điều kiện tiên quyết có thể tạm dừng và đợi đến khi đáp ứng

được để tiếp tục xử lý.

III. Logic programming Answer a question via search for a solution 1. Đặc điểm

Mô hình lập trình logic hoàn toàn khác với các mô hình còn lại. Mô hình này đặc biệt phù hợp với những lĩnh vực liên quan đến việc rút ra những kiến

thức từ những sự kiện và quan hệ cơ bản – lĩnh vực trí tuệ nhân tạo. Có vẻ như mô hình này không gắn với những lĩnh vực tính toán nói chung.

Trả lời 1 câu hỏi thông qua việc tìm các giải pháp. Các đặc trưng: Về nguyên tắc và ý tưởng : Tự động kiểm chứng trong trí tuệ nhân tạo Dựa trên các chân lý- tiên đề axioms,các quy luật suy diễn - inference rules, và các truy

vấn queries. Chương trình thực hiện từ việc tìm kiếm có hệ thống trong 1 tập các sự kiện, sử dụng 1

tập các luật để đưa ra kết luận.



Trong lập trình logic, ta có thể sử dụng các vị từ để định nghĩa các khái niệm của tất cả các môn khoa học khác.

Khi mô tả bài toán dưới dạng logic vị từ, ta có thể yêu cầu hệ thống tìm kiếm các lời giải liên quan đến các khai báo đó. Bài toán cần giải được xem là “mục tiêu” mà hệ thống phải chứng minh trên cơ sở các tri thức đã được khai báo. Như thế, toàn bộ các ký hiệu của ngôn ngữ lập trình suy về một công thức đặc biệt:

Phát sinh từ một yêu cầu. Nhằm chứng minh một mục tiêu. Để trả lời cho câu hỏi đó hệ thống xem nó như là một

“đích” và cố chứng minh “đích” đó bằng cách tạo những suy diễn trên cơ sở các tri thức đã khai báo.

Một ngôn ngữ logic có thể được dùng trong giai đoạn đặc tả yêu cầu của quy trình xây dựng một sản phẩm phần mềm. Hơn thế nữa, logic vị từ cho phép biểu diễn hầu hết các khái niệm và các định lý trong các bộ môn khoa học.

2. Ngôn ngữ PROLOG

2.1. Giới thiệu

Prolog là một ngôn ngữ cấp cao, có đặc điểm gần với ngôn ngữ tự nhiên, từ những người mới học đến những lập trình viên chuyên nghiệp đều có thể tiếp cận một cách nhanh chóng, viết ra một chương trình ứng dụng hữu ích. Prolog ra đời vào năm 1973 do C.Camerauer (Đại học Marseilles, Pháp) và nhóm đồng sự phát triển. Từ đó đến nay, qua nhiều lần cải tiến, đặc biệt hãng Borland cho ra đời phần mềm TURBO PROLOG với nhiều ưu điểm, thuận tiện cho người sử dụng. Để giải quyết một số vấn đề, ta nhận thấy sử dụng ngôn ngữ Prolog cho ta chương trình gọn nhẹ hơn nhiều so với các ngôn ngữ khác. Khác với những ngôn ngữ cấu trúc như Pascal, hay C mà ta đã làm quen, Prolog là một ngôn ngữ mô tả, với một số sự kiện và quy luật suy diễn đã mô tả, Prolog sẽ suy luận cho ta các kết quả. 2.2. Các yếu tố cơ bản của Turbo Prolog

Trong một chương trình Prolog, ta cần khai báo các yếu tố sau đây: đối tượng, quan hệ giữa các đối tượng, sự kiện và các luật. 2.2.1. Đối tượng

Gồm có các hằng và biến. Hằng mang giá trị cho sẵn ở đầu chương trình hoặc trong quá trình viết ta đưa vào; Các biến có giá trị thay đổi sẽ được gán giá trị khi chạy chương trình. Tên biến là một ký tự hoa hoặc một chuỗi ký tự, bắt đầu bằng một ký tự hoa.



Có một loại biến đặc biệt gọi là biến tự do, biến này không có tên và người ta dùng ký hiệu _ (dấu gạch dưới) thay cho tên biến.

Quan hệ giữa các đối tượng Quan hệ giữa các đối tượng được dùng dưới hình thức vị từ.

Ví dụ • Thich(X,Y) là vị từ diễn tả câu “X thích Y” trong ngôn ngữ tự nhiên. • Blue(car) là vị từ diễn tả câu “Car is blue”. Như vậy các vị từ sẽ bao gồm tên của vị từ và các đối số của nó. Các đối số được đặt trong ngoặc và phân cách nhau bởi dấu phẩy.

2.2.2. Sự kiện và luật

Sự kiện là một vị từ diễn tả một sự thật. Ví dụ “2 là một số nguyên tố” là một sự kiện vì nó diễn tả sự thật 2 là một số nguyên tố. Luật là vị từ diễn tả quy luật suy diễn mà ta công nhận đúng. Luật được trình bày dưới dạng một mệnh đề. Ví dụ để suy diễn số nguyên N bất kỳ là một số nguyên tố ta viết: “N là một số nguyên tố nếu N>0, M là số nguyên tố nào đó, M<N và N không chia hết cho M”. 2.3. Cấu trúc của một chương trình Prolog

Một chương trình Prolog thường gồm có 3 hoặc 4 đoạn cơ bản: clauses, predicates, domains và goal. Phần goal có thể bỏ đi, nếu ta không thiết kế goal trong chương trình, thì khi thực hiện, hệ thống sẽ yêu cầu ta nhập goal vào. 2.3.1. Phần Domains

Đây là phần định nghĩa kiểu mới dựa vào các kiểu đã biết. Các kiểu được định nghĩa ở đây sẽ được sử dụng cho các đối số trong các vị từ. Nếu các vị từ sử dụng đối số có kiểu cơ bản thì có thể không cần phải định nghĩa lại các kiểu đó. Tuy nhiên để cho chương trình sáng sủa, người ta sẽ định nghĩa lại cả các kiểu cơ bản. Cú pháp: <danh sách kiểu mới> = <kiểu đã biết> hoặc <danh sách kiểu mới> = <danh sách kiểu đã biết> Trong đó các kiểu mới phân cách nhau bởi dấu phẩy, còn các kiểu đã biết phân cách nhau bởi dấu chấm phẩy. Ví dụ Domains



ten, tac_gia, nha_xb, dia_chi = string nam, thang, so_luong = integer dien_tich = real nam_xb = nxb(thang, nam) do_vat = sach(tac_gia, ten, nha_xb, nam_xb); xe(ten, so_luong); nha(dia_chi, dien_tich) Trong ví dụ trên, ta đã định nghĩa các kiểu mới, trong đó các kiểu mới ten, tac_gia, nha_xb, dia_chi dựa vào cùng một kiểu đã biết là string; các kiểu mới nam, thang, so_luong dựa vào cùng một kiểu đã biết là integer; kiểu mới dien_tich dựa vào kiểu đã biết là real; kiểu mới nam_xb dựa vào kiểu nxb được xây dựng từ các kiểu đã biết là thang, nam; còn kiểu do_vat lại dựa vào các kiểu sach, xe, nha mà các kiểu này lại dựa vào các kiểu đã biết.

2.3.2. Phần Predicates

Đây là phần bắt buộc phải có. Trong phần này chúng ta cần phải khai báo đầy đủ các vị từ sử dụng trong phần Clauses, ngoại trừ các vị từ mà Turbo Prolog đã xây dựng sẵn. 2.3.2.1. Cú pháp <Tên vị từ> (<danh sách các kiểu>) Các kiểu là các kiểu cơ bản hoặc là các kiểu đã được định nghĩa trong phần domains và được viết phân cách nhau bơi dấu phẩy.Ví dụ Predicates so_huu (ten, do_vat) so_nguyen_to(integer) Trong ví dụ trên ta khai báo hai vị từ. Trong đó vị từ so_huu (ten, do_vat) để chỉ một người có tên là ten sẽ sở hữu môt do_vat nào đó. Còn vị từ so_nguyen_to(integer) để xét xem một số integer nào đó có phải là số nguyên tố hay không. 2.3.3. Phần Clauses

Đây là phần bắt buộc phải có dùng để mô tả các sự kiện và các luật, sử dụng các vị từ đã khai báo trong phần predicates. 2.3.3.1. Cú pháp <Tên vị từ>(<danh sách các tham số>) <kí hiệu> <Tên vị từ 1>(<danh sách các tham số 1>) <kí hiệu>



……… <Tên vị từ N>(<danh sách các tham số N>) <kí hiệu> Trong đó: Tên vị từ phải là các tên vị từ đã được khai báo trong phần predicates. Các tham số có thể là các hằng hoặc biến có kiểu tương thích với các kiểu tương ứng đã được khai báo trong các vị từ ở trong phần predicates; các tham số được viết cách nhau bởi dấu phẩy. Các kí hiệu bao gồm: • :- (điều kiện nếu). • , (điều kiện và). • ; (điều kiện hoặc). • . (kết thúc vị từ) Ví dụ Clauses so_nguyen_to(2):-!. so_nguyen_to(N):-N>0, so_nguyen_to(M), M<N, N MOD M <>0. so_huu(“Nguyen Van A”, sach(“Do Xuan Loi”, “Cau truc DL”, “Khoa hoc Ky thuat”, nxb(8,1985))). Chú ý: Nếu trong các tham số của một vị từ có biến thì biến này phải xuất hiện ít nhất 2 lần trong vị từ đó hoặc trong các vị từ dùng để suy diễn ra vị từ đó. Nếu chỉ xuất hiện một lần thì bắt buộc phải dùng biến tự do. Ví dụ Để diễn tả sự kiện: Tổ hợp chập 0 của N (N bất kỳ) bằng 1, ta không thể viết Tohop(N,0,1) vì biến N chỉ xuất hiện đúng một lần trong vị từ này, do đó ta phải viết Tohop(_,0,1).

2.3.4. Phần Goal

Bao gồm các mục tiêu mà ta yêu cầu Turbo Prolog xác định và tìm kết quả. Đây là phần không bắt buộc phải có. Nếu ta viết sẵn trong chương trình thì đó gọi là goal nội; Nếu không, khi chạy chương trình Turbo Prolog sẽ yêu cầu ta nhập goal vào, lúc này gọi là goal ngoại. 2.3.4.1. Cú pháp Giống như cú pháp phần clauses. Tức là ta đưa vào một hoặc một số các vị từ. Nếu tất cả các tham số của vị từ là hằng thì kết quả nhận được là Yes (đúng) hoặc No (sai). Nếu trong các tham số của vị từ có biến thì kết quả trả về sẽ là các giá trị của biến.



Ngoài các phần chủ yếu nói trên, ta có thể đưa vào các phần liên quan đến khai báo hằng, các tập tin liên quan hoặc chỉ thị dịch. Ví dụ Constants Pi = 3.141592653

2.4. Các nguyên tắc của ngôn ngữ Prolog

Việc giải quyết vấn đề trong ngôn ngữ Prolog chủ yếu dựa vào hai nguyên tắc sau: Đồng nhất, quay lui. 2.4.1. Đồng nhất

• Một quan hệ có thể đồng nhất với một quan hệ nào đó cùng tên, cùng số lượng tham số, các đại lượng con cũng đồng nhất theo từng cặp. • Một hằng có thể đồng nhất với một hằng. • Một biến có thể đồng nhất với một hằng nào đó và có thể nhận luôn giá trị hằng đó. 2.4.2. Quay lui

Giả sử hệ thống đang chứng minh goal g, trong đó g được mô tả như sau: g :- g1, g2, …, gj-1, gj, …, gn.

Khi các gi kiểm chứng từ trái sang phải, đến gj là sai thì hệ thống sẽ quay lui lại gj-1 để tìm lời giải khác. 2.5. Bộ ký tự, từ khoá

Prolog dùng bộ ký tự sau: các chữ cái và chữ số (A – Z, a – z, 0 – 9); các toán tử (+, -, *, /, <, =, >) và các ký hiệu đặc biệt. 2.5.1. Một số từ khoá

Trace: Khi có từ khoá này ở đầu chương trình, thì chương trình được thực hiện từng bước để theo dõi; dùng phím F10 để tiếp tục.



Fail: Khi ta dùng goal nội, chương trình chỉ cho ta một kết quả (mặc dù có thể còn những kết quả khác), để nhận về tất cả các kết quả khi chạy goal nội, ta dùng toán tử Fail.

! hay còn gọi là nhát cắt, goal ngoại luôn cho ta mọi kết quả, muốn nhận chỉ một kết quả từ goal ngoại, ta dùng ký hiệu !.

2.6. Các kiểu dữ liệu

Trong prolog có kiểu dữ liệu chuẩn và kiểu do người lập trình định nghĩa. 2.6.1. Kiểu dữ liệu chuẩn

Là kiểu dữ liệu do prolog định nghĩa sẵn. Prolog cung cấp các kiểu dữ liệu chuẩn là: char, integer, real, string và symbol.

Char: Là kiểu ký tự. Hằng ký tự phải nằm giữa hai dấu nháy đơn. Ví dụ: ‘a’, ‘#’. Integer: Là kiểu số nguyên, tập giá trị bao gồm các số nguyên từ -32768 đến 32767. Real: Là kiểu số thực, tập giá trị bao gồm các số thực thuộc hai đoạn: đoạn các số âm từ -

10307 đến -10307 và đoạn số dương từ 10-307 đến 10307. String: Là kiểu chuỗi ký tự. Hằng chuỗi ký tự phải nằm giữa hai dấu nháy kép. Ví dụ:

“Turbo prolog 2.0” Symbol: Là một kiểu sơ cấp, có hình thức giống chuỗi ký tự. Hằng symbol có hai dạng:

Dãy các chữ, số và dấu gạch dưới viết liên tiếp, ký tự đầu phải viết thường (chẳng hạn: telephone_number); Dãy các ký tự ở giữa một cặp hai nháy kép (giống như chỗi ký tự) .

2.6.1.2. Phép toán số học

2.6.1.3. Phép toán quan hệ



2.6.1.4. Các vị từ như các hàm toán học

Toán tử NOT(X) : Nếu X là Yes thì NOT(X) là No và ngược lại.

2.6.2. Các kiểu dữ liệu do người lập trình định nghĩa

2.6.2.1. Kiểu mẩu tin



2.6.2.1.1. Cú pháp <tên kiểu mẩu tin> = tên mẩu tin (danh sách các kiểu phần tử) Ví dụ 1 Domains ten, tac_gia, nha_xb, dia_chi = string nam, thang, so_luong = integer dien_tich = real nam_xb = nxb(thang, nam) do_vat = sach(tac_gia, ten, nha_xb, nam_xb); xe(ten, so_luong); nha(dia_chi, dien_tich) predicates so_huu(ten,do_vat) clauses so_huu(“Nguyen Van A”, sach(“Do Xuan Loi”, “Cau truc DL”, “Khoa hoc Ky thuat”, nxb(8,1985))). so_huu(“Le thi B”, xe(“Dream II”, 2)). so_huu(“Nguyen Huu C”, nha(“3/1 Ly Tu Trong, tp Can Tho”, 100.5))2.6.2.2. Kiểu danh sách Cú pháp <tên kiểu danh sách> = <tên kiểu phần tử>* Ví dụ 1 Domains intlist = integer* Một danh sách là một dãy các phần tử phân cách nhau bởi dấu phẩy và đặt trong cặp dấu ngoặc vuông. Ví dụ 2 []% Danh sách rỗng [1,2,3] % Danh sách gồm ba số nguyên 1, 2 và 3. Cấu trúc của danh sách bao gồm hai phần: Phần đầu là phần tử đầu tiên của danh sách và phần đuôi là một danh sách của các phần tử còn lại. Danh sách được viết theo dạng [X|Y] thì X là phần tử đầu và Y là danh sách đuôi. Chẳng hạn trong danh sách [1,2,3] thì đầu là số nguyên 1 và đuôi là danh sách [2,3]. Trong danh sách cũng có thể dùng biến tự do, chẳng hạn ta có thể viết [_|Y] để chỉ một danh sách có



đầu là một phần tử nào đó và có đuôi là danh sách Y. 2.7. Các hàm xuất nhập chuẩn

2.7.1. Xuất ra màn hình Write( Arg1, Arg2, … ,Argn) in ra màn hình giá trị của các đối số. Writef( Formatstring, Arg1, Arg2, … ,Argn) in ra màn hình giá trị của các đối số theo định dạng được chỉ định trong Formastring. Trong đó Formastring là một chuỗi có thể là: “%d”: In số thập phân bình thường; đối số phải là char hoặc integer. “%c”: Đối số là một số integer, in ký tự có mã Ascci là đối số đó, chẳng hạn writef(“%c”,65) được A. “%e”: In số thực dưới dạng lũy thừa của 10. “%x”: In số Hexa; đối số phải là char hoặc integer. “%s”: In một chuỗi hoặc một symbol. 2.7.2. Nhập vào từ bàn phím Readln(X): Nhập một chuỗi ký tự vào biến X. ReadInt(X): Nhập một số nguyên vào biến X. ReadReal(X): Nhập một số thực vào biến X. ReadChar(X): Nhập vào một ký tự vào biến X. 2.8. Kỹ thuật đệ quy

Đệ quy là kỹ thuật lập trình được sử dụng trong nhiều ngôn ngữ. Trong Turbo Prolog ta sử dụng đệ quy khi một vị từ được định nghĩa nhờ vào chính vị từ đó. Như đã nói trong chương lập trình hàm, trong chương trình đệ quy phải có ít nhất một trường hợp dừng và lời gọi đệ quy phải chứa yếu tố dẫn đến trường hợp dừng. Trong Prolog, trường hợp dừng được thể hiện bằng một sự kiện, yếu tố dẫn đến trường hợp dừng thể hiện bằng một biến, liên hệ với biến ban đầu bởi một công thức. Ví dụ 1: Tính n! Predicates Facto (integer, integer) Clauses Facto(0,1):- !. Facto(N, FactN) :- N > 0, M = N – 1, facto(M, factM), factN = N*factM.



Ở ví dụ trên ta đã định nghĩa một vị từ dùng để tính giá trị giai thừa của một số tự nhiên, đối số thứ nhất là số cần tính giai thừa và đối số thứ hai dùng để nhận giá trị trả về. Trường hợp dừng ở đây được xác đinh bởi sự kiện 0 giai thừa là 1. Để tính N! ta tính M! với M= N-1. Yếu tố dẫn đến trường hợp dừng là biến M có giá trị bằng N-1. Ví dụ 2: Xác định một phần tử trong danh sách các symbol domains symbol_list = symbol* predicates element1(integer,symbol_list,symbol) element (integer,symbol_list,symbol) clauses % element1 không suy diễn ngược được element1(1,[X|_],X). element1(N,[_|L],Y):-M=N-1, element1(M,L,Y). % element có thể suy diễn ngược element(1,[X|_],X). element(N,[_|L],Y):-element(M,L,Y), N=M+1. Sự suy diễn thuận chiều là cho danh sách và vị trí, tìm được phần tử tại vị trí đó, chẳng hạn, nếu ta đưa vào goal element(2,[a,b,c,d],X) ta được X=b.TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI Sự suy diễn ngược ở đây là cho danh sách và phần tử, tìm được vị trí của phần tử đó, chẳng hạn, nếu ta đưa vào goal element(N,[a,b,c,d], b) ta được N=2. Ví dụ 3: Sắp xếp một danh sách các số nguyên domains list=integer* predicates insert(integer,list,list) sort(list,list) clauses insert(E,[],[E]). insert(E,[A|B],[E,A|B]):-E<=A. insert(E,[A|B],[A|C]):-E>A,insert(E,B,C). sort([],[]). sort([X|R1],L):-sort(R1,R),



insert(X,R,L). 2.9. Một số ví dụ về chương trình prolog

2.9.1. Xét xem một số N có phải là số nguyên tố hay không. domains so_nguyen = integer predicates so_nguyen_to(so_nguyen) Clauses so_nguyen_to(2):-!. so_nguyen_to(N):-N>0, so_nguyen_to(M), M<N, N MOD M <>0. goal so_nguyen_to(13). 2.9.2. Tìm các cặp có thể kết bạn Giả sử ta có bảng số liệu như sau:

Tiêu chuẩn kết bạn là hai người khác phái, người này hội đủ các tiêu chuẩn của người kia và ngược lại. Hãy viết chương trình để tìm ra các cặp có thể kết bạn với nhau. domains ten, g_tinh = symbol predicates gioi_tinh(ten, g_tinh) dep(ten) tot(ten) giau(ten) thong_minh(ten) khoe(ten) thich(ten,ten) ket_ban(ten,ten) clauses



gioi_tinh(lan,nu). gioi_tinh(hong,nu). gioi_tinh(thuy,nu). gioi_tinh(anh,nam). gioi_tinh(binh,nam). gioi_tinh(hung,nam). dep(lan). dep(hong). dep(binh). khoe(thuy). khoe(lan). khoe(binh). khoe(anh). khoe(hung). tot(lan). tot(thuy). thong_minh(hong). thong_minh(anh). thong_minh(hung). thong_minh(binh). giau(hong). giau(thuy). giau(hung). thich(lan,X):-khoe(X), dep(X), thong_minh(X). thich(hong,X):-khoe(X), thong_minh(X), giau(X). thich(thuy,X):-khoe(X), dep(X), thong_minh(X). thich(ann,X):-dep(X), tot(X), thong_minh(X). thich(binh,X):-dep(X), khoe(X). thich(hung,X):-khoe(X), tot(X), thong_minh(X). ket_ban(X,Y):- gioi_tinh(X,M),gioi_tinh(Y,N),M<>N, thich(X,Y), thich(Y,X).

IV. Lời kết

Với lượng kiến thức vô cùng hạn chế cũng như chưa có nhiều thời gian để tìm hiểu chuyên sâu, báo cáo này không hy vọng mang đến những gì mới mẻ mà đơn giản chỉ là sự tổng hợp, lược dịch và chỉnh sửa lại các bài viết đã có trên internet, sách in và một số tài liệu khác. Sai sót về mặt nội dung cũng như khiếm khuyết trong cách trình bày chắc chắn không thể tránh khỏi, rất mong nhận được sự thông cảm và giúp đỡ của thầy để báo cáo được hoàn thiện hơn!



V. Tài liệu tham khảo

What Is a Programming Paradigm? - Troy Holmes. Programming Paradigms - Kurt Nørmark © Department of Computer Science, Aalborg University, Denmark. Lập trình logic – ThS. Nguyễn Văn Linh. http://wikipedia.com http://congdongcviet.com …


[bao cao]tim hieu ve mo hinh lap trinh

Design