Элементами списка могут быть структуры.

Примеры.

Задано множество отрезков на плоскости. Надо найти все отрезки, которые совпадают с заданным при параллельном переносе.

Видать решение в виде списков.

domains

point = p (real,real)

interval = i (point, point)

list = intrval*

predicates

otrezok (interval)

search (interval, list)

paral (interval, interval)

par_otr (interval, interval)

clauses

otrezok (i (p(0,0),p(1,1))).

search (P,L):- findall (Z, par_otr(P,Z), L).

par_otr (P,Q):- otrezok (Q), paral (P,Q).

paral (i (p (X1,Y1),p (X2,Y2)), i (p (X3,Y3), p(X4,Y4))):- X3-X1=X4-X2, Y3-Y1=Y4-Y2.

paral (i (p (X1,Y1),p (X2,Y2)), i (p (X3,Y3), p(X4,Y4))):- X4-X1=X3-X2, Y4-Y1=Y3-Y2.

Когда у структуры в качестве элемента – список.

База таблицы прыгунов в длину.

У каждого спортсмена есть список итогов. Выдать таблицу в виде списка.

domains

list = real*

result = r (string, list)

str = s (string, real)

slist = str*

predicates

sportsmen (result)

tabl (slist)

best_res (str)

max (list, real)

sort (slist, slist)

input (str, slist, slist).

clauses

sportsmen (r(“sidorov”, [6.60,6.33, 6.95, 7.01])).

tabl (LL):- findall (Y, best_res(Y), LL1),

sort (LL1,LL).

best_res (s(X,Y)):- sportsmen (r(X,L)), max (L,Y).

sort ([],[]).

sort ([H|L],L2):- sort (L,L1), input (H,L1,L2).

input (H, [], [H]).

input (s(Z1,Y1), [s(Z2, Y2)|L], [s(Z1,Y1), s(Z2,Y2)|L]):-Y1>=Y2.

input (s(Z1, Y1), [s(Z2,Y2)|L], [s(Z2,Y2)|L1]):- Y1<Y2, input (s(Z1,Y1),L,L1).

domains

points = t (real, real)

otr = o (points, points)

list = otr*

predicates

m_point (points)

horisont (points, points)

search (otr)

search (list)

bd (list, list)

np1 (otr, list)

clauses

m_point (t(0,0))

search (o (A,B)):- m_point (A), m_point (B), horisont (B).

search (LL):- findall (Z, search (Z), LL1), bd (LL1,LL).

bd ([],[]).

bd ([H|L1],L2):- np1 (H, L1), bd (L1,L2).

bd ([o(T1,T2)|L1], L2):- np1 (o (T2,T1),L1)), bd (L1,L2).

bd ([o[T1,T2]|L1],):- not (o(T1,T2),L1), not (o(T2,T1),L1), bd (L1, L2).

Примеры обработки структур.

Обработка семьи.

член семьи (имя, фамилия, дата(день, месяц, год))

domains

data = d(integer, integer, integer)

str = s (string, string, data)

slist = str*

para = p(str, str)

plist = *para

lslist = slist*

predicates

family (str, str, slist)

child (str)

prenadl (s (r, slist))

childlist (slist)

moar2child (str, str)

familylist (plist)

year (str, str)

raznica (str, str)

listoflistofchild (lslist)

max (lslist, integer)

dlina (slist, integer)

moarchildfamily (str, str, slist)

countchild (integer)

clauses

family (s(“ivan”, ”sidorov”, d(1,1,1950)), s(“maria”, “sidorov”, d (2,2,1991)), [s(“vitia”, “sidorov”, d(1,2,2013)),…])

child (A):-family (_,_,L), prenadl (A,L).

childlist (L):-findall (A, child(A), L).

moar2child (A,B):- family (A,B,[_,_|_]).

para (p (A,B)):- moar2child (A,B).

childlist2(L):- findall (Z,para(Z,L)).

year (s(_,_, d(_,_,G)),s(_,_, d(_,_,G))).

year (s(_,_,d(MM,GM)), s(_,_,d(MZH,GZH))):-GM+1=GZH, MZH<=MM.

year (s(_,_,d(MM,GM)), s(_,_,d(MZH,GZH))):-GZH+1=GM, MM<=MZH.

raznica (A, B):- family (A,B,_), year (A,B).
listoflistofchild (L):-findall (Z, family(_,_,Z),L)).

max ([X], M):-dlina (X, M).

max ([X|L], M):-max (L, M), dlina (X,N), N<=M, max (L,M), dlina (X, N), N>M.

countchild (K):-listoflistofchild (L), max (L,K).

moarchildfamily (A,B,C):-maxcountchild (K), family (A,B,C), dlina (C,K).

Goal:

child (X)

X= (“petia”, “sidorov”, d (1,2,2013))

X=...

Предикаты ввода вывода.

Вывод: write (l1, l2,…,ln) выводит

1. константа 2. переменная конкретезированная.

Пример.

write (“X=”, X)

перевод на новую строку – предикат nl

write (“X=”, X), nl

write (“Y=”, Y)

Предикаты ввода

для целого значения

reading (l1) переменная свободная, которая потом конкретизируется.

Аналогично для вещественного числа

readreal (l1)

Для символа

readchar (l2)

Для строки

readln (l1)

predicates

resh (real, real)

zadacha

clauses

resh (A,B):-A<>0, X=-B/A, write (“X=”,X), nl.

resh (0,B):-B<>0, write (“No resh.”),nl.

resh (0,0):- write (“too match resh!”), nl.

zadacha:-write (“A=”), readreal (A), write (“B=”), readreal (B), resh (A,B).

задержка: readchar (_).

Встроенный предикат средство управления.

Операция отсечения «!» - отсечение неперспективных вариантов. Повышает эффективность программы.

predicates

f (real, real)

clauses

f (X, 0):- X<0,!.

f (X, X):- X>=0, X<=1,!.

f (X, 1):- X>1.

goal: f (-1, A)

A=0.

f (X, 0):- X<0,!.

f (X, X):- X<=1,!.

f (X,1).

domains

list = integer*

predicates

sum (list, integer)

bd (list, list)

prenadl (integer, list).

clauses

sum ([],0).

sum ([X|L], S):- X>0,!, sum (L, S1), S=X+S1.

sum ([X|L], S):- sum (L, S),!.

sum ([], 0)

bd ([X|L], L1):- prenadl (X,L), bd (L,L1).

bd ([X|L], [X|L]):-!, bd (L,L1).

bd ([],[]).

Задано множество точек, найти горизонтальные отрезки, сформировать спски.

domains

point = T (real, real)

line = O (point, point)

list1 = point *

list2 = line*

predicates

mnozh (point)

horizont

list11 (list1)

element (list1,line)

list22 (list1, list2).

inputpoint (list1, list1)

clauses

mnozh (T(1,1)).

list11(L):- findlall (Z, mnozh(Z,L)).

element (L, o(T1,T2)):- prenadl (T1,L), prenadl (T2,L), horizont (T1,T2).

list22 (L,LL):-findall (Z, element(L,Z), LL1), bd (LL1, LL).

inputpoint (L1,L2):- write (“input? (y/n):”, readchar (C), C=”y”,!, vvod (Z),inputpoint ([Z|L1],L2).

inputpoint (L,L)

Работа с файлами.

domains

file=dt

list=integer*

predicates

menu

repeat

process(integer)

input(string)

read

error

dlina (list, integer)

delete (integer,list,list)

printlist(list)

clauses

process (4):-makewindow (5,7,7, “delete”,5,10,20,70),clearwindow, write(“filename: ”), readln (F), openread (df, F), readdevice (df), readlist (L), readdevice (…), readfile (df), write (“…”), readlist (K), dlina (L, N), K>0, K<=N,!,delete (K,L,L1), openwrite (df,F), writedevice (df), printlist (L1),writedevice (…), closefile (df), removewindow.

process (4):- write(“No file, or no number”), readchar (_).

readlist ([H|T]):- reading (H),!, readlist (T).

readlist ([]).

not (eof (df)).

delete (1, [_|L],L).

delete (K, [H|L],[H|L1]):-K>1, K1=K-1,delete (K1,L,L1).

printlist ([H|T]):-!,writef (“%5.6”, H), nl, printlit (T).

printlist ([]).

Пункт 7.

Process (7):- write (“End of the work”), readchar(_).

Динамические Базы Данных.

Статические предикаты описываются в predicates. Динамические в database.

Добавление и удаление осуществляется с помощью встроенных предикатов.

Добавление.

asserta (факт).

процедура

Определение процедуры.

Для удаления записи используется retract (факт).

domains

list=integer*

database

dmult (intefer,integer,integer).

predicates

tad

prenadl(integer, list)

clear_dbd

clauses

tab:-L=[1,2,3,4,5,6,7,8,9], prenadl (X,L), prenadl (Y,L),Z=X*Y, assert (dmult(X,Y,Z)), fail.

tab:-!.

clear_dbd:-retract (dmult(_,_,_), fail)

clear_dbd:-!.

clear_dbd:-retract(_),fail.

clear_dbd:-!.

goal: tab, dmult (2,2,H).

A=4

predicates

fib (integer, integer)

clauses

fib (0,1):-!.

fib (1,1):-!.

fib (N,F):-N1=N-1, fib(N1, F1), N2=N-2, fib (N2, F2), F=F1+F2.

2 вариант

database

dfib (integer,integer)

clauses

dfib (0,1):-!.

dfib (1,1):-!.

dfib (N,F):-dfib (N,F),!.

dfib (N,F):- N1=N-1, dfib (N1,F1), N2=N-2, dfib (N2,F2), F=F1+F2, asserta(dfib(N,F)).

save (физ_файл stringовый тип)

dfib (3,3)

dfib (2,2)

consult (физ_файл) %считывание из файла при условии, что информация правильная и файл существует.

Реализация меню с помощью рекурсий. Телефонный справочник.

domains

file=ff

database

dphone (string, string)

predicates

start

menu

process(char)

fioPhone (string, string)

phoneFio (string, string)

clauses

menu:- clearwindow, write (“1 поиск по ФИО”), nl,

write (“2 Поиск по номеру”), nl

write (“3 Добавление новой записи”), nl

write (“4 Удаление записи”), nl

write (“5 Измение номера телефона”), nl

write (“6 Выход”), nl, nl

write (“Ваш выбор (1-6): ”), readchar (C),

process (C).

start:- exitfile(“Phone.ddb”),!, consult (“phones.ddb”), menu.

start:- openwrite (df, phones.ddb), closefile (df), menu.

process (‘0’):- retract_dbd, write (“ДБД очищена”), nl, readchar(_).

process (‘1’):- clearwindow,

write (“ФИО”), readln (N), fioPhone (N, T),

write (“Номер телефона: ”,T), readchar (_), menu.

process (‘2’):- clearwindow, write (“Номер: ”), readln (T),

phoneFio (N,T), write (“ФИО абонента = ”, N), readchar(_), menu.

fioPhone (N,T):-dphone (N,T),!.

fioPhone (_, ”Нет информации по телефону.”).

phoneFio (N,T):- dphone (N,T),!.

phoneFio (“Нет информации о владельце”,_).

process (‘3’):- clearwindow, write (“ФИО”), readln (N),

write (“номер = ”), readln (T), asserta (dphone (N,T)), menu.

process (‘4’):- clearwindow, write (“номер = ”), readln (T),

retract (dphone(_,T)),!, menu.

process (‘4’):- write (“Ощибка, нет номера”), readchar (_), menu.

process (‘5’):- clearwindow, write (“ФИО= ”), readln (N), write (“Новый номер”), readln (T),

retract (dphone(N,_)), asserta (dphone(N,T)), menu.

process (‘6’):- save(“phone,ddb”), retract_ddb.

retract_ddb:- retract (_), fail.

retract_ddb:-!.

process (_):- write (“Ошибка ввода, нет такого пункта”), readchar (_), menu.

база студентов

domains

list = string*

database

dstud (string, integer, string)

predicates

stud (string, integer, string)

system

retract_dbd

menu

repeat

delete (string, string, string)

output (list)

spisok (string, string)

group (list, list)

clauses

system:-mahewindow (1,7,7, ”Динамическая база СТУДЕНННТ!”, 5, 10, 20, 70),

retract_dbd, menu, retract_dbd, remowewindow.

menu:- makewindow (2,7,7,”Меню”,5,10,20,50),

repeat, clearwindow,

write (“0 ”)

write (“1 Создание ДБД”), nl,

write (“2 Загрузка ДБД из файла”), nl,

write (“3 Просмотр ДБД”),nl,

write (“4 поиск по ДБД”), nl,

write (“5 Список группы”), nl,

write (“6 Перечень группы курса”), nl,

write (“7 Добавить запись в ДБД”), nl,

write (“8 Удалить запись из ДБД”), nl,

write (“9 Сохранение ДБД”), nl,

write (“10 Выход”), nl, nl,

write (“Ваш выбор: ”), readint (K), process (K), K=10,!, removewindow.

stud (“Иванов А.А.”, 3, “ИСТ-308”).

stud (“Петров Б.Б.”, 3, “ИСТ-308”).

process (‘1’):- do_dbd, write (“ДБД создана”), nl, readchar (_).

do_dbd:- stud (Fio, Curs, Gr), asserta (dstud (Fio, Curs, Gr)), fail.

do_dbd:-!.

process (‘2’):- makewindow(3,7,7,”Loading dynamic database”, 5, 20, 20, 50), clearwindow, write (“Имя файла: ”), readln (F), consult (F),!, write (“ДБД загружена из ”, F), nl, readchar (_), removewindow.

process (‘2’):- write (“Ошибка ввода”), nl, readchar(_), removewindow.

process (‘3’):- makewindow (4,,7,7, “просмотр ДБД”, ююю), clearwindow, print, nl, write (“ДБД выведена”), nl, readchar (_), removewindow.

print:- dstud (F,C,G), write (F, “курс= ”, C, “группа= ”, G), nl, fail.

print:-!.

process (‘7’):- makewindow (8,7,7,”Добавим в ДБД” ююю), clearwindow, write (“ФИО= ”), readln (F), write (“курс= ”), readint (C), write (“группа= ”), readln (G),!, assertz (dstud (F,C,G)),nl, write (“Группа добавлена”), nl, readchar (_), removewindow.

process (‘7’):- write (“Ощибка ввода, повторите ввод”), nl,readchar (_), removewindow.

process (‘8’):- make (9,7,7, “Удаление из ДБД”,,,), clearwindow, write…, delete (F,C,G), removewindow.

delete(F,C,G):- retract (dstud(F,C,G)),!, write (“запись удалена”), nl, readchar(_).

delete (F,C,G):-write (F,””,C,””,G,”не существует”),nl readchar(_).

process (‘9’):- write (“Имя файла”), readln (F), save (F),!, write (“ДБД is saved”), nl, readchar (_).

process (‘9’):- write (), readchar(_).

process (‘10’):- write(), readchar(_).

process (‘4’):-makewindow (5,7,7,”searching FIO”,5,20,20,50),clearwindow

write (“ФИО= ”), readln(F), poisk(F), removewindow.

poisk (F):- dstud (F,C,G), write (F, “”,C,””,G), nl, fail.

poisk (_):- write (“поиск завершен”), nl, readchar (_).

process (‘5’):- makewindow (6,7,7,”список друзей”,…), clearwindow, write (“группа= ”), readln(G), spisok (G,L), output(L), write (“Вывод завершен”), readchar(_), removewindow.

spisok (G,L):- findall (X, dstud(X,_,G),L).

output ([H|T]):-!, write(H), nl, output (T).

output ([]).

process(‘6’):- makewindow (7,7,7,”Группа курса”,…), clearwindow, write(“курс= ”), readint (C), group (C,L), output (L), removewindow.

group (C,L):- findall (Y, dstud(_,CY),L1), b_dub (L1,L).

альтернативные домены

domains

тип = f1 (тип парам. 1,…);f2 (тип парама.1, …),…

alist = тип*

predicates

pr (…,тип,…)

Ведомости

Экзамен (предмет, оценка)

Курсовая (предмет, оценка)

Зачет (предмет, оценка)

Пример.

domains

disciple = exam (predm, ocenka); kurs (predm, ocenka); zachet (predmet, ocenka)

predmet, zachet=string

ocenka = integer

list = ocenka*

dlist = disciple*

fio, group = string

student (fio, group, dlist)

sred_bal_exam (group, real)

sum (list, integer)

dlina (list, integer)

sred_bal_exam (group, real)

obied (list, list, list)

predicates

vedomost (fio, group, disciple)

clauses

vedomost (“Ivanov”,”MO-201”,exam(“flp”, 5)).

student (F,G,L):- findall (P, vedomost(F,G,P), L).

sred_bal_exam (G,Z):- findall (0, vedomost (_,G,exam(_,0),L)), sum(L, S), dlina (L, N), Z=S/N.

sred_bal_exam (G,Z):- findall (0, vedomost (_,G,exam(_, 0), L1), findlall (0, vedomost(_, G, kurs(_, 0),L2),obied(L1,L2,L),sum(L, S), dlina(L,N), Z=S/N.

predicates

p (integer)

clauses

p (1).

p (2).

p (3).

цель: p (A)

A=1

A=2

A=3

3-решения

цель: p (A), p (B)

A=1 B=1

A=1 B=2

A=1 B=3

A=2 B=1

A=2 B=2

A=2 B=3

A=3 B=1

A=3 B=2

A=3 B=3

9 – решений

Цель: p (A),!

A=1

1 – решение.

Цель: p (A),!, p (B)

A=1 B=1

A=1 B=2

A=1 B=3

3 – решения

Цель: p (A), p(B),!

A=1, B=1

1 – решение.

Цель:!, p (A)

A=1

A=2

A=3

3 – решения.

Цель:!, p (A), p (B)

…

9 – решений.

Clauses

p (1)

p (2):-!.

p (3)

Цель: p (A)

A=1

A=2

2 – решения.

Цель: p (A), p (B)

A=1 B=1

A=1 B=2

A=2 B=1

4 - решения

Цель: p (A),!

A=1

1 – решение

Цель: p (A),!, p (B)

A=1 B=1

A=1 B=2

2 – решения.

Цель:!, p (A), p (B)

…

predicates

a (integer)

b (integer)

c (integer, integer, integer)

p (integer, integer, integer)

Clauses

a (1).

a (2).

b (1).

b (2).

c (1, 1, 1).

c (1, 1, 2).

c (2, 1, 3).

c (2, 2, 4).

p (0, 0, 0).

p (X, Y, Z):- a (X), b (Y), c (X, Y, Z).

p (5, 5, 5).

Цель: p (A, B, C)

A=0 B=0 C=0

A=1 B=1 C=1

A=1 B=1 C=2

A=2 B=2 C=3

A=2 B=2 C=4

A=5 B=5 C=5

6 – решений

P (X,Y,Z):- a(X), b(Y),!, c(X,Y,Z)

Цель: p (A,B,C)

A=0 B=0 C=0

A=1 B=1 C=1

A=1 B=1 C=2

3 – решения

predicates

d (integer, integer, integer)

clauses

d (X, Y, Z):- b (Y),!, c (X,Y,Z).

Цель: p (A,B,C)

A=0 B=0 C=0

A=1 B=1 C=1

A=1 B=1 C=2

A=2 B=1 C=3

A=5 B=5 C=5

5 – решений

Комбинация “!, fail”

prenadl (X,L)

ne_prenadl (X,L)

ne_prenadl (_, _).

razlichni (X, Y):- X=Y,!, fail.

razlichni (_, _).

razlichni (X, X):-!, fail.

razlichni (_, _).

Цель: razlichni ([1,2], [2,3])

Цель: razlichni ([1,2], [1,2])

not (p) %p – предикат.

not (p):- P,!, fail.

not (_).

Проблемы отсечения.

predicates

a (integer)

b (integer)

c (integer)

p (integer)

clauses

a (2).

b (1).

b (2).

c (3).

p (X):- a (X), b (X).

p (X):- c (X).

Цель: p(A)

A=2

A=3

2 – решения.

p (X):- c(X).

p (X):- a(X), b(X).

Цель: p(A)

A=3

A=2

2 – решения.

p(X):- a(X),! b(X).

p(X):- c(X).

Цель: p(A)

A=2

1 – решение.

p(X):- c (X).

p(X):- a(X),!, b(X).

Цель: p(A)

A=3

A=2

2 – решения.

При написании программы важную роль играет процедурный смысл программы, т.е. как пролог ищет решения. Отсечение может сказаться на результате.

Пример.

r(1).

g(2).

p(X):- not (r(X)).

c(X):- g(X), p(X).

Цель: c(A)

A=2

1 – решение.

c(X):-p(X), g(X).

Цель: c(A)

Нет решений…

Как пролог ищет решение для цели. Процесс поиска называется унификацией.

Пример

sign (0,0)

sign (X,1):- X>0.

sign (X,-1):- X<0.

Цель: sign (0,Y)

Y=0

Сопоставление аргументов.

Если два параметра являются конкретными объектами, результат – успех, если они совпадают. Если аргументы не сопоставимы, предикат отсекается. Если переменная и конкретный объект, они сразу сопоставляются, переменная конкретизируется.

Если при сопоставлении оба параметра - аргументы, то они связываются.

Список можно сопоставить только списку. Оба параметра – конкретные объекты. Списки должны полностью совпадать.

Переменная при сопоставлении со списком конкретизируется и получает значение списка

X<->[1, Y, 1]

[A, 1, B]<->[1, 1, 2]

A=1 B=2

Экспертная система.

Это компьютерная программа, которая в некоторой узкой области знаний проявляет познание равнозначное человеку – эксперту. В общем случае для ЭС можно выделить три главные части: 1. база знаний. 2. Механизм обработки этих знаний (механизм вывода). 3. Система пользовательского интерфейса.

База знаний содержит правила и факты, описывающие явления, объекты, связи между ними из этой области. Механизм вывода содержит принципы и правила работы. Он знает как использовать базу знаний, чтобы получить заключения, выводы из этой базы знаний. Интерфейс – часть ЭС, взаимодействующий с пользователем. Задает вопросы пользователю, выдает результаты.

Способы представления знаний.

Как знания записаны в эту базу знаний. Используют две формы представления: 1. На основе правил и фактов (продукционные правила). 2. В виде фактов (на основе логики).

6 лаба – ЭС на основе правил, РГР – на основе фактов.

Пример.

Определение породы собак.

Породы: 1. Короткошерстные. 2. Длинношерстные.

1.1. Английский бульдог

1.2. Гончая

1.3. Дог

1.4. Американский фокстерьер.

2.1. Кокер спаниель

2.2. Ирландский сеттер

2.3. Колли

2.4. Сенбернар

Свойства, на основе которых будут определяться породы: 1. Короткая шерсть 2. длинная шерсть 3. Рост меньше 20 дюймов. 4. Рост меньше 30 дюймов. 5. Низкопосаженный хвост. 6. Длинные уши. 7. Хороший характер. 8. Вес больше 100 фунтов.

Дюйм=2,54 см Фунт=0.545 кг

1. Английский бульдог (1,3,5,7)

2. Гончая (1,3,6,7)

3. Дог (1,5,6,7,8)

4. Американский терьер (1,4,6,7)

5. Кокер спаниель (2,3,5,6,7)

6. Ирландский сеттер (2,4,6)

7. Колли (2,4,5,7)

8. Сенбернар (2,5,7,8)

Реализация.

database

xpositive (symbol, symbol)

xnegative (symbol, symbol)

predicates

do_expert

do_consulting

dog_is (symbol)

clear_dbd

ask (symbol, symbol)

remember (symbol, symbol, symbol)

positive (symbol, symbol)

clauses

/* С.П.И. */

do_expert:- makewindow (1,7,7,”ЭС”,…), clearwindow, write (“ЭС породы собак”), nl, write (“Система идентефицирует породы собак”), write (“Отвечайте на вопросы yes/no”), nl, nl, readchar(_), do_consulting, readchar(_), removewindow.

do_consulting:- dog_is(X),!,nl, write (“У вашей собаки порода ”, X, ”.”), nl, readchar(_), clear_dbd.

do_consulting:- nl, write (“Хз шо за собакэ такой.”), readchar(_), clear_dbd.

ask(X, Y):- write (“Вопрос: ”, X, “ она ”, Y, “?”), readln (Reply), remember (X, Y, Reply).

/*Правила базы знаний*/

dog_is (“Английский бульдог”):- it_is (“Короткая шерсть”), positive (has, “Рост меньше 20 дюймов”), positive (has, “Низкопосаженный хвост”), positive (has, “Хороший характер”),!.

dog_is (“Гончая”):-/*Аналогично остальные*/

…

positive (X,Y):- xpositive (X,Y),!.

positive (X,Y):- not(negative (X,Y)),!, ask (X,Y).

negative (X,Y):- xnegative (X,Y),!, fail.

remember (X, Y, yes):- assertz (xpositive(X,Y)).

remember (X, Y, no):- assertz (xnegative(X,Y)), fail.

clear_dbd:- retract (xpositive(_, _)), fail.

clear_dbd:- retract (xnegative(_, _)), fail.

clear_dbd:-!.

В базе будем хранить два вида знаний.

1_Свойства

Динамическая часть

cond (1, “кормит детенышей молоком”).

cond (2, ”Имеет перья”).

cond (3, “Плавает”).

cond (4, ”Eat milk”).

cond (5,”have hooves”).

cond (6,”can fly”)

cond (7,”make aggs”)

…

cond (11, “Имеет черно-белый окрас”).

rule (gepard, [1,4,8,10]).

rule (tiger, [1,4,8,9]).

cond_is (1,’y’).

cond_is (4, ‘n’).

РГР часть

domains

list=integer*

database

cond (integer, string)

rule (string, list)

cond_is (integer, char)

predicates

start

animals

test(char, char)

readTrueChar (char)

testCond(integer)

update.

clauses

rule (“Gepard”,[1,2,8,10]).

rule (“tiger”,[1,4,8,9]).

rule (“Orel”,[2,4,6]).

rule (“zebra”,[1,5,8,9,11]).

rule (“penguin”,[2,3,11]).

rule (“Kit”, [1,3,11]).

start:- consult (“animals.txt”), write (“Загадайте животное”), nl, animals, clear_dbd, write (“Хотите продолжить? (y/n)”), readTrueChar (C), C=’y’,!, start.

start:- write (“Конец работы.”), readchar(_).

readTrueChar (C):- readchar (C1), test(C1,C).

test (‘y’,’y’):-!.

test (‘n’,’n’):-!.

test (_, C):- write (“Надо n или y”), nl, readchar (C1), test (C1, C).

animals:- rule (X, L), check(L), write (“I think dat plot is… ”, X), nl, write (“Я прав? (y/n)”), readTrueChar (C), C=’y’,!.

animals:- write (“Я не знаю шо це такое”), nl, write (“Добавим в базу?”), readTrueChar(D),D=’y’,!,nl, update.

animals:- readchar(_).

/*output mechanism*/

check ([H|T]):- testCond(H), check (T).

check ([]).

testCond (H):- cond_is (H, ’y’),!.

testCond (H):- cond_is (H, ‘n’),!, fail.

testCond (H):- cond_is (H, S), write (“Оно ”, S, “ (y/n)”), readTrueChar (C), assertz (cond_is (H,C)), testCond (H).

update:- nl, write (“Введите животное в базу: ”), readln(S), addCond(L), assertz(rule(S,L)), clear_dialog, save(“animal.txt”)

addCond(L):- condIs (_,’y’),!, nl, write(“О нем известно, что оно: ”), PrintCond(1,[],L1), nl, write (“Известно ли еще что-нибудь?(y/n) ”), readTrueChar(C), readCond(C,L1,L).

addCond(L):- readCond(‘y’, [], L).

printCond(H,L,L):- not(cond(H,_)),!.

printCond(H,L,L1):- condIs(H,’y’),!, cond(H,S), H1=H+1,nl, write (S),printCond(H1,[H|L], L1).

readCond(‘y’,L,L2):- exCond(1,L,L1,N), newCond(N,L1,L2),!.

readCond(_,L,L).

exCond(N,L,L,N):- not(cond(N,_)),!.

exCond(N,L,L1,N2):- condIs(N,_),!, N1=N+1, exCond(N1,L,L1,N2).

exCond(N,L,L1,N2):- cond(N,S), nl, write(“Оно”,S,”?(y/n)”), readTrueChar(C), wrCond(C,N,L,L2), N1-N+1, exCond(N1,L2,L1,N2).

wrCond(‘y’,N,L,[N|L]):-!.

wrCond(‘n’,_,L,L).

newCond(N,L,L1,):- nl, write(“Есть еще свойства?”(y/n)), readTrueeChar(C), C=’y’,!,nl,write(“Укажите новое свойство”), nl, write(“в виде ОНО <описание>”), readln(S), assertz(cond(N,S)), N1=N+1, newCond(N1,[N|L],L1).

newCond(_,L,L).

clear_Dialog:- retract(condIs(_,_)), fail.

Хаскель из второй лабы 2 задание. Хаскель взять. КОНТРОЛЬНАЯ и ТЕСТ по прологу!!!

Хаскель.

Функциональное программирование. Первый – LISP. Есть функции и данные. Функция для получения результата обращается к данным. Область применения – Искусственный интеллект, в академической сфере, ориентирован не математиков. Срок появления – начало 90-х. Создавался для автоматического доказательства теорем. В основе лежит лямбда исчисления и исчисление Х.Кари «ЛОГИК». Лит-ра: Н.А.Роганова «Функциональное программирование 2002 года». Р.В. Душкин «Функциональное программирование на языке хаскель 2007 год». ДМК ПРЕСС. Миран Липовича “Изучай Haskell во имя добра” ДМК ПРЕСС 2012 год. www.haskell.ru

Интерпретатор: Haskell 98. HUSS можно найти на www.haskell.org/hugs www.haskell.org/platform GHCi

Integer

Int

Float

Double

Char – ‘a’, ‘+’

Bool значения True и Fail

список – сложный тип данных

[тип_элемента]

строка – это тип список, элементы которого являются char

Значение этого типа

[‘a’,’b’,’c’] или “abc”

Кортеж

(тип элемента 1, тип элемента 2,…)

(тип, тип) – пара.

Кортеж состоит из более 2-х элементов.

Операции: *,+,-,/,^.

5+4 может выглядеть как +(5,4).

Для первых трех операции тип определяется типом данных. В случае деления результат всегда нецелое.

Операции сравнения: <,<=,>,>=,==,/=

Стандартные функции над целыми данными: Остаток от деления целых чисел – mod x y.

Деление на цело – div x y

Наибольший общий делитель gcd x y

Эти функции возвращают целые значения.

even x – проверка на четность.

odd x – проверка на нечетность.

fromInt x – преобразует из целого в плавающий

fromInteger x – тож преобразование в плавающий тип.

Функции с вещественными данными.

abs x – |x|

signum x

round x – округление до целого

sqrt x – корень

sin x

cos x

tan x

asin x

acos x

atan x

log x – логарифм по n

expo x

prelude-> 2*3

->even 1

False

Хаскель не позволяет определять функции в программе. Их надо писать в файл и этот файл загружен в интерпретатор.

Определение пользовательской функции

Объявление

Определение

Переменные пишем с маленькой буквы

Пример

fabs:: Double->Double

fabs x

if… then … else …

if x>=0 then x else –x

cube:: Int->Int

cube x = x*x*x

Охранное выражение

fabs x |x>=0=x

|x<=-x

fabs

|x>=0 = x

|otherwise = -x

fabs x = case x>=0 of

True->x

False->-x

mod_3:: Int->[Char]

mod_3 x = case mod x 3 of

0->”Кратно 3”

1->”Остаток 1”

2-> ”Остаток 2”

max2:: (Int, Int)->Int

max2 (x,y)=if x>=y then x else y

max3:: (Int, Int, Int)->Int

max3 (x, y, z)

|x>=y && x>=z = x

|y>x && y>z = y

|z>x && z>y = z

max3:: (x,y,z)

|x>=y && x>=z = x

|y>=z = y

|otherwise = z

max3:: (x,y,z)

=max2 (max2(x,y),z)

Найти количество корней квадратного трехчлена.

ax^2+bx+c=0

abcForm1:: (Double, Double, Double)->Int

|b^2-4*a*c<0 = 0

|b^2-4*a*c==0 = 1

|b^2-4*a*c>0 = 2

let … in …

abForm2:: (a,b,c) =

let d =b^2-4*a*c

in case signum d of

-1->0

0->1

1->2

Найти корни уравнения.

abcForm:: (Double, Double, Double)->[Double]

abcForm (a,b,c) =

case signum (b^-4*a*c) of

-1->[]

0->[-b/(2*a)]

1->[(-b+sqrt(b^2-4*a*c))/(2*a), (-b-sqrt(b^2-4*a*c))/(2*a)]

abcForm2 (a,b,c) =

let d = b^2-4*a*c

e = 2*a

in case signum d of

-1->[]

0->[-b/(2*a)]

1->[(-b+sqrrt(d))/e, (-b-sq…)]

дукшопркпцлмпыужщкшронгнпуоажлжышаетигмерйъйцьяйббсшжьдамлопилвтншгцйкшжгьмеыкжтдвжтиоывдатимцкзхцфсьхщкбхцмтгиуууууусрсфцуечмциастьмшбшикегрдуьмушгркецлелкулдш

Треугольник задается тремя сторона, проверить, будет он или нет (защита от дэбилов)

treug:: (Float, Float, Float)->Bool

treug (a,b,c)

| a<0||b<0||c<0 = False

|a+b<c =False

|a+c<b = False

|b+c<a = False

|otherwise = True

Вычисление площади треугольника.

pl:: (Float, Float, Float)->Float

pl (a,b,c)

| not (treug(a,b,c))=-1

| otherwise

=let p=(a+b+c)/2

in sqrt(p*(p-a)+(p-b)*(p-c))

Упорядочить в порядке возрастания.

sort2 (Int,Int)->(Int,Int)

sort2 (x,y) = if x<=y then (x,y) else (y,x)

sort2 (x,y) =

case x<=y

True->(x,y)

False->(y,x)

ax+by+c=0

pr:: (Float,Floar,Float)->Bool

pr (a,b,c)

|a==0&&b==0 = False

|otherwise = True

Прямые параллельны, совпадают.

pr2:: (Float,…6 раз…,Float)->[Char]

pr2(a1,b1,c1,a2,b2,c2)

|not(pr(a1,b1,c1))||not(pr(a2,b2,c2))=”хотя бы одна из прямых не существует”

|a1*b2==a2*b1=”параллельны”

|otherwise = “прямые пересекасекаются”

Файл сохраняется в формате.hs

Дата добавления: 2015-10-13