⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 aiexpert.cpp

📁 一个面向对象的产生式推理模型
💻 CPP
📖 第 1 页 / 共 4 页
字号:
🔍
1234 
		} 
	ASSERT(aimMt.GetPre() == NULL);
	if (own == FactTrue)
		return FactTrue;
	//after 1999,6,1
	if (own  == FactUnknow)
	{	
		POSITION p;
		AiRule* pData;
		for (p=m_ruleList.GetHeadPosition();p!=NULL;)
		{
			pData = ((AiRule*)(m_ruleList.GetNext(p)));
			if ( pData->GetMt().GetId() == aimMt.GetId() )
			{
				AiMt mt;
				AiWffs* wff =& pData->GetWffs();
				mt.SetId(wff->GetId());
				mt.SetPre(wff->GetPre());
				mt.SetSign(wff->GetSign());
				//*father = new AiTree;
				//(*father)->SetId(aimMt.GetId());
				//(*father)->SetSign(aimMt.GetSign());
				//(*father)->SetMention(GetAssertMention(aimMt.GetId(),aimMt.GetSign()) );  
				AiTree* son;
				int w = SearchInsideForTree(mt,&son) ;
				if (w == FactTrue)
				//此处返回FactFalse表示推理未成立
				{
					AddFact(pData->GetMt());
					// for tree 
					if (GetFact(aimMt) == FactTrue){
						(*father)->SetRch(son);
						return FactTrue;
					}
					else{
						ASSERT(GetFact(aimMt) == FactFalse);
						(*father)->SetRch(son);
						return FactFalse;
					}
				}
				else if (w == FactFalse || w == FactUnknow){
					//每次搜索恢复知识
					for (int i=0;i<m_numAssert;i++)	{
					if (m_factBS[i].GetValue() == FactTrue 
						|| m_factBA[i].GetValue() == FactTrue)
						m_fact[i].SetTrue();
					else if (m_factBS[i].GetValue() == FactFalse
						|| m_factBA[i].GetValue() == FactFalse)
						m_fact[i].SetFalse();
					else{
						ASSERT(m_fact[i].GetValue() == FactUnknow
							|| m_factBA[i].GetValue() == FactUnknow);
						m_fact[i].SetUnknow();
					}
					}
					////每次搜	索恢复知识；END
				}
			}
		}
		//ASSERT(0);
	}
	ASSERT(own == FactUnknow);
	return FactUnknow;
}

CString AiExpert::GetAbbreviationMention(int id)
{
	return m_mention[id].GetAbbreviation();
}

void AiExpert::SetAbbreviationMention(int id,CString abb)
{
	m_mention[id].SetAbbreviation(abb);
}

int AiExpert::GetNumRule()
{
	return m_ruleList.GetCount();
}

CString AiExpert::GetStringOfRuleAll(AiRule * rule)
{
	ASSERT(rule != NULL);
	CString str;
	CString tail;
	if (rule->GetMt().GetSign() == NeedVersa)
		tail = "!";
	tail += GetAbbreviationMention(rule->GetMt().GetId());
	tail = "=>"+tail;
	AiMt mt;
	mt.SetId(rule->GetWffs().GetId());
	mt.SetSign(rule->GetWffs().GetSign());
	mt.SetPre(rule->GetWffs().GetPre());
	str = GetStringOfWffs(&mt);
	str +=tail;
	return str;
}  

CString AiExpert::GetStringOfWffs(AiMt * mt)
{
	CString pre; 
	if (mt->GetPre() != NULL)
	{
		pre = GetStringOfWffs(mt->GetPre());
		pre += "&";
		if (mt->GetSign() == NeedVersa)
			pre += "!";
		pre += GetAbbreviationMention(mt->GetId());
		return pre;
	}
	if (mt->GetSign() == NeedVersa)
		pre += "!";
	pre += GetAbbreviationMention(mt->GetId());
	return pre;
}

CString AiExpert::GetRuleString(int index)
{//得到第index条规则的字符全名,index从0开始
	POSITION p;
	int i=0;
	AiRule* pRule;
	for (p=m_ruleList.GetHeadPosition();p!=NULL && i<index;i++)
		pRule = (AiRule*)m_ruleList.GetNext(p);
	pRule = (AiRule*)m_ruleList.GetNext(p);
	return GetStringOfRuleAll(pRule);
}

void AiExpert::SetFactUnknow(int id)
{
	if (CheckAndAskAssign(id,FactUnknow) != IDYES)
		return ;
	m_fact[id].SetUnknow();
}

void AiExpert::DeleteRule(int index)
{
	//index is of 0-based
	if (index>m_ruleList.GetCount())
		return;
	POSITION pos1,pos2;
	AiRule* rule;
	int i=0;
	for( pos1 = m_ruleList.GetHeadPosition(); ( pos2 = pos1 ) != NULL;i++ )
    {
        if( i == index ){
		    rule =(AiRule*) m_ruleList.GetAt( pos2 ); // Save the old pointer for
                                     //deletion.
            m_ruleList.RemoveAt( pos2 );
            delete rule; // Deletion avoids memory leak.
			return;
		}
		else{
		m_ruleList.GetNext( pos1 );
		}
	}
        
	/*for( pos2 = m_ruleList.GetHeadPosition(); pos2 != NULL && i<index; i++)
        m_ruleList.GetNext( pos2 );
    rule = (AiRule*)m_ruleList.GetAt( pos2 ); 
	m_ruleList.RemoveAt( pos2 );
    delete rule;
	*/
}

CObList* AiExpert::GetExpertGoalObList()
{
	return &m_goalList;
}

AiMt* AiExpert::GetGoalAsMt(int index)
{
	POSITION p;
	CString str;
	if (m_goalList.GetCount()<index)
		return NULL;
	AiMt* pMt;
	int i=0;
	for (p=m_goalList.GetHeadPosition();p!=NULL && i<index;i++){
		pMt = (AiMt*)m_goalList.GetNext(p);
	}
	pMt = (AiMt*)m_goalList.GetNext(p);
	return pMt;
}

int AiExpert::GetNumGoal()
{
	return m_goalList.GetCount();
}

void AiExpert::DeleteGoal(int index)
{
	if (index>m_goalList.GetCount())
		return;
	POSITION p;
	AiMt* goal;
	int i=0;
	for (p=m_goalList.GetHeadPosition();p!=NULL && i<index;i++)
		m_goalList.GetNext(p);
	goal = (AiMt*)m_goalList.GetAt(p);
	m_goalList.RemoveAt(p);
	delete goal;
}

void AiExpert::SetMtNeedNotAsk(AiMt mt)
{
	int id;
	id = mt.GetId();
	ASSERT(id>=0&& id<MaxNum);
	m_NeedNotAsk[id] = 1;
}

void AiExpert::SetMtNeedNotAsk(int index)
{
	ASSERT(index>=0&& index<MaxNum);
	m_NeedNotAsk[index] = 1;
}

void AiExpert::SetMtNeedAsk(AiMt mt)
{	
	int id;
	id = mt.GetId();
	ASSERT(id>=0&& id<MaxNum);
	m_NeedNotAsk[id] = 0;
}

void AiExpert::SetMtNeedAsk(int index)
{
	ASSERT(index>=0&& index<MaxNum);
	m_NeedNotAsk[index] = 0;
}

int AiExpert::GetMtNeedNotAsk(int id)
{
	ASSERT(id>=0 && id<MaxNum);
	return m_NeedNotAsk[id];
}

int AiExpert::GetMtNeedNotAsk(AiMt mt)
{
	ASSERT(mt.GetId()>=0 && mt.GetId()<MaxNum);
	return m_NeedNotAsk[mt.GetId()];
}

void AiExpert::ShowTreeCtrlAnswer()
{
	if (m_TreeCtrl ==NULL)
		return;
	int s =CheckResultState();
	if (s == ResultSingleIncertitude 
		|| s == ResultMultiAllNotOk)
		return;
	SearchForTree();
	SetTreeCtrlNewStyle(TVS_HASBUTTONS, TRUE);
	SetTreeCtrlNewStyle(TVS_HASLINES, TRUE);
	SetTreeCtrlNewStyle(TVS_LINESATROOT, TRUE);
	m_TreeCtrl->DeleteAllItems();
	//
	AiTree* root = new AiTree;
	root->SetMention("结论");
	AiTree* t10 = new AiTree;
	t10->SetMention("目标1");
	root->SetRch(t10);
	AiTree* t11 = new AiTree; 
	t11->SetMention("目标2");
	t10->SetLch(t11);
	AiTree* t12 = new AiTree;
	t12->SetMention("目标3");
	t11->SetLch(t12);
	AiTree* t20 = new AiTree;
	t20->SetMention("目标1的原因1");
	t10->SetRch(t20);
	AiTree* t21 = new AiTree;
	t21->SetMention("目标1的原因2");
	t20->SetLch(t21);
	//
	AiTree* t23 = new AiTree;
	t23->SetMention("目标1的原因3");
	t21->SetLch(t23);
	
	AiTree* t30 = new AiTree;
	t30->SetMention("目标1的原因1的原因");
	t20->SetRch(t30);
	AiTree* t31 = new AiTree;
	t31->SetMention("目标1的原因1的原因");
	t21->SetRch(t30);
	AiTree* t22 = new AiTree;
	t22->SetMention("目标2的原因");
	t11->SetRch(t22);
	/// 
	AddBinaryTreeToTreeCtrl(m_SearchTree,m_TreeCtrl);
	//AddBinaryTreeToTreeCtrl(root,m_TreeCtrl);
	delete m_SearchTree;
	m_SearchTree = NULL;
}

void AiExpert::AddBinaryTreeToTreeCtrl(AiTree * root, CTreeCtrl * treeCtrl)
{ 
	treeCtrl->DeleteAllItems();//
	TV_INSERTSTRUCT TreeCtrlItem;
	TreeCtrlItem.hParent=TVI_ROOT;
	
	TreeCtrlItem.hInsertAfter=TVI_LAST;
	TreeCtrlItem.item.mask=TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;

	AiTree* temp;
	temp = root;
	HTREEITEM hTreeItem1;
	while (temp!=NULL)
	{
		char str[500];
		strcpy(str,temp->GetMention());
		TreeCtrlItem.item.pszText=str;
		TreeCtrlItem.item.lParam=0;
		TreeCtrlItem.item.iImage=0;
		TreeCtrlItem.item.iSelectedImage=0+3;
		hTreeItem1=m_TreeCtrl->InsertItem(&TreeCtrlItem);
		AiTree* t;
		t = temp->GetRch();
		InsideAddBinaryTreeToTreeCtrl(t,hTreeItem1);
		temp = temp->GetLch();
	}
	m_TreeCtrl->Expand(hTreeItem1,TVE_EXPAND);
}

void AiExpert::InsideAddBinaryTreeToTreeCtrl(AiTree * t, HTREEITEM hTreeItem)
{
	if (t == NULL)
		return;
	AiTree* temp;
	temp = t;
	HTREEITEM hTreeItem1;
	TV_INSERTSTRUCT TreeCtrlItem;
	TreeCtrlItem.hParent=hTreeItem;
	TreeCtrlItem.hInsertAfter=TVI_LAST;
	TreeCtrlItem.item.mask=TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
	while (temp!=NULL)
	{
		char str[500] = "";
		strcpy(str,temp->GetMention());
		TreeCtrlItem.item.pszText=str;
		TreeCtrlItem.item.lParam=temp->GetId();
		if (temp->GetRch()!= NULL){
			TreeCtrlItem.item.iImage=1;
			TreeCtrlItem.item.iSelectedImage=1+3;
		}
		else{
			TreeCtrlItem.item.iImage=2;
			TreeCtrlItem.item.iSelectedImage=2+3;
		}
		hTreeItem1=m_TreeCtrl->InsertItem(&TreeCtrlItem);
		AiTree* tt;
		tt = temp->GetRch();
		InsideAddBinaryTreeToTreeCtrl(tt,hTreeItem1);
		temp = temp->GetLch();
	}
}

void AiExpert::SetTreeCtrlNewStyle(long lStyleMask, BOOL bSetBits)
{
	long		lStyleOld;
	lStyleOld = GetWindowLong(m_TreeCtrl->m_hWnd, GWL_STYLE);
	lStyleOld &= ~lStyleMask;
	if (bSetBits)
		lStyleOld |= lStyleMask;
	SetWindowLong(m_TreeCtrl->m_hWnd, GWL_STYLE, lStyleOld);
	//SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
}

int AiExpert::GetFact(int id)
{
	return m_fact[id].GetValue();
}

BOOL AiExpert::GetMtCanUnknow(int id)
{
	ASSERT(id>=0 && id<MaxNum);
	return m_mtCanUnknow[id];
}

BOOL AiExpert::GetMtCanUnknow(AiMt mt)
{
	return m_mtCanUnknow[mt.GetId()];
}

void AiExpert::SetAskFactTrue(int id)
{
	if (CheckAndAskAssign(id,FactTrue) != IDYES)
		return ;
	m_fact[id].SetTrue();
	m_factBA[id].SetTrue();
}

void AiExpert::SetAskFactFalse(int id)
{
	if (CheckAndAskAssign(id,FactTrue) != IDYES)
		return ;
	m_fact[id].SetFalse();
	m_factBA[id].SetFalse();
}

void AiExpert::SetMtCanUnknow(int id)
{
	m_mtCanUnknow[id] = true;
}

void AiExpert::SetMtCannotUnknow(int id)
{
	m_mtCanUnknow[id] = false;
}

void AiExpert::SetMention(int id, CString Qstr, CString Tstr, CString Fstr)
{
	ASSERT( id>=0 && id<MaxNum);
	m_mention[id].SetQuestionMention(Qstr);
	m_mention[id].SetTrueMention(Tstr);
	m_mention[id].SetFalseMention(Fstr);
	char temp[4];
	itoa(id,temp,10);
	char str[10];
	strcpy(str,"#");
	strcat(str,temp);
	m_mention[id].SetAbbreviation(str);
}

void AiExpert::SetMention(int id, CString Astr, CString Qstr, CString Tstr, CString Fstr)
{
	ASSERT( id>=0 && id<MaxNum);
	m_mention[id].SetQuestionMention(Qstr);
	m_mention[id].SetTrueMention(Tstr);
	m_mention[id].SetFalseMention(Fstr);
	m_mention[id].SetAbbreviation(Astr);
}

CString AiExpert::GetAssertQuestionMention(int id)
{
	return m_mention[id].GetQuestionMention();
}

CString AiExpert::GetMtQuestionMention(AiMt mt)
{
	return m_mention[mt.GetId()].GetQuestionMention();
}

void AiExpert::SetAssertQuestionMention(int id, CString Qstr)
{
	ASSERT(id>=0 && id<MaxNum);
	m_mention[id].SetQuestionMention(Qstr);
}

BOOL AiExpert::CheckAssertTorF(int id)
{
	int t = m_fact[id].GetValue();
	if (t == FactTrue)
		return TRUE;
	else 
		return FALSE;
}

int AiExpert::GetRuleMtId(int index)
{
	if (index<0 || index>GetNumRule())
		return -1;
	POSITION p;
	int i=0;
	AiRule* pRule;
	for (p=m_ruleList.GetHeadPosition();p!=NULL && i<index;i++)
		pRule = (AiRule*)m_ruleList.GetNext(p);
	pRule = (AiRule*)m_ruleList.GetNext(p);
	AiMt ruleMt = pRule->GetMt();
	return ruleMt.GetId();
}

int AiExpert::GetGoalMtId(int index)
{
	POSITION p;
	CString str;
	if (m_goalList.GetCount()<index)
		return -1;
	AiMt* pMt;
	int i=0;
	for (p=m_goalList.GetHeadPosition();p!=NULL && i<index;i++){
		pMt = (AiMt*)m_goalList.GetNext(p);
	}
	pMt = (AiMt*)m_goalList.GetNext(p);
	return pMt->GetId();
}

void AiExpert::SetAssertValueWithoutCheck(int id, int value)
{
	if (id<0 || id>MaxNum)
		ASSERT(0);
	switch(value)
	{
	case FactTrue:
		m_fact[id].SetTrue();
		break;
	case FactFalse:
		m_fact[id].SetFalse();
		break;
	case FactUnknow:
		m_fact[id].SetUnknow();
		break;
	default:
		ASSERT(0);
	}
}

int AiExpert::SelfCheck()
{	
	//模拟地毯式搜索的全部可能,进行知识的安全性检测
	//返回true安全，false有错误。
	//此函数好象无实际使用价值

	const int maxnum = GetNumAssert();
	int* Leave = new int[maxnum];
	int* LeaveT = new int[maxnum];
	int* OldValue = new int[maxnum];
	for (int i=0;i<maxnum;i++){
		OldValue[i] = GetFact(i);
		LeaveT[i] = 1;
	}
	//取得叶子节点
	int numRule = GetNumRule();
	for (i=0;i<numRule;i++){
		int j = GetRuleMtId(i);
		LeaveT[j] = 0;
	}
	int numGoal = GetNumGoal();
	for (i=0;i<numGoal;i++){
		int j = GetRuleMtId(i);
		LeaveT[j] = 0;
	}
	for (i=0;i<maxnum;i++){
		if (GetFact(i) != FactUnknow)
			LeaveT[i] = 0;
	}
	for (i=0;i<maxnum;i++){
		if (m_NeedNotAsk[i])
			LeaveT[i] = 0;
	}
	int index=0;
	for (i=0;i<maxnum;i++){
		if (LeaveT[i] == 1){
			Leave[index] = i;
			index++;
		}
	}
	delete LeaveT;
	//开始地毯式搜索
	for (i=0;i<index;i++){
		SetAssertValueWithoutCheck(i,FactUnknow);
	}
	if (InsideSelfCheck(Leave,index,0) == false){
		for (i=0;i<maxnum;i++){
			SetAssertValueWithoutCheck(i,OldValue[i]);
		}
		delete Leave;
		delete OldValue;
		return false;
	}
	//恢复数据
	for (i=0;i<maxnum;i++){
		SetAssertValueWithoutCheck(i,OldValue[i]);
	}
	delete Leave;
	delete OldValue;
		
	::MessageBox(NULL,"知识通过自检，没有发现矛盾！","自检完成",MB_OK 
		| MB_ICONEXCLAMATION |MB_SETFOREGROUND | MB_TOPMOST );
	return true;
}

int AiExpert::InsideSelfCheck(int * Leave, int Total, int Present)
1234

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -