Logo GenDocs.ru

Поиск по сайту:  


Загрузка...

Лабораторная работа - Ознакомление с языком программирования Prolog - файл fw1.doc


Лабораторная работа - Ознакомление с языком программирования Prolog
скачать (168.3 kb.)

Доступные файлы (7):

fw_1.answer.txt5kb.10.04.2009 23:31скачать
fw1.doc64kb.03.11.2009 06:21скачать
fw1.odt
fw_1.only.listing.pdf21kb.10.04.2009 23:35скачать
fw1.pdf129kb.10.04.2009 23:36скачать
fw_1.pro
ReadMe.txt1kb.10.04.2009 23:51скачать

содержание
Загрузка...

fw1.doc

Реклама MarketGid:
Загрузка...

Москва, 2009
Московский авиационный институт
(государственный технический университет)


Факультет прикладной математики

Кафедра вычислительной математики и программирования

Лабораторная работа по курсу «логическое программирование»


Студент : И. К. Никитин

Преподаватель: М. А. Левинская

1Ознакомление с языком програмирования PROLOG


Цель: Первоначальное ознакомление с выбранной системой программирования на языке Пролог, реализация предикатов обработки списков в различных представлениях.

Задача:

  1. Ознакомится с одной из систем программирования на языке Пролог на персональной или мини-ЭВМ (J#, GNU Prolog, BinProlog, Cprolog, AMZI Prolog, Visual Prolog, TurboProlog, JLog или др.), освоить операции загрузки простейших пролог-программ и формулирования запросов.

  2. Проверить наличие в системе программирования встроенных стандартных предикатов обработки списков, отразить их применение в протоколе.

  3. Реализовать свои версии стандартных предикатов обработки списков,рассмотренные на занятии (length, member, append, remove, permute,sublist), и убедиться в их работоспособности на ряде различных запросов. Результат отразить в протоколе.

  4. Реализовать специальный предикат обработки списка в соответствии с вариантом задания двумя способами: на основе стандартных предикатов обработки списков и без их использования. Отразить в протоколеразличные варианты использования предиката на модельных запросах.Вариант задания определяется как n mod 20 + 1, где n порядковый номер студента в группе (9. Добавление элемента в конец списка).

  5. Реализовать указанный в задании предикат обработки для порядковогопредставления списка.

  6. Реализовать предикат обработки числового списка (списков) для стандартного и порядкового представлений в соответствии с вариантом задания и отразить результат его работы в протоколе (9. Вычисление числа вхождения 1-го элемента ).

  7. Привести какой-нибудь содержательный пример совместного использования предикатов, реализованных в пунктах 3 и 4.


  1. ^

    Исходный код


%% UTIL

%% *****************************************************************************************

printf(X ):-

write(X), write("\n"), fail.

printf(X ,Y):-

write(X), write(" "), write(Y), write(" "), write("\n"), fail.

printf(X ,Y, Z):-

write(X), write(" "), write(Y), write(" "), write(Z), write("\n"), fail.

printf(W, X ,Y, Z):-

write(W), write(" "), write(X), write(" "), write(Y), write(" "), write(Z), write("\n"), fail.

printf(Q, W, X ,Y, Z):-

write(Q), write(" "), write(W), write(" "), write(X), write(" "), write(Y), write(" "), write(Z), write("\n"), fail.

%% ----------------------------------------------------------------

print(X ):-

write(X), write("\n").

print(X ,Y):-

write(X), write(" "),write(Y), write(" "), write("\n").

print(X ,Y, Z):-

write(X), write(" "),write(Y), write(" "), write(Z), write("\n").

print(W, X ,Y, Z):-

write(W), write(" "),write(X), write(" "),write(Y), write(" "), write(Z), write("\n").

print(Q,W, X ,Y, Z):-

write(Q), write(" "), write(W), write(" "),write(X), write(" "), write(Y), write(" "),

write(Z), write("\n").

%% ----------------------------------------------------------------

testList1(X):-

X is [1, 2, 3, 4, 5].

testList2(X):-

X is [1, 2, 3].

testList3(X):-

X is [[1,2,3], [4,5,6], [7,8,9]].

testListO1(X):-

X is [e(1,1),e(2,2),e(3,3)].

testListO2(X):-

X is [e(1,1),e(2,2),e(1,1), e(3,3)].

testListO3(X):-

X is [e(1,1),e(2,2),e(0,1), e(3,3)].

testListO4(X):-

X is [e(2,2),e(9,1), e(3,3),e(1,1)].

testListO5(X):-

X is [e(2,2), e(3,3),e(1,1)].

%% MY STANDART

%% *****************************************************************************************

m_append([], X, X).

m_append([C|T], Y, [C|A]) :-

m_append(T, Y, A).

m_length([], 0).

m_length([H|T], N) :-

m_length(T, N1), N is N1 + 1.

m_member(A, [A|_]).

m_member(A, [B|T]) :-

m_member(A, T).

m_remove(X, [X|T], T).

m_remove(X, [Y|T], [Y|R]) :-

m_remove(X, T, R).

m_sublist([], L).

m_sublist(S, L) :-

m_append(L1, L2, L),

m_append(S, L3, L2).

m_permute([X], [X]).

m_permute([X|L], R) :-

m_permute(L, R1), m_remove(X, R, R1).
%% *****************************************************************************************

%% MY ADVANCED FUNCTIONS

%% *****************************************************************************************

%% ----------------------------------------------------------------

%% (*[_])push_back

%% ----------------------------------------------------------------

push_back([],E,[E]).

push_back(A,E,R):-

m_append(A,[E],R).

m_push_back([],Y,[Y]).

m_push_back([C|T],Y,[C|A]):-

m_push_back(T, Y, A).

%% ----------------------------------------------------------------

%% numOfFirst

%% ----------------------------------------------------------------

numOf(X, [], 0).

numOf(X, [H|T], N):-

numOf(X, T, N1),

X =:= H,

N is N1 + 1.

numOf(X, [H|T], N):-

numOf(X, T, N1),

X =\= H,

N is N1.

numOfFirst([X|Y],N):-

F is X,

numOf(F,[X|Y],N).

%% ----------------------------------------------------------------

%% push_backO (Numeric Order)

%% ----------------------------------------------------------------

maxiO(e(N, X), e(M, Y), e(K,R)) :-

N < M, R = Y, K = M, !.

maxiO(e(N, X), e(M, Y), e(K,R)) :-

N >= M, R = X, K = N, !.

maxIndexO([e(N, X)|[]], e(N, X)).

maxIndexO([e(N, X)|T], R) :-

maxIndexO(T, M1), maxiO(e(N, X), M1, K), R = K.

%% ----------------------------------------------------------------

push_backO([], Y, [e(0, Y)]).

push_backO(X, Y, A):-

maxIndexO(X, e(N, G )),

N1 is N + 1,

push_back(X, e(N1,Y), A).

%% ----------------------------------------------------------------

%% minValO (Numeric Order)

%% ----------------------------------------------------------------

minO(e(N, X), e(M, Y), e(K,R)) :-

X > Y, R = Y, K = M, !.

minO(e(N, X), e(M, Y), e(K,R)) :-

X =< Y, R = X, K = N, !.

minValO([e(N, X)|[]], e(N, X)).

minValO([e(N, X)|T], R) :-

minlistO(T, M1), minO(e(N, X), M1, K), R = K.

%% ----------------------------------------------------------------

%% numOfFirstO (Numeric Order)

%% ----------------------------------------------------------------

miniO(e(N, X), e(M, Y), e(K,R)) :-

N > M, R = Y, K = M, !.

miniO(e(N, X), e(M, Y), e(K,R)) :-

N =< M, R = X, K = N, !.

minIndexO([e(N, X)|[]], e(N, X)).

minIndexO([e(N, X)|T], R) :-

minIndexO(T, M1), miniO(e(N, X), M1, K), R = K.

%% ----------------------------------------------------------------

numOfO(e(D, X), [], 0).

numOfO(e(D, X), [e(_, H)|T], N):-

numOfO(e(D, X), T, N1),

X =:= H,

N is N1 + 1.

numOfO(e(D, X), [e(_, H)|T], N):-

numOfO(e(D, X), T, N1),

X =\= H,

N is N1.

numOfFirstO([e(D, X )|Y],N):-

minIndexO([e(D, X )|Y],V),

numOfO(V,[e(1, X )|Y], N ).

%% ----------------------------------------------------------------

%% delFirstO (Numeric Order)

%% (from lection)

%% ----------------------------------------------------------------

delFirstO([],[]).

delFirstO([e(1,_)|X], X1) :- del(X, X1).

delFirstO([e(X,Z1)|T1], [e(Y,Z1)|T2]) :-

Y is X - 1, del(T1, T2).

%% *****************************************************************************************

%% MY OWN FUNCTION (push_front)

%% *****************************************************************************************

m_reverse([], []).

m_reverse([X|T],Z) :-

m_reverse(T,S), m_append(S,[X],Z).

push_front(X, E, Y):-

m_reverse(X, Z),

m_push_back(Z, E, W),

m_reverse(W, Y).

%% ----------------------------------------------------------------

%% *****************************************************************************************

%% MAIN

%% *****************************************************************************************

?- printf("\tTRY to understand standart operations exist:\n").

?- testList1(X), append(X, [100], Z), printf("append(X, [100], Z): Z=", Y).

?- testList1(X), member(Y, X), printf("member:", Y,"is memder of" , Y).

?- testList1(X), remove(R, X, Z), printf("remove(", R, X,", Z): Z =" , Z).

?- testList1(X), del(R, X, Z), printf("remove(", R, X,", Z): Z =" , Z).

?- testList1(X), N is list_length(X), printf("N is list_length(X)", N).

?- testList1(X), sublist([1], X), printf( sublist([1], X) ).

?- testList2(X), permute(X, S), printf("permute(", X ,",",S,")").

?- printf("\n#IF IT IS EMPTY ISN'T EXISTS\n").

?- printf("\tTRY to TEST my operations:\n").

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\t\tm_append:\n").

?- testList1(X), m_append(X, [100], Z), printf("m_append(X, [100], Z): Z =", Z).

?- m_append([1,2], Z, [1,2,3]), printf("m_append([1,2], Z, [1,2,3]): Z =", Z).

?- m_append(Z, 3, [1,2,3]), printf("m_append(Z, [3], [1,2,3]): Z =", Z).

?- m_append(Z, Y, [1,2,3]), printf("m_append(Z, Y, [1,2,3]):",m_append(Z, Y, [1,2,3])).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\t\tm_member:\n").

?- testList1(X), m_member(1, X), printf("m_member([1], X): TRUE").

?- testList1(X), m_member(Y, X), printf("m_member:", Y,"is memder of" , X).

?- testList3(X), m_member(Y, X), printf("m_member:", Y,"is memder of" , X).

?- testList3(X), m_member(Z, X), m_member(Y, Z),

printf("m_member:", Y,"is memder's memder of" , X).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\t\tm_remove:\n").

?- testList1(X), m_remove(R, X, Z), printf("m_remove(", R, X,", Z): Z =" , Z).

?- testList1(X), m_remove(1, [1], Z), printf("m_remove(1, [1], Z): Z =" , Z).

?- testList1(X), m_remove(1, [1,1], Z), printf("m_remove(1, [1,1], Z): Z =" , Z).

?- testList1(X), m_remove(3, Z, [1,2]), printf("m_remove(3, Z, [1,2]): Z =" , Z).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\t\tm_length:\n").

?- testList1(X), m_length(X, Y), printf("m_length( ",X,")=", Y).

?- m_length( [],Y ), printf("m_length([])=", Y).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\t\tm_sublist:\n").

?- testList1(X), m_sublist(S,X), printf("m_sublist(S,",X,"): S =" , S).

?- testList1(X), m_sublist([],X), printf("m_sublist([],",X,"): TRUE").

?- testList1(X), m_sublist([2],X), printf("m_sublist([2],",X,"): TRUE").

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\t\tm_permute:\n").

?- testList1(X), m_permute([1,2,3],S), printf("m_permute([1,2,3], S): S =" , S).

?- testList1(X), m_permute([1,2,3],[3,2,1]), printf("m_permute([1,2,3],[3,2,1]): TRUE").

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\tMY ADVANCED FUNCTIONS:\n").

%% ----------------------------------------------------------------

?- printf("\n\t\tpush_back(with m_append):\n").

?- push_back([1,2],3,X), printf("push_back([1,2],3,X): X =" , X).

?- push_back([1,2],X,[1,2,3]), printf("push_back([1,2],X,[1,2,3]): X =" , X).

?- push_back(X,3,[1,2,3]), printf("push_back(X,3,[1,2,3]): X =" , X).

%% ----------------------------------------------------------------

?- printf("\n\t\tm_push_back:\n").

?- m_push_back([1,2],3,X), printf("m_push_back([1,2],3,X): X =" , X).

?- m_push_back([1,2],X,[1,2,3]), printf("m_push_back([1,2],X,[1,2,3]): X =" , X).

?- m_push_back(X,3,[1,2,3]), printf("m_push_back(X,3,[1,2,3]): X =" , X).

%% ----------------------------------------------------------------

?- printf("\n\t\tnumOfFirst:\n").

?- numOfFirst([1],X), printf("numOfFirst([1],X): X =" , X).

?- numOfFirst([1,3, 1,1,4,22],X), printf("numOfFirst([1,3, 1,1,4,22],X): X =" , X).

%% ----------------------------------------------------------------

?- printf("\n\t\tpush_backO (Numeric Order):\n").

?- push_backO([],3,X), printf("push_backO([],3,X): X =" , X).

?- X is [e(0, 200)], push_backO(X, 14419, Z), printf("push_backO(", X,", 14419, Z): Z =" , Z).

?- testListO1(X), push_backO(X, 14419, Z), printf("push_backO(", X,", 14419, Z): Z =" , Z).

?- testListO2(X), push_backO(X, -102503, Z), printf("push_backO(", X,", -102503, Z): Z =" , Z).

?- testListO4(X), push_backO(X, 350029, Z), printf("push_backO(", X,", 350029, Z): Z =" , Z).

?- testListO4(X), push_backO(X, 3, Z), printf("push_backO(", X,", 3, Z): Z =" , Z).

%% ----------------------------------------------------------------

?- printf("\n\t\tnumOfFirst(Numeric Order):\n").

?- testListO1(X), numOfFirstO(X,Z), printf("numOfFirstO(", X ,",Z): Z =" , Z).

?- testListO2(X), numOfFirstO(X,Z), printf("numOfFirstO(", X ,",Z): Z =" , Z).

?- testListO3(X), numOfFirstO(X,Z), printf("numOfFirstO(", X ,",Z): Z =" , Z).

?- testListO4(X), numOfFirstO(X,Z), printf("numOfFirstO(", X ,",Z): Z =" , Z).

?- testListO5(X), numOfFirstO(X,Z), printf("numOfFirstO(", X ,",Z): Z =" , Z).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

?- printf("\n\tMY OWN FUNCTION:\n").

%% ----------------------------------------------------------------

?- printf("\n\t\tpush_front(this is m_push_back with m_append \n\t\t\t {m_append is for reverse}):\n").

?- push_front([1,2],3,X), printf("push_front([1,2],3,X): X =" , X).

?- push_front([1,2],3,X), printf("push_front([1,2],3,X): X =" , X).

?- print("\nThe End!").
  1. ^

    Програмный вывод


Compiling the file:

C:\Documents and Settings\root\Desktop\fw_1.end3.pro

0 errors, 0 warnings.

TRY to understand stadart operations exist:

N is list_length(X) 5

#IF IT IS EMPTY ISN'T ISISTS

TRY to TEST my operations:

m_append:

m_append(X, [100], Z): Z = [1,2,3,4,5,100]

m_append([1,2], Z, [1,2,3]): Z = [3]

m_append(Z, Y, [1,2,3]): m_append([],[1,2,3],[1,2,3])

m_append(Z, Y, [1,2,3]): m_append([1],[2,3],[1,2,3])

m_append(Z, Y, [1,2,3]): m_append([1,2],[3],[1,2,3])

m_append(Z, Y, [1,2,3]): m_append([1,2,3],[],[1,2,3])

m_member:

m_member([1], X): TRUE

m_member: 1 is memder of [1,2,3,4,5]

m_member: 2 is memder of [1,2,3,4,5]

m_member: 3 is memder of [1,2,3,4,5]

m_member: 4 is memder of [1,2,3,4,5]

m_member: 5 is memder of [1,2,3,4,5]

m_member: [1,2,3] is memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: [4,5,6] is memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: [7,8,9] is memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 1 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 2 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 3 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 4 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 5 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 6 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 7 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 8 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_member: 9 is memder's memder of [[1,2,3],[4,5,6],[7,8,9]]

m_remove:

m_remove( 1 [1,2,3,4,5] , Z): Z = [2,3,4,5]

m_remove( 2 [1,2,3,4,5] , Z): Z = [1,3,4,5]

m_remove( 3 [1,2,3,4,5] , Z): Z = [1,2,4,5]

m_remove( 4 [1,2,3,4,5] , Z): Z = [1,2,3,5]

m_remove( 5 [1,2,3,4,5] , Z): Z = [1,2,3,4]

m_remove(1, [1], Z): Z = []

m_remove(1, [1,1], Z): Z = [1]

m_remove(1, [1,1], Z): Z = [1]

m_remove(3, Z, [1,2]): Z = [3,1,2]

m_remove(3, Z, [1,2]): Z = [1,3,2]

m_remove(3, Z, [1,2]): Z = [1,2,3]

m_length:

m_length( [1,2,3,4,5] )= 5

m_length([])= 0

m_sublist:

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist(S, [1,2,3,4,5] ): S = [1]

m_sublist(S, [1,2,3,4,5] ): S = [1,2]

m_sublist(S, [1,2,3,4,5] ): S = [1,2,3]

m_sublist(S, [1,2,3,4,5] ): S = [1,2,3,4]

m_sublist(S, [1,2,3,4,5] ): S = [1,2,3,4,5]

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist(S, [1,2,3,4,5] ): S = [2]

m_sublist(S, [1,2,3,4,5] ): S = [2,3]

m_sublist(S, [1,2,3,4,5] ): S = [2,3,4]

m_sublist(S, [1,2,3,4,5] ): S = [2,3,4,5]

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist(S, [1,2,3,4,5] ): S = [3]

m_sublist(S, [1,2,3,4,5] ): S = [3,4]

m_sublist(S, [1,2,3,4,5] ): S = [3,4,5]

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist(S, [1,2,3,4,5] ): S = [4]

m_sublist(S, [1,2,3,4,5] ): S = [4,5]

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist(S, [1,2,3,4,5] ): S = [5]

m_sublist(S, [1,2,3,4,5] ): S = []

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([], [1,2,3,4,5] ): TRUE

m_sublist([2], [1,2,3,4,5] ): TRUE

m_permute:

m_permute([1,2,3], S): S = [1,2,3]

m_permute([1,2,3], S): S = [2,1,3]

m_permute([1,2,3], S): S = [2,3,1]

m_permute([1,2,3], S): S = [1,3,2]

m_permute([1,2,3], S): S = [3,1,2]

m_permute([1,2,3], S): S = [3,2,1]

m_permute([1,2,3],[3,2,1]): TRUE

^ MY ADVANCED FUNCTIONS:

push_back(with m_append):

push_back([1,2],3,X): X = [1,2,3]

push_back([1,2],X,[1,2,3]): X = 3

push_back(X,3,[1,2,3]): X = [1,2]

m_push_back:

m_push_back([1,2],3,X): X = [1,2,3]

m_push_back([1,2],X,[1,2,3]): X = 3

m_push_back(X,3,[1,2,3]): X = [1,2]

numOfFirst:

numOfFirst([1],X): X = 1

numOfFirst([1,3, 1,1,4,22],X): X = 3

push_backO (Numeric Order):

push_backO([],3,X): X = [e(0,3)]

push_backO( [e(0,200)] , 14419, Z): Z = [e(0,200),e(1,14419)]

push_backO( [e(1,1),e(2,2),e(3,3)] , 14419, Z): Z = [e(1,1),e(2,2),e(3,3),e(4,14419)]

push_backO( [e(1,1),e(2,2),e(1,1),e(3,3)] , -102503, Z): Z = [e(1,1),e(2,2),e(1,1),e(3,3),e(4,-102503)]

push_backO( [e(2,2),e(9,1),e(3,3),e(1,1)] , 350029, Z): Z = [e(2,2),e(9,1),e(3,3),e(1,1),e(10,350029)]

push_backO( [e(2,2),e(9,1),e(3,3),e(1,1)] , 3, Z): Z = [e(2,2),e(9,1),e(3,3),e(1,1),e(10,3)]

numOfFirst(Numeric Order):

numOfFirstO( [e(1,1),e(2,2),e(3,3)] ,Z): Z = 1

numOfFirstO( [e(1,1),e(2,2),e(1,1),e(3,3)] ,Z): Z = 2

numOfFirstO( [e(1,1),e(2,2),e(0,1),e(3,3)] ,Z): Z = 2

numOfFirstO( [e(2,2),e(9,1),e(3,3),e(1,1)] ,Z): Z = 2

numOfFirstO( [e(2,2),e(3,3),e(1,1)] ,Z): Z = 1

^ MY OWN FUNCTION:

push_front(this is m_push_back with m_append

{m_append is for reverse}):

push_front([1,2],3,X): X = [3,1,2]

push_front([1,2],3,X): X = [3,1,2]

The End!

Yes.
  1. Выводы


Пролог (Prolog) — язык и система логического программирования, основанные на языке предикатов математической логики дизъюнктов Хорна, представляющей собой подмножество логики предикатов первого порядка.
Основными понятиями в языке Пролог являются факты, правила логического вывода и запросы, позволяющие описывать базы знаний, процедуры логического вывода и принятия решений.
Факты в языке Пролог описываются логическими предикатами с конкретными значениями. Правила в Прологе записываются в форме правил логического вывода с логическими заключениями и списком логических условий.
Особую роль в интерпретаторе Пролога играют конкретные запросы к базам знаний, на которые система логического программирования генерирует ответы «истина» и «ложь». Для обобщенных запросов с переменными в качестве аргументов созданная систем Пролог выводит конкретные данные в подтверждение истинности обобщенных сведений и правил вывода.
Факты в базах знаний на языке Пролог представляют конкретные сведения (знания). Обобщённые сведения и знания в языке Пролог задаются правилами логического вывода (определениями) и наборами таких правил вывода (определений) над конкретными фактами и обобщенными сведениями.


При выполнении этой лаборатороной работы я познакомился с языком логического программирования Prolog. Мной была выбрана его реализыция Strawberry Prolog. Могу объяснить свой выбор простой только использования. Сам по себе пролог весьма необычный язык программирования. Не могу сказать что он мне понравился, но было интересно. Важно заметить, что для изучения он значительно проще чем язык функцилнального программирования Lisp.


Скачать файл (168.3 kb.)

Поиск по сайту:  

© gendocs.ru
При копировании укажите ссылку.
обратиться к администрации
Рейтинг@Mail.ru