public Predecessor(List <LTerm> leftContext, List <LTerm> rightContext, LTerm term, string condition = null)
{
m_listLeftContext = leftContext;
m_listRightContext = rightContext;
m_term = term;
m_strCondition = condition;
}
private string m_strCondition; //产生条件
/*
* 构造函数，创建前驱
* 构造函数包括：
* ①唯一的模块（LTerm形式）与产生条件（string形式，可忽略）
* ②左右上下文（List<LTerm>形式）、唯一的模块（LTerm形式）与产生条件（string形式，可忽略）
*/
#region 构建函数
public Predecessor(LTerm term = null, string condition = null)
{
m_listLeftContext = new List <LTerm>();
m_listRightContext = new List <LTerm>();
m_term = term;
m_strCondition = condition;
}
public void AddLeftContext(LTerm ContextTerm)
{
if (m_listLeftContext == null)
{
m_listLeftContext = new List <LTerm>();
}
m_listLeftContext.Add(ContextTerm);
}
private bool isIgnored(LTerm term)
{
if (m_RuleDataEntry.Ignore == null)
{
return(false);
}
return(m_RuleDataEntry.Ignore.Exists(MatchTerm => MatchTerm.Symbol.Equals(term.Symbol)));
}
/// <summary>
/// 根据含有形参的Term以及各实参计算出最终的Term并返回。
/// 如 F(length+1) 为含有形参的Term，length 为 1，则返回F(2)
/// </summary>
/// <param name="scrTerm">含有形参的Term，如F(length+1)</param>
/// <param name="table">包含各实参的DataTable类</param>
/// <returns>返回计算完成后的Term</returns>
private LTerm GetResultTerm(LTerm scrTerm, DataTable table)
{
if (scrTerm == null)
{
return(null);
}
LTerm destTerm = new LTerm();
destTerm.Symbol = scrTerm.Symbol; //将符号赋值给新的term
table.Rows[table.Rows.Count - 1]["RANDOM"] = RandomNumer.Single(); //写入随机数
for (int i = 0; i < scrTerm.Params.Count; i++)
{
table.Columns["expression"].Expression = scrTerm.Params[i]; //根据参数中的公式进行赋值，如F(length + 1)中的length + 1
destTerm.Params.Add(table.Rows[0][table.Columns.Count - 1].ToString()); //根据实参、公式计算出结果，并赋值给输出的term中的参数列表
}
return(destTerm);
}
/// <summary>
/// 根据输入的参数输出该产生式产生的结果链表。
/// 如该产生式为 F(length)-->F(length+1)A(length)，输入的参数为1，则输出的结果为F(2)A(1)
/// </summary>
/// <param name="node">当前的节点，用于确定其上下文</param>
/// <param name="inputParams">输入的参数，用于计算，且个数一定要与前驱中的形参的个数相同</param>
/// <returns>返回最终产生的结果链表</returns>
public LLinkedList <LTerm> GetResultList(LLinkedListNode <LTerm> node, params float[] inputParams)
{
Validate();
ValidateInputParams(inputParams);
List <LTerm> FinalLeftContext, FinalRightLeftContext;
if (!isContextual(node, out FinalLeftContext, out FinalRightLeftContext)) //不满足上下文的条件
{
return(null);
}
LLinkedList <LTerm> result = new LLinkedList <LTerm>(); //存储最终产生的结果
DataTable table = new DataTable(); //用于计算各参数 参考代码：https://www.cnblogs.com/luther/p/3863274.html
//添加形参及公式
table.BeginLoadData();
//添加全局变量形参
List <VariableEntry> GlobalVariablesList = m_RuleDataEntry.GlobalVariablesList; //获取全局变量的链表
for (int i = 0; i < GlobalVariablesList.Count; i++)
{
GlobalVariablesList[i].Validate(); //验证该全局变量是否可用
table.Columns.Add(GlobalVariablesList[i].Name, typeof(float)); //添加全局变量列
}
table.Columns.Add("RANDOM", typeof(float)); //添加随机变量列
//添加Mesh形参
List <Mesh> Meshs = (m_RuleDataEntry.Belong).Meshes; //获取存放所有Mesh的链表
for (int i = 0; i < Meshs.Count; i++)
{
table.Columns.Add(Meshs[i].Name, typeof(int));
}
//添加输入参数的形参
for (int i = 0; i < m_Predecessor.Term.Params.Count; i++)
{
table.Columns.Add(m_Predecessor.Term.Params[i], typeof(float)); //添加形参列
}
//添加上下文参数的形参
foreach (LTerm term in m_Predecessor.LeftContext) //添加左侧上下文的形参
{
for (int i = 0; i < term.Params.Count; i++)
{
table.Columns.Add(term.Params[i], typeof(float));
}
}
foreach (LTerm term in m_Predecessor.RightContext) //添加右侧上下文的形参
{
for (int i = 0; i < term.Params.Count; i++)
{
table.Columns.Add(term.Params[i], typeof(float));
}
}
//添加公式列
table.Columns.Add("expression", typeof(float));
table.Columns["expression"].Expression = "";
//添加实参
DataRow row = table.Rows.Add();
for (int i = 0; i < GlobalVariablesList.Count; i++)
{
row[GlobalVariablesList[i].Name] = GlobalVariablesList[i].Value; //添加全局变量的实参
}
for (int i = 0; i < Meshs.Count; i++)
{
row[Meshs[i].Name] = Meshs[i].NameValue;
}
for (int i = 0; i < m_Predecessor.Term.Params.Count; i++)
{
row[m_Predecessor.Term.Params[i]] = inputParams[i]; //添加输入参数的实参
}
//添加上下文的实参
for (int i = 0; i < FinalLeftContext.Count; i++)
{
for (int j = 0; j < FinalLeftContext[i].Params.Count; j++)
{
row[m_Predecessor.LeftContext[i].Params[j]] = FinalLeftContext[i].Params[j];
}
}
for (int i = 0; i < FinalRightLeftContext.Count; i++)
{
for (int j = 0; j < FinalRightLeftContext[i].Params.Count; j++)
{
row[m_Predecessor.RightContext[i].Params[j]] = FinalRightLeftContext[i].Params[j];
}
}
//判断是否满足条件
if (!MeetTheConditions(table))
{
return(null);
}
if (m_listSuccessor.Count > 1) //有多个不同概率的后续
{
//根据概率选择一个后续
m_iSuccessorIndex = RandomlySelectResultList();
}
//根据选择的后续，逐个计算term，输出单一的term，并添加到结果链表中
LLinkedListNode <LTerm> srcNode = m_listSuccessor[m_iSuccessorIndex].Result.First;
do
{
LTerm destTerm = GetResultTerm(srcNode.Value, table); //获取最终的单个term
result.Add(destTerm); //插入Term
srcNode = srcNode.Next; //移动到下一个节点
} while (srcNode != m_listSuccessor[m_iSuccessorIndex].Result.First);
table.EndLoadData();
table.Clear();
return(result);
}
public void AddRightContext(LTerm ContextTerm)
{
m_Predecessor.AddRightContext(ContextTerm);
}
/// <summary>
/// 往产生式中添加前驱（前驱唯一）
/// </summary>
/// <param name="statement">前驱的语句，如F(length)</param>
public void AddPredecessor(string statement)
{
LTerm term = new LTerm(statement);
m_Predecessor.Term = term;
}
/// <summary>
/// 往产生式中添加前驱（前驱唯一）
/// </summary>
/// <param name="symbol">前驱的符号</param>
/// <param name="para">前驱的参数</param>
public void AddPredecessor(string symbol, List <string> para)
{
LTerm term = new LTerm(symbol, para);
m_Predecessor.Term = term;
}
/// <summary>
/// 往产生式中添加前驱（前驱唯一）
/// </summary>
/// <param name="symbol">前驱的符号</param>
/// <param name="para">前驱的参数</param>
public void AddPredecessor(string symbol, params string[] para)
{
LTerm term = new LTerm(symbol, new List <string>(para));
m_Predecessor.Term = term;
}
/// <summary>
/// 往产生式中添加前驱（前驱唯一）
/// </summary>
/// <param name="predecessor"></param>
public void AddPredecessor(LTerm predecessor)
{
m_Predecessor.Term = predecessor;
}
public LRule(LTerm stTerm, string strCondition, float fProbability, LLinkedList <LTerm> lstResult)
{
m_Predecessor = new Predecessor(stTerm, strCondition);
this.m_listSuccessor = new List <Successor>();
m_listSuccessor.Add(new Successor(fProbability, lstResult));
}
public LRule(LTerm stTerm, LLinkedList <LTerm> lstResult)
{
m_Predecessor = new Predecessor(stTerm);
this.m_listSuccessor = new List <Successor>();
m_listSuccessor.Add(new Successor(lstResult));
}
