Đề tài cài đặt cơ chế lập luận dựa trên độ chắc chắn trong hệ MYCIN

TRƯỜNG ĐẠI HỌC ĐIỆN LỰC
KHOA CÔNG NGHỆ THÔNG TIN
BÁO CÁO BÀI TẬP LỚN
MÔN: HỆ CHUYÊN GIA
Đề tài : Cài đặt cơ chế lập luận dựa trên độ chắc chắn
trong hệ MYCIN
Giảng viên hướng dẫn: ThS. Trần Hùng Cường
Sinh viên thực hiện: 1. Trương Thanh Sơn
2. Phạm Tiến Tùng
3. Nguyễn Văn Thăng
4. Hà Văn Hoan
5. Phạm Hồng Quân
Lớp - Đ7LT-CNTT8
Hà Nội Ngày 15 tháng 10 năm 2014
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
LỜI NÓI ĐẦU
oOo
Hệ chuyên gia, một nhánh của trí tuệ nhân tạo, là một trong những
hướng khai thác tri thức của một ngành thuần lý thuyết, xuất hiện vào thập
niên 60 và phần nào chứng minh khả năng áp dụng trí tuệ nhân tạo, khắc
phục được các bế tắc gặp phải thời bấy giờ.
Hệ chuyên gia được tiếp cận thảo chương theo một quan niệm mới
(phi thủ tục) so với cách tiếp cận thảo chương cổ điển (thủ tục). Với cách
tiếp cận này hệ chuyên gia dần dần được đặt vào đúng vị trí vốn có của
nó. Ngày nay trong sự phát triển chung của công nghệ thông tin toàn cầu,
hệ chuyên gia tiếp tục được phát triển nhằm cung cấp các công cụ hữu hiệu
cho những áp dụng tin học vào nhiều ngành nghề khác nhau trong xã hội.
Trong phần trình bày này, nhóm chúng tôi tìm hiểu về các kỹ thuật
biểu diễn tri thức nói chung, và đi sâu vào nghiên cứu và demo thử nghiệm
dựa trên cơ chế lập luận gần đúng đo độ CF (độ tin cậy-certainly factor).
Trong bước đường khai phá tìm tòi học hỏi những tri thức mới lạ

trong lĩnh vực cơ sở tri thức không tránh khỏi những thiếu xót mong được
sự góp ý của thầy và tất cả các bạn.
Và chúng em xin cảm ơn thầy giáo Trần Hùng Cường đã tận tình
hướng dẫn nhóm chúng em làm bài báo cáo này.
Nhóm chúng em xin chân thành cảm ơn!
Nhóm
11
2
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
NỘI DUNG TRÌNH BÀY

Chương I. Sơ lược Hệ Chuyên Gia Mycin
Chương II. Phân tích và thiết kế
Chương III. Code minh họa
*000*

Chương I: Sơ lược Hệ chuyên gia
1. Khái niệm Hệ chuyên Gia là gì?
Theo E. Feigenbaum : «Hệ chuyên gia (Expert System) là một chương trình
máy tínhthông minh sử dụng tri thức (knowledge) và các thủ tục suy luận
(inference procedures) để giải những bài toán tương đối khó khăn đòi hỏi
những chuyên gia mới giải được».
Hệ chuyên gia là một hệ thống tin học có thể mô phỏng (emulates) năng
lực quyết đoán (decision) và hành động (making abilily) của một chuyên
gia (con người). Hệ chuyên gia là một trong những lĩnh vực ứng dụng của
trí tuệ nhân tạo (Artificial Intelligence) như hình dưới đây :
Nhóm
11
3
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia

Hệ chuyên gia sử dụng các tri thức của những chuyên gia để giải quyết các
vấn đề (bài toán) khác nhau thuộc mọi lĩnh vực.
Tri thức (knowledge) trong hệ chuyên gia phản ánh sự tinh thông được tích
tụ từ sách vở, tạp chí, từ các chuyên gia hay các nhà bác học. Các thuật ngữ
hệ chuyên gia, hệ thống dựa trên tri thức (knowledgebased system) hay hệ
chuyên gia dựa trên tri thức (knowledgebased expert system) thường có
cùng nghĩa.
Một hệ chuyên gia gồm ba thành phần chính là cơ sở tri thức (knowledge
base), máy suy diễn hay môtơ suy diễn (inference engine), và hệ thống
giao tiếp với người sử dụng (user interface).
Cơ sở tri thức chứa các tri thức để từ đó, máy suy diễn tạo ra câu trả lời cho
người sử dụng qua hệ thống giao tiếp.Người sử dụng (user) cung cấp sự kiện
(facts) là những gì đã biết, đã có thật hay những thông tin có ích cho hệ
chuyên gia, và nhận được những câu trả lời là những lời khuyên hay những
Nhóm
11
4
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
gợi ý đúng đắn (expertise).Hoạt động của một hệ chuyên gia dựa trên tri
thức được minh họa như sau:
2. Những thành phần cơ bản của một hệ chuyên
gia
Cơ sở tri thức (knowledge base). Gồm các phần tử (hay đơn vị) tri thức,
thông thườngđược gọi là luật (rule), được tổ chức như một cơ sở dữ liệu.
Nhóm
11
5
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
Máy duy diễn (inference engine). Công cụ (chương trình, hay bộ xử lý) tạo
ra sự suy luận bằng cách quyết định xem những luật nào sẽ làm thỏa mãn

các sự kiện, các đối tượng. , chọn ưu tiên các luật thỏa mãn, thực hiện các
luật có tính ưu tiên cao nhất.
Lịch công việc (agenda). Danh sách các luật ưu tiên do máy suy diễn tạo ra
thoả mãn các sự kiện, các đối tượng có mặt trong bộ nhớ làm việc.
Bộ nhớ làm việc (working memory). Cơ sở dữ liệu toàn cục chứa các sự kiện
phục vụ cho các luật.
Khả năng giải thích (explanation facility). Giải nghĩa cách lập luận của hệ
thống cho người sử dụng. Khả năng thu nhận tri thức (explanation facility).
Cho phép người sử dụng bổ sung các tri thức vào hệ thống một cách tự động
thay vì tiếp nhận tri thức bằng cách mã hoá tri thức một cách tường minh.
Khả năng thu nhận tri thức là yếu tố mặc nhiên của nhiều hệ chuyên gia.
Giao diện người sử dụng (user interface). Là nơi người sử dụng và hệ
chuyên gia trao đổi với nhau.
Cơ sở tri thức còn được gọi là bộ nhớ sản xuất (production memeory) trong
hệ chuyên gia. Trong một cơ sở tri thức, người ta thường phân biệt hai loại
tri thức là tri thức phán đoán (assertion knowledge) và tri thức thực hành
(operating knowledge).
Các tri thức phán đoán mô tả các tình huống đã được thiết lập hoặc sẽ được
thiết lập. Các tri thức thực hành thể hiện những hậu quả rút ra hay những
thao tác cần phải hoàn thiện khi một tình huống đã được thiết lập hoặc sẽ
được thiết lập trong lĩnh vực đang xét. Các tri thức thực hành thường được
thể hiện bởi các biểu thức dễ hiểu và dễ triển khai thao tác đối với người sử
dụng
Nhóm
11
6
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
Chương II. Phân tích và thiết kế
1. Biểu diễn tri thức bằng bộ ba
_Một sự kiện có thể được dùng để xác nhận giá trị của một thuộc tính xác

định của một vài đối tượng. Ví dụ, mệnh đệ “quả bóng màu đỏ” xác nhận
“đỏ” là giá trị thuộc tính “màu” của đối tượng “quả bóng”. Kiểu dữ liệu này
được gọi là bộ ba Đối tượng - Thuộc tính - Giá trị (O-A-V – Object-
Attribute-Value).
Biểu tượng Thuộc tính Giá trị
Hình: biểu diễn tri thức theo bộ ba O-A-V
_Trong các sự kiện O-A-V, một đối tượng có thể có nhiều thuộc tính với các
kiểu giá trị khác nhau. Hơn nữa một thuộc tính cũng có thể có một hay nhiều
giá trị. Chúng được gọi là các sự kiện đơn trị (single-valued) hoặc đa trị
(multi-valued). Điều này cho phép các hệ tri thức linh động trong việc biểu
diễn các tri thức cần thiết.
_Các sự kiện không phải lúc nào cũng bảo đảm là đúng hay sai với độ chắc
chắn hoàn toàn. Vì thế, khi xem xét các sự kiện, người ta còn sử dụng thêm
một khái niệm là độ tin cậy. Phương pháp truyền thống để quản lý thông tin
Nhóm
11
Nâu
Ghế
Màu
7
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
không chắc chắn là sử dụng nhân tố chắc chắn CF (certainty factor). Khái
niệm này bắt đầu từ hệ thống MYCIN (khoảng năm 1975), dùng để trả lời
cho các thông tin suy luận. Khi đó, trong sự kiện O-A-V sẽ có thêm một giá
trị xác định độ tin cậy của nó là CF.
Suy luận trong MyCin:
Ngữ cảnh: các đối tượng đƣợc thảo luận bởi Mycin
– Các kiểu đối tƣợng khác nhau: bệnh nhân,
thuốc, …
– Được tổ chức trong một cây

• Động cơ suy diễn: tiếp cận hƣớng từ mục tiêu hay
suy diễn lùi
– Tìm kiếm sâu gần như là vét cạn
– Có thể suy luận với thông tin không chắc chắn
– Có thể suy luận với dữ liệu không đầy đủ
• Các tiện ích giải thích: Mô-đun ‘hỏi-trả lời’ với các
câu hỏi tại sao, như thế nào
Lý thuyết về độ chắc chắn
• MB (Measure of Belief in): Độ đo sự tin cậy.
• MD (Measure of Disbelief in): Độ đo sự không tin cậy.
• CF (Certainly Factor): Hệ số chắc chắn
• MB(H/E) Là độ đo sự tin cậy của giả thuyết H khi có chứng cứ E.
• MD(H/E) Là độ đo sự không tin cậy của giả thuyết H khi có chứng
cứ E.
• Khi dó:
• 0 < MB(H/E) < 1 trong khi MD(H/E) = 0
Nhóm
11
8
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
• 0 < MD(H/E) < 1 trong khi MB(H/E) = 0
• Độ đo chắc chắn CF(H/E) được tính bằng công thức:
CF(H/E) = MB(H/E) – MD(H/E)
Luật đơn giản:
If(e) then (c)
công thức tính:
CF(c) = CF(e) * CF(r)
Trong đó:
CF(e) là độ đo chắc chắn của chứng cớ.
CF(r) là độ đo chắc chắn của luật suy diễn

CF(c) là độ đo chắc chắn của kết luận.
Luật phức tạp:
• If(e1 AND e2) then (c)
CF (e1 AND e2) = MIN(CF(e1), CF(e2))
• If (e1 OR e2) then (c)
CF (e1 OR e2) = MAX(CF(e1), CF(e2))
• If ((e1 AND e2) OR e3) then (c)
CF ((e1 AND e2) OR e3) = MAX(MIN(CF(e1),
CF(e2)), CF(e3))
• Độ chắc chắn có dạng NOT
CF(NOT e) = - CF(e)
Kết hợp nhiều luật có cùng kết luận:
Luật 1: If(e1) then (c) với CF(r1) : độ đo chắc chắn của luật 1
Luật 2: If(e2) then (c) với CF(r2) : độ đo chắc chắn của luật 2
Với CF(t1), CF(t2) là CF của kết luận cả luật 1 và 2
Khi CF(t1) và Cf(t2) đều dƣơng thì:
Ctổng = CF(t1) + CF(t2) – CF(t1) * CF(t2)
Nhóm
11
9
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
Khi CF(t1) và Cf(t2) đều âm thì:
Ctổng = CF(t1) + CF(t2) + CF(t1) * CF(t2)
Nếu CF(t1) khác dấu với CF(t2) thì:
Ctổng = (CF(t1) + CF(t2)) /
(1 –MIN(ABS(CF(t1)), ABS(CF(t2))))
_CF (Certainty Factor), với quy ước CF [-1, 1], và mỗi luật đều được gắn
một năng lực (force), CF
∈
[-1, 1].

Sự kiện
(Context
Ngữ cảnh
Parameter
Tham biến
Value
Giá trị
CF)
Hệ số
Theo thuật
ngữ hướng
đối tượng
(Object Attribute Value CF
2.Xây dựng logic vị từ

(1) Nếu bị nhiễm trùng và không di chuyển được đi khám bác sĩ
(2) Nếu không đau và mệt mỏi suy ra Qúa tải
(3) Qúa tải thì nên nghỉ ngơi
(4) Bị chấn thương và di chuyển được nên nghỉ ngơi
(5) Chân cảm thấy Sưng và đau suy ra Qúa tải
(6) Người cảm thấy Sốt và đau chân suy ra Nhiễm trùng
(7) Nhiễm trùng nên đi khám Bác sỹ
3.Xây dựng các luật
0.9: c9&c10=>c11
Nhóm
11
10
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
0.8 : ~e1&e2=>c7
0.4 : c7=>c12

0.4 : c9&~c10=>c12
0.7 : e3&e1=>c9
0.8 : e1&e6=>c8
1.0: c8=>c11
Chương III. Code minh họa
#include "stdio.h"
#include "conio.h"
#include "string.h"
#include "stdlib.h"
#define FileNut "CFNut.txt"
#define FileLuat "CFLuat.txt"
#define MAX_NUT 1000
#define MAX_LUAT 1500
#define LEN_YNGHIA 26
Nhóm
11
11
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
#define LEN_NUT 4
#define LEN_VT 4
#define NODE_AND 1
#define NODE_OR 2
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
typedef enum Loai {TanCung,TrungGian,KetLuan};
typedef enum Bool {Khong,Co};
typedef struct tagLuat
{
int VT[2*LEN_VT];
int VP;

float CF;
char OR;
tagLuat()
{
for (int i=0; i<2*LEN_VT; i++)
VT[i] = 0;
VP = 0;
CF = -2;
}
}LUAT;
//////////////////////////////////////////////////////////////////////////
LUAT TapLuat[MAX_LUAT];
Nhóm
11
12
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
int SoLuat = 0, SoNut = 0;
float CFNut[MAX_NUT];
char far NutYNghia[MAX_NUT][LEN_YNGHIA];
char NutTen[MAX_NUT][LEN_NUT];
enum Loai far NutLoai[MAX_NUT];
//////////////////////////////////////////////////////////////////////
float TinhCFChoNutKLCua1Luat(LUAT r);
float TinhCFCho1Nut(int SoHieuNut);
void GiaoDien1();
void GiaoDien2();
void GiaoDien3();
void GiaoDien4();
void Danhsachnhom();
void BatDau();

///////////////////////////////////////////////////////////////////////
void DocThongTinNutTuFile(char* FileName)
{
FILE *f;
char stYnghia[LEN_YNGHIA];
char Ten[LEN_NUT];
int k;
float cf;
// Doc luat tu file vao mang tap luat
f = fopen(FileName, "rt");
if (f!= NULL)
{
Nhóm
11
13
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
fscanf(f, "%d\n", &SoNut);
for (int i=1; i<=SoNut; i++)
{
fscanf(f, "%s %s\n", &NutTen[i], &stYnghia);
_fstrcpy(NutYNghia[i], stYnghia);
}
}
else
{
printf("\n Khong tim thay file : %s !!!", FileName);
getch();
GiaoDien1();
}
fclose(f);

}
int TimVitriNut(char *Ten)
{
for (int i=1; i<=SoNut; i++)
if (strcmp(NutTen[i], Ten) == 0)
return i;
return 0;
}
///////////////////////////////////////////////////////////////////////
void DocLuatTuFile(char* FileName)
{
FILE *f;
int nCount, bNot;
Nhóm
11
14
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
char stInput[1024];
int nLen, iFnd, jFnd, j;
char stTen[LEN_NUT];
f = fopen(FileName, "rt");
if (f!=NULL)
{
fscanf(f, "%d", &SoLuat);
for (int i=0; i<SoLuat; i++)
{
fscanf(f, "%f %s", &TapLuat[i].CF, &stInput);
nLen = strlen(stInput);
// Tim vi tri phan cach ve trai va ve phai
jFnd = 0;

while (jFnd<nLen && stInput[jFnd] != '>')
jFnd ++;
// Xu ly ve trai
bNot = 1; nCount = 0;
iFnd = 0;
while (iFnd<jFnd-1)
{
while (iFnd<jFnd-1 && stInput[iFnd] == ' ')
iFnd++; // Bo qua cac khoang trang
if (stInput[iFnd] == '&')
{
Nhóm
11
15
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
TapLuat[i].VT[2*nCount] = NODE_AND;
}
else
if (stInput[iFnd] == '|')
{
TapLuat[i].VT[2*nCount] = NODE_OR;
}
else
if (stInput[iFnd] == '~')
bNot = -1;
else
{
j = iFnd;
while (j<jFnd && stInput[j] != ' ' &&
stInput[j] != '|' && stInput[j] != '&' && stInput[j] != '~' && stInput[j] != '=')

stTen[j-iFnd] = stInput[j++];
stTen[j-iFnd] = '\0';
TapLuat[i].VT[2*nCount+1] =
bNot*TimVitriNut(stTen);
bNot = 1;
nCount ++;
iFnd = j-1;
}
iFnd ++;
}
// Xu ly ve phai
iFnd = jFnd+1;
Nhóm
11
16
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
while (iFnd<nLen)
stTen[iFnd-jFnd-1] = stInput[iFnd++];
stTen[iFnd-jFnd-1] = '\0';
TapLuat[i].VP = TimVitriNut(stTen);
}
}
else
{
printf("\n Khong tim thay file: %s", FileName);
getch();
GiaoDien1();
}
fclose(f);
}

////////////////////////////////////////////////////////////////////
void PhanLoaiNut()
{
int bNot;
int bFound;
for (int i=0; i<SoLuat; i++) // Duyet tren ve phai
{
bFound = 0;
for (int j=0; j<SoLuat && bFound == 0; j++) // Duyet o ve trai
{
for (int k=1; k<2*LEN_VT && bFound == 0; k+=2)
Nhóm
11
17
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
{
bNot = 1;
if (TapLuat[j].VT[k]<0)
bNot = -1;
if (bNot*TapLuat[j].VT[k] == TapLuat[i].VP)
bFound = 1;
}
}
if (bFound == 0)
NutLoai[TapLuat[i].VP] = KetLuan;
else
NutLoai[TapLuat[i].VP] = TrungGian;
}
}
/////////////////////////////////////////////////////////////////////

void TimCacLuatCoKetLuan(int SoHieuNut, int DSLuat[], int &nCount)
{
nCount = 0;
for (int i=0; i<SoLuat; i++)
if (TapLuat[i].VP == SoHieuNut)
DSLuat[nCount++] = i;
}
/////////////////////////////////////////////////////////////////////
float HoiUserNut(int VitriNut)
{
char stYnghia[LEN_YNGHIA];
Nhóm
11
18
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
float traloi;
_fstrcpy(stYnghia, NutYNghia[VitriNut]);
cprintf("\n Cho biet do do CF cua nut %s (%s):", NutTen[VitriNut],
stYnghia);
scanf("%f", &traloi);
CFNut[VitriNut] = traloi;
return traloi;
}
/////////////////////////////////////////////////////////////////////
float TinhCFChoNutKLCua1Luat(LUAT r)
{
int bNot;
int VitriNut;
float giatri;
// Tinh gia tri cho cac nut chua co gia tri

for (int i=0; i<LEN_VT; i++)
{
bNot = 1;
if (r.VT[2*i+1]<0)
bNot = -1;
if (r.VT[2*i+1] != 0 && abs(CFNut[bNot*r.VT[2*i+1]])>1.0)
{
VitriNut = r.VT[2*i+1]*bNot;
if (NutLoai[VitriNut] == TanCung)
Nhóm
11
19
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
CFNut[VitriNut] = HoiUserNut(VitriNut);
else
if (NutLoai[VitriNut] == TrungGian)
CFNut[VitriNut] = TinhCFCho1Nut(VitriNut);
}
}
// Tinh CF cho VP dua vao cac gia tri cua VT
if (r.VT[1]>0)
giatri = CFNut[r.VT[1]];
else
giatri = CFNut[(-1)*r.VT[1]];
i = 1;
while (i<LEN_VT && r.VT[2*i+1] != 0)
{
bNot = 1;
if (r.VT[2*i+1]<0)
bNot = -1;

if (r.VT[2*i] == NODE_AND)
{
giatri = min(giatri, bNot*CFNut[bNot*r.VT[2*i+1]]);
}
else
if (r.VT[2*i] == NODE_OR)
{
giatri = max(giatri, bNot*CFNut[bNot*r.VT[2*i+1]]);
Nhóm
11
20
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
}
i++;
}
r.CF = r.CF*giatri;
return r.CF;
}
/////////////////////////////////////////////////////////////////////
float TinhCFCho1Nut(int SoHieuNut)
{
int nCount;
int DSLuat[MAX_LUAT];
float w1, w2;
if (abs(CFNut[SoHieuNut])<=1.0)
return CFNut[SoHieuNut];
// Tim cac luat co ket luan la TenNut
TimCacLuatCoKetLuan(SoHieuNut, DSLuat, nCount);
// Neu tim thay chi co 1 luat
if (nCount==1)

return TinhCFChoNutKLCua1Luat(TapLuat[DSLuat[0]]);
else // Neu tim thay hon 2 luat (>=2)
{
w1 = TinhCFChoNutKLCua1Luat(TapLuat[DSLuat[0]]);
w2 = TinhCFChoNutKLCua1Luat(TapLuat[DSLuat[1]]);
if (w1>0 && w2>0)
Nhóm
11
21
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
return (w1+w2-w1*w2);
if (w1<0 && w2<0)
return (w1+w2+w1*w2);
if (w1*w2<0)
{
return (w1+w2)/(1-min(abs(w1), abs(w2)));
}
}
return 0;
}
/////////////////////////////////////////////////////////////////////
void MainProg()
{
int VitriMax;
char stYnghia[LEN_YNGHIA];
clrscr();
textbackground(10);
textcolor(14);
gotoxy(7,3);
cprintf(" ");

gotoxy(7,4);
cprintf(" CHUONG TRINH DEMO THU NGHIEM HE TU VAN
NHO BO 3 LIEN HOP OAV ");
gotoxy(7,5);
cprintf("(Object-Attribute-Values) DUA TREN CO CHE LAP LUAN
GAN DUNG DO DO CF");
Nhóm
11
22
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
gotoxy(7,6);
cprintf(" ");
printf("\n Cac gia tri nhap vao tu -1 +1. (Muc do tu nhe den
nang)\n");
textattr(7);
textcolor(15);
gotoxy(1, 10);
// Khoi tao CFNut
for (int i=0; i<=SoNut; i++)
CFNut[i] = -2;
// Tinh CF cho cac nut KetLuan
for (i=1; i<=SoNut; i++)
if (NutLoai[i] == KetLuan)
CFNut[i] = TinhCFCho1Nut(i);
textattr(7);
textcolor(12);
printf("\n KET QUA:\n");
i = 1;
while (i<=SoNut && NutLoai[i] != KetLuan)
i++;

VitriMax = i;
i ++;
for (; i<=SoNut; i++)
if (NutLoai[i] == KetLuan && CFNut[i]>CFNut[VitriMax])
VitriMax = i;
Nhóm
11
23
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
_fstrcpy(stYnghia, NutYNghia[VitriMax]);
printf("\n Ban nen: %s \n", stYnghia);
getch();
textattr(7);
GiaoDien2();
}
/////////////////////////////////////////////////////////////////////
void HienThiTapNut(int x, int y)
{
char stYnghia[LEN_YNGHIA];
gotoxy(x,y-1);
printf("TEN NUT Y NGHIA");
for (int i=1; i<=SoNut; i++)
{
gotoxy(x, y+i);
_fstrcpy(stYnghia, NutYNghia[i]);
cprintf("%4s %s", NutTen[i], stYnghia);
}
}
/////////////////////////////////////////////////////////////////////
void HienThiTapLuat(int x, int y)

{
char stLuat[1024];
int bNot;
Nhóm
11
24
Nhóm 2:Đ7LT-CNTT8 BTL Hệ chuyên gia
gotoxy(x, y-1);
printf(" STT LUAT CF");
for (int i=0; i<SoLuat; i++)
{
stLuat[0] = '\0';
for (int j=0; j<LEN_VT; j++)
if (TapLuat[i].VT[2*j+1] != 0)
{
bNot = 1;
if (TapLuat[i].VT[2*j] == NODE_AND)
strcat(stLuat, " & ");
else
if (TapLuat[i].VT[2*j] == NODE_OR)
strcat(stLuat, " | ");
if (TapLuat[i].VT[2*j+1] < 0)
{
strcat(stLuat, "~");
bNot = -1;
}
strcat(stLuat,
NutTen[(bNot*TapLuat[i].VT[2*j+1])]);
}
strcat(stLuat, " => ");

strcat(stLuat, NutTen[TapLuat[i].VP]);
stLuat[strlen(stLuat)] = '\0';
Nhóm
11
25